Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2026-11-18 09:36:54

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
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 // Create a test context
0049 GeometryContext geoContext = GeometryContext::dangerouslyDefaultConstruct();
0050 MagneticFieldContext magFieldContext = MagneticFieldContext();
0051 
0052 // 4D vertex distributions
0053 // x-/y-position
0054 std::uniform_real_distribution<double> vXYDist(-0.1_mm, 0.1_mm);
0055 // z-position
0056 std::uniform_real_distribution<double> vZDist(-20_mm, 20_mm);
0057 // time
0058 std::uniform_real_distribution<double> vTDist(-1_ns, 1_ns);
0059 
0060 // Track parameter distributions
0061 // d0
0062 std::uniform_real_distribution<double> d0Dist(-0.01_mm, 0.01_mm);
0063 // z0
0064 std::uniform_real_distribution<double> z0Dist(-0.2_mm, 0.2_mm);
0065 // pT
0066 std::uniform_real_distribution<double> pTDist(0.4_GeV, 10_GeV);
0067 // phi
0068 std::uniform_real_distribution<double> phiDist(-std::numbers::pi,
0069                                                std::numbers::pi);
0070 // theta
0071 std::uniform_real_distribution<double> thetaDist(1., std::numbers::pi - 1.);
0072 // charge helper
0073 std::uniform_real_distribution<double> qDist(-1, 1);
0074 // time
0075 std::uniform_real_distribution<double> tDist(-0.002_ns, 0.002_ns);
0076 
0077 // Track parameter resolution distributions
0078 // impact parameters
0079 std::uniform_real_distribution<double> resIPDist(0., 100_um);
0080 // angles
0081 std::uniform_real_distribution<double> resAngDist(0., 0.1);
0082 // q/p
0083 std::uniform_real_distribution<double> resQoPDist(-0.1, 0.1);
0084 // Track time resolution distribution
0085 std::uniform_real_distribution<double> resTDist(0.1_ns, 0.2_ns);
0086 
0087 // Number of tracks distritbution
0088 std::uniform_int_distribution<std::uint32_t> nTracksDist(3, 10);
0089 
0090 // Dummy user-defined InputTrack type
0091 struct InputTrackStub {
0092   explicit InputTrackStub(const BoundTrackParameters& params)
0093       : m_parameters(params) {}
0094 
0095   const BoundTrackParameters& parameters() const { return m_parameters; }
0096 
0097   // store e.g. link to original objects here
0098 
0099  private:
0100   BoundTrackParameters m_parameters;
0101 };
0102 
0103 BOOST_AUTO_TEST_SUITE(VertexingSuite)
0104 
0105 ///
0106 /// @brief Unit test for FullBilloirVertexFitter
0107 /// with default input track type (= BoundTrackParameters)
0108 ///
0109 BOOST_AUTO_TEST_CASE(billoir_vertex_fitter_defaulttrack_test) {
0110   // Set up RNG
0111   int seed = 31415;
0112   std::mt19937 gen(seed);
0113   // Set up constant B-Field
0114   auto bField = std::make_shared<ConstantBField>(Vector3{0.0, 0.0, 1_T});
0115 
0116   // Set up Eigenstepper
0117   EigenStepper<> stepper(bField);
0118   // Set up propagator with void navigator
0119   auto propagator = std::make_shared<Propagator<EigenStepper<>>>(stepper);
0120 
0121   HelicalTrackLinearizer::Config ltConfig;
0122   ltConfig.propagator = propagator;
0123   HelicalTrackLinearizer linearizer(ltConfig);
0124 
0125   // Constraint for vertex fit
0126   Vertex constraint;
0127   Vertex customConstraint;
0128   // Some arbitrary values
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   // Set up Billoir vertex fitter with default tracks
0141   using VertexFitter = FullBilloirVertexFitter;
0142   VertexFitter::Config vertexFitterCfg;
0143   vertexFitterCfg.extractParameters.connect<&InputTrack::extractParameters>();
0144   vertexFitterCfg.trackLinearizer
0145       .connect<&HelicalTrackLinearizer::linearizeTrack>(&linearizer);
0146   // A track linearizer is required.
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   // Vertexing options for default tracks
0154   VertexingOptions vfOptions(geoContext, magFieldContext);
0155   VertexingOptions vfOptionsConstr(geoContext, magFieldContext, constraint);
0156 
0157   // Create a custom std::function to extract BoundTrackParameters from
0158   // user-defined InputTrack
0159   auto extractParameters = [](const InputTrack& params) {
0160     return params.as<InputTrackStub>()->parameters();
0161   };
0162 
0163   // Set up Billoir vertex fitter with user-defined input tracks
0164   VertexFitter::Config customVertexFitterCfg;
0165   customVertexFitterCfg.extractParameters.connect(extractParameters);
0166   customVertexFitterCfg.trackLinearizer
0167       .connect<&HelicalTrackLinearizer::linearizeTrack>(&linearizer);
0168   VertexFitter customBilloirFitter(customVertexFitterCfg);
0169   // Vertexing options for custom tracks
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     // Without constraint
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     // With constraint
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   // Number of events
0197   const int nEvents = 100;
0198   for (int eventIdx = 0; eventIdx < nEvents; ++eventIdx) {
0199     // Number of tracks
0200     std::uint32_t nTracks = nTracksDist(gen);
0201 
0202     // Create position of vertex and perigee surface
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     // Calculate d0 and z0 corresponding to the vertex position
0213     double d0V = std::hypot(x, y);
0214     double z0V = z;
0215 
0216     // Vector to store track objects used for vertex fit
0217     std::vector<BoundTrackParameters> tracks;
0218     std::vector<InputTrackStub> customTracks;
0219 
0220     // Calculate random track emerging from vicinity of vertex position
0221     for (std::uint32_t iTrack = 0; iTrack < nTracks; iTrack++) {
0222       // Charge
0223       double q = std::copysign(1., qDist(gen));
0224 
0225       // Track parameters
0226       BoundVector paramVec;
0227       paramVec << d0V + d0Dist(gen), z0V + z0Dist(gen), phiDist(gen),
0228           thetaDist(gen), q / pTDist(gen), t + tDist(gen);
0229 
0230       // Resolutions
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       // Fill vector of track objects with simple covariance matrix
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 }  // namespace ActsTests