distributed_mesh.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_DISTRIBUTED_MESH_H
#define LIBMESH_DISTRIBUTED_MESH_H

// Local Includes
#include "libmesh/mapvector.h"
#include "libmesh/unstructured_mesh.h"
#include "libmesh/auto_ptr.h" // libmesh_make_unique

// C++ Includes
#include <cstddef>
#include <set>

namespace libMesh
{

// Forward declarations
class Elem;
class Node;


class DistributedMesh : public UnstructuredMesh
{
public:

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

  DistributedMesh (const UnstructuredMesh & other_mesh);

  DistributedMesh (const DistributedMesh & other_mesh);

  DistributedMesh(DistributedMesh &&) = default;

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

  virtual std::unique_ptr<MeshBase> clone () const override
  { return libmesh_make_unique<DistributedMesh>(*this); }

  virtual ~DistributedMesh();

  virtual void clear() override;

  virtual void redistribute () override;

  virtual void update_post_partitioning () override;

  virtual bool is_serial () const override
  { return _is_serial; }

  virtual bool is_serial_on_zero () const override
  { return _is_serial || _is_serial_on_proc_0; }

  virtual void set_distributed () override
  { _is_serial = false;
    _is_serial_on_proc_0 = false; }

  virtual bool is_replicated () const override
  { return false; }

  template <typename T>
  void libmesh_assert_valid_parallel_object_ids(const mapvector<T *,dof_id_type> &) 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 (mapvector<T *,dof_id_type> &);

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

  // Cached methods that can be called in serial
  virtual dof_id_type n_nodes () const override { return _n_nodes; }
  virtual dof_id_type max_node_id () const override { return _max_node_id; }
  virtual void reserve_nodes (const dof_id_type) override {}
  virtual dof_id_type n_elem () const override { return _n_elem; }
  virtual dof_id_type n_active_elem () const override;
  virtual dof_id_type max_elem_id () const override { return _max_elem_id; }
  virtual void reserve_elem (const dof_id_type) override {}

  // 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;
#endif

  virtual const Point & point (const dof_id_type i) const override;

  virtual const Node * node_ptr (const dof_id_type i) const override;
  virtual Node * node_ptr (const dof_id_type i) override;

  virtual const Node * query_node_ptr (const dof_id_type i) const override;
  virtual Node * query_node_ptr (const dof_id_type i) override;

  virtual const Elem * elem_ptr (const dof_id_type i) const override;
  virtual Elem * elem_ptr (const dof_id_type i) override;

  virtual const Elem * query_elem_ptr (const dof_id_type i) const override;
  virtual Elem * query_elem_ptr (const dof_id_type i) override;

  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;
  virtual Node * add_node (Node * n) override;

  virtual Node * insert_node(Node * n) override;

  virtual void own_node (Node & n) override;

  virtual void delete_node (Node * n) override;
  virtual void renumber_node (dof_id_type old_id, dof_id_type new_id) override;
  virtual Elem * add_elem (Elem * e) override;
  virtual Elem * insert_elem (Elem * e) override;
  virtual void delete_elem (Elem * e) override;
  virtual void renumber_elem (dof_id_type old_id, dof_id_type new_id) override;

  virtual void fix_broken_node_and_element_numbering () override;

public:
  virtual element_iterator elements_begin () override;
  virtual element_iterator elements_end () override;
  virtual const_element_iterator elements_begin() const override;
  virtual const_element_iterator elements_end() const override;
  virtual SimpleRange<element_iterator> element_ptr_range() override { return {elements_begin(), elements_end()}; }
  virtual SimpleRange<const_element_iterator> element_ptr_range() const override { return {elements_begin(), elements_end()}; }

  virtual element_iterator active_elements_begin () override;
  virtual element_iterator active_elements_end () override;
  virtual const_element_iterator active_elements_begin() const override;
  virtual const_element_iterator active_elements_end() const override;
  virtual SimpleRange<element_iterator> active_element_ptr_range() override { return {active_elements_begin(), active_elements_end()}; }
  virtual SimpleRange<const_element_iterator> active_element_ptr_range() const override  { return {active_elements_begin(), active_elements_end()}; }

  virtual element_iterator ancestor_elements_begin () override;
  virtual element_iterator ancestor_elements_end () override;
  virtual const_element_iterator ancestor_elements_begin() const override;
  virtual const_element_iterator ancestor_elements_end() const override;

  virtual element_iterator subactive_elements_begin () override;
  virtual element_iterator subactive_elements_end () override;
  virtual const_element_iterator subactive_elements_begin() const override;
  virtual const_element_iterator subactive_elements_end() const override;

