int run( char* argv[], GRINS::Runner & grins )
{
grins.init();
grins.run();
GRINS::Simulation & sim = grins.get_simulation();
// Get equation systems to create ExactSolution object
std::shared_ptr<libMesh::EquationSystems>
es = sim.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("StretchedElasticSheet", "u");
exact_sol.compute_error("StretchedElasticSheet", "v");
exact_sol.compute_error("StretchedElasticSheet", "w");
double u_l2error = exact_sol.l2_error("StretchedElasticSheet", "u");
double u_h1error = exact_sol.h1_error("StretchedElasticSheet", "u");
double v_l2error = exact_sol.l2_error("StretchedElasticSheet", "v");
double v_h1error = exact_sol.h1_error("StretchedElasticSheet", "v");
double w_l2error = exact_sol.l2_error("StretchedElasticSheet", "w");
double w_h1error = exact_sol.h1_error("StretchedElasticSheet", "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 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;
}
return return_flag;
}
//Write all headers, empty line, and body
//TODO: support for live forwarding of chunked encoding.
static inline int write_common(HTTP_Message* message, int connection)
{
//Write headers
if(write_headers(message->headers, connection)) return 1;
//Write blank line
if(write_ref(es_temp("\r\n"), connection)) return 1;
//Write body
if(write_ref(es_ref(&message->body), connection)) return 1;
return 0;
}
static inline int write_request_line(HTTP_ReqLine* line, int connection)
{
if(write_ref(method_name(line->method), connection)) return 1;
if(write_ref(es_temp(" "), connection)) return 1;
if(line->domain.size)
{
if(write_ref(es_temp("http://"), connection)) return 1;
if(write_ref(es_ref(&line->domain), connection)) return 1;
}
if(write_str(es_printf("/%.*s HTTP/1.%c\r\n", ES_STRINGPRINT(&line->path),
line->http_version), connection))
return 1;
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 < 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 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[])
{
// 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;
}
static inline int write_str(String str, int connection)
{
int result = write_ref(es_ref(&str), connection);
es_free(&str);
return result;
}
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;
}
