GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator > Class Template Reference

#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)
	~ReactingLowMachNavierStokes ()
virtual void	read_input_options (const GetPot &input)
	Read options from GetPot input file. 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	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	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	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_side_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)
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 (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 (const AssemblyContext &c, unsigned int qp) const
const Mixture &	gas_mixture () const
virtual bool	enabled_on_elem (const libMesh::Elem *elem)
	Find if current physics is active on supplied element. More...
void	set_is_steady (bool is_steady)
	Sets whether this physics is to be solved with a steady solver or not. More...
bool	is_steady () const
	Returns whether or not this physics is being solved with a steady solver. More...
virtual void	auxiliary_init (MultiphysicsSystem &system)
	Any auxillary initialization a Physics class may need. More...
virtual void	nonlocal_time_derivative (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Time dependent part(s) of physics for scalar variables. More...
virtual void	element_constraint (bool compute_jacobian, AssemblyContext &context, CachedValues &cache)
	Constraint part(s) of physics for element interiors. More...
virtual void	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_nonlocal_time_derivative_cache (const AssemblyContext &context, CachedValues &cache)
virtual void	compute_element_constraint_cache (const AssemblyContext &context, CachedValues &cache)
virtual void	compute_side_constraint_cache (const AssemblyContext &context, CachedValues &cache)
virtual void	compute_nonlocal_constraint_cache (const AssemblyContext &context, CachedValues &cache)
virtual void	compute_mass_residual_cache (const AssemblyContext &context, CachedValues &cache)
virtual void	compute_nonlocal_mass_residual_cache (const AssemblyContext &context, CachedValues &cache)
BCHandlingBase *	get_bc_handler ()
ICHandlingBase *	get_ic_handler ()
virtual void	set_parameter (libMesh::Number &param_variable, const GetPot &input, const std::string &param_name, libMesh::Number param_default)
	Each subclass can simultaneously read a parameter value from. More...
virtual void	register_parameter (const std::string &param_name, libMesh::ParameterMultiPointer< libMesh::Number > &param_pointer) const
	Each subclass will register its copy of an independent. More...

Protected 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...
Mixture	_gas_mixture
libMesh::Number	_p0
unsigned int	_dim
	Physical dimension of problem. More...
unsigned int	_n_species
	Number of species. More...
std::vector< VariableIndex >	_species_vars
	Indices for each (owned) variable;. More...
VariableIndex	_u_var
VariableIndex	_v_var
VariableIndex	_w_var
VariableIndex	_p_var
VariableIndex	_T_var
VariableIndex	_p0_var
std::vector< std::string >	_species_var_names
	Names of each (owned) variable in the system. More...
std::string	_u_var_name
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	_species_FE_family
	Element type, read from input. More...
GRINSEnums::FEFamily	_V_FE_family
GRINSEnums::FEFamily	_P_FE_family
GRINSEnums::FEFamily	_T_FE_family
GRINSEnums::Order	_species_order
	Element orders, read from input. More...
GRINSEnums::Order	_V_order
GRINSEnums::Order	_P_order
GRINSEnums::Order	_T_order
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
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
	ReactingLowMachNavierStokes ()

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

References GRINS::Physics::_bc_handler, GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_gas_mixture, GRINS::Physics::_ic_handler, GRINS::Physics::_is_axisymmetric, GRINS::BCHandlingBase::is_axisymmetric(), and GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::read_input_options().

    : ReactingLowMachNavierStokesBase<Mixture,Evaluator>(physics_name,input),
    _p_pinning(input,physics_name),
    _rho_index(0),
    _mu_index(0),
    _k_index(0),
    _cp_index(0)
  {
    this->read_input_options(input);

    // This is deleted in the base class
    this->_bc_handler = new ReactingLowMachNavierStokesBCHandling<typename Mixture::ChemistryParent>( physics_name, input,
                                                                                                      this->_gas_mixture.chemistry() );

    if( this->_bc_handler->is_axisymmetric() )
      {
        this->_is_axisymmetric = true;
      }

    this->_ic_handler = new GenericICHandler( physics_name, input );

    return;
  }

template<typename Mixture , typename Evaluator >

GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::~ReactingLowMachNavierStokes

(

)

Definition at line 68 of file reacting_low_mach_navier_stokes.C.

  {
    return;
  }

template<typename Mixture, typename Evaluator>

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

private

Member Function Documentation

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

inherited

Definition at line 150 of file physics.C.

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

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

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

inherited

Definition at line 144 of file physics.C.

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

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

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

virtualinherited

Any auxillary initialization a Physics class may need.

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

Definition at line 113 of file physics.C.

  {
    return;
  }

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

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 444 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);

    for (unsigned int qp = 0; qp != n_qpoints; ++qp)
      {
        u[qp] = context.interior_value(this->_u_var, qp);
        v[qp] = context.interior_value(this->_v_var, qp);

        grad_u[qp] = context.interior_gradient(this->_u_var, qp);
        grad_v[qp] = context.interior_gradient(this->_v_var, qp);
        if( this->_dim > 2 )
          {
            w[qp] = context.interior_value(this->_w_var, qp);
            grad_w[qp] = context.interior_gradient(this->_w_var, qp);
          }
        T[qp] = context.interior_value(this->_T_var, qp);
        grad_T[qp] = context.interior_gradient(this->_T_var, qp);

        p[qp] = context.interior_value(this->_p_var, qp);
        p0[qp] = this->get_p0_steady(context, qp);

        mass_fractions[qp].resize(this->_n_species);
        grad_mass_fractions[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[s],qp), 0.0 );
            grad_mass_fractions[qp][s] = context.interior_gradient(this->_species_vars[s],qp);
          }
        
        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] );
      }
    
    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);

    /* These quantities must be computed after T, mass_fractions, p0
       are set into the cache. */
    std::vector<libMesh::Real> mu;
    mu.resize(n_qpoints);

    std::vector<libMesh::Real> cp;
    cp.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)
      {
        gas_evaluator.mu_and_k(cache,qp,mu[qp],k[qp]);
        cp[qp] = gas_evaluator.cp(cache,qp);

        h_s[qp].resize(this->_n_species);
        gas_evaluator.h_s( cache, qp, h_s[qp] );

        D_s[qp].resize(this->_n_species);
        gas_evaluator.D( cache, qp, D_s[qp] );

        omega_dot_s[qp].resize(this->_n_species);
        gas_evaluator.omega_dot( cache, qp, omega_dot_s[qp] );
      }

    cache.set_values(Cache::MIXTURE_VISCOSITY, mu);
    cache.set_values(Cache::MIXTURE_SPECIFIC_HEAT_P, cp);
    cache.set_values(Cache::MIXTURE_THERMAL_CONDUCTIVITY, k);
    cache.set_vector_values(Cache::SPECIES_ENTHALPY, h_s);
    cache.set_vector_values(Cache::DIFFUSION_COEFFS, D_s);
    cache.set_vector_values(Cache::OMEGA_DOT, omega_dot_s);

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

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 633 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 );

        value = gas_evaluator.mu( T, 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 );

        value = gas_evaluator.k( T, 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 );

        value = gas_evaluator.cp( T, 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;
  }

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

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::compute_side_time_derivative_cache ( const AssemblyContext &  context, CachedValues &  cache  )

virtual

Todo:

Add mechanism for checking if this side is a catalytic wall so we don't compute these quantities unnecessarily.

Todo:

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

Reimplemented from GRINS::Physics.

Definition at line 592 of file reacting_low_mach_navier_stokes.C.

References GRINS::Cache::MASS_FRACTIONS, GRINS::Cache::MIXTURE_DENSITY, GRINS::CachedValues::set_values(), GRINS::CachedValues::set_vector_values(), and GRINS::Cache::TEMPERATURE.

  {
    Evaluator gas_evaluator( this->_gas_mixture );

    const unsigned int n_qpoints = context.get_side_qrule().n_points();

    // Need for Catalytic Wall
    std::vector<libMesh::Real> T, rho;
    T.resize(n_qpoints);
    rho.resize(n_qpoints);

    std::vector<std::vector<libMesh::Real> > mass_fractions;
    mass_fractions.resize(n_qpoints);

    for (unsigned int qp = 0; qp != n_qpoints; ++qp)
      {
        T[qp] = context.side_value(this->_T_var, qp);

        mass_fractions[qp].resize(this->_n_species);
        for( unsigned int s = 0; s < this->_n_species; s++ )
          {
            mass_fractions[qp][s] = std::max( context.side_value(this->_species_vars[s],qp), 0.0 );
          }
        const libMesh::Real p0 = this->get_p0_steady_side(context, qp);

        rho[qp] = this->rho( T[qp], p0, gas_evaluator.R_mix(mass_fractions[qp]) );
      }

    cache.set_values(Cache::TEMPERATURE, T);
    cache.set_vector_values(Cache::MASS_FRACTIONS, mass_fractions);
    cache.set_values(Cache::MIXTURE_DENSITY, rho);

    return;
  }

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

virtualinherited

Constraint part(s) of physics for element interiors.

Reimplemented in GRINS::IncompressibleNavierStokes< Viscosity >, GRINS::AveragedTurbineAdjointStabilization< Viscosity >, GRINS::VelocityDragAdjointStabilization< Viscosity >, GRINS::AveragedFanAdjointStabilization< Viscosity >, GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >, GRINS::ElasticMembrane< StressStrainLaw >, GRINS::Stokes< Viscosity >, GRINS::BoussinesqBuoyancyAdjointStabilization< Viscosity >, GRINS::ParsedVelocitySourceAdjointStabilization< Viscosity >, GRINS::VelocityPenaltyAdjointStabilization< Viscosity >, GRINS::IncompressibleNavierStokesAdjointStabilization< Viscosity >, and GRINS::IncompressibleNavierStokesSPGSMStabilization< Viscosity >.

Definition at line 236 of file physics.C.

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

  {
    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 182 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::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[0];

    // The number of local degrees of freedom in each variable.
    const unsigned int n_p_dofs = context.get_dof_indices(this->_p_var).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->_u_var).size();
    const unsigned int n_T_dofs = context.get_dof_indices(this->_T_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 pressure shape functions at interior quadrature points.
    const std::vector<std::vector<libMesh::Real> >& p_phi =
      context.get_element_fe(this->_p_var)->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->_u_var)->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->_u_var)->get_dphi();

    // The temperature shape functions at interior quadrature points.
    const std::vector<std::vector<libMesh::Real> >& T_phi =
      context.get_element_fe(this->_T_var)->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->_T_var)->get_dphi();

    const std::vector<libMesh::Point>& u_qpoint =
      context.get_element_fe(this->_u_var)->get_xyz();

    libMesh::DenseSubVector<libMesh::Number>& Fp = context.get_elem_residual(this->_p_var); // R_{p}

    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}

    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 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( this->_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[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( this->_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;
  }

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

template<typename Mixture , typename Evaluator >

const Mixture & GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::gas_mixture ( ) const

inlineinherited

Definition at line 236 of file reacting_low_mach_navier_stokes_base.h.

  {
    return _gas_mixture;
  }

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<typename Mixture , typename Evaluator >

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::get_p0_steady ( const AssemblyContext &  c, unsigned int  qp  ) const

inlineinherited

Definition at line 168 of file reacting_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<typename Mixture , typename Evaluator >

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::get_p0_steady ( const AssemblyContext &  c, const libMesh::Point &  p  ) const

inlineinherited

Definition at line 202 of file reacting_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<typename Mixture , typename Evaluator >

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::get_p0_steady_side ( const AssemblyContext &  c, unsigned int  qp  ) const

inlineinherited

Definition at line 185 of file reacting_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<typename Mixture , typename Evaluator >

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::get_p0_transient ( const AssemblyContext &  c, unsigned int  qp  ) const

inlineinherited

Definition at line 219 of file reacting_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<typename Mixture , typename Evaluator >

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

virtual

Initialize context for added physics variables.

Reimplemented from GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >.

Definition at line 162 of file reacting_low_mach_navier_stokes.C.

References GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::init_context().

  {
    // First call base class
    ReactingLowMachNavierStokesBase<Mixture,Evaluator>::init_context(context);

    // We also need the side shape functions, etc.
    context.get_side_fe(this->_u_var)->get_JxW();
    context.get_side_fe(this->_u_var)->get_phi();
    context.get_side_fe(this->_u_var)->get_dphi();
    context.get_side_fe(this->_u_var)->get_xyz();

    context.get_side_fe(this->_T_var)->get_JxW();
    context.get_side_fe(this->_T_var)->get_phi();
    context.get_side_fe(this->_T_var)->get_dphi();
    context.get_side_fe(this->_T_var)->get_xyz();

    return;
  }

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

inherited

Definition at line 133 of file physics.C.

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

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

    return;
  }

template<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::init_variables ( libMesh::FEMSystem *  system )

virtualinherited

Initialize variables for this physics.

Implements GRINS::Physics.

Definition at line 130 of file reacting_low_mach_navier_stokes_base.C.

  {
    // Get libMesh to assign an index for each variable
    this->_dim = system->get_mesh().mesh_dimension();
    
    _species_vars.reserve(this->_n_species);
    for( unsigned int i = 0; i < this->_n_species; i++ )
      {
        _species_vars.push_back( system->add_variable( _species_var_names[i], 
                                                       this->_species_order, _species_FE_family) );
      }

    _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<typename Mixture , typename Evaluator >

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

inlineinherited

Definition at line 137 of file reacting_low_mach_navier_stokes_base.h.

  {
    libmesh_assert_equal_to(mass_fracs.size(), this->_n_species);

    for( unsigned int var = 0; var < this->_n_species; var++ )
      {
        mass_fracs[var] = c.point_value(_species_vars[var],p);
      }

    return;
  }

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

  {
    libmesh_not_implemented();

    return;
  }

template<typename Mixture , typename Evaluator >

unsigned int GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::n_species ( ) const

inlineinherited

Definition at line 125 of file reacting_low_mach_navier_stokes_base.h.

  { return _n_species; }

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<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokes< Mixture, Evaluator >::read_input_options ( const GetPot &  input )

virtual

Read options from GetPot input file.

Reimplemented from GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >.

Definition at line 74 of file reacting_low_mach_navier_stokes.C.

References GRINS::reacting_low_mach_navier_stokes.

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

  {
    // Other quantities read in base class

    // Read pressure pinning information
    this->_pin_pressure = input("Physics/"+reacting_low_mach_navier_stokes+"/pin_pressure", false );
  
    return;
  }

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

virtualinherited

Each subclass will register its copy of an independent.

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

Definition at line 50 of file parameter_user.C.

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

  {
    std::map<std::string, libMesh::Number*>::const_iterator it =
      _my_parameters.find(param_name);

    if (it != _my_parameters.end())
      {
        std::cout << _my_name << " uses parameter " << param_name
                  << std::endl;
        param_pointer.push_back(it->second);
      }
  }

template<typename 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 85 of file reacting_low_mach_navier_stokes.C.

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

  {
    std::string section = "Physics/"+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 "+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;
  }

template<typename Mixture , typename Evaluator >

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::rho ( libMesh::Real  T, libMesh::Real  p0, libMesh::Real  R_mix  ) const

inlineinherited

Definition at line 153 of file reacting_low_mach_navier_stokes_base.h.

  {
    libMesh::Real value = 0;
    if( this->_fixed_density )
      value = this->_fixed_rho_value;
    else
      value = p0/(R_mix*T);

    return value;
  }

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<typename Mixture , typename Evaluator >

void GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::set_time_evolving_vars ( libMesh::FEMSystem *  system )

virtualinherited

Sets velocity variables to be time-evolving.

Reimplemented from GRINS::Physics.

Definition at line 162 of file reacting_low_mach_navier_stokes_base.C.

  {
    const unsigned int dim = system->get_mesh().mesh_dimension();

    for( unsigned int i = 0; i < this->_n_species; i++ )
      {
        system->time_evolving( _species_vars[i] );
      }

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

template<typename Mixture , typename Evaluator >

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

virtual

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

Reimplemented from GRINS::Physics.

Definition at line 420 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->_p_var );
      }

    return;
  }

