Parses mole fraction values and converts to mass fractions. More...

#include <constant_function_dirichlet_bc_factory.h>

Inheritance diagram for GRINS::MoleFractionsDirichletBCFactory:

Collaboration diagram for GRINS::MoleFractionsDirichletBCFactory:

Public Member Functions
	MoleFractionsDirichletBCFactory (const std::string &bc_type_name)

	~MoleFractionsDirichletBCFactory ()

Public Member Functions inherited from GRINS::ConstantFunctionDirichletBCFactory
	ConstantFunctionDirichletBCFactory (const std::string &bc_type_name)

	~ConstantFunctionDirichletBCFactory ()

Public Member Functions inherited from GRINS::DirichletBCFactoryFunctionBase< libMesh::FunctionBase< libMesh::Number > >
	DirichletBCFactoryFunctionBase (const std::string &bc_type_name)

	~DirichletBCFactoryFunctionBase ()

Public Member Functions inherited from GRINS::DirichletBCFactoryAbstract
	DirichletBCFactoryAbstract (const std::string &bc_type_name)

	~DirichletBCFactoryAbstract ()

Public Member Functions inherited from GRINS::BCFactoryAbstract< libMesh::DirichletBoundary >
	BCFactoryAbstract (const std::string &bc_type_name)

	~BCFactoryAbstract ()

Public Member Functions inherited from GRINS::FactoryWithGetPot< libMesh::DirichletBoundary >
	FactoryWithGetPot (const std::string &name)

	~FactoryWithGetPot ()

Public Member Functions inherited from GRINS::FactoryAbstract< libMesh::DirichletBoundary >
virtual	~FactoryAbstract ()

Public Member Functions inherited from GRINS::ParsedFunctionFactoryHelper< libMesh::FunctionBase< libMesh::Number > >
	ParsedFunctionFactoryHelper ()

	~ParsedFunctionFactoryHelper ()

Protected Member Functions
virtual void	add_found_vars (const GetPot &input, MultiphysicsSystem &system, const std::string &section, const std::set< std::string > &vars_found, libMesh::CompositeFunction< libMesh::Number > &composite_func, std::set< std::string > &vars_added) const
	Here, we're expected vars_found to correspond to mole fractions and we'll add mass fractions. More...

virtual void	set_vars_to_search_for (const std::string &section, const std::vector< std::string > &var_names, std::vector< std::string > &vars_to_search_for) const
	We'll search for mole fractions: X_<species_name>. More...

template<typename ChemistryType >
void	add_mole_frac_to_mass_frac (const GetPot &input, const std::string &section, const std::set< std::string > &vars_found, const std::string &material, const SpeciesMassFractionsVariable &species_fe_var, libMesh::CompositeFunction< libMesh::Number > &composite_func, std::set< std::string > &vars_added) const

void	extract_species_name (const std::string &var_name, const std::string &prefix, std::string &species_name) const

std::string	extract_var_section (const std::string &section) const

Protected Member Functions inherited from GRINS::ConstantFunctionDirichletBCFactory
virtual libMesh::UniquePtr< libMesh::FunctionBase< libMesh::Number > >	build_func (const GetPot &input, MultiphysicsSystem &system, std::vector< std::string > &var_names, const std::string &section)
	Builds ConstantFunction objects for boundary conditions. More...

Protected Member Functions inherited from GRINS::DirichletBCFactoryFunctionBase< libMesh::FunctionBase< libMesh::Number > >
libMesh::UniquePtr< libMesh::DirichletBoundary >	make_dirichlet_boundary (const std::set< BoundaryID > &bc_ids, const libMesh::System &system, libMesh::UniquePtr< libMesh::FunctionBase< libMesh::Number > > &func, const std::vector< VariableIndex > &var_indices)
	Dispatch, based on FunctionType, to the correct DirchletBoundary construction. More...

virtual const std::vector< std::string > &	get_var_names () const
	Helper function that can be overridded in subclasses. More...

Protected Member Functions inherited from GRINS::DirichletBCFactoryAbstract
void	check_for_vars (const GetPot &input, const std::string &section, const std::vector< std::string > &var_names, std::set< std::string > *vars_found=NULL)
	Helper function. More...

Protected Member Functions inherited from GRINS::BCFactoryAbstract< libMesh::DirichletBoundary >
void	check_for_multiple_expressions (const GetPot &input, const std::string &section, const std::string &var_name) const
	Ensure that there is only one expression for the [Section/var_name] variable. More...

