nimble Namespace Reference

Namespaces
namespace	details
namespace	quanta
namespace	serialization

Classes
class	Block
class	BlockBase
struct	BlockData
class	BlockMaterialInterfaceBase
class	BlockMaterialInterfaceFactoryBase
struct	BlockProperties
class	BoundaryCondition
class	BoundaryConditionManager
class	BvhContactManager
struct	CGScratchSpace
class	CommandLineConfiguration
struct	ComputeInternalForceFunctor
class	ContactEntity
class	ContactInterface
class	ContactManager
class	CRSMatrixContainer
class	DataManager
class	ElasticMaterial
class	Element
	Abstract class for representing an element. More...
class	ExodusOutput
class	ExplicitTimeIntegrator
class	Field
struct	FieldIds
class	GenesisMesh
class	HexElement
	Class for an 8-node hexahedral element. More...
class	IntegratorBase
class	KokkosContactManager
class	Material
class	MaterialFactory
class	MaterialFactoryBase
class	MaterialParameters
class	MatrixContainer
class	ModelData
class	ModelDataBase
class	mpicontext
struct	NarrowphaseFunc
struct	NarrowphaseResult
class	NeohookeanMaterial
class	NimbleApplication
class	Parser
struct	PenaltyContactEnforcement
class	ProfilingTimer
class	QuasistaticTimeIntegrator
struct	ReductionClique_t
class	SerialContactManager
class	TimeKeeper
class	Timer
struct	TimingInfo
class	TpetraContainer
class	TpetraMatrixContainer
class	UqModel
class	VectorCommunicator
class	View
class	Viewify

Typedefs
typedef int	comm_type

Enumerations
enum	Relation { UNDEFINED_RELATION = 0 , NODE , ELEMENT , GLOBAL }
enum	Length {   LENGTH_0 = 0 , LENGTH_1 = 1 , LENGTH_2 = 2 , LENGTH_3 = 3 ,   LENGTH_4 = 4 , LENGTH_5 = 5 , LENTGH_6 = 6 , LENGTH_7 = 7 ,   LENGTH_8 = 8 , LENGTH_9 = 9 , LENGTH_10 = 10 , LENGTH_11 = 11 ,   LENGTH_12 = 12 , LENGTH_13 = 13 , LENGTH_14 = 14 , LENGTH_15 = 15 ,   LENGTH_16 = 16 , LENGTH_17 = 17 , LENGTH_18 = 18 , LENGTH_19 = 19 ,   LENGTH_20 = 20 , SCALAR , VECTOR , SYMMETRIC_TENSOR ,   FULL_TENSOR , UNDEFINED_LENGTH }
enum	Step { UNDEFINED_STEP = 0 , STEP_N , STEP_NP1 }

Functions
std::vector< int >	PackIDSpace (const std::vector< int > &raw_node_ids, int max_nodes_assigned_to_a_rank, const mpicontext &context)
int	GetMaximumNodeId (const std::vector< int > &global_node_ids, const mpicontext &context)
std::unique_ptr< int[]>	GetNumberOfNodesAssignedToEachRank (const std::vector< int > &global_node_ids, const mpicontext &context)
void	EnsureCheckpoint (const mpicontext &context, const std::string &message)
template<class Key, class Val>
std::vector< std::pair< Key, std::vector< Val > > >	GroupConsecutive (const std::vector< std::pair< Key, Val > > &lst)
NIMBLE_INLINE_FUNCTION double	TriangleArea (double pt_1_x, double pt_1_y, double pt_1_z, double pt_2_x, double pt_2_y, double pt_2_z, double pt_3_x, double pt_3_y, double pt_3_z)
NIMBLE_INLINE_FUNCTION double	PointEdgeClosestPointFindT (double const p1[], double const p2[], double const p[])
NIMBLE_INLINE_FUNCTION double	PointEdgeClosestPointFindDistanceSquared (double const p1[], double const p2[], double const p[], double t)
void	ParseContactCommand (std::string const &command, std::vector< std::string > &primary_block_names, std::vector< std::string > &secondary_block_names, double &penalty_parameter)
template<typename ArgT>
void	SerializeContactFaces (int num_entities, ArgT contact_entities, std::vector< char > &buffer)
template<typename ArgT>
void	UnserializeContactFaces (int num_entities, ArgT contact_entities, std::vector< char > &buffer)
std::shared_ptr< nimble::ContactManager >	GetContactManager (std::shared_ptr< ContactInterface > interface, nimble::DataManager &data_manager)
int	LengthToInt (Length length, int dim)
std::string	AddIntegrationPointPrefix (std::string label, int ipt_number)
std::string	RemoveIntegrationPointPrefix (std::string label)
bool	HasIntegrationPointPrefix (std::string label)
int	LabelToIntegrationPointNumber (std::string label)
std::vector< std::string >	GetComponentLabels (std::string label, Length length, int dim)
std::string	GetComponentLabel (std::string label, Length length, int dim, int component_index, int ipt)
Length	LabelToLength (std::string label, std::map< int, Field > const &data_fields, int dim)
void	PopulateDiagonalPreconditioner (const CRSMatrixContainer &A, CRSMatrixContainer &M)
bool	CG_SolveSystem (nimble::CRSMatrixContainer &A, const double *b, CGScratchSpace &cg_scratch, double *x, int &num_iterations, double cg_tol, int max_iterations)
double	InnerProduct (unsigned int num_entries, const double *vec_1, const double *vec_2)
double	InnerProduct (const std::vector< double > &vec_1, const std::vector< double > &vec_2)
void	LU_Decompose (int num_entries, MatrixContainer &mat, int *index)
void	LU_Solve (int num_entries, MatrixContainer &mat, double *vec, int *index)
void	LU_SolveSystem (int num_entries, MatrixContainer &mat, double *vec, int *scratch)
void	DetermineTangentMatrixNonzeroStructure (GenesisMesh const &mesh, std::vector< int > const &linear_system_node_ids, std::vector< int > &i_index, std::vector< int > &j_index)
template void	ModelData::EmplaceBlocks< nimble::Block > (nimble::DataManager &data_manager, const std::shared_ptr< nimble::MaterialFactoryBase > &material_factory_base)
std::string	IOFileName (std::string const &serial_name, std::string const &extension, std::string const &label, int my_rank, int num_ranks)
void	IOFileNameThreadSafe (char const *const serial_file_name, char const *const extension, char const *const label, int my_mpi_rank, int mpi_num_ranks, int my_thread_rank, int num_threads, char *const file_name)
std::vector< std::string >	tokenize_string (const std::string &s)
double	string_to_double (const std::string &s)
std::string	NimbleVersion ()
template<std::size_t N>
details::AXPYResult< N >	operator* (double alpha, const nimble::Viewify< N > &A)
std::list< std::string >	split (std::string line)

