int main(int argc, char* argv[])
{
// Register new solver
GRINS::SolverFactoryBasic<GRINS::PressureContinuationSolver>
press_solver_factory("pressure_continuation");
GRINS::Runner grins(argc,argv);
grins.init();
grins.run();
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.
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 < 3 )
{
// TODO: Need more consistent error handling.
std::cerr << "Error: Must specify libMesh input file and exact solution file." << std::endl;
exit(1); // TODO: something more sophisticated for parallel runs?
}
GRINS::Runner grins(argc,argv);
int return_flag = 0;
return_flag = run( argv, grins );
return return_flag;
}
int main(int argc, char* argv[])
{
GRINS::Runner grins(argc,argv);
grins.init();
const GetPot & inputfile = grins.get_input_file();
//FIXME: We need to move this to within the Simulation object somehow...
std::string restart_file = inputfile( "restart-options/restart_file", "none" );
if( restart_file == "none" )
{
GRINS::Simulation & sim = grins.get_simulation();
// Asssign initial temperature value
std::string system_name = inputfile( "screen-options/system_name", "GRINS" );
std::shared_ptr<libMesh::EquationSystems> es = sim.get_equation_system();
const libMesh::System& system = es->get_system(system_name);
libMesh::Parameters ¶ms = es->parameters;
libMesh::Real T_init = inputfile("Materials/Gas/ReferenceTemperature/value", 0.0);
libMesh::Real p0_init = inputfile("Materials/Gas/ThermodynamicPressure/value", 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 );
}
grins.run();
return 0;
}
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 run( int argc, char* argv[], const GetPot& input )
{
// Initialize libMesh library.
libMesh::LibMeshInit libmesh_init(argc, argv);
GRINS::SimulationBuilder sim_builder;
std::tr1::shared_ptr<GRINS::BoundaryConditionsFactory> bc_factory( new NitridationCalibration::BoundaryConditionsFactory(input) );
sim_builder.attach_bc_factory( bc_factory );
std::tr1::shared_ptr<GRINS::QoIFactory> qoi_factory( new NitridationCalibration::QoIFactory );
sim_builder.attach_qoi_factory( qoi_factory );
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" );
std::tr1::shared_ptr<NitridationCalibration::TubeTempBC> wall_temp;
std::string system_name = input( "screen-options/system_name", "GRINS" );
if( restart_file == "none" )
{
// Asssign initial temperature value
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_1", 0.0, 0 );
libMesh::Real& w_N = params.set<libMesh::Real>( "w_N" );
w_N = input( "Physics/ReactingLowMachNavierStokes/bound_species_1", 0.0, 1 );
wall_temp.reset( new NitridationCalibration::TubeTempBC( input ) );
std::tr1::shared_ptr<NitridationCalibration::TubeTempBC>& dummy = params.set<std::tr1::shared_ptr<NitridationCalibration::TubeTempBC> >( "wall_temp" );
dummy = wall_temp;
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();
//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(system_name, "u");
exact_sol.compute_error(system_name, "v");
if( (es->get_mesh()).mesh_dimension() == 3 )
exact_sol.compute_error(system_name, "w");
exact_sol.compute_error(system_name, "p");
exact_sol.compute_error(system_name, "T");
exact_sol.compute_error(system_name, "w_N2");
exact_sol.compute_error(system_name, "w_N");
exact_sol.compute_error(system_name, "w_CN");
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");
double T_l2error = exact_sol.l2_error(system_name, "T");
double T_h1error = exact_sol.h1_error(system_name, "T");
double wN_l2error = exact_sol.l2_error(system_name, "w_N");
double wN_h1error = exact_sol.h1_error(system_name, "w_N");
double wN2_l2error = exact_sol.l2_error(system_name, "w_N2");
double wN2_h1error = exact_sol.h1_error(system_name, "w_N2");
double wCN_l2error = exact_sol.l2_error(system_name, "w_CN");
double wCN_h1error = exact_sol.h1_error(system_name, "w_CN");
double w_l2error = 0.0,
w_h1error = 0.0;
if( (es->get_mesh()).mesh_dimension() == 3 )
{
w_l2error = exact_sol.l2_error(system_name, "w");
w_h1error = exact_sol.h1_error(system_name, "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 = 5.0e-10;
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 ||
wN_l2error > tol || wN_h1error > tol ||
wN2_l2error > tol || wN2_h1error > tol ||
wCN_l2error > tol || wCN_h1error > tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for solution fields." << 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
<< "w_N l2 error = " << wN_l2error << std::endl
<< "w_N h1 error = " << wN_h1error << std::endl
<< "w_N2 l2 error = " << wN2_l2error << std::endl
<< "w_N2 h1 error = " << wN2_h1error << std::endl
<< "w_CN l2 error = " << wCN_l2error << std::endl
<< "w_CN h1 error = " << wCN_h1error << std::endl;
}
// Now test QoI Values
const libMesh::Real mass_loss_reg = atof(argv[3]);
const libMesh::Real avg_N_reg = atof(argv[4]);
/* The value we compute is negative by convention, but the data are given
as positive by convention, so convert to data convention. */
const libMesh::Real mass_loss_comp = std::fabs(grins.get_qoi_value(0));
const libMesh::Real avg_N_comp = grins.get_qoi_value(1);
const double qoi_tol = 1.0e-9;
const double mass_loss_error = std::fabs( (mass_loss_comp - mass_loss_reg)/mass_loss_reg );
const double avg_N_error = std::fabs( (avg_N_comp - avg_N_reg)/avg_N_reg );
if( mass_loss_error > qoi_tol ||
avg_N_error > qoi_tol )
{
return_flag = 1;
std::cout << "Tolerance exceeded for qoi values." << std::endl
<< "tolerance = " << qoi_tol << std::endl
<< "mass loss = " << mass_loss_comp << std::endl
<< "avg N = " << avg_N_comp << std::endl
<< "mass loss error = " << mass_loss_error << std::endl
<< "avg N error = " << avg_N_error << std::endl;
}
return return_flag;
}
int main(int argc, char* argv[])
{
GRINS::Runner grins(argc,argv);
// This is a tough problem to get to converge without PETSc
libmesh_example_requires
(libMesh::default_solver_package() != libMesh::LASPACK_SOLVERS,
"--enable-petsc");
grins.init();
const GetPot & inputfile = grins.get_input_file();
GRINS::Simulation & sim = grins.get_simulation();
//FIXME: We need to move this to within the Simulation object somehow...
std::string restart_file = inputfile( "restart-options/restart_file", "none" );
if( restart_file == "none" )
{
// Asssign initial temperature value
std::string system_name = inputfile( "screen-options/system_name", "GRINS" );
std::shared_ptr<libMesh::EquationSystems> es = sim.get_equation_system();
const libMesh::System& system = es->get_system(system_name);
libMesh::Parameters ¶ms = es->parameters;
libMesh::Real T_init = inputfile("Materials/TestMaterial/ReferenceTemperature/value", 0.0);
libMesh::Real p0_init = inputfile("Materials/TestMaterial/ThermodynamicPressure/value", 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 );
}
grins.run();
libMesh::Real qoi = sim.get_qoi_value(0);
// Note that this is a *really* coarse mesh. This is just for testing
// and not even close to the real QoI for this problem.
// Erroneous value from libMesh 0.9.2.2
// const libMesh::Real exact_qoi = 4.8158910676325055;
// Value after libMesh 7acb6fc9 bugfix
const libMesh::Real exact_qoi = 4.8654229502012685;
const libMesh::Real tol = 1.0e-9;
int return_flag = 0;
libMesh::Real rel_error = std::fabs( (qoi-exact_qoi)/exact_qoi );
if( rel_error > tol )
{
// Skip this test until we know what changed
// return_flag = 1;
return_flag = 77;
std::cerr << std::setprecision(16)
<< std::scientific
<< "Error: QoI value mismatch." << std::endl
<< "Computed qoi = " << qoi << std::endl
<< "Exact qoi = " << exact_qoi << std::endl
<< "Relative error = " << rel_error << std::endl;
}
return return_flag;
}
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;
}
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;
}
