access_traits.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_access_traits_h
#define dealii_arborx_access_traits_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_ARBORX
#  include <deal.II/base/bounding_box.h>
 
#  include <ArborX.hpp>
 
#  include <utility>
 
#endif
 
DEAL_II_NAMESPACE_OPEN
 
#ifdef DEAL_II_WITH_ARBORX
namespace ArborXWrappers
{
#  if ARBORX_VERSION_MAJOR < 2
  class PointPredicate
  {
  protected:
    template <int dim, typename Number>
    PointPredicate(const std::vector<::Point<dim, Number>> &points);
 
    std::size_t
    size() const;
 
    const ::Point<3, float> &
    get(unsigned int i) const;
 
  private:
    std::vector<::Point<3, float>> points;
  };
 
 
 
  class PointIntersectPredicate : private PointPredicate
  {
  public:
    template <int dim, typename Number>
    PointIntersectPredicate(
      const std::vector<::Point<dim, Number>> &points);
 
    // We need these since we inherit privately to avoid polymorphic use.
    using PointPredicate::get;
    using PointPredicate::size;
  };
 
 
 
  class PointNearestPredicate : private PointPredicate
  {
  public:
    template <int dim, typename Number>
    PointNearestPredicate(const std::vector<::Point<dim, Number>> &points,
                          const unsigned int n_nearest_neighbors);
 
    unsigned int
    get_n_nearest_neighbors() const;
 
    // We need these since we inherit privately to avoid polymorphic use.
    using PointPredicate::get;
    using PointPredicate::size;
 
  private:
    unsigned int n_nearest_neighbors;
  };
 
 
 
  class BoundingBoxPredicate
  {
  protected:
    template <int dim, typename Number>
    BoundingBoxPredicate(
      const std::vector<::BoundingBox<dim, Number>> &bounding_boxes);
 
    std::size_t
    size() const;
 
    const ::BoundingBox<3, float> &
    get(unsigned int i) const;
 
  private:
    std::vector<::BoundingBox<3, float>> bounding_boxes;
  };
 
 
 
  class BoundingBoxIntersectPredicate : private BoundingBoxPredicate
  {
  public:
    template <int dim, typename Number>
    BoundingBoxIntersectPredicate(
      const std::vector<::BoundingBox<dim, Number>> &bounding_boxes);
 
    // We need these since we inherit privately to avoid polymorphic use.
    using BoundingBoxPredicate::get;
    using BoundingBoxPredicate::size;
  };
 
 
  class BoundingBoxNearestPredicate : private BoundingBoxPredicate
  {
  public:
    template <int dim, typename Number>
    BoundingBoxNearestPredicate(
      const std::vector<::BoundingBox<dim, Number>> &bounding_boxes,
      const unsigned int                                   n_nearest_neighbors);
 
    unsigned int
    get_n_nearest_neighbors() const;
 
    // We need these since we inherit privately to avoid polymorphic use.
    using BoundingBoxPredicate::get;
    using BoundingBoxPredicate::size;
 
  private:
    unsigned int n_nearest_neighbors;
  };
 
 
 
  class SpherePredicate
  {
  protected:
    template <int dim, typename Number>
    SpherePredicate(
      const std::vector<std::pair<::Point<dim, Number>, Number>>
        &spheres);
 
    std::size_t
    size() const;
 
    const std::pair<::Point<3, float>, float> &
    get(unsigned int) const;
 
  private:
    std::vector<std::pair<::Point<3, float>, float>> spheres;
  };
 
 
 
  class SphereIntersectPredicate : private SpherePredicate
  {
  public:
    template <int dim, typename Number>
    SphereIntersectPredicate(
      const std::vector<std::pair<::Point<dim, Number>, Number>>
        &spheres);
 
    // We need these since we inherit privately to avoid polymorphic use.
    using SpherePredicate::get;
    using SpherePredicate::size;
  };
 
 
 
  class SphereNearestPredicate : private SpherePredicate
  {
  public:
    template <int dim, typename Number>
    SphereNearestPredicate(
      const std::vector<std::pair<::Point<dim, Number>, Number>> &spheres,
      const unsigned int n_nearest_neighbors);
 
    unsigned int
    get_n_nearest_neighbors() const;
 
    // We need these since we inherit privately to avoid polymorphic use.
    using SpherePredicate::get;
    using SpherePredicate::size;
 
  private:
    unsigned int n_nearest_neighbors;
  };
#  else
  namespace internal
  {
    template <int dim, typename Number>
    ArborX::Point<dim, Number>
    to_arborx_point(const ::Point<dim, Number> &p)
    {
      if constexpr (dim == 1)
        {
          return {{p[0]}};
        }
 
      if constexpr (dim == 2)
        {
          return {{p[0], p[1]}};
        }
 
      if constexpr (dim == 3)
        {
          return {{p[0], p[1], p[2]}};
        }
    }
 
    struct IndexableGetter
    {
      template <int dim, typename Number>
      ArborX::Point<dim, Number>
      operator()(const ArborX::PairValueIndex<::Point<dim, Number>,
                                              unsigned int> &pair) const
      {
        return to_arborx_point(pair.value);
      }
 
 
 
      template <int dim, typename Number>
      ArborX::Box<dim, Number>
      operator()(const ArborX::PairValueIndex<::BoundingBox<dim, Number>,
                                              unsigned int> &pair) const
      {
        const auto boundary_points = pair.value.get_boundary_points();
        const ::Point<dim, Number> min_corner = boundary_points.first;
        const ::Point<dim, Number> max_corner = boundary_points.second;
        return {to_arborx_point(min_corner), to_arborx_point(max_corner)};
      }
 
 
 
      template <int dim, typename Number>
      ArborX::Sphere<dim, Number>
      operator()(const ArborX::PairValueIndex<
                 std::pair<::Point<dim, Number>, Number>,
                 unsigned int> &pair) const
      {
        return {to_arborx_point(pair.value.first), pair.value.second};
      }
    };
 
 
 
    struct ExtractIndex
    {
      template <typename Query, typename Value, typename Output>
      KOKKOS_FUNCTION void
      operator()(const Query &, const Value &value, const Output &out) const
      {
        out(value.index);
      }
    };
 
 
 
    struct ExtractIndexRank
    {
      unsigned int rank;
 
      template <typename Predicate, typename Value, typename Output>
      KOKKOS_FUNCTION void
      operator()(const Predicate &,
                 const ArborX::PairValueIndex<Value> &value,
                 const Output                        &out) const
      {
        out({value.index, rank});
      }
    };
  } // namespace internal
 
 
 
  template <int dim, typename Number>
  class PointIntersectPredicate
  {
  public:
    PointIntersectPredicate(
      const std::vector<::Point<dim, Number>> &points);
 
    std::size_t
    size() const;
 
    const ::Point<dim, Number> &
    get(unsigned int i) const;
 
    static constexpr bool is_nearest = false;
 
  private:
    std::vector<::Point<dim, Number>> points;
  };
 
 
 
  template <int dim, typename Number>
  class PointNearestPredicate
  {
  public:
    PointNearestPredicate(const std::vector<::Point<dim, Number>> &points,
                          const unsigned int n_nearest_neighbors);
 
    unsigned int
    get_n_nearest_neighbors() const;
 
    std::size_t
    size() const;
 
    const ::Point<dim, Number> &
    get(unsigned int i) const;
 
 
    static constexpr bool is_nearest = true;
 
  private:
    std::vector<::Point<dim, Number>> points;
    unsigned int                            n_nearest_neighbors;
  };
 
 
 
  template <int dim, typename Number>
  class BoundingBoxIntersectPredicate
  {
  public:
    BoundingBoxIntersectPredicate(
      const std::vector<::BoundingBox<dim, Number>> &bounding_boxes);
 
    std::size_t
    size() const;
 
    const ::BoundingBox<dim, Number> &
    get(unsigned int i) const;
 
    static constexpr bool is_nearest = false;
 
  private:
    std::vector<::BoundingBox<dim, Number>> bounding_boxes;
  };
 
 
 
  template <int dim, typename Number>
  class BoundingBoxNearestPredicate
  {
  public:
    BoundingBoxNearestPredicate(
      const std::vector<::BoundingBox<dim, Number>> &bounding_boxes,
      const unsigned int                                   n_nearest_neighbors);
 
    unsigned int
    get_n_nearest_neighbors() const;
 
    std::size_t
    size() const;
 
