File indexing completed on 2026-11-18 09:36:54
0001
0002
0003
0004
0005
0006
0007
0008
0009 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Definitions/TrackParametrization.hpp"
0013 #include "Acts/Definitions/Units.hpp"
0014 #include "Acts/EventData/BoundTrackParameters.hpp"
0015 #include "Acts/Geometry/GeometryContext.hpp"
0016 #include "Acts/Geometry/GeometryIdentifier.hpp"
0017 #include "Acts/MagneticField/ConstantBField.hpp"
0018 #include "Acts/MagneticField/MagneticFieldContext.hpp"
0019 #include "Acts/MagneticField/MagneticFieldQuery.hpp"
0020 #include "Acts/Propagator/EigenStepper.hpp"
0021 #include "Acts/Propagator/Propagator.hpp"
0022 #include "Acts/Surfaces/PerigeeSurface.hpp"
0023 #include "Acts/Surfaces/Surface.hpp"
0024 #include "Acts/Utilities/Result.hpp"
0025 #include "Acts/Vertexing/FullBilloirVertexFitter.hpp"
0026 #include "Acts/Vertexing/HelicalTrackLinearizer.hpp"
0027 #include "Acts/Vertexing/TrackAtVertex.hpp"
0028 #include "Acts/Vertexing/Vertex.hpp"
0029 #include "Acts/Vertexing/VertexingOptions.hpp"
0030 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0031
0032 #include <cmath>
0033 #include <iostream>
0034 #include <memory>
0035 #include <numbers>
0036 #include <random>
0037 #include <stdexcept>
0038 #include <utility>
0039 #include <vector>
0040
0041 using namespace Acts;
0042 using namespace Acts::UnitLiterals;
0043
0044 namespace ActsTests {
0045
0046 using Covariance = BoundMatrix;
0047
0048
0049 GeometryContext geoContext = GeometryContext::dangerouslyDefaultConstruct();
0050 MagneticFieldContext magFieldContext = MagneticFieldContext();
0051
0052
0053
0054 std::uniform_real_distribution<double> vXYDist(-0.1_mm, 0.1_mm);
0055
0056 std::uniform_real_distribution<double> vZDist(-20_mm, 20_mm);
0057
0058 std::uniform_real_distribution<double> vTDist(-1_ns, 1_ns);
0059
0060
0061
0062 std::uniform_real_distribution<double> d0Dist(-0.01_mm, 0.01_mm);
0063
0064 std::uniform_real_distribution<double> z0Dist(-0.2_mm, 0.2_mm);
0065
0066 std::uniform_real_distribution<double> pTDist(0.4_GeV, 10_GeV);
0067
0068 std::uniform_real_distribution<double> phiDist(-std::numbers::pi,
0069 std::numbers::pi);
0070
0071 std::uniform_real_distribution<double> thetaDist(1., std::numbers::pi - 1.);
0072
0073 std::uniform_real_distribution<double> qDist(-1, 1);
0074
0075 std::uniform_real_distribution<double> tDist(-0.002_ns, 0.002_ns);
0076
0077
0078
0079 std::uniform_real_distribution<double> resIPDist(0., 100_um);
0080
0081 std::uniform_real_distribution<double> resAngDist(0., 0.1);
0082
0083 std::uniform_real_distribution<double> resQoPDist(-0.1, 0.1);
0084
0085 std::uniform_real_distribution<double> resTDist(0.1_ns, 0.2_ns);
0086
0087
0088 std::uniform_int_distribution<std::uint32_t> nTracksDist(3, 10);
0089
0090
0091 struct InputTrackStub {
0092 explicit InputTrackStub(const BoundTrackParameters& params)
0093 : m_parameters(params) {}
0094
0095 const BoundTrackParameters& parameters() const { return m_parameters; }
0096
0097
0098
0099 private:
0100 BoundTrackParameters m_parameters;
0101 };
0102
0103 BOOST_AUTO_TEST_SUITE(VertexingSuite)
0104
0105
0106
0107
0108
0109 BOOST_AUTO_TEST_CASE(billoir_vertex_fitter_defaulttrack_test) {
0110
0111 int seed = 31415;
0112 std::mt19937 gen(seed);
0113
0114 auto bField = std::make_shared<ConstantBField>(Vector3{0.0, 0.0, 1_T});
0115
0116
0117 EigenStepper<> stepper(bField);
0118
0119 auto propagator = std::make_shared<Propagator<EigenStepper<>>>(stepper);
0120
0121 HelicalTrackLinearizer::Config ltConfig;
0122 ltConfig.propagator = propagator;
0123 HelicalTrackLinearizer linearizer(ltConfig);
0124
0125
0126 Vertex constraint;
0127 Vertex customConstraint;
0128
0129 SquareMatrix4 covMatVtx = SquareMatrix4::Zero();
0130 double ns2 = Acts::UnitConstants::ns * Acts::UnitConstants::ns;
0131 covMatVtx(0, 0) = 30_mm2;
0132 covMatVtx(1, 1) = 30_mm2;
0133 covMatVtx(2, 2) = 30_mm2;
0134 covMatVtx(3, 3) = 30 * ns2;
0135 constraint.setFullCovariance(covMatVtx);
0136 constraint.setFullPosition(Vector4(0, 0, 0, 0));
0137 customConstraint.setFullCovariance(covMatVtx);
0138 customConstraint.setFullPosition(Vector4(0, 0, 0, 0));
0139
0140
0141 using VertexFitter = FullBilloirVertexFitter;
0142 VertexFitter::Config vertexFitterCfg;
0143 vertexFitterCfg.extractParameters.connect<&InputTrack::extractParameters>();
0144 vertexFitterCfg.trackLinearizer
0145 .connect<&HelicalTrackLinearizer::linearizeTrack>(&linearizer);
0146
0147 auto invalidCfg = vertexFitterCfg;
0148 invalidCfg.trackLinearizer = {};
0149 BOOST_CHECK_THROW(VertexFitter{invalidCfg}, std::invalid_argument);
0150
0151 VertexFitter billoirFitter(vertexFitterCfg);
0152 MagneticFieldQuery field(*bField, magFieldContext);
0153
0154 VertexingOptions vfOptions(geoContext, magFieldContext);
0155 VertexingOptions vfOptionsConstr(geoContext, magFieldContext, constraint);
0156
0157
0158
0159 auto extractParameters = [](const InputTrack& params) {
0160 return params.as<InputTrackStub>()->parameters();
0161 };
0162
0163
0164 VertexFitter::Config customVertexFitterCfg;
0165 customVertexFitterCfg.extractParameters.connect(extractParameters);
0166 customVertexFitterCfg.trackLinearizer
0167 .connect<&HelicalTrackLinearizer::linearizeTrack>(&linearizer);
0168 VertexFitter customBilloirFitter(customVertexFitterCfg);
0169
0170 VertexingOptions customVfOptions(geoContext, magFieldContext);
0171 VertexingOptions customVfOptionsConstr(geoContext, magFieldContext,
0172 customConstraint);
0173
0174 BOOST_TEST_CONTEXT(
0175 "Testing FullBilloirVertexFitter when input track vector is empty.") {
0176 const std::vector<const BoundTrackParameters*> emptyVector;
0177 const std::vector<InputTrack> emptyVectorInput;
0178
0179
0180 Vertex fittedVertex =
0181 billoirFitter.fit(emptyVectorInput, vfOptions, field).value();
0182
0183 Vector3 origin(0., 0., 0.);
0184 SquareMatrix4 zeroMat = SquareMatrix4::Zero();
0185 BOOST_CHECK_EQUAL(fittedVertex.position(), origin);
0186 BOOST_CHECK_EQUAL(fittedVertex.fullCovariance(), zeroMat);
0187
0188
0189 fittedVertex =
0190 billoirFitter.fit(emptyVectorInput, vfOptionsConstr, field).value();
0191
0192 BOOST_CHECK_EQUAL(fittedVertex.position(), origin);
0193 BOOST_CHECK_EQUAL(fittedVertex.fullCovariance(), zeroMat);
0194 }
0195
0196
0197 const int nEvents = 100;
0198 for (int eventIdx = 0; eventIdx < nEvents; ++eventIdx) {
0199
0200 std::uint32_t nTracks = nTracksDist(gen);
0201
0202
0203 double x = vXYDist(gen);
0204 double y = vXYDist(gen);
0205 double z = vZDist(gen);
0206 double t = vTDist(gen);
0207
0208 Vector4 trueVertex(x, y, z, t);
0209 std::shared_ptr<PerigeeSurface> perigeeSurface =
0210 Surface::makeShared<PerigeeSurface>(Vector3(0., 0., 0.));
0211
0212
0213 double d0V = std::hypot(x, y);
0214 double z0V = z;
0215
0216
0217 std::vector<BoundTrackParameters> tracks;
0218 std::vector<InputTrackStub> customTracks;
0219
0220
0221 for (std::uint32_t iTrack = 0; iTrack < nTracks; iTrack++) {
0222
0223 double q = std::copysign(1., qDist(gen));
0224
0225
0226 BoundVector paramVec;
0227 paramVec << d0V + d0Dist(gen), z0V + z0Dist(gen), phiDist(gen),
0228 thetaDist(gen), q / pTDist(gen), t + tDist(gen);
0229
0230
0231 double resD0 = resIPDist(gen);
0232 double resZ0 = resIPDist(gen);
0233 double resPh = resAngDist(gen);
0234 double resTh = resAngDist(gen);
0235 double resQp = resQoPDist(gen);
0236 double resT = resTDist(gen);
0237
0238
0239 Covariance covMat;
0240
0241 covMat << resD0 * resD0, 0., 0., 0., 0., 0., 0., resZ0 * resZ0, 0., 0.,
0242 0., 0., 0., 0., resPh * resPh, 0., 0., 0., 0., 0., 0., resTh * resTh,
0243 0., 0., 0., 0., 0., 0., resQp * resQp, 0., 0., 0., 0., 0., 0.,
0244 resT * resT;
0245 tracks.emplace_back(BoundTrackParameters(perigeeSurface, paramVec, covMat,
0246 ParticleHypothesis::pion()));
0247 customTracks.emplace_back(
0248 BoundTrackParameters(perigeeSurface, paramVec, std::move(covMat),
0249 ParticleHypothesis::pion()));
0250 }
0251
0252 std::vector<InputTrack> inputTracks;
0253 for (const auto& trk : tracks) {
0254 inputTracks.push_back(InputTrack{&trk});
0255 }
0256
0257 std::vector<InputTrack> customInputTracks;
0258 for (const auto& trk : customTracks) {
0259 customInputTracks.push_back(InputTrack{&trk});
0260 }
0261
0262 auto fit = [&trueVertex, &nTracks, &field](const auto& fitter,
0263 const auto& trksPtr,
0264 const auto& vfOpts) {
0265 auto fittedVertex = fitter.fit(trksPtr, vfOpts, field).value();
0266 if (!fittedVertex.tracks().empty()) {
0267 CHECK_CLOSE_ABS(fittedVertex.position(), trueVertex.head(3), 1_mm);
0268 auto tracksAtVtx = fittedVertex.tracks();
0269 auto trackAtVtx = tracksAtVtx[0];
0270 CHECK_CLOSE_ABS(fittedVertex.time(), trueVertex[3], 1_ns);
0271 }
0272
0273 std::cout << "\nFitting " << nTracks << " tracks" << std::endl;
0274 std::cout << "True Vertex:\n" << trueVertex << std::endl;
0275 std::cout << "Fitted Vertex:\n"
0276 << fittedVertex.fullPosition() << std::endl;
0277 };
0278
0279 BOOST_TEST_CONTEXT(
0280 "Testing FullBilloirVertexFitter without vertex constraint.") {
0281 fit(billoirFitter, inputTracks, vfOptions);
0282 }
0283 BOOST_TEST_CONTEXT(
0284 "Testing FullBilloirVertexFitter with vertex constraint.") {
0285 fit(billoirFitter, inputTracks, vfOptionsConstr);
0286 }
0287 BOOST_TEST_CONTEXT(
0288 "Testing FullBilloirVertexFitter with custom tracks (no vertex "
0289 "constraint).") {
0290 fit(customBilloirFitter, customInputTracks, customVfOptions);
0291 }
0292 BOOST_TEST_CONTEXT(
0293 "Testing FullBilloirVertexFitter with custom tracks (with vertex "
0294 "constraint).") {
0295 fit(customBilloirFitter, customInputTracks, customVfOptionsConstr);
0296 }
0297 }
0298 }
0299
0300 BOOST_AUTO_TEST_SUITE_END()
0301
0302 }