nimble_kokkos::ModelData Class Reference

#include <nimble_kokkos_model_data.h>

Inheritance diagram for nimble_kokkos::ModelData:

Public Member Functions
	ModelData ()
	~ModelData () override
int	AllocateNodeData (nimble::Length length, std::string label, int num_objects) override
	Allocate data storage for a node-based quantity.
int	GetFieldId (const std::string &field_label) const override
	Returns the field ID for a specific label.
void	InitializeBlocks (nimble::DataManager &data_manager, const std::shared_ptr< nimble::MaterialFactoryBase > &material_factory_base) override
	Initialize the different blocks in the mesh.
void	UpdateStates (const nimble::DataManager &data_manager) override
	Copy time state (n+1) into time state (n)
nimble::Viewify< 1 >	GetScalarNodeData (int field_id) override
	Get view of scalar quantity defined on nodes.
nimble::Viewify< 2 >	GetVectorNodeData (int field_id) override
	Get view of vector quantity defined on nodes.
void	ComputeLumpedMass (nimble::DataManager &data_manager) override
	Compute the lumped mass.
void	InitializeExodusOutput (nimble::DataManager &data_manager) override
void	WriteExodusOutput (nimble::DataManager &data_manager, double time_current) override
	Write output of simulation in Exodus format.
void	ComputeInternalForce (nimble::DataManager &data_manager, double time_previous, double time_current, bool is_output_step, const nimble::Viewify< 2 > &displacement, nimble::Viewify< 2 > &force) override
	Compute the internal force.
void	UpdateWithNewVelocity (nimble::DataManager &data_manager, double dt) override
	Update model with new velocity.
void	UpdateWithNewDisplacement (nimble::DataManager &data_manager, double dt) override
	Update model with new displacement.
int	AllocateElementData (int block_id, nimble::Length length, std::string label, int num_objects)
int	AllocateIntegrationPointData (int block_id, nimble::Length length, std::string label, int num_objects, std::vector< double > initial_value=std::vector< double >())
std::vector< int >	GetBlockIds () const
std::vector< std::string >	GetScalarNodeDataLabels () const
std::vector< std::string >	GetVectorNodeDataLabels () const
std::vector< std::string >	GetSymmetricTensorIntegrationPointDataLabels (int block_id) const
std::vector< std::string >	GetFullTensorIntegrationPointDataLabels (int block_id) const
HostScalarNodeView	GetHostScalarNodeData (int field_id)
HostVectorNodeView	GetHostVectorNodeData (int field_id)
HostSymTensorIntPtView	GetHostSymTensorIntegrationPointData (int block_id, int field_id, nimble::Step step)
HostFullTensorIntPtView	GetHostFullTensorIntegrationPointData (int block_id, int field_id, nimble::Step step)
HostScalarElemView	GetHostScalarElementData (int block_id, int field_id)
HostSymTensorElemView	GetHostSymTensorElementData (int block_id, int field_id)
HostFullTensorElemView	GetHostFullTensorElementData (int block_id, int field_id)
DeviceScalarNodeView	GetDeviceScalarNodeData (int field_id)
DeviceVectorNodeView	GetDeviceVectorNodeData (int field_id)
DeviceSymTensorIntPtView	GetDeviceSymTensorIntegrationPointData (int block_id, int field_id, nimble::Step step)
DeviceFullTensorIntPtView	GetDeviceFullTensorIntegrationPointData (int block_id, int field_id, nimble::Step step)
DeviceScalarIntPtView	GetDeviceScalarIntegrationPointData (int block_id, int field_id, nimble::Step step)
DeviceVectorIntPtView	GetDeviceVectorIntegrationPointData (int block_id, int field_id, nimble::Step step)
DeviceScalarElemView	GetDeviceScalarElementData (int block_id, int field_id)
DeviceSymTensorElemView	GetDeviceSymTensorElementData (int block_id, int field_id)
DeviceFullTensorElemView	GetDeviceFullTensorElementData (int block_id, int field_id)
DeviceScalarNodeGatheredView	GatherScalarNodeData (int field_id, int num_elements, int num_nodes_per_element, const DeviceElementConnectivityView &elem_conn_d, DeviceScalarNodeGatheredView gathered_view_d)
DeviceVectorNodeGatheredView	GatherVectorNodeData (int field_id, int num_elements, int num_nodes_per_element, const DeviceElementConnectivityView &elem_conn_d, DeviceVectorNodeGatheredView gathered_view_d)
void	ScatterScalarNodeData (int field_id, int num_elements, int num_nodes_per_element, const DeviceElementConnectivityView &elem_conn_d, const DeviceScalarNodeGatheredView &gathered_view_d)
void	ScatterVectorNodeData (int field_id, int num_elements, int num_nodes_per_element, const DeviceElementConnectivityView &elem_conn_d, const DeviceVectorNodeGatheredView &gathered_view_d)
void	ScatterScalarNodeDataUsingKokkosScatterView (int field_id, int num_elements, int num_nodes_per_element, const DeviceElementConnectivityView &elem_conn_d, const DeviceScalarNodeGatheredView &gathered_view_d)
Public Member Functions inherited from nimble::ModelDataBase
	ModelDataBase ()=default
	Constructor.
virtual	~ModelDataBase ()=default
	Destructor.
int	GetFieldIdChecked (const std::string &field_label) const
virtual void	InitializeBlocks (nimble::DataManager &data_manager, const std::shared_ptr< nimble::MaterialFactoryBase > &material_factory_base)=0
	Initialize the different blocks in the mesh.
nimble::Viewify< 1 >	GetScalarNodeData (const std::string &label)
	Get view of scalar quantity defined on nodes.
nimble::Viewify< 2 >	GetVectorNodeData (const std::string &label)
	Get view of vector quantity defined on nodes.
virtual void	ComputeExternalForce (nimble::DataManager &data_manager, double time_previous, double time_current, bool is_output_step)
	Compute the external force.
virtual void	ApplyInitialConditions (nimble::DataManager &data_manager)
	Apply initial conditions.
virtual void	ApplyKinematicConditions (nimble::DataManager &data_manager, double time_current, double time_previous)
	Apply kinematic conditions.
int	GetDimension () const
	Get the spatial dimension.
void	SetCriticalTimeStep (double time_step)
	Set the critical time step.
void	SetDimension (int dim)
	Set spatial dimension.
void	SetReferenceCoordinates (const nimble::GenesisMesh &mesh)
	Set reference coordinates.
double	GetCriticalTimeStep () const
	Get the critical time step.
const std::vector< std::string > &	GetNodeDataLabelsForOutput () const
const std::map< int, std::vector< std::string > > &	GetElementDataLabels () const
const std::map< int, std::vector< std::string > > &	GetElementDataLabelsForOutput () const
const std::map< int, std::vector< std::string > > &	GetDerivedElementDataLabelsForOutput () const

Protected Types
using	Data = std::unique_ptr<FieldBase>

Protected Member Functions
void	InitializeGatheredVectors (const nimble::GenesisMesh &mesh_)
void	InitializeBlockData (nimble::DataManager &data_manager)
	Initialize block data for material information.
template<FieldType ft>
Field< ft >::View	GetDeviceElementData (int block_id, int field_id)
template<FieldType ft>
Field< ft >::View	GetDeviceIntPointData (int block_id, int field_id, nimble::Step step)

Protected Attributes
std::map< std::string, int >	field_label_to_field_id_map_
std::map< int, nimble_kokkos::Block >	blocks_
	Blocks.
std::vector< Data >	host_node_data_
std::vector< Data >	device_node_data_
std::map< int, int >	field_id_to_host_node_data_index_
std::map< int, int >	field_id_to_device_node_data_index_
std::map< int, int >	block_id_to_element_data_index_
std::vector< std::vector< Data > >	host_element_data_
std::vector< std::vector< Data > >	device_element_data_
std::vector< std::map< int, int > >	field_id_to_host_element_data_index_
std::vector< std::map< int, int > >	field_id_to_device_element_data_index_
std::map< int, int >	block_id_to_integration_point_data_index_
std::vector< std::vector< Data > >	host_integration_point_data_step_n_
std::vector< std::vector< Data > >	host_integration_point_data_step_np1_
std::vector< std::vector< Data > >	device_integration_point_data_step_n_
std::vector< std::vector< Data > >	device_integration_point_data_step_np1_
std::vector< std::map< int, int > >	field_id_to_host_integration_point_data_index_
std::vector< std::map< int, int > >	field_id_to_device_integration_point_data_index_
std::unique_ptr< nimble_kokkos::ExodusOutputManager >	exodus_output_manager_
std::vector< nimble_kokkos::DeviceVectorNodeGatheredView >	gathered_reference_coordinate_d
std::vector< nimble_kokkos::DeviceVectorNodeGatheredView >	gathered_displacement_d
std::vector< nimble_kokkos::DeviceVectorNodeGatheredView >	gathered_internal_force_d
std::vector< nimble_kokkos::DeviceVectorNodeGatheredView >	gathered_contact_force_d
nimble_kokkos::HostVectorNodeView	displacement_h_
nimble_kokkos::DeviceVectorNodeView	displacement_d_
nimble_kokkos::HostVectorNodeView	velocity_h_
nimble_kokkos::DeviceVectorNodeView	velocity_d_
std::vector< nimble::BlockData >	block_data_
Protected Attributes inherited from nimble::ModelDataBase
int	dim_ = 3
	Problem dimension, either 2 or 3.
