Adds VMS-based stabilization to LowMachNavierStokes physics class. More...

#include <low_mach_navier_stokes_braack_stab.h>

Inheritance diagram for GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >:

Collaboration diagram for GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >:

[legend]

Public Member Functions
	LowMachNavierStokesBraackStabilization (const GRINS::PhysicsName &physics_name, const GetPot &input)

virtual	~LowMachNavierStokesBraackStabilization ()

virtual void	element_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent 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	init_context (AssemblyContext &context)
	Initialize context for added physics variables. More...

libMesh::Real	compute_res_continuity_steady (AssemblyContext &context, unsigned int qp) const

libMesh::Real	compute_res_continuity_transient (AssemblyContext &context, unsigned int qp) const

libMesh::RealGradient	compute_res_momentum_steady (AssemblyContext &context, unsigned int qp) const

libMesh::RealGradient	compute_res_momentum_transient (AssemblyContext &context, unsigned int qp) const

libMesh::Real	compute_res_energy_steady (AssemblyContext &context, unsigned int qp) const

libMesh::Real	compute_res_energy_transient (AssemblyContext &context, unsigned int qp) const

virtual void	read_input_options (const GetPot &input)
	Read options from GetPot input file. More...

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

virtual void	set_time_evolving_vars (libMesh::FEMSystem *system)
	Sets velocity variables to be time-evolving. More...

libMesh::Real	T (const libMesh::Point &p, const AssemblyContext &c) const

libMesh::Real	rho (libMesh::Real T, libMesh::Real p0) const

libMesh::Real	d_rho_dT (libMesh::Real T, libMesh::Real p0) const

libMesh::Real	get_p0_steady (const AssemblyContext &c, unsigned int qp) const

libMesh::Real	get_p0_steady (const AssemblyContext &c, const libMesh::Point &p) const

libMesh::Real	get_p0_steady_side (const AssemblyContext &c, unsigned int qp) const

libMesh::Real	get_p0_transient (AssemblyContext &c, unsigned int qp) const

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...

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	register_postprocessing_vars (const GetPot &input, PostProcessedQuantities< libMesh::Real > &postprocessing)
	Register name of postprocessed quantity with PostProcessedQuantities. 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	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)

virtual void	compute_postprocessed_quantity (unsigned int quantity_index, const AssemblyContext &context, const libMesh::Point &point, libMesh::Real &value)

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...

Protected Member Functions
void	assemble_continuity_time_deriv (bool compute_jacobian, AssemblyContext &context)

void	assemble_momentum_time_deriv (bool compute_jacobian, AssemblyContext &context)

void	assemble_energy_time_deriv (bool compute_jacobian, AssemblyContext &context)

void	assemble_continuity_mass_residual (bool compute_jacobian, AssemblyContext &context)

void	assemble_momentum_mass_residual (bool compute_jacobian, AssemblyContext &context)

void	assemble_energy_mass_residual (bool compute_jacobian, AssemblyContext &context)

Protected Attributes
LowMachNavierStokesStabilizationHelper	_stab_helper

libMesh::Number	_p0_over_R
	Thermodynamic pressure divided by gas constant. More...

libMesh::Number	_p0

libMesh::Number	_R

libMesh::Number	_T0

unsigned int	_dim
	Physical dimension of problem. More...

VariableIndex	_u_var
	Indices for each (owned) variable;. More...

VariableIndex	_v_var

VariableIndex	_w_var

VariableIndex	_p_var

VariableIndex	_T_var

VariableIndex	_p0_var

std::string	_u_var_name
	Names of each (owned) variable in the system. More...

std::string	_v_var_name

std::string	_w_var_name

std::string	_p_var_name

std::string	_T_var_name

std::string	_p0_var_name

GRINSEnums::FEFamily	_V_FE_family
	Element type, read from input. More...

GRINSEnums::FEFamily	_P_FE_family

GRINSEnums::FEFamily	_T_FE_family

GRINSEnums::Order	_V_order
	Element orders, read from input. More...

GRINSEnums::Order	_P_order

GRINSEnums::Order	_T_order

Viscosity	_mu
	Viscosity object. More...

SpecificHeat	_cp
	Specific heat object. More...

ThermalConductivity	_k
	Thermal conductivity object. More...

libMesh::Point	_g
	Gravity vector. More...

bool	_enable_thermo_press_calc
	Flag to enable thermodynamic pressure calculation. More...

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
	LowMachNavierStokesBraackStabilization ()

Detailed Description

template<class Viscosity, class SpecificHeat, class ThermalConductivity>
class GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >

Adds VMS-based stabilization to LowMachNavierStokes physics class.

Definition at line 36 of file low_mach_navier_stokes_braack_stab.h.

Constructor & Destructor Documentation

template<class Mu , class SH , class TC >

GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::LowMachNavierStokesBraackStabilization	(	const GRINS::PhysicsName &	physics_name,
		const GetPot &	input
	)

Definition at line 42 of file low_mach_navier_stokes_braack_stab.C.

     : LowMachNavierStokesStabilizationBase<Mu,SH,TC>(physics_name,input)
   {
     return;
   }

template<class Mu , class SH , class TC >

GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::~LowMachNavierStokesBraackStabilization ( )

virtual

Definition at line 50 of file low_mach_navier_stokes_braack_stab.C.

   {
     return;
   }

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >::LowMachNavierStokesBraackStabilization ( )

private

Member Function Documentation

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::assemble_continuity_mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context
	)

protected

