#include <physics_factory_reacting_flows.h>

Inheritance diagram for GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >:

Collaboration diagram for GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >:

Public Member Functions
	PhysicsFactoryReactingFlows (const std::string &physics_name, const std::string &core_physics_name)

	~PhysicsFactoryReactingFlows ()

Public Member Functions inherited from GRINS::PhysicsFactoryWithCore
	PhysicsFactoryWithCore (const std::string &physics_name, const std::string &core_physics_name)

	~PhysicsFactoryWithCore ()

Public Member Functions inherited from GRINS::PhysicsFactoryBase
	PhysicsFactoryBase (const std::string &physics_name)

	~PhysicsFactoryBase ()

Public Member Functions inherited from GRINS::FactoryWithGetPotPhysicsName< Physics >
	FactoryWithGetPotPhysicsName (const std::string &name)

	~FactoryWithGetPotPhysicsName ()

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

	~FactoryWithGetPot ()

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

Protected Member Functions
virtual libMesh::UniquePtr< Physics >	build_physics (const GetPot &input, const std::string &physics_name)

void	grins_antioch_model_error_msg (const std::string &viscosity_model, const std::string &conductivity_model, const std::string &diffusivity_model) const

Protected Member Functions inherited from GRINS::PhysicsFactoryWithCore
std::string	find_core_physics_name (const std::string &physics_name)

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

Private Member Functions
void	build_mix_avged_physics (const GetPot &input, const std::string &physics_name, const std::string &material, const std::string &thermo_model, const std::string &diffusivity_model, const std::string &conductivity_model, const std::string &viscosity_model, libMesh::UniquePtr< Physics > &new_physics)

void	build_const_physics (const GetPot &input, const std::string &physics_name, const std::string &material, const std::string &thermo_model, const std::string &diffusivity_model, const std::string &conductivity_model, const std::string &viscosity_model, libMesh::UniquePtr< Physics > &new_physics)

template<typename KineticsThermo , typename Thermo >
void	build_mix_avged_physics_with_thermo (const GetPot &input, const std::string &physics_name, const std::string &material, const std::string &diffusivity_model, const std::string &conductivity_model, const std::string &viscosity_model, libMesh::UniquePtr< Physics > &new_physics)

template<typename KineticsThermo , typename Thermo >
void	build_const_physics_with_thermo (const GetPot &input, const std::string &physics_name, const std::string &material, const std::string &conductivity_model, libMesh::UniquePtr< Physics > &new_physics)

template<typename KineticsThermo , typename Thermo , typename Viscosity , typename Conductivity , typename Diffusivity >
void	build_mix_avged_physics_ptr (const GetPot &input, const std::string &physics_name, const std::string &material, libMesh::UniquePtr< Physics > &new_physics)

template<typename KineticsThermo , typename Thermo , typename Conductivity >
void	build_const_physics_ptr (const GetPot &input, const std::string &physics_name, const std::string &material, libMesh::UniquePtr< Physics > &new_physics)

Additional Inherited Members
Static Public Member Functions inherited from GRINS::FactoryWithGetPotPhysicsName< Physics >
static void	set_physics_name (const std::string &physics_name)
	Setter for physics name. More...

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

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

Static Protected Member Functions inherited from GRINS::PhysicsFactoryWithCore
static std::map< std::string, std::string > &	core_physics_names ()
	Cache for "core" physics names. More...

Static Protected Member Functions inherited from GRINS::FactoryAbstract< Physics >
static FactoryAbstract< Physics > &	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< Physics > * > &	factory_map ()

Static Protected Attributes inherited from GRINS::FactoryWithGetPotPhysicsName< Physics >
static std::string	_physics_name

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

Detailed Description

template<template< typename, typename > class DerivedPhysics>
class GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >

Definition at line 41 of file physics_factory_reacting_flows.h.

Constructor & Destructor Documentation

template<template< typename, typename > class DerivedPhysics>

GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::PhysicsFactoryReactingFlows	(	const std::string &	physics_name,
		const std::string &	core_physics_name
	)

