MooseMesh.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#ifdef MOOSE_KOKKOS_ENABLED
#include "KokkosMesh.h"
#endif
 
#include "MooseObject.h"
#include "BndNode.h"
#include "BndElement.h"
#include "Restartable.h"
#include "MooseEnum.h"
#include "PerfGraphInterface.h"
#include "MooseHashing.h"
#include "MooseApp.h"
#include "FaceInfo.h"
#include "ElemInfo.h"
 
#include <memory> //std::unique_ptr
#include <filesystem>
#include <unordered_map>
#include <unordered_set>
 
// libMesh
#include "libmesh/elem_range.h"
#include "libmesh/mesh_base.h"
#include "libmesh/replicated_mesh.h"
#include "libmesh/distributed_mesh.h"
#include "libmesh/node_range.h"
#include "libmesh/nanoflann.hpp"
#include "libmesh/vector_value.h"
#include "libmesh/point.h"
#include "libmesh/partitioner.h"
 
class Assembly;
class RelationshipManager;
class MooseVariableBase;
class MooseAppCoordTransform;
class MooseUnits;
 
// libMesh forward declarations
namespace libMesh
{
class ExodusII_IO;
class QBase;
class PeriodicBoundaries;
class Partitioner;
class GhostingFunctor;
class BoundingBox;
}
// Useful typedefs
typedef libMesh::StoredRange<std::set<Node *>::iterator, Node *> SemiLocalNodeRange;
 
// List of supported geometrical elements
const std::string LIST_GEOM_ELEM = "EDGE EDGE2 EDGE3 EDGE4 "
                                   "QUAD QUAD4 QUAD8 QUAD9 "
                                   "TRI TRI3 TRI6 TRI7 "
                                   "HEX HEX8 HEX20 HEX27 "
                                   "TET TET4 TET10 TET14 "
                                   "PRISM PRISM6 PRISM15 PRISM18 "
                                   "PYRAMID PYRAMID5 PYRAMID13 PYRAMID14 "
                                   "C0POLYGON C0POLYHEDRON";
 
class QpMap
{
public:
  QpMap() : _distance(std::numeric_limits<Real>::max()) {}
 
  unsigned int _from;
 
  unsigned int _to;
 
  Real _distance;
};
 
class MooseMesh : public MooseObject, public Restartable, public PerfGraphInterface
{
public:
  static InputParameters validParams();
 
  static const std::array<bool, 3> periodic_dim_default;
 
  MooseMesh(const InputParameters & parameters);
  MooseMesh(const MooseMesh & other_mesh);
  MooseMesh() = delete;
  MooseMesh & operator=(const MooseMesh & other_mesh) = delete;
 
  virtual ~MooseMesh();
 
  // The type of libMesh::MeshBase that will be used
  enum class ParallelType
  {
    DEFAULT,
    REPLICATED,
    DISTRIBUTED
  };
 
  virtual MooseMesh & clone() const;
 
  virtual std::unique_ptr<MooseMesh> safeClone() const = 0;
 
  void determineUseDistributedMesh();
 
  std::unique_ptr<MeshBase> buildMeshBaseObject(unsigned int dim = libMesh::invalid_uint);
 
  template <typename T>
  std::unique_ptr<T> buildTypedMesh(unsigned int dim = libMesh::invalid_uint);
 
  void setMeshBase(std::unique_ptr<MeshBase> mesh_base);
 
  static MooseEnum partitioning();
 
  static MooseEnum elemTypes();
 
  virtual void init();
 
  virtual void buildMesh() = 0;
 
  virtual std::vector<std::filesystem::path>
  writeRecoveryFiles(const std::filesystem::path & file_base);
 
  virtual unsigned int dimension() const;
 
  virtual unsigned int spatialDimension() const { return _mesh->spatial_dimension(); }
 
  virtual unsigned int effectiveSpatialDimension() const;
 
  unsigned int getBlocksMaxDimension(const std::vector<SubdomainName> & blocks) const;
 
  std::vector<BoundaryID> getBoundaryIDs(const Elem * const elem,
                                         const unsigned short int side) const;
 
  std::vector<std::vector<BoundaryID>> getBoundaryIDs(const Elem * const elem) const;
 
  const Elem * getLowerDElem(const Elem *, unsigned short int) const;
 
  unsigned int getHigherDSide(const Elem * elem) const;
 
  const std::set<BoundaryID> & getBoundaryIDs() const;
 
  void buildNodeList();
  void buildBndElemList();
 
  const std::unordered_map<dof_id_type, std::vector<dof_id_type>> & nodeToElemMap();
 
  struct bnd_node_iterator;
  struct const_bnd_node_iterator;
 
  struct bnd_elem_iterator;
  struct const_bnd_elem_iterator;
 
  virtual bnd_node_iterator bndNodesBegin();
  virtual bnd_node_iterator bndNodesEnd();
 
  virtual bnd_elem_iterator bndElemsBegin();
  virtual bnd_elem_iterator bndElemsEnd();
 
  void buildNodeListFromSideList();
 
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> buildSideList();
 
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
  buildActiveSideList() const;
 
  unsigned int sideWithBoundaryID(const Elem * const elem, const BoundaryID boundary_id) const;
 
  MeshBase::node_iterator localNodesBegin();
  MeshBase::node_iterator localNodesEnd();
  MeshBase::const_node_iterator localNodesBegin() const;
  MeshBase::const_node_iterator localNodesEnd() const;
 