double	critical_time_step_ = 0.0
	Critical time step.
std::vector< std::string >	output_node_component_labels_
	Output labels for node data that will be written to disk.
std::map< int, std::vector< std::string > >	element_component_labels_
std::map< int, std::vector< std::string > >	output_element_component_labels_
	Output labels for element data that will be written to disk.
std::map< int, std::vector< std::string > >	derived_output_element_data_labels_
	Output labels for derived element data that will be written to disk.

Member Typedef Documentation

Data

using nimble_kokkos::ModelData::Data = std::unique_ptr<FieldBase>

protected

Constructor & Destructor Documentation

ModelData()

nimble_kokkos::ModelData::ModelData

(

)

: exodus_output_manager_(std::unique_ptr<ExodusOutputManager>(new ExodusOutputManager())) {}

~ModelData()

nimble_kokkos::ModelData::~ModelData ( )

override

{}

Member Function Documentation

AllocateElementData()

int nimble_kokkos::ModelData::AllocateElementData	(	int	block_id,
		nimble::Length	length,
		std::string	label,
		int	num_objects )

{
  int  field_id;
  auto it = field_label_to_field_id_map_.find(label);
  if (it == field_label_to_field_id_map_.end()) {
    field_id                            = field_label_to_field_id_map_.size();
    field_label_to_field_id_map_[label] = field_id;
  } else {
    field_id = it->second;
  }
 
  if (block_id_to_element_data_index_.find(block_id) == block_id_to_element_data_index_.end()) {
    block_id_to_element_data_index_[block_id] = host_element_data_.size();
    host_element_data_.emplace_back();
    device_element_data_.emplace_back();
    field_id_to_host_element_data_index_.emplace_back();
    field_id_to_device_element_data_index_.emplace_back();
  }
  int block_index = block_id_to_element_data_index_.at(block_id);
 
  if (length == nimble::SCALAR) {
    device_element_data_.at(block_index).emplace_back(new Field<FieldType::DeviceScalarElem>(label, num_objects));
  } else if (length == nimble::SYMMETRIC_TENSOR) {
    device_element_data_.at(block_index).emplace_back(new Field<FieldType::DeviceSymTensorElem>(label, num_objects));
  } else if (length == nimble::FULL_TENSOR) {
    device_element_data_.at(block_index).emplace_back(new Field<FieldType::DeviceFullTensorElem>(label, num_objects));
  } else {
    throw std::invalid_argument(
        "\nError:  Invalid device data length in "
        "nimble_kokkos::ModelData::AllocateElementData().\n");
  }
 
  field_id_to_device_element_data_index_.at(block_index)[field_id] = device_element_data_.at(block_index).size() - 1;
 
  FieldBase* d_field = device_element_data_.at(block_index).back().get();
 
  if (d_field->type() == FieldType::DeviceScalarElem) {
    auto                                     field  = dynamic_cast<Field<FieldType::DeviceScalarElem>*>(d_field);
    Field<FieldType::DeviceScalarElem>::View d_view = field->data();
    auto                                     h_view = Kokkos::create_mirror_view(d_view);
    host_element_data_.at(block_index).emplace_back(new Field<FieldType::HostScalarElem>(h_view));
  } else if (d_field->type() == FieldType::DeviceSymTensorElem) {
    auto                                        field  = dynamic_cast<Field<FieldType::DeviceSymTensorElem>*>(d_field);
    Field<FieldType::DeviceSymTensorElem>::View d_view = field->data();
    auto                                        h_view = Kokkos::create_mirror_view(d_view);
    host_element_data_.at(block_index).emplace_back(new Field<FieldType::HostSymTensorElem>(h_view));
  } else if (d_field->type() == FieldType::DeviceFullTensorElem) {
    auto                                         field = dynamic_cast<Field<FieldType::DeviceFullTensorElem>*>(d_field);
    Field<FieldType::DeviceFullTensorElem>::View d_view = field->data();
    auto                                         h_view = Kokkos::create_mirror_view(d_view);
    host_element_data_.at(block_index).emplace_back(new Field<FieldType::HostFullTensorElem>(h_view));
  } else {
    throw std::invalid_argument(
        "\nError:  Invalid host data length in "
        "nimble_kokkos::ModelData::AllocateElementData().\n");
  }
 
  field_id_to_host_element_data_index_.at(block_index)[field_id] = host_element_data_.at(block_index).size() - 1;
 
  return field_id;
}

AllocateIntegrationPointData()

int nimble_kokkos::ModelData::AllocateIntegrationPointData	(	int	block_id,
		nimble::Length	length,
		std::string	label,
		int	num_objects,
		std::vector< double >	initial_value = std::vector<double>() )

