Loading...
Searching...
No Matches
dolfinx::graph::build Namespace Reference

## Functions

std::tuple< graph::AdjacencyList< std::int64_t >, std::vector< int >, std::vector< std::int64_t >, std::vector< int > > | distribute (MPI_Comm comm, const graph::AdjacencyList< std::int64_t > &list, const graph::AdjacencyList< std::int32_t > &destinations)
| Distribute adjacency list nodes to destination ranks.
std::tuple< std::vector< std::int64_t >, std::vector< int >, std::vector< std::int64_t >, std::vector< int > > | distribute (MPI_Comm comm, std::span< const std::int64_t > list, std::array< std::size_t, 2 > shape, const graph::AdjacencyList< std::int32_t > &destinations)
| Distribute fixed size nodes to destination ranks.
std::vector< std::int64_t > | compute_ghost_indices (MPI_Comm comm, std::span< const std::int64_t > owned_indices, std::span< const std::int64_t > ghost_indices, std::span< const int > ghost_owners)
| Take a set of distributed input global indices, including ghosts, and determine the new global indices after remapping.
std::vector< std::int64_t > | compute_local_to_global (std::span< const std::int64_t > global, std::span< const std::int32_t > local)
std::vector< std::int32_t > | compute_local_to_local (std::span< const std::int64_t > local0_to_global, std::span< const std::int64_t > local1_to_global)
| Compute a local0-to-local1 map from two local-to-global maps with common global indices.

## Detailed Description

Tools for distributed graphs

Todo
  Add a function that sends data to the 'owner'

## Function Documentation

## compute_ghost_indices()

std::vector< std::int64_t > compute_ghost_indices | ( | MPI_Comm | comm,
|  | std::span< const std::int64_t > | owned_indices,
|  | std::span< const std::int64_t > | ghost_indices,
|  | std::span< const int > | ghost_owners )

Take a set of distributed input global indices, including ghosts, and determine the new global indices after remapping.

Each rank receive 'input' global indices [i0, i1, ..., i(m-1), im, ..., i(n-1)], where the first m indices are owned by the caller and the remainder are 'ghosts' indices that are owned by other ranks.

Each rank assigns new global indices to its owned indices. The new index is the rank offset (scan of the number of indices owned by the lower rank processes, typically computed using MPI_Exscan with MPI_SUM), i.e. i1 -> offset + 1, i2 -> offset + 2, etc. Ghost indices are number by the remote owning processes. The function returns the new ghost global indices by retrieving the new indices from the owning ranks.

Parameters

  [in] | comm | MPI communicator
  [in] | owned_indices | List of owned global indices. It should not contain duplicates, and these indices must not appear in owned_indices on other ranks.
  [in] | ghost_indices | List of ghost global indices.
  [in] | ghost_owners | The owning rank for each entry in ghost_indices.

Returns
  New global indices for the ghost indices.

## compute_local_to_global()

std::vector< std::int64_t > compute_local_to_global | ( | std::span< const std::int64_t > | global,
|  | std::span< const std::int32_t > | local )

Given an adjacency list with global, possibly non-contiguous, link indices and a local adjacency list with contiguous link indices starting from zero, compute a local-to-global map for the links. Both adjacency lists must have the same shape.

Parameters

  [in] | global | Adjacency list with global link indices.
  [in] | local | Adjacency list with local, contiguous link indices.

Returns
  Map from local index to global index, which if applied to the local adjacency list indices would yield the global adjacency list.

## compute_local_to_local()

std::vector< std::int32_t > compute_local_to_local | ( | std::span< const std::int64_t > | local0_to_global,
|  | std::span< const std::int64_t > | local1_to_global )

Compute a local0-to-local1 map from two local-to-global maps with common global indices.

Parameters

  [in] | local0_to_global | Map from local0 indices to global indices
  [in] | local1_to_global | Map from local1 indices to global indices

Returns
  Map from local0 indices to local1 indices

## distribute() [1/2]

std::tuple< graph::AdjacencyList< std::int64_t >, std::vector< int >, std::vector< std::int64_t >, std::vector< int > > distribute | ( | MPI_Comm | comm,
|  | const graph::AdjacencyList< std::int64_t > & | list,
|  | const graph::AdjacencyList< std::int32_t > & | destinations )

Distribute adjacency list nodes to destination ranks.

The global index of each node is assumed to be the local index plus the offset for this rank.

Parameters

  [in] | comm | MPI Communicator
  [in] | list | The adjacency list to distribute
  [in] | destinations | Destination ranks for the ith node in the adjacency list. The first rank is the 'owner' of the node.

Returns
  1. Received adjacency list for this process
  2. Source ranks for each node in the adjacency list
  3. Original global index for each node in the adjacency list
  4. Owning rank of ghost nodes.

## distribute() [2/2]

std::tuple< std::vector< std::int64_t >, std::vector< int >, std::vector< std::int64_t >, std::vector< int > > distribute | ( | MPI_Comm | comm,
|  | std::span< const std::int64_t > | list,
|  | std::array< std::size_t, 2 > | shape,
|  | const graph::AdjacencyList< std::int32_t > & | destinations )

Distribute fixed size nodes to destination ranks.

The global index of each node is assumed to be the local index plus the offset for this rank.

Parameters

  [in] | comm | MPI Communicator
  [in] | list | Constant degree (valency) adjacency list. The array shape is (num_nodes, degree). Storage is row-major.
  [in] | shape | Shape (num_nodes, degree) of list.
  [in] | destinations | Destination ranks for the ith node (row) of list. The first rank is the 'owner' of the node.

Returns
  1. Received adjacency list on this process. The array shape is (num_nodes, degree). Storage is row-major.
  2. Source rank for each received node.
  3. Original global index for each received node.
  4. Owning rank of ghost nodes.