#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 GsfPropagatorAdapter &Propagator, const FullConvolutionWithMaterial &Convolutor)

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

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

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

virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const=0

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

virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) 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< 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...

std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Cylinder &) const override

std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Plane &) const override

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

virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final

void	setMaterialLocation (const MaterialLocation location)

bool	setMaxDirectionChange (float phiMax) override

void	setPropagationDirection (PropagationDirection dir) override

	~GsfPropagatorWithMaterial () override

Public Member Functions inherited from Propagator
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 Surface &) 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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final

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.

64 { 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.

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

Referenced by clone().

◆ 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.

34 {}

Member Function Documentation

◆ clone()

GsfPropagatorWithMaterial* GsfPropagatorWithMaterial::clone ( void ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 79 of file GsfPropagatorWithMaterial.h.

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

References GsfPropagatorWithMaterial(), theConvolutor, and theGeometricalPropagator.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

◆ 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.

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

References theConvolutor.

Referenced by propagateWithPath().

◆ 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.

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

References Propagator::propagationDirection(), and theConvolutor.

Referenced by propagateWithPath().

◆ 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.

77 { return *theConvolutor; }

References theConvolutor.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

◆ geometricalPropagator()

const Propagator& GsfPropagatorWithMaterial::geometricalPropagator ( ) const

inline

Access to the geometrical propagator.

Definition at line 75 of file GsfPropagatorWithMaterial.h.

75 { return *theGeometricalPropagator; }

References theGeometricalPropagator.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

◆ magneticField()

const MagneticField* GsfPropagatorWithMaterial::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 83 of file GsfPropagatorWithMaterial.h.

83 { return theGeometricalPropagator->magneticField(); }

References GsfPropagatorAdapter::magneticField(), and theGeometricalPropagator.

◆ materialAtSource()

bool GsfPropagatorWithMaterial::materialAtSource ( ) const

private

Inclusion of material at the source?

Definition at line 123 of file GsfPropagatorWithMaterial.cc.

                                                        {
   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);
 }

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

Referenced by propagateWithPath().

◆ 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]

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.

                                                                     {
   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);
 }

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

◆ propagateWithPath() [2/13]

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

◆ propagateWithPath() [3/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.

                                                                                                                    {
   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);
 }

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

◆ propagateWithPath() [4/13]

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

◆ propagateWithPath() [5/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() [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 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() [8/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() [9/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.

                                                                           {
   // 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);
 }

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

◆ 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.

                                                                     {
   // 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);
 }

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

◆ propagateWithPath() [11/13]

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

inline

Definition at line 91 of file Propagator.h.

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

◆ propagateWithPath() [12/13]

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

inline

Definition at line 86 of file Propagator.h.

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

◆ propagateWithPath() [13/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");
 }

◆ 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.

73 { theMaterialLocation = location; }

References EcalCondDBWriter_cfi::location, and theMaterialLocation.

◆ 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.

60 { return theGeometricalPropagator->setMaxDirectionChange(phiMax); }

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

◆ 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.

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

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

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().

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MultiTSOS

◆ TsosWP

Member Enumeration Documentation

◆ MaterialLocation

Constructor & Destructor Documentation

◆ GsfPropagatorWithMaterial() [1/2]

◆ GsfPropagatorWithMaterial() [2/2]

◆ ~GsfPropagatorWithMaterial()

Member Function Documentation

◆ clone()

◆ convoluteStateWithMaterial()

◆ convoluteWithMaterial()

◆ convolutionWithMaterial()

◆ geometricalPropagator()

◆ magneticField()

◆ materialAtSource()

◆ propagate() [1/4]

◆ propagate() [2/4]

◆ propagate() [3/4]

◆ propagate() [4/4]

◆ propagateWithPath() [1/13]

◆ propagateWithPath() [2/13]

◆ propagateWithPath() [3/13]

◆ propagateWithPath() [4/13]

◆ propagateWithPath() [5/13]

◆ propagateWithPath() [6/13]

◆ propagateWithPath() [7/13]

◆ propagateWithPath() [8/13]

◆ propagateWithPath() [9/13]

◆ propagateWithPath() [10/13]

◆ propagateWithPath() [11/13]

◆ propagateWithPath() [12/13]

◆ propagateWithPath() [13/13]

◆ setMaterialLocation()

◆ setMaxDirectionChange()

◆ setPropagationDirection()

Member Data Documentation

◆ theConvolutor

◆ theGeometricalPropagator

◆ theMaterialLocation