distributed_mesh.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2026 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_DISTRIBUTED_MESH_H
#define LIBMESH_DISTRIBUTED_MESH_H
 
// Local Includes
#include "libmesh_config.h"
 
#if LIBMESH_MAPVECTOR_CHUNK_SIZE == 1
#  include "libmesh/mapvector.h"
#else
#  include "libmesh/chunked_mapvector.h"
#endif
 
#include "libmesh/unstructured_mesh.h"
 
// C++ Includes
#include <cstddef>
#include <memory>
#include <set>
 
namespace libMesh
{
 
// Forward declarations
class Elem;
class Node;
 
 
class DistributedMesh : public UnstructuredMesh
{
public:
 
  template <typename Obj>
#if LIBMESH_MAPVECTOR_CHUNK_SIZE == 1
  using dofobject_container = mapvector<Obj *, dof_id_type>;
#else
  using dofobject_container = chunked_mapvector<Obj *, dof_id_type, LIBMESH_MAPVECTOR_CHUNK_SIZE>;
#endif
 
  explicit
  DistributedMesh (const Parallel::Communicator & comm_in,
                   unsigned char dim=1);
 
  DistributedMesh (const MeshBase & other_mesh);
 
  DistributedMesh (const DistributedMesh & other_mesh);
 
  DistributedMesh(DistributedMesh &&) = delete;
 
  DistributedMesh & operator= (const DistributedMesh &) = delete;
 
  DistributedMesh & operator= (DistributedMesh && other_mesh);
 
  virtual MeshBase & assign(MeshBase && other_mesh) override;
 
  virtual bool subclass_locally_equals (const MeshBase & other_mesh) const override;
 
  virtual std::unique_ptr<MeshBase> clone () const override
  {
    auto returnval = std::make_unique<DistributedMesh>(*this);
#ifdef DEBUG
    libmesh_assert(*returnval == *this);
#endif
    return returnval;
  }
 
  virtual ~DistributedMesh();
 
  virtual void clear() override;
 
  virtual void clear_elems() override;
 
  virtual void redistribute () override;
 
  virtual void update_post_partitioning () override;
 
  virtual bool is_serial () const override final
  { return _is_serial; }
 
  virtual bool is_serial_on_zero () const override final
  { return _is_serial || _is_serial_on_proc_0; }
 
  virtual void set_distributed () override final
  { _is_serial = false;
    _is_serial_on_proc_0 = false; }
 
  virtual bool is_replicated () const override final
  { return false; }
 
  template <typename T>
  void libmesh_assert_valid_parallel_object_ids(const dofobject_container<T> &) const;
 
  virtual void libmesh_assert_valid_parallel_ids() const override;
 
  void libmesh_assert_valid_parallel_p_levels() const;
 
  void libmesh_assert_valid_parallel_flags() const;
 
  template <typename T>
  dof_id_type renumber_dof_objects (dofobject_container<T> &);
 
  virtual void renumber_nodes_and_elements () override;
 
  virtual void allgather() override;
 
  virtual void gather_to_zero() override;
 
  virtual void delete_remote_elements() override;
 
  virtual void add_extra_ghost_elem(Elem * e);
 
  virtual void clear_extra_ghost_elems() { _extra_ghost_elems.clear(); }
 
  virtual void clear_extra_ghost_elems(const std::set<Elem *> & extra_ghost_elems);
 
  const std::set<Elem *> & extra_ghost_elems() const { return _extra_ghost_elems; }
 
  // Cached methods that can be called in serial
  virtual dof_id_type n_nodes () const override final { return _n_nodes; }
  virtual dof_id_type max_node_id () const override final { return _max_node_id; }
  virtual void reserve_nodes (const dof_id_type) override final {}
  virtual dof_id_type n_elem () const override final { return _n_elem; }
  virtual dof_id_type n_active_elem () const override final;
  virtual dof_id_type max_elem_id () const override final { return _max_elem_id; }
  virtual void reserve_elem (const dof_id_type) override final {}
 
  // Parallel only method to update the caches
  virtual void update_parallel_id_counts () override;
 
