Skip to content

Commit c3f883f

Browse files
krasznaakrasznaa
authored
Merge pull request #1088 from krasznaa/OptionsIprovements-main-20250724
CMDL Options Improvements, main branch (2025.07.24.)
1 parent 8a78f14 commit c3f883f

14 files changed

+333
-98
lines changed

‎examples/options/include/traccc/options/track_seeding.hpp‎

Lines changed: 48 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,39 +1,75 @@
11
/** TRACCC library, part of the ACTS project (R&D line)
22
*
3-
* (c) 2022-2024 CERN for the benefit of the ACTS project
3+
* (c) 2022-2025 CERN for the benefit of the ACTS project
44
*
55
* Mozilla Public License Version 2.0
66
*/
77

88
#pragma once
99

1010
// Project include(s).
11+
#include "traccc/options/details/config_provider.hpp"
1112
#include "traccc/options/details/interface.hpp"
13+
#include "traccc/options/details/value_array.hpp"
1214
#include "traccc/seeding/detail/seeding_config.hpp"
1315

14-
// System include(s).
15-
#include <iosfwd>
16-
1716
namespace traccc::opts {
1817

1918
/// Command line options used to configure track seeding
20-
class track_seeding : public interface {
19+
class track_seeding : public interface,
20+
public config_provider<seedfinder_config>,
21+
public config_provider<seedfilter_config>,
22+
public config_provider<spacepoint_grid_config>,
23+
public config_provider<vector3> {
2124

2225
public:
23-
/// @name Options
26+
/// Constructor
27+
track_seeding();
28+
29+
/// @name Configuration conversion operators
2430
/// @{
2531

26-
/// Configuration for the seed-finding
27-
traccc::seedfinder_config seedfinder;
28-
/// Configuration for the seed filtering
29-
traccc::seedfilter_config seedfilter;
32+
/// Configuration provider for the seed-finder
33+
explicit operator seedfinder_config() const override;
34+
/// Configuration provider for the seed-filter
35+
explicit operator seedfilter_config() const override;
36+
/// Configuration provider for the spacepoint grid
37+
explicit operator spacepoint_grid_config() const override;
38+
/// Configuration provider for the constant magnetic field assumed
39+
explicit operator vector3() const override;
3040

3141
/// @}
3242

33-
/// Constructor
34-
track_seeding();
43+
/// Read/process the command line options
44+
///
45+
/// @param vm The command line options to interpret/read
46+
///
47+
void read(const boost::program_options::variables_map& vm) override;
3548

49+
/// Get a printable representation of the configuration
3650
std::unique_ptr<configuration_printable> as_printable() const override;
51+
52+
private:
53+
/// Configuration for the seed-finding
54+
seedfinder_config m_seedfinder;
55+
/// Configuration for the seed filtering
56+
seedfilter_config m_seedfilter;
57+
58+
/// Z range for the used spacepoints
59+
opts::value_array<float, 2> m_z_range{m_seedfinder.zMin / unit<float>::mm,
60+
m_seedfinder.zMax / unit<float>::mm};
61+
/// R range for the used spacepoints
62+
opts::value_array<float, 2> m_r_range{m_seedfinder.rMin / unit<float>::mm,
63+
m_seedfinder.rMax / unit<float>::mm};
64+
/// Z range for the collision region
65+
opts::value_array<float, 2> m_vertex_range{
66+
m_seedfinder.collisionRegionMin / unit<float>::mm,
67+
m_seedfinder.collisionRegionMax / unit<float>::mm};
68+
/// Delta R range for the used spacepoints
69+
opts::value_array<float, 2> m_delta_r_range{
70+
m_seedfinder.deltaRMin / unit<float>::mm,
71+
m_seedfinder.deltaRMax / unit<float>::mm};
72+
3773
}; // struct track_seeding
3874

3975
} // namespace traccc::opts

‎examples/options/src/track_propagation.cpp‎

Lines changed: 39 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -52,11 +52,45 @@ track_propagation::track_propagation()
5252
"search-window",
5353
po::value(&m_search_window)->default_value(m_search_window),
5454
"Size of the grid surface search window");
55-
m_desc.add_options()("rk-tolerance-mm [mm]",
55+
m_desc.add_options()("rk-tolerance-mm",
5656
po::value(&(m_config.stepping.rk_error_tol))
5757
->default_value(m_config.stepping.rk_error_tol /
5858
traccc::unit<float>::mm),
59-
"The Runge-Kutta stepper tolerance");
59+
"The Runge-Kutta stepper tolerance [mm]");
60+
m_desc.add_options()("stepping-min-stepsize",
61+
po::value(&(m_config.stepping.min_stepsize))
62+
->default_value(m_config.stepping.min_stepsize /
63+
traccc::unit<float>::mm),
64+
"The minimum step size [mm]");
65+
m_desc.add_options()("stepping-path-limit",
66+
po::value(&(m_config.stepping.path_limit))
67+
->default_value(m_config.stepping.path_limit /
68+
traccc::unit<float>::m),
69+
"The maximum path length for the stepper [m]");
70+
m_desc.add_options()("stepping-max-rk-updates",
71+
po::value(&(m_config.stepping.max_rk_updates))
72+
->default_value(m_config.stepping.max_rk_updates),
73+
"The maximum number of Runge-Kutta updates");
74+
m_desc.add_options()("stepping-use-mean-loss",
75+
po::value(&(m_config.stepping.use_mean_loss))
76+
->default_value(m_config.stepping.use_mean_loss),
77+
"Enable the Bethe energy loss model");
78+
79+
m_desc.add_options()(
80+
"stepping-do-covariance-transport",
81+
po::value(&(m_config.stepping.do_covariance_transport))
82+
->default_value(m_config.stepping.do_covariance_transport),
83+
"Enable covariance transport in the stepper");
84+
m_desc.add_options()(
85+
"stepping-use-eloss-gradient",
86+
po::value(&(m_config.stepping.use_eloss_gradient))
87+
->default_value(m_config.stepping.use_eloss_gradient),
88+
"Enable the energy loss gradient in covariance transport");
89+
m_desc.add_options()(
90+
"stepping-use-field-gradient",
91+
po::value(&(m_config.stepping.use_field_gradient))
92+
->default_value(m_config.stepping.use_field_gradient),
93+
"Enable the B-field gradient in covariance transport");
6094
}
6195

