unbounded.hpp

// This file is part of the ACTS project.
//
// Copyright (C) 2016 CERN for the benefit of the ACTS project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// Project include(s)
#include "detray/definitions/algebra.hpp"
#include "detray/definitions/containers.hpp"
#include "detray/definitions/detail/qualifiers.hpp"
#include "detray/definitions/indexing.hpp"
#include "detray/geometry/detail/shape_utils.hpp"
#include "detray/utils/string_helpers.hpp"
 
// System include(s)
#include <limits>
#include <ostream>
#include <string>
#include <string_view>
 
namespace detray {

template <typename shape_t>
class unbounded {
 public:
  using shape = shape_t;
  using boundaries = typename shape::boundaries;

  template <concepts::scalar scalar_t>
  using bounds_type = darray<scalar_t, boundaries::e_size>;

  static constexpr std::string_view name_prefix = "unbounded ";

  static constexpr utils::string_view_concat2 name{name_prefix, shape::name};

  template <concepts::algebra algebra_t>
  using local_frame_type = typename shape::template local_frame_type<algebra_t>;

  template <typename bool_t>
  using result_type = detail::boundary_check_result<bool_t>;

  static constexpr std::size_t dim{shape_t::dim};

  template <concepts::scalar scalar_t, concepts::point point_t>
  DETRAY_HOST_DEVICE constexpr scalar_t min_dist_to_boundary(
      const bounds_type<scalar_t>& /*bounds*/, const point_t& /*loc_p*/) const {
    return std::numeric_limits<scalar_t>::max();
  }

  template <concepts::algebra algebra_t>
  DETRAY_HOST_DEVICE constexpr result_type<dbool<algebra_t>> check_boundaries(
      const bounds_type<dscalar<algebra_t>>& /*bounds*/,
      const dtransform3D<algebra_t>& /*trf*/,
      const dpoint3D<algebra_t>& /*glob_p*/,
      const dscalar<algebra_t> /*tol*/ = 0.f,
      const dscalar<algebra_t> /*edge_tol*/ = 0.f) const {
    if constexpr (std::same_as<result_type<dbool<algebra_t>>,
                               dbool<algebra_t>>) {
      return true;
    } else {
      return {true, true};
    }
  }

  template <typename bounds_t, concepts::point point_t,
            concepts::scalar scalar_t>
  DETRAY_HOST_DEVICE constexpr auto check_boundaries(
      const bounds_t& /*bounds*/, const point_t& /*loc_p*/,
      const scalar_t tol = 0.f, const scalar_t edge_tol = 0.f) const {
    using bool_t = decltype(tol < edge_tol);
 
    if constexpr (std::same_as<result_type<bool_t>, bool_t>) {
      return bool_t{true};
    } else {
      return result_type<bool_t>{true, true};
    }
  }


  template <concepts::scalar scalar_t>
  DETRAY_HOST_DEVICE constexpr scalar_t measure(
      const bounds_type<scalar_t>& bounds) const {
    if constexpr (dim == 2) {
      return area(bounds);
    } else {
      return volume(bounds);
    }
  }

  template <concepts::scalar scalar_t>
  DETRAY_HOST_DEVICE constexpr scalar_t area(
      const bounds_type<scalar_t>& /*unused*/) const {
    return std::numeric_limits<scalar_t>::max();
  }

  template <concepts::scalar scalar_t>
  DETRAY_HOST_DEVICE constexpr scalar_t volume(
      const bounds_type<scalar_t>& /*unused*/) const {
    return std::numeric_limits<scalar_t>::max();
  }

  template <concepts::scalar scalar_t>
  DETRAY_HOST_DEVICE constexpr bounds_type<scalar_t> merge(
      const bounds_type<scalar_t>& /*bounds*/,
      const bounds_type<scalar_t>& /*o_bounds*/) const {
    return {};
  }

  template <concepts::algebra algebra_t>
  DETRAY_HOST_DEVICE inline darray<dscalar<algebra_t>, 6> local_min_bounds(
      const bounds_type<dscalar<algebra_t>>& bounds,
      const dscalar<algebra_t> env =
          std::numeric_limits<dscalar<algebra_t>>::epsilon()) const {
    return shape{}.template local_min_bounds<algebra_t>(bounds, env);
  }

  template <concepts::algebra algebra_t>
  DETRAY_HOST_DEVICE auto centroid(
      const bounds_type<dscalar<algebra_t>>& bounds) const {
    return shape{}.template centroid<algebra_t>(bounds);
  }

  template <concepts::algebra algebra_t>
  DETRAY_HOST dvector<dpoint3D<algebra_t>> vertices(
      const bounds_type<dscalar<algebra_t>>& bounds, dindex n_seg) const {
    return shape{}.template vertices<algebra_t>(bounds, n_seg);
  }

  template <concepts::scalar scalar_t>
  DETRAY_HOST constexpr bool check_consistency(
      const bounds_type<scalar_t>& /*bounds*/,
      const std::ostream& /*os*/) const {
    return true;
  }
};
 
}  // namespace detray