Definition at line 313 of file low_mach_navier_stokes_braack_stab.C.

   {
     // The number of local degrees of freedom in each variable.
     const unsigned int n_p_dofs = context.get_dof_indices(this->_p_var).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_u_var)->get_JxW();
 
     // The pressure shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& p_dphi =
       context.get_element_fe(this->_p_var)->get_dphi();
 
     libMesh::DenseSubVector<libMesh::Number> &Fp = context.get_elem_residual(this->_p_var); // R_{p}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::FEBase* fe = context.get_element_fe(this->_u_var);
 
         libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
 
         libMesh::Real T = context.fixed_interior_value( this->_T_var, qp );
         libMesh::Real rho = this->rho( T, this->get_p0_transient( context, qp ) );
 
         libMesh::Real mu = this->_mu(T);
         libMesh::Real k = this->_k(T);
         libMesh::Real cp = this->_cp(T);
 
         libMesh::RealGradient U( context.fixed_interior_value( this->_u_var, qp ),
                                  context.fixed_interior_value( this->_v_var, qp ) );
         if( this->_dim == 3 )
           U(2) = context.fixed_interior_value( this->_w_var, qp );
 
         libMesh::Real tau_M = this->_stab_helper.compute_tau_momentum( context, qp, g, G, rho, U, mu, false );
         libMesh::RealGradient RM_t = this->compute_res_momentum_transient( context, qp );
 
         libMesh::Real tau_E = this->_stab_helper.compute_tau_energy( context, qp, g, G, rho, U, k, cp, false );
         libMesh::Real RE_t = this->compute_res_energy_transient( context, qp );
 
         // Now a loop over the pressure degrees of freedom.  This
         // computes the contributions of the continuity equation.
         for (unsigned int i=0; i != n_p_dofs; i++)
           {
             Fp(i) += ( tau_M*RM_t*p_dphi[i][qp] 
                        +  tau_E*RE_t*(U*p_dphi[i][qp])/T
                        )*JxW[qp];
           }
       }
 
     return;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::assemble_continuity_time_deriv	(	bool	compute_jacobian,
		AssemblyContext &	context
	)

protected

Definition at line 94 of file low_mach_navier_stokes_braack_stab.C.

   {
     // The number of local degrees of freedom in each variable.
     const unsigned int n_p_dofs = context.get_dof_indices(this->_p_var).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_u_var)->get_JxW();
 
     // The pressure shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& p_dphi =
       context.get_element_fe(this->_p_var)->get_dphi();
 
     libMesh::DenseSubVector<libMesh::Number> &Fp = context.get_elem_residual(this->_p_var); // R_{p}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::FEBase* fe = context.get_element_fe(this->_u_var);
 
         libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
 
         libMesh::Real T = context.interior_value( this->_T_var, qp );
         libMesh::Real rho = this->rho( T, this->get_p0_steady( context, qp ) );
 
         libMesh::Real mu = this->_mu(T);
         libMesh::Real k = this->_k(T);
         libMesh::Real cp = this->_cp(T);
 
         libMesh::RealGradient U( context.interior_value( this->_u_var, qp ),
                                  context.interior_value( this->_v_var, qp ) );
         if( this->_dim == 3 )
           U(2) = context.interior_value( this->_w_var, qp ); // w
 
         libMesh::Real tau_M = this->_stab_helper.compute_tau_momentum( context, qp, g, G, rho, U, mu, this->_is_steady );
         libMesh::Real tau_E = this->_stab_helper.compute_tau_energy( context, qp, g, G, rho, U, k, cp, this->_is_steady );
 
         libMesh::RealGradient RM_s = this->compute_res_momentum_steady( context, qp );
         libMesh::Real RE_s = this->compute_res_energy_steady( context, qp );
 
         // Now a loop over the pressure degrees of freedom.  This
         // computes the contributions of the continuity equation.
         for (unsigned int i=0; i != n_p_dofs; i++)
           {
             Fp(i) += ( tau_M*RM_s*p_dphi[i][qp] 
                        + tau_E*RE_s*(U*p_dphi[i][qp])/T )*JxW[qp];
           }
 
       }
 
     return;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::assemble_energy_mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context
	)

protected

Definition at line 468 of file low_mach_navier_stokes_braack_stab.C.

   {
     // The number of local degrees of freedom in each variable.
     const unsigned int n_T_dofs = context.get_dof_indices(this->_T_var).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_T_var)->get_JxW();
 
     // The temperature shape functions gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& T_gradphi =
       context.get_element_fe(this->_T_var)->get_dphi();
 
     const std::vector<std::vector<libMesh::RealTensor> >& T_hessphi =
       context.get_element_fe(this->_T_var)->get_d2phi();
 
     libMesh::DenseSubVector<libMesh::Number> &FT = context.get_elem_residual(this->_T_var); // R_{T}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::Number u, v;
         u = context.fixed_interior_value(this->_u_var, qp);
         v = context.fixed_interior_value(this->_v_var, qp);
 
         libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_T_var, qp);
 
         libMesh::NumberVectorValue U(u,v);
         if (this->_dim == 3)
           U(2) = context.fixed_interior_value(this->_w_var, qp); // w
 
         libMesh::Real T = context.fixed_interior_value( this->_T_var, qp );
         libMesh::Real rho = this->rho( T, this->get_p0_transient( context, qp ) );
 
         libMesh::Real k = this->_k(T);
         libMesh::Real cp = this->_cp(T);
 
         libMesh::Number rho_cp = rho*cp;
 
         libMesh::FEBase* fe = context.get_element_fe(this->_u_var);
 
         libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
 
         libMesh::Real tau_E = this->_stab_helper.compute_tau_energy( context, qp, g, G, rho, U, k, cp, false );
 
         libMesh::Real RE_t = this->compute_res_energy_transient( context, qp );
 
         for (unsigned int i=0; i != n_T_dofs; i++)
           {
             FT(i) += ( rho_cp*tau_E*RE_t*U*T_gradphi[i][qp]
                        + tau_E*RE_t*k*(T_hessphi[i][qp](0,0) + T_hessphi[i][qp](1,1) + T_hessphi[i][qp](2,2)) 
                        )*JxW[qp];
           }
 
       }
 
     return;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::assemble_energy_time_deriv	(	bool	compute_jacobian,
		AssemblyContext &	context
	)

protected