Variables
constexpr int	MAX_C_STR_SIZE = 256

Typedef Documentation

comm_type

typedef int nimble::comm_type

Enumeration Type Documentation

Length

enum nimble::Length

Enumerator
LENGTH_0
LENGTH_1
LENGTH_2
LENGTH_3
LENGTH_4
LENGTH_5
LENTGH_6
LENGTH_7
LENGTH_8
LENGTH_9
LENGTH_10
LENGTH_11
LENGTH_12
LENGTH_13
LENGTH_14
LENGTH_15
LENGTH_16
LENGTH_17
LENGTH_18
LENGTH_19
LENGTH_20
SCALAR
VECTOR
SYMMETRIC_TENSOR
FULL_TENSOR
UNDEFINED_LENGTH

{
  LENGTH_0  = 0,
  LENGTH_1  = 1,
  LENGTH_2  = 2,
  LENGTH_3  = 3,
  LENGTH_4  = 4,
  LENGTH_5  = 5,
  LENTGH_6  = 6,
  LENGTH_7  = 7,
  LENGTH_8  = 8,
  LENGTH_9  = 9,
  LENGTH_10 = 10,
  LENGTH_11 = 11,
  LENGTH_12 = 12,
  LENGTH_13 = 13,
  LENGTH_14 = 14,
  LENGTH_15 = 15,
  LENGTH_16 = 16,
  LENGTH_17 = 17,
  LENGTH_18 = 18,
  LENGTH_19 = 19,
  LENGTH_20 = 20,
  SCALAR,
  VECTOR,
  SYMMETRIC_TENSOR,
  FULL_TENSOR,
  UNDEFINED_LENGTH
};

Relation

enum nimble::Relation

Enumerator
UNDEFINED_RELATION
NODE
ELEMENT
GLOBAL

{
  UNDEFINED_RELATION = 0,
  NODE,
  ELEMENT,
  GLOBAL
};

Step

enum nimble::Step

Enumerator
UNDEFINED_STEP
STEP_N
STEP_NP1

{
  UNDEFINED_STEP = 0,
  STEP_N,
  STEP_NP1
};

Function Documentation

AddIntegrationPointPrefix()

std::string nimble::AddIntegrationPointPrefix	(	std::string	label,
		int	ipt_number )

{
  std::string       modified_label;
  std::stringstream ss;
  ss << ipt_number;
  if (ss.str().size() == 1) {
    modified_label = "ipt0" + ss.str() + "_" + label;
  } else {
    modified_label = "ipt" + ss.str() + "_" + label;
  }
  return modified_label;
}

CG_SolveSystem()

bool nimble::CG_SolveSystem	(	nimble::CRSMatrixContainer &	A,
		const double *	b,
		CGScratchSpace &	cg_scratch,
		double *	x,
		int &	num_iterations,
		double	cg_tol,
		int	max_iterations )

