access_traits.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2021 - 2022 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#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>
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace ArborXWrappers
{
  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;
  };
} // namespace ArborXWrappers
 
DEAL_II_NAMESPACE_CLOSE
 
namespace ArborX
{
  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);
  };
 
 
 
  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);
  };
 
  // ------------------------------- 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
 
  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());
  }
} // namespace ArborX
 
#endif
 
#endif