Definition at line 250 of file low_mach_navier_stokes_braack_stab.C.

   {
     // The number of local degrees of freedom in each variable.
     const unsigned int n_T_dofs = context.get_dof_indices(this->_T_var).size();
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_T_var)->get_JxW();
 
     // The temperature shape functions gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& T_gradphi =
       context.get_element_fe(this->_T_var)->get_dphi();
 
     const std::vector<std::vector<libMesh::RealTensor> >& T_hessphi =
       context.get_element_fe(this->_T_var)->get_d2phi();
 
     libMesh::DenseSubVector<libMesh::Number> &FT = context.get_elem_residual(this->_T_var); // R_{T}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::Number u, v;
         u = context.interior_value(this->_u_var, qp);
         v = context.interior_value(this->_v_var, qp);
 
         libMesh::Gradient grad_T = context.interior_gradient(this->_T_var, qp);
 
         libMesh::NumberVectorValue U(u,v);
         if (this->_dim == 3)
           U(2) = context.interior_value(this->_w_var, qp);
       
         libMesh::Real T = context.interior_value( this->_T_var, qp );
         libMesh::Real rho = this->rho( T, this->get_p0_steady( context, qp ) );
 
         libMesh::Real k = this->_k(T);
         libMesh::Real cp = this->_cp(T);
 
         libMesh::Number rho_cp = rho*this->_cp(T);
 
         libMesh::FEBase* fe = context.get_element_fe(this->_u_var);
 
         libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
 
         libMesh::Real tau_E = this->_stab_helper.compute_tau_energy( context, qp, g, G, rho, U, k, cp, this->_is_steady );
 
         libMesh::Real RE_s = this->compute_res_energy_steady( context, qp );
 
         for (unsigned int i=0; i != n_T_dofs; i++)
           {
             FT(i) += ( rho_cp*tau_E*RE_s*U*T_gradphi[i][qp]
                        + tau_E*RE_s*k*(T_hessphi[i][qp](0,0) + T_hessphi[i][qp](1,1) + T_hessphi[i][qp](2,2) ) 
                        )*JxW[qp];
           }
 
       }
 
     return;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::assemble_momentum_mass_residual	(	bool	compute_jacobian,
		AssemblyContext &	context
	)

protected

Definition at line 370 of file low_mach_navier_stokes_braack_stab.C.

   {
     // The number of local degrees of freedom in each variable.
     const unsigned int n_u_dofs = context.get_dof_indices(this->_u_var).size();
 
     // Check number of dofs is same for _u_var, v_var and w_var.
     libmesh_assert (n_u_dofs == context.get_dof_indices(this->_v_var).size());
     if (this->_dim == 3)
       libmesh_assert (n_u_dofs == context.get_dof_indices(this->_w_var).size());
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_u_var)->get_JxW();
 
     // The velocity shape function gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& u_gradphi =
       context.get_element_fe(this->_u_var)->get_dphi();
 
     const std::vector<std::vector<libMesh::RealTensor> >& u_hessphi =
       context.get_element_fe(this->_u_var)->get_d2phi();
 
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(this->_u_var); // R_{u}
     libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(this->_v_var); // R_{v}
     libMesh::DenseSubVector<libMesh::Number> &Fw = context.get_elem_residual(this->_w_var); // R_{w}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::Real T = context.fixed_interior_value( this->_T_var, qp );
         libMesh::Real rho = this->rho( T, this->get_p0_transient( context, qp ) );
 
         libMesh::Real mu = this->_mu(T);
 
         libMesh::RealGradient U( context.fixed_interior_value(this->_u_var, qp),
                                  context.fixed_interior_value(this->_v_var, qp) );
 
         libMesh::RealGradient grad_u = context.fixed_interior_gradient(this->_u_var, qp);
         libMesh::RealGradient grad_v = context.fixed_interior_gradient(this->_v_var, qp);
         libMesh::RealGradient grad_w;
 
         if( this->_dim == 3 )
           {
             U(2) = context.fixed_interior_value(this->_w_var, qp);
             grad_w = context.fixed_interior_gradient(this->_w_var, qp);
           }
 
         libMesh::FEBase* fe = context.get_element_fe(this->_u_var);
 
         libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
 
         libMesh::Real tau_M = this->_stab_helper.compute_tau_momentum( context, qp, g, G, rho, U, mu, false );
         libMesh::Real tau_C = this->_stab_helper.compute_tau_continuity( tau_M, g );
 
         libMesh::Real RC_t = this->compute_res_continuity_transient( context, qp );
         libMesh::RealGradient RM_t = this->compute_res_momentum_transient( context, qp );
       
         for (unsigned int i=0; i != n_u_dofs; i++)
           {
             Fu(i) += (  tau_C*RC_t*u_gradphi[i][qp](0)
                         + tau_M*RM_t(0)*rho*U*u_gradphi[i][qp]
                         + mu*tau_M*RM_t(0)*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) 
                                             + u_hessphi[i][qp](0,0) + u_hessphi[i][qp](0,1) 
                                             - 2.0/3.0*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,0)) ) 
                         )*JxW[qp];
 
             Fv(i) += ( tau_C*RC_t*u_gradphi[i][qp](1)
                        + tau_M*RM_t(1)*rho*U*u_gradphi[i][qp]
                        + mu*tau_M*RM_t(1)*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) 
                                            + u_hessphi[i][qp](1,0) + u_hessphi[i][qp](1,1) 
                                            - 2.0/3.0*(u_hessphi[i][qp](0,1) + u_hessphi[i][qp](1,1)) ) 
                        )*JxW[qp];
 
             if( this->_dim == 3 )
               {
                 Fw(i) -= mu*tau_M*RM_t(0)*(u_hessphi[i][qp](2,2) + u_hessphi[i][qp](0,2) 
                                            - 2.0/3.0*u_hessphi[i][qp](2,0))*JxW[qp];
 
                 Fv(i) -= mu*tau_M*RM_t(1)*(u_hessphi[i][qp](2,2) + u_hessphi[i][qp](1,2)
                                            - 2.0/3.0*u_hessphi[i][qp](2,1))*JxW[qp];
 
                 Fw(i) -= ( tau_C*RC_t*u_gradphi[i][qp](2)
                            + tau_M*RM_t(2)*rho*U*u_gradphi[i][qp]
                            + mu*tau_M*RM_t(2)*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) + u_hessphi[i][qp](2,2)
                                                + u_hessphi[i][qp](2,0) + u_hessphi[i][qp](2,1) + u_hessphi[i][qp](2,2)
                                                - 2.0/3.0*(u_hessphi[i][qp](0,2) + u_hessphi[i][qp](1,2) 
                                                           + u_hessphi[i][qp](2,2)) 
                                                ) 
                            )*JxW[qp];
               }
           }
 
       }
     return;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::assemble_momentum_time_deriv	(	bool	compute_jacobian,
		AssemblyContext &	context
	)

