nimble::Parser Class Reference

#include <nimble_parser.h>

Public Member Functions
	Parser ()
virtual	~Parser ()=default
void	Initialize ()
std::string	GenesisFileName () const
std::string	ExodusFileName () const
bool	UseTwoLevelMeshDecomposition () const
bool	WriteTimingDataFile () const
std::string	TimeIntegrationScheme () const
double	NonlinearSolverRelativeTolerance () const
int	NonlinearSolverMaxIterations () const
double	InitialTime () const
double	FinalTime () const
int	NumLoadSteps () const
int	OutputFrequency () const
bool	HasContact () const
bool	ContactVisualization () const
std::string	ContactVisualizationFileName () const
std::string	ContactString () const
std::string	GetModelMaterialParameters (int block_id) const
int	GetBlockIdFromMaterial (const std::string &material_key) const
std::vector< std::string > const &	GetBoundaryConditionStrings () const
std::string	GetOutputFieldString () const
void	SetToUseTpetra ()
	Set that Tpetra is used for the simulation.
void	SetToUseUQ ()
	Set that UQ is used for the simulation.
void	SetToUseVT ()
	Set that VT is used for the simulation.
bool	UseTpetra () const
	Indicate whether Tpetra is used for the simulation.
bool	UseUQ () const
	Indicate whether UQ is used for the simulation.
bool	UseVT () const
	Indicate whether VT is used.
void	SetRankID (int myrank)
	Set the rank index.
int	GetRankID () const
	Get the rank index.
void	SetNumRanks (int nrank)
	Set the number of ranks.
int	GetNumRanks () const
	Get the number of ranks.
void	SetInputFilename (const std::string &name)
	Set the string for the input file.

Protected Member Functions
virtual void	ParseKeyValue (const std::string &k, const std::string &v)
void	ReadFile ()

Protected Attributes
std::string	genesis_file_name_
std::string	exodus_file_name_
bool	use_two_level_mesh_decomposition_
bool	write_timing_data_file_
double	nonlinear_solver_relative_tolerance_
int	nonlinear_solver_max_iterations_
std::string	time_integration_scheme_
double	initial_time_ {0.0}
double	final_time_ {0.0}
int	num_load_steps_
int	output_frequency_
std::string	contact_string_
std::string	contact_backend_string_
bool	visualize_contact_entities_
bool	visualize_contact_bounding_boxes_
std::string	contact_visualization_file_name_
std::map< std::string, std::string >	material_strings_
std::map< int, BlockProperties >	model_blocks_
std::vector< std::string >	boundary_condition_strings_
std::string	output_field_string_
bool	env_set_ = false
	Boolean indicating whether the environment has been set.
std::string	file_name_ = std::string("none")
	Filename for input file to read.
bool	use_vt_ = false
	Boolean setting the usage of VT.
bool	use_tpetra_ = false
	Boolean setting the usage of Tpetra.
bool	use_uq_ = false
	Boolean setting the usage of UQ.
int	my_rank_ = 0
	Rank ID when running with MPI.
int	num_ranks_ = 1
	Number of ranks when running with MPI.

Constructor & Destructor Documentation

Parser()

nimble::Parser::Parser

(

)

    : genesis_file_name_("none"),
      use_two_level_mesh_decomposition_(false),
      write_timing_data_file_(false),
      exodus_file_name_("none"),
      time_integration_scheme_("explicit"),
      nonlinear_solver_relative_tolerance_(1.0e-6),
      nonlinear_solver_max_iterations_(200),
      initial_time_(0.0),
      final_time_(0.0),
      num_load_steps_(0),
      output_frequency_(1),
      visualize_contact_entities_(false),
      visualize_contact_bounding_boxes_(false),
      contact_visualization_file_name_("none")
 
{
}

~Parser()

virtual nimble::Parser::~Parser ( )

virtualdefault

Member Function Documentation

ContactString()

std::string nimble::Parser::ContactString ( ) const

inline

  {
    return contact_string_;
  }