{
  bool set_initial_value = false;
  if (!initial_value.empty()) set_initial_value = true;
 
  int  field_id;
  auto it = field_label_to_field_id_map_.find(label);
  if (it == field_label_to_field_id_map_.end()) {
    field_id                            = field_label_to_field_id_map_.size();
    field_label_to_field_id_map_[label] = field_id;
  } else {
    field_id = it->second;
  }
 
  if (block_id_to_integration_point_data_index_.find(block_id) == block_id_to_integration_point_data_index_.end()) {
    block_id_to_integration_point_data_index_[block_id] = host_integration_point_data_step_n_.size();
    host_integration_point_data_step_n_.emplace_back();
    host_integration_point_data_step_np1_.emplace_back();
    device_integration_point_data_step_n_.emplace_back();
    device_integration_point_data_step_np1_.emplace_back();
    field_id_to_host_integration_point_data_index_.emplace_back();
    field_id_to_device_integration_point_data_index_.emplace_back();
  }
  int block_index = block_id_to_integration_point_data_index_.at(block_id);
 
  if (length == nimble::SCALAR) {
    device_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceScalarNode>(label, num_objects));
    device_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceScalarNode>(label, num_objects));
  } else if (length == nimble::VECTOR) {
    device_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceVectorNode>(label, num_objects));
    device_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceVectorNode>(label, num_objects));
  } else if (length == nimble::SYMMETRIC_TENSOR) {
    device_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceSymTensorIntPt>(label, num_objects));
    device_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceSymTensorIntPt>(label, num_objects));
  } else if (length == nimble::FULL_TENSOR) {
    device_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceFullTensorIntPt>(label, num_objects));
    device_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::DeviceFullTensorIntPt>(label, num_objects));
  } else {
    throw std::invalid_argument(
        "\nError:  Invalid device data length in "
        "nimble_kokkos::ModelData::AllocateIntegrationPointData().\n");
  }
 
  field_id_to_device_integration_point_data_index_.at(block_index)[field_id] =
      device_integration_point_data_step_n_.at(block_index).size() - 1;
 
  FieldBase* d_field_step_n   = device_integration_point_data_step_n_.at(block_index).back().get();
  FieldBase* d_field_step_np1 = device_integration_point_data_step_np1_.at(block_index).back().get();
 
  if (d_field_step_n->type() == FieldType::DeviceScalarNode) {
    auto field_step_n = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(d_field_step_n);
    Field<FieldType::DeviceScalarNode>::View d_view_step_n = field_step_n->data();
    auto                                     h_view_step_n = Kokkos::create_mirror_view(d_view_step_n);
    host_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::HostScalarNode>(h_view_step_n));
 
    auto field_step_np1 = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(d_field_step_np1);
    Field<FieldType::DeviceScalarNode>::View d_view_step_np1 = field_step_np1->data();
    auto                                     h_view_step_np1 = Kokkos::create_mirror_view(d_view_step_np1);
    host_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::HostScalarNode>(h_view_step_np1));
 
    if (set_initial_value) {
      int num_elem = h_view_step_n.extent(0);
      for (int i_elem = 0; i_elem < num_elem; ++i_elem) {
        h_view_step_n(i_elem)   = initial_value.at(0);
        h_view_step_np1(i_elem) = initial_value.at(0);
      }
      Kokkos::deep_copy(d_view_step_n, h_view_step_n);
      Kokkos::deep_copy(d_view_step_np1, h_view_step_np1);
    }
  } else if (d_field_step_n->type() == FieldType::DeviceVectorNode) {
    auto field_step_n = dynamic_cast<Field<FieldType::DeviceVectorNode>*>(d_field_step_n);
    Field<FieldType::DeviceVectorNode>::View d_view_step_n = field_step_n->data();
    auto                                     h_view_step_n = Kokkos::create_mirror_view(d_view_step_n);
    host_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::HostVectorNode>(h_view_step_n));
 
    auto field_step_np1 = dynamic_cast<Field<FieldType::DeviceVectorNode>*>(d_field_step_np1);
    Field<FieldType::DeviceVectorNode>::View d_view_step_np1 = field_step_np1->data();
    auto                                     h_view_step_np1 = Kokkos::create_mirror_view(d_view_step_np1);
    host_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::HostVectorNode>(h_view_step_np1));
 
    if (set_initial_value) {
      int num_elem    = h_view_step_n.extent(0);
      int num_entries = 3;
      for (int i_elem = 0; i_elem < num_elem; ++i_elem) {
        for (int i_entry = 0; i_entry < num_entries; ++i_entry) {
          h_view_step_n(i_elem, i_entry)   = initial_value.at(i_entry);
          h_view_step_np1(i_elem, i_entry) = initial_value.at(i_entry);
        }
      }
      Kokkos::deep_copy(d_view_step_n, h_view_step_n);
      Kokkos::deep_copy(d_view_step_np1, h_view_step_np1);
    }
  } else if (d_field_step_n->type() == FieldType::DeviceSymTensorIntPt) {
    auto field_step_n = dynamic_cast<Field<FieldType::DeviceSymTensorIntPt>*>(d_field_step_n);
    Field<FieldType::DeviceSymTensorIntPt>::View d_view_step_n = field_step_n->data();
    auto                                         h_view_step_n = Kokkos::create_mirror_view(d_view_step_n);
    host_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::HostSymTensorIntPt>(h_view_step_n));
 
    auto field_step_np1 = dynamic_cast<Field<FieldType::DeviceSymTensorIntPt>*>(d_field_step_np1);
    Field<FieldType::DeviceSymTensorIntPt>::View d_view_step_np1 = field_step_np1->data();
    auto                                         h_view_step_np1 = Kokkos::create_mirror_view(d_view_step_np1);
    host_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::HostSymTensorIntPt>(h_view_step_np1));
 
    if (set_initial_value) {
      int num_elem    = h_view_step_n.extent(0);
      int num_int_pt  = h_view_step_n.extent(1);
      int num_entries = 6;
      for (int i_elem = 0; i_elem < num_elem; ++i_elem) {
        for (int i_int_pt = 0; i_int_pt < num_int_pt; ++i_int_pt) {
          for (int i_entry = 0; i_entry < num_entries; ++i_entry) {
            h_view_step_n(i_elem, i_int_pt, i_entry)   = initial_value.at(i_entry);
            h_view_step_np1(i_elem, i_int_pt, i_entry) = initial_value.at(i_entry);
          }
        }
      }
      Kokkos::deep_copy(d_view_step_n, h_view_step_n);
      Kokkos::deep_copy(d_view_step_np1, h_view_step_np1);
    }
  } else if (d_field_step_n->type() == FieldType::DeviceFullTensorIntPt) {
    auto field_step_n = dynamic_cast<Field<FieldType::DeviceFullTensorIntPt>*>(d_field_step_n);
    Field<FieldType::DeviceFullTensorIntPt>::View d_view_step_n = field_step_n->data();
    auto                                          h_view_step_n = Kokkos::create_mirror_view(d_view_step_n);
    host_integration_point_data_step_n_.at(block_index)
        .emplace_back(new Field<FieldType::HostFullTensorIntPt>(h_view_step_n));
 
    auto field_step_np1 = dynamic_cast<Field<FieldType::DeviceFullTensorIntPt>*>(d_field_step_np1);
    Field<FieldType::DeviceFullTensorIntPt>::View d_view_step_np1 = field_step_np1->data();
    auto                                          h_view_step_np1 = Kokkos::create_mirror_view(d_view_step_np1);
    host_integration_point_data_step_np1_.at(block_index)
        .emplace_back(new Field<FieldType::HostFullTensorIntPt>(h_view_step_np1));
 
    if (set_initial_value) {
      int num_elem    = h_view_step_n.extent(0);
      int num_int_pt  = h_view_step_n.extent(1);
      int num_entries = 9;
      for (int i_elem = 0; i_elem < num_elem; ++i_elem) {
        for (int i_int_pt = 0; i_int_pt < num_int_pt; ++i_int_pt) {
          for (int i_entry = 0; i_entry < num_entries; ++i_entry) {
            h_view_step_n(i_elem, i_int_pt, i_entry)   = initial_value.at(i_entry);
            h_view_step_np1(i_elem, i_int_pt, i_entry) = initial_value.at(i_entry);
          }
        }
      }
      Kokkos::deep_copy(d_view_step_n, h_view_step_n);
      Kokkos::deep_copy(d_view_step_np1, h_view_step_np1);
    }
  } else {
    throw std::invalid_argument(
        "\nError:  Invalid host data length in "
        "nimble_kokkos::ModelData::AllocateElementData().\n");
  }
 
  field_id_to_host_integration_point_data_index_.at(block_index)[field_id] =
      host_integration_point_data_step_n_.at(block_index).size() - 1;
 
  return field_id;
}

AllocateNodeData()

int nimble_kokkos::ModelData::AllocateNodeData ( nimble::Length length, std::string label, int num_objects )

overridevirtual

Allocate data storage for a node-based quantity.

Parameters

length
label
num_objects

Returns

Field ID for the data allocated

Implements nimble::ModelDataBase.

{
  int  field_id;
  auto it = field_label_to_field_id_map_.find(label);
  if (it == field_label_to_field_id_map_.end()) {
    field_id                            = field_label_to_field_id_map_.size();
    field_label_to_field_id_map_[label] = field_id;
  } else {
    field_id = it->second;
  }
 
  if (length == nimble::SCALAR) {
    // device_node_data_ is of type std::vector< std::unique_ptr< FieldBase > >
    device_node_data_.emplace_back(new Field<FieldType::DeviceScalarNode>(label, num_objects));
  } else if (length == nimble::VECTOR) {
    device_node_data_.emplace_back(new Field<FieldType::DeviceVectorNode>(label, num_objects));
  } else {
    throw std::invalid_argument(
        "\nError:  Invalid device data length in "
        "nimble_kokkos::ModelData::AllocateNodeData().\n");
  }
 
  field_id_to_device_node_data_index_[field_id] = device_node_data_.size() - 1;
 
  FieldBase* d_field = device_node_data_.back().get();
 
  if (d_field->type() == FieldType::DeviceScalarNode) {
    auto                                     field  = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(d_field);
    Field<FieldType::DeviceScalarNode>::View d_view = field->data();
    auto                                     h_view = Kokkos::create_mirror_view(d_view);
    host_node_data_.emplace_back(new Field<FieldType::HostScalarNode>(h_view));
  } else if (d_field->type() == FieldType::DeviceVectorNode) {
    auto                                     field  = dynamic_cast<Field<FieldType::DeviceVectorNode>*>(d_field);
    Field<FieldType::DeviceVectorNode>::View d_view = field->data();
    auto                                     h_view = Kokkos::create_mirror_view(d_view);
    host_node_data_.emplace_back(new Field<FieldType::HostVectorNode>(h_view));
  } else {
    throw std::invalid_argument(
        "\nError:  Invalid host data length in "
        "nimble_kokkos::ModelData::AllocateNodeData().\n");
  }
 
  field_id_to_host_node_data_index_[field_id] = host_node_data_.size() - 1;
 
  return field_id;
}

ComputeInternalForce()

void nimble_kokkos::ModelData::ComputeInternalForce ( nimble::DataManager & data_manager, double time_previous, double time_current, bool is_output_step, const nimble::Viewify< 2 > & displacement, nimble::Viewify< 2 > & force )

overridevirtual

Compute the internal force.

Parameters

[in]	data_manager
[in]	time_previous
[in]	time_current
[in]	is_output_step
[in]	displacement
[out]	internal_force	Output for internal force

Reimplemented from nimble::ModelDataBase.