inline

Definition at line 44 of file physics_factory_reacting_flows.h.

46 : PhysicsFactoryWithCore(physics_name,core_physics_name)

47 {}

GRINS::PhysicsFactoryWithCore::PhysicsFactoryWithCore

PhysicsFactoryWithCore(const std::string &physics_name, const std::string &core_physics_name)

Definition: physics_factory_with_core.C:30

template<template< typename, typename > class DerivedPhysics>

GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::~PhysicsFactoryReactingFlows ( )

inline

Definition at line 49 of file physics_factory_reacting_flows.h.

49 {};

Member Function Documentation

template<template< typename, typename > class DerivedPhysics>

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_const_physics	(	const GetPot &	input,
		const std::string &	physics_name,
		const std::string &	material,
		const std::string &	thermo_model,
		const std::string &	diffusivity_model,
		const std::string &	conductivity_model,
		const std::string &	viscosity_model,
		libMesh::UniquePtr< Physics > &	new_physics
	)

private

Definition at line 146 of file physics_factory_reacting_flows.C.

References GRINS::AntiochOptions::cea_nasa_model(), GRINS::AntiochOptions::constant_lewis_diffusivity_model(), GRINS::AntiochOptions::constant_viscosity_model(), and GRINS::AntiochOptions::stat_mech_thermo_model().

   {
     // First check the things we must have for constant transport models
     if( viscosity_model != AntiochOptions::constant_viscosity_model() )
       libmesh_error_msg("Error: For constant transport_model, viscosity model must be constant!");
 
     if( diffusivity_model != AntiochOptions::constant_lewis_diffusivity_model() )
       libmesh_error_msg("Error: For constant transport_model, diffusivity model must be constant_lewis!");
 
 
     if( thermo_model == AntiochOptions::stat_mech_thermo_model() )
       {
         this->build_const_physics_with_thermo<Antioch::CEACurveFit<libMesh::Real>,
                                               Antioch::StatMechThermodynamics<libMesh::Real> >
           (input,physics_name,material,conductivity_model,new_physics);
       }
     else if( thermo_model == AntiochOptions::cea_nasa_model() )
       {
         this->build_const_physics_with_thermo<Antioch::CEACurveFit<libMesh::Real>,
                                               Antioch::IdealGasMicroThermo<Antioch::NASAEvaluator<libMesh::Real,Antioch::CEACurveFit<libMesh::Real> > > >
           (input,physics_name,material,conductivity_model,new_physics);
       }
     else
       this->grins_antioch_model_error_msg(viscosity_model,conductivity_model,diffusivity_model);
   }

template<template< typename, typename > class DerivedPhysics>

template<typename KineticsThermo , typename Thermo , typename Conductivity >

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_const_physics_ptr	(	const GetPot &	input,
		const std::string &	physics_name,
		const std::string &	material,
		libMesh::UniquePtr< Physics > &	new_physics
	)

inlineprivate

Definition at line 161 of file physics_factory_reacting_flows.h.

References GRINS::AntiochConstantTransportMixtureBuilder::build_mixture().

     {
       AntiochConstantTransportMixtureBuilder mix_builder;
 
       libMesh::UniquePtr<GRINS::AntiochConstantTransportMixture<KineticsThermo,Conductivity> >
         gas_mixture = mix_builder.build_mixture<KineticsThermo,Conductivity>(input,material);
 
       new_physics.reset(new DerivedPhysics<AntiochConstantTransportMixture<KineticsThermo,Conductivity>,
                         AntiochConstantTransportEvaluator<KineticsThermo,Thermo,Conductivity> >
                         (physics_name,input,gas_mixture) );
     }

template<template< typename, typename > class DerivedPhysics>

template<typename KineticsThermo , typename Thermo >

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_const_physics_with_thermo	(	const GetPot &	input,
		const std::string &	physics_name,
		const std::string &	material,
		const std::string &	conductivity_model,
		libMesh::UniquePtr< Physics > &	new_physics
	)

inlineprivate

Definition at line 122 of file physics_factory_reacting_flows.h.

References GRINS::AntiochOptions::constant_conductivity_model(), and GRINS::AntiochOptions::constant_prandtl_conductivity_model().

     {
       if( conductivity_model == AntiochOptions::constant_conductivity_model() )
         {
           this->build_const_physics_ptr<KineticsThermo,Thermo,ConstantConductivity>
             (input,physics_name,material,new_physics);
         }
       else if( conductivity_model == AntiochOptions::constant_prandtl_conductivity_model() )
         {
           this->build_const_physics_ptr<KineticsThermo,Thermo,ConstantPrandtlConductivity>
             (input,physics_name,material,new_physics);
         }
       else
         {
           std::string error = "ERROR: Invalid conductivity model for constant transport!\n";
           error += "       Valid choices are "+AntiochOptions::constant_conductivity_model()+"\n";
           error += "                         "+AntiochOptions::constant_prandtl_conductivity_model()+"\n";
 
           libmesh_error_msg(error);
         }
     }

template<template< typename, typename > class DerivedPhysics>

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_mix_avged_physics	(	const GetPot &	input,
		const std::string &	physics_name,
		const std::string &	material,
		const std::string &	thermo_model,
		const std::string &	diffusivity_model,
		const std::string &	conductivity_model,
		const std::string &	viscosity_model,
		libMesh::UniquePtr< Physics > &	new_physics
	)

private

Definition at line 115 of file physics_factory_reacting_flows.C.

References GRINS::AntiochOptions::cea_nasa_model(), and GRINS::AntiochOptions::stat_mech_thermo_model().

   {
     if( (thermo_model == AntiochOptions::stat_mech_thermo_model()) )
       {
         this->build_mix_avged_physics_with_thermo<Antioch::CEACurveFit<libMesh::Real>,
                                                   Antioch::StatMechThermodynamics<libMesh::Real> >
           (input,physics_name,material,diffusivity_model,
            conductivity_model,viscosity_model,
            new_physics);
       }
     else if( (thermo_model == AntiochOptions::cea_nasa_model()) )
       {
         this->build_mix_avged_physics_with_thermo<Antioch::CEACurveFit<libMesh::Real>,
                                                   Antioch::IdealGasMicroThermo<Antioch::NASAEvaluator<libMesh::Real, Antioch::CEACurveFit<libMesh::Real> >, libMesh::Real> >
           (input,physics_name,material,diffusivity_model,
            conductivity_model,viscosity_model,
            new_physics);
       }
     else
       {
         std::string error = "Error: Unknown Antioch thermo model "+thermo_model+"\n";
         error += "       Valid values are: "+AntiochOptions::stat_mech_thermo_model()+"\n";
         error += "       Valid values are: "+AntiochOptions::cea_nasa_model()+"\n";
       }
   }

template<template< typename, typename > class DerivedPhysics>

template<typename KineticsThermo , typename Thermo , typename Viscosity , typename Conductivity , typename Diffusivity >

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_mix_avged_physics_ptr	(	const GetPot &	input,
		const std::string &	physics_name,
		const std::string &	material,
		libMesh::UniquePtr< Physics > &	new_physics
	)

inlineprivate

Definition at line 147 of file physics_factory_reacting_flows.h.

References GRINS::AntiochMixtureAveragedTransportMixtureBuilder::build_mixture().

Referenced by GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_mix_avged_physics_with_thermo().

     {
       AntiochMixtureAveragedTransportMixtureBuilder mix_builder;
 
       libMesh::UniquePtr<AntiochMixtureAveragedTransportMixture<KineticsThermo,Thermo,Viscosity,Conductivity,Diffusivity> >
         gas_mixture = mix_builder.build_mixture<KineticsThermo,Thermo,Viscosity,Conductivity,Diffusivity>(input,material);
 
       new_physics.reset(new DerivedPhysics<AntiochMixtureAveragedTransportMixture<KineticsThermo,Thermo,Viscosity,Conductivity,Diffusivity>,
                         AntiochMixtureAveragedTransportEvaluator<KineticsThermo,Thermo,Viscosity,Conductivity,Diffusivity> >
                         (physics_name,input,gas_mixture) );
     }

