#include <reacting_low_mach_navier_stokes.h>

Inheritance diagram for GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >:

Collaboration diagram for GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >:

Public Member Functions
	ReactingLowMachNavierStokes (const PhysicsName &physics_name, const GetPot &input, libMesh::UniquePtr< Mixture > &gas_mix)

virtual	~ReactingLowMachNavierStokes ()

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 postprocessing variables for ReactingLowMachNavierStokes. More...

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

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

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

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

virtual void	compute_element_time_derivative_cache (AssemblyContext &context)

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

Public Member Functions inherited from GRINS::ReactingLowMachNavierStokesBase< Mixture >
	ReactingLowMachNavierStokesBase (const PhysicsName &physics_name, const GetPot &input, libMesh::UniquePtr< Mixture > &gas_mix)

virtual	~ReactingLowMachNavierStokesBase ()

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

const Mixture &	gas_mixture () const

Public Member Functions inherited from GRINS::ReactingLowMachNavierStokesAbstract
	ReactingLowMachNavierStokesAbstract (const PhysicsName &physics_name, const GetPot &input)

virtual	~ReactingLowMachNavierStokesAbstract ()

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

unsigned int	n_species () const

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

void	mass_fractions (const libMesh::Point &p, const AssemblyContext &c, std::vector< libMesh::Real > &mass_fracs) const

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

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

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

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

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

Public Member Functions inherited from GRINS::Physics
	Physics (const GRINS::PhysicsName &physics_name, const GetPot &input)

virtual	~Physics ()

virtual void	init_variables (libMesh::FEMSystem *)
	Initialize variables for this physics. 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	preassembly (MultiphysicsSystem &)
	Perform any necessary setup before element assembly begins. More...

virtual void	reinit (MultiphysicsSystem &)
	Any reinitialization that needs to be done. More...

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

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

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

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

virtual void	damping_residual (bool, AssemblyContext &)
	Damping matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. More...

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

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

virtual void	compute_side_time_derivative_cache (AssemblyContext &)

virtual void	compute_nonlocal_time_derivative_cache (AssemblyContext &)

virtual void	compute_element_constraint_cache (AssemblyContext &)

virtual void	compute_side_constraint_cache (AssemblyContext &)

virtual void	compute_nonlocal_constraint_cache (AssemblyContext &)

virtual void	compute_damping_residual_cache (AssemblyContext &)

virtual void	compute_mass_residual_cache (AssemblyContext &)

virtual void	compute_nonlocal_mass_residual_cache (AssemblyContext &)

ICHandlingBase *	get_ic_handler ()

Public Member Functions inherited from GRINS::ParameterUser
	ParameterUser (const std::string &user_name)

virtual	~ParameterUser ()

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	set_parameter (libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &func, const GetPot &input, const std::string &func_param_name, const std::string &param_default)
	Each subclass can simultaneously read a parsed function from. More...

virtual void	set_parameter (libMesh::ParsedFEMFunction< libMesh::Number > &func, const GetPot &input, const std::string &func_param_name, const std::string &param_default)
	Each subclass can simultaneously read a parsed function from. More...

virtual void	move_parameter (const libMesh::Number &old_parameter, libMesh::Number &new_parameter)
	When cloning an object, we need to update parameter pointers. More...

virtual void	move_parameter (const libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &old_func, libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &new_func)
	When cloning an object, we need to update parameter pointers. More...

virtual void	move_parameter (const libMesh::ParsedFEMFunction< libMesh::Number > &old_func, libMesh::ParsedFEMFunction< libMesh::Number > &new_func)
	When cloning an object, we need to update parameter pointers. More...

Protected Attributes
bool	_pin_pressure
	Enable pressure pinning. More...

PressurePinning	_p_pinning

unsigned int	_rho_index
	Index from registering this quantity. More...

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

unsigned int	_mu_index
	Index from registering this quantity. More...

unsigned int	_k_index
	Index from registering this quantity. More...

unsigned int	_cp_index
	Index from registering this quantity. More...

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

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

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

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

Protected Attributes inherited from GRINS::ReactingLowMachNavierStokesBase< Mixture >
libMesh::UniquePtr< Mixture >	_gas_mixture

Protected Attributes inherited from GRINS::ReactingLowMachNavierStokesAbstract
libMesh::Number	_p0

VelocityVariable &	_flow_vars

PressureFEVariable &	_press_var

PrimitiveTempFEVariables &	_temp_vars

SpeciesMassFractionsVariable &	_species_vars

ThermoPressureVariable *	_p0_var

unsigned int	_n_species
	Number of species. More...

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

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

bool	_fixed_density

libMesh::Real	_fixed_rho_value

Protected Attributes inherited from GRINS::Physics
const PhysicsName	_physics_name
	Name of the physics object. Used for reading physics specific inputs. More...

GRINS::ICHandlingBase *	_ic_handler

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

Private Member Functions
	ReactingLowMachNavierStokes ()

Additional Inherited Members
Static Public Member Functions inherited from GRINS::Physics
static void	set_is_axisymmetric (bool is_axisymmetric)
	Set whether we should treat the problem as axisymmetric. More...

static bool	is_axisymmetric ()

Static Public Attributes inherited from GRINS::ParameterUser
static std::string	zero_vector_function = std::string("{0}")
	A parseable function string with LIBMESH_DIM components, all 0. More...