  virtual element_iterator not_active_elements_begin () override;
  virtual element_iterator not_active_elements_end () override;
  virtual const_element_iterator not_active_elements_begin() const override;
  virtual const_element_iterator not_active_elements_end() const override;

  virtual element_iterator not_ancestor_elements_begin () override;
  virtual element_iterator not_ancestor_elements_end () override;
  virtual const_element_iterator not_ancestor_elements_begin() const override;
  virtual const_element_iterator not_ancestor_elements_end() const override;

  virtual element_iterator not_subactive_elements_begin () override;
  virtual element_iterator not_subactive_elements_end () override;
  virtual const_element_iterator not_subactive_elements_begin() const override;
  virtual const_element_iterator not_subactive_elements_end() const override;

  virtual element_iterator local_elements_begin () override;
  virtual element_iterator local_elements_end () override;
  virtual const_element_iterator local_elements_begin () const override;
  virtual const_element_iterator local_elements_end () const override;

  virtual element_iterator semilocal_elements_begin () override;
  virtual element_iterator semilocal_elements_end () override;
  virtual const_element_iterator semilocal_elements_begin () const override;
  virtual const_element_iterator semilocal_elements_end () const override;

  virtual element_iterator active_semilocal_elements_begin () override;
  virtual element_iterator active_semilocal_elements_end () override;
  virtual const_element_iterator active_semilocal_elements_begin () const override;
  virtual const_element_iterator active_semilocal_elements_end () const override;

  virtual element_iterator facelocal_elements_begin () override;
  virtual element_iterator facelocal_elements_end () override;
  virtual const_element_iterator facelocal_elements_begin () const override;
  virtual const_element_iterator facelocal_elements_end () const override;

  virtual element_iterator not_local_elements_begin () override;
  virtual element_iterator not_local_elements_end () override;
  virtual const_element_iterator not_local_elements_begin () const override;
  virtual const_element_iterator not_local_elements_end () const override;

  virtual element_iterator active_local_elements_begin () override;
  virtual element_iterator active_local_elements_end () override;
  virtual const_element_iterator active_local_elements_begin () const override;
  virtual const_element_iterator active_local_elements_end () const override;
  virtual SimpleRange<element_iterator> active_local_element_ptr_range() override { return {active_local_elements_begin(), active_local_elements_end()}; }
  virtual SimpleRange<const_element_iterator> active_local_element_ptr_range() const override  { return {active_local_elements_begin(), active_local_elements_end()}; }

  virtual element_iterator active_not_local_elements_begin () override;
  virtual element_iterator active_not_local_elements_end () override;
  virtual const_element_iterator active_not_local_elements_begin () const override;
  virtual const_element_iterator active_not_local_elements_end () const override;

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

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

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

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

  virtual element_iterator pid_elements_begin (processor_id_type proc_id) override;
  virtual element_iterator pid_elements_end (processor_id_type proc_id) override;
  virtual const_element_iterator pid_elements_begin (processor_id_type proc_id) const override;
  virtual const_element_iterator pid_elements_end (processor_id_type proc_id) const override;

  virtual element_iterator type_elements_begin (ElemType type) override;
  virtual element_iterator type_elements_end (ElemType type) override;
  virtual const_element_iterator type_elements_begin (ElemType type) const override;
  virtual const_element_iterator type_elements_end (ElemType type) const override;

  virtual element_iterator active_type_elements_begin (ElemType type) override;
  virtual element_iterator active_type_elements_end (ElemType type) override;
  virtual const_element_iterator active_type_elements_begin (ElemType type) const override;
  virtual const_element_iterator active_type_elements_end (ElemType type) const override;

  virtual element_iterator active_pid_elements_begin (processor_id_type proc_id) override;
  virtual element_iterator active_pid_elements_end (processor_id_type proc_id) override;
  virtual const_element_iterator active_pid_elements_begin (processor_id_type proc_id) const override;
  virtual const_element_iterator active_pid_elements_end (processor_id_type proc_id) const override;

  virtual element_iterator unpartitioned_elements_begin () override;
  virtual element_iterator unpartitioned_elements_end () override;
  virtual const_element_iterator unpartitioned_elements_begin () const override;
  virtual const_element_iterator unpartitioned_elements_end () const override;

  virtual element_iterator active_unpartitioned_elements_begin () override;
  virtual element_iterator active_unpartitioned_elements_end () override;
  virtual const_element_iterator active_unpartitioned_elements_begin () const override;
  virtual const_element_iterator active_unpartitioned_elements_end () const override;

