Helper functions for parsing material properties. More...

#include <materials_parsing.h>

Public Member Functions
	MaterialsParsing ()

	~MaterialsParsing ()

Static Public Member Functions
static bool	have_material (const GetPot &input, const std::string &physics)
	Check if Physics/physics section has a material variable. More...

static std::string	material_name (const GetPot &input, const std::string &physics)
	Get the name of the material in the Physics/physics section. More...

static void	viscosity_model (const GetPot &input, const std::string &physics, const std::string &material, std::string &model)
	Parse the viscosity model for the given material. More...

static void	thermal_conductivity_model (const GetPot &input, const std::string &physics, const std::string &material, std::string &model)
	Parse the conductivity model for the given material. More...

static void	specific_heat_model (const GetPot &input, const std::string &physics, const std::string &material, std::string &model)
	Parse the specific heat model for the given material. More...

static void	turb_viscosity_model (const GetPot &input, const std::string &physics, const std::string &material, std::string &model)
	Parse the turbulence viscosity model for the given material. More...

static void	stress_strain_model (const GetPot &input, const std::string &, const std::string &material, std::string &model, std::string &strain_energy)
	Parse the stress-strain model for the given material. More...

static void	read_density (const std::string &core_physics_name, const GetPot &input, ParameterUser &params, libMesh::Real &rho)
	Helper function to reading density from input. More...

static void	read_specific_heat (const std::string &core_physics_name, const GetPot &input, ParameterUser &params, libMesh::Real &cp)
	Helper function to reading scalar specific heat from input. More...

static void	read_property (const GetPot &input, const std::string &old_option, const std::string &property, const std::string &core_physics, ParameterUser &param_user, libMesh::Real &value)
	Helper function for parsing/maintaing backward compatibility. More...

static void	dep_input_warning (const std::string &old_option, const std::string &property)
	Helper function for parsing/maintaing backward compatibility. More...

static void	duplicate_input_test (const GetPot &input, const std::string &option1, const std::string &option2)
	Helper function for parsing/maintaing backward compatibility. More...

static void	check_for_input_option (const GetPot &input, const std::string &option)
	Helper function to check for option and error out if it's not found. More...

static void	parse_chemical_species (const GetPot &input, const std::string &material, std::vector< std::string > &species_names)
	Helper function for parsing the chemical species. More...

static void	parse_species_varnames (const GetPot &input, const std::string &material, const std::string &prefix, std::vector< std::string > &species_names)
	Helper function for parsing the chemical species and setting variable name. More...

static libMesh::Real	parse_lewis_number (const GetPot &input, const std::string &material)

static std::string	parse_chemical_kinetics_datafile_name (const GetPot &input, const std::string &material)

Detailed Description

Helper functions for parsing material properties.

There's no state needed for these functions so we put them in a namespace instead of an object.

Definition at line 42 of file materials_parsing.h.

Constructor & Destructor Documentation

GRINS::MaterialsParsing::MaterialsParsing ( )

inline

Definition at line 45 of file materials_parsing.h.

45 {};

GRINS::MaterialsParsing::~MaterialsParsing ( )

inline

Definition at line 46 of file materials_parsing.h.

46 {};

Member Function Documentation

void GRINS::MaterialsParsing::check_for_input_option	(	const GetPot &	input,
		const std::string &	option
	)

inlinestatic

Helper function to check for option and error out if it's not found.

Definition at line 159 of file materials_parsing.h.

Referenced by GRINS::PhysicsFactoryHelper::parse_antioch_models().

   {
     if( !input.have_variable(option) )
       libmesh_error_msg("ERROR: Could not find required input parameter "+option+"!");
   }

void GRINS::MaterialsParsing::dep_input_warning	(	const std::string &	old_option,
		const std::string &	property
	)

static

Helper function for parsing/maintaing backward compatibility.

Definition at line 436 of file materials_parsing.C.

References grins_warning.

