#include <elastic_cable.h>

Inheritance diagram for GRINS::ElasticCable< StressStrainLaw >:

Collaboration diagram for GRINS::ElasticCable< StressStrainLaw >:

Public Member Functions
	ElasticCable (const PhysicsName &physics_name, const GetPot &input, bool lambda_sq_var)

virtual	~ElasticCable ()

virtual void	register_postprocessing_vars (const GetPot &input, PostProcessedQuantities< libMesh::Real > &postprocessing)
	Register postprocessing variables for ElasticCable. 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	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	init_variables (libMesh::FEMSystem *system)
	Initialize variables for this physics. 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	element_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for element interiors. 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
	ElasticCable ()

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	_A

bool	_is_compressible

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

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

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

Detailed Description

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

Definition at line 38 of file elastic_cable.h.

Constructor & Destructor Documentation

template<typename StressStrainLaw >

GRINS::ElasticCable< StressStrainLaw >::ElasticCable	(	const PhysicsName &	physics_name,
		const GetPot &	input,
		bool	lambda_sq_var
	)

Definition at line 46 of file elastic_cable.C.

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

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

template<typename StressStrainLaw >

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

virtual

Definition at line 72 of file elastic_cable.C.

   {
     return;
   }

template<typename StressStrainLaw >

GRINS::ElasticCable< StressStrainLaw >::ElasticCable ( )

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::ElasticCable< StressStrainLaw >::build_new_fe	(	const libMesh::Elem &	elem,
		const libMesh::FEGenericBase< libMesh::Real > *	fe,
		const libMesh::Point	p
	)

private

Definition at line 414 of file elastic_cable.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::ElasticCable< 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 446 of file elastic_cable.C.

   {
     const std::vector<libMesh::RealGradient>& dxdxi  = elem.get_dxyzdxi();
 
     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();
 
     libMesh::RealGradient dxi( dxidx[qp], dxidy[qp], dxidz[qp] );
 
     libMesh::RealGradient dudxi( grad_u(0), grad_v(0), grad_w(0) );
 
     // Covariant metric tensor of reference configuration
     a_cov.zero();
     a_cov(0,0) = dxdxi[qp]*dxdxi[qp];
     a_cov(1,1)    = 1.0;
     a_cov(2,2)    = 1.0;
 
     // Covariant metric tensor of current configuration
     A_cov.zero();
     A_cov(0,0) = (dxdxi[qp] + dudxi)*(dxdxi[qp] + dudxi);
 
     // Contravariant metric tensor of reference configuration
     a_contra.zero();
     a_contra(0,0) = 1/a_cov(0,0);
     a_contra(1,1) = 1.0;
     a_contra(2,2) = 1.0;
 
     // Contravariant metric tensor in current configuration is A_cov^{-1}
     A_contra.zero();
     A_contra(0,0) =  1/A_cov(0,0);
 
     // If the material is compressible, then lambda_sq is an independent variable
     if( _is_compressible )
       {
         libmesh_not_implemented();
         //lambda_sq = context.interior_value(this->_lambda_sq_var, qp);
       }
     else
       {
         // If the material is incompressible, lambda^2 is known
         lambda_sq = a_cov(0,0)/A_cov(0,0);//det_a/det_A;
       }
 
     //Update the covariant and contravariant tensors of current configuration
     A_cov(1,1)    = lambda_sq;
     A_cov(2,2)    = lambda_sq;
     A_contra(1,1) = 1.0/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::ElasticCable< 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 308 of file elastic_cable.C.

   {
     bool is_strain = false;
     if( !_strain_indices.empty() )
       is_strain = ( _strain_indices[0] == quantity_index );
 
     bool is_stress = false;
     if( !_stress_indices.empty() )
       is_stress = ( _stress_indices[0] == quantity_index );
 
     bool is_force = false;
     if( !_force_indices.empty() )
       is_force = ( _force_indices[0] == quantity_index );
 
     if( is_strain || is_stress || is_force )
       {
         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();
 
         // Need these to build up the covariant and contravariant metric tensors
         const std::vector<libMesh::RealGradient>& dxdxi  = fe_new->get_dxyzdxi();
 
         // 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] );
             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) );
         libMesh::RealGradient grad_y( dxdxi[0](1) );
         libMesh::RealGradient grad_z( dxdxi[0](2) );
 
         libMesh::TensorValue<libMesh::Real> a_cov, a_contra, A_cov, A_contra;
         libMesh::Real lambda_sq = 0;
 
         this->compute_metric_tensors(0, *fe_new, context, grad_u, grad_v, grad_w, a_cov, a_contra, A_cov, A_contra, lambda_sq );
 
         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(1,a_contra,a_cov,A_contra,A_cov,tau);
 
         // 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
               {
                 //Wat?!
                 libmesh_error();
               }
             return;
           }
 
         if( is_stress )
           {
             if( _stress_indices[0] == quantity_index )
               {
                 // Need to convert to Cauchy stress
                 value = tau(0,0)/std::sqrt(I3);
               }
             else
               {
                 libmesh_error();
               }
           }
         if( is_force )
           {
 
             if( _force_indices[0] == quantity_index )
               {
                 //This force is in deformed configuration and will be significantly influenced by large strains
                 value = tau(0,0)/std::sqrt(I3)*_A;
               }
             else
               {
                 libmesh_error();
               }
           }
       }
 
     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;
   }

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

virtualinherited

Constraint part(s) of physics for element interiors.

Definition at line 236 of file physics.C.

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

   {
     return;
   }

template<typename StressStrainLaw >

void GRINS::ElasticCable< 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 134 of file elastic_cable.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());
 
     //Grab the Jacobian matrix as submatrices
     //libMesh::DenseMatrix<libMesh::Number> &K = context.get_elem_jacobian();
     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 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 unsigned int dim = 1; // The cable dimension is always 1 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] );
             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) );
         libMesh::RealGradient grad_y( dxdxi[qp](1) );
         libMesh::RealGradient grad_z( dxdxi[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 tensor
         libMesh::TensorValue<libMesh::Real> tau;
         ElasticityTensor C;
         //_stress_strain_law.compute_stress(dim,a_contra,a_cov,A_contra,A_cov,tau);
         _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] );
 
             Fu(i) -= tau(0,0)*_A*( (grad_x(0) + grad_u(0))*u_gradphi(0) ) * jac;
 
             Fv(i) -= tau(0,0)*_A*( (grad_y(0) + grad_v(0))*u_gradphi(0) ) * jac;
 
             Fw(i) -= tau(0,0)*_A*( (grad_z(0) + grad_w(0))*u_gradphi(0) ) * jac;
 
           }
 
         if( compute_jacobian )
           {
             for(unsigned int i=0; i != n_u_dofs; i++)
               {
                 libMesh::RealGradient u_gradphi_I( dphi_dxi[i][qp] );
                 for(unsigned int j=0; j != n_u_dofs; j++)
                   {
                     libMesh::RealGradient u_gradphi_J( dphi_dxi[j][qp] );
 
                     const libMesh::Real diag_term = _A*jac*tau(0,0)*( u_gradphi_J(0)*u_gradphi_I(0));
 
                     Kuu(i,j) -= diag_term;
 
                     Kvv(i,j) -= diag_term;
 
                     Kww(i,j) -= diag_term;
 
                     const libMesh::Real dgamma_du = ( u_gradphi_J(0)*(grad_x(0)+grad_u(0)) );
 
                     const libMesh::Real dgamma_dv = ( u_gradphi_J(0)*(grad_y(0)+grad_v(0)) );
 
                     const libMesh::Real dgamma_dw = ( u_gradphi_J(0)*(grad_z(0)+grad_w(0)) );
 
                     const libMesh::Real C1 = _A*jac*C(0,0,0,0);
 
                     const libMesh::Real x_term = C1*( (grad_x(0)+grad_u(0))*u_gradphi_I(0) );
 
                     const libMesh::Real y_term = C1*( (grad_y(0)+grad_v(0))*u_gradphi_I(0) );
 
                     const libMesh::Real z_term = C1*( (grad_z(0)+grad_w(0))*u_gradphi_I(0) );
 
                     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;
 
                   }
               }
             //libmesh_not_implemented();
           }
       }
 
     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::ElasticCableBase::get_fe ( const AssemblyContext & context )

inlineprotectedinherited

Definition at line 67 of file elastic_cable_base.h.

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

Referenced by GRINS::ElasticCableConstantGravity::element_time_derivative(), and GRINS::ElasticCableBase::init_context().

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

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::ElasticCableBase::init_context ( AssemblyContext & context )

virtualinherited

Initialize context for added physics variables.

Reimplemented from GRINS::Physics.

Definition at line 70 of file elastic_cable_base.C.

References GRINS::ElasticCableBase::get_fe().

   {
     this->get_fe(context)->get_JxW();
     this->get_fe(context)->get_phi();
     this->get_fe(context)->get_dphidxi();
 
     // Need for constructing metric tensors
     this->get_fe(context)->get_dxyzdxi();
     this->get_fe(context)->get_dxidx();
     this->get_fe(context)->get_dxidy();
     this->get_fe(context)->get_dxidz();
 
     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;
   }

void GRINS::ElasticCableBase::init_variables ( libMesh::FEMSystem * system )

virtualinherited

Initialize variables for this physics.

Implements GRINS::Physics.

Definition at line 51 of file elastic_cable_base.C.

References GRINS::ElasticCableBase::_disp_vars, and GRINS::SolidMechanicsFEVariables::init().

   {
     // is_2D = false, is_3D = true
     _disp_vars.init(system,false,true);
 
     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::ElasticCable< 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 299 of file elastic_cable.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::ElasticCable< StressStrainLaw >::register_postprocessing_vars	(	const GetPot &	input,
		PostProcessedQuantities< libMesh::Real > &	postprocessing
	)

virtual

Register postprocessing variables for ElasticCable.

Reimplemented from GRINS::Physics.

Definition at line 79 of file elastic_cable.C.

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

   {
     std::string section = "Physics/"+elastic_cable+"/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 only, i.e., locally normal to the cutting plane
                 // sigma_yy=sigma_zz = 0 by assumption of this Physics
                 _stress_indices.resize(1);
 
                 this->_stress_indices[0] = postprocessing.register_quantity("cable_stress");
 
               }
             else if( name == std::string("strain") )
               {
                 // eps_xx only, i.e., locally normal to the cutting plane
                 // eps_yy=eps_zz = 0 by assumption of this Physics
                 _strain_indices.resize(1);
 
                 this->_strain_indices[0] = postprocessing.register_quantity("cable_strain");
 
               }
             else if( name == std::string("force") )
               {
                 // force_x only, i.e., locally normal to the cutting plane
                 // force_y=force_z=0 by assumption of this Physics
                 _force_indices.resize(1);
 
                 this->_force_indices[0] = postprocessing.register_quantity("cable_force");
 
               }
             else
               {
                 std::cerr << "Error: Invalue output_vars value for "+elastic_cable << std::endl
                           << "       Found " << name << std::endl
                           << "       Acceptable values are: stress" << std::endl
                           << "                              strain" << std::endl
                           << "                              force " << 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::ElasticCableBase::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 60 of file elastic_cable_base.C.

References GRINS::ElasticCableBase::_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::ElasticCable< 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 281 of file elastic_cable.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;
   }

Member Data Documentation

template<typename StressStrainLaw >

libMesh::Real GRINS::ElasticCable< StressStrainLaw >::_A

private

Definition at line 93 of file elastic_cable.h.

Referenced by GRINS::ElasticCable< StressStrainLaw >::ElasticCable().

GRINS::BCHandlingBase* GRINS::Physics::_bc_handler

protectedinherited

Definition at line 256 of file physics.h.

Referenced by GRINS::Physics::attach_dirichlet_bound_func(), GRINS::Physics::attach_neumann_bound_func(), GRINS::AxisymmetricHeatTransfer< Conductivity >::AxisymmetricHeatTransfer(), GRINS::ElasticCable< StressStrainLaw >::ElasticCable(), GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane(), GRINS::Physics::get_bc_handler(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::Physics::init_bcs(), GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >::LowMachNavierStokes(), GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes(), GRINS::SpalartAllmaras< Viscosity >::SpalartAllmaras(), GRINS::Stokes< Viscosity >::Stokes(), and GRINS::Physics::~Physics().

SolidMechanicsFEVariables GRINS::ElasticCableBase::_disp_vars

protectedinherited

Definition at line 56 of file elastic_cable_base.h.

Referenced by GRINS::ElasticCableConstantGravity::element_time_derivative(), GRINS::ElasticCableBase::get_fe(), GRINS::ElasticCableBase::init_variables(), and GRINS::ElasticCableBase::set_time_evolving_vars().

std::set<libMesh::subdomain_id_type> GRINS::Physics::_enabled_subdomains

protectedinherited

Subdomains on which the current Physics class is enabled.

Definition at line 261 of file physics.h.

Referenced by GRINS::Physics::enabled_on_elem(), and GRINS::Physics::read_input_options().

template<typename StressStrainLaw >

std::vector<unsigned int> GRINS::ElasticCable< StressStrainLaw >::_force_indices

private

Index from registering this quantity. Each component will have it's own index.

Definition at line 104 of file elastic_cable.h.

GRINS::ICHandlingBase* GRINS::Physics::_ic_handler

protectedinherited

Definition at line 258 of file physics.h.

Referenced by GRINS::AveragedTurbine< Viscosity >::AveragedTurbine(), GRINS::AxisymmetricHeatTransfer< Conductivity >::AxisymmetricHeatTransfer(), GRINS::ElasticCable< StressStrainLaw >::ElasticCable(), GRINS::ElasticMembrane< StressStrainLaw >::ElasticMembrane(), GRINS::Physics::get_ic_handler(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::Physics::init_ics(), GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >::LowMachNavierStokes(), GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes(), GRINS::ScalarODE::ScalarODE(), GRINS::SpalartAllmaras< Viscosity >::SpalartAllmaras(), GRINS::Stokes< Viscosity >::Stokes(), and GRINS::Physics::~Physics().

bool GRINS::Physics::_is_axisymmetric

protectedinherited

Definition at line 268 of file physics.h.

Referenced by GRINS::HeatTransfer< Conductivity >::HeatTransfer(), GRINS::IncompressibleNavierStokes< Viscosity >::IncompressibleNavierStokes(), GRINS::Physics::Physics(), and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes().

template<typename StressStrainLaw >

bool GRINS::ElasticCable< StressStrainLaw >::_is_compressible

private

Definition at line 95 of file elastic_cable.h.

bool GRINS::Physics::_is_steady = false

staticprotectedinherited

Caches whether or not the solver that's being used is steady or not.

This is need, for example, in flow stabilization as the tau terms change depending on whether the solver is steady or unsteady.

Definition at line 266 of file physics.h.

Referenced by GRINS::Physics::is_steady(), and GRINS::Physics::set_is_steady().

const PhysicsName GRINS::Physics::_physics_name

protectedinherited

Name of the physics object. Used for reading physics specific inputs.

We use a reference because the physics names are const global objects in GRINS namespace

No, we use a copy, because otherwise as soon as the memory in std::set<std::string> requested_physics gets overwritten we get in trouble.

Definition at line 254 of file physics.h.

Referenced by GRINS::SourceTermBase::parse_var_info(), and GRINS::Physics::read_input_options().

template<typename StressStrainLaw >

std::vector<unsigned int> GRINS::ElasticCable< StressStrainLaw >::_strain_indices

private

Index from registering this quantity. Each component will have it's own index.

Definition at line 101 of file elastic_cable.h.

template<typename StressStrainLaw >

std::vector<unsigned int> GRINS::ElasticCable< StressStrainLaw >::_stress_indices

private

Index from registering this quantity. Each component will have it's own index.

Definition at line 98 of file elastic_cable.h.

template<typename StressStrainLaw >

StressStrainLaw GRINS::ElasticCable< StressStrainLaw >::_stress_strain_law

private

Definition at line 91 of file elastic_cable.h.

The documentation for this class was generated from the following files:

src/physics/include/grins/elastic_cable.h
src/physics/src/elastic_cable.C

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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