Protected Member Functions inherited from GRINS::Physics
libMesh::UniquePtr< libMesh::FEGenericBase< libMesh::Real > >	build_new_fe (const libMesh::Elem elem, const libMesh::FEGenericBase< libMesh::Real > fe, const libMesh::Point p)

void	parse_enabled_subdomains (const GetPot &input, const std::string &physics_name)

void	check_var_subdomain_consistency (const FEVariablesBase &var) const
	Check that var is enabled on at least the subdomains this Physics is. More...

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

static bool	_is_axisymmetric = false
	Caches whether we are solving an axisymmetric problem or not. More...

Detailed Description

template<typename Mixture, typename Evaluator>
class GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >

Definition at line 35 of file reacting_low_mach_navier_stokes.h.

Constructor & Destructor Documentation

template<typename Mixture , typename Evaluator >

GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes	(	const PhysicsName &	physics_name,
		const GetPot &	input,
		libMesh::UniquePtr< Mixture > &	gas_mix
	)

Definition at line 42 of file reacting_low_mach_navier_stokes.C.

References GRINS::Physics::_ic_handler, GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_pin_pressure, and GRINS::PhysicsNaming::reacting_low_mach_navier_stokes().

     : ReactingLowMachNavierStokesBase<Mixture>(physics_name,input,gas_mix),
     _p_pinning(input,physics_name),
     _rho_index(0),
     _mu_index(0),
     _k_index(0),
     _cp_index(0)
   {
     this->_pin_pressure = input("Physics/"+PhysicsNaming::reacting_low_mach_navier_stokes()+"/pin_pressure", false );
 
     this->_ic_handler = new GenericICHandler( physics_name, input );
   }

template<typename Mixture , typename Evaluator >

virtual GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::~ReactingLowMachNavierStokes ( )

inlinevirtual

Definition at line 42 of file reacting_low_mach_navier_stokes.h.

42 {};

template<typename Mixture , typename Evaluator >

GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes ( )

private

Member Function Documentation

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::auxiliary_init ( MultiphysicsSystem & system )

virtual

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.

Reimplemented from GRINS::Physics.

Definition at line 58 of file reacting_low_mach_navier_stokes.C.

   {
     if( _pin_pressure )
       _p_pinning.check_pin_location(system.get_mesh());
   }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::compute_element_time_derivative_cache ( AssemblyContext & context )

virtual

Todo:: Need to figure out something smarter for controling species that go slightly negative.

Reimplemented from GRINS::Physics.

Definition at line 546 of file reacting_low_mach_navier_stokes.C.

References GRINS::Cache::DIFFUSION_COEFFS, GRINS::AssemblyContext::get_cached_values(), GRINS::Cache::MASS_FRACTIONS, GRINS::Cache::MASS_FRACTIONS_GRAD, GRINS::Cache::MIXTURE_DENSITY, GRINS::Cache::MIXTURE_GAS_CONSTANT, GRINS::Cache::MIXTURE_SPECIFIC_HEAT_P, GRINS::Cache::MIXTURE_THERMAL_CONDUCTIVITY, GRINS::Cache::MIXTURE_VISCOSITY, GRINS::Cache::MOLAR_MASS, GRINS::Cache::OMEGA_DOT, GRINS::Cache::PRESSURE, GRINS::CachedValues::set_gradient_values(), GRINS::CachedValues::set_values(), GRINS::CachedValues::set_vector_gradient_values(), GRINS::CachedValues::set_vector_values(), GRINS::Cache::SPECIES_ENTHALPY, GRINS::Cache::TEMPERATURE, GRINS::Cache::TEMPERATURE_GRAD, GRINS::Cache::THERMO_PRESSURE, GRINS::Cache::X_VELOCITY, GRINS::Cache::X_VELOCITY_GRAD, GRINS::Cache::Y_VELOCITY, GRINS::Cache::Y_VELOCITY_GRAD, GRINS::Cache::Z_VELOCITY, and GRINS::Cache::Z_VELOCITY_GRAD.

   {
     CachedValues & cache = context.get_cached_values();
 
     Evaluator gas_evaluator( *(this->_gas_mixture) );
 
     const unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     std::vector<libMesh::Real> u, v, w, T, p, p0;
     u.resize(n_qpoints);
     v.resize(n_qpoints);
     if( this->_flow_vars.dim() > 2 )
       w.resize(n_qpoints);
 
     T.resize(n_qpoints);
     p.resize(n_qpoints);
     p0.resize(n_qpoints);
 
     std::vector<libMesh::Gradient> grad_u, grad_v, grad_w, grad_T;
     grad_u.resize(n_qpoints);
     grad_v.resize(n_qpoints);
     if( this->_flow_vars.dim() > 2 )
       grad_w.resize(n_qpoints);
 
     grad_T.resize(n_qpoints);
 
     std::vector<std::vector<libMesh::Real> > mass_fractions;
     std::vector<std::vector<libMesh::Gradient> > grad_mass_fractions;
     mass_fractions.resize(n_qpoints);
     grad_mass_fractions.resize(n_qpoints);
 
     std::vector<libMesh::Real> M;
     M.resize(n_qpoints);
 
     std::vector<libMesh::Real> R;
     R.resize(n_qpoints);
 
     std::vector<libMesh::Real> rho;
     rho.resize(n_qpoints);
 
     std::vector<libMesh::Real> cp;
     cp.resize(n_qpoints);
 
     std::vector<libMesh::Real> mu;
     mu.resize(n_qpoints);
 
     std::vector<libMesh::Real> k;
     k.resize(n_qpoints);
 
     std::vector<std::vector<libMesh::Real> > h_s;
     h_s.resize(n_qpoints);
 
     std::vector<std::vector<libMesh::Real> > D_s;
     D_s.resize(n_qpoints);
 
     std::vector<std::vector<libMesh::Real> > omega_dot_s;
     omega_dot_s.resize(n_qpoints);
 
     for (unsigned int qp = 0; qp != n_qpoints; ++qp)
       {
         u[qp] = context.interior_value(this->_flow_vars.u(), qp);
         v[qp] = context.interior_value(this->_flow_vars.v(), qp);
 
         grad_u[qp] = context.interior_gradient(this->_flow_vars.u(), qp);
         grad_v[qp] = context.interior_gradient(this->_flow_vars.v(), qp);
         if( this->_flow_vars.dim() > 2 )
           {
             w[qp] = context.interior_value(this->_flow_vars.w(), qp);
             grad_w[qp] = context.interior_gradient(this->_flow_vars.w(), qp);
           }
 
         T[qp] = context.interior_value(this->_temp_vars.T(), qp);
         grad_T[qp] = context.interior_gradient(this->_temp_vars.T(), qp);
 
         p[qp] = context.interior_value(this->_press_var.p(), qp);
         p0[qp] = this->get_p0_steady(context, qp);
 
         mass_fractions[qp].resize(this->_n_species);
         grad_mass_fractions[qp].resize(this->_n_species);
         h_s[qp].resize(this->_n_species);
 
         for( unsigned int s = 0; s < this->_n_species; s++ )
           {
             mass_fractions[qp][s] = std::max( context.interior_value(this->_species_vars.species(s),qp), 0.0 );
             grad_mass_fractions[qp][s] = context.interior_gradient(this->_species_vars.species(s),qp);
             h_s[qp][s] = gas_evaluator.h_s( T[qp], s );
           }
 
         M[qp] = gas_evaluator.M_mix( mass_fractions[qp] );
 
         R[qp] = gas_evaluator.R_mix( mass_fractions[qp] );
 
         rho[qp] = this->rho( T[qp], p0[qp], R[qp] );
 
         cp[qp] = gas_evaluator.cp(T[qp], p0[qp], mass_fractions[qp]);
 
         D_s[qp].resize(this->_n_species);
 
         gas_evaluator.mu_and_k_and_D( T[qp], rho[qp], cp[qp], mass_fractions[qp],
                                       mu[qp], k[qp], D_s[qp] );
 
         omega_dot_s[qp].resize(this->_n_species);
         gas_evaluator.omega_dot( T[qp], rho[qp], mass_fractions[qp], omega_dot_s[qp] );
       }
 
     cache.set_values(Cache::X_VELOCITY, u);
     cache.set_values(Cache::Y_VELOCITY, v);
     cache.set_gradient_values(Cache::X_VELOCITY_GRAD, grad_u);
     cache.set_gradient_values(Cache::Y_VELOCITY_GRAD, grad_v);
 
     if(this->_flow_vars.dim() > 2)
       {
         cache.set_values(Cache::Z_VELOCITY, w);
         cache.set_gradient_values(Cache::Z_VELOCITY_GRAD, grad_w);
       }
 
     cache.set_values(Cache::TEMPERATURE, T);
     cache.set_gradient_values(Cache::TEMPERATURE_GRAD, grad_T);
     cache.set_values(Cache::PRESSURE, p);
     cache.set_values(Cache::THERMO_PRESSURE, p0);
     cache.set_vector_values(Cache::MASS_FRACTIONS, mass_fractions);
     cache.set_vector_gradient_values(Cache::MASS_FRACTIONS_GRAD, grad_mass_fractions);
     cache.set_values(Cache::MOLAR_MASS, M);
     cache.set_values(Cache::MIXTURE_GAS_CONSTANT, R);
     cache.set_values(Cache::MIXTURE_DENSITY, rho);
     cache.set_values(Cache::MIXTURE_SPECIFIC_HEAT_P, cp);
     cache.set_values(Cache::MIXTURE_VISCOSITY, mu);
     cache.set_values(Cache::MIXTURE_THERMAL_CONDUCTIVITY, k);
     cache.set_vector_values(Cache::DIFFUSION_COEFFS, D_s);
     cache.set_vector_values(Cache::SPECIES_ENTHALPY, h_s);
     cache.set_vector_values(Cache::OMEGA_DOT, omega_dot_s);
   }

template<typename Mixture , typename Evaluator >

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

virtual

Reimplemented from GRINS::Physics.

