nimble::Block Class Reference

#include <nimble_block.h>

Inheritance diagram for nimble::Block:

Public Member Functions
	Block ()
	~Block () override=default
void	Initialize (std::string const &model_material_parameters, MaterialFactory &factory)
void	InstantiateMaterialModel (MaterialFactory &factory)
void	InstantiateElement () override
void	GetDataLabelsAndLengths (std::vector< std::pair< std::string, Length > > &data_labels_and_lengths)
void	ComputeLumpedMassMatrix (const double *const reference_coordinates, int num_elem, const int *const elem_conn, double *lumped_mass) const
void	InitializeElementData (int num_elem_in_block, std::vector< int > const &elem_global_ids_in_block, std::vector< std::string > const &elem_data_labels, std::vector< std::string > const &derived_elem_data_labels, std::vector< double > &elem_data_n, std::vector< double > &elem_data_np1, MaterialFactory &material_factory, DataManager &data_manager)
void	ComputeInternalForce (const double *reference_coordinates, const double *displacement, const double *velocity, double *internal_force, double time_previous, double time_current, int num_elem, const int *elem_conn, const int *elem_global_ids, std::vector< std::string > const &elem_data_labels, std::vector< double > const &elem_data_n, std::vector< double > &elem_data_np1, DataManager &data_manager, bool is_output_step, bool compute_stress_only=false) const
void	ComputeDerivedElementData (const double *const reference_coordinates, const double *const displacement, int num_elem, const int *const elem_conn, int num_elem_data, std::vector< double > const &elem_data_np1, int num_derived_elem_data, std::vector< std::vector< double > > &derived_elem_data)
Public Member Functions inherited from nimble::BlockBase
	BlockBase ()=default
virtual	~BlockBase ()=default
double	GetDensity () const
double	GetBulkModulus () const
double	GetShearModulus () const
std::shared_ptr< Material >	GetMaterialPointer () const
std::shared_ptr< Element >	GetElementPointer () const
virtual double	ComputeCriticalTimeStep (const nimble::Viewify< 2 > &node_reference_coordinates, const nimble::Viewify< 2 > &node_displacements, int num_elem, const int *elem_conn) const
template<typename MatT>
void	ComputeTangentStiffnessMatrix (int num_global_unknowns, const double *const reference_coordinates, const double *const displacement, int num_elem, const int *const elem_conn, const int *const global_node_ids, MatT &tangent_stiffness) const

Protected Member Functions
void	DetermineDataOffsets (std::vector< std::string > const &elem_data_labels, std::vector< std::string > const &derived_elem_data_labels)

Protected Attributes
std::vector< int >	def_grad_offset_
std::vector< int >	stress_offset_
std::vector< int >	state_data_offset_
int	vol_ave_volume_offset_
std::vector< int >	vol_ave_offsets_
std::map< int, int >	vol_ave_index_to_derived_data_index_
Protected Attributes inherited from nimble::BlockBase
std::string	model_material_parameters_ = "none"
std::shared_ptr< Element >	element_ = nullptr
std::shared_ptr< Material >	material_ = nullptr

Constructor & Destructor Documentation

Block()

nimble::Block::Block ( )

inline

: BlockBase(), vol_ave_volume_offset_(-1) {}

~Block()

nimble::Block::~Block ( )

overridedefault

Member Function Documentation

ComputeDerivedElementData()

void nimble::Block::ComputeDerivedElementData	(	const double *const	reference_coordinates,
		const double *const	displacement,
		int	num_elem,
		const int *const	elem_conn,
		int	num_elem_data,
		std::vector< double > const &	elem_data_np1,
		int	num_derived_elem_data,
		std::vector< std::vector< double > > &	derived_elem_data )

{
  // Currently supported derived element data are:
  // 1) Element volume
  // 2) Volume-averaged element data
 
  if (num_derived_elem_data == 0) { return; }
  if (derived_elem_data.size() != num_derived_elem_data) { derived_elem_data.resize(num_derived_elem_data); }
  for (auto& vec : derived_elem_data) {
    if (vec.size() != num_elem) { vec.resize(num_elem); }
  }
 
  int dim                 = element_->Dim();
  int vector_size         = LengthToInt(VECTOR, dim);
  int num_node_per_elem   = element_->NumNodesPerElement();
  int num_int_pt_per_elem = element_->NumIntegrationPointsPerElement();
  int num_data_per_int_pt = num_elem_data / num_int_pt_per_elem;
 
  // Containers that will be passed to an individual element to compute element
  // volume and volume-averaged quantities
  double       cur_coord[vector_size * num_node_per_elem];
  unsigned int num_vol_ave_data = vol_ave_offsets_.size() / num_int_pt_per_elem;
  double       int_pt_quantities[num_vol_ave_data * num_int_pt_per_elem];
  double       volume;
  double       vol_ave_quantities[num_vol_ave_data];
 
  // Loop over each element and compute element volume and volume-averaged
  // quantities
  for (int i_elem = 0; i_elem < num_elem; i_elem++) {
    // Load per element data containers
    for (int node = 0; node < num_node_per_elem; node++) {
      int node_id = elem_conn[i_elem * num_node_per_elem + node];
      for (int i = 0; i < vector_size; i++) {
        cur_coord[node * vector_size + i] =
            reference_coordinates[vector_size * node_id + i] + displacement[vector_size * node_id + i];
      }
    }
    for (int i = 0; i < num_vol_ave_data * num_int_pt_per_elem; ++i) {
      int_pt_quantities[i] = elem_data_np1[i_elem * num_data_per_int_pt * num_int_pt_per_elem + vol_ave_offsets_.at(i)];
    }
 
    // Compute element volume and volume-averaged quantities
    element_->ComputeVolumeAverage(cur_coord, num_vol_ave_data, &int_pt_quantities[0], volume, vol_ave_quantities);
 
    // Copy the results into the global containers for derived data
    for (int i = 0; i < num_vol_ave_data; i++) {
      derived_elem_data.at(vol_ave_index_to_derived_data_index_[i]).at(i_elem) = vol_ave_quantities[i];
    }
    if (vol_ave_volume_offset_ != -1) { derived_elem_data.at(vol_ave_volume_offset_).at(i_elem) = volume; }
  }
}

ComputeInternalForce()

void nimble::Block::ComputeInternalForce	(	const double *	reference_coordinates,
		const double *	displacement,
		const double *	velocity,
		double *	internal_force,
		double	time_previous,
		double	time_current,
		int	num_elem,
		const int *	elem_conn,
		const int *	elem_global_ids,
		std::vector< std::string > const &	elem_data_labels,
		std::vector< double > const &	elem_data_n,
		std::vector< double > &	elem_data_np1,
		DataManager &	data_manager,
		bool	is_output_step,
		bool	compute_stress_only = false ) const

{
  double* elem_data_np1_ptr = elem_data_np1.data();
  int     num_element_data  = static_cast<int>(elem_data_labels.size());
 
  ComputeInternalForceFunctor functor(
      element_,
      material_,
      def_grad_offset_,
      stress_offset_,
      state_data_offset_,
      reference_coordinates,
      displacement,
      velocity,
      internal_force,
      time_previous,
      time_current,
      num_elem,
      elem_conn,
      elem_global_ids,
      num_element_data,
      &elem_data_n[0],
      elem_data_np1_ptr,
      data_manager,
      is_output_step,
      compute_stress_only);
 
#ifdef NIMBLE_HAVE_KOKKOS
  Kokkos::parallel_for(num_elem, functor);
#else
  for (int elem = 0; elem < num_elem; elem++) { functor(elem); }  // for (int elem = 0; elem < num_elem; elem++)
#endif
}

ComputeLumpedMassMatrix()

void nimble::Block::ComputeLumpedMassMatrix	(	const double *const	reference_coordinates,
		int	num_elem,
		const int *const	elem_conn,
		double *	lumped_mass ) const

{
  int    dim               = element_->Dim();
  int    num_node_per_elem = element_->NumNodesPerElement();
  double density           = GetDensity();
 
  int vector_size = 0;
  if (dim == 2) {
    vector_size = 2;
  } else if (dim == 3) {
    vector_size = 3;
  }
 
  double ref_coord[vector_size * num_node_per_elem];
  double mass[num_node_per_elem];
 
  for (int elem = 0; elem < num_elem; elem++) {
    for (int node = 0; node < num_node_per_elem; node++) {
      int node_id = elem_conn[elem * num_node_per_elem + node];
      for (int i = 0; i < vector_size; i++) {
        ref_coord[node * vector_size + i] = reference_coordinates[vector_size * node_id + i];
      }
    }
 
    element_->ComputeLumpedMass(density, ref_coord, mass);
 
    for (int node = 0; node < num_node_per_elem; node++) {
      int node_id = elem_conn[elem * num_node_per_elem + node];
      lumped_mass[node_id] += mass[node];
    }
  }
}

DetermineDataOffsets()

void nimble::Block::DetermineDataOffsets ( std::vector< std::string > const & elem_data_labels, std::vector< std::string > const & derived_elem_data_labels )

protected

{
  int dim                  = element_->Dim();
  int num_int_pt_per_elem  = element_->NumIntegrationPointsPerElement();
  int num_data_per_element = static_cast<int>(elem_data_labels.size());
  int num_data_per_int_pt  = num_data_per_element / num_int_pt_per_elem;
  int full_tensor_size     = LengthToInt(FULL_TENSOR, dim);
  int sym_tensor_size      = LengthToInt(SYMMETRIC_TENSOR, dim);
 
  // Determine the offset for the derformation gradient in the element data
  // container
  def_grad_offset_.clear();
  for (int i_ipt = 0; i_ipt < num_int_pt_per_elem; i_ipt++) {
    for (int i_component = 0; i_component < full_tensor_size; i_component++) {
      std::string def_grad_label = GetComponentLabel("deformation_gradient", FULL_TENSOR, dim, i_component, i_ipt + 1);
      for (unsigned int i_label = 0; i_label < num_data_per_element; i_label++) {
        if (elem_data_labels.at(i_label) == def_grad_label) { def_grad_offset_.push_back(i_label); }
      }
    }
  }
 
  NIMBLE_ASSERT(def_grad_offset_.size() == full_tensor_size * num_int_pt_per_elem,
                "\nError in Block::ComputeInternalForce(), failed to index def_grad "
                "into global data.\n");
 
  // Determine the offset for the stress in the element data container
  stress_offset_.clear();
  for (int i_ipt = 0; i_ipt < num_int_pt_per_elem; i_ipt++) {
    for (int i_component = 0; i_component < sym_tensor_size; i_component++) {
      std::string stress_label = GetComponentLabel("stress", SYMMETRIC_TENSOR, dim, i_component, i_ipt + 1);
      for (unsigned int i_label = 0; i_label < num_data_per_element; i_label++) {
        if (elem_data_labels.at(i_label) == stress_label) { stress_offset_.push_back(i_label); }
      }
    }
  }
 
  NIMBLE_ASSERT(stress_offset_.size() == sym_tensor_size * num_int_pt_per_elem,
                "\nError in Block::ComputeInternalForce(), failed to index stress into "
                "global data.\n");
 
  // Determine the offset for the state data in the element data container
  int                      num_state_data = material_->NumStateVariables();
  std::vector<std::string> state_data_labels(num_state_data);
  for (int i = 0; i < num_state_data; ++i) {
    char label[MaterialParameters::MAX_MAT_MODEL_STR_LEN];
    material_->GetStateVariableLabel(i, label);
    state_data_labels[i] = label;
  }
  state_data_offset_.clear();
  for (int i_ipt = 0; i_ipt < num_int_pt_per_elem; i_ipt++) {
    for (int i_state_data = 0; i_state_data < num_state_data; i_state_data++) {
      std::string raw_label        = state_data_labels.at(i_state_data);
      std::string state_data_label = GetComponentLabel(raw_label, SCALAR, dim, 0, i_ipt + 1);
      for (unsigned int i_label = 0; i_label < num_data_per_element; i_label++) {
        if (elem_data_labels.at(i_label) == state_data_label) { state_data_offset_.push_back(i_label); }
      }
    }
  }
 
  NIMBLE_ASSERT(state_data_offset_.size() == num_state_data * num_int_pt_per_elem,
                "\nError in Block::ComputeInternalForce(), failed to index state data "
                "into global data.\n");
 
  // Determine which requested derived data are volume-averaged data
  // and set up some bookkeeping
  std::vector<std::string> vol_ave_labels;
  vol_ave_volume_offset_ = -1;
  for (unsigned int i_derived_data = 0; i_derived_data < derived_elem_data_labels.size(); i_derived_data++) {
    std::string const& label = derived_elem_data_labels[i_derived_data];
    if (label == "volume") {
      vol_ave_volume_offset_ = i_derived_data;
    } else {
      vol_ave_index_to_derived_data_index_[vol_ave_labels.size()] = i_derived_data;
      vol_ave_labels.push_back(label);
    }
  }
  unsigned int num_vol_ave_data = vol_ave_labels.size();
  vol_ave_offsets_.resize(num_vol_ave_data * num_int_pt_per_elem);
  // Bookkeeping to allow for loading the per element containers
  for (unsigned int i_vol_ave_label = 0; i_vol_ave_label < num_vol_ave_data; ++i_vol_ave_label) {
    std::string const& vol_ave_label = vol_ave_labels[i_vol_ave_label];
    for (unsigned int i_elem_data_label = 0; i_elem_data_label < num_data_per_int_pt; ++i_elem_data_label) {
      std::string const& elem_data_label = RemoveIntegrationPointPrefix(elem_data_labels[i_elem_data_label]);
      if (vol_ave_label == elem_data_label) {
        for (int i_int_pt = 0; i_int_pt < num_int_pt_per_elem; ++i_int_pt) {
          vol_ave_offsets_[i_vol_ave_label + i_int_pt * num_vol_ave_data] =
              i_elem_data_label + i_int_pt * num_data_per_int_pt;
        }
      }
    }
  }
}

GetDataLabelsAndLengths()

void nimble::Block::GetDataLabelsAndLengths

(

std::vector< std::pair< std::string, Length > > &

data_labels_and_lengths

)

{
  int                                         num_int_pts = element_->NumIntegrationPointsPerElement();
  std::vector<std::pair<std::string, Length>> mat_model_data_labels_and_lengths;
  // kinematic data
  mat_model_data_labels_and_lengths.push_back(std::pair<std::string, Length>("deformation_gradient", FULL_TENSOR));
  mat_model_data_labels_and_lengths.push_back(std::pair<std::string, Length>("stress", SYMMETRIC_TENSOR));
  // material state data
  int  num_data = material_->NumStateVariables();
  char label[MaterialParameters::MAX_MAT_MODEL_STR_LEN];
  for (int i = 0; i < num_data; ++i) {
    material_->GetStateVariableLabel(i, label);
    mat_model_data_labels_and_lengths.push_back(std::pair<std::string, Length>(label, SCALAR));
  }
  for (int i_ipt = 0; i_ipt < num_int_pts; i_ipt++) {
    for (unsigned int i_label = 0; i_label < mat_model_data_labels_and_lengths.size(); i_label++) {
      std::string                    material_label = mat_model_data_labels_and_lengths[i_label].first;
      Length                         length         = mat_model_data_labels_and_lengths[i_label].second;
      std::string                    label          = AddIntegrationPointPrefix(material_label, i_ipt + 1);
      std::pair<std::string, Length> label_and_length(label, length);
      data_labels_and_lengths.push_back(label_and_length);
    }
  }
}

Initialize()

void nimble::Block::Initialize	(	std::string const &	model_material_parameters,
		MaterialFactory &	factory )

{
  model_material_parameters_ = model_material_parameters;
  InstantiateMaterialModel(factory);
  InstantiateElement();
}

InitializeElementData()

void nimble::Block::InitializeElementData	(	int	num_elem_in_block,
		std::vector< int > const &	elem_global_ids_in_block,
		std::vector< std::string > const &	elem_data_labels,
		std::vector< std::string > const &	derived_elem_data_labels,
		std::vector< double > &	elem_data_n,
		std::vector< double > &	elem_data_np1,
		MaterialFactory &	material_factory,
		DataManager &	data_manager )

{
  int num_int_pts = element_->NumIntegrationPointsPerElement();
#ifndef NIMBLE_HAVE_KOKKOS
  for (int i_elem = 0; i_elem < num_elem_in_block; ++i_elem) {
    int elem_global_id = elem_global_ids_in_block.at(i_elem);
  }
#endif
 
  unsigned int stride = elem_data_labels.size();
 
  std::map<std::string, double> state_variable_initial_values;
  char                          label[MaterialParameters::MAX_MAT_MODEL_STR_LEN];
  for (int i = 0; i < material_->NumStateVariables(); ++i) {
    material_->GetStateVariableLabel(i, label);
    double      state_variable_initial_value = material_->GetStateVariableInitialValue(i);
    std::string state_variable_label(label);
    state_variable_initial_values[state_variable_label] = state_variable_initial_value;
  }
 
  for (unsigned int i_variable = 0; i_variable < elem_data_labels.size(); i_variable++) {
    std::string label     = elem_data_labels[i_variable];
    std::string ipt_label = RemoveIntegrationPointPrefix(label);
 
    double initial_value = 0.0;
    auto   it            = state_variable_initial_values.find(label);
    if (it != state_variable_initial_values.end()) { initial_value = it->second; }
 
    for (int i_elem = 0; i_elem < num_elem_in_block; ++i_elem) {
      // override the material's intial values for the special cases
      // of global element id and integration point number
      if (ipt_label == "global_elem_id") {
        int elem_global_id = elem_global_ids_in_block.at(i_elem);
        initial_value      = elem_global_id;
      } else if (ipt_label == "ipt_id") {
        int integration_point_id = static_cast<double>(LabelToIntegrationPointNumber(label));
        initial_value            = integration_point_id;
      } else if (
          ipt_label == "deformation_gradient_xx" || ipt_label == "deformation_gradient_yy" ||
          ipt_label == "deformation_gradient_zz") {
        initial_value = 1.0;
      }
 
      int index            = i_elem * stride + i_variable;
      elem_data_n[index]   = initial_value;
      elem_data_np1[index] = initial_value;
    }
  }
 
  DetermineDataOffsets(elem_data_labels, derived_elem_data_labels);
}

InstantiateElement()

void nimble::Block::InstantiateElement ( )

overridevirtual

Implements nimble::BlockBase.

{
  element_ = std::make_shared<HexElement>();
}

InstantiateMaterialModel()

void nimble::Block::InstantiateMaterialModel

(

MaterialFactory &

factory

)

{
  if (model_material_parameters_ != "none") {
    factory.parse_and_create(model_material_parameters_);
    material_ = factory.get_material();
  } else {
    NIMBLE_ABORT("\nError in Block::InstantiateMaterialModel(), invalid material "
        "parameters\n");
  }
}

Member Data Documentation

def_grad_offset_

std::vector<int> nimble::Block::def_grad_offset_

protected

state_data_offset_

std::vector<int> nimble::Block::state_data_offset_

protected

stress_offset_

std::vector<int> nimble::Block::stress_offset_

protected

vol_ave_index_to_derived_data_index_

std::map<int, int> nimble::Block::vol_ave_index_to_derived_data_index_

protected

vol_ave_offsets_

std::vector<int> nimble::Block::vol_ave_offsets_

protected

vol_ave_volume_offset_

int nimble::Block::vol_ave_volume_offset_

protected

---

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

• src/nimble_block.h
• src/nimble_block.cc