Reference documentation for deal.II version 8.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Classes | Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
parallel::distributed::Triangulation< dim, spacedim > Class Template Reference

#include <tria.h>

Inheritance diagram for parallel::distributed::Triangulation< dim, spacedim >:
[legend]

Classes

struct  NumberCache
 

Public Types

enum  Settings { default_setting = 0x0, mesh_reconstruction_after_repartitioning = 0x1, construct_multigrid_hierarchy = 0x2 }
 
enum  CellStatus { CELL_PERSIST, CELL_REFINE, CELL_COARSEN, CELL_INVALID }
 
typedef ::Triangulation< dim,
spacedim >
::active_cell_iterator 
active_cell_iterator
 
typedef ::Triangulation< dim,
spacedim >::cell_iterator 
cell_iterator
 
- Public Types inherited from Triangulation< dim, spacedim >
enum  MeshSmoothing {
  none = 0x0, limit_level_difference_at_vertices = 0x1, eliminate_unrefined_islands = 0x2, patch_level_1 = 0x4,
  coarsest_level_1 = 0x8, allow_anisotropic_smoothing = 0x10, eliminate_refined_inner_islands = 0x100, eliminate_refined_boundary_islands = 0x200,
  do_not_produce_unrefined_islands = 0x400, smoothing_on_refinement, smoothing_on_coarsening, maximum_smoothing = 0xffff ^ allow_anisotropic_smoothing
}
 
typedef TriaIterator
< CellAccessor< dim, spacedim > > 
cell_iterator
 
typedef TriaActiveIterator
< CellAccessor< dim, spacedim > > 
active_cell_iterator
 
typedef TriaIterator
< TriaAccessor< dim-1, dim,
spacedim > > 
face_iterator
 
typedef TriaActiveIterator
< TriaAccessor< dim-1, dim,
spacedim > > 
active_face_iterator
 
typedef
IteratorSelector::line_iterator 
line_iterator
 
typedef
IteratorSelector::active_line_iterator 
active_line_iterator
 
typedef
IteratorSelector::quad_iterator 
quad_iterator
 
typedef
IteratorSelector::active_quad_iterator 
active_quad_iterator
 
typedef
IteratorSelector::hex_iterator 
hex_iterator
 
typedef
IteratorSelector::active_hex_iterator 
active_hex_iterator
 

Public Member Functions

 Triangulation (MPI_Comm mpi_communicator, const typename::Triangulation< dim, spacedim >::MeshSmoothing smooth_grid=(::Triangulation< dim, spacedim >::none), const Settings settings=default_setting)
 
virtual ~Triangulation ()
 
virtual void clear ()
 
virtual void copy_triangulation (const ::Triangulation< dim, spacedim > &old_tria)
 
virtual void create_triangulation (const std::vector< Point< spacedim > > &vertices, const std::vector< CellData< dim > > &cells, const SubCellData &subcelldata)
 
virtual void execute_coarsening_and_refinement ()
 
types::subdomain_id locally_owned_subdomain () const
 
unsigned int n_locally_owned_active_cells () const
 
types::global_dof_index n_global_active_cells () const
 
virtual unsigned int n_global_levels () const
 
const std::vector< unsigned int > & n_locally_owned_active_cells_per_processor () const
 
MPI_Comm get_communicator () const
 
virtual std::size_t memory_consumption () const
 
virtual std::size_t memory_consumption_p4est () const
 
void write_mesh_vtk (const char *file_basename) const
 
unsigned int get_checksum () const
 
void save (const char *filename) const
 
void load (const char *filename)
 
unsigned int register_data_attach (const std::size_t size, const std_cxx1x::function< void(const cell_iterator &, const CellStatus, void *)> &pack_callback)
 
void notify_ready_to_unpack (const unsigned int offset, const std_cxx1x::function< void(const cell_iterator &, const CellStatus, const void *)> &unpack_callback)
 
const std::vector
< types::global_dof_index > & 
get_p4est_tree_to_coarse_cell_permutation () const
 
void add_periodicity (const std::vector< GridTools::PeriodicFacePair< cell_iterator > > &)
 
- Public Member Functions inherited from Triangulation< dim, spacedim >
 Triangulation (const MeshSmoothing smooth_grid=none, const bool check_for_distorted_cells=false)
 
 Triangulation (const Triangulation< dim, spacedim > &t)
 
virtual void set_mesh_smoothing (const MeshSmoothing mesh_smoothing)
 
void set_boundary (const types::boundary_id number, const Boundary< dim, spacedim > &boundary_object)
 
void set_boundary (const types::boundary_id number)
 
const Boundary< dim, spacedim > & get_boundary (const types::boundary_id number) const
 
std::vector< types::boundary_idget_boundary_indicators () const
 
virtual void copy_triangulation (const Triangulation< dim, spacedim > &old_tria)
 
virtual void create_triangulation_compatibility (const std::vector< Point< spacedim > > &vertices, const std::vector< CellData< dim > > &cells, const SubCellData &subcelldata)
 
void flip_all_direction_flags ()
 
void distort_random (const double factor, const bool keep_boundary=true) DEAL_II_DEPRECATED
 
template<class Archive >
void save (Archive &ar, const unsigned int version) const
 
template<class Archive >
void load (Archive &ar, const unsigned int version)
 
void set_all_refine_flags ()
 
void refine_global (const unsigned int times=1)
 
bool prepare_coarsening_and_refinement ()
 
void save_refine_flags (std::ostream &out) const
 
void save_refine_flags (std::vector< bool > &v) const
 
void load_refine_flags (std::istream &in)
 
void load_refine_flags (const std::vector< bool > &v)
 
void save_coarsen_flags (std::ostream &out) const
 
void save_coarsen_flags (std::vector< bool > &v) const
 
void load_coarsen_flags (std::istream &out)
 
void load_coarsen_flags (const std::vector< bool > &v)
 
bool get_anisotropic_refinement_flag () const
 
void clear_user_flags ()
 
void save_user_flags (std::ostream &out) const
 
void save_user_flags (std::vector< bool > &v) const
 
void load_user_flags (std::istream &in)
 
void load_user_flags (const std::vector< bool > &v)
 
void clear_user_flags_line ()
 
void save_user_flags_line (std::ostream &out) const
 
void save_user_flags_line (std::vector< bool > &v) const
 
void load_user_flags_line (std::istream &in)
 
void load_user_flags_line (const std::vector< bool > &v)
 
void clear_user_flags_quad ()
 
void save_user_flags_quad (std::ostream &out) const
 
void save_user_flags_quad (std::vector< bool > &v) const
 
void load_user_flags_quad (std::istream &in)
 
void load_user_flags_quad (const std::vector< bool > &v)
 
void clear_user_flags_hex ()
 
void save_user_flags_hex (std::ostream &out) const
 
void save_user_flags_hex (std::vector< bool > &v) const
 
void load_user_flags_hex (std::istream &in)
 
void load_user_flags_hex (const std::vector< bool > &v)
 
void clear_user_data ()
 
void clear_user_pointers () DEAL_II_DEPRECATED
 
void save_user_indices (std::vector< unsigned int > &v) const
 
void load_user_indices (const std::vector< unsigned int > &v)
 
void save_user_pointers (std::vector< void * > &v) const
 
void load_user_pointers (const std::vector< void * > &v)
 
void save_user_indices_line (std::vector< unsigned int > &v) const
 
void load_user_indices_line (const std::vector< unsigned int > &v)
 
void save_user_indices_quad (std::vector< unsigned int > &v) const
 
void load_user_indices_quad (const std::vector< unsigned int > &v)
 
void save_user_indices_hex (std::vector< unsigned int > &v) const
 
void load_user_indices_hex (const std::vector< unsigned int > &v)
 
void save_user_pointers_line (std::vector< void * > &v) const
 
void load_user_pointers_line (const std::vector< void * > &v)
 
void save_user_pointers_quad (std::vector< void * > &v) const
 
void load_user_pointers_quad (const std::vector< void * > &v)
 
void save_user_pointers_hex (std::vector< void * > &v) const
 
void load_user_pointers_hex (const std::vector< void * > &v)
 
cell_iterator begin (const unsigned int level=0) const
 
active_cell_iterator begin_active (const unsigned int level=0) const
 
cell_iterator end () const
 
cell_iterator end (const unsigned int level) const
 
active_cell_iterator end_active (const unsigned int level) const
 
cell_iterator last () const
 
active_cell_iterator last_active () const
 
face_iterator begin_face () const
 
active_face_iterator begin_active_face () const
 
face_iterator end_face () const
 
unsigned int n_lines () const
 
unsigned int n_lines (const unsigned int level) const
 
unsigned int n_active_lines () const
 
unsigned int n_active_lines (const unsigned int level) const
 
unsigned int n_quads () const
 
unsigned int n_quads (const unsigned int level) const
 
unsigned int n_active_quads () const
 
unsigned int n_active_quads (const unsigned int level) const
 
unsigned int n_hexs () const
 
unsigned int n_hexs (const unsigned int level) const
 
unsigned int n_active_hexs () const
 
unsigned int n_active_hexs (const unsigned int level) const
 
unsigned int n_cells () const
 
unsigned int n_cells (const unsigned int level) const
 
unsigned int n_active_cells () const
 
unsigned int n_active_cells (const unsigned int level) const
 
unsigned int n_faces () const
 
unsigned int n_active_faces () const
 
unsigned int n_levels () const
 
unsigned int n_vertices () const
 
const std::vector< Point
< spacedim > > & 
get_vertices () const
 
unsigned int n_used_vertices () const
 
bool vertex_used (const unsigned int index) const
 
const std::vector< bool > & get_used_vertices () const
 
unsigned int max_adjacent_cells () const
 
unsigned int n_raw_lines () const
 
unsigned int n_raw_lines (const unsigned int level) const
 
unsigned int n_raw_quads () const
 
unsigned int n_raw_quads (const unsigned int level) const
 
unsigned int n_raw_hexs () const
 
unsigned int n_raw_hexs (const unsigned int level) const
 
unsigned int n_raw_cells (const unsigned int level) const
 
unsigned int n_raw_faces () const
 
 DeclException1 (ExcInvalidLevel, int,<< "The given level "<< arg1<< " is not in the valid range!")
 
 DeclException0 (ExcTriangulationNotEmpty)
 
 DeclException0 (ExcGridReadError)
 
 DeclException0 (ExcFacesHaveNoLevel)
 
 DeclException1 (ExcEmptyLevel, int,<< "You tried to do something on level "<< arg1<< ", but this level is empty.")
 
 DeclException0 (ExcNonOrientableTriangulation)
 
void add_refinement_listener (RefinementListener &listener) const DEAL_II_DEPRECATED
 
void remove_refinement_listener (RefinementListener &listener) const DEAL_II_DEPRECATED
 
- Public Member Functions inherited from Subscriptor
 Subscriptor ()
 
 Subscriptor (const Subscriptor &)
 
virtual ~Subscriptor ()
 
Subscriptoroperator= (const Subscriptor &)
 
void subscribe (const char *identifier=0) const
 
void unsubscribe (const char *identifier=0) const
 
unsigned int n_subscriptions () const
 
void list_subscribers () const
 
 DeclException3 (ExcInUse, int, char *, std::string &,<< "Object of class "<< arg2<< " is still used by "<< arg1<< " other objects.\n"<< "(Additional information: "<< arg3<< ")\n"<< "Note the entry in the Frequently Asked Questions of "<< "deal.II (linked to from http://www.dealii.org/) for "<< "more information on what this error means.")
 
 DeclException2 (ExcNoSubscriber, char *, char *,<< "No subscriber with identifier \""<< arg2<< "\" did subscribe to this object of class "<< arg1)
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 

Private Types

typedef std_cxx1x::function
< void(typename Triangulation
< dim, spacedim >
::cell_iterator, CellStatus,
void *) > 
pack_callback_t
 
typedef std::pair< unsigned
int, pack_callback_t > 
callback_pair_t
 
typedef std::list
< callback_pair_t > 
callback_list_t
 

Private Member Functions

typename::internal::p4est::types
< dim >::tree * 
init_tree (const int dealii_coarse_cell_index) const
 
void setup_coarse_cell_to_p4est_tree_permutation ()
 
void copy_new_triangulation_to_p4est (::internal::int2type< 2 >)
 
void copy_new_triangulation_to_p4est (::internal::int2type< 3 >)
 
void copy_local_forest_to_triangulation ()
 
void update_number_cache ()
 
void attach_mesh_data ()
 
void fill_vertices_with_ghost_neighbors (std::map< unsigned int, std::set<::types::subdomain_id > > &vertices_with_ghost_neighbors)
 

Private Attributes

MPI_Comm mpi_communicator
 
Settings settings
 
types::subdomain_id my_subdomain
 
bool triangulation_has_content
 
NumberCache number_cache
 
typename::internal::p4est::types
< dim >::connectivity * 
connectivity
 
typename::internal::p4est::types
< dim >::forest * 
parallel_forest
 
typename::internal::p4est::types
< dim >::ghost * 
parallel_ghost
 
bool refinement_in_progress
 
unsigned int attached_data_size
 
unsigned int n_attached_datas
 
unsigned int n_attached_deserialize
 
callback_list_t attached_data_pack_callbacks
 
std::vector
< types::global_dof_index
coarse_cell_to_p4est_tree_permutation
 
std::vector
< types::global_dof_index
p4est_tree_to_coarse_cell_permutation
 

Friends

template<int , int >
class ::internal::DoFHandler::Policy::ParallelDistributed
 

Additional Inherited Members

- Public Attributes inherited from Triangulation< dim, spacedim >
Signals signals
 
- Static Public Attributes inherited from Triangulation< dim, spacedim >
static const StraightBoundary
< dim, spacedim > 
straight_boundary
 
static const unsigned int dimension = dim
 
static const unsigned int space_dimension = spacedim
 
- Static Protected Member Functions inherited from Triangulation< dim, spacedim >
static void write_bool_vector (const unsigned int magic_number1, const std::vector< bool > &v, const unsigned int magic_number2, std::ostream &out)
 
static void read_bool_vector (const unsigned int magic_number1, std::vector< bool > &v, const unsigned int magic_number2, std::istream &in)
 
- Protected Attributes inherited from Triangulation< dim, spacedim >
MeshSmoothing smooth_grid
 

Detailed Description

template<int dim, int spacedim>
class parallel::distributed::Triangulation< dim, spacedim >

This class acts like the Triangulation class, but it distributes the mesh across a number of different processors when using MPI. The class's interface does not add a lot to the Triangulation class but there are a number of difficult algorithms under the hood that ensure we always have a load-balanced, fully distributed mesh. Use of this class is explained in step-40, step-32, the Parallel computing with multiple processors using distributed memory documentation module, as well as the distributed_paper . See there for more information.

Note
This class does not support anisotropic refinement, because it relies on the p4est library that does not support this. Attempts to refine cells anisotropically will result in errors.

Interaction with boundary description

Refining and coarsening a distributed triangulation is a complicated process because cells may have to be migrated from one processor to another. On a single processor, materializing that part of the global mesh that we want to store here from what we have stored before therefore may involve several cycles of refining and coarsening the locally stored set of cells until we have finally gotten from the previous to the next triangulation. (This process is described in more detail in the distributed_paper.) Unfortunately, in this process, some information can get lost relating to flags that are set by user code and that are inherited from mother to child cell but that are not moved along with a cell if that cell is migrated from one processor to another.

An example are boundary indicators. Assume, for example, that you start with a single cell that is refined once globally, yielding four children. If you have four processors, each one owns one cell. Assume now that processor 1 sets the boundary indicators of the external boundaries of the cell it owns to 42. Since processor 0 does not own this cell, it doesn't set the boundary indicators of its ghost cell copy of this cell. Now, assume we do several mesh refinement cycles and end up with a configuration where this processor suddenly finds itself as the owner of this cell. If boundary indicator 42 means that we need to integrate Neumann boundary conditions along this boundary, then processor 0 will forget to do so because it has never set the boundary indicator along this cell's boundary to 42.

The way to avoid this dilemma is to make sure that things like setting boundary indicators or material ids is done immediately every time a parallel triangulation is refined. This is not necessary for sequential triangulations because, there, these flags are inherited from mother to child cell and remain with a cell even if it is refined and the children are later coarsened again, but this does not hold for distributed triangulations. It is made even more difficult by the fact that in the process of refining a parallel distributed triangulation, the triangulation may call Triangulation::execute_coarsening_and_refinement multiple times and this function needs to know about boundaries. In other words, it is not enough to just set boundary indicators on newly created faces only after calling distributed::parallel::Triangulation::execute_coarsening_and_refinement: it actually has to happen while that function is still running.

The way to do this is by writing a function that sets boundary indicators and that will be called by the Triangulation class. The triangulation does not provide a pointer to itself to the function being called, nor any other information, so the trick is to get this information into the function. C++ provides a nice mechanism for this that is best explained using an example:

#include <deal.II/base/std_cxx1x/bind.h>
template <int dim>
void set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation)
{
... set boundary indicators on the triangulation object ...
}
template <int dim>
void
MyClass<dim>::
create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
{
... create the coarse mesh ...
coarse_grid.signals.post_refinement.connect
(std_cxx1x::bind (&set_boundary_indicators<dim>,
std_cxx1x::ref(coarse_grid)));
}

What the call to std_cxx1x::bind does is to produce an object that can be called like a function with no arguments. It does so by taking the address of a function that does, in fact, take an argument but permanently fix this one argument to a reference to the coarse grid triangulation. After each refinement step, the triangulation will then call the object so created which will in turn call set_boundary_indicators<dim> with the reference to the coarse grid as argument.

This approach can be generalized. In the example above, we have used a global function that will be called. However, sometimes it is necessary that this function is in fact a member function of the class that generates the mesh, for example because it needs to access run-time parameters. This can be achieved as follows: assuming the set_boundary_indicators() function has been declared as a (non-static, but possibly private) member function of the MyClass class, then the following will work:

#include <deal.II/base/std_cxx1x/bind.h>
template <int dim>
void
MyClass<dim>::
set_boundary_indicators (parallel::distributed::Triangulation<dim> &triangulation) const
{
... set boundary indicators on the triangulation object ...
}
template <int dim>
void
MyClass<dim>::
create_coarse_mesh (parallel::distributed::Triangulation<dim> &coarse_grid) const
{
... create the coarse mesh ...
coarse_grid.signals.post_refinement.connect
(std_cxx1x::bind (&MyGeometry<dim>::set_boundary_indicators,
std_cxx1x::cref(*this),
std_cxx1x::ref(coarse_grid)));
}

Here, like any other member function, set_boundary_indicators implicitly takes a pointer or reference to the object it belongs to as first argument. std::bind again creates an object that can be called like a global function with no arguments, and this object in turn calls set_boundary_indicators with a pointer to the current object and a reference to the triangulation to work on. Note that because the create_coarse_mesh function is declared as const, it is necessary that the set_boundary_indicators function is also declared const.

Note:For reasons that have to do with the way the parallel::distributed::Triangulation is implemented, functions that have been attached to the post-refinement signal of the triangulation are called more than once, sometimes several times, every time the triangulation is actually refined.

Author
Wolfgang Bangerth, Timo Heister 2008, 2009, 2010, 2011

Definition at line 35 of file grid_refinement.h.

Member Typedef Documentation

template<int dim, int spacedim>
typedef ::Triangulation<dim,spacedim>::active_cell_iterator parallel::distributed::Triangulation< dim, spacedim >::active_cell_iterator

Import the various iterator typedefs from the base class.

Definition at line 327 of file tria.h.

Member Enumeration Documentation

template<int dim, int spacedim>
enum parallel::distributed::Triangulation::Settings

Generic settings for distributed Triangulations. If mesh_reconstruction_after_repartitioning is set, the deal.II mesh will be reconstructed from the coarse mesh every time a repartioning in p4est happens. This can be a bit more expensive, but guarantees the same memory layout and therefore cell ordering in the deal.II mesh. As assembly is done in the deal.II cell ordering, this flag is required to get reproducible behaviour after snapshot/resume.

The flag construct_multigrid_hierarchy needs to be set to use the geometric multigrid functionality. This option requires additional computation and communication. Note: geometric multigrid is still a work in progress.

Definition at line 353 of file tria.h.

template<int dim, int spacedim>
enum parallel::distributed::Triangulation::CellStatus

Used to inform in the callbacks of register_data_attach() and notify_ready_to_unpack() how the cell with the given cell_iterator is going to change. Note that this may me different than the refine_flag() and coarsen_flag() in the cell_iterator because of refinement constraints that this machine does not see.

Definition at line 648 of file tria.h.

Constructor & Destructor Documentation

template<int dim, int spacedim>
parallel::distributed::Triangulation< dim, spacedim >::Triangulation ( MPI_Comm  mpi_communicator,
const typename::Triangulation< dim, spacedim >::MeshSmoothing  smooth_grid = (::Triangulation< dim, spacedim >::none),
const Settings  settings = default_setting 
)

Constructor.

Parameters
mpi_communicatordenotes the MPI communicator to be used for the triangulation.
smooth_gridDegree and kind of mesh smoothing to be applied to the mesh. See the Triangulation class for a description of the kinds of smoothing operations that can be applied.
settingsSee the description of the Settings enumerator.
Note
This class does not currently support the check_for_distorted_cells argument provided by the base class.
While it is possible to pass all of the mesh smoothing flags listed in the base class to objects of this type, it is not always possible to honor all of these smoothing options if they would require knowledge of refinement/coarsening flags on cells not locally owned by this processor. As a consequence, for some of these flags, the ultimate number of cells of the parallel triangulation may depend on the number of processors into which it is partitioned. On the other hand, if no smoothing flags are passed, if you always mark the same cells of the mesh, you will always get the exact same refined mesh independent of the number of processors into which the triangulation is partitioned.
template<int dim, int spacedim>
virtual parallel::distributed::Triangulation< dim, spacedim >::~Triangulation ( )
virtual