protected

Definition at line 151 of file low_mach_navier_stokes_braack_stab.C.

   {
     // The number of local degrees of freedom in each variable.
     const unsigned int n_u_dofs = context.get_dof_indices(this->_u_var).size();
 
     // Check number of dofs is same for _u_var, v_var and w_var.
     libmesh_assert (n_u_dofs == context.get_dof_indices(this->_v_var).size());
     if (this->_dim == 3)
       libmesh_assert (n_u_dofs == context.get_dof_indices(this->_w_var).size());
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_u_var)->get_JxW();
 
     // The velocity shape function gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& u_gradphi =
       context.get_element_fe(this->_u_var)->get_dphi();
 
     const std::vector<std::vector<libMesh::RealTensor> >& u_hessphi =
       context.get_element_fe(this->_u_var)->get_d2phi();
 
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(this->_u_var); // R_{u}
     libMesh::DenseSubVector<libMesh::Number> &Fv = context.get_elem_residual(this->_v_var); // R_{v}
     libMesh::DenseSubVector<libMesh::Number> &Fw = context.get_elem_residual(this->_w_var); // R_{w}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::Real T = context.interior_value( this->_T_var, qp );
         libMesh::Real rho = this->rho( T, this->get_p0_steady( context, qp ) );
 
         libMesh::Real mu = this->_mu(T);
 
         libMesh::RealGradient U( context.interior_value(this->_u_var, qp),
                                  context.interior_value(this->_v_var, qp) );
 
         libMesh::RealGradient grad_u = context.interior_gradient(this->_u_var, qp);
         libMesh::RealGradient grad_v = context.interior_gradient(this->_v_var, qp);
         libMesh::RealGradient grad_w;
 
         if( this->_dim == 3 )
           {
             U(2) = context.interior_value(this->_w_var, qp);
             grad_w = context.interior_gradient(this->_w_var, qp);
           }
 
         libMesh::FEBase* fe = context.get_element_fe(this->_u_var);
 
         libMesh::RealGradient g = this->_stab_helper.compute_g( fe, context, qp );
         libMesh::RealTensor G = this->_stab_helper.compute_G( fe, context, qp );
 
         libMesh::Real tau_M = this->_stab_helper.compute_tau_momentum( context, qp, g, G, rho, U, mu, this->_is_steady );
         libMesh::Real tau_C = this->_stab_helper.compute_tau_continuity( tau_M, g );
 
         libMesh::Real RC_s = this->compute_res_continuity_steady( context, qp );
         libMesh::RealGradient RM_s = this->compute_res_momentum_steady( context, qp );
 
         for (unsigned int i=0; i != n_u_dofs; i++)
           {
             Fu(i) += ( tau_C*RC_s*u_gradphi[i][qp](0)
                        + tau_M*RM_s(0)*rho*U*u_gradphi[i][qp] 
                        + mu*tau_M*RM_s(0)*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) 
                                            + u_hessphi[i][qp](0,0) + u_hessphi[i][qp](0,1) 
                                            - 2.0/3.0*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,0)) ) 
                        )*JxW[qp];
 
             Fv(i) += ( tau_C*RC_s*u_gradphi[i][qp](1)
                        + tau_M*RM_s(1)*rho*U*u_gradphi[i][qp]
                        + mu*tau_M*RM_s(1)*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) 
                                            + u_hessphi[i][qp](1,0) + u_hessphi[i][qp](1,1) 
                                            - 2.0/3.0*(u_hessphi[i][qp](0,1) + u_hessphi[i][qp](1,1)) ) 
                        )*JxW[qp];
 
             if( this->_dim == 3 )
               {
                 Fu(i) += mu*tau_M*RM_s(0)*(u_hessphi[i][qp](2,2) + u_hessphi[i][qp](0,2) 
                                            - 2.0/3.0*u_hessphi[i][qp](2,0))*JxW[qp];
 
                 Fv(i) += mu*tau_M*RM_s(1)*(u_hessphi[i][qp](2,2) + u_hessphi[i][qp](1,2)
                                            - 2.0/3.0*u_hessphi[i][qp](2,1))*JxW[qp];
 
                 Fw(i) += ( tau_C*RC_s*u_gradphi[i][qp](2)
                            + tau_M*RM_s(2)*rho*U*u_gradphi[i][qp]
                            + mu*tau_M*RM_s(2)*(u_hessphi[i][qp](0,0) + u_hessphi[i][qp](1,1) + u_hessphi[i][qp](2,2)
                                                + u_hessphi[i][qp](2,0) + u_hessphi[i][qp](2,1) + u_hessphi[i][qp](2,2)
                                                - 2.0/3.0*(u_hessphi[i][qp](0,2) + u_hessphi[i][qp](1,2) 
                                                           + u_hessphi[i][qp](2,2)) 
                                                ) 
                            )*JxW[qp];
               }
           }
 
       }
     return;
   }

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;
   }

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;
   }

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;
   }

void GRINS::Physics::compute_postprocessed_quantity	(	unsigned int	quantity_index,
		const AssemblyContext &	context,
		const libMesh::Point &	point,
		libMesh::Real &	value
	)

virtualinherited

Reimplemented in GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >, GRINS::HeatTransfer< Conductivity >, GRINS::ParsedVelocitySource< Viscosity >, GRINS::VelocityPenalty< Viscosity >, GRINS::ElasticMembrane< StressStrainLaw >, and GRINS::ElasticCable< StressStrainLaw >.

Definition at line 271 of file physics.C.

   {
     return;
   }

template<class Mu , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::compute_res_continuity_steady	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

inherited

Definition at line 70 of file low_mach_navier_stokes_stab_base.C.

   {
     libMesh::Real T = context.fixed_interior_value(this->_T_var, qp);
     libMesh::RealGradient grad_T = context.fixed_interior_gradient(this->_T_var, qp);
 
     libMesh::RealGradient U( context.fixed_interior_value(this->_u_var, qp),
                              context.fixed_interior_value(this->_v_var, qp) );  
 
     libMesh::RealGradient grad_u, grad_v;
 
     grad_u = context.fixed_interior_gradient(this->_u_var, qp);
     grad_v = context.fixed_interior_gradient(this->_v_var, qp);
 
     libMesh::Real divU = grad_u(0) + grad_v(1);
 
     if( this->_dim == 3 )
       {
         U(2) = context.fixed_interior_value(this->_w_var, qp);
         divU += (context.fixed_interior_gradient(this->_w_var, qp))(2);
       }
 
     return divU - (U*grad_T)/T;
   }

template<class Mu , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::compute_res_continuity_transient	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

inherited

Definition at line 96 of file low_mach_navier_stokes_stab_base.C.

   {
     libMesh::Real T = context.fixed_interior_value(this->_T_var, qp);
     libMesh::Real T_dot = context.interior_value(this->_T_var, qp);
 
     libMesh::Real RC_t = -T_dot/T;
 
     if( this->_enable_thermo_press_calc )
       {
         libMesh::Real p0 = context.fixed_interior_value(this->_p0_var, qp);
         libMesh::Real p0_dot = context.interior_value(this->_p0_var, qp);
 
         RC_t += p0_dot/p0;
       }
 
     return RC_t;
   }

template<class Mu , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::compute_res_energy_steady	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

inherited

Definition at line 220 of file low_mach_navier_stokes_stab_base.C.

   {
     libMesh::Real T = context.fixed_interior_value(this->_T_var, qp);
     libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_T_var, qp);
     libMesh::Tensor hess_T = context.fixed_interior_hessian(this->_T_var, qp);
 
     libMesh::Real rho = this->rho(T, this->get_p0_transient(context,qp) );
     libMesh::Real rho_cp = rho*this->_cp(T);
 
     libMesh::RealGradient rhocpU( rho_cp*context.fixed_interior_value(this->_u_var, qp), 
                                   rho_cp*context.fixed_interior_value(this->_v_var, qp) );
     if(this->_dim == 3)
       rhocpU(2) = rho_cp*context.fixed_interior_value(this->_w_var, qp);
 
     libMesh::Real hess_term = hess_T(0,0) + hess_T(1,1);
 #if LIBMESH_DIM > 2
     hess_term += hess_T(2,2);
 #endif
 
     return rhocpU*grad_T - this->_k.deriv(T)*(grad_T*grad_T) - this->_k(T)*(hess_term);
   }

template<class Mu , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::compute_res_energy_transient	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

inherited

Definition at line 245 of file low_mach_navier_stokes_stab_base.C.

   {
     libMesh::Real T = context.fixed_interior_value(this->_T_var, qp);
     libMesh::Real rho = this->rho(T, this->get_p0_transient(context,qp) );
     libMesh::Real rho_cp = rho*this->_cp(T);
     libMesh::Real T_dot = context.interior_value(this->_T_var, qp);
 
     libMesh::Real RE_t = rho_cp*T_dot;
 
     if( this->_enable_thermo_press_calc )
       {
         RE_t -= context.interior_value(this->_p0_var, qp);
       }
   
     return RE_t;
   }

template<class Mu , class SH , class TC >

libMesh::RealGradient GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::compute_res_momentum_steady	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

inherited

Definition at line 116 of file low_mach_navier_stokes_stab_base.C.

   {
     libMesh::Real T = context.fixed_interior_value(this->_T_var, qp);
 
     libMesh::Real rho = this->rho(T, this->get_p0_transient(context,qp) );
 
     libMesh::RealGradient U( context.fixed_interior_value(this->_u_var, qp), 
                              context.fixed_interior_value(this->_v_var, qp) );
     if(this->_dim == 3)
       U(2) = context.fixed_interior_value(this->_w_var, qp);
 
     libMesh::RealGradient grad_p = context.fixed_interior_gradient(this->_p_var, qp);
 
     libMesh::RealGradient grad_u = context.fixed_interior_gradient(this->_u_var, qp);
     libMesh::RealGradient grad_v = context.fixed_interior_gradient(this->_v_var, qp);
 
     libMesh::RealTensor hess_u = context.fixed_interior_hessian(this->_u_var, qp);
     libMesh::RealTensor hess_v = context.fixed_interior_hessian(this->_v_var, qp);
 
     libMesh::RealGradient rhoUdotGradU;
     libMesh::RealGradient divGradU;
     libMesh::RealGradient divGradUT;
     libMesh::RealGradient divdivU;
 
     if( this->_dim < 3 )
       {
         rhoUdotGradU = rho*_stab_helper.UdotGradU( U, grad_u, grad_v );
         divGradU  = _stab_helper.div_GradU( hess_u, hess_v );
         divGradUT = _stab_helper.div_GradU_T( hess_u, hess_v );
         divdivU   = _stab_helper.div_divU_I( hess_u, hess_v );
       }
     else
       {
         libMesh::RealGradient grad_w = context.fixed_interior_gradient(this->_w_var, qp);
         libMesh::RealTensor hess_w = context.fixed_interior_hessian(this->_w_var, qp);
       
         rhoUdotGradU = rho*_stab_helper.UdotGradU( U, grad_u, grad_v, grad_w );
 
         divGradU  = _stab_helper.div_GradU( hess_u, hess_v, hess_w );
         divGradUT = _stab_helper.div_GradU_T( hess_u, hess_v, hess_w );
         divdivU   = _stab_helper.div_divU_I( hess_u, hess_v, hess_w );
       }
 
     libMesh::RealGradient divT = this->_mu(T)*(divGradU + divGradUT - 2.0/3.0*divdivU);
 
     if( this->_mu.deriv(T) != 0.0 )
       {
         libMesh::Gradient grad_T = context.fixed_interior_gradient(this->_T_var, qp);
 
         libMesh::Gradient grad_u = context.fixed_interior_gradient(this->_u_var, qp);
         libMesh::Gradient grad_v = context.fixed_interior_gradient(this->_v_var, qp);
 
         libMesh::Gradient gradTgradu( grad_T*grad_u, grad_T*grad_v );
 
         libMesh::Gradient gradTgraduT( grad_T(0)*grad_u(0) + grad_T(1)*grad_u(1),
                                        grad_T(0)*grad_v(0) + grad_T(1)*grad_v(1) );
 
         libMesh::Real divU = grad_u(0) + grad_v(1);
 
         libMesh::Gradient gradTdivU( grad_T(0)*divU, grad_T(1)*divU );
 
         if(this->_dim == 3)
           {
             libMesh::Gradient grad_w = context.fixed_interior_gradient(this->_w_var, qp);
 
             gradTgradu(2) = grad_T*grad_w;
 
             gradTgraduT(0) += grad_T(2)*grad_u(2);
             gradTgraduT(1) += grad_T(2)*grad_v(2);
             gradTgraduT(2) = grad_T(0)*grad_w(0) + grad_T(1)*grad_w(1) + grad_T(2)*grad_w(2);
 
             divU += grad_w(2);
             gradTdivU(0) += grad_T(0)*grad_w(2);
             gradTdivU(1) += grad_T(1)*grad_w(2);
             gradTdivU(2) += grad_T(2)*divU;
           }
       
         divT += this->_mu.deriv(T)*( gradTgradu + gradTgraduT - 2.0/3.0*gradTdivU );
       }
 
     libMesh::RealGradient rhog( rho*this->_g(0), rho*this->_g(1) );
     if(this->_dim == 3)
       rhog(2) = rho*this->_g(2);
 
     return rhoUdotGradU + grad_p - divT - rhog;
   }

