MooseMesh.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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

#include "MooseObject.h"
#include "BndNode.h"
#include "BndElement.h"
#include "Restartable.h"
#include "MooseEnum.h"
#include "PerfGraphInterface.h"

#include <memory> //std::unique_ptr
#include <unordered_map>
#include <unordered_set>

// libMesh
#include "libmesh/elem_range.h"
#include "libmesh/mesh_base.h"
#include "libmesh/node_range.h"
#include "libmesh/nanoflann.hpp"
#include "libmesh/vector_value.h"

// forward declaration
class MooseMesh;
class Assembly;
class RelationshipManager;

// libMesh forward declarations
namespace libMesh
{
class ExodusII_IO;
class QBase;
class PeriodicBoundaries;
class Partitioner;
class GhostingFunctor;
class BoundingBox;
}

// Useful typedefs
typedef StoredRange<std::set<Node *>::iterator, Node *> SemiLocalNodeRange;

template <>
InputParameters validParams<MooseMesh>();

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:
  MooseMesh(const InputParameters & parameters);
  MooseMesh(const MooseMesh & other_mesh);

  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;

  std::unique_ptr<MeshBase> buildMeshBaseObject(ParallelType override_type = ParallelType::DEFAULT);

  void setMeshBase(std::unique_ptr<MeshBase> mesh_base);

  virtual void init();

  virtual void buildMesh() = 0;

  virtual unsigned int dimension() const;

  virtual unsigned int effectiveSpatialDimension() const;

  std::vector<BoundaryID> getBoundaryIDs(const Elem * const elem,
                                         const unsigned short int side) const;

  const std::set<BoundaryID> & getBoundaryIDs() const;

  void buildNodeList();
  void buildBndElemList();

  const std::map<dof_id_type, std::vector<dof_id_type>> & nodeToElemMap();

  const std::map<dof_id_type, std::vector<dof_id_type>> & nodeToActiveSemilocalElemMap();

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

  void buildSideList(std::vector<dof_id_type> & el,
                     std::vector<unsigned short int> & sl,
                     std::vector<boundary_id_type> & il);
  std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> buildSideList();

  unsigned int sideWithBoundaryID(const Elem * const elem, const BoundaryID boundary_id) const;

  MeshBase::const_node_iterator localNodesBegin();
  MeshBase::const_node_iterator localNodesEnd();

  MeshBase::const_element_iterator activeLocalElementsBegin();
  const MeshBase::const_element_iterator activeLocalElementsEnd();

  virtual dof_id_type nNodes() const;
  virtual dof_id_type nElem() 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;


  ConstElemRange * getActiveLocalElementRange();
  NodeRange * getActiveNodeRange();
  SemiLocalNodeRange * getActiveSemiLocalNodeRange() const;
  ConstNodeRange * getLocalNodeRange();
  StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *> * getBoundaryNodeRange();
  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::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;

  void prepare(bool force = false);

  void update();

  unsigned int uniformRefineLevel() const;

  void setUniformRefineLevel(unsigned int);

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

  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;

  BoundingBox getInflatedProcessorBoundingBox(Real inflation_multiplier = 0.01) const;

  operator libMesh::MeshBase &();
  operator const libMesh::MeshBase &() const;

  MeshBase & getMesh();
  const MeshBase & getMesh() const;

  virtual ExodusII_IO * exReader() const;

  void printInfo(std::ostream & os = libMesh::out) 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_name) const;

  void setSubdomainName(SubdomainID subdomain_id, SubdomainName name);

  const std::string & getSubdomainName(SubdomainID subdomain_id);

  void setBoundaryName(BoundaryID boundary_id, BoundaryName name);

  const std::string & getBoundaryName(BoundaryID boundary_id);

  void buildPeriodicNodeMap(std::multimap<dof_id_type, dof_id_type> & periodic_node_map,
                            unsigned int var_number,
                            PeriodicBoundaries * pbs) const;

  void buildPeriodicNodeSets(std::map<BoundaryID, std::set<dof_id_type>> & periodic_node_sets,
                             unsigned int var_number,
                             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(unsigned int var_num, BoundaryID primary, BoundaryID secondary);

  bool isTranslatedPeriodic(unsigned int nonlinear_var_num, unsigned int component) const;

  RealVectorValue minPeriodicVector(unsigned int nonlinear_var_num, Point p, Point q) const;

  Real minPeriodicDistance(unsigned int nonlinear_var_num, Point p, Point q) const;

  const std::pair<BoundaryID, BoundaryID> * getPairedBoundaryMapping(unsigned int component);

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

  const std::set<BoundaryID> & getSubdomainBoundaryIds(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;

  bool isDistributedMesh() const { return _use_distributed_mesh; }

  bool isParallelTypeForced() const { return _parallel_type_overridden; }

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

  void setCustomPartitioner(Partitioner * partitioner);


  bool isCustomPartitionerRequested() const;
  void setIsCustomPartitionerRequested(bool cpr);

  bool isRegularOrthogonal() { return _regular_orthogonal_mesh; }

  bool hasSecondOrderElements();

  virtual std::unique_ptr<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; }

protected:
  std::vector<std::unique_ptr<GhostingFunctor>> _ghosting_functors;

  std::vector<std::shared_ptr<RelationshipManager>> _relationship_managers;

  ParallelType _parallel_type;

  bool _use_distributed_mesh;
  bool _distribution_overridden;
  bool _parallel_type_overridden;

  std::unique_ptr<libMesh::MeshBase> _mesh;

  MooseEnum _partitioner_name;
  bool _partitioner_overridden;

  std::unique_ptr<Partitioner> _custom_partitioner;
  bool _custom_partitioner_requested;

  enum
  {
    X = 0,
    Y,
    Z
  };
  enum
  {
    MIN = 0,
    MAX
  };

  unsigned int _uniform_refine_level;

  bool _is_changed;

  bool _is_nemesis;

  bool _is_prepared;

  bool _needs_prepare_for_use;

  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<ConstElemRange> _active_local_elem_range;

  std::unique_ptr<SemiLocalNodeRange> _active_semilocal_node_range;
  std::unique_ptr<NodeRange> _active_node_range;
  std::unique_ptr<ConstNodeRange> _local_node_range;
  std::unique_ptr<StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *>> _bnd_node_range;
  std::unique_ptr<StoredRange<MooseMesh::const_bnd_elem_iterator, const BndElement *>>
      _bnd_elem_range;

  std::map<dof_id_type, std::vector<dof_id_type>> _node_to_elem_map;
  bool _node_to_elem_map_built;

  std::map<dof_id_type, std::vector<dof_id_type>> _node_to_active_semilocal_elem_map;
  bool _node_to_active_semilocal_elem_map_built;

  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::vector<std::pair<BoundaryID, BoundaryID>> _paired_boundary;

  void cacheInfo();
  void freeBndNodes();
  void freeBndElems();

private:
  std::map<unsigned int, std::vector<bool>> _periodic_dim;

  RealVectorValue _half_range;

  std::vector<Node *> _extreme_nodes;

  void detectPairedSidesets();

  void buildRefinementMap(const Elem & elem,
                          QBase & qrule,
                          QBase & qrule_face,
                          int parent_side,
                          int child,
                          int child_side);

  void buildCoarseningMap(const Elem & elem, QBase & qrule, 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,
                            QBase & qrule,
                            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);

  std::map<std::pair<int, ElemType>, std::vector<std::vector<QpMap>>> _elem_type_to_refinement_map;

  std::map<ElemType, std::map<std::pair<int, int>, std::vector<std::vector<QpMap>>>>
      _elem_type_to_child_side_refinement_map;

  std::map<std::pair<int, ElemType>, std::vector<std::pair<unsigned int, QpMap>>>
      _elem_type_to_coarsening_map;

  std::map<SubdomainID, std::set<BoundaryID>> _subdomain_boundary_ids;

  bool _allow_recovery;

  bool _construct_node_list_from_side_list;

  PerfID _prepare_timer;
  PerfID _update_timer;
  PerfID _mesh_changed_timer;
  PerfID _cache_changed_lists_timer;
  PerfID _update_active_semi_local_node_range_timer;
  PerfID _build_node_list_timer;
  PerfID _build_bnd_elem_list_timer;
  PerfID _node_to_elem_map_timer;
  PerfID _node_to_active_semilocal_elem_map_timer;
  PerfID _get_active_local_element_range_timer;
  PerfID _get_active_node_range_timer;
  PerfID _get_local_node_range_timer;
  PerfID _get_boundary_node_range_timer;
  PerfID _get_boundary_element_range_timer;
  PerfID _cache_info_timer;
  PerfID _build_periodic_node_map_timer;
  PerfID _build_periodic_node_sets_timer;
  PerfID _detect_orthogonal_dim_ranges_timer;
  PerfID _detect_paired_sidesets_timer;
  PerfID _build_refinement_map_timer;
  PerfID _build_coarsening_map_timer;
  PerfID _find_adaptivity_qp_maps_timer;
  PerfID _build_refinement_and_coarsening_maps_timer;
  PerfID _change_boundary_id_timer;
  PerfID _init_timer;
  PerfID _read_recovered_mesh_timer;
  PerfID _ghost_ghosted_boundaries_timer;

  bool _need_delete;
};

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 StoredRange<MooseMesh::const_bnd_node_iterator, const BndNode *> ConstBndNodeRange;
typedef StoredRange<MooseMesh::const_bnd_elem_iterator, const BndElement *> ConstBndElemRange;