#include <elastic_membrane.h>

Inheritance diagram for GRINS::ElasticMembrane< StressStrainLaw >:

Collaboration diagram for GRINS::ElasticMembrane< StressStrainLaw >:

Public Member Functions
	ElasticMembrane (const GRINS::PhysicsName &physics_name, const GetPot &input, bool is_compressible)

virtual	~ElasticMembrane ()

virtual void	init_variables (libMesh::FEMSystem *system)
	Initialize variables for this physics. More...

virtual void	register_postprocessing_vars (const GetPot &input, PostProcessedQuantities< libMesh::Real > &postprocessing)
	Register postprocessing variables for ElasticMembrane. More...

virtual void	element_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for element interiors. More...

virtual void	side_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for boundaries of elements on the domain boundary. More...

virtual void	element_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for element interiors. More...

virtual void	mass_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Mass matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. More...

virtual void	compute_postprocessed_quantity (unsigned int quantity_index, const AssemblyContext &context, const libMesh::Point &point, libMesh::Real &value)
	Compute the registered postprocessed quantities. More...

virtual void	set_time_evolving_vars (libMesh::FEMSystem *system)
	Set which variables are time evolving. More...

virtual void	init_context (AssemblyContext &context)
	Initialize context for added physics variables. More...

virtual void	read_input_options (const GetPot &input)
	Read options from GetPot input file. By default, nothing is read. More...

virtual bool	enabled_on_elem (const libMesh::Elem *elem)
	Find if current physics is active on supplied element. More...

void	set_is_steady (bool is_steady)
	Sets whether this physics is to be solved with a steady solver or not. More...

bool	is_steady () const
	Returns whether or not this physics is being solved with a steady solver. More...

virtual void	auxiliary_init (MultiphysicsSystem &system)
	Any auxillary initialization a Physics class may need. More...

virtual void	nonlocal_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for scalar variables. More...

virtual void	side_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for boundaries of elements on the domain boundary. More...

virtual void	nonlocal_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for scalar variables. More...

virtual void	nonlocal_mass_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Mass matrix part(s) for scalar variables. More...

void	init_bcs (libMesh::FEMSystem *system)

void	init_ics (libMesh::FEMSystem *system, libMesh::CompositeFunction< libMesh::Number > &all_ics)

void	attach_neumann_bound_func (GRINS::NBCContainer &neumann_bcs)

void	attach_dirichlet_bound_func (const GRINS::DBCContainer &dirichlet_bc)

virtual void	compute_element_time_derivative_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_side_time_derivative_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_nonlocal_time_derivative_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_element_constraint_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_side_constraint_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_nonlocal_constraint_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_mass_residual_cache (const AssemblyContext &context, CachedValues &cache)

virtual void	compute_nonlocal_mass_residual_cache (const AssemblyContext &context, CachedValues &cache)

BCHandlingBase *	get_bc_handler ()

ICHandlingBase *	get_ic_handler ()

virtual void	set_parameter (libMesh::Number &param_variable, const GetPot &input, const std::string &param_name, libMesh::Number param_default)
	Each subclass can simultaneously read a parameter value from. More...

virtual void	register_parameter (const std::string &param_name, libMesh::ParameterMultiPointer< libMesh::Number > &param_pointer) const
	Each subclass will register its copy of an independent. More...

Protected Member Functions
const libMesh::FEGenericBase< libMesh::Real > *	get_fe (const AssemblyContext &context)

Protected Attributes
SolidMechanicsFEVariables	_disp_vars

const PhysicsName	_physics_name
	Name of the physics object. Used for reading physics specific inputs. More...

GRINS::BCHandlingBase *	_bc_handler

GRINS::ICHandlingBase *	_ic_handler

std::set< libMesh::subdomain_id_type >	_enabled_subdomains
	Subdomains on which the current Physics class is enabled. More...

bool	_is_axisymmetric

Static Protected Attributes
static bool	_is_steady = false
	Caches whether or not the solver that's being used is steady or not. More...

Private Member Functions
	ElasticMembrane ()

libMesh::AutoPtr< libMesh::FEGenericBase< libMesh::Real > >	build_new_fe (const libMesh::Elem &elem, const libMesh::FEGenericBase< libMesh::Real > *fe, const libMesh::Point p)

void	compute_metric_tensors (unsigned int qp, const libMesh::FEBase &elem, const AssemblyContext &context, const libMesh::Gradient &grad_u, const libMesh::Gradient &grad_v, const libMesh::Gradient &grad_w, libMesh::TensorValue< libMesh::Real > &a_cov, libMesh::TensorValue< libMesh::Real > &a_contra, libMesh::TensorValue< libMesh::Real > &A_cov, libMesh::TensorValue< libMesh::Real > &A_contra, libMesh::Real &lambda_sq)

Private Attributes
StressStrainLaw	_stress_strain_law

libMesh::Real	_h0

bool	_is_compressible

VariableIndex	_lambda_sq_var
	Variable index for lambda_sq variable. More...

std::vector< unsigned int >	_stress_indices
	Index from registering this quantity for postprocessing. Each component will have it's own index. More...

unsigned int	_stress_zz_index
	Index from registering sigma_zz for postprocessing. Mainly for sanity checking. More...

std::vector< unsigned int >	_strain_indices
	Index from registering this quantity for postprocessing. Each component will have it's own index. More...

Detailed Description

template<typename StressStrainLaw>
class GRINS::ElasticMembrane< StressStrainLaw >

Definition at line 35 of file elastic_membrane.h.

Constructor & Destructor Documentation

template<typename StressStrainLaw >

GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane	(	const GRINS::PhysicsName &	physics_name,
		const GetPot &	input,
		bool	is_compressible
	)

Definition at line 47 of file elastic_membrane.C.

References GRINS::Physics::_bc_handler, GRINS::ElasticMembrane< StressStrainLaw >::_h0, GRINS::Physics::_ic_handler, and GRINS::ParameterUser::set_parameter().

     : ElasticMembraneBase(physics_name,input),
       _stress_strain_law(input),
       _h0(1.0),
       _is_compressible(is_compressible)
   {
     // Force the user to set h0
     if( !input.have_variable("Physics/"+physics_name+"/h0") )
       {
         std::cerr << "Error: Must specify initial thickness for "+physics_name << std::endl
                   << "       Input the option Physics/"+physics_name+"/h0" << std::endl;
         libmesh_error();
       }
 
     this->set_parameter
       (_h0, input, "Physics/"+physics_name+"/h0", _h0 );
 
     this->_bc_handler = new SolidMechanicsBCHandling( physics_name, input );
 
     this->_ic_handler = new GenericICHandler(physics_name, input);
 
     return;
   }

template<typename StressStrainLaw >

GRINS::ElasticMembrane< StressStrainLaw >::~ElasticMembrane ( )

virtual

Definition at line 73 of file elastic_membrane.C.

   {
     return;
   }

template<typename StressStrainLaw >

GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane ( )

private

Member Function Documentation

void GRINS::Physics::attach_dirichlet_bound_func ( const GRINS::DBCContainer & dirichlet_bc )

inherited

Definition at line 150 of file physics.C.

References GRINS::Physics::_bc_handler, and GRINS::BCHandlingBase::attach_dirichlet_bound_func().

   {
     _bc_handler->attach_dirichlet_bound_func( dirichlet_bc );
     return;
   }

void GRINS::Physics::attach_neumann_bound_func ( GRINS::NBCContainer & neumann_bcs )

inherited

Definition at line 144 of file physics.C.

References GRINS::Physics::_bc_handler, and GRINS::BCHandlingBase::attach_neumann_bound_func().

   {
     _bc_handler->attach_neumann_bound_func( neumann_bcs );
     return;
   }

void GRINS::Physics::auxiliary_init ( MultiphysicsSystem & system )

virtualinherited

Any auxillary initialization a Physics class may need.

This is called after all variables are added, so this method can safely query the MultiphysicsSystem about variable information.

Definition at line 113 of file physics.C.

   {
     return;
   }

template<typename StressStrainLaw >

libMesh::AutoPtr< libMesh::FEGenericBase< libMesh::Real > > GRINS::ElasticMembrane< StressStrainLaw >::build_new_fe	(	const libMesh::Elem &	elem,
		const libMesh::FEGenericBase< libMesh::Real > *	fe,
		const libMesh::Point	p
	)

private

Todo:: This is straight up copied from libMesh. Should make this a friend or public.

Definition at line 610 of file elastic_membrane.C.

   {
     using namespace libMesh;
     FEType fe_type = fe->get_fe_type();
 
     // If we don't have an Elem to evaluate on, then the only functions
     // we can sensibly evaluate are the scalar dofs which are the same
     // everywhere.
     libmesh_assert(&elem || fe_type.family == SCALAR);
 
     unsigned int elem_dim = &elem ? elem.dim() : 0;
 
     AutoPtr<FEGenericBase<libMesh::Real> >
       fe_new(FEGenericBase<libMesh::Real>::build(elem_dim, fe_type));
 
     // Map the physical co-ordinates to the master co-ordinates using the inverse_map from fe_interface.h
     // Build a vector of point co-ordinates to send to reinit
     Point master_point = &elem ?
       FEInterface::inverse_map(elem_dim, fe_type, &elem, p) :
       Point(0);
 
     std::vector<Point> coor(1, master_point);
 
     // Reinitialize the element and compute the shape function values at coor
     fe_new->reinit (&elem, &coor);
 
     return fe_new;
   }

void GRINS::Physics::compute_element_constraint_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 185 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::element_constraint().

   {
     return;
   }

void GRINS::Physics::compute_element_time_derivative_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Reimplemented in GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 167 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::element_time_derivative().

   {
     return;
   }

