Inheritance diagram for SolidBag:

Public Member Functions
	SolidBag ()

void	actionsBeforeOomphTimeStep () override

void	bendBag ()

void	setSuctionAsBodyForce (double bodyForce)

Public Member Functions inherited from SolidProblem< RefineableQDPVDElement< 3, 2 > >
	SolidProblem ()
	Constructor: set default constitutive law and time stepper. More...

void	setName (const std::string &name)
	set function for name_ More...

std::string	getName () const
	get function for name_ More...

void	setElasticModulus (double elasticModulus)
	set function for elasticModulus_ More...

double	getElasticModulus () const
	get function for elasticModulus_ More...

void	addDissipation (double dissipation)

void	setupRefinementParameters (const double &min_error_target, const double &max_error_target, Z2ErrorEstimator *&error_estimator_pt)

void	addAnisotropy (double Ex, double Ey, double Ez)

void	setOomphGravity (double gravity)
	set function for elasticModulus_ More...

double	getOomphGravity () const
	get function for gravity_ More...

void	setPoissonRatio (double poissonRatio)
	set function for poissonRatio_ More...

double	getPoissonRatio () const
	get function for poissonRatio_ More...

void	setDensity (double density)
	set function for density_ More...

double	getDensity () const
	get function for density_ More...

void	setBodyForceAsGravity (double gravity=9.8)
	set function for body_force_pt More...

void	setIsPinned (std::function< bool(SolidNode *, unsigned)> isPinned)
	set function for isPinned_ More...

void	pinBoundary (unsigned b)

void	pinBoundaries (std::vector< unsigned > b)

std::enable_if< std::is_base_of< RefineableQDPVDElement< 3, 2 >, ELEMENT >::value, void >	setDissipation (double dissipation)
	Sets the dissipation coefficient for all elements. More...

void	setNewtonSolverTolerance (double Newton_solver_tolerance)
	set function for Newton_solver_tolerance More...

void	setMaxNewtonIterations (unsigned Max_newton_iterations)
	set function for Max_newton_iterations More...

void	setOomphTimeStep (double dt)
	set function for time step More...

double	getOomphTimeStep () const
	get function for time step More...

double	getOomphTime () const
	get function for current time More...

SolidMesh *&	solid_mesh_pt ()
	Get function for the solid mesh pointer. More...

SolidMesh *const &	solid_mesh_pt () const
	Get function for the solid mesh pointer. More...

SolidMesh *&	traction_mesh_pt ()
	Get function for the traction mesh pointer. More...

SolidMesh *const &	traction_mesh_pt () const
	Get function for the traction mesh pointer. More...

void	getDomainSize (std::array< double, 3 > &min, std::array< double, 3 > &max) const
	Computes the domain size (min/max of the nodal positions in x/y/z) More...

void	prepareForSolve ()

void	countPinned ()
	returns statistics about pinned nodes to the console More...

void	solveSteady (const unsigned &max_adapt=0)

virtual void	actionsBeforeSolve ()

virtual void	actionsAfterSolve ()

void	solveUnsteady (double timeMax, double dt, unsigned saveCount=10, const unsigned &max_adapt=0)

void	solveUnsteadyForgiving (double timeMax, double timeMaxMin, double dt, unsigned saveCount=10)

void	removeOldFiles () const

void	get_x (const Vector< double > &xi, Vector< double > &x) const

double	getDeflection (Vector< double > xi, unsigned d) const

void	setSolidCubicMesh (const unsigned &nx, const unsigned &ny, const unsigned &nz, const double &xMin, const double &xMax, const double &yMin, const double &yMax, const double &zMin, const double &zMax)

void	saveSolidMesh ()

void	loadSolidMesh (std::string infileName, bool cubic=true)

void	writeToVTK ()

void	getMassMomentumEnergy (double &mass, Vector< double > &com, Vector< double > &linearMomentum, Vector< double > &angularMomentum, double &elasticEnergy, double &kineticEnergy) const
	See PVDEquationsBase<DIM>::get_energy. More...

Private Attributes
double	gripperDisplacement = 0.0

Additional Inherited Members
Public Types inherited from SolidProblem< RefineableQDPVDElement< 3, 2 > >
enum	Boundary

Protected Types inherited from SolidProblem< RefineableQDPVDElement< 3, 2 > >
typedef RefineableQDPVDElement< 3, 2 >	ELEMENT

Protected Attributes inherited from SolidProblem< RefineableQDPVDElement< 3, 2 > >
std::string	name_

double	elasticModulus_
	Elastic modulus (set via setSolid) More...

double	poissonRatio_
	Poisson's ratio (set via setSolid) More...

double	density_
	Density. More...

double	gravity_
	Density. More...

void(*	body_force_fct )(const double &time, const Vector< double > &xi, Vector< double > &b)
	Pointer to the body force function. More...

ConstitutiveLaw *	constitutive_law_pt
	Pointer to constitutive law (should be set in constructor) More...

SolidMesh *	Solid_mesh_pt
	Pointer to solid mesh. More...

SolidMesh *	Traction_mesh_pt
	Pointer to mesh of traction elements. More...

std::function< bool(SolidNode *, unsigned)>	isPinned_
	Function to determine which nodal positions are pinned. More...

Constructor & Destructor Documentation

◆ SolidBag()

SolidBag::SolidBag ( )

