nimble::BlockBase Class Reference

#include <nimble_block_base.h>

Inheritance diagram for nimble::BlockBase:

Public Member Functions
	BlockBase ()=default
virtual	~BlockBase ()=default
virtual void	InstantiateElement ()=0
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 Attributes
std::string	model_material_parameters_ = "none"
std::shared_ptr< Element >	element_ = nullptr
std::shared_ptr< Material >	material_ = nullptr

Constructor & Destructor Documentation

BlockBase()

nimble::BlockBase::BlockBase ( )

default

~BlockBase()

virtual nimble::BlockBase::~BlockBase ( )

virtualdefault

Member Function Documentation

ComputeCriticalTimeStep()

double nimble::BlockBase::ComputeCriticalTimeStep ( const nimble::Viewify< 2 > & node_reference_coordinates, const nimble::Viewify< 2 > & node_displacements, int num_elem, const int * elem_conn ) const

virtual

{
  int    dim                = element_->Dim();
  int    num_node_per_elem  = element_->NumNodesPerElement();
  double sound_speed        = std::sqrt(GetBulkModulus() / GetDensity());
  double critical_time_step = std::numeric_limits<double>::max();
 
  int vector_size = 0;
  if (dim == 2) {
    vector_size = 2;
  } else if (dim == 3) {
    vector_size = 3;
  }
  double node_coord[vector_size * 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++) {
        node_coord[node * vector_size + i] = node_reference_coordinates(node_id, i) + node_displacements(node_id, i);
      }
    }
 
    double elem_critical_time_step = element_->ComputeCharacteristicLength(node_coord) / sound_speed;
    if (elem_critical_time_step < critical_time_step) { critical_time_step = elem_critical_time_step; }
  }
 
  return critical_time_step;
}

ComputeTangentStiffnessMatrix()

template<typename MatT>

template void nimble::BlockBase::ComputeTangentStiffnessMatrix< CRSMatrixContainer >	(	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

{
  int dim                 = element_->Dim();
  int num_node_per_elem   = element_->NumNodesPerElement();
  int num_int_pt_per_elem = element_->NumIntegrationPointsPerElement();
 
  int vector_size      = LengthToInt(nimble::VECTOR, dim);
  int full_tensor_size = LengthToInt(nimble::FULL_TENSOR, dim);
  int sym_tensor_size  = LengthToInt(nimble::SYMMETRIC_TENSOR, dim);
 
  double cur_coord[vector_size * num_node_per_elem];
  double material_tangent[6 * 6 * num_int_pt_per_elem];  // correct for 3D,
  // overkill for 2D
  double element_tangent[num_node_per_elem * vector_size * num_node_per_elem * vector_size];
 
  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++) {
        cur_coord[node * vector_size + i] =
            reference_coordinates[vector_size * node_id + i] + displacement[vector_size * node_id + i];
      }
    }
 
    material_->GetTangent(num_int_pt_per_elem, material_tangent);
 
    element_->ComputeTangent(cur_coord, material_tangent, element_tangent);
 
    for (int row = 0; row < num_node_per_elem; row++) {
      int global_row_node = global_node_ids[elem_conn[elem * num_node_per_elem + row]];
      for (int col = 0; col < num_node_per_elem; col++) {
        int global_col_node = global_node_ids[elem_conn[elem * num_node_per_elem + col]];
        for (int i = 0; i < vector_size; i++) {
          for (int j = 0; j < vector_size; j++) {
            int    local_row_index  = row * vector_size + i;
            int    local_col_index  = col * vector_size + j;
            int    global_row_index = global_row_node * vector_size + i;
            int    global_col_index = global_col_node * vector_size + j;
            double value = element_tangent[local_row_index * num_node_per_elem * vector_size + local_col_index];
            tangent_stiffness(global_row_index, global_col_index) += value;
            // tangent_stiffness.sumIntoValue(global_row_index,
            // global_col_index, value);
          }
        }
      }
    }
  }
}

GetBulkModulus()

double nimble::BlockBase::GetBulkModulus ( ) const

inline

  {
    return material_->GetBulkModulus();
  }

GetDensity()

double nimble::BlockBase::GetDensity ( ) const

inline

  {
    return material_->GetDensity();
  }

GetElementPointer()

std::shared_ptr< Element > nimble::BlockBase::GetElementPointer ( ) const

inline

  {
    return element_;
  }

GetMaterialPointer()

std::shared_ptr< Material > nimble::BlockBase::GetMaterialPointer ( ) const

inline

  {
    return material_;
  }

GetShearModulus()

double nimble::BlockBase::GetShearModulus ( ) const

inline

  {
    return material_->GetShearModulus();
  }

InstantiateElement()

virtual void nimble::BlockBase::InstantiateElement ( )

pure virtual

Implemented in nimble::Block, and nimble_kokkos::Block.

Member Data Documentation

element_

std::shared_ptr<Element> nimble::BlockBase::element_ = nullptr

protected

material_

std::shared_ptr<Material> nimble::BlockBase::material_ = nullptr

protected

model_material_parameters_

std::string nimble::BlockBase::model_material_parameters_ = "none"

protected

---

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

• src/nimble_block_base.h
• src/nimble_block_base.cc