d1/dd6/ImpactPointEstimator_8hpp_source.html

// 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 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 BoundParameters& trkParams,

                                     const Vector3D& vtxPos) const;


  Result<std::unique_ptr<const BoundParameters>> estimate3DImpactParameters(

      const GeometryContext& gctx, const Acts::MagneticFieldContext& mctx,

      const BoundParameters& trkParams, const Vector3D& vtxPos) const;


  Result<double> get3dVertexCompatibility(const GeometryContext& gctx,

                                          const BoundParameters* trkParams,

                                          const Vector3D& vertexPos) const;


  Result<ImpactParametersAndSigma> estimateImpactParameters(

      const BoundParameters& 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 BoundParameters& trkParams,

                                      const Vector3D& vtxPos, Vector3D& deltaR,

                                      Vector3D& momDir) const;

};


}  // namespace Acts


#include "Acts/Vertexing/ImpactPointEstimator.ipp"