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[])
{
/* 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;
}
//---------------------------------------------------------------------------//
// Example driver.
//---------------------------------------------------------------------------//
int main(int argc, char* argv[])
{
// INITIALIZATION
// --------------
// Setup communication.
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
// Extract the raw mpi communicator.
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
Teuchos::RCP<const Teuchos::MpiComm<int> > mpi_comm =
Teuchos::rcp_dynamic_cast<const Teuchos::MpiComm<int> >(comm);
Teuchos::RCP<const Teuchos::OpaqueWrapper<MPI_Comm> > opaque_comm =
mpi_comm->getRawMpiComm();
MPI_Comm raw_comm = (*opaque_comm)();
// Build the parameter list from the xml input.
Teuchos::RCP<Teuchos::ParameterList> plist = Teuchos::rcp(
new Teuchos::ParameterList());
Teuchos::updateParametersFromXmlFile("input.xml",
Teuchos::inoutArg(*plist));
// Load the mesh.
Teuchos::RCP<moab::Interface> source_iface = Teuchos::rcp(new moab::Core());
std::string meshFileName("sahex1_unic.h5m");
std::string options = std::string(
"PARALLEL=READ_PART;PARTITION=PARALLEL_PARTITION;"
"PARALLEL_RESOLVE_SHARED_ENTS;PARTITION_DISTRIBUTE;"
"PARALLEL_GHOSTS=3.0.1;");
source_iface->load_file(meshFileName.c_str(), 0, options.c_str());
// Get the parallel moab instance.
Teuchos::RCP<moab::ParallelComm> source_mesh = Teuchos::rcp(
moab::ParallelComm::get_pcomm(source_iface.getRawPtr(),0), false );
// Get the entity set for the source part. Just use the root set for now.
moab::EntityHandle source_set = source_iface->get_root_set();
// Get the nodes in the source set.
std::vector<moab::EntityHandle> source_nodes;
moab::ErrorCode error = source_iface->get_entities_by_type(
source_set, moab::MBVERTEX, source_nodes);
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
int num_source_nodes = source_nodes.size();
// Create a mesh set for just the source nodes. We need this so we can
// build a vector over the nodes.
moab::EntityHandle source_node_set;
error = source_iface->create_meshset(0, source_node_set);
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
error = source_iface->add_entities(source_node_set,
source_nodes.data(),
num_source_nodes);
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
// Create a source data tag.
moab::Tag source_data_tag;
std::string source_data_tag_name("u_src");
double default_val = 0.0;
bool created = false;
error = source_iface->tag_get_handle(source_data_tag_name.c_str(), 1,
moab::MB_TYPE_DOUBLE, source_data_tag,
moab::MB_TAG_DENSE | moab::MB_TAG_CREAT,
static_cast<void*>(&default_val), &created);
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
assert(created);
// Create some data and put it on the tag.
Teuchos::Array<double> source_tag_data(num_source_nodes);
Teuchos::Array<double> source_coords(3);
for (int n = 0; n < num_source_nodes; ++n) {
error = source_iface->get_coords(&source_nodes[n], 1,
source_coords.getRawPtr());
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
source_tag_data[n] = dataFunction(source_coords[0], source_coords[1],
source_coords[2]);
}
error = source_iface->tag_set_data(
source_data_tag, source_nodes.data(),
num_source_nodes, static_cast<void*>(source_tag_data.getRawPtr()));
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
// Make the tag parallel consistent.
moab::Range shared_entities;
error = source_mesh->get_shared_entities( -1, shared_entities, -1, false, true );
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
error = source_mesh->exchange_tags( source_data_tag, shared_entities );
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
// TARGET MESH READ
// ----------------
// Initialize libmesh.
libMesh::LibMeshInit libmesh_init( argc, argv, raw_comm );
// Create a target mesh.
Teuchos::RCP<libMesh::Mesh> tgt_mesh = Teuchos::rcp(
new libMesh::Mesh(libmesh_init.comm()));
tgt_mesh->read("sahex.e");
// Make a libmesh system. We will put a first order linear basis on the
// elements for all subdomains.
std::string tgt_var_name = "tgt_var";
std::string tgt_err_name = "tgt_err";
libMesh::EquationSystems tgt_equation_systems(*tgt_mesh);
libMesh::System& tgt_system = tgt_equation_systems.add_system<
libMesh::ExplicitSystem>("Target System");
int tgt_var_id = tgt_system.add_variable(tgt_var_name);
int tgt_err_id = tgt_system.add_variable(tgt_err_name);
tgt_equation_systems.init();
// SETUP DTK DATA
// --------------
// Create a manager for the source set elements.
DataTransferKit::MoabManager src_manager(source_mesh, source_set);
// Create a manager for the target set nodes.
DataTransferKit::LibmeshManager tgt_manager(tgt_mesh,
Teuchos::rcpFromRef(tgt_system));
// Create a solution vector for the source.
Teuchos::RCP<Tpetra::MultiVector<double, int, DataTransferKit::SupportId> > src_vector =
src_manager.createFieldMultiVector(source_node_set,
source_data_tag);
// Create a solution vector for the target.
Teuchos::RCP<Tpetra::MultiVector<double, int, DataTransferKit::SupportId> > tgt_vector =
tgt_manager.createFieldMultiVector(tgt_var_name);
// Print out mesh info.
Teuchos::RCP<Teuchos::FancyOStream>
fancy_out = Teuchos::VerboseObjectBase::getDefaultOStream();
fancy_out->setShowProcRank( true );
src_manager.functionSpace()->entitySet()->describe( *fancy_out );
tgt_manager.functionSpace()->entitySet()->describe( *fancy_out );
// Create a map operator.
Teuchos::ParameterList& dtk_list = plist->sublist("DataTransferKit");
DataTransferKit::MapOperatorFactory op_factory;
Teuchos::RCP<DataTransferKit::MapOperator> map_op =
op_factory.create(src_vector->getMap(), tgt_vector->getMap(),
dtk_list);
// Setup the map operator.
map_op->setup(src_manager.functionSpace(), tgt_manager.functionSpace());
// SOLUTION TRANSFER
// -----------------
// Apply the map operator.
map_op->apply(*src_vector, *tgt_vector);
// COMPUTE THE SOLUTION ERROR
// --------------------------
double gold_value = 0.0;
double error_l2_norm = 0.0;
double var_l2_norm = 0.0;
double tgt_value = 0.0;
std::unordered_map<libMesh::dof_id_type, double> tgt_val_map;
std::unordered_map<libMesh::dof_id_type, double> error_val_map;
libMesh::Mesh::const_element_iterator elements_begin =
tgt_mesh->local_elements_begin();
libMesh::Mesh::const_element_iterator elements_end =
tgt_mesh->local_elements_end();
std::vector<libMesh::dof_id_type> elem_dof_ids;
int elem_n_nodes = 0;
libMesh::Node* node;
std::vector<libMesh::dof_id_type> err_dof_ids;
for (auto element = elements_begin; element != elements_end; ++element) {
tgt_system.get_dof_map().dof_indices(*element, elem_dof_ids,
tgt_var_id);
tgt_system.get_dof_map().dof_indices(*element, err_dof_ids, tgt_err_id);
elem_n_nodes = (*element)->n_nodes();
for (int n = 0; n < elem_n_nodes; ++n)
{
node = (*element)->get_node(n);
if ( comm->getRank() == node->processor_id() )
{
gold_value = dataFunction((*node)(0), (*node)(1), (*node)(2));
tgt_value = tgt_system.solution->el(elem_dof_ids[n]);
tgt_system.solution->set(err_dof_ids[n],
(tgt_value - gold_value) / gold_value);
tgt_val_map.emplace(err_dof_ids[n], tgt_value * tgt_value);
error_val_map.emplace(err_dof_ids[n],
(tgt_value - gold_value) * (tgt_value - gold_value));
}
}
}
tgt_system.solution->close();
tgt_system.update();
for (auto tval = tgt_val_map.begin(), eval = error_val_map.begin();
tval != tgt_val_map.end(); ++tval, ++eval) {
var_l2_norm += tval->second;
error_l2_norm += eval->second;
}
error_l2_norm = std::sqrt(error_l2_norm);
var_l2_norm = std::sqrt(var_l2_norm);
std::cout << "|e|_2 / |f|_2: " << error_l2_norm / var_l2_norm << std::endl;
// SOURCE MESH WRITE
// -----------------
error = source_iface->write_file("source_moab_out.h5m", "H5M",
"PARALLEL=WRITE_PART", &source_set, 1, &source_data_tag, 1);
checkMoabErrorCode(error);
assert(moab::MB_SUCCESS == error);
// TARGET MESH WRITE
// -----------------
libMesh::ExodusII_IO(*tgt_mesh).write_equation_systems(
"target_libmesh_out.exo", tgt_equation_systems);
}
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;
}