template<template< typename, typename > class DerivedPhysics>

template<typename KineticsThermo , typename Thermo >

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_mix_avged_physics_with_thermo	(	const GetPot &	input,
		const std::string &	physics_name,
		const std::string &	material,
		const std::string &	diffusivity_model,
		const std::string &	conductivity_model,
		const std::string &	viscosity_model,
		libMesh::UniquePtr< Physics > &	new_physics
	)

inlineprivate

Definition at line 76 of file physics_factory_reacting_flows.h.

References GRINS::AntiochOptions::blottner_viscosity_model(), GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_mix_avged_physics_ptr(), GRINS::AntiochOptions::constant_lewis_diffusivity_model(), GRINS::AntiochOptions::eucken_conductivity_model(), GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::grins_antioch_model_error_msg(), GRINS::AntiochOptions::kinetic_theory_conductivity_model(), GRINS::AntiochOptions::kinetic_theory_diffusivity_model(), GRINS::AntiochOptions::kinetic_theory_viscosity_model(), and GRINS::AntiochOptions::sutherland_viscosity_model().

     {
       if( (diffusivity_model == AntiochOptions::constant_lewis_diffusivity_model()) &&
           (conductivity_model == AntiochOptions::eucken_conductivity_model()) &&
           (viscosity_model == AntiochOptions::sutherland_viscosity_model()) )
         {
           this->build_mix_avged_physics_ptr<KineticsThermo,
                                             Thermo,
                                             Antioch::SutherlandViscosity<libMesh::Real>,
                                             Antioch::EuckenThermalConductivity<Thermo>,
                                             Antioch::ConstantLewisDiffusivity<libMesh::Real> >(input,physics_name,material,new_physics);
         }
       else if( (diffusivity_model == AntiochOptions::constant_lewis_diffusivity_model()) &&
                (conductivity_model == AntiochOptions::eucken_conductivity_model()) &&
                (viscosity_model == AntiochOptions::blottner_viscosity_model()) )
         {
           this->build_mix_avged_physics_ptr<KineticsThermo,
                                             Thermo,
                                             Antioch::BlottnerViscosity<libMesh::Real>,
                                             Antioch::EuckenThermalConductivity<Thermo>,
                                             Antioch::ConstantLewisDiffusivity<libMesh::Real> >(input,physics_name,material,new_physics);
         }
       else if( (diffusivity_model == AntiochOptions::kinetic_theory_diffusivity_model()) &&
                (conductivity_model == AntiochOptions::kinetic_theory_conductivity_model()) &&
                (viscosity_model == AntiochOptions::kinetic_theory_viscosity_model()) )
         {
 #ifdef ANTIOCH_HAVE_GSL
           this->build_mix_avged_physics_ptr<KineticsThermo,
                                             Thermo,
                                             Antioch::KineticsTheoryViscosity<libMesh::Real,Antioch::GSLSpliner>,
                                             Antioch::KineticsTheoryThermalConductivity<Thermo,libMesh::Real>,
                                             Antioch::MolecularBinaryDiffusion<libMesh::Real,Antioch::GSLSpliner> >(input,physics_name,material,new_physics);
 #else
           libmesh_error_msg("ERROR: Antioch requires GSL in order to use kinetics theory based models!");
 #endif // ANTIOCH_HAVE_GSL
         }
       else
         this->grins_antioch_model_error_msg(viscosity_model,conductivity_model,diffusivity_model);
     }

template<template< typename, typename > class DerivedPhysics>

libMesh::UniquePtr< Physics > GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_physics	(	const GetPot &	input,
		const std::string &	physics_name
	)

protectedvirtual

Implements GRINS::PhysicsFactoryBase.

Definition at line 27 of file physics_factory_reacting_flows.C.