template<typename Mixture , typename Evaluator >

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

virtual

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

Todo:

Need to implement thermodynamic pressure calcuation for cases where it's needed.

Reimplemented from GRINS::Physics.

Definition at line 400 of file reacting_low_mach_navier_stokes.C.

  {
    std::vector<BoundaryID> ids = context.side_boundary_ids();

    for( std::vector<BoundaryID>::const_iterator it = ids.begin();
         it != ids.end(); it++ )
      {
        libmesh_assert (*it != libMesh::BoundaryInfo::invalid_id);

        this->_bc_handler->apply_neumann_bcs( context, cache, compute_jacobian, *it );
      }

    return;
  }

template<typename Mixture , typename Evaluator >

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::T ( const libMesh::Point &  p, const AssemblyContext &  c  ) const

inlineinherited

Definition at line 131 of file reacting_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<typename Mixture, typename Evaluator>

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

protected

Index from registering this quantity.

Definition at line 103 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

unsigned int GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_dim

protectedinherited

Physical dimension of problem.

Definition at line 83 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

bool GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_enable_thermo_press_calc

protectedinherited

Flag to enable thermodynamic pressure calculation.

Definition at line 111 of file reacting_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<typename Mixture, typename Evaluator>

bool GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_fixed_density

protectedinherited

Definition at line 113 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

libMesh::Real GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_fixed_rho_value

protectedinherited

Definition at line 115 of file reacting_low_mach_navier_stokes_base.h.

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

template<typename Mixture, typename Evaluator>

libMesh::Point GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_g

protectedinherited

Gravity vector.

Definition at line 108 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

Mixture GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_gas_mixture

protectedinherited

Definition at line 78 of file reacting_low_mach_navier_stokes_base.h.

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

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 109 of file reacting_low_mach_navier_stokes.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<typename Mixture, typename Evaluator>

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

protected

Index from registering this quantity.

Definition at line 100 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 106 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 97 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

unsigned int GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_n_species

protectedinherited

Number of species.

Definition at line 86 of file reacting_low_mach_navier_stokes_base.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 112 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

libMesh::Number GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_p0

protectedinherited

Definition at line 80 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

VariableIndex GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_p0_var

protectedinherited

Definition at line 95 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::string GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_p0_var_name

protectedinherited

Definition at line 99 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::FEFamily GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_P_FE_family

protectedinherited

Definition at line 102 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::Order GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_P_order

protectedinherited

Definition at line 105 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

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

protected

Definition at line 88 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

VariableIndex GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_p_var

protectedinherited

Definition at line 93 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::string GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_p_var_name

protectedinherited

Definition at line 99 of file reacting_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<typename Mixture, typename Evaluator>

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

protected

Enable pressure pinning.

Definition at line 86 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

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

protected

Index from registering this quantity.

Definition at line 91 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::FEFamily GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_species_FE_family

protectedinherited

Element type, read from input.

Definition at line 102 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::Order GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_species_order

protectedinherited

Element orders, read from input.

Definition at line 105 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::vector<std::string> GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_species_var_names

protectedinherited

Names of each (owned) variable in the system.

Definition at line 98 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::vector<VariableIndex> GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_species_vars

protectedinherited

Indices for each (owned) variable;.

Definition at line 89 of file reacting_low_mach_navier_stokes_base.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 94 of file reacting_low_mach_navier_stokes.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::FEFamily GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_T_FE_family

protectedinherited

Definition at line 102 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::Order GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_T_order

protectedinherited

Definition at line 105 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

VariableIndex GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_T_var

protectedinherited

Definition at line 94 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::string GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_T_var_name

protectedinherited

Definition at line 99 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

VariableIndex GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_u_var

protectedinherited

Definition at line 90 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::string GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_u_var_name

protectedinherited

Definition at line 99 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::FEFamily GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_V_FE_family

protectedinherited

Definition at line 102 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

GRINSEnums::Order GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_V_order

protectedinherited

Definition at line 105 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

VariableIndex GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_v_var

protectedinherited

Definition at line 91 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::string GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_v_var_name

protectedinherited

Definition at line 99 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

VariableIndex GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_w_var

protectedinherited

Definition at line 92 of file reacting_low_mach_navier_stokes_base.h.

template<typename Mixture, typename Evaluator>

std::string GRINS::ReactingLowMachNavierStokesBase< Mixture, Evaluator >::_w_var_name

protectedinherited

Definition at line 99 of file reacting_low_mach_navier_stokes_base.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