template<class Mu , class SH , class TC >

libMesh::RealGradient GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::compute_res_momentum_transient	(	AssemblyContext &	context,
		unsigned int	qp
	)		const

inherited

Definition at line 205 of file low_mach_navier_stokes_stab_base.C.

   {
     libMesh::Real T = context.fixed_interior_value(this->_T_var, qp);
     libMesh::Real rho = this->rho(T, this->get_p0_transient(context,qp) );
 
     libMesh::RealGradient u_dot( context.interior_value(this->_u_var, qp), context.interior_value(this->_v_var, qp) );
 
     if(this->_dim == 3)
       u_dot(2) = context.interior_value(this->_w_var, qp);
 
     return rho*u_dot;
   }

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<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::d_rho_dT	(	libMesh::Real	T,
		libMesh::Real	p0
	)		const

inlineinherited

Definition at line 151 of file low_mach_navier_stokes_base.h.

   {
     return -p0/(this->_R*(T*T));
   }

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<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::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 56 of file low_mach_navier_stokes_braack_stab.C.

   {
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("LowMachNavierStokesBraackStabilization::element_time_derivative");
 #endif
 
     this->assemble_continuity_time_deriv( compute_jacobian, context );
     this->assemble_momentum_time_deriv( compute_jacobian, context );
     this->assemble_energy_time_deriv( compute_jacobian, context );
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("LowMachNavierStokesBraackStabilization::element_time_derivative");
 #endif
     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;
   }

ICHandlingBase * GRINS::Physics::get_ic_handler ( )

inlineinherited

Definition at line 288 of file physics.h.

References GRINS::Physics::_ic_handler.

   {
     return _ic_handler;
   }

template<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::get_p0_steady	(	const AssemblyContext &	c,
		unsigned int	qp
	)		const

inlineinherited

Definition at line 158 of file low_mach_navier_stokes_base.h.

   {
     libMesh::Real p0;
     if( this->_enable_thermo_press_calc )
       {
         p0 = c.interior_value( _p0_var, qp );
       }
     else
       {
         p0 = _p0;
       }
     return p0;
   }

template<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::get_p0_steady	(	const AssemblyContext &	c,
		const libMesh::Point &	p
	)		const

inlineinherited

Definition at line 192 of file low_mach_navier_stokes_base.h.

   {
     libMesh::Real p0;
     if( this->_enable_thermo_press_calc )
       {
         p0 = c.point_value( _p0_var, p );
       }
     else
       {
         p0 = _p0;
       }
     return p0;
   }

template<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::get_p0_steady_side	(	const AssemblyContext &	c,
		unsigned int	qp
	)		const

inlineinherited

Definition at line 175 of file low_mach_navier_stokes_base.h.

   {
     libMesh::Real p0;
     if( this->_enable_thermo_press_calc )
       {
         p0 = c.side_value( _p0_var, qp );
       }
     else
       {
         p0 = _p0;
       }
     return p0;
   }

template<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::get_p0_transient	(	AssemblyContext &	c,
		unsigned int	qp
	)		const

inlineinherited

Definition at line 209 of file low_mach_navier_stokes_base.h.

   {
     libMesh::Real p0;
     if( this->_enable_thermo_press_calc )
       {
         p0 = c.fixed_interior_value( _p0_var, qp );
       }
     else
       {
         p0 = _p0;
       }
     return p0;
   }

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;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesStabilizationBase< Mu, SH, TC >::init_context ( AssemblyContext & context )

virtualinherited

Initialize context for added physics variables.

Reimplemented from GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >.

Definition at line 54 of file low_mach_navier_stokes_stab_base.C.

References GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::init_context().

   {
     // First call base class
     LowMachNavierStokesBase<Mu,SH,TC>::init_context(context);
   
     // We need pressure derivatives
     context.get_element_fe(this->_p_var)->get_dphi();
 
     // We also need second derivatives, so initialize those.
     context.get_element_fe(this->_u_var)->get_d2phi();
     context.get_element_fe(this->_T_var)->get_d2phi();
 
     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<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBase< Mu, SH, TC >::init_variables ( libMesh::FEMSystem * system )

virtualinherited

Initialize variables for this physics.

Implements GRINS::Physics.

Definition at line 130 of file low_mach_navier_stokes_base.C.

   {
     // Get libMesh to assign an index for each variable
     this->_dim = system->get_mesh().mesh_dimension();
 
     _u_var = system->add_variable( _u_var_name, this->_V_order, _V_FE_family);
     _v_var = system->add_variable( _v_var_name, this->_V_order, _V_FE_family);
 
     if (_dim == 3)
       _w_var = system->add_variable( _w_var_name, this->_V_order, _V_FE_family);
     else
       _w_var = _u_var;
 
     _p_var = system->add_variable( _p_var_name, this->_P_order, _P_FE_family);
     _T_var = system->add_variable( _T_var_name, this->_T_order, _T_FE_family);
 
     /* If we need to compute the thermodynamic pressure, we force this to be a first
        order scalar variable. */
     if( _enable_thermo_press_calc )
       _p0_var = system->add_variable( _p0_var_name, libMesh::FIRST, libMesh::SCALAR);
 
     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<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBraackStabilization< Mu, SH, TC >::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 75 of file low_mach_navier_stokes_braack_stab.C.

   {
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->BeginTimer("LowMachNavierStokesBraackStabilization::mass_residual");
 #endif
 
     this->assemble_continuity_mass_residual( compute_jacobian, context );
     this->assemble_momentum_mass_residual( compute_jacobian, context );
     this->assemble_energy_mass_residual( compute_jacobian, context );
 
 #ifdef GRINS_USE_GRVY_TIMERS
     this->_timer->EndTimer("LowMachNavierStokesBraackStabilization::mass_residual");
 #endif
     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;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBase< Mu, SH, TC >::read_input_options ( const GetPot & input )

virtualinherited

Read options from GetPot input file.

Reimplemented from GRINS::Physics.

Reimplemented in GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >.

Definition at line 63 of file low_mach_navier_stokes_base.C.

References GRINS::low_mach_navier_stokes, GRINS::p_var_name_default, GRINS::T_var_name_default, GRINS::u_var_name_default, GRINS::v_var_name_default, and GRINS::w_var_name_default.

Referenced by GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::LowMachNavierStokesBase().

   {
     // Read FE info
     this->_V_FE_family =
       libMesh::Utility::string_to_enum<GRINSEnums::FEFamily>( input("Physics/"+low_mach_navier_stokes+"/V_FE_family", "LAGRANGE") );
 
     this->_P_FE_family =
       libMesh::Utility::string_to_enum<GRINSEnums::FEFamily>( input("Physics/"+low_mach_navier_stokes+"/P_FE_family", "LAGRANGE") );
 
     this->_T_FE_family =
       libMesh::Utility::string_to_enum<GRINSEnums::FEFamily>( input("Physics/"+low_mach_navier_stokes+"/T_FE_family", "LAGRANGE") );
 
     this->_V_order =
       libMesh::Utility::string_to_enum<GRINSEnums::Order>( input("Physics/"+low_mach_navier_stokes+"/V_order", "SECOND") );
 
     this->_P_order =
       libMesh::Utility::string_to_enum<GRINSEnums::Order>( input("Physics/"+low_mach_navier_stokes+"/P_order", "FIRST") );
 
     this->_T_order =
       libMesh::Utility::string_to_enum<GRINSEnums::Order>( input("Physics/"+low_mach_navier_stokes+"/T_order", "SECOND") );
 
     // Read variable naming info
     this->_u_var_name = input("Physics/VariableNames/u_velocity", u_var_name_default );
     this->_v_var_name = input("Physics/VariableNames/v_velocity", v_var_name_default );
     this->_w_var_name = input("Physics/VariableNames/w_velocity", w_var_name_default );
     this->_p_var_name = input("Physics/VariableNames/pressure", p_var_name_default );
     this->_T_var_name = input("Physics/VariableNames/temperature", T_var_name_default );
 
     // Read thermodynamic state info
     this->set_parameter
       (_p0, input, "Physics/"+low_mach_navier_stokes+"/p0", 0.0 ); /* thermodynamic pressure */
     this->set_parameter
       (_T0, input, "Physics/"+low_mach_navier_stokes+"/T0", 0.0 ); /* Reference temperature */
     this->set_parameter
       (_R, input, "Physics/"+low_mach_navier_stokes+"/R", 0.0 ); /* gas constant */
 
     if( _R <= 0.0 )
       {
         std::cerr << "=========================================" << std::endl
                   << " Error: Gas constant R must be positive. " << std::endl
                   << " Detected value R = " << _R << std::endl
                   << "=========================================" << std::endl;
         libmesh_error();
       }
 
     _p0_over_R = _p0/_R;
 
     _enable_thermo_press_calc = input("Physics/"+low_mach_navier_stokes+"/enable_thermo_press_calc", false );
 
     if( _enable_thermo_press_calc )
       {
         _p0_var_name = input("Physics/VariableNames/thermo_presure", "p0" );
       }
 
     // Read gravity vector
     unsigned int g_dim = input.vector_variable_size("Physics/"+low_mach_navier_stokes+"/g");
 
     _g(0) = input("Physics/"+low_mach_navier_stokes+"/g", 0.0, 0 );
     _g(1) = input("Physics/"+low_mach_navier_stokes+"/g", 0.0, 1 );
   
     if( g_dim == 3)
       _g(2) = input("Physics/"+low_mach_navier_stokes+"/g", 0.0, 2 );
   
     return;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBase< Mu, SH, TC >::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 from GRINS::ParameterUser.

Definition at line 198 of file low_mach_navier_stokes_base.C.

References GRINS::ParameterUser::register_parameter().

   {
     ParameterUser::register_parameter(param_name, param_pointer);
     _mu.register_parameter(param_name, param_pointer);
     _cp.register_parameter(param_name, param_pointer);
     _k.register_parameter(param_name, param_pointer);
   }

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

virtualinherited

Register name of postprocessed quantity with PostProcessedQuantities.

Each Physics class will need to cache an unsigned int corresponding to each postprocessed quantity. This will be used in computing the values and putting them in the CachedVariables object.

Reimplemented in GRINS::ParsedVelocitySource< Viscosity >, GRINS::VelocityPenalty< Viscosity >, GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::HeatTransfer< Conductivity >, GRINS::ElasticCable< StressStrainLaw >, GRINS::ElasticMembrane< StressStrainLaw >, and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >.

Definition at line 161 of file physics.C.

   {
     return;
   }

template<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::rho	(	libMesh::Real	T,
		libMesh::Real	p0
	)		const

inlineinherited

Definition at line 144 of file low_mach_navier_stokes_base.h.

   {
     return p0/(this->_R*T);
   }

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;
   }

template<class Mu , class SH , class TC >

void GRINS::LowMachNavierStokesBase< Mu, SH, TC >::set_time_evolving_vars ( libMesh::FEMSystem * system )

virtualinherited

Sets velocity variables to be time-evolving.

Reimplemented from GRINS::Physics.

Definition at line 155 of file low_mach_navier_stokes_base.C.

   {
     const unsigned int dim = system->get_mesh().mesh_dimension();
 
     system->time_evolving(_u_var);
     system->time_evolving(_v_var);
 
     if (dim == 3)
       system->time_evolving(_w_var);
 
     system->time_evolving(_T_var);
     system->time_evolving(_p_var);
 
     if( _enable_thermo_press_calc )
       system->time_evolving(_p0_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;
   }   

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

virtualinherited

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

Reimplemented in GRINS::AxisymmetricHeatTransfer< Conductivity >, GRINS::LowMachNavierStokes< Viscosity, SpecificHeat, ThermalConductivity >, GRINS::HeatTransfer< Conductivity >, GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >, GRINS::ElasticCable< StressStrainLaw >, and GRINS::ElasticMembrane< StressStrainLaw >.

Definition at line 222 of file physics.C.

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

   {
     return;
   }

template<class V , class SH , class TC >

libMesh::Real GRINS::LowMachNavierStokesBase< V, SH, TC >::T	(	const libMesh::Point &	p,
		const AssemblyContext &	c
	)		const

inlineinherited

Definition at line 137 of file low_mach_navier_stokes_base.h.

   {
     return c.point_value(_T_var,p);
   }

Member Data Documentation

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().

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

SpecificHeat GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_cp

protectedinherited

Specific heat object.

Definition at line 118 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

unsigned int GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_dim

protectedinherited

Physical dimension of problem.

Definition at line 95 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

bool GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_enable_thermo_press_calc

protectedinherited

Flag to enable thermodynamic pressure calculation.

Definition at line 127 of file low_mach_navier_stokes_base.h.

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<class Viscosity , class SpecificHeat , class ThermalConductivity >

libMesh::Point GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_g

protectedinherited

Gravity vector.

Definition at line 124 of file low_mach_navier_stokes_base.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().

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().

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

ThermalConductivity GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_k

protectedinherited

Thermal conductivity object.

Definition at line 121 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

Viscosity GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_mu

protectedinherited

Viscosity object.

Definition at line 115 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

libMesh::Number GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_p0

protectedinherited

Definition at line 92 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

libMesh::Number GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_p0_over_R

protectedinherited

Thermodynamic pressure divided by gas constant.

Definition at line 90 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

VariableIndex GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_p0_var

protectedinherited

Definition at line 103 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

std::string GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_p0_var_name

protectedinherited

Definition at line 106 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINSEnums::FEFamily GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_P_FE_family

protectedinherited

Definition at line 109 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINSEnums::Order GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_P_order

protectedinherited

Definition at line 112 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

VariableIndex GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_p_var

protectedinherited

Definition at line 101 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

std::string GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_p_var_name

protectedinherited

Definition at line 106 of file low_mach_navier_stokes_base.h.

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<class Viscosity , class SpecificHeat , class ThermalConductivity >

libMesh::Number GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_R

protectedinherited

Definition at line 92 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

LowMachNavierStokesStabilizationHelper GRINS::LowMachNavierStokesStabilizationBase< Viscosity, SpecificHeat, ThermalConductivity >::_stab_helper

protectedinherited

Definition at line 69 of file low_mach_navier_stokes_stab_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

libMesh::Number GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_T0

protectedinherited

Definition at line 92 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINSEnums::FEFamily GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_T_FE_family

protectedinherited

Definition at line 109 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINSEnums::Order GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_T_order

protectedinherited

Definition at line 112 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

VariableIndex GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_T_var

protectedinherited

Definition at line 102 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

std::string GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_T_var_name

protectedinherited

Definition at line 106 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

VariableIndex GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_u_var

protectedinherited

Indices for each (owned) variable;.

Definition at line 98 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

std::string GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_u_var_name

protectedinherited

Names of each (owned) variable in the system.

Definition at line 106 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINSEnums::FEFamily GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_V_FE_family

protectedinherited

Element type, read from input.

Definition at line 109 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

GRINSEnums::Order GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_V_order

protectedinherited

Element orders, read from input.

Definition at line 112 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

VariableIndex GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_v_var

protectedinherited

Definition at line 99 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

std::string GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_v_var_name

protectedinherited

Definition at line 106 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

VariableIndex GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_w_var

protectedinherited

Definition at line 100 of file low_mach_navier_stokes_base.h.

template<class Viscosity , class SpecificHeat , class ThermalConductivity >

std::string GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::_w_var_name

protectedinherited

Definition at line 106 of file low_mach_navier_stokes_base.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

template<class Viscosity, class SpecificHeat, class ThermalConductivity> class GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class Viscosity, class SpecificHeat, class ThermalConductivity>
class GRINS::LowMachNavierStokesBraackStabilization< Viscosity, SpecificHeat, ThermalConductivity >