access_traits.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2021 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>
 
 
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;
  };
} // 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 <>
  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);
  };
 
  // ------------------------------- 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());
  }
} // namespace ArborX
 
#endif
 
#endif