libMesh::DTKAdapter Class Reference

The DTKAdapter is used with the DTKSolutionTransfer object to adapt libmesh data to the DTK interface. More...

#include <dtk_adapter.h>

Public Types
typedef DataTransferKit::MeshContainer< int >	MeshContainerType
typedef DataTransferKit::FieldContainer< double >	FieldContainerType
typedef DataTransferKit::MeshTraits< MeshContainerType >::global_ordinal_type	GlobalOrdinal
typedef DataTransferKit::FieldEvaluator< GlobalOrdinal, FieldContainerType >	EvaluatorType
typedef Teuchos::RCP< EvaluatorType >	RCP_Evaluator

Public Member Functions
	DTKAdapter (Teuchos::RCP< const Teuchos::Comm< int > > in_comm, EquationSystems &in_es)
Teuchos::RCP< DataTransferKit::MeshManager< MeshContainerType > >	get_mesh_manager ()
RCP_Evaluator	get_variable_evaluator (std::string var_name)
Teuchos::RCP< DataTransferKit::FieldManager< MeshContainerType > >	get_target_coords ()
Teuchos::RCP< DataTransferKit::FieldManager< FieldContainerType > >	get_values_to_fill (std::string var_name)
void	update_variable_values (std::string var_name)
	After computing values for a variable in this EquationSystems we need to take those values and put them in the actual solution vector.

Protected Member Functions
System *	find_sys (std::string var_name)
	Small helper function for finding the system containing the variable.
DataTransferKit::DTK_ElementTopology	get_element_topology (const Elem *elem)
void	get_semi_local_nodes (std::set< unsigned int > &semi_local_nodes)
	Helper function that fills the std::set with all of the node numbers of nodes connected to local elements.

Protected Attributes
Teuchos::RCP< const Teuchos::Comm< int > >	comm
EquationSystems &	es
const MeshBase &	mesh
unsigned int	dim
unsigned int	num_local_nodes
Teuchos::ArrayRCP< int >	vertices
Teuchos::RCP< DataTransferKit::MeshManager< MeshContainerType > >	mesh_manager
RCP_Evaluator	field_evaluator
Teuchos::RCP< DataTransferKit::FieldManager< MeshContainerType > >	target_coords
std::map< std::string, Teuchos::RCP< DataTransferKit::FieldManager< FieldContainerType > > >	values_to_fill
	Map of variable names to arrays to be filled by a transfer.
std::map< std::string, RCP_Evaluator >	evaluators
	Map of variable names to RCP_Evaluator objects.

Detailed Description

The DTKAdapter is used with the DTKSolutionTransfer object to adapt libmesh data to the DTK interface.

Author

Derek Gaston

Date

2013

Definition at line 52 of file dtk_adapter.h.

Member Typedef Documentation

EvaluatorType

typedef DataTransferKit::FieldEvaluator<GlobalOrdinal,FieldContainerType> libMesh::DTKAdapter::EvaluatorType

Definition at line 60 of file dtk_adapter.h.

FieldContainerType

typedef DataTransferKit::FieldContainer<double> libMesh::DTKAdapter::FieldContainerType

Definition at line 58 of file dtk_adapter.h.

GlobalOrdinal

typedef DataTransferKit::MeshTraits<MeshContainerType>::global_ordinal_type libMesh::DTKAdapter::GlobalOrdinal

Definition at line 59 of file dtk_adapter.h.

MeshContainerType

typedef DataTransferKit::MeshContainer<int> libMesh::DTKAdapter::MeshContainerType

Definition at line 57 of file dtk_adapter.h.

RCP_Evaluator

typedef Teuchos::RCP<EvaluatorType> libMesh::DTKAdapter::RCP_Evaluator

Definition at line 61 of file dtk_adapter.h.

Constructor & Destructor Documentation

DTKAdapter()

libMesh::DTKAdapter::DTKAdapter	(	Teuchos::RCP< const Teuchos::Comm< int > >	in_comm,
		EquationSystems &	in_es
	)