{
  //
  // This version does not use the Viewify objects displacement and force
  // It may need to be updated for quasi-static simulations
  //
 
  const auto& mesh      = data_manager.GetMesh();
  const auto& field_ids = data_manager.GetFieldIDs();
 
  auto block_material_interface_factory = data_manager.GetBlockMaterialInterfaceFactory();
 
  nimble_kokkos::DeviceVectorNodeView internal_force_h = GetHostVectorNodeData(field_ids.internal_force);
  nimble_kokkos::DeviceVectorNodeView internal_force_d = GetDeviceVectorNodeData(field_ids.internal_force);
  Kokkos::deep_copy(internal_force_d, (double)(0.0));
 
  // Compute element-level kinematics
  constexpr int mpi_vector_dim = 3;
 
  int block_index = 0;
  for (auto& block_it : blocks_) {
    //
    const int block_id           = block_it.first;
    const int num_elem_in_block  = mesh.GetNumElementsInBlock(block_id);
    const int num_nodes_per_elem = mesh.GetNumNodesPerElement(block_id);
 
    nimble_kokkos::Block& block     = block_it.second;
    nimble::Element*      element_d = block.GetDeviceElement();
 
    auto elem_conn_d                           = block.GetDeviceElementConnectivityView();
    auto gathered_reference_coordinate_block_d = gathered_reference_coordinate_d.at(block_index);
    auto gathered_displacement_block_d         = gathered_displacement_d.at(block_index);
    auto gathered_internal_force_block_d       = gathered_internal_force_d.at(block_index);
 
    GatherVectorNodeData(
        field_ids.reference_coordinates,
        num_elem_in_block,
        num_nodes_per_elem,
        elem_conn_d,
        gathered_reference_coordinate_block_d);
 
    GatherVectorNodeData(
        field_ids.displacement, num_elem_in_block, num_nodes_per_elem, elem_conn_d, gathered_displacement_block_d);
 
    auto deformation_gradient_step_np1_d =
        GetDeviceFullTensorIntegrationPointData(block_id, field_ids.deformation_gradient, nimble::STEP_NP1);
 
    //
    // COMPUTE DEFORMATION GRADIENTS
    //
    Kokkos::parallel_for(
        "Deformation Gradient", num_elem_in_block, KOKKOS_LAMBDA(const int i_elem) {
          nimble_kokkos::DeviceVectorNodeGatheredSubView element_reference_coordinate_d =
              Kokkos::subview(gathered_reference_coordinate_block_d, i_elem, Kokkos::ALL(), Kokkos::ALL());
          nimble_kokkos::DeviceVectorNodeGatheredSubView element_displacement_d =
              Kokkos::subview(gathered_displacement_block_d, i_elem, Kokkos::ALL(), Kokkos::ALL());
          nimble_kokkos::DeviceFullTensorIntPtSubView element_deformation_gradient_step_np1_d =
              Kokkos::subview(deformation_gradient_step_np1_d, i_elem, Kokkos::ALL(), Kokkos::ALL());
          element_d->ComputeDeformationGradients(
              element_reference_coordinate_d, element_displacement_d, element_deformation_gradient_step_np1_d);
        });
 
    //
    // Insert the update for the state variables
    //
 
    block_index += 1;
  }
 
  if (block_material_interface_factory) {
    auto block_material_interface =
        block_material_interface_factory->create(time_previous, time_current, field_ids, block_data_, this);
    block_material_interface->ComputeStress();
  }
 
  //
  // Stress divergence
  //
  block_index = 0;
  for (auto& block_it : blocks_) {
    const int block_id           = block_it.first;
    const int num_elem_in_block  = mesh.GetNumElementsInBlock(block_id);
    const int num_nodes_per_elem = mesh.GetNumNodesPerElement(block_id);
 
    nimble_kokkos::Block& block     = block_it.second;
    nimble::Element*      element_d = block.GetDeviceElement();
 
    nimble_kokkos::DeviceElementConnectivityView elem_conn_d = block.GetDeviceElementConnectivityView();
    nimble_kokkos::DeviceVectorNodeGatheredView  gathered_reference_coordinate_block_d =
        gathered_reference_coordinate_d.at(block_index);
    nimble_kokkos::DeviceVectorNodeGatheredView gathered_displacement_block_d = gathered_displacement_d.at(block_index);
    nimble_kokkos::DeviceVectorNodeGatheredView gathered_internal_force_block_d =
        gathered_internal_force_d.at(block_index);
 
    nimble_kokkos::DeviceSymTensorIntPtView stress_step_np1_d =
        GetDeviceSymTensorIntegrationPointData(block_id, field_ids.stress, nimble::STEP_NP1);
 
    // COMPUTE NODAL FORCES
    Kokkos::parallel_for(
        "Force", num_elem_in_block, KOKKOS_LAMBDA(const int i_elem) {
          nimble_kokkos::DeviceVectorNodeGatheredSubView element_reference_coordinate_d =
              Kokkos::subview(gathered_reference_coordinate_block_d, i_elem, Kokkos::ALL, Kokkos::ALL);
          nimble_kokkos::DeviceVectorNodeGatheredSubView element_displacement_d =
              Kokkos::subview(gathered_displacement_block_d, i_elem, Kokkos::ALL, Kokkos::ALL);
          nimble_kokkos::DeviceSymTensorIntPtSubView element_stress_step_np1_d =
              Kokkos::subview(stress_step_np1_d, i_elem, Kokkos::ALL, Kokkos::ALL);
          nimble_kokkos::DeviceVectorNodeGatheredSubView element_internal_force_d =
              Kokkos::subview(gathered_internal_force_block_d, i_elem, Kokkos::ALL, Kokkos::ALL);
          element_d->ComputeNodalForces(
              element_reference_coordinate_d,
              element_displacement_d,
              element_stress_step_np1_d,
              element_internal_force_d);
        });
 
    ScatterVectorNodeData(
        field_ids.internal_force, num_elem_in_block, num_nodes_per_elem, elem_conn_d, gathered_internal_force_block_d);
 
    block_index += 1;
  }  // loop over blocks
 
  Kokkos::deep_copy(internal_force_h, internal_force_d);
 
  auto myVectorCommunicator = data_manager.GetVectorCommunicator();
  myVectorCommunicator->VectorReduction(mpi_vector_dim, internal_force_h);
}

ComputeLumpedMass()

void nimble_kokkos::ModelData::ComputeLumpedMass ( nimble::DataManager & data_manager )

overridevirtual

Compute the lumped mass.

Parameters

data_manager

Reference to the data manager

Implements nimble::ModelDataBase.

{
  const auto& mesh_               = data_manager.GetMesh();
  const auto& parser_             = data_manager.GetParser();
  auto&       field_ids_          = data_manager.GetFieldIDs();
  auto        vector_communicator = data_manager.GetVectorCommunicator();
 
  int num_nodes  = static_cast<int>(mesh_.GetNumNodes());
  int num_blocks = static_cast<int>(mesh_.GetNumBlocks());
 
  std::vector<nimble_kokkos::DeviceScalarNodeGatheredView> gathered_lumped_mass_d(
      num_blocks, nimble_kokkos::DeviceScalarNodeGatheredView("gathered_lumped_mass", 1));
  int block_index = 0;
  for (const auto& block_it : blocks_) {
    int block_id          = block_it.first;
    int num_elem_in_block = mesh_.GetNumElementsInBlock(block_id);
    Kokkos::resize(gathered_lumped_mass_d.at(block_index), num_elem_in_block);
    block_index += 1;
  }
 
  auto lumped_mass_h = GetHostScalarNodeData(field_ids_.lumped_mass);
  Kokkos::deep_copy(lumped_mass_h, (double)(0.0));
 
  auto lumped_mass_d = GetDeviceScalarNodeData(field_ids_.lumped_mass);
  Kokkos::deep_copy(lumped_mass_d, (double)(0.0));
 
  auto reference_coordinate = GetVectorNodeData("reference_coordinate");
  auto displacement         = GetVectorNodeData("displacement");
 
  critical_time_step_ = std::numeric_limits<double>::max();
 
  block_index = 0;
  for (auto& block_it : blocks_) {
    int                   block_id           = block_it.first;
    nimble_kokkos::Block& block              = block_it.second;
    nimble::Element*      element_d          = block.GetDeviceElement();
    double                density            = block.GetDensity();
    int                   num_elem_in_block  = mesh_.GetNumElementsInBlock(block_id);
    int                   num_nodes_per_elem = mesh_.GetNumNodesPerElement(block_id);
    int                   elem_conn_length   = num_elem_in_block * num_nodes_per_elem;
    int const*            elem_conn          = mesh_.GetConnectivity(block_id);
 
    nimble_kokkos::HostElementConnectivityView elem_conn_h("element_connectivity_h", elem_conn_length);
    for (int i = 0; i < elem_conn_length; i++) { elem_conn_h(i) = elem_conn[i]; }
    auto&& elem_conn_d = block.GetDeviceElementConnectivityView();
    Kokkos::resize(elem_conn_d, elem_conn_length);
    Kokkos::deep_copy(elem_conn_d, elem_conn_h);
 
    auto gathered_reference_coordinate_block_d = gathered_reference_coordinate_d.at(block_index);
    auto gathered_lumped_mass_block_d          = gathered_lumped_mass_d.at(block_index);
 
    GatherVectorNodeData(
        field_ids_.reference_coordinates,
        num_elem_in_block,
        num_nodes_per_elem,
        elem_conn_d,
        gathered_reference_coordinate_block_d);
 
    // COMPUTE LUMPED MASS
    Kokkos::parallel_for(
        "Lumped Mass", num_elem_in_block, KOKKOS_LAMBDA(const int i_elem) {
          auto element_reference_coordinate_d =
              Kokkos::subview(gathered_reference_coordinate_block_d, i_elem, Kokkos::ALL, Kokkos::ALL);
          auto element_lumped_mass_d = Kokkos::subview(gathered_lumped_mass_block_d, i_elem, Kokkos::ALL);
          element_d->ComputeLumpedMass(density, element_reference_coordinate_d, element_lumped_mass_d);
        });
 
    // SCATTER TO NODE DATA
    ScatterScalarNodeData(
        field_ids_.lumped_mass, num_elem_in_block, num_nodes_per_elem, elem_conn_d, gathered_lumped_mass_block_d);
 
    double block_critical_time_step =
        block.ComputeCriticalTimeStep(reference_coordinate, displacement, num_elem_in_block, elem_conn);
    if (block_critical_time_step < critical_time_step_) { critical_time_step_ = block_critical_time_step; }
 
    block_index += 1;
  }
  Kokkos::deep_copy(lumped_mass_h, lumped_mass_d);
 
  // MPI vector reduction on lumped mass
  std::vector<double> mpi_scalar_buffer(num_nodes);
  for (unsigned int i = 0; i < num_nodes; i++) { mpi_scalar_buffer[i] = lumped_mass_h(i); }
  vector_communicator->VectorReduction(1, mpi_scalar_buffer.data());
  for (int i = 0; i < num_nodes; i++) { lumped_mass_h(i) = mpi_scalar_buffer[i]; }
}

