ImpactPointEstimator.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ImpactPointEstimator.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2019-2023 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/EventData/TrackParameters.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/MagneticField/MagneticFieldContext.hpp"
#include "Acts/MagneticField/MagneticFieldProvider.hpp"
#include "Acts/MagneticField/NullBField.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Utilities/Result.hpp"
#include "Acts/Vertexing/TrackAtVertex.hpp"
#include "Acts/Vertexing/Vertex.hpp"

namespace Acts {

struct ImpactParametersAndSigma {
  // Impact parameters ...
  double d0 = 0.;
  double z0 = 0.;
  // ... and their standard deviations wrt a vertex, e.g.:
  // sigmaD0 = sqrt(Var(X) + Var(Y) + Var(d0)),
  // where X and Y are the x- and y-coordinate of the vertex
  double sigmaD0 = 0.;
  double sigmaZ0 = 0.;
  // Absolute difference in time between the vertex and the track at the 2D PCA
  // ...
  std::optional<double> deltaT = std::nullopt;
  // ... and standard deviation wrt a vertex
  std::optional<double> sigmaDeltaT = std::nullopt;
};

template <typename input_track_t, typename propagator_t,
          typename propagator_options_t = PropagatorOptions<>>
class ImpactPointEstimator {
 public:
  struct State {
    State(MagneticFieldProvider::Cache fieldCacheIn)
        : fieldCache(std::move(fieldCacheIn)) {}
    MagneticFieldProvider::Cache fieldCache;
  };

  struct Config {
    Config(std::shared_ptr<const MagneticFieldProvider> bIn,
           std::shared_ptr<const propagator_t> prop)
        : bField(std::move(bIn)), propagator(std::move(prop)) {}

    Config(std::shared_ptr<propagator_t> prop)
        : bField{std::make_shared<NullBField>()}, propagator(std::move(prop)) {}

    std::shared_ptr<const MagneticFieldProvider> bField;
    std::shared_ptr<const propagator_t> propagator;
    int maxIterations = 20;
    double precision = 1.e-10;
  };

  ImpactPointEstimator(const Config& cfg) : m_cfg(cfg) {}

  Result<double> calculateDistance(const GeometryContext& gctx,
                                   const BoundTrackParameters& trkParams,
                                   const Vector3& vtxPos, State& state) const;

  Result<BoundTrackParameters> estimate3DImpactParameters(
      const GeometryContext& gctx, const Acts::MagneticFieldContext& mctx,
      const BoundTrackParameters& trkParams, const Vector3& vtxPos,
      State& state) const;

  template <unsigned int nDim>
  Result<double> getVertexCompatibility(
      const GeometryContext& gctx, const BoundTrackParameters* trkParams,
      const ActsVector<nDim>& vertexPos) const;

  template <unsigned int nDim>
  Result<std::pair<Acts::ActsVector<nDim>, Acts::Vector3>>
  getDistanceAndMomentum(const GeometryContext& gctx,
                         const BoundTrackParameters& trkParams,
                         const ActsVector<nDim>& vtxPos, State& state) const;

  Result<ImpactParametersAndSigma> getImpactParameters(
      const BoundTrackParameters& track, const Vertex<input_track_t>& vtx,
      const GeometryContext& gctx, const MagneticFieldContext& mctx,
      bool calculateTimeIP = false) const;

  Result<std::pair<double, double>> getLifetimeSignOfTrack(
      const BoundTrackParameters& track, const Vertex<input_track_t>& vtx,
      const Acts::Vector3& direction, const GeometryContext& gctx,
      const MagneticFieldContext& mctx) const;

  Result<double> get3DLifetimeSignOfTrack(
      const BoundTrackParameters& track, const Vertex<input_track_t>& vtx,
      const Acts::Vector3& direction, const GeometryContext& gctx,
      const MagneticFieldContext& mctx) const;

 private:
  const Config m_cfg;

  Result<double> performNewtonOptimization(const Vector3& helixCenter,
                                           const Vector3& vtxPos, double phi,
                                           double theta, double rho) const;
};

}  // namespace Acts

#include "Acts/Vertexing/ImpactPointEstimator.ipp"