payloads.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/geometry.hpp"
#include "detray/definitions/grid_axis.hpp"
#include "detray/io/frontend/definitions.hpp"
#include "detray/utils/invalid_values.hpp"
 
// System include(s)
#include <array>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <map>
#include <optional>
#include <ostream>
#include <string>
#include <vector>
 
//
// Intermediate data representation as an abstraction to different IO formats
//

namespace detray::io {

struct common_header_payload {
  std::string version{};
  std::string detector{};
  std::string tag{};
  std::string date{};
};

template <typename sub_header_payload_t = bool>
struct header_payload {
  common_header_payload common{};
  std::optional<sub_header_payload_t> sub_header;
};

struct single_link_payload {
  std::size_t link{std::numeric_limits<std::size_t>::max()};
};

template <typename type_id_t>
struct typed_link_payload {
  using type_id = type_id_t;

  type_id type{type_id::unknown};
  std::size_t index{std::numeric_limits<std::size_t>::max()};
};


struct geo_sub_header_payload {
  std::size_t n_volumes{0ul};
  std::size_t n_surfaces{0ul};
};

using geo_header_payload = header_payload<geo_sub_header_payload>;

using material_link_payload = typed_link_payload<io::material_id>;

using acc_links_payload = typed_link_payload<io::accel_id>;

struct transform_payload {
  std::array<io::scalar, 3u> tr{};
  // Column major rotation matrix
  std::array<io::scalar, 9u> rot{};
 
 private:
  DETRAY_HOST friend inline std::ostream& operator<<(
      std::ostream& os, const transform_payload& transform) {
    const auto& r = transform.rot;
    os << "rot: ";
    os << std::fixed << std::setw(4);
    auto print_line = [&](std::size_t i) {
      os << r[i] << " " << r[i + 3] << " " << r[i + 6] << "\n";
    };
    print_line(0);
    os << "     ";
    print_line(1);
    os << "     ";
    print_line(2);

    const auto& t = transform.tr;
 
    os << "tr:  ";
    os << t[0] << " " << t[1] << " " << t[2];
    return os;
  }
};

struct mask_payload {
  using mask_shape = io::shape_id;

  static constexpr std::size_t end_of_world =
      detray::detail::invalid_value<std::size_t>();

  mask_shape shape{mask_shape::unknown};
  single_link_payload volume_link{end_of_world};
  std::vector<io::scalar> boundaries{};
};

struct surface_payload {
  std::optional<std::size_t> index_in_coll;
  transform_payload transform{};
  std::vector<mask_payload> masks{};
  std::optional<material_link_payload> material;
  std::uint64_t source{};
  std::optional<std::uint64_t> identifier{
      detray::detail::invalid_value<std::uint64_t>()};

  detray::surface_id type{detray::surface_id::e_sensitive};
};

struct volume_payload {
  std::string name{};
  detray::volume_id type{detray::volume_id::e_cylinder};
  transform_payload transform{};
  std::vector<surface_payload> surfaces{};
  single_link_payload index{};
  std::optional<std::vector<acc_links_payload>> acc_links{};
};



struct homogeneous_material_sub_header_payload {
  std::size_t n_slabs{0ul};
  std::size_t n_slab_surfaces{0ul};
  std::size_t n_rods{0ul};
  std::size_t n_rod_surfaces{0ul};
};

using homogeneous_material_header_payload =
    header_payload<homogeneous_material_sub_header_payload>;

struct material_param_payload {
  std::array<io::scalar, 7u> params{};
};

struct surface_material_payload {
  using mat_type = io::material_id;

  mat_type type{mat_type::unknown};
  std::optional<std::size_t> index_in_coll;
  single_link_payload surface{};
  io::scalar thickness{std::numeric_limits<io::scalar>::max()};
  material_param_payload mat{};
};

struct volume_material_payload {
  // Not implemented
};

struct material_volume_payload {
  single_link_payload volume_link{};
  std::optional<volume_material_payload> volume_mat;
  std::vector<surface_material_payload> surface_mat{};
};

struct detector_homogeneous_material_payload {
  std::vector<material_volume_payload> volumes{};
};



struct grid_sub_header_payload {
  std::size_t n_grids{0u};
};

using grid_header_payload = header_payload<grid_sub_header_payload>;

struct axis_payload {
  axis::binning binning{axis::binning::e_regular};
  axis::bounds bounds{axis::bounds::e_closed};
  axis::label label{axis::label::e_r};

  std::size_t bins{0u};
  std::vector<io::scalar> edges{};
 
 private:
  DETRAY_HOST friend inline std::ostream& operator<<(std::ostream& os,
                                                     const axis_payload& axis) {
    os << "axis_payload{binning: " << axis.binning
       << ", bounds: " << axis.bounds << ", label: " << axis.label
       << ", bins: " << axis.bins << ", edges: [";
    for (std::size_t i = 0; i < axis.edges.size(); ++i) {
      if (i > 0) {
        os << ", ";
      }
      os << axis.edges[i];
    }
    os << "]}";
    return os;
  }
};

template <typename content_t = std::size_t>
struct grid_bin_payload {
  std::vector<unsigned int> loc_index{};
  std::vector<content_t> content{};
};

template <typename bin_content_t = std::size_t,
          typename grid_id_t = io::accel_id>
struct grid_payload {
  using grid_type = grid_id_t;
  // volume-local surface or global volume index the grids belongs to
  single_link_payload owner_link{};
  // Type and global index of the grid (index is optional only for debugging)
  typed_link_payload<grid_id_t> grid_link{};

  std::vector<axis_payload> axes{};
  std::vector<grid_bin_payload<bin_content_t>> bins{};
};

template <typename bin_content_t = std::size_t,
          typename grid_id_t = io::accel_id>
struct detector_grids_payload {
  // A collection of grids (can be the surface search grid, volume or surface
  // material grids) per volume index (not all volumes may contain grids)
  std::map<std::size_t, std::vector<grid_payload<bin_content_t, grid_id_t>>>
      grids = {};
};


struct detector_payload {
  std::vector<volume_payload> volumes = {};
  std::optional<grid_payload<std::size_t, io::accel_id>> volume_grid;
};
 
}  // namespace detray::io