Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2026-11-19 09:43:49

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 "ActsExamples/TrackFinding/TrackParamsEstimationAlgorithm.hpp"
0010 
0011 #include "Acts/EventData/ParticleHypothesis.hpp"
0012 #include "Acts/Utilities/Logger.hpp"
0013 #include "ActsExamples/EventData/SpacePoint.hpp"
0014 #include "ActsExamples/EventData/Track.hpp"
0015 #include "ActsExamples/Framework/AlgorithmContext.hpp"
0016 
0017 #include <cstddef>
0018 #include <ostream>
0019 #include <stdexcept>
0020 #include <utility>
0021 #include <vector>
0022 
0023 namespace ActsExamples {
0024 
0025 TrackParamsEstimationAlgorithm::TrackParamsEstimationAlgorithm(
0026     const Config& cfg, std::unique_ptr<const Acts::Logger> logger)
0027     : IAlgorithm("TrackParamsEstimationAlgorithm", std::move(logger)),
0028       m_cfg(cfg),
0029       m_estimator(
0030           [&]() {
0031             SeedParamsEstimator::Config estimatorCfg =
0032                 m_cfg.seedParamsEstimation;
0033             if (estimatorCfg.trackingGeometry == nullptr) {
0034               estimatorCfg.trackingGeometry = m_cfg.trackingGeometry;
0035             }
0036             if (estimatorCfg.magneticField == nullptr) {
0037               estimatorCfg.magneticField = m_cfg.magneticField;
0038             }
0039             return estimatorCfg;
0040           }(),
0041           this->logger().clone()) {
0042   if (m_cfg.inputSeeds.empty()) {
0043     throw std::invalid_argument("Missing seeds input collection");
0044   }
0045   if (m_cfg.outputTrackParameters.empty()) {
0046     throw std::invalid_argument("Missing track parameters output collection");
0047   }
0048 
0049   m_inputSeeds.initialize(m_cfg.inputSeeds);
0050   m_inputTracks.maybeInitialize(m_cfg.inputProtoTracks);
0051   m_inputParticleHypotheses.maybeInitialize(m_cfg.inputParticleHypotheses);
0052   m_inputFreeParameters.maybeInitialize(m_cfg.inputFreeParameters);
0053 
0054   m_outputTrackParameters.initialize(m_cfg.outputTrackParameters);
0055   m_outputSeeds.maybeInitialize(m_cfg.outputSeeds);
0056   m_outputTracks.maybeInitialize(m_cfg.outputProtoTracks);
0057 }
0058 
0059 ProcessCode TrackParamsEstimationAlgorithm::execute(
0060     const AlgorithmContext& ctx) const {
0061   auto const& seeds = m_inputSeeds(ctx);
0062   ACTS_VERBOSE("Read " << seeds.size() << " seeds");
0063 
0064   TrackParametersContainer trackParameters;
0065   trackParameters.reserve(seeds.size());
0066 
0067   SeedContainer outputSeeds;
0068   if (m_outputSeeds.isInitialized()) {
0069     outputSeeds.assignSpacePointContainer(seeds.spacePointContainer());
0070     outputSeeds.reserve(seeds.size());
0071   }
0072 
0073   const ProtoTrackContainer* inputTracks = nullptr;
0074   ProtoTrackContainer outputTracks;
0075   if (m_inputTracks.isInitialized() && m_outputTracks.isInitialized()) {
0076     const auto& inputTracksRef = m_inputTracks(ctx);
0077     if (seeds.size() != inputTracksRef.size()) {
0078       ACTS_FATAL("Inconsistent number of seeds and proto tracks");
0079       return ProcessCode::ABORT;
0080     }
0081     inputTracks = &inputTracksRef;
0082     outputTracks.reserve(seeds.size());
0083   }
0084 
0085   const std::vector<Acts::ParticleHypothesis>* inputParticleHypotheses =
0086       nullptr;
0087   if (m_inputParticleHypotheses.isInitialized()) {
0088     const auto& inputParticleHypothesesRef = m_inputParticleHypotheses(ctx);
0089     if (seeds.size() != inputParticleHypothesesRef.size()) {
0090       ACTS_FATAL("Inconsistent number of seeds and particle hypotheses");
0091       return ProcessCode::ABORT;
0092     }
0093     inputParticleHypotheses = &inputParticleHypothesesRef;
0094   }
0095 
0096   const std::vector<Acts::FreeVector>* inputFreeParameters = nullptr;
0097   if (m_inputFreeParameters.isInitialized()) {
0098     const auto& inputFreeParametersRef = m_inputFreeParameters(ctx);
0099     if (seeds.size() != inputFreeParametersRef.size()) {
0100       ACTS_FATAL("Inconsistent number of seeds and free parameters");
0101       return ProcessCode::ABORT;
0102     }
0103     inputFreeParameters = &inputFreeParametersRef;
0104   }
0105 
0106   SeedParamsEstimator::Cache cache = m_estimator.makeCache(ctx.magFieldContext);
0107 
0108   struct {
0109     std::size_t selection = 0;
0110     std::size_t fit = 0;
0111     std::size_t degenerate = 0;
0112     std::size_t transport = 0;
0113 
0114     std::size_t total() const {
0115       return selection + fit + degenerate + transport;
0116     }
0117   } skipped;
0118 
0119   // Loop over all found seeds to estimate track parameters
0120   for (std::size_t iseed = 0; iseed < seeds.size(); ++iseed) {
0121     const auto& seed = seeds[iseed];
0122     if (seed.spacePoints().size() < 3) {
0123       ACTS_WARNING("Seed " << iseed << " has less than 3 space points, skip");
0124       continue;
0125     }
0126 
0127     const Acts::ParticleHypothesis hypothesis =
0128         inputParticleHypotheses != nullptr
0129             ? inputParticleHypotheses->at(iseed)
0130             : m_estimator.config().particleHypothesis;
0131 
0132     const Acts::Result<TrackParameters, SeedParamsEstimator::Failure> estimate =
0133         m_estimator.estimate(
0134             ctx.recoGeoContext, ctx.magFieldContext, cache, seed, hypothesis,
0135             inputFreeParameters != nullptr ? &inputFreeParameters->at(iseed)
0136                                            : nullptr,
0137             SeedParamsEstimator::Anchor::First);
0138     if (!estimate.ok()) {
0139       using enum SeedParamsEstimator::Failure;
0140       switch (estimate.error()) {
0141         case FieldLookup:
0142           return ProcessCode::ABORT;
0143         case SpacePointSelection:
0144           ++skipped.selection;
0145           break;
0146         case Fit:
0147           ++skipped.fit;
0148           break;
0149         case Degenerate:
0150           ++skipped.degenerate;
0151           break;
0152         case Transport:
0153           ++skipped.transport;
0154           break;
0155         case MissingSurface:
0156         case WeakField:
0157           break;
0158       }
0159       ACTS_DEBUG("Seed " << iseed << " has no estimate, skip");
0160       continue;
0161     }
0162 
0163     const TrackParameters& trackParams =
0164         trackParameters.emplace_back(*estimate);
0165     ACTS_VERBOSE("Estimated track parameters: " << trackParams);
0166     if (m_outputSeeds.isInitialized()) {
0167       auto newSp = outputSeeds.createSeed();
0168       // TODO copy shorthand
0169       newSp.assignSpacePointIndices(seed.spacePointIndices());
0170       newSp.quality() = seed.quality();
0171       newSp.vertexZ() = seed.vertexZ();
0172     }
0173     if (m_outputTracks.isInitialized() && inputTracks != nullptr) {
0174       outputTracks.push_back(inputTracks->at(iseed));
0175     }
0176   }
0177 
0178   ACTS_DEBUG("Estimated " << trackParameters.size() << " track parameters from "
0179                           << seeds.size() << " seeds");
0180   if (skipped.total() > 0) {
0181     ACTS_DEBUG(
0182         "Skipped " << skipped.selection
0183                    << " seeds without a space point selection, " << skipped.fit
0184                    << " without a fit, " << skipped.degenerate
0185                    << " with a degenerate estimate and " << skipped.transport
0186                    << " without a transport to the surface");
0187   }
0188 
0189   m_outputTrackParameters(ctx, std::move(trackParameters));
0190   if (m_outputSeeds.isInitialized()) {
0191     m_outputSeeds(ctx, std::move(outputSeeds));
0192   }
0193 
0194   if (m_outputTracks.isInitialized()) {
0195     m_outputTracks(ctx, std::move(outputTracks));
0196   }
0197 
0198   return ProcessCode::SUCCESS;
0199 }
0200 
0201 }  // namespace ActsExamples