#include <reacting_low_mach_navier_stokes.h>

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

[legend]

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

[legend]

Public Member Functions
	ReactingLowMachNavierStokes (const PhysicsName &physics_name, const GetPot &input)

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, CachedValues &cache)
	Time dependent part(s) of physics for element interiors. More...

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

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

virtual void	compute_element_time_derivative_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)

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

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

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 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	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	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	damping_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Damping matrix part(s) for element interiors. All boundary terms lie within the time_derivative part. More...

virtual void	nonlocal_mass_residual (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	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 (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_damping_residual_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)

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

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

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

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

VelocityFEVariables	_flow_vars

PressureFEVariable	_press_var

PrimitiveTempFEVariables	_temp_vars

libMesh::UniquePtr< ThermoPressureFEVariable >	_p0_var

SpeciesMassFractionsFEVariables	_species_vars

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)

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
	)

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),
     _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 41 of file reacting_low_mach_navier_stokes.h.

41 {};

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 56 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	(	const AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

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

Reimplemented from GRINS::Physics.

Definition at line 405 of file reacting_low_mach_navier_stokes.C.

References GRINS::Cache::DIFFUSION_COEFFS, 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.

   {
     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->_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->_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->_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->_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 540 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);
 
         value = gas_evaluator.k( T, p0, Y );
       }
     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/else quantity_index
 
     return;
   }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::element_constraint	(	bool	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

virtual

Constraint part(s) of physics for element interiors.

Reimplemented from GRINS::Physics.

Definition at line 381 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	compute_jacobian,
		AssemblyContext &	context,
		CachedValues &	cache
	)

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 158 of file reacting_low_mach_navier_stokes.C.

References GRINS::Cache::DIFFUSION_COEFFS, GRINS::CachedValues::get_cached_gradient_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();
       }
     // 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.
     libmesh_assert (n_u_dofs == context.get_dof_indices(this->_flow_vars.v()).size());
     if (this->_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 = context.get_elem_residual(this->_flow_vars.v()); // R_{v}
     libMesh::DenseSubVector<libMesh::Real>* Fw = NULL;
 
     if( this->_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, v, T;
         u = cache.get_cached_values(Cache::X_VELOCITY)[qp];
         v = cache.get_cached_values(Cache::Y_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,v);
         if (this->_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 = cache.get_cached_gradient_values(Cache::Y_VELOCITY_GRAD)[qp];
 
         libMesh::Gradient grad_w;
         if (this->_dim == 3)
           grad_w = cache.get_cached_gradient_values(Cache::Z_VELOCITY_GRAD)[qp];
 
         libMesh::Number divU = grad_u(0) + grad_v(1);
         if (this->_dim == 3)
           divU += grad_w(2);
 
         libMesh::NumberVectorValue grad_uT( grad_u(0), grad_v(0) );
         libMesh::NumberVectorValue grad_vT( grad_u(1), grad_v(1) );
         libMesh::NumberVectorValue grad_wT;
         if( this->_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;
               }
 
             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->_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 140 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	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 395 of file reacting_low_mach_navier_stokes.C.

   {
     libmesh_not_implemented();
 
     return;
   }

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 63 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) );
                   }
 
                 std::cout << "omega_dot size = " << _omega_dot_index.size() << std::endl;
               }
             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 96 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 102 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 93 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 99 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 90 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 105 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture , typename Evaluator >

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

protected

Definition at line 81 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 79 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 84 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 87 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 >