utils.h

// Copyright (C) 2009-2025 Anders Logg and Garth N. Wells
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include "MPI.h"
#include <algorithm>
#include <boost/functional/hash.hpp>
#include <cstddef>
#include <cstdint>
#include <dolfinx/graph/AdjacencyList.h>
#include <iterator>
#include <mpi.h>
#include <ranges>
#include <stdexcept>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

namespace dolfinx::common
{
template <std::ranges::input_range U, std::ranges::input_range V>
std::pair<std::vector<typename U::value_type>,
          std::vector<typename V::value_type>>
sort_unique(const U& indices, const V& values)
{
  if (indices.size() != values.size())
    throw std::runtime_error("Cannot sort two arrays of different lengths");
 
  using T = std::pair<typename U::value_type, typename V::value_type>;
  std::vector<T> data(indices.size());
  std::ranges::transform(indices, values, data.begin(),
                         [](const auto& idx, const auto& v) -> T
                         { return {idx, v}; });
 
  // Sort by (index, value), then drop duplicate indices keeping the
  // first of each run, i.e. the smallest value (as documented).
  std::ranges::sort(data);
  auto it = std::ranges::unique(data, [](const auto& a, const auto& b)
                                { return a.first == b.first; })
                .begin();
 
  std::vector<typename U::value_type> indices_new;
  std::vector<typename V::value_type> values_new;
  std::size_t n = std::distance(data.begin(), it);
  indices_new.reserve(n);
  values_new.reserve(n);
  std::transform(data.begin(), it, std::back_inserter(indices_new),
                 [](const auto& d) { return d.first; });
  std::transform(data.begin(), it, std::back_inserter(values_new),
                 [](const auto& d) { return d.second; });
 
  return {std::move(indices_new), std::move(values_new)};
}

template <class T>
std::size_t hash_local(const T& x)
{
  boost::hash<T> hash;
  return hash(x);
}

template <class T>
std::size_t hash_global(MPI_Comm comm, const T& x)
{
  // Compute local hash
  std::size_t local_hash = hash_local(x);
 
  // Gather hash keys on root process
  std::vector<std::size_t> all_hashes(dolfinx::MPI::size(comm));
  int err = MPI_Gather(&local_hash, 1, dolfinx::MPI::mpi_t<std::size_t>,
                       all_hashes.data(), 1, dolfinx::MPI::mpi_t<std::size_t>,
                       0, comm);
  dolfinx::MPI::check_error(comm, err);
 
  // Hash the received hash keys
  boost::hash<std::vector<std::size_t>> hash;
  std::size_t global_hash = hash(all_hashes);
 
  // Broadcast hash key to all processes
  err = MPI_Bcast(&global_hash, 1, dolfinx::MPI::mpi_t<std::size_t>, 0, comm);
  dolfinx::MPI::check_error(comm, err);
 
  return global_hash;
}

std::string comm_to_json(
    const graph::AdjacencyList<std::tuple<int, std::size_t, std::int8_t>,
                               std::pair<std::int32_t, std::int32_t>>& g);
} // namespace dolfinx::common