  virtual element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) override;
  virtual element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) override;
  virtual const_element_iterator active_local_subdomain_elements_begin (subdomain_id_type subdomain_id) const override;
  virtual const_element_iterator active_local_subdomain_elements_end (subdomain_id_type subdomain_id) const override;

  virtual element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) override;
  virtual element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) override;
  virtual const_element_iterator active_subdomain_elements_begin (subdomain_id_type subdomain_id) const override;
  virtual const_element_iterator active_subdomain_elements_end (subdomain_id_type subdomain_id) const override;

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

  virtual element_iterator ghost_elements_begin () override;
  virtual element_iterator ghost_elements_end () override;
  virtual const_element_iterator ghost_elements_begin () const override;
  virtual const_element_iterator ghost_elements_end () const override;

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

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

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

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

#ifdef LIBMESH_ENABLE_AMR
  virtual element_iterator flagged_elements_begin (unsigned char rflag) override;
  virtual element_iterator flagged_elements_end (unsigned char rflag) override;
  virtual const_element_iterator flagged_elements_begin (unsigned char rflag) const override;
  virtual const_element_iterator flagged_elements_end (unsigned char rflag) const override;

  virtual element_iterator flagged_pid_elements_begin (unsigned char rflag,
                                                       processor_id_type pid) override;
  virtual element_iterator flagged_pid_elements_end (unsigned char rflag,
                                                     processor_id_type pid) override;
  virtual const_element_iterator flagged_pid_elements_begin (unsigned char rflag,
                                                             processor_id_type pid) const override;
  virtual const_element_iterator flagged_pid_elements_end (unsigned char rflag,
                                                           processor_id_type pid) const override;
#endif // LIBMESH_ENABLE_AMR

  virtual node_iterator nodes_begin () override;
  virtual node_iterator nodes_end () override;
  virtual const_node_iterator nodes_begin () const override;
  virtual const_node_iterator nodes_end () const override;
  virtual SimpleRange<node_iterator> node_ptr_range() override { return {nodes_begin(), nodes_end()}; }
  virtual SimpleRange<const_node_iterator> node_ptr_range() const override { return {nodes_begin(), nodes_end()}; }

  virtual node_iterator active_nodes_begin () override;
  virtual node_iterator active_nodes_end () override;
  virtual const_node_iterator active_nodes_begin () const override;
  virtual const_node_iterator active_nodes_end () const override;

  virtual node_iterator local_nodes_begin () override;
  virtual node_iterator local_nodes_end () override;
  virtual const_node_iterator local_nodes_begin () const override;
  virtual const_node_iterator local_nodes_end () const override;
  virtual SimpleRange<node_iterator> local_node_ptr_range() override { return {local_nodes_begin(), local_nodes_end()}; }
  virtual SimpleRange<const_node_iterator> local_node_ptr_range() const override { return {local_nodes_begin(), local_nodes_end()}; }

  virtual node_iterator pid_nodes_begin (processor_id_type proc_id) override;
  virtual node_iterator pid_nodes_end (processor_id_type proc_id) override;
  virtual const_node_iterator pid_nodes_begin (processor_id_type proc_id) const override;
  virtual const_node_iterator pid_nodes_end (processor_id_type proc_id) const override;

  virtual node_iterator bid_nodes_begin (boundary_id_type bndry_id) override;
  virtual node_iterator bid_nodes_end (boundary_id_type bndry_id) override;
  virtual const_node_iterator bid_nodes_begin (boundary_id_type bndry_id) const override;
  virtual const_node_iterator bid_nodes_end (boundary_id_type bndry_id) const override;

  virtual node_iterator bnd_nodes_begin () override;
  virtual node_iterator bnd_nodes_end () override;
  virtual const_node_iterator bnd_nodes_begin () const override;
  virtual const_node_iterator bnd_nodes_end () const override;

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


protected:

  mapvector<Node *, dof_id_type> _nodes;

  mapvector<Elem *, dof_id_type> _elements;

  bool _is_serial;

  bool _is_serial_on_proc_0;

  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 mapvector<Elem *, dof_id_type>::veclike_iterator             elem_iterator_imp;
  typedef mapvector<Elem *, dof_id_type>::const_veclike_iterator const_elem_iterator_imp;

  typedef mapvector<Node *, dof_id_type>::veclike_iterator             node_iterator_imp;
  typedef mapvector<Node *, dof_id_type>::const_veclike_iterator const_node_iterator_imp;
};


} // namespace libMesh

#endif // LIBMESH_DISTRIBUTED_MESH_H