GatherScalarNodeData()

DeviceScalarNodeGatheredView nimble_kokkos::ModelData::GatherScalarNodeData	(	int	field_id,
		int	num_elements,
		int	num_nodes_per_element,
		const DeviceElementConnectivityView &	elem_conn_d,
		DeviceScalarNodeGatheredView	gathered_view_d )

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(base_field_ptr);
  auto       data              = derived_field_ptr->data();
  Kokkos::parallel_for(
      "GatherScalarNodeData", num_elements, KOKKOS_LAMBDA(const int i_elem) {
        for (int i_node = 0; i_node < num_nodes_per_element; i_node++) {
          gathered_view_d(i_elem, i_node) = data(elem_conn_d(num_nodes_per_element * i_elem + i_node));
        }
      });
  return gathered_view_d;
}

GatherVectorNodeData()

DeviceVectorNodeGatheredView nimble_kokkos::ModelData::GatherVectorNodeData	(	int	field_id,
		int	num_elements,
		int	num_nodes_per_element,
		const DeviceElementConnectivityView &	elem_conn_d,
		DeviceVectorNodeGatheredView	gathered_view_d )

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceVectorNode>*>(base_field_ptr);
  auto       data              = derived_field_ptr->data();
  Kokkos::parallel_for(
      "GatherVectorNodeData", num_elements, KOKKOS_LAMBDA(const int i_elem) {
        for (int i_node = 0; i_node < num_nodes_per_element; i_node++) {
          int node_index = elem_conn_d(num_nodes_per_element * i_elem + i_node);
          for (int i_coord = 0; i_coord < 3; i_coord++) {
            gathered_view_d(i_elem, i_node, i_coord) = data(node_index, i_coord);
          }
        }
      });
  return gathered_view_d;
}

GetBlockIds()

std::vector< int > nimble_kokkos::ModelData::GetBlockIds

(

)

const

{
  std::vector<int> block_ids;
  for (auto const& entry : block_id_to_integration_point_data_index_) { block_ids.push_back(entry.first); }
  return block_ids;
}

GetDeviceElementData()

template<FieldType ft>

Field< ft >::View nimble_kokkos::ModelData::GetDeviceElementData ( int block_id, int field_id )

protected

{
  int  block_index       = block_id_to_element_data_index_.at(block_id);
  int  data_index        = field_id_to_device_element_data_index_.at(block_index).at(field_id);
  auto base_field_ptr    = device_element_data_.at(block_index).at(data_index).get();
  auto derived_field_ptr = dynamic_cast<Field<ft>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetDeviceFullTensorElementData()

DeviceFullTensorElemView nimble_kokkos::ModelData::GetDeviceFullTensorElementData	(	int	block_id,
		int	field_id )

{
  return GetDeviceElementData<FieldType::DeviceFullTensorElem>(block_id, field_id);
}

GetDeviceFullTensorIntegrationPointData()

DeviceFullTensorIntPtView nimble_kokkos::ModelData::GetDeviceFullTensorIntegrationPointData	(	int	block_id,
		int	field_id,
		nimble::Step	step )

{
  return GetDeviceIntPointData<FieldType::DeviceFullTensorIntPt>(block_id, field_id, step);
}

GetDeviceIntPointData()

template<FieldType ft>

Field< ft >::View nimble_kokkos::ModelData::GetDeviceIntPointData ( int block_id, int field_id, nimble::Step step )

protected

{
  int        block_index    = block_id_to_integration_point_data_index_.at(block_id);
  int        data_index     = field_id_to_device_integration_point_data_index_.at(block_index).at(field_id);
  FieldBase* base_field_ptr = nullptr;
  if (step == nimble::STEP_N) {
    base_field_ptr = device_integration_point_data_step_n_.at(block_index).at(data_index).get();
  } else if (step == nimble::STEP_NP1) {
    base_field_ptr = device_integration_point_data_step_np1_.at(block_index).at(data_index).get();
  }
  auto derived_field_ptr = dynamic_cast<Field<ft>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetDeviceScalarElementData()

DeviceScalarElemView nimble_kokkos::ModelData::GetDeviceScalarElementData	(	int	block_id,
		int	field_id )

{
  return GetDeviceElementData<FieldType::DeviceScalarElem>(block_id, field_id);
}

GetDeviceScalarIntegrationPointData()

DeviceScalarIntPtView nimble_kokkos::ModelData::GetDeviceScalarIntegrationPointData	(	int	block_id,
		int	field_id,
		nimble::Step	step )

{
  return GetDeviceIntPointData<FieldType::DeviceScalarIntPt>(block_id, field_id, step);
}

GetDeviceScalarNodeData()

DeviceScalarNodeView nimble_kokkos::ModelData::GetDeviceScalarNodeData

(

int

field_id

)

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetDeviceSymTensorElementData()

DeviceSymTensorElemView nimble_kokkos::ModelData::GetDeviceSymTensorElementData	(	int	block_id,
		int	field_id )

{
  return GetDeviceElementData<FieldType::DeviceSymTensorElem>(block_id, field_id);
}

GetDeviceSymTensorIntegrationPointData()

DeviceSymTensorIntPtView nimble_kokkos::ModelData::GetDeviceSymTensorIntegrationPointData	(	int	block_id,
		int	field_id,
		nimble::Step	step )

{
  return GetDeviceIntPointData<FieldType::DeviceSymTensorIntPt>(block_id, field_id, step);
}

GetDeviceVectorIntegrationPointData()

DeviceVectorIntPtView nimble_kokkos::ModelData::GetDeviceVectorIntegrationPointData	(	int	block_id,
		int	field_id,
		nimble::Step	step )

{
  return GetDeviceIntPointData<FieldType::DeviceVectorIntPt>(block_id, field_id, step);
}

GetDeviceVectorNodeData()

DeviceVectorNodeView nimble_kokkos::ModelData::GetDeviceVectorNodeData

(

int

field_id

)

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceVectorNode>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetFieldId()

int nimble_kokkos::ModelData::GetFieldId ( const std::string & field_label ) const

inlineoverridevirtual

Returns the field ID for a specific label.

Parameters

field_label

Label for a stored quantity

Returns

Field ID to identify the data storage

Implements nimble::ModelDataBase.

  {
    return field_label_to_field_id_map_.at(field_label);
  }

GetFullTensorIntegrationPointDataLabels()

std::vector< std::string > nimble_kokkos::ModelData::GetFullTensorIntegrationPointDataLabels

(

int

block_id

)

const

{
  int                      block_index = block_id_to_integration_point_data_index_.at(block_id);
  std::vector<std::string> ipt_data_labels;
  for (auto const& entry : field_label_to_field_id_map_) {
    std::string const& field_label = entry.first;
    int                field_id    = entry.second;
    for (auto const& ipt_entry : field_id_to_device_integration_point_data_index_.at(block_index)) {
      int ipt_data_field_id = ipt_entry.first;
      if (field_id == ipt_data_field_id) {
        int ipt_data_index = ipt_entry.second;
        if (device_integration_point_data_step_np1_.at(block_index).at(ipt_data_index)->type() ==
            FieldType::DeviceFullTensorIntPt) {
          if (std::find(ipt_data_labels.begin(), ipt_data_labels.end(), field_label) == ipt_data_labels.end()) {
            ipt_data_labels.push_back(field_label);
          }
        }
      }
    }
  }
  return ipt_data_labels;
}

GetHostFullTensorElementData()

HostFullTensorElemView nimble_kokkos::ModelData::GetHostFullTensorElementData	(	int	block_id,
		int	field_id )

{
  int        block_index    = block_id_to_element_data_index_.at(block_id);
  int        data_index     = field_id_to_host_element_data_index_.at(block_index).at(field_id);
  FieldBase* base_field_ptr = nullptr;
  base_field_ptr            = host_element_data_.at(block_index).at(data_index).get();
  auto derived_field_ptr    = dynamic_cast<Field<FieldType::HostFullTensorElem>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetHostFullTensorIntegrationPointData()

HostFullTensorIntPtView nimble_kokkos::ModelData::GetHostFullTensorIntegrationPointData	(	int	block_id,
		int	field_id,
		nimble::Step	step )

{
  int        block_index    = block_id_to_integration_point_data_index_.at(block_id);
  int        data_index     = field_id_to_host_integration_point_data_index_.at(block_index).at(field_id);
  FieldBase* base_field_ptr = nullptr;
  if (step == nimble::STEP_N) {
    base_field_ptr = host_integration_point_data_step_n_.at(block_index).at(data_index).get();
  } else if (step == nimble::STEP_NP1) {
    base_field_ptr = host_integration_point_data_step_np1_.at(block_index).at(data_index).get();
  }
  auto derived_field_ptr = dynamic_cast<Field<FieldType::HostFullTensorIntPt>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetHostScalarElementData()

HostScalarElemView nimble_kokkos::ModelData::GetHostScalarElementData	(	int	block_id,
		int	field_id )

{
  int        block_index    = block_id_to_element_data_index_.at(block_id);
  int        data_index     = field_id_to_host_element_data_index_.at(block_index).at(field_id);
  FieldBase* base_field_ptr = nullptr;
  base_field_ptr            = host_element_data_.at(block_index).at(data_index).get();
  auto derived_field_ptr    = dynamic_cast<Field<FieldType::HostScalarElem>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetHostScalarNodeData()

HostScalarNodeView nimble_kokkos::ModelData::GetHostScalarNodeData

(

int

field_id

)

{
  int        index             = field_id_to_host_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = host_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::HostScalarNode>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetHostSymTensorElementData()

HostSymTensorElemView nimble_kokkos::ModelData::GetHostSymTensorElementData	(	int	block_id,
		int	field_id )

{
  int        block_index    = block_id_to_element_data_index_.at(block_id);
  int        data_index     = field_id_to_host_element_data_index_.at(block_index).at(field_id);
  FieldBase* base_field_ptr = nullptr;
  base_field_ptr            = host_element_data_.at(block_index).at(data_index).get();
  auto derived_field_ptr    = dynamic_cast<Field<FieldType::HostSymTensorElem>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetHostSymTensorIntegrationPointData()

HostSymTensorIntPtView nimble_kokkos::ModelData::GetHostSymTensorIntegrationPointData	(	int	block_id,
		int	field_id,
		nimble::Step	step )

{
  int        block_index    = block_id_to_integration_point_data_index_.at(block_id);
  int        data_index     = field_id_to_host_integration_point_data_index_.at(block_index).at(field_id);
  FieldBase* base_field_ptr = nullptr;
  if (step == nimble::STEP_N) {
    base_field_ptr = host_integration_point_data_step_n_.at(block_index).at(data_index).get();
  } else if (step == nimble::STEP_NP1) {
    base_field_ptr = host_integration_point_data_step_np1_.at(block_index).at(data_index).get();
  }
  auto derived_field_ptr = dynamic_cast<Field<FieldType::HostSymTensorIntPt>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetHostVectorNodeData()

HostVectorNodeView nimble_kokkos::ModelData::GetHostVectorNodeData

(

int

field_id

)

{
  int        index             = field_id_to_host_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = host_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::HostVectorNode>*>(base_field_ptr);
  return derived_field_ptr->data();
}

GetScalarNodeData()

nimble::Viewify< 1 > nimble_kokkos::ModelData::GetScalarNodeData ( int field_id )

overridevirtual

Get view of scalar quantity defined on nodes.

Parameters

field_id

the field id (see DataManager::GetFieldIDs())

Returns

Viewify<1> object for scalar quantity

Implements nimble::ModelDataBase.

{
  auto field_view   = GetHostScalarNodeData(field_id);
  auto field_size   = static_cast<int>(field_view.extent(0));
  auto field_stride = static_cast<int>(field_view.stride_0());
  return {field_view.data(), {field_size}, {field_stride}};
}

GetScalarNodeDataLabels()

std::vector< std::string > nimble_kokkos::ModelData::GetScalarNodeDataLabels

(

)

const

{
  std::vector<std::string> node_data_labels;
  for (auto const& entry : field_label_to_field_id_map_) {
    std::string const& field_label = entry.first;
    int                field_id    = entry.second;
    for (auto const& node_entry : field_id_to_host_node_data_index_) {
      int node_data_field_id = node_entry.first;
      if (field_id == node_data_field_id) {
        int node_data_index = node_entry.second;
        if (host_node_data_.at(node_data_index)->type() == FieldType::HostScalarNode)
          node_data_labels.push_back(field_label);
      }
    }
  }
  return node_data_labels;
}

GetSymmetricTensorIntegrationPointDataLabels()

std::vector< std::string > nimble_kokkos::ModelData::GetSymmetricTensorIntegrationPointDataLabels

(

int

block_id

)

const

{
  int                      block_index = block_id_to_integration_point_data_index_.at(block_id);
  int                      num_blocks  = static_cast<int>(block_id_to_integration_point_data_index_.size());
  std::vector<std::string> ipt_data_labels;
  for (auto const& entry : field_label_to_field_id_map_) {
    std::string const& field_label = entry.first;
    int                field_id    = entry.second;
    for (auto const& ipt_entry : field_id_to_device_integration_point_data_index_.at(block_index)) {
      int ipt_data_field_id = ipt_entry.first;
      if (field_id == ipt_data_field_id) {
        int ipt_data_index = ipt_entry.second;
        if (device_integration_point_data_step_np1_.at(block_index).at(ipt_data_index)->type() ==
            FieldType::DeviceSymTensorIntPt) {
          if (std::find(ipt_data_labels.begin(), ipt_data_labels.end(), field_label) == ipt_data_labels.end()) {
            ipt_data_labels.push_back(field_label);
          }
        }
      }
    }
  }
  return ipt_data_labels;
}

GetVectorNodeData()

nimble::Viewify< 2 > nimble_kokkos::ModelData::GetVectorNodeData ( int field_id )

overridevirtual

Get view of vector quantity defined on nodes.

Parameters

field_id

the field id (see DataManager::GetFieldIDs())

Returns

Viewify<2> object for vector quantity

Implements nimble::ModelDataBase.

{
  auto field_view = GetHostVectorNodeData(field_id);
  auto size0      = static_cast<int>(field_view.extent(0));
  auto size1      = static_cast<int>(field_view.extent(1));
  auto stride0    = static_cast<int>(field_view.stride_0());
  auto stride1    = static_cast<int>(field_view.stride_1());
  return {field_view.data(), {size0, size1}, {stride0, stride1}};
}

GetVectorNodeDataLabels()

std::vector< std::string > nimble_kokkos::ModelData::GetVectorNodeDataLabels

(

)

const

{
  std::vector<std::string> node_data_labels;
  for (auto const& entry : field_label_to_field_id_map_) {
    std::string const& field_label = entry.first;
    int                field_id    = entry.second;
    for (auto const& node_entry : field_id_to_host_node_data_index_) {
      int node_data_field_id = node_entry.first;
      if (field_id == node_data_field_id) {
        int node_data_index = node_entry.second;
        if (host_node_data_.at(node_data_index)->type() == FieldType::HostVectorNode)
          node_data_labels.push_back(field_label);
      }
    }
  }
  return node_data_labels;
}

InitializeBlockData()

void nimble_kokkos::ModelData::InitializeBlockData ( nimble::DataManager & data_manager )

protected

Initialize block data for material information.

Parameters

data_manager

{
  //
  // Build up block data for stress computation
  //
  const auto& mesh = data_manager.GetMesh();
  for (auto&& block_it : blocks_) {
    int                   block_id                           = block_it.first;
    nimble_kokkos::Block& block                              = block_it.second;
    nimble::Material*     material_d                         = block.GetDeviceMaterialModel();
    int                   num_elem_in_block                  = mesh.GetNumElementsInBlock(block_id);
    int                   num_integration_points_per_element = block.GetHostElement()->NumIntegrationPointsPerElement();
    block_data_.emplace_back(&block, material_d, block_id, num_elem_in_block, num_integration_points_per_element);
  }
}

InitializeBlocks()

void nimble_kokkos::ModelData::InitializeBlocks ( nimble::DataManager & data_manager, const std::shared_ptr< nimble::MaterialFactoryBase > & material_factory_base )

override

Initialize the different blocks in the mesh.

Parameters

data_manager	Reference to the data manager
material_factory_base	Shared pointer to the material factory

{
  bool store_unrotated_stress(true);
 
  const auto& mesh_      = data_manager.GetMesh();
  const auto& parser_    = data_manager.GetParser();
  auto&       field_ids_ = data_manager.GetFieldIDs();
 
  auto       material_factory_ptr = dynamic_cast<nimble_kokkos::MaterialFactory*>(material_factory_base.get());
  const auto num_blocks           = static_cast<int>(mesh_.GetNumBlocks());
 
  //
  // Blocks
  //
  std::vector<int> block_ids = mesh_.GetBlockIds();
  for (int i = 0; i < num_blocks; i++) {
    int                block_id                  = block_ids.at(i);
    std::string const& model_material_parameters = parser_.GetModelMaterialParameters(block_id);
    int                num_elements_in_block     = mesh_.GetNumElementsInBlock(block_id);
    blocks_[block_id]                            = nimble_kokkos::Block();
    blocks_.at(block_id).Initialize(model_material_parameters, num_elements_in_block, *material_factory_ptr);
    //
    // MPI version use model_data.DeclareElementData(block_id,
    // data_labels_and_lengths);
    //
    std::vector<double> initial_value(9, 0.0);
    initial_value[0] = initial_value[1] = initial_value[2] = 1.0;
    field_ids_.deformation_gradient                        = AllocateIntegrationPointData(
        block_id, nimble::FULL_TENSOR, "deformation_gradient", num_elements_in_block, initial_value);
    // volume-averaged quantities for I/O are stored as element data
    AllocateElementData(block_id, nimble::FULL_TENSOR, "deformation_gradient", num_elements_in_block);
 
    field_ids_.stress =
        AllocateIntegrationPointData(block_id, nimble::SYMMETRIC_TENSOR, "stress", num_elements_in_block);
    if (store_unrotated_stress) {
      field_ids_.unrotated_stress =
          AllocateIntegrationPointData(block_id, nimble::SYMMETRIC_TENSOR, "stress", num_elements_in_block);
    }
 
    // volume-averaged quantities for I/O are stored as element data
    AllocateElementData(block_id, nimble::SYMMETRIC_TENSOR, "stress", num_elements_in_block);
 
    if (parser_.GetOutputFieldString().find("volume") != std::string::npos) {
      AllocateElementData(block_id, nimble::SCALAR, "volume", num_elements_in_block);
    }
 
    if (blocks_.at(block_id).GetMaterialPointer()->NumStateVariables() > 0) {
      //
      // Verify which state variables are actually needed
      //
      field_ids_.state_sym_tensor =
          AllocateIntegrationPointData(block_id, nimble::SYMMETRIC_TENSOR, "state_sym_tensor", num_elements_in_block);
      field_ids_.state_full_tensor =
          AllocateIntegrationPointData(block_id, nimble::FULL_TENSOR, "state_full_tensor", num_elements_in_block);
      field_ids_.state_scalar =
          AllocateIntegrationPointData(block_id, nimble::SCALAR, "state_scalar", num_elements_in_block);
      field_ids_.state_vec3D =
          AllocateIntegrationPointData(block_id, nimble::VECTOR, "state_vec3D", num_elements_in_block);
    }
  }
 
  // Initialize gathered containers when using explicit scheme
  if (parser_.TimeIntegrationScheme() == "explicit") InitializeGatheredVectors(mesh_);
 
  InitializeBlockData(data_manager);
}

InitializeExodusOutput()

void nimble_kokkos::ModelData::InitializeExodusOutput ( nimble::DataManager & data_manager )

overridevirtual

Reimplemented from nimble::ModelDataBase.

{
  const auto& mesh_   = data_manager.GetMesh();
  const auto& parser_ = data_manager.GetParser();
 
  // Initialize the exodus-output-manager
  exodus_output_manager_->SpecifyOutputFields(*this, parser_.GetOutputFieldString());
 
  output_node_component_labels_    = std::move(exodus_output_manager_->GetNodeDataLabelsForOutput());
  output_element_component_labels_ = std::move(exodus_output_manager_->GetElementDataLabelsForOutput());
 
  derived_output_element_data_labels_.clear();
  std::vector<int> block_ids = mesh_.GetBlockIds();
  for (auto block_id : block_ids) {
    derived_output_element_data_labels_[block_id] = std::vector<std::string>();  // TODO eliminate this
  }
 
  auto& field_ids = data_manager.GetFieldIDs();
  displacement_h_ = GetHostVectorNodeData(field_ids.displacement);
  displacement_d_ = GetDeviceVectorNodeData(field_ids.displacement);
 
  velocity_h_ = GetHostVectorNodeData(field_ids.velocity);
  velocity_d_ = GetDeviceVectorNodeData(field_ids.velocity);
}

InitializeGatheredVectors()

void nimble_kokkos::ModelData::InitializeGatheredVectors ( const nimble::GenesisMesh & mesh_ )

protected

{
  int num_blocks = static_cast<int>(mesh_.GetNumBlocks());
 
  gathered_reference_coordinate_d.resize(
      num_blocks, nimble_kokkos::DeviceVectorNodeGatheredView("gathered_reference_coordinates", 1));
  gathered_displacement_d.resize(num_blocks, nimble_kokkos::DeviceVectorNodeGatheredView("gathered_displacement", 1));
  gathered_internal_force_d.resize(
      num_blocks, nimble_kokkos::DeviceVectorNodeGatheredView("gathered_internal_force", 1));
  gathered_contact_force_d.resize(num_blocks, nimble_kokkos::DeviceVectorNodeGatheredView("gathered_contact_force", 1));
 
  int block_index = 0;
  for (const auto& block_it : blocks_) {
    int block_id          = block_it.first;
    int num_elem_in_block = mesh_.GetNumElementsInBlock(block_id);
    Kokkos::resize(gathered_reference_coordinate_d.at(block_index), num_elem_in_block);
    Kokkos::resize(gathered_displacement_d.at(block_index), num_elem_in_block);
    Kokkos::resize(gathered_internal_force_d.at(block_index), num_elem_in_block);
    Kokkos::resize(gathered_contact_force_d.at(block_index), num_elem_in_block);
    block_index += 1;
  }
}

ScatterScalarNodeData()

void nimble_kokkos::ModelData::ScatterScalarNodeData	(	int	field_id,
		int	num_elements,
		int	num_nodes_per_element,
		const DeviceElementConnectivityView &	elem_conn_d,
		const DeviceScalarNodeGatheredView &	gathered_view_d )

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(base_field_ptr);
  Field<FieldType::DeviceScalarNode>::AtomicView data = derived_field_ptr->data();
  Kokkos::parallel_for(
      "ScatterScalarNodeData", num_elements, KOKKOS_LAMBDA(const int i_elem) {
        for (int i_node = 0; i_node < num_nodes_per_element; i_node++) {
          data(elem_conn_d(num_nodes_per_element * i_elem + i_node)) += gathered_view_d(i_elem, i_node);
        }
      });
}

ScatterScalarNodeDataUsingKokkosScatterView()

void nimble_kokkos::ModelData::ScatterScalarNodeDataUsingKokkosScatterView	(	int	field_id,
		int	num_elements,
		int	num_nodes_per_element,
		const DeviceElementConnectivityView &	elem_conn_d,
		const DeviceScalarNodeGatheredView &	gathered_view_d )

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceScalarNode>*>(base_field_ptr);
  auto       data              = derived_field_ptr->data();
  auto       scatter_view =
      Kokkos::Experimental::create_scatter_view(data);  // DJL it is a terrible idea to allocate this here
  scatter_view.reset();
  Kokkos::parallel_for(
      "GatherVectorNodeData", num_elements, KOKKOS_LAMBDA(const int i_elem) {
        auto scattered_access = scatter_view.access();
        for (int i_node = 0; i_node < num_nodes_per_element; i_node++) {
          scattered_access(elem_conn_d(num_nodes_per_element * i_elem + i_node)) += gathered_view_d(i_elem, i_node);
        }
      });
  Kokkos::Experimental::contribute(data, scatter_view);
}

ScatterVectorNodeData()

void nimble_kokkos::ModelData::ScatterVectorNodeData	(	int	field_id,
		int	num_elements,
		int	num_nodes_per_element,
		const DeviceElementConnectivityView &	elem_conn_d,
		const DeviceVectorNodeGatheredView &	gathered_view_d )

{
  int        index             = field_id_to_device_node_data_index_.at(field_id);
  FieldBase* base_field_ptr    = device_node_data_.at(index).get();
  auto       derived_field_ptr = dynamic_cast<Field<FieldType::DeviceVectorNode>*>(base_field_ptr);
  Field<FieldType::DeviceVectorNode>::AtomicView data = derived_field_ptr->data();
  Kokkos::parallel_for(
      "ScatterVectorNodeData", num_elements, KOKKOS_LAMBDA(const int i_elem) {
        for (int i_node = 0; i_node < num_nodes_per_element; i_node++) {
          int node_index = elem_conn_d(num_nodes_per_element * i_elem + i_node);
          for (int i_coord = 0; i_coord < 3; i_coord++) {
            data(node_index, i_coord) += gathered_view_d(i_elem, i_node, i_coord);
          }
        }
      });
}

UpdateStates()

void nimble_kokkos::ModelData::UpdateStates ( const nimble::DataManager & data_manager )

overridevirtual

Copy time state (n+1) into time state (n)

Parameters

data_manager

Reference to the data manager

Implements nimble::ModelDataBase.

{
  const auto& field_ids_ = data_manager.GetFieldIDs();
 
  // Copy STEP_NP1 data to STEP_N
  int block_index = 0;
  for (auto& block_it : blocks_) {
    int  block_id = block_it.first;
    auto deformation_gradient_step_n_d =
        GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.deformation_gradient, nimble::STEP_N);
    auto unrotated_stress_step_n_d =
        GetDeviceSymTensorIntegrationPointData(block_id, field_ids_.unrotated_stress, nimble::STEP_N);
    auto stress_step_n_d = GetDeviceSymTensorIntegrationPointData(block_id, field_ids_.stress, nimble::STEP_N);
    auto deformation_gradient_step_np1_d =
        GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.deformation_gradient, nimble::STEP_NP1);
    auto unrotated_stress_step_np1_d =
        GetDeviceSymTensorIntegrationPointData(block_id, field_ids_.unrotated_stress, nimble::STEP_NP1);
    auto stress_step_np1_d = GetDeviceSymTensorIntegrationPointData(block_id, field_ids_.stress, nimble::STEP_NP1);
    Kokkos::deep_copy(deformation_gradient_step_n_d, deformation_gradient_step_np1_d);
    Kokkos::deep_copy(unrotated_stress_step_n_d, unrotated_stress_step_np1_d);
    Kokkos::deep_copy(stress_step_n_d, stress_step_np1_d);
    //
    if (blocks_.at(block_id).GetMaterialPointer()->NumStateVariables() > 0) {
      if (field_ids_.state_sym_tensor >= 0) {
        auto state_sym_tensor_n =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_sym_tensor, nimble::STEP_N);
        auto state_sym_tensor_np1 =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_sym_tensor, nimble::STEP_NP1);
        Kokkos::deep_copy(state_sym_tensor_n, state_sym_tensor_np1);
      }
      //
      if (field_ids_.state_full_tensor >= 0) {
        auto state_full_tensor_n =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_full_tensor, nimble::STEP_N);
        auto state_full_tensor_np1 =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_full_tensor, nimble::STEP_NP1);
        Kokkos::deep_copy(state_full_tensor_n, state_full_tensor_np1);
      }
      //
      if (field_ids_.state_scalar >= 0) {
        auto state_scalar_n =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_scalar, nimble::STEP_N);
        auto state_scalar_np1 =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_scalar, nimble::STEP_NP1);
        Kokkos::deep_copy(state_scalar_n, state_scalar_np1);
      }
      //
      if (field_ids_.state_vec3D >= 0) {
        auto state_vector_n = GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_vec3D, nimble::STEP_N);
        auto state_vector_np1 =
            GetDeviceFullTensorIntegrationPointData(block_id, field_ids_.state_vec3D, nimble::STEP_NP1);
        Kokkos::deep_copy(state_vector_n, state_vector_np1);
      }
    }
    //
    block_index += 1;
  }
}

