AnalyticalPropagator.h

Go to the documentation of this file.

#ifndef _COMMONRECO_ANALYTICALPROPAGATOR_H_
#define _COMMONRECO_ANALYTICALPROPAGATOR_H_

#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "FWCore/Utilities/interface/Visibility.h"

#include <cmath>
#include <cfloat>

class Surface;
class Cylinder;
class Plane;
class HelixPlaneCrossing;
class MagneticField;

class AnalyticalPropagator final : public Propagator {
public:
  AnalyticalPropagator(const MagneticField* field,
                       PropagationDirection dir = alongMomentum,
                       float maxDPhi = 1.6,
                       bool isOld = true)
      : Propagator(dir),
        theMaxDPhi2(maxDPhi * maxDPhi),
        theMaxDBzRatio(0.5),
        theField(field),
        isOldPropagationType(isOld) {}

  ~AnalyticalPropagator() override {}

  //
  // use base class methods where necessary:
  // - propagation from TrajectoryStateOnSurface
  //     (will use propagation from FreeTrajectoryState)
  // - propagation to general Surface
  //     (will use specialised methods for planes or cylinders)
  //
  using Propagator::propagate;
  using Propagator::propagateWithPath;

private:
  std::pair<TrajectoryStateOnSurface, double> propagateWithPath(const FreeTrajectoryState& fts,
                                                                const Plane& plane) const override;

  std::pair<TrajectoryStateOnSurface, double> propagateWithPath(const FreeTrajectoryState& fts,
                                                                const Cylinder& cylinder) const override;

public:
  bool setMaxDirectionChange(float phiMax) override {
    theMaxDPhi2 = phiMax * phiMax;
    return true;
  }

  AnalyticalPropagator* clone() const override { return new AnalyticalPropagator(*this); }

  void setMaxRelativeChangeInBz(const float maxDBz) { theMaxDBzRatio = maxDBz; }

private:
  std::pair<TrajectoryStateOnSurface, double> propagatedStateWithPath(const FreeTrajectoryState& fts,
                                                                      const Surface& surface,
                                                                      const GlobalTrajectoryParameters& gtp,
                                                                      const double& s) const dso_internal;

  bool propagateParametersOnCylinder(const FreeTrajectoryState& fts,
                                     const Cylinder& cylinder,
                                     GlobalPoint& x,
                                     GlobalVector& p,
                                     double& s) const dso_internal;

  bool propagateParametersOnPlane(const FreeTrajectoryState& fts,
                                  const Plane& plane,
                                  GlobalPoint& x,
                                  GlobalVector& p,
                                  double& s) const dso_internal;

  bool propagateWithLineCrossing(const GlobalPoint&, const GlobalVector&, const Plane&, GlobalPoint&, double&) const
      dso_internal;
  bool propagateWithLineCrossing(const GlobalPoint&, const GlobalVector&, const Cylinder&, GlobalPoint&, double&) const
      dso_internal;
  bool propagateWithHelixCrossing(
      HelixPlaneCrossing&, const Plane&, const float, GlobalPoint&, GlobalVector&, double& s) const dso_internal;

  const MagneticField* magneticField() const override { return theField; }

private:
  typedef std::pair<TrajectoryStateOnSurface, double> TsosWP;
  float theMaxDPhi2;
  float theMaxDBzRatio;
  const MagneticField* theField;
  bool isOldPropagationType;
};

#endif