ContactVisualization()

bool nimble::Parser::ContactVisualization ( ) const

inline

  {
    bool visualize_contact = visualize_contact_entities_ || visualize_contact_bounding_boxes_;
    return visualize_contact;
  }

ContactVisualizationFileName()

std::string nimble::Parser::ContactVisualizationFileName ( ) const

inline

  {
    return contact_visualization_file_name_;
  }

ExodusFileName()

std::string nimble::Parser::ExodusFileName ( ) const

inline

  {
    return exodus_file_name_;
  }

FinalTime()

double nimble::Parser::FinalTime ( ) const

inline

  {
    return final_time_;
  }

GenesisFileName()

std::string nimble::Parser::GenesisFileName ( ) const

inline

  {
    return genesis_file_name_;
  }

GetBlockIdFromMaterial()

int nimble::Parser::GetBlockIdFromMaterial ( const std::string & material_key ) const

inline

  {
    int block_id = -1;
    // std::map<int, BlockProperties>::iterator it;
    // for(it = model_blocks_.begin(); it != model_blocks_.end();
    // it++){
    for (auto const& entry : model_blocks_) {
      BlockProperties const& block_props = entry.second;  // it->second;
      if (material_key == block_props.material_key_) {
        block_id = entry.first;  // it->first; //Found the block id with the
                                 // material string
        break;
      }
    }
    return block_id;
  }

GetBoundaryConditionStrings()

std::vector< std::string > const & nimble::Parser::GetBoundaryConditionStrings ( ) const

inline

  {
    return boundary_condition_strings_;
  }

GetModelMaterialParameters()

std::string nimble::Parser::GetModelMaterialParameters ( int block_id ) const

inline

  {
    if (model_blocks_.find(block_id) == model_blocks_.end()) {
      std::string none_str("none");
      return none_str;
    }
    BlockProperties const& block          = model_blocks_.at(block_id);
    std::string const&     material_key   = block.material_key_;
    std::string const&     material_props = material_strings_.at(material_key);
    return material_props;
  }

GetNumRanks()

int nimble::Parser::GetNumRanks ( ) const

inline

Get the number of ranks.

  {
    return num_ranks_;
  }

GetOutputFieldString()

std::string nimble::Parser::GetOutputFieldString ( ) const

inline

  {
    if (output_field_string_.empty()) {
      std::string msg =
          "\n**** Error in Parser::GetOutputFieldString(), output fields not "
          "found (possible input deck error?).";
      throw std::invalid_argument(msg);
    }
    return output_field_string_;
  }

GetRankID()

int nimble::Parser::GetRankID ( ) const

inline

Get the rank index.

  {
    return my_rank_;
  }

HasContact()

bool nimble::Parser::HasContact ( ) const

inline

  {
    return (!contact_string_.empty());
  }

Initialize()

void nimble::Parser::Initialize

(

)

{
  ReadFile();
}

InitialTime()

double nimble::Parser::InitialTime ( ) const

inline

  {
    return initial_time_;
  }

NonlinearSolverMaxIterations()

int nimble::Parser::NonlinearSolverMaxIterations ( ) const

inline

  {
    return nonlinear_solver_max_iterations_;
  }

NonlinearSolverRelativeTolerance()

double nimble::Parser::NonlinearSolverRelativeTolerance ( ) const

inline

  {
    return nonlinear_solver_relative_tolerance_;
  }

NumLoadSteps()

int nimble::Parser::NumLoadSteps ( ) const

inline

  {
    return num_load_steps_;
  }

OutputFrequency()

int nimble::Parser::OutputFrequency ( ) const

inline

  {
    return output_frequency_;
  }

ParseKeyValue()

void nimble::Parser::ParseKeyValue ( const std::string & k, const std::string & v )

protectedvirtual

{
  if (key == "genesis input file") {
    genesis_file_name_ = value;
  } else if (key == "exodus output file") {
    exodus_file_name_ = value;
  } else if (key == "use two level mesh decomposition") {
    std::string value_upper_case(value);
    std::transform(
        value_upper_case.begin(), value_upper_case.end(), value_upper_case.begin(), (int (*)(int))std::toupper);
    if (value_upper_case == "TRUE" || value_upper_case == "YES" || value_upper_case == "ON") {
      use_two_level_mesh_decomposition_ = true;
    } else if (value_upper_case == "FALSE" || value_upper_case == "NO" || value_upper_case == "OFF") {
      use_two_level_mesh_decomposition_ = false;
    } else {
      std::string msg =
          "\n**** Error in Parser::ReadFile(), unexpected value for \"use two "
          "level mesh decomposition\" " +
          value + "\n";
      throw std::invalid_argument(msg);
    }
  } else if (key == "write timing data file") {
    std::string value_upper_case(value);
    std::transform(
        value_upper_case.begin(), value_upper_case.end(), value_upper_case.begin(), (int (*)(int))std::toupper);
    if (value_upper_case == "TRUE" || value_upper_case == "YES" || value_upper_case == "ON") {
      write_timing_data_file_ = true;
    } else if (value_upper_case == "FALSE" || value_upper_case == "NO" || value_upper_case == "OFF") {
      write_timing_data_file_ = false;
    } else {
      std::string msg =
          "\n**** Error in Parser::ReadFile(), unexpected value for \"write "
          "timing data file\" " +
          value + "\n";
      throw std::invalid_argument(msg);
    }
  } else if (key == "time integration scheme") {
    time_integration_scheme_ = value;
  } else if (key == "nonlinear solver relative tolerance") {
    nonlinear_solver_relative_tolerance_ = std::atof(value.c_str());
  } else if (key == "nonlinear solver maximum iterations") {
    nonlinear_solver_max_iterations_ = std::atoi(value.c_str());
  } else if (key == "initial time") {
    initial_time_ = std::atof(value.c_str());
  } else if (key == "final time") {
    final_time_ = std::atof(value.c_str());
  } else if (key == "number of load steps") {
    num_load_steps_ = std::atoi(value.c_str());
  } else if (key == "output frequency") {
    output_frequency_ = std::atoi(value.c_str());
  } else if (key == "contact") {
    contact_string_ = value;
  } else if (key == "contact backend") {
    contact_backend_string_ = value;
  } else if (key == "contact visualization") {
    std::stringstream        ss(value);
    std::string              val;
    std::vector<std::string> vals;
    while (ss >> val) { vals.push_back(val); }
 
    if (vals.size() != 6 || vals[0] != "visualize_contact_entities" || (vals[1] != "on" && vals[1] != "off") ||
        vals[2] != "visualize_bounding_boxes" || (vals[3] != "on" && vals[3] != "off") || vals[4] != "file_name") {
      std::string msg =
          "\n**** Error in Parser::ReadFile(), unexpected value for \"contact "
          "visualization\"\n";
      msg +=
          "**** Allowable syntax is \"visualize_contact_entities <on/off> "
          "visualize_bounding_boxes <on/off> file_name <file_name.e>\"\n";
      throw std::invalid_argument(msg);
    }
 
    visualize_contact_entities_ = false;
    if (vals[1] == "on") { visualize_contact_entities_ = true; }
 
    visualize_contact_bounding_boxes_ = false;
    if (vals[3] == "on") { visualize_contact_bounding_boxes_ = true; }
 
    contact_visualization_file_name_ = vals[5];
  } else if (key == "material parameters") {
    size_t      space_pos           = value.find(" ");
    std::string material_key        = value.substr(0, space_pos);
    std::string material_props      = value.substr(space_pos + 1, value.size());
    material_strings_[material_key] = material_props;
  } else if (key == "element block") {
    BlockProperties block_props(value);
    model_blocks_[block_props.block_id_] = block_props;
  } else if (key == "boundary condition") {
    boundary_condition_strings_.push_back(value);
  } else if (key == "output fields") {
    output_field_string_ = value;
  } else if (key == "contact dicing") {
    int tmp = std::atoi(value.c_str());
#ifdef NIMBLE_HAVE_BVH
    contact_dicing_ = tmp;
#else
    std::cout << " **** Parser::ReadFile(), skipping key " + key + "\n";
#endif
  } else if (key == "contact splitting") {
    size_t      space_pos     = value.find(" ");
    std::string split_key     = value.substr(0, space_pos);
    std::string split_alg     = value.substr(space_pos + 1, value.size());
#ifdef NIMBLE_HAVE_BVH
    contact_splitting_ = split_alg;
#else
    std::cout << " **** Parser::ReadFile(), skipping key " + key + "\n";
#endif
  }
#ifdef NIMBLE_HAVE_UQ
  else if (key == "uq parameters") {
    size_t      space_pos                = value.find(" ");
    std::string material_key             = value.substr(0, space_pos);
    std::string uq_params                = value.substr(space_pos + 1, value.size());
    uq_parameters_strings_[material_key] = uq_params;
  } else if (key == "uq model") {
    uq_model_string_ = value;
  }
#endif
  else {
    std::string msg = "\n**** Error in Parser::ReadFile(), unknown key " + key + "\n";
    throw std::invalid_argument(msg);
  }
}

ReadFile()

void nimble::Parser::ReadFile ( )

protected

{
  int         max_chars_per_line = 1000;
  std::string delimiter(" ");
 
  std::ifstream fin;
  fin.open(file_name_.c_str());
  if (!fin.good()) {
    std::string msg = "\n**** Error in Parser::ReadFile(), unable to read file " + file_name_ + "\n";
    throw std::invalid_argument(msg);
  }
 
  while (!fin.eof()) {
    char buf[max_chars_per_line];
    fin.getline(buf, max_chars_per_line);
    std::string line(buf);
 
    // Strip out comments (# character)
    size_t pound_pos = line.find("#");
    if (pound_pos != std::string::npos) { line = line.substr(0, pound_pos); }
    // Strip out leading and trailing whitespace
    if (line.size() > 0) {
      size_t start_pos = line.find_first_not_of(" \t");
      size_t end_pos   = line.find_last_not_of(" \t");
      line             = line.substr(start_pos, end_pos - start_pos + 1);
    }
 
    if (line.size() > 0) {
      // Obtain key and value
      // Commands are delimited with a colon
      size_t      colon_pos = line.find(":");
      std::string key       = line.substr(0, colon_pos);
      key                   = key.substr(key.find_first_not_of(" "), key.find_last_not_of(" ") + 1);
      std::string value     = line.substr(colon_pos + 1, line.size());
      value                 = value.substr(value.find_first_not_of(" "), value.find_last_not_of(" ") + 1);
 
      ParseKeyValue(key, value);
    }
  }
}

SetInputFilename()

void nimble::Parser::SetInputFilename ( const std::string & name )

inline

Set the string for the input file.

Parameters

[in]

name

Input filename

  {
    file_name_ = name;
  }

SetNumRanks()

void nimble::Parser::SetNumRanks ( int nrank )

inline

Set the number of ranks.

Parameters

[in]

nrank

Number of MPI ranks

  {
    num_ranks_ = nrank;
  }

SetRankID()

void nimble::Parser::SetRankID ( int myrank )

inline

Set the rank index.

Parameters

[in]

myrank

Rank index

  {
    my_rank_ = myrank;
  }

SetToUseTpetra()

void nimble::Parser::SetToUseTpetra ( )

inline

Set that Tpetra is used for the simulation.

Note

The function will abort when an environment has been set previously

  {
    use_tpetra_ = true;
  }

SetToUseUQ()

void nimble::Parser::SetToUseUQ ( )

inline

Set that UQ is used for the simulation.

  {
    use_uq_ = true;
  }

SetToUseVT()

void nimble::Parser::SetToUseVT ( )

inline

Set that VT is used for the simulation.

Note

The function will abort when an environment has been set previously

  {
    use_vt_  = true;
  }

TimeIntegrationScheme()

std::string nimble::Parser::TimeIntegrationScheme ( ) const

inline

  {
    if (time_integration_scheme_ != "explicit" && time_integration_scheme_ != "quasistatic") {
      std::string msg =
          "\n**** Error in Parser::TimeIntegrationScheme(), invalid "
          "integration scheme " +
          time_integration_scheme_ + ".\n";
      throw std::invalid_argument(msg);
    }
    return time_integration_scheme_;
  }

UseTpetra()

bool nimble::Parser::UseTpetra ( ) const

inline

Indicate whether Tpetra is used for the simulation.

  {
    return use_tpetra_;
  }

UseTwoLevelMeshDecomposition()

bool nimble::Parser::UseTwoLevelMeshDecomposition ( ) const

inline

  {
    return use_two_level_mesh_decomposition_;
  }

UseUQ()

bool nimble::Parser::UseUQ ( ) const

inline

Indicate whether UQ is used for the simulation.

  {
    return use_uq_;
  }

UseVT()

bool nimble::Parser::UseVT ( ) const

inline

Indicate whether VT is used.

  {
    return use_vt_;
  }

WriteTimingDataFile()

bool nimble::Parser::WriteTimingDataFile ( ) const

inline

  {
    return write_timing_data_file_;
  }

Member Data Documentation

boundary_condition_strings_

std::vector<std::string> nimble::Parser::boundary_condition_strings_

protected

contact_backend_string_

std::string nimble::Parser::contact_backend_string_

protected

contact_string_

std::string nimble::Parser::contact_string_

protected

contact_visualization_file_name_

std::string nimble::Parser::contact_visualization_file_name_

protected

env_set_

bool nimble::Parser::env_set_ = false

protected

Boolean indicating whether the environment has been set.

exodus_file_name_

std::string nimble::Parser::exodus_file_name_

protected

file_name_

std::string nimble::Parser::file_name_ = std::string("none")

protected

Filename for input file to read.

final_time_

double nimble::Parser::final_time_ {0.0}

protected

{0.0};

genesis_file_name_

std::string nimble::Parser::genesis_file_name_

protected

initial_time_

double nimble::Parser::initial_time_ {0.0}

protected

{0.0};

material_strings_

std::map<std::string, std::string> nimble::Parser::material_strings_

protected

model_blocks_

std::map<int, BlockProperties> nimble::Parser::model_blocks_

protected

my_rank_

int nimble::Parser::my_rank_ = 0

protected

Rank ID when running with MPI.

nonlinear_solver_max_iterations_

int nimble::Parser::nonlinear_solver_max_iterations_

protected

nonlinear_solver_relative_tolerance_

double nimble::Parser::nonlinear_solver_relative_tolerance_

protected

num_load_steps_

int nimble::Parser::num_load_steps_

protected

num_ranks_

int nimble::Parser::num_ranks_ = 1

protected

Number of ranks when running with MPI.

output_field_string_

std::string nimble::Parser::output_field_string_

protected

output_frequency_

int nimble::Parser::output_frequency_

protected

time_integration_scheme_

std::string nimble::Parser::time_integration_scheme_

protected

use_tpetra_

bool nimble::Parser::use_tpetra_ = false

protected

Boolean setting the usage of Tpetra.

use_two_level_mesh_decomposition_

bool nimble::Parser::use_two_level_mesh_decomposition_

protected

use_uq_

bool nimble::Parser::use_uq_ = false

protected

Boolean setting the usage of UQ.

use_vt_

bool nimble::Parser::use_vt_ = false

protected

Boolean setting the usage of VT.

visualize_contact_bounding_boxes_

bool nimble::Parser::visualize_contact_bounding_boxes_

protected

visualize_contact_entities_

bool nimble::Parser::visualize_contact_entities_

protected

write_timing_data_file_

bool nimble::Parser::write_timing_data_file_

protected

---

The documentation for this class was generated from the following files:

• src/nimble_parser.h
• src/nimble_parser.cc