StraightLinePropagator Class Reference

#include <StraightLinePropagator.h>

Inheritance diagram for StraightLinePropagator:

Public Member Functions
StraightLinePropagator *	clone () const override
const MagneticField *	magneticField () const override
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const final
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const final
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const final
template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const
	Propagate to PCA to a line (given by 2 points) given a starting point. More...
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const
	Propagate to PCA to a line (given by beamSpot position and slope) given a starting point. More...
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const=0
std::pair< TSOS, double >	propagateWithPath (const FreeTrajectoryState &fts, const Plane &surface) const override
std::pair< TSOS, double >	propagateWithPath (const FreeTrajectoryState &fts, const Cylinder &surface) const override
	StraightLinePropagator (const MagneticField *field, PropagationDirection aDir=alongMomentum)
	~StraightLinePropagator () override
Public Member Functions inherited from Propagator
template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const final
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const final
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const
	Propagate to PCA to a line (given by 2 points) given a starting point. More...
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const
	Propagate to PCA to a line (given by beamSpot position and slope) given a starting point. More...
virtual PropagationDirection	propagationDirection () const final
	Propagator (PropagationDirection dir=alongMomentum)
virtual bool	setMaxDirectionChange (float phiMax)
virtual void	setPropagationDirection (PropagationDirection dir)
virtual	~Propagator ()

Private Types
typedef FreeTrajectoryState	FTS
typedef TrajectoryStateOnSurface	TSOS

Private Member Functions
AlgebraicMatrix55	jacobian (double &s) const
TrajectoryStateOnSurface	propagatedState (const FreeTrajectoryState &fts, const Surface &surface, const AlgebraicMatrix55 &jacobian, const GlobalPoint &x, const GlobalVector &p) const
TrajectoryStateOnSurface	propagatedState (const FreeTrajectoryState &fts, const Surface &surface, const AlgebraicMatrix55 &jacobian, const LocalPoint &x, const LocalVector &p) const
bool	propagateParametersOnCylinder (const FreeTrajectoryState &fts, const Cylinder &cylinder, GlobalPoint &x, GlobalVector &p, double &s) const
bool	propagateParametersOnPlane (const FreeTrajectoryState &fts, const Plane &plane, LocalPoint &x, LocalVector &p, double &s) const

Private Attributes
const MagneticField *	theField

Detailed Description

As the name indicates, propagates track parameters according to a straight line model. Intended for test beams without magnetic field and similar cases.

Warning

The errors are NOT propagated.

Definition at line 16 of file StraightLinePropagator.h.

Member Typedef Documentation

FTS

typedef FreeTrajectoryState StraightLinePropagator::FTS

private

Definition at line 18 of file StraightLinePropagator.h.

TSOS

typedef TrajectoryStateOnSurface StraightLinePropagator::TSOS

private

Definition at line 19 of file StraightLinePropagator.h.

Constructor & Destructor Documentation

StraightLinePropagator()

StraightLinePropagator::StraightLinePropagator ( const MagneticField *  field, PropagationDirection  aDir = alongMomentum  )

inline

Definition at line 22 of file StraightLinePropagator.h.

Referenced by clone().

      : Propagator(aDir), theField(field) {}

~StraightLinePropagator()

StraightLinePropagator::~StraightLinePropagator ( )

inlineoverride

Definition at line 25 of file StraightLinePropagator.h.

{}

Member Function Documentation

clone()

StraightLinePropagator* StraightLinePropagator::clone ( void  ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 34 of file StraightLinePropagator.h.

References StraightLinePropagator().

{ return new StraightLinePropagator(*this); }

jacobian()

AlgebraicMatrix55 StraightLinePropagator::jacobian ( double &  s ) const

private

Definition at line 86 of file StraightLinePropagator.cc.

References alongMomentum, DeadROC_duringRun::dir, dqmiolumiharvest::j, Propagator::propagationDirection(), and alignCSCRings::s.

Referenced by propagatedState(), and propagateWithPath().

                                                                  {
  //Jacobian for 5*5 local error matrix
  AlgebraicMatrix55 j = AlgebraicMatrixID();  //Jacobian

  double dir = (propagationDirection() == alongMomentum) ? 1. : -1.;
  if (s * dir < 0.)
    return j;

  j(3, 1) = s;
  j(4, 2) = s;

  return j;
}

magneticField()

const MagneticField* StraightLinePropagator::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 36 of file StraightLinePropagator.h.

References theField.

{ return theField; }

propagate() [1/4]

template<typename STA , typename SUR >

TrajectoryStateOnSurface Propagator::propagate ( typename STA  , typename SUR    )

inline

Definition at line 50 of file Propagator.h.

                                                                                 {
    return propagateWithPath(state, surface).first;
  }

propagate() [2/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 109 of file Propagator.h.

                                                                                                                   {
    return propagateWithPath(ftsStart, pDest).first;
  }

propagate() [3/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 112 of file Propagator.h.

                                                                               {
    return propagateWithPath(ftsStart, pDest1, pDest2).first;
  }

propagate() [4/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 117 of file Propagator.h.

                                                                                  {
    return propagateWithPath(ftsStart, beamSpot).first;
  }

propagatedState() [1/2]

TrajectoryStateOnSurface StraightLinePropagator::propagatedState ( const FreeTrajectoryState &  fts, const Surface &  surface, const AlgebraicMatrix55 &  jacobian, const GlobalPoint &  x, const GlobalVector &  p  ) const

private

Definition at line 65 of file StraightLinePropagator.cc.

References FreeTrajectoryState::charge(), FreeTrajectoryState::hasError(), jacobian(), AlCaHLTBitMon_ParallelJobs::p, theField, createJobs::tmp, and x.

Referenced by propagateWithPath().

                                                                                              {
  if (fts.hasError()) {
    // propagate error
    TSOS tmp(fts, surface);
    const AlgebraicSymMatrix55& eLocal = tmp.localError().matrix();
    AlgebraicSymMatrix55 lte = ROOT::Math::Similarity(jacobian, eLocal);
    LocalTrajectoryError eloc(lte);

    TSOS tmp2(tmp.localParameters(), eloc, surface, theField);
    GlobalTrajectoryParameters gtp(x, p, fts.charge(), theField);
    return TSOS(gtp, tmp2.cartesianError(), surface);
  } else {
    // return state without errors
    return TSOS(GlobalTrajectoryParameters(x, p, fts.charge(), theField), surface);
  }
}

propagatedState() [2/2]

TrajectoryStateOnSurface StraightLinePropagator::propagatedState ( const FreeTrajectoryState &  fts, const Surface &  surface, const AlgebraicMatrix55 &  jacobian, const LocalPoint &  x, const LocalVector &  p  ) const

private

Definition at line 46 of file StraightLinePropagator.cc.

References FreeTrajectoryState::charge(), FreeTrajectoryState::hasError(), jacobian(), AlCaHLTBitMon_ParallelJobs::p, theField, createJobs::tmp, and x.

                                                                                             {
  if (fts.hasError()) {
    // propagate error
    TSOS tmp(fts, surface);
    const AlgebraicSymMatrix55& eLocal = tmp.localError().matrix();
    AlgebraicSymMatrix55 lte = ROOT::Math::Similarity(jacobian, eLocal);
    LocalTrajectoryError eloc(lte);
    LocalTrajectoryParameters ltp(x, p, fts.charge());
    return TSOS(ltp, eloc, surface, theField);
  } else {
    // return state without errors
    return TSOS(LocalTrajectoryParameters(x, p, fts.charge()), surface, theField);
  }
}

propagateParametersOnCylinder()

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

private

Definition at line 100 of file StraightLinePropagator.cc.

References alongMomentum, DeadROC_duringRun::dir, dt, FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), Propagator::propagationDirection(), Cylinder::radius(), alignCSCRings::s, Surface::toGlobal(), x, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by propagateWithPath().

                                                                                                {
  GlobalPoint sp = cylinder.toGlobal(LocalPoint(0., 0.));
  if (sp.x() != 0. || sp.y() != 0.) {
    throw PropagationException("Cannot propagate to an arbitrary cylinder");
  }

  x = fts.position();
  p = fts.momentum();
  s = cylinder.radius() - x.perp();

  double dir = (propagationDirection() == alongMomentum) ? 1. : -1.;
  if (s * dir < 0.)
    return false;

  double dt = s / p.perp();
  x = GlobalPoint(x.x() + p.x() * dt, x.y() + p.y() * dt, x.z() + p.z() * dt);

  return true;
}

propagateParametersOnPlane()

bool StraightLinePropagator::propagateParametersOnPlane ( const FreeTrajectoryState &  fts, const Plane &  plane, LocalPoint &  x, LocalVector &  p, double &  s  ) const

private

Definition at line 121 of file StraightLinePropagator.cc.

References FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), alignCSCRings::s, GloballyPositioned< T >::toLocal(), and x.

Referenced by propagateWithPath().

                                                                                        {
  //Do extrapolation in local frame of plane
  //  LocalPoint sp = plane.toLocal(plane.position());
  x = plane.toLocal(fts.position());
  p = plane.toLocal(fts.momentum());
  s = -x.z();  // sp.z() - x.z(); local z of plane always 0

  //double dir = (propagationDirection() == alongMomentum) ? 1. : -1.;
  //if(s*dir < 0.) return false;
  if ((p.x() != 0 || p.y() != 0) && p.z() == 0 && s != 0)
    return false;

  x = LocalPoint(x.x() + (p.x() / p.z()) * s, x.y() + (p.y() / p.z()) * s, x.z() + s);

  return true;
}

propagateWithPath() [1/11]

std::pair< FreeTrajectoryState, double > Propagator::propagateWithPath

Propagate to PCA to a line (given by beamSpot position and slope) given a starting point.

Definition at line 53 of file Propagator.cc.

                                                                                                         {
  throw cms::Exception("Propagator::propagate(FTS,beamSpot) not implemented");
  return std::pair<FreeTrajectoryState, double>();
}

propagateWithPath() [2/11]

std::pair< FreeTrajectoryState, double > Propagator::propagateWithPath

Propagate to PCA to a line (given by 2 points) given a starting point.

Definition at line 47 of file Propagator.cc.

                                                                                               {
  throw cms::Exception("Propagator::propagate(FTS,GlobalPoint,GlobalPoint) not implemented");
  return std::pair<FreeTrajectoryState, double>();
}

propagateWithPath() [3/11]

std::pair< FreeTrajectoryState, double > Propagator::propagateWithPath

implemented by Stepping Helix Propagate to PCA to point given a starting point

Definition at line 42 of file Propagator.cc.

                                                                                               {
  throw cms::Exception("Propagator::propagate(FTS,GlobalPoint) not implemented");
  return std::pair<FreeTrajectoryState, double>();
}

propagateWithPath() [4/11]

std::pair< TrajectoryStateOnSurface, double > Propagator::propagateWithPath

final

The methods propagateWithPath() are identical to the corresponding methods propagate() in what concerns the resulting TrajectoryStateOnSurface, but they provide in addition the exact path length along the trajectory.Only use the generic method if the surface type (plane or cylinder) is not known at the calling point.

Definition at line 10 of file Propagator.cc.

                                                                                                    {
  // try plane first, most probable case (disk "is a" plane too)
  const Plane* bp = dynamic_cast<const Plane*>(&sur);
  if (bp != nullptr)
    return propagateWithPath(state, *bp);

  // if not plane try cylinder
  const Cylinder* bc = dynamic_cast<const Cylinder*>(&sur);
  if (bc != nullptr)
    return propagateWithPath(state, *bc);

  // unknown surface - can't do it!
  throw PropagationException("The surface is neither Cylinder nor Plane");
}

propagateWithPath() [5/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

propagateWithPath() [6/11]

std::pair< TrajectoryStateOnSurface, double > Propagator::propagateWithPath

final

The following three methods are equivalent to the corresponding methods above, but if the starting state is a TrajectoryStateOnSurface, it's better to use it as such rather than use just the FreeTrajectoryState part. It may help some concrete propagators.Only use the generic method if the surface type (plane or cylinder) is not known at the calling point.

Definition at line 26 of file Propagator.cc.

                                                                                                    {
  // try plane first, most probable case (disk "is a" plane too)
  const Plane* bp = dynamic_cast<const Plane*>(&sur);
  if (bp != nullptr)
    return propagateWithPath(state, *bp);

  // if not plane try cylinder
  const Cylinder* bc = dynamic_cast<const Cylinder*>(&sur);
  if (bc != nullptr)
    return propagateWithPath(state, *bc);

  // unknown surface - can't do it!
  throw PropagationException("The surface is neither Cylinder nor Plane");
}

propagateWithPath() [7/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

inline

Definition at line 86 of file Propagator.h.

                                                                                                {
    return propagateWithPath(*tsos.freeState(), sur);
  }

propagateWithPath() [8/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

inline

Definition at line 91 of file Propagator.h.

                                                                                                   {
    return propagateWithPath(*tsos.freeState(), sur);
  }

propagateWithPath() [9/11]

virtual std::pair<TrajectoryStateOnSurface, double> Propagator::propagateWithPath

propagateWithPath() [10/11]

std::pair< TrajectoryStateOnSurface, double > StraightLinePropagator::propagateWithPath ( const FreeTrajectoryState &  fts, const Plane &  surface  ) const

overridevirtual

Implements Propagator.

Definition at line 8 of file StraightLinePropagator.cc.

References FreeTrajectoryState::charge(), FreeTrajectoryState::hasError(), jacobian(), AlCaHLTBitMon_ParallelJobs::p, propagatedState(), propagateParametersOnPlane(), alignCSCRings::s, theField, and x.

                                                                                                                {
  // propagate parameters
  LocalPoint x;
  LocalVector p;
  double s = 0;
  bool parametersOK = propagateParametersOnPlane(fts, plane, x, p, s);
  if (!parametersOK)
    return std::make_pair(TrajectoryStateOnSurface(), 0.);

  // compute propagated state
  if (fts.hasError()) {
    return std::make_pair(propagatedState(fts, plane, jacobian(s), x, p), s);
  } else {
    // return state without errors
    return std::make_pair(TSOS(LocalTrajectoryParameters(x, p, fts.charge()), plane, theField), s);
  }
}

propagateWithPath() [11/11]

std::pair< TrajectoryStateOnSurface, double > StraightLinePropagator::propagateWithPath ( const FreeTrajectoryState &  fts, const Cylinder &  surface  ) const

overridevirtual

Implements Propagator.

Definition at line 27 of file StraightLinePropagator.cc.

References FreeTrajectoryState::charge(), FreeTrajectoryState::hasError(), jacobian(), AlCaHLTBitMon_ParallelJobs::p, propagatedState(), propagateParametersOnCylinder(), alignCSCRings::s, theField, and x.

                                                                                                                      {
  // propagate parameters
  GlobalPoint x;
  GlobalVector p;
  double s = 0;
  bool parametersOK = propagateParametersOnCylinder(fts, cylinder, x, p, s);
  if (!parametersOK)
    return std::make_pair(TrajectoryStateOnSurface(), 0.);

  // compute propagated state
  if (fts.hasError()) {
    return std::make_pair(propagatedState(fts, cylinder, jacobian(s), x, p), s);
  } else {
    // return state without errors
    return std::make_pair(TSOS(GlobalTrajectoryParameters(x, p, fts.charge(), theField), cylinder), s);
  }
}

Member Data Documentation

theField

const MagneticField* StraightLinePropagator::theField

private

Definition at line 39 of file StraightLinePropagator.h.

Referenced by magneticField(), propagatedState(), and propagateWithPath().