References GRINS::AntiochOptions::constant_transport_model(), GRINS::MaterialsParsing::material_name(), GRINS::AntiochOptions::mix_avged_transport_model(), GRINS::PhysicsFactoryHelper::parse_antioch_models(), and GRINS::PhysicsFactoryHelper::parse_thermochemistry_model().

   {
     std::string core_physics = this->find_core_physics_name(physics_name);
 
     std::string material = MaterialsParsing::material_name(input,core_physics);
 
     std::string thermochem_lib;
     PhysicsFactoryHelper::parse_thermochemistry_model( input,
                                                        core_physics,
                                                        thermochem_lib );
 
     libMesh::UniquePtr<Physics> new_physics;
 
     if( thermochem_lib == "cantera" )
       {
 #ifdef GRINS_HAVE_CANTERA
         libMesh::UniquePtr<CanteraMixture> gas_mix( new CanteraMixture(input,material) );
 
         new_physics.reset(new DerivedPhysics<CanteraMixture,CanteraEvaluator>(physics_name,input,gas_mix));
 #else
         libmesh_error_msg("Error: Cantera not enabled in this configuration. Reconfigure using --with-cantera option.");
 
 #endif // GRINS_HAVE_CANTERA
       }
 
     else if( thermochem_lib == "antioch" )
       {
 #ifdef GRINS_HAVE_ANTIOCH
 
         std::string transport_model;
         std::string thermo_model;
         std::string viscosity_model;
         std::string conductivity_model;
         std::string diffusivity_model;
 
         PhysicsFactoryHelper::parse_antioch_models( input,
                                                     core_physics,
                                                     transport_model,
                                                     thermo_model,
                                                     viscosity_model,
                                                     conductivity_model,
                                                     diffusivity_model );
 
         if( transport_model == AntiochOptions::mix_avged_transport_model() )
           {
             this->build_mix_avged_physics( input, physics_name, material, thermo_model, diffusivity_model,
                                            conductivity_model, viscosity_model, new_physics );
           }
 
         else if( transport_model == AntiochOptions::constant_transport_model() )
           {
             this->build_const_physics( input, physics_name, material, thermo_model, diffusivity_model,
                                        conductivity_model, viscosity_model, new_physics );
           }
         else // transport_model
           {
             std::string error = "Error: Unknown Antioch transport_model "+transport_model+"!\n";
             error += "       Valid values are: "+AntiochOptions::constant_transport_model()+"\n";
             error += "                         "+AntiochOptions::mix_avged_transport_model()+"\n";
 
             libmesh_error_msg(error);
           }
 #else
         libmesh_error_msg("Error: Antioch not enabled in this configuration. Reconfigure using --with-antioch option.");
 
 #endif // GRINS_HAVE_ANTIOCH
       }
 
     else
       {
         std::string error = "Error: Invalid thermo-chemistry library"+thermochem_lib+"!\n";
         error += "       Valid values are: antioch\n";
         error += "                         cantera\n";
 
         libmesh_error_msg(error);
       }
 
     libmesh_assert(new_physics);
 
     return new_physics;
   }

template<template< typename, typename > class DerivedPhysics>

void GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::grins_antioch_model_error_msg	(	const std::string &	viscosity_model,
		const std::string &	conductivity_model,
		const std::string &	diffusivity_model
	)		const

protected

Definition at line 178 of file physics_factory_reacting_flows.C.

Referenced by GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_mix_avged_physics_with_thermo().

   {
     std::string error = "Error: Unknown Antioch model combination:\n";
     error += "viscosity_model    = "+viscosity_model+"\n";
     error += "conductivity_model = "+conductivity_model+"\n";
     error += "diffusivity_model = "+diffusivity_model+"\n";
 
     libmesh_error_msg(error);
   }

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

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

Public Member Functions

Protected Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

template<template< typename, typename > class DerivedPhysics> class GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >

Constructor & Destructor Documentation

Member Function Documentation

template<template< typename, typename > class DerivedPhysics>
class GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >