GsfPropagatorWithMaterial Class Reference

#include <GsfPropagatorWithMaterial.h>

Inheritance diagram for GsfPropagatorWithMaterial:

Public Types
enum	MaterialLocation { atSource, atDestination, fromDirection }

Public Member Functions
GsfPropagatorWithMaterial *	clone () const override
const FullConvolutionWithMaterial &	convolutionWithMaterial () const
	Access to the convolutor and thus to the material effects. More...
const Propagator &	geometricalPropagator () const
	Access to the geometrical propagator. More...
	GsfPropagatorWithMaterial (const Propagator &Propagator, const GsfMaterialEffectsUpdator &MEUpdator)
	GsfPropagatorWithMaterial (const GsfPropagatorAdapter &Propagator, const FullConvolutionWithMaterial &Convolutor)
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 FreeTrajectoryState &, const Cylinder &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final
virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const=0
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final
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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Cylinder &sur) const
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Plane &sur) const
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Plane &) const override
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Cylinder &) const override
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const override
std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const override
void	setMaterialLocation (const MaterialLocation location)
bool	setMaxDirectionChange (float phiMax) override
void	setPropagationDirection (PropagationDirection dir) override
	~GsfPropagatorWithMaterial () 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< 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	~Propagator ()

Private Types
typedef std::vector< TrajectoryStateOnSurface >	MultiTSOS
typedef std::pair< TrajectoryStateOnSurface, double >	TsosWP

Private Member Functions
TrajectoryStateOnSurface	convoluteStateWithMaterial (const TrajectoryStateOnSurface, const PropagationDirection) const
	Convolution of state with material effects. More...
std::pair< TrajectoryStateOnSurface, double >	convoluteWithMaterial (const std::pair< TrajectoryStateOnSurface, double > &) const
	Convolution of state+path with material effects. More...
bool	materialAtSource () const
	Inclusion of material at the source? More...

Private Attributes
DeepCopyPointerByClone< FullConvolutionWithMaterial >	theConvolutor
DeepCopyPointerByClone< GsfPropagatorAdapter >	theGeometricalPropagator
MaterialLocation	theMaterialLocation

Detailed Description

Propagation including material effects on destination surface for multiple trajectory states. Propagates components independently using a specific propagator for the geometrical part and a GsfMaterialEffectsUpdator to include multiple scattering and energy loss at the destination. The number of components will increase according to the result of the GsfMaterialEffectsUpdator.

Definition at line 23 of file GsfPropagatorWithMaterial.h.

Member Typedef Documentation

MultiTSOS

typedef std::vector<TrajectoryStateOnSurface> GsfPropagatorWithMaterial::MultiTSOS

private

Definition at line 105 of file GsfPropagatorWithMaterial.h.

TsosWP

typedef std::pair<TrajectoryStateOnSurface, double> GsfPropagatorWithMaterial::TsosWP

private

Definition at line 104 of file GsfPropagatorWithMaterial.h.

Member Enumeration Documentation

MaterialLocation

enum GsfPropagatorWithMaterial::MaterialLocation

Enumerator
atSource
atDestination
fromDirection

Definition at line 64 of file GsfPropagatorWithMaterial.h.

{ atSource, atDestination, fromDirection };

Constructor & Destructor Documentation

GsfPropagatorWithMaterial() [1/2]

GsfPropagatorWithMaterial::GsfPropagatorWithMaterial	(	const Propagator &	Propagator,
		const GsfMaterialEffectsUpdator &	MEUpdator
	)

Constructor with explicit single state propagator and material effects objects.

Definition at line 11 of file GsfPropagatorWithMaterial.cc.

Referenced by clone().

    : Propagator(aPropagator.propagationDirection()),
      theGeometricalPropagator(new GsfPropagatorAdapter(aPropagator)),
      theConvolutor(new FullConvolutionWithMaterial(aMEUpdator)),
      theMaterialLocation(atDestination) {}

GsfPropagatorWithMaterial() [2/2]

GsfPropagatorWithMaterial::GsfPropagatorWithMaterial	(	const GsfPropagatorAdapter &	Propagator,
		const FullConvolutionWithMaterial &	Convolutor
	)

Constructor with explicit multi state propagator and convolutor.

Definition at line 18 of file GsfPropagatorWithMaterial.cc.

    : Propagator(aGsfPropagator.propagationDirection()),
      theGeometricalPropagator(aGsfPropagator.clone()),
      theConvolutor(aConvolutor.clone()),
      theMaterialLocation(atDestination) {}

~GsfPropagatorWithMaterial()

GsfPropagatorWithMaterial::~GsfPropagatorWithMaterial ( )

inlineoverride

Definition at line 34 of file GsfPropagatorWithMaterial.h.

{}

Member Function Documentation

clone()

GsfPropagatorWithMaterial* GsfPropagatorWithMaterial::clone ( void  ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 79 of file GsfPropagatorWithMaterial.h.

References GsfPropagatorWithMaterial(), theConvolutor, and theGeometricalPropagator.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

                                                    {
    return new GsfPropagatorWithMaterial(*theGeometricalPropagator, *theConvolutor);
  }

convoluteStateWithMaterial()

TrajectoryStateOnSurface GsfPropagatorWithMaterial::convoluteStateWithMaterial ( const TrajectoryStateOnSurface  tsos, const PropagationDirection  propDir  ) const

private

Convolution of state with material effects.

Definition at line 115 of file GsfPropagatorWithMaterial.cc.

References theConvolutor.

Referenced by propagateWithPath().

                                                                                   {
  //
  // convolute with material
  //
  return (*theConvolutor)(tsos, propDir);
}

convoluteWithMaterial()

std::pair< TrajectoryStateOnSurface, double > GsfPropagatorWithMaterial::convoluteWithMaterial ( const std::pair< TrajectoryStateOnSurface, double > &  ) const

private

Convolution of state+path with material effects.

Definition at line 106 of file GsfPropagatorWithMaterial.cc.

References Propagator::propagationDirection(), and theConvolutor.

Referenced by propagateWithPath().

                                        {
  //
  // convolute with material
  //
  PropagationDirection propDir = PropagationDirectionFromPath()(aStateWithPath.second, propagationDirection());
  return TsosWP((*theConvolutor)(aStateWithPath.first, propDir), aStateWithPath.second);
}

convolutionWithMaterial()

const FullConvolutionWithMaterial& GsfPropagatorWithMaterial::convolutionWithMaterial ( ) const

inline

Access to the convolutor and thus to the material effects.

Definition at line 77 of file GsfPropagatorWithMaterial.h.

References theConvolutor.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

{ return *theConvolutor; }

geometricalPropagator()

const Propagator& GsfPropagatorWithMaterial::geometricalPropagator ( ) const

inline

Access to the geometrical propagator.

Definition at line 75 of file GsfPropagatorWithMaterial.h.

References theGeometricalPropagator.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

{ return *theGeometricalPropagator; }

magneticField()

const MagneticField* GsfPropagatorWithMaterial::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 83 of file GsfPropagatorWithMaterial.h.

References GsfPropagatorAdapter::magneticField(), and theGeometricalPropagator.

{ return theGeometricalPropagator->magneticField(); }

materialAtSource()

bool GsfPropagatorWithMaterial::materialAtSource ( ) const

private

Inclusion of material at the source?

Definition at line 123 of file GsfPropagatorWithMaterial.cc.

References alongMomentum, anyDirection, atDestination, atSource, Exception, fromDirection, Propagator::propagationDirection(), and theMaterialLocation.

Referenced by propagateWithPath().

                                                       {
  if (propagationDirection() == anyDirection) {
    if (theMaterialLocation != atDestination) {
      throw cms::Exception("LogicError") << "PropagatorWithMaterial: propagation direction = anyDirection is "
                                         << "incompatible with adding of material at source";
    }
  }
  return theMaterialLocation == atSource ||
         (theMaterialLocation == fromDirection && propagationDirection() == alongMomentum);
}

propagate() [1/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 109 of file Propagator.h.

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

propagate() [2/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 112 of file Propagator.h.

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

propagate() [3/4]

virtual FreeTrajectoryState Propagator::propagate

inlinefinal

Definition at line 117 of file Propagator.h.

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

propagate() [4/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;
  }

propagateWithPath() [1/13]

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

inline

Definition at line 86 of file Propagator.h.

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

propagateWithPath() [2/13]

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() [3/13]

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

propagateWithPath() [4/13]

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

propagateWithPath() [5/13]

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() [6/13]

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() [7/13]

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() [8/13]

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

inline

Definition at line 91 of file Propagator.h.

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

propagateWithPath() [9/13]

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() [10/13]

std::pair< TrajectoryStateOnSurface, double > GsfPropagatorWithMaterial::propagateWithPath ( const TrajectoryStateOnSurface &  tsos, const Plane &  plane  ) const

overridevirtual

Propagation to plane with path length calculation.

Reimplemented from Propagator.

Definition at line 25 of file GsfPropagatorWithMaterial.cc.

References convoluteStateWithMaterial(), convoluteWithMaterial(), TrajectoryStateOnSurface::isValid(), materialAtSource(), GsfPropagatorAdapter::propagateWithPath(), Propagator::propagationDirection(), and theGeometricalPropagator.

                                                                    {
  // add material before propagation?
  //
  TrajectoryStateOnSurface stateAtSource;
  if (materialAtSource())
    stateAtSource = convoluteStateWithMaterial(tsos, propagationDirection());
  else
    stateAtSource = tsos;
  if (!stateAtSource.isValid())
    return TsosWP(stateAtSource, 0.);
  //
  // geometrical propagation
  //
  TsosWP propStateWP(theGeometricalPropagator->propagateWithPath(stateAtSource, plane));
  if (!(propStateWP.first).isValid())
    return propStateWP;
  //
  // return convoluted state
  //
  return convoluteWithMaterial(propStateWP);
}

propagateWithPath() [11/13]

std::pair< TrajectoryStateOnSurface, double > GsfPropagatorWithMaterial::propagateWithPath ( const TrajectoryStateOnSurface &  tsos, const Cylinder &  cylinder  ) const

overridevirtual

Propagation to cylinder with path length calculation.

Reimplemented from Propagator.

Definition at line 48 of file GsfPropagatorWithMaterial.cc.

References convoluteStateWithMaterial(), convoluteWithMaterial(), TrajectoryStateOnSurface::isValid(), materialAtSource(), GsfPropagatorAdapter::propagateWithPath(), Propagator::propagationDirection(), and theGeometricalPropagator.

                                                                          {
  // add material before propagation?
  //
  TrajectoryStateOnSurface stateAtSource;
  if (materialAtSource())
    stateAtSource = convoluteStateWithMaterial(tsos, propagationDirection());
  else
    stateAtSource = tsos;
  if (!stateAtSource.isValid())
    return TsosWP(stateAtSource, 0.);
  //
  // geometrical propagation
  //
  TsosWP propStateWP(theGeometricalPropagator->propagateWithPath(stateAtSource, cylinder));
  if (!(propStateWP.first).isValid())
    return propStateWP;
  //
  // return convoluted state
  //
  return convoluteWithMaterial(propStateWP);
}

propagateWithPath() [12/13]

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

overridevirtual

Propagation to plane with path length calculation. Use from FTS implies single state (better use PropagatorWithMaterial)!

Implements Propagator.

Definition at line 71 of file GsfPropagatorWithMaterial.cc.

References convoluteWithMaterial(), materialAtSource(), GsfPropagatorAdapter::propagateWithPath(), and theGeometricalPropagator.

                                                                                                                   {
  static std::atomic<int> nWarn(0);
  if (nWarn++ < 5)
    edm::LogInfo("GsfPropagatorWithMaterial")
        << "GsfPropagatorWithMaterial used from FTS: input state might have been collapsed!";
  TsosWP propStateWP = theGeometricalPropagator->propagateWithPath(fts, plane);
  if (!(propStateWP.first).isValid() || materialAtSource())
    return propStateWP;
  //
  // return convoluted state
  //
  return convoluteWithMaterial(propStateWP);
}

propagateWithPath() [13/13]

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

overridevirtual

Propagation to cylinder with path length calculation. Use from FTS implies single state (better use PropagatorWithMaterial)!

Implements Propagator.

Definition at line 86 of file GsfPropagatorWithMaterial.cc.

References convoluteWithMaterial(), materialAtSource(), GsfPropagatorAdapter::propagateWithPath(), and theGeometricalPropagator.

                                                                    {
  static std::atomic<int> nWarn(0);
  if (nWarn++ < 5)
    edm::LogInfo("GsfPropagatorWithMaterial")
        << "GsfPropagatorWithMaterial used from FTS: input state might have been collapsed!";
  TsosWP propStateWP = theGeometricalPropagator->propagateWithPath(fts, cylinder);
  if (!(propStateWP.first).isValid() || materialAtSource())
    return propStateWP;
  //
  // return convoluted state
  //
  return convoluteWithMaterial(propStateWP);
}

setMaterialLocation()

void GsfPropagatorWithMaterial::setMaterialLocation ( const MaterialLocation  location )

inline

Choice of location for including material effects: fromDirection is equivalent to atSource for propagation alongMomentum and to atDestination for propagation oppositeToMomentum. Inclusion of material effects at the source (either explicitely or implicitely) is not possible if propagating with anyDirection and will effectively disable material effects when propagating from a FreeTrajectoryState.

Definition at line 73 of file GsfPropagatorWithMaterial.h.

References EcalCondDBWriter_cfi::location, and theMaterialLocation.

{ theMaterialLocation = location; }

setMaxDirectionChange()

bool GsfPropagatorWithMaterial::setMaxDirectionChange ( float  phiMax )

inlineoverridevirtual

Set the maximal change of direction (integrated along the path) for any single propagation. If reaching of the destination surface requires change of direction that exceeds this value the Propagator returns an invalid state. For example, a track may reach a forward plane after many spirals, which may be undesirable for a track reconstructor. Setting this value to pi will force the propagation to fail. The default value is "no limit". The method returnd true if the concrete propagator respects the limit, false otherwise.

Reimplemented from Propagator.

Definition at line 60 of file GsfPropagatorWithMaterial.h.

References AlignmentTrackSelector_cfi::phiMax, GsfPropagatorAdapter::setMaxDirectionChange(), and theGeometricalPropagator.

{ return theGeometricalPropagator->setMaxDirectionChange(phiMax); }

setPropagationDirection()

void GsfPropagatorWithMaterial::setPropagationDirection ( PropagationDirection  dir )

overridevirtual

The propagation direction can now be set for every propagator. There is no more distinction between unidirectional and bidirectional at class level. The value "anyDiriction" for PropagationDirection provides the functionality of the ex-BidirectionalPropagator. The values "alongMomentum" and "oppositeToMomentum" provide the functionality of the ex-UnidirectionalPropagator.

Reimplemented from Propagator.

Definition at line 101 of file GsfPropagatorWithMaterial.cc.

References DeadROC_duringRun::dir, GsfPropagatorAdapter::setPropagationDirection(), Propagator::setPropagationDirection(), and theGeometricalPropagator.

                                                                                {
  theGeometricalPropagator->setPropagationDirection(dir);
  Propagator::setPropagationDirection(dir);
}

Member Data Documentation

theConvolutor

DeepCopyPointerByClone<FullConvolutionWithMaterial> GsfPropagatorWithMaterial::theConvolutor

private

Definition at line 100 of file GsfPropagatorWithMaterial.h.

Referenced by clone(), convoluteStateWithMaterial(), convoluteWithMaterial(), and convolutionWithMaterial().

theGeometricalPropagator

DeepCopyPointerByClone<GsfPropagatorAdapter> GsfPropagatorWithMaterial::theGeometricalPropagator

private

Definition at line 98 of file GsfPropagatorWithMaterial.h.

Referenced by clone(), geometricalPropagator(), magneticField(), propagateWithPath(), setMaxDirectionChange(), and setPropagationDirection().

theMaterialLocation

MaterialLocation GsfPropagatorWithMaterial::theMaterialLocation

private

Definition at line 102 of file GsfPropagatorWithMaterial.h.

Referenced by materialAtSource(), and setMaterialLocation().