Referenced by GRINS::ConstantConductivity::ConstantConductivity(), GRINS::ConstantPrandtlConductivity::ConstantPrandtlConductivity(), GRINS::ConstantSpecificHeat::ConstantSpecificHeat(), GRINS::HookesLaw::HookesLaw(), GRINS::HookesLaw1D::HookesLaw1D(), GRINS::MooneyRivlin::MooneyRivlin(), parse_chemical_kinetics_datafile_name(), parse_chemical_species(), parse_lewis_number(), GRINS::CanteraMixture::parse_mixture(), GRINS::AverageNusseltNumber::parse_thermal_conductivity(), GRINS::ParsedConductivity::ParsedConductivity(), read_density(), GRINS::BoussinesqBuoyancyBase::read_property(), read_property(), and read_specific_heat().

   {
     std::string warning = "WARNING: Input option "+old_option+" is DEPRECATED!\n";
     warning += "         Please update to use Materials/MATERIAL_NAME/"+property+"\n";
     grins_warning(warning);
   }

void GRINS::MaterialsParsing::duplicate_input_test	(	const GetPot &	input,
		const std::string &	option1,
		const std::string &	option2
	)

static

Helper function for parsing/maintaing backward compatibility.

Definition at line 444 of file materials_parsing.C.

Referenced by GRINS::ViscosityBase::check_input_consistency(), GRINS::ConstantConductivity::ConstantConductivity(), GRINS::ConstantPrandtlConductivity::ConstantPrandtlConductivity(), GRINS::ConstantSpecificHeat::ConstantSpecificHeat(), GRINS::HookesLaw::HookesLaw(), GRINS::HookesLaw1D::HookesLaw1D(), GRINS::MooneyRivlin::MooneyRivlin(), parse_chemical_kinetics_datafile_name(), parse_chemical_species(), parse_lewis_number(), GRINS::AverageNusseltNumber::parse_thermal_conductivity(), GRINS::ParsedConductivity::ParsedConductivity(), read_density(), GRINS::BoussinesqBuoyancyBase::read_property(), read_property(), and read_specific_heat().

   {
     if( input.have_variable(option1) &&
         input.have_variable(option2) )
       {
         libmesh_error_msg("ERROR: Can't specify both "+option1+" and "+option2+"!");
       }
   }

bool GRINS::MaterialsParsing::have_material	(	const GetPot &	input,
		const std::string &	physics
	)

inlinestatic

Check if Physics/physics section has a material variable.

Definition at line 147 of file materials_parsing.h.

Referenced by GRINS::BoussinesqBuoyancyBase::no_input_warning(), GRINS::PhysicsFactoryHelper::parse_conductivity_model(), GRINS::PhysicsFactoryHelper::parse_specific_heat_model(), GRINS::PhysicsFactoryHelper::parse_turb_viscosity_model(), GRINS::PhysicsFactoryHelper::parse_viscosity_model(), and read_density().

   {
     return input.have_variable("Physics/"+physics+"/material");
   }

std::string GRINS::MaterialsParsing::material_name	(	const GetPot &	input,
		const std::string &	physics
	)

inlinestatic

Get the name of the material in the Physics/physics section.

Definition at line 153 of file materials_parsing.h.

Referenced by GRINS::PhysicsFactoryReactingFlows< DerivedPhysics >::build_physics(), GRINS::ConvectionDiffusion::ConvectionDiffusion(), do_transport_eval(), main(), GRINS::PhysicsFactoryHelper::parse_antioch_models(), GRINS::PhysicsFactoryHelper::parse_conductivity_model(), GRINS::PhysicsFactoryHelper::parse_specific_heat_model(), GRINS::PhysicsFactoryHelper::parse_stress_strain_model(), GRINS::PhysicsFactoryHelper::parse_thermochemistry_model(), GRINS::PhysicsFactoryHelper::parse_turb_viscosity_model(), GRINS::PhysicsFactoryHelper::parse_viscosity_model(), GRINS::BoussinesqBuoyancyBase::read_property(), and read_property().

   {
     return input("Physics/"+physics+"/material", "DIE!");
   }

std::string GRINS::MaterialsParsing::parse_chemical_kinetics_datafile_name	(	const GetPot &	input,
		const std::string &	material
	)

static

Definition at line 408 of file materials_parsing.C.

References dep_input_warning(), and duplicate_input_test().

Referenced by GRINS::AntiochMixture< KineticsThermoCurveFit >::AntiochMixture(), GRINS::AntiochMixtureBuilderBase::build_reaction_set(), and GRINS::CanteraMixture::CanteraMixture().

   {
     // Can't specify both old_option and property
     MaterialsParsing::duplicate_input_test(input,
                                            "Physics/Chemistry/chem_file",
                                            "Materials/"+material+"/GasMixture/kinetics_data");
 
     std::string filename;
     if( input.have_variable("Physics/Chemistry/chem_file") )
       {
         MaterialsParsing::dep_input_warning("Physics/Chemistry/chem_file",
                                             "GasMixture/kinetics_data" );
 
         filename = input("Physics/Chemistry/chem_file","DIE!");
       }
     else if( input.have_variable("Materials/"+material+"/GasMixture/kinetics_data") )
       {
         filename = input("Materials/"+material+"/GasMixture/kinetics_data", "DIE!");
       }
     else
       {
         libmesh_error_msg("ERROR: Could not find valid input for kinetics_data!");
       }
 
     return filename;
   }

void GRINS::MaterialsParsing::parse_chemical_species	(	const GetPot &	input,
		const std::string &	material,
		std::vector< std::string > &	species_names
	)

static

Helper function for parsing the chemical species.

The user-provided vector will populated with the chemical species names in the input file. "Physics/Chemistry/species" is deprecated in favor of "Material/"+material+"/GasMixture/species"

Todo:: Make this prefix string an input option

Definition at line 326 of file materials_parsing.C.

References dep_input_warning(), and duplicate_input_test().

Referenced by GRINS::AntiochChemistry::AntiochChemistry(), GRINS::AntiochMixtureBuilderBase::build_chem_mix(), and parse_species_varnames().

   {
     // Clear out anything the user might've put in there.
     species_names.clear();
 
     MaterialsParsing::duplicate_input_test( input,
                                             "Physics/Chemistry/species",
                                             "Materials/"+material+"/GasMixture/species");
 
     std::string species_input;
     if( input.have_variable("Physics/Chemistry/species") )
       {
         MaterialsParsing::dep_input_warning("Physics/Chemistry/species","GasMixture/species");
         species_input = "Physics/Chemistry/species";
       }
     else if( input.have_variable("Materials/"+material+"/GasMixture/species") )
       {
         species_input = "Materials/"+material+"/GasMixture/species";
       }
     else
       {
         libmesh_error_msg("ERROR: Valid input for species not found!");
       }
 
     // Read variable naming info
     unsigned int n_species = input.vector_variable_size(species_input);
 
     species_names.reserve(n_species);
     for( unsigned int i = 0; i < n_species; i++ )
       {
         species_names.push_back( input( species_input, "DIE!", i ) );
       }
   }

libMesh::Real GRINS::MaterialsParsing::parse_lewis_number	(	const GetPot &	input,
		const std::string &	material
	)

static

Definition at line 381 of file materials_parsing.C.

References dep_input_warning(), and duplicate_input_test().

Referenced by GRINS::AntiochConstantTransportMixture< KineticsThermoCurveFit, Conductivity >::AntiochConstantTransportMixture(), GRINS::AntiochConstantTransportMixtureBuilder::build_constant_lewis_diff(), GRINS::AntiochMixtureAveragedTransportMixtureBuilder::specialized_build_diffusivity(), and GRINS::AntiochMixtureAveragedTransportMixture< KineticsThermoCurveFit, Thermo, Viscosity, Conductivity, Diffusivity >::specialized_build_diffusivity().

   {
 
     // Can't specify both old_option and property
     MaterialsParsing::duplicate_input_test(input,
                                            "Physics/Antioch/Le",
                                            "Materials/"+material+"/LewisNumber/value");
 
     libMesh::Real Le = 0.0;
     if( input.have_variable("Physics/Antioch/Le") )
       {
         MaterialsParsing::dep_input_warning("Physics/Antioch/Le", "LewisNumber/value" );
         Le = input("Physics/Antioch/Le", 0.0);
       }
     else if( input.have_variable("Materials/"+material+"/LewisNumber/value") )
       {
         Le = input("Materials/"+material+"/LewisNumber/value", 0.0);
       }
     else
       {
         libmesh_error_msg("ERROR: Could not find value input for LewisNumber!");
       }
 
     return Le;
   }

void GRINS::MaterialsParsing::parse_species_varnames	(	const GetPot &	input,
		const std::string &	material,
		const std::string &	prefix,
		std::vector< std::string > &	species_names
	)

static

Helper function for parsing the chemical species and setting variable name.

The user-provided vector will populated with the chemical species variable names based on the species name the input file. The variable name will used for adding the variable to the libMesh System. "Physics/Chemistry/species" is deprecated in favor of "Material/"+material+"/GasMixture/species"

Definition at line 364 of file materials_parsing.C.

References parse_chemical_species().

Referenced by GRINS::SpeciesVariableFactory< VariableType >::parse_var_names().

   {
     std::vector<std::string> species_names;
     MaterialsParsing::parse_chemical_species(input,material,species_names);
     unsigned int n_species = species_names.size();
     species_varnames.reserve(n_species);
 
     for( unsigned int i = 0; i < n_species; i++ )
       {
         std::string var_name = prefix+species_names[i];
         species_varnames.push_back(var_name);
       }
   }

void GRINS::MaterialsParsing::read_density	(	const std::string &	core_physics_name,
		const GetPot &	input,
		ParameterUser &	params,
		libMesh::Real &	rho
	)

static

Helper function to reading density from input.

In particular, we want to handle backward compatibility before the introduction of material names in the input.

Definition at line 126 of file materials_parsing.C.

References dep_input_warning(), duplicate_input_test(), grins_warning, have_material(), GRINS::PhysicsNaming::incompressible_navier_stokes(), and GRINS::ParameterUser::set_parameter().