  // And more parallel only methods to test non-cached values
  virtual dof_id_type parallel_n_nodes () const override;
  dof_id_type parallel_max_node_id () const;
  virtual dof_id_type parallel_n_elem () const override;
  dof_id_type parallel_max_elem_id () const;
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  virtual unique_id_type parallel_max_unique_id () const override;
  virtual void set_next_unique_id(unique_id_type id) override;
#endif
 
  virtual const Point & point (const dof_id_type i) const override final;
 
  virtual const Node * node_ptr (const dof_id_type i) const override final;
  virtual Node * node_ptr (const dof_id_type i) override final;
 
  virtual const Node * query_node_ptr (const dof_id_type i) const override final;
  virtual Node * query_node_ptr (const dof_id_type i) override final;
 
  virtual const Elem * elem_ptr (const dof_id_type i) const override final;
  virtual Elem * elem_ptr (const dof_id_type i) override final;
 
  virtual const Elem * query_elem_ptr (const dof_id_type i) const override final;
  virtual Elem * query_elem_ptr (const dof_id_type i) override final;
 
  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) override final;
  virtual Node * add_node (Node * n) override final;
  virtual Node * add_node (std::unique_ptr<Node> n) override final;
 
  virtual void own_node (Node & n) override final;
 
  virtual void delete_node (Node * n) override final;
  virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) override final;
  virtual Elem * add_elem (Elem * e) override final;
  virtual Elem * add_elem (std::unique_ptr<Elem> e) override final;
  virtual Elem * insert_elem (Elem * e) override final;
  virtual Elem * insert_elem (std::unique_ptr<Elem> e) override final;
  virtual void delete_elem (Elem * e) override final;
  virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) override final;
 
  virtual void fix_broken_node_and_element_numbering () override;
 
public:
  DECLARE_ELEM_ITERATORS(,,);
  DECLARE_ELEM_ITERATORS(active_,,);
  DECLARE_ELEM_ITERATORS(ancestor_,,)
  DECLARE_ELEM_ITERATORS(subactive_,,)
  DECLARE_ELEM_ITERATORS(local_,,)
  DECLARE_ELEM_ITERATORS(unpartitioned_,,)
  DECLARE_ELEM_ITERATORS(facelocal_,,)
  DECLARE_ELEM_ITERATORS(level_, unsigned int level, level)
  DECLARE_ELEM_ITERATORS(pid_, processor_id_type pid, pid)
  DECLARE_ELEM_ITERATORS(type_, ElemType type, type)
 
  DECLARE_ELEM_ITERATORS(active_subdomain_, subdomain_id_type sid, sid)
  DECLARE_ELEM_ITERATORS(active_subdomain_set_, std::set<subdomain_id_type> ss, ss)
 
  // Backwards compatibility
  virtual SimpleRange<element_iterator> active_subdomain_elements_ptr_range(subdomain_id_type sid) override final { return active_subdomain_element_ptr_range(sid); }
  virtual SimpleRange<const_element_iterator> active_subdomain_elements_ptr_range(subdomain_id_type sid) const override final { return active_subdomain_element_ptr_range(sid); }
  virtual SimpleRange<element_iterator> active_local_subdomain_elements_ptr_range(subdomain_id_type sid) override final { return active_local_subdomain_element_ptr_range(sid); }
  virtual SimpleRange<const_element_iterator> active_local_subdomain_elements_ptr_range(subdomain_id_type sid) const override final { return active_local_subdomain_element_ptr_range(sid); }
  virtual SimpleRange<element_iterator> active_subdomain_set_elements_ptr_range(std::set<subdomain_id_type> ss) override final { return active_subdomain_set_element_ptr_range(ss); }
  virtual SimpleRange<const_element_iterator> active_subdomain_set_elements_ptr_range(std::set<subdomain_id_type> ss) const override final { return active_subdomain_set_element_ptr_range(ss); }
 
  DECLARE_ELEM_ITERATORS(not_active_,,);
  DECLARE_ELEM_ITERATORS(not_ancestor_,,);
  DECLARE_ELEM_ITERATORS(not_subactive_,,);
  DECLARE_ELEM_ITERATORS(not_local_,,);
  DECLARE_ELEM_ITERATORS(not_level_, unsigned int level, level)
 
  DECLARE_ELEM_ITERATORS(active_local_,,)
  DECLARE_ELEM_ITERATORS(active_not_local_,,)
  DECLARE_ELEM_ITERATORS(active_unpartitioned_,,)
  DECLARE_ELEM_ITERATORS(active_type_, ElemType type, type)
  DECLARE_ELEM_ITERATORS(active_pid_, processor_id_type pid, pid)
  DECLARE_ELEM_ITERATORS(local_level_, unsigned int level, level)
  DECLARE_ELEM_ITERATORS(local_not_level_, unsigned int level, level)
  DECLARE_ELEM_ITERATORS(active_local_subdomain_, subdomain_id_type sid, sid)
  DECLARE_ELEM_ITERATORS(active_local_subdomain_set_, std::set<subdomain_id_type> ss, ss)
 
  DECLARE_ELEM_ITERATORS(semilocal_,,)
  DECLARE_ELEM_ITERATORS(ghost_,,)
  DECLARE_ELEM_ITERATORS(active_semilocal_,,)
 
  DECLARE_ELEM_ITERATORS(evaluable_, const DofMap & dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint, dof_map LIBMESH_COMMA var_num)
  DECLARE_ELEM_ITERATORS(multi_evaluable_, std::vector<const DofMap *> dof_maps, dof_maps)
 
