int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 2 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
// Initialize libMesh library.
LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( libMesh_inputfile,
sim_builder );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
grins.run();
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.Finalize();
if( Parallel::Communicator_World.rank() == 0 ) grvy_timer.Summarize();
#endif
return 0;
}
int main(int argc, char* argv[])
{
// Check command line count.
if( argc < 5 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file, exact solution file, exact mass loss QoI, and exact average N QoI." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
int return_flag = run(argc,argv,libMesh_inputfile);
return return_flag;
}
int main(int argc, char* argv[])
{
/* Echo GRINS version, libMesh version, and command */
libMesh::out << "=========================================================="
<< std::endl;
libMesh::out << "GRINS Version: " << GRINS_BUILD_VERSION << std::endl
<< "libMesh Version: " << LIBMESH_BUILD_VERSION << std::endl
<< "Running with command:\n";
for (int i=0; i != argc; ++i)
std::cout << argv[i] << ' ';
std::cout << std::endl
<< "=========================================================="
<< std::endl;
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 2 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
GetPot command_line(argc,argv);
// GetPot doesn't throw an error for a nonexistent file?
{
std::ifstream i(libMesh_input_filename.c_str());
if (!i)
{
std::cerr << "Error: Could not read from libMesh input file "
<< libMesh_input_filename << std::endl;
exit(1);
}
}
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( libMesh_inputfile,
command_line,
sim_builder,
libmesh_init.comm() );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
grins.run();
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.Finalize();
if( Parallel::Communicator_World.rank() == 0 ) grvy_timer.Summarize();
#endif
return 0;
}
int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 2 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
GRINS::SharedPtr<GRINS::BoundaryConditionsFactory> bc_factory( new ParabolicBCFactory );
sim_builder.attach_bc_factory(bc_factory);
GRINS::Simulation grins( libMesh_inputfile,
sim_builder,
libmesh_init.comm() );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
// Solve
grins.run();
// Get equation systems to create ExactSolution object
GRINS::SharedPtr<libMesh::EquationSystems> es = grins.get_equation_system();
// Create Exact solution object and attach exact solution quantities
libMesh::ExactSolution exact_sol(*es);
exact_sol.attach_exact_value(&exact_solution);
exact_sol.attach_exact_deriv(&exact_derivative);
// Compute error and get it in various norms
exact_sol.compute_error("GRINS", "u");
double l2error = exact_sol.l2_error("GRINS", "u");
double h1error = exact_sol.h1_error("GRINS", "u");
int return_flag = 0;
const double tol = 1.0e-8;
if( l2error > tol || h1error > tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for velocity in Poiseuille test." << std::endl
<< "l2 error = " << l2error << std::endl
<< "h1 error = " << h1error << std::endl;
}
// Compute error and get it in various norms
exact_sol.compute_error("GRINS", "p");
l2error = exact_sol.l2_error("GRINS", "p");
h1error = exact_sol.h1_error("GRINS", "p");
if( l2error > tol || h1error > tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for pressure in Poiseuille test." << std::endl
<< "l2 error = " << l2error << std::endl
<< "h1 error = " << h1error << std::endl;
}
return return_flag;
}
int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 3 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file and solution file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
sim_builder.attach_bc_factory( GRINS::SharedPtr<GRINS::BoundaryConditionsFactory>( new GRINS::ThermallyDrivenFlowTestBCFactory( libMesh_inputfile ) ) );
GRINS::Simulation grins( libMesh_inputfile,
sim_builder,
libmesh_init.comm() );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
// Do solve here
grins.run();
// Get equation systems to create ExactSolution object
GRINS::SharedPtr<libMesh::EquationSystems> es = grins.get_equation_system();
//es->write("foobar.xdr");
// 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 = std::string(argv[2]);
es_ref.read( solution_file );
exact_sol.attach_reference_solution( &es_ref );
// Compute error and get it in various norms
exact_sol.compute_error("GRINS", "u");
exact_sol.compute_error("GRINS", "v");
if( (es->get_mesh()).mesh_dimension() == 3 )
exact_sol.compute_error("GRINS", "w");
exact_sol.compute_error("GRINS", "p");
exact_sol.compute_error("GRINS", "T");
double u_l2error = exact_sol.l2_error("GRINS", "u");
double u_h1error = exact_sol.h1_error("GRINS", "u");
double v_l2error = exact_sol.l2_error("GRINS", "v");
double v_h1error = exact_sol.h1_error("GRINS", "v");
double p_l2error = exact_sol.l2_error("GRINS", "p");
double p_h1error = exact_sol.h1_error("GRINS", "p");
double T_l2error = exact_sol.l2_error("GRINS", "T");
double T_h1error = exact_sol.h1_error("GRINS", "T");
double w_l2error = 0.0,
w_h1error = 0.0;
if( (es->get_mesh()).mesh_dimension() == 3 )
{
w_l2error = exact_sol.l2_error("GRINS", "w");
w_h1error = exact_sol.h1_error("GRINS", "w");
}
int return_flag = 0;
// This is the tolerance of the iterative linear solver so
// it's unreasonable to expect anything better than this.
double tol = 8.0e-9;
if( u_l2error > tol || u_h1error > tol ||
v_l2error > tol || v_h1error > tol ||
w_l2error > tol || w_h1error > tol ||
p_l2error > tol || p_h1error > tol ||
T_l2error > tol || T_h1error > tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for thermally driven flow test." << std::endl
<< "tolerance = " << tol << std::endl
<< "u l2 error = " << u_l2error << std::endl
<< "u h1 error = " << u_h1error << std::endl
<< "v l2 error = " << v_l2error << std::endl
<< "v h1 error = " << v_h1error << std::endl
<< "w l2 error = " << w_l2error << std::endl
<< "w h1 error = " << w_h1error << std::endl
<< "p l2 error = " << p_l2error << std::endl
<< "p h1 error = " << p_h1error << std::endl
<< "T l2 error = " << T_l2error << std::endl
<< "T h1 error = " << T_h1error << std::endl;
}
return return_flag;
}
int main(int argc, char* argv[])
{
GetPot command_line(argc,argv);
if( !command_line.have_variable("input") )
{
std::cerr << "ERROR: Must specify input file on command line with input=<file>." << std::endl;
exit(1);
}
if( !command_line.have_variable("soln-data") )
{
std::cerr << "ERROR: Must specify solution data on command line with soln-data=<file>." << std::endl;
exit(1);
}
if( !command_line.have_variable("vars") )
{
std::cerr << "ERROR: Must specify variables on command line with vars='var1 var2'" << std::endl;
exit(1);
}
if( !command_line.have_variable("norms") )
{
std::cerr << "ERROR: Must specify error norms on command line with norms='L2 H1'" << std::endl;
exit(1);
}
if( !command_line.have_variable("tol") )
{
std::cerr << "ERROR: Must specify test tolerance on command line with tol=<tol>" << std::endl;
exit(1);
}
// libMesh input file should be first argument
std::string libMesh_input_filename = command_line("input", "DIE!");
{
std::ifstream i(libMesh_input_filename.c_str());
if (!i)
{
std::cerr << "Error: Could not read from libMesh input file "
<< libMesh_input_filename << std::endl;
exit(1);
}
}
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
int return_flag = 0;
std::string chem_lib = libMesh_inputfile("Physics/ReactingLowMachNavierStokes/thermochemistry_library", "DIE!");
if( chem_lib == std::string("cantera") )
{
#ifdef GRINS_HAVE_CANTERA
return_flag = run(argc,argv,libMesh_inputfile,command_line);
#else
return_flag = 77;
#endif
}
else if( chem_lib == std::string("antioch") )
{
#ifdef GRINS_HAVE_ANTIOCH
return_flag = run(argc,argv,libMesh_inputfile,command_line);
#else
return_flag = 77;
#endif
}
else
{
return_flag = 1;
}
return return_flag;
}
int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 2 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( libMesh_inputfile,
sim_builder,
libmesh_init.comm() );
//FIXME: We need to move this to within the Simulation object somehow...
std::string restart_file = libMesh_inputfile( "restart-options/restart_file", "none" );
if( restart_file == "none" )
{
// Asssign initial temperature value
std::string system_name = libMesh_inputfile( "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 T_init = libMesh_inputfile("Physics/LowMachNavierStokes/T0", 0.0);
libMesh::Real p0_init = libMesh_inputfile("Physics/LowMachNavierStokes/p0", 0.0);
libMesh::Real& dummy_T = params.set<libMesh::Real>("T_init");
dummy_T = T_init;
libMesh::Real& dummy_p0 = params.set<libMesh::Real>("p0_init");
dummy_p0 = p0_init;
system.project_solution( initial_values, NULL, params );
}
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
grins.run();
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.Finalize();
if( Parallel::Communicator_World.rank() == 0 ) grvy_timer.Summarize();
#endif
return 0;
}
int main(int argc, char* argv[])
{
// Check command line count.
if( argc < 4 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file, regression file, and regression tolerance." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
// Initialize libMesh library.
LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( libMesh_inputfile,
sim_builder,
libmesh_init.comm() );
grins.run();
// Get equation systems to create ExactSolution object
std::tr1::shared_ptr<EquationSystems> es = grins.get_equation_system();
//es->write("foobar.xdr");
// Create Exact solution object and attach exact solution quantities
ExactSolution exact_sol(*es);
EquationSystems es_ref( es->get_mesh() );
// Filename of file where comparison solution is stashed
std::string solution_file = std::string(argv[2]);
es_ref.read( solution_file );
exact_sol.attach_reference_solution( &es_ref );
std::string system_name = libMesh_inputfile( "screen-options/system_name", "GRINS" );
// Compute error and get it in various norms
exact_sol.compute_error(system_name, "u");
exact_sol.compute_error(system_name, "v");
exact_sol.compute_error(system_name, "p");
double u_l2error = exact_sol.l2_error(system_name, "u");
double u_h1error = exact_sol.h1_error(system_name, "u");
double v_l2error = exact_sol.l2_error(system_name, "v");
double v_h1error = exact_sol.h1_error(system_name, "v");
double p_l2error = exact_sol.l2_error(system_name, "p");
double p_h1error = exact_sol.h1_error(system_name, "p");
int return_flag = 0;
// This is the tolerance of the iterative linear solver so
// it's unreasonable to expect anything better than this.
double tol = atof(argv[3]);
if( u_l2error > tol || u_h1error > tol ||
v_l2error > tol || v_h1error > tol ||
p_l2error > tol || p_h1error > tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for thermally driven flow test." << std::endl
<< "tolerance = " << tol << std::endl
<< "u l2 error = " << u_l2error << std::endl
<< "u h1 error = " << u_h1error << std::endl
<< "v l2 error = " << v_l2error << std::endl
<< "v h1 error = " << v_h1error << std::endl
<< "p l2 error = " << p_l2error << std::endl
<< "p h1 error = " << p_h1error << std::endl;
}
return return_flag;
}
int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 2 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for iarallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
// Initialize libMesh library.
LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( libMesh_inputfile,
sim_builder,
libmesh_init.comm() );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
// Solve
grins.run();
Number qoi = grins.get_qoi_value( 0 );
int return_flag = 0;
const Number exact_value = -0.5;
const Number rel_error = std::fabs( (qoi - exact_value )/exact_value );
const Number tol = 1.0e-15;
if( rel_error > tol )
{
std::cerr << "Computed voriticity QoI mismatch greater than tolerance." << std::endl
<< "Computed value = " << qoi << std::endl
<< "Exact value = " << exact_value << std::endl
<< "Relative error = " << rel_error << std::endl
<< "Tolerance = " << tol << std::endl;
return_flag = 1;
}
return return_flag;
}
int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 3 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
// GetPot doesn't throw an error for a nonexistent file?
{
std::ifstream i(libMesh_input_filename.c_str());
if (!i)
{
std::cerr << "Error: Could not read from libMesh input file "
<< libMesh_input_filename << std::endl;
exit(1);
}
}
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
libMesh::out << "Starting GRINS with command:\n";
for (int i=0; i != argc; ++i)
libMesh::out << argv[i] << ' ';
libMesh::out << std::endl;
GRINS::SimulationBuilder sim_builder;
GRINS::Simulation grins( libMesh_inputfile,
sim_builder,
libmesh_init.comm() );
std::string system_name = libMesh_inputfile( "screen-options/system_name", "GRINS" );
// Get equation systems
GRINS::SharedPtr<libMesh::EquationSystems> es = grins.get_equation_system();
const libMesh::System& system = es->get_system(system_name);
libMesh::Parameters ¶ms = es->parameters;
system.project_solution( initial_values, NULL, params );
grins.run();
//es->write("suspended_cable_test.xdr");
// 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 = std::string(argv[2]);
es_ref.read( solution_file );
exact_sol.attach_reference_solution( &es_ref );
// Compute error and get it in various norms
exact_sol.compute_error(system_name, "u");
exact_sol.compute_error(system_name, "v");
exact_sol.compute_error(system_name, "w");
double u_l2error = exact_sol.l2_error(system_name, "u");
double u_h1error = exact_sol.h1_error(system_name, "u");
double v_l2error = exact_sol.l2_error(system_name, "v");
double v_h1error = exact_sol.h1_error(system_name, "v");
double w_l2error = exact_sol.l2_error(system_name, "w");
double w_h1error = exact_sol.h1_error(system_name, "w");
int return_flag = 0;
double tol = 5.0e-8;
if( u_l2error > tol || u_h1error > tol ||
v_l2error > tol || v_h1error > tol ||
w_l2error > tol || w_h1error > tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for suspended cable test." << std::endl
<< "tolerance = " << tol << std::endl
<< "u l2 error = " << u_l2error << std::endl
<< "u h1 error = " << u_h1error << std::endl
<< "v l2 error = " << v_l2error << std::endl
<< "v h1 error = " << v_h1error << std::endl
<< "w l2 error = " << w_l2error << std::endl
<< "w h1 error = " << w_h1error << std::endl;
}
return return_flag;
}
int main(int argc, char* argv[])
{
#ifdef GRINS_USE_GRVY_TIMERS
GRVY::GRVY_Timer_Class grvy_timer;
grvy_timer.Init("GRINS Timer");
#endif
// Check command line count.
if( argc < 2 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
// libMesh input file should be first argument
std::string libMesh_input_filename = argv[1];
// Create our GetPot object.
GetPot libMesh_inputfile( libMesh_input_filename );
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.BeginTimer("Initialize Solver");
#endif
// Initialize libMesh library.
LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
std::tr1::shared_ptr<BunsenBCFactory> bc_factory( new BunsenBCFactory );
sim_builder.attach_bc_factory( bc_factory );
std::tr1::shared_ptr<GRINS::PhysicsFactory> physics_factory( new BunsenPhysicsFactory );
sim_builder.attach_physics_factory( physics_factory );
GRINS::Simulation grins( libMesh_inputfile,
sim_builder );
//FIXME: We need to move this to within the Simulation object somehow...
std::string restart_file = libMesh_inputfile( "restart-options/restart_file", "none" );
// If we are "cold starting", setup the flow field.
if( restart_file == "none" )
{
// Asssign initial temperature value
std::string system_name = libMesh_inputfile( "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);
Parameters ¶ms = es->parameters;
libMesh::Real& T_init = params.set<libMesh::Real>("T_init");
T_init = libMesh_inputfile("InitialConditions/T0", 0.0);
libMesh::Real& p0 = params.set<libMesh::Real>("p0");
p0 = libMesh_inputfile("Physics/ReactingLowMachNavierStokes/p0", 1.0e5);
#ifdef GRINS_HAVE_CANTERA
//Cantera::IdealGasMix& cantera = GRINS::CanteraSingleton::cantera_instance(libMesh_inputfile);
#endif
libMesh::Real& w_H2 = params.set<libMesh::Real>( "w_H2" );
w_H2 = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 0 );
libMesh::Real& w_O2 = params.set<libMesh::Real>( "w_O2" );
w_O2 = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 1 );
libMesh::Real& w_H2O = params.set<libMesh::Real>( "w_H2O" );
w_H2O = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 2 );
libMesh::Real& w_H = params.set<libMesh::Real>( "w_H" );
w_H = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 3 );
libMesh::Real& w_O = params.set<libMesh::Real>( "w_O" );
w_O = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 4 );
libMesh::Real& w_OH = params.set<libMesh::Real>( "w_OH" );
w_OH = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 5 );
libMesh::Real& w_HO2 = params.set<libMesh::Real>( "w_HO2" );
w_HO2 = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 6 );
libMesh::Real& w_H2O2 = params.set<libMesh::Real>( "w_H2O2" );
w_H2O2 = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 7 );
libMesh::Real& w_N2 = params.set<libMesh::Real>( "w_N2" );
w_N2 = libMesh_inputfile( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 8 );
std::cout << "==============================================" << std::endl;
std::cout << "Projecting Solution." << std::endl;
std::cout << "==============================================" << std::endl;
system.project_solution( initial_values, NULL, params );
std::cout << "==============================================" << std::endl;
std::cout << "Done Projecting Solution!" << std::endl;
std::cout << "==============================================" << std::endl;
}
/* If we're restarting to try and get ignition, then we need to setup a
"restart" system and using the IgniteInitalGuess functor to do the projection
on the "real" system. */
if( libMesh_inputfile( "restart-options/ignition", false ) &&
restart_file != std::string("none") )
{
std::string system_name = libMesh_inputfile( "screen-options/system_name", "GRINS" );
/*
GetPot restart_input( "bunsen_restart.in" );
GRINS::Simulation restart_sim( restart_input,
sim_builder );
std::tr1::shared_ptr<libMesh::EquationSystems> restart_es = restart_sim.get_equation_system();
libMesh::System& restart_system = restart_es->get_system(system_name);
GRINS::MultiphysicsSystem& restart_ms_system = libmesh_cast_ref<GRINS::MultiphysicsSystem&>( restart_system );
*/
std::tr1::shared_ptr<libMesh::EquationSystems> es = grins.get_equation_system();
libMesh::System& system = es->get_system(system_name);
GRINS::MultiphysicsSystem& ms_system = libmesh_cast_ref<GRINS::MultiphysicsSystem&>( system );
Bunsen::IgniteInitialGuess<libMesh::Real> ignite( libMesh_inputfile, ms_system,
ms_system );
es->reinit();
std::cout << "==============================================" << std::endl;
std::cout << "Projecting Solution." << std::endl;
std::cout << "==============================================" << std::endl;
ms_system.project_solution( &ignite );
std::cout << "==============================================" << std::endl;
std::cout << "Done Projecting Solution!" << std::endl;
std::cout << "==============================================" << std::endl;
}
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.EndTimer("Initialize Solver");
// Attach GRVY timer to solver
grins.attach_grvy_timer( &grvy_timer );
#endif
grins.run();
#ifdef GRINS_USE_GRVY_TIMERS
grvy_timer.Finalize();
if( Parallel::Communicator_World.rank() == 0 ) grvy_timer.Summarize();
#endif
return 0;
}
