#include <reacting_low_mach_navier_stokes_bc_handling.h>

Inheritance diagram for GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >:

Collaboration diagram for GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >:

Public Member Functions
	ReactingLowMachNavierStokesBCHandling (const std::string &physics_name, const GetPot &input, const Chemistry &chem_mixture)

virtual	~ReactingLowMachNavierStokesBCHandling ()

virtual int	string_to_int (const std::string &bc_type_in) const

virtual void	init_bc_data (const libMesh::FEMSystem &system)
	Override this method to initialize any system-dependent data. More...

virtual void	init_bc_types (const GRINS::BoundaryID bc_id, const std::string &bc_id_string, const int bc_type, const std::string &bc_vars, const std::string &bc_value, const GetPot &input)

virtual void	user_init_dirichlet_bcs (libMesh::FEMSystem *system, libMesh::DofMap &dof_map, GRINS::BoundaryID bc_id, GRINS::BCType bc_type) const

virtual void	init_dirichlet_bcs (libMesh::FEMSystem *system) const

virtual void	user_apply_neumann_bcs (AssemblyContext &context, const GRINS::CachedValues &cache, const bool request_jacobian, const GRINS::BoundaryID bc_id, const GRINS::BCType bc_type) const

void	set_species_bc_type (GRINS::BoundaryID bc_id, int bc_type)

void	set_species_bc_values (GRINS::BoundaryID bc_id, const std::vector< libMesh::Real > &species_values)

libMesh::Real	get_species_bc_value (GRINS::BoundaryID bc_id, unsigned int species) const

CatalyticWallBase< Chemistry > *	get_catalytic_wall (const BoundaryID bc_id)

void	set_temp_bc_type (GRINS::BoundaryID bc_id, int bc_type)

void	set_temp_bc_value (GRINS::BoundaryID bc_id, libMesh::Real value)

libMesh::Real	get_temp_bc_value (GRINS::BoundaryID bc_id) const

void	attach_neumann_bound_func (GRINS::NBCContainer &neumann_bcs)

void	attach_dirichlet_bound_func (const GRINS::DBCContainer &dirichlet_bc)

virtual void	read_bc_data (const GetPot &input, const std::string &id_str, const std::string &bc_str, const std::string &var_str, const std::string &val_str)

virtual void	apply_neumann_bcs (AssemblyContext &context, const GRINS::CachedValues &cache, const bool request_jacobian, const GRINS::BoundaryID bc_id) const

virtual void	init_dirichlet_bc_func_objs (libMesh::FEMSystem *system) const

virtual void	init_periodic_bcs (libMesh::FEMSystem *system) const

void	set_dirichlet_bc_type (GRINS::BoundaryID bc_id, int bc_type)

void	set_neumann_bc_type (GRINS::BoundaryID bc_id, int bc_type)

void	set_dirichlet_bc_value (GRINS::BoundaryID bc_id, libMesh::Real value, int component=0)

void	set_neumann_bc_value (GRINS::BoundaryID bc_id, const libMesh::Point &q_in)

libMesh::Real	get_dirichlet_bc_value (GRINS::BoundaryID bc_id, int component=0) const

const libMesh::Point &	get_neumann_bc_value (GRINS::BoundaryID bc_id) const

std::tr1::shared_ptr< GRINS::NeumannFuncObj >	get_neumann_bound_func (GRINS::BoundaryID bc_id, GRINS::VariableIndex var_id) const

std::tr1::shared_ptr< GRINS::NeumannFuncObj >	get_neumann_bound_func (GRINS::BoundaryID bc_id, GRINS::VariableIndex var_id)

GRINS::BCType	get_dirichlet_bc_type (const GRINS::BoundaryID bc_id) const

bool	is_axisymmetric () const

Protected Types
enum	BC_BASE { PERIODIC = -5, CONSTANT_DIRICHLET, PARSED_DIRICHLET, PARSED_FEM_DIRICHLET, AXISYMMETRIC }

Protected Member Functions
void	build_catalycities (const GetPot &input, const std::string &reactant, const std::string &bc_id_string, const BoundaryID bc_id, boost::scoped_ptr< CatalycityBase > &gamma_r)

Protected Attributes
std::map< GRINS::BoundaryID, std::vector< libMesh::Real > >	_species_bc_values

std::vector< std::pair< BoundaryID, BCType > >	_species_bc_map

unsigned int	_n_species

std::vector< std::string >	_species_var_names

std::vector< GRINS::VariableIndex >	_species_vars

std::multimap< BoundaryID, std::tr1::shared_ptr< CatalyticWallBase< Chemistry > > >	_catalytic_walls

const Chemistry &	_chemistry

std::string	_u_var_name

std::string	_v_var_name

std::string	_w_var_name

std::string	_T_var_name

GRINS::VariableIndex	_T_var

std::map< GRINS::BoundaryID, libMesh::Real >	_T_values

std::vector< std::pair< BoundaryID, BCType > >	_temp_bc_map

std::vector< std::pair< BoundaryID, BCType > >	_dirichlet_bc_map
	Map between boundary id and Dirichlet boundary condition type. More...

std::map< GRINS::BoundaryID, GRINS::BCType >	_neumann_bc_map
	Map between boundary id and Neumann boundary condition type. More...

std::map< GRINS::BoundaryID, libMesh::Point >	_dirichlet_values
	Stash prescribed Dirichlet boundary values. More...

std::map< GRINS::BoundaryID, libMesh::Point >	_q_values
	Stash prescribed boundary fluxes. More...

std::map< GRINS::BoundaryID, GRINS::NBCContainer >	_neumann_bound_funcs

std::vector< GRINS::DBCContainer >	_dirichlet_bound_funcs

GRINS::BoundaryConditions	_bound_conds
	Object that stashes generic boundary condition types. More...

std::vector< GRINS::PBCContainer >	_periodic_bcs

unsigned int	_num_periodic_bcs

std::string	_physics_name

Static Protected Attributes
static bool	_axisymmetric = false
	Flag to cache whether or not there is an axisymmetric boundary present. More...

