#include <GsfTrajectorySmoother.h>

Inheritance diagram for GsfTrajectorySmoother:

Public Member Functions
virtual GsfTrajectorySmoother *	clone () const

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)

const Propagator *	propagator () const

virtual std::vector< Trajectory >	trajectories (const Trajectory &aTraj) const

const TrajectoryStateUpdator *	updator () const

virtual	~GsfTrajectorySmoother ()

Public Member Functions inherited from TrajectorySmoother
virtual	~TrajectorySmoother ()

Private Types
typedef TrajectoryMeasurement	TM

typedef TrajectoryStateOnSurface	TSOS

Private Attributes
const DetLayerGeometry	dummyGeometry

const FullConvolutionWithMaterial *	theConvolutor

float	theErrorRescaling

const MeasurementEstimator *	theEstimator

const DetLayerGeometry *	theGeometry

const GsfPropagatorAdapter *	theGeomPropagator

bool	theMatBeforeUpdate

const MultiTrajectoryStateMerger *	theMerger

GsfPropagatorWithMaterial *	thePropagator

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 FullConvolutionWithMaterial::clone(), GsfPropagatorWithMaterial::convolutionWithMaterial(), dummyGeometry, GsfPropagatorWithMaterial::geometricalPropagator(), theConvolutor, theGeometry, theGeomPropagator, theMatBeforeUpdate, and thePropagator.

Referenced by clone().

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

GsfTrajectorySmoother::~GsfTrajectorySmoother ( )

virtual

Definition at line 37 of file GsfTrajectorySmoother.cc.

References theConvolutor, theEstimator, theGeomPropagator, theMerger, thePropagator, and theUpdator.

                                               {
   delete thePropagator;
   delete theGeomPropagator;
   delete theConvolutor;
   delete theUpdator;
   delete theEstimator;
   delete theMerger;
 }

Member Function Documentation

virtual GsfTrajectorySmoother* GsfTrajectorySmoother::clone ( void ) const

inlinevirtual

Implements TrajectorySmoother.

Definition at line 54 of file GsfTrajectorySmoother.h.

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

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

const MeasurementEstimator* GsfTrajectorySmoother::estimator ( void ) const

inline

Definition at line 52 of file GsfTrajectorySmoother.h.

References theEstimator.

Referenced by trajectories().

52 {return theEstimator;}

GsfTrajectorySmoother::theEstimator

const MeasurementEstimator * theEstimator

Definition: GsfTrajectorySmoother.h:65

const Propagator* GsfTrajectorySmoother::propagator ( void ) const

inline

propagator used (full propagator, if material effects are applied before the update, otherwise purely geometrical part)

Definition at line 47 of file GsfTrajectorySmoother.h.

References theGeomPropagator, and thePropagator.

Referenced by trajectories().

                                        {
     if ( thePropagator) return thePropagator;
     else  return theGeomPropagator;
   }

std::vector< Trajectory > GsfTrajectorySmoother::trajectories ( const Trajectory & aTraj ) const

virtual

Implements TrajectorySmoother.

Definition at line 47 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(), oppositeToMomentum, Propagator::propagate(), Propagator::propagationDirection(), propagator(), TrajectoryStateOnSurface::rescaleError(), edm::second(), Trajectory::seed(), GsfPropagatorWithMaterial::setPropagationDirection(), TrajectoryStateOnSurface::surface(), theConvolutor, theErrorRescaling, theGeometry, theMatBeforeUpdate, theMerger, thePropagator, 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 std::vector<Trajectory>();
   
   if (  aTraj.direction() == alongMomentum) {
     thePropagator->setPropagationDirection(oppositeToMomentum);
   }
   else {
     thePropagator->setPropagationDirection(alongMomentum);
   }
 
   Trajectory myTraj(aTraj.seed(), propagator()->propagationDirection());
   
   std::vector<TM> 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 std::vector<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 std::vector<Trajectory>();
     }
 
     //check validity
     if (!avtm.back().forwardPredictedState().isValid() || !predTsos.isValid() || !avtm.back().updatedState().isValid()){
       edm::LogError("InvalidState")<<"first hit";
       return std::vector<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 std::vector<Trajectory>();
     }
 
     myTraj.push(TM(avtm.back().forwardPredictedState(),
            avtm.back().recHit(),
            0.,
            theGeometry->idToLayer(avtm.back().recHit()->geographicalId() )  ));
   }
   
   TrajectoryStateCombiner combiner;
 
   for(std::vector<TM>::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 = propagator()->propagate(currTsos,
                      *(*itm).recHit()->surface());
     }
     if ( predTsos.isValid() && theConvolutor && theMatBeforeUpdate )
       predTsos = (*theConvolutor)(predTsos,
                   propagator()->propagationDirection());
     if(!predTsos.isValid()) {
       edm::LogInfo("GsfTrajectorySmoother") << "GsfTrajectorySmoother: predicted tsos not valid!";
       return std::vector<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,
                     propagator()->propagationDirection());
       if(!currTsos.isValid()) {
     edm::LogInfo("GsfTrajectorySmoother") 
       << "GsfTrajectorySmoother: tsos not valid after update / material effects!";
     return std::vector<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 std::vector<Trajectory>();
       }
 
       TSOS smooTsos = combiner((*itm).updatedState(), predTsos);
 
       if(!smooTsos.isValid()) {
     LogDebug("GsfTrajectorySmoother") <<
       "KFTrajectorySmoother: smoothed tsos not valid!";
     return std::vector<Trajectory>();
       }
 
       if (!(*itm).forwardPredictedState().isValid() || !predTsos.isValid() || !smooTsos.isValid() ){
     edm::LogError("InvalidState")<<"inside hits with combination.";
     return std::vector<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 std::vector<Trajectory>();
       }
 
       if (!(*itm).forwardPredictedState().isValid() || !predTsos.isValid() || !combTsos.isValid() ){
     edm::LogError("InvalidState")<<"inside hits with invalid rechit.";
         return std::vector<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 = propagator()->propagate(currTsos,
                        *avtm.front().recHit()->surface());
   }
   if ( predTsos.isValid() && theConvolutor && theMatBeforeUpdate )
     predTsos = (*theConvolutor)(predTsos,
                 propagator()->propagationDirection());
   if(!predTsos.isValid()) {
     edm::LogInfo("GsfTrajectorySmoother") << "GsfTrajectorySmoother: predicted tsos not valid!";
     return std::vector<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,
                   propagator()->propagationDirection());
     if(!currTsos.isValid()) {
       edm::LogInfo("GsfTrajectorySmoother") 
     << "GsfTrajectorySmoother: tsos not valid after update / material effects!";
       return std::vector<Trajectory>();
     }
   
     if (!avtm.front().forwardPredictedState().isValid() || !predTsos.isValid() || !currTsos.isValid() ){
       edm::LogError("InvalidState")<<"last hit";
       return std::vector<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 std::vector<Trajectory>();
     }
     myTraj.push(TM(avtm.front().forwardPredictedState(),
            avtm.front().recHit(),
            0.,
            theGeometry->idToLayer(avtm.front().recHit()->geographicalId()) ));
   }
 
   return std::vector<Trajectory>(1, myTraj); 
 }