![]() |
Reference documentation for deal.II version 8.1.0
|
#include <tria.h>
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 |
![]() | |
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 > > &) |
![]() | |
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_id > | get_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 |
![]() | |
Subscriptor () | |
Subscriptor (const Subscriptor &) | |
virtual | ~Subscriptor () |
Subscriptor & | operator= (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 | |
![]() | |
Signals | signals |
![]() | |
static const StraightBoundary < dim, spacedim > | straight_boundary |
static const unsigned int | dimension = dim |
static const unsigned int | space_dimension = 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) |
![]() | |
MeshSmoothing | smooth_grid |
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.
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:
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:
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.
Definition at line 35 of file grid_refinement.h.
typedef ::Triangulation<dim,spacedim>::active_cell_iterator parallel::distributed::Triangulation< dim, spacedim >::active_cell_iterator |
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.
mpi_communicator | denotes the MPI communicator to be used for the triangulation. |
smooth_grid | Degree 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. |
settings | See the description of the Settings enumerator. |
check_for_distorted_cells
argument provided by the base class.
|
virtual |
Destructor.
Reimplemented from Triangulation< dim, spacedim >.
|
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 >.
|
virtual |
Implementation of the same function as in the base class.
|
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 >.
|
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 >.
|
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 >.
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).
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.
|
virtual |
Returns the global maximum level. This may be bigger than n_levels.
Reimplemented from Triangulation< dim, 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().
MPI_Comm parallel::distributed::Triangulation< dim, spacedim >::get_communicator | ( | ) | const |
Return the MPI communicator used by this triangulation.
|
virtual |
Return the local memory consumption in bytes.
Reimplemented from Triangulation< dim, spacedim >.
|
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.
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.
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.
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.
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.
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().
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().
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).
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.
|
private |
Return a pointer to the p4est tree that belongs to the given dealii_coarse_cell_index()
|
private |
The function that computes the permutation between the two data storage schemes.
|
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.
|
private |
Copy the local part of the refined forest from p4est into the attached triangulation.
|
private |
Update the number_cache variable after mesh creation or refinement.
|
private |
Internal function notifying all registered classes to attach their data before repartitioning occurs. Called from execute_coarsening_and_refinement().
|
private |
fills a map that, for each vertex, lists all the processors whose subdomains are adjacent to that vertex. Used by DoFHandler::Policy::ParallelDistributed.
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
|
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.
|
private |
number of bytes that get attached to the Triangulation through register_data_attach() for example SolutionTransfer.
|
private |
number of functions that get attached to the Triangulation through register_data_attach() for example SolutionTransfer.
|
private |
|
private |
List of callback functions registered by register_data_attach() that are going to be called for packing data.
|
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.