mpi/distribution/airy_cantilever/airy_cantilever2.cc File Reference

#include "generic.h"
#include "solid.h"
#include "constitutive.h"
#include "meshes/rectangular_quadmesh.h"

Classes
class	oomph::MySolidElement< ELEMENT >
	Wrapper class for solid element to modify the output. More...
class	oomph::FaceGeometry< MySolidElement< ELEMENT > >
	FaceGeometry of wrapped element is the same as the underlying element. More...
class	CantileverProblem< ELEMENT >
	Problem class for the cantilever "beam" structure. More...

Namespaces
	oomph
	DRAIG: Change all instances of (SPATIAL_DIM) to (DIM-1).
	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)

Variables
double	Global_Physical_Variables::C2 =1.3
	"Mooney Rivlin" coefficient for generalised Mooney Rivlin law More...

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");
 
 bool use_fd=false;
 
 // Is the material incomressible
 bool incompress=false;
 
 // Number of cases per implementation
 unsigned ncase=5;
 
 
 // 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<MySolidElement<RefineableQPVDElement<2,3> > > 
      problem(incompress,use_fd);
 
#ifdef OOMPH_HAS_MPI
     //Distribute it
     std::ifstream input_file;
     std::ofstream output_file;
     char filename[100];
 
     // Get the partition from file
     unsigned n_partition=problem.mesh_pt()->nelement();
     Vector<unsigned> element_partition(n_partition);
     sprintf(filename,"airy_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     
 
     //Run it
     problem.run_it(0+i*ncase);
    }
#else   
    {
     //Set up the problem with pure displacement based elements
     CantileverProblem<MySolidElement<QPVDElement<2,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,"airy_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
 
     //Run it
     problem.run_it(0+i*ncase);
    }
#endif
    
 
#ifdef REFINE
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<MySolidElement<
      RefineableQPVDElementWithContinuousPressure<2> > > 
      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,"airy_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<MySolidElement<
      QPVDElementWithContinuousPressure<2> > > 
      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,"airy_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);
    }
#endif
 
 
#ifdef REFINE    
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<MySolidElement<
      RefineableQPVDElementWithPressure<2> > > 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,"airy_cantilever_%i_partition.dat",2+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<MySolidElement<
      QPVDElementWithPressure<2> > > 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,"airy_cantilever_%i_partition.dat",2+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<MySolidElement<
      RefineableQPVDElementWithContinuousPressure<2> > > 
      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,"airy_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<MySolidElement<
      QPVDElementWithContinuousPressure<2> > > 
      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,"airy_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<MySolidElement<
      RefineableQPVDElementWithPressure<2> > > 
      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,"airy_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<MySolidElement<
      QPVDElementWithPressure<2> > > 
      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,"airy_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().