mpi/distribution/three_d_cantilever/three_d_cantilever.cc File Reference

#include "generic.h"
#include "solid.h"
#include "constitutive.h"
#include "meshes/simple_cubic_mesh.template.h"
#include "meshes/quarter_tube_mesh.h"

Classes
class	RefineableElasticQuarterTubeMesh< ELEMENT >
	Simple quarter tube mesh upgraded to become a solid mesh. More...
class	ElasticQuarterTubeMesh< ELEMENT >
	Simple quarter tube mesh upgraded to become a solid mesh. More...
class	RefineableElasticCubicMesh< ELEMENT >
	Simple cubic mesh upgraded to become a solid mesh. More...
class	ElasticCubicMesh< ELEMENT >
	Simple cubic mesh upgraded to become a solid mesh. More...
class	CantileverProblem< ELEMENT >
	Problem class for the cantilever "beam" structure. More...

Namespaces
	Global_Physical_Variables
	Global variables.

Functions
void	Global_Physical_Variables::constant_pressure (const Vector< double > &xi, const Vector< double > &x, const Vector< double > &n, Vector< double > &traction)
	Constant pressure load. More...
void	Global_Physical_Variables::gravity (const double &time, const Vector< double > &xi, Vector< double > &b)
	Non-dimensional gravity as body force. More...
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

Driver for cantilever beam loaded by surface traction and/or gravity

{
#ifdef OOMPH_HAS_MPI
 MPI_Helpers::init(argc,argv);
#endif
 
 DocInfo mesh_doc_info;
 bool report_stats=true;
 mesh_doc_info.number()=10;
 mesh_doc_info.set_directory("RESLT_MESH");
 
 // Use finite differencing
 bool use_fd=false;
 
 // Number of cases per implementation
 unsigned ncase=5;
 
 // Is the material incomressible
 bool incompress=true;
 
 // Loop over fd and analytical implementation
 for (unsigned i=0;i<2;i++)
  {
 
   // Generalised Hookean constitutive equations
   //-------------------------------------------
   {
    Global_Physical_Variables::Constitutive_law_pt =
     new GeneralisedHookean(&Global_Physical_Variables::Nu,
                            &Global_Physical_Variables::E);
 
    incompress=false;
 
#ifdef REFINE
    {
     //Set up the problem with pure displacement based elements
     CantileverProblem<RefineableQPVDElement<3,3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",0+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(0+i*ncase);
    }
#else
    {
     //Set up the problem with pure displacement based elements
     CantileverProblem<QPVDElement<3,3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",0+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(0+i*ncase);
    }
#endif
 
 
#ifdef REFINE
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<RefineableQPVDElementWithContinuousPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",1+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(1+i*ncase);
    }
#else
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<QPVDElementWithContinuousPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",0+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(1+i*ncase);
    }
#endif
 
 
 
#ifdef REFINE
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<RefineableQPVDElementWithPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",1+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(2+i*ncase);
    }
#else
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<QPVDElementWithPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",0+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(2+i*ncase);
    }
#endif
 
    delete Global_Physical_Variables::Constitutive_law_pt;
    Global_Physical_Variables::Constitutive_law_pt=0;
  }
 
 
 
   // Incompressible Mooney Rivlin
   //-----------------------------
   {
    Global_Physical_Variables::Strain_energy_function_pt =
     new MooneyRivlin(&Global_Physical_Variables::C1,
                      &Global_Physical_Variables::C2);
 
    // Define a constitutive law (based on strain energy function)
    Global_Physical_Variables::Constitutive_law_pt =
     new IsotropicStrainEnergyFunctionConstitutiveLaw(
      Global_Physical_Variables::Strain_energy_function_pt);
 
    incompress=true;
 
 
#ifdef REFINE
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<RefineableQPVDElementWithContinuousPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",3+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(3+i*ncase);
    }
#else
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<QPVDElementWithContinuousPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",3+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(3+i*ncase);
    }
#endif
 
 
 
#ifdef REFINE
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<RefineableQPVDElementWithPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",4+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(4+i*ncase);
    }
#else
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<QPVDElementWithPressure<3> >
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"three_d_cantilever_%i_partition.dat",4+i*ncase);
     input_file.open(filename);
     std::string input_string;
     for (unsigned e=0;e<n_partition;e++)
      {
       getline(input_file,input_string,'\n');
       element_partition[e]=atoi(input_string.c_str());
      }
 
     problem.distribute(element_partition,mesh_doc_info,report_stats);
 
     problem.check_halo_schemes(mesh_doc_info);
     mesh_doc_info.number()++;
#endif
 
     problem.run_it(4+i*ncase);
    }
#endif
 
    delete  Global_Physical_Variables::Strain_energy_function_pt;
    Global_Physical_Variables::Strain_energy_function_pt=0;
 
    delete Global_Physical_Variables::Constitutive_law_pt;
    Global_Physical_Variables::Constitutive_law_pt=0;
   }
 
 
   use_fd=true;
   std::cout << "\n\n\n CR Total fill_in... : bla \n\n\n " << std::endl;
 
  }
 
#ifdef OOMPH_HAS_MPI
 MPI_Helpers::finalize();
#endif
 
} //end of main

References Global_Physical_Variables::C1, Global_Physical_Variables::C2, Global_Physical_Variables::Constitutive_law_pt, Global_Physical_Variables::E, e(), MergeRestartFiles::filename, i, Global_Physical_Variables::Nu, oomph::DocInfo::number(), problem, oomph::DocInfo::set_directory(), Global_Physical_Variables::Strain_energy_function_pt, and oomph::Global_string_for_annotation::string().