MeshAlignment2D3D Class Reference

Builds mapping between a 2D boundary and a 3D boundary. More...

#include <MeshAlignment2D3D.h>

Inheritance diagram for MeshAlignment2D3D:

Public Member Functions
	MeshAlignment2D3D (const MooseMesh &mesh)
	Constructor. More...
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, const Point &axis_point, const RealVectorValue &axis_direction)
	Extracts mesh information and builds the mapping. More...
void	buildCoupledElemQpIndexMapSecondary (Assembly &assembly)
	Builds the map used for getting the coupled quadrature point index. More...
const std::vector< Real > &	getPrimaryArea (const dof_id_type primary_elem_id) const
	Gets the area for each quadrature point on a primary element. More...
bool	hasCoupledPrimaryElemID (const dof_id_type &secondary_elem_id) const
	Returns true if the given secondary element ID has a coupled primary element. More...
dof_id_type	getCoupledPrimaryElemID (const dof_id_type &secondary_elem_id) const
	Gets the coupled primary element ID for a given secondary element ID. More...
bool	hasCoupledSecondaryElemIDs (const dof_id_type &primary_elem_id) const
	Returns true if the given primary element ID has coupled secondary elements. More...
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. More...
unsigned int	getPrimaryNumberOfQuadraturePoints () const
	Gets the number of quadrature points for faces on the primary boundary. More...
unsigned int	getSecondaryNumberOfQuadraturePoints () const
	Gets the number of quadrature points for faces on the secondary boundary. More...
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. More...
unsigned int	getMaxCouplingSize () const
	Gets the maximum number of secondary elements coupled to any primary element. More...
const std::vector< dof_id_type > &	getPrimaryElemIDs () const
	Returns the list of element IDs on the primary boundary. More...
const std::vector< dof_id_type > &	getSecondaryElemIDs () const
	Returns the list of element IDs on the secondary boundary. More...
bool	meshesAreAligned () const
	Returns true if the primary and secondary meshes are aligned. More...

Protected Member Functions
void	buildMapping ()
	Builds the mapping using the extracted mesh information. More...
void	checkAlignment (const Point &axis_point, const RealVectorValue &axis_direction)
	Checks the alignment and sets _mesh_alignment accordingly. More...
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. More...
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. More...

Protected Attributes
std::map< dof_id_type, std::vector< Real > >	_primary_elem_id_to_area
	Map of primary element ID to area for each quadrature point. More...
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. More...
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. More...
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. More...
unsigned int	_n_qp_primary
	Number of quadrature points for faces on the primary boundary. More...
unsigned int	_n_qp_secondary
	Number of quadrature points for faces on the secondary boundary. More...
unsigned long	_max_coupling_size
	The maximum number of secondary elements coupled to any primary element. More...
const MooseMesh &	_mesh
	Mesh. More...
std::vector< dof_id_type >	_primary_elem_ids
	List of primary element IDs. More...
std::vector< dof_id_type >	_secondary_elem_ids
	List of secondary element IDs. More...
std::vector< Point >	_primary_elem_points
	List of primary element points. More...
std::vector< Point >	_secondary_elem_points
	List of secondary element points. More...
std::vector< unsigned short int >	_primary_side_ids
	List of primary side IDs (if any) More...
std::vector< unsigned short int >	_secondary_side_ids
	List of secondary side IDs (if any) More...
std::vector< dof_id_type >	_primary_node_ids
	List of primary node IDs. More...
std::vector< dof_id_type >	_secondary_node_ids
	List of secondary node IDs. More...
std::vector< Point >	_primary_node_points
	List of primary node points. More...
std::vector< Point >	_secondary_node_points
	List of secondary node points. More...
bool	_meshes_are_aligned
	Flag that meshes are aligned. More...

Detailed Description

Builds mapping between a 2D boundary and a 3D boundary.

The "primary" mesh is the 2D boundary, and the "secondary" mesh is the 3D boundary.

Definition at line 21 of file MeshAlignment2D3D.h.

Constructor & Destructor Documentation

MeshAlignment2D3D()

MeshAlignment2D3D::MeshAlignment2D3D

(

const MooseMesh &

mesh

)

Constructor.

Parameters

mesh[in]

mesh Mesh

Definition at line 17 of file MeshAlignment2D3D.C.

: MeshAlignmentOneToMany(mesh) {}

Member Function Documentation

buildCoupledElemQpIndexMapSecondary()

void MeshAlignment2D3D::buildCoupledElemQpIndexMapSecondary

(

Assembly &

assembly

)

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

This method is used for coupling a 2D boundary to a 3D boundary, where the map will be used within a side user object for the 3D boundary. 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 45 of file MeshAlignment2D3D.C.

Referenced by HSCoupler2D3DUserObject::HSCoupler2D3DUserObject().

