ACTS
Experiment-independent tracking
Loading...
Searching...
No Matches
grid_factory.hpp
1// This file is part of the ACTS project.
2//
3// Copyright (C) 2016 CERN for the benefit of the ACTS project
4//
5// This Source Code Form is subject to the terms of the Mozilla Public
6// License, v. 2.0. If a copy of the MPL was not distributed with this
7// file, You can obtain one at https://mozilla.org/MPL/2.0/.
8
9#pragma once
10
11// Project include(s).
12#include "detray/definitions/algebra.hpp"
13#include "detray/definitions/containers.hpp"
14#include "detray/definitions/units.hpp"
15#include "detray/geometry/concepts.hpp"
16#include "detray/geometry/mask.hpp"
17#include "detray/geometry/shapes.hpp"
18#include "detray/utils/grid/axis.hpp"
19#include "detray/utils/grid/concepts.hpp"
20#include "detray/utils/grid/detail/axis_helpers.hpp"
21#include "detray/utils/grid/grid.hpp"
22#include "detray/utils/grid/grid_collection.hpp"
23#include "detray/utils/grid/populators.hpp"
24#include "detray/utils/grid/serializers.hpp"
25
26// Vecmem include(s)
27#include <vecmem/memory/memory_resource.hpp>
28
29// System include(s)
30#include <cassert>
31#include <iostream>
32#include <string>
33#include <type_traits>
34
35namespace detray {
36
48template <typename bin_t, template <std::size_t> class serializer_t,
49 concepts::algebra algebra_t>
50class grid_factory {
51 public:
52 // All grids are owning since they are used to fill the data
54 static constexpr bool is_owning = true;
55
57 using bin_type = bin_t;
59 template <typename grid_shape_t>
60 using grid_type = grid<algebra_t, axes<grid_shape_t>, bin_type, serializer_t>;
62 template <typename grid_shape_t>
63 using loc_bin_index = typename grid_type<grid_shape_t>::loc_bin_index;
64
66 using scalar_type = dscalar<algebra_t>;
68 template <typename T>
69 using vector_type = host_container_types::template vector_type<T>;
71 using algebra_type = algebra_t;
72
73 grid_factory() = default;
74
77 explicit grid_factory(vecmem::memory_resource &resource)
78 : m_resource(&resource) {}
79
80 //
81 // annulus 2D
82 //
90 template <
91 typename r_bounds = axis::closed<axis::label::e_r>,
92 typename phi_bounds = axis::circular<>,
93 typename r_binning = axis::regular<scalar_type, host_container_types>,
94 typename phi_binning = axis::regular<scalar_type, host_container_types>>
95 requires std::is_enum_v<decltype(r_bounds::label)>
96 auto new_grid(const mask<annulus2D, algebra_type> &grid_bounds,
97 const darray<std::size_t, 2UL> n_bins,
98 const std::vector<std::pair<loc_bin_index<annulus2D>, dindex>>
99 &bin_capacities = {},
100 const darray<std::vector<scalar_type>, 2UL> &bin_edges =
101 darray<std::vector<scalar_type>, 2UL>(),
102 const darray<std::vector<scalar_type>, 2UL> &axis_spans =
103 darray<std::vector<scalar_type>, 2UL>()) const {
104 static_assert(
105 std::is_same_v<phi_bounds, axis::circular<>>,
106 "Phi axis bounds need to be circular for stereo annulus shape");
107
108 // Axes boundaries and local indices
109 using boundary = annulus2D::boundaries;
110 using axes_t = axes<annulus2D>::template type<algebra_t>;
111 using local_frame = typename axes_t::template frame<algebra_t>;
112
113 constexpr auto e_r_axis = static_cast<dindex>(axes_t::label0);
114 constexpr auto e_phi_axis = static_cast<dindex>(axes_t::label1);
115
116 auto b_values = grid_bounds.values();
117 // Overwrite the mask values if axis spans are provided
118 if (!axis_spans[0UL].empty()) {
119 assert(axis_spans[0UL].size() == 2UL);
120 b_values[boundary::e_min_r] = axis_spans[0UL].at(0UL);
121 b_values[boundary::e_max_r] = axis_spans[0UL].at(1UL);
122 }
123 scalar_type min_phi =
124 b_values[boundary::e_average_phi] - b_values[boundary::e_min_phi_rel];
125 scalar_type max_phi =
126 b_values[boundary::e_average_phi] + b_values[boundary::e_max_phi_rel];
127 if (!axis_spans[1UL].empty()) {
128 assert(axis_spans[1UL].size() == 2UL);
129 min_phi = axis_spans[1UL].at(0UL);
130 max_phi = axis_spans[1UL].at(1UL);
131 }
132
133 return new_grid<local_frame>(
134 {b_values[boundary::e_min_r], b_values[boundary::e_max_r], min_phi,
135 max_phi},
136 {n_bins[e_r_axis], n_bins[e_phi_axis]}, bin_capacities,
137 {bin_edges[e_r_axis], bin_edges[e_phi_axis]},
138 types::list<r_bounds, phi_bounds>{},
139 types::list<r_binning, phi_binning>{});
140 }
141
142 //
143 // cuboid 3D
144 //
152 template <
153 typename x_bounds = axis::closed<axis::label::e_x>,
154 typename y_bounds = axis::closed<axis::label::e_y>,
155 typename z_bounds = axis::closed<axis::label::e_z>,
156 typename x_binning = axis::regular<scalar_type, host_container_types>,
157 typename y_binning = axis::regular<scalar_type, host_container_types>,
158 typename z_binning = axis::regular<scalar_type, host_container_types>>
159 requires std::is_enum_v<decltype(x_bounds::label)>
160 auto new_grid(const mask<cuboid3D, algebra_type> &grid_bounds,
161 const darray<std::size_t, 3UL> n_bins,
162 const std::vector<std::pair<loc_bin_index<cuboid3D>, dindex>>
163 &bin_capacities = {},
164 const darray<std::vector<scalar_type>, 3UL> &bin_edges =
165 darray<std::vector<scalar_type>, 3UL>(),
166 const darray<std::vector<scalar_type>, 3UL> &axis_spans =
167 darray<std::vector<scalar_type>, 3UL>()) const {
168 // Axes boundaries and local indices
169 using boundary = cuboid3D::boundaries;
170 using axes_t = axes<cuboid3D>::template type<algebra_t>;
171 using local_frame = typename axes_t::template frame<algebra_t>;
172
173 constexpr auto e_x_axis = static_cast<dindex>(axes_t::label0);
174 constexpr auto e_y_axis = static_cast<dindex>(axes_t::label1);
175 constexpr auto e_z_axis = static_cast<dindex>(axes_t::label2);
176
177 // Overwrite the mask values if axis spans are provided
178 auto b_values = grid_bounds.values();
179 if (!axis_spans[0UL].empty()) {
180 assert(axis_spans[0UL].size() == 2UL);
181 b_values[boundary::e_min_x] = axis_spans[0UL].at(0UL);
182 b_values[boundary::e_max_x] = axis_spans[0UL].at(1UL);
183 }
184 if (!axis_spans[1UL].empty()) {
185 assert(axis_spans[1UL].size() == 2UL);
186 b_values[boundary::e_min_y] = axis_spans[1UL].at(0UL);
187 b_values[boundary::e_max_y] = axis_spans[1UL].at(1UL);
188 }
189 if (!axis_spans[2UL].empty()) {
190 assert(axis_spans[2UL].size() == 2UL);
191 b_values[boundary::e_min_z] = axis_spans[2UL].at(0UL);
192 b_values[boundary::e_max_z] = axis_spans[2UL].at(1UL);
193 }
194
195 return new_grid<local_frame>(
196 {b_values[boundary::e_min_x], b_values[boundary::e_max_x],
197 b_values[boundary::e_min_y], b_values[boundary::e_max_y],
198 b_values[boundary::e_min_z], b_values[boundary::e_max_z]},
199 {n_bins[e_x_axis], n_bins[e_y_axis], n_bins[e_z_axis]}, bin_capacities,
200 {bin_edges[e_x_axis], bin_edges[e_y_axis], bin_edges[e_z_axis]},
201 types::list<x_bounds, y_bounds, z_bounds>{},
202 types::list<x_binning, y_binning, z_binning>{});
203 }
204
205 //
206 // cylinder 2D
207 //
215 template <
216 typename rphi_bounds = axis::circular<axis::label::e_rphi>,
217 typename z_bounds = axis::closed<axis::label::e_cyl_z>,
218 typename rphi_binning = axis::regular<scalar_type, host_container_types>,
219 typename z_binning = axis::regular<scalar_type, host_container_types>>
220 requires std::is_enum_v<decltype(rphi_bounds::label)>
221 auto new_grid(const mask<cylinder2D, algebra_type> &grid_bounds,
222 const darray<std::size_t, 2UL> n_bins,
223 const std::vector<std::pair<loc_bin_index<cylinder2D>, dindex>>
224 &bin_capacities = {},
225 const darray<std::vector<scalar_type>, 2UL> &bin_edges =
226 darray<std::vector<scalar_type>, 2UL>(),
227 const darray<std::vector<scalar_type>, 2UL> &axis_spans =
228 darray<std::vector<scalar_type>, 2UL>()) const {
229 static_assert(
230 std::is_same_v<rphi_bounds, axis::circular<axis::label::e_rphi>>,
231 "Phi axis bounds need to be circular for cylinder2D shape");
232
233 // Axes boundaries and local indices
234 using boundary = cylinder2D::boundaries;
235 using axes_t = axes<cylinder2D>::template type<algebra_t>;
236 using local_frame = typename axes_t::template frame<algebra_t>;
237
238 constexpr auto e_rphi_axis = static_cast<dindex>(axes_t::label0);
239 constexpr auto e_z_axis = static_cast<dindex>(axes_t::label1);
240
241 auto b_values = grid_bounds.values();
242 if (!axis_spans[1UL].empty()) {
243 assert(axis_spans[1UL].size() == 2UL);
244 b_values[boundary::e_lower_z] = axis_spans[1UL].at(0UL);
245 b_values[boundary::e_upper_z] = axis_spans[1UL].at(1UL);
246 }
247 return new_grid<local_frame>(
248 {-constant<scalar_type>::pi, constant<scalar_type>::pi,
249 b_values[boundary::e_lower_z], b_values[boundary::e_upper_z]},
250 {n_bins[e_rphi_axis], n_bins[e_z_axis]}, bin_capacities,
251 {bin_edges[e_rphi_axis], bin_edges[e_z_axis]},
252 types::list<rphi_bounds, z_bounds>{},
253 types::list<rphi_binning, z_binning>{});
254 }
255
256 //
257 // concentric cylinder 2D
258 //
266 template <
267 typename rphi_bounds = axis::circular<axis::label::e_rphi>,
268 typename z_bounds = axis::closed<axis::label::e_cyl_z>,
269 typename rphi_binning = axis::regular<scalar_type, host_container_types>,
270 typename z_binning = axis::regular<scalar_type, host_container_types>>
271 requires std::is_enum_v<decltype(rphi_bounds::label)>
272 auto new_grid(
273 const mask<concentric_cylinder2D, algebra_type> &grid_bounds,
274 const darray<std::size_t, 2UL> n_bins,
275 const std::vector<std::pair<loc_bin_index<concentric_cylinder2D>, dindex>>
276 &bin_capacities = {},
277 const darray<std::vector<scalar_type>, 2UL> &bin_edges =
278 darray<std::vector<scalar_type>, 2UL>(),
279 const darray<std::vector<scalar_type>, 2UL> &axis_spans =
280 darray<std::vector<scalar_type>, 2UL>()) const {
281 static_assert(
282 std::is_same_v<rphi_bounds, axis::circular<axis::label::e_rphi>>,
283 "Phi axis bounds need to be circular for cylinder2D portal shape");
284
285 // Axes boundaries and local indices
286 using boundary = concentric_cylinder2D::boundaries;
287 using axes_t = axes<concentric_cylinder2D>::template type<algebra_t>;
288 using local_frame = typename axes_t::template frame<algebra_t>;
289
290 constexpr auto e_rphi_axis = static_cast<dindex>(axes_t::label0);
291 constexpr auto e_z_axis = static_cast<dindex>(axes_t::label1);
292
293 auto b_values = grid_bounds.values();
294 if (!axis_spans[1UL].empty()) {
295 assert(axis_spans[1UL].size() == 2UL);
296 b_values[boundary::e_lower_z] = axis_spans[1UL].at(0UL);
297 b_values[boundary::e_upper_z] = axis_spans[1UL].at(1UL);
298 }
299
300 return new_grid<local_frame>(
301 {-constant<scalar_type>::pi, constant<scalar_type>::pi,
302 b_values[boundary::e_lower_z], b_values[boundary::e_upper_z]},
303 {n_bins[e_rphi_axis], n_bins[e_z_axis]}, bin_capacities,
304 {bin_edges[e_rphi_axis], bin_edges[e_z_axis]},
305 types::list<rphi_bounds, z_bounds>{},
306 types::list<rphi_binning, z_binning>{});
307 }
308
309 //
310 // cylinder 3D
311 //
319 template <
320 typename r_bounds = axis::closed<axis::label::e_r>,
321 typename phi_bounds = axis::circular<>,
322 typename z_bounds = axis::closed<axis::label::e_z>,
323 typename r_binning = axis::regular<scalar_type, host_container_types>,
324 typename phi_binning = axis::regular<scalar_type, host_container_types>,
325 typename z_binning = axis::regular<scalar_type, host_container_types>>
326 requires std::is_enum_v<decltype(r_bounds::label)>
327 auto new_grid(const mask<cylinder3D, algebra_type> &grid_bounds,
328 const darray<std::size_t, 3UL> n_bins,
329 const std::vector<std::pair<loc_bin_index<cylinder3D>, dindex>>
330 &bin_capacities = {},
331 const darray<std::vector<scalar_type>, 3UL> &bin_edges =
332 darray<std::vector<scalar_type>, 3UL>(),
333 const darray<std::vector<scalar_type>, 3UL> &axis_spans =
334 darray<std::vector<scalar_type>, 3UL>()) const {
335 static_assert(std::is_same_v<phi_bounds, axis::circular<>>,
336 "Phi axis bounds need to be circular for cylinder3D shape");
337
338 // Axes boundaries and local indices
339 using boundary = cylinder3D::boundaries;
340 using axes_t = axes<cylinder3D>::template type<algebra_t>;
341 using local_frame = typename axes_t::template frame<algebra_t>;
342
343 constexpr auto e_r_axis = static_cast<dindex>(axes_t::label0);
344 constexpr auto e_phi_axis = static_cast<dindex>(axes_t::label1);
345 constexpr auto e_z_axis = static_cast<dindex>(axes_t::label2);
346
347 auto b_values = grid_bounds.values();
348
349 // Overwrite the mask values if axis spans are provided
350 if (!axis_spans[0UL].empty()) {
351 assert(axis_spans[0UL].size() == 2UL);
352 b_values[boundary::e_min_r] = axis_spans[0UL].at(0UL);
353 b_values[boundary::e_max_r] = axis_spans[0UL].at(1UL);
354 }
355 scalar_type min_phi = -constant<scalar_type>::pi;
356 scalar_type max_phi = constant<scalar_type>::pi;
357 if (!axis_spans[1UL].empty()) {
358 assert(axis_spans[1UL].size() == 2UL);
359 min_phi = axis_spans[1UL].at(0UL);
360 max_phi = axis_spans[1UL].at(1UL);
361 }
362 if (!axis_spans[2UL].empty()) {
363 assert(axis_spans[2UL].size() == 2UL);
364 b_values[boundary::e_min_z] = axis_spans[2UL].at(0UL);
365 b_values[boundary::e_max_z] = axis_spans[2UL].at(1UL);
366 }
367
368 return new_grid<local_frame>(
369 {b_values[boundary::e_min_r], b_values[boundary::e_max_r], min_phi,
370 max_phi, -b_values[boundary::e_min_z], b_values[boundary::e_max_z]},
371 {n_bins[e_r_axis], n_bins[e_phi_axis], n_bins[e_z_axis]},
372 bin_capacities,
373 {bin_edges[e_r_axis], bin_edges[e_phi_axis], bin_edges[e_z_axis]},
374 types::list<r_bounds, phi_bounds, z_bounds>{},
375 types::list<r_binning, phi_binning, z_binning>{});
376 }
377
378 //
379 // polar 2D
380 //
388 template <
389 typename r_bounds = axis::closed<axis::label::e_r>,
390 typename phi_bounds = axis::circular<>,
391 typename r_binning = axis::regular<scalar_type, host_container_types>,
392 typename phi_binning = axis::regular<scalar_type, host_container_types>>
393 requires std::is_enum_v<decltype(r_bounds::label)>
394 auto new_grid(const mask<ring2D, algebra_type> &grid_bounds,
395 const darray<std::size_t, 2UL> n_bins,
396 const std::vector<std::pair<loc_bin_index<ring2D>, dindex>>
397 &bin_capacities = {},
398 const darray<std::vector<scalar_type>, 2UL> &bin_edges =
399 darray<std::vector<scalar_type>, 2UL>(),
400 const darray<std::vector<scalar_type>, 2UL> &axis_spans =
401 darray<std::vector<scalar_type>, 2UL>()) const {
402 static_assert(std::is_same_v<phi_bounds, axis::circular<>>,
403 "Phi axis bounds need to be circular for ring shape");
404
405 // Axes boundaries and local indices
406 using boundary = ring2D::boundaries;
407 using axes_t = axes<ring2D>::template type<algebra_t>;
408 using local_frame = typename axes_t::template frame<algebra_t>;
409
410 constexpr auto e_r_axis = static_cast<dindex>(axes_t::label0);
411 constexpr auto e_phi_axis = static_cast<dindex>(axes_t::label1);
412
413 auto b_values = grid_bounds.values();
414 // Overwrite the mask values if axis spans are provided
415 if (!axis_spans[0UL].empty()) {
416 assert(axis_spans[0UL].size() == 2UL);
417 b_values[boundary::e_inner_r] = axis_spans[0UL].at(0UL);
418 b_values[boundary::e_outer_r] = axis_spans[0UL].at(1UL);
419 }
420
421 return new_grid<local_frame>(
422 {b_values[boundary::e_inner_r], b_values[boundary::e_outer_r],
423 -constant<scalar_type>::pi, constant<scalar_type>::pi},
424 {n_bins[e_r_axis], n_bins[e_phi_axis]}, bin_capacities,
425 {bin_edges[e_r_axis], bin_edges[e_phi_axis]},
426 types::list<r_bounds, phi_bounds>{},
427 types::list<r_binning, phi_binning>{});
428 }
429
430 //
431 // rectangle 2D
432 //
440 template <
441 typename x_bounds = axis::closed<axis::label::e_x>,
442 typename y_bounds = axis::closed<axis::label::e_y>,
443 typename x_binning = axis::regular<scalar_type, host_container_types>,
444 typename y_binning = axis::regular<scalar_type, host_container_types>>
445 requires std::is_enum_v<decltype(x_bounds::label)>
446 auto new_grid(const mask<rectangle2D, algebra_type> &grid_bounds,
447 const darray<std::size_t, 2UL> n_bins,
448 const std::vector<std::pair<loc_bin_index<rectangle2D>, dindex>>
449 &bin_capacities = {},
450 const darray<std::vector<scalar_type>, 2UL> &bin_edges =
451 darray<std::vector<scalar_type>, 2UL>(),
452 const darray<std::vector<scalar_type>, 2UL> &axis_spans =
453 darray<std::vector<scalar_type>, 2UL>()) const {
454 // Axes boundaries and local indices
455 using boundary = rectangle2D::boundaries;
456 using axes_t = axes<rectangle2D>::template type<algebra_t>;
457 using local_frame = typename axes_t::template frame<algebra_t>;
458
459 constexpr auto e_x_axis = static_cast<dindex>(axes_t::label0);
460 constexpr auto e_y_axis = static_cast<dindex>(axes_t::label1);
461
462 auto b_values = grid_bounds.values();
463 // Overwrite the mask values if axis spans are provided
464 if (!axis_spans[0UL].empty()) {
465 assert(axis_spans[0UL].size() == 2UL);
466 b_values[boundary::e_half_x] = axis_spans[0UL].at(1UL);
467 }
468 if (!axis_spans[1UL].empty()) {
469 assert(axis_spans[1UL].size() == 2UL);
470 b_values[boundary::e_half_y] = axis_spans[1UL].at(1UL);
471 }
472
473 return new_grid<local_frame>(
474 {-b_values[boundary::e_half_x], b_values[boundary::e_half_x],
475 -b_values[boundary::e_half_y], b_values[boundary::e_half_y]},
476 {n_bins[e_x_axis], n_bins[e_y_axis]}, bin_capacities,
477 {bin_edges[e_x_axis], bin_edges[e_y_axis]},
478 types::list<x_bounds, y_bounds>{}, types::list<x_binning, y_binning>{});
479 }
480
481 //
482 // trapezoid 2D
483 //
491 template <
492 typename x_bounds = axis::closed<axis::label::e_x>,
493 typename y_bounds = axis::closed<axis::label::e_y>,
494 typename x_binning = axis::regular<scalar_type, host_container_types>,
495 typename y_binning = axis::regular<scalar_type, host_container_types>>
496 requires std::is_enum_v<decltype(x_bounds::label)>
497 auto new_grid(const mask<trapezoid2D, algebra_type> &grid_bounds,
498 const darray<std::size_t, 2UL> n_bins,
499 const std::vector<std::pair<loc_bin_index<trapezoid2D>, dindex>>
500 &bin_capacities = {},
501 const darray<std::vector<scalar_type>, 2UL> &bin_edges =
502 darray<std::vector<scalar_type>, 2UL>(),
503 const darray<std::vector<scalar_type>, 2UL> &axis_spans =
504 darray<std::vector<scalar_type>, 2UL>()) const {
505 // Axes boundaries and local indices
506 using boundary = trapezoid2D::boundaries;
507 using axes_t = axes<trapezoid2D>::template type<algebra_t>;
508 using local_frame = typename axes_t::template frame<algebra_t>;
509
510 constexpr auto e_x_axis = static_cast<dindex>(axes_t::label0);
511 constexpr auto e_y_axis = static_cast<dindex>(axes_t::label1);
512
513 auto b_values = grid_bounds.values();
514 // Overwrite the mask values if axis spans are provided
515 if (!axis_spans[0UL].empty()) {
516 assert(axis_spans[0UL].size() == 2UL);
517 b_values[boundary::e_half_length_1] = axis_spans[0UL].at(1UL);
518 }
519 if (!axis_spans[1UL].empty()) {
520 assert(axis_spans[1UL].size() == 2UL);
521 b_values[boundary::e_half_length_2] = axis_spans[1UL].at(1UL);
522 }
523
524 return new_grid<local_frame>(
525 {-b_values[boundary::e_half_length_1],
526 b_values[boundary::e_half_length_1],
527 -b_values[boundary::e_half_length_2],
528 b_values[boundary::e_half_length_2]},
529 {n_bins[e_x_axis], n_bins[e_y_axis]}, bin_capacities,
530 {bin_edges[e_x_axis], bin_edges[e_y_axis]},
531 types::list<x_bounds, y_bounds>{}, types::list<x_binning, y_binning>{});
532 }
533
551 template <concepts::coordinate_frame grid_frame_t, typename... bound_ts,
552 typename... binning_ts>
553 auto new_grid(
554 const std::vector<scalar_type> &spans,
555 const std::vector<std::size_t> &n_bins,
556 const std::vector<std::pair<axis::multi_bin<sizeof...(bound_ts)>, dindex>>
557 &bin_capacities = {},
558 const std::vector<std::vector<scalar_type>> &ax_bin_edges = {},
559 const types::list<bound_ts...> & /*unused*/ = {},
560 const types::list<binning_ts...> & /*unused*/ = {}) const {
561 static_assert(sizeof...(bound_ts) == sizeof...(binning_ts),
562 "number of axis bounds and binning types has to match");
563
564 // Build the coordinate axes and the grid
565 using axes_t = axis::multi_axis<is_owning, grid_frame_t,
566 axis::single_axis<bound_ts, binning_ts>...>;
567 using grid_t = grid<algebra_t, axes_t, bin_t, serializer_t>;
568
569 return new_grid<grid_t>(spans, n_bins, bin_capacities, ax_bin_edges);
570 }
571
580 template <typename grid_shape_t, typename... bound_ts, typename... binning_ts>
581 requires concepts::shape<grid_shape_t, algebra_t>
582 auto new_grid(
583 const std::vector<scalar_type> &spans,
584 const std::vector<std::size_t> &n_bins,
585 const std::vector<std::pair<axis::multi_bin<sizeof...(bound_ts)>, dindex>>
586 &bin_capacities = {},
587 const std::vector<std::vector<scalar_type>> &ax_bin_edges = {},
588 const types::list<bound_ts...> &bounds = {},
589 const types::list<binning_ts...> &binnings = {}) const {
590 return new_grid<
591 typename grid_shape_t::template local_frame_type<algebra_t>>(
592 spans, n_bins, bin_capacities, ax_bin_edges, bounds, binnings);
593 }
594
602 template <concepts::grid grid_t, typename grid_shape_t>
603 requires concepts::shape<grid_shape_t, algebra_t>
604 auto new_grid(
605 const mask<grid_shape_t, algebra_type> &m,
606 const darray<std::size_t, grid_t::dim> &n_bins,
607 const std::vector<std::pair<typename grid_t::loc_bin_index, dindex>>
608 &bin_capacities = {},
609 const darray<std::vector<scalar_type>, grid_t::dim> &ax_bin_edges = {})
610 const {
611 return new_grid(m, n_bins, bin_capacities, ax_bin_edges,
612 typename grid_t::axes_type::bounds{},
613 typename grid_t::axes_type::binnings{});
614 }
615
623 template <typename grid_shape_t, typename... bound_ts, typename... binning_ts>
624 requires concepts::shape<grid_shape_t, algebra_t>
625 auto new_grid(
626 const mask<grid_shape_t, algebra_type> &m,
627 const darray<std::size_t, grid_shape_t::dim> &n_bins,
628 const std::vector<std::pair<axis::multi_bin<sizeof...(bound_ts)>, dindex>>
629 &bin_capacities = {},
630 const darray<std::vector<scalar_type>, grid_shape_t::dim> &ax_bin_edges =
631 {},
632 const types::list<bound_ts...> & /*unused*/ = {},
633 const types::list<binning_ts...> & /*unused*/ = {}) const {
634 return new_grid<bound_ts..., binning_ts...>(m, n_bins, bin_capacities,
635 ax_bin_edges);
636 }
637
650 template <concepts::grid grid_t>
651 auto new_grid(
652 const std::vector<scalar_type> &spans,
653 const std::vector<std::size_t> &n_bins,
654 [[maybe_unused]] const std::vector<
655 std::pair<typename grid_t::loc_bin_index, dindex>> &bin_capacities =
656 {},
657 const std::vector<std::vector<scalar_type>> &ax_bin_edges = {}) const {
658 using owning_grid_t = typename grid_t::template type<true>;
659 using axes_t = typename owning_grid_t::axes_type;
660
661 // Prepare data
662 vector_type<dsized_index_range> axes_data{};
663 vector_type<scalar_type> bin_edges{};
664
665 // Call init for every axis
666 unroll_axis_init<typename axes_t::binnings>(
667 spans, n_bins, ax_bin_edges, axes_data, bin_edges,
668 std::make_index_sequence<axes_t::dim>{});
669
670 // Assemble the grid and return it
671 axes_t axes(std::move(axes_data), std::move(bin_edges));
672
673 typename owning_grid_t::bin_container_type bin_data{};
674
675 // Bins with dynamic capacity and "index grids" need different treatment
676 if constexpr (std::is_same_v<bin_t, bins::dynamic_array<
677 typename grid_t::value_type>>) {
678 // Bin and bin entries vector are separate containers
679 bin_data.bins.resize(axes.nbins());
680 // Set correct bin capacities, if they were provided
681 if (!bin_capacities.empty()) {
682 // Set memory offsets correctly
683 typename grid_t::template serializer_type<grid_t::dim> serializer{};
684 dindex total_cap{0u};
685 for (const auto &capacity : bin_capacities) {
686 // Get the empty bin by its global index
687 auto &data = bin_data.bins[serializer(axes, capacity.first)];
688
689 data.offset = total_cap;
690 data.capacity = capacity.second;
691 data.size = 0u;
692
693 total_cap += data.capacity;
694 }
695 assert(total_cap > 0);
696 bin_data.entries.resize(
697 total_cap, detail::invalid_value<typename grid_t::value_type>());
698 }
699 } else {
700 // Bin entries are contained in the bins directly
701 bin_data.resize(axes.nbins(), bin_type{});
702 }
703
704 return owning_grid_t(std::move(bin_data), std::move(axes));
705 }
706
707 private:
710 template <std::size_t I, typename binnings>
711 auto axis_init([[maybe_unused]] const std::vector<scalar_type> &spans,
712 [[maybe_unused]] const std::vector<std::size_t> &n_bins,
713 [[maybe_unused]] const std::vector<std::vector<scalar_type>>
714 &ax_bin_edges,
715 vector_type<dsized_index_range> &axes_data,
716 vector_type<scalar_type> &bin_edges) const {
717 if constexpr (std::is_same_v<
718 types::at<binnings, I>,
719 axis::regular<scalar_type, host_container_types>>) {
720 axes_data.push_back({static_cast<dindex>(bin_edges.size()),
721 static_cast<dindex>(n_bins.at(I))});
722 bin_edges.push_back(spans.at(I * 2u));
723 bin_edges.push_back(spans.at(I * 2u + 1u));
724 } else {
725 const auto &bin_edges_loc = ax_bin_edges.at(I);
726 axes_data.push_back({static_cast<dindex>(bin_edges.size()),
727 static_cast<dindex>(bin_edges_loc.size() - 1u)});
728 bin_edges.insert(bin_edges.end(), bin_edges_loc.begin(),
729 bin_edges_loc.end());
730 }
731 }
732
734 template <typename binnings, std::size_t... I>
735 auto unroll_axis_init(
736 const std::vector<scalar_type> &spans,
737 const std::vector<std::size_t> &n_bins,
738 const std::vector<std::vector<scalar_type>> &ax_bin_edges,
739 vector_type<dsized_index_range> &axes_data,
740 vector_type<scalar_type> &bin_edges,
741 std::index_sequence<I...> /*ids*/) const {
742 (axis_init<I, binnings>(spans, n_bins, ax_bin_edges, axes_data, bin_edges),
743 ...);
744 }
745
746 vecmem::memory_resource *m_resource{};
747};
748
750template <concepts::grid grid_t>
751using grid_factory_type =
752 grid_factory<typename grid_t::bin_type,
753 simple_serializer /*grid_t::template serializer_type*/,
754 typename grid_t::algebra_type>;
755
756} // namespace detray
detray::annulus2D::boundaries
boundaries
Names for the mask boundary values.
Definition annulus2D.hpp:54
detray::concentric_cylinder2D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition concentric_cylinder2D.hpp:38
detray::cuboid3D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition cuboid3D.hpp:38
detray::cylinder2D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition cylinder2D.hpp:39
detray::cylinder3D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition cylinder3D.hpp:38
detray::grid_factory
Provides functionality to instantiate grids and grid collections.
Definition grid_factory.hpp:50
detray::grid_factory::new_grid
auto new_grid(const mask< grid_shape_t, algebra_type > &m, const darray< std::size_t, grid_t::dim > &n_bins, const std::vector< std::pair< typename grid_t::loc_bin_index, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, grid_t::dim > &ax_bin_edges={}) const
Helper overload for grid builder: Build from mask and resolve bounds and binnings from concrete grid ...
Definition grid_factory.hpp:604
detray::grid_factory::vector_type
host_container_types::template vector_type< T > vector_type
Host vector container type used by grid storage.
Definition grid_factory.hpp:69
detray::grid_factory::new_grid
auto new_grid(const std::vector< scalar_type > &spans, const std::vector< std::size_t > &n_bins, const std::vector< std::pair< axis::multi_bin< sizeof...(bound_ts)>, dindex > > &bin_capacities={}, const std::vector< std::vector< scalar_type > > &ax_bin_edges={}, const types::list< bound_ts... > &bounds={}, const types::list< binning_ts... > &binnings={}) const
Helper to build grid from shape plus binning and bounds types.
Definition grid_factory.hpp:582
detray::grid_factory::new_grid
auto new_grid(const mask< cylinder2D, algebra_type > &grid_bounds, const darray< std::size_t, 2UL > n_bins, const std::vector< std::pair< loc_bin_index< cylinder2D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 2UL > &bin_edges=darray< std::vector< scalar_type >, 2UL >(), const darray< std::vector< scalar_type >, 2UL > &axis_spans=darray< std::vector< scalar_type >, 2UL >()) const
Build a cylindrical 2D grid from its mask and axis binning.
Definition grid_factory.hpp:221
detray::grid_factory::new_grid
auto new_grid(const mask< cylinder3D, algebra_type > &grid_bounds, const darray< std::size_t, 3UL > n_bins, const std::vector< std::pair< loc_bin_index< cylinder3D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 3UL > &bin_edges=darray< std::vector< scalar_type >, 3UL >(), const darray< std::vector< scalar_type >, 3UL > &axis_spans=darray< std::vector< scalar_type >, 3UL >()) const
Build a cylindrical 3D grid from its mask and axis binning.
Definition grid_factory.hpp:327
detray::grid_factory::new_grid
auto new_grid(const std::vector< scalar_type > &spans, const std::vector< std::size_t > &n_bins, const std::vector< std::pair< axis::multi_bin< sizeof...(bound_ts)>, dindex > > &bin_capacities={}, const std::vector< std::vector< scalar_type > > &ax_bin_edges={}, const types::list< bound_ts... > &={}, const types::list< binning_ts... > &={}) const
Create and empty grid with fully initialized axes.
Definition grid_factory.hpp:553
detray::grid_factory::new_grid
auto new_grid(const mask< concentric_cylinder2D, algebra_type > &grid_bounds, const darray< std::size_t, 2UL > n_bins, const std::vector< std::pair< loc_bin_index< concentric_cylinder2D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 2UL > &bin_edges=darray< std::vector< scalar_type >, 2UL >(), const darray< std::vector< scalar_type >, 2UL > &axis_spans=darray< std::vector< scalar_type >, 2UL >()) const
Build a concentric cylindrical grid from its mask and axis binning.
Definition grid_factory.hpp:272
detray::grid_factory::loc_bin_index
typename grid_type< grid_shape_t >::loc_bin_index loc_bin_index
Local index type for bins in a grid of the selected shape.
Definition grid_factory.hpp:63
detray::grid_factory< typename grid_t::bin_type, simple_serializer, typename grid_t::algebra_type >::is_owning
static constexpr bool is_owning
Definition grid_factory.hpp:54
detray::grid_factory::grid_factory
grid_factory(vecmem::memory_resource &resource)
Takes the resource of the detector to allocate memory correctly.
Definition grid_factory.hpp:77
detray::grid_factory::new_grid
auto new_grid(const std::vector< scalar_type > &spans, const std::vector< std::size_t > &n_bins, const std::vector< std::pair< typename grid_t::loc_bin_index, dindex > > &bin_capacities={}, const std::vector< std::vector< scalar_type > > &ax_bin_edges={}) const
Create and empty grid with fully initialized axes.
Definition grid_factory.hpp:651
detray::grid_factory::bin_type
bin_t bin_type
Bin container type used for grid values.
Definition grid_factory.hpp:57
detray::grid_factory::new_grid
auto new_grid(const mask< ring2D, algebra_type > &grid_bounds, const darray< std::size_t, 2UL > n_bins, const std::vector< std::pair< loc_bin_index< ring2D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 2UL > &bin_edges=darray< std::vector< scalar_type >, 2UL >(), const darray< std::vector< scalar_type >, 2UL > &axis_spans=darray< std::vector< scalar_type >, 2UL >()) const
Build a ring grid from its mask and axis binning.
Definition grid_factory.hpp:394
detray::grid_factory::algebra_type
algebra_t algebra_type
Linear algebra backend used by the grid.
Definition grid_factory.hpp:71
detray::grid_factory::new_grid
auto new_grid(const mask< annulus2D, algebra_type > &grid_bounds, const darray< std::size_t, 2UL > n_bins, const std::vector< std::pair< loc_bin_index< annulus2D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 2UL > &bin_edges=darray< std::vector< scalar_type >, 2UL >(), const darray< std::vector< scalar_type >, 2UL > &axis_spans=darray< std::vector< scalar_type >, 2UL >()) const
Build an annular grid from its mask and axis binning.
Definition grid_factory.hpp:96
detray::grid_factory::scalar_type
dscalar< algebra_t > scalar_type
Scalar type used by axes and geometry coordinates.
Definition grid_factory.hpp:66
detray::grid_factory::new_grid
auto new_grid(const mask< grid_shape_t, algebra_type > &m, const darray< std::size_t, grid_shape_t::dim > &n_bins, const std::vector< std::pair< axis::multi_bin< sizeof...(bound_ts)>, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, grid_shape_t::dim > &ax_bin_edges={}, const types::list< bound_ts... > &={}, const types::list< binning_ts... > &={}) const
Helper overload for grid builder: Build from mask and resolve bounds and binnings.
Definition grid_factory.hpp:625
detray::grid_factory::new_grid
auto new_grid(const mask< rectangle2D, algebra_type > &grid_bounds, const darray< std::size_t, 2UL > n_bins, const std::vector< std::pair< loc_bin_index< rectangle2D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 2UL > &bin_edges=darray< std::vector< scalar_type >, 2UL >(), const darray< std::vector< scalar_type >, 2UL > &axis_spans=darray< std::vector< scalar_type >, 2UL >()) const
Build a rectangular grid from its mask and axis binning.
Definition grid_factory.hpp:446
detray::grid_factory::new_grid
auto new_grid(const mask< cuboid3D, algebra_type > &grid_bounds, const darray< std::size_t, 3UL > n_bins, const std::vector< std::pair< loc_bin_index< cuboid3D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 3UL > &bin_edges=darray< std::vector< scalar_type >, 3UL >(), const darray< std::vector< scalar_type >, 3UL > &axis_spans=darray< std::vector< scalar_type >, 3UL >()) const
Build a cuboid grid from its mask and axis binning.
Definition grid_factory.hpp:160
detray::grid_factory::new_grid
auto new_grid(const mask< trapezoid2D, algebra_type > &grid_bounds, const darray< std::size_t, 2UL > n_bins, const std::vector< std::pair< loc_bin_index< trapezoid2D >, dindex > > &bin_capacities={}, const darray< std::vector< scalar_type >, 2UL > &bin_edges=darray< std::vector< scalar_type >, 2UL >(), const darray< std::vector< scalar_type >, 2UL > &axis_spans=darray< std::vector< scalar_type >, 2UL >()) const
Build a trapezoidal grid from its mask and axis binning.
Definition grid_factory.hpp:497
detray::grid_factory::grid_type
grid< algebra_t, axes< grid_shape_t >, bin_type, serializer_t > grid_type
Grid type parameterized by a geometric shape.
Definition grid_factory.hpp:60
detray::grid_impl< coordinate_axes< axes_t, algebra_t, ownership, containers >, bin_t, simple_serializer >::loc_bin_index
typename axes_type::loc_bin_index loc_bin_index
Definition grid.hpp:58
detray::mask
Mask a region on a surface and link it to a volume.
Definition mask.hpp:46
detray::mask::values
auto values() const -> const mask_values &
Definition mask.hpp:251
detray::rectangle2D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition rectangle2D.hpp:36
detray::ring2D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition ring2D.hpp:40
detray::trapezoid2D::boundaries
boundaries
Indices describing the entries in the shape boundary array.
Definition trapezoid2D.hpp:40
detray::concepts::algebra
Algebra plugin concept.
Definition concepts.hpp:147
Acts::UnitConstants::m
constexpr double m
Meter.
Definition Units.hpp:97
Acts::UnitConstants::u
constexpr double u
atomic mass unit u
Definition Units.hpp:155
detray
Detray include(s).
Definition array_operators.hpp:18
detray::dscalar
get_scalar_t< A, T > dscalar
Scalar type for algebra A and value type T.
Definition algebra.hpp:64
detray::dindex
unsigned int dindex
Default index type.
Definition indexing.hpp:18
detray::darray
std::array< value_t, kDIM > darray
Fixed-size array container.
Definition containers.hpp:30
detray::grid
grid_impl< coordinate_axes< axes_t, algebra_t, ownership, containers >, bin_t, simple_serializer > grid
Type alias for easier construction.
Definition grid.hpp:422
detray::grid_factory_type
grid_factory< typename grid_t::bin_type, simple_serializer, typename grid_t::algebra_type > grid_factory_type
Infer a grid factory type from an already completely assembled grid type.
Definition grid_factory.hpp:751
detray::axis::multi_bin
Multi-bin: contains bin indices from multiple axes.
Definition axis.hpp:36
detray::constant::pi
static constexpr scalar_t pi
π
Definition units.hpp:136