TrackFitting/src/TrackFittingAlgorithm.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/TrackFitting/TrackFittingAlgorithm.hpp"
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/EventData/GenericBoundTrackParameters.hpp"
0013 #include "Acts/EventData/SourceLink.hpp"
0014 #include "Acts/EventData/TrackProxy.hpp"
0015 #include "Acts/EventData/VectorMultiTrajectory.hpp"
0016 #include "Acts/EventData/VectorTrackContainer.hpp"
0017 #include "Acts/Surfaces/PerigeeSurface.hpp"
0018 #include "Acts/Surfaces/Surface.hpp"
0019 #include "Acts/Utilities/Logger.hpp"
0020 #include "Acts/Utilities/Result.hpp"
0021 #include "ActsExamples/EventData/IndexSourceLink.hpp"
0022 #include "ActsExamples/EventData/Measurement.hpp"
0023 #include "ActsExamples/EventData/MeasurementCalibration.hpp"
0024 #include "ActsExamples/Framework/AlgorithmContext.hpp"
0025 #include "ActsExamples/TrackFitting/TrackFitterFunction.hpp"
0026
0027 #include <cstddef>
0028 #include <ostream>
0029 #include <stdexcept>
0030 #include <system_error>
0031 #include <utility>
0032 #include <vector>
0033
0034 namespace ActsExamples {
0035
0036 TrackFittingAlgorithm::TrackFittingAlgorithm(Config config,
0037                                              Acts::Logging::Level level)
0038     : IAlgorithm("TrackFittingAlgorithm", level), m_cfg(std::move(config)) {
0039   if (m_cfg.inputMeasurements.empty()) {
0040     throw std::invalid_argument("Missing input measurement collection");
0041   }
0042   if (m_cfg.inputProtoTracks.empty()) {
0043     throw std::invalid_argument("Missing input proto tracks collection");
0044   }
0045   if (m_cfg.inputInitialTrackParameters.empty()) {
0046     throw std::invalid_argument(
0047         "Missing input initial track parameters collection");
0048   }
0049   if (m_cfg.outputTracks.empty()) {
0050     throw std::invalid_argument("Missing output tracks collection");
0051   }
0052   if (!m_cfg.calibrator) {
0053     throw std::invalid_argument("Missing calibrator");
0054   }
0055   if (m_cfg.inputClusters.empty() && m_cfg.calibrator->needsClusters()) {
0056     throw std::invalid_argument("The configured calibrator needs clusters");
0057   }
0058
0059   m_inputMeasurements.initialize(m_cfg.inputMeasurements);
0060   m_inputProtoTracks.initialize(m_cfg.inputProtoTracks);
0061   m_inputInitialTrackParameters.initialize(m_cfg.inputInitialTrackParameters);
0062   m_inputClusters.maybeInitialize(m_cfg.inputClusters);
0063   m_outputTracks.initialize(m_cfg.outputTracks);
0064 }
0065
0066 ProcessCode TrackFittingAlgorithm::execute(const AlgorithmContext& ctx) const {
0067   // Read input data
0068   const auto& measurements = m_inputMeasurements(ctx);
0069   const auto& protoTracks = m_inputProtoTracks(ctx);
0070   const auto& initialParameters = m_inputInitialTrackParameters(ctx);
0071
0072   const ClusterContainer* clusters =
0073       m_inputClusters.isInitialized() ? &m_inputClusters(ctx) : nullptr;
0074
0075   ACTS_DEBUG("Input measurements: " << measurements.size());
0076   ACTS_DEBUG("Input proto tracks: " << protoTracks.size());
0077   ACTS_DEBUG("Input initial parameters: " << initialParameters.size());
0078   ACTS_DEBUG("Input clusters: " << (clusters ? clusters->size() : 0));
0079
0080   // Consistency cross checks
0081   if (protoTracks.size() != initialParameters.size()) {
0082     ACTS_FATAL("Inconsistent number of proto tracks and parameters "
0083                << protoTracks.size() << " vs " << initialParameters.size());
0084     return ProcessCode::ABORT;
0085   }
0086
0087   // Construct a perigee surface as the target surface
0088   auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
0089       Acts::Vector3{0., 0., 0.});
0090
0091   // Measurement calibrator must be instantiated here, because we need the
0092   // measurements to construct it. The other extensions are hold by the
0093   // fit-function-object
0094   MeasurementCalibratorAdapter calibrator(*(m_cfg.calibrator), measurements,
0095                                           clusters);
0096
0097   TrackFitterFunction::GeneralFitterOptions options{
0098       ctx.geoContext,
0099       ctx.magFieldContext,
0100       ctx.calibContext,
0101       pSurface.get(),
0102       Acts::PropagatorPlainOptions(ctx.geoContext, ctx.magFieldContext),
0103       false};
0104
0105   auto trackContainer = std::make_shared<Acts::VectorTrackContainer>();
0106   auto trackStateContainer = std::make_shared<Acts::VectorMultiTrajectory>();
0107   TrackContainer tracks(trackContainer, trackStateContainer);
0108
0109   // reserve space for the track containers
0110   // simply assume 30 states per track for now
0111   trackContainer->reserve(protoTracks.size());
0112   trackStateContainer->reserve(protoTracks.size() * 30);
0113
0114   // Perform the fit for each input track
0115   std::vector<Acts::SourceLink> trackSourceLinks;
0116   for (std::size_t itrack = 0; itrack < protoTracks.size(); ++itrack) {
0117     // Check if you are not in picking mode
0118     if (m_cfg.pickTrack > -1 &&
0119         static_cast<std::size_t>(m_cfg.pickTrack) != itrack) {
0120       continue;
0121     }
0122
0123     // The list of hits and the initial start parameters
0124     const auto& protoTrack = protoTracks[itrack];
0125     const auto& initialParams = initialParameters[itrack];
0126
0127     // We can have empty tracks which must give empty fit results so the number
0128     // of entries in input and output containers matches.
0129     if (protoTrack.empty()) {
0130       ACTS_WARNING("Empty track " << itrack << " found.");
0131       continue;
0132     }
0133
0134     ACTS_VERBOSE("Initial 4 position: "
0135                  << initialParams.fourPosition(ctx.geoContext).transpose());
0136     ACTS_VERBOSE(
0137         "Initial direction: " << initialParams.direction().transpose());
0138     ACTS_VERBOSE("Initial momentum: " << initialParams.absoluteMomentum());
0139
0140     // Clear & reserve the right size
0141     trackSourceLinks.clear();
0142     trackSourceLinks.reserve(protoTrack.size());
0143
0144     // Fill the source links via their indices from the container
0145     for (auto measIndex : protoTrack) {
0146       ConstVariableBoundMeasurementProxy measurement =
0147           measurements.getMeasurement(measIndex);
0148       IndexSourceLink sourceLink(measurement.geometryId(), measIndex);
0149       trackSourceLinks.push_back(Acts::SourceLink(sourceLink));
0150     }
0151
0152     ACTS_VERBOSE("Invoke fitter for track " << itrack);
0153     auto result = (*m_cfg.fit)(trackSourceLinks, initialParams, options,
0154                                calibrator, tracks);
0155
0156     if (result.ok()) {
0157       // Get the fit output object
0158       const auto& track = result.value();
0159       if (track.hasReferenceSurface()) {
0160         ACTS_VERBOSE("Fitted parameters for track " << itrack);
0161         ACTS_VERBOSE("  " << track.parameters().transpose());
0162         ACTS_VERBOSE("Measurements: (prototrack->track): "
0163                      << protoTrack.size() << " -> " << track.nMeasurements());
0164       } else {
0165         ACTS_VERBOSE("No fitted parameters for track " << itrack);
0166       }
0167     } else {
0168       ACTS_WARNING("Fit failed for track "
0169                    << itrack << " with error: " << result.error() << ", "
0170                    << result.error().message());
0171     }
0172   }
0173
0174   if (logger().doPrint(Acts::Logging::DEBUG)) {
0175     std::stringstream ss;
0176     trackStateContainer->statistics().toStream(ss);
0177     ACTS_DEBUG(ss.str());
0178   }
0179
0180   ConstTrackContainer constTracks{
0181       std::make_shared<Acts::ConstVectorTrackContainer>(
0182           std::move(*trackContainer)),
0183       std::make_shared<Acts::ConstVectorMultiTrajectory>(
0184           std::move(*trackStateContainer))};
0185
0186   m_outputTracks(ctx, std::move(constTracks));
0187   return ProcessCode::SUCCESS;
0188 }
0189
0190 }  // namespace ActsExamples