#ifdef LIBMESH_ENABLE_AMR
  DECLARE_ELEM_ITERATORS(flagged_, unsigned char rflag, rflag)
 
  // Elem::refinement_flag() == rflag && Elem::processor_id() == pid
  DECLARE_ELEM_ITERATORS(flagged_pid_, unsigned char rflag LIBMESH_COMMA processor_id_type pid, rflag LIBMESH_COMMA pid)
#endif
 
  DECLARE_NODE_ITERATORS(,,)
  DECLARE_NODE_ITERATORS(active_,,)
  DECLARE_NODE_ITERATORS(local_,,)
  DECLARE_NODE_ITERATORS(bnd_,,)
  DECLARE_NODE_ITERATORS(pid_, processor_id_type pid, pid)
  DECLARE_NODE_ITERATORS(bid_, boundary_id_type bid, bid)
 
  DECLARE_NODE_ITERATORS(evaluable_, const DofMap & dof_map LIBMESH_COMMA unsigned int var_num = libMesh::invalid_uint, dof_map LIBMESH_COMMA var_num)
 
  DECLARE_NODE_ITERATORS(multi_evaluable_, std::vector<const DofMap *> dof_maps, dof_maps)
 
 
protected:
 
  virtual void move_nodes_and_elements(MeshBase && other_mesh) override;
 
  dofobject_container<Node> _nodes;
 
  dofobject_container<Elem> _elements;
 
  bool _is_serial;
 
  bool _is_serial_on_proc_0;
 
  bool _deleted_coarse_elements;
 
  dof_id_type _n_nodes, _n_elem, _max_node_id, _max_elem_id;
 
  dof_id_type _next_free_local_node_id,
    _next_free_local_elem_id;
  dof_id_type _next_free_unpartitioned_node_id,
    _next_free_unpartitioned_elem_id;
 
#ifdef LIBMESH_ENABLE_UNIQUE_ID
  unique_id_type _next_unpartitioned_unique_id;
#endif
 
  std::set<Elem *> _extra_ghost_elems;
 
private:
 
  typedef dofobject_container<Elem>::veclike_iterator             elem_iterator_imp;
  typedef dofobject_container<Elem>::const_veclike_iterator const_elem_iterator_imp;
 
  typedef dofobject_container<Node>::veclike_iterator             node_iterator_imp;
  typedef dofobject_container<Node>::const_veclike_iterator const_node_iterator_imp;
};
 
 
} // namespace libMesh
 
#endif // LIBMESH_DISTRIBUTED_MESH_H