GsfPropagatorWithMaterial Class Reference

#include <GsfPropagatorWithMaterial.h>

Inheritance diagram for GsfPropagatorWithMaterial:

Public Types
enum	MaterialLocation { atSource, atDestination, fromDirection }

Public Member Functions
virtual 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 std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Plane &) const override
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Cylinder &) const override
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const override
virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const override
void	setMaterialLocation (const MaterialLocation location)
virtual bool	setMaxDirectionChange (float phiMax) override
virtual void	setPropagationDirection (PropagationDirection dir) override
	~GsfPropagatorWithMaterial ()
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

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

private

Definition at line 125 of file GsfPropagatorWithMaterial.h.

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

private

Definition at line 124 of file GsfPropagatorWithMaterial.h.

Member Enumeration Documentation

enum GsfPropagatorWithMaterial::MaterialLocation

Enumerator
atSource
atDestination
fromDirection

Definition at line 76 of file GsfPropagatorWithMaterial.h.

{atSource, atDestination, fromDirection};

Constructor & Destructor Documentation

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

Constructor with explicit multi state propagator and convolutor.

Definition at line 20 of file GsfPropagatorWithMaterial.cc.

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

GsfPropagatorWithMaterial::~GsfPropagatorWithMaterial ( )

inline

Definition at line 37 of file GsfPropagatorWithMaterial.h.

References Propagator::propagate(), propagateWithPath(), and Propagator::propagateWithPath().

{}

Member Function Documentation

virtual GsfPropagatorWithMaterial* GsfPropagatorWithMaterial::clone ( void  ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 97 of file GsfPropagatorWithMaterial.h.

References GsfPropagatorWithMaterial(), theConvolutor, and theGeometricalPropagator.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

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

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

private

Convolution of state with material effects.

Definition at line 122 of file GsfPropagatorWithMaterial.cc.

References theConvolutor.

Referenced by magneticField(), and propagateWithPath().

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

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

private

Convolution of state+path with material effects.

Definition at line 110 of file GsfPropagatorWithMaterial.cc.

References Propagator::propagationDirection(), and theConvolutor.

Referenced by magneticField(), and propagateWithPath().

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

const FullConvolutionWithMaterial& GsfPropagatorWithMaterial::convolutionWithMaterial ( ) const

inline

Access to the convolutor and thus to the material effects.

Definition at line 93 of file GsfPropagatorWithMaterial.h.

References theConvolutor.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

                                                                     {
    return *theConvolutor;
  }

const Propagator& GsfPropagatorWithMaterial::geometricalPropagator ( ) const

inline

Access to the geometrical propagator.

Definition at line 89 of file GsfPropagatorWithMaterial.h.

References theGeometricalPropagator.

Referenced by GsfTrajectorySmoother::GsfTrajectorySmoother().

                                                  {
    return *theGeometricalPropagator;
  }

const MagneticField* GsfPropagatorWithMaterial::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 102 of file GsfPropagatorWithMaterial.h.

References convoluteStateWithMaterial(), convoluteWithMaterial(), GsfPropagatorAdapter::magneticField(), materialAtSource(), and theGeometricalPropagator.

{return theGeometricalPropagator->magneticField();}

bool GsfPropagatorWithMaterial::materialAtSource ( ) const

private

Inclusion of material at the source?

Definition at line 132 of file GsfPropagatorWithMaterial.cc.

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

Referenced by magneticField(), and 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);
}

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 30 of file GsfPropagatorWithMaterial.cc.

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

Referenced by ~GsfPropagatorWithMaterial().

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

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

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

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

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 85 of file GsfPropagatorWithMaterial.h.

References theMaterialLocation.

                                                             {
    theMaterialLocation = location;
  }

virtual 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 70 of file GsfPropagatorWithMaterial.h.

References dir, GsfPropagatorAdapter::setMaxDirectionChange(), setPropagationDirection(), and theGeometricalPropagator.

                                                             {
    return theGeometricalPropagator->setMaxDirectionChange(phiMax);
  }

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 104 of file GsfPropagatorWithMaterial.cc.

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

Referenced by setMaxDirectionChange().

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

Member Data Documentation

DeepCopyPointerByClone<FullConvolutionWithMaterial> GsfPropagatorWithMaterial::theConvolutor

private

Definition at line 120 of file GsfPropagatorWithMaterial.h.

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

DeepCopyPointerByClone<GsfPropagatorAdapter> GsfPropagatorWithMaterial::theGeometricalPropagator

private

Definition at line 118 of file GsfPropagatorWithMaterial.h.

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

MaterialLocation GsfPropagatorWithMaterial::theMaterialLocation

private

Definition at line 122 of file GsfPropagatorWithMaterial.h.

Referenced by materialAtSource(), and setMaterialLocation().