parallel_mesh.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 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_PARALLEL_MESH_H
#define LIBMESH_PARALLEL_MESH_H

// Local Includes -----------------------------------
#include "libmesh/mapvector.h"
#include "libmesh/unstructured_mesh.h"

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

namespace libMesh
{

// Forward declarations
class Elem;
class Node;


// ------------------------------------------------------------
// UnstructuredMesh class definition
class ParallelMesh : public UnstructuredMesh
{
public:

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

#ifndef LIBMESH_DISABLE_COMMWORLD

  explicit
  ParallelMesh (unsigned char dim=1);
#endif


  ParallelMesh (const UnstructuredMesh& other_mesh);

  ParallelMesh (const ParallelMesh& other_mesh);

  virtual UniquePtr<MeshBase> clone () const
  { return UniquePtr<MeshBase>(new ParallelMesh(*this)); }

  virtual ~ParallelMesh();

  virtual void clear();

  virtual void redistribute ();

  virtual void update_post_partitioning ();

  virtual bool is_serial () const
  { return _is_serial; }

  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;

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

  virtual void allgather();

  virtual void delete_remote_elements();

  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 { return _n_nodes; }
  virtual dof_id_type max_node_id () const { return _max_node_id; }
  virtual void reserve_nodes (const dof_id_type) { }
  virtual dof_id_type n_elem () const { return _n_elem; }
  virtual dof_id_type n_active_elem () const;
  virtual dof_id_type max_elem_id () const { return _max_elem_id; }
  virtual void reserve_elem (const dof_id_type) { }

  // Parallel only method to update the caches
  virtual void update_parallel_id_counts ();

  // And more parallel only methods to test non-cached values
  dof_id_type parallel_n_nodes () const;
  dof_id_type parallel_max_node_id () const;
  dof_id_type parallel_n_elem () const;
  dof_id_type parallel_max_elem_id () const;

  virtual const Point& point (const dof_id_type i) const ;
  virtual const Node&  node  (const dof_id_type i) const ;
  virtual Node& node (const dof_id_type i) ;
  virtual const Node* node_ptr (const dof_id_type i) const ;
  virtual Node* node_ptr (const dof_id_type i) ;
  virtual const Node* query_node_ptr (const dof_id_type i) const ;
  virtual Node* query_node_ptr (const dof_id_type i) ;
  virtual const Elem* elem (const dof_id_type i) const ;
  virtual Elem* elem (const dof_id_type i) ;
  virtual const Elem* query_elem (const dof_id_type i) const ;
  virtual Elem* query_elem (const dof_id_type i) ;

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

  virtual Node* insert_node(Node* n);

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

  virtual void fix_broken_node_and_element_numbering ();

public:
  element_iterator elements_begin ();
  element_iterator elements_end   ();

  element_iterator active_elements_begin ();
  element_iterator active_elements_end   ();

  element_iterator ancestor_elements_begin ();
  element_iterator ancestor_elements_end   ();

  element_iterator subactive_elements_begin ();
  element_iterator subactive_elements_end   ();

  element_iterator not_active_elements_begin ();
  element_iterator not_active_elements_end   ();

  element_iterator not_ancestor_elements_begin ();
  element_iterator not_ancestor_elements_end   ();

  element_iterator not_subactive_elements_begin ();
  element_iterator not_subactive_elements_end   ();

  element_iterator local_elements_begin ();
  element_iterator local_elements_end   ();

  element_iterator semilocal_elements_begin ();
  element_iterator semilocal_elements_end   ();

  element_iterator facelocal_elements_begin ();
  element_iterator facelocal_elements_end   ();

  element_iterator not_local_elements_begin ();
  element_iterator not_local_elements_end   ();

  element_iterator active_local_elements_begin ();
  element_iterator active_local_elements_end   ();

  element_iterator active_not_local_elements_begin ();
  element_iterator active_not_local_elements_end   ();

  element_iterator level_elements_begin (const unsigned int level);
  element_iterator level_elements_end   (const unsigned int level);

  element_iterator not_level_elements_begin (const unsigned int level);
  element_iterator not_level_elements_end   (const unsigned int level);

  element_iterator local_level_elements_begin (const unsigned int level);
  element_iterator local_level_elements_end   (const unsigned int level);

  element_iterator local_not_level_elements_begin (const unsigned int level);
  element_iterator local_not_level_elements_end   (const unsigned int level);

  element_iterator pid_elements_begin (const processor_id_type proc_id);
  element_iterator pid_elements_end   (const processor_id_type proc_id);

  element_iterator type_elements_begin (const ElemType type);
  element_iterator type_elements_end   (const ElemType type);

  element_iterator active_type_elements_begin (const ElemType type);
  element_iterator active_type_elements_end   (const ElemType type);