UpdateWithNewDisplacement()

void nimble_kokkos::ModelData::UpdateWithNewDisplacement ( nimble::DataManager & data_manager, double dt )

overridevirtual

Update model with new displacement.

Parameters

[in]	data_manager	Reference to the data manager
[in]	dt	Current time step

Note

This routine wll synchronize the host and device displacements.

Reimplemented from nimble::ModelDataBase.

{
  Kokkos::deep_copy(displacement_d_, displacement_h_);
}

UpdateWithNewVelocity()

void nimble_kokkos::ModelData::UpdateWithNewVelocity ( nimble::DataManager & data_manager, double dt )

overridevirtual

Update model with new velocity.

Parameters

[in]	data_manager	Reference to the data manager
[in]	dt	Current time step

Note

This routine wll synchronize the host and device velocities.

Reimplemented from nimble::ModelDataBase.

{
  Kokkos::deep_copy(velocity_d_, velocity_h_);
}

WriteExodusOutput()

void nimble_kokkos::ModelData::WriteExodusOutput ( nimble::DataManager & data_manager, double time_current )

overridevirtual

Write output of simulation in Exodus format.

Parameters

[in]	data_manager	Reference to data manager
[in]	time_current	Time value

Reimplemented from nimble::ModelDataBase.

{
  auto        mesh_         = data_manager.GetMesh();
  const auto& parser_       = data_manager.GetParser();
  auto        exodus_output = data_manager.GetExodusOutput();
 
  Kokkos::deep_copy(displacement_d_, displacement_h_);
  Kokkos::deep_copy(velocity_d_, velocity_h_);
 
  exodus_output_manager_->ComputeElementData(
      mesh_, (*this), blocks_, gathered_reference_coordinate_d, gathered_displacement_d);
 
  auto const& node_data_output = exodus_output_manager_->GetNodeDataForOutput(*this);
  auto const& elem_data_output = exodus_output_manager_->GetElementDataForOutput(*this);
 
  std::vector<double>                             glbl_data;
  std::map<int, std::vector<std::vector<double>>> drvd_elem_data;
 
  exodus_output->WriteStep(
      time_current,
      glbl_data,
      node_data_output,
      output_element_component_labels_,
      elem_data_output,
      derived_output_element_data_labels_,
      drvd_elem_data);
}

Member Data Documentation

block_data_

std::vector<nimble::BlockData> nimble_kokkos::ModelData::block_data_

protected

block_id_to_element_data_index_

std::map<int, int> nimble_kokkos::ModelData::block_id_to_element_data_index_

protected

block_id_to_integration_point_data_index_

std::map<int, int> nimble_kokkos::ModelData::block_id_to_integration_point_data_index_

protected

blocks_

std::map<int, nimble_kokkos::Block> nimble_kokkos::ModelData::blocks_

protected

Blocks.

device_element_data_

std::vector<std::vector<Data> > nimble_kokkos::ModelData::device_element_data_

protected

device_integration_point_data_step_n_

std::vector<std::vector<Data> > nimble_kokkos::ModelData::device_integration_point_data_step_n_

protected

device_integration_point_data_step_np1_

std::vector<std::vector<Data> > nimble_kokkos::ModelData::device_integration_point_data_step_np1_

protected

device_node_data_

std::vector<Data> nimble_kokkos::ModelData::device_node_data_

protected

displacement_d_

nimble_kokkos::DeviceVectorNodeView nimble_kokkos::ModelData::displacement_d_

protected

displacement_h_

nimble_kokkos::HostVectorNodeView nimble_kokkos::ModelData::displacement_h_

protected

exodus_output_manager_

std::unique_ptr<nimble_kokkos::ExodusOutputManager> nimble_kokkos::ModelData::exodus_output_manager_

protected

field_id_to_device_element_data_index_

std::vector<std::map<int, int> > nimble_kokkos::ModelData::field_id_to_device_element_data_index_

protected

field_id_to_device_integration_point_data_index_

std::vector<std::map<int, int> > nimble_kokkos::ModelData::field_id_to_device_integration_point_data_index_

protected

field_id_to_device_node_data_index_

std::map<int, int> nimble_kokkos::ModelData::field_id_to_device_node_data_index_

protected

field_id_to_host_element_data_index_

std::vector<std::map<int, int> > nimble_kokkos::ModelData::field_id_to_host_element_data_index_

protected

field_id_to_host_integration_point_data_index_

std::vector<std::map<int, int> > nimble_kokkos::ModelData::field_id_to_host_integration_point_data_index_

protected

field_id_to_host_node_data_index_

std::map<int, int> nimble_kokkos::ModelData::field_id_to_host_node_data_index_

protected

field_label_to_field_id_map_

std::map<std::string, int> nimble_kokkos::ModelData::field_label_to_field_id_map_

protected

gathered_contact_force_d

std::vector<nimble_kokkos::DeviceVectorNodeGatheredView> nimble_kokkos::ModelData::gathered_contact_force_d

protected

gathered_displacement_d

std::vector<nimble_kokkos::DeviceVectorNodeGatheredView> nimble_kokkos::ModelData::gathered_displacement_d

protected

gathered_internal_force_d

std::vector<nimble_kokkos::DeviceVectorNodeGatheredView> nimble_kokkos::ModelData::gathered_internal_force_d

protected

gathered_reference_coordinate_d

std::vector<nimble_kokkos::DeviceVectorNodeGatheredView> nimble_kokkos::ModelData::gathered_reference_coordinate_d

protected

host_element_data_

std::vector<std::vector<Data> > nimble_kokkos::ModelData::host_element_data_

protected

host_integration_point_data_step_n_

std::vector<std::vector<Data> > nimble_kokkos::ModelData::host_integration_point_data_step_n_

protected

host_integration_point_data_step_np1_

std::vector<std::vector<Data> > nimble_kokkos::ModelData::host_integration_point_data_step_np1_

protected

host_node_data_

std::vector<Data> nimble_kokkos::ModelData::host_node_data_

protected

velocity_d_

nimble_kokkos::DeviceVectorNodeView nimble_kokkos::ModelData::velocity_d_

protected

velocity_h_

nimble_kokkos::HostVectorNodeView nimble_kokkos::ModelData::velocity_h_

protected

---

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

• src/nimble_kokkos_model_data.h
• src/nimble_kokkos_model_data.cc