int main(int argc, char** argv)
{
std::string working_directory = "";
std::string decomp_method = "";
std::string mesh = "";
std::string type = "exodusii";
size_t spatial_dimension = 3;
int compression_level = 0;
bool compression_shuffle = false;
int db_integer_size = 4;
//----------------------------------
// Process the broadcast command line arguments
bopt::options_description desc("options");
// NOTE: Options --directory --output-log --runtest are handled/defined in UseCaseEnvironment
desc.add_options()
("directory,d", bopt::value<std::string>(&working_directory),
"working directory with trailing '/'" )
("decomposition,D", bopt::value<std::string>(&decomp_method),
"decomposition method" )
("mesh", bopt::value<std::string>(&mesh),
"mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. See GeneratedMesh documentation for more options. Can also specify a filename. The generated mesh will be output to the file 'generated_mesh.out'" )
("dimension", bopt::value<size_t>(&spatial_dimension), "problem spatial dimension" )
("compression_level", bopt::value<int>(&compression_level), "compression level [1..9] to use" )
("shuffle", bopt::value<bool>(&compression_shuffle), "use shuffle filter prior to compressing data" )
("db_integer_size", bopt::value<int>(&db_integer_size), "use 4 or 8-byte integers on output database" );
stk::get_options_description().add(desc);
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
if (mesh.empty()) {
std::cerr << "\nERROR: The --mesh option is required\n";
std::cerr << "\nApplication " << desc << "\n";
std::exit(EXIT_FAILURE);
}
type = "exodusii";
if (strncasecmp("gen:", mesh.c_str(), 4) == 0) {
mesh = mesh.substr(4, mesh.size());
type = "generated";
}
if (strncasecmp("dof:", mesh.c_str(), 4) == 0) {
mesh = mesh.substr(4, mesh.size());
type = "dof";
}
driver(use_case_environment.m_comm, spatial_dimension,
working_directory, mesh, type, decomp_method,
compression_level, compression_shuffle, db_integer_size);
return 0;
}
int main ( int argc, char * argv[] )
{
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
stk::ParallelMachine parallel_machine = use_case_environment.m_comm;
bool status = true;
{
std::cout << "Use Case 1, unequal element weights ... ";
bool local_status = stk::rebalance::use_cases::test_unequal_weights(parallel_machine);
stk::all_reduce(parallel_machine, stk::ReduceMin<1>(&local_status));
printStatus(local_status);
status = status && local_status;
}
{
std::cout << "Use Case 2, heavy entities ... ";
bool local_status = stk::rebalance::use_cases::test_heavy_nodes(parallel_machine);
stk::all_reduce(parallel_machine, stk::ReduceMin<1>(&local_status));
printStatus(local_status);
status = status && local_status;
}
{
std::cout << "Use Case 3, contact surfaces ... ";
bool local_status = stk::rebalance::use_cases::test_contact_surfaces(parallel_machine);
stk::all_reduce(parallel_machine, stk::ReduceMin<1>(&local_status));
printStatus(local_status);
status = status && local_status;
}
{
std::cout << "Use Case 4, greedy sideset ... ";
bool local_status = stk::rebalance::use_cases::test_greedy_sideset(parallel_machine);
stk::all_reduce(parallel_machine, stk::ReduceMin<1>(&local_status));
printStatus(local_status);
status = status && local_status;
}
bool collective_result = use_case::print_status(parallel_machine, status);
int return_code = collective_result ? 0 : -1;
return return_code;
}
int main(int argc, char **argv)
{
#ifdef STK_MESH_TRACE_ENABLED
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
#else
stk::parallel_machine_init(&argc, &argv);
#endif
testing::InitGoogleTest(&argc, argv);
gl_argc = argc;
gl_argv = argv;
int returnVal = RUN_ALL_TESTS();
#ifndef STK_MESH_TRACE_ENABLED
stk::parallel_machine_finalize();
#endif
return returnVal;
}
int main(int argc, char** argv)
{
stk::search::Options range;
stk::search::Options domain;
std::string working_directory = "";
bool performance = false;
/** \todo IMPLEMENT -- what should the syntax and options for this look like? */
std::string search_type = "";
//----------------------------------
// Process the broadcast command line arguments
bopt::options_description desc("options");
// NOTE: Options --directory --output-log --runtest are handled/defined in UseCaseEnvironment
desc.add_options()
("directory,d", bopt::value<std::string>(&working_directory),
"working directory with trailing '/'" )
("search_type", bopt::value<std::string>(&search_type),
"type of search to run. Valid options are:\n"
" point_in_box: \tdomain consists of an axis-aligned bounding box for each 'domain_entity' in the mesh,"
"range is a PointBoundingBox3D at the centroid of each'range_entity'\n"
" overlap: \tdomain consists of an axis-aligned bounding box for each 'domain_entity' in the mesh,"
"range is also an axis-aligned bounding box of each 'range_entity'.")
("range_mesh", bopt::value<std::string>(&range.mesh_filename),
"range mesh file.\n \tUse name of form 'gen:NxMxL' to generate a hex mesh of size N by M by L intervals.\n\tUse --helpmesh for more detailed help on the mesh options.")
("range_entity", bopt::value<std::string>(&range.entity)->default_value("element"),
"Entity type to use for range:\n"
" node: \tAll nodes in the model,\n"
" nodeset: \tAll nodes in a nodeset,\n"
" edge: \tAll edges in the model (probably none),\n"
" face: \tSkin the model and use all exposed faces,\n"
" faceset: \tFaces, but only those faces in a faceset,\n"
" element: \tAll elements in the model.")
("range_offset",
bopt::value<double>(&range.offset)->default_value(0.0),
"offset to be applied to domain axis-aligned bounding boxes. The bounding box extent will be increased by this amount in each direction." )
("range_scale",
bopt::value<double>(&range.scale)->default_value(0.0),
"scale factor to be applied to domain axis-aligned bounding boxes. The bounding box extent will be increased by max_d*scale+offset where max_d is max of max_i-min_i for i=x,y,z)" )
("domain_mesh", bopt::value<std::string>(&domain.mesh_filename),
"domain mesh file."
"\n \tUse name of form 'gen:NxMxL' to generate a hex mesh of size N by M by L intervals."
"\n \tUse --helpmesh for more detailed help on the mesh options." )
("domain_entity", bopt::value<std::string>(&domain.entity)->default_value("element"),
"Entity type to use for domain:\n"
" node: \tAll nodes in the model,\n"
" nodeset: \tAll nodes in a nodeset,\n"
" edge: \tAll edges in the model (probably none),\n"
" face: \tSkin the model and use all exposed faces,\n"
" faceset: \tFaces, but only those faces in a faceset,\n"
" element: \tAll elements in the model.")
("domain_offset",
bopt::value<double>(&domain.offset)->default_value(0.0),
"offset to be applied to domain axis-aligned bounding boxes. The bounding box extent will be increased by this amount in each direction." )
("domain_scale",
bopt::value<double>(&domain.scale)->default_value(0.0),
"scale factor to be applied to domain axis-aligned bounding boxes. The bounding box extent will be increased by max_d*scale+offset where max_d is max of max_i-min_i for i=x,y,z)" )
("performance", "Run to measure performance; disable output that may affect runtime.")
("helpmesh", "Print detailed description of mesh options and then exit.");
stk::get_options_description().add(desc);
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
bopt::variables_map &vm = stk::get_variables_map();
//----------------------------------
if (vm.count("helpmesh")) {
stk::io::show_mesh_help();
std::exit(EXIT_SUCCESS);
}
if (vm.count("performance"))
performance = true;
if (search_type.empty()) {
std::cerr << "\nOPTION ERROR: A --search_type must be specified.\n\n";
std::cerr << stk::get_options_description() << "\n";
std::exit(EXIT_FAILURE);
}
if (range.mesh_filename.empty()) {
std::cerr << "\nOPTION ERROR: The '--range_mesh <filename>' option is required for the use cases!\n\n";
std::cerr << stk::get_options_description() << "\n";
std::exit(EXIT_FAILURE);
}
if (domain.mesh_filename.empty()) {
domain.mesh_filename = range.mesh_filename;
domain.mesh_type = range.mesh_type;
}
if (strncasecmp("gen:", range.mesh_filename.c_str(), 4) == 0) {
// Strip off the 'gen:' prefix and set the type to "generated"
range.mesh_filename = range.mesh_filename.substr(4, range.mesh_filename.size());
range.mesh_type = "generated";
}
if (strncasecmp("gen:", domain.mesh_filename.c_str(), 4) == 0) {
// Strip off the 'gen:' prefix and set the type to "generated"
domain.mesh_filename = domain.mesh_filename.substr(4, domain.mesh_filename.size());
domain.mesh_type = "generated";
}
performance_driver(use_case_environment.m_comm,
working_directory,
search_type,
range,
domain,
performance);
return 0;
}
int main(int argc, char** argv)
{
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
stk_classic::ParallelMachine comm = use_case_environment.m_comm;
//----------------------------------
// Broadcast argc and argv to all processors.
stk_classic::BroadcastArg b_arg(comm, argc, argv);
//----------------------------------
// Process the broadcast command line arguments
bopt::options_description desc("options");
stk_classic::get_options_description().add(desc);
int num_trials = 0;
int nthreads = 1;
int bucket_size = 1000;
desc.add_options()
("help,h", "produce help message")
("performance", "run performance test [14/14a/blas only]")
("mesh,m", bopt::value<std::string>(), "mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. See GeneratedMesh documentation for more options. Use 'gears' to generate the gears mesh." )
("directory,d", bopt::value<std::string>(), "working directory with trailing '/'" )
("output-log,o", bopt::value<std::string>(), "output log path" )
("runtest,r", bopt::value<std::string>(), "runtest pid file" )
("threads", bopt::value<int>(&nthreads)->default_value(1), "number of threads [14/14a/blas only]")
("trials", bopt::value<int>(&num_trials)->default_value(1), "number of trials (execute loops) [14/14a/blas only]")
("bucket_size", bopt::value<int>(&bucket_size)->default_value(1000), "size of buckets used internally in stk_classic::mesh [14/14a/blas only]")
("tbb", "Use Threaded Building Blocks algorithm thread runner [14/14a/blas only]")
("tpi", "Use Thread Pool Interface algorithm thread runner [14/14a/blas only]")
("nonthreaded", "Run algorithms non-threaded [default] [14/14a/blas only]")
( use_case_7 , "use case 7" )
( use_case_blas , "use case blas (fill, axpby, dot, norm)" )
( use_case_14 , "use case 14 (hex internal force algorithm)" )
( use_case_14a , "use case 14a (hex internal force algorithm)" )
( use_case_24 , "use case 24 " );
bopt::variables_map vm;
try {
bopt::store(bopt::parse_command_line(b_arg.m_argc, b_arg.m_argv, desc), vm);
bopt::notify(vm);
}
catch (std::exception &x) {
std::cout << x.what() << std::endl;
std::exit(1);
}
//----------------------------------
if (vm.count("help")) {
std::cout << desc << "\n";
std::exit(EXIT_SUCCESS);
}
bool run_performance_test = vm.count( "performance" ) > 0;
std::string thread_runner = "NonThreaded";
if (vm.count("tbb"))
thread_runner = "TBB";
if (vm.count("tpi"))
thread_runner = "TPI";
// if (vm.count("dgb"))
// thread_runner = "DGB";
if (vm.count("nonthreaded"))
thread_runner = "NonThreaded";
std::string working_directory = "";
std::string in_filename = "";
std::string in_filetype = "exodusii";
if (vm.count("mesh")) {
in_filename = boost::any_cast<std::string>(vm["mesh"].value());;
if (strncasecmp("gen:", in_filename.c_str(), 4) == 0) {
// Strip off the 'gen:' prefix and set the type to "generated"
in_filename = in_filename.substr(4, in_filename.size());
in_filetype = "generated";
}
if (strncasecmp("gears:", in_filename.c_str(), 6) == 0) {
// Strip off the 'gears:' prefix and set the type to "gears"
in_filename = in_filename.substr(6, in_filename.size());
in_filetype = "gears";
}
if (vm.count("directory")) {
working_directory = boost::any_cast<std::string>(vm["directory"].value());
}
} else {
std::cout << "OPTION ERROR: The '--mesh <filename>' option is required for all use cases!\n";
std::exit(EXIT_FAILURE);
}
bool success = false;
if ( vm.count( use_case_7 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 7, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
success = stk_classic::app::use_case_7_driver( comm , run_performance_test , in_filename , nthreads, thread_runner );
}
else if ( vm.count( use_case_blas ) ) {
success = stk_classic::app::use_case_blas_driver(comm, nthreads, num_trials, working_directory,
in_filename, in_filetype, thread_runner, bucket_size,
run_performance_test);
}
else if ( vm.count( use_case_14 ) ) {
success = stk_classic::app::use_case_14_driver(comm, nthreads, num_trials, working_directory,
in_filename, in_filetype, thread_runner, bucket_size,
run_performance_test);
}
else if ( vm.count( use_case_14a ) ) {
success = stk_classic::app::use_case_14a_driver(comm, nthreads, num_trials, working_directory,
in_filename, in_filetype, thread_runner, bucket_size,
run_performance_test);
}
else if ( vm.count( use_case_24 ) ) {
if (in_filetype == "generated") {
std::cout << "OPTION ERROR: The 'generated mesh option' option is not supported for use case 24!\n";
std::exit(EXIT_FAILURE);
}
if (in_filetype == "gears") {
std::cout << "OPTION ERROR: The 'gears mesh option' option is not supported for use case 24!\n";
std::exit(EXIT_FAILURE);
}
success = stk_classic::app::use_case_24_driver( comm, working_directory, in_filename, "1mCube.e" );
}
else {
std::cout << "OPTION ERROR: Missing a use case selection option. Use --help option to see valid options.\n";
std::exit(EXIT_FAILURE);
}
use_case::print_status(comm, success);
return 0;
}
int main(int argc, char **argv)
{
stk::diag::Timer timer("Transfer Use Cases",
use_case::TIMER_TRANSFER,
use_case::timer());
use_case::timerSet().setEnabledTimerMask(use_case::TIMER_ALL);
bool status = true;
std::string range_mesh = "9x9x9";
std::string range_mesh_type = "generated";
std::string domain_mesh = "8x8x8";
std::string domain_filetype = "generated";
//----------------------------------
// Process the broadcast command line arguments
bopt::options_description desc("Transfer use case options");
// NOTE: Options --directory --output-log --runtest are handled/defined in UseCaseEnvironment
desc.add_options()
("range_mesh", bopt::value<std::string>(&range_mesh),
"range mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. "
"See GeneratedMesh documentation for more options. Use 'gears' to generate the gears mesh." )
("domain_mesh", bopt::value<std::string>(&domain_mesh),
"domain mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. "
"See GeneratedMesh documentation for more options. Use 'gears' to generate the gears mesh." )
("use_case_5", "transfer use case 5 -- node (range) to node (domain) copy search." )
("use_case_6", "transfer use case 6 -- node (range) to node (domain) copy search." )
("use_case_7", "transfer use case 7 -- node (range) to node (domain) copy search." )
("use_case_8", "transfer use case 8 -- node (range) to node (domain) copy search." )
("offset", bopt::value<double>()->default_value(0.1), "transfer use case 3 offset" )
("scale", bopt::value<double>()->default_value(0.0), "transfer use case 3 scale." )
;
stk::get_options_description().add(desc);
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
const std::string working_directory = use_case_environment.m_workingDirectory;
bopt::variables_map &vm = stk::get_variables_map();
stk::ParallelMachine comm = use_case_environment.m_comm;
if (vm.count("use_case_5")) {
status = use_case_5_driver(comm);
}
if (vm.count("use_case_6")) {
status = status && use_case_6_driver(comm, working_directory, range_mesh, range_mesh_type, domain_mesh, domain_filetype);
}
if (vm.count("use_case_7")) {
status = status && use_case_7_driver(comm, working_directory, domain_mesh, domain_filetype);
}
if (vm.count("use_case_8")) {
status = status && use_case_8_driver(comm, working_directory, domain_mesh, domain_filetype);
}
timer.stop();
const bool collective_result = use_case::print_status(comm, status);
const int return_code = collective_result ? 0 : -1;
return return_code;
}
int main(int argc, char** argv)
{
std::string working_directory = "";
std::string range_mesh = "";
std::string range_filetype = "exodusii";
std::string range_entity = "";
std::string domain_mesh = "";
std::string domain_filetype = "exodusii";
std::string domain_entity = "";
//----------------------------------
// Process the broadcast command line arguments
bopt::options_description desc("Search use case options");
// NOTE: Options --directory --output-log --runtest are handled/defined in UseCaseEnvironment
desc.add_options()
("range_mesh", bopt::value<std::string>(&range_mesh),
"range mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. See GeneratedMesh documentation for more options. Use 'gears' to generate the gears mesh." )
("domain_mesh", bopt::value<std::string>(&domain_mesh),
"domain mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. See GeneratedMesh documentation for more options. Use 'gears' to generate the gears mesh." )
("range_entity", bopt::value<std::string>(&range_entity)->default_value("element"),
"node, edge, face, element")
("domain_entity", bopt::value<std::string>(&domain_entity)->default_value("element"),
"node, edge, face, element")
("use_case_1", "search use case 1" )
("use_case_4", "search use case 4" );
stk::get_options_description().add(desc);
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
bopt::variables_map &vm = stk::get_variables_map();
//----------------------------------
if (range_mesh.empty()) {
std::cerr << "OPTION ERROR: The '--range_mesh <filename>' option is required for the use cases!\n";
std::cerr << stk::get_options_description() << std::endl;
std::exit(EXIT_FAILURE);
}
if (domain_mesh.empty()) {
domain_mesh = range_mesh;
domain_filetype = range_filetype;
}
if (strncasecmp("gen:", range_mesh.c_str(), 4) == 0) {
// Strip off the 'gen:' prefix and set the type to "generated"
range_mesh = range_mesh.substr(4, range_mesh.size());
range_filetype = "generated";
}
if (strncasecmp("gears:", range_mesh.c_str(), 5) == 0) {
// Strip off the 'gears:' prefix and set the type to "gears"
range_mesh = range_mesh.substr(6, range_mesh.size());
range_filetype = "gears";
}
if (strncasecmp("gen:", domain_mesh.c_str(), 4) == 0) {
// Strip off the 'gen:' prefix and set the type to "generated"
domain_mesh = domain_mesh.substr(4, domain_mesh.size());
domain_filetype = "generated";
}
if (strncasecmp("gears:", domain_mesh.c_str(), 6) == 0) {
// Strip off the 'gears:' prefix and set the type to "gears"
domain_mesh = domain_mesh.substr(6, domain_mesh.size());
domain_filetype = "gears";
}
if (!vm.count("use_case_1") && !vm.count("use_case_4")) {
std::cout << "OPTION ERROR: At least one of '--use_case_1' or '--use_case_4' must be specified.\n";
std::exit(EXIT_FAILURE);
}
if (vm.count("use_case_1")) {
use_case_1_driver(use_case_environment.m_comm,
working_directory,
range_mesh, range_filetype, range_entity,
domain_mesh, domain_filetype, domain_entity);
}
if (vm.count("use_case_4")) {
use_case_4_driver(use_case_environment.m_comm,
working_directory,
range_mesh, range_filetype, range_entity,
domain_mesh, domain_filetype, domain_entity);
}
// if we've made it this far, the use case has passed
use_case::print_status(use_case_environment.m_comm, true);
return 0;
}
int main(int argc, char** argv)
{
use_case::UseCaseEnvironment use_case_environment(&argc, &argv);
stk::ParallelMachine comm = use_case_environment.m_comm;
//----------------------------------
// Broadcast argc and argv to all processors.
stk::BroadcastArg b_arg(comm, argc, argv);
//----------------------------------
// Process the broadcast command line arguments
bopt::options_description desc("options");
stk::get_options_description().add(desc);
int nthreads = 1;
int bucket_size = 1000;
desc.add_options()
("help,h", "produce help message")
("mesh,m", bopt::value<std::string>(), "mesh file. Use name of form 'gen:NxMxL' to internally generate a hex mesh of size N by M by L intervals. See GeneratedMesh documentation for more options. Use 'gears' to generate the gears mesh." )
("directory,d", bopt::value<std::string>(), "working directory with trailing '/'" )
("output-log,o", bopt::value<std::string>(), "output log path" )
("runtest,r", bopt::value<std::string>(), "runtest pid file" )
("threads", bopt::value<int>(&nthreads)->default_value(1), "number of threads")
("bucket_size", bopt::value<int>(&bucket_size)->default_value(1000), "size of buckets used internally in stk::mesh")
("tbb", "Use Threaded Building Blocks algorithm thread runner")
("tpi", "Use Thread Pool Interface algorithm thread runner")
("nonthreaded", "Run algorithms non-threaded [default]")
("solver_params", "Teuchos parameter XML filename")
( use_case_1 , "use case 1" )
( use_case_2 , "use case 2" )
( use_case_3 , "use case 3" )
( use_case_4 , "use case 4" )
( use_case_5 , "use case 5" )
( use_case_7 , "use case 7" );
bopt::variables_map vm;
try {
bopt::store(bopt::parse_command_line(b_arg.m_argc, b_arg.m_argv, desc), vm);
bopt::notify(vm);
}
catch (std::exception &x) {
std::cout << x.what() << std::endl;
std::cout << "Test Failed" << std::endl;
stk::parallel_machine_finalize();
std::exit(1);
}
//----------------------------------
if (vm.count("help")) {
std::cout << desc << "\n";
std::exit(EXIT_SUCCESS);
}
std::string thread_runner = "NonThreaded";
if (vm.count("tbb"))
thread_runner = "TBB";
if (vm.count("tpi"))
thread_runner = "TPI";
if (vm.count("nonthreaded"))
thread_runner = "NonThreaded";
// Used by multiple use cases.
std::string working_directory = "";
std::string in_filename = "";
std::string in_filetype = "exodusii";
if (vm.count("mesh")) {
in_filename = boost::any_cast<std::string>(vm["mesh"].value());;
if (strncasecmp("gen:", in_filename.c_str(), 4) == 0) {
// Strip off the 'gen:' prefix and set the type to "generated"
in_filename = in_filename.substr(4, in_filename.size());
in_filetype = "generated";
}
if (strncasecmp("gears:", in_filename.c_str(), 6) == 0) {
// Strip off the 'gears:' prefix and set the type to "gears"
in_filename = in_filename.substr(6, in_filename.size());
in_filetype = "gears";
}
if (vm.count("directory")) {
working_directory = boost::any_cast<std::string>(vm["directory"].value());
}
} else {
std::cout << "OPTION ERROR: The '--mesh <filename>' option is required for all use cases!\n";
std::exit(EXIT_FAILURE);
}
bool success = false;
if ( vm.count( use_case_1 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 1, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
success = stk_linsys_usecases::use_case_1_driver( comm , in_filename );
}
else if ( vm.count( use_case_2 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 2, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
success = stk_linsys_usecases::use_case_2_driver( comm , in_filename );
}
else if ( vm.count( use_case_3 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 3, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
success = stk_linsys_usecases::use_case_3_driver( comm , in_filename );
}
else if ( vm.count( use_case_4 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 4, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
success = stk_linsys_usecases::use_case_4_driver( comm , in_filename );
}
else if ( vm.count( use_case_5 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 5, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
std::string solver_params = "";
if( vm.count("solver_params")) {
solver_params = boost::any_cast<std::string>(vm["solver_params"].value());
}
success = stk_linsys_usecases::use_case_5_driver( comm , in_filename, solver_params );
}
else if ( vm.count( use_case_7 ) ) {
if (in_filetype != "generated") {
std::cout << "OPTION ERROR: For use case 7, only the 'generated' mesh option is supported!\n";
std::exit(EXIT_FAILURE);
}
std::string solver_params = "";
if( vm.count("solver_params")) {
solver_params = boost::any_cast<std::string>(vm["solver_params"].value());
}
success = stk_linsys_usecases::use_case_7_driver( comm , in_filename, solver_params );
}
else {
std::cout << "OPTION ERROR: Missing a use case selection option. Use --help option to see valid options.\n";
std::exit(EXIT_FAILURE);
}
use_case::print_status(comm, success);
return 0;
}