Definition at line 682 of file reacting_low_mach_navier_stokes.C.

   {
     Evaluator gas_evaluator( *(this->_gas_mixture) );
 
     if( quantity_index == this->_rho_index )
       {
         std::vector<libMesh::Real> Y( this->_n_species );
         libMesh::Real T = this->T(point,context);
         libMesh::Real p0 = this->get_p0_steady(context,point);
         this->mass_fractions( point, context, Y );
 
         value = this->rho( T, p0, gas_evaluator.R_mix(Y) );
       }
     else if( quantity_index == this->_mu_index )
       {
         std::vector<libMesh::Real> Y( this->_n_species );
         libMesh::Real T = this->T(point,context);
         this->mass_fractions( point, context, Y );
         libMesh::Real p0 = this->get_p0_steady(context,point);
 
         value = gas_evaluator.mu( T, p0, Y );
       }
     else if( quantity_index == this->_k_index )
       {
         std::vector<libMesh::Real> Y( this->_n_species );
 
         libMesh::Real T = this->T(point,context);
         this->mass_fractions( point, context, Y );
         libMesh::Real p0 = this->get_p0_steady(context,point);
 
         libMesh::Real cp = gas_evaluator.cp( T, p0, Y );
 
         libMesh::Real rho = this->rho( T, p0, gas_evaluator.R_mix(Y) );
 
         libMesh::Real mu, k;
         std::vector<libMesh::Real> D( this->_n_species );
 
         gas_evaluator.mu_and_k_and_D( T, rho, cp, Y, mu, k, D );
 
         value = k;
         return;
       }
     else if( quantity_index == this->_cp_index )
       {
         std::vector<libMesh::Real> Y( this->_n_species );
         libMesh::Real T = this->T(point,context);
         this->mass_fractions( point, context, Y );
         libMesh::Real p0 = this->get_p0_steady(context,point);
 
         value = gas_evaluator.cp( T, p0, Y );
       }
     // Now check for species dependent stuff
     else
       {
         if( !this->_h_s_index.empty() )
           {
             libmesh_assert_equal_to( _h_s_index.size(), this->n_species() );
 
             for( unsigned int s = 0; s < this->n_species(); s++ )
               {
                 if( quantity_index == this->_h_s_index[s] )
                   {
                     libMesh::Real T = this->T(point,context);
 
                     value = gas_evaluator.h_s( T, s );
                     return;
                   }
               }
           }
 
         if( !this->_mole_fractions_index.empty() )
           {
             libmesh_assert_equal_to( _mole_fractions_index.size(), this->n_species() );
 
             for( unsigned int s = 0; s < this->n_species(); s++ )
               {
                 if( quantity_index == this->_mole_fractions_index[s] )
                   {
                     std::vector<libMesh::Real> Y( this->_n_species );
                     this->mass_fractions( point, context, Y );
 
                     libMesh::Real M = gas_evaluator.M_mix(Y);
 
                     value = gas_evaluator.X( s, M, Y[s] );
                     return;
                   }
               }
           }
 
         if( !this->_omega_dot_index.empty() )
           {
             libmesh_assert_equal_to( _omega_dot_index.size(), this->n_species() );
 
             for( unsigned int s = 0; s < this->n_species(); s++ )
               {
                 if( quantity_index == this->_omega_dot_index[s] )
                   {
                     std::vector<libMesh::Real> Y( this->n_species() );
                     this->mass_fractions( point, context, Y );
 
                     libMesh::Real T = this->T(point,context);
 
                     libMesh::Real p0 = this->get_p0_steady(context,point);
 
                     libMesh::Real rho = this->rho( T, p0, gas_evaluator.R_mix(Y) );
 
                     std::vector<libMesh::Real> omega_dot( this->n_species() );
                     gas_evaluator.omega_dot( T, rho, Y, omega_dot );
 
                     value = omega_dot[s];
                     return;
                   }
               }
           }
 
         if( !this->_Ds_index.empty() )
           {
             libmesh_assert_equal_to( _Ds_index.size(), this->n_species() );
 
             for( unsigned int s = 0; s < this->n_species(); s++ )
               {
                 if( quantity_index == this->_Ds_index[s] )
                   {
                     std::vector<libMesh::Real> Y( this->_n_species );
 
                     libMesh::Real T = this->T(point,context);
                     this->mass_fractions( point, context, Y );
                     libMesh::Real p0 = this->get_p0_steady(context,point);
 
                     libMesh::Real cp = gas_evaluator.cp( T, p0, Y );
 
                     libMesh::Real rho = this->rho( T, p0, gas_evaluator.R_mix(Y) );
 
                     libMesh::Real mu, k;
                     std::vector<libMesh::Real> D( this->_n_species );
 
                     gas_evaluator.mu_and_k_and_D( T, rho, cp, Y, mu, k, D );
 
                     value = D[s];
                     return;
                   }
               }
           }
 
       } // if/else quantity_index
 
     return;
   }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::element_constraint	(	bool	,
		AssemblyContext &
	)

virtual

Constraint part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 404 of file reacting_low_mach_navier_stokes.C.

   {
     // Pin p = p_value at p_point
     if( this->_pin_pressure )
       {
         _p_pinning.pin_value( context, compute_jacobian, this->_press_var.p() );
       }
 
     return;
   }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::element_time_derivative	(	bool	,
		AssemblyContext &
	)

virtual

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

Todo:: Need to add SCEBD term.

Todo:: Would it be better to put this in its own DoF loop and do the if check once?

Reimplemented from GRINS::Physics.

Definition at line 164 of file reacting_low_mach_navier_stokes.C.