{
  for (const auto i_secondary : index_range(_secondary_elem_ids))
  {
    const auto secondary_elem_id = _secondary_elem_ids[i_secondary];
    const Elem * secondary_elem = _mesh.queryElemPtr(secondary_elem_id);
    // The PID check is needed to exclude ghost elements, since those don't
    // necessarily have a coupled element on this processor:
    if (secondary_elem && secondary_elem->processor_id() == _mesh.processor_id())
    {
      const auto secondary_side_id = _secondary_side_ids[i_secondary];
      assembly.setCurrentSubdomainID(secondary_elem->subdomain_id());
      assembly.reinit(secondary_elem, secondary_side_id);
      const auto secondary_qps = assembly.qPointsFace().stdVector();
      _n_qp_secondary = secondary_qps.size();

      const auto primary_elem_id = getCoupledPrimaryElemID(secondary_elem_id);
      auto it = std::find(_primary_elem_ids.begin(), _primary_elem_ids.end(), primary_elem_id);
      const auto i_primary = std::distance(_primary_elem_ids.begin(), it);
      const auto primary_side_id = _primary_side_ids[i_primary];

      // This element should be ghosted, so this should be safe
      const Elem * primary_elem = _mesh.elemPtr(primary_elem_id);
      assembly.setCurrentSubdomainID(primary_elem->subdomain_id());
      assembly.reinit(primary_elem, primary_side_id);
      auto primary_qps = assembly.qPointsFace().stdVector();
      _n_qp_primary = primary_qps.size();

      // compute the area for each quadrature point on the primary side
      if (_primary_elem_id_to_area.find(primary_elem_id) == _primary_elem_id_to_area.end())
      {
        const auto & JxW = assembly.JxWFace();
        const auto & coord = assembly.coordTransformation();
        std::vector<Real> area(_n_qp_primary, 0.0);
        for (unsigned int qp = 0; qp < _n_qp_primary; qp++)
          area[qp] = JxW[qp] * coord[qp];
        _primary_elem_id_to_area[primary_elem_id] = area;
      }

      _secondary_elem_id_to_qp_indices[secondary_elem_id].resize(secondary_qps.size());
      KDTree kd_tree_qp(primary_qps, _mesh.getMaxLeafSize());
      for (const auto i : index_range(secondary_qps))
      {
        unsigned int patch_size = 1;
        std::vector<std::size_t> return_index(patch_size);
        kd_tree_qp.neighborSearch(secondary_qps[i], patch_size, return_index);
        _secondary_elem_id_to_qp_indices[secondary_elem_id][i] = return_index[0];
      }
    }
  }
}

buildMapping()

void MeshAlignmentOneToMany::buildMapping ( )

protectedinherited

Builds the mapping using the extracted mesh information.

Definition at line 20 of file MeshAlignmentOneToMany.C.

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

{
  // 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);
      }
  }
}

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.

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

{
  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;
    }
  }
}

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.

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

{
  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);
      }
    }
  }
}

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.

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

{
  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;
  }
}

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.

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

{
  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;
}

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.

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

{
  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];
}

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.

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

{
  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;
}

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.

Referenced by HSCoupler2D3D::check().

{ return _max_coupling_size; }

getPrimaryArea()

const std::vector< Real > & MeshAlignment2D3D::getPrimaryArea

(

const dof_id_type

primary_elem_id

)

const

Gets the area for each quadrature point on a primary element.

Parameters

[in]

primary_elem_id

Primary element ID

Definition at line 98 of file MeshAlignment2D3D.C.

Referenced by HSCoupler2D3DUserObject::execute().

{
  auto it = _primary_elem_id_to_area.find(primary_elem_id);
  mooseAssert(it != _primary_elem_id_to_area.end(), "The element ID has no area stored.");
  return it->second;
}

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.

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

{ return _primary_elem_ids; }

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.

Referenced by HSCoupler2D3DUserObject::execute().

{ return _n_qp_primary; }

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.

Referenced by HSCoupler2D3D::setupMesh().

{ return _secondary_elem_ids; }

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.

Referenced by ADHeatTransferFromHeatStructure3D1PhaseUserObject::execute().

{ return _n_qp_secondary; }

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.

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

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

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.

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

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

initialize()

void MeshAlignment2D3D::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,
		const Point &	axis_point,
		const RealVectorValue &	axis_direction
	)

Extracts mesh information and builds the mapping.

Parameters

	secondary_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
[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 20 of file MeshAlignment2D3D.C.

Referenced by HSCoupler2D3D::setupMesh().

{
  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();
  checkAlignment(axis_point, axis_direction);
}

meshesAreAligned()

bool MeshAlignmentBase::meshesAreAligned ( ) const

inlineinherited

Returns true if the primary and secondary meshes are aligned.

Definition at line 44 of file MeshAlignmentBase.h.

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

{ return _meshes_are_aligned; }

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 MeshAlignment1D3D::buildCoupledElemQpIndexMap(), MeshAlignment::buildCoupledElemQpIndexMap(), buildCoupledElemQpIndexMapSecondary(), MeshAlignmentOneToMany::buildMapping(), MeshAlignment::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(), 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(), buildCoupledElemQpIndexMapSecondary(), and MeshAlignmentOneToMany::getSecondaryNumberOfQuadraturePoints().

_primary_elem_id_to_area

std::map<dof_id_type, std::vector<Real> > MeshAlignment2D3D::_primary_elem_id_to_area

protected

Map of primary element ID to area for each quadrature point.

Definition at line 66 of file MeshAlignment2D3D.h.

Referenced by buildCoupledElemQpIndexMapSecondary(), and getPrimaryArea().

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

---

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

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