Vertexing/src/IterativeVertexFinderAlgorithm.cpp

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/Vertexing/IterativeVertexFinderAlgorithm.hpp"
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Propagator/SympyStepper.hpp"
0013 #include "Acts/Propagator/VoidNavigator.hpp"
0014 #include "Acts/Utilities/Logger.hpp"
0015 #include "Acts/Utilities/Result.hpp"
0016 #include "Acts/Vertexing/IterativeVertexFinder.hpp"
0017 #include "Acts/Vertexing/TrackAtVertex.hpp"
0018 #include "Acts/Vertexing/Vertex.hpp"
0019 #include "ActsExamples/Framework/AlgorithmContext.hpp"
0020
0021 #include <ostream>
0022 #include <stdexcept>
0023 #include <system_error>
0024
0025 #include "VertexingHelpers.hpp"
0026
0027 namespace ActsExamples {
0028
0029 IterativeVertexFinderAlgorithm::IterativeVertexFinderAlgorithm(
0030     const Config& config, std::unique_ptr<const Acts::Logger> logger)
0031     : IAlgorithm("IterativeVertexFinder", std::move(logger)), m_cfg(config) {
0032   if (m_cfg.inputTrackParameters.empty()) {
0033     throw std::invalid_argument("Missing input track parameter collection");
0034   }
0035   if (m_cfg.outputProtoVertices.empty()) {
0036     throw std::invalid_argument("Missing output proto vertices collection");
0037   }
0038   if (m_cfg.outputVertices.empty()) {
0039     throw std::invalid_argument("Missing output vertices collection");
0040   }
0041
0042   m_inputTrackParameters.initialize(m_cfg.inputTrackParameters);
0043   m_outputProtoVertices.initialize(m_cfg.outputProtoVertices);
0044   m_outputVertices.initialize(m_cfg.outputVertices);
0045 }
0046
0047 ProcessCode IterativeVertexFinderAlgorithm::execute(
0048     const AlgorithmContext& ctx) const {
0049   // retrieve input tracks and convert into the expected format
0050
0051   const auto& inputTrackParameters = m_inputTrackParameters(ctx);
0052   // TODO change this from pointers to tracks parameters to actual tracks
0053   auto inputTracks = makeInputTracks(inputTrackParameters);
0054
0055   if (inputTrackParameters.size() != inputTracks.size()) {
0056     ACTS_ERROR("Input track containers do not align: "
0057                << inputTrackParameters.size() << " != " << inputTracks.size());
0058   }
0059
0060   for (const auto& trk : inputTrackParameters) {
0061     if (trk.covariance() && trk.covariance()->determinant() <= 0) {
0062       // actually we should consider this as an error but I do not want the CI
0063       // to fail
0064       ACTS_WARNING("input track " << trk << " has det(cov) = "
0065                                   << trk.covariance()->determinant());
0066     }
0067   }
0068
0069   // Set up SympyStepper
0070   Acts::SympyStepper stepper(m_cfg.bField);
0071
0072   // Set up propagator with void navigator
0073   auto propagator = std::make_shared<Propagator>(
0074       stepper, Acts::VoidNavigator{}, logger().cloneWithSuffix("Propagator"));
0075   // Setup the vertex fitter
0076   Fitter::Config vertexFitterCfg;
0077   vertexFitterCfg.extractParameters
0078       .connect<&Acts::InputTrack::extractParameters>();
0079   // Setup the track linearizer
0080   Linearizer::Config linearizerCfg;
0081   linearizerCfg.bField = m_cfg.bField;
0082   linearizerCfg.propagator = propagator;
0083   Linearizer linearizer(linearizerCfg,
0084                         logger().cloneWithSuffix("HelicalTrackLinearizer"));
0085
0086   vertexFitterCfg.trackLinearizer.connect<&Linearizer::linearizeTrack>(
0087       &linearizer);
0088   Fitter vertexFitter(vertexFitterCfg,
0089                       logger().cloneWithSuffix("FullBilloirVertexFitter"));
0090
0091   // Setup the seed finder
0092   Acts::ImpactPointEstimator::Config ipEstCfg(m_cfg.bField, propagator);
0093   Acts::ImpactPointEstimator ipEst(
0094       ipEstCfg, logger().cloneWithSuffix("ImpactPointEstimator"));
0095
0096   Acts::GaussianTrackDensity::Config densityCfg;
0097   densityCfg.extractParameters.connect<&Acts::InputTrack::extractParameters>();
0098   auto seeder = std::make_shared<Seeder>(
0099       Seeder::Config{Acts::GaussianTrackDensity(densityCfg)});
0100   // Set up the actual vertex finder
0101   Finder::Config finderCfg(std::move(vertexFitter), seeder, ipEst);
0102   finderCfg.trackLinearizer.connect<&Linearizer::linearizeTrack>(&linearizer);
0103
0104   finderCfg.maxVertices = m_cfg.maxIterations;
0105   finderCfg.reassignTracksAfterFirstFit = false;
0106   finderCfg.extractParameters.connect<&Acts::InputTrack::extractParameters>();
0107   finderCfg.field = m_cfg.bField;
0108   Finder finder(std::move(finderCfg), logger().clone());
0109   Acts::IVertexFinder::State state{std::in_place_type<Finder::State>,
0110                                    *m_cfg.bField, ctx.magFieldContext};
0111   Options finderOpts(ctx.recoGeoContext, ctx.magFieldContext);
0112
0113   // find vertices
0114   auto result = finder.find(inputTracks, finderOpts, state);
0115
0116   VertexContainer vertices;
0117   if (result.ok()) {
0118     vertices = std::move(result.value());
0119   } else {
0120     ACTS_ERROR("Error in vertex finder: " << result.error().message());
0121   }
0122
0123   // show some debug output
0124   ACTS_DEBUG("Found " << vertices.size() << " vertices in event");
0125   for (const auto& vtx : vertices) {
0126     ACTS_DEBUG("Found vertex at " << vtx.fullPosition().transpose() << " with "
0127                                   << vtx.tracks().size() << " tracks.");
0128   }
0129
0130   // store proto vertices extracted from the found vertices
0131   m_outputProtoVertices(ctx, makeProtoVertices(inputTracks, vertices));
0132
0133   // store found vertices
0134   m_outputVertices(ctx, std::move(vertices));
0135
0136   return ProcessCode::SUCCESS;
0137 }
0138
0139 }  // namespace ActsExamples