nimble::DataManager Class Reference

#include <nimble_data_manager.h>

Public Member Functions
	DataManager (const nimble::Parser &parser, const nimble::GenesisMesh &mesh)
	Constructor.
	~DataManager ()=default
	Destructor.
void	InitializeOutput (const std::string &filename)
	Initialize the data for Exodus output.
const nimble::Parser &	GetParser () const
	Return constant reference to parser information.
const nimble::GenesisMesh &	GetMesh () const
	Return constant reference to mesh.
std::shared_ptr< nimble::ModelDataBase >	GetModelData ()
	Return shared pointer to ModelData objet.
const nimble::FieldIds &	GetFieldIDs () const
	Return a const reference to the field IDs.
nimble::FieldIds &	GetFieldIDs ()
	Return reference to the field IDs.
std::shared_ptr< nimble::VectorCommunicator >	GetVectorCommunicator ()
	Return shared pointer to VectorCommunicator objet.
void	WriteOutput (double time_current)
	Write output of simulations.
std::shared_ptr< nimble::ExodusOutput >	GetExodusOutput ()
void	SetBlockMaterialInterfaceFactory (const std::shared_ptr< nimble::BlockMaterialInterfaceFactoryBase > &block_material_factory)
	Set BlockMaterialInterfaceFactoryBase object and initialize block data information.
const std::shared_ptr< nimble::BlockMaterialInterfaceFactoryBase > &	GetBlockMaterialInterfaceFactory () const
	Return shared pointer to BlockMaterialInterfaceFactoryBase object.
std::shared_ptr< nimble::BoundaryConditionManager >	GetBoundaryConditionManager ()
	Return shared pointer to BoundaryConditionManager object.

Protected Member Functions
void	Initialize ()
	Initialize data for simulation.

Protected Attributes
const nimble::Parser &	parser_
const nimble::GenesisMesh &	mesh_
std::shared_ptr< nimble::ModelDataBase >	model_data_ = nullptr
nimble::FieldIds	field_ids_
std::shared_ptr< nimble::VectorCommunicator >	vector_communicator_ = nullptr
std::shared_ptr< nimble::ExodusOutput >	exodus_output_ = nullptr
std::shared_ptr< nimble::BlockMaterialInterfaceFactoryBase >	block_material_factory_ = nullptr
std::shared_ptr< nimble::BoundaryConditionManager >	boundary_condition_ = nullptr

Constructor & Destructor Documentation

DataManager()

nimble::DataManager::DataManager	(	const nimble::Parser &	parser,
		const nimble::GenesisMesh &	mesh )

Constructor.

Parameters

parser	Reference to parser information
mesh	Reference to mesh

    : parser_(parser),
      mesh_(mesh),
      model_data_(),
      field_ids_(),
      vector_communicator_(nullptr),
      boundary_condition_(new nimble::BoundaryConditionManager())
{
  Initialize();
}

~DataManager()

nimble::DataManager::~DataManager ( )

default

Destructor.

Member Function Documentation

GetBlockMaterialInterfaceFactory()

const std::shared_ptr< nimble::BlockMaterialInterfaceFactoryBase > & nimble::DataManager::GetBlockMaterialInterfaceFactory

(

)

const

Return shared pointer to BlockMaterialInterfaceFactoryBase object.

Returns

Shared pointer

{
  return block_material_factory_;
}

GetBoundaryConditionManager()

std::shared_ptr< nimble::BoundaryConditionManager > nimble::DataManager::GetBoundaryConditionManager ( )

inline

Return shared pointer to BoundaryConditionManager object.

Returns

Shared pointer

  {
    return boundary_condition_;
  }

GetExodusOutput()

std::shared_ptr< nimble::ExodusOutput > nimble::DataManager::GetExodusOutput ( )

inline

  {
    return exodus_output_;
  }

GetFieldIDs() [1/2]

nimble::FieldIds & nimble::DataManager::GetFieldIDs ( )

inline