  MeshBase::element_iterator activeLocalElementsBegin();
  const MeshBase::element_iterator activeLocalElementsEnd();
  MeshBase::const_element_iterator activeLocalElementsBegin() const;
  const MeshBase::const_element_iterator activeLocalElementsEnd() const;
 
  virtual dof_id_type nNodes() const;
  virtual dof_id_type nElem() const;
 
  virtual dof_id_type nLocalNodes() const { return _mesh->n_local_nodes(); }
  virtual dof_id_type nActiveElem() const { return _mesh->n_active_elem(); }
  virtual dof_id_type nActiveLocalElem() const { return _mesh->n_active_local_elem(); }
  // NOTE: Expensive operation (iterates through all elements to gather subdomains)
  virtual SubdomainID nSubdomains() const { return _mesh->n_subdomains(); }
  virtual unsigned int nPartitions() const { return _mesh->n_partitions(); }
  virtual bool skipPartitioning() const { return _mesh->skip_partitioning(); }
  virtual bool skipNoncriticalPartitioning() const;
 
  virtual dof_id_type maxNodeId() const;
  virtual dof_id_type maxElemId() const;
 
  virtual const Node & node(const dof_id_type i) const;
  virtual Node & node(const dof_id_type i);
  virtual const Node & nodeRef(const dof_id_type i) const;
  virtual Node & nodeRef(const dof_id_type i);
  virtual const Node * nodePtr(const dof_id_type i) const;
  virtual Node * nodePtr(const dof_id_type i);
  virtual const Node * queryNodePtr(const dof_id_type i) const;
  virtual Node * queryNodePtr(const dof_id_type i);
 
  virtual Elem * elem(const dof_id_type i);
  virtual const Elem * elem(const dof_id_type i) const;
  virtual Elem * elemPtr(const dof_id_type i);
  virtual const Elem * elemPtr(const dof_id_type i) const;
  virtual Elem * queryElemPtr(const dof_id_type i);
  virtual const Elem * queryElemPtr(const dof_id_type i) const;
 
  bool prepared() const;
  virtual void prepared(bool state);
 
  void needsPrepareForUse();
 
  void meshChanged();
 
  virtual void onMeshChanged();
 
  void cacheChangedLists();
 
  ConstElemPointerRange * refinedElementRange() const;
 
  ConstElemPointerRange * coarsenedElementRange() const;
 
  const std::vector<const Elem *> & coarsenedElementChildren(const Elem * elem) const;
 
  void updateActiveSemiLocalNodeRange(std::set<dof_id_type> & ghosted_elems);
 
  bool isSemiLocal(Node * const node) const;
 
 
  const libMesh::ConstElemRange * getActiveLocalElementRange();
  libMesh::NodeRange * getActiveNodeRange();
  SemiLocalNodeRange * getActiveSemiLocalNodeRange() const;
  libMesh::ConstNodeRange * getLocalNodeRange();
  libMesh::StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *> *
  getBoundaryNodeRange();
  libMesh::StoredRange<MooseMesh::const_bnd_elem_iterator, const BndElement *> *
  getBoundaryElementRange();
 
  const std::unordered_map<boundary_id_type, std::unordered_set<dof_id_type>> &
  getBoundariesToElems() const;
 
  const std::unordered_map<boundary_id_type, std::unordered_set<dof_id_type>> &
  getBoundariesToActiveSemiLocalElemIds() const;
 
  std::unordered_set<dof_id_type> getBoundaryActiveSemiLocalElemIds(BoundaryID bid) const;
 
  std::unordered_set<dof_id_type> getBoundaryActiveNeighborElemIds(BoundaryID bid) const;
 
  bool isBoundaryFullyExternalToSubdomains(BoundaryID bid,
                                           const std::set<SubdomainID> & blk_group) const;
 
  const std::set<SubdomainID> & meshSubdomains() const;
 
  const std::set<BoundaryID> & meshBoundaryIds() const;
 
  const std::set<BoundaryID> & meshSidesetIds() const;
 
  const std::set<BoundaryID> & meshNodesetIds() const;
 
  void setBoundaryToNormalMap(std::unique_ptr<std::map<BoundaryID, RealVectorValue>> boundary_map);
 
  // DEPRECATED METHOD
  void setBoundaryToNormalMap(std::map<BoundaryID, RealVectorValue> * boundary_map);
 
  void setMeshBoundaryIDs(std::set<BoundaryID> boundary_IDs);
 
  const RealVectorValue & getNormalByBoundaryID(BoundaryID id) const;
 
  bool prepare(const MeshBase * mesh_to_clone);
 
  void update();
 
  unsigned int uniformRefineLevel() const;
 
  void setUniformRefineLevel(unsigned int, bool deletion = true);
 
  bool skipDeletionRepartitionAfterRefine() const;
 
  bool skipRefineWhenUseSplit() const { return _skip_refine_when_use_split; }
 
  void addGhostedBoundary(BoundaryID boundary_id);
 
  void setGhostedBoundaryInflation(const std::vector<Real> & inflation);
 
  const std::set<unsigned int> & getGhostedBoundaries() const;
 
  const std::vector<Real> & getGhostedBoundaryInflation() const;
 
  void ghostGhostedBoundaries();
 
  void needGhostGhostedBoundaries(bool needghost) { _need_ghost_ghosted_boundaries = needghost; }
 
  unsigned int getPatchSize() const;
 
  unsigned int getGhostingPatchSize() const { return _ghosting_patch_size; }
 
  unsigned int getMaxLeafSize() const { return _max_leaf_size; }
 
  void setPatchUpdateStrategy(Moose::PatchUpdateType patch_update_strategy);
 
  const Moose::PatchUpdateType & getPatchUpdateStrategy() const;
 
  libMesh::BoundingBox getInflatedProcessorBoundingBox(Real inflation_multiplier = 0.01) const;
 
  operator libMesh::MeshBase &();
  operator const libMesh::MeshBase &() const;
 
  MeshBase & getMesh();
  MeshBase & getMesh(const std::string & name);
  const MeshBase & getMesh() const;
  const MeshBase & getMesh(const std::string & name) const;
  const MeshBase * getMeshPtr() const;
 
#ifdef MOOSE_KOKKOS_ENABLED
  Moose::Kokkos::Mesh * getKokkosMesh() { return _kokkos_mesh.get(); }
  const Moose::Kokkos::Mesh * getKokkosMesh() const { return _kokkos_mesh.get(); }
#endif
 
  void printInfo(std::ostream & os = libMesh::out, const unsigned int verbosity = 0) const;
 
  const std::set<SubdomainID> & getNodeBlockIds(const Node & node) const;
 
  const std::vector<dof_id_type> & getNodeList(boundary_id_type nodeset_id) const;
 
  const Node * addUniqueNode(const Point & p, Real tol = 1e-6);
 
  Node * addQuadratureNode(const Elem * elem,
                           const unsigned short int side,
                           const unsigned int qp,
                           BoundaryID bid,
                           const Point & point);
 
  Node * getQuadratureNode(const Elem * elem, const unsigned short int side, const unsigned int qp);
 
  void clearQuadratureNodes();
 
  BoundaryID getBoundaryID(const BoundaryName & boundary_name) const;
 
  std::vector<BoundaryID> getBoundaryIDs(const std::vector<BoundaryName> & boundary_name,
                                         bool generate_unknown = false) const;
 
  SubdomainID getSubdomainID(const SubdomainName & subdomain_name) const;
 
  std::vector<SubdomainID>
  getSubdomainIDs(const std::vector<SubdomainName> & subdomain_names) const;
  std::set<SubdomainID> getSubdomainIDs(const std::set<SubdomainName> & subdomain_names) const;
 
  void setSubdomainName(SubdomainID subdomain_id, const SubdomainName & name);
 
  static void
  setSubdomainName(MeshBase & mesh, SubdomainID subdomain_id, const SubdomainName & name);
 
  const std::string & getSubdomainName(SubdomainID subdomain_id) const;
 
  std::vector<SubdomainName>
  getSubdomainNames(const std::vector<SubdomainID> & subdomain_ids) const;
 
  void setBoundaryName(BoundaryID boundary_id, BoundaryName name);
 
  const std::string & getBoundaryName(const BoundaryID boundary_id) const;
 
  std::string getBoundaryString(const BoundaryID boundary_id) const;
 
  void buildPeriodicNodeMap(std::multimap<dof_id_type, dof_id_type> & periodic_node_map,
                            unsigned int var_number,
                            libMesh::PeriodicBoundaries * pbs) const;
 
  void buildPeriodicNodeSets(std::map<BoundaryID, std::set<dof_id_type>> & periodic_node_sets,
                             unsigned int var_number,
                             libMesh::PeriodicBoundaries * pbs) const;
 
  Real dimensionWidth(unsigned int component) const;
 
 
  virtual Real getMinInDimension(unsigned int component) const;
  virtual Real getMaxInDimension(unsigned int component) const;
 
  bool detectOrthogonalDimRanges(Real tol = 1e-6);
 
  void addPeriodicVariable(const unsigned int sys_num,
                           const unsigned int var_num,
                           const BoundaryID primary,
                           const BoundaryID secondary);
 
  const std::array<bool, 3> & queryPeriodicDimensions(const unsigned int sys_num,
                                                      const unsigned int var_num) const;
  const std::array<bool, 3> & queryPeriodicDimensions(const MooseVariableBase & var) const;
 
  bool isTranslatedPeriodic(const unsigned int sys_num,
                            const unsigned int var_num,
                            const unsigned int component) const;
 
  bool isTranslatedPeriodic(const MooseVariableBase & var, const unsigned int component) const;
 
  bool isTranslatedPeriodic(const unsigned int var_num, const unsigned int component) const;
 
  RealVectorValue
  minPeriodicVector(const unsigned int sys_num, const unsigned int var_num, Point p, Point q) const;
 
  RealVectorValue
  minPeriodicVector(const MooseVariableBase & var, const Point & p, const Point & q) const;
 
  RealVectorValue
  minPeriodicVector(const unsigned int var_num, const Point & p, const Point & q) const;
 
  Real minPeriodicDistance(const unsigned int sys_num,
                           const unsigned int var_num,
                           const Point & p,
                           const Point & q) const;
 
  Real minPeriodicDistance(const MooseVariableBase & var, const Point & p, const Point & q) const;
 
  Real minPeriodicDistance(const unsigned int var_num, const Point & p, const Point & q) const;
 
  void detectPairedSidesets();
 
  bool hasDetectedPairedSidesets() const { return _paired_boundary.has_value(); }
 
  const std::pair<BoundaryID, BoundaryID> * getPairedBoundaryMapping(unsigned int component) const;
 
  void buildRefinementAndCoarseningMaps(Assembly * assembly);
 
  const std::vector<std::vector<QpMap>> &
  getRefinementMap(const Elem & elem, int parent_side, int child, int child_side);
 
  const std::vector<std::pair<unsigned int, QpMap>> & getCoarseningMap(const Elem & elem,
                                                                       int input_side);
 
  void
  changeBoundaryId(const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev);
 
  static void changeBoundaryId(MeshBase & mesh,
                               const boundary_id_type old_id,
                               const boundary_id_type new_id,
                               bool delete_prev);
 
  const std::set<BoundaryID> & getSubdomainBoundaryIds(const SubdomainID subdomain_id) const;
 
  std::set<BoundaryID> getSubdomainInterfaceBoundaryIds(const SubdomainID subdomain_id) const;
 
  std::set<SubdomainID> getBoundaryConnectedBlocks(const BoundaryID bid) const;
 
  std::set<SubdomainID> getBoundaryConnectedSecondaryBlocks(const BoundaryID bid) const;
 
  std::set<SubdomainID> getInterfaceConnectedBlocks(const BoundaryID bid) const;
 
  const std::set<SubdomainID> & getBlockConnectedBlocks(const SubdomainID subdomain_id) const;
 
  bool isBoundaryNode(dof_id_type node_id) const;
 
  bool isBoundaryNode(dof_id_type node_id, BoundaryID bnd_id) const;
 
  bool isBoundaryElem(dof_id_type elem_id) const;
 
  bool isBoundaryElem(dof_id_type elem_id, BoundaryID bnd_id) const;
 
  void errorIfDistributedMesh(std::string name) const;
 
  virtual bool isDistributedMesh() const { return _use_distributed_mesh; }
 
  bool isParallelTypeForced() const { return _parallel_type_overridden; }
 
  void setParallelType(ParallelType parallel_type);
 
  ParallelType getParallelType() const { return _parallel_type; }
 
  /*
   * Set/Get the partitioner name
   */
  const MooseEnum & partitionerName() const { return _partitioner_name; }
 
  bool isPartitionerForced() const { return _partitioner_overridden; }
 
  void allowRecovery(bool allow) { _allow_recovery = allow; }
 
  static void setPartitioner(MeshBase & mesh_base,
                             MooseEnum & partitioner,
                             bool use_distributed_mesh,
                             const InputParameters & params,
                             MooseObject & context_obj);
 
  void setCustomPartitioner(libMesh::Partitioner * partitioner);
 
 
  bool isCustomPartitionerRequested() const;
  void setIsCustomPartitionerRequested(bool cpr);
 
  bool isRegularOrthogonal() { return _regular_orthogonal_mesh; }
 
  bool hasSecondOrderElements();
 
  virtual std::unique_ptr<libMesh::PointLocatorBase> getPointLocator() const;
 
  virtual std::string getFileName() const { return ""; }
 
  using PeriodicNodeInfo = std::pair<const Node *, BoundaryID>;
 
  void needsRemoteElemDeletion(bool need_delete) { _need_delete = need_delete; }
 
  bool needsRemoteElemDeletion() const { return _need_delete; }
 
  void allowRemoteElementRemoval(bool allow_removal);
 
  bool allowRemoteElementRemoval() const { return _allow_remote_element_removal; }
 
  void deleteRemoteElements();
 
  bool hasMeshBase() const { return _mesh.get() != nullptr; }
 
  bool hasElementID(const std::string & id_name) const;
 
  unsigned int getElementIDIndex(const std::string & id_name) const;
 
  dof_id_type maxElementID(unsigned int elem_id_index) const { return _max_ids[elem_id_index]; }
 
  dof_id_type minElementID(unsigned int elem_id_index) const { return _min_ids[elem_id_index]; }
 
  bool areElemIDsIdentical(const std::string & id_name1, const std::string & id_name2) const;
 
  std::set<dof_id_type> getAllElemIDs(unsigned int elem_id_index) const;
 
  std::set<dof_id_type> getElemIDsOnBlocks(unsigned int elem_id_index,
                                           const std::set<SubdomainID> & blks) const;
 
  unsigned int getMaxSidesPerElem() const { return _max_sides_per_elem; }
 
  unsigned int getMaxNodesPerElem() const { return _max_nodes_per_elem; }
 
  unsigned int getMaxNodesPerSide() const { return _max_nodes_per_side; }
 
  std::unordered_map<dof_id_type, std::set<dof_id_type>>
  getElemIDMapping(const std::string & from_id_name, const std::string & to_id_name) const;
 
  unsigned int nFace() const { return _face_info.size(); }
 
  const std::vector<const FaceInfo *> & faceInfo() const;
 
  struct face_info_iterator;
  struct const_face_info_iterator;
 
  face_info_iterator ownedFaceInfoBegin();
  face_info_iterator ownedFaceInfoEnd();
 
  struct elem_info_iterator;
  struct const_elem_info_iterator;
 
  elem_info_iterator ownedElemInfoBegin();
  elem_info_iterator ownedElemInfoEnd();
 
  const FaceInfo * faceInfo(const Elem * elem, unsigned int side) const;
 
  const ElemInfo & elemInfo(const dof_id_type id) const;
 
  const std::vector<const ElemInfo *> & elemInfoVector() const { return _elem_info; }
 
  const std::vector<FaceInfo> & allFaceInfo() const;
 
  void cacheFaceInfoVariableOwnership() const;
 
  void cacheFVElementalDoFs() const;
 
  void computeFiniteVolumeCoords() const;
 
  void isDisplaced(bool is_displaced) { _is_displaced = is_displaced; }
 
  bool isDisplaced() const { return _is_displaced; }
 
  const std::map<boundary_id_type, std::vector<dof_id_type>> & nodeSetNodes() const;
 
  Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const;
 
  Moose::CoordinateSystemType getUniqueCoordSystem() const;
 
  const std::map<SubdomainID, Moose::CoordinateSystemType> & getCoordSystem() const;
 
  void setCoordSystem(const std::vector<SubdomainName> & blocks, const MultiMooseEnum & coord_sys);
 
  void setAxisymmetricCoordAxis(const MooseEnum & rz_coord_axis);
 
  void setGeneralAxisymmetricCoordAxes(const std::vector<SubdomainName> & blocks,
                                       const std::vector<std::pair<Point, RealVectorValue>> & axes);
 
  const std::pair<Point, RealVectorValue> &
  getGeneralAxisymmetricCoordAxis(SubdomainID subdomain_id) const;
 
  bool usingGeneralAxisymmetricCoordAxes() const;
 
  unsigned int getAxisymmetricRadialCoord() const;
 
  void checkCoordinateSystems();
 
  void setCoordData(const MooseMesh & other_mesh);
 
  void markFiniteVolumeInfoDirty() { _finite_volume_info_dirty = true; }
 
  bool isFiniteVolumeInfoDirty() const { return _finite_volume_info_dirty; }
 
  MooseAppCoordTransform & coordTransform();
 
  const MooseUnits & lengthUnit() const;
 
  const std::unordered_map<std::pair<const Elem *, unsigned short int>, const Elem *> &
  getLowerDElemMap() const;
 
  bool isSplit() const { return _is_split; }
 
  void buildFiniteVolumeInfo() const;
 
  void setupFiniteVolumeMeshData() const;
 
  void doingPRefinement(bool doing_p_refinement) { _doing_p_refinement = doing_p_refinement; }
 
  [[nodiscard]] bool doingPRefinement() const { return _doing_p_refinement; }
 
  unsigned int maxPLevel() const { return _max_p_level; }
 
  unsigned int maxHLevel() const { return _max_h_level; }
 
  const std::vector<QpMap> & getPRefinementMap(const Elem & elem) const;
  const std::vector<QpMap> & getPRefinementSideMap(const Elem & elem) const;
  const std::vector<QpMap> & getPCoarseningMap(const Elem & elem) const;
  const std::vector<QpMap> & getPCoarseningSideMap(const Elem & elem) const;
 
  void buildPRefinementAndCoarseningMaps(Assembly * assembly);
 
  bool hasLowerD() const { return getMesh().elem_dimensions().size() > 1; }
 
  const std::set<SubdomainID> & interiorLowerDBlocks() const { return _lower_d_interior_blocks; }
  const std::set<SubdomainID> & boundaryLowerDBlocks() const { return _lower_d_boundary_blocks; }
 
  bool getConstructNodeListFromSideList() { return _construct_node_list_from_side_list; }
 
  bool getDisplaceNodeListBySideList() { return _displace_node_list_by_side_list; }
 
  bool possiblyRebuildNodeToElemMap();
 
protected:
  bool allowRecovery() const { return _allow_recovery; }
 
  std::vector<std::unique_ptr<libMesh::GhostingFunctor>> _ghosting_functors;
 
  std::vector<std::shared_ptr<RelationshipManager>> _relationship_managers;
 
  bool _built_from_other_mesh = false;
 
  ParallelType _parallel_type;
 
  bool _use_distributed_mesh;
  bool _distribution_overridden;
  bool _parallel_type_overridden;
 
  std::unique_ptr<libMesh::MeshBase> _mesh;
 
#ifdef MOOSE_KOKKOS_ENABLED
  std::unique_ptr<Moose::Kokkos::Mesh> _kokkos_mesh;
#endif
 
  MooseEnum _partitioner_name;
  bool _partitioner_overridden;
 
  std::unique_ptr<libMesh::Partitioner> _custom_partitioner;
  bool _custom_partitioner_requested;
 
  enum
  {
    X = 0,
    Y,
    Z
  };
  enum
  {
    MIN = 0,
    MAX
  };
 
  unsigned int _uniform_refine_level;
 
  bool _skip_refine_when_use_split;
 
  bool _skip_deletion_repartition_after_refine;
 
  bool _is_changed;
 
  bool _is_nemesis;
 
  bool _moose_mesh_prepared = false;
 
  std::unique_ptr<ConstElemPointerRange> _refined_elements;
 
  std::unique_ptr<ConstElemPointerRange> _coarsened_elements;
 
  std::map<const Elem *, std::vector<const Elem *>> _coarsened_element_children;
 
  std::set<Node *> _semilocal_node_list;
 
  std::unique_ptr<SemiLocalNodeRange> _active_semilocal_node_range;
  std::unique_ptr<libMesh::NodeRange> _active_node_range;
  std::unique_ptr<libMesh::ConstNodeRange> _local_node_range;
  std::unique_ptr<libMesh::StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *>>
      _bnd_node_range;
  std::unique_ptr<libMesh::StoredRange<MooseMesh::const_bnd_elem_iterator, const BndElement *>>
      _bnd_elem_range;
 
  std::unordered_map<dof_id_type, std::vector<dof_id_type>> _node_to_elem_map;
 
  bool _node_to_elem_map_built = false;
 
  std::set<SubdomainID> _mesh_subdomains;
 
 
  std::set<BoundaryID> _mesh_boundary_ids;
  std::set<BoundaryID> _mesh_sideset_ids;
  std::set<BoundaryID> _mesh_nodeset_ids;
 
  std::unique_ptr<std::map<BoundaryID, RealVectorValue>> _boundary_to_normal_map;
 
  std::vector<BndNode *> _bnd_nodes;
  typedef std::vector<BndNode *>::iterator bnd_node_iterator_imp;
  typedef std::vector<BndNode *>::const_iterator const_bnd_node_iterator_imp;
  std::map<boundary_id_type, std::set<dof_id_type>> _bnd_node_ids;
 
  std::vector<BndElement *> _bnd_elems;
  typedef std::vector<BndElement *>::iterator bnd_elem_iterator_imp;
  typedef std::vector<BndElement *>::const_iterator const_bnd_elem_iterator_imp;
 
  std::unordered_map<boundary_id_type, std::unordered_set<dof_id_type>> _bnd_elem_ids;
 
  std::map<dof_id_type, Node *> _quadrature_nodes;
  std::map<dof_id_type, std::map<unsigned int, std::map<dof_id_type, Node *>>>
      _elem_to_side_to_qp_to_quadrature_nodes;
  std::vector<BndNode> _extra_bnd_nodes;
 
  std::map<dof_id_type, std::set<SubdomainID>> _block_node_list;
 
  std::map<boundary_id_type, std::vector<dof_id_type>> _node_set_nodes;
 
  std::set<unsigned int> _ghosted_boundaries;
  std::vector<Real> _ghosted_boundaries_inflation;
 
  unsigned int _patch_size;
 
  unsigned int _ghosting_patch_size;
 
  // The maximum number of points in each leaf of the KDTree used in the nearest neighbor search.
  unsigned int _max_leaf_size;
 
  Moose::PatchUpdateType _patch_update_strategy;
 
  std::vector<Node *> _node_map;
 
  bool _regular_orthogonal_mesh;
 
  std::vector<std::vector<Real>> _bounds;
 
  std::optional<std::vector<std::pair<BoundaryID, BoundaryID>>> _paired_boundary;
 
  const bool _is_split;
 
  void cacheInfo();
  void freeBndNodes();
  void freeBndElems();
  void setPartitionerHelper(MeshBase * mesh = nullptr);
 
private:
  std::unordered_map<dof_id_type, std::vector<dof_id_type>> & internalNodeToElemMap();
 
  mutable std::unordered_map<dof_id_type, ElemInfo> _elem_to_elem_info;
 
  mutable std::vector<const ElemInfo *> _elem_info;
 
  mutable std::vector<FaceInfo> _all_face_info;
 
  mutable std::vector<const FaceInfo *> _face_info;
 
  mutable std::unordered_map<std::pair<const Elem *, unsigned int>, FaceInfo *>
      _elem_side_to_face_info;
 
  // true if the _face_info member needs to be rebuilt/updated.
  mutable bool _finite_volume_info_dirty = true;
 
  // True if we have cached elemental dofs ids for the linear finite volume variables.
  // This happens in the first system which has a linear finite volume variable, considering
  // that currently we only support one variable per linear system.
  mutable bool _linear_finite_volume_dofs_cached = false;
 
  std::map<std::pair<unsigned int, unsigned int>, std::array<bool, 3>> _periodic_dim;
 
  RealVectorValue _half_range;
 
  std::vector<Node *> _extreme_nodes;
 
  void buildRefinementMap(const Elem & elem,
                          libMesh::QBase & qrule,
                          libMesh::QBase & qrule_face,
                          int parent_side,
                          int child,
                          int child_side);
 
  void buildCoarseningMap(const Elem & elem,
                          libMesh::QBase & qrule,
                          libMesh::QBase & qrule_face,
                          int input_side);
 
  void mapPoints(const std::vector<Point> & from,
                 const std::vector<Point> & to,
                 std::vector<QpMap> & qp_map);
 
  void findAdaptivityQpMaps(const Elem * template_elem,
                            libMesh::QBase & qrule,
                            libMesh::QBase & qrule_face,
                            std::vector<std::vector<QpMap>> & refinement_map,
                            std::vector<std::pair<unsigned int, QpMap>> & coarsen_map,
                            int parent_side,
                            int child,
                            int child_side);
 
  void buildHRefinementAndCoarseningMaps(Assembly * assembly);
 
  const std::vector<QpMap> & getPRefinementMapHelper(
      const Elem & elem,
      const std::map<std::pair<libMesh::ElemType, unsigned int>, std::vector<QpMap>> &) const;
  const std::vector<QpMap> & getPCoarseningMapHelper(
      const Elem & elem,
      const std::map<std::pair<libMesh::ElemType, unsigned int>, std::vector<QpMap>> &) const;
 
  void updateCoordTransform();
 
  void checkDuplicateSubdomainNames();
 
  std::map<std::pair<int, libMesh::ElemType>, std::vector<std::vector<QpMap>>>
      _elem_type_to_refinement_map;
 
  std::map<std::pair<libMesh::ElemType, unsigned int>, std::vector<QpMap>>
      _elem_type_to_p_refinement_map;
  std::map<std::pair<libMesh::ElemType, unsigned int>, std::vector<QpMap>>
      _elem_type_to_p_refinement_side_map;
 
  std::map<libMesh::ElemType, std::map<std::pair<int, int>, std::vector<std::vector<QpMap>>>>
      _elem_type_to_child_side_refinement_map;
 
  std::map<std::pair<int, libMesh::ElemType>, std::vector<std::pair<unsigned int, QpMap>>>
      _elem_type_to_coarsening_map;
 
  std::map<std::pair<libMesh::ElemType, unsigned int>, std::vector<QpMap>>
      _elem_type_to_p_coarsening_map;
  std::map<std::pair<libMesh::ElemType, unsigned int>, std::vector<QpMap>>
      _elem_type_to_p_coarsening_side_map;
 
  struct SubdomainData
  {
    std::set<SubdomainID> neighbor_subs;
 
    std::set<BoundaryID> boundary_ids;
  };
 
  std::unordered_map<SubdomainID, SubdomainData> _sub_to_data;
 
  std::unordered_map<SubdomainID, std::set<BoundaryID>> _neighbor_subdomain_boundary_ids;
 
  std::set<SubdomainID> _lower_d_interior_blocks;
  std::set<SubdomainID> _lower_d_boundary_blocks;
  std::unordered_map<std::pair<const Elem *, unsigned short int>, const Elem *>
      _higher_d_elem_side_to_lower_d_elem;
  std::unordered_map<const Elem *, unsigned short int> _lower_d_elem_to_higher_d_elem_side;
 
  bool _allow_recovery;
 
  bool _construct_node_list_from_side_list;
 
  bool _displace_node_list_by_side_list;
 
  bool _need_delete;
 
  bool _allow_remote_element_removal;
 
  std::set<Elem *> _ghost_elems_from_ghost_boundaries;
 
  bool _need_ghost_ghosted_boundaries;
 
  std::vector<std::unordered_map<SubdomainID, std::set<dof_id_type>>> _block_id_mapping;
  std::vector<dof_id_type> _max_ids;
  std::vector<dof_id_type> _min_ids;
  std::vector<std::vector<bool>> _id_identical_flag;
 
  unsigned int _max_sides_per_elem;
 
  unsigned int _max_nodes_per_elem;
 
  unsigned int _max_nodes_per_side;
 
  void computeMaxPerElemAndSide();
 
  bool _is_displaced;
 
  void buildElemIDInfo();
 
  void buildLowerDMesh();
 
  std::map<SubdomainID, Moose::CoordinateSystemType> & _coord_sys;
 
  unsigned int _rz_coord_axis;
 
  std::unordered_map<SubdomainID, std::pair<Point, RealVectorValue>> _subdomain_id_to_rz_coord_axis;
 
  std::unique_ptr<MooseAppCoordTransform> _coord_transform;
 
  bool _coord_system_set;
 
  std::vector<SubdomainName> _provided_coord_blocks;
 
  bool _doing_p_refinement;
  unsigned int _max_p_level;
  unsigned int _max_h_level;
 
  template <typename T>
  struct MeshType;
};
 
inline MooseAppCoordTransform &
MooseMesh::coordTransform()
{
  mooseAssert(_coord_transform, "The coordinate transformation object is null.");
  return *_coord_transform;
}
 
template <>
struct MooseMesh::MeshType<libMesh::ReplicatedMesh>
{
  static const ParallelType value = ParallelType::REPLICATED;
};
 
template <>
struct MooseMesh::MeshType<libMesh::DistributedMesh>
{
  static const ParallelType value = ParallelType::DISTRIBUTED;
};
 
struct MooseMesh::face_info_iterator
  : variant_filter_iterator<MeshBase::Predicate, const FaceInfo *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  face_info_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate, const FaceInfo *>(d, e, p)
  {
  }
};
 
struct MooseMesh::const_face_info_iterator : variant_filter_iterator<MeshBase::Predicate,
                                                                     const FaceInfo * const,
                                                                     const FaceInfo * const &,
                                                                     const FaceInfo * const *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  const_face_info_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate,
                              const FaceInfo * const,
                              const FaceInfo * const &,
                              const FaceInfo * const *>(d, e, p)
  {
  }
 
  // The conversion-to-const ctor.  Takes a regular iterator and calls the appropriate
  // variant_filter_iterator copy constructor.  Note that this one is *not* templated!
  const_face_info_iterator(const MooseMesh::face_info_iterator & rhs)
    : variant_filter_iterator<MeshBase::Predicate,
                              const FaceInfo * const,
                              const FaceInfo * const &,
                              const FaceInfo * const *>(rhs)
  {
  }
};
 
struct MooseMesh::elem_info_iterator
  : variant_filter_iterator<MeshBase::Predicate, const ElemInfo *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  elem_info_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate, const ElemInfo *>(d, e, p)
  {
  }
};
 
struct MooseMesh::const_elem_info_iterator : variant_filter_iterator<MeshBase::Predicate,
                                                                     const ElemInfo * const,
                                                                     const ElemInfo * const &,
                                                                     const ElemInfo * const *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  const_elem_info_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate,
                              const ElemInfo * const,
                              const ElemInfo * const &,
                              const ElemInfo * const *>(d, e, p)
  {
  }
 
  // The conversion-to-const ctor.  Takes a regular iterator and calls the appropriate
  // variant_filter_iterator copy constructor.  Note that this one is *not* templated!
  const_elem_info_iterator(const MooseMesh::elem_info_iterator & rhs)
    : variant_filter_iterator<MeshBase::Predicate,
                              const ElemInfo * const,
                              const ElemInfo * const &,
                              const ElemInfo * const *>(rhs)
  {
  }
};
 
struct MooseMesh::bnd_node_iterator : variant_filter_iterator<MeshBase::Predicate, BndNode *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  bnd_node_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate, BndNode *>(d, e, p)
  {
  }
};
 