    const ::BoundingBox<dim, Number> &
    get(unsigned int i) const;
 
    static constexpr bool is_nearest = true;
 
  private:
    std::vector<::BoundingBox<dim, Number>> bounding_boxes;
    unsigned int                                  n_nearest_neighbors;
  };
 
 
 
  template <int dim, typename Number>
  class SphereIntersectPredicate
  {
  public:
    SphereIntersectPredicate(
      const std::vector<std::pair<::Point<dim, Number>, Number>>
        &spheres);
 
    std::size_t
    size() const;
 
    const std::pair<::Point<dim, Number>, Number> &
    get(unsigned int) const;
 
    static constexpr bool is_nearest = false;
 
  private:
    std::vector<std::pair<::Point<dim, Number>, Number>> spheres;
  };
 
 
 
  template <int dim, typename Number>
  class SphereNearestPredicate
  {
  public:
    SphereNearestPredicate(
      const std::vector<std::pair<::Point<dim, Number>, Number>> &spheres,
      const unsigned int n_nearest_neighbors);
 
    unsigned int
    get_n_nearest_neighbors() const;
 
    std::size_t
    size() const;
 
    const std::pair<::Point<dim, Number>, Number> &
    get(unsigned int) const;
 
    static constexpr bool is_nearest = true;
 
  private:
    std::vector<std::pair<::Point<dim, Number>, Number>> spheres;
    unsigned int n_nearest_neighbors;
  };
#  endif
} // namespace ArborXWrappers
#endif
 
DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
 
 
#ifdef DEAL_II_WITH_ARBORX
  namespace ArborX
{
#  if ARBORX_VERSION_MAJOR < 2
  template <int dim, typename Number>
  struct AccessTraits<std::vector<::Point<dim, Number>>, PrimitivesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const std::vector<::Point<dim, Number>> &v);
 
    static Point
    get(const std::vector<::Point<dim, Number>> &v, std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<std::vector<::BoundingBox<dim, Number>>,
                      PrimitivesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const std::vector<::BoundingBox<dim, Number>> &v);
 
    static Box
    get(const std::vector<::BoundingBox<dim, Number>> &v, std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<
    std::vector<std::pair<::Point<dim, Number>, Number>>,
    PrimitivesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const std::vector<std::pair<::Point<dim, Number>, Number>> &v);
 
    static Sphere
    get(const std::vector<std::pair<::Point<dim, Number>, Number>> &v,
        std::size_t                                                       i);
  };
#  else
  template <typename T>
  struct AccessTraits<
    std::vector<T>,
    std::enable_if_t<
      std::is_same_v<T, ::Point<T::dimension, float>> ||
      std::is_same_v<T, ::Point<T::dimension, double>> ||
      std::is_same_v<T, ::BoundingBox<T::dimension, float>> ||
      std::is_same_v<T, ::BoundingBox<T::dimension, double>> ||
      std::is_same_v<T, std::pair<::Point<T::dimension, float>, float>> ||
      std::is_same_v<T,
                     std::pair<::Point<T::dimension, double>, double>>>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const std::vector<T> &v);
 
    static T
    get(const std::vector<T> &v, std::size_t i);
  };
#  endif
 
 
 
#  if ARBORX_VERSION_MAJOR < 2
  template <>
  struct AccessTraits<::ArborXWrappers::PointIntersectPredicate,
                      PredicatesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::PointIntersectPredicate &pt_intersect);
 
    static auto
    get(const ::ArborXWrappers::PointIntersectPredicate &pt_intersect,
        std::size_t                                            i);
  };
 
 
 
  template <>
  struct AccessTraits<::ArborXWrappers::PointNearestPredicate,
                      PredicatesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::PointNearestPredicate &pt_nearest);
 
    static auto
    get(const ::ArborXWrappers::PointNearestPredicate &pt_nearest,
        std::size_t                                          i);
  };
 
 
 
  template <>
  struct AccessTraits<::ArborXWrappers::BoundingBoxIntersectPredicate,
                      PredicatesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::BoundingBoxIntersectPredicate
           &bb_intersect);
 
    static auto
    get(
      const ::ArborXWrappers::BoundingBoxIntersectPredicate &bb_intersect,
      std::size_t                                                  i);
  };
 
 
 
  template <>
  struct AccessTraits<::ArborXWrappers::BoundingBoxNearestPredicate,
                      PredicatesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::BoundingBoxNearestPredicate &bb_nearest);
 
    static auto
    get(const ::ArborXWrappers::BoundingBoxNearestPredicate &bb_nearest,
        std::size_t                                                i);
  };
 
 
 
  template <>
  struct AccessTraits<::ArborXWrappers::SphereIntersectPredicate,
                      PredicatesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::SphereIntersectPredicate &sph_intersect);
 
    static auto
    get(const ::ArborXWrappers::SphereIntersectPredicate &sph_intersect,
        std::size_t                                             i);
  };
 
 
 
  template <>
  struct AccessTraits<::ArborXWrappers::SphereNearestPredicate,
                      PredicatesTag>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::SphereNearestPredicate &sph_nearest);
 
    static auto
    get(const ::ArborXWrappers::SphereNearestPredicate &sph_nearest,
        std::size_t                                           i);
  };
#  else
  template <int dim, typename Number>
  struct AccessTraits<
    ::ArborXWrappers::PointIntersectPredicate<dim, Number>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::PointIntersectPredicate<dim, Number>
           &pt_intersect);
 
    static auto
    get(const ::ArborXWrappers::PointIntersectPredicate<dim, Number>
                   &pt_intersect,
        std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<
    ::ArborXWrappers::PointNearestPredicate<dim, Number>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::PointNearestPredicate<dim, Number>
           &pt_nearest);
 
    static auto
    get(const ::ArborXWrappers::PointNearestPredicate<dim, Number>
                   &pt_nearest,
        std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<
    ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(
      const ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>
        &bb_intersect);
 
    static auto
    get(const ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>
                   &bb_intersect,
        std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<
    ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>
           &bb_nearest);
 
    static auto
    get(const ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>
                   &bb_nearest,
        std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<
    ::ArborXWrappers::SphereIntersectPredicate<dim, Number>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::SphereIntersectPredicate<dim, Number>
           &sph_intersect);
 
    static auto
    get(const ::ArborXWrappers::SphereIntersectPredicate<dim, Number>
                   &sph_intersect,
        std::size_t i);
  };
 
 
 
  template <int dim, typename Number>
  struct AccessTraits<
    ::ArborXWrappers::SphereNearestPredicate<dim, Number>>
  {
    using memory_space = Kokkos::HostSpace;
 
    static std::size_t
    size(const ::ArborXWrappers::SphereNearestPredicate<dim, Number>
           &sph_nearest);
 
    static auto
    get(const ::ArborXWrappers::SphereNearestPredicate<dim, Number>
                   &sph_nearest,
        std::size_t i);
  };
#  endif
 
  // ------------------------------- Inline ----------------------------------//
 
  // The implementation of AccessTraits<..., PredicatesTag> needs to be in the
  // header file otherwise the return type of auto get() cannot be determined.
  // We use auto because ArborX does not expose the type of intersects
 
#  if ARBORX_VERSION_MAJOR < 2
  inline std::size_t
  AccessTraits<::ArborXWrappers::PointIntersectPredicate, PredicatesTag>::
    size(const ::ArborXWrappers::PointIntersectPredicate &pt_intersect)
  {
    return pt_intersect.size();
  }
 
 
 
  inline auto
  AccessTraits<::ArborXWrappers::PointIntersectPredicate, PredicatesTag>::
    get(const ::ArborXWrappers::PointIntersectPredicate &pt_intersect,
        std::size_t                                            i)
  {
    const auto dealii_point = pt_intersect.get(i);
    return intersects(Point{dealii_point[0], dealii_point[1], dealii_point[2]});
  }
 
 
 
  inline std::size_t
  AccessTraits<::ArborXWrappers::PointNearestPredicate, PredicatesTag>::
    size(const ::ArborXWrappers::PointNearestPredicate &pt_nearest)
  {
    return pt_nearest.size();
  }
 
 
 
  inline auto
  AccessTraits<::ArborXWrappers::PointNearestPredicate, PredicatesTag>::
    get(const ::ArborXWrappers::PointNearestPredicate &pt_nearest,
        std::size_t                                          i)
  {
    const auto dealii_point = pt_nearest.get(i);
    return nearest(Point{dealii_point[0], dealii_point[1], dealii_point[2]},
                   pt_nearest.get_n_nearest_neighbors());
  }
 
 
 
  inline std::size_t
  AccessTraits<::ArborXWrappers::BoundingBoxIntersectPredicate,
               PredicatesTag>::
    size(
      const ::ArborXWrappers::BoundingBoxIntersectPredicate &bb_intersect)
  {
    return bb_intersect.size();
  }
 
 
 
  inline auto
  AccessTraits<::ArborXWrappers::BoundingBoxIntersectPredicate,
               PredicatesTag>::
    get(
      const ::ArborXWrappers::BoundingBoxIntersectPredicate &bb_intersect,
      std::size_t                                                  i)
  {
    const auto boundary_points = bb_intersect.get(i).get_boundary_points();
    const ::Point<3, float> min_corner = boundary_points.first;
    const ::Point<3, float> max_corner = boundary_points.second;
 
    return intersects(Box{{min_corner[0], min_corner[1], min_corner[2]},
                          {max_corner[0], max_corner[1], max_corner[2]}});
  }
 
 
 
  inline std::size_t
  AccessTraits<::ArborXWrappers::BoundingBoxNearestPredicate,
               PredicatesTag>::
    size(const ::ArborXWrappers::BoundingBoxNearestPredicate &bb_nearest)
  {
    return bb_nearest.size();
  }
 
 
 
  inline auto AccessTraits<::ArborXWrappers::BoundingBoxNearestPredicate,
                           PredicatesTag>::
    get(const ::ArborXWrappers::BoundingBoxNearestPredicate &bb_nearest,
        std::size_t                                                i)
  {
    const auto boundary_points = bb_nearest.get(i).get_boundary_points();
    const ::Point<3, float> min_corner = boundary_points.first;
    const ::Point<3, float> max_corner = boundary_points.second;
 
    return nearest(Box{{min_corner[0], min_corner[1], min_corner[2]},
                       {max_corner[0], max_corner[1], max_corner[2]}},
                   bb_nearest.get_n_nearest_neighbors());
  }
 
 
 
  inline std::size_t AccessTraits<
    ::ArborXWrappers::SphereIntersectPredicate,
    PredicatesTag>::size(const ::ArborXWrappers::SphereIntersectPredicate
                           &sph_intersect)
  {
    return sph_intersect.size();
  }
 
 
 
  inline auto AccessTraits<::ArborXWrappers::SphereIntersectPredicate,
                           PredicatesTag>::
    get(const ::ArborXWrappers::SphereIntersectPredicate &sph_intersect,
        std::size_t                                             i)
  {
    const auto sphere = sph_intersect.get(i);
    return intersects(
      Sphere{{sphere.first[0], sphere.first[1], sphere.first[2]},
             sphere.second});
  }
 
 
 
  inline std::size_t
  AccessTraits<::ArborXWrappers::SphereNearestPredicate, PredicatesTag>::
    size(const ::ArborXWrappers::SphereNearestPredicate &sph_nearest)
  {
    return sph_nearest.size();
  }
 
 
 
  inline auto
  AccessTraits<::ArborXWrappers::SphereNearestPredicate, PredicatesTag>::
    get(const ::ArborXWrappers::SphereNearestPredicate &sph_nearest,
        std::size_t                                           i)
  {
    const auto sphere = sph_nearest.get(i);
    return nearest(Sphere{{sphere.first[0], sphere.first[1], sphere.first[2]},
                          sphere.second},
                   sph_nearest.get_n_nearest_neighbors());
  }
#  else
  template <int dim, typename Number>
  inline std::size_t
  AccessTraits<::ArborXWrappers::PointIntersectPredicate<dim, Number>>::
    size(const ::ArborXWrappers::PointIntersectPredicate<dim, Number>
           &pt_intersect)
  {
    return pt_intersect.size();
  }
 
 
 
  template <int dim, typename Number>
  inline auto
  AccessTraits<::ArborXWrappers::PointIntersectPredicate<dim, Number>>::
    get(const ::ArborXWrappers::PointIntersectPredicate<dim, Number>
                   &pt_intersect,
        std::size_t i)
  {
    return intersects(
      ::ArborXWrappers::internal::to_arborx_point(pt_intersect.get(i)));
  }
 
 
 
  template <int dim, typename Number>
  inline std::size_t
  AccessTraits<::ArborXWrappers::PointNearestPredicate<dim, Number>>::
    size(const ::ArborXWrappers::PointNearestPredicate<dim, Number>
           &pt_nearest)
  {
    return pt_nearest.size();
  }
 
 
 
  template <int dim, typename Number>
  inline auto
  AccessTraits<::ArborXWrappers::PointNearestPredicate<dim, Number>>::get(
    const ::ArborXWrappers::PointNearestPredicate<dim, Number>
               &pt_nearest,
    std::size_t i)
  {
    return nearest(::ArborXWrappers::internal::to_arborx_point(
                     pt_nearest.get(i)),
                   pt_nearest.get_n_nearest_neighbors());
  }
 
 
 
  template <int dim, typename Number>
  inline std::size_t AccessTraits<
    ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>>::
    size(
      const ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>
        &bb_intersect)
  {
    return bb_intersect.size();
  }
 
 
 
  template <int dim, typename Number>
  inline auto AccessTraits<
    ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>>::
    get(const ::ArborXWrappers::BoundingBoxIntersectPredicate<dim, Number>
                   &bb_intersect,
        std::size_t i)
  {
    const auto boundary_points = bb_intersect.get(i).get_boundary_points();
    const ::Point<dim, Number> min_corner = boundary_points.first;
    const ::Point<dim, Number> max_corner = boundary_points.second;
 
    return intersects(
      Box{::ArborXWrappers::internal::to_arborx_point(min_corner),
          ::ArborXWrappers::internal::to_arborx_point(max_corner)});
  }
 
 
 
  template <int dim, typename Number>
  inline std::size_t AccessTraits<
    ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>>::
    size(const ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>
           &bb_nearest)
  {
    return bb_nearest.size();
  }
 
 
 
  template <int dim, typename Number>
  inline auto AccessTraits<
    ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>>::
    get(const ::ArborXWrappers::BoundingBoxNearestPredicate<dim, Number>
                   &bb_nearest,
        std::size_t i)
  {
    const auto boundary_points = bb_nearest.get(i).get_boundary_points();
    const ::Point<dim, Number> min_corner = boundary_points.first;
    const ::Point<dim, Number> max_corner = boundary_points.second;
 
    return nearest(
      Box{::ArborXWrappers::internal::to_arborx_point(min_corner),
          ::ArborXWrappers::internal::to_arborx_point(max_corner)},
      bb_nearest.get_n_nearest_neighbors());
  }
 
 
 
  template <int dim, typename Number>
  inline std::size_t
  AccessTraits<::ArborXWrappers::SphereIntersectPredicate<dim, Number>>::
    size(const ::ArborXWrappers::SphereIntersectPredicate<dim, Number>
           &sph_intersect)
  {
    return sph_intersect.size();
  }
 
 
 
  template <int dim, typename Number>
  inline auto
  AccessTraits<::ArborXWrappers::SphereIntersectPredicate<dim, Number>>::
    get(const ::ArborXWrappers::SphereIntersectPredicate<dim, Number>
                   &sph_intersect,
        std::size_t i)
  {
    const auto sphere = sph_intersect.get(i);
    return intersects(
      Sphere{::ArborXWrappers::internal::to_arborx_point(sphere.first),
             sphere.second});
  }
 
 
 
  template <int dim, typename Number>
  inline std::size_t
  AccessTraits<::ArborXWrappers::SphereNearestPredicate<dim, Number>>::
    size(const ::ArborXWrappers::SphereNearestPredicate<dim, Number>
           &sph_nearest)
  {
    return sph_nearest.size();
  }
 
 
 
  template <int dim, typename Number>
  inline auto
  AccessTraits<::ArborXWrappers::SphereNearestPredicate<dim, Number>>::
    get(const ::ArborXWrappers::SphereNearestPredicate<dim, Number>
                   &sph_nearest,
        std::size_t i)
  {
    const auto sphere = sph_nearest.get(i);
    return nearest(Sphere{::ArborXWrappers::internal::to_arborx_point(
                            sphere.first),
                          sphere.second},
                   sph_nearest.get_n_nearest_neighbors());
  }
#  endif
} // namespace ArborX
 
#endif
 
DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
  DEAL_II_NAMESPACE_CLOSE
 
#endif