Private Types
enum	RLMNS_BC_TYPES { ZERO_SPECIES_FLUX =20, PRESCRIBED_SPECIES, PRESCRIBED_MOLE_FRACTIONS, GAS_RECOMBINATION_CATALYTIC_WALL, GAS_SOLID_CATALYTIC_WALL, GENERAL_SPECIES }

Private Member Functions
	ReactingLowMachNavierStokesBCHandling ()

Detailed Description

template<typename Chemistry>
class GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >

Definition at line 38 of file reacting_low_mach_navier_stokes_bc_handling.h.

Member Enumeration Documentation

enum GRINS::BCHandlingBase::BC_BASE

protectedinherited

Enumerator
PERIODIC
CONSTANT_DIRICHLET
PARSED_DIRICHLET
PARSED_FEM_DIRICHLET
AXISYMMETRIC

Definition at line 163 of file bc_handling_base.h.

                 { PERIODIC = -5,
                   CONSTANT_DIRICHLET,
                   PARSED_DIRICHLET,
                   PARSED_FEM_DIRICHLET,
                   AXISYMMETRIC };

template<typename Chemistry>

enum GRINS::ReactingLowMachNavierStokesBCHandling::RLMNS_BC_TYPES

private

Enumerator
ZERO_SPECIES_FLUX
PRESCRIBED_SPECIES
PRESCRIBED_MOLE_FRACTIONS
GAS_RECOMBINATION_CATALYTIC_WALL
GAS_SOLID_CATALYTIC_WALL
GENERAL_SPECIES

Definition at line 107 of file reacting_low_mach_navier_stokes_bc_handling.h.

                        { ZERO_SPECIES_FLUX=20, 
                          PRESCRIBED_SPECIES,
                          PRESCRIBED_MOLE_FRACTIONS,
                          GAS_RECOMBINATION_CATALYTIC_WALL,
                          GAS_SOLID_CATALYTIC_WALL,
                          GENERAL_SPECIES };

Constructor & Destructor Documentation

template<typename Chemistry >

GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::ReactingLowMachNavierStokesBCHandling	(	const std::string &	physics_name,
		const GetPot &	input,
		const Chemistry &	chem_mixture
	)

Todo:: Make this prefix string an input option

Definition at line 49 of file reacting_low_mach_navier_stokes_bc_handling.C.

References GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::_n_species, GRINS::BCHandlingBase::_physics_name, GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::_species_var_names, and GRINS::BCHandlingBase::read_bc_data().

     : LowMachNavierStokesBCHandling(physics_name,input),
       _n_species( input.vector_variable_size("Physics/Chemistry/species") ),
       _species_var_names(_n_species),
       _species_vars(_n_species),
       _chemistry(chemistry)
   {
 
     for( unsigned int s = 0; s < _n_species; s++ )
       {
         std::string var_name = "w_"+std::string(input( "Physics/Chemistry/species", "DIE!", s ));
         _species_var_names[s] =  var_name;
       }
 
     std::string id_str = "Physics/"+_physics_name+"/species_bc_ids";
     std::string bc_str = "Physics/"+_physics_name+"/species_bc_types";
     std::string var_str = "Physics/"+_physics_name+"/species_bc_variables";
     std::string val_str = "Physics/"+_physics_name+"/species_bc_values";
     
     this->read_bc_data( input, id_str, bc_str, var_str, val_str );
     
     return;
   }

template<typename Chemistry >

GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::~ReactingLowMachNavierStokesBCHandling ( )

virtual

Definition at line 77 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     return;
   }

template<typename Chemistry>

GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::ReactingLowMachNavierStokesBCHandling ( )

private

Member Function Documentation

void GRINS::BCHandlingBase::apply_neumann_bcs	(	AssemblyContext &	context,
		const GRINS::CachedValues &	cache,
		const bool	request_jacobian,
		const GRINS::BoundaryID	bc_id
	)		const

virtualinherited

Definition at line 234 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_neumann_bc_map, and GRINS::BCHandlingBase::user_apply_neumann_bcs().

   {
     std::map< BoundaryID, BCType>::const_iterator 
       bc_map_it = _neumann_bc_map.find( bc_id );
 
     /* We assume that if you didn't put a boundary id in, then you didn't want to
        set a boundary condition on that boundary. */
     if( bc_map_it != _neumann_bc_map.end() )
       {
         this->user_apply_neumann_bcs( context, cache, request_jacobian,
                                       bc_id, bc_map_it->second );
       }
     return;
   }

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

inherited

Definition at line 67 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bound_funcs.

