#include <GsfTrajectorySmoother.h>

Inheritance diagram for GsfTrajectorySmoother:

Public Member Functions
virtual GsfTrajectorySmoother *	clone () const override

const MeasurementEstimator *	estimator () const

	GsfTrajectorySmoother (const GsfPropagatorWithMaterial &aPropagator, const TrajectoryStateUpdator &aUpdator, const MeasurementEstimator &aEstimator, const MultiTrajectoryStateMerger &merger, float errorRescaling, const bool materialBeforeUpdate=true, const DetLayerGeometry *detLayerGeometry=0)

virtual void	setHitCloner (TkCloner const *hc)

virtual Trajectory	trajectory (const Trajectory &aTraj) const override

const TrajectoryStateUpdator *	updator () const

virtual	~GsfTrajectorySmoother ()

Public Member Functions inherited from TrajectorySmoother
virtual TrajectoryContainer	trajectories (const Trajectory &traj) const

virtual	~TrajectorySmoother ()

Private Types
typedef TrajectoryMeasurement	TM

typedef TrajectoryStateOnSurface	TSOS

Private Attributes
const DetLayerGeometry	dummyGeometry

const GsfPropagatorWithMaterial *	theAlongPropagator

const FullConvolutionWithMaterial *	theConvolutor

float	theErrorRescaling

const MeasurementEstimator *	theEstimator

const DetLayerGeometry *	theGeometry

const GsfPropagatorAdapter *	theGeomPropagator

bool	theMatBeforeUpdate

const MultiTrajectoryStateMerger *	theMerger

const GsfPropagatorWithMaterial *	theOppositePropagator

bool	theTiming

const TrajectoryStateUpdator *	theUpdator

Additional Inherited Members
Public Types inherited from TrajectorySmoother
typedef std::vector< Trajectory >	TrajectoryContainer

typedef TrajectoryContainer::iterator	TrajectoryIterator

Detailed Description

A GSF smoother, similar to KFTrajectorySmoother, but (for testing purposes) without combination with the forward fit.

Definition at line 21 of file GsfTrajectorySmoother.h.

Member Typedef Documentation

typedef TrajectoryMeasurement GsfTrajectorySmoother::TM

private

Definition at line 26 of file GsfTrajectorySmoother.h.

typedef TrajectoryStateOnSurface GsfTrajectorySmoother::TSOS

private

Definition at line 25 of file GsfTrajectorySmoother.h.

Constructor & Destructor Documentation

GsfTrajectorySmoother::GsfTrajectorySmoother	(	const GsfPropagatorWithMaterial &	aPropagator,
		const TrajectoryStateUpdator &	aUpdator,
		const MeasurementEstimator &	aEstimator,
		const MultiTrajectoryStateMerger &	merger,
		float	errorRescaling,
		const bool	materialBeforeUpdate = `true`,
		const DetLayerGeometry *	detLayerGeometry = `0`
	)

Constructor with explicit components for propagation, update, chi2 calculation, merging and flag for merging before / after the update (i.e. fully configured). It clones the algorithms.

Definition at line 9 of file GsfTrajectorySmoother.cc.

References alongMomentum, FullConvolutionWithMaterial::clone(), GsfPropagatorWithMaterial::clone(), GsfPropagatorWithMaterial::convolutionWithMaterial(), dummyGeometry, GsfPropagatorWithMaterial::geometricalPropagator(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, theAlongPropagator, theConvolutor, theGeometry, theGeomPropagator, theMatBeforeUpdate, and theOppositePropagator.

Referenced by clone().

                                                                    :
   theAlongPropagator(nullptr),
   theOppositePropagator(nullptr),
   theGeomPropagator(nullptr),
   theConvolutor(nullptr),
   theUpdator(aUpdator.clone()),
   theEstimator(aEstimator.clone()),
   theMerger(aMerger.clone()),
   theMatBeforeUpdate(materialBeforeUpdate),
   theErrorRescaling(errorRescaling),
   theGeometry(detLayerGeometry)
 {
   auto p = aPropagator.clone();
   p->setPropagationDirection(alongMomentum);
   theAlongPropagator = p;
   p = aPropagator.clone();
   p->setPropagationDirection(oppositeToMomentum);
   theOppositePropagator = p;
   if ( !theMatBeforeUpdate ) {
     theGeomPropagator = new GsfPropagatorAdapter(aPropagator.geometricalPropagator());
     theConvolutor = aPropagator.convolutionWithMaterial().clone();
   }
 
   if(!theGeometry) theGeometry = &dummyGeometry;
 
   //   static SimpleConfigurable<bool> timeConf(false,"GsfTrajectorySmoother:activateTiming");
   //   theTiming = timeConf.value();
 }

GsfTrajectorySmoother::~GsfTrajectorySmoother ( )

virtual

Definition at line 44 of file GsfTrajectorySmoother.cc.

References theAlongPropagator, theConvolutor, theEstimator, theGeomPropagator, theMerger, theOppositePropagator, and theUpdator.

                                               {
   delete theAlongPropagator;
   delete theOppositePropagator;
   delete theGeomPropagator;
   delete theConvolutor;
   delete theUpdator;
   delete theEstimator;
   delete theMerger;
 }

Member Function Documentation

virtual GsfTrajectorySmoother* GsfTrajectorySmoother::clone ( void ) const

inlineoverridevirtual

Implements TrajectorySmoother.

Definition at line 48 of file GsfTrajectorySmoother.h.

References GsfTrajectorySmoother(), theAlongPropagator, theErrorRescaling, theEstimator, theGeometry, theMatBeforeUpdate, theMerger, and theUpdator.

   {
     return new GsfTrajectorySmoother(*theAlongPropagator,*theUpdator,*theEstimator,
                      *theMerger,theErrorRescaling,theMatBeforeUpdate,theGeometry);
   }

const MeasurementEstimator* GsfTrajectorySmoother::estimator ( void ) const

inline

Definition at line 46 of file GsfTrajectorySmoother.h.

References theEstimator.

Referenced by trajectory().

46 {return theEstimator;}

GsfTrajectorySmoother::theEstimator

const MeasurementEstimator * theEstimator

Definition: GsfTrajectorySmoother.h:64

virtual void GsfTrajectorySmoother::setHitCloner ( TkCloner const * hc )

inlinevirtual

Implements TrajectorySmoother.

Definition at line 54 of file GsfTrajectorySmoother.h.

54 {

55 }

Trajectory GsfTrajectorySmoother::trajectory ( const Trajectory & aTraj ) const

overridevirtual

Implements TrajectorySmoother.

Definition at line 55 of file GsfTrajectorySmoother.cc.

References alongMomentum, heavyFlavorValidationHarvestingSequence_cff::combiner, Trajectory::direction(), Trajectory::empty(), MeasurementEstimator::estimate(), TrajectoryMeasurement::estimate(), estimator(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), DetLayerGeometry::idToLayer(), TrajectoryStateOnSurface::isValid(), LogDebug, Trajectory::measurements(), MultiTrajectoryStateMerger::merge(), TrajectoryStateOnSurface::rescaleError(), edm::second(), Trajectory::seed(), TrajectoryStateOnSurface::surface(), theAlongPropagator, theConvolutor, theErrorRescaling, theGeometry, theGeomPropagator, theMatBeforeUpdate, theMerger, theOppositePropagator, TrajectoryStateUpdator::update(), and updator().

                                                                {
 
   //   static TimingReport::Item* propTimer =
   //     &(*TimingReport::current())[string("GsfTrajectorySmoother:propagation")];
   //   propTimer->switchCPU(false);
   //   if ( !theTiming )  propTimer->switchOn(false);
   //   static TimingReport::Item* updateTimer =
   //     &(*TimingReport::current())[string("GsfTrajectorySmoother:update")];
   //   updateTimer->switchCPU(false);
   //   if ( !theTiming )  updateTimer->switchOn(false);
   
   if(aTraj.empty()) return Trajectory();
   
   const Propagator* usePropagator = theAlongPropagator;
   if (  aTraj.direction() == alongMomentum) {
     usePropagator = theOppositePropagator;
   }
   if( not usePropagator) {
     usePropagator = theGeomPropagator;
   }
 
   Trajectory myTraj(aTraj.seed(), usePropagator->propagationDirection());
   
   std::vector<TM> const & avtm = aTraj.measurements();
   
   TSOS predTsos = avtm.back().forwardPredictedState();
   predTsos.rescaleError(theErrorRescaling);
 
   if(!predTsos.isValid()) {
     edm::LogInfo("GsfTrajectorySmoother") 
       << "GsfTrajectorySmoother: predicted tsos of last measurement not valid!";
     return Trajectory();
   }
   TSOS currTsos;
 
   //first smoothed tm is last fitted
   if(avtm.back().recHit()->isValid()) {
     {
     //       TimeMe t(*updateTimer,false);
     currTsos = updator()->update(predTsos, *avtm.back().recHit());
     }
 
     if(!currTsos.isValid()) {
       edm::LogInfo("GsfTrajectorySmoother") << "GsfTrajectorySmoother: tsos not valid after update!";
       return Trajectory();
     }
     
     //check validity
     if (!avtm.back().forwardPredictedState().isValid() || !predTsos.isValid() || !avtm.back().updatedState().isValid()){
       edm::LogError("InvalidState")<<"first hit";
       return Trajectory();
     }
     
     myTraj.push(TM(avtm.back().forwardPredictedState(), 
            predTsos,
            avtm.back().updatedState(),
            avtm.back().recHit(),
            avtm.back().estimate(),
            theGeometry->idToLayer(avtm.back().recHit()->geographicalId()) ), 
         avtm.back().estimate());
   } else {
     currTsos = predTsos;
     //check validity
     if (!avtm.back().forwardPredictedState().isValid()){
       edm::LogError("InvalidState")<<"first hit on invalid hit";
       return Trajectory();
     }
 
     myTraj.push(TM(avtm.back().forwardPredictedState(),
            avtm.back().recHit(),
            0.,
            theGeometry->idToLayer(avtm.back().recHit()->geographicalId() )  ));
   }
   
   TrajectoryStateCombiner combiner;
 
   for(std::vector<TM>::const_reverse_iterator itm = avtm.rbegin() + 1; 
       itm < avtm.rend() - 1; ++itm) {
     {
       //       TimeMe t(*propTimer,false);
       //       //
       //       // check type of surface in case of invalid hit
       //       // (in this version only propagations to planes are
       //       // supported for multi trajectory states)
       //       //
       //       if ( !(*itm).recHit().isValid() ) {
       //    const BoundPlane* plane = 
       //      dynamic_cast<const BoundPlane*>(&(*itm).recHit().det().surface());
       //    //
       //    // no plane: insert invalid 
       //    if ( plane==0 ) {
       //      myTraj.push(TM(TrajectoryStateOnSurface(),
       //             (*itm).recHit());
       //      continue;
       //    }
       //     }
       predTsos = usePropagator->propagate(currTsos,
                      *(*itm).recHit()->surface());
     }
     if ( predTsos.isValid() && theConvolutor && theMatBeforeUpdate )
       predTsos = (*theConvolutor)(predTsos,
                   usePropagator->propagationDirection());
     if(!predTsos.isValid()) {
       edm::LogInfo("GsfTrajectorySmoother") << "GsfTrajectorySmoother: predicted tsos not valid!";
       return Trajectory();
     }
     if ( theMerger )  predTsos = theMerger->merge(predTsos);
 
     if((*itm).recHit()->isValid()) {
       //update
       {
     //  TimeMe t(*updateTimer,false);
     currTsos = updator()->update(predTsos, *(*itm).recHit());
       }
       if ( currTsos.isValid() && theConvolutor && !theMatBeforeUpdate )
     currTsos = (*theConvolutor)(currTsos,
                     usePropagator->propagationDirection());
       if(!currTsos.isValid()) {
     edm::LogInfo("GsfTrajectorySmoother") 
       << "GsfTrajectorySmoother: tsos not valid after update / material effects!";
     return Trajectory();
       }
       //3 different possibilities to calculate smoothed state:
       //1: update combined predictions with hit
       //2: combine fwd-prediction with bwd-filter
       //3: combine bwd-prediction with fwd-filter
       TSOS combTsos = combiner(predTsos, (*itm).forwardPredictedState());
       if(!combTsos.isValid()) {
     LogDebug("GsfTrajectorySmoother") << 
       "KFTrajectorySmoother: combined tsos not valid!\n"<<
       "pred Tsos pos: "<<predTsos.globalPosition()<< "\n" <<
       "pred Tsos mom: "<<predTsos.globalMomentum()<< "\n" <<
       "TrackingRecHit: "<<(*itm).recHit()->surface()->toGlobal((*itm).recHit()->localPosition())<< "\n" ;
     return Trajectory();
       }
 
       TSOS smooTsos = combiner((*itm).updatedState(), predTsos);
 
       if(!smooTsos.isValid()) {
     LogDebug("GsfTrajectorySmoother") <<
       "KFTrajectorySmoother: smoothed tsos not valid!";
     return Trajectory();
       }
 
       if (!(*itm).forwardPredictedState().isValid() || !predTsos.isValid() || !smooTsos.isValid() ){
     edm::LogError("InvalidState")<<"inside hits with combination.";
     return Trajectory();
       }
 
 
       myTraj.push(TM((*itm).forwardPredictedState(),
              predTsos,
              smooTsos,
              (*itm).recHit(),
              estimator()->estimate(combTsos, *(*itm).recHit()).second,
              theGeometry->idToLayer((*itm).recHit()->geographicalId() ) ),
           (*itm).estimate());
     } 
     else {
       currTsos = predTsos;
       TSOS combTsos = combiner(predTsos, (*itm).forwardPredictedState());
       
       if(!combTsos.isValid()) {
         LogDebug("GsfTrajectorySmoother") << 
           "KFTrajectorySmoother: combined tsos not valid!";
         return Trajectory();
       }
 
       if (!(*itm).forwardPredictedState().isValid() || !predTsos.isValid() || !combTsos.isValid() ){
     edm::LogError("InvalidState")<<"inside hits with invalid rechit.";
         return Trajectory();
       }
 
       myTraj.push(TM((*itm).forwardPredictedState(),
                  predTsos,
                  combTsos,
                  (*itm).recHit(),
              0.,
              theGeometry->idToLayer((*itm).recHit()->geographicalId()) ));
     }
     if ( theMerger )  currTsos = theMerger->merge(currTsos);
   }
 
   //last smoothed tm is last filtered
   {
     //     TimeMe t(*propTimer,false);
     predTsos = usePropagator->propagate(currTsos,
                        *avtm.front().recHit()->surface());
   }
   if ( predTsos.isValid() && theConvolutor && theMatBeforeUpdate )
     predTsos = (*theConvolutor)(predTsos,
                 usePropagator->propagationDirection());
   if(!predTsos.isValid()) {
     edm::LogInfo("GsfTrajectorySmoother") << "GsfTrajectorySmoother: predicted tsos not valid!";
     return Trajectory();
   }
   if ( theMerger )  predTsos = theMerger->merge(predTsos);
 
   if(avtm.front().recHit()->isValid()) {
     //update
     {
       //       TimeMe t(*updateTimer,false);
       currTsos = updator()->update(predTsos, *avtm.front().recHit());
     }
     if ( currTsos.isValid() && theConvolutor && !theMatBeforeUpdate )
       currTsos = (*theConvolutor)(currTsos,
                   usePropagator->propagationDirection());
     if(!currTsos.isValid()) {
       edm::LogInfo("GsfTrajectorySmoother") 
     << "GsfTrajectorySmoother: tsos not valid after update / material effects!";
       return Trajectory();
     }
   
     if (!avtm.front().forwardPredictedState().isValid() || !predTsos.isValid() || !currTsos.isValid() ){
       edm::LogError("InvalidState")<<"last hit";
       return Trajectory();
     }
 
     myTraj.push(TM(avtm.front().forwardPredictedState(),
            predTsos,
            currTsos,
            avtm.front().recHit(),
            estimator()->estimate(predTsos, *avtm.front().recHit()).second,
            theGeometry->idToLayer(avtm.front().recHit()->geographicalId() )),
         avtm.front().estimate());
     //estimator()->estimate(predTsos, avtm.front().recHit()));
   }
   else {
     if (!avtm.front().forwardPredictedState().isValid()){
       edm::LogError("InvalidState")<<"last invalid hit";
       return Trajectory();
     }
     myTraj.push(TM(avtm.front().forwardPredictedState(),
            avtm.front().recHit(),
            0.,
            theGeometry->idToLayer(avtm.front().recHit()->geographicalId()) ));
   }
 
   return myTraj; 
 }