Return reference to the field IDs.

Returns

Field IDs

  {
    return field_ids_;
  }

GetFieldIDs() [2/2]

const nimble::FieldIds & nimble::DataManager::GetFieldIDs ( ) const

inline

Return a const reference to the field IDs.

Returns

Field IDs

  {
    return field_ids_;
  }

GetMesh()

const nimble::GenesisMesh & nimble::DataManager::GetMesh ( ) const

inline

Return constant reference to mesh.

Returns

Reference to mesh

  {
    return mesh_;
  }

GetModelData()

std::shared_ptr< nimble::ModelDataBase > nimble::DataManager::GetModelData ( )

inline

Return shared pointer to ModelData objet.

Returns

Shared pointer

  {
    return model_data_;
  }

GetParser()

const nimble::Parser & nimble::DataManager::GetParser ( ) const

inline

Return constant reference to parser information.

Returns

Reference to parser information

  {
    return parser_;
  }

GetVectorCommunicator()

std::shared_ptr< nimble::VectorCommunicator > nimble::DataManager::GetVectorCommunicator ( )

inline

Return shared pointer to VectorCommunicator objet.

Returns

Shared pointer

  {
    return vector_communicator_;
  }

Initialize()

void nimble::DataManager::Initialize ( )

protected

Initialize data for simulation.

{
  const auto dim       = static_cast<int>(mesh_.GetDim());
  const auto num_nodes = static_cast<int>(mesh_.GetNumNodes());
 
  //--- Create VectorCommunicator
#ifdef NIMBLE_HAVE_TRILINOS
  auto comm = (parser_.UseTpetra()) ? Tpetra::getDefaultComm() : Teuchos::RCP<const Teuchos::Comm<int>>();
#else
  int comm = 0;
#endif
  vector_communicator_ = std::make_shared<nimble::VectorCommunicator>(dim, num_nodes, comm);
 
  std::vector<int> global_node_ids(num_nodes);
  int const* const global_node_ids_ptr = mesh_.GetNodeGlobalIds();
  for (int n = 0; n < num_nodes; ++n) { global_node_ids[n] = global_node_ids_ptr[n]; }
 
  // DJL
  // Here is where the initialization occurs for MPI operations
  // In this call, each rank determines which nodes are shared with which other
  // ranks This information is stored so that the vector reductions will work
  // later
  vector_communicator_->Initialize(global_node_ids);
 
  //--- Create ModelData
  if (parser_.UseUQ()) {
#ifdef NIMBLE_HAVE_UQ
    model_data_ = std::make_shared<nimble_uq::ModelData>();
#else
    NIMBLE_ABORT(" Wrong environment !\n");
#endif
  } else {
    model_data_ = std::make_shared<nimble_kokkos::ModelData>();
  }
 
  model_data_->SetDimension(dim);
 
  //
  // Initialize the boundary condition manager
  //
 
  std::map<int, std::string> const&      node_set_names          = mesh_.GetNodeSetNames();
  std::map<int, std::vector<int>> const& node_sets               = mesh_.GetNodeSets();
  std::map<int, std::string> const&      side_set_names          = mesh_.GetSideSetNames();
  std::map<int, std::vector<int>> const& side_sets               = mesh_.GetSideSets();
  std::vector<std::string> const&        bc_strings              = parser_.GetBoundaryConditionStrings();
  std::string                            time_integration_scheme = parser_.TimeIntegrationScheme();
  boundary_condition_->Initialize(
      node_set_names, node_sets, side_set_names, side_sets, bc_strings, dim, time_integration_scheme);
 
  //
  // Initialize vectors for storing fields
  //
 
  if (time_integration_scheme == "explicit")
    field_ids_.lumped_mass = model_data_->AllocateNodeData(nimble::SCALAR, "lumped_mass", num_nodes);
 
  field_ids_.reference_coordinates = model_data_->AllocateNodeData(nimble::VECTOR, "reference_coordinate", num_nodes);
  field_ids_.displacement          = model_data_->AllocateNodeData(nimble::VECTOR, "displacement", num_nodes);
  field_ids_.velocity              = model_data_->AllocateNodeData(nimble::VECTOR, "velocity", num_nodes);
  field_ids_.acceleration          = model_data_->AllocateNodeData(nimble::VECTOR, "acceleration", num_nodes);
 
  field_ids_.internal_force = model_data_->AllocateNodeData(nimble::VECTOR, "internal_force", num_nodes);
  field_ids_.external_force = model_data_->AllocateNodeData(nimble::VECTOR, "external_force", num_nodes);
 
  field_ids_.contact_force = model_data_->AllocateNodeData(nimble::VECTOR, "contact_force", num_nodes);
 
  if (time_integration_scheme == "quasistatic") {
    //
    // These variables are used in the "quasi-static" simulations
    //
    model_data_->AllocateNodeData(nimble::VECTOR, "trial_displacement", num_nodes);
    model_data_->AllocateNodeData(nimble::VECTOR, "displacement_fluctuation", num_nodes);
    model_data_->AllocateNodeData(nimble::VECTOR, "trial_internal_force", num_nodes);
    model_data_->AllocateNodeData(nimble::SCALAR, "skin_node", num_nodes);
  }
 
  model_data_->SetReferenceCoordinates(mesh_);
}

InitializeOutput()

void nimble::DataManager::InitializeOutput

(

const std::string &

filename

)

Initialize the data for Exodus output.

Parameters

filename

File name for the output files

{
  std::vector<std::string> global_data_labels;
 
  exodus_output_ = std::shared_ptr<nimble::ExodusOutput>(new nimble::ExodusOutput);
  exodus_output_->Initialize(filename, mesh_);
 
  auto& node_data_labels_for_output = model_data_->GetNodeDataLabelsForOutput();
  auto& elem_data_labels_for_output = model_data_->GetElementDataLabelsForOutput();
  auto& derived_elem_data_labels    = model_data_->GetDerivedElementDataLabelsForOutput();
 
  model_data_->InitializeExodusOutput(*this);
 
  exodus_output_->InitializeDatabase(
      mesh_, global_data_labels, node_data_labels_for_output, elem_data_labels_for_output, derived_elem_data_labels);
}

SetBlockMaterialInterfaceFactory()

void nimble::DataManager::SetBlockMaterialInterfaceFactory

(

const std::shared_ptr< nimble::BlockMaterialInterfaceFactoryBase > &

block_material_factory

)

Set BlockMaterialInterfaceFactoryBase object and initialize block data information.

{
  block_material_factory_ = block_material_factory;
}

WriteOutput()

void nimble::DataManager::WriteOutput

(

double

time_current

)

Write output of simulations.

Parameters

[in]

time_current

Time value

{
  model_data_->WriteExodusOutput(*this, time_current);
}

Member Data Documentation

block_material_factory_

std::shared_ptr<nimble::BlockMaterialInterfaceFactoryBase> nimble::DataManager::block_material_factory_ = nullptr

protected

boundary_condition_

std::shared_ptr<nimble::BoundaryConditionManager> nimble::DataManager::boundary_condition_ = nullptr

protected

exodus_output_

std::shared_ptr<nimble::ExodusOutput> nimble::DataManager::exodus_output_ = nullptr

protected

field_ids_

nimble::FieldIds nimble::DataManager::field_ids_

protected

mesh_

const nimble::GenesisMesh& nimble::DataManager::mesh_

protected

model_data_

std::shared_ptr<nimble::ModelDataBase> nimble::DataManager::model_data_ = nullptr

protected

parser_

const nimble::Parser& nimble::DataManager::parser_

protected

vector_communicator_

std::shared_ptr<nimble::VectorCommunicator> nimble::DataManager::vector_communicator_ = nullptr

protected

---

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

• src/nimble_data_manager.h
• src/nimble_data_manager.cc