MeshAlignment Class Reference

Builds mapping between two aligned subdomains/boundaries. More...

#include <MeshAlignment.h>

Inheritance diagram for MeshAlignment:

Public Member Functions
	MeshAlignment (const MooseMesh &mesh, bool require_same_translation=false)
	Constructor.
void	initialize (const std::vector< dof_id_type > &primary_elem_ids, const std::vector< std::tuple< dof_id_type, unsigned short int > > &secondary_boundary_info)
	Extracts mesh information and builds the mapping.
void	initialize (const std::vector< std::tuple< dof_id_type, unsigned short int > > &primary_boundary_info, const std::vector< std::tuple< dof_id_type, unsigned short int > > &secondary_boundary_info)
	Extracts mesh information and builds the mapping.
void	buildCoupledElemQpIndexMap (Assembly &assembly)
	Builds the map used for getting the coupled quadrature point index.
bool	meshesAreCoincident () const
	Returns true if the primary and secondary meshes are coincident.
bool	hasCoupledElemID (const dof_id_type &elem_id) const
	Returns true if the element ID has a coupled element ID.
const dof_id_type &	getCoupledElemID (const dof_id_type &elem_id) const
	Gets the coupled element ID for a given element ID.
bool	hasCoupledNodeID (const dof_id_type &node_id) const
	Returns true if the node ID has a coupled node ID.
const dof_id_type &	getCoupledNodeID (const dof_id_type &node_id) const
	Gets the coupled node ID for a given node ID.
unsigned int	getCoupledElemQpIndex (const dof_id_type &elem_id, const unsigned int &qp) const
	Gets the quadrature point index on the coupled element corresponding to the quadrature point index on the provided primary element.
const std::vector< dof_id_type > &	getPrimaryElemIDs () const
	Returns the list of element IDs on the primary boundary.
const std::vector< dof_id_type > &	getSecondaryElemIDs () const
	Returns the list of element IDs on the secondary boundary.
bool	meshesAreAligned () const
	Returns true if the primary and secondary meshes are aligned.

Protected Member Functions
void	buildMapping ()
	Builds the mapping using the extracted mesh information.
std::map< dof_id_type, std::vector< Point > >	getLocalQuadraturePointMap (Assembly &assembly, const std::vector< dof_id_type > &elem_ids, const std::vector< unsigned short int > &side_ids) const
	Gets the local quadrature point map for the primary or secondary side.
void	extractFrom1DElements (const std::vector< dof_id_type > &elem_ids, std::vector< Point > &elem_points, std::vector< dof_id_type > &node_ids, std::vector< Point > &node_points) const
	Extracts mesh information from 1D elements.
void	extractFromBoundaryInfo (const std::vector< std::tuple< dof_id_type, unsigned short int > > &boundary_info, std::vector< dof_id_type > &elem_ids, std::vector< unsigned short int > &side_ids, std::vector< Point > &side_points, std::vector< dof_id_type > &node_ids, std::vector< Point > &node_points) const
	Extracts mesh information from boundary info.

Protected Attributes
std::map< dof_id_type, dof_id_type >	_coupled_elem_ids
	Map of element ID to coupled element ID.
std::map< dof_id_type, dof_id_type >	_coupled_node_ids
	Map of node ID to coupled node ID.
std::map< dof_id_type, std::vector< unsigned int > >	_coupled_elem_qp_indices
	Map of element ID to vector of coupled quadrature points.
const bool	_require_same_translation
	Flag that alignment requires that pairings have same translation vector.
bool	_meshes_are_coincident
	Flag that meshes are coincident.
bool	_meshes_have_same_translation
	Flag that each pairing has the same translation vector.
const MooseMesh &	_mesh
	Mesh.
std::vector< dof_id_type >	_primary_elem_ids
	List of primary element IDs.
std::vector< dof_id_type >	_secondary_elem_ids
	List of secondary element IDs.
std::vector< Point >	_primary_elem_points
	List of primary element points.
std::vector< Point >	_secondary_elem_points
	List of secondary element points.
std::vector< unsigned short int >	_primary_side_ids
	List of primary side IDs (if any)
std::vector< unsigned short int >	_secondary_side_ids
	List of secondary side IDs (if any)
std::vector< dof_id_type >	_primary_node_ids
	List of primary node IDs.
std::vector< dof_id_type >	_secondary_node_ids
	List of secondary node IDs.
std::vector< Point >	_primary_node_points
	List of primary node points.
std::vector< Point >	_secondary_node_points
	List of secondary node points.
bool	_meshes_are_aligned
	Flag that meshes are aligned.

Detailed Description

Builds mapping between two aligned subdomains/boundaries.

This class handles cases where there is a 1:1 mapping between elements on the primary and secondary meshes:

• 1D subdomain coupled to 2D boundary
• 2D boundary coupled to 2D boundary

Definition at line 24 of file MeshAlignment.h.

Constructor & Destructor Documentation

MeshAlignment()

MeshAlignment::MeshAlignment	(	const MooseMesh &	mesh,
		bool	require_same_translation = false
	)

Constructor.

Parameters

	mesh[in]	mesh Mesh
[in]	require_same_translation.	If true, mesh alignment requires the same translation. Else it just requires that all primary elements have exactly one pairing.

Definition at line 16 of file MeshAlignment.C.

  : MeshAlignmentBase(mesh),
    _require_same_translation(require_same_translation),
    _meshes_are_coincident(false),
    _meshes_have_same_translation(false)
{
}

Member Function Documentation

buildCoupledElemQpIndexMap()

void MeshAlignment::buildCoupledElemQpIndexMap

(

Assembly &

assembly

)

Builds the map used for getting the coupled quadrature point index.

This method needs the assembly object, so it needs to be called from an object that has assembly access (components do not).

Parameters

assembly

The assembly object

Definition at line 152 of file MeshAlignment.C.

{
  // get local quadrature point maps on each side
  std::map<dof_id_type, std::vector<Point>> primary_qp_map =
      getLocalQuadraturePointMap(assembly, _primary_elem_ids, _primary_side_ids);
  std::map<dof_id_type, std::vector<Point>> secondary_qp_map =
      getLocalQuadraturePointMap(assembly, _secondary_elem_ids, _secondary_side_ids);
 
  // build mapping
  for (const auto & primary_elem_id : _primary_elem_ids)
  {
    const Elem * primary_elem = _mesh.queryElemPtr(primary_elem_id);
    // The PID check is needed to exclude ghost elements, since those don't
    // necessarily have a coupled element on this processor:
    if (primary_elem && primary_elem->processor_id() == _mesh.processor_id())
    {
      std::vector<Point> & primary_qps = primary_qp_map[primary_elem_id];
 
      const dof_id_type secondary_elem_id = getCoupledElemID(primary_elem_id);
      std::vector<Point> & secondary_qps = secondary_qp_map[secondary_elem_id];
 
      mooseAssert(primary_qps.size() == secondary_qps.size(),
                  "The numbers of quadrature points for each element must be the same");
 
      _coupled_elem_qp_indices[primary_elem_id].resize(primary_qps.size());
      KDTree kd_tree_qp(secondary_qps, _mesh.getMaxLeafSize());
      for (std::size_t i = 0; i < primary_qps.size(); i++)
      {
        unsigned int patch_size = 1;
        std::vector<std::size_t> return_index(patch_size);
        kd_tree_qp.neighborSearch(primary_qps[i], patch_size, return_index);
        _coupled_elem_qp_indices[primary_elem_id][i] = return_index[0];
      }
    }
  }
}

Referenced by FlowChannelHeatStructureCouplerUserObject::FlowChannelHeatStructureCouplerUserObject(), and HeatFluxFromHeatStructureBaseUserObject::HeatFluxFromHeatStructureBaseUserObject().

buildMapping()

void MeshAlignment::buildMapping ( )

protected

Builds the mapping using the extracted mesh information.

Definition at line 66 of file MeshAlignment.C.

{
  _meshes_are_coincident = true;
  std::vector<unsigned int> primary_elem_pairing_count(_primary_elem_ids.size(), 0);
 
  // Build the element mapping
  if (_primary_elem_points.size() > 0 && _secondary_elem_points.size() > 0)
  {
    // find the primary elements that are nearest to the secondary elements
    KDTree kd_tree(_primary_elem_points, _mesh.getMaxLeafSize());
    for (std::size_t i_secondary = 0; i_secondary < _secondary_elem_points.size(); i_secondary++)
    {
      unsigned int patch_size = 1;
      std::vector<std::size_t> return_index(patch_size);
      kd_tree.neighborSearch(_secondary_elem_points[i_secondary], patch_size, return_index);
      const std::size_t i_primary = return_index[0];
 
      // Flip flag if any pair of points are not coincident
      if (!_secondary_elem_points[i_secondary].absolute_fuzzy_equals(
              _primary_elem_points[i_primary]))
        _meshes_are_coincident = false;
 
      const auto primary_elem_id = _primary_elem_ids[i_primary];
      const auto secondary_elem_id = _secondary_elem_ids[i_secondary];
 
      _coupled_elem_ids.insert({primary_elem_id, secondary_elem_id});
      _coupled_elem_ids.insert({secondary_elem_id, primary_elem_id});
 
      primary_elem_pairing_count[i_primary]++;
    }
  }
 
  // Build the node mapping
  Point reference_translation_vector;
  _meshes_have_same_translation = true;
  if (_primary_node_points.size() > 0 && _secondary_node_points.size() > 0)
  {
    // find the primary nodes that are nearest to the secondary nodes
    KDTree kd_tree(_primary_node_points, _mesh.getMaxLeafSize());
    for (std::size_t i_secondary = 0; i_secondary < _secondary_node_points.size(); i_secondary++)
    {
      unsigned int patch_size = 1;
      std::vector<std::size_t> return_index(patch_size);
      kd_tree.neighborSearch(_secondary_node_points[i_secondary], patch_size, return_index);
      const std::size_t i_primary = return_index[0];
 
      const Point translation_vector =
          _primary_node_points[i_primary] - _secondary_node_points[i_secondary];
 
      if (i_secondary == 0)
        reference_translation_vector = translation_vector;
      else
      {
        if (!MooseUtils::absoluteFuzzyEqual(
                (reference_translation_vector - translation_vector).norm(), 0))
          _meshes_have_same_translation = false;
      }
 
      const auto primary_node_id = _primary_node_ids[i_primary];
      const auto secondary_node_id = _secondary_node_ids[i_secondary];
 
      _coupled_node_ids.insert({primary_node_id, secondary_node_id});
      _coupled_node_ids.insert({secondary_node_id, primary_node_id});
    }
 
    if (_meshes_have_same_translation &&
        MooseUtils::absoluteFuzzyEqual(reference_translation_vector.norm(), 0))
      _meshes_are_coincident = true;
    else
      _meshes_are_coincident = false;
 
    // Check if meshes are aligned
    if (_require_same_translation)
      _meshes_are_aligned = _meshes_have_same_translation;
    else
    {
      // Else require that all primary boundary elements have exactly one pairing
      _meshes_are_aligned = true;
      for (std::size_t i_primary = 0; i_primary < _primary_elem_ids.size(); i_primary++)
        if (primary_elem_pairing_count[i_primary] != 1)
          _meshes_are_aligned = false;
    }
  }
}

Referenced by initialize(), and initialize().

extractFrom1DElements()

void MeshAlignmentBase::extractFrom1DElements ( const std::vector< dof_id_type > &  elem_ids, std::vector< Point > &  elem_points, std::vector< dof_id_type > &  node_ids, std::vector< Point > &  node_points  ) const

protectedinherited

Extracts mesh information from 1D elements.

Parameters

[in]	elem_ids	Vector of element IDs
[out]	elem_points	Vector of element centroids
[out]	node_ids	Vector of node IDs
[out]	node_points	Vector of node points

Definition at line 20 of file MeshAlignmentBase.C.

{
  elem_points.clear();
  node_ids.clear();
  node_points.clear();
 
  for (const auto & elem_id : elem_ids)
  {
    const Elem * elem = _mesh.elemPtr(elem_id);
    elem_points.push_back(elem->vertex_average());
 
    for (const auto j : elem->node_index_range())
    {
      const Node & node = elem->node_ref(j);
      const auto node_id = node.id();
      if (std::find(node_ids.begin(), node_ids.end(), node_id) == node_ids.end())
      {
        node_ids.push_back(node_id);
        node_points.push_back(node);
      }
    }
  }
}

Referenced by initialize(), and MeshAlignment1D3D::initialize().

extractFromBoundaryInfo()

void MeshAlignmentBase::extractFromBoundaryInfo ( const std::vector< std::tuple< dof_id_type, unsigned short int > > &  boundary_info, std::vector< dof_id_type > &  elem_ids, std::vector< unsigned short int > &  side_ids, std::vector< Point > &  side_points, std::vector< dof_id_type > &  node_ids, std::vector< Point > &  node_points  ) const

protectedinherited

Extracts mesh information from boundary info.

Parameters

[in]	boundary_info	Vector of tuples of element ID and side ID on boundary
[out]	elem_ids	Vector of element IDs
[out]	side_ids	Vector of side IDs
[out]	side_points	Vector of side centroids
[out]	node_ids	Vector of node IDs
[out]	node_points	Vector of node points

Definition at line 48 of file MeshAlignmentBase.C.

{
  elem_ids.clear();
  side_ids.clear();
  side_points.clear();
  node_ids.clear();
  node_points.clear();
 
  for (const auto & elem_id_and_side : boundary_info)
  {
    auto elem_id = std::get<0>(elem_id_and_side);
    elem_ids.push_back(elem_id);
 
    auto side = std::get<1>(elem_id_and_side);
    side_ids.push_back(side);
 
    const Elem * elem = _mesh.elemPtr(elem_id);
    const Elem * side_elem = elem->build_side_ptr(side).release();
    const Point side_center = side_elem->vertex_average();
    side_points.push_back(side_center);
 
    for (const auto j : side_elem->node_index_range())
    {
      const Node & node = side_elem->node_ref(j);
      const auto node_id = node.id();
      if (std::find(node_ids.begin(), node_ids.end(), node_id) == node_ids.end())
      {
        node_ids.push_back(node_id);
        node_points.push_back(node);
      }
    }
    delete side_elem;
  }
}

Referenced by initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

getCoupledElemID()

const dof_id_type & MeshAlignment::getCoupledElemID

(

const dof_id_type &

elem_id

)

const

Gets the coupled element ID for a given element ID.

Parameters

[in]

elem_id

Element ID for which to find the coupled element ID

Definition at line 230 of file MeshAlignment.C.

{
  mooseAssert(hasCoupledElemID(elem_id), "The element ID has no coupled element.");
  return _coupled_elem_ids.find(elem_id)->second;
}

Referenced by buildCoupledElemQpIndexMap(), FlowChannelHeatStructureCouplerUserObject::execute(), HeatFluxFromHeatStructureBaseUserObject::execute(), FlowChannelHeatStructureCouplerUserObject::getNearestElem(), HeatFluxFromHeatStructureBaseUserObject::getNearestElem(), HeatStructure2DCouplerBase::setupMesh(), and HeatTransferFromHeatStructure1Phase::setupMesh().

getCoupledElemQpIndex()

unsigned int MeshAlignment::getCoupledElemQpIndex	(	const dof_id_type &	elem_id,
		const unsigned int &	qp
	)		const

Gets the quadrature point index on the coupled element corresponding to the quadrature point index on the provided primary element.

Only local elements on the primary mesh may be queried.

Parameters

[in]	elem_id	Element ID for which to find the coupled quadrature point
[in]	qp	Quadrature point index on the given element

Definition at line 250 of file MeshAlignment.C.

{
  auto it = _coupled_elem_qp_indices.find(elem_id);
  mooseAssert(it != _coupled_elem_qp_indices.end(),
              "The element ID has no coupled quadrature point indices.");
  mooseAssert(qp < it->second.size(), "The quadrature index does not exist in the map.");
  return it->second[qp];
}

Referenced by FlowChannelHeatStructureCouplerUserObject::execute(), and HeatFluxFromHeatStructureBaseUserObject::execute().

getCoupledNodeID()

const dof_id_type & MeshAlignment::getCoupledNodeID

(

const dof_id_type &

node_id

)

const

Gets the coupled node ID for a given node ID.

Parameters

[in]

node_id

Node ID for which to find the coupled node ID

Definition at line 243 of file MeshAlignment.C.

{
  mooseAssert(hasCoupledNodeID(node_id), "The node ID has no coupled node.");
  return _coupled_node_ids.find(node_id)->second;
}

Referenced by HeatStructure2DCouplerBCBase::computeCoupledTemperature(), and MeshAlignmentVariableTransferMaterial::computeProperties().

getLocalQuadraturePointMap()

std::map< dof_id_type, std::vector< Point > > MeshAlignment::getLocalQuadraturePointMap ( Assembly &  assembly, const std::vector< dof_id_type > &  elem_ids, const std::vector< unsigned short int > &  side_ids  ) const

protected

Gets the local quadrature point map for the primary or secondary side.

Parameters

[in]	assembly	Assembly
[in]	elem_ids	Vector of element IDs
[in]	side_ids	Vector of side IDs (if any)

Definition at line 190 of file MeshAlignment.C.

{
  std::map<dof_id_type, std::vector<Point>> elem_id_to_qps;
  for (unsigned int i = 0; i < elem_ids.size(); i++)
  {
    const auto elem_id = elem_ids[i];
    const Elem * elem = _mesh.queryElemPtr(elem_id);
    if (elem)
    {
      assembly.setCurrentSubdomainID(elem->subdomain_id());
 
      MooseArray<Point> q_points;
      if (side_ids.size() > 0)
      {
        assembly.reinit(elem, side_ids[i]);
        q_points = assembly.qPointsFace();
      }
      else
      {
        assembly.reinit(elem);
        q_points = assembly.qPoints();
      }
 
      for (std::size_t i = 0; i < q_points.size(); i++)
        elem_id_to_qps[elem_id].push_back(q_points[i]);
    }
  }
 
  return elem_id_to_qps;
}

Referenced by buildCoupledElemQpIndexMap().

getPrimaryElemIDs()

const std::vector< dof_id_type > & MeshAlignmentBase::getPrimaryElemIDs ( ) const

inlineinherited

Returns the list of element IDs on the primary boundary.

Definition at line 34 of file MeshAlignmentBase.h.

{ return _primary_elem_ids; }

Referenced by HeatStructure2DCouplerBase::setupMesh(), HeatTransferFromHeatStructure1Phase::setupMesh(), and HSCoupler2D2DRadiation::setupMesh().

getSecondaryElemIDs()

const std::vector< dof_id_type > & MeshAlignmentBase::getSecondaryElemIDs ( ) const

inlineinherited

Returns the list of element IDs on the secondary boundary.

Definition at line 39 of file MeshAlignmentBase.h.

{ return _secondary_elem_ids; }

Referenced by HSCoupler2D3D::setupMesh().

hasCoupledElemID()

bool MeshAlignment::hasCoupledElemID

(

const dof_id_type &

elem_id

)

const

Returns true if the element ID has a coupled element ID.

Parameters

[in]

elem_id

Element ID for which to find the coupled element ID

Definition at line 224 of file MeshAlignment.C.

{
  return _coupled_elem_ids.find(elem_id) != _coupled_elem_ids.end();
}

Referenced by getCoupledElemID(), HeatStructure2DCouplerBase::setupMesh(), and HeatTransferFromHeatStructure1Phase::setupMesh().

hasCoupledNodeID()

bool MeshAlignment::hasCoupledNodeID

(

const dof_id_type &

node_id

)

const

Returns true if the node ID has a coupled node ID.

Parameters

[in]

node_id

Node ID for which to find the coupled node ID

Definition at line 237 of file MeshAlignment.C.

{
  return _coupled_node_ids.find(node_id) != _coupled_node_ids.end();
}

Referenced by HeatStructure2DCouplerBCBase::computeCoupledTemperature(), and getCoupledNodeID().

initialize() [1/2]

void MeshAlignment::initialize	(	const std::vector< dof_id_type > &	primary_elem_ids,
		const std::vector< std::tuple< dof_id_type, unsigned short int > > &	secondary_boundary_info
	)

Extracts mesh information and builds the mapping.

This version is for 1D elements coupled to a 2D boundary.

Parameters

primary_elem_ids[in]	List of primary element IDs
secondary_boundary_info[in]	List of tuples (elem_id, side_id) of the secondary side

Definition at line 25 of file MeshAlignment.C.

{
  _primary_elem_ids = primary_elem_ids;
  extractFrom1DElements(
      _primary_elem_ids, _primary_elem_points, _primary_node_ids, _primary_node_points);
 
  extractFromBoundaryInfo(secondary_boundary_info,
                          _secondary_elem_ids,
                          _secondary_side_ids,
                          _secondary_elem_points,
                          _secondary_node_ids,
                          _secondary_node_points);
 
  buildMapping();
}

Referenced by HeatStructure2DCouplerBase::setupMesh(), and HeatTransferFromHeatStructure1Phase::setupMesh().

initialize() [2/2]

void MeshAlignment::initialize	(	const std::vector< std::tuple< dof_id_type, unsigned short int > > &	primary_boundary_info,
		const std::vector< std::tuple< dof_id_type, unsigned short int > > &	secondary_boundary_info
	)

Extracts mesh information and builds the mapping.

This version is for a 2D boundary coupled to another 2D boundary.

Parameters

primary_boundary_info[in]	List of tuples (elem_id, side_id) of the primary side
secondary_boundary_info[in]	List of tuples (elem_id, side_id) of the secondary side

Definition at line 44 of file MeshAlignment.C.

{
  extractFromBoundaryInfo(primary_boundary_info,
                          _primary_elem_ids,
                          _primary_side_ids,
                          _primary_elem_points,
                          _primary_node_ids,
                          _primary_node_points);
 
  extractFromBoundaryInfo(secondary_boundary_info,
                          _secondary_elem_ids,
                          _secondary_side_ids,
                          _secondary_elem_points,
                          _secondary_node_ids,
                          _secondary_node_points);
 
  buildMapping();
}

meshesAreAligned()

bool MeshAlignmentBase::meshesAreAligned ( ) const

inlineinherited

Returns true if the primary and secondary meshes are aligned.

Definition at line 44 of file MeshAlignmentBase.h.

{ return _meshes_are_aligned; }

Referenced by HeatStructure2DCoupler::check(), HeatStructure2DRadiationCouplerRZ::check(), HSCoupler2D2DRadiation::check(), HSCoupler2D3D::check(), HeatStructure2DCouplerBase::setupMesh(), HeatTransferFromHeatStructure1Phase::setupMesh(), HSCoupler2D2DRadiation::setupMesh(), and HSCoupler2D3D::setupMesh().

meshesAreCoincident()

bool MeshAlignment::meshesAreCoincident ( ) const

inline

Returns true if the primary and secondary meshes are coincident.

Definition at line 73 of file MeshAlignment.h.

{ return _meshes_are_coincident; }

Member Data Documentation

_coupled_elem_ids

std::map<dof_id_type, dof_id_type> MeshAlignment::_coupled_elem_ids

protected

Map of element ID to coupled element ID.

Definition at line 133 of file MeshAlignment.h.

Referenced by buildMapping(), getCoupledElemID(), and hasCoupledElemID().

_coupled_elem_qp_indices

std::map<dof_id_type, std::vector<unsigned int> > MeshAlignment::_coupled_elem_qp_indices

protected

Map of element ID to vector of coupled quadrature points.

Definition at line 137 of file MeshAlignment.h.

Referenced by buildCoupledElemQpIndexMap(), and getCoupledElemQpIndex().

_coupled_node_ids

std::map<dof_id_type, dof_id_type> MeshAlignment::_coupled_node_ids

protected

Map of node ID to coupled node ID.

Definition at line 135 of file MeshAlignment.h.

Referenced by buildMapping(), getCoupledNodeID(), and hasCoupledNodeID().

_mesh

const MooseMesh& MeshAlignmentBase::_mesh

protectedinherited

Mesh.

Definition at line 79 of file MeshAlignmentBase.h.

Referenced by buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentBase::extractFrom1DElements(), MeshAlignmentBase::extractFromBoundaryInfo(), and getLocalQuadraturePointMap().

_meshes_are_aligned

bool MeshAlignmentBase::_meshes_are_aligned

protectedinherited

Flag that meshes are aligned.

Definition at line 105 of file MeshAlignmentBase.h.

Referenced by buildMapping(), MeshAlignmentOneToMany::checkAlignment(), and MeshAlignmentBase::meshesAreAligned().

_meshes_are_coincident

bool MeshAlignment::_meshes_are_coincident

protected

Flag that meshes are coincident.

Definition at line 142 of file MeshAlignment.h.

Referenced by buildMapping(), and meshesAreCoincident().

_meshes_have_same_translation

bool MeshAlignment::_meshes_have_same_translation

protected

Flag that each pairing has the same translation vector.

Definition at line 144 of file MeshAlignment.h.

Referenced by buildMapping().

_primary_elem_ids

std::vector<dof_id_type> MeshAlignmentBase::_primary_elem_ids

protectedinherited

List of primary element IDs.

Definition at line 82 of file MeshAlignmentBase.h.

Referenced by buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignmentBase::getPrimaryElemIDs(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_primary_elem_points

std::vector<Point> MeshAlignmentBase::_primary_elem_points

protectedinherited

List of primary element points.

Definition at line 86 of file MeshAlignmentBase.h.

Referenced by buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_primary_node_ids

std::vector<dof_id_type> MeshAlignmentBase::_primary_node_ids

protectedinherited

List of primary node IDs.

Definition at line 96 of file MeshAlignmentBase.h.

Referenced by buildMapping(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_primary_node_points

std::vector<Point> MeshAlignmentBase::_primary_node_points

protectedinherited

List of primary node points.

Definition at line 100 of file MeshAlignmentBase.h.

Referenced by buildMapping(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_primary_side_ids

std::vector<unsigned short int> MeshAlignmentBase::_primary_side_ids

protectedinherited

List of primary side IDs (if any)

Definition at line 91 of file MeshAlignmentBase.h.

Referenced by buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_require_same_translation

const bool MeshAlignment::_require_same_translation

protected

Flag that alignment requires that pairings have same translation vector.

Definition at line 140 of file MeshAlignment.h.

Referenced by buildMapping().

_secondary_elem_ids

std::vector<dof_id_type> MeshAlignmentBase::_secondary_elem_ids

protectedinherited

List of secondary element IDs.

Definition at line 84 of file MeshAlignmentBase.h.

Referenced by buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignmentBase::getSecondaryElemIDs(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_secondary_elem_points

std::vector<Point> MeshAlignmentBase::_secondary_elem_points

protectedinherited

List of secondary element points.

Definition at line 88 of file MeshAlignmentBase.h.

Referenced by buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_secondary_node_ids

std::vector<dof_id_type> MeshAlignmentBase::_secondary_node_ids

protectedinherited

List of secondary node IDs.

Definition at line 98 of file MeshAlignmentBase.h.

Referenced by buildMapping(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_secondary_node_points

std::vector<Point> MeshAlignmentBase::_secondary_node_points

protectedinherited

List of secondary node points.

Definition at line 102 of file MeshAlignmentBase.h.

Referenced by buildMapping(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

_secondary_side_ids

std::vector<unsigned short int> MeshAlignmentBase::_secondary_side_ids

protectedinherited

List of secondary side IDs (if any)

Definition at line 93 of file MeshAlignmentBase.h.

Referenced by buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), initialize(), MeshAlignment1D3D::initialize(), initialize(), MeshAlignment2D3D::initialize(), and MeshAlignment2D2D::initialize().

---

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

• thermal_hydraulics/include/utils/MeshAlignment.h
• thermal_hydraulics/src/utils/MeshAlignment.C