Referenced by GRINS::ElasticMembraneBase< StressStrainLaw >::ElasticMembraneBase(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransferBase< Conductivity >::HeatTransferBase(), GRINS::IncompressibleNavierStokesBase< Viscosity >::IncompressibleNavierStokesBase(), and GRINS::AxisymmetricHeatTransfer< Conductivity >::read_input_options().

   {
     bool have_material = MaterialsParsing::have_material(input,core_physics_name);
 
     std::string material = input("Physics/"+core_physics_name+"/material", "DIE!");
 
     // Error if both material/Density and rho are specified
     MaterialsParsing::duplicate_input_test(input,
                                            "Physics/"+core_physics_name+"/rho",
                                            "Materials/"+material+"/Density/value" );
 
     // It's deprecated to have nothing and default to 1.0
     if( !input.have_variable("Physics/"+core_physics_name+"/rho") &&
         !have_material )
       {
         // For some insane reason, we'd originally tied density specifically
         // to PhysicsNaming::incompressible_navier_stokes(), so we'll check for that first.
         if( input.have_variable("Physics/"+PhysicsNaming::incompressible_navier_stokes()+"/rho") )
           {
             std::string warning = "WARNING: neither Physics/"+core_physics_name+"/rho nor\n";
             warning += "         Physics/"+core_physics_name+"/material options were detected.\n";
             warning += "         But we found Physics/"+PhysicsNaming::incompressible_navier_stokes()+"/rho so we using that.\n";
             warning += "        This behavior is DEPRECATED.\n";
             warning += "         Please update and use Physics/"+core_physics_name+"/material.\n";
             grins_warning(warning);
 
             params.set_parameter
               (rho, input,
                "Physics/"+PhysicsNaming::incompressible_navier_stokes()+"/rho", 1.0 /*default*/);
           }
         // Otherwise, the insanity continued and we defaulted to 1.0
         else
           {
             std::string warning = "WARNING: neither Physics/"+core_physics_name+"/rho nor\n";
             warning += "         Physics/"+core_physics_name+"/material  nor\n";
             warning += "         Physics/"+PhysicsNaming::incompressible_navier_stokes()+"/rho options were detected.\n";
             warning += "         We are assuming a density value of 1.0. This is DEPRECATED.\n";
             warning += "         Please update and use Physics/"+core_physics_name+"/material.\n";
             grins_warning(warning);
 
             params.set_parameter
               (rho, input,
                "Physics/"+core_physics_name+"/rho", 1.0 /*default*/);
           }
       }
     // It's deprecated to use rho as the density input
     else if( input.have_variable("Physics/"+core_physics_name+"/rho") )
       {
         MaterialsParsing::dep_input_warning( "Physics/"+core_physics_name+"/rho",
                                              "Density/value" );
 
         params.set_parameter
           (rho, input,
            "Physics/"+core_physics_name+"/rho", 1.0 /*default*/);
       }
 
     // This is the preferred version
     else if( have_material )
       {
         if( !input.have_variable("Materials/"+material+"/Density/value") )
           libmesh_error_msg("ERROR: Could not find Materials/"+material+"/Density/value in input!");
 
         params.set_parameter
           (rho, input,
            "Materials/"+material+"/Density/value", 0.0 /*default*/);
       }
     // Wat?
     else
       libmesh_error();
 
     // Let's make sure we actually got a valid density value
     if( rho <= 0.0 )
       {
         libmesh_error_msg("ERROR: Detected non-positive value of density!");
       }
   }

void GRINS::MaterialsParsing::read_property	(	const GetPot &	input,
		const std::string &	old_option,
		const std::string &	property,
		const std::string &	core_physics,
		ParameterUser &	param_user,
		libMesh::Real &	value
	)

static

Helper function for parsing/maintaing backward compatibility.

This function assumes that one of the old_option or the material-based property input must be specified. If that's not the case, this function should'nt be used. This also assumes that the property value should be positive and will error out if it's not.

Definition at line 286 of file materials_parsing.C.

References dep_input_warning(), duplicate_input_test(), material_name(), and GRINS::ParameterUser::set_parameter().

Referenced by GRINS::ElasticCableAbstract::ElasticCableAbstract(), GRINS::ElasticMembraneBase< StressStrainLaw >::ElasticMembraneBase(), GRINS::ReactingLowMachNavierStokesAbstract::read_input_options(), and GRINS::LowMachNavierStokesBase< Viscosity, SpecificHeat, ThermalConductivity >::read_input_options().

   {
     std::string material = MaterialsParsing::material_name(input,core_physics);
 
     // Can't specify both old_option and property
     MaterialsParsing::duplicate_input_test(input,
                                            old_option,
                                            "Materials/"+material+"/"+property+"/value" );
 
     // Deprecated
     if( input.have_variable(old_option) )
       {
         MaterialsParsing::dep_input_warning( old_option,property+"/value" );
 
         param_user.set_parameter(value, input, old_option, 0.0 /*default*/);
       }
     // Preferred
     else if( input.have_variable("Materials/"+material+"/"+property+"/value" ) )
       {
         param_user.set_parameter
           (value, input, "Materials/"+material+"/"+property+"/value", 0.0 /*default*/);
       }
     // If nothing was set, that's an error
     else
       {
         libmesh_error_msg("ERROR: No valid input found for "+property+"!");
       }
 
     // Make sure value is positive
     if( value <= 0.0 )
       {
         libmesh_error_msg("ERROR: Detected non-positive "+property+"!");
       }
   }

void GRINS::MaterialsParsing::read_specific_heat	(	const std::string &	core_physics_name,
		const GetPot &	input,
		ParameterUser &	params,
		libMesh::Real &	cp
	)

static

Helper function to reading scalar specific heat from input.

In particular, we want to handle backward compatibility before the introduction of material names in the input.

Definition at line 206 of file materials_parsing.C.

References dep_input_warning(), duplicate_input_test(), grins_warning, GRINS::PhysicsNaming::heat_transfer(), and GRINS::ParameterUser::set_parameter().

Referenced by GRINS::BoussinesqBuoyancySPGSMStabilization< Viscosity >::BoussinesqBuoyancySPGSMStabilization(), GRINS::HeatConduction< Conductivity >::HeatConduction(), GRINS::HeatTransferBase< Conductivity >::HeatTransferBase(), and GRINS::AxisymmetricHeatTransfer< Conductivity >::read_input_options().

   {
     std::string material = input("Physics/"+core_physics_name+"/material", "DIE!");
 
     // Error if both material/SpecificHeat and Cp are specified
     MaterialsParsing::duplicate_input_test(input,
                                            "Physics/"+core_physics_name+"/Cp",
                                            "Materials/"+material+"/SpecificHeat/value" );
 
     // It's deprecated to have nothing and default to 1.0
     if( !input.have_variable("Physics/"+core_physics_name+"/Cp") &&
         ( !input.have_variable("Physics/"+core_physics_name+"/material") ||
           !input.have_variable("Materials/"+material+"/SpecificHeat/value") ) )
       {
         // For some insane reason, we'd originally tied Cp specifically
         // to PhysicsNaming::heat_transfer(), so we'll check for that first.
         if( input.have_variable("Physics/"+PhysicsNaming::heat_transfer()+"/Cp") )
           {
             std::string warning = "WARNING: neither Physics/"+core_physics_name+"/Cp nor\n";
             warning += "         Physics/"+core_physics_name+"/material options were detected.\n";
             warning += "         But we found Physics/"+PhysicsNaming::heat_transfer()+"/Cp so we using that.\n";
             warning += "        This behavior is DEPRECATED.\n";
             warning += "         Please update and use Physics/"+core_physics_name+"/material.\n";
             grins_warning(warning);
 
             params.set_parameter
               (cp, input,
                "Physics/"+PhysicsNaming::heat_transfer()+"/Cp", 1.0 /*default*/);
           }
         // Otherwise, the insanity continued and we defaulted to 1.0
         else
           {
             std::string warning = "WARNING: neither Physics/"+core_physics_name+"/Cp nor\n";
             warning += "         Physics/"+core_physics_name+"/material  nor\n";
             warning += "         Physics/"+PhysicsNaming::heat_transfer()+"/Cp options were detected.\n";
             warning += "         We are assuming a specific heat value of 1.0. This is DEPRECATED.\n";
             warning += "         Please update and use Physics/"+core_physics_name+"/material.\n";
             grins_warning(warning);
 
             params.set_parameter
               (cp, input,
                "Physics/"+core_physics_name+"/Cp", 1.0 /*default*/);
           }
       }
 
     // It's deprecated to use Cp as the specific heat input
     if( input.have_variable("Physics/"+core_physics_name+"/Cp") )
       {
         MaterialsParsing::dep_input_warning( "Physics/"+core_physics_name+"/Cp",
                                              "SpecificHeat/value" );
 
         params.set_parameter
           (cp, input,
            "Physics/"+core_physics_name+"/Cp", 1.0 /*default*/);
       }
 
     // This is the preferred version
     if( input.have_variable("Physics/"+core_physics_name+"/material") &&
         input.have_variable("Materials/"+material+"/SpecificHeat/value") )
       {
         // This function only supports reading a constant
         if( input("Materials/"+material+"/SpecificHeat/model", "DIE!") !=
             std::string("constant") )
           libmesh_error_msg("ERROR: Only constant SpecificHeat model supported!");
 
         params.set_parameter
           (cp, input,
            "Materials/"+material+"/SpecificHeat/value", 0.0 /*default*/);
       }
 
     // Let's make sure we actually got a valid density value
     if( cp <= 0.0 )
       {
         libmesh_error_msg("ERROR: Detected non-positive value of cp!");
       }
   }

void GRINS::MaterialsParsing::specific_heat_model	(	const GetPot &	input,
		const std::string &	physics,
		const std::string &	material,
		std::string &	model
	)

static

Parse the specific heat model for the given material.

Definition at line 65 of file materials_parsing.C.

Referenced by GRINS::PhysicsFactoryHelper::parse_specific_heat_model().

   {
     if( !input.have_variable("Materials/"+material+"/SpecificHeat/model") )
       {
         libmesh_error_msg("Error: Could not find Materials/"+material+"/SpecificHeat/model in input file.");
       }
 
     model = input( "Materials/"+material+"/SpecificHeat/model", "DIE!" );
   }

void GRINS::MaterialsParsing::stress_strain_model	(	const GetPot &	input,
		const std::string &	,
		const std::string &	material,
		std::string &	model,
		std::string &	strain_energy
	)

static

Parse the stress-strain model for the given material.

Definition at line 91 of file materials_parsing.C.

References grins_warning.

Referenced by GRINS::PhysicsFactoryHelper::parse_stress_strain_model().

   {
     if( !input.have_variable("Materials/"+material+"/StressStrainLaw/model") )
       {
         libmesh_error_msg("Error: Could not find Materials/"+material+"/StressStrainLaw/model in input file!");
       }
 
     model = input("Materials/"+material+"/StressStrainLaw/model", "DIE!");
     strain_energy = input("Materials/"+material+"/StressStrainLaw/strain_energy", "none");
     // These options are deprecated
     if( model == std::string( "HookesLaw" ) )
       {
         std::string warning = "WARNING: Detected model HookesLaw. This is DEPRECATED!\n";
         warning += "         Please update to use hookes_law.\n";
         grins_warning(warning);
 
         model = std::string("hookes_law");
       }
 
     if( model == std::string( "MooneyRivlin" ) )
       {
         std::string warning = "WARNING: Detected model MooneyRivlin. This is DEPRECATED!\n";
         warning += "         Please update model to use incompressible_hyperelasticity and\n";
         warning += "         set strain_energy to mooney_rivlin.\n";
         grins_warning(warning);
 
         model = std::string("incompressible_hyperelasticity");
         strain_energy = std::string("mooney_rivlin");
       }
   }

void GRINS::MaterialsParsing::thermal_conductivity_model	(	const GetPot &	input,
		const std::string &	physics,
		const std::string &	material,
		std::string &	model
	)

static

Parse the conductivity model for the given material.

Definition at line 50 of file materials_parsing.C.

Referenced by GRINS::PhysicsFactoryHelper::parse_conductivity_model().

   {
     if( !input.have_variable("Materials/"+material+"/ThermalConductivity/model") )
       {
         libmesh_error_msg("Error: Could not find Materials/"+material+"/ThermalConductivity/model in input file.");
       }
 
     model = input( "Materials/"+material+"/ThermalConductivity/model", "DIE!" );
 
     return;
   }

void GRINS::MaterialsParsing::turb_viscosity_model	(	const GetPot &	input,
		const std::string &	physics,
		const std::string &	material,
		std::string &	model
	)

static

Parse the turbulence viscosity model for the given material.

Definition at line 78 of file materials_parsing.C.

Referenced by GRINS::PhysicsFactoryHelper::parse_turb_viscosity_model().

   {
     if( !input.have_variable("Materials/"+material+"/Viscosity/turb_visc_model") )
       {
         libmesh_error_msg("Error: Could not find Materials/"+material+"/Viscosity/turb_visc_model in input file.");
       }
 
     model = input( "Materials/"+material+"/Viscosity/turb_visc_model", "DIE!" );
   }

void GRINS::MaterialsParsing::viscosity_model	(	const GetPot &	input,
		const std::string &	physics,
		const std::string &	material,
		std::string &	model
	)

static

Parse the viscosity model for the given material.

Definition at line 35 of file materials_parsing.C.

Referenced by GRINS::PhysicsFactoryHelper::parse_viscosity_model().

   {
     if( !input.have_variable("Materials/"+material+"/Viscosity/model") )
       {
         libmesh_error_msg("Error: Could not find Materials/"+material+"/Viscosity/model in input file.");
       }
 
     model = input( "Materials/"+material+"/Viscosity/model", "DIE!" );
 
     return;
   }

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

src/properties/include/grins/materials_parsing.h
src/properties/src/materials_parsing.C

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation