IndexMap.h

// Copyright (C) 2015-2022 Chris Richardson, Garth N. Wells and Igor Baratta
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include "IndexMap.h"
#include <cstdint>
#include <dolfinx/common/MPI.h>
#include <memory>
#include <span>
#include <utility>
#include <vector>
 
namespace dolfinx::common
{
// Forward declaration
class IndexMap;
 
std::vector<int32_t>
compute_owned_indices(std::span<const std::int32_t> indices,
                      const IndexMap& map);
 
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 common::IndexMap>, int>>& maps);
 
class IndexMap
{
public:
  IndexMap(MPI_Comm comm, std::int32_t local_size);
 
  IndexMap(MPI_Comm comm, std::int32_t local_size,
           std::span<const std::int64_t> ghosts, std::span<const int> owners);
 
  IndexMap(MPI_Comm comm, std::int32_t local_size,
           const std::array<std::vector<int>, 2>& src_dest,
           std::span<const std::int64_t> ghosts, std::span<const int> owners);
 
  // Copy constructor
  IndexMap(const IndexMap& map) = delete;
 
  IndexMap(IndexMap&& map) = default;
 
  ~IndexMap() = default;
 
  IndexMap& operator=(IndexMap&& map) = default;
 
  // Copy assignment
  IndexMap& operator=(const IndexMap& map) = delete;
 
  std::array<std::int64_t, 2> local_range() const noexcept;
 
  std::int32_t num_ghosts() const noexcept;
 
  std::int32_t size_local() const noexcept;
 
  std::int64_t size_global() const noexcept;
 
  const std::vector<std::int64_t>& ghosts() const noexcept;
 
  MPI_Comm comm() const;
 
  void local_to_global(std::span<const std::int32_t> local,
                       std::span<std::int64_t> global) const;
 
  void global_to_local(std::span<const std::int64_t> global,
                       std::span<std::int32_t> local) const;
 
  std::vector<std::int64_t> global_indices() const;
 
  const std::vector<int>& owners() const { return _owners; }
 
  std::pair<IndexMap, std::vector<std::int32_t>>
  create_submap(std::span<const std::int32_t> indices) const;
 
  graph::AdjacencyList<int> index_to_dest_ranks() const;
 
  std::vector<std::int32_t> shared_indices() const;
 
  const std::vector<int>& src() const noexcept;
 
  const std::vector<int>& dest() const noexcept;
 
  bool overlapped() const noexcept;
 
  std::array<double, 2> imbalance() const;
 
private:
  // Range of indices (global) owned by this process
  std::array<std::int64_t, 2> _local_range;
 
  // Number indices across communicator
  std::int64_t _size_global;
 
  // MPI communicator that map is defined on
  dolfinx::MPI::Comm _comm;
 
  // Local-to-global map for ghost indices
  std::vector<std::int64_t> _ghosts;
 
  // Local-to-global map for ghost indices
  std::vector<int> _owners;
 
  // Set of ranks that own ghosts
  std::vector<int> _src;
 
  // Set of ranks ghost owned indices
  std::vector<int> _dest;
 
  // True if map has overlaps (ghosts)
  bool _overlapping;
};
} // namespace dolfinx::common