solid/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 ()

Function Documentation

main()

int main

(

)

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

{
 
 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);
     
     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);
     
     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); 
     
     problem.run_it(1+i*ncase);
    }
#else
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<MySolidElement<
      QPVDElementWithContinuousPressure<2> > > 
      problem(incompress,use_fd); 
     
     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); 
     
     problem.run_it(2+i*ncase);
    }
#else
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<MySolidElement<
      QPVDElementWithPressure<2> > > problem(incompress,use_fd); 
     
     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); 
     
     problem.run_it(3+i*ncase);
    }
#else
    {
     //Set up the problem with continous pressure/displacement
     CantileverProblem<MySolidElement<
      QPVDElementWithContinuousPressure<2> > > 
      problem(incompress,use_fd); 
     
     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); 
     
     problem.run_it(4+i*ncase);
    }
#else
    {
     //Set up the problem with discontinous pressure/displacement
     CantileverProblem<MySolidElement<
      QPVDElementWithPressure<2> > > 
      problem(incompress,use_fd); 
     
     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;
   
  }
 
} //end of main

References Global_Physical_Variables::C1, Global_Physical_Variables::C2, Global_Physical_Variables::Constitutive_law_pt, Global_Physical_Variables::E, i, Global_Physical_Variables::Nu, problem, and Global_Physical_Variables::Strain_energy_function_pt.