options/src/track_propagation.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2023-2025 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // Project include(s).
0009 #include "traccc/options/track_propagation.hpp"
0010
0011 #include "traccc/definitions/common.hpp"
0012 #include "traccc/examples/utils/printable.hpp"
0013
0014 // System include(s).
0015 #include <format>
0016 #include <limits>
0017
0018 namespace traccc::opts {
0019
0020 /// Convenience namespace shorthand
0021 namespace po = boost::program_options;
0022
0023 track_propagation::track_propagation()
0024     : interface("Track Propagation Options") {
0025   m_search_window[0] = m_config.navigation.search_window[0];
0026   m_search_window[1] = m_config.navigation.search_window[1];
0027
0028   m_desc.add_options()("constraint-step-size-mm",
0029                        po::value(&(m_config.stepping.step_constraint))
0030                            ->default_value(m_config.stepping.step_constraint /
0031                                            traccc::unit<float>::mm),
0032                        "The constrained step size [mm]");
0033   m_desc.add_options()(
0034       "overstep-tolerance-um",
0035       po::value(&(m_config.navigation.intersection.overstep_tolerance))
0036           ->default_value(m_config.navigation.intersection.overstep_tolerance /
0037                           traccc::unit<float>::um),
0038       "The overstep tolerance [um]");
0039   m_desc.add_options()(
0040       "min-mask-tolerance-mm",
0041       po::value(&(m_config.navigation.intersection.min_mask_tolerance))
0042           ->default_value(m_config.navigation.intersection.min_mask_tolerance /
0043                           traccc::unit<float>::mm),
0044       "The minimum mask tolerance [mm]");
0045   m_desc.add_options()(
0046       "max-mask-tolerance-mm",
0047       po::value(&(m_config.navigation.intersection.max_mask_tolerance))
0048           ->default_value(m_config.navigation.intersection.max_mask_tolerance /
0049                           traccc::unit<float>::mm),
0050       "The maximum mask tolerance [mm]");
0051   m_desc.add_options()(
0052       "mask-tolerance-scaling",
0053       po::value(&(m_config.navigation.intersection.mask_tolerance_scalor))
0054           ->default_value(
0055               m_config.navigation.intersection.mask_tolerance_scalor),
0056       "Scale factor between min. and max. mask tolerance with surface "
0057       "distance");
0058
0059   m_desc.add_options()(
0060       "accumulated-noise-factor",
0061       po::value(&(m_config.navigation.accumulated_error))
0062           ->default_value(m_config.navigation.accumulated_error),
0063       "Scale factor on the total track path length to model accumualted "
0064       "noise [%]");
0065
0066   m_desc.add_options()(
0067       "scattering-stddevs",
0068       po::value(&(m_config.navigation.n_scattering_stddev))
0069           ->default_value(m_config.navigation.n_scattering_stddev),
0070       "Number of angle standard deviations to use for the noise modelling");
0071
0072   m_desc.add_options()(
0073       "search-window",
0074       po::value(&m_search_window)->default_value(m_search_window),
0075       "Size of the grid surface search window");
0076   m_desc.add_options()(
0077       "mask-tolerance-scaling",
0078       po::value(&(m_config.navigation.intersection.mask_tolerance_scalor))
0079           ->default_value(
0080               m_config.navigation.intersection.mask_tolerance_scalor),
0081       "Scale factor between min. and max. mask tolerance with surface "
0082       "distance");
0083
0084   m_desc.add_options()(
0085       "accumulated-noise-factor",
0086       po::value(&(m_config.navigation.accumulated_error))
0087           ->default_value(m_config.navigation.accumulated_error),
0088       "Scale factor on the total track path length to model accumualted "
0089       "noise [%]");
0090
0091   m_desc.add_options()(
0092       "scattering-stddevs",
0093       po::value(&(m_config.navigation.n_scattering_stddev))
0094           ->default_value(m_config.navigation.n_scattering_stddev),
0095       "Number of angle standard deviations to use for the noise modelling");
0096   m_desc.add_options()("rk-tolerance-mm",
0097                        po::value(&(m_config.stepping.rk_error_tol))
0098                            ->default_value(m_config.stepping.rk_error_tol /
0099                                            traccc::unit<float>::mm),
0100                        "The Runge-Kutta stepper tolerance [mm]");
0101   m_desc.add_options()("stepping-min-stepsize",
0102                        po::value(&(m_config.stepping.min_stepsize))
0103                            ->default_value(m_config.stepping.min_stepsize /
0104                                            traccc::unit<float>::mm),
0105                        "The minimum step size [mm]");
0106   m_desc.add_options()("stepping-path-limit",
0107                        po::value(&(m_config.stepping.path_limit))
0108                            ->default_value(m_config.stepping.path_limit /
0109                                            traccc::unit<float>::m),
0110                        "The maximum path length for the stepper [m]");
0111   m_desc.add_options()("stepping-max-rk-updates",
0112                        po::value(&(m_config.stepping.max_rk_updates))
0113                            ->default_value(m_config.stepping.max_rk_updates),
0114                        "The maximum number of Runge-Kutta updates");
0115   m_desc.add_options()("stepping-use-mean-loss",
0116                        po::value(&(m_config.stepping.use_mean_loss))
0117                            ->default_value(m_config.stepping.use_mean_loss),
0118                        "Enable the Bethe energy loss model");
0119
0120   m_desc.add_options()(
0121       "stepping-do-covariance-transport",
0122       po::value(&(m_config.stepping.do_covariance_transport))
0123           ->default_value(m_config.stepping.do_covariance_transport),
0124       "Enable covariance transport in the stepper");
0125   m_desc.add_options()(
0126       "stepping-use-eloss-gradient",
0127       po::value(&(m_config.stepping.use_eloss_gradient))
0128           ->default_value(m_config.stepping.use_eloss_gradient),
0129       "Enable the energy loss gradient in covariance transport");
0130   m_desc.add_options()(
0131       "stepping-use-field-gradient",
0132       po::value(&(m_config.stepping.use_field_gradient))
0133           ->default_value(m_config.stepping.use_field_gradient),
0134       "Enable the B-field gradient in covariance transport");
0135 }
0136
0137 void track_propagation::read(const po::variables_map &) {
0138   m_config.stepping.step_constraint *= traccc::unit<float>::mm;
0139   m_config.stepping.rk_error_tol *= traccc::unit<float>::mm;
0140   m_config.navigation.intersection.overstep_tolerance *=
0141       traccc::unit<float>::um;
0142   m_config.navigation.intersection.min_mask_tolerance *=
0143       traccc::unit<float>::mm;
0144   m_config.navigation.intersection.max_mask_tolerance *=
0145       traccc::unit<float>::mm;
0146   m_config.navigation.search_window = m_search_window;
0147   m_config.navigation.accumulated_error /= 100.f;
0148
0149   m_config.stepping.min_stepsize *= traccc::unit<float>::mm;
0150   m_config.stepping.path_limit *= traccc::unit<float>::m;
0151 }
0152
0153 track_propagation::operator detray::propagation::config() const {
0154   return m_config;
0155 }
0156
0157 std::unique_ptr<configuration_printable> track_propagation::as_printable()
0158     const {
0159   auto cat_nav = std::make_unique<configuration_category>("Navigation");
0160
0161   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0162       "Min mask tolerance",
0163       std::to_string(m_config.navigation.intersection.min_mask_tolerance /
0164                      traccc::unit<float>::mm) +
0165           " mm"));
0166   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0167       "Max mask tolerance",
0168       std::to_string(m_config.navigation.intersection.max_mask_tolerance /
0169                      traccc::unit<float>::mm) +
0170           " mm"));
0171   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0172       "Mask tolerance scaling",
0173       std::to_string(m_config.navigation.intersection.mask_tolerance_scalor)));
0174   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0175       "Path tolerance",
0176       std::to_string(m_config.navigation.intersection.path_tolerance /
0177                      traccc::unit<float>::um) +
0178           " um"));
0179   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0180       "Scale factor for accumulated noise",
0181       std::to_string(m_config.navigation.accumulated_error * 100.f) + " %"));
0182   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0183       "# scattering stddevs to assume",
0184       std::to_string(m_config.navigation.n_scattering_stddev)));
0185   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0186       "Overstep tolerance",
0187       std::to_string(m_config.navigation.intersection.overstep_tolerance /
0188                      traccc::unit<float>::um) +
0189           " um"));
0190   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0191       "Search window",
0192       std::to_string(m_config.navigation.search_window[0]) + " x " +
0193           std::to_string(m_config.navigation.search_window[1])));
0194   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0195       "Scale factor for accumulated noise",
0196       std::to_string(m_config.navigation.accumulated_error * 100.f) + " %"));
0197   cat_nav->add_child(std::make_unique<configuration_kv_pair>(
0198       "# scattering stddevs to assume",
0199       std::to_string(m_config.navigation.n_scattering_stddev)));
0200
0201   auto cat_tsp = std::make_unique<configuration_category>("Transport");
0202
0203   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0204       "Min step size",
0205       std::to_string(m_config.stepping.min_stepsize / traccc::unit<float>::mm) +
0206           " mm"));
0207   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0208       "Runge-Kutta tolerance",
0209       std::to_string(m_config.stepping.rk_error_tol / traccc::unit<float>::mm) +
0210           " mm"));
0211   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0212       "Max step updates", std::to_string(m_config.stepping.max_rk_updates)));
0213   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0214       "Step size constraint", std::to_string(m_config.stepping.step_constraint /
0215                                              traccc::unit<float>::mm) +
0216                                   " mm"));
0217   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0218       "Path limit",
0219       std::to_string(m_config.stepping.path_limit / traccc::unit<float>::m) +
0220           " m"));
0221   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0222       "Enable Bethe energy loss",
0223       std::format("{}", m_config.stepping.use_mean_loss)));
0224   cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
0225       "Enable covariance transport",
0226       std::format("{}", m_config.stepping.do_covariance_transport)));
0227
0228   if (m_config.stepping.do_covariance_transport) {
0229     auto cat_cov =
0230         std::make_unique<configuration_category>("Covariance transport");
0231
0232     cat_cov->add_child(std::make_unique<configuration_kv_pair>(
0233         "Enable energy loss gradient",
0234         std::format("{}", m_config.stepping.use_eloss_gradient)));
0235     cat_cov->add_child(std::make_unique<configuration_kv_pair>(
0236         "Enable B-field gradient",
0237         std::format("{}", m_config.stepping.use_field_gradient)));
0238
0239     cat_tsp->add_child(std::move(cat_cov));
0240   }
0241
0242   auto cat_geo = std::make_unique<configuration_category>("Geometry context");
0243
0244   auto cat = std::make_unique<configuration_category>(m_description);
0245
0246   cat->add_child(std::move(cat_nav));
0247   cat->add_child(std::move(cat_tsp));
0248   cat->add_child(std::move(cat_geo));
0249
0250   return cat;
0251 }
0252
0253 }  // namespace traccc::opts