mesh_base.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_MESH_BASE_H
#define LIBMESH_MESH_BASE_H

// Local Includes
#include "libmesh/auto_ptr.h" // deprecated
#include "libmesh/boundary_info.h"
#include "libmesh/dof_object.h" // for invalid_processor_id
#include "libmesh/libmesh_common.h"
#include "libmesh/multi_predicates.h"
#include "libmesh/point_locator_base.h"
#include "libmesh/variant_filter_iterator.h"
#include "libmesh/parallel_object.h"
#include "libmesh/simple_range.h"

#ifdef LIBMESH_FORWARD_DECLARE_ENUMS
namespace libMesh
{
enum ElemType : int;
}
#else
#include "libmesh/enum_elem_type.h"
#endif

// C++ Includes
#include <cstddef>
#include <string>
#include <memory>

namespace libMesh
{

// forward declarations
class Elem;
class GhostingFunctor;
class Node;
class Point;
class Partitioner;

template <class MT>
class MeshInput;


class MeshBase : public ParallelObject
{
public:

  MeshBase (const Parallel::Communicator & comm_in,
            unsigned char dim=1);

  MeshBase (const MeshBase & other_mesh);

  MeshBase(MeshBase &&);

  MeshBase & operator= (const MeshBase &) = delete;
  MeshBase & operator= (MeshBase &&) = delete;

  virtual std::unique_ptr<MeshBase> clone() const = 0;

  virtual ~MeshBase ();

  virtual std::unique_ptr<Partitioner> & partitioner() { return _partitioner; }

  const BoundaryInfo & get_boundary_info() const { return *boundary_info; }

  BoundaryInfo & get_boundary_info() { return *boundary_info; }

  virtual void clear ();

  bool is_prepared () const
  { return _is_prepared; }

  virtual bool is_serial () const
  { return true; }

  virtual bool is_serial_on_zero () const
  { return true; }

  virtual void set_distributed ()
  { libmesh_error(); }

  virtual bool is_replicated () const
  { return true; }

  virtual void allgather () {}

  virtual void gather_to_zero() {}

  virtual void delete_remote_elements () {}

  unsigned int mesh_dimension () const;

  void set_mesh_dimension (unsigned char d)
  { _elem_dims.clear(); _elem_dims.insert(d); }

  const std::set<unsigned char> & elem_dimensions() const
  { return _elem_dims; }

  unsigned int spatial_dimension () const;

  void set_spatial_dimension(unsigned char d);

  virtual dof_id_type n_nodes () const = 0;

  virtual dof_id_type parallel_n_nodes () const = 0;

  dof_id_type n_nodes_on_proc (const processor_id_type proc) const;

  dof_id_type n_local_nodes () const
  { return this->n_nodes_on_proc (this->processor_id()); }

  dof_id_type n_unpartitioned_nodes () const
  { return this->n_nodes_on_proc (DofObject::invalid_processor_id); }

  virtual dof_id_type max_node_id () const = 0;

#ifdef LIBMESH_ENABLE_UNIQUE_ID

  unique_id_type next_unique_id() { return _next_unique_id; }

  void set_next_unique_id(unique_id_type id) { _next_unique_id = id; }
#endif

  virtual void reserve_nodes (const dof_id_type nn) = 0;

  virtual dof_id_type n_elem () const = 0;

  virtual dof_id_type parallel_n_elem () const = 0;

  virtual dof_id_type max_elem_id () const = 0;

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  virtual unique_id_type parallel_max_unique_id () const = 0;
#endif

  virtual void reserve_elem (const dof_id_type ne) = 0;

  virtual void update_parallel_id_counts () = 0;

  virtual dof_id_type n_active_elem () const = 0;

  dof_id_type n_elem_on_proc (const processor_id_type proc) const;

  dof_id_type n_local_elem () const
  { return this->n_elem_on_proc (this->processor_id()); }

  dof_id_type n_unpartitioned_elem () const
  { return this->n_elem_on_proc (DofObject::invalid_processor_id); }

  dof_id_type n_active_elem_on_proc (const processor_id_type proc) const;

  dof_id_type n_active_local_elem () const
  { return this->n_active_elem_on_proc (this->processor_id()); }

  dof_id_type n_sub_elem () const;

  dof_id_type n_active_sub_elem () const;

  virtual const Point & point (const dof_id_type i) const = 0;

  virtual const Node & node_ref (const dof_id_type i) const {
    return *this->node_ptr(i);
  }

  virtual Node & node_ref (const dof_id_type i) {
    return *this->node_ptr(i);
  }

#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual const Node & node (const dof_id_type i) const
  {
    libmesh_deprecated();
    return *this->node_ptr(i);
  }
#endif

#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual Node & node (const dof_id_type i)
  {
    libmesh_deprecated();
    return *this->node_ptr(i);
  }
#endif

  virtual const Node * node_ptr (const dof_id_type i) const = 0;

  virtual Node * node_ptr (const dof_id_type i) = 0;

  virtual const Node * query_node_ptr (const dof_id_type i) const = 0;

  virtual Node * query_node_ptr (const dof_id_type i) = 0;

  virtual const Elem & elem_ref (const dof_id_type i) const {
    return *this->elem_ptr(i);
  }

  virtual Elem & elem_ref (const dof_id_type i) {
    return *this->elem_ptr(i);
  }

  virtual const Elem * elem_ptr (const dof_id_type i) const = 0;

  virtual Elem * elem_ptr (const dof_id_type i) = 0;

#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual const Elem * elem (const dof_id_type i) const
  {
    libmesh_deprecated();
    return this->elem_ptr(i);
  }
#endif

#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual Elem * elem (const dof_id_type i)
  {
    libmesh_deprecated();
    return this->elem_ptr(i);
  }
#endif

  virtual const Elem * query_elem_ptr (const dof_id_type i) const = 0;

  virtual Elem * query_elem_ptr (const dof_id_type i) = 0;

#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual const Elem * query_elem (const dof_id_type i) const
  {
    libmesh_deprecated();
    return this->query_elem_ptr(i);
  }
#endif

#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual Elem * query_elem (const dof_id_type i)
  {
    libmesh_deprecated();
    return this->query_elem_ptr(i);
  }
#endif

  virtual Node * add_point (const Point & p,
                            const dof_id_type id = DofObject::invalid_id,
                            const processor_id_type proc_id =
                            DofObject::invalid_processor_id) = 0;

  virtual Node * add_node (Node * n) = 0;

  virtual Node * insert_node(Node * n) = 0;

  virtual void delete_node (Node * n) = 0;

  virtual void own_node (Node &) {}

  virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) = 0;

  virtual Elem * add_elem (Elem * e) = 0;

  virtual Elem * insert_elem (Elem * e) = 0;

  virtual void delete_elem (Elem * e) = 0;

  virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) = 0;

  virtual void find_neighbors (const bool reset_remote_elements = false,
                               const bool reset_current_list    = true) = 0;

  virtual void renumber_nodes_and_elements () = 0;

  virtual void fix_broken_node_and_element_numbering () = 0;


#ifdef LIBMESH_ENABLE_AMR

  virtual bool contract () = 0;
#endif

  void prepare_for_use (const bool skip_renumber_nodes_and_elements=false, const bool skip_find_neighbors=false);

  virtual void partition (const unsigned int n_parts);

  void partition ()
  { this->partition(this->n_processors()); }

  virtual void redistribute () {}

  virtual void update_post_partitioning () {}

  void allow_renumbering(bool allow) { _skip_renumber_nodes_and_elements = !allow; }
  bool allow_renumbering() const { return !_skip_renumber_nodes_and_elements; }

  void allow_remote_element_removal(bool allow) { _allow_remote_element_removal = allow; }
  bool allow_remote_element_removal() const { return _allow_remote_element_removal; }

  void skip_partitioning(bool skip) { _skip_partitioning = skip; }
  bool skip_partitioning() const { return _skip_partitioning || !_partitioner.get(); }

  void add_ghosting_functor(GhostingFunctor & ghosting_functor)
  { _ghosting_functors.insert(&ghosting_functor); }

  void remove_ghosting_functor(GhostingFunctor & ghosting_functor);

  std::set<GhostingFunctor *>::const_iterator ghosting_functors_begin() const
  { return _ghosting_functors.begin(); }

  std::set<GhostingFunctor *>::const_iterator ghosting_functors_end() const
  { return _ghosting_functors.end(); }

  GhostingFunctor & default_ghosting() { return *_default_ghosting; }

  void subdomain_ids (std::set<subdomain_id_type> & ids) const;

  subdomain_id_type n_subdomains () const;

  unsigned int n_partitions () const
  { return _n_parts; }

  std::string get_info () const;

  void print_info (std::ostream & os=libMesh::out) const;

  friend std::ostream & operator << (std::ostream & os, const MeshBase & m);

  virtual void read  (const std::string & name,
                      void * mesh_data=nullptr,
                      bool skip_renumber_nodes_and_elements=false,
                      bool skip_find_neighbors=false) = 0;
  virtual void write (const std::string & name) = 0;

  virtual void all_first_order () = 0;

  virtual void all_second_order (const bool full_ordered=true) = 0;

  typedef Predicates::multi_predicate Predicate;

  struct element_iterator;
  struct const_element_iterator;

  struct node_iterator;
  struct const_node_iterator;

  unsigned int recalculate_n_partitions();

