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