MeshAlignment2D2D Class Reference

Builds mapping between multiple 2D boundaries. More...

#include <MeshAlignment2D2D.h>

Inheritance diagram for MeshAlignment2D2D:

Public Member Functions
	MeshAlignment2D2D (const MooseMesh &mesh)
	Constructor.
void	initialize (const std::vector< std::vector< std::tuple< dof_id_type, unsigned short int > > > &boundary_infos, const Point &axis_point, const RealVectorValue &axis_direction)
	Extracts mesh information and builds the mapping.
bool	hasCoupledPrimaryElemID (const dof_id_type &secondary_elem_id) const
	Returns true if the given secondary element ID has a coupled primary element.
dof_id_type	getCoupledPrimaryElemID (const dof_id_type &secondary_elem_id) const
	Gets the coupled primary element ID for a given secondary element ID.
bool	hasCoupledSecondaryElemIDs (const dof_id_type &primary_elem_id) const
	Returns true if the given primary element ID has coupled secondary elements.
const std::vector< dof_id_type > &	getCoupledSecondaryElemIDs (const dof_id_type &primary_elem_id) const
	Gets the coupled secondary element IDs for a given primary element ID.
unsigned int	getPrimaryNumberOfQuadraturePoints () const
	Gets the number of quadrature points for faces on the primary boundary.
unsigned int	getSecondaryNumberOfQuadraturePoints () const
	Gets the number of quadrature points for faces on the secondary boundary.
unsigned int	getCoupledPrimaryElemQpIndex (const dof_id_type &secondary_elem_id, const unsigned int &secondary_qp) const
	Gets the quadrature point index on the primary element corresponding to the quadrature point index on the provided secondary element.
unsigned int	getMaxCouplingSize () const
	Gets the maximum number of secondary elements coupled to any 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.
void	checkAlignment (const Point &axis_point, const RealVectorValue &axis_direction)
	Checks the alignment and sets _mesh_alignment accordingly.
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, std::vector< dof_id_type > >	_primary_elem_id_to_secondary_elem_ids
	Map of primary element ID to coupled secondary element IDs.
std::map< dof_id_type, dof_id_type >	_secondary_elem_id_to_primary_elem_id
	Map of secondary element ID to coupled primary element ID.
std::map< dof_id_type, std::vector< unsigned int > >	_secondary_elem_id_to_qp_indices
	Map of secondary element ID to vector of coupled quadrature points.
unsigned int	_n_qp_primary
	Number of quadrature points for faces on the primary boundary.
unsigned int	_n_qp_secondary
	Number of quadrature points for faces on the secondary boundary.
unsigned long	_max_coupling_size
	The maximum number of secondary elements coupled to any primary element.
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 multiple 2D boundaries.

Definition at line 19 of file MeshAlignment2D2D.h.

Constructor & Destructor Documentation

MeshAlignment2D2D()

MeshAlignment2D2D::MeshAlignment2D2D

(

const MooseMesh &

mesh

)

Constructor.

Parameters

mesh[in]

mesh Mesh

Definition at line 12 of file MeshAlignment2D2D.C.

: MeshAlignmentOneToMany(mesh) {}

Member Function Documentation

buildMapping()

void MeshAlignmentOneToMany::buildMapping ( )

protectedinherited

Builds the mapping using the extracted mesh information.

Definition at line 20 of file MeshAlignmentOneToMany.C.

{
  // 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];
 
      const auto primary_elem_id = _primary_elem_ids[i_primary];
      const auto secondary_elem_id = _secondary_elem_ids[i_secondary];
 
      _secondary_elem_id_to_primary_elem_id[secondary_elem_id] = primary_elem_id;
 
      auto it = _primary_elem_id_to_secondary_elem_ids.find(primary_elem_id);
      if (it == _primary_elem_id_to_secondary_elem_ids.end())
        _primary_elem_id_to_secondary_elem_ids.insert({primary_elem_id, {secondary_elem_id}});
      else
        it->second.push_back(secondary_elem_id);
    }
 
    // Determine max coupling size
    for (const auto primary_elem_id : _primary_elem_ids)
      if (hasCoupledSecondaryElemIDs(primary_elem_id))
      {
        const auto & secondary_elem_ids = getCoupledSecondaryElemIDs(primary_elem_id);
        _max_coupling_size = std::max(secondary_elem_ids.size(), _max_coupling_size);
      }
  }
}

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