#ifdef LIBMESH_ENABLE_DEPRECATED
  const PointLocatorBase & point_locator () const;
#endif

  std::unique_ptr<PointLocatorBase> sub_point_locator () const;

  void clear_point_locator ();

  void set_count_lower_dim_elems_in_point_locator(bool count_lower_dim_elems);

  bool get_count_lower_dim_elems_in_point_locator() const;

  virtual void libmesh_assert_valid_parallel_ids() const {}

  std::string & subdomain_name(subdomain_id_type id);
  const std::string & subdomain_name(subdomain_id_type id) const;

  subdomain_id_type get_id_by_name(const std::string & name) const;

  //
  // element_iterator accessors
  //

  virtual element_iterator elements_begin () = 0;
  virtual element_iterator elements_end () = 0;
  virtual const_element_iterator elements_begin () const = 0;
  virtual const_element_iterator elements_end () const = 0;
  virtual SimpleRange<element_iterator> element_ptr_range() = 0;
  virtual SimpleRange<const_element_iterator> element_ptr_range() const = 0;

  virtual element_iterator ancestor_elements_begin () = 0;
  virtual element_iterator ancestor_elements_end () = 0;
  virtual const_element_iterator ancestor_elements_begin () const = 0;
  virtual const_element_iterator ancestor_elements_end () const = 0;

  virtual element_iterator subactive_elements_begin () = 0;
  virtual element_iterator subactive_elements_end () = 0;
  virtual const_element_iterator subactive_elements_begin () const = 0;
  virtual const_element_iterator subactive_elements_end () const = 0;

  virtual element_iterator semilocal_elements_begin () = 0;
  virtual element_iterator semilocal_elements_end () = 0;
  virtual const_element_iterator semilocal_elements_begin () const = 0;
  virtual const_element_iterator semilocal_elements_end () const = 0;

  virtual element_iterator facelocal_elements_begin () = 0;
  virtual element_iterator facelocal_elements_end () = 0;
  virtual const_element_iterator facelocal_elements_begin () const = 0;
  virtual const_element_iterator facelocal_elements_end () const = 0;

  virtual element_iterator level_elements_begin (unsigned int level) = 0;
  virtual element_iterator level_elements_end (unsigned int level) = 0;
  virtual const_element_iterator level_elements_begin (unsigned int level) const = 0;
  virtual const_element_iterator level_elements_end (unsigned int level) const = 0;

  virtual element_iterator pid_elements_begin (processor_id_type proc_id) = 0;
  virtual element_iterator pid_elements_end (processor_id_type proc_id) = 0;
  virtual const_element_iterator pid_elements_begin (processor_id_type proc_id) const = 0;
  virtual const_element_iterator pid_elements_end (processor_id_type proc_id) const = 0;

  virtual element_iterator type_elements_begin (ElemType type) = 0;
  virtual element_iterator type_elements_end (ElemType type) = 0;
  virtual const_element_iterator type_elements_begin (ElemType type) const = 0;
  virtual const_element_iterator type_elements_end (ElemType type) const = 0;

  virtual element_iterator unpartitioned_elements_begin () = 0;
  virtual element_iterator unpartitioned_elements_end () = 0;
  virtual const_element_iterator unpartitioned_elements_begin () const = 0;
  virtual const_element_iterator unpartitioned_elements_end () const = 0;

  virtual element_iterator active_unpartitioned_elements_begin () = 0;
  virtual element_iterator active_unpartitioned_elements_end () = 0;
  virtual const_element_iterator active_unpartitioned_elements_begin () const = 0;
  virtual const_element_iterator active_unpartitioned_elements_end () const = 0;

  virtual element_iterator ghost_elements_begin () = 0;
  virtual element_iterator ghost_elements_end () = 0;
  virtual const_element_iterator ghost_elements_begin () const = 0;
  virtual const_element_iterator ghost_elements_end () const = 0;

  virtual element_iterator
  evaluable_elements_begin (const DofMap & dof_map,
                            unsigned int var_num = libMesh::invalid_uint) = 0;

  virtual element_iterator
  evaluable_elements_end (const DofMap & dof_map,
                          unsigned int var_num = libMesh::invalid_uint) = 0;

  virtual const_element_iterator
  evaluable_elements_begin (const DofMap & dof_map,
                            unsigned int var_num = libMesh::invalid_uint) const = 0;

  virtual const_element_iterator
  evaluable_elements_end (const DofMap & dof_map,
                          unsigned int var_num = libMesh::invalid_uint) const = 0;

#ifdef LIBMESH_ENABLE_AMR

  virtual element_iterator flagged_elements_begin (unsigned char rflag) = 0;
  virtual element_iterator flagged_elements_end (unsigned char rflag) = 0;
  virtual const_element_iterator flagged_elements_begin (unsigned char rflag) const = 0;
  virtual const_element_iterator flagged_elements_end (unsigned char rflag) const = 0;

  virtual element_iterator flagged_pid_elements_begin (unsigned char rflag,
                                                       processor_id_type pid) = 0;
  virtual element_iterator flagged_pid_elements_end (unsigned char rflag,
                                                     processor_id_type pid) = 0;
  virtual const_element_iterator flagged_pid_elements_begin (unsigned char rflag,
                                                             processor_id_type pid) const = 0;
  virtual const_element_iterator flagged_pid_elements_end (unsigned char rflag,
                                                           processor_id_type pid) const = 0;
#endif

  virtual element_iterator active_elements_begin () = 0;
  virtual element_iterator active_elements_end () = 0;
  virtual const_element_iterator active_elements_begin () const = 0;
  virtual const_element_iterator active_elements_end () const = 0;
  virtual SimpleRange<element_iterator> active_element_ptr_range() = 0;
  virtual SimpleRange<const_element_iterator> active_element_ptr_range() const = 0;

  virtual element_iterator local_elements_begin () = 0;
  virtual element_iterator local_elements_end () = 0;
  virtual const_element_iterator local_elements_begin () const = 0;
  virtual const_element_iterator local_elements_end () const = 0;

  virtual element_iterator active_semilocal_elements_begin () = 0;
  virtual element_iterator active_semilocal_elements_end () = 0;
  virtual const_element_iterator active_semilocal_elements_begin () const = 0;
  virtual const_element_iterator active_semilocal_elements_end () const = 0;

  virtual element_iterator active_type_elements_begin (ElemType type) = 0;
  virtual element_iterator active_type_elements_end (ElemType type) = 0;
  virtual const_element_iterator active_type_elements_begin (ElemType type) const = 0;
  virtual const_element_iterator active_type_elements_end (ElemType type) const = 0;

  virtual element_iterator active_pid_elements_begin (processor_id_type proc_id) = 0;
  virtual element_iterator active_pid_elements_end (processor_id_type proc_id) = 0;
  virtual const_element_iterator active_pid_elements_begin (processor_id_type proc_id) const = 0;
  virtual const_element_iterator active_pid_elements_end (processor_id_type proc_id) const = 0;

  virtual element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) = 0;
  virtual element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) = 0;
  virtual const_element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) const = 0;
  virtual const_element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) const = 0;

  virtual element_iterator active_subdomain_set_elements_begin (std::set<subdomain_id_type> ss) = 0;
  virtual element_iterator active_subdomain_set_elements_end (std::set<subdomain_id_type> ss) = 0;
  virtual const_element_iterator active_subdomain_set_elements_begin (std::set<subdomain_id_type> ss) const = 0;
  virtual const_element_iterator active_subdomain_set_elements_end (std::set<subdomain_id_type> ss) const = 0;

  virtual element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) = 0;
  virtual element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) = 0;
  virtual const_element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const = 0;
  virtual const_element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const = 0;

  virtual element_iterator local_level_elements_begin (unsigned int level) = 0;
  virtual element_iterator local_level_elements_end (unsigned int level) = 0;
  virtual const_element_iterator local_level_elements_begin (unsigned int level) const = 0;
  virtual const_element_iterator local_level_elements_end (unsigned int level) const = 0;

  virtual element_iterator local_not_level_elements_begin (unsigned int level) = 0;
  virtual element_iterator local_not_level_elements_end (unsigned int level) = 0;
  virtual const_element_iterator local_not_level_elements_begin (unsigned int level) const = 0;
  virtual const_element_iterator local_not_level_elements_end (unsigned int level) const = 0;

  virtual element_iterator not_level_elements_begin (unsigned int level) = 0;
  virtual element_iterator not_level_elements_end (unsigned int level) = 0;
  virtual const_element_iterator not_level_elements_begin (unsigned int level) const = 0;
  virtual const_element_iterator not_level_elements_end (unsigned int level) const = 0;

  virtual element_iterator active_local_elements_begin () = 0;
  virtual element_iterator active_local_elements_end () = 0;
  virtual const_element_iterator active_local_elements_begin () const = 0;
  virtual const_element_iterator active_local_elements_end () const = 0;
  virtual SimpleRange<element_iterator> active_local_element_ptr_range() = 0;
  virtual SimpleRange<const_element_iterator> active_local_element_ptr_range() const = 0;

  virtual element_iterator active_not_local_elements_begin () = 0;
  virtual element_iterator active_not_local_elements_end () = 0;
  virtual const_element_iterator active_not_local_elements_begin () const = 0;
  virtual const_element_iterator active_not_local_elements_end () const = 0;

  virtual element_iterator not_local_elements_begin () = 0;
  virtual element_iterator not_local_elements_end () = 0;
  virtual const_element_iterator not_local_elements_begin () const = 0;
  virtual const_element_iterator not_local_elements_end () const = 0;

  virtual element_iterator not_subactive_elements_begin () = 0;
  virtual element_iterator not_subactive_elements_end () = 0;
  virtual const_element_iterator not_subactive_elements_begin () const = 0;
  virtual const_element_iterator not_subactive_elements_end () const = 0;

  virtual element_iterator not_active_elements_begin () = 0;
  virtual element_iterator not_active_elements_end () = 0;
  virtual const_element_iterator not_active_elements_begin () const = 0;
  virtual const_element_iterator not_active_elements_end () const = 0;

  virtual element_iterator not_ancestor_elements_begin () = 0;
  virtual element_iterator not_ancestor_elements_end () = 0;
  virtual const_element_iterator not_ancestor_elements_begin () const = 0;
  virtual const_element_iterator not_ancestor_elements_end () const = 0;

  //
  // node_iterator accessors
  //

  virtual node_iterator nodes_begin () = 0;
  virtual node_iterator nodes_end () = 0;
  virtual const_node_iterator nodes_begin () const = 0;
  virtual const_node_iterator nodes_end () const = 0;
  virtual SimpleRange<node_iterator> node_ptr_range() = 0;
  virtual SimpleRange<const_node_iterator> node_ptr_range() const = 0;

  virtual node_iterator active_nodes_begin () = 0;
  virtual node_iterator active_nodes_end () = 0;
  virtual const_node_iterator active_nodes_begin () const = 0;
  virtual const_node_iterator active_nodes_end () const = 0;

  virtual node_iterator local_nodes_begin () = 0;
  virtual node_iterator local_nodes_end () = 0;
  virtual const_node_iterator local_nodes_begin () const = 0;
  virtual const_node_iterator local_nodes_end () const = 0;
  virtual SimpleRange<node_iterator> local_node_ptr_range() = 0;
  virtual SimpleRange<const_node_iterator> local_node_ptr_range() const = 0;

  virtual node_iterator pid_nodes_begin (processor_id_type proc_id) = 0;
  virtual node_iterator pid_nodes_end (processor_id_type proc_id) = 0;
  virtual const_node_iterator pid_nodes_begin (processor_id_type proc_id) const = 0;
  virtual const_node_iterator pid_nodes_end (processor_id_type proc_id) const = 0;

  virtual node_iterator bid_nodes_begin (boundary_id_type bndry_id) = 0;
  virtual node_iterator bid_nodes_end (boundary_id_type bndry_id) = 0;
  virtual const_node_iterator bid_nodes_begin (boundary_id_type bndry_id) const = 0;
  virtual const_node_iterator bid_nodes_end (boundary_id_type bndry_id) const = 0;

  virtual node_iterator bnd_nodes_begin () = 0;
  virtual node_iterator bnd_nodes_end () = 0;
  virtual const_node_iterator bnd_nodes_begin () const = 0;
  virtual const_node_iterator bnd_nodes_end () const = 0;

  virtual node_iterator
  evaluable_nodes_begin (const DofMap & dof_map,
                         unsigned int var_num = libMesh::invalid_uint) = 0;

  virtual node_iterator
  evaluable_nodes_end (const DofMap & dof_map,
                       unsigned int var_num = libMesh::invalid_uint) = 0;

  virtual const_node_iterator
  evaluable_nodes_begin (const DofMap & dof_map,
                         unsigned int var_num = libMesh::invalid_uint) const = 0;

  virtual const_node_iterator
  evaluable_nodes_end (const DofMap & dof_map,
                       unsigned int var_num = libMesh::invalid_uint) const = 0;

  std::map<subdomain_id_type, std::string> & set_subdomain_name_map ()
  { return _block_id_to_name; }
  const std::map<subdomain_id_type, std::string> & get_subdomain_name_map () const
  { return _block_id_to_name; }


  void cache_elem_dims();

  void detect_interior_parents();


  std::unique_ptr<BoundaryInfo> boundary_info;


protected:

  unsigned int & set_n_partitions ()
  { return _n_parts; }

  unsigned int _n_parts;

  bool _is_prepared;

  mutable std::unique_ptr<PointLocatorBase> _point_locator;

  bool _count_lower_dim_elems_in_point_locator;

  std::unique_ptr<Partitioner> _partitioner;

#ifdef LIBMESH_ENABLE_UNIQUE_ID

  unique_id_type _next_unique_id;
#endif

  bool _skip_partitioning;

  bool _skip_renumber_nodes_and_elements;

  bool _allow_remote_element_removal;

  std::map<subdomain_id_type, std::string> _block_id_to_name;

  std::set<unsigned char> _elem_dims;

  unsigned char _spatial_dimension;

  std::unique_ptr<GhostingFunctor> _default_ghosting;

  std::set<GhostingFunctor *> _ghosting_functors;

  friend class Partitioner;

  friend class MeshInput<MeshBase>;

  friend class BoundaryInfo;
};











struct
MeshBase::element_iterator : variant_filter_iterator<MeshBase::Predicate, Elem *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  element_iterator (const IterType & d,
                    const IterType & e,
                    const PredType & p ) :
    variant_filter_iterator<MeshBase::Predicate, Elem *>(d,e,p) {}
};




struct
MeshBase::const_element_iterator : variant_filter_iterator<MeshBase::Predicate,
                                                           Elem * const,
                                                           Elem * const &,
                                                           Elem * const *>
{
  template <typename PredType, typename IterType>
  const_element_iterator (const IterType & d,
                          const IterType & e,
                          const PredType & p ) :
    variant_filter_iterator<MeshBase::Predicate, Elem * const, Elem * const &, Elem * const *>(d,e,p)  {}

  const_element_iterator (const MeshBase::element_iterator & rhs) :
    variant_filter_iterator<Predicate, Elem * const, Elem * const &, Elem * const *>(rhs) {}
};







struct
MeshBase::node_iterator : variant_filter_iterator<MeshBase::Predicate, Node *>
{
  template <typename PredType, typename IterType>
  node_iterator (const IterType & d,
                 const IterType & e,
                 const PredType & p ) :
    variant_filter_iterator<MeshBase::Predicate, Node *>(d,e,p) {}
};




struct
MeshBase::const_node_iterator : variant_filter_iterator<MeshBase::Predicate,
                                                        Node * const,
                                                        Node * const &,
                                                        Node * const *>
{
  template <typename PredType, typename IterType>
  const_node_iterator (const IterType & d,
                       const IterType & e,
                       const PredType & p ) :
    variant_filter_iterator<MeshBase::Predicate, Node * const, Node * const &, Node * const *>(d,e,p)  {}

  const_node_iterator (const MeshBase::node_iterator & rhs) :
    variant_filter_iterator<Predicate, Node * const, Node * const &, Node * const *>(rhs) {}
};


} // namespace libMesh

#endif // LIBMESH_MESH_BASE_H