IndexMap.h

// Copyright (C) 2015-2024 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 "MPI.h"
#include <array>
#include <cstdint>
#include <functional>
#include <memory>
#include <span>
#include <tuple>
#include <utility>
#include <vector>
 
namespace dolfinx::common
{
// Forward declaration
class IndexMap;

enum class IndexMapOrder : bool
{
  preserve = true, 
  any = false      
};

std::vector<std::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 IndexMap>, int>>&
        maps);

std::tuple<IndexMap, std::vector<std::int32_t>, bool>
create_sub_index_map(const IndexMap& imap,
                     std::span<const std::int32_t> indices,
                     IndexMapOrder order = IndexMapOrder::any);

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,
           int tag = static_cast<int>(dolfinx::MPI::tag::consensus_nbx));

  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 (deleted)
  IndexMap(const IndexMap& map) = delete;

  IndexMap(IndexMap&& map) = default;

  ~IndexMap() = default;
 
  // Copy assignment (deleted)
  IndexMap& operator=(const IndexMap& map) = delete;

  IndexMap& operator=(IndexMap&& map) = default;

  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;

  std::span<const 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;

  std::span<const int> owners() const noexcept { return _owners; }

  std::pair<std::vector<int>, std::vector<std::int32_t>> index_to_dest_ranks(
      int tag = static_cast<int>(dolfinx::MPI::tag::consensus_nbx)) const;

  std::vector<std::int32_t> shared_indices() const;

  std::span<const int> src() const noexcept;

  std::span<const int> dest() const noexcept;

  std::vector<std::int32_t> weights_src() const;

  std::vector<std::int32_t> weights_dest() const;

  std::array<std::vector<int>, 2> rank_type(int split_type) const;
 
private:
  // Global range of owned indices
  std::array<std::int64_t, 2> _local_range;
 
  // Global number of indices
  std::int64_t _size_global;
 
  // Map communicator
  dolfinx::MPI::Comm _comm;
 
  // Global ghost indices
  std::vector<std::int64_t> _ghosts;
 
  // Owner ranks for ghosts
  std::vector<int> _owners;
 
  // Ranks that own ghosts
  std::vector<int> _src;
 
  // Ranks that ghost owned entries
  std::vector<int> _dest;
};
 
} // namespace dolfinx::common