{
  // see "An Introduction to the Conjugate Gradient Method Without the Agonizing
  // Pain", J.R. Shewchuk, 1994.
 
  double       alpha, beta, delta_old, delta_new;
  unsigned int num_entries = A.NumRows();
  cg_scratch.Resize(num_entries);
  double* d = cg_scratch.d.data();
  double* r = cg_scratch.r.data();
  double* s = cg_scratch.s.data();
  double* q = cg_scratch.q.data();
 
  // diagonal preconditioner
  CRSMatrixContainer& M = cg_scratch.M;
  PopulateDiagonalPreconditioner(A, M);
 
  // r = b - Ax
  A.MatVec(x, q);
  for (unsigned int i = 0; i < num_entries; i++) { r[i] = b[i] - q[i]; }
 
  // d = M^-1 r
  M.DiagonalMatrixMatVec(r, d);
 
  // delta_new = r^T d
  // delta_old = delta_new
  delta_new = delta_old = InnerProduct(num_entries, r, d);
  double tolerance      = cg_tol * delta_old;
 
  int iteration      = 0;
 
  while (delta_new > tolerance && iteration < max_iterations) {
    // q = Ad
    A.MatVec(d, q);
 
    // alpha = delta_new / (d^T q)
    alpha = delta_new / InnerProduct(num_entries, d, q);
 
    // x = x + alpha * d
    for (unsigned int i = 0; i < num_entries; i++) { x[i] += alpha * d[i]; }
 
    if (iteration % 50 == 0) {
      // r = b - Ax
      A.MatVec(x, q);  // here, q is just a place to store Ax
      for (unsigned int i = 0; i < num_entries; i++) { r[i] = b[i] - q[i]; }
    } else {
      // r = r - alpha * q
      for (unsigned int i = 0; i < num_entries; i++) { r[i] -= alpha * q[i]; }
    }
 
    // s = M^-1 r
    M.DiagonalMatrixMatVec(r, s);
 
    // delta_old = delta_new
    delta_old = delta_new;
 
    // delta_new = r^T s
    delta_new = InnerProduct(num_entries, r, s);
 
    // beta = delta_new / delta_old
    beta = delta_new / delta_old;
 
    // d = s + beta * d
    for (unsigned int i = 0; i < num_entries; i++) { d[i] = s[i] + beta * d[i]; }
 
    iteration += 1;
  }
 
  num_iterations = iteration;
  bool success   = true;
  if (iteration == max_iterations) { success = false; }
  return success;
}

DetermineTangentMatrixNonzeroStructure()

void nimble::DetermineTangentMatrixNonzeroStructure	(	GenesisMesh const &	mesh,
		std::vector< int > const &	linear_system_node_ids,
		std::vector< int > &	i_index,
		std::vector< int > &	j_index )

{
  std::vector<int> block_ids = mesh.GetBlockIds();
  int              dim       = mesh.GetDim();
  int              num_rows  = linear_system_node_ids.size() * dim;
 
  // column indexes for the nonzeros in each row
  std::vector<std::set<int>> nonzeros(num_rows);
 
  for (auto const& block_id : block_ids) {
    int              num_elem           = mesh.GetNumElementsInBlock(block_id);
    int              num_nodes_per_elem = mesh.GetNumNodesPerElement(block_id);
    std::vector<int> linear_system_dof(num_nodes_per_elem * dim);
    int const*       elem_conn = mesh.GetConnectivity(block_id);
    for (int i_elem = 0; i_elem < num_elem; i_elem++) {
      for (int i_node = 0; i_node < num_nodes_per_elem; i_node++) {
        for (int i_dim = 0; i_dim < dim; i_dim++) {
          linear_system_dof[i_node * dim + i_dim] =
              linear_system_node_ids[elem_conn[num_nodes_per_elem * i_elem + i_node]] * dim + i_dim;
        }
      }
      int row, col;
      for (int i = 0; i < num_nodes_per_elem * dim; i++) {
        for (int j = 0; j < num_nodes_per_elem * dim; j++) {
          row = linear_system_dof[i];
          col = linear_system_dof[j];
          nonzeros[row].insert(col);
          nonzeros[col].insert(row);
        }
      }
    }
  }
 
  // i_index and j_index are arrays containing the row and column indices,
  // respectively, for each nonzero
  int num_entries(0);
  for (int i_row = 0; i_row < num_rows; i_row++) { num_entries += nonzeros[i_row].size(); }
  i_index.resize(num_entries);
  j_index.resize(num_entries);
  int index(0);
  for (int i_row = 0; i_row < num_rows; i_row++) {
    for (auto const& entry : nonzeros[i_row]) {
      i_index[index]   = i_row;
      j_index[index++] = entry;
    }
  }
}

EnsureCheckpoint()

void nimble::EnsureCheckpoint	(	const mpicontext &	context,
		const std::string &	message )

GetComponentLabel()

std::string nimble::GetComponentLabel	(	std::string	label,
		Length	length,
		int	dim,
		int	component_index,
		int	ipt )