  element_iterator active_pid_elements_begin (const processor_id_type proc_id);
  element_iterator active_pid_elements_end   (const processor_id_type proc_id);

  element_iterator unpartitioned_elements_begin ();
  element_iterator unpartitioned_elements_end ();

  element_iterator active_local_subdomain_elements_begin (const subdomain_id_type subdomain_id);
  element_iterator active_local_subdomain_elements_end   (const subdomain_id_type subdomain_id);

  element_iterator active_subdomain_elements_begin (const subdomain_id_type subdomain_id);
  element_iterator active_subdomain_elements_end   (const subdomain_id_type subdomain_id);


  const_element_iterator elements_begin() const;
  const_element_iterator elements_end()   const;

  const_element_iterator active_elements_begin() const;
  const_element_iterator active_elements_end()   const;

  const_element_iterator ancestor_elements_begin() const;
  const_element_iterator ancestor_elements_end()   const;

  const_element_iterator subactive_elements_begin() const;
  const_element_iterator subactive_elements_end()   const;

  const_element_iterator not_active_elements_begin() const;
  const_element_iterator not_active_elements_end()   const;

  const_element_iterator not_ancestor_elements_begin() const;
  const_element_iterator not_ancestor_elements_end()   const;

  const_element_iterator not_subactive_elements_begin() const;
  const_element_iterator not_subactive_elements_end()   const;

  const_element_iterator local_elements_begin () const;
  const_element_iterator local_elements_end   () const;

  const_element_iterator semilocal_elements_begin () const;
  const_element_iterator semilocal_elements_end   () const;

  const_element_iterator facelocal_elements_begin () const;
  const_element_iterator facelocal_elements_end   () const;

  const_element_iterator not_local_elements_begin () const;
  const_element_iterator not_local_elements_end   () const;

  const_element_iterator active_local_elements_begin () const;
  const_element_iterator active_local_elements_end   () const;

  const_element_iterator active_not_local_elements_begin () const;
  const_element_iterator active_not_local_elements_end   () const;

  const_element_iterator level_elements_begin (const unsigned int level) const;
  const_element_iterator level_elements_end   (const unsigned int level) const;

  const_element_iterator not_level_elements_begin (const unsigned int level) const;
  const_element_iterator not_level_elements_end   (const unsigned int level) const;

  const_element_iterator local_level_elements_begin (const unsigned int level) const;
  const_element_iterator local_level_elements_end   (const unsigned int level) const;

  const_element_iterator local_not_level_elements_begin (const unsigned int level) const;
  const_element_iterator local_not_level_elements_end   (const unsigned int level) const;

  const_element_iterator pid_elements_begin (const processor_id_type proc_id) const;
  const_element_iterator pid_elements_end   (const processor_id_type proc_id) const;

  const_element_iterator type_elements_begin (const ElemType type) const;
  const_element_iterator type_elements_end   (const ElemType type) const;

  const_element_iterator active_type_elements_begin (const ElemType type) const;
  const_element_iterator active_type_elements_end   (const ElemType type) const;

  const_element_iterator active_pid_elements_begin (const processor_id_type proc_id) const;
  const_element_iterator active_pid_elements_end   (const processor_id_type proc_id) const;

  const_element_iterator unpartitioned_elements_begin () const;
  const_element_iterator unpartitioned_elements_end () const;

  const_element_iterator active_local_subdomain_elements_begin (const subdomain_id_type subdomain_id) const;
  const_element_iterator active_local_subdomain_elements_end   (const subdomain_id_type subdomain_id) const;

  const_element_iterator active_subdomain_elements_begin (const subdomain_id_type subdomain_id) const;
  const_element_iterator active_subdomain_elements_end   (const subdomain_id_type subdomain_id) const;





  node_iterator nodes_begin();
  node_iterator nodes_end();

  node_iterator active_nodes_begin();
  node_iterator active_nodes_end();

  node_iterator local_nodes_begin  ();
  node_iterator local_nodes_end    ();

  node_iterator pid_nodes_begin (const processor_id_type proc_id);
  node_iterator pid_nodes_end   (const processor_id_type proc_id);

  const_node_iterator nodes_begin() const;
  const_node_iterator nodes_end()   const;

  const_node_iterator active_nodes_begin() const;
  const_node_iterator active_nodes_end()   const;

  const_node_iterator local_nodes_begin  () const;
  const_node_iterator local_nodes_end    () const;

  const_node_iterator pid_nodes_begin (const processor_id_type proc_id) const;
  const_node_iterator pid_nodes_end   (const processor_id_type proc_id) const;

protected:

#ifdef LIBMESH_ENABLE_UNIQUE_ID
  virtual void assign_unique_ids();
#endif

  mapvector<Node*,dof_id_type> _nodes;

  mapvector<Elem*,dof_id_type> _elements;

  bool _is_serial;

  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;

  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_PARALLEL_MESH_H