inline

     {
         //read in variables from parameter file
         double elasticModulus = 2e6;
         double poisson = 0.4;
         double density = 1000;
         double length = 0.16;
         double width = 0.13;
         double thickness = 1e-4;
         double resolution = 0.01;
         double timeMax = 0.75;
         double rim = 0.01;
         double gripperTraverse = 0.01;
         double gripperLength = 0.01;
         double gripperHeight = 0.01;
         double suctionForce = 1e3;
  
         setName("SolidBag1");
         removeOldFiles();
         setElasticModulus(elasticModulus);
         setPoissonRatio(poisson);
         setDensity(density);
         setSolidCubicMesh(width/resolution, 2, 2.0*length/resolution, -width / 2, width / 2, 0, thickness, -length, length);
  
         setIsPinned([length, gripperLength, gripperHeight, width, rim](SolidNode* n, unsigned d) {
             if (d == 0 || d == 2)
             { //pin gripper region in x- and z-direction
                 return ( n->is_on_boundary(Boundary::X_MIN)
                     || n->is_on_boundary(Boundary::X_MAX) )
                     && fabs(n->xi(2) - ( length - gripperLength - 0.5*gripperHeight )) < 0.51*gripperHeight;
             }
             else /*if (d==1)*/ { //pin rim in y-direction
                 return fabs(n->xi(0)) > width / 2 - 1.01 * rim || n->xi(2) < 1.01 * rim;
             }
         });
         
         // bend the plate into a bag
         bendBag();
  
         //double d = thickness, l = width/2.0;
         //double omega = sqrt(getElasticModulus()*std::pow(1.875*d,2)/(12*getDensity()*std::pow(l,4)));
         //double timeScale = 2*constants::pi/omega;
         setOomphTimeStep(0.01);
         logger(INFO, "Time step %", getOomphTimeStep());
         
         // add dissipation
         //addDissipation(getCriticalDissipation(width)); //todo: use dissipationScale?
  
         setSuctionAsBodyForce(suctionForce);
  
         setNewtonSolverTolerance(1e-6);
         linear_solver_pt()->disable_doc_time();
         //disable_info_in_newton_solve();
         prepareForSolve();
  
         solveSteady();
  
         // Solve the  problem
         gripperDisplacement = gripperTraverse / timeMax * getOomphTimeStep();
         solveUnsteady(timeMax, getOomphTimeStep(), 3);
     }

Member Function Documentation

◆ actionsBeforeOomphTimeStep()

void SolidBag::actionsBeforeOomphTimeStep ( )

inlineoverridevirtual

Squeeze the bag at the top from both sides by a given factor.

Parameters

distance

Reimplemented from SolidProblem< RefineableQDPVDElement< 3, 2 > >.

     {
         // number of nodes in mesh
         const unsigned n_node = solid_mesh_pt()->nnode();
         // for all nodes in mesh
         for (unsigned i = 0; i < n_node; i++)
         {
             SolidNode* n_pt = solid_mesh_pt()->node_pt(i);
             if (n_pt->position_is_pinned(0))
             {
                 //factorMax = gripperDisplacement*dt/(0.5*W)
                 //const double factor = factorMax * n_pt->xi(2) / (Global_Physical_Variables::length.Z);
                 n_pt->x(0) += n_pt->x(0) > 0 ? -gripperDisplacement : gripperDisplacement;
             }
         }
     }

References gripperDisplacement, i, oomph::Mesh::nnode(), oomph::SolidMesh::node_pt(), oomph::SolidNode::position_is_pinned(), SolidProblem< RefineableQDPVDElement< 3, 2 > >::solid_mesh_pt(), and oomph::Node::x().

◆ bendBag()

void SolidBag::bendBag ( )

inline

     {
         logger(INFO, "Bend bag");
         double gapThickness = 1e-6;
         // bend the plate into a bag
         Vector<double> xi(3);
         for (unsigned i = 0; i < solid_mesh_pt()->nnode(); i++)
         {
             SolidNode* n_pt = solid_mesh_pt()->node_pt(i);
             // shift all points in y by gapThickness/2
             n_pt->xi(1) += gapThickness / 2;
             n_pt->x(1) += gapThickness / 2;
             //rotate lower half (z<0) in yz-plane by 180 deg
             if (n_pt->xi(2) < 0)
             {
                 n_pt->xi(2) *= -1;
                 n_pt->xi(1) *= -1;
                 n_pt->x(2) *= -1;
                 n_pt->x(1) *= -1;
             }
             // center lowest row
             if (n_pt->xi(2) < gapThickness)
             {
                 n_pt->xi(1) = 0;
                 n_pt->x(1) = 0;
             }
         }
     }

References e(), i, INFO, logger, oomph::Mesh::nnode(), oomph::SolidMesh::node_pt(), SolidProblem< RefineableQDPVDElement< 3, 2 > >::solid_mesh_pt(), oomph::Node::x(), and oomph::SolidNode::xi().

Referenced by SolidBag().

◆ setSuctionAsBodyForce()

void SolidBag::setSuctionAsBodyForce ( double bodyForce )

inline

     {
         // define a static body force
         static double bodyForce_;
         bodyForce_ = bodyForce;
         logger(INFO, "Adding suction as body force, rho g = %", bodyForce);
         body_force_fct = [](const double& time, const Vector<double>& xi, Vector<double>& b) {
             b[0] = 0.0;
             b[1] = xi[1] >= 0 ? bodyForce_ : -bodyForce_;
             b[2] = 0.0;
         };
     }