Destructor.

Reimplemented from Triangulation< dim, spacedim >.

Member Function Documentation

template<int dim, int spacedim>
virtual void parallel::distributed::Triangulation< dim, spacedim >::clear ( )
virtual

Reset this triangulation into a virgin state by deleting all data.

Note that this operation is only allowed if no subscriptions to this object exist any more, such as DoFHandler objects using it.

Reimplemented from Triangulation< dim, spacedim >.

template<int dim, int spacedim>
virtual void parallel::distributed::Triangulation< dim, spacedim >::copy_triangulation ( const ::Triangulation< dim, spacedim > &  old_tria)
virtual

Implementation of the same function as in the base class.

template<int dim, int spacedim>
virtual void parallel::distributed::Triangulation< dim, spacedim >::create_triangulation ( const std::vector< Point< spacedim > > &  vertices,
const std::vector< CellData< dim > > &  cells,
const SubCellData subcelldata 
)
virtual

Create a triangulation as documented in the base class.

This function also sets up the various data structures necessary to distribute a mesh across a number of processors. This will be necessary once the mesh is being refined, though we will always keep the entire coarse mesh that is generated by this function on all processors.

Reimplemented from Triangulation< dim, spacedim >.

template<int dim, int spacedim>
virtual void parallel::distributed::Triangulation< dim, spacedim >::execute_coarsening_and_refinement ( )
virtual

Coarsen and refine the mesh according to refinement and coarsening flags set.

Since the current processor only has control over those cells it owns (i.e. the ones for which

cell->subdomain_id()

this->locally_owned_subdomain()), refinement and coarsening flags are only respected for those locally owned cells. Flags may be set on other cells as well (and may often, in fact, if you call Triangulation::prepare_coarsening_and_refinement) but will be largely ignored: the decision to refine the global mesh will only be affected by flags set on locally owned cells.

Reimplemented from Triangulation< dim, spacedim >.

template<int dim, int spacedim>
types::subdomain_id parallel::distributed::Triangulation< dim, spacedim >::locally_owned_subdomain ( ) const
virtual

Return the subdomain id of those cells that are owned by the current processor. All cells in the triangulation that do not have this subdomain id are either owned by another processor or have children that only exist on other processors.

Reimplemented from Triangulation< dim, spacedim >.

template<int dim, int spacedim>
unsigned int parallel::distributed::Triangulation< dim, spacedim >::n_locally_owned_active_cells ( ) const

Return the number of active cells in the triangulation that are locally owned, i.e. that have a subdomain_id equal to locally_owned_subdomain(). Note that there may be more active cells in the triangulation stored on the present processor, such as for example ghost cells, or cells further away from the locally owned block of cells but that are needed to ensure that the triangulation that stores this processor's set of active cells still remains balanced with respect to the 2:1 size ratio of adjacent cells.

As a consequence of the remark above, the result of this function is always smaller or equal to the result of the function with the same name in the Triangulation base class, which includes the active ghost and artificial cells (see also GlossArtificialCell and GlossGhostCell).

template<int dim, int spacedim>
types::global_dof_index parallel::distributed::Triangulation< dim, spacedim >::n_global_active_cells ( ) const

Return the sum over all processors of the number of active cells owned by each processor. This equals the overall number of active cells in the distributed triangulation.

template<int dim, int spacedim>
virtual unsigned int parallel::distributed::Triangulation< dim, spacedim >::n_global_levels ( ) const
virtual

Returns the global maximum level. This may be bigger than n_levels.

Reimplemented from Triangulation< dim, spacedim >.

template<int dim, int spacedim>
const std::vector<unsigned int>& parallel::distributed::Triangulation< dim, spacedim >::n_locally_owned_active_cells_per_processor ( ) const

Return the number of active cells owned by each of the MPI processes that contribute to this triangulation. The element of this vector indexed by locally_owned_subdomain() equals the result of n_locally_owned_active_cells().

template<int dim, int spacedim>
MPI_Comm parallel::distributed::Triangulation< dim, spacedim >::get_communicator ( ) const