checkAlignment()

void MeshAlignmentOneToMany::checkAlignment ( const Point &  axis_point, const RealVectorValue &  axis_direction  )

protectedinherited

Checks the alignment and sets _mesh_alignment accordingly.

Parameters

[in]	axis_point	Any point on the axis of the 1D or 2D boundary
[in]	axis_direction	Direction of the axis for the 1D or 2D boundary

Definition at line 57 of file MeshAlignmentOneToMany.C.

{
  if (_primary_elem_points.size() > 0 && _secondary_elem_points.size() > 0)
  {
    // Check if meshes are aligned: all secondary boundary faces paired to a
    // primary element/face must have the same axial coordinate.
    _meshes_are_aligned = true;
    for (const auto i_primary : index_range(_primary_elem_ids))
    {
      const auto primary_elem_id = _primary_elem_ids[i_primary];
      const auto primary_elem_point = _primary_elem_points[i_primary];
      const auto primary_ax_coord = axis_direction * (primary_elem_point - axis_point);
 
      if (hasCoupledSecondaryElemIDs(primary_elem_id))
      {
        const auto & secondary_elem_ids = getCoupledSecondaryElemIDs(primary_elem_id);
        for (const auto secondary_elem_id : secondary_elem_ids)
        {
          auto it =
              std::find(_secondary_elem_ids.begin(), _secondary_elem_ids.end(), secondary_elem_id);
          const auto i_secondary = std::distance(_secondary_elem_ids.begin(), it);
          const auto secondary_elem_point = _secondary_elem_points[i_secondary];
          const auto secondary_ax_coord = axis_direction * (secondary_elem_point - axis_point);
          if (!MooseUtils::absoluteFuzzyEqual(secondary_ax_coord, primary_ax_coord))
            _meshes_are_aligned = false;
        }
      }
      else
        _meshes_are_aligned = false;
    }
  }
}

Referenced by MeshAlignment2D3D::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 MeshAlignment::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 MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and initialize().

getCoupledPrimaryElemID()

dof_id_type MeshAlignmentOneToMany::getCoupledPrimaryElemID ( const dof_id_type &  secondary_elem_id ) const

inherited

Gets the coupled primary element ID for a given secondary element ID.

Parameters

[in]

secondary_elem_id

Secondary element ID for which to find the coupled primary element ID

Definition at line 99 of file MeshAlignmentOneToMany.C.

{
  mooseAssert(hasCoupledPrimaryElemID(secondary_elem_id),
              "The element ID has no coupled elements.");
  return _secondary_elem_id_to_primary_elem_id.find(secondary_elem_id)->second;
}

Referenced by MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), HSCoupler2D3DUserObject::execute(), and HSCoupler2D3D::setupMesh().

getCoupledPrimaryElemQpIndex()

unsigned int MeshAlignmentOneToMany::getCoupledPrimaryElemQpIndex ( const dof_id_type &  secondary_elem_id, const unsigned int &  secondary_qp  ) const

inherited

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

Only secondary elements corresponding to local primary elements may be queried.

Parameters

[in]	secondary_elem_id	Secondary element ID for which to find the coupled quadrature point
[in]	secondary_qp	Quadrature point index on the given secondary element

Definition at line 122 of file MeshAlignmentOneToMany.C.

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

Referenced by ADHeatTransferFromHeatStructure3D1PhaseUserObject::execute(), and HSCoupler2D3DUserObject::execute().

getCoupledSecondaryElemIDs()

const std::vector< dof_id_type > & MeshAlignmentOneToMany::getCoupledSecondaryElemIDs ( const dof_id_type &  primary_elem_id ) const

inherited

Gets the coupled secondary element IDs for a given primary element ID.

Parameters

[in]

primary_elem_id

Primary element ID for which to find the coupled secondary element IDs

Definition at line 114 of file MeshAlignmentOneToMany.C.

{
  mooseAssert(hasCoupledSecondaryElemIDs(primary_elem_id),
              "The element ID has no coupled elements.");
  return _primary_elem_id_to_secondary_elem_ids.find(primary_elem_id)->second;
}

Referenced by MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), ADHeatTransferFromHeatStructure3D1PhaseUserObject::execute(), HSCoupler2D2DRadiationUserObject::execute(), HeatTransferFromHeatStructure3D1Phase::setupMesh(), and HSCoupler2D2DRadiation::setupMesh().

getMaxCouplingSize()

unsigned int MeshAlignmentOneToMany::getMaxCouplingSize ( ) const

inlineinherited

Gets the maximum number of secondary elements coupled to any primary element.

Definition at line 88 of file MeshAlignmentOneToMany.h.

{ return _max_coupling_size; }

Referenced by HSCoupler2D3D::check().

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().

getPrimaryNumberOfQuadraturePoints()

unsigned int MeshAlignmentOneToMany::getPrimaryNumberOfQuadraturePoints ( ) const

inlineinherited

Gets the number of quadrature points for faces on the primary boundary.

Definition at line 65 of file MeshAlignmentOneToMany.h.

{ return _n_qp_primary; }

Referenced by HSCoupler2D3DUserObject::execute().

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().

getSecondaryNumberOfQuadraturePoints()

unsigned int MeshAlignmentOneToMany::getSecondaryNumberOfQuadraturePoints ( ) const

inlineinherited

Gets the number of quadrature points for faces on the secondary boundary.

Definition at line 70 of file MeshAlignmentOneToMany.h.

{ return _n_qp_secondary; }

Referenced by ADHeatTransferFromHeatStructure3D1PhaseUserObject::execute().

hasCoupledPrimaryElemID()

bool MeshAlignmentOneToMany::hasCoupledPrimaryElemID ( const dof_id_type &  secondary_elem_id ) const

inherited

Returns true if the given secondary element ID has a coupled primary element.

Parameters

[in]

secondary_elem_id

Secondary element ID for which to find the coupled primary element ID

Definition at line 92 of file MeshAlignmentOneToMany.C.

{
  return _secondary_elem_id_to_primary_elem_id.find(secondary_elem_id) !=
         _secondary_elem_id_to_primary_elem_id.end();
}

Referenced by MeshAlignmentOneToMany::getCoupledPrimaryElemID(), and HSCoupler2D3D::setupMesh().

hasCoupledSecondaryElemIDs()

bool MeshAlignmentOneToMany::hasCoupledSecondaryElemIDs ( const dof_id_type &  primary_elem_id ) const

inherited

Returns true if the given primary element ID has coupled secondary elements.

Parameters

[in]

primary_elem_id

Primary element ID for which to find the coupled secondary element IDs

Definition at line 107 of file MeshAlignmentOneToMany.C.

{
  return _primary_elem_id_to_secondary_elem_ids.find(primary_elem_id) !=
         _primary_elem_id_to_secondary_elem_ids.end();
}

Referenced by MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignmentOneToMany::getCoupledSecondaryElemIDs(), and HeatTransferFromHeatStructure3D1Phase::setupMesh().

initialize()

void MeshAlignment2D2D::initialize	(	const std::vector< std::vector< std::tuple< dof_id_type, unsigned short int > > > &	boundary_infos,
		const Point &	axis_point,
		const RealVectorValue &	axis_direction
	)

Extracts mesh information and builds the mapping.

Parameters

[in]	boundary_infos	List of tuples (elem_id, side_id) for each side
[in]	axis_point	Any point on the axis of the 1D or 2D boundary
[in]	axis_direction	Direction of the axis for the 1D or 2D boundary

Definition at line 15 of file MeshAlignment2D2D.C.

{
  const auto n_boundaries = boundary_infos.size();
  if (n_boundaries > 1)
  {
    extractFromBoundaryInfo(boundary_infos[0],
                            _primary_elem_ids,
                            _primary_side_ids,
                            _primary_elem_points,
                            _primary_node_ids,
                            _primary_node_points);
 
    for (unsigned int i = 1; i < n_boundaries; ++i)
    {
      std::vector<dof_id_type> elem_ids;
      std::vector<unsigned short int> side_ids;
      std::vector<dof_id_type> node_ids;
      std::vector<Point> elem_points;
      std::vector<Point> node_points;
      extractFromBoundaryInfo(
          boundary_infos[i], elem_ids, side_ids, elem_points, node_ids, node_points);
      _secondary_elem_ids.insert(_secondary_elem_ids.end(), elem_ids.begin(), elem_ids.end());
      _secondary_side_ids.insert(_secondary_side_ids.end(), side_ids.begin(), side_ids.end());
      _secondary_node_ids.insert(_secondary_node_ids.end(), node_ids.begin(), node_ids.end());
      _secondary_elem_points.insert(
          _secondary_elem_points.end(), elem_points.begin(), elem_points.end());
      _secondary_node_points.insert(
          _secondary_node_points.end(), node_points.begin(), node_points.end());
    }
 
    buildMapping();
    checkAlignment(axis_point, axis_direction);
  }
}

Referenced by HSCoupler2D2DRadiation::setupMesh().

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().

Member Data Documentation

_max_coupling_size

unsigned long MeshAlignmentOneToMany::_max_coupling_size

protectedinherited

The maximum number of secondary elements coupled to any primary element.

Definition at line 117 of file MeshAlignmentOneToMany.h.

Referenced by MeshAlignmentOneToMany::buildMapping(), and MeshAlignmentOneToMany::getMaxCouplingSize().

_mesh

const MooseMesh& MeshAlignmentBase::_mesh

protectedinherited

Mesh.

Definition at line 79 of file MeshAlignmentBase.h.

Referenced by MeshAlignment::buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), MeshAlignment::buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentBase::extractFrom1DElements(), MeshAlignmentBase::extractFromBoundaryInfo(), and MeshAlignment::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 MeshAlignment::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), and MeshAlignmentBase::meshesAreAligned().

_n_qp_primary

unsigned int MeshAlignmentOneToMany::_n_qp_primary

protectedinherited

Number of quadrature points for faces on the primary boundary.

Definition at line 112 of file MeshAlignmentOneToMany.h.

Referenced by MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), and MeshAlignmentOneToMany::getPrimaryNumberOfQuadraturePoints().

_n_qp_secondary

unsigned int MeshAlignmentOneToMany::_n_qp_secondary

protectedinherited

Number of quadrature points for faces on the secondary boundary.

Definition at line 114 of file MeshAlignmentOneToMany.h.

Referenced by MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), and MeshAlignmentOneToMany::getSecondaryNumberOfQuadraturePoints().

_primary_elem_id_to_secondary_elem_ids

std::map<dof_id_type, std::vector<dof_id_type> > MeshAlignmentOneToMany::_primary_elem_id_to_secondary_elem_ids

protectedinherited

Map of primary element ID to coupled secondary element IDs.

Definition at line 105 of file MeshAlignmentOneToMany.h.

Referenced by MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::getCoupledSecondaryElemIDs(), and MeshAlignmentOneToMany::hasCoupledSecondaryElemIDs().

_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 MeshAlignment::buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), MeshAlignment::buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignmentBase::getPrimaryElemIDs(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildMapping(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildMapping(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and initialize().

_secondary_elem_id_to_primary_elem_id

std::map<dof_id_type, dof_id_type> MeshAlignmentOneToMany::_secondary_elem_id_to_primary_elem_id

protectedinherited

Map of secondary element ID to coupled primary element ID.

Definition at line 107 of file MeshAlignmentOneToMany.h.

Referenced by MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::getCoupledPrimaryElemID(), and MeshAlignmentOneToMany::hasCoupledPrimaryElemID().

_secondary_elem_id_to_qp_indices

std::map<dof_id_type, std::vector<unsigned int> > MeshAlignmentOneToMany::_secondary_elem_id_to_qp_indices

protectedinherited

Map of secondary element ID to vector of coupled quadrature points.

Definition at line 109 of file MeshAlignmentOneToMany.h.

Referenced by MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), and MeshAlignmentOneToMany::getCoupledPrimaryElemQpIndex().

_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 MeshAlignment::buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), MeshAlignment::buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignmentBase::getSecondaryElemIDs(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildMapping(), MeshAlignmentOneToMany::buildMapping(), MeshAlignmentOneToMany::checkAlignment(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildMapping(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildMapping(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and 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 MeshAlignment::buildCoupledElemQpIndexMap(), MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary(), MeshAlignment::initialize(), MeshAlignment1D3D::initialize(), MeshAlignment::initialize(), MeshAlignment2D3D::initialize(), and initialize().

---

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

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