unmasked.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/coordinates/cartesian2D.hpp"
#include "detray/geometry/detail/shape_utils.hpp"
 
// System include(s)
#include <limits>
#include <ostream>
#include <string_view>
 
namespace detray {

template <std::size_t DIM = 2>
class unmasked {
 public:
  static constexpr std::string_view name = "unmasked";

  enum boundaries : unsigned int { e_size = 1u };

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

  template <concepts::algebra algebra_t>
  using local_frame_type = cartesian2D<algebra_t>;

  template <typename bool_t>
  using result_type = bool_t;

  static constexpr std::size_t dim{DIM};

  template <concepts::scalar scalar_t, concepts::point point_t>
  DETRAY_HOST_DEVICE inline 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 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 {
    return true;
  }

  template <concepts::scalar scalar_t, concepts::point point_t>
  DETRAY_HOST_DEVICE constexpr auto check_boundaries(
      const bounds_type<scalar_t>& /*bounds*/, const point_t& /*loc_p*/,
      const scalar_t tol = 0.f, const scalar_t edge_tol = 0.f) const
      -> decltype(tol < edge_tol) {
    return 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 {
    using scalar_t = dscalar<algebra_t>;
    constexpr scalar_t inv{detail::invalid_value<scalar_t>()};
 
    return {-inv, -inv, -inv, inv, inv, inv};
  }

  template <concepts::algebra algebra_t>
  DETRAY_HOST_DEVICE dpoint3D<algebra_t> centroid(
      const bounds_type<dscalar<algebra_t>>& /*unused*/) const {
    return {0.f, 0.f, 0.f};
  }

  template <concepts::algebra algebra_t>
  DETRAY_HOST dvector<dpoint3D<algebra_t>> vertices(
      const bounds_type<dscalar<algebra_t>>& bounds, dindex /*unused*/) const {
    return local_min_bounds(bounds);
  }

  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