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 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/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 {
  double IPd0 = 0.;
  double IPz0 = 0.;
  double IPz0SinTheta = 0.;
  double sigmad0 = 0.;
  double sigmaz0 = 0.;
  double sigmaz0SinTheta = 0.;
  double PVsigmad0 = 0.;
  double PVsigmaz0 = 0.;
  double PVsigmaz0SinTheta = 0.;
};

template <typename input_track_t, typename propagator_t,
          typename propagator_options_t = PropagatorOptions<>>
class ImpactPointEstimator {
  using BField_t = typename propagator_t::Stepper::BField;

 public:
  struct State {
    State(const Acts::MagneticFieldContext& mctx) : fieldCache(mctx) {}
    typename BField_t::Cache fieldCache;
  };

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

    template <typename T = BField_t,
              std::enable_if_t<std::is_same<T, NullBField>::value, int> = 0>
    Config(std::shared_ptr<propagator_t> prop) : propagator(std::move(prop)) {}

    BField_t bField;
    std::shared_ptr<propagator_t> propagator;
    int maxIterations = 20;
    double precision = 1.e-10;
    double minQoP = 1e-15;
    double maxRho = 1e+15;
  };

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

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

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

  Result<double> get3dVertexCompatibility(const GeometryContext& gctx,
                                          const BoundTrackParameters* trkParams,
                                          const Vector3D& vertexPos) const;

  Result<ImpactParametersAndSigma> estimateImpactParameters(
      const BoundTrackParameters& track, const Vertex<input_track_t>& vtx,
      const GeometryContext& gctx, const MagneticFieldContext& mctx) const;

 private:
  const Config m_cfg;

  Result<double> performNewtonApproximation(const Vector3D& trkPos,
                                            const Vector3D& vtxPos, double phi,
                                            double theta, double r) const;

  Result<void> getDistanceAndMomentum(const GeometryContext& gctx,
                                      const BoundTrackParameters& trkParams,
                                      const Vector3D& vtxPos, Vector3D& deltaR,
                                      Vector3D& momDir, State& state) const;
};

}  // namespace Acts

#include "Acts/Vertexing/ImpactPointEstimator.ipp"