6296
void track_propagation::read(const po::variables_map &) {
@@ -67,6 +101,9 @@ void track_propagation::read(const po::variables_map &) {
67101
m_config.navigation.min_mask_tolerance *= traccc::unit<float>::mm;
68102
m_config.navigation.max_mask_tolerance *= traccc::unit<float>::mm;
69103
m_config.navigation.search_window = m_search_window;
104+
105+
m_config.stepping.min_stepsize *= traccc::unit<float>::mm;
106+
m_config.stepping.path_limit *= traccc::unit<float>::m;
70107
}
71108

72109
track_propagation::operator detray::propagation::config() const {
@@ -125,10 +162,6 @@ std::unique_ptr<configuration_printable> track_propagation::as_printable()
125162
"Path limit",
126163
std::to_string(m_config.stepping.path_limit / traccc::unit<float>::m) +
127164
" m"));
128-
cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
129-
"Min step size", std::to_string(m_config.stepping.min_stepsize /
130-
traccc::unit<float>::mm) +
131-
" mm"));
132165
cat_tsp->add_child(std::make_unique<configuration_kv_pair>(
133166
"Enable Bethe energy loss",
134167
std::format("{}", m_config.stepping.use_mean_loss)));

‎examples/options/src/track_seeding.cpp‎

Lines changed: 145 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,12 +10,156 @@
1010

1111
#include "traccc/examples/utils/printable.hpp"
1212

13+
// System include(s).
14+
#include <format>
15+
1316
namespace traccc::opts {
1417

15-
track_seeding::track_seeding() : interface("Track Seeding Options") {}
18+
/// Convenience namespace shorthand
19+
namespace po = boost::program_options;
20+
21+
track_seeding::track_seeding() : interface("Track Seeding Options") {
22+
23+
m_desc.add_options()(
24+
"seedfinder-z-range",
25+
po::value(&m_z_range)->value_name("MIN:MAX")->default_value(m_z_range),
26+
"Spacepoint Z range [mm]");
27+
m_desc.add_options()(
28+
"seedfinder-r-range",
29+
po::value(&m_r_range)->value_name("MIN:MAX")->default_value(m_r_range),
30+
"Spacepoint R range [mm]");
31+
m_desc.add_options()("seedfinder-vertex-range",
32+
po::value(&m_vertex_range)
33+
->value_name("MIN:MAX")
34+
->default_value(m_vertex_range),
35+
"Vertex Z range [mm]");
36+
37+
m_desc.add_options()(
38+
"seedfinder-minPt",
39+
po::value(&m_seedfinder.minPt)
40+
->default_value(m_seedfinder.minPt / unit<float>::GeV),
41+
"Minimum track momentum [GeV]");
42+
43+
m_desc.add_options()("seedfinder-cotThetaMax",
44+
po::value(&m_seedfinder.cotThetaMax)
45+
->default_value(m_seedfinder.cotThetaMax),
46+
"Maximum cotangent of theta angle [unitless]");
47+
m_desc.add_options()(
48+
"seedfinder-deltaR-range",
49+
po::value(&m_delta_r_range)->default_value(m_delta_r_range),
50+
"Distance range in radious between measurements within one seed [mm]");
51+
52+
m_desc.add_options()(
53+
"seedfinder-impactMax",
54+
po::value(&m_seedfinder.impactMax)
55+
->default_value(m_seedfinder.impactMax / unit<float>::mm),
56+
"Maximum impact parameter [mm]");
57+
m_desc.add_options()("seedfinder-sigmaScattering",
58+
po::value(&m_seedfinder.sigmaScattering)
59+
->default_value(m_seedfinder.sigmaScattering),
60+
"Scattering angle sigma [unitless]");
61+
m_desc.add_options()(
62+
"seedfinder-maxPtScattering",
63+
po::value(&m_seedfinder.maxPtScattering)
64+
->default_value(m_seedfinder.maxPtScattering / unit<float>::GeV),
65+
"Upper pt limit for scattering calculation [GeV]");
66+
67+
m_desc.add_options()("seedfinder-maxSeedsPerSpM",
68+
po::value(&m_seedfinder.maxSeedsPerSpM)
69+
->default_value(m_seedfinder.maxSeedsPerSpM),
70+
"Maximum number of seeds per middle space point");
71+
m_desc.add_options()(
72+
"seedfinder-bFieldInZ",
73+
po::value(&m_seedfinder.bFieldInZ)
74+
->default_value(m_seedfinder.bFieldInZ / unit<float>::T),
75+
"B-field in Z direction [T]");
76+
}
77+
78+
track_seeding::operator seedfinder_config() const {
79+
80+
return m_seedfinder;
81+
}
82+
83+
track_seeding::operator seedfilter_config() const {
84+
85+
return m_seedfilter;
86+
}
87+
88+
track_seeding::operator spacepoint_grid_config() const {
89+
90+
return {m_seedfinder};
91+
}
92+
93+
track_seeding::operator vector3() const {
94+
95+
return {0.f, 0.f, m_seedfinder.bFieldInZ};
96+
}
97+
98+
void track_seeding::read(const po::variables_map&) {
99+
100+
m_seedfinder.zMin = m_z_range[0] * unit<float>::mm;
101+
m_seedfinder.zMax = m_z_range[1] * unit<float>::mm;
102+
m_seedfinder.rMin = m_r_range[0] * unit<float>::mm;
103+
m_seedfinder.rMax = m_r_range[1] * unit<float>::mm;
104+
m_seedfinder.collisionRegionMin = m_vertex_range[0] * unit<float>::mm;
105+
m_seedfinder.collisionRegionMax = m_vertex_range[1] * unit<float>::mm;
106+
m_seedfinder.deltaRMin = m_delta_r_range[0] * unit<float>::mm;
107+
m_seedfinder.deltaRMax = m_delta_r_range[1] * unit<float>::mm;
108+
109+
m_seedfinder.minPt *= unit<float>::GeV;
110+
m_seedfinder.impactMax *= unit<float>::mm;
111+
m_seedfinder.maxPtScattering *= unit<float>::GeV;
112+
m_seedfinder.bFieldInZ *= unit<float>::T;
113+
114+
m_seedfinder.setup();
115+
}
16116

17117
std::unique_ptr<configuration_printable> track_seeding::as_printable() const {
118+
18119
auto cat = std::make_unique<configuration_category>(m_description);
120+
121+
cat->add_child(std::make_unique<configuration_kv_pair>(
122+
"Spacepoint Z range",
123+
std::format("[{:.1f} - {:.1f}] mm", m_seedfinder.zMin / unit<float>::mm,
124+
m_seedfinder.zMax / unit<float>::mm)));
125+
cat->add_child(std::make_unique<configuration_kv_pair>(
126+
"Spacepoint R range",
127+
std::format("[{:.2f} - {:.2f}] mm", m_seedfinder.rMin / unit<float>::mm,
128+
m_seedfinder.rMax / unit<float>::mm)));
129+
cat->add_child(std::make_unique<configuration_kv_pair>(
130+
"Vertex Z range",
131+
std::format("[{:.2f} - {:.2f}] mm",
132+
m_seedfinder.collisionRegionMin / unit<float>::mm,
133+
m_seedfinder.collisionRegionMax / unit<float>::mm)));
134+
135+
cat->add_child(std::make_unique<configuration_kv_pair>(
136+
"Minimum track momentum",
137+
std::format("{:.2f} GeV", m_seedfinder.minPt / unit<float>::GeV)));
138+
cat->add_child(std::make_unique<configuration_kv_pair>(
139+
"Maximum cotangent of theta angle",
140+
std::format("{:.4f}", m_seedfinder.cotThetaMax)));
141+
cat->add_child(std::make_unique<configuration_kv_pair>(
142+
"Distance range in radious between measurements within one seed",
143+
std::format("[{:.2f} - {:.2f}] mm",
144+
m_seedfinder.deltaRMin / unit<float>::mm,
145+
m_seedfinder.deltaRMax / unit<float>::mm)));
146+
cat->add_child(std::make_unique<configuration_kv_pair>(
147+
"Maximum impact parameter",
148+
std::format("{:.2f} mm", m_seedfinder.impactMax / unit<float>::mm)));
149+
cat->add_child(std::make_unique<configuration_kv_pair>(
150+
"Scattering angle sigma",
151+
std::format("{:.2f}", m_seedfinder.sigmaScattering)));
152+
cat->add_child(std::make_unique<configuration_kv_pair>(
153+
"Upper pt limit for scattering calculation",
154+
std::format("{:.2f} GeV",
155+
m_seedfinder.maxPtScattering / unit<float>::GeV)));
156+
cat->add_child(std::make_unique<configuration_kv_pair>(
157+
"Maximum seeds per middle space point",
158+
std::to_string(m_seedfinder.maxSeedsPerSpM)));
159+
cat->add_child(std::make_unique<configuration_kv_pair>(
160+
"B-field in Z direction",
161+
std::format("{:.2f} T", m_seedfinder.bFieldInZ / unit<float>::T)));
162+
19163
return cat;
20164
}
21165
} // namespace traccc::opts

‎examples/run/alpaka/seeding_example_alpaka.cpp‎

Lines changed: 13 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -114,6 +114,7 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
114114

115115
// B field value and its type
116116
const auto field = traccc::details::make_magnetic_field(bfield_opts);
117+
const traccc::vector3 field_vec(seeding_opts);
117118

118119
// Construct a Detray detector object, if supported by the configuration.
119120
traccc::default_detector::host host_det{mng_mr};
@@ -133,17 +134,20 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
133134
track_state_d2h{mr, copy, logger().clone("TrackStateD2HCopyAlg")};
134135

135136
// Seeding algorithms
137+
const traccc::seedfinder_config seedfinder_config(seeding_opts);
138+
const traccc::seedfilter_config seedfilter_config(seeding_opts);
139+
const traccc::spacepoint_grid_config spacepoint_grid_config(seeding_opts);
136140
traccc::host::seeding_algorithm sa(
137-
seeding_opts.seedfinder, {seeding_opts.seedfinder},
138-
seeding_opts.seedfilter, host_mr, logger().clone("HostSeedingAlg"));
141+
seedfinder_config, spacepoint_grid_config, seedfilter_config, host_mr,
142+
logger().clone("HostSeedingAlg"));
139143
traccc::host::track_params_estimation tp(
140144
host_mr, logger().clone("HostTrackParEstAlg"));
141145

142146
// Alpaka Algorithms
143147
traccc::alpaka::seeding_algorithm sa_alpaka{
144-
seeding_opts.seedfinder,
145-
{seeding_opts.seedfinder},
146-
seeding_opts.seedfilter,
148+
seedfinder_config,
149+
spacepoint_grid_config,
150+
seedfilter_config,
147151
mr,
148152
async_copy,
149153
queue,
@@ -266,10 +270,9 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
266270
{
267271
traccc::performance::timer t("Track params (alpaka)",
268272
elapsedTimes);
269-
params_alpaka_buffer =
270-
tp_alpaka(measurements_alpaka_buffer,
271-
spacepoints_alpaka_buffer, seeds_alpaka_buffer,
272-
{0.f, 0.f, seeding_opts.seedfinder.bFieldInZ});
273+
params_alpaka_buffer = tp_alpaka(
274+
measurements_alpaka_buffer, spacepoints_alpaka_buffer,
275+
seeds_alpaka_buffer, field_vec);
273276
queue.synchronize();
274277
} // stop measuring track params alpaka timer
275278

@@ -279,8 +282,7 @@ int seq_run(const traccc::opts::track_seeding& seeding_opts,
279282
elapsedTimes);
280283
params = tp(vecmem::get_data(measurements_per_event),
281284
vecmem::get_data(spacepoints_per_event),
282-
vecmem::get_data(seeds),
283-
{0.f, 0.f, seeding_opts.seedfinder.bFieldInZ});
285+
vecmem::get_data(seeds), field_vec);
284286
} // stop measuring track params cpu timer
285287

286288
/*------------------------

0 commit comments

Comments
 (0)