void GRINS::Physics::compute_mass_residual_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 203 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::mass_residual().

   {
     return;
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::compute_metric_tensors	(	unsigned int	qp,
		const libMesh::FEBase &	elem,
		const AssemblyContext &	context,
		const libMesh::Gradient &	grad_u,
		const libMesh::Gradient &	grad_v,
		const libMesh::Gradient &	grad_w,
		libMesh::TensorValue< libMesh::Real > &	a_cov,
		libMesh::TensorValue< libMesh::Real > &	a_contra,
		libMesh::TensorValue< libMesh::Real > &	A_cov,
		libMesh::TensorValue< libMesh::Real > &	A_contra,
		libMesh::Real &	lambda_sq
	)

private

Definition at line 642 of file elastic_membrane.C.

   {
     const std::vector<libMesh::RealGradient>& dxdxi  = elem.get_dxyzdxi();
     const std::vector<libMesh::RealGradient>& dxdeta = elem.get_dxyzdeta();
 
     const std::vector<libMesh::Real>& dxidx  = elem.get_dxidx();
     const std::vector<libMesh::Real>& dxidy  = elem.get_dxidy();
     const std::vector<libMesh::Real>& dxidz  = elem.get_dxidz();
 
     const std::vector<libMesh::Real>& detadx  = elem.get_detadx();
     const std::vector<libMesh::Real>& detady  = elem.get_detady();
     const std::vector<libMesh::Real>& detadz  = elem.get_detadz();
 
     libMesh::RealGradient dxi( dxidx[qp], dxidy[qp], dxidz[qp] );
     libMesh::RealGradient deta( detadx[qp], detady[qp], detadz[qp] );
 
     libMesh::RealGradient dudxi( grad_u(0), grad_v(0), grad_w(0) );
     libMesh::RealGradient dudeta( grad_u(1), grad_v(1), grad_w(1) );
 
     // Covariant metric tensor of reference configuration
     a_cov.zero();
     a_cov(0,0) = dxdxi[qp]*dxdxi[qp];
     a_cov(0,1) = dxdxi[qp]*dxdeta[qp];
     a_cov(1,0) = dxdeta[qp]*dxdxi[qp];
     a_cov(1,1) = dxdeta[qp]*dxdeta[qp];
 
     libMesh::Real det_a = a_cov(0,0)*a_cov(1,1) - a_cov(0,1)*a_cov(1,0);
 
     // Covariant metric tensor of current configuration
     A_cov.zero();
     A_cov(0,0) = (dxdxi[qp] + dudxi)*(dxdxi[qp] + dudxi);
     A_cov(0,1) = (dxdxi[qp] + dudxi)*(dxdeta[qp] + dudeta);
     A_cov(1,0) = (dxdeta[qp] + dudeta)*(dxdxi[qp] + dudxi);
     A_cov(1,1) = (dxdeta[qp] + dudeta)*(dxdeta[qp] + dudeta);
 
     // Contravariant metric tensor of reference configuration
     a_contra.zero();
     a_contra(0,0) = dxi*dxi;
     a_contra(0,1) = dxi*deta;
     a_contra(1,0) = deta*dxi;
     a_contra(1,1) = deta*deta;
 
     // Contravariant metric tensor in current configuration is A_cov^{-1}
     libMesh::Real det_A = A_cov(0,0)*A_cov(1,1) - A_cov(0,1)*A_cov(1,0);
 
     A_contra.zero();
     A_contra(0,0) =  A_cov(1,1)/det_A;
     A_contra(0,1) = -A_cov(0,1)/det_A;
     A_contra(1,0) = -A_cov(1,0)/det_A;
     A_contra(1,1) =  A_cov(0,0)/det_A;
 
     a_cov(2,2)    = 1.0;
     a_contra(2,2) = 1.0;
 
 
     // If the material is compressible, then lambda_sq is an independent variable
     if( _is_compressible )
       {
         lambda_sq = context.interior_value(this->_lambda_sq_var, qp);
       }
     else
       {
         // If the material is incompressible, lambda^2 is known
         lambda_sq = det_a/det_A;
       }
 
     A_cov(2,2) = lambda_sq;
     A_contra(2,2) = 1.0/lambda_sq;
 
     return;
   }

void GRINS::Physics::compute_nonlocal_constraint_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 197 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_constraint().

   {
     return;
   }

void GRINS::Physics::compute_nonlocal_mass_residual_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 209 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_mass_residual().

   {
     return;
   }

void GRINS::Physics::compute_nonlocal_time_derivative_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 179 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_time_derivative().

   {
     return;
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::compute_postprocessed_quantity	(	unsigned int	quantity_index,
		const AssemblyContext &	context,
		const libMesh::Point &	point,
		libMesh::Real &	value
	)

virtual

Compute the registered postprocessed quantities.

Reimplemented from GRINS::Physics.

Definition at line 432 of file elastic_membrane.C.

References GRINS::Constants::two_pi.

   {
     bool is_stress = false;
     if( !_stress_indices.empty() )
       is_stress= ( _stress_indices[0] == quantity_index ||
                    _stress_indices[1] == quantity_index ||
                    _stress_indices[2] == quantity_index ||
                    _stress_indices[3] == quantity_index ||
                    _stress_indices[4] == quantity_index ||
                    _stress_indices[5] == quantity_index ||
                    _stress_indices[6] == quantity_index ||
                    _stress_zz_index == quantity_index   );
 
     bool is_strain = false;
     if( !_strain_indices.empty() )
       is_strain = ( _strain_indices[0] == quantity_index ||
                     _strain_indices[1] == quantity_index ||
                     _strain_indices[2] == quantity_index   );
 
     if( is_stress || is_strain )
       {
         const unsigned int n_u_dofs = context.get_dof_indices(_disp_vars.u_var()).size();
 
         const libMesh::DenseSubVector<libMesh::Number>& u_coeffs = context.get_elem_solution( _disp_vars.u_var() );
         const libMesh::DenseSubVector<libMesh::Number>& v_coeffs = context.get_elem_solution( _disp_vars.v_var() );
         const libMesh::DenseSubVector<libMesh::Number>& w_coeffs = context.get_elem_solution( _disp_vars.w_var() );
 
         // Build new FE for the current point. We need this to build tensors at point.
         libMesh::AutoPtr<libMesh::FEGenericBase<libMesh::Real> > fe_new =
           this->build_new_fe( context.get_elem(), this->get_fe(context),
                               point );
 
         const std::vector<std::vector<libMesh::Real> >& dphi_dxi =
           fe_new->get_dphidxi();
 
         const std::vector<std::vector<libMesh::Real> >& dphi_deta =
           fe_new->get_dphideta();
 
         // Need these to build up the covariant and contravariant metric tensors
         const std::vector<libMesh::RealGradient>& dxdxi  = fe_new->get_dxyzdxi();
         const std::vector<libMesh::RealGradient>& dxdeta = fe_new->get_dxyzdeta();
 
         // Gradients are w.r.t. master element coordinates
         libMesh::Gradient grad_u, grad_v, grad_w;
         for( unsigned int d = 0; d < n_u_dofs; d++ )
           {
             libMesh::RealGradient u_gradphi( dphi_dxi[d][0], dphi_deta[d][0] );
             grad_u += u_coeffs(d)*u_gradphi;
             grad_v += v_coeffs(d)*u_gradphi;
             grad_w += w_coeffs(d)*u_gradphi;
           }
 
         libMesh::RealGradient grad_x( dxdxi[0](0), dxdeta[0](0) );
         libMesh::RealGradient grad_y( dxdxi[0](1), dxdeta[0](1) );
         libMesh::RealGradient grad_z( dxdxi[0](2), dxdeta[0](2) );
 
         libMesh::TensorValue<libMesh::Real> a_cov, a_contra, A_cov, A_contra;
         libMesh::Real lambda_sq = 0;
 
         // We're only computing one point at a time, so qp = 0 always
         this->compute_metric_tensors(0, *fe_new, context, grad_u, grad_v, grad_w,
                                      a_cov, a_contra, A_cov, A_contra, lambda_sq );
 
         // We have everything we need for strain now, so check if we are computing strain
         if( is_strain )
           {
             if( _strain_indices[0] == quantity_index )
               {
                 value = 0.5*(A_cov(0,0) - a_cov(0,0));
               }
             else if( _strain_indices[1] == quantity_index )
               {
                 value = 0.5*(A_cov(0,1) - a_cov(0,1));
               }
             else if( _strain_indices[2] == quantity_index )
               {
                 value = 0.5*(A_cov(1,1) - a_cov(1,1));
               }
             else
               {
                 //Wat?!
                 libmesh_error();
               }
             return;
           }
 
         if( is_stress )
           {
             libMesh::Real det_a = a_cov(0,0)*a_cov(1,1) - a_cov(0,1)*a_cov(1,0);
             libMesh::Real det_A = A_cov(0,0)*A_cov(1,1) - A_cov(0,1)*A_cov(1,0);
 
             libMesh::Real I3 = lambda_sq*det_A/det_a;
 
             libMesh::TensorValue<libMesh::Real> tau;
             _stress_strain_law.compute_stress(2,a_contra,a_cov,A_contra,A_cov,tau);
 
             if( _stress_indices[0] == quantity_index )
               {
                 // Need to convert to Cauchy stress
                 value = tau(0,0)/std::sqrt(I3);
               }
             else if( _stress_indices[1] == quantity_index )
               {
                 // Need to convert to Cauchy stress
                 value = tau(0,1)/std::sqrt(I3);
               }
             else if( _stress_indices[2] == quantity_index )
               {
                 // Need to convert to Cauchy stress
                 value = tau(1,1)/std::sqrt(I3);
               }
             else if( _stress_indices[3] == quantity_index )
               {
                 value = 0.5*(tau(0,0) + tau(1,1)) + std::sqrt(0.25*(tau(0,0)-tau(1,1))*(tau(0,0)-tau(1,1))
                                                               + tau(0,1)*tau(0,1) );
               }
             else if( _stress_indices[4] == quantity_index ||
                      _stress_indices[5] == quantity_index ||
                      _stress_indices[6] == quantity_index   )
               {
                 if(_is_compressible)
                   {
                     tau(2,2) = _stress_strain_law.compute_33_stress( a_contra, a_cov, A_contra, A_cov );
                   }
 
                 libMesh::Real stress_I1 = tau(0,0) + tau(1,1) + tau(2,2);
                 libMesh::Real stress_I2 = 0.5*(stress_I1*stress_I1 - (tau(0,0)*tau(0,0) + tau(1,1)*tau(1,1)
                                                                       + tau(2,2)*tau(2,2) + tau(0,1)*tau(0,1)
                                                                       + tau(1,0)*tau(1,0)) );
 
                 libMesh::Real stress_I3 = tau(2,2)*( tau(0,0)*tau(1,1) - tau(1,0)*tau(0,1) );
 
                 /* Formulae for principal stresses from:
                    http://en.wikiversity.org/wiki/Principal_stresses */
 
                 // I_2^2 - 3*I_2
                 libMesh::Real C1 = (stress_I1*stress_I1 - 3*stress_I2);
 
                 // 2*I_1^3 - 9*I_1*_I2 + 27*I_3
                 libMesh::Real C2 = (2*stress_I1*stress_I1*stress_I1 - 9*stress_I1*stress_I2 + 27*stress_I3)/54;
 
                 libMesh::Real theta = std::acos( C2/(2*std::sqrt(C1*C1*C1)) )/3.0;
 
                 if( _stress_indices[4] == quantity_index )
                   {
                     value = (stress_I1 + 2.0*std::sqrt(C1)*std::cos(theta))/3.0;
                   }
 
                 if( _stress_indices[5] == quantity_index )
                   {
                     value = (stress_I1 + 2.0*std::sqrt(C1)*std::cos(theta+Constants::two_pi/3.0))/3.0;
                   }
 
                 if( _stress_indices[6] == quantity_index )
                   {
                     value = (stress_I1 + 2.0*std::sqrt(C1)*std::cos(theta+2.0*Constants::two_pi/3.0))/3.0;
                   }
               }
             else if( _stress_zz_index == quantity_index )
               {
                 value = _stress_strain_law.compute_33_stress( a_contra, a_cov, A_contra, A_cov );
               }
             else
               {
                 //Wat?!
                 libmesh_error();
               }
           } // is_stress
 
       }
 
     return;
   }

void GRINS::Physics::compute_side_constraint_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Definition at line 191 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_constraint().

   {
     return;
   }

void GRINS::Physics::compute_side_time_derivative_cache	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Reimplemented in GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 173 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_time_derivative().

   {
     return;
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::element_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Constraint part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 333 of file elastic_membrane.C.

   {
     // Only compute the constraint is tracking lambda_sq as an independent variable
     if( _is_compressible )
       {
         unsigned int n_qpoints = context.get_element_qrule().n_points();
 
         const unsigned int n_u_dofs = context.get_dof_indices(_disp_vars.u_var()).size();
 
         const std::vector<libMesh::Real> &JxW = context.get_element_fe(this->_lambda_sq_var)->get_JxW();
 
         libMesh::DenseSubVector<libMesh::Number>& Fl = context.get_elem_residual(this->_lambda_sq_var);
 
         const std::vector<std::vector<libMesh::Real> >& phi =
           context.get_element_fe(this->_lambda_sq_var)->get_phi();
 
         const unsigned int n_lambda_sq_dofs = context.get_dof_indices(this->_lambda_sq_var).size();
 
         const libMesh::DenseSubVector<libMesh::Number>& u_coeffs = context.get_elem_solution( _disp_vars.u_var() );
         const libMesh::DenseSubVector<libMesh::Number>& v_coeffs = context.get_elem_solution( _disp_vars.v_var() );
         const libMesh::DenseSubVector<libMesh::Number>& w_coeffs = context.get_elem_solution( _disp_vars.w_var() );
 
         // All shape function gradients are w.r.t. master element coordinates
         const std::vector<std::vector<libMesh::Real> >& dphi_dxi =
           this->get_fe(context)->get_dphidxi();
 
         const std::vector<std::vector<libMesh::Real> >& dphi_deta =
           this->get_fe(context)->get_dphideta();
 
         for (unsigned int qp=0; qp != n_qpoints; qp++)
           {
             libMesh::Real jac = JxW[qp];
 
             libMesh::Gradient grad_u, grad_v, grad_w;
             for( unsigned int d = 0; d < n_u_dofs; d++ )
               {
                 libMesh::RealGradient u_gradphi( dphi_dxi[d][qp], dphi_deta[d][qp] );
                 grad_u += u_coeffs(d)*u_gradphi;
                 grad_v += v_coeffs(d)*u_gradphi;
                 grad_w += w_coeffs(d)*u_gradphi;
               }
 
             libMesh::TensorValue<libMesh::Real> a_cov, a_contra, A_cov, A_contra;
             libMesh::Real lambda_sq = 0;
 
             this->compute_metric_tensors( qp, *(this->get_fe(context)), context,
                                           grad_u, grad_v, grad_w,
                                           a_cov, a_contra, A_cov, A_contra,
                                           lambda_sq );
 
             libMesh::Real stress_33 = _stress_strain_law.compute_33_stress( a_contra, a_cov, A_contra, A_cov );
 
             for (unsigned int i=0; i != n_lambda_sq_dofs; i++)
               {
                 Fl(i) += stress_33*phi[i][qp]*jac;
               }
 
             if( compute_jacobian )
               {
                 libmesh_not_implemented();
               }
           }
       } // is_compressible
 
     return;
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::element_time_derivative	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Time dependent part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 159 of file elastic_membrane.C.

   {
     const unsigned int n_u_dofs = context.get_dof_indices(_disp_vars.u_var()).size();
 
     const std::vector<libMesh::Real> &JxW =
       this->get_fe(context)->get_JxW();
 
     // Residuals that we're populating
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(_disp_vars.u_var());
     libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(_disp_vars.v_var());
     libMesh::DenseSubVector<libMesh::Number> &Fw = context.get_elem_residual(_disp_vars.w_var());
 
     libMesh::DenseSubMatrix<libMesh::Number>& Kuu = context.get_elem_jacobian(_disp_vars.u_var(),_disp_vars.u_var());
     libMesh::DenseSubMatrix<libMesh::Number>& Kuv = context.get_elem_jacobian(_disp_vars.u_var(),_disp_vars.v_var());
     libMesh::DenseSubMatrix<libMesh::Number>& Kuw = context.get_elem_jacobian(_disp_vars.u_var(),_disp_vars.w_var());
 
     libMesh::DenseSubMatrix<libMesh::Number>& Kvu = context.get_elem_jacobian(_disp_vars.v_var(),_disp_vars.u_var());
     libMesh::DenseSubMatrix<libMesh::Number>& Kvv = context.get_elem_jacobian(_disp_vars.v_var(),_disp_vars.v_var());
     libMesh::DenseSubMatrix<libMesh::Number>& Kvw = context.get_elem_jacobian(_disp_vars.v_var(),_disp_vars.w_var());
 
     libMesh::DenseSubMatrix<libMesh::Number>& Kwu = context.get_elem_jacobian(_disp_vars.w_var(),_disp_vars.u_var());
     libMesh::DenseSubMatrix<libMesh::Number>& Kwv = context.get_elem_jacobian(_disp_vars.w_var(),_disp_vars.v_var());
     libMesh::DenseSubMatrix<libMesh::Number>& Kww = context.get_elem_jacobian(_disp_vars.w_var(),_disp_vars.w_var());
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     // All shape function gradients are w.r.t. master element coordinates
     const std::vector<std::vector<libMesh::Real> >& dphi_dxi =
       this->get_fe(context)->get_dphidxi();
 
     const std::vector<std::vector<libMesh::Real> >& dphi_deta =
       this->get_fe(context)->get_dphideta();
 
     const libMesh::DenseSubVector<libMesh::Number>& u_coeffs = context.get_elem_solution( _disp_vars.u_var() );
     const libMesh::DenseSubVector<libMesh::Number>& v_coeffs = context.get_elem_solution( _disp_vars.v_var() );
     const libMesh::DenseSubVector<libMesh::Number>& w_coeffs = context.get_elem_solution( _disp_vars.w_var() );
 
     // Need these to build up the covariant and contravariant metric tensors
     const std::vector<libMesh::RealGradient>& dxdxi  = this->get_fe(context)->get_dxyzdxi();
     const std::vector<libMesh::RealGradient>& dxdeta = this->get_fe(context)->get_dxyzdeta();
 
     const unsigned int dim = 2; // The manifold dimension is always 2 for this physics
 
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         // Gradients are w.r.t. master element coordinates
         libMesh::Gradient grad_u, grad_v, grad_w;
         for( unsigned int d = 0; d < n_u_dofs; d++ )
           {
             libMesh::RealGradient u_gradphi( dphi_dxi[d][qp], dphi_deta[d][qp] );
             grad_u += u_coeffs(d)*u_gradphi;
             grad_v += v_coeffs(d)*u_gradphi;
             grad_w += w_coeffs(d)*u_gradphi;
           }
 
         libMesh::RealGradient grad_x( dxdxi[qp](0), dxdeta[qp](0) );
         libMesh::RealGradient grad_y( dxdxi[qp](1), dxdeta[qp](1) );
         libMesh::RealGradient grad_z( dxdxi[qp](2), dxdeta[qp](2) );
 
 
         libMesh::TensorValue<libMesh::Real> a_cov, a_contra, A_cov, A_contra;
         libMesh::Real lambda_sq = 0;
 
         this->compute_metric_tensors( qp, *(this->get_fe(context)), context,
                                       grad_u, grad_v, grad_w,
                                       a_cov, a_contra, A_cov, A_contra,
                                       lambda_sq );
 
         // Compute stress and elasticity tensors
         libMesh::TensorValue<libMesh::Real> tau;
         ElasticityTensor C;
         _stress_strain_law.compute_stress_and_elasticity(dim,a_contra,a_cov,A_contra,A_cov,tau,C);
 
         libMesh::Real jac = JxW[qp];
 
         for (unsigned int i=0; i != n_u_dofs; i++)
           {
             libMesh::RealGradient u_gradphi( dphi_dxi[i][qp], dphi_deta[i][qp] );
 
             for( unsigned int alpha = 0; alpha < dim; alpha++ )
               {
                 for( unsigned int beta = 0; beta < dim; beta++ )
                   {
                     Fu(i) -= 0.5*tau(alpha,beta)*_h0*( (grad_x(beta) + grad_u(beta))*u_gradphi(alpha) +
                                                        (grad_x(alpha) + grad_u(alpha))*u_gradphi(beta) )*jac;
 
                     Fv(i) -= 0.5*tau(alpha,beta)*_h0*( (grad_y(beta) + grad_v(beta))*u_gradphi(alpha) +
                                                        (grad_y(alpha) + grad_v(alpha))*u_gradphi(beta) )*jac;
 
                     Fw(i) -= 0.5*tau(alpha,beta)*_h0*( (grad_z(beta) + grad_w(beta))*u_gradphi(alpha) +
                                                        (grad_z(alpha) + grad_w(alpha))*u_gradphi(beta) )*jac;
                   }
               }
           }
 
         if( compute_jacobian )
           {
             for (unsigned int i=0; i != n_u_dofs; i++)
               {
                 libMesh::RealGradient u_gradphi_i( dphi_dxi[i][qp], dphi_deta[i][qp] );
 
                 for (unsigned int j=0; j != n_u_dofs; j++)
                   {
                     libMesh::RealGradient u_gradphi_j( dphi_dxi[j][qp], dphi_deta[j][qp] );
 
                     for( unsigned int alpha = 0; alpha < dim; alpha++ )
                       {
                         for( unsigned int beta = 0; beta < dim; beta++ )
                           {
                             const libMesh::Real diag_term = 0.5*_h0*jac*tau(alpha,beta)*( u_gradphi_j(beta)*u_gradphi_i(alpha) +
                                                                                           u_gradphi_j(alpha)*u_gradphi_i(beta) );
                             Kuu(i,j) -= diag_term;
 
                             Kvv(i,j) -= diag_term;
 
                             Kww(i,j) -= diag_term;
 
                             for( unsigned int lambda = 0; lambda < dim; lambda++ )
                               {
                                 for( unsigned int mu = 0; mu < dim; mu++ )
                                   {
                                     const libMesh::Real dgamma_du = 0.5*( u_gradphi_j(lambda)*(grad_x(mu)+grad_u(mu)) +
                                                                           (grad_x(lambda)+grad_u(lambda))*u_gradphi_j(mu) );
 
                                     const libMesh::Real dgamma_dv = 0.5*( u_gradphi_j(lambda)*(grad_y(mu)+grad_v(mu)) +
                                                                           (grad_y(lambda)+grad_v(lambda))*u_gradphi_j(mu) );
 
                                     const libMesh::Real dgamma_dw = 0.5*( u_gradphi_j(lambda)*(grad_z(mu)+grad_w(mu)) +
                                                                           (grad_z(lambda)+grad_w(lambda))*u_gradphi_j(mu) );
 
                                     const libMesh::Real C1 = 0.5*_h0*jac*C(alpha,beta,lambda,mu);
 
                                     const libMesh::Real x_term = C1*( (grad_x(beta)+grad_u(beta))*u_gradphi_i(alpha) +
                                                                       (grad_x(alpha)+grad_u(alpha))*u_gradphi_i(beta) );
 
                                     const libMesh::Real y_term = C1*( (grad_y(beta)+grad_v(beta))*u_gradphi_i(alpha) +
                                                                       (grad_y(alpha)+grad_v(alpha))*u_gradphi_i(beta) );
 
                                     const libMesh::Real z_term = C1*( (grad_z(beta)+grad_w(beta))*u_gradphi_i(alpha) +
                                                                       (grad_z(alpha)+grad_w(alpha))*u_gradphi_i(beta) );
 
                                     Kuu(i,j) -= x_term*dgamma_du;
 
                                     Kuv(i,j) -= x_term*dgamma_dv;
 
                                     Kuw(i,j) -= x_term*dgamma_dw;
 
                                     Kvu(i,j) -= y_term*dgamma_du;
 
                                     Kvv(i,j) -= y_term*dgamma_dv;
 
                                     Kvw(i,j) -= y_term*dgamma_dw;
 
                                     Kwu(i,j) -= z_term*dgamma_du;
 
                                     Kwv(i,j) -= z_term*dgamma_dv;
 
                                     Kww(i,j) -= z_term*dgamma_dw;
                                   }
                               }
                           }
                       }
                   }
               }
           }
 
       }
 
     return;
   }

bool GRINS::Physics::enabled_on_elem ( const libMesh::Elem * elem )

virtualinherited

Find if current physics is active on supplied element.

Definition at line 83 of file physics.C.

References GRINS::Physics::_enabled_subdomains.

   {
     // Check if enabled_subdomains flag has been set and if we're
     // looking at a real element (rather than a nonlocal evaluation)
     if( !elem || _enabled_subdomains.empty() ) 
       return true;
   
     // Check if current physics is enabled on elem
     if( _enabled_subdomains.find( elem->subdomain_id() ) == _enabled_subdomains.end() )
       return false;
 
     return true;
   }

BCHandlingBase * GRINS::Physics::get_bc_handler ( )

inlineinherited

Definition at line 282 of file physics.h.

References GRINS::Physics::_bc_handler.

   {
     return _bc_handler;
   }

const libMesh::FEGenericBase< libMesh::Real > * GRINS::ElasticMembraneBase::get_fe ( const AssemblyContext & context )

inlineprotectedinherited

Definition at line 66 of file elastic_membrane_base.h.

References GRINS::ElasticMembraneBase::_disp_vars, and GRINS::SolidMechanicsVariables::u_var().

Referenced by GRINS::ElasticMembraneConstantPressure::element_time_derivative(), and GRINS::ElasticMembraneBase::init_context().

   {
     // For this Physics, we need to make sure that we grab only the 2D elements
     return context.get_element_fe(_disp_vars.u_var(),2);
   }

ICHandlingBase * GRINS::Physics::get_ic_handler ( )

inlineinherited

Definition at line 288 of file physics.h.

References GRINS::Physics::_ic_handler.

   {
     return _ic_handler;
   }

void GRINS::Physics::init_bcs ( libMesh::FEMSystem * system )

inherited

Definition at line 118 of file physics.C.

References GRINS::Physics::_bc_handler, GRINS::BCHandlingBase::init_bc_data(), GRINS::BCHandlingBase::init_dirichlet_bc_func_objs(), GRINS::BCHandlingBase::init_dirichlet_bcs(), and GRINS::BCHandlingBase::init_periodic_bcs().

   {
     // Only need to init BC's if the physics actually created a handler
     if( _bc_handler )
       {
         _bc_handler->init_bc_data( *system );
         _bc_handler->init_dirichlet_bcs( system );
         _bc_handler->init_dirichlet_bc_func_objs( system );
         _bc_handler->init_periodic_bcs( system );
       }
 
     return;
   }

void GRINS::ElasticMembraneBase::init_context ( AssemblyContext & context )

virtualinherited

Initialize context for added physics variables.

Reimplemented from GRINS::Physics.

Definition at line 68 of file elastic_membrane_base.C.

References GRINS::ElasticMembraneBase::get_fe().

   {
     this->get_fe(context)->get_JxW();
     this->get_fe(context)->get_phi();
     this->get_fe(context)->get_dphidxi();
     this->get_fe(context)->get_dphideta();
 
     // Need for constructing metric tensors
     this->get_fe(context)->get_dxyzdxi();
     this->get_fe(context)->get_dxyzdeta();
     this->get_fe(context)->get_dxidx();
     this->get_fe(context)->get_dxidy();
     this->get_fe(context)->get_dxidz();
     this->get_fe(context)->get_detadx();
     this->get_fe(context)->get_detady();
     this->get_fe(context)->get_detadz();
 
     return;
   }

void GRINS::Physics::init_ics	(	libMesh::FEMSystem *	system,
		libMesh::CompositeFunction< libMesh::Number > &	all_ics
	)

inherited

Definition at line 133 of file physics.C.

References GRINS::Physics::_ic_handler, and GRINS::ICHandlingBase::init_ic_data().

   {
     if( _ic_handler )
       {
         _ic_handler->init_ic_data( *system, all_ics );
       }
 
     return;
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::init_variables ( libMesh::FEMSystem * system )

virtual

Initialize variables for this physics.

Todo:: Might want to make Order/FEType inputable

Reimplemented from GRINS::ElasticMembraneBase.

Definition at line 79 of file elastic_membrane.C.

References GRINS::ElasticMembraneBase::init_variables().

   {
     // First call base class
     ElasticMembraneBase::init_variables(system);
 
     // Now build lambda_sq variable if we need it
     if(_is_compressible)
       {
         _lambda_sq_var = system->add_variable( "lambda_sq", GRINSEnums::FIRST, GRINSEnums::LAGRANGE);
       }
 
     return;
   }

bool GRINS::Physics::is_steady ( ) const

inherited

Returns whether or not this physics is being solved with a steady solver.

Definition at line 103 of file physics.C.

References GRINS::Physics::_is_steady.

Referenced by GRINS::Physics::set_is_steady().

   {
     return _is_steady;
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Mass matrix part(s) for element interiors. All boundary terms lie within the time_derivative part.

Reimplemented from GRINS::Physics.

Definition at line 423 of file elastic_membrane.C.

   {
     libmesh_not_implemented();
     return;
   }

void GRINS::Physics::nonlocal_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Constraint part(s) of physics for scalar variables.

Reimplemented in GRINS::ScalarODE.

Definition at line 250 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_constraint().

   {
     return;
   }   

void GRINS::Physics::nonlocal_mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Mass matrix part(s) for scalar variables.

Reimplemented in GRINS::ScalarODE, and GRINS::AveragedTurbine< Viscosity >.

Definition at line 264 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_mass_residual().

   {
     return;
   }

void GRINS::Physics::nonlocal_time_derivative	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Time dependent part(s) of physics for scalar variables.

Reimplemented in GRINS::AveragedTurbine< Viscosity >, and GRINS::ScalarODE.

Definition at line 229 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::nonlocal_time_derivative().

   {
     return;
   }

void GRINS::Physics::read_input_options ( const GetPot & input )

virtualinherited

Read options from GetPot input file. By default, nothing is read.

Reimplemented in GRINS::ScalarODE, GRINS::AveragedTurbineBase< Viscosity >, GRINS::AxisymmetricBoussinesqBuoyancy, GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::AxisymmetricHeatTransfer< Conductivity >, GRINS::AveragedFanBase< Viscosity >, GRINS::ParsedVelocitySourceBase< Viscosity >, GRINS::VelocityDragBase< Viscosity >, GRINS::VelocityPenaltyBase< Viscosity >, GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::HeatTransfer< Conductivity >, GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 70 of file physics.C.

References GRINS::Physics::_enabled_subdomains, and GRINS::Physics::_physics_name.

Referenced by GRINS::HeatTransferBase< Conductivity >::HeatTransferBase(), GRINS::HeatTransferStabilizationBase< Conductivity >::HeatTransferStabilizationBase(), GRINS::IncompressibleNavierStokesAdjointStabilization< Viscosity >::IncompressibleNavierStokesAdjointStabilization(), GRINS::IncompressibleNavierStokesSPGSMStabilization< Viscosity >::IncompressibleNavierStokesSPGSMStabilization(), GRINS::Physics::Physics(), and GRINS::SpalartAllmarasSPGSMStabilization< Viscosity >::SpalartAllmarasSPGSMStabilization().

   {
     int num_ids = input.vector_variable_size( "Physics/"+this->_physics_name+"/enabled_subdomains" );
 
     for( int i = 0; i < num_ids; i++ )
       {
         libMesh::subdomain_id_type dumvar = input( "Physics/"+this->_physics_name+"/enabled_subdomains", -1, i );
         _enabled_subdomains.insert( dumvar );
       }
 
     return;
   }

void GRINS::ParameterUser::register_parameter	(	const std::string &	param_name,
		libMesh::ParameterMultiPointer< libMesh::Number > &	param_pointer
	)		const

virtualinherited

Each subclass will register its copy of an independent.

Reimplemented in GRINS::AxisymmetricHeatTransfer< Conductivity >, GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::IncompressibleNavierStokesBase< Viscosity >, GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >, GRINS::HeatConduction< Conductivity >, GRINS::HeatTransferBase< Conductivity >, and GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >.

Definition at line 50 of file parameter_user.C.

Referenced by GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >::register_parameter(), GRINS::HeatTransferBase< Conductivity >::register_parameter(), GRINS::HeatConduction< Conductivity >::register_parameter(), GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::register_parameter(), GRINS::IncompressibleNavierStokesBase< Viscosity >::register_parameter(), GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::register_parameter(), and GRINS::AxisymmetricHeatTransfer< Conductivity >::register_parameter().

   {
     std::map<std::string, libMesh::Number*>::const_iterator it =
       _my_parameters.find(param_name);
 
     if (it != _my_parameters.end())
       {
         std::cout << _my_name << " uses parameter " << param_name
                   << std::endl;
         param_pointer.push_back(it->second);
       }
   }

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::register_postprocessing_vars	(	const GetPot &	input,
		PostProcessedQuantities< libMesh::Real > &	postprocessing
	)

virtual

Register postprocessing variables for ElasticMembrane.

Reimplemented from GRINS::Physics.

Definition at line 95 of file elastic_membrane.C.

References GRINS::elastic_membrane, and GRINS::PostProcessedQuantities< NumericType >::register_quantity().

   {
     std::string section = "Physics/"+elastic_membrane+"/output_vars";
 
     if( input.have_variable(section) )
       {
         unsigned int n_vars = input.vector_variable_size(section);
 
         for( unsigned int v = 0; v < n_vars; v++ )
           {
             std::string name = input(section,"DIE!",v);
 
             if( name == std::string("stress") )
               {
                 // sigma_xx, sigma_xy, sigma_yy, sigma_yx = sigma_xy
                 // sigma_zz = 0 by assumption of this Physics
                 _stress_indices.resize(7);
 
                 this->_stress_indices[0] = postprocessing.register_quantity("stress_xx");
 
                 this->_stress_indices[1] = postprocessing.register_quantity("stress_xy");
 
                 this->_stress_indices[2] = postprocessing.register_quantity("stress_yy");
 
                 this->_stress_indices[3] = postprocessing.register_quantity("sigma_max");
 
                 this->_stress_indices[4] = postprocessing.register_quantity("sigma_1");
 
                 this->_stress_indices[5] = postprocessing.register_quantity("sigma_2");
 
                 this->_stress_indices[6] = postprocessing.register_quantity("sigma_3");
               }
             else if( name == std::string( "stress_zz" ) )
               {
                 // This is mostly for sanity checking the plane stress condition
                 this->_stress_zz_index = postprocessing.register_quantity("stress_zz");
               }
             else if( name == std::string("strain") )
               {
                 // eps_xx, eps_xy, eps_yy, eps_yx = eps_xy
                 _strain_indices.resize(3);
 
                 this->_strain_indices[0] = postprocessing.register_quantity("strain_xx");
 
                 this->_strain_indices[1] = postprocessing.register_quantity("strain_xy");
 
                 this->_strain_indices[2] = postprocessing.register_quantity("strain_yy");
               }
             else
               {
                 std::cerr << "Error: Invalue output_vars value for "+elastic_membrane << std::endl
                           << "       Found " << name << std::endl
                           << "       Acceptable values are: stress" << std::endl
                           << "                              strain" << std::endl;
                 libmesh_error();
               }
           }
       }
 
     return;
   }

void GRINS::Physics::set_is_steady ( bool is_steady )

inherited

Sets whether this physics is to be solved with a steady solver or not.

Since the member variable is static, only needs to be called on a single physics.

Definition at line 97 of file physics.C.

References GRINS::Physics::_is_steady, and GRINS::Physics::is_steady().

   {
     _is_steady = is_steady;
     return;
   }

void GRINS::ParameterUser::set_parameter	(	libMesh::Number &	param_variable,
		const GetPot &	input,
		const std::string &	param_name,
		libMesh::Number	param_default
	)

virtualinherited

Each subclass can simultaneously read a parameter value from.

Definition at line 35 of file parameter_user.C.

References GRINS::ParameterUser::_my_name, and GRINS::ParameterUser::_my_parameters.

Referenced by GRINS::AveragedFanAdjointStabilization< Viscosity >::AveragedFanAdjointStabilization(), GRINS::AveragedTurbineAdjointStabilization< Viscosity >::AveragedTurbineAdjointStabilization(), GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >::BoussinesqBuoyancyAdjointStabilization(), GRINS::BoussinesqBuoyancyBase::BoussinesqBuoyancyBase(), GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::BoussinesqBuoyancySPGSMStabilization(), GRINS::ConstantConductivity::ConstantConductivity(), GRINS::ConstantPrandtlConductivity::ConstantPrandtlConductivity(), GRINS::ConstantSourceFunction::ConstantSourceFunction(), GRINS::ConstantSourceTerm::ConstantSourceTerm(), GRINS::ConstantSpecificHeat::ConstantSpecificHeat(), GRINS::ConstantViscosity::ConstantViscosity(), GRINS::ElasticCable< StressStrainLaw >::ElasticCable(), GRINS::ElasticCableConstantGravity::ElasticCableConstantGravity(), GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane(), GRINS::ElasticMembraneConstantPressure::ElasticMembraneConstantPressure(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransferBase< Conductivity >::HeatTransferBase(), GRINS::IncompressibleNavierStokesBase< Viscosity >::IncompressibleNavierStokesBase(), GRINS::AverageNusseltNumber::init(), GRINS::MooneyRivlin::MooneyRivlin(), GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::ReactingLowMachNavierStokesBase(), GRINS::HookesLaw1D::read_input_options(), GRINS::HookesLaw::read_input_options(), GRINS::AxisymmetricBoussinesqBuoyancy::read_input_options(), and GRINS::VelocityDragAdjointStabilization< Viscosity >::VelocityDragAdjointStabilization().

   {
     param_variable = input(param_name, param_default);
 
     libmesh_assert_msg(!_my_parameters.count(param_name),
       "ERROR: " << _my_name << " double-registered parameter " <<
       param_name);
 
     _my_parameters[param_name] = &param_variable;
   }

void GRINS::ElasticMembraneBase::set_time_evolving_vars ( libMesh::FEMSystem * system )

virtualinherited

Set which variables are time evolving.

Set those variables which evolve in time (as opposed to variables that behave like constraints). This is done separately from init_variables() because the MultiphysicsSystem must initialize its base class before time_evolving variables can be set. Default implementation is no time evolving variables.

Reimplemented from GRINS::Physics.

Definition at line 58 of file elastic_membrane_base.C.

References GRINS::ElasticMembraneBase::_disp_vars, GRINS::SolidMechanicsVariables::u_var(), GRINS::SolidMechanicsVariables::v_var(), and GRINS::SolidMechanicsVariables::w_var().

   {
     // Tell the system to march temperature forward in time
     system->time_evolving(_disp_vars.u_var());
     system->time_evolving(_disp_vars.v_var());
     system->time_evolving(_disp_vars.w_var());
 
     return;
   }

void GRINS::Physics::side_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtualinherited

Constraint part(s) of physics for boundaries of elements on the domain boundary.

Reimplemented in GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 243 of file physics.C.

Referenced by GRINS::MultiphysicsSystem::side_constraint().

   {
     return;
   }   

template<typename StressStrainLaw >

void GRINS::ElasticMembrane< StressStrainLaw >::side_time_derivative	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Time dependent part(s) of physics for boundaries of elements on the domain boundary.

Reimplemented from GRINS::Physics.

Definition at line 403 of file elastic_membrane.C.

   {
     /*
       std::vector<BoundaryID> ids = context.side_boundary_ids();
 
       for( std::vector<BoundaryID>::const_iterator it = ids.begin();
       it != ids.end(); it++ )
       {
       libmesh_assert (*it != libMesh::BoundaryInfo::invalid_id);
 
       _bc_handler->apply_neumann_bcs( context, cache, compute_jacobian, *it );
       }
     */
 
     return;
   }