References GRINS::Cache::DIFFUSION_COEFFS, GRINS::CachedValues::get_cached_gradient_values(), GRINS::AssemblyContext::get_cached_values(), GRINS::CachedValues::get_cached_values(), GRINS::CachedValues::get_cached_vector_gradient_values(), GRINS::CachedValues::get_cached_vector_values(), GRINS::Physics::is_axisymmetric(), GRINS::Cache::MASS_FRACTIONS_GRAD, GRINS::Cache::MIXTURE_DENSITY, GRINS::Cache::MIXTURE_SPECIFIC_HEAT_P, GRINS::Cache::MIXTURE_THERMAL_CONDUCTIVITY, GRINS::Cache::MIXTURE_VISCOSITY, GRINS::Cache::MOLAR_MASS, GRINS::Cache::OMEGA_DOT, GRINS::Cache::PRESSURE, GRINS::Cache::SPECIES_ENTHALPY, GRINS::Cache::TEMPERATURE, GRINS::Cache::TEMPERATURE_GRAD, GRINS::Cache::X_VELOCITY, GRINS::Cache::X_VELOCITY_GRAD, GRINS::Cache::Y_VELOCITY, GRINS::Cache::Y_VELOCITY_GRAD, GRINS::Cache::Z_VELOCITY, and GRINS::Cache::Z_VELOCITY_GRAD.

   {
     if( compute_jacobian )
       libmesh_not_implemented();
 
     const CachedValues & cache = context.get_cached_values();
 
     // Convenience
     const VariableIndex s0_var = this->_species_vars.species(0);
 
     // The number of local degrees of freedom in each variable.
     const unsigned int n_p_dofs = context.get_dof_indices(this->_press_var.p()).size();
     const unsigned int n_s_dofs = context.get_dof_indices(s0_var).size();
     const unsigned int n_u_dofs = context.get_dof_indices(this->_flow_vars.u()).size();
     const unsigned int n_T_dofs = context.get_dof_indices(this->_temp_vars.T()).size();
 
     // Check number of dofs is same for _flow_vars.u(), v_var and w_var.
     if (this->_flow_vars.dim() > 1)
       libmesh_assert (n_u_dofs == context.get_dof_indices(this->_flow_vars.v()).size());
 
     if (this->_flow_vars.dim() == 3)
       libmesh_assert (n_u_dofs == context.get_dof_indices(this->_flow_vars.w()).size());
 
     // Element Jacobian * quadrature weights for interior integration.
     const std::vector<libMesh::Real>& JxW =
       context.get_element_fe(this->_flow_vars.u())->get_JxW();
 
     // The pressure shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::Real> >& p_phi =
       context.get_element_fe(this->_press_var.p())->get_phi();
 
     // The species shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::Real> >& s_phi = context.get_element_fe(s0_var)->get_phi();
 
     // The species shape function gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::Gradient> >& s_grad_phi = context.get_element_fe(s0_var)->get_dphi();
 
     // The pressure shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::Real> >& u_phi =
       context.get_element_fe(this->_flow_vars.u())->get_phi();
 
     // The velocity shape function gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& u_gradphi =
       context.get_element_fe(this->_flow_vars.u())->get_dphi();
 
     // The temperature shape functions at interior quadrature points.
     const std::vector<std::vector<libMesh::Real> >& T_phi =
       context.get_element_fe(this->_temp_vars.T())->get_phi();
 
     // The temperature shape functions gradients at interior quadrature points.
     const std::vector<std::vector<libMesh::RealGradient> >& T_gradphi =
       context.get_element_fe(this->_temp_vars.T())->get_dphi();
 
     const std::vector<libMesh::Point>& u_qpoint =
       context.get_element_fe(this->_flow_vars.u())->get_xyz();
 
     libMesh::DenseSubVector<libMesh::Number>& Fp = context.get_elem_residual(this->_press_var.p()); // R_{p}
 
     libMesh::DenseSubVector<libMesh::Number> &Fu = context.get_elem_residual(this->_flow_vars.u()); // R_{u}
 
     libMesh::DenseSubVector<libMesh::Number>* Fv = NULL;
     if( this->_flow_vars.dim() > 1 )
       Fv = &context.get_elem_residual(this->_flow_vars.v()); // R_{v}
 
     libMesh::DenseSubVector<libMesh::Number>* Fw = NULL;
     if( this->_flow_vars.dim() == 3 )
       Fw = &context.get_elem_residual(this->_flow_vars.w()); // R_{w}
 
     libMesh::DenseSubVector<libMesh::Number> &FT = context.get_elem_residual(this->_temp_vars.T()); // R_{T}
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
     for (unsigned int qp=0; qp != n_qpoints; qp++)
       {
         libMesh::Number rho = cache.get_cached_values(Cache::MIXTURE_DENSITY)[qp];
 
         libMesh::Number u, T;
         u = cache.get_cached_values(Cache::X_VELOCITY)[qp];
 
         T = cache.get_cached_values(Cache::TEMPERATURE)[qp];
 
         const libMesh::Gradient& grad_T =
           cache.get_cached_gradient_values(Cache::TEMPERATURE_GRAD)[qp];
 
         libMesh::NumberVectorValue U(u);
         if (this->_flow_vars.dim() > 1)
           U(1) = cache.get_cached_values(Cache::Y_VELOCITY)[qp];
         if (this->_flow_vars.dim() == 3)
           U(2) = cache.get_cached_values(Cache::Z_VELOCITY)[qp]; // w
 
         libMesh::Gradient grad_u = cache.get_cached_gradient_values(Cache::X_VELOCITY_GRAD)[qp];
         libMesh::Gradient grad_v;
 
         if (this->_flow_vars.dim() > 1)
           grad_v = cache.get_cached_gradient_values(Cache::Y_VELOCITY_GRAD)[qp];
 
         libMesh::Gradient grad_w;
         if (this->_flow_vars.dim() == 3)
           grad_w = cache.get_cached_gradient_values(Cache::Z_VELOCITY_GRAD)[qp];
 
         libMesh::Number divU = grad_u(0);
         if (this->_flow_vars.dim() > 1)
           divU += grad_v(1);
         if (this->_flow_vars.dim() == 3)
           divU += grad_w(2);
 
         libMesh::NumberVectorValue grad_uT( grad_u(0) );
         libMesh::NumberVectorValue grad_vT;
         if( this->_flow_vars.dim() > 1 )
           {
             grad_uT(1) = grad_v(0);
             grad_vT = libMesh::NumberVectorValue( grad_u(1), grad_v(1) );
           }
         libMesh::NumberVectorValue grad_wT;
         if( this->_flow_vars.dim() == 3 )
           {
             grad_uT(2) = grad_w(0);
             grad_vT(2) = grad_w(1);
             grad_wT = libMesh::NumberVectorValue( grad_u(2), grad_v(2), grad_w(2) );
           }
 
         libMesh::Number mu = cache.get_cached_values(Cache::MIXTURE_VISCOSITY)[qp];
         libMesh::Number p = cache.get_cached_values(Cache::PRESSURE)[qp];
 
         const std::vector<libMesh::Real>& D =
           cache.get_cached_vector_values(Cache::DIFFUSION_COEFFS)[qp];
 
         libMesh::Number cp =
           cache.get_cached_values(Cache::MIXTURE_SPECIFIC_HEAT_P)[qp];
 
         libMesh::Number k =
           cache.get_cached_values(Cache::MIXTURE_THERMAL_CONDUCTIVITY)[qp];
 
         const std::vector<libMesh::Real>& omega_dot =
           cache.get_cached_vector_values(Cache::OMEGA_DOT)[qp];
 
         const std::vector<libMesh::Real>& h =
           cache.get_cached_vector_values(Cache::SPECIES_ENTHALPY)[qp];
 
         const libMesh::Number r = u_qpoint[qp](0);
 
         libMesh::Real jac = JxW[qp];
 
         if(Physics::is_axisymmetric())
           {
             divU += U(0)/r;
             jac *= r;
           }
 
         libMesh::Real M = cache.get_cached_values(Cache::MOLAR_MASS)[qp];
 
         std::vector<libMesh::Gradient> grad_ws = cache.get_cached_vector_gradient_values(Cache::MASS_FRACTIONS_GRAD)[qp];
         libmesh_assert_equal_to( grad_ws.size(), this->_n_species );
 
         // Continuity Residual
         libMesh::Gradient mass_term(0.0,0.0,0.0);
         for(unsigned int s=0; s < this->_n_species; s++ )
           {
             mass_term += grad_ws[s]/this->_gas_mixture->M(s);
           }
         mass_term *= M;
 
         for (unsigned int i=0; i != n_p_dofs; i++)
           {
             Fp(i) += (-U*(mass_term + grad_T/T) + divU)*jac*p_phi[i][qp];
           }
 
         // Species residuals
         for(unsigned int s=0; s < this->_n_species; s++ )
           {
             libMesh::DenseSubVector<libMesh::Number> &Fs =
               context.get_elem_residual(this->_species_vars.species(s)); // R_{s}
 
             const libMesh::Real term1 = -rho*(U*grad_ws[s]) + omega_dot[s];
             const libMesh::Gradient term2 = -rho*D[s]*grad_ws[s];
 
             for (unsigned int i=0; i != n_s_dofs; i++)
               {
                 Fs(i) += ( term1*s_phi[i][qp] + term2*s_grad_phi[i][qp] )*jac;
               }
           }
 
         // Momentum residuals
         for (unsigned int i=0; i != n_u_dofs; i++)
           {
             Fu(i) += ( -rho*U*grad_u*u_phi[i][qp]
                        + p*u_gradphi[i][qp](0)
                        - mu*(u_gradphi[i][qp]*grad_u + u_gradphi[i][qp]*grad_uT
                              - 2.0/3.0*divU*u_gradphi[i][qp](0) )
                        + rho*this->_g(0)*u_phi[i][qp]
                        )*jac;
 
             if(Physics::is_axisymmetric())
               {
                 Fu(i) += u_phi[i][qp]*( p/r - 2*mu*U(0)/(r*r) - 2.0/3.0*mu*divU/r )*jac;
               }
 
             if (this->_flow_vars.dim() > 1)
               {
                 (*Fv)(i) += ( -rho*U*grad_v*u_phi[i][qp]
                               + p*u_gradphi[i][qp](1)
                               - mu*(u_gradphi[i][qp]*grad_v + u_gradphi[i][qp]*grad_vT
                                     - 2.0/3.0*divU*u_gradphi[i][qp](1) )
                               + rho*this->_g(1)*u_phi[i][qp]
                               )*jac;
               }
 
             if (this->_flow_vars.dim() == 3)
               {
                 (*Fw)(i) += ( -rho*U*grad_w*u_phi[i][qp]
                               + p*u_gradphi[i][qp](2)
                               - mu*(u_gradphi[i][qp]*grad_w + u_gradphi[i][qp]*grad_wT
                                     - 2.0/3.0*divU*u_gradphi[i][qp](2) )
                               + rho*this->_g(2)*u_phi[i][qp]
                               )*jac;
               }
           }
 
         // Energy residual
         libMesh::Real chem_term = 0.0;
         for(unsigned int s=0; s < this->_n_species; s++ )
           {
             chem_term += h[s]*omega_dot[s];
           }
 
         for (unsigned int i=0; i != n_T_dofs; i++)
           {
             FT(i) += ( ( -rho*cp*U*grad_T - chem_term )*T_phi[i][qp]
                        - k*grad_T*T_gradphi[i][qp]  )*jac;
           }
 
       } // quadrature loop
 
     return;
   }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::init_context ( AssemblyContext & context )

virtual

Initialize context for added physics variables.

Reimplemented from GRINS::ReactingLowMachNavierStokesAbstract.

Definition at line 145 of file reacting_low_mach_navier_stokes.C.

References GRINS::ReactingLowMachNavierStokesAbstract::init_context().

   {
     // First call base class
     ReactingLowMachNavierStokesAbstract::init_context(context);
 
     // We also need the side shape functions, etc.
     context.get_side_fe(this->_flow_vars.u())->get_JxW();
     context.get_side_fe(this->_flow_vars.u())->get_phi();
     context.get_side_fe(this->_flow_vars.u())->get_dphi();
     context.get_side_fe(this->_flow_vars.u())->get_xyz();
 
     context.get_side_fe(this->_temp_vars.T())->get_JxW();
     context.get_side_fe(this->_temp_vars.T())->get_phi();
     context.get_side_fe(this->_temp_vars.T())->get_dphi();
     context.get_side_fe(this->_temp_vars.T())->get_xyz();
   }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::mass_residual	(	bool	,
		AssemblyContext &
	)

virtual

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

Reimplemented from GRINS::Physics.

Definition at line 418 of file reacting_low_mach_navier_stokes.C.

   {
     const unsigned int n_p_dofs = context.get_dof_indices(this->_press_var.p()).size();
     const unsigned int n_u_dofs = context.get_dof_indices(this->_flow_vars.u()).size();
     const unsigned int n_T_dofs = context.get_dof_indices(this->_temp_vars.T()).size();
     const VariableIndex s0_var = this->_species_vars.species(0);
     const unsigned int n_s_dofs = context.get_dof_indices(s0_var).size();
 
     const std::vector<libMesh::Real> &JxW =
       context.get_element_fe(this->_flow_vars.u())->get_JxW();
 
     const std::vector<std::vector<libMesh::Real> >& p_phi =
       context.get_element_fe(this->_press_var.p())->get_phi();
 
     const std::vector<std::vector<libMesh::Real> >& u_phi =
       context.get_element_fe(this->_flow_vars.u())->get_phi();
 
     const std::vector<std::vector<libMesh::Real> >& T_phi =
       context.get_element_fe(this->_temp_vars.T())->get_phi();
 
     const std::vector<std::vector<libMesh::Real> >& s_phi =
       context.get_element_fe(s0_var)->get_phi();
 
 
     // The subvectors and submatrices we need to fill:
     libMesh::DenseSubVector<libMesh::Real> &F_p = context.get_elem_residual(this->_press_var.p());
 
     // The subvectors and submatrices we need to fill:
     libMesh::DenseSubVector<libMesh::Real> &F_u = context.get_elem_residual(this->_flow_vars.u());
 
     libMesh::DenseSubVector<libMesh::Real>* F_v = NULL;
     if( this->_flow_vars.dim() > 1 )
       F_v  = &context.get_elem_residual(this->_flow_vars.v());
 
     libMesh::DenseSubVector<libMesh::Real>* F_w = NULL;
     if( this->_flow_vars.dim() == 3 )
       F_w  = &context.get_elem_residual(this->_flow_vars.w()); // R_{w}
 
     libMesh::DenseSubVector<libMesh::Real> &F_T = context.get_elem_residual(this->_temp_vars.T());
 
     unsigned int n_qpoints = context.get_element_qrule().n_points();
 
     const std::vector<libMesh::Point>& u_qpoint =
       context.get_element_fe(this->_flow_vars.u())->get_xyz();
 
     for (unsigned int qp = 0; qp != n_qpoints; ++qp)
       {
         libMesh::Real u_dot, v_dot = 0.0, w_dot = 0.0;
         context.interior_rate(this->_flow_vars.u(), qp, u_dot);
 
         if( this->_flow_vars.dim() > 1 )
           context.interior_rate(this->_flow_vars.v(), qp, v_dot);
 
         if( this->_flow_vars.dim() == 3 )
           context.interior_rate(this->_flow_vars.w(), qp, w_dot);
 
         libMesh::Real T_dot;
         context.interior_rate(this->_temp_vars.T(), qp, T_dot);
 
         libMesh::Real T = context.interior_value(this->_temp_vars.T(), qp);
 
         std::vector<libMesh::Real> ws(this->n_species());
         for(unsigned int s=0; s < this->_n_species; s++ )
           ws[s] = context.interior_value(this->_species_vars.species(s), qp);
 
         Evaluator gas_evaluator( *(this->_gas_mixture) );
         const libMesh::Real R_mix = gas_evaluator.R_mix(ws);
         const libMesh::Real p0 = this->get_p0_steady(context,qp);
         const libMesh::Real rho = this->rho(T, p0, R_mix);
         const libMesh::Real cp = gas_evaluator.cp(T,p0,ws);
         const libMesh::Real M = gas_evaluator.M_mix( ws );
 
         libMesh::Real jac = JxW[qp];
         const libMesh::Number r = u_qpoint[qp](0);
 
         if( this->_is_axisymmetric )
           jac *= r;
 
         // M_dot = -M^2 \sum_s w_dot[s]/Ms
         libMesh::Real M_dot = 0.0;
 
         // Species residual
         for(unsigned int s=0; s < this->n_species(); s++)
           {
             libMesh::DenseSubVector<libMesh::Number> &F_s =
               context.get_elem_residual(this->_species_vars.species(s));
 
             libMesh::Real ws_dot;
             context.interior_rate(this->_species_vars.species(s), qp, ws_dot);
 
             for (unsigned int i = 0; i != n_s_dofs; ++i)
               F_s(i) -= rho*ws_dot*s_phi[i][qp]*jac;
 
             // Start accumulating M_dot
             M_dot += ws_dot/this->_gas_mixture->M(s);
           }
 
         // Continuity residual
         // M_dot = -M^2 \sum_s w_dot[s]/Ms
         libMesh::Real M_dot_over_M = M_dot*(-M);
 
         for (unsigned int i = 0; i != n_p_dofs; ++i)
           F_p(i) -= (T_dot/T-M_dot_over_M)*p_phi[i][qp]*jac;
 
         // Momentum residual
         for (unsigned int i = 0; i != n_u_dofs; ++i)
           {
             F_u(i) -= rho*u_dot*u_phi[i][qp]*jac;
 
             if( this->_flow_vars.dim() > 1 )
               (*F_v)(i) -= rho*v_dot*u_phi[i][qp]*jac;
 
             if( this->_flow_vars.dim() == 3 )
               (*F_w)(i) -= rho*w_dot*u_phi[i][qp]*jac;
           }
 
         // Energy residual
         for (unsigned int i = 0; i != n_T_dofs; ++i)
           F_T(i) -= rho*cp*T_dot*T_phi[i][qp]*jac;
 
         if( compute_jacobian )
           libmesh_not_implemented();
 
       }
   }

template<typename Mixture , typename Evaluator >

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

virtual

Register postprocessing variables for ReactingLowMachNavierStokes.

Reimplemented from GRINS::Physics.

Definition at line 65 of file reacting_low_mach_navier_stokes.C.

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

   {
     std::string section = "Physics/"+PhysicsNaming::reacting_low_mach_navier_stokes()+"/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("rho") )
               {
                 this->_rho_index = postprocessing.register_quantity( name );
               }
             else if( name == std::string("mu") )
               {
                 this->_mu_index = postprocessing.register_quantity( name );
               }
             else if( name == std::string("k") )
               {
                 this->_k_index = postprocessing.register_quantity( name );
               }
             else if( name == std::string("cp") )
               {
                 this->_cp_index = postprocessing.register_quantity( name );
               }
             else if( name == std::string("mole_fractions") )
               {
                 this->_mole_fractions_index.resize(this->n_species());
 
                 for( unsigned int s = 0; s < this->n_species(); s++ )
                   {
                     this->_mole_fractions_index[s] = postprocessing.register_quantity( "X_"+this->_gas_mixture->species_name(s) );
                   }
               }
             else if( name == std::string("h_s") )
               {
                 this->_h_s_index.resize(this->n_species());
 
                 for( unsigned int s = 0; s < this->n_species(); s++ )
                   {
                     this->_h_s_index[s] = postprocessing.register_quantity( "h_"+this->_gas_mixture->species_name(s) );
                   }
               }
             else if( name == std::string("omega_dot") )
               {
                 this->_omega_dot_index.resize(this->n_species());
 
                 for( unsigned int s = 0; s < this->n_species(); s++ )
                   this->_omega_dot_index[s] = postprocessing.register_quantity( "omega_dot_"+this->_gas_mixture->species_name(s) );
               }
             else if( name == std::string("D_s") )
               {
                 this->_Ds_index.resize(this->n_species());
 
                 for( unsigned int s = 0; s < this->n_species(); s++ )
                   this->_Ds_index[s] = postprocessing.register_quantity( "D_"+this->_gas_mixture->species_name(s) );
               }
             else
               {
                 std::cerr << "Error: Invalue output_vars value for "+PhysicsNaming::reacting_low_mach_navier_stokes() << std::endl
                           << "       Found " << name << std::endl
                           << "       Acceptable values are: rho" << std::endl
                           << "                              mu" << std::endl
                           << "                              k" << std::endl
                           << "                              cp" << std::endl
                           << "                              mole_fractions" << std::endl
                           << "                              omega_dot" << std::endl;
                 libmesh_error();
               }
           }
       }
 
     return;
   }

Member Data Documentation

template<typename Mixture , typename Evaluator >

unsigned int GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_cp_index

protected

Index from registering this quantity.

Definition at line 93 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

std::vector<unsigned int> GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_Ds_index

protected

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

Definition at line 105 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

std::vector<unsigned int> GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_h_s_index

protected

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

Definition at line 99 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

unsigned int GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_k_index

protected

Index from registering this quantity.

Definition at line 90 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

std::vector<unsigned int> GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_mole_fractions_index

protected

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

Definition at line 96 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

unsigned int GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_mu_index

protected

Index from registering this quantity.

Definition at line 87 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

std::vector<unsigned int> GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_omega_dot_index

protected

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

Definition at line 102 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

PressurePinning GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_p_pinning

protected

Definition at line 78 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

bool GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_pin_pressure

protected

Enable pressure pinning.

Definition at line 76 of file reacting_low_mach_navier_stokes.h.

Referenced by GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::ReactingLowMachNavierStokes().

template<typename Mixture , typename Evaluator >

unsigned int GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_rho_index

protected

Index from registering this quantity.

Definition at line 81 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

std::vector<unsigned int> GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::_species_viscosity

protected

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

Definition at line 84 of file reacting_low_mach_navier_stokes.h.

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

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

Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

template<typename Mixture, typename Evaluator> class GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename Mixture, typename Evaluator>
class GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >