DOLFINx 0.9.0
DOLFINx C++ interface
Loading...
Searching...
No Matches
dolfinx::common Namespace Reference

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)
 Sort two arrays based on the values in array indices.
 
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.
 

Detailed Description

Miscellaneous classes, functions and types.

Generic tools.

This namespace provides utility type functions for managing subsystems, convenience classes and library-wide typedefs.

Enumeration Type Documentation

◆ IndexMapOrder

enum class IndexMapOrder : bool
strong

Enum to control preservation of ghost index ordering in sub-IndexMaps.

Enumerator
preserve 

Preserve the ordering of ghost indices.

any 

Allow arbitrary ordering of ghost indices in sub-maps.

Function Documentation

◆ compute_owned_indices()

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.

Parameters
[in]indicesList of indices
[in]mapThe index map
Returns
Indices owned by the calling process

◆ create_sub_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.

Parameters
[in]imapParent map to create a new sub-map from.
[in]indicesLocal indices in imap (owned and ghost) to include in the new index map.
[in]orderControl the order in which ghost indices appear in the new map.
[in]allow_owner_changeIf 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.
Returns
The (i) new index map and (ii) a map from local indices in the submap to local indices in the original (this) map.
Precondition
indices must be sorted and must not contain duplicates.

◆ hash_global()

template<class T >
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.

Note
Collective
Parameters
[in]commThe communicator on which to compute the hash.
[in]xThe object to compute a hash of.
Returns
The hash values.

◆ hash_local()

template<class T >
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/).

Parameters
[in]xThe object to compute a hash of.
Returns
The hash values.

◆ sort_unique()

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 )

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.

Parameters
[in]indicesArray of indices.
[in]valuesArray of values.
Returns
Sorted (indices, values), with sorting based on indices.

◆ stack_index_maps()

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.

Note
Index maps with a block size are unrolled in the data for the concatenated index map.
Communication is required to compute the new ghost indices.
Parameters
[in]mapsList of (index map, block size) pairs
Returns
The (0) global offset of a concatenated map for the calling rank, (1) local offset for the owned indices of each submap in the concatenated map, (2) new indices for the ghosts for each submap, and (3) owner rank of each ghost entry for each submap.