Referenced by GRINS::Physics::attach_dirichlet_bound_func(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::IncompressibleNavierStokesBCHandling::init_bc_types(), and GRINS::BCHandlingBase::init_bc_types().

   {
     _dirichlet_bound_funcs.push_back( dirichlet_bc );
     return;
   }

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

inherited

Definition at line 61 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_neumann_bound_funcs, and GRINS::NBCContainer::get_bc_id().

Referenced by GRINS::Physics::attach_neumann_bound_func().

   {
     _neumann_bound_funcs.insert( std::make_pair( neumann_bcs.get_bc_id(), neumann_bcs ) );
     return;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::build_catalycities	(	const GetPot &	input,
		const std::string &	reactant,
		const std::string &	bc_id_string,
		const BoundaryID	bc_id,
		boost::scoped_ptr< CatalycityBase > &	gamma_r
	)

protected

Todo:: We assuming single reaction and single product the product is generated at minus the rate the reactant is consumed. Might want to remove this someday.

Definition at line 578 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     std::string catalycity_type = input("Physics/"+_physics_name+"/gamma_"+reactant+"_"+bc_id_string+"_type", "none");
 
     if( catalycity_type == std::string("constant") )
       {
         std::string gamma_r_string = "Physics/"+_physics_name+"/gamma_"+reactant+"_"+bc_id_string;
         libMesh::Real gamma = input(gamma_r_string, 0.0);
 
         if( !input.have_variable(gamma_r_string) )
           {
             std::cout << "Error: Could not find catalycity for species " << reactant
                       << ", for boundary " << bc_id << std::endl;
             libmesh_error();
           }
 
         gamma_r.reset( new ConstantCatalycity( gamma ) );
       }
     else if( catalycity_type == std::string("arrhenius") )
       {
         std::string gamma_r_string = "Physics/"+_physics_name+"/gamma0_"+reactant+"_"+bc_id_string;
         std::string Ta_r_string = "Physics/"+_physics_name+"/Ta_"+reactant+"_"+bc_id_string;
 
         libMesh::Real gamma0 = input(gamma_r_string, 0.0);
         libMesh::Real Ta = input(Ta_r_string, 0.0);
 
         if( !input.have_variable(gamma_r_string) )
           {
             std::cout << "Error: Could not find gamma0 for species " << reactant
                       << ", for boundary " << bc_id << std::endl;
             libmesh_error();
           }
 
         if( !input.have_variable(Ta_r_string) )
           {
             std::cout << "Error: Could not find Ta for species " << reactant
                       << ", for boundary " << bc_id << std::endl;
             libmesh_error();
           }
 
         gamma_r.reset( new ArrheniusCatalycity( gamma0, Ta ) );
       }
     else if( catalycity_type == std::string("power") )
       {
         std::string gamma_r_string = "Physics/"+_physics_name+"/gamma0_"+reactant+"_"+bc_id_string;
         std::string Tref_r_string = "Physics/"+_physics_name+"/Tref_"+reactant+"_"+bc_id_string;
         std::string alpha_r_string = "Physics/"+_physics_name+"/alpha_"+reactant+"_"+bc_id_string;
 
         libMesh::Real gamma0 = input(gamma_r_string, 0.0);
         libMesh::Real Tref = input(Tref_r_string, 0.0);
         libMesh::Real alpha = input(alpha_r_string, 0.0);
 
         if( !input.have_variable(gamma_r_string) )
           {
             std::cout << "Error: Could not find gamma0 for species " << reactant
                       << ", for boundary " << bc_id << std::endl;
             libmesh_error();
           }
 
         if( !input.have_variable(Tref_r_string) )
           {
             std::cout << "Error: Could not find Tref for species " << reactant
                       << ", for boundary " << bc_id << std::endl;
             libmesh_error();
           }
 
         if( !input.have_variable(alpha_r_string) )
           {
             std::cout << "Error: Could not find alpha for species " << reactant
                       << ", for boundary " << bc_id << std::endl;
             libmesh_error();
           }
 
         gamma_r.reset( new PowerLawCatalycity( gamma0, Tref, alpha ) );
       }
     else
       {
         std::cerr << "Error: Unsupported catalycity type " << catalycity_type << std::endl
                   << "       for reactant " << reactant << std::endl
                   << "Valid catalycity types are: constant" << std::endl
                   << "                            arrhenius" << std::endl
                   << "                            power" << std::endl;
 
         libmesh_error();
       }
 
 
     return;
   }

template<typename Chemistry >

CatalyticWallBase< Chemistry > * GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::get_catalytic_wall ( const BoundaryID bc_id )

Todo:: Need to generalize this to multiple catalytic-walls-for-same-bcid case.

Definition at line 675 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     return (_catalytic_walls.find(bc_id)->second).get();
   }

GRINS::BCType GRINS::BCHandlingBase::get_dirichlet_bc_type ( const GRINS::BoundaryID bc_id ) const

inlineinherited

Definition at line 207 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_dirichlet_bc_map.

   {
     BCType bc_type_out = -100;
 
     for( std::vector<std::pair<BoundaryID,BCType> >::const_iterator it = _dirichlet_bc_map.begin();
          it != _dirichlet_bc_map.end(); it++ )
       {
         if( it->first == bc_id ) bc_type_out = it->second;
       }
 
     libmesh_assert_not_equal_to( bc_type_out, -100 );
 
     return bc_type_out;
   }

libMesh::Real GRINS::BCHandlingBase::get_dirichlet_bc_value	(	GRINS::BoundaryID	bc_id,
		int	component = `0`
	)		const

inherited

Definition at line 273 of file bc_handling_base.C.

Referenced by GRINS::HeatTransferBCHandling::user_init_dirichlet_bcs(), GRINS::LowMachNavierStokesBCHandling::user_init_dirichlet_bcs(), GRINS::IncompressibleNavierStokesBCHandling::user_init_dirichlet_bcs(), GRINS::SolidMechanicsBCHandling::user_init_dirichlet_bcs(), and GRINS::AxisymmetricHeatTransferBCHandling::user_init_dirichlet_bcs().

   {
     return (_dirichlet_values.find(bc_id)->second)(component);
   }

const libMesh::Point & GRINS::BCHandlingBase::get_neumann_bc_value ( GRINS::BoundaryID bc_id ) const

inlineinherited

Definition at line 185 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_q_values.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::user_apply_neumann_bcs(), GRINS::HeatTransferBCHandling::user_apply_neumann_bcs(), and GRINS::SolidMechanicsBCHandling::user_apply_neumann_bcs().

   {
     return (_q_values.find(bc_id))->second;
   }

std::tr1::shared_ptr< GRINS::NeumannFuncObj > GRINS::BCHandlingBase::get_neumann_bound_func	(	GRINS::BoundaryID	bc_id,
		GRINS::VariableIndex	var_id
	)		const

inlineinherited

Definition at line 192 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_neumann_bound_funcs.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::user_apply_neumann_bcs(), and GRINS::HeatTransferBCHandling::user_apply_neumann_bcs().

   {
     return ((_neumann_bound_funcs.find(bc_id))->second).get_func(var_id);
   }

std::tr1::shared_ptr< GRINS::NeumannFuncObj > GRINS::BCHandlingBase::get_neumann_bound_func	(	GRINS::BoundaryID	bc_id,
		GRINS::VariableIndex	var_id
	)

inlineinherited

Definition at line 200 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_neumann_bound_funcs.

   {
     return ((_neumann_bound_funcs.find(bc_id))->second).get_func(var_id);
   }

template<typename Chemistry >

libMesh::Real GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::get_species_bc_value	(	GRINS::BoundaryID	bc_id,
		unsigned int	species
	)		const

Definition at line 498 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     return (_species_bc_values.find(bc_id)->second)[species];
   }

libMesh::Real GRINS::LowMachNavierStokesBCHandling::get_temp_bc_value ( GRINS::BoundaryID bc_id ) const

inherited

Definition at line 489 of file low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::_T_values.

Referenced by GRINS::LowMachNavierStokesBCHandling::user_init_dirichlet_bcs().

   {
     return _T_values.find(bc_id)->second;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::init_bc_data ( const libMesh::FEMSystem & system )

virtual

Override this method to initialize any system-dependent data.

Override this method to, for example, cache a System variable number. This is called before any of the other init methods in this class. By default, does nothing.

Reimplemented from GRINS::LowMachNavierStokesBCHandling.

Definition at line 398 of file reacting_low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::init_bc_data().

   {
     // Call base class
     LowMachNavierStokesBCHandling::init_bc_data(system);
 
     for( unsigned int s = 0; s < this->_n_species; s++ )
       {
         _species_vars[s] = system.variable_number( _species_var_names[s] );
       }
 
     // See if we have a catalytic wall and initialize them if we do
     for( std::map< GRINS::BoundaryID, GRINS::BCType>::const_iterator bc_map = _neumann_bc_map.begin();
          bc_map != _neumann_bc_map.end(); ++bc_map )
       {
         const BoundaryID bc_id = bc_map->first;
         const BCType bc_type = bc_map->second;
 
         if( bc_type == GAS_RECOMBINATION_CATALYTIC_WALL ||
             bc_type == GAS_SOLID_CATALYTIC_WALL )
           {
             typedef typename std::multimap<BoundaryID, std::tr1::shared_ptr<CatalyticWallBase<Chemistry> > >::iterator it_type;
 
             std::pair< it_type, it_type > it_range = _catalytic_walls.equal_range( bc_id );
 
             for( it_type it = it_range.first; it != it_range.second; ++it )
               {
                 (it->second)->init(system);
 
                 if( this->is_axisymmetric() )
                   {
                     (it->second)->set_axisymmetric(true);
                   }
               }
           } // if( bc_type == GAS_RECOMBINATION_CATALYTIC_WALL )
 
       } // end loop over bc_ids
 
     return;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::init_bc_types	(	const GRINS::BoundaryID	bc_id,
		const std::string &	bc_id_string,
		const int	bc_type,
		const std::string &	bc_vars,
		const std::string &	bc_value,
		const GetPot &	input
	)

virtual

Todo:: We currently can only handle reactions of the type R -> P, i.e not R1+R2 -> P, etc.

Reimplemented from GRINS::LowMachNavierStokesBCHandling.

Definition at line 120 of file reacting_low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::init_bc_types(), and GRINS::StringUtilities::split_string().

   {
     switch(bc_type)
       {
       case(ZERO_SPECIES_FLUX):
         {
           this->set_neumann_bc_type( bc_id, bc_type );
         }
         break;
 
       case(PRESCRIBED_SPECIES):
         {
           this->set_species_bc_type( bc_id, bc_type );
 
           unsigned int n_species_comps = input.vector_variable_size("Physics/"+_physics_name+"/bound_species_"+bc_id_string);
 
           if( n_species_comps != _n_species )
             {
               std::cerr << "Error: The number of prescribed species values must match" << std::endl
                         << "       the number of species in the simulation." << std::endl
                         << "n_species       = " << _n_species << std::endl
                         << "n_species_comps = " << n_species_comps << std::endl;
               libmesh_error();
             }
           
           std::vector<libMesh::Real> species_mass_fracs(n_species_comps);
 
           for( unsigned int s = 0; s < n_species_comps; s++ )
             {
               species_mass_fracs[s] = input("Physics/"+_physics_name+"/bound_species_"+bc_id_string, -1.0, s );
 
               if( (species_mass_fracs[s] > 1.0) ||
                   (species_mass_fracs[s] < 0.0)   )
                 {
                   std::cerr << "Error: prescribed species mass fraction must be between 0.0 and 1.0" << std::endl
                             << "w[" << s << "] = " << species_mass_fracs[s] << std::endl;
                   libmesh_error();
                 }
             }
 
           this->set_species_bc_values( bc_id, species_mass_fracs );
         }
         break;
 
       case(PRESCRIBED_MOLE_FRACTIONS):
         {
           this->set_species_bc_type( bc_id, bc_type );
 
           unsigned int n_species_comps = input.vector_variable_size("Physics/"+_physics_name+"/bound_species_"+bc_id_string);
 
           if( n_species_comps != _n_species )
             {
               std::cerr << "Error: The number of prescribed species values must match" << std::endl
                         << "       the number of species in the simulation." << std::endl
                         << "n_species       = " << _n_species << std::endl
                         << "n_species_comps = " << n_species_comps << std::endl;
               libmesh_error();
             }
           
           std::vector<libMesh::Real> species_mole_fracs(n_species_comps);
 
           for( unsigned int s = 0; s < n_species_comps; s++ )
             {
               species_mole_fracs[s] = input("Physics/"+_physics_name+"/bound_species_"+bc_id_string, -1.0, s );
 
               if( (species_mole_fracs[s] > 1.0) ||
                   (species_mole_fracs[s] < 0.0)   )
                 {
                   std::cerr << "Error: prescribed species mole fraction must be between 0.0 and 1.0" << std::endl
                             << "w[" << s << "] = " << species_mole_fracs[s] << std::endl;
                   libmesh_error();
                 }
             }
 
           // Compute M
           libMesh::Real M = 0.0;
           for( unsigned int s = 0; s < n_species_comps; s++ )
             {
               M += species_mole_fracs[s]*_chemistry.M(s);
             }
 
           // Convert mole fractions to mass fractions
           std::vector<libMesh::Real> species_mass_fracs(n_species_comps);
           for( unsigned int s = 0; s < n_species_comps; s++ )
             {
               species_mass_fracs[s] = species_mole_fracs[s]*_chemistry.M(s)/M;
             }
 
           this->set_species_bc_values( bc_id, species_mass_fracs );
         }
         break;
 
       case(GENERAL_SPECIES):
         {
           this->set_dirichlet_bc_type( bc_id, bc_type );
         }
         break;
 
       case(GAS_RECOMBINATION_CATALYTIC_WALL):
         {
           this->set_neumann_bc_type( bc_id, bc_type );
 
           // Parse catalytic reactions on this wall
           std::string reactions_string = "Physics/"+_physics_name+"/wall_catalytic_reactions_"+bc_id_string;
           if( !input.have_variable(reactions_string) )
             {
               std::cerr << "Error: Could not find list of catalytic reactions for boundary id " << bc_id 
                         << std::endl;
               libmesh_error();
             }
 
           const unsigned int n_reactions = input.vector_variable_size(reactions_string);
 
           for( unsigned int r = 0; r < n_reactions; r++ )
             {
               std::string reaction = input(reactions_string, "DIE!", r);
 
               // First, split each reaction into reactants and products
               std::vector<std::string> partners;
               StringUtilities::split_string(reaction, "->", partners);
 
               const std::string& reactant = partners[0];
               const std::string& product = partners[1];
 
               if( partners.size() == 2 )
                 {
                   /* ------------- Grab the reactant and product species indices ------------- */
                   const unsigned int r_species = _chemistry.species_index( reactant );
                   const unsigned int p_species = _chemistry.species_index( product );
 
                   /* ------------- Parse and construct the corresponding catalyticities ------------- */
 
                   // These are temporary and will be cloned, so let them be destroyed when we're done
                   boost::scoped_ptr<CatalycityBase> gamma_r(NULL);
 
                   this->build_catalycities( input, reactant, bc_id_string, bc_id, gamma_r );
 
                   /* ------------- Now cache the CatalyticWall functions to init later ------------- */
                   libmesh_assert( gamma_r );
 
                   std::tr1::shared_ptr<CatalyticWallBase<Chemistry> > wall_ptr( new GasRecombinationCatalyticWall<Chemistry>( _chemistry, *gamma_r, r_species, p_species ) );
 
                   _catalytic_walls.insert( std::make_pair(bc_id, wall_ptr ) );
 
                 } // if( partners.size() == 2 )
               else
                 {
                   std::cerr << "Error: Can currently only handle 1 reactant and 1 product" << std::endl
                             << "in a catalytic reaction." << std::endl
                             << "Found " << partners.size() << " species." << std::endl;
                   libmesh_error();
                 }
 
             } // loop over reactions
         }
         break;
 
         case(GAS_SOLID_CATALYTIC_WALL):
           {
             this->set_neumann_bc_type( bc_id, bc_type );
 
             // Parse catalytic reactions on this wall
             std::string reactions_string = "Physics/"+_physics_name+"/wall_gas_solid_reactions_"+bc_id_string;
             if( !input.have_variable(reactions_string) )
               {
                 std::cerr << "Error: Could not find list of gas-solid catalytic reactions for boundary id "
                           << bc_id
                           << std::endl;
                 libmesh_error();
               }
 
             const unsigned int n_reactions = input.vector_variable_size(reactions_string);
 
             for( unsigned int r = 0; r < n_reactions; r++ )
               {
                 std::string reaction = input(reactions_string, "DIE!", r);
 
                 /* We are expecting reactions of the form
                    X+Y(s)->Z  or
                    Y(s)+X->X
                 So, first we'll split on the "->", then split the reactants up and
                 figure out which is the gas species and which is the solid species. */
 
                 std::vector<std::string> partners;
                 StringUtilities::split_string(reaction, "->", partners);
 
                 const std::string pre_split_reactants = partners[0];
                 const std::string& product = partners[1];
 
                 std::vector<std::string> split_reactants;
                 StringUtilities::split_string(pre_split_reactants, "+", split_reactants);
 
                 // We can only handle two reactants currently
                 if( split_reactants.size() != 2 )
                   {
                     std::cerr << "Error: Currently, GasSolidCatalyticWall boundary condition only supports"
                               << std::endl
                               << "       reactions of the form X+Y(s)->Z or Y(s)+X->X. Found "
                               << split_reactants.size() << " reactants." << std::endl;
                     libmesh_error();
                   }
 
                 std::string gas_reactant;
                 std::string solid_reactant;
                 // Check if the first reactant is the solid one
                 if( split_reactants[0].find("(s)") == split_reactants[0].npos )
                   {
                     // If not found, check the second entry
                     if( split_reactants[1].find("(s)") == split_reactants[1].npos )
                       {
                         std::cerr << "Error: could not find solid reactant for GasSolidCatalyticWall" << std::endl
                                   << "       boundary condition. Found reactants " << split_reactants[0]
                                   << ", " << split_reactants[1] << std::endl;
                         libmesh_error();
                       }
                     else
                       {
                         gas_reactant = split_reactants[0];
                         solid_reactant = split_reactants[1].substr(0,split_reactants[1].find("(s)"));
                       }
                   }
                 // Found (s) in the first entry
                 else
                   {
                     // Check that there's not 2 solid reactants
                     if( split_reactants[1].find("(s)") != split_reactants[1].npos )
                       {
                         std::cerr << "Error: can have only one solid reactant for GasSolidCatalyticWall" << std::endl
                                   << "       boundary condition. Found reactants " << split_reactants[0]
                                   << ", " << split_reactants[1] << std::endl;
                         libmesh_error();
                       }
 
                     gas_reactant = split_reactants[1];
                     solid_reactant = split_reactants[0].substr(0,split_reactants[0].find("(s)"));
                   }
 
                 /* Now we have the gas reactant, the solid reactant, and the gas product strings.
                    Next we grab the species indices, build the catalycity, then build the
                    CatalyticWallBase object. */
                 const unsigned int rg_species = _chemistry.species_index( gas_reactant );
                 const unsigned int rs_species = _chemistry.species_index( solid_reactant );
                 const unsigned int p_species  = _chemistry.species_index( product );
 
                 // This is temporary and will be cloned, so let it be destroyed when we're done
                 boost::scoped_ptr<CatalycityBase> gamma_r(NULL);
 
                 this->build_catalycities( input, gas_reactant, bc_id_string, bc_id, gamma_r );
 
                 libmesh_assert( gamma_r );
 
                 std::tr1::shared_ptr<CatalyticWallBase<Chemistry> > wall_ptr( new GasSolidCatalyticWall<Chemistry>( _chemistry, *gamma_r, rg_species, rs_species, p_species ) );
 
                 _catalytic_walls.insert( std::make_pair(bc_id, wall_ptr ) );
 
               } // loop over reactions
           }
         break;
 
       default:
         {
           LowMachNavierStokesBCHandling::init_bc_types( bc_id, bc_id_string, bc_type,
                                                         bc_vars, bc_value, input );
         }
         break;
 
       } //switch(bc_type)
 
     return;
   }

void GRINS::BCHandlingBase::init_dirichlet_bc_func_objs ( libMesh::FEMSystem * system ) const

virtualinherited

Definition at line 116 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bound_funcs.

Referenced by GRINS::Physics::init_bcs().

   {
     libMesh::DofMap& dof_map = system->get_dof_map();
 
     for( std::vector< DBCContainer >::const_iterator 
            it = _dirichlet_bound_funcs.begin();
          it != _dirichlet_bound_funcs.end();
          it++ )
       {
         // First, get variable names. We convert them to variable ids,
         // both to tell the DirichletBoundary what variables to
         // project and to tell the CompositeFunction what remapping to
         // do.
         std::vector<VariableName> var_names = (*it).get_var_names();
       
         std::vector<VariableIndex> dbc_vars;
 
         for( std::vector<VariableName>::const_iterator name = var_names.begin();
              name != var_names.end();
              name++ )
           {
             dbc_vars.push_back( system->variable_number( *name ) );
           }
       
         // Get bc_id's
         std::set<BoundaryID> bc_ids = (*it).get_bc_ids();
       
         // Get Dirichlet bc functor
         std::tr1::shared_ptr<libMesh::FunctionBase<libMesh::Number> >
           func = (*it).get_func();
 
         // Remap indices as necessary
         if (func.get())
           {
             libMesh::CompositeFunction<libMesh::Number> remapped_func;
             remapped_func.attach_subfunction(*func, dbc_vars);
 
             // Now create DirichletBoundary object and give it to libMesh
             // libMesh makes it own copy of the DirichletBoundary so we can
             // let this one die.
             libMesh::DirichletBoundary dbc( bc_ids, dbc_vars,
                                             remapped_func );
       
             dof_map.add_dirichlet_boundary( dbc );
           }
         else
           {
             // Get Dirichlet bc functor
             const std::string& func_string = (*it).get_fem_func_string();
 
             libmesh_assert_not_equal_to(func_string, "");
 
             // Need to belatedly create Dirichlet functor since we
             // didn't have a System object handy until now.
             libMesh::ParsedFEMFunction<libMesh::Number>
               func(*system, func_string);
 
             libMesh::CompositeFEMFunction<libMesh::Number> remapped_func;
             remapped_func.attach_subfunction(func, dbc_vars);
 
             // Now create DirichletBoundary object and give it to libMesh
             // libMesh makes it own copy of the DirichletBoundary so we can
             // let this one die.
             libMesh::DirichletBoundary dbc( bc_ids, dbc_vars,
                                             *system,
                                             remapped_func );
       
             dof_map.add_dirichlet_boundary( dbc );
           }
       }
 
     return;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::init_dirichlet_bcs ( libMesh::FEMSystem * system ) const

virtual

Reimplemented from GRINS::LowMachNavierStokesBCHandling.

Definition at line 505 of file reacting_low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::init_dirichlet_bcs().

   {
     LowMachNavierStokesBCHandling::init_dirichlet_bcs(system);
 
     libMesh::DofMap& dof_map = system->get_dof_map();
 
     for( std::vector<std::pair<BoundaryID,BCType> >::const_iterator it = _species_bc_map.begin();
          it != _species_bc_map.end();
          it++ )
       {
         this->user_init_dirichlet_bcs( system, dof_map, it->first, it->second );
       }
 
     return;
   }

void GRINS::BCHandlingBase::init_periodic_bcs ( libMesh::FEMSystem * system ) const

virtualinherited

Definition at line 203 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_num_periodic_bcs, and GRINS::BCHandlingBase::_periodic_bcs.

Referenced by GRINS::Physics::init_bcs().

   {
     /* Consistency check required to make sure user actually set periodic bc data.
        This is needed because of the way we parse periodic boundary conditions. */
     if( _periodic_bcs.size() != _num_periodic_bcs/2 )
       {
         std::cerr << "=========================================================="  << std::endl
                   << "Error: Inconsistency in perioidic boundary conditions."      << std::endl
                   << "       There were " << _num_periodic_bcs << " deteced but "  << std::endl
                   << "       only " << _periodic_bcs.size() << " pairs of data "   << std::endl
                   << "       were set."                                            << std::endl
                   << "=========================================================="  << std::endl;
         libmesh_error();
       }
 
     libMesh::DofMap& dof_map = system->get_dof_map();
 
     for( std::vector< PBCContainer >::const_iterator it = _periodic_bcs.begin();
          it != _periodic_bcs.end();
          it++ )
       {
         libMesh::PeriodicBoundary bc( it->get_offset_vector() );
         bc.myboundary = it->get_master_bcid();
         bc.pairedboundary = it->get_slave_bcid();
 
         dof_map.add_periodic_boundary( bc );
       }
 
     return;
   }

bool GRINS::BCHandlingBase::is_axisymmetric ( ) const

inlineinherited

Definition at line 179 of file bc_handling_base.h.

References GRINS::BCHandlingBase::_axisymmetric.

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

   {
     return _axisymmetric;
   }

void GRINS::BCHandlingBase::read_bc_data	(	const GetPot &	input,
		const std::string &	id_str,
		const std::string &	bc_str,
		const std::string &	var_str,
		const std::string &	val_str
	)

virtualinherited

Definition at line 73 of file bc_handling_base.C.

References GRINS::BCHandlingBase::init_bc_types(), and GRINS::BCHandlingBase::string_to_int().

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::AxisymmetricHeatTransferBCHandling(), GRINS::HeatTransferBCHandling::HeatTransferBCHandling(), GRINS::IncompressibleNavierStokesBCHandling::IncompressibleNavierStokesBCHandling(), GRINS::LowMachNavierStokesBCHandling::LowMachNavierStokesBCHandling(), GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::ReactingLowMachNavierStokesBCHandling(), GRINS::SolidMechanicsBCHandling::SolidMechanicsBCHandling(), and GRINS::SpalartAllmarasBCHandling::SpalartAllmarasBCHandling().

   {
     int num_ids = input.vector_variable_size(id_str);
     int num_bcs = input.vector_variable_size(bc_str);
     // int num_vars = input.vector_variable_size(var_str);
     // int num_vals = input.vector_variable_size(val_str);
 
     if( num_ids != num_bcs )
       {
         std::cerr << "Error: Must specify equal number of boundary ids and boundary conditions"
                   << std::endl;
         libmesh_error();
       }
 
     for( int i = 0; i < num_ids; i++ )
       {
         int bc_id = input(id_str, -1, i );
         std::string bc_type_in = input(bc_str, "NULL", i );
 
         int bc_type = this->string_to_int( bc_type_in );
 
         std::stringstream ss;
         ss << bc_id;
         std::string bc_id_string = ss.str();
 
         std::string bc_val = input(val_str, std::string(""), i );
 
         std::string bc_vars = input(var_str, std::string(""), i );
 
         this->init_bc_types( bc_id, bc_id_string, bc_type, bc_vars, bc_val, input );
       }
 
     return;
   }

void GRINS::BCHandlingBase::set_dirichlet_bc_type	(	GRINS::BoundaryID	bc_id,
		int	bc_type
	)

inherited

Definition at line 252 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_bc_map.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::SpalartAllmarasBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::SolidMechanicsBCHandling::init_bc_types(), and GRINS::IncompressibleNavierStokesBCHandling::init_bc_types().

   {
     _dirichlet_bc_map.push_back( std::make_pair(bc_id, bc_type) );
     return;
   }

void GRINS::BCHandlingBase::set_dirichlet_bc_value	(	GRINS::BoundaryID	bc_id,
		libMesh::Real	value,
		int	component = `0`
	)

inherited

Definition at line 264 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_dirichlet_values.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), GRINS::IncompressibleNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _dirichlet_values[bc_id](component) = value;
     return;
   }

void GRINS::BCHandlingBase::set_neumann_bc_type	(	GRINS::BoundaryID	bc_id,
		int	bc_type
	)

inherited

Definition at line 258 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_neumann_bc_map.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _neumann_bc_map[bc_id] = bc_type;
     return;
   }

void GRINS::BCHandlingBase::set_neumann_bc_value	(	GRINS::BoundaryID	bc_id,
		const libMesh::Point &	q_in
	)

inherited

Definition at line 278 of file bc_handling_base.C.

References GRINS::BCHandlingBase::_q_values.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::init_bc_types(), GRINS::HeatTransferBCHandling::init_bc_types(), GRINS::LowMachNavierStokesBCHandling::init_bc_types(), and GRINS::SolidMechanicsBCHandling::init_bc_types().

   {
     _q_values[bc_id] = q_in;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::set_species_bc_type	(	GRINS::BoundaryID	bc_id,
		int	bc_type
	)

Definition at line 483 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     _species_bc_map.push_back( std::make_pair(bc_id,bc_type) );
     return;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::set_species_bc_values	(	GRINS::BoundaryID	bc_id,
		const std::vector< libMesh::Real > &	species_values
	)

Definition at line 490 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     _species_bc_values[bc_id] = species_values;
     return;
   }

void GRINS::LowMachNavierStokesBCHandling::set_temp_bc_type	(	GRINS::BoundaryID	bc_id,
		int	bc_type
	)

inherited

Definition at line 476 of file low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::_temp_bc_map.

Referenced by GRINS::LowMachNavierStokesBCHandling::init_bc_types().

   {
     _temp_bc_map.push_back( std::make_pair(bc_id,bc_type) );
     return;
   }