{
  if (length == VECTOR) {
    switch (component_index) {
      case 0: label += "_x"; break;
      case 1: label += "_y"; break;
      case 2: label += "_z"; break;
      default: throw std::invalid_argument("\nError in GetComponentLabel().\n");
    }
  } else if (length == SYMMETRIC_TENSOR) {
    if (dim == 2) {
      switch (component_index) {
        case 0: label += "_xx"; break;
        case 1: label += "_yy"; break;
        case 2: label += "_xy"; break;
        default: throw std::invalid_argument("\nError in GetComponentLabel().\n");
      }
    } else if (dim == 3) {
      switch (component_index) {
        case 0: label += "_xx"; break;
        case 1: label += "_yy"; break;
        case 2: label += "_zz"; break;
        case 3: label += "_xy"; break;
        case 4: label += "_yz"; break;
        case 5: label += "_zx"; break;
        default: throw std::invalid_argument("\nError in GetComponentLabel().\n");
      }
    }
  } else if (length == FULL_TENSOR) {
    if (dim == 2) {
      switch (component_index) {
        case 0: label += "_xx"; break;
        case 1: label += "_yy"; break;
        case 2: label += "_xy"; break;
        case 3: label += "_yx"; break;
        default: throw std::invalid_argument("\nError in GetComponentLabel().\n");
      }
    } else if (dim == 3) {
      switch (component_index) {
        case 0: label += "_xx"; break;
        case 1: label += "_yy"; break;
        case 2: label += "_zz"; break;
        case 3: label += "_xy"; break;
        case 4: label += "_yz"; break;
        case 5: label += "_zx"; break;
        case 6: label += "_yx"; break;
        case 7: label += "_zy"; break;
        case 8: label += "_xz"; break;
        default: throw std::invalid_argument("\nError in GetComponentLabel().\n");
      }
    }
  }
 
  label = AddIntegrationPointPrefix(label, ipt);
 
  return label;
}

GetComponentLabels()

std::vector< std::string > nimble::GetComponentLabels	(	std::string	label,
		Length	length,
		int	dim )

{
  std::vector<std::string> labels;
  if (length == SCALAR) {
    labels.push_back(label);
  } else if (length == VECTOR) {
    labels.push_back(label + "_x");
    labels.push_back(label + "_y");
    if (dim == 3) { labels.push_back(label + "_z"); }
  } else if (length == SYMMETRIC_TENSOR) {
    if (dim == 2) {
      labels.push_back(label + "_xx");
      labels.push_back(label + "_yy");
      labels.push_back(label + "_xy");
    } else if (dim == 3) {
      labels.push_back(label + "_xx");
      labels.push_back(label + "_yy");
      labels.push_back(label + "_zz");
      labels.push_back(label + "_xy");
      labels.push_back(label + "_yz");
      labels.push_back(label + "_zx");
    }
  } else if (length == FULL_TENSOR) {
    if (dim == 2) {
      labels.push_back(label + "_xx");
      labels.push_back(label + "_yy");
      labels.push_back(label + "_xy");
      labels.push_back(label + "_xy");
    } else if (dim == 3) {
      labels.push_back(label + "_xx");
      labels.push_back(label + "_yy");
      labels.push_back(label + "_zz");
      labels.push_back(label + "_xy");
      labels.push_back(label + "_yz");
      labels.push_back(label + "_zx");
      labels.push_back(label + "_yx");
      labels.push_back(label + "_zy");
      labels.push_back(label + "_xz");
    }
  } else {
    int num_labels = static_cast<int>(length);
    for (int i = 0; i < num_labels; i++) {
      std::stringstream ss;
      ss << "_" << i + 1;
      labels.push_back(label + ss.str());
    }
  }
  return labels;
}

GetContactManager()

std::shared_ptr< nimble::ContactManager > nimble::GetContactManager	(	std::shared_ptr< ContactInterface >	interface,
		nimble::DataManager &	data_manager )

{
  if (!data_manager.GetParser().HasContact()) return nullptr;
 
#ifdef NIMBLE_HAVE_BVH
  if (data_manager.GetParser().UseVT()) {
    return std::make_shared<nimble::BvhContactManager>(
        interface, data_manager, data_manager.GetParser().ContactDicing(),
        data_manager.GetParser().ContactSplitting());
  }
#endif
 
#if defined(NIMBLE_HAVE_ARBORX)
#if defined(ARBORX_ENABLE_MPI) && defined(NIMBLE_HAVE_MPI)
  return std::make_shared<nimble::ArborXParallelContactManager>(interface, data_manager);
#else
  return std::make_shared<nimble::ArborXSerialContactManager>(interface, data_manager);
#endif
#endif
 
  return std::make_shared<nimble::ContactManager>(interface, data_manager);
}

GetMaximumNodeId()

int nimble::GetMaximumNodeId	(	const std::vector< int > &	global_node_ids,
		const mpicontext &	context )

GetNumberOfNodesAssignedToEachRank()

std::unique_ptr< int[]> nimble::GetNumberOfNodesAssignedToEachRank	(	const std::vector< int > &	global_node_ids,
		const mpicontext &	context )

GroupConsecutive()

template<class Key, class Val>

std::vector< std::pair< Key, std::vector< Val > > > nimble::GroupConsecutive

(

const std::vector< std::pair< Key, Val > > &

lst

)

{
  if (lst.size() == 0) return {};
  std::vector<int> key_ids;
  key_ids.reserve(lst.size() + 1);
  const Key* group_key  = &lst[0].first;
  int        max_key_id = 0;
  int        lst_size   = lst.size();
  for (const std::pair<Key, Val>& p : lst) {
    if (p.first != *group_key) {
      ++max_key_id;
      group_key = &p.first;
    }
    key_ids.push_back(max_key_id);
  }
  key_ids.push_back(max_key_id + 1);
  std::vector<std::pair<Key, std::vector<Val>>> groups;
  groups.reserve(max_key_id + 1);
  {
    int prev_key_id = 0;
    int group_size  = 1;
    for (int i = 1; i <= lst_size; ++i) {
      if (key_ids[i] != prev_key_id) {
        groups.emplace_back(lst[i - 1].first, std::vector<Val>(group_size));
        auto&                      new_elem = groups.back();
        const std::pair<Key, Val>* src_ptr  = &lst[i - group_size];
        for (Val& q : new_elem.second) {
          q = src_ptr->second;
          ++src_ptr;
        }
        group_size  = 1;
        prev_key_id = key_ids[i];
      } else {
        ++group_size;
      }
    }
  }
  return groups;
}

HasIntegrationPointPrefix()

bool nimble::HasIntegrationPointPrefix

(

std::string

label

)

{
  std::string label_without_prefix = RemoveIntegrationPointPrefix(label);
  if (label == label_without_prefix) { return false; }
  return true;
}

InnerProduct() [1/2]

double nimble::InnerProduct ( const std::vector< double > & vec_1, const std::vector< double > & vec_2 )

inline

{
  return InnerProduct(vec_1.size(), &vec_1[0], &vec_2[0]);
}

InnerProduct() [2/2]

double nimble::InnerProduct ( unsigned int num_entries, const double * vec_1, const double * vec_2 )

inline

{
  double result(0.0);
  for (unsigned int i = 0; i < num_entries; i++) { result += vec_1[i] * vec_2[i]; }
#ifdef NIMBLE_HAVE_MPI
  double restmp = result;
  MPI_Allreduce(&restmp, &result, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
#endif
  return result;
}

IOFileName()

std::string nimble::IOFileName	(	std::string const &	serial_name,
		std::string const &	extension,
		std::string const &	label,
		int	my_rank,
		int	num_ranks )

{
  if (serial_name == "none") { return serial_name; }
 
  std::string file_name = serial_name;
  size_t      pos       = file_name.rfind(".g");
  if (pos != std::string::npos) { file_name = file_name.substr(0, pos); }
  pos = file_name.rfind(".e");
  if (pos != std::string::npos) { file_name = file_name.substr(0, pos); }
  if (!label.empty()) { file_name += "." + label; }
  file_name += "." + extension;
  if (num_ranks > 1) {
    std::stringstream num_ranks_ss;
    num_ranks_ss << num_ranks;
    std::stringstream my_rank_ss;
    my_rank_ss << my_rank;
    int               num_zero_padding = num_ranks_ss.str().size() - my_rank_ss.str().size();
    std::stringstream ss;
    ss << file_name << "." << num_ranks << ".";
    for (int i = 0; i < num_zero_padding; i++) { ss << 0; }
    ss << my_rank;
    // file_name += ss.str(); // DJL not thread safe??
    ss >> file_name;
  }
  return file_name;
}

IOFileNameThreadSafe()

void nimble::IOFileNameThreadSafe	(	char const *const	serial_file_name,
		char const *const	extension,
		char const *const	label,
		int	my_mpi_rank,
		int	mpi_num_ranks,
		int	my_thread_rank,
		int	num_threads,
		char *const	file_name )

{
  // copy the input file name to the output file name
  strcpy(file_name, serial_file_name);
 
  // strip off .g or .e suffix
  size_t len = strlen(file_name);
  if (len > 2) { file_name[len - 2] = '\0'; }
 
  // add the label, if any, to the file_name
  size_t label_len = strlen(label);
  if (label_len > 0) {
    strcat(file_name, ".");
    strcat(file_name, label);
  }
 
  // add the extension to the file name
  size_t extension_len = strlen(extension);
  if (extension_len > 0) {
    strcat(file_name, ".");
    strcat(file_name, extension);
  }
 
  if (mpi_num_ranks > 1) {
    // total number of mpi ranks
    char mpi_num_ranks_str[MAX_C_STR_SIZE];
    sprintf(mpi_num_ranks_str, "%d", mpi_num_ranks);
    strcat(file_name, ".");
    strcat(file_name, mpi_num_ranks_str);
 
    // padded mpi rank number
    char my_mpi_rank_str[MAX_C_STR_SIZE];
    sprintf(my_mpi_rank_str, "%d", my_mpi_rank);
    size_t required_str_len = strlen(mpi_num_ranks_str);
    size_t current_str_len  = strlen(my_mpi_rank_str);
    strcat(file_name, ".");
    size_t num_zero_padding = required_str_len - current_str_len;
    for (size_t i = 0; i < num_zero_padding; i++) { strcat(file_name, "0"); }
    strcat(file_name, my_mpi_rank_str);
  }
 
  if (num_threads > 1) {
    // total number of threads
    char num_threads_str[MAX_C_STR_SIZE];
    sprintf(num_threads_str, "%d", num_threads);
    strcat(file_name, ".");
    strcat(file_name, num_threads_str);
 
    // padded thread number
    char my_thread_rank_str[MAX_C_STR_SIZE];
    sprintf(my_thread_rank_str, "%d", my_thread_rank);
    size_t required_str_len = strlen(num_threads_str);
    size_t current_str_len  = strlen(my_thread_rank_str);
    strcat(file_name, ".");
    size_t num_zero_padding = required_str_len - current_str_len;
    for (size_t i = 0; i < num_zero_padding; i++) { strcat(file_name, "0"); }
    strcat(file_name, my_thread_rank_str);
  }
}

LabelToIntegrationPointNumber()

int nimble::LabelToIntegrationPointNumber

(

std::string

label

)

{
  int int_pt_number;
 
  size_t pos = label.find("ipt");
  NIMBLE_ASSERT(pos == 0, 
        "\nError:  LabelToIntegratinPointNumber() called with a label that "
        "does not beging with ipt.\n");
 
  // remove "ipt"
  std::string temp = label.substr(3);
 
  std::stringstream ss;
  bool              first_digits = true;
  for (char& c : temp) {
    if (first_digits && isdigit(c)) {
      ss << c;
    } else {
      first_digits = false;
    }
  }
  ss >> int_pt_number;
 
  return int_pt_number;
}

LabelToLength()

Length nimble::LabelToLength	(	std::string	label,
		std::map< int, Field > const &	data_fields,
		int	dim )

{
  label = RemoveIntegrationPointPrefix(label);
  for (auto const& it : data_fields) {
    Field const& field = it.second;
    if (label == RemoveIntegrationPointPrefix(field.label_)) { return field.length_; }
  }
  throw std::invalid_argument("\nError in LabelToLength(), failed to find label " + label + ".\n");
}

LengthToInt()

int nimble::LengthToInt	(	Length	length,
		int	dim )

{
  int value;
  if (dim == 2) {
    switch (length) {
      case SCALAR: value = 1; break;
      case VECTOR: value = 2; break;
      case SYMMETRIC_TENSOR: value = 3; break;
      case FULL_TENSOR: value = 4; break;
      case UNDEFINED_LENGTH: throw std::invalid_argument("\nError in LengthToInt(), unrecognized Length.\n");
      default: value = static_cast<int>(length); break;
    }
  } else if (dim == 3) {
    switch (length) {
      case SCALAR: value = 1; break;
      case VECTOR: value = 3; break;
      case SYMMETRIC_TENSOR: value = 6; break;
      case FULL_TENSOR: value = 9; break;
      case UNDEFINED_LENGTH: throw std::invalid_argument("\nError in LengthToInt(), unrecognized Length.\n");
      default: value = static_cast<int>(length); break;
    }
  } else {
    throw std::invalid_argument("\nError in LengthToInt(), unrecognized dimension.\n");
  }
  return value;
}

LU_Decompose()

void nimble::LU_Decompose	(	int	num_entries,
		MatrixContainer &	mat,
		int *	index )

LU_Solve()

void nimble::LU_Solve	(	int	num_entries,
		MatrixContainer &	mat,
		double *	vec,
		int *	index )

LU_SolveSystem()

void nimble::LU_SolveSystem	(	int	num_entries,
		MatrixContainer &	mat,
		double *	vec,
		int *	scratch )

ModelData::EmplaceBlocks< nimble::Block >()

template void nimble::ModelData::EmplaceBlocks< nimble::Block >	(	nimble::DataManager &	data_manager,
		const std::shared_ptr< nimble::MaterialFactoryBase > &	material_factory_base )

NimbleVersion()

std::string nimble::NimbleVersion ( )

inline

{
  return (NIMBLE_VERSION_STRING);
}

operator*()

template<std::size_t N>

details::AXPYResult< N > nimble::operator*	(	double	alpha,
		const nimble::Viewify< N > &	A )

{
  return {A, alpha};
}

PackIDSpace()

std::vector< int > nimble::PackIDSpace	(	const std::vector< int > &	raw_node_ids,
		int	max_nodes_assigned_to_a_rank,
		const mpicontext &	context )

ParseContactCommand()

void nimble::ParseContactCommand	(	std::string const &	command,
		std::vector< std::string > &	primary_block_names,
		std::vector< std::string > &	secondary_block_names,
		double &	penalty_parameter )

{
  std::string contact_primary_key;
  std::string contact_secondary_key;
 
  std::stringstream ss(command);
 
  ss >> contact_primary_key;
  if ((contact_primary_key != "primary_blocks") && (contact_primary_key != "master_blocks")) {
    std::stringstream error_ss;
    error_ss << "\n**** Error processing contact command, unknown key: " << contact_primary_key << std::endl;
    throw std::invalid_argument(error_ss.str());
  }
 
  bool secondary_key_found = false;
  while (ss.good() && !secondary_key_found) {
    std::string temp;
    ss >> temp;
    if ((temp == "secondary_blocks") || (temp == "slave_blocks")) {
      secondary_key_found = true;
    } else {
      primary_block_names.push_back(temp);
    }
  }
 
  if (!secondary_key_found) {
    throw std::invalid_argument(
        "\n**** Error processing contact command, expected "
        "\"secondary_blocks\" or \"slave_blocks\" (deprectated).\n");
  }
 
  bool penalty_parameter_key_found = false;
  while (ss.good() && !penalty_parameter_key_found) {
    std::string temp;
    ss >> temp;
    if (temp == "penalty_parameter") {
      penalty_parameter_key_found = true;
    } else {
      secondary_block_names.push_back(temp);
    }
  }
 
  if (!penalty_parameter_key_found) {
    throw std::invalid_argument(
        "\n**** Error processing contact command, expected "
        "\"penalty_parameter\".\n");
  }
 
  ss >> penalty_parameter;
}

PointEdgeClosestPointFindDistanceSquared()

NIMBLE_INLINE_FUNCTION double nimble::PointEdgeClosestPointFindDistanceSquared	(	double const	p1[],
		double const	p2[],
		double const	p[],
		double	t )

{
  double temp1 = p1[0] + (p2[0] - p1[0]) * t - p[0];
  double temp2 = p1[1] + (p2[1] - p1[1]) * t - p[1];
  double temp3 = p1[2] + (p2[2] - p1[2]) * t - p[2];
  return (temp1 * temp1 + temp2 * temp2 + temp3 * temp3);
}

PointEdgeClosestPointFindT()

NIMBLE_INLINE_FUNCTION double nimble::PointEdgeClosestPointFindT	(	double const	p1[],
		double const	p2[],
		double const	p[] )

{
  return ((p[0] - p1[0]) * (p2[0] - p1[0]) + (p[1] - p1[1]) * (p2[1] - p1[1]) + (p[2] - p1[2]) * (p2[2] - p1[2])) /
         ((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]) + (p2[2] - p1[2]) * (p2[2] - p1[2]));
}

PopulateDiagonalPreconditioner()

void nimble::PopulateDiagonalPreconditioner	(	const CRSMatrixContainer &	A,
		CRSMatrixContainer &	M )

Parameters

A	Input sparse matrix
M	Diagonal preconditioner (mathematically M = (diag(A))^{-1})

{
  // the preconditioner must be a diagonal matrix
  if (M.num_rows_ != M.data_.size()) {
    throw std::invalid_argument(
        "**** Error in PopulateDiagonalPreconditioner(), preconditioner must "
        "be a diagonal matrix.\n");
  }
 
  int m_index(0);
  for (int i = 0; i < A.data_.size(); i++) {
    if (A.i_index_[i] == A.j_index_[i]) { M.data_[m_index++] = 1.0 / A.data_[i]; }
  }
}

RemoveIntegrationPointPrefix()

std::string nimble::RemoveIntegrationPointPrefix

(

std::string

label

)

{
  std::string stripped_label(label);
 
  size_t pos = label.find("ipt");
  if (pos == 0) {
    // remove "ipt"
    std::string temp = label.substr(3);
    // strip off integers, they are the integration point number
    // the initial value of 1 is for the trailing underscore
    int  num_digits   = 1;
    bool first_digits = true;
    for (char& c : temp) {
      if (first_digits && isdigit(c)) {
        num_digits++;
      } else {
        first_digits = false;
      }
    }
    stripped_label = temp.substr(num_digits);
  }
  return stripped_label;
}

SerializeContactFaces()

template<typename ArgT>

void nimble::SerializeContactFaces	(	int	num_entities,
		ArgT	contact_entities,
		std::vector< char > &	buffer )

{
  constexpr size_t size_int    = sizeof(int);
  constexpr size_t size_double = sizeof(double);
  size_t           entity_size = 10 * sizeof(double) + 8 * sizeof(int);
  buffer.resize(entity_size * num_entities);
  char* scan = &buffer[0];
  for (int i = 0; i < num_entities; i++) {
    memcpy(scan, &contact_entities[i].coord_1_x_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_1_y_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_1_z_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_2_x_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_2_y_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_2_z_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_3_x_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_3_y_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].coord_3_z_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].char_len_, size_double);
    scan += size_double;
    memcpy(scan, &contact_entities[i].contact_entity_global_id_, size_int);
    scan += size_int;
    memcpy(scan, &contact_entities[i].node_id_for_node_1_, size_int);
    scan += size_int;
    memcpy(scan, &contact_entities[i].node_id_for_node_2_, size_int);
    scan += size_int;
    memcpy(scan, &contact_entities[i].node_id_1_for_fictitious_node_, size_int);
    scan += size_int;
    memcpy(scan, &contact_entities[i].node_id_2_for_fictitious_node_, size_int);
    scan += size_int;
    memcpy(scan, &contact_entities[i].node_id_3_for_fictitious_node_, size_int);
    scan += size_int;
    memcpy(scan, &contact_entities[i].node_id_4_for_fictitious_node_, size_int);
    scan += size_int;
  }
}

split()

std::list< std::string > nimble::split

(

std::string

line

)

{
  auto iss   = std::istringstream{line};
  auto str   = std::string{};
  auto items = std::list<std::string>();
  while (iss >> str) { items.push_back(str); }
  return items;
};

string_to_double()

double nimble::string_to_double ( const std::string & s )

inline

{
  std::stringstream ss;
  ss << s;
  double val = std::numeric_limits<double>::max();
  ss >> val;
  return val;
}

tokenize_string()

std::vector< std::string > nimble::tokenize_string ( const std::string & s )

inline

{
  std::vector<std::string> tokens;
  auto                     quote_delimited_segments = tokenize_string_with_separator(s, '"');
  auto                     is_quoted_segment        = [](int i) -> bool { return (i % 2) == 1; };
  auto                     quote                    = quote_delimited_segments.begin();
  auto                     quote_end                = quote_delimited_segments.end();
  int                      i                        = 0;
  for (; quote != quote_end; ++quote, ++i) {
    if (is_quoted_segment(i)) {
      tokens.push_back(*quote);
    } else {
      auto segment_tokens = tokenize_string_with_separator(*quote, ' ');
      tokens.insert(tokens.end(), segment_tokens.begin(), segment_tokens.end());
    }
  }
  return tokens;
}

TriangleArea()

NIMBLE_INLINE_FUNCTION double nimble::TriangleArea	(	double	pt_1_x,
		double	pt_1_y,
		double	pt_1_z,
		double	pt_2_x,
		double	pt_2_y,
		double	pt_2_z,
		double	pt_3_x,
		double	pt_3_y,
		double	pt_3_z )

{
  double a[3], b[3], cross[3], area;
  a[0] = pt_2_x - pt_1_x;
  a[1] = pt_2_y - pt_1_y;
  a[2] = pt_2_z - pt_1_z;
  b[0] = pt_3_x - pt_1_x;
  b[1] = pt_3_y - pt_1_y;
  b[2] = pt_3_z - pt_1_z;
  CrossProduct(b, a, cross);
  area = 0.5 * std::sqrt(cross[0] * cross[0] + cross[1] * cross[1] + cross[2] * cross[2]);
  return area;
}

UnserializeContactFaces()

template<typename ArgT>

void nimble::UnserializeContactFaces	(	int	num_entities,
		ArgT	contact_entities,
		std::vector< char > &	buffer )

{
  constexpr size_t size_int    = sizeof(int);
  constexpr size_t size_double = sizeof(double);
  ContactEntity    entity;
  entity.entity_type_ = ContactEntity::TRIANGLE;
  entity.num_nodes_   = 3;
  entity.force_1_x_   = 0.0;
  entity.force_1_y_   = 0.0;
  entity.force_1_z_   = 0.0;
  entity.force_2_x_   = 0.0;
  entity.force_2_y_   = 0.0;
  entity.force_2_z_   = 0.0;
  entity.force_3_x_   = 0.0;
  entity.force_3_y_   = 0.0;
  entity.force_3_z_   = 0.0;
  char* scan          = &buffer[0];
  for (int i = 0; i < num_entities; i++) {
    memcpy(&entity.coord_1_x_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_1_y_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_1_z_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_2_x_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_2_y_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_2_z_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_3_x_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_3_y_, scan, size_double);
    scan += size_double;
    memcpy(&entity.coord_3_z_, scan, size_double);
    scan += size_double;
    memcpy(&entity.char_len_, scan, size_double);
    scan += size_double;
    memcpy(&entity.contact_entity_global_id_, scan, size_int);
    scan += size_int;
    memcpy(&entity.node_id_for_node_1_, scan, size_int);
    scan += size_int;
    memcpy(&entity.node_id_for_node_2_, scan, size_int);
    scan += size_int;
    memcpy(&entity.node_id_1_for_fictitious_node_, scan, size_int);
    scan += size_int;
    memcpy(&entity.node_id_2_for_fictitious_node_, scan, size_int);
    scan += size_int;
    memcpy(&entity.node_id_3_for_fictitious_node_, scan, size_int);
    scan += size_int;
    memcpy(&entity.node_id_4_for_fictitious_node_, scan, size_int);
    scan += size_int;
    entity.SetBoundingBox();
    contact_entities[i] = entity;
  }
}

Variable Documentation

MAX_C_STR_SIZE

int nimble::MAX_C_STR_SIZE = 256

constexpr