utils.h

// Copyright (C) 2009-2022 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 <algorithm>
#include <boost/functional/hash.hpp>
#include <dolfinx/common/MPI.h>
#include <mpi.h>
#include <utility>
#include <vector>
 
namespace dolfinx::common
{
 
namespace impl
{
template <int N, class InputIt, class OutputIt>
inline void copy_N(InputIt first, OutputIt result)
{
  for (int i = 0; i < N; ++i)
    *result++ = *first++;
}
} // namespace impl
 
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)
{
  if (indices.size() != values.size())
    throw std::runtime_error("Cannot sort two arrays of different lengths");
 
  using T = typename std::pair<typename U::value_type, typename V::value_type>;
  std::vector<T> data(indices.size());
  std::transform(indices.begin(), indices.end(), values.begin(), data.begin(),
                 [](auto& idx, auto& v) -> T {
                   return {idx, v};
                 });
 
  // Sort make unique
  std::sort(data.begin(), data.end());
  auto it = std::unique(data.begin(), data.end(),
                        [](auto& a, auto& b) { return a.first == b.first; });
 
  std::vector<typename U::value_type> indices_new;
  std::vector<typename V::value_type> values_new;
  indices_new.reserve(data.size());
  values_new.reserve(data.size());
  std::transform(data.begin(), it, std::back_inserter(indices_new),
                 [](auto& d) { return d.first; });
  std::transform(data.begin(), it, std::back_inserter(values_new),
                 [](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));
  MPI_Gather(&local_hash, 1, dolfinx::MPI::mpi_type<std::size_t>(),
             all_hashes.data(), 1, dolfinx::MPI::mpi_type<std::size_t>(), 0,
             comm);
 
  // 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
  MPI_Bcast(&global_hash, 1, dolfinx::MPI::mpi_type<std::size_t>(), 0, comm);
 
  return global_hash;
}
 
} // namespace dolfinx::common