void MultiphysicsSystem::read_input_options( const GetPot& input )
{
// Cache this for building boundary condition later
_input = &input;
// Read options for MultiphysicsSystem first
this->verify_analytic_jacobians = input("linear-nonlinear-solver/verify_analytic_jacobians", 0.0 );
this->print_solution_norms = input("screen-options/print_solution_norms", false );
this->print_solutions = input("screen-options/print_solutions", false );
this->print_residual_norms = input("screen-options/print_residual_norms", false );
// backwards compatibility with old config files.
/*! \todo Remove old print_residual nomenclature */
this->print_residuals = input("screen-options/print_residual", false );
if (this->print_residuals)
libmesh_deprecated();
this->print_residuals = input("screen-options/print_residuals", this->print_residuals );
this->print_jacobian_norms = input("screen-options/print_jacobian_norms", false );
this->print_jacobians = input("screen-options/print_jacobians", false );
this->print_element_solutions = input("screen-options/print_element_solutions", false );
this->print_element_residuals = input("screen-options/print_element_residuals", false );
this->print_element_jacobians = input("screen-options/print_element_jacobians", false );
_use_numerical_jacobians_only = input("linear-nonlinear-solver/use_numerical_jacobians_only", false );
numerical_jacobian_h =
input("linear-nonlinear-solver/numerical_jacobian_h",
numerical_jacobian_h);
const unsigned int n_numerical_jacobian_h_values =
input.vector_variable_size
("linear-nonlinear-solver/numerical_jacobian_h_values");
if (n_numerical_jacobian_h_values !=
input.vector_variable_size
("linear-nonlinear-solver/numerical_jacobian_h_variables"))
{
std::cerr << "Error: found " << n_numerical_jacobian_h_values
<< " numerical_jacobian_h_values" << std::endl;
std::cerr << " but "
<< input.vector_variable_size
("linear-nonlinear-solver/numerical_jacobian_h_variables")
<< " numerical_jacobian_h_variables" << std::endl;
libmesh_error();
}
_numerical_jacobian_h_variables.resize(n_numerical_jacobian_h_values);
_numerical_jacobian_h_values.resize(n_numerical_jacobian_h_values);
for (unsigned int i=0; i != n_numerical_jacobian_h_values; ++i)
{
_numerical_jacobian_h_variables[i] =
input("linear-nonlinear-solver/numerical_jacobian_h_variables",
"", i);
_numerical_jacobian_h_values[i] =
input("linear-nonlinear-solver/numerical_jacobian_h_values",
libMesh::Real(0), i);
}
}
void ICHandlingBase::read_ic_data( const GetPot& input, const std::string& id_str,
const std::string& ic_str,
const std::string& var_str,
const std::string& value_str)
{
int num_ids = input.vector_variable_size(id_str);
int num_ics = input.vector_variable_size(ic_str);
int num_vars = input.vector_variable_size(var_str);
int num_values = input.vector_variable_size(value_str);
if( num_ids != num_ics )
{
std::cerr << "Error: number of subdomain ids " << num_ids
<< "must equal number of initial condition types " << num_ics
<< std::endl;
libmesh_error();
}
if( num_ids != num_vars )
{
std::cerr << "Error: number of subdomain ids " << num_ids
<< "must equal number of variable name lists " << num_vars
<< std::endl;
libmesh_error();
}
if( num_ids != num_values )
{
std::cerr << "Error: number of subdomain ids " << num_ids
<< "must equal number of initial condition values " << num_values
<< std::endl;
libmesh_error();
}
if( num_ids > 1 )
{
std::cerr << "Error: GRINS does not yet support per-subdomain initial conditions" << std::endl;
libmesh_not_implemented();
}
for( int i = 0; i < num_ids; i++ )
{
int ic_id = input(id_str, -1, i );
std::string ic_type_in = input(ic_str, "NULL", i );
std::string ic_value_in = input(value_str, "NULL", i );
std::string ic_vars_in = input(var_str, "NULL", i );
int ic_type = this->string_to_int( ic_type_in );
std::stringstream ss;
ss << ic_id;
std::string ic_id_string = ss.str();
this->init_ic_types( ic_id, ic_id_string, ic_type, ic_vars_in, ic_value_in, input );
}
return;
}
void Simulation::init_params( const GetPot& input,
SimulationBuilder& /*sim_builder*/ )
{
unsigned int n_adjoint_parameters =
input.vector_variable_size("QoI/adjoint_sensitivity_parameters");
unsigned int n_forward_parameters =
input.vector_variable_size("QoI/forward_sensitivity_parameters");
// If the user actually asks for parameter sensitivities, then we
// set up the parameter vectors to use.
if ( n_adjoint_parameters )
{
// If we're doing adjoint sensitivities, dq/dp only makes
// sense if we have q
CompositeQoI* qoi =
libMesh::cast_ptr<CompositeQoI*>
(this->_multiphysics_system->get_qoi());
if (!qoi)
{
std::cout <<
"Error: adjoint_sensitivity_parameters are specified but\n"
<< "no QoIs have been specified.\n" << std::endl;
libmesh_error();
}
_adjoint_parameters.initialize
(input, "QoI/adjoint_sensitivity_parameters",
*this->_multiphysics_system, qoi);
}
if ( n_forward_parameters )
{
// If we're doing forward sensitivities, du/dp can make
// sense even with no q defined
CompositeQoI* qoi =
dynamic_cast<CompositeQoI*>
(this->_multiphysics_system->get_qoi());
// dynamic_cast returns NULL if our QoI isn't a CompositeQoI;
// i.e. if there were no QoIs that made us bother setting up
// the CompositeQoI object. Passing NULL tells
// ParameterManager not to bother asking for qoi registration
// of parameters.
_forward_parameters.initialize
(input, "QoI/forward_sensitivity_parameters",
*this->_multiphysics_system, qoi);
}
}
void ParsedBoundaryQoI::init( const GetPot& input, const MultiphysicsSystem& system )
{
// Read boundary ids on which we want to compute qoi
int num_bcs = input.vector_variable_size("QoI/ParsedBoundary/bc_ids");
if( num_bcs <= 0 )
{
std::cerr << "Error: Must specify at least one boundary id to compute"
<< " parsed boundary QoI." << std::endl
<< "Found: " << num_bcs << std::endl;
libmesh_error();
}
for( int i = 0; i < num_bcs; i++ )
{
_bc_ids.insert( input("QoI/ParsedBoundary/bc_ids", -1, i ) );
}
std::string qoi_functional_string =
input("QoI/ParsedBoundary/qoi_functional", std::string("0"));
if (qoi_functional_string == "0")
libmesh_error_msg("Error! Zero ParsedBoundaryQoI specified!" <<
std::endl);
this->qoi_functional.reset
(new libMesh::ParsedFEMFunction<libMesh::Number>
(system, qoi_functional_string));
}
void AverageNusseltNumber::read_input_options( const GetPot& input )
{
// Read thermal conductivity
this->_k = input( "QoI/NusseltNumber/thermal_conductivity", -1.0 );
if( this->_k < 0.0 )
{
std::cerr << "Error: thermal conductivity for AverageNusseltNumber must be positive." << std::endl
<< "Found k = " << _k << std::endl;
libmesh_error();
}
// Read boundary ids for which we want to compute
int num_bcs = input.vector_variable_size("QoI/NusseltNumber/bc_ids");
if( num_bcs <= 0 )
{
std::cerr << "Error: Must specify at least one boundary id to compute"
<< " average Nusselt number." << std::endl
<< "Found: " << num_bcs << std::endl;
libmesh_error();
}
for( int i = 0; i < num_bcs; i++ )
{
_bc_ids.insert( input("QoI/NusseltNumber/bc_ids", -1, i ) );
}
this->_scaling = input( "QoI/NusseltNumber/scaling", 1.0 );
return;
}
void AdaptiveTimeSteppingOptions::parse_options(const GetPot& input, const std::string& section)
{
// If the user set the target tolerance, for them to set the other values too
if( input.have_variable(section+"/target_tolerance") )
{
if( !input.have_variable(section+"/upper_tolerance") )
libmesh_error_msg("ERROR: Must specify "+section+"/upper_tolerance for adaptive time stepping!");
if( !input.have_variable(section+"/max_growth") )
libmesh_error_msg("ERROR: Must specify "+section+"/max_growth for adaptive time stepping!");
}
_target_tolerance = input(section+"/target_tolerance", 0.0 );
_upper_tolerance = input(section+"/upper_tolerance", 0.0 );
_max_growth = input(section+"/max_growth", 0.0 );
// parse component_norm
const unsigned int n_component_norm =
input.vector_variable_size(section+"/component_norm");
for (unsigned int i=0; i != n_component_norm; ++i)
{
const std::string current_norm = input(section+"/component_norm", std::string("L2"), i);
_component_norm.set_type(i, libMesh::Utility::string_to_enum<libMesh::FEMNormType>(current_norm) );
}
}
void QoIFactory::check_qoi_physics_consistency( const GetPot& input,
const std::string& qoi_name )
{
int num_physics = input.vector_variable_size("Physics/enabled_physics");
// This should be checked other places, but let's be double sure.
libmesh_assert(num_physics > 0);
std::set<std::string> requested_physics;
std::set<std::string> required_physics;
// Build Physics name set
for( int i = 0; i < num_physics; i++ )
{
requested_physics.insert( input("Physics/enabled_physics", "NULL", i ) );
}
/* If it's Nusselt, we'd better have HeatTransfer or LowMachNavierStokes.
HeatTransfer implicitly requires fluids, so no need to check for those. `*/
if( qoi_name == avg_nusselt )
{
required_physics.insert(heat_transfer);
required_physics.insert(low_mach_navier_stokes);
this->consistency_helper( requested_physics, required_physics, qoi_name );
}
return;
}
void SourceTermBase::parse_var_info( const GetPot& input )
{
if( !input.have_variable("Physics/"+this->_physics_name+"/Variables/names") )
{
libMesh::err << "Error: Must have at least one variable for source function." << std::endl
<< " Ensure that Physics/"+this->_physics_name+"/Variables/names is set." << std::endl;
libmesh_error();
}
unsigned int n_vars = input.vector_variable_size("Physics/"+this->_physics_name+"/Variables/names");
// Make sure we have consisent number of FE types and FE orders
/*! \todo In the future, after refactoring Variable parsing, we should be
able get the FE type and order information from there. */
unsigned int n_fe_types = input.vector_variable_size("Physics/"+this->_physics_name+"/Variables/FE_types");
unsigned int n_fe_orders = input.vector_variable_size("Physics/"+this->_physics_name+"/Variables/FE_orders");
if( n_fe_types != n_vars )
{
libMesh::err << "Error: Must have matching number of variable names and FE types." << std::endl
<< " Found " << n_fe_types << " FE types and " << n_vars << " variables." << std::endl
<< " Ensure Physics/"+this->_physics_name+"/Variables/FE_types is consistent." << std::endl;
libmesh_error();
}
if( n_fe_orders != n_vars )
{
libMesh::err << "Error: Must have matching number of variable names and FE orders." << std::endl
<< " Found " << n_fe_orders << " FE orders and " << n_vars << " variables." << std::endl
<< " Ensure Physics/"+this->_physics_name+"/Variables/FE_orders is consistent." << std::endl;
libmesh_error();
}
_var_names.reserve(n_vars);
_var_FE.reserve(n_vars);
_var_order.reserve(n_vars);
for( unsigned int v = 0; v < n_vars; v++ )
{
_var_names.push_back( input("Physics/"+this->_physics_name+"/Variables/names", "DIE!", v) );
_var_FE.push_back( libMesh::Utility::string_to_enum<GRINSEnums::FEFamily>(input("Physics/"+this->_physics_name+"/Variables/FE_types", "DIE!", v)) );
_var_order.push_back( libMesh::Utility::string_to_enum<GRINSEnums::Order>(input("Physics/"+this->_physics_name+"/Variables/FE_orders", "DIE!", v)) );
}
return;
}
PostProcessedQuantities<NumericType>::PostProcessedQuantities( const GetPot& input )
: libMesh::FEMFunctionBase<NumericType>(),
_prev_point(1.0e15,0.0,0.0) //Initialize to an absurd value
{
this->build_name_map();
/* Parse the quantities requested for postprocessing and cache the
corresponding enum value */
unsigned int n_quantities = input.vector_variable_size( "vis-options/output_vars" );
std::vector<std::string> names(n_quantities);
_quantities.resize(n_quantities);
for( unsigned int n = 0; n < n_quantities; n++ )
{
names[n] = input("vis-options/output_vars", "DIE!", n);
typename std::map<std::string, unsigned int>::const_iterator name_it =
_quantity_name_map.find(names[n]);
if( name_it != _quantity_name_map.end() )
{
_quantities[n] = name_it->second;
}
else
{
std::cerr << "Error: Invalid name " << names[n] << " for PostProcessedQuantity."
<< std::endl;
libmesh_error();
}
// Need to cache species names if needed.
if( names[n] == std::string("mole_fractions") )
{
unsigned int species_size = input.vector_variable_size( "Physics/Chemistry/species" );
_species_names.resize(species_size);
for( unsigned int s = 0; s < species_size; s++ )
{
_species_names[s] = input("Physics/Chemistry/species","DIE!",s);
}
}
}
return;
}
void
BCInterfaceData::readParameters( const GetPot& dataFile, const char* parameters )
{
UInt parametersSize = dataFile.vector_variable_size( parameters );
M_parameters.resize( parametersSize );
for ( UInt j( 0 ); j < parametersSize; ++j )
M_parameters[j] = dataFile( parameters, 0, j );
}
void OldStyleBCBuilder::build_periodic_bc( const GetPot& input,
const std::string& section,
BoundaryID bc_id,
libMesh::DofMap& dof_map )
{
std::string wall_input = section+"/periodic_wall_";
wall_input += StringUtilities::T_to_string<BoundaryID>(bc_id);
if( input.have_variable(wall_input) )
{
libMesh::boundary_id_type invalid_bid =
std::numeric_limits<libMesh::boundary_id_type>::max();
libMesh::boundary_id_type slave_id = invalid_bid;
libMesh::boundary_id_type master_id = invalid_bid;
if( input.vector_variable_size(wall_input) != 2 )
libmesh_error_msg("ERROR: "+wall_input+" must have only 2 components!");
master_id = bc_id;
if( input(wall_input,invalid_bid,0) == bc_id )
slave_id = input(wall_input,invalid_bid,1);
else
slave_id = input(wall_input,invalid_bid,0);
std::string offset_input = section+"/periodic_offset_";
offset_input += StringUtilities::T_to_string<BoundaryID>(bc_id);
if( !input.have_variable(offset_input) )
libmesh_error_msg("ERROR: Could not find "+offset_input+"!");
unsigned int n_comps = input.vector_variable_size(offset_input);
libMesh::Real invalid_real = std::numeric_limits<libMesh::Real>::max();
libMesh::RealVectorValue offset_vector;
for( unsigned int i = 0; i < n_comps; i++ )
offset_vector(i) = input(offset_input,invalid_real,i);
this->add_periodic_bc_to_dofmap( master_id, slave_id,
offset_vector, dof_map );
}
}
void VelocityPenalty<Mu>::register_postprocessing_vars( const GetPot& input,
PostProcessedQuantities<libMesh::Real>& postprocessing )
{
std::string section = "Physics/"+this->_physics_name+"/output_vars";
std::string vel_penalty = "vel_penalty";
if (this->_physics_name == "VelocityPenalty2")
vel_penalty += '2';
if (this->_physics_name == "VelocityPenalty3")
vel_penalty += '3';
if( input.have_variable(section) )
{
unsigned int n_vars = input.vector_variable_size(section);
for( unsigned int v = 0; v < n_vars; v++ )
{
std::string name = input(section,"DIE!",v);
if( name == std::string("velocity_penalty") )
{
_velocity_penalty_x_index =
postprocessing.register_quantity( vel_penalty+"_x" );
_velocity_penalty_y_index =
postprocessing.register_quantity( vel_penalty+"_y" );
_velocity_penalty_z_index =
postprocessing.register_quantity( vel_penalty+"_z" );
}
else if( name == std::string("velocity_penalty_base") )
{
_velocity_penalty_base_x_index =
postprocessing.register_quantity( vel_penalty+"_base_x" );
_velocity_penalty_base_y_index =
postprocessing.register_quantity( vel_penalty+"_base_y" );
_velocity_penalty_base_z_index =
postprocessing.register_quantity( vel_penalty+"_base_z" );
}
else
{
std::cerr << "Error: Invalue output_vars value for "+this->_physics_name << std::endl
<< " Found " << name << std::endl
<< " Acceptable values are: velocity_penalty" << std::endl
<< " velocity_penalty_base" << std::endl;
libmesh_error();
}
}
}
return;
}
void HeatTransferBCHandling::init_bc_types( const 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 )
{
switch(bc_type)
{
case(ISOTHERMAL_WALL):
{
this->set_dirichlet_bc_type( bc_id, bc_type );
this->set_dirichlet_bc_value( bc_id, input("Physics/"+_physics_name+"/T_wall_"+bc_id_string, 0.0 ) );
}
break;
case(ADIABATIC_WALL):
{
this->set_neumann_bc_type( bc_id, bc_type );
}
break;
case(PRESCRIBED_HEAT_FLUX):
{
this->set_neumann_bc_type( bc_id, bc_type );
libMesh::RealGradient q_in;
int num_q_components = input.vector_variable_size("Physics/"+_physics_name+"/q_wall_"+bc_id_string);
for( int i = 0; i < num_q_components; i++ )
{
q_in(i) = input("Physics/"+_physics_name+"/q_wall_"+bc_id_string, 0.0, i );
}
this->set_neumann_bc_value( bc_id, q_in );
}
break;
case(GENERAL_HEAT_FLUX):
{
this->set_neumann_bc_type( bc_id, bc_type );
}
break;
default:
{
// Call base class to detect any physics-common boundary conditions
BCHandlingBase::init_bc_types( bc_id, bc_id_string, bc_type,
bc_vars, bc_value, input );
}
}// End switch(bc_type)
return;
}
// ===================================================
// Private Methods
// ===================================================
void
BCInterfaceData1D::readResistance ( const GetPot& dataFile, const char* resistance )
{
UInt resistanceSize = dataFile.vector_variable_size ( resistance );
M_resistance.resize ( resistanceSize );
for ( UInt j ( 0 ); j < resistanceSize; ++j )
{
M_resistance[j] = dataFile ( resistance, 0, j );
}
}
void Physics::read_input_options( const GetPot& input )
{
int num_ids = input.vector_variable_size( "Physics/"+this->_physics_name+"/enabled_subdomains" );
for( int i = 0; i < num_ids; i++ )
{
libMesh::subdomain_id_type dumvar = input( "Physics/"+this->_physics_name+"/enabled_subdomains", -1, i );
_enabled_subdomains.insert( dumvar );
}
return;
}
void NeumannBCFactoryAbstract::check_for_flux( const GetPot& input, const std::string& flux_input,
const std::vector<std::string>& var_names )
{
if( !input.have_variable(flux_input) )
libmesh_error_msg("ERROR: Could not find input specification for "+flux_input+"!");
unsigned int flux_size = input.vector_variable_size(flux_input);
if( flux_size != var_names.size() )
{
std::string error_msg = "ERROR: Mismatch in size between flux input and variables size!\n";
error_msg += " Found flux size = "+StringUtilities::T_to_string<unsigned int>(flux_size)+"\n";
error_msg += " Found variables size = "+StringUtilities::T_to_string<unsigned int>(var_names.size())+"\n";
libmesh_error_msg(error_msg);
}
}
void
PreconditionerComposed::createParametersList ( list_Type& /*list*/,
const GetPot& dataFile,
const std::string& section,
const std::string& subSection )
{
//! See http://trilinos.sandia.gov/packages/docs/r9.0/packages/ifpack/doc/html/index.html
//! for more informations on the parameters
ASSERT ( !M_prec->number(), "Error, when initializing the preconditioner, it must be empty" );
for ( UInt i (0); i < dataFile.vector_variable_size ( ( section + "/" + subSection + "/list" ).data() ); ++i )
{
epetraPrecPtr_Type tmp ( PRECFactory::instance().createObject ( dataFile ( ( section + "/" + subSection + "/list" ).data(), "ML", i ) ) );
M_prec->push_back (tmp);
M_prec->OperatorView() [i]->createParametersList (M_prec->OperatorView() [i]->parametersList(), dataFile, section, dataFile ( ( section + "/" + subSection + "/sections" ).data(), "ML", i ) );
}
}
std::vector<std::string> VariableFactoryBasic<VariableType>::parse_var_names( const GetPot& input,
const std::string& var_section )
{
std::vector<std::string> var_names;
std::string input_sec = var_section+"/names";
// Make sure the names are present
if( !input.have_variable(input_sec) )
libmesh_error_msg("ERROR: Could not find input parameter "+input_sec);
unsigned int n_names = input.vector_variable_size(input_sec);
var_names.resize(n_names);
for( unsigned int i = 0; i < n_names; i++ )
var_names[i] = input(input_sec,std::string("DIE!"),i);
return var_names;
}
void Vorticity::read_input_options( const GetPot& input )
{
// Extract subdomain on which to compute to qoi
int num_ids = input.vector_variable_size( "QoI/Vorticity/enabled_subdomains" );
if( num_ids == 0 )
{
std::cerr << "Error: Must specify at least one subdomain id on which to compute vorticity." << std::endl;
libmesh_error();
}
for( int i = 0; i < num_ids; i++ )
{
libMesh::subdomain_id_type s_id = input( "QoI/Vorticity/enabled_subdomains", -1, i );
_subdomain_ids.insert( s_id );
}
return;
}
void AverageNusseltNumber::init
(const GetPot& input,
const MultiphysicsSystem& system,
unsigned int /*qoi_num*/ )
{
this->set_parameter
( _k, input, "QoI/NusseltNumber/thermal_conductivity", -1.0 );
this->set_parameter
( _scaling, input, "QoI/NusseltNumber/scaling", 1.0 );
if( this->_k < 0.0 )
{
std::cerr << "Error: thermal conductivity for AverageNusseltNumber must be positive." << std::endl
<< "Found k = " << _k << std::endl;
libmesh_error();
}
// Read boundary ids for which we want to compute
int num_bcs = input.vector_variable_size("QoI/NusseltNumber/bc_ids");
if( num_bcs <= 0 )
{
std::cerr << "Error: Must specify at least one boundary id to compute"
<< " average Nusselt number." << std::endl
<< "Found: " << num_bcs << std::endl;
libmesh_error();
}
for( int i = 0; i < num_bcs; i++ )
{
_bc_ids.insert( input("QoI/NusseltNumber/bc_ids", -1, i ) );
}
// Grab temperature variable index
std::string T_var_name = input( "Physics/VariableNames/Temperature",
T_var_name_default );
this->_T_var = system.variable_number(T_var_name);
return;
}
void ParameterManager::initialize
( const GetPot& input,
const std::string & parameters_varname,
MultiphysicsSystem & system,
CompositeQoI * qoi)
{
const unsigned int n_parameters =
input.vector_variable_size(parameters_varname);
libmesh_assert(n_parameters);
this->parameter_name_list.resize(n_parameters);
this->parameter_vector.clear();
for (unsigned int i=0; i != n_parameters; ++i)
{
std::string param_name =
input(parameters_varname, std::string(), i);
this->parameter_name_list[i] = param_name;
libMesh::ParameterMultiAccessor<libMesh::Number> *next_param =
new libMesh::ParameterMultiAccessor<libMesh::Number>();
// We always have Physics solving for u
system.register_parameter(param_name, *next_param);
// We don't always have QoIs when solving for du/dp
if (qoi)
qoi->register_parameter(param_name, *next_param);
if (next_param->size() == 0)
{
std::cout << "No parameters named " << param_name <<
" found in active Physics or QoIs" << std::endl;
libmesh_error();
}
this->parameter_vector.push_back
(libMesh::UniquePtr<libMesh::ParameterAccessor<libMesh::Number> >
(next_param));
}
}
AntiochChemistry::AntiochChemistry( const GetPot& input )
: _antioch_gas(NULL)
{
if( !input.have_variable("Physics/Chemistry/species") )
{
std::cerr << "Error: Must specify species list to use Antioch." << std::endl;
libmesh_error();
}
unsigned int n_species = input.vector_variable_size("Physics/Chemistry/species");
std::vector<std::string> species_list(n_species);
for( unsigned int s = 0; s < n_species; s++ )
{
species_list[s] = input( "Physics/Chemistry/species", "DIE!", s );
}
_antioch_gas.reset( new Antioch::ChemicalMixture<libMesh::Real>( species_list ) );
return;
}
AntiochChemistry::AntiochChemistry( const GetPot& input )
: _antioch_gas(NULL)
{
if( !input.have_variable("Physics/Chemistry/species") )
{
std::cerr << "Error: Must specify species list to use Antioch." << std::endl;
libmesh_error();
}
unsigned int n_species = input.vector_variable_size("Physics/Chemistry/species");
std::vector<std::string> species_list(n_species);
for( unsigned int s = 0; s < n_species; s++ )
{
species_list[s] = input( "Physics/Chemistry/species", "DIE!", s );
}
bool verbose_antioch_read = input("Physics/Antioch/verbose_read",false);
std::string species_data_filename = input("Physics/Antioch/species_data", "default" );
if( species_data_filename == std::string("default") )
species_data_filename = Antioch::DefaultInstallFilename::chemical_mixture();
std::string vibration_data_filename = input("Physics/Antioch/vibration_data", "default" );
if( vibration_data_filename == std::string("default") )
vibration_data_filename = Antioch::DefaultInstallFilename::vibrational_data();
std::string electronic_data_filename = input("Physics/Antioch/electronic_data", "default" );
if( electronic_data_filename == std::string("default") )
electronic_data_filename = Antioch::DefaultInstallFilename::electronic_data();
// By default, Antioch is using its ASCII parser. We haven't added more options yet.
_antioch_gas.reset( new Antioch::ChemicalMixture<libMesh::Real>( species_list,
verbose_antioch_read,
species_data_filename,
vibration_data_filename,
electronic_data_filename ) );
return;
}
PressurePinning::PressurePinning( const GetPot& input,
const std::string& physics_name )
{
_pin_value = input("Physics/"+physics_name+"/pin_value", 0.0 );
unsigned int pin_loc_dim = input.vector_variable_size("Physics/"+physics_name+"/pin_location");
// If the user is specifying a pin_location, it had better be at least 2-dimensional
if( pin_loc_dim > 0 && pin_loc_dim < 2 )
{
std::cerr << "Error: pressure pin location must be at least 2 dimensional"
<< std::endl;
libmesh_error();
}
_pin_location(0) = input("Physics/"+physics_name+"/pin_location", 0.0, 0 );
_pin_location(1) = input("Physics/"+physics_name+"/pin_location", 0.0, 1 );
if( pin_loc_dim == 3 )
_pin_location(2) = input("Physics/"+physics_name+"/pin_location", 0.0, 2 );
return;
}
void FEMParameters::read(GetPot &input)
{
std::vector<std::string> variable_names;
GETPOT_INT_INPUT(coarserefinements);
GETPOT_INPUT(domainfile);
GETPOT_INPUT(solver_quiet);
GETPOT_INPUT(reuse_preconditioner);
GETPOT_INPUT(require_residual_reduction);
GETPOT_INPUT(min_step_length);
GETPOT_INT_INPUT(max_linear_iterations);
GETPOT_INT_INPUT(max_nonlinear_iterations);
GETPOT_INPUT(relative_step_tolerance);
GETPOT_INPUT(relative_residual_tolerance);
GETPOT_INPUT(initial_linear_tolerance);
GETPOT_INPUT(minimum_linear_tolerance);
GETPOT_INPUT(linear_tolerance_multiplier);
GETPOT_INT_INPUT(nelem_target);
GETPOT_INPUT(global_tolerance);
GETPOT_INPUT(refine_fraction);
GETPOT_INPUT(coarsen_fraction);
GETPOT_INPUT(coarsen_threshold);
GETPOT_INT_INPUT(max_adaptivesteps);
GETPOT_INPUT(refine_uniformly);
GETPOT_INPUT(indicator_type);
GETPOT_INPUT(patch_reuse);
GETPOT_REGISTER(fe_family);
const unsigned int n_fe_family =
std::max(1u, input.vector_variable_size("fe_family"));
fe_family.resize(n_fe_family, "LAGRANGE");
for (unsigned int i=0; i != n_fe_family; ++i)
fe_family[i] = input("fe_family", fe_family[i].c_str(), i);
GETPOT_REGISTER(fe_order);
const unsigned int n_fe_order =
input.vector_variable_size("fe_order");
fe_order.resize(n_fe_order, 1);
for (unsigned int i=0; i != n_fe_order; ++i)
fe_order[i] = input("fe_order", (int)fe_order[i], i);
GETPOT_INPUT(analytic_jacobians);
GETPOT_INPUT(verify_analytic_jacobians);
GETPOT_INPUT(print_solution_norms);
GETPOT_INPUT(print_solutions);
GETPOT_INPUT(print_residual_norms);
GETPOT_INPUT(print_residuals);
GETPOT_INPUT(print_jacobian_norms);
GETPOT_INPUT(print_jacobians);
std::vector<std::string> bad_variables =
input.unidentified_arguments(variable_names);
if (libMesh::global_processor_id() == 0 && !bad_variables.empty())
{
std::cerr << "ERROR: Unrecognized variables:" << std::endl;
for (unsigned int i = 0; i != bad_variables.size(); ++i)
std::cerr << bad_variables[i] << std::endl;
std::cerr << "not found among recognized variables." << std::endl;
for (unsigned int i = 0; i != variable_names.size(); ++i)
std::cerr << variable_names[i] << std::endl;
libmesh_error();
}
}
void FEMParameters::read(GetPot &input)
{
std::vector<std::string> variable_names;
GETPOT_INT_INPUT(initial_timestep);
GETPOT_INT_INPUT(n_timesteps);
GETPOT_INPUT(transient);
GETPOT_INT_INPUT(deltat_reductions);
GETPOT_INPUT(timesolver_core);
GETPOT_INPUT(end_time);
GETPOT_INPUT(deltat);
GETPOT_INPUT(timesolver_theta);
GETPOT_INPUT(timesolver_maxgrowth);
GETPOT_INPUT(timesolver_tolerance);
GETPOT_INPUT(timesolver_upper_tolerance);
GETPOT_INPUT(steadystate_tolerance);
GETPOT_REGISTER(timesolver_norm);
const unsigned int n_timesolver_norm = input.vector_variable_size("timesolver_norm");
timesolver_norm.resize(n_timesolver_norm, L2);
for (unsigned int i=0; i != n_timesolver_norm; ++i)
{
int current_norm = 0; // L2
if (timesolver_norm[i] == H1)
current_norm = 1;
if (timesolver_norm[i] == H2)
current_norm = 2;
current_norm = input("timesolver_norm", current_norm, i);
if (current_norm == 0)
timesolver_norm[i] = L2;
else if (current_norm == 1)
timesolver_norm[i] = H1;
else if (current_norm == 2)
timesolver_norm[i] = H2;
else
timesolver_norm[i] = DISCRETE_L2;
}
GETPOT_INT_INPUT(dimension);
GETPOT_INPUT(domaintype);
GETPOT_INPUT(domainfile);
GETPOT_INPUT(elementtype);
GETPOT_INPUT(elementorder);
GETPOT_INPUT(domain_xmin);
GETPOT_INPUT(domain_ymin);
GETPOT_INPUT(domain_zmin);
GETPOT_INPUT(domain_edge_width);
GETPOT_INPUT(domain_edge_length);
GETPOT_INPUT(domain_edge_height);
GETPOT_INT_INPUT(coarsegridx);
GETPOT_INT_INPUT(coarsegridy);
GETPOT_INT_INPUT(coarsegridz);
GETPOT_INT_INPUT(coarserefinements);
GETPOT_INT_INPUT(extrarefinements);
GETPOT_INT_INPUT(nelem_target);
GETPOT_INPUT(global_tolerance);
GETPOT_INPUT(refine_fraction);
GETPOT_INPUT(coarsen_fraction);
GETPOT_INPUT(coarsen_threshold);
GETPOT_INT_INPUT(max_adaptivesteps);
GETPOT_INT_INPUT(initial_adaptivesteps);
GETPOT_INT_INPUT(write_interval);
GETPOT_INPUT(output_xda);
GETPOT_INPUT(output_xdr);
GETPOT_INPUT(output_gz);
#ifndef LIBMESH_HAVE_GZSTREAM
output_gz = false;
#endif
GETPOT_INPUT(output_bz2);
#ifndef LIBMESH_HAVE_BZ2
output_bz2 = false;
#endif
GETPOT_INPUT(output_gmv);
GETPOT_INPUT(write_gmv_error);
#ifndef LIBMESH_HAVE_GMV
output_gmv = false;
write_gmv_error = false;
#endif
GETPOT_INPUT(output_tecplot);
GETPOT_INPUT(write_tecplot_error);
#ifndef LIBMESH_HAVE_TECPLOT_API
output_tecplot = false;
write_tecplot_error = false;
#endif
GETPOT_REGISTER(system_types);
const unsigned int n_system_types =
input.vector_variable_size("system_types");
if (n_system_types)
{
system_types.resize(n_system_types, "");
for (unsigned int i=0; i != n_system_types; ++i)
{
system_types[i] = input("system_types", system_types[i], i);
}
}
GETPOT_REGISTER(periodic_boundaries);
const unsigned int n_periodic_bcs =
input.vector_variable_size("periodic_boundaries");
if (n_periodic_bcs)
{
if (domaintype != "square" &&
domaintype != "cylinder" &&
domaintype != "file" &&
domaintype != "od2")
{
libMesh::out << "Periodic boundaries need rectilinear domains" << std::endl;;
libmesh_error();
}
for (unsigned int i=0; i != n_periodic_bcs; ++i)
{
unsigned int myboundary =
input("periodic_boundaries", -1, i);
unsigned int pairedboundary = 0;
RealVectorValue translation_vector;
if (dimension == 2)
switch (myboundary)
{
case 0:
pairedboundary = 2;
translation_vector = RealVectorValue(0., domain_edge_length);
break;
case 1:
pairedboundary = 3;
translation_vector = RealVectorValue(-domain_edge_width, 0);
break;
default:
libMesh::out << "Unrecognized periodic boundary id " <<
myboundary << std::endl;;
libmesh_error();
}
else if (dimension == 3)
switch (myboundary)
{
case 0:
pairedboundary = 5;
translation_vector = RealVectorValue(0., 0., domain_edge_height);
break;
case 1:
pairedboundary = 3;
translation_vector = RealVectorValue(0., domain_edge_length, 0.);
break;
case 2:
pairedboundary = 4;
translation_vector = RealVectorValue(-domain_edge_width, 0., 0.);
break;
default:
libMesh::out << "Unrecognized periodic boundary id " <<
myboundary << std::endl;;
libmesh_error();
}
periodic_boundaries.push_back(PeriodicBoundary(translation_vector));
periodic_boundaries[i].myboundary = myboundary;
periodic_boundaries[i].pairedboundary = pairedboundary;
}
}
// Use std::string inputs so GetPot doesn't have to make a bunch
// of internal C string copies
std::string zero_string = "zero";
std::string empty_string = "";
GETPOT_REGISTER(dirichlet_condition_types);
GETPOT_REGISTER(dirichlet_condition_values);
GETPOT_REGISTER(dirichlet_condition_boundaries);
GETPOT_REGISTER(dirichlet_condition_variables);
const unsigned int n_dirichlet_conditions=
input.vector_variable_size("dirichlet_condition_types");
if (n_dirichlet_conditions !=
input.vector_variable_size("dirichlet_condition_values"))
{
libMesh::out << "Error: " << n_dirichlet_conditions
<< " Dirichlet condition types does not match "
<< input.vector_variable_size("dirichlet_condition_values")
<< " Dirichlet condition values." << std::endl;
libmesh_error();
}
if (n_dirichlet_conditions !=
input.vector_variable_size("dirichlet_condition_boundaries"))
{
libMesh::out << "Error: " << n_dirichlet_conditions
<< " Dirichlet condition types does not match "
<< input.vector_variable_size("dirichlet_condition_boundaries")
<< " Dirichlet condition boundaries." << std::endl;
libmesh_error();
}
if (n_dirichlet_conditions !=
input.vector_variable_size("dirichlet_condition_variables"))
{
libMesh::out << "Error: " << n_dirichlet_conditions
<< " Dirichlet condition types does not match "
<< input.vector_variable_size("dirichlet_condition_variables")
<< " Dirichlet condition variables sets." << std::endl;
libmesh_error();
}
for (unsigned int i=0; i != n_dirichlet_conditions; ++i)
{
const std::string func_type =
input("dirichlet_condition_types", zero_string, i);
const std::string func_value =
input("dirichlet_condition_values", empty_string, i);
const boundary_id_type func_boundary =
input("dirichlet_condition_boundaries", boundary_id_type(0), i);
dirichlet_conditions[func_boundary] =
(new_function_base(func_type, func_value).release());
const std::string variable_set =
input("dirichlet_condition_variables", empty_string, i);
for (unsigned int i=0; i != variable_set.size(); ++i)
{
if (variable_set[i] == '1')
dirichlet_condition_variables[func_boundary].push_back(i);
else if (variable_set[i] != '0')
{
libMesh::out << "Unable to understand Dirichlet variable set"
<< variable_set << std::endl;
libmesh_error();
}
}
}
GETPOT_REGISTER(neumann_condition_types);
GETPOT_REGISTER(neumann_condition_values);
GETPOT_REGISTER(neumann_condition_boundaries);
GETPOT_REGISTER(neumann_condition_variables);
const unsigned int n_neumann_conditions=
input.vector_variable_size("neumann_condition_types");
if (n_neumann_conditions !=
input.vector_variable_size("neumann_condition_values"))
{
libMesh::out << "Error: " << n_neumann_conditions
<< " Neumann condition types does not match "
<< input.vector_variable_size("neumann_condition_values")
<< " Neumann condition values." << std::endl;
libmesh_error();
}
if (n_neumann_conditions !=
input.vector_variable_size("neumann_condition_boundaries"))
{
libMesh::out << "Error: " << n_neumann_conditions
<< " Neumann condition types does not match "
<< input.vector_variable_size("neumann_condition_boundaries")
<< " Neumann condition boundaries." << std::endl;
libmesh_error();
}
if (n_neumann_conditions !=
input.vector_variable_size("neumann_condition_variables"))
{
libMesh::out << "Error: " << n_neumann_conditions
<< " Neumann condition types does not match "
<< input.vector_variable_size("neumann_condition_variables")
<< " Neumann condition variables sets." << std::endl;
libmesh_error();
}
for (unsigned int i=0; i != n_neumann_conditions; ++i)
{
const std::string func_type =
input("neumann_condition_types", zero_string, i);
const std::string func_value =
input("neumann_condition_values", empty_string, i);
const boundary_id_type func_boundary =
input("neumann_condition_boundaries", boundary_id_type(0), i);
neumann_conditions[func_boundary] =
(new_function_base(func_type, func_value).release());
const std::string variable_set =
input("neumann_condition_variables", empty_string, i);
for (unsigned int i=0; i != variable_set.size(); ++i)
{
if (variable_set[i] == '1')
neumann_condition_variables[func_boundary].push_back(i);
else if (variable_set[i] != '0')
{
libMesh::out << "Unable to understand Neumann variable set"
<< variable_set << std::endl;
libmesh_error();
}
}
}
GETPOT_REGISTER(initial_condition_types);
GETPOT_REGISTER(initial_condition_values);
GETPOT_REGISTER(initial_condition_subdomains);
const unsigned int n_initial_conditions=
input.vector_variable_size("initial_condition_types");
if (n_initial_conditions !=
input.vector_variable_size("initial_condition_values"))
{
libMesh::out << "Error: " << n_initial_conditions
<< " initial condition types does not match "
<< input.vector_variable_size("initial_condition_values")
<< " initial condition values." << std::endl;
libmesh_error();
}
if (n_initial_conditions !=
input.vector_variable_size("initial_condition_subdomains"))
{
libMesh::out << "Error: " << n_initial_conditions
<< " initial condition types does not match "
<< input.vector_variable_size("initial_condition_subdomains")
<< " initial condition subdomains." << std::endl;
libmesh_error();
}
for (unsigned int i=0; i != n_initial_conditions; ++i)
{
const std::string func_type =
input("initial_condition_types", zero_string, i);
const std::string func_value =
input("initial_condition_values", empty_string, i);
const subdomain_id_type func_subdomain =
input("initial_condition_subdomains", subdomain_id_type(0), i);
initial_conditions[func_subdomain] =
(new_function_base(func_type, func_value).release());
}
GETPOT_REGISTER(other_interior_function_types);
GETPOT_REGISTER(other_interior_function_values);
GETPOT_REGISTER(other_interior_function_subdomains);
GETPOT_REGISTER(other_interior_function_ids);
const unsigned int n_other_interior_functions =
input.vector_variable_size("other_interior_function_types");
if (n_other_interior_functions !=
input.vector_variable_size("other_interior_function_values"))
{
libMesh::out << "Error: " << n_other_interior_functions
<< " other interior function types does not match "
<< input.vector_variable_size("other_interior_function_values")
<< " other interior function values." << std::endl;
libmesh_error();
}
if (n_other_interior_functions !=
input.vector_variable_size("other_interior_function_subdomains"))
{
libMesh::out << "Error: " << n_other_interior_functions
<< " other interior function types does not match "
<< input.vector_variable_size("other_interior_function_subdomains")
<< " other interior function subdomains." << std::endl;
libmesh_error();
}
if (n_other_interior_functions !=
input.vector_variable_size("other_interior_function_ids"))
{
libMesh::out << "Error: " << n_other_interior_functions
<< " other interior function types does not match "
<< input.vector_variable_size("other_interior_function_ids")
<< " other interior function ids." << std::endl;
libmesh_error();
}
for (unsigned int i=0; i != n_other_interior_functions; ++i)
{
const std::string func_type =
input("other_interior_function_types", zero_string, i);
const std::string func_value =
input("other_interior_function_values", empty_string, i);
const subdomain_id_type func_subdomain =
input("other_interior_condition_subdomains", subdomain_id_type(0), i);
const int func_id =
input("other_interior_condition_ids", int(0), i);
other_interior_functions[func_id][func_subdomain] =
(new_function_base(func_type, func_value).release());
}
GETPOT_REGISTER(other_boundary_function_types);
GETPOT_REGISTER(other_boundary_function_values);
GETPOT_REGISTER(other_boundary_function_boundaries);
GETPOT_REGISTER(other_boundary_function_ids);
const unsigned int n_other_boundary_functions =
input.vector_variable_size("other_boundary_function_types");
if (n_other_boundary_functions !=
input.vector_variable_size("other_boundary_function_values"))
{
libMesh::out << "Error: " << n_other_boundary_functions
<< " other boundary function types does not match "
<< input.vector_variable_size("other_boundary_function_values")
<< " other boundary function values." << std::endl;
libmesh_error();
}
if (n_other_boundary_functions !=
input.vector_variable_size("other_boundary_function_boundaries"))
{
libMesh::out << "Error: " << n_other_boundary_functions
<< " other boundary function types does not match "
<< input.vector_variable_size("other_boundary_function_boundaries")
<< " other boundary function boundaries." << std::endl;
libmesh_error();
}
if (n_other_boundary_functions !=
input.vector_variable_size("other_boundary_function_ids"))
{
libMesh::out << "Error: " << n_other_boundary_functions
<< " other boundary function types does not match "
<< input.vector_variable_size("other_boundary_function_ids")
<< " other boundary function ids." << std::endl;
libmesh_error();
}
for (unsigned int i=0; i != n_other_boundary_functions; ++i)
{
const std::string func_type =
input("other_boundary_function_types", zero_string, i);
const std::string func_value =
input("other_boundary_function_values", empty_string, i);
const boundary_id_type func_boundary =
input("other_boundary_function_boundaries", boundary_id_type(0), i);
const int func_id =
input("other_boundary_function_ids", int(0), i);
other_boundary_functions[func_id][func_boundary] =
(new_function_base(func_type, func_value).release());
}
GETPOT_INPUT(run_simulation);
GETPOT_INPUT(run_postprocess);
GETPOT_REGISTER(fe_family);
const unsigned int n_fe_family =
std::max(1u, input.vector_variable_size("fe_family"));
fe_family.resize(n_fe_family, "LAGRANGE");
for (unsigned int i=0; i != n_fe_family; ++i)
fe_family[i] = input("fe_family", fe_family[i].c_str(), i);
GETPOT_REGISTER(fe_order);
const unsigned int n_fe_order =
input.vector_variable_size("fe_order");
fe_order.resize(n_fe_order, 1);
for (unsigned int i=0; i != n_fe_order; ++i)
fe_order[i] = input("fe_order", (int)fe_order[i], i);
GETPOT_INPUT(extra_quadrature_order);
GETPOT_INPUT(analytic_jacobians);
GETPOT_INPUT(verify_analytic_jacobians);
GETPOT_INPUT(numerical_jacobian_h);
GETPOT_INPUT(print_solution_norms);
GETPOT_INPUT(print_solutions);
GETPOT_INPUT(print_residual_norms);
GETPOT_INPUT(print_residuals);
GETPOT_INPUT(print_jacobian_norms);
GETPOT_INPUT(print_jacobians);
GETPOT_INPUT(print_element_jacobians);
GETPOT_INPUT(use_petsc_snes);
GETPOT_INPUT(time_solver_quiet);
GETPOT_INPUT(solver_quiet);
GETPOT_INPUT(solver_verbose);
GETPOT_INPUT(require_residual_reduction);
GETPOT_INPUT(min_step_length);
GETPOT_INT_INPUT(max_linear_iterations);
GETPOT_INT_INPUT(max_nonlinear_iterations);
GETPOT_INPUT(relative_step_tolerance);
GETPOT_INPUT(relative_residual_tolerance);
GETPOT_INPUT(initial_linear_tolerance);
GETPOT_INPUT(minimum_linear_tolerance);
GETPOT_INPUT(linear_tolerance_multiplier);
GETPOT_INT_INPUT(initial_sobolev_order);
GETPOT_INT_INPUT(initial_extra_quadrature);
GETPOT_INPUT(indicator_type);
GETPOT_INT_INPUT(sobolev_order);
GETPOT_INPUT(system_config_file);
std::vector<std::string> bad_variables =
input.unidentified_arguments(variable_names);
if (libMesh::processor_id() == 0 && !bad_variables.empty())
{
std::cerr << "ERROR: Unrecognized variables:" << std::endl;
for (unsigned int i = 0; i != bad_variables.size(); ++i)
std::cerr << bad_variables[i] << std::endl;
std::cerr << "Not found among recognized variables:" << std::endl;
for (unsigned int i = 0; i != variable_names.size(); ++i)
std::cerr << variable_names[i] << std::endl;
libmesh_error();
}
}
int do_transport_eval( const GetPot& input )
{
GRINS::AntiochWilkeTransportMixture<Thermo,Viscosity,Conductivity,Diffusivity> mixture(input);
GRINS::AntiochWilkeTransportEvaluator<Thermo,Viscosity,Conductivity,Diffusivity> evaluator(mixture);
libMesh::Real T0 = input( "Conditions/T0", 300.0 );
libMesh::Real T1 = input( "Conditions/T1", 300.0 );
libMesh::Real T_inc = input( "Conditions/T_increment", 100.0 );
libMesh::Real rho = input( "Conditions/density", 1.0e-3 );
const unsigned int n_species = mixture.n_species();
std::vector<libMesh::Real> Y(n_species);
if( input.vector_variable_size( "Conditions/mass_fractions" ) != n_species )
{
std::cerr << "Error: mass fractions size not consistent with n_species"
<< std::endl;
libmesh_error();
}
for( unsigned int s = 0; s < n_species; s++ )
{
Y[s] = input( "Conditions/mass_fractions", 0.0, s );
}
libMesh::Real T = T0;
std::ofstream output;
output.open( "transport.dat", std::ios::trunc );
output << "# Species names" << std::endl;
for( unsigned int s = 0; s < n_species; s++ )
{
output << mixture.species_name( s ) << " ";
}
output << std::endl;
output << "# T [K] mu k D[s]" << std::endl;
output.close();
while( T < T1 )
{
output.open( "transport.dat", std::ios::app );
output << std::scientific << std::setprecision(16);
output << T << " ";
libMesh::Real mu = evaluator.mu(T,Y);
libMesh::Real k = evaluator.k(T,Y);
output << mu << " ";
output << k << " ";
std::vector<libMesh::Real> D(n_species);
for( unsigned int s = 0; s< n_species; s++ )
{
evaluator.D(rho, evaluator.cp(T,Y), k, D);
output << D[s] << " ";
}
output << std::endl;
output.close();
T += T_inc;
}
return 0;
}
libMesh::CompositeFunction<libMesh::Number>& composite_func ) const
#else
void PrescribedMoleFractionsDirichletOldStyleBCFactory::add_funcs( const GetPot& input,
MultiphysicsSystem& /*system*/,
const std::string& input_string,
const std::vector<std::string>& var_names,
libMesh::CompositeFunction<libMesh::Number>& /*composite_func*/ ) const
#endif
{
const unsigned int n_vars = var_names.size();
// Parse in all the species mole fracs that are in the input
std::vector<libMesh::Number> species_mole_fracs(n_vars);
libMesh::Number invalid_num = std::numeric_limits<libMesh::Number>::max();
if( input.vector_variable_size(input_string) != n_vars )
libmesh_error_msg("ERROR: Expected "+StringUtilities::T_to_string<unsigned int>(n_vars)+" components in "+input_string);
for(unsigned int v = 0; v < n_vars; v++ )
species_mole_fracs[v] = input(input_string,invalid_num,v);
// Make sure mole fracs sum to 1
libMesh::Number sum = 0.0;
for(unsigned int v = 0; v < n_vars; 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));
// To avoid compiler warnings without GRINS or Cantera
#if defined(GRINS_HAVE_ANTIOCH) || defined(GRINS_HAVE_CANTERA)
// 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>
(VariablesParsing::species_mass_fractions_section());
#endif
std::string thermochem_lib;
MaterialsParsing::thermochemistry_lib( input,
PhysicsNaming::reacting_low_mach_navier_stokes(),
thermochem_lib );
if( thermochem_lib == "cantera" )
{
#ifdef GRINS_HAVE_CANTERA
this->convert_mole_fracs_and_add_to_func<CanteraMixture>(input,
species_mole_fracs,
species_fe_var,
composite_func);
#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->convert_mole_fracs_and_add_to_func<AntiochChemistry>(input,
species_mole_fracs,
species_fe_var,
composite_func);
#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+"!");
}
FullModelComposition<Vec,Mat>::FullModelComposition( int argc, char** argv,
const QUESO::BaseEnvironment& queso_env,
const GetPot& model_input )
: _model(ModelBuilder<Vec,Mat>::build_model(queso_env,model_input)),
_comm_handler(queso_env.subComm().Comm(),
model_input.vector_variable_size("Likelihood/datasets") )
{
// Grab the datasets we'll be working with
unsigned int n_datasets = model_input.vector_variable_size("Likelihood/datasets");
std::vector<std::string> datasets(n_datasets);
for( unsigned int d = 0; d < n_datasets; d++ )
{
datasets[d] = model_input( "Likelihood/datasets", "DIE!", d );
}
// This is the dataset the current set of processors is going to work on
int dataset_index = this->_comm_handler.get_dataset_index();
// Input for this dataset
_forward_run_input.reset( new GetPot(datasets[dataset_index]) );
// Setup data space, 2 datapoints per dataset
unsigned int n_datapoints = 2*n_datasets;
QUESO::VectorSpace<Vec,Mat> data_space( queso_env, "data_", n_datapoints, NULL);
_observations.reset( data_space.newVector() );
_covariance.reset( data_space.newVector() );
// Now parse data values and the corresponding covariances
// Each processor parses its own dataset
// Then we'll gather/broadcast to everyone
std::vector<double> local_values(2);
std::vector<double> all_values(n_datapoints);
// Convention, mass_loss is first, then avg_N
local_values[0] = (*_forward_run_input)("MassLossLikelihood/data_value", 0.0);
local_values[1] = (*_forward_run_input)("AverageNLikelihood/data_value", 0.0);
if( _comm_handler.get_inter0_rank() >= 0 )
MPI_Gather( &local_values[0], 2, MPI_DOUBLE,
&all_values[0], 2, MPI_DOUBLE, 0,
_comm_handler.get_inter_chain_0_comm() );
MPI_Bcast( &all_values[0], n_datapoints, MPI_DOUBLE,
0, _comm_handler.get_inter_chain_comm() );
for( unsigned int i = 0; i < n_datapoints; i++ )
(*_observations)[i] = all_values[i];
local_values[0] = (*_forward_run_input)("MassLossLikelihood/sigma", -1.0);
local_values[1] = (*_forward_run_input)("AverageNLikelihood/sigma", -1.0);
if( _comm_handler.get_inter0_rank() >= 0 )
MPI_Gather( &local_values[0], 2, MPI_DOUBLE,
&all_values[0], 2, MPI_DOUBLE, 0,
_comm_handler.get_inter_chain_0_comm() );
MPI_Bcast( &all_values[0], n_datapoints, MPI_DOUBLE,
0, _comm_handler.get_inter_chain_comm() );
for( unsigned int i = 0; i < n_datapoints; i++ )
(*_covariance)[i] = all_values[i];
// Now setup model to be evaluated on this set of processors
// We do this last because of the UFO check in GRINS
_model_evaluator.reset( new FullModelEvaluator<Vec,Mat>(argc,argv,
queso_env,
*(_forward_run_input.get()),
_comm_handler.get_split_chain_comm(),
*(_model.get())) );
}
int run( int argc, char* argv[], const GetPot& input, GetPot& command_line )
{
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( input,
sim_builder,
libmesh_init.comm() );
//FIXME: We need to move this to within the Simulation object somehow...
std::string restart_file = input( "restart-options/restart_file", "none" );
if( restart_file == "none" )
{
// Asssign initial temperature value
std::string system_name = input( "screen-options/system_name", "GRINS" );
std::tr1::shared_ptr<libMesh::EquationSystems> es = grins.get_equation_system();
const libMesh::System& system = es->get_system(system_name);
libMesh::Parameters ¶ms = es->parameters;
libMesh::Real& w_N2 = params.set<libMesh::Real>( "w_N2" );
w_N2 = input( "Physics/ReactingLowMachNavierStokes/bound_species_0", 0.0, 0.0 );
libMesh::Real& w_N = params.set<libMesh::Real>( "w_N" );
w_N = input( "Physics/ReactingLowMachNavierStokes/bound_species_0", 0.0, 1.0 );
system.project_solution( initial_values, NULL, params );
}
grins.run();
// Get equation systems to create ExactSolution object
std::tr1::shared_ptr<libMesh::EquationSystems> es = grins.get_equation_system();
// Create Exact solution object and attach exact solution quantities
libMesh::ExactSolution exact_sol(*es);
libMesh::EquationSystems es_ref( es->get_mesh() );
// Filename of file where comparison solution is stashed
std::string solution_file = command_line("soln-data", "DIE!");
es_ref.read( solution_file );
exact_sol.attach_reference_solution( &es_ref );
// Now grab the variables for which we want to compare
unsigned int n_vars = command_line.vector_variable_size("vars");
std::vector<std::string> vars(n_vars);
for( unsigned int v = 0; v < n_vars; v++ )
{
vars[v] = command_line("vars", "DIE!", v);
}
// Now grab the norms to compute for each variable error
unsigned int n_norms = command_line.vector_variable_size("norms");
std::vector<std::string> norms(n_norms);
for( unsigned int n = 0; n < n_norms; n++ )
{
norms[n] = command_line("norms", "DIE!", n);
if( norms[n] != std::string("L2") &&
norms[n] != std::string("H1") )
{
std::cerr << "ERROR: Invalid norm input " << norms[n] << std::endl
<< " Valid values are: L2" << std::endl
<< " H1" << std::endl;
}
}
const std::string& system_name = grins.get_multiphysics_system_name();
// Now compute error for each variable
for( unsigned int v = 0; v < n_vars; v++ )
{
exact_sol.compute_error(system_name, vars[v]);
}
int return_flag = 0;
double tol = command_line("tol", 1.0e-10);
// Now test error for each variable, for each norm
for( unsigned int v = 0; v < n_vars; v++ )
{
for( unsigned int n = 0; n < n_norms; n++ )
{
test_error_norm( exact_sol, system_name, vars[v], norms[n], tol, return_flag );
}
}
return return_flag;
}
