![]() |
Reference documentation for deal.II version 9.6.0
|
#include <deal.II/distributed/tria_base.h>
Public Types | |
using | cell_iterator |
enum | MeshSmoothing |
using | level_cell_iterator |
using | active_cell_iterator |
using | face_iterator |
using | active_face_iterator |
using | vertex_iterator |
using | active_vertex_iterator |
using | line_iterator |
using | active_line_iterator |
using | quad_iterator |
using | active_quad_iterator |
using | hex_iterator |
using | active_hex_iterator |
using | CellStatus |
Public Member Functions | |
DistributedTriangulationBase (const MPI_Comm mpi_communicator, const typename ::Triangulation< dim, spacedim >::MeshSmoothing smooth_grid=(::Triangulation< dim, spacedim >::none), const bool check_for_distorted_cells=false) | |
virtual bool | has_hanging_nodes () const override |
virtual void | load (const std::string &filename, const bool autopartition)=0 |
virtual MPI_Comm | get_communicator () const override |
virtual bool | is_multilevel_hierarchy_constructed () const=0 |
virtual void | copy_triangulation (const ::Triangulation< dim, spacedim > &old_tria) override |
virtual void | copy_triangulation (const Triangulation< dim, spacedim > &other_tria) |
unsigned int | n_locally_owned_active_cells () const |
virtual types::global_cell_index | n_global_active_cells () const override |
virtual std::size_t | memory_consumption () const override |
virtual unsigned int | n_global_levels () const override |
types::subdomain_id | locally_owned_subdomain () const override |
const std::set< types::subdomain_id > & | ghost_owners () const |
const std::set< types::subdomain_id > & | level_ghost_owners () const |
std::weak_ptr< const Utilities::MPI::Partitioner > | global_active_cell_index_partitioner () const override |
std::weak_ptr< const Utilities::MPI::Partitioner > | global_level_cell_index_partitioner (const unsigned int level) const override |
virtual std::vector< types::boundary_id > | get_boundary_ids () const override |
virtual std::vector< types::manifold_id > | get_manifold_ids () const override |
void | communicate_locally_moved_vertices (const std::vector< bool > &vertex_locally_moved) |
virtual types::coarse_cell_id | n_global_coarse_cells () const override |
virtual void | clear () override |
virtual void | set_mesh_smoothing (const MeshSmoothing mesh_smoothing) |
virtual const MeshSmoothing & | get_mesh_smoothing () const |
void | set_manifold (const types::manifold_id number, const Manifold< dim, spacedim > &manifold_object) |
void | reset_manifold (const types::manifold_id manifold_number) |
void | reset_all_manifolds () |
void | set_all_manifold_ids (const types::manifold_id number) |
void | set_all_manifold_ids_on_boundary (const types::manifold_id number) |
void | set_all_manifold_ids_on_boundary (const types::boundary_id b_id, const types::manifold_id number) |
const Manifold< dim, spacedim > & | get_manifold (const types::manifold_id number) const |
virtual void | create_triangulation (const std::vector< Point< spacedim > > &vertices, const std::vector< CellData< dim > > &cells, const SubCellData &subcelldata) |
virtual void | create_triangulation (const TriangulationDescription::Description< dim, spacedim > &construction_data) |
void | flip_all_direction_flags () |
bool | prepare_coarsening_and_refinement () |
bool | prepare_coarsening_and_refinement () |
bool | prepare_coarsening_and_refinement () |
unsigned int | n_quads () const |
unsigned int | n_quads (const unsigned int) const |
unsigned int | n_quads () const |
unsigned int | n_quads (const unsigned int) const |
unsigned int | n_quads () const |
unsigned int | n_quads (const unsigned int) const |
unsigned int | n_active_quads (const unsigned int) const |
unsigned int | n_active_quads () const |
unsigned int | n_active_quads (const unsigned int) const |
unsigned int | n_active_quads () const |
unsigned int | n_active_quads (const unsigned int) const |
unsigned int | n_active_quads () 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 | max_adjacent_cells () const |
unsigned int | max_adjacent_cells () const |
unsigned int | max_adjacent_cells () const |
unsigned int | n_raw_quads (const unsigned int) const |
unsigned int | n_raw_quads (const unsigned int) const |
unsigned int | n_raw_quads (const unsigned int) const |
unsigned int | n_raw_quads (const unsigned int level) const |
unsigned int | n_raw_quads (const unsigned int level) const |
unsigned int | n_raw_quads (const unsigned int) const |
unsigned int | n_raw_quads () const |
unsigned int | n_raw_hexs (const unsigned int) const |
unsigned int | n_raw_hexs (const unsigned int) const |
unsigned int | n_raw_hexs (const unsigned int) const |
unsigned int | n_raw_hexs (const unsigned int level) const |
void | save (Archive &ar, const unsigned int version) const |
virtual void | save (const std::string &file_basename) const |
void | load (Archive &ar, const unsigned int version) |
virtual void | load (const std::string &file_basename) |
virtual void | add_periodicity (const std::vector< GridTools::PeriodicFacePair< cell_iterator > > &) |
const std::map< std::pair< cell_iterator, unsigned int >, std::pair< std::pair< cell_iterator, unsigned int >, unsigned char > > & | get_periodic_face_map () const |
const std::vector< ReferenceCell > & | get_reference_cells () const |
bool | all_reference_cells_are_hyper_cube () const |
bool | all_reference_cells_are_simplex () const |
bool | is_mixed_mesh () const |
void | serialize (Archive &archive, const unsigned int version) |
Mesh refinement | |
void | set_all_refine_flags () |
void | refine_global (const unsigned int times=1) |
void | coarsen_global (const unsigned int times=1) |
virtual void | execute_coarsening_and_refinement () |
virtual bool | prepare_coarsening_and_refinement () |
History of a triangulation | |
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 |
User data | |
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 | 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 functions | |
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 |
cell_iterator | create_cell_iterator (const CellId &cell_id) const |
bool | contains_cell (const CellId &cell_id) const |
Cell iterator functions returning ranges of iterators | |
IteratorRange< cell_iterator > | cell_iterators () const |
IteratorRange< active_cell_iterator > | active_cell_iterators () const |
IteratorRange< cell_iterator > | cell_iterators_on_level (const unsigned int level) const |
IteratorRange< active_cell_iterator > | active_cell_iterators_on_level (const unsigned int level) const |
Face iterator functions | |
face_iterator | begin_face () const |
active_face_iterator | begin_active_face () const |
face_iterator | end_face () const |
IteratorRange< active_face_iterator > | active_face_iterators () const |
Vertex iterator functions | |
vertex_iterator | begin_vertex () const |
active_vertex_iterator | begin_active_vertex () const |
vertex_iterator | end_vertex () const |
Information about the triangulation | |
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 |
Triangulation< dim, spacedim > & | get_triangulation () |
const Triangulation< dim, spacedim > & | get_triangulation () const |
Internal information about the number of objects | |
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 level) const |
unsigned int | n_raw_cells (const unsigned int level) const |
unsigned int | n_raw_faces () const |
Subscriptor functionality | |
Classes derived from Subscriptor provide a facility to subscribe to this object. This is mostly used by the SmartPointer class. | |
void | subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const |
void | unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const |
unsigned int | n_subscriptions () const |
template<typename StreamType > | |
void | list_subscribers (StreamType &stream) const |
void | list_subscribers () const |
Static Public Member Functions | |
static ::ExceptionBase & | ExcInUse (int arg1, std::string arg2, std::string arg3) |
static ::ExceptionBase & | ExcNoSubscriber (std::string arg1, std::string arg2) |
Exceptions | |
static ::ExceptionBase & | ExcInvalidLevel (int arg1, int arg2) |
static ::ExceptionBase & | ExcTriangulationNotEmpty (int arg1, int arg2) |
static ::ExceptionBase & | ExcGridReadError () |
static ::ExceptionBase & | ExcFacesHaveNoLevel () |
static ::ExceptionBase & | ExcEmptyLevel (int arg1) |
static ::ExceptionBase & | ExcBoundaryIdNotFound (types::boundary_id arg1) |
static ::ExceptionBase & | ExcInconsistentCoarseningFlags () |
Public Attributes | |
Keeping up with what happens to a triangulation | |
Signals | signals |
Static Public Attributes | |
static constexpr unsigned int | dimension |
static constexpr unsigned int | space_dimension |
static constexpr auto | CELL_PERSIST |
static constexpr auto | CELL_REFINE |
static constexpr auto | CELL_COARSEN |
static constexpr auto | CELL_INVALID |
Protected Member Functions | |
virtual void | update_number_cache () |
void | update_reference_cells () override |
void | reset_global_cell_indices () |
void | update_periodic_face_map () |
Static Protected Member Functions | |
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 | |
const MPI_Comm | mpi_communicator |
types::subdomain_id | my_subdomain |
types::subdomain_id | n_subdomains |
NumberCache | number_cache |
MeshSmoothing | smooth_grid |
std::vector< ReferenceCell > | reference_cells |
Private Types | |
using | IteratorSelector |
using | raw_cell_iterator |
using | raw_face_iterator |
using | raw_vertex_iterator |
using | raw_line_iterator |
using | raw_quad_iterator |
using | raw_hex_iterator |
using | map_value_type = decltype(counter_map)::value_type |
using | map_iterator = decltype(counter_map)::iterator |
Static Private Attributes | |
static std::mutex | mutex |
Serialization facilities. | |
unsigned int | register_data_attach (const std::function< std::vector< char >(const cell_iterator &, const ::CellStatus)> &pack_callback, const bool returns_variable_size_data) |
void | notify_ready_to_unpack (const unsigned int handle, const std::function< void(const cell_iterator &, const ::CellStatus, const boost::iterator_range< std::vector< char >::const_iterator > &)> &unpack_callback) |
std::vector< typename internal::CellAttachedDataSerializer< dim, spacedim >::cell_relation_t > | local_cell_relations |
internal::CellAttachedDataSerializer< dim, spacedim > | data_serializer |
void | save_attached_data (const unsigned int global_first_cell, const unsigned int global_num_cells, const std::string &file_basename) const |
void | load_attached_data (const unsigned int global_first_cell, const unsigned int global_num_cells, const unsigned int local_num_cells, const std::string &file_basename, const unsigned int n_attached_deserialize_fixed, const unsigned int n_attached_deserialize_variable) |
void | update_cell_relations () |
internal::CellAttachedData< dim, spacedim > | cell_attached_data |
A base class for distributed triangulations, i.e., triangulations that do not store all cells on all processors. This implies that not every detail of a triangulation may be known on each processor. In particular, you have to expect that triangulations of classes derived from this one only store some of the active cells (namely, the locally owned cells), along with ghost cells and possibly artificial cells. In contrast to the classes derived from parallel::TriangulationBase, it is certain that the classes derived from the current class will not store the entire triangulation as long as it has a large enough number of cells. (The difference to parallel::TriangulationBase is that the parallel::shared::Triangulation is derived from parallel::TriangulationBase, but not from the current class.) The distinction is not large in practice: Everything that is difficult for parallel distributed triangulation is generally also difficult for any other kind of parallel triangulation classes; however, this intermediate base class allows to further differentiate between the different kinds of classes providing parallel mesh functionality.
This class can, then, be used to test whether a pointer or reference to a triangulation object refers to any kind of parallel triangulation, or whether the triangulation is in fact parallel distributed. In other words, one could write a function like this:
Definition at line 457 of file tria_base.h.
using parallel::DistributedTriangulationBase< dim, spacedim >::cell_iterator |
Definition at line 470 of file tria_base.h.
|
privateinherited |
|
inherited |
|
inherited |
An alias that is used to identify active cell iterators. The concept of iterators is discussed at length in the iterators documentation topic.
The current alias identifies active cells in a triangulation. The TriaActiveIterator class works like a pointer to active objects that when you dereference it yields an object of type CellAccessor. CellAccessor is a class that identifies properties that are specific to cells in a triangulation, but it is derived (and consequently inherits) from TriaAccessor that describes what you can ask of more general objects (lines, faces, as well as cells) in a triangulation.
|
inherited |
An alias that is used to identify iterators that point to faces. The concept of iterators is discussed at length in the iterators documentation topic.
The current alias identifies faces in a triangulation. The TriaIterator class works like a pointer to objects that when you dereference it yields an object of type TriaAccessor, i.e., class that can be used to query geometric properties of faces such as their vertices, their area, etc.
|
inherited |
An alias that is used to identify iterators that point to active faces, i.e., to faces that have no children. Active faces must be faces of at least one active cell.
Other than the "active" qualification, this alias is identical to the face_iterator
alias. In particular, dereferencing either yields the same kind of object.
|
inherited |
An alias that defines an iterator type to iterate over vertices of a mesh. The concept of iterators is discussed at length in the iterators documentation topic.
|
inherited |
An alias that defines an iterator type to iterate over vertices of a mesh. The concept of iterators is discussed at length in the iterators documentation topic.
This alias is in fact identical to the vertex_iterator
alias above since all vertices in a mesh are active (i.e., are a vertex of an active cell).
|
inherited |
|
inherited |
An alias that allows iterating over the active lines, i.e., that subset of lines that have no children. In one-dimensional meshes, these are the cells of the mesh, whereas in two-dimensional meshes the lines are the faces of cells.
In two- or three-dimensional meshes, lines without children (i.e., the active lines) are part of at least one active cell. Each such line may additionally be a child of a line of a coarser cell adjacent to a cell that is active. (This coarser neighbor would then also be active.)
|
inherited |
|
inherited |
An alias that allows iterating over the active quads, i.e., that subset of quads that have no children. In two-dimensional meshes, these are the cells of the mesh, whereas in three-dimensional meshes the quads are the faces of cells.
In three-dimensional meshes, quads without children (i.e., the active quads) are faces of at least one active cell. Each such quad may additionally be a child of a quad face of a coarser cell adjacent to a cell that is active. (This coarser neighbor would then also be active.)
|
inherited |
|
inherited |
An alias that allows iterating over the active hexes of a mesh. This iterator only makes sense in three-dimensional meshes, where hexes are the cells of the mesh. Consequently, in these three-dimensional meshes, this iterator is equivalent to the active_cell_iterator
alias.
|
inherited |
The elements of this enum
are used to inform functions how a specific cell is going to change. This is used in the course of transferring data from one mesh to a refined or coarsened version of the mesh, for example. Note that this may me different than the refine_flag() and coarsen_flag() set on a cell, for example in parallel calculations, because of refinement constraints that an individual machine does not see.
|
privateinherited |
Declare a number of iterator types for raw iterators, i.e., iterators that also iterate over holes in the list of cells left by cells that have been coarsened away in previous mesh refinement cycles.
Since users should never have to access these internal properties of how we store data, these iterator types are made private.
|
privateinherited |
|
privateinherited |
|
privateinherited |
|
privateinherited |
|
privateinherited |
|
privateinherited |
The data type used in counter_map.
Definition at line 229 of file subscriptor.h.
|
privateinherited |
The iterator type used in counter_map.
Definition at line 234 of file subscriptor.h.
|
inherited |
Declare some symbolic names for mesh smoothing algorithms. The meaning of these flags is documented in the Triangulation class.
parallel::DistributedTriangulationBase< dim, spacedim >::DistributedTriangulationBase | ( | const MPI_Comm | mpi_communicator, |
const typename ::Triangulation< dim, spacedim >::MeshSmoothing | smooth_grid = (::Triangulation<dim, spacedim>::none), | ||
const bool | check_for_distorted_cells = false ) |
Constructor.
Definition at line 672 of file tria_base.cc.
|
overridevirtual |
Return true if the triangulation has hanging nodes.
In the context of parallel distributed triangulations, every processor stores only that part of the triangulation it owns locally. However, it also stores coarser levels, and to guarantee the 2:1 relationship between cells, this may mean that there are hanging nodes between cells that are not locally owned or ghost cells (i.e., between ghost cells and artificial cells, or between artificial and artificial cells; see the glossary). One is not typically interested in this case, so the function returns whether there are hanging nodes between any two cells of the "global" mesh, i.e., the union of locally owned cells on all processors.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 698 of file tria_base.cc.
|
pure virtual |
Same as the function above.
Implemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< 1, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
|
overridevirtualinherited |
Return MPI communicator used by this triangulation.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 100 of file tria_base.cc.
|
pure virtualinherited |
Return if multilevel hierarchy is supported and has been constructed.
Implemented in parallel::shared::Triangulation< dim, spacedim >.
|
overridevirtualinherited |
Implementation of the same function as in the base class.
Reimplemented in parallel::shared::Triangulation< dim, spacedim >.
Definition at line 117 of file tria_base.cc.
|
virtualinherited |
Copy other_tria
to this triangulation. This operation is not cheap, so you should be careful with using this. We do not implement this function as a copy constructor, since it makes it easier to maintain collections of triangulations if you can assign them values later on.
This triangulation must be empty beforehand.
The function is made virtual
since some derived classes might want to disable or extend the functionality of this function.
|
inherited |
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).
Definition at line 139 of file tria_base.cc.
|
overridevirtualinherited |
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 triangulation.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 147 of file tria_base.cc.
|
overridevirtualinherited |
Return the local memory consumption in bytes.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 153 of file tria_base.cc.
|
overridevirtualinherited |
Return the global maximum level. This may be bigger than the number Triangulation::n_levels() (a function in this class's base class) returns if the current processor only stores cells in parts of the domain that are not very refined, but if other processors store cells in more deeply refined parts of the domain.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 164 of file tria_base.cc.
|
overridevirtualinherited |
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 >.
Definition at line 173 of file tria_base.cc.
|
inherited |
Return a set of MPI ranks of the processors that have at least one ghost cell adjacent to the cells of the local processor. In other words, this is the set of subdomain_id() for all ghost cells.
The returned sets are symmetric, that is if i
is contained in the list of processor j
, then j
will also be contained in the list of processor i
.
Definition at line 185 of file tria_base.cc.
|
inherited |
Return a set of MPI ranks of the processors that have at least one level ghost cell adjacent to our cells used in geometric multigrid. In other words, this is the set of level_subdomain_id() for all level ghost cells.
The returned sets are symmetric, that is if i
is contained in the list of processor j
, then j
will also be contained in the list of processor i
.
Definition at line 203 of file tria_base.cc.
|
overridevirtualinherited |
Return the partitioner for the global indices of the cells on the active level of the triangulation, which is returned by the function CellAccessor::global_active_cell_index().
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 206 of file tria_base.cc.
|
overridevirtualinherited |
Return the partitioner for the global indices of the cells on the given level
of the triangulation, which is returned by the function CellAccessor::global_level_cell_index().
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 209 of file tria_base.cc.
|
overridevirtualinherited |
Return a vector containing all boundary indicators assigned to boundary faces of active cells of this Triangulation object. Note, that each boundary indicator is reported only once. The size of the return vector will represent the number of different indicators (which is greater or equal one).
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 226 of file tria_base.cc.
|
overridevirtualinherited |
Return a vector containing all manifold indicators assigned to the objects of the active cells of this Triangulation. Note, that each manifold indicator is reported only once. The size of the return vector will represent the number of different indicators (which is greater or equal one).
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 244 of file tria_base.cc.
|
inherited |
When vertices have been moved locally, for example using code like
then this function can be used to update the location of vertices between MPI processes.
All the vertices that have been moved and might be in the ghost layer of a process have to be reported in the vertex_locally_moved
argument. This ensures that that part of the information that has to be send between processes is actually sent. Additionally, it is quite important that vertices on the boundary between processes are reported on exactly one process (e.g. the one with the highest id). Otherwise we could expect undesirable results if multiple processes move a vertex differently. A typical strategy is to let processor \(i\) move those vertices that are adjacent to cells whose owners include processor \(i\) but no other processor \(j\) with \(j<i\); in other words, for vertices at the boundary of a subdomain, the processor with the lowest subdomain id "owns" a vertex.
vertex_locally_moved
argument may not contain vertices that aren't at least on ghost cells.vertex_locally_moved | A bitmap indicating which vertices have been moved. The size of this array must be equal to Triangulation::n_vertices() and must be a subset of those vertices flagged by GridTools::get_locally_owned_vertices(). |
Definition at line 299 of file tria_base.cc.
|
overridevirtualinherited |
Return the total number of coarse cells. If the coarse mesh is replicated on each process, this simply returns n_cells(0)
.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 303 of file tria_base.cc.
|
overridevirtualinherited |
Reset this triangulation to an empty 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 >.
Definition at line 312 of file tria_base.cc.
|
protectedvirtualinherited |
Update the number_cache variable after mesh creation or refinement.
Definition at line 395 of file tria_base.cc.
|
overrideprotectedvirtualinherited |
Update the internal reference_cells vector.
Reimplemented from Triangulation< dim, spacedim >.
Definition at line 398 of file tria_base.cc.
|
protectedinherited |
Reset global active cell indices and global level cell indices.
Definition at line 404 of file tria_base.cc.
|
virtualinherited |
Set the mesh smoothing to mesh_smoothing
. This overrides the MeshSmoothing given to the constructor.
|
virtualinherited |
Return the mesh smoothing requirements that are obeyed.
|
inherited |
Assign a manifold object to a certain part of the triangulation. If an object with manifold number number
is refined, this object is used to find the location of new vertices (see the results section of step-49 for a more in-depth discussion of this, with examples). It is also used for non-linear (i.e.: non-Q1) transformations of cells to the unit cell in shape function calculations.
A copy of manifold_object
is created using Manifold<dim, spacedim>::clone() and stored internally.
It is possible to remove or replace a Manifold object during the lifetime of a non-empty triangulation. Usually, this is done before the first refinement and is dangerous afterwards. Removal of a manifold object is done by reset_manifold(). This operation then replaces the manifold object given before by a straight manifold approximation.
|
inherited |
Reset those parts of the triangulation with the given manifold_number
to use a FlatManifold object. This is the default state of a non-curved triangulation, and undoes assignment of a different Manifold object by the function Triangulation::set_manifold().
manifold_number
will still have the same ID after calling this function so that the function get_manifold_ids() will still return the same set of IDs.
|
inherited |
Reset all parts of the triangulation, regardless of their manifold_id, to use a FlatManifold object. This undoes assignment of all Manifold objects by the function Triangulation::set_manifold().
|
inherited |
Set the manifold_id of all cells and faces to the given argument.
|
inherited |
Set the manifold_id of all boundary faces to the given argument.
|
inherited |
Set the manifold_id of all boundary faces and edges with given boundary_id b_id
to the given manifold_id number
.
|
inherited |
Return a constant reference to a Manifold object used for this triangulation. number
is the same as in set_manifold().
|
virtualinherited |
Create a triangulation from a list of vertices and a list of cells, each of the latter being a list of 1<<dim
vertex indices. The triangulation must be empty upon calling this function and the cell list should be useful (connected domain, etc.). The result of calling this function is a coarse mesh.
Material data for the cells is given within the cells
array, while boundary information is given in the subcelldata
field.
The numbering of vertices within the cells
array is subject to some constraints; see the general class documentation for this.
For conditions when this function can generate a valid triangulation, see the documentation of this class, and the GridIn and GridTools::consistently_order_cells() function.
If the check_for_distorted_cells
flag was specified upon creation of this object, at the very end of its operation, the current function walks over all cells and verifies that none of the cells is deformed (see the entry on distorted cells in the glossary), where we call a cell deformed if the determinant of the Jacobian of the mapping from reference cell to real cell is negative at least at one of the vertices (this computation is done using the GeometryInfo::jacobian_determinants_at_vertices function). If there are deformed cells, this function throws an exception of kind DistortedCellList. Since this happens after all data structures have been set up, you can catch and ignore this exception if you know what you do – for example, it may be that the determinant is zero (indicating that you have collapsed edges in a cell) but that this is ok because you didn't intend to integrate on this cell anyway. On the other hand, deformed cells are often a sign of a mesh that is too coarse to resolve the geometry of the domain, and in this case ignoring the exception is probably unwise.
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, parallel::shared::Triangulation< dim, spacedim >, and parallel::shared::Triangulation< dim, dim >.
|
virtualinherited |
Create a triangulation from the provided TriangulationDescription::Description.
construction_data | The data needed for this process. |
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, parallel::fullydistributed::Triangulation< dim, spacedim >, parallel::shared::Triangulation< dim, spacedim >, and parallel::shared::Triangulation< dim, dim >.
|
inherited |
Revert or flip the direction flags of a triangulation with dim==spacedim-1
, see GlossDirectionFlag.
This function throws an exception if dim==spacedim
or if dim<spacedim-1
.
|
inherited |
Flag all active cells for refinement. This will refine all cells of all levels which are not already refined (i.e. only cells are refined which do not yet have children). The cells are only flagged, not refined, thus you have the chance to save the refinement flags.
|
inherited |
Refine all cells times
times. In other words, in each one of the times
iterations, loop over all cells and refine each cell uniformly into \(2^\text{dim}\) children. In practice, this function repeats the following operations times
times: call set_all_refine_flags() followed by execute_coarsening_and_refinement(). The end result is that the number of cells increases by a factor of \((2^\text{dim})^\text{times}=2^{\text{dim} \times \text{times}}\).
The execute_coarsening_and_refinement() function called in this loop may throw an exception if it creates cells that are distorted (see its documentation for an explanation). This exception will be propagated through this function if that happens, and you may not get the actual number of refinement steps in that case.
times > 1
) . See the section on signals in the general documentation of this class.
|
inherited |
Coarsen all cells the given number of times.
In each of one of the times
iterations, all cells will be marked for coarsening. If an active cell is already on the coarsest level, it will be ignored.
times > 1
) . See the section on signals in the general documentation of this class.
|
virtualinherited |
Execute both refinement and coarsening of the triangulation.
The function resets all refinement and coarsening flags to false. It uses the user flags for internal purposes. They will therefore be overwritten by undefined content.
To allow user programs to fix up these cells if that is desired, this function after completing all other work may throw an exception of type DistortedCellList that contains a list of those cells that have been refined and have at least one child that is distorted. The function does not create such an exception if no cells have created distorted children. Note that for the check for distorted cells to happen, the check_for_distorted_cells
flag has to be specified upon creation of a triangulation object.
See the general docs for more information.
virtual
to allow derived classes to insert hooks, such as saving refinement flags and the like (see e.g. the PersistentTriangulation class). Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, parallel::fullydistributed::Triangulation< dim, spacedim >, parallel::shared::Triangulation< dim, spacedim >, and parallel::shared::Triangulation< dim, dim >.
|
virtualinherited |
Do both preparation for refinement and coarsening as well as mesh smoothing.
Regarding the refinement process it fixes the closure of the refinement in dim>=2
(make sure that no two cells are adjacent with a refinement level differing with more than one), etc. It performs some mesh smoothing if the according flag was given to the constructor of this class. The function returns whether additional cells have been flagged for refinement.
See the general doc of this class for more information on smoothing upon refinement.
Regarding the coarsening part, flagging and deflagging cells in preparation of the actual coarsening step are done. This includes deleting coarsen flags from cells which may not be deleted (e.g. because one neighbor is more refined than the cell), doing some smoothing, etc.
The effect is that only those cells are flagged for coarsening which will actually be coarsened. This includes the fact that all flagged cells belong to parent cells of which all children are flagged.
The function returns whether some cells' flagging has been changed in the process.
This function uses the user flags, so store them if you still need them afterwards.
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
|
inherited |
|
inherited |
|
inherited |
|
inherited |
Save the addresses of the cells which are flagged for refinement to out
. For usage, read the general documentation for this class.
|
inherited |
Same as above, but store the flags to a bitvector rather than to a file.
|
inherited |
Read the information stored by save_refine_flags
.
|
inherited |
Read the information stored by save_refine_flags
.
|
inherited |
Analogue to save_refine_flags
.
|
inherited |
Same as above, but store the flags to a bitvector rather than to a file.
|
inherited |
Analogue to load_refine_flags
.
|
inherited |
Analogue to load_refine_flags
.
|
inherited |
Return whether this triangulation has ever undergone anisotropic (as opposed to only isotropic) refinement.
|
inherited |
Clear all user flags. See also GlossUserFlags.
|
inherited |
Save all user flags. See the general documentation for this class and the documentation for the save_refine_flags
for more details. See also GlossUserFlags.
|
inherited |
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.
|
inherited |
Read the information stored by save_user_flags
. See also GlossUserFlags.
|
inherited |
Read the information stored by save_user_flags
. See also GlossUserFlags.
|
inherited |
Clear all user flags on lines. See also GlossUserFlags.
|
inherited |
Save the user flags on lines. See also GlossUserFlags.
|
inherited |
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.
|
inherited |
Load the user flags located on lines. See also GlossUserFlags.
|
inherited |
Load the user flags located on lines. See also GlossUserFlags.
|
inherited |
Clear all user flags on quads. See also GlossUserFlags.
|
inherited |
Save the user flags on quads. See also GlossUserFlags.
|
inherited |
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.
|
inherited |
Load the user flags located on quads. See also GlossUserFlags.
|
inherited |
Load the user flags located on quads. See also GlossUserFlags.
|
inherited |
Clear all user flags on quads. See also GlossUserFlags.
|
inherited |
Save the user flags on hexs. See also GlossUserFlags.
|
inherited |
Same as above, but store the flags to a bitvector rather than to a file. The output vector is resized if necessary. See also GlossUserFlags.
|
inherited |
Load the user flags located on hexs. See also GlossUserFlags.
|
inherited |
Load the user flags located on hexs. See also GlossUserFlags.
|
inherited |
Clear all user pointers and indices and allow the use of both for next access. See also GlossUserData.
|
inherited |
Save all user indices. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Read the information stored by save_user_indices(). See also GlossUserData.
|
inherited |
Save all user pointers. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Read the information stored by save_user_pointers(). See also GlossUserData.
|
inherited |
Save the user indices on lines. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Load the user indices located on lines. See also GlossUserData.
|
inherited |
Save the user indices on quads. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Load the user indices located on quads. See also GlossUserData.
|
inherited |
Save the user indices on hexes. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Load the user indices located on hexs. See also GlossUserData.
|
inherited |
Save the user indices on lines. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Load the user pointers located on lines. See also GlossUserData.
|
inherited |
Save the user pointers on quads. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Load the user pointers located on quads. See also GlossUserData.
|
inherited |
Save the user pointers on hexes. The output vector is resized if necessary. See also GlossUserData.
|
inherited |
Load the user pointers located on hexs. See also GlossUserData.
|
inherited |
Iterator to the first used cell on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
inherited |
Iterator to the first active cell on level level
. If the given level does not contain any active cells (i.e., all cells on this level are further refined, then this function returns end_active(level)
so that loops of the kind
have zero iterations, as may be expected if there are no active cells on this level.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
inherited |
Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.
|
inherited |
Return an iterator which is the first iterator not on level. If level
is the last level, then this returns end()
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
inherited |
Return an active iterator which is the first active iterator not on the given level. If level
is the last level, then this returns end()
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
inherited |
Return an iterator pointing to the last used cell.
|
inherited |
Return an iterator pointing to the last active cell.
|
inherited |
Return an iterator to a cell of this Triangulation object constructed from an independent CellId object.
|
inherited |
Check if the triangulation contains a cell with the id cell_id
. If the given argument corresponds to a valid cell in this triangulation, this operation will always return true for sequential triangulations where the current processor stores all cells that are part of the triangulation. On the other hand, if this is a parallel triangulation, then the current processor may not actually know about this cell. In this case, this operation will return true for locally relevant cells, but may return false for artificial cells that are less refined on the current processor.
|
inherited |
Return an iterator range that contains all cells (active or not) that make up this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().
|
inherited |
Return an iterator range that contains all active cells that make up this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11, see also C++11 standard.
Range-based for loops are useful in that they require much less code than traditional loops (see here for a discussion of how they work). An example is that without range-based for loops, one often writes code such as the following (assuming for a moment that our goal is setting the user flag on every active cell):
Using C++11's range-based for loops, this is now entirely equivalent to the following:
[this->begin_active(), this->end())
|
inherited |
Return an iterator range that contains all cells (active or not) that make up the given level of this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().
[in] | level | A given level in the refinement hierarchy of this triangulation. |
[this->begin(level), this->end(level))
|
inherited |
Return an iterator range that contains all active cells that make up the given level of this triangulation. Such a range is useful to initialize range-based for loops as supported by C++11. See the example in the documentation of active_cell_iterators().
[in] | level | A given level in the refinement hierarchy of this triangulation. |
[this->begin_active(level), this->end(level))
|
inherited |
Iterator to the first used face.
|
inherited |
Iterator to the first active face.
|
inherited |
Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.
|
inherited |
Return an iterator range that contains all active faces that make up this triangulation. This function is the face version of Triangulation::active_cell_iterators(), and allows one to write code like, e.g.,
[this->begin_active_face(), this->end_face())
|
inherited |
Iterator to the first used vertex. This function can only be used if dim is not one.
|
inherited |
Iterator to the first active vertex. Because all vertices are active, begin_vertex() and begin_active_vertex() return the same vertex. This function can only be used if dim is not one.
|
inherited |
Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states. This function can only be used if dim is not one.
|
inherited |
In the following, most functions are provided in two versions, with and without an argument describing the level. The versions with this argument are only applicable for objects describing the cells of the present triangulation. For example: in 2d n_lines(level)
cannot be called, only n_lines()
, as lines are faces in 2d and therefore have no level. Return the total number of used lines, active or not.
|
inherited |
Return the total number of used lines, active or not on level level
.
|
inherited |
Return the total number of active lines.
|
inherited |
Return the total number of active lines, on level level
.
|
inherited |
Return the total number of used quads, active or not.
|
inherited |
Return the total number of used quads, active or not on level level
.
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
Return the total number of active quads, active or not.
|
inherited |
Return the total number of active quads, active or not on level level
.
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
Return the total number of used hexahedra, active or not.
|
inherited |
Return the total number of used hexahedra, active or not on level level
.
|
inherited |
|
inherited |
|
inherited |
Return the total number of active hexahedra, active or not.
|
inherited |
Return the total number of active hexahedra, active or not on level level
.
|
inherited |
|
inherited |
|
inherited |
Return the total number of used cells, active or not. Maps to n_lines()
in one space dimension and so on.
|
inherited |
Return the total number of used cells, active or not, on level level
. Maps to n_lines(level)
in one space dimension and so on.
|
inherited |
Return the total number of active cells. Maps to n_active_lines()
in one space dimension and so on.
|
inherited |
Return the total number of active cells on level level
. Maps to n_active_lines(level)
in one space dimension and so on.
|
inherited |
|
inherited |
Return the total number of active faces. In 2d, the result equals n_active_lines(), in 3d it equals n_active_quads(), while in 1d it equals the number of used vertices.
|
inherited |
Return the number of levels in this triangulation.
|
inherited |
Return the total number of vertices. Some of them may not be used, which usually happens upon coarsening of a triangulation when some vertices are discarded, but we do not want to renumber the remaining ones, leading to holes in the numbers of used vertices. You can get the number of used vertices using n_used_vertices
function.
|
inherited |
Return a constant reference to all the vertices present in this triangulation. Note that not necessarily all vertices in this array are actually used; for example, if you coarsen a mesh, then some vertices are deleted, but their positions in this array are unchanged as the indices of vertices are only allocated once. You can find out about which vertices are actually used by the function get_used_vertices().
|
inherited |
Return the number of vertices that are presently in use, i.e. belong to at least one used element.
|
inherited |
Return true
if the vertex with this index
is used.
|
inherited |
Return a constant reference to the array of bools
indicating whether an entry in the vertex array is used or not.
|
inherited |
Return the maximum number of cells meeting at a common vertex. Since this number is an invariant under refinement, only the cells on the coarsest level are considered. The operation is thus reasonably fast. The invariance is only true for sufficiently many cells in the coarsest triangulation (e.g. for a single cell one would be returned), so a minimum of four is returned in two dimensions, 8 in three dimensions, etc, which is how many cells meet if the triangulation is refined.
In one space dimension, two is returned.
|
inherited |
|
inherited |
|
inherited |
|
inherited |
Return a reference to the current object.
This doesn't seem to be very useful but allows to write code that can access the underlying triangulation for anything that satisfies the MeshType concept (which may not only be a triangulation, but also a DoFHandler, for example).
|
inherited |
Return a reference to the current object. This is the const-version of the previous function.
|
inherited |
Total number of lines, used or unused.
|
inherited |
Number of lines, used or unused, on the given level.
|
inherited |
Total number of quads, used or unused.
|
inherited |
Number of quads, used or unused, on the given level.
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
Number of hexs, used or unused, on the given level.
|
inherited |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
Number of cells, used or unused, on the given level.
|
inherited |
Return the total number of faces, used or not. In 2d, the result equals n_raw_lines(), in 3d it equals n_raw_quads(), while in 1d it equals the number of vertices.
|
inherited |
Write the data of this object to a stream for the purpose of serialization using the BOOST serialization library.
|
virtualinherited |
Save the mesh and associated information into a number of files that all use the provided basename as a starting prefix, plus some suffixes that indicate the specific use of that file.
Save the triangulation into the given file. Internally, this function calls the save function which uses BOOST archives.
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< 1, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
|
inherited |
Read the data of this object from a stream for the purpose of serialization using the BOOST serialization library. Throw away the previous content.
|
virtualinherited |
Load the triangulation saved with save() back in.
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< 1, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
|
virtualinherited |
Declare the (coarse) face pairs given in the argument of this function as periodic. This way it is possible to obtain neighbors across periodic boundaries.
The vector can be filled by the function GridTools::collect_periodic_faces.
For more information on periodic boundary conditions see GridTools::collect_periodic_faces, DoFTools::make_periodicity_constraints and step-45.
|
inherited |
Return the periodic_face_map.
|
inherited |
Return vector filled with the used reference-cell types of this triangulation.
|
inherited |
Indicate if the triangulation only consists of hypercube-like cells, i.e., lines, quadrilaterals, or hexahedra.
|
inherited |
Indicate if the triangulation only consists of simplex-like cells, i.e., lines, triangles, or tetrahedra.
|
inherited |
Indicate if the triangulation consists of different cell types (mix of simplices, hypercubes, ...) or different face types, as in the case of pyramids or wedges..
|
inherited |
Write and read the data of this object from a stream for the purpose of serialization. using the BOOST serialization library.
This function is used in step-83.
|
inherited |
Register a function that can be used to attach data of fixed size to cells. This is useful for two purposes: (i) Upon refinement and coarsening of a triangulation (e.g. in parallel::distributed::Triangulation::execute_coarsening_and_refinement()), one needs to be able to store one or more data vectors per cell that characterizes the solution values on the cell so that this data can then be transferred to the new owning processor of the cell (or its parent/children) when the mesh is re-partitioned; (ii) when serializing a computation to a file, it is necessary to attach data to cells so that it can be saved (e.g. in parallel::distributed::Triangulation::save()) along with the cell's other information and, if necessary, later be reloaded from disk with a different subdivision of cells among the processors.
The way this function works is that it allows any number of interest parties to register their intent to attach data to cells. One example of classes that do this is parallel::distributed::SolutionTransfer where each parallel::distributed::SolutionTransfer object that works on the current Triangulation object then needs to register its intent. Each of these parties registers a callback function (the first argument here, pack_callback
) that will be called whenever the triangulation's execute_coarsening_and_refinement() or save() functions are called.
The current function then returns an integer handle that corresponds to the number of data set that the callback provided here will attach. While this number could be given a precise meaning, this is not important: You will never actually have to do anything with this number except return it to the notify_ready_to_unpack() function. In other words, each interested party (i.e., the caller of the current function) needs to store their respective returned handle for later use when unpacking data in the callback provided to notify_ready_to_unpack().
Whenever pack_callback
is then called by execute_coarsening_and_refinement() or load() on a given cell, it receives a number of arguments. In particular, the first argument passed to the callback indicates the cell for which it is supposed to attach data. This is always an active cell.
The second, CellStatus, argument provided to the callback function will tell you if the given cell will be coarsened, refined, or will persist as is. (This status may be different than the refinement or coarsening flags set on that cell, to accommodate things such as the "one hanging node per edge" rule.). These flags need to be read in context with the p4est quadrant they belong to, as their relations are gathered in local_cell_relations.
Specifically, the values for this argument mean the following:
CellStatus::cell_will_persist
: The cell won't be refined/coarsened, but might be moved to a different processor. If this is the case, the callback will want to pack up the data on this cell into an array and store it at the provided address for later unpacking wherever this cell may land.CellStatus::cell_will_be_refined
: This cell will be refined into 4 or 8 cells (in 2d and 3d, respectively). However, because these children don't exist yet, you cannot access them at the time when the callback is called. Thus, in local_cell_relations, the corresponding p4est quadrants of the children cells are linked to the deal.II cell which is going to be refined. To be specific, only the very first child is marked with CellStatus::cell_will_be_refined
, whereas the others will be marked with CellStatus::cell_invalid
, which indicates that these cells will be ignored by default during the packing or unpacking process. This ensures that data is only transferred once onto or from the parent cell. If the callback is called with CellStatus::cell_will_be_refined
, the callback will want to pack up the data on this cell into an array and store it at the provided address for later unpacking in a way so that it can then be transferred to the children of the cell that will then be available. In other words, if the data the callback will want to pack up corresponds to a finite element field, then the prolongation from parent to (new) children will have to happen during unpacking.CellStatus::children_will_be_coarsened
: The children of this cell will be coarsened into the given cell. These children still exist, so if this is the value given to the callback as second argument, the callback will want to transfer data from the children to the current parent cell and pack it up so that it can later be unpacked again on a cell that then no longer has any children (and may also be located on a different processor). In other words, if the data the callback will want to pack up corresponds to a finite element field, then it will need to do the restriction from children to parent at this point.CellStatus::cell_invalid
: See CellStatus::cell_will_be_refined
.CellStatus::cell_will_persist
.The callback function is expected to return a memory chunk of the format std::vector<char>
, representing the packed data on a certain cell.
The second parameter returns_variable_size_data
indicates whether the returned size of the memory region from the callback function varies by cell (=true
) or stays constant on each one throughout the whole domain (=false
).
|
inherited |
This function is the opposite of register_data_attach(). It is called after the execute_coarsening_and_refinement() or save()/load() functions are done when classes and functions that have previously attached data to a triangulation for either transfer to other processors, across mesh refinement, or serialization of data to a file are ready to receive that data back. The important part about this process is that the triangulation cannot do this right away from the end of execute_coarsening_and_refinement() or load() via a previously attached callback function (as the register_data_attach() function does) because the classes that eventually want the data back may need to do some setup between the point in time where the mesh has been recreated and when the data can actually be received. An example is the parallel::distributed::SolutionTransfer class that can really only receive the data once not only the mesh is completely available again on the current processor, but only after a DoFHandler has been reinitialized and distributed degrees of freedom. In other words, there is typically a significant amount of set up that needs to happen in user space before the classes that can receive data attached to cell are ready to actually do so. When they are, they use the current function to tell the triangulation object that now is the time when they are ready by calling the current function.
The supplied callback function is then called for each newly locally owned cell. The first argument to the callback is an iterator that designates the cell; the second argument indicates the status of the cell in question; and the third argument localizes a memory area by two iterators that contains the data that was previously saved from the callback provided to register_data_attach().
The CellStatus will indicate if the cell was refined, coarsened, or persisted unchanged. The cell_iterator
argument to the callback will then either be an active, locally owned cell (if the cell was not refined), or the immediate parent if it was refined during execute_coarsening_and_refinement(). Therefore, contrary to during register_data_attach(), you can now access the children if the status is CellStatus::cell_will_be_refined
but no longer for callbacks with status CellStatus::children_will_be_coarsened
.
The first argument to this function, handle
, corresponds to the return value of register_data_attach(). (The precise meaning of what the numeric value of this handle is supposed to represent is neither important, nor should you try to use it for anything other than transmit information between a call to register_data_attach() to the corresponding call to notify_ready_to_unpack().)
|
protectedinherited |
Save additional cell-attached data from files all starting with the base name given as last argument. The first arguments are used to determine the offsets where to write buffers to.
Called by save.
|
protectedinherited |
Load additional cell-attached data files all starting with the base name given as fourth argument, if any was saved. The first arguments are used to determine the offsets where to read buffers from.
Called by load.
|
protectedinherited |
A function to record the CellStatus of currently active cells. This information is mandatory to transfer data between meshes during adaptation or serialization, e.g., using SolutionTransfer.
Relations will be stored in the private member local_cell_relations. For an extensive description of CellStatus, see the documentation for the member function register_data_attach().
|
staticinherited |
Exception
|
staticinherited |
The function raising this exception can only operate on an empty Triangulation, i.e., a Triangulation without grid cells.
|
staticinherited |
Trying to re-read a grid, an error occurred.
|
staticinherited |
Exception
|
staticinherited |
The triangulation level you accessed is empty.
|
staticinherited |
Exception
Requested boundary_id not found
|
staticinherited |
Exception
|
staticprotectedinherited |
Write a bool vector to the given stream, writing a pre- and a postfix magic number. The vector is written in an almost binary format, i.e. the bool flags are packed but the data is written as ASCII text.
The flags are stored in a binary format: for each true
, a 1
bit is stored, a 0
bit otherwise. The bits are stored as unsigned char
, thus avoiding endianness. They are written to out
in plain text, thus amounting to 3.6 bits in the output per bits in the input on the average. Other information (magic numbers and number of elements of the input vector) is stored as plain text as well. The format should therefore be interplatform compatible.
|
staticprotectedinherited |
Re-read a vector of bools previously written by write_bool_vector
and compare with the magic numbers.
|
protectedinherited |
Recreate information about periodic neighbors from periodic_face_pairs_level_0.
|
privateinherited |
Iterator to the first cell, used or not, on level level
. If a level has no cells, a past-the-end iterator is returned.
|
privateinherited |
Return a raw iterator which is the first iterator not on level. If level
is the last level, then this returns end()
.
|
privateinherited |
Iterator to the first line, used or not, on level level
. If a level has no lines, a past-the-end iterator is returned. If lines are no cells, i.e. for dim>1
no level
argument must be given. The same applies for all the other functions above, of course.
|
privateinherited |
Iterator to the first used line on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator to the first active line on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.
|
privateinherited |
Iterator to the first quad, used or not, on the given level. If a level has no quads, a past-the-end iterator is returned. If quads are no cells, i.e. for \(dim>2\) no level argument must be given.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator to the first used quad on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator to the first active quad on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.
|
privateinherited |
Iterator to the first hex, used or not, on level level
. If a level has no hexes, a past-the-end iterator is returned.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator to the first used hex on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator to the first active hex on level level
.
level
argument needs to correspond to a level of the triangulation, i.e., should be less than the value returned by n_levels(). On the other hand, for parallel computations using a parallel::distributed::Triangulation object, it is often convenient to write loops over the cells of all levels of the global mesh, even if the local portion of the triangulation does not actually have cells at one of the higher levels. In those cases, the level
argument is accepted if it is less than what the n_global_levels() function returns. If the given level
is between the values returned by n_levels() and n_global_levels(), then no cells exist in the local portion of the triangulation at this level, and the function simply returns what end() would return.
|
privateinherited |
Iterator past the end; this iterator serves for comparisons of iterators with past-the-end or before-the-beginning states.
|
privateinherited |
The (public) function clear() will only work when the triangulation is not subscribed to by other users. The clear_despite_subscriptions() function now allows the triangulation being cleared even when there are subscriptions.
Make sure, you know what you do, when calling this function, as its use is reasonable in very rare cases, only. For example, when the subscriptions were for the initially empty Triangulation and the Triangulation object wants to release its memory before throwing an assertion due to input errors (e.g. in the create_triangulation() function).
|
privateinherited |
Reset triangulation policy.
|
privateinherited |
For all cells, set the active cell indices so that active cells know the how many-th active cell they are, and all other cells have an invalid value. This function is called after mesh creation, refinement, and serialization.
|
privateinherited |
Reset cache for the cells' vertex indices.
|
privateinherited |
Refine all cells on all levels which were previously flagged for refinement.
Note, that this function uses the line->user_flags
for dim=2,3
and the quad->user_flags
for dim=3
.
The function returns a list of cells that have produced children that satisfy the criteria of distorted cells if the check_for_distorted_cells
flag was specified upon creation of this object, at
|
privateinherited |
Coarsen all cells which were flagged for coarsening, or rather: delete all children of those cells of which all child cells are flagged for coarsening and several other constraints hold (see the general doc of this class).
|
privateinherited |
Make sure that either all or none of the children of a cell are tagged for coarsening.
|
privatevirtualinherited |
Translate the unique id of a coarse cell to its index. See the glossary entry on coarse cell IDs for more information.
coarse_cell_id | Unique id of the coarse cell. |
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< 1, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
|
privatevirtualinherited |
Translate the index of coarse cell to its unique id. See the glossary entry on coarse cell IDs for more information.
coarse_cell_index | Index of the coarse cell. |
Reimplemented in parallel::distributed::Triangulation< dim, spacedim >, parallel::distributed::Triangulation< 1, spacedim >, parallel::distributed::Triangulation< dim, dim >, parallel::distributed::Triangulation< dim, spacedim >, and parallel::fullydistributed::Triangulation< dim, spacedim >.
|
inherited |
Subscribes a user of the object by storing the pointer validity
. The subscriber may be identified by text supplied as identifier
.
Definition at line 135 of file subscriptor.cc.
|
inherited |
Unsubscribes a user from the object.
identifier
and the validity
pointer must be the same as the one supplied to subscribe(). Definition at line 155 of file subscriptor.cc.
|
inlineinherited |
Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.
Definition at line 300 of file subscriptor.h.
|
inlineinherited |
List the subscribers to the input stream
.
Definition at line 317 of file subscriptor.h.
|
inherited |
List the subscribers to deallog
.
Definition at line 203 of file subscriptor.cc.
|
privatenoexceptinherited |
Check that there are no objects subscribing to this object. If this check passes then it is safe to destroy the current object. It this check fails then this function will either abort or print an error message to deallog (by using the AssertNothrow mechanism), but will not throw an exception.
Definition at line 52 of file subscriptor.cc.
|
protectedinherited |
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 320 of file tria_base.h.
|
protectedinherited |
The subdomain id to be used for the current processor. This is the MPI rank.
Definition at line 326 of file tria_base.h.
|
protectedinherited |
The total number of subdomains (or the size of the MPI communicator).
Definition at line 331 of file tria_base.h.
|
protectedinherited |
Definition at line 389 of file tria_base.h.
|
staticconstexprinherited |
|
staticconstexprinherited |
|
staticconstexprinherited |
|
staticconstexprinherited |
|
staticconstexprinherited |
|
staticconstexprinherited |
|
mutableinherited |
|
inherited |
|
protectedinherited |
Vector of pairs, each containing a deal.II cell iterator and its respective CellStatus. To update its contents, use the update_cell_relations() member function.
|
protectedinherited |
|
protectedinherited |
|
protectedinherited |
|
privateinherited |
|
privateinherited |
If add_periodicity() is called, this variable stores the given periodic face pairs on level 0 for later access during the identification of ghost cells for the multigrid hierarchy and for setting up the periodic_face_map.
|
privateinherited |
If add_periodicity() is called, this variable stores the active periodic face pairs.
|
privateinherited |
|
privateinherited |
|
privateinherited |
|
privateinherited |
|
privateinherited |
Collection of manifold objects. We store only objects, which are not of type FlatManifold.
|
privateinherited |
|
privateinherited |
|
privateinherited |
A map that relates the number of a boundary vertex to the boundary indicator. This field is only used in 1d. We have this field because we store boundary indicator information with faces in 2d and higher where we have space in the structures that store data for faces, but in 1d there is no such space for faces.
The field is declared as a pointer for a rather mundane reason: all other fields of this class that can be modified by the TriaAccessor hierarchy are pointers, and so these accessor classes store a const pointer to the triangulation. We could no longer do so for TriaAccessor<0,1,spacedim> if this field (that can be modified by TriaAccessor::set_boundary_id) were not a pointer.
|
privateinherited |
A map that relates the number of a boundary vertex to the manifold indicator. This field is only used in 1d. We have this field because we store manifold indicator information with faces in 2d and higher where we have space in the structures that store data for faces, but in 1d there is no such space for faces.
The field is declared as a pointer for a rather mundane reason: all other fields of this class that can be modified by the TriaAccessor hierarchy are pointers, and so these accessor classes store a const pointer to the triangulation. We could no longer do so for TriaAccessor<0,1,spacedim> if this field (that can be modified by TriaAccessor::set_manifold_id) were not a pointer.
|
mutableprivateinherited |
Store the number of objects which subscribed to this object. Initially, this number is zero, and upon destruction it shall be zero again (i.e. all objects which subscribed should have unsubscribed again).
The creator (and owner) of an object is counted in the map below if HE manages to supply identification.
We use the mutable
keyword in order to allow subscription to constant objects also.
This counter may be read from and written to concurrently in multithreaded code: hence we use the std::atomic
class template.
Definition at line 218 of file subscriptor.h.
|
mutableprivateinherited |
In this map, we count subscriptions for each different identification string supplied to subscribe().
Definition at line 224 of file subscriptor.h.
|
mutableprivateinherited |
In this vector, we store pointers to the validity bool in the SmartPointer objects that subscribe to this class.
Definition at line 240 of file subscriptor.h.
|
mutableprivateinherited |
Pointer to the typeinfo object of this object, from which we can later deduce the class name. Since this information on the derived class is neither available in the destructor, nor in the constructor, we obtain it in between and store it here.
Definition at line 248 of file subscriptor.h.
|
staticprivateinherited |
A mutex used to ensure data consistency when accessing the mutable
members of this class. This lock is used in the subscribe() and unsubscribe() functions, as well as in list_subscribers()
.
Definition at line 271 of file subscriptor.h.