void GRINS::LowMachNavierStokesBCHandling::set_temp_bc_value	(	GRINS::BoundaryID	bc_id,
		libMesh::Real	value
	)

inherited

Definition at line 482 of file low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::_T_values.

Referenced by GRINS::LowMachNavierStokesBCHandling::init_bc_types().

   {
     _T_values[bc_id] = value;
     return;
   }

template<typename Chemistry >

int GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::string_to_int ( const std::string & bc_type_in ) const

virtual

Reimplemented from GRINS::LowMachNavierStokesBCHandling.

Definition at line 83 of file reacting_low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::string_to_int().

   {
     int bc_type_out;
 
     if( bc_type == "zero_species_flux" )
       {
         bc_type_out = ZERO_SPECIES_FLUX;
       }
     else if( bc_type == "prescribed_species" )
       {
         bc_type_out = PRESCRIBED_SPECIES;
       }
     else if( bc_type == "prescribed_mole_fracs" )
       {
         bc_type_out = PRESCRIBED_MOLE_FRACTIONS;
       }
     else if( bc_type == "gas_recombination_catalytic_wall" )
       {
         bc_type_out = GAS_RECOMBINATION_CATALYTIC_WALL;
       }
     else if( bc_type == "gas_solid_catalytic_wall" )
       {
         bc_type_out = GAS_SOLID_CATALYTIC_WALL;
       }
     else if( bc_type == "general_species" )
       {
         bc_type_out = GENERAL_SPECIES;
       }
     else
       {
         bc_type_out = LowMachNavierStokesBCHandling::string_to_int( bc_type );
       }
 
     return bc_type_out;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::user_apply_neumann_bcs	(	AssemblyContext &	context,
		const GRINS::CachedValues &	cache,
		const bool	request_jacobian,
		const GRINS::BoundaryID	bc_id,
		const GRINS::BCType	bc_type
	)		const

virtual

Reimplemented from GRINS::BCHandlingBase.

Definition at line 522 of file reacting_low_mach_navier_stokes_bc_handling.C.

   {
     switch( bc_type )
       {
       case( GENERAL_SPECIES ):
         {
           for( std::vector<VariableIndex>::const_iterator var = _species_vars.begin();
                var != _species_vars.end();
                ++var )
             {
               if( this->is_axisymmetric() )
                 {
                   _bound_conds.apply_neumann_normal_axisymmetric( context, cache,
                                                                   request_jacobian, *var, -1.0, 
                                                                   this->get_neumann_bound_func( bc_id, *var ) );
                 }
               else
                 {
                   _bound_conds.apply_neumann_normal( context, cache,
                                                      request_jacobian, *var, 1.0, 
                                                      this->get_neumann_bound_func( bc_id, *var ) );
                 }
             }
         }
         break;
 
       case( GAS_RECOMBINATION_CATALYTIC_WALL ):
       case( GAS_SOLID_CATALYTIC_WALL ):
         {
           typedef typename std::multimap<BoundaryID, std::tr1::shared_ptr<CatalyticWallBase<Chemistry> > >::const_iterator it_type;
 
           std::pair< it_type, it_type > it_range = _catalytic_walls.equal_range( bc_id );
 
           for( it_type it = it_range.first; it != it_range.second; ++it )
               {
                 (it->second)->apply_fluxes(context, cache, request_jacobian );
               }
         }
       break;
 
       default:
         {
           std::cerr << "Error: Invalid Neumann BC type for " << _physics_name
                     << std::endl;
           libmesh_error();
         }
       }
 
     return;
   }

template<typename Chemistry >

void GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::user_init_dirichlet_bcs	(	libMesh::FEMSystem *	system,
		libMesh::DofMap &	dof_map,
		GRINS::BoundaryID	bc_id,
		GRINS::BCType	bc_type
	)		const

virtual

Reimplemented from GRINS::LowMachNavierStokesBCHandling.

Definition at line 439 of file reacting_low_mach_navier_stokes_bc_handling.C.

References GRINS::LowMachNavierStokesBCHandling::user_init_dirichlet_bcs().

   {
     switch( bc_type )
       {
       case(ZERO_SPECIES_FLUX):
         // Do nothing BC
         break;
       case(PRESCRIBED_SPECIES):
       case(PRESCRIBED_MOLE_FRACTIONS):
         {
           std::set<GRINS::BoundaryID> dbc_ids;
           dbc_ids.insert(bc_id);
 
           for( unsigned int s = 0; s < _n_species; s++ )
             {
               std::vector<GRINS::VariableIndex> dbc_vars(1,_species_vars[s]);
 
               libMesh::ConstFunction<libMesh::Number> species_func( this->get_species_bc_value(bc_id,s) );
 
               libMesh::DirichletBoundary species_dbc( dbc_ids, 
                                                       dbc_vars, 
                                                       &species_func );
             
               dof_map.add_dirichlet_boundary( species_dbc );
             }
         }
         break;
       
       case(GENERAL_SPECIES):
         // This case is handled in the BoundaryConditionFactory classes.
         break;
       default:
         {
           LowMachNavierStokesBCHandling::user_init_dirichlet_bcs(system,dof_map,bc_id,bc_type);
         }
       } //switch( bc_type )
 
     return;
   }

Member Data Documentation

bool GRINS::BCHandlingBase::_axisymmetric = false

staticprotectedinherited

Flag to cache whether or not there is an axisymmetric boundary present.

Definition at line 170 of file bc_handling_base.h.

Referenced by GRINS::BCHandlingBase::is_axisymmetric(), and GRINS::BCHandlingBase::string_to_int().

GRINS::BoundaryConditions GRINS::BCHandlingBase::_bound_conds

protectedinherited

Object that stashes generic boundary condition types.

Todo:: Move this so that only one object is needed. Perhaps make static?

Definition at line 156 of file bc_handling_base.h.

Referenced by GRINS::AxisymmetricHeatTransferBCHandling::user_apply_neumann_bcs(), GRINS::HeatTransferBCHandling::user_apply_neumann_bcs(), and GRINS::SolidMechanicsBCHandling::user_apply_neumann_bcs().

template<typename Chemistry>

std::multimap<BoundaryID, std::tr1::shared_ptr<CatalyticWallBase<Chemistry> > > GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::_catalytic_walls

protected

Definition at line 98 of file reacting_low_mach_navier_stokes_bc_handling.h.

template<typename Chemistry>

const Chemistry& GRINS::ReactingLowMachNavierStokesBCHandling< Chemistry >::_chemistry

protected

Definition at line 100 of file reacting_low_mach_navier_stokes_bc_handling.h.

std::vector<std::pair<BoundaryID,BCType> > GRINS::BCHandlingBase::_dirichlet_bc_map

protectedinherited

Map between boundary id and Dirichlet boundary condition type.

We need to keep this around because the libMesh::DirichletBoundary objects can't be created until we init the variables. We use a vector of pairs so that the boundary condition functors get added to the libMesh::DofMap in the same order as in the input file.

Definition at line 137 of file bc_handling_base.h.

Referenced by GRINS::BCHandlingBase::get_dirichlet_bc_type(), GRINS::LowMachNavierStokesBCHandling::init_dirichlet_bcs(), GRINS::BCHandlingBase::init_dirichlet_bcs(), and GRINS::BCHandlingBase::set_dirichlet_bc_type().