bvh.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2021 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_arborx_bvh_h
#define dealii_arborx_bvh_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_ARBORX
#  include <deal.II/arborx/access_traits.h>
 
#  include <ArborX_Config.hpp>
#  include <ArborX_LinearBVH.hpp>
#  include <Kokkos_Core.hpp>
 
#endif
 
DEAL_II_NAMESPACE_OPEN
 
#ifdef DEAL_II_WITH_ARBORX
namespace ArborXWrappers
{
#  if ARBORX_VERSION_MAJOR < 2
  class BVH
  {
  public:
    template <int dim, typename Number>
    BVH(const std::vector<BoundingBox<dim, Number>> &bounding_boxes);
 
    template <int dim, typename Number>
    BVH(const std::vector<Point<dim, Number>> &points);
 
    template <typename QueryType>
    std::pair<std::vector<int>, std::vector<int>>
    query(const QueryType &queries);
 
  private:
    ArborX::BVH<Kokkos::HostSpace> bvh;
  };
 
 
 
  template <int dim, typename Number>
  BVH::BVH(const std::vector<BoundingBox<dim, Number>> &bounding_boxes)
    : bvh(Kokkos::DefaultHostExecutionSpace{}, bounding_boxes)
  {}
 
 
 
  template <int dim, typename Number>
  BVH::BVH(const std::vector<Point<dim, Number>> &points)
    : bvh(Kokkos::DefaultHostExecutionSpace{}, points)
  {}
 
 
 
  template <typename QueryType>
  std::pair<std::vector<int>, std::vector<int>>
  BVH::query(const QueryType &queries)
  {
    Kokkos::View<int *, Kokkos::HostSpace> indices("indices", 0);
 
    Kokkos::View<int *, Kokkos::HostSpace> offset("offset", 0);
    ArborX::query(
      bvh, Kokkos::DefaultHostExecutionSpace{}, queries, indices, offset);
    std::vector<int> indices_vector;
    indices_vector.insert(indices_vector.begin(),
                          indices.data(),
                          indices.data() + indices.extent(0));
    std::vector<int> offset_vector;
    offset_vector.insert(offset_vector.begin(),
                         offset.data(),
                         offset.data() + offset.extent(0));
 
    return {indices_vector, offset_vector};
  }
#  else
  template <typename Value>
  class BVH
  {
  public:
    BVH(const std::vector<Value> &values);
 
    template <typename QueryType>
    std::pair<std::vector<int>, std::vector<int>>
    query(const QueryType &queries);
 
  private:
    ArborX::BVH<Kokkos::HostSpace,
                ArborX::PairValueIndex<Value, unsigned int>,
                internal::IndexableGetter>
      bvh;
  };
 
 
 
  template <typename Value>
  BVH<Value>::BVH(const std::vector<Value> &values)
    : bvh(Kokkos::DefaultHostExecutionSpace{},
          ArborX::Experimental::attach_indices(values),
          internal::IndexableGetter{})
  {}
 
 
 
  template <typename Value>
  template <typename QueryType>
  std::pair<std::vector<int>, std::vector<int>>
  BVH<Value>::query(const QueryType &queries)
  {
    Kokkos::View<int *, Kokkos::HostSpace> indices("indices", 0);
 
    Kokkos::View<int *, Kokkos::HostSpace> offset("offset", 0);
    bvh.query(Kokkos::DefaultHostExecutionSpace{},
              queries,
              internal::ExtractIndex{},
              indices,
              offset);
    std::vector<int> indices_vector;
    indices_vector.insert(indices_vector.begin(),
                          indices.data(),
                          indices.data() + indices.extent(0));
    std::vector<int> offset_vector;
    offset_vector.insert(offset_vector.begin(),
                         offset.data(),
                         offset.data() + offset.extent(0));
 
    return {indices_vector, offset_vector};
  }
#  endif
} // namespace ArborXWrappers
 
#endif
 
DEAL_II_NAMESPACE_CLOSE
#endif