DOLFINx 0.8.0
DOLFINx C++ interface
|
Miscellaneous classes, functions and types. More...
Classes | |
class | IndexMap |
class | Scatterer |
A Scatterer supports the MPI scattering and gathering of data that is associated with a common::IndexMap. More... | |
class | TimeLogger |
Timer logging. More... | |
class | TimeLogManager |
Logger initialisation. More... | |
class | Timer |
Enumerations | |
enum class | IndexMapOrder : bool { preserve = true , any = false } |
Functions | |
std::vector< int32_t > | compute_owned_indices (std::span< const std::int32_t > indices, const IndexMap &map) |
Given a sorted vector of indices (local numbering, owned or ghost) and an index map, this function returns the indices owned by this process, including indices that might have been in the list of indices on another processes. | |
std::tuple< std::int64_t, std::vector< std::int32_t >, std::vector< std::vector< std::int64_t > >, std::vector< std::vector< int > > > | stack_index_maps (const std::vector< std::pair< std::reference_wrapper< const IndexMap >, int > > &maps) |
Compute layout data and ghost indices for a stacked (concatenated) index map, i.e. 'splice' multiple maps into one. | |
std::pair< IndexMap, std::vector< std::int32_t > > | create_sub_index_map (const IndexMap &imap, std::span< const std::int32_t > indices, IndexMapOrder order=IndexMapOrder::any, bool allow_owner_change=false) |
Create a new index map from a subset of indices in an existing index map. | |
template<typename U , typename V > | |
std::pair< std::vector< typename U::value_type >, std::vector< typename V::value_type > > | sort_unique (const U &indices, const V &values) |
template<class T > | |
std::size_t | hash_local (const T &x) |
Compute a hash of a given object. | |
template<class T > | |
std::size_t | hash_global (MPI_Comm comm, const T &x) |
Compute a hash for a distributed (MPI) object. | |
Miscellaneous classes, functions and types.
Generic tools.
This namespace provides utility type functions for managing subsystems, convenience classes and library-wide typedefs.
|
strong |
std::vector< int32_t > compute_owned_indices | ( | std::span< const std::int32_t > | indices, |
const IndexMap & | map ) |
Given a sorted vector of indices (local numbering, owned or ghost) and an index map, this function returns the indices owned by this process, including indices that might have been in the list of indices on another processes.
[in] | indices | List of indices |
[in] | map | The index map |
std::pair< IndexMap, std::vector< std::int32_t > > create_sub_index_map | ( | const IndexMap & | imap, |
std::span< const std::int32_t > | indices, | ||
IndexMapOrder | order = IndexMapOrder::any, | ||
bool | allow_owner_change = false ) |
Create a new index map from a subset of indices in an existing index map.
[in] | imap | Parent map to create a new sub-map from. |
[in] | indices | Local indices in imap (owned and ghost) to include in the new index map. |
[in] | order | Control the order in which ghost indices appear in the new map. |
[in] | allow_owner_change | If true , indices that are not included in indices by their owning process can be included in indices by processes that ghost the indices to be included in the new submap. These indices will be owned by one of the sharing processes in the submap. If false , and exception is raised if an index is included by a sharing process and not by the owning process. |
indices
must be sorted and must not contain duplicates. std::size_t hash_global | ( | MPI_Comm | comm, |
const T & | x ) |
Compute a hash for a distributed (MPI) object.
A hash is computed on each process for the local part of the object. Then, a hash of the std::vector containing each local hash key in rank order is returned.
[in] | comm | The communicator on which to compute the hash. |
[in] | x | The object to compute a hash of. |
std::size_t hash_local | ( | const T & | x | ) |
Compute a hash of a given object.
The hash is computed using Boost container hash (https://www.boost.org/doc/libs/release/libs/container_hash/).
[in] | x | The object to compute a hash of. |
std::pair< std::vector< typename U::value_type >, std::vector< typename V::value_type > > sort_unique | ( | const U & | indices, |
const V & | values ) |
Sort two arrays based on the values in array indices
. Any duplicate indices and the corresponding value are removed. In the case of duplicates, the entry with the smallest value is retained.
[in] | indices | Array of indices |
[in] | values | Array of values |
std::tuple< std::int64_t, std::vector< std::int32_t >, std::vector< std::vector< std::int64_t > >, std::vector< std::vector< int > > > stack_index_maps | ( | const std::vector< std::pair< std::reference_wrapper< const IndexMap >, int > > & | maps | ) |
Compute layout data and ghost indices for a stacked (concatenated) index map, i.e. 'splice' multiple maps into one.
The input maps are concatenated, with indices in maps
and owned by the caller remaining owned by the caller. Ghost data is stored at the end of the local range as normal, with the ghosts in blocks in the order of the index maps in maps
.
[in] | maps | List of (index map, block size) pairs |