toy_metadata.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/core/detail/multi_store.hpp"
#include "detray/core/detail/single_store.hpp"
#include "detray/definitions/algebra.hpp"
#include "detray/definitions/containers.hpp"
#include "detray/definitions/indexing.hpp"
#include "detray/geometry/mask.hpp"
#include "detray/geometry/shapes/concentric_cylinder2D.hpp"
#include "detray/geometry/shapes/cylinder3D.hpp"
#include "detray/geometry/shapes/rectangle2D.hpp"
#include "detray/geometry/shapes/ring2D.hpp"
#include "detray/geometry/shapes/trapezoid2D.hpp"
#include "detray/geometry/surface_descriptor.hpp"
#include "detray/material/material_map.hpp"
#include "detray/material/material_slab.hpp"
#include "detray/navigation/accelerators/brute_force.hpp"
#include "detray/navigation/accelerators/spatial_grid.hpp"
 
namespace detray {

template <concepts::algebra algebra_t>
struct toy_metadata {
  using algebra_type = algebra_t;
  using scalar_t = dscalar<algebra_type>;

  using nav_link = std::uint_least16_t;
 
  template <template <typename...> class vector_t = dvector>
  using transform_store =
      single_store<dtransform3D<algebra_type>, vector_t, geometry_context>;

  using rectangle2D_t = mask<detray::rectangle2D, algebra_type, nav_link>;
  using trapezoid2D_t = mask<detray::trapezoid2D, algebra_type, nav_link>;
  using concentric_cylinder2D_t =
      mask<detray::concentric_cylinder2D, algebra_type, nav_link>;
  using ring2D_t = mask<detray::ring2D, algebra_type, nav_link>;

  enum class mask_id : std::uint_least8_t {
    e_rectangle2D = 0u,
    e_trapezoid2D = 1u,
    e_concentric_cylinder2D = 2u,
    e_ring2D = 3u,
  };
 
  DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                     mask_id id) {
    switch (id) {
      case mask_id::e_rectangle2D:
        os << "e_rectangle2D";
        break;
      case mask_id::e_trapezoid2D:
        os << "e_trapezoid2D";
        break;
      case mask_id::e_concentric_cylinder2D:
        os << "e_concentric_cylinder2D";
        break;
      case mask_id::e_ring2D:
        os << "e_ring2D";
        break;
      default:
        os << "invalid";
    }
    return os;
  };
 
  template <template <typename...> class vector_t = dvector>
  using mask_store = regular_multi_store<mask_id, empty_context, dtuple,
                                         vector_t, rectangle2D_t, trapezoid2D_t,
                                         concentric_cylinder2D_t, ring2D_t>;
 
  template <typename container_t>
  using concentric_cylinder2D_map_t =
      material_map<algebra_type, detray::concentric_cylinder2D, container_t>;
  template <typename container_t>
  using ring2D_map_t = material_map<algebra_type, detray::ring2D, container_t>;
  using material_slab_t = material_slab<scalar_t>;

  enum class material_id : std::uint_least8_t {
    e_concentric_cylinder2D_map = 0u,
    e_ring2D_map = 1u,
    e_material_slab = 2u,
    e_none = 3u,
  };
 
  DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                     material_id id) {
    switch (id) {
      case material_id::e_concentric_cylinder2D_map:
        os << "e_concentric_cylinder2D_map";
        break;
      case material_id::e_ring2D_map:
        os << "e_ring2D_map";
        break;
      case material_id::e_material_slab:
        os << "e_material_slab";
        break;
      case material_id::e_none:
        os << "e_none";
        break;
      default:
        os << "invalid";
    }
    return os;
  };
 
  template <typename container_t = host_container_types>
  using material_store =
      multi_store<material_id, empty_context, dtuple,
                  grid_collection<concentric_cylinder2D_map_t<container_t>>,
                  grid_collection<ring2D_map_t<container_t>>,
                  typename container_t::template vector_type<material_slab_t>>;

  using transform_link = typename transform_store<>::single_link;
  using mask_link = typename mask_store<>::range_link;
  using material_link = typename material_store<>::single_link;
  using surface_type =
      surface_descriptor<mask_link, material_link, transform_link, nav_link>;
 
  template <typename axes_t, typename bin_entry_t, typename container_t>
  using static_simple_grid_t =
      spatial_grid<algebra_type, axes_t,
                   detray::bins::static_array<bin_entry_t, 1>,
                   detray::simple_serializer, container_t, false>;
 
  template <typename container_t>
  using surface_concentric_cylinder2D_grid_t =
      static_simple_grid_t<axes<detray::concentric_cylinder2D>, surface_type,
                           container_t>;
  template <typename container_t>
  using surface_ring2D_grid_t =
      static_simple_grid_t<axes<detray::ring2D>, surface_type, container_t>;
 
  template <typename axes_t, typename bin_entry_t, typename container_t>
  using single_simple_grid_t =
      spatial_grid<algebra_type, axes_t, detray::bins::single<bin_entry_t>,
                   detray::simple_serializer, container_t, false>;
 
  template <typename container_t>
  using volume_cylinder3D_grid_t =
      single_simple_grid_t<axes<detray::cylinder3D>, dindex, container_t>;

  enum class accel_id : std::uint_least8_t {
    e_surface_brute_force = 0u,
    e_surface_concentric_cylinder2D_grid = 1u,
    e_surface_ring2D_grid = 2u,
    e_volume_cylinder3D_grid = 3u,
    e_surface_default = e_surface_brute_force,
    e_volume_default = e_volume_cylinder3D_grid,
  };
 
  DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                     accel_id id) {
    switch (id) {
      case accel_id::e_surface_brute_force:
        os << "e_surface_brute_force";
        break;
      case accel_id::e_surface_concentric_cylinder2D_grid:
        os << "e_surface_concentric_cylinder2D_grid";
        break;
      case accel_id::e_surface_ring2D_grid:
        os << "e_surface_ring2D_grid";
        break;
      case accel_id::e_volume_cylinder3D_grid:
        os << "e_volume_cylinder3D_grid";
        break;
      default:
        os << "invalid";
    }
    return os;
  };
 
  template <typename container_t = host_container_types>
  using accelerator_store = multi_store<
      accel_id, empty_context, dtuple,
      brute_force_collection<surface_type, container_t>,
      grid_collection<surface_concentric_cylinder2D_grid_t<container_t>>,
      grid_collection<surface_ring2D_grid_t<container_t>>,
      grid_collection<volume_cylinder3D_grid_t<container_t>>>;

  enum geo_objects : std::uint_least8_t {
    e_passive = 0u,
    e_portal = 0u,
    e_sensitive = 1u,
    e_volume = 2u,
    e_size = 3u,
    e_all = e_size,
  };
 
  DETRAY_HOST inline friend std::ostream& operator<<(std::ostream& os,
                                                     geo_objects id) {
    switch (id) {
      case geo_objects::e_sensitive:
        os << "e_sensitive";
        break;
      case geo_objects::e_portal:
        os << "e_passive/e_portal";
        break;
      case geo_objects::e_volume:
        os << "e_volume";
        break;
      case geo_objects::e_size:
        os << "e_size";
        break;
      default:
        os << "invalid";
    }
    return os;
  };

  using object_link_type =
      dmulti_index<dtyped_index<accel_id, dindex>, geo_objects::e_size>;
};
 
}  // namespace detray