nimble::BoundaryCondition Class Reference

#include <nimble_boundary_condition.h>

Public Types
enum	Boundary_Condition_Type {   UNDEFINED = 0 , INITIAL_VELOCITY = 1 , PRESCRIBED_VELOCITY = 2 , PRESCRIBED_DISPLACEMENT = 3 ,   PRESCRIBED_TRACTION = 4 }

Public Member Functions
	BoundaryCondition ()
virtual	~BoundaryCondition ()
bool	Initialize (int dim, std::string bc_string, std::map< int, std::string > const &node_set_names, std::map< int, std::string > const &side_set_names)

Public Attributes
int	dim_ {0}
std::string	node_set_name_ {"unknown"}
int	node_set_id_ {-1}
std::string	side_set_name_ {"unknown"}
int	side_set_id_ {-1}
int	coordinate_ {-1}
double	magnitude_ {0.0}
Boundary_Condition_Type	bc_type_ {UNDEFINED}
bool	has_expression_ {false}
std::string	expression_string_ {""}
ExpressionParsing::BoundaryConditionFunctor	expression_

Member Enumeration Documentation

Boundary_Condition_Type

enum nimble::BoundaryCondition::Boundary_Condition_Type

Enumerator
UNDEFINED
INITIAL_VELOCITY
PRESCRIBED_VELOCITY
PRESCRIBED_DISPLACEMENT
PRESCRIBED_TRACTION

  {
    UNDEFINED               = 0,
    INITIAL_VELOCITY        = 1,
    PRESCRIBED_VELOCITY     = 2,
    PRESCRIBED_DISPLACEMENT = 3,
    PRESCRIBED_TRACTION     = 4,
  };

Constructor & Destructor Documentation

BoundaryCondition()

nimble::BoundaryCondition::BoundaryCondition ( )

inline

{}

~BoundaryCondition()

virtual nimble::BoundaryCondition::~BoundaryCondition ( )

inlinevirtual

{}

Member Function Documentation

Initialize()

bool nimble::BoundaryCondition::Initialize	(	int	dim,
		std::string	bc_string,
		std::map< int, std::string > const &	node_set_names,
		std::map< int, std::string > const &	side_set_names )

{
  bool is_valid = true;
 
  dim_ = dim;
  std::string       bc_type_string("undefined");
  std::string       coordinate_string("undefined");
  std::stringstream ss(bc_string);
  ss >> bc_type_string;
 
  if (bc_type_string == "initial_velocity") {
    bc_type_ = INITIAL_VELOCITY;
  } else if (bc_type_string == "prescribed_velocity") {
    bc_type_ = PRESCRIBED_VELOCITY;
  } else if (bc_type_string == "prescribed_displacement") {
    bc_type_ = PRESCRIBED_DISPLACEMENT;
  } else if (bc_type_string == "prescribed_traction") {
    bc_type_ = PRESCRIBED_TRACTION;
  } else {
    throw std::invalid_argument(
        "Error processing boundary condition, unknown boundary condition "
        "type: " +
        bc_type_string);
  }
 
  bool const is_neumann_bc = bc_type_ == PRESCRIBED_TRACTION;
 
  if (is_neumann_bc == true) {
    ss >> side_set_name_;
  } else {
    ss >> node_set_name_;
  }
  ss >> coordinate_string;
 
  // figure out if magnitude is a double or an expression (check for quotes)
  int num_quotes = std::count(bc_string.begin(), bc_string.end(), '"');
  if (num_quotes == 2) {
    has_expression_    = true;
    size_t first_pos   = bc_string.find('"');
    size_t last_pos    = bc_string.rfind('"');
    expression_string_ = bc_string.substr(first_pos + 1, last_pos - first_pos - 1);
    expression_        = ExpressionParsing::BoundaryConditionFunctor(expression_string_);
  } else if (num_quotes == 0) {
    has_expression_ = false;
    ss >> magnitude_;  // DJL valgrind complains about this
  } else {
    throw std::invalid_argument("Error processing boundary condition, illegal number of quotes: " + bc_string);
  }
 
  std::transform(bc_type_string.begin(), bc_type_string.end(), bc_type_string.begin(), ::tolower);
  std::transform(coordinate_string.begin(), coordinate_string.end(), coordinate_string.begin(), ::tolower);
 
  // If id is -1, then either
  // 1) no nodes/sides on this processor belong to the node/side set, or
  // 2) the node/side set doesn't exist at all.
  if (is_neumann_bc == true) {
    side_set_id_ = find_name_id(side_set_names, side_set_name_);
    if (side_set_id_ == -1) is_valid = false;
  } else {
    node_set_id_ = find_name_id(node_set_names, node_set_name_);
    if (node_set_id_ == -1) is_valid = false;
  }
 
  if (coordinate_string == "x") {
    coordinate_ = 0;
  } else if (coordinate_string == "y") {
    coordinate_ = 1;
  } else if (coordinate_string == "z") {
    coordinate_ = 2;
  } else {
    throw std::invalid_argument("Error processing boundary condition, unknown coordinate: " + coordinate_string);
  }
 
  return is_valid;
}

Member Data Documentation

bc_type_

Boundary_Condition_Type nimble::BoundaryCondition::bc_type_ {UNDEFINED}

{UNDEFINED};

coordinate_

int nimble::BoundaryCondition::coordinate_ {-1}

{-1};

dim_

int nimble::BoundaryCondition::dim_ {0}

{0};

expression_

ExpressionParsing::BoundaryConditionFunctor nimble::BoundaryCondition::expression_

expression_string_

std::string nimble::BoundaryCondition::expression_string_ {""}

{""};

has_expression_

bool nimble::BoundaryCondition::has_expression_ {false}

{false};

magnitude_

double nimble::BoundaryCondition::magnitude_ {0.0}

{0.0};

node_set_id_

int nimble::BoundaryCondition::node_set_id_ {-1}

{-1};

node_set_name_

std::string nimble::BoundaryCondition::node_set_name_ {"unknown"}

{"unknown"};

side_set_id_

int nimble::BoundaryCondition::side_set_id_ {-1}

{-1};

side_set_name_

std::string nimble::BoundaryCondition::side_set_name_ {"unknown"}

{"unknown"};

---

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

• src/nimble_boundary_condition.h
• src/nimble_boundary_condition.cc