struct MooseMesh::const_bnd_node_iterator : variant_filter_iterator<MeshBase::Predicate,
                                                                    BndNode * const,
                                                                    BndNode * const &,
                                                                    BndNode * const *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  const_bnd_node_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate,
                              BndNode * const,
                              BndNode * const &,
                              BndNode * const *>(d, e, p)
  {
  }
 
  // The conversion-to-const ctor.  Takes a regular iterator and calls the appropriate
  // variant_filter_iterator copy constructor.  Note that this one is *not* templated!
  const_bnd_node_iterator(const MooseMesh::bnd_node_iterator & rhs)
    : variant_filter_iterator<MeshBase::Predicate,
                              BndNode * const,
                              BndNode * const &,
                              BndNode * const *>(rhs)
  {
  }
};
 
struct MooseMesh::bnd_elem_iterator : variant_filter_iterator<MeshBase::Predicate, BndElement *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  bnd_elem_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate, BndElement *>(d, e, p)
  {
  }
};
 
struct MooseMesh::const_bnd_elem_iterator : variant_filter_iterator<MeshBase::Predicate,
                                                                    BndElement * const,
                                                                    BndElement * const &,
                                                                    BndElement * const *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  const_bnd_elem_iterator(const IterType & d, const IterType & e, const PredType & p)
    : variant_filter_iterator<MeshBase::Predicate,
                              BndElement * const,
                              BndElement * const &,
                              BndElement * const *>(d, e, p)
  {
  }
 
  // The conversion-to-const ctor.  Takes a regular iterator and calls the appropriate
  // variant_filter_iterator copy constructor.  Note that this one is *not* templated!
  const_bnd_elem_iterator(const bnd_elem_iterator & rhs)
    : variant_filter_iterator<MeshBase::Predicate,
                              BndElement * const,
                              BndElement * const &,
                              BndElement * const *>(rhs)
  {
  }
};
 
typedef libMesh::StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *> ConstBndNodeRange;
typedef libMesh::StoredRange<MooseMesh::const_bnd_elem_iterator, const BndElement *>
    ConstBndElemRange;
 
template <typename T>
std::unique_ptr<T>
MooseMesh::buildTypedMesh(unsigned int dim)
{
  // If the requested mesh type to build doesn't match our current value for _use_distributed_mesh,
  // then we need to make sure to make our state consistent because other objects, like the periodic
  // boundary condition action, will be querying isDistributedMesh()
  if (_use_distributed_mesh != std::is_same<T, libMesh::DistributedMesh>::value)
  {
    if (getMeshPtr())
      mooseError("A MooseMesh object is being asked to build a libMesh mesh that is a different "
                 "parallel type than the libMesh mesh that it wraps. This is not allowed. Please "
                 "create another MooseMesh object to wrap the new libMesh mesh");
    setParallelType(MeshType<T>::value);
  }
 
  if (dim == libMesh::invalid_uint)
  {
    if (isParamValid("dim"))
      dim = getParam<MooseEnum>("dim");
    else
      // Legacy selection of the default for the 'dim' parameter
      dim = 1;
  }
 
  auto mesh = std::make_unique<T>(_communicator, dim);
 
  if (!getParam<bool>("allow_renumbering"))
    mesh->allow_renumbering(false);
 
  mesh->allow_remote_element_removal(_allow_remote_element_removal);
  _app.attachRelationshipManagers(*mesh, *this);
 
  if (_custom_partitioner_requested)
  {
    // Check of partitioner is supplied (not allowed if custom partitioner is used)
    if (!parameters().isParamSetByAddParam("partitioner"))
      mooseError("If partitioner block is provided, partitioner keyword cannot be used!");
    // Set custom partitioner
    if (!_custom_partitioner.get())
      mooseError("Custom partitioner requested but not set!");
    mesh->partitioner() = _custom_partitioner->clone();
  }
  else
    setPartitionerHelper(mesh.get());
 
  return mesh;
}
 
inline bool
MooseMesh::skipDeletionRepartitionAfterRefine() const
{
  return _skip_deletion_repartition_after_refine;
}
 
inline void
MooseMesh::setParallelType(ParallelType parallel_type)
{
  _parallel_type = parallel_type;
  determineUseDistributedMesh();
}
 
inline bool
MooseMesh::hasElementID(const std::string & id_name) const
{
  return getMesh().has_elem_integer(id_name);
}
 
inline unsigned int
MooseMesh::getElementIDIndex(const std::string & id_name) const
{
  if (!hasElementID(id_name))
    mooseError("Mesh does not have element ID for ", id_name);
  return getMesh().get_elem_integer_index(id_name);
}
 
inline bool
MooseMesh::areElemIDsIdentical(const std::string & id_name1, const std::string & id_name2) const
{
  auto id1 = getElementIDIndex(id_name1);
  auto id2 = getElementIDIndex(id_name2);
  return _id_identical_flag[id1][id2];
}
 
inline const std::vector<const FaceInfo *> &
MooseMesh::faceInfo() const
{
  return _face_info;
}
 
inline const std::vector<FaceInfo> &
MooseMesh::allFaceInfo() const
{
  return _all_face_info;
}
 
inline const std::map<boundary_id_type, std::vector<dof_id_type>> &
MooseMesh::nodeSetNodes() const
{
  return _node_set_nodes;
}
 
inline const std::unordered_map<std::pair<const Elem *, unsigned short int>, const Elem *> &
MooseMesh::getLowerDElemMap() const
{
  return _higher_d_elem_side_to_lower_d_elem;
}