DOLFINx 0.10.0.0
DOLFINx C++ interface
Loading...
Searching...
No Matches
dolfinx::refinement Namespace Reference

Mesh refinement algorithms. More...

Namespaces

namespace  plaza
 Plaza mesh refinement.
 

Enumerations

enum class  Option : std::uint8_t { none = 0b00 , parent_facet = 0b01 , parent_cell = 0b10 , parent_cell_and_facet = 0b11 }
 Options for data to compute during mesh refinement. More...
 

Functions

constexpr Option operator| (Option a, Option b)
 Combine two refinement options into one, both flags will be set for the resulting option.
 
constexpr bool option_parent_facet (Option a)
 Check if parent_facet flag is set.
 
constexpr bool option_parent_cell (Option a)
 Check if parent_cell flag is set.
 
template<std::floating_point T>
std::tuple< mesh::Mesh< T >, std::optional< std::vector< std::int32_t > >, std::optional< std::vector< std::int8_t > > > refine (const mesh::Mesh< T > &mesh, std::optional< std::span< const std::int32_t > > edges, const mesh::CellPartitionFunction &partitioner=mesh::create_cell_partitioner(mesh::GhostMode::none), Option option=Option::none)
 Refine a mesh with markers.
 
void update_logical_edgefunction (MPI_Comm comm, const std::vector< std::vector< std::int32_t > > &marked_for_update, std::span< std::int8_t > marked_edges, const common::IndexMap &map)
 Communicate edge markers between processes that share edges.
 
template<std::floating_point T>
std::tuple< std::map< std::int32_t, std::int64_t >, std::vector< T >, std::array< std::size_t, 2 > > create_new_vertices (MPI_Comm comm, const graph::AdjacencyList< int > &shared_edges, const mesh::Mesh< T > &mesh, std::span< const std::int8_t > marked_edges)
 Add new vertex for each marked edge, and create new_vertex_coordinates and global_edge->new_vertex map.
 
std::vector< std::int64_t > adjust_indices (const common::IndexMap &map, std::int32_t n)
 Given an index map, add "n" extra indices at the end of local range.
 
std::array< std::vector< std::int32_t >, 2 > transfer_facet_meshtag (const mesh::MeshTags< std::int32_t > &tags0, const mesh::Topology &topology1, std::span< const std::int32_t > cell, std::span< const std::int8_t > facet)
 Transfer facet MeshTags from coarse mesh to refined mesh.
 
std::array< std::vector< std::int32_t >, 2 > transfer_cell_meshtag (const mesh::MeshTags< std::int32_t > &tags0, const mesh::Topology &topology1, std::span< const std::int32_t > parent_cell)
 Transfer cell MeshTags from coarse mesh to refined mesh.
 

Detailed Description

Mesh refinement algorithms.

Methods for refining meshes uniformly, or with markers, using edge bisection.

Enumeration Type Documentation

◆ Option

enum class Option : std::uint8_t
strong

Options for data to compute during mesh refinement.

Enumerator
none 

No extra data

parent_facet 

Compute list of the cell-local facet indices in the parent cell of each facet in each new cell (or -1 if no match)

parent_cell 

Compute list with the parent cell index for each new cell

Function Documentation

◆ adjust_indices()

std::vector< std::int64_t > adjust_indices ( const common::IndexMap & map,
std::int32_t n )

Given an index map, add "n" extra indices at the end of local range.

Todo
Improve docstring.
Note
The returned global indices (local and ghosts) are adjust for the addition of new local indices.
Parameters
[in]mapIndex map.
[in]nNumber of new local indices.
Returns
New global indices for both owned and ghosted indices in input index map.

◆ create_new_vertices()

template<std::floating_point T>
std::tuple< std::map< std::int32_t, std::int64_t >, std::vector< T >, std::array< std::size_t, 2 > > create_new_vertices ( MPI_Comm comm,
const graph::AdjacencyList< int > & shared_edges,
const mesh::Mesh< T > & mesh,
std::span< const std::int8_t > marked_edges )

Add new vertex for each marked edge, and create new_vertex_coordinates and global_edge->new_vertex map.

Communicate new vertices with MPI to all affected processes.

Parameters
[in]commMPI Communicator for neighborhood
[in]shared_edgesFor each local edge on a process map to ghost processes
[in]meshExisting mesh
[in]marked_edgesA marker for all edges on the process (local + ghosts) indicating if an edge should be refined
Returns
(0) map from local edge index to new vertex global index, (1) the coordinates of the new vertices (row-major storage) and (2) the shape of the new coordinates.

◆ refine()

template<std::floating_point T>
std::tuple< mesh::Mesh< T >, std::optional< std::vector< std::int32_t > >, std::optional< std::vector< std::int8_t > > > refine ( const mesh::Mesh< T > & mesh,
std::optional< std::span< const std::int32_t > > edges,
const mesh::CellPartitionFunction & partitioner = mesh::create_cell_partitioner(mesh::GhostMode::none),
Option option = Option::none )

Refine a mesh with markers.

The refined mesh can be optionally re-partitioned across processes. Passing nullptr for partitioner, refined cells will be on the same process as the parent cell.

Parent-child relationships can be optionally computed. Parent-child relationships can be used to create MeshTags on the refined mesh from MeshTags on the parent mesh.

Warning
Using the default partitioner for a refined mesh, the refined mesh will not include ghosts cells (cells connected by facet to an owned cell) even if the parent mesh is ghosted.
Passing nullptr for partitioner, the refined mesh will not have ghosts cells even if the parent mesh is ghosted. The possibility to not re-partition the refined mesh and include ghost cells in the refined mesh will be added in a future release.
Parameters
[in]meshInput mesh to be refined.
[in]edgesIndices of the edges that should be split in the refinement. If not provided (std::nullopt), uniform refinement is performed.
[in]partitionerPartitioner to be used to distribute the refined mesh. If not callable, refined cells will be on the same process as the parent cell.
[in]optionControl the computation of parent facets, parent cells. If an option is not selected, an empty list is returned.
Returns
New mesh, and optional parent cell indices and parent facet indices.

◆ transfer_cell_meshtag()

std::array< std::vector< std::int32_t >, 2 > transfer_cell_meshtag ( const mesh::MeshTags< std::int32_t > & tags0,
const mesh::Topology & topology1,
std::span< const std::int32_t > parent_cell )

Transfer cell MeshTags from coarse mesh to refined mesh.

Warning
The refined mesh must not have been redistributed during refinement.
Mesh/topology GhostMode must be mesh::GhostMode::none.
Parameters
[in]tags0Tags on the parent mesh.
[in]topology1Refined mesh topology.
[in]parent_cellParent cell of each cell in refined mesh.
Returns
(0) entities and (1) values on the refined topology.

◆ transfer_facet_meshtag()

std::array< std::vector< std::int32_t >, 2 > transfer_facet_meshtag ( const mesh::MeshTags< std::int32_t > & tags0,
const mesh::Topology & topology1,
std::span< const std::int32_t > cell,
std::span< const std::int8_t > facet )

Transfer facet MeshTags from coarse mesh to refined mesh.

Warning
The refined mesh must not have been redistributed during refinement.
Mesh/topology GhostMode must be mesh::GhostMode::none.
Parameters
[in]tags0Tags on the parent mesh.
[in]topology1Refined mesh topology.
[in]cellParent cell of each cell in refined mesh
[in]facetLocal facets of parent in each cell in refined mesh.
Returns
(0) entities and (1) values on the refined topology.

◆ update_logical_edgefunction()

void update_logical_edgefunction ( MPI_Comm comm,
const std::vector< std::vector< std::int32_t > > & marked_for_update,
std::span< std::int8_t > marked_edges,
const common::IndexMap & map )

Communicate edge markers between processes that share edges.

Parameters
[in]commMPI Communicator for neighborhood
[in]marked_for_updateLists of edges to be updated on each neighbor. marked_for_update[r] is the list of edge indices that are marked by the caller and are shared with local MPI rank r.
[in,out]marked_edgesMarker for each edge on the calling process
[in]mapIndex map for the mesh edges