Definition at line 46 of file dtk_adapter.C.

                                                                                         :
  comm(in_comm),
  es(in_es),
  mesh(in_es.get_mesh()),
  dim(mesh.mesh_dimension())
{
  std::set<unsigned int> semi_local_nodes;
  get_semi_local_nodes(semi_local_nodes);
 
  num_local_nodes = semi_local_nodes.size();
 
  vertices.resize(num_local_nodes);
  Teuchos::ArrayRCP<double> coordinates(num_local_nodes * dim);
 
  // Fill in the vertices and coordinates
  {
    unsigned int i = 0;
 
    for (const auto & id : semi_local_nodes)
      {
        const Node & node = mesh.node_ref(id);
 
        vertices[i] = node.id();
 
        for (unsigned int j=0; j<dim; j++)
          coordinates[(j*num_local_nodes) + i] = node(j);
 
        i++;
      }
  }
 
  // Currently assuming all elements are the same!
  DataTransferKit::DTK_ElementTopology element_topology = get_element_topology(mesh.elem_ptr(0));
  unsigned int n_nodes_per_elem = mesh.elem_ptr(0)->n_nodes();
 
  unsigned int n_local_elem = mesh.n_local_elem();
 
  Teuchos::ArrayRCP<int> elements(n_local_elem);
  Teuchos::ArrayRCP<int> connectivity(n_nodes_per_elem*n_local_elem);
 
  // Fill in the elements and connectivity
  {
    unsigned int i = 0;
 
    for (const auto & elem : as_range(mesh.local_elements_begin(),
                                      mesh.local_elements_end()))
      {
        elements[i] = elem->id();
 
        for (unsigned int j=0; j<n_nodes_per_elem; j++)
          connectivity[(j*n_local_elem)+i] = elem->node_id(j);
 
        i++;
      }
  }
 
  Teuchos::ArrayRCP<int> permutation_list(n_nodes_per_elem);
  std::iota(permutation_list.begin(), permutation_list.end(), 0);
 
  /*
    if (this->processor_id() == 1)
    sleep(1);
 
    libMesh::out<<"n_nodes_per_elem: "<<n_nodes_per_elem<<std::endl;
 
    libMesh::out<<"Dim: "<<dim<<std::endl;
 
    libMesh::err<<"Vertices size: "<<vertices.size()<<std::endl;
    {
    libMesh::err<<this->processor_id()<<" Vertices: ";
 
    for (std::size_t i=0; i<vertices.size(); i++)
    libMesh::err<<vertices[i]<<" ";
 
    libMesh::err<<std::endl;
    }
 
    libMesh::err<<"Coordinates size: "<<coordinates.size()<<std::endl;
    {
    libMesh::err<<this->processor_id()<<" Coordinates: ";
 
    for (std::size_t i=0; i<coordinates.size(); i++)
    libMesh::err<<coordinates[i]<<" ";
 
    libMesh::err<<std::endl;
    }
 
    libMesh::err<<"Connectivity size: "<<connectivity.size()<<std::endl;
    {
    libMesh::err<<this->processor_id()<<" Connectivity: ";
 
    for (std::size_t i=0; i<connectivity.size(); i++)
    libMesh::err<<connectivity[i]<<" ";
 
    libMesh::err<<std::endl;
    }
 
    libMesh::err<<"Permutation_List size: "<<permutation_list.size()<<std::endl;
    {
    libMesh::err<<this->processor_id()<<" Permutation_List: ";
 
    for (std::size_t i=0; i<permutation_list.size(); i++)
    libMesh::err<<permutation_list[i]<<" ";
 
    libMesh::err<<std::endl;
    }
 
  */
  Teuchos::RCP<MeshContainerType>
    mesh_container = Teuchos::rcp(new MeshContainerType(dim,
                                                        vertices,
                                                        coordinates,
                                                        element_topology,
                                                        n_nodes_per_elem,
                                                        elements,
                                                        connectivity,
                                                        permutation_list));
 
  // We only have 1 element topology in this grid so we make just one mesh block
  Teuchos::ArrayRCP<Teuchos::RCP<MeshContainerType>> mesh_blocks(1);
  mesh_blocks[0] = mesh_container;
 
  // Create the MeshManager
  mesh_manager = Teuchos::rcp(new DataTransferKit::MeshManager<MeshContainerType>(mesh_blocks, comm, dim) );
 
  // Pack the coordinates into a field, this will be the positions we'll ask for other systems fields at
  target_coords = Teuchos::rcp(new DataTransferKit::FieldManager<MeshContainerType>(mesh_container, comm));
}

References libMesh::as_range(), comm, dim, libMesh::MeshBase::elem_ptr(), get_element_topology(), get_semi_local_nodes(), libMesh::DofObject::id(), mesh, mesh_manager, libMesh::MeshBase::n_local_elem(), libMesh::Elem::n_nodes(), libMesh::MeshBase::node_ref(), num_local_nodes, target_coords, and vertices.

Member Function Documentation

find_sys()

System * libMesh::DTKAdapter::find_sys ( std::string  var_name )

protected

Small helper function for finding the system containing the variable.

Note

This implies that variable names are unique across all systems!

Note that this implies that variable names are unique across all systems!

Definition at line 245 of file dtk_adapter.C.

{
  System * sys = nullptr;
 
  // Find the system this variable is from
  for (auto i : make_range(es.n_systems()))
    {
      if (es.get_system(i).has_variable(var_name))
        {
          sys = &es.get_system(i);
          break;
        }
    }
 
  libmesh_assert(sys);
 
  return sys;
}

References es, libMesh::EquationSystems::get_system(), libMesh::libmesh_assert(), libMesh::make_range(), and libMesh::EquationSystems::n_systems().

Referenced by get_variable_evaluator(), and update_variable_values().

get_element_topology()

DataTransferKit::DTK_ElementTopology libMesh::DTKAdapter::get_element_topology ( const Elem *  elem )

protected

Returns

The DTK ElementTopology for a given Elem.

Definition at line 265 of file dtk_adapter.C.

{
  ElemType type = elem->type();
 
  if (type == EDGE2)
    return DataTransferKit::DTK_LINE_SEGMENT;
  else if (type == TRI3)
    return DataTransferKit::DTK_TRIANGLE;
  else if (type == QUAD4)
    return DataTransferKit::DTK_QUADRILATERAL;
  else if (type == TET4)
    return DataTransferKit::DTK_TETRAHEDRON;
  else if (type == HEX8)
    return DataTransferKit::DTK_HEXAHEDRON;
  else if (type == PYRAMID5)
    return DataTransferKit::DTK_PYRAMID;
 
  libmesh_error_msg("Element type not supported by DTK!");
}

References libMesh::EDGE2, libMesh::HEX8, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::TET4, libMesh::TRI3, and libMesh::Elem::type().

Referenced by DTKAdapter().

get_mesh_manager()

Teuchos::RCP< DataTransferKit::MeshManager< MeshContainerType > > libMesh::DTKAdapter::get_mesh_manager ( )

inline

Definition at line 64 of file dtk_adapter.h.

{ return mesh_manager; }

References mesh_manager.

Referenced by libMesh::DTKSolutionTransfer::transfer().

get_semi_local_nodes()

void libMesh::DTKAdapter::get_semi_local_nodes ( std::set< unsigned int > &  semi_local_nodes )

protected

Helper function that fills the std::set with all of the node numbers of nodes connected to local elements.

Definition at line 286 of file dtk_adapter.C.

{
  for (const auto & elem : as_range(mesh.local_elements_begin(), mesh.local_elements_end()))
    for (const Node & node : elem->node_ref_range())
      semi_local_nodes.insert(node.id());
}

References libMesh::as_range(), and mesh.

Referenced by DTKAdapter().

get_target_coords()

Teuchos::RCP< DataTransferKit::FieldManager< MeshContainerType > > libMesh::DTKAdapter::get_target_coords ( )

inline

Definition at line 66 of file dtk_adapter.h.

{ return target_coords; }

References target_coords.

Referenced by libMesh::DTKSolutionTransfer::transfer().

get_values_to_fill()

Teuchos::RCP< DataTransferKit::FieldManager< DTKAdapter::FieldContainerType > > libMesh::DTKAdapter::get_values_to_fill

(

std::string

var_name

)

Definition at line 193 of file dtk_adapter.C.

{
  // We try emplacing a nullptr into the "values_to_fill" map.
  auto [it, emplaced] = values_to_fill.emplace(var_name, nullptr);
 
  // If the emplace succeeded, that means it was a new entry in the
  // map, so we need to actually construct the object.
  if (emplaced)
    {
      Teuchos::ArrayRCP<double> data_space(num_local_nodes);
      Teuchos::RCP<FieldContainerType> field_container = Teuchos::rcp(new FieldContainerType(data_space, 1));
      it->second = Teuchos::rcp(new DataTransferKit::FieldManager<FieldContainerType>(field_container, comm));
    }
 
  return it->second;
}

References comm, num_local_nodes, and values_to_fill.

Referenced by libMesh::DTKSolutionTransfer::transfer().

get_variable_evaluator()

DTKAdapter::RCP_Evaluator libMesh::DTKAdapter::get_variable_evaluator

(

std::string

var_name

)

Definition at line 176 of file dtk_adapter.C.

{
  // We try emplacing a nullptr into the "evaluators" map.
  auto [it, emplaced] = evaluators.emplace(var_name, nullptr);
 
  // If the emplace succeeded, that means it was a new entry in the
  // map, so we need to actually construct the object.
  if (emplaced)
    {
      System * sys = find_sys(var_name);
      it->second = Teuchos::rcp(new DTKEvaluator(*sys, var_name));
    }
 
  return it->second;
}

References evaluators, and find_sys().

Referenced by libMesh::DTKSolutionTransfer::transfer().

update_variable_values()

void libMesh::DTKAdapter::update_variable_values

(

std::string

var_name

)

After computing values for a variable in this EquationSystems we need to take those values and put them in the actual solution vector.

Definition at line 211 of file dtk_adapter.C.

{
  System * sys = find_sys(var_name);
  unsigned int var_num = sys->variable_number(var_name);
 
  Teuchos::RCP<FieldContainerType> values = values_to_fill[var_name]->field();
 
  unsigned int i=0;
  // Loop over the values (one for each node) and assign the value of this variable at each node
  for (const auto & value : *values)
    {
      unsigned int node_num = vertices[i];
      const Node & node = mesh.node_ref(node_num);
 
      if (node.processor_id() == sys->processor_id())
        {
          // The 0 is for the component... this only works for LAGRANGE!
          dof_id_type dof = node.dof_number(sys->number(), var_num, 0);
          sys->solution->set(dof, value);
        }
 
      i++;
    }
 
  sys->solution->close();
}

References libMesh::DofObject::dof_number(), find_sys(), mesh, libMesh::MeshBase::node_ref(), libMesh::System::number(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::System::solution, value, values_to_fill, libMesh::System::variable_number(), and vertices.

Referenced by libMesh::DTKSolutionTransfer::transfer().

Member Data Documentation

comm

Teuchos::RCP<const Teuchos::Comm<int> > libMesh::DTKAdapter::comm

protected

Definition at line 94 of file dtk_adapter.h.

Referenced by DTKAdapter(), and get_values_to_fill().

dim

unsigned int libMesh::DTKAdapter::dim

protected

Definition at line 97 of file dtk_adapter.h.

Referenced by DTKAdapter().

es

EquationSystems& libMesh::DTKAdapter::es

protected

Definition at line 95 of file dtk_adapter.h.

Referenced by find_sys().

evaluators

std::map<std::string, RCP_Evaluator> libMesh::DTKAdapter::evaluators

protected

Map of variable names to RCP_Evaluator objects.

Definition at line 110 of file dtk_adapter.h.

Referenced by get_variable_evaluator().

field_evaluator

RCP_Evaluator libMesh::DTKAdapter::field_evaluator

protected

Definition at line 103 of file dtk_adapter.h.

mesh

const MeshBase& libMesh::DTKAdapter::mesh

protected

Definition at line 96 of file dtk_adapter.h.

Referenced by DTKAdapter(), get_semi_local_nodes(), and update_variable_values().

mesh_manager

Teuchos::RCP<DataTransferKit::MeshManager<MeshContainerType> > libMesh::DTKAdapter::mesh_manager

protected

Definition at line 102 of file dtk_adapter.h.

Referenced by DTKAdapter(), and get_mesh_manager().

num_local_nodes

unsigned int libMesh::DTKAdapter::num_local_nodes

protected

Definition at line 99 of file dtk_adapter.h.

Referenced by DTKAdapter(), and get_values_to_fill().

target_coords

Teuchos::RCP<DataTransferKit::FieldManager<MeshContainerType> > libMesh::DTKAdapter::target_coords

protected

Definition at line 104 of file dtk_adapter.h.

Referenced by DTKAdapter(), and get_target_coords().

values_to_fill

std::map<std::string, Teuchos::RCP<DataTransferKit::FieldManager<FieldContainerType> > > libMesh::DTKAdapter::values_to_fill

protected

Map of variable names to arrays to be filled by a transfer.

Definition at line 107 of file dtk_adapter.h.

Referenced by get_values_to_fill(), and update_variable_values().

vertices

Teuchos::ArrayRCP<int> libMesh::DTKAdapter::vertices

protected

Definition at line 100 of file dtk_adapter.h.

Referenced by DTKAdapter(), and update_variable_values().

---

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

• include/solution_transfer/dtk_adapter.h
• src/solution_transfer/dtk_adapter.C