Return the MPI communicator used by this triangulation.

template<int dim, int spacedim>
virtual std::size_t parallel::distributed::Triangulation< dim, spacedim >::memory_consumption ( ) const
virtual

Return the local memory consumption in bytes.

Reimplemented from Triangulation< dim, spacedim >.

template<int dim, int spacedim>
virtual std::size_t parallel::distributed::Triangulation< dim, spacedim >::memory_consumption_p4est ( ) const
virtual

Return the local memory consumption contained in the p4est data structures alone. This is already contained in memory_consumption() but made available separately for debugging purposes.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::write_mesh_vtk ( const char *  file_basename) const

A collective operation that produces a sequence of output files with the given file base name that contain the mesh in VTK format.

More than anything else, this function is useful for debugging the interface between deal.II and p4est.

template<int dim, int spacedim>
unsigned int parallel::distributed::Triangulation< dim, spacedim >::get_checksum ( ) const

Produce a check sum of the triangulation. This is a collective operation and is mostly useful for debugging purposes.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::save ( const char *  filename) const

Save the refinement information from the coarse mesh into the given file. This file needs to be reachable from all nodes in the computation on a shared network file system. See the SolutionTransfer class on how to store solution vectors into this file.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::load ( const char *  filename)

Load the refinement information saved with save() back in. The mesh must contain the same coarse mesh that was used in save(). You do not need to load with the same number of MPI processes that you saved with. Rather, if a mesh is loaded with a different number of MPI processes than used at the time of saving, the mesh is repartitioned appropriately.

template<int dim, int spacedim>
unsigned int parallel::distributed::Triangulation< dim, spacedim >::register_data_attach ( const std::size_t  size,
const std_cxx1x::function< void(const cell_iterator &, const CellStatus, void *)> &  pack_callback 
)

Register a function with the current Triangulation object that will be used to attach data to active cells before execute_coarsening_and_refinement(). In execute_coarsening_and_refinement() the Triangulation will call the given function pointer and provide size bytes to store data. If necessary, this data will be transferred to the new owner of that cell during repartitioning the tree. See notify_ready_to_unpack() on how to retrieve the data.

Callers need to store the return value. It specifies an offset of the position at which data can later be retrieved during a call to notify_ready_to_unpack().

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::notify_ready_to_unpack ( const unsigned int  offset,
const std_cxx1x::function< void(const cell_iterator &, const CellStatus, const void *)> &  unpack_callback 
)

The given function is called for each new active cell and supplies a pointer to the data saved with register_data_attach().

template<int dim, int spacedim>
const std::vector<types::global_dof_index>& parallel::distributed::Triangulation< dim, spacedim >::get_p4est_tree_to_coarse_cell_permutation ( ) const

Returns a permutation vector for the order the coarse cells are handed of to p4est. For example the first element i in this vector denotes that the first cell in hierarchical ordering is the ith deal cell starting from begin(0).

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::add_periodicity ( const std::vector< GridTools::PeriodicFacePair< cell_iterator > > &  )

Join faces in the p4est forest for periodic boundary conditions. As a result, each pair of faces will differ by at most one refinement level and ghost neighbors will be available across these faces.

The vector can be filled by the function GridTools::collect_periodic_faces.

Todo:
At the moment just default orientation is implemented.
Note
Before this function can be used the Triangulation has to be initialized and must not be refined. Calling this function more than once is possible, but not recommended: The function destroys and rebuilds the p4est forest each time it is called.
template<int dim, int spacedim>
typename ::internal::p4est::types<dim>::tree* parallel::distributed::Triangulation< dim, spacedim >::init_tree ( const int  dealii_coarse_cell_index) const
private

Return a pointer to the p4est tree that belongs to the given dealii_coarse_cell_index()

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::setup_coarse_cell_to_p4est_tree_permutation ( )
private

The function that computes the permutation between the two data storage schemes.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::copy_new_triangulation_to_p4est ( ::internal::int2type< 2 >  )
private

Take the contents of a newly created triangulation we are attached to and copy it to p4est data structures.

This function exists in 2d and 3d variants.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::copy_local_forest_to_triangulation ( )
private

Copy the local part of the refined forest from p4est into the attached triangulation.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::update_number_cache ( )
private

Update the number_cache variable after mesh creation or refinement.

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::attach_mesh_data ( )
private

Internal function notifying all registered classes to attach their data before repartitioning occurs. Called from execute_coarsening_and_refinement().

template<int dim, int spacedim>
void parallel::distributed::Triangulation< dim, spacedim >::fill_vertices_with_ghost_neighbors ( std::map< unsigned int, std::set<::types::subdomain_id > > &  vertices_with_ghost_neighbors)
private

fills a map that, for each vertex, lists all the processors whose subdomains are adjacent to that vertex. Used by DoFHandler::Policy::ParallelDistributed.

Member Data Documentation

template<int dim, int spacedim>
MPI_Comm parallel::distributed::Triangulation< dim, spacedim >::mpi_communicator
private

MPI communicator to be used for the triangulation. We create a unique communicator for this class, which is a duplicate of the one passed to the constructor.

Definition at line 743 of file tria.h.

template<int dim, int spacedim>
Settings parallel::distributed::Triangulation< dim, spacedim >::settings
private

store the Settings.

Definition at line 748 of file tria.h.

template<int dim, int spacedim>
types::subdomain_id parallel::distributed::Triangulation< dim, spacedim >::my_subdomain
private

The subdomain id to be used for the current processor.

Definition at line 755 of file tria.h.

template<int dim, int spacedim>
bool parallel::distributed::Triangulation< dim, spacedim >::triangulation_has_content
private

A flag that indicates whether the triangulation has actual content.

Definition at line 761 of file tria.h.

template<int dim, int spacedim>
typename ::internal::p4est::types<dim>::connectivity* parallel::distributed::Triangulation< dim, spacedim >::connectivity
private

A data structure that holds the connectivity between trees. Since each tree is rooted in a coarse grid cell, this data structure holds the connectivity between the cells of the coarse grid.

Definition at line 787 of file tria.h.

template<int dim, int spacedim>
typename ::internal::p4est::types<dim>::forest* parallel::distributed::Triangulation< dim, spacedim >::parallel_forest
private

A data structure that holds the local part of the global triangulation.

Definition at line 794 of file tria.h.

template<int dim, int spacedim>
typename ::internal::p4est::types<dim>::ghost* parallel::distributed::Triangulation< dim, spacedim >::parallel_ghost
private

A data structure that holds some information about the ghost cells of the triangulation.

Definition at line 799 of file tria.h.

template<int dim, int spacedim>
bool parallel::distributed::Triangulation< dim, spacedim >::refinement_in_progress
private

A flag that indicates whether refinement of a triangulation is currently in progress. This flag is used to disambiguate whether a call to execute_coarsening_and_triangulation came from the outside or through a recursive call. While the first time we want to take over work to copy things from a refined p4est, the other times we don't want to get in the way as these latter calls to Triangulation::execute_coarsening_and_refinement() are simply there in order to re-create a triangulation that matches the p4est.

Definition at line 821 of file tria.h.

template<int dim, int spacedim>
unsigned int parallel::distributed::Triangulation< dim, spacedim >::attached_data_size
private

number of bytes that get attached to the Triangulation through register_data_attach() for example SolutionTransfer.

Definition at line 829 of file tria.h.

template<int dim, int spacedim>
unsigned int parallel::distributed::Triangulation< dim, spacedim >::n_attached_datas
private

number of functions that get attached to the Triangulation through register_data_attach() for example SolutionTransfer.

Definition at line 836 of file tria.h.

template<int dim, int spacedim>
unsigned int parallel::distributed::Triangulation< dim, spacedim >::n_attached_deserialize
private

number of functions that need to unpack their data after a call from load()

Definition at line 842 of file tria.h.

template<int dim, int spacedim>
callback_list_t parallel::distributed::Triangulation< dim, spacedim >::attached_data_pack_callbacks
private

List of callback functions registered by register_data_attach() that are going to be called for packing data.

Definition at line 857 of file tria.h.

template<int dim, int spacedim>
std::vector<types::global_dof_index> parallel::distributed::Triangulation< dim, spacedim >::coarse_cell_to_p4est_tree_permutation
private

Two arrays that store which p4est tree corresponds to which coarse grid cell and vice versa. We need these arrays because p4est goes with the original order of coarse cells when it sets up its forest, and then applies the Morton ordering within each tree. But if coarse grid cells are badly ordered this may mean that individual parts of the forest stored on a local machine may be split across coarse grid cells that are not geometrically close. Consequently, we apply a Cuthill-McKee preordering to ensure that the part of the forest stored by p4est is located on geometrically close coarse grid cells.

Definition at line 880 of file tria.h.


The documentation for this class was generated from the following files: