TrackFindingBaseAlg.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
namespace ActsTrk {
  template <class HandleArrayKeyType, class ContainerType>
  StatusCode TrackFindingBaseAlg::getContainersFromKeys(
      const EventContext &ctx,
      HandleArrayKeyType &handleKeyArray,
      std::vector<const ContainerType *> &outputContainers,
      std::size_t &sum) const {
    outputContainers.reserve(handleKeyArray.size());
    for (const auto &handleKey : handleKeyArray) {
      ATH_MSG_DEBUG("Reading input collection with key " << handleKey.key());
      auto handle = SG::makeHandle(handleKey, ctx);
      ATH_CHECK(handle.isValid());
      outputContainers.push_back(handle.cptr());
      ATH_MSG_DEBUG("Retrieved " << outputContainers.back()->size()
                                 << " input elements from key " << handle.key());
      sum += outputContainers.back()->size();
    }
 
    return StatusCode::SUCCESS;
  }
 
  template <class MeasurementSource>
  std::variant<std::unique_ptr<Acts::BoundTrackParameters>, TrackFindingBaseAlg::EStat> TrackFindingBaseAlg::doRefit(
      const MeasurementSource &measurement,
      const Acts::BoundTrackParameters &initialParameters,
      const DetectorContextHolder &detContext,
      const bool paramsAtOutermostSurface) const {
    // Perform KF before CKF
    const Acts::Surface* targetSurface = nullptr;
    // get the proper surface
    if (not paramsAtOutermostSurface) {
      // inner-most surface
      targetSurface = m_unalibMeasSurfAcc.get(measurement.sp().front()->measurements().front());
    } else {
      // outer-most surface
      targetSurface = m_unalibMeasSurfAcc.get(measurement.sp().back()->measurements().back());
    }
    if (not targetSurface) {
      ATH_MSG_WARNING("Could not identify the target surface for fitting the provided seed");
      return kNSeedRefitFailure;
    }
    const auto fittedSeedCollection = m_fitterTool->fit(measurement, initialParameters,
                                                        detContext.geometry, detContext.magField, detContext.calib,
                                                        *targetSurface);
    if (not fittedSeedCollection) {
      ATH_MSG_VERBOSE("KF fit failure");
      return kNSeedRefitFailure;
    }
    if (fittedSeedCollection->size() != 1) {
      ATH_MSG_WARNING("KF produced " << fittedSeedCollection->size() << " tracks but should produce 1!");
      return kNSeedRefitFailure;
    }
    const auto fittedSeed = fittedSeedCollection->getTrack(0);
 
    // get the track state at the beginning of the track, where we started
    std::optional<typename decltype(fittedSeed)::ConstTrackStateProxy> trackState {std::nullopt};
    if (paramsAtOutermostSurface) {
      trackState = fittedSeed.outermostTrackState();
    } else {
      trackState = fittedSeed.innermostTrackState();
      if (!trackState) {
        // if the track is not forward linked (fixed by #5666), then we need to search back to the innermost track state
        for (auto st : fittedSeed.trackStatesReversed()) {
          trackState = st;
        }
      }
    }
 
    if (!trackState) {
      ATH_MSG_VERBOSE("Missing "
                      << (paramsAtOutermostSurface ? "outermost" : "innermost")
                      << " track state");
      return kNSeedRefitFailure;
    }
    const auto boundParameters = fittedSeed.createParametersFromState(trackState.value());
 
    // Check pTmin requirement
    const double etaSeed = -std::log(std::tan(0.5 * boundParameters.parameters()[Acts::eBoundTheta]));
    const auto &cutSet = getCuts(etaSeed);
    if (boundParameters.transverseMomentum() < cutSet.ptMin * m_seedRefitPtMinFactor) {
      ATH_MSG_VERBOSE("min pt requirement not satisfied after param refinement: pt min is " << cutSet.ptMin << " but Refined params have pt of " << boundParameters.transverseMomentum());
      return kNRejectedRefinedSeeds;
    }
 
    // Return updated parameters
    return std::make_unique<Acts::BoundTrackParameters>(boundParameters);
  };
}  // namespace ActsTrk