void	build_var_indices (const MultiphysicsSystem &system, const std::vector< std::string > &var_names, std::vector< VariableIndex > &var_indices) const

virtual void	check_state () const
	Helper function to reduce code duplication. More...

virtual void	reset_state ()
	Helper function to redue code duplication. More...

Protected Member Functions inherited from GRINS::FactoryAbstract< libMesh::DirichletBoundary >
	FactoryAbstract (const std::string &name)
	Constructor is protected. Use the build() method to construct Base objects. More...

Protected Member Functions inherited from GRINS::ParsedFunctionFactoryHelper< libMesh::FunctionBase< libMesh::Number > >
libMesh::UniquePtr< libMesh::FunctionBase< libMesh::Number > >	build_parsed_func (const MultiphysicsSystem &system, const std::string &expression)

libMesh::UniquePtr< libMesh::FunctionBase< libMesh::Number > >	build_composite_func ()

Additional Inherited Members
Static Public Member Functions inherited from GRINS::BCFactoryAbstract< libMesh::DirichletBoundary >
static void	set_system (MultiphysicsSystem &system)

static void	set_bc_ids (const std::set< BoundaryID > &bc_ids)
	Boundary id for the current boundary condition section. More...

static void	set_fe_var (const FEVariablesBase &fe_var)
	Active variable for the current boundary condition. More...

static void	set_section (const std::string &section)
	Sets the current section of the input file. More...

static bool	have_bc_type (const std::string &bc_type)

Static Public Member Functions inherited from GRINS::FactoryWithGetPot< libMesh::DirichletBoundary >
static void	set_getpot (const GetPot &input)

Static Public Member Functions inherited from GRINS::FactoryAbstract< libMesh::DirichletBoundary >
static libMesh::UniquePtr< libMesh::DirichletBoundary >	build (const std::string &name)
	Use this method to build objects of type Base. More...

Static Protected Member Functions inherited from GRINS::FactoryAbstract< libMesh::DirichletBoundary >
static FactoryAbstract< libMesh::DirichletBoundary > &	get_factory (const std::string &name)
	Helper method that looks up the factory and returns it if present, or error if it's not. More...

static DerivedType &	get_factory_subclass (const std::string &name)
	Like get_factory, but will downcast to DerivedType. More...

static std::map< std::string, FactoryAbstract< libMesh::DirichletBoundary > * > &	factory_map ()

Static Protected Attributes inherited from GRINS::BCFactoryAbstract< libMesh::DirichletBoundary >
static MultiphysicsSystem *	_system
	We store only a raw pointer here because we can't make a copy. More...

static const std::set< BoundaryID > *	_bc_ids
	BoundaryID for constructing a particular boundary condition. More...

static const FEVariablesBase *	_fe_var
	The FEVariablesBase class associated with the boundary condition being built. More...

static std::string	_section

Static Protected Attributes inherited from GRINS::FactoryWithGetPot< libMesh::DirichletBoundary >
static const GetPot *	_input
	We store only a raw pointer here because we can't make a copy. More...

Detailed Description

Parses mole fraction values and converts to mass fractions.

Only valid for SpeciesMassFraction FEVariables.

Definition at line 95 of file constant_function_dirichlet_bc_factory.h.

Constructor & Destructor Documentation

GRINS::MoleFractionsDirichletBCFactory::MoleFractionsDirichletBCFactory ( const std::string & bc_type_name )

inline

Definition at line 98 of file constant_function_dirichlet_bc_factory.h.

99 : ConstantFunctionDirichletBCFactory(bc_type_name)

100 {}

GRINS::ConstantFunctionDirichletBCFactory::ConstantFunctionDirichletBCFactory

ConstantFunctionDirichletBCFactory(const std::string &bc_type_name)

Definition: constant_function_dirichlet_bc_factory.h:46

GRINS::MoleFractionsDirichletBCFactory::~MoleFractionsDirichletBCFactory ( )

inline

Definition at line 102 of file constant_function_dirichlet_bc_factory.h.

102 {}

Member Function Documentation

void GRINS::MoleFractionsDirichletBCFactory::add_found_vars	(	const GetPot &	input,
		MultiphysicsSystem &	system,
		const std::string &	section,
		const std::set< std::string > &	vars_found,
		libMesh::CompositeFunction< libMesh::Number > &	composite_func,
		std::set< std::string > &	vars_added
	)		const

protectedvirtual

Here, we're expected vars_found to correspond to mole fractions and we'll add mass fractions.

vars_found should have things like X_N, etc. The prefix will be "X_" for mole fractions. Then, we'll add mass fractions, using the corresponding names in the SpeciesMassFractionsVariable. We'll match them based on the species names.

Reimplemented from GRINS::ConstantFunctionDirichletBCFactory.

Definition at line 158 of file constant_function_dirichlet_bc_factory.C.

References GRINS::SpeciesMassFractionsVariable::material().

   {
     // Strip out the Variable name from the section
     std::string var_section = extract_var_section(section);
 
     // This only makes sense for SpeciesMassFractionsVariable in the VariableWarehouse.
     // This call will error out if it's not there.
     const SpeciesMassFractionsVariable& species_fe_var =
       GRINSPrivate::VariableWarehouse::get_variable_subclass<SpeciesMassFractionsVariable>
       (var_section);
 
     const std::string& material = species_fe_var.material();
 
     std::string thermochem_input_str = "Materials/"+material+"/GasMixture/thermochemistry_library";
 
     if( !input.have_variable(thermochem_input_str) )
       libmesh_error_msg("ERROR: Could not find input option "+thermochem_input_str+" !");
 
     const std::string thermochem_lib = input(thermochem_input_str, std::string("DIE!") );
 
     if( thermochem_lib == "cantera" )
       {
 #ifdef GRINS_HAVE_CANTERA
         this->add_mole_frac_to_mass_frac<CanteraMixture>(input,section,vars_found,material,
                                                          species_fe_var,composite_func,vars_added);
 #else
         libmesh_error_msg("Error: Cantera not enabled in this configuration. Reconfigure using --with-cantera option.");
 #endif
       }
     else if( thermochem_lib == "antioch" )
       {
 #ifdef GRINS_HAVE_ANTIOCH
         this->add_mole_frac_to_mass_frac<AntiochChemistry>(input,section,vars_found,material,
                                                            species_fe_var,composite_func,vars_added);
 #else
         libmesh_error_msg("Error: Antioch not enabled in this configuration. Reconfigure using --with-antioch option.");
 #endif
       }
     else
       libmesh_error_msg("ERROR: Invalid thermochemistry library "+thermochem_lib+"!");
   }

template<typename ChemistryType >

template void GRINS::MoleFractionsDirichletBCFactory::add_mole_frac_to_mass_frac< AntiochChemistry >	(	const GetPot &	input,
		const std::string &	section,
		const std::set< std::string > &	vars_found,
		const std::string &	material,
		const SpeciesMassFractionsVariable &	species_fe_var,
		libMesh::CompositeFunction< libMesh::Number > &	composite_func,
		std::set< std::string > &	vars_added
	)		const

protected

Todo:: We should have a ChemsitryWarehouse or something to just grab this from one place instead of rebuilding.

Definition at line 214 of file constant_function_dirichlet_bc_factory.C.

References GRINS::ChemistryBuilder::build_chemistry(), GRINS::SpeciesMassFractionsVariable::prefix(), GRINS::SpeciesMassFractionsVariable::species(), and GRINS::StringUtilities::split_string().

   {
     unsigned int n_vars_found = vars_found.size();
 
     // Parse in all the species mole fracs that are in the input (it is assumed non-specified are 0)
     std::vector<libMesh::Number> species_mole_fracs(n_vars_found);
     libMesh::Number invalid_num = std::numeric_limits<libMesh::Number>::max();
     {
       unsigned int count = 0;
       for(std::set<std::string>::const_iterator var = vars_found.begin();
           var != vars_found.end(); ++var )
         {
           species_mole_fracs[count] = input(section+"/"+(*var),invalid_num);
           count++;
         }
     }
 
     // Make sure mole fracs sum to 1
     libMesh::Number sum = 0.0;
     for(unsigned int v = 0; v < n_vars_found; v++ )
       sum += species_mole_fracs[v];
 
     libMesh::Number tol = std::numeric_limits<libMesh::Number>::epsilon()*10;
     if( std::abs(sum-1.0) > tol )
       libmesh_error_msg("ERROR: Mole fractions do not sum to 1! Found sum = "+StringUtilities::T_to_string<libMesh::Number>(sum));
 
     // Extract species names
     std::vector<std::string> species_names(n_vars_found);
     {
       unsigned int count = 0;
       for(std::set<std::string>::const_iterator var = vars_found.begin();
           var != vars_found.end(); ++var )
         {
           std::vector<std::string> split_name;
           // vars_found should have the form "X_<species name>"
           StringUtilities::split_string((*var),"_",split_name);
           libmesh_assert_equal_to(split_name[0],std::string("X"));
           libmesh_assert_equal_to(split_name.size(),2);
           species_names[count] = split_name[1];
           count++;
         }
     }
 
     // Now convert to mass frac and add to composite function
     ChemistryBuilder chem_builder;
     libMesh::UniquePtr<ChemistryType> chem_ptr;
     chem_builder.build_chemistry(input,material,chem_ptr);
 
     const ChemistryType & chem = *chem_ptr;
 
     libMesh::Real M = 0.0;
     for(unsigned int v = 0; v < n_vars_found; v++ )
       {
         unsigned int s = chem.species_index(species_names[v]);
         M += species_mole_fracs[v]*chem.M(s);
       }
 
     const std::string& prefix = species_fe_var.prefix();
 
     for(unsigned int v = 0; v < n_vars_found; v++ )
       {
         // Finish computing species mass fraction
         unsigned int s = chem.species_index(species_names[v]);
         libMesh::Number species_mass_fracs = species_mole_fracs[v]*chem.M(s)/M;
 
         // Add the function
         std::vector<VariableIndex> var_idx(1,species_fe_var.species(s));
         libMesh::ConstFunction<libMesh::Number> const_func(species_mass_fracs);
         composite_func.attach_subfunction(const_func,var_idx);
 
         // Log that we added this variable
         vars_added.insert(prefix+species_names[v]);
       }
   }

void GRINS::MoleFractionsDirichletBCFactory::extract_species_name	(	const std::string &	var_name,
		const std::string &	prefix,
		std::string &	species_name
	)		const

protected

Definition at line 118 of file constant_function_dirichlet_bc_factory.C.

References GRINS::StringUtilities::split_string().

Referenced by set_vars_to_search_for().

   {
     std::vector<std::string> split_name;
     StringUtilities::split_string(var_name,prefix,split_name);
 
     // split_string won't add the prefix, since it was used as the delimiter, so
     // split_name should just have the lingering species name
     libmesh_assert_equal_to(split_name.size(), 1);
 
     species_name = split_name[0];
   }

std::string GRINS::MoleFractionsDirichletBCFactory::extract_var_section ( const std::string & section ) const

protected

Definition at line 297 of file constant_function_dirichlet_bc_factory.C.

References GRINS::StringUtilities::split_string().

Referenced by set_vars_to_search_for().

   {
     std::vector<std::string> tokens;
     StringUtilities::split_string(section,"/",tokens);
     return tokens.back();
   }

void GRINS::MoleFractionsDirichletBCFactory::set_vars_to_search_for	(	const std::string &	section,
		const std::vector< std::string > &	var_names,
		std::vector< std::string > &	vars_to_search_for
	)		const

protectedvirtual

We'll search for mole fractions: X_<species_name>.

We extract the species name from var_names and then set the corresponding vars_to_search_for to X_<species_name>.

Reimplemented from GRINS::ConstantFunctionDirichletBCFactory.

Definition at line 132 of file constant_function_dirichlet_bc_factory.C.

References extract_species_name(), extract_var_section(), and GRINS::SpeciesMassFractionsVariable::prefix().

   {
     libmesh_assert_equal_to(var_names.size(),vars_to_search_for.size());
 
     // Strip out the Variable name from the section
     std::string var_section = extract_var_section(section);
 
     // This only makes sense for SpeciesMassFractionsVariable in the VariableWarehouse.
     // This call will error out if it's not there.
     const SpeciesMassFractionsVariable& species_fe_var =
       GRINSPrivate::VariableWarehouse::get_variable_subclass<SpeciesMassFractionsVariable>
       (var_section);
 
     const std::string& prefix = species_fe_var.prefix();
     for( unsigned int v = 0; v < var_names.size(); v++ )
       {
         std::string species_name;
         this->extract_species_name(var_names[v],prefix,species_name);
         vars_to_search_for[v] = "X_"+species_name;
       }
   }

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

src/boundary_conditions/include/grins/constant_function_dirichlet_bc_factory.h
src/boundary_conditions/src/constant_function_dirichlet_bc_factory.C

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation