#include <CkfTrajectoryBuilder.h>

Inheritance diagram for CkfTrajectoryBuilder:

Public Types
typedef std::vector < TempTrajectory >	TempTrajectoryContainer

typedef std::vector< Trajectory >	TrajectoryContainer

Public Types inherited from BaseCkfTrajectoryBuilder
typedef std::vector < TempTrajectory >	TempTrajectoryContainer

typedef std::vector< Trajectory >	TrajectoryContainer

typedef TrajectoryContainer::iterator	TrajectoryIterator

Public Types inherited from TrajectoryBuilder
typedef std::vector< Trajectory >	TrajectoryContainer

typedef TrajectoryContainer::iterator	TrajectoryIterator

Public Member Functions
TempTrajectory	buildTrajectories (const TrajectorySeed &, TrajectoryContainer &ret, const TrajectoryFilter *) const

	CkfTrajectoryBuilder (const edm::ParameterSet &conf, edm::ConsumesCollector &iC)

	CkfTrajectoryBuilder (const edm::ParameterSet &conf, TrajectoryFilter *filter)

void	rebuildTrajectories (TempTrajectory const &startingTraj, const TrajectorySeed &, TrajectoryContainer &result) const

virtual TrajectoryContainer	trajectories (const TrajectorySeed &seed) const
	trajectories building starting from a seed More...

virtual void	trajectories (const TrajectorySeed &seed, TrajectoryContainer &ret) const
	trajectories building starting from a seed More...

	~CkfTrajectoryBuilder ()

Public Member Functions inherited from BaseCkfTrajectoryBuilder
	BaseCkfTrajectoryBuilder (const edm::ParameterSet &conf, TrajectoryFilter filter, TrajectoryFilter inOutFilter=0)

	BaseCkfTrajectoryBuilder (const BaseCkfTrajectoryBuilder &)=delete

const TransientTrackingRecHitBuilder *	hitBuilder () const

BaseCkfTrajectoryBuilder &	operator= (const BaseCkfTrajectoryBuilder &)=delete

virtual void	setDebugger (CkfDebugger *dbg) const

virtual void	setEvent (const edm::Event &event) const

void	setEvent (const edm::Event &iEvent, const edm::EventSetup &iSetup, const MeasurementTrackerEvent *data)

void	setNavigationSchool (NavigationSchool const *nv)

virtual void	unset () const

virtual	~BaseCkfTrajectoryBuilder ()

Public Member Functions inherited from TrajectoryBuilder
virtual void	rebuildSeedingRegion (const TrajectorySeed &, TrajectoryContainer &result) const

virtual	~TrajectoryBuilder ()

Protected Member Functions
virtual void	findCompatibleMeasurements (const TrajectorySeed &seed, const TempTrajectory &traj, std::vector< TrajectoryMeasurement > &result) const

void	limitedCandidates (const TrajectorySeed &seed, TempTrajectory &startingTraj, TrajectoryContainer &result) const

void	limitedCandidates (const boost::shared_ptr< const TrajectorySeed > &sharedSeed, TempTrajectoryContainer &candidates, TrajectoryContainer &result) const

void	setEvent_ (const edm::Event &iEvent, const edm::EventSetup &iSetup) override

void	updateTrajectory (TempTrajectory &traj, TM &&tm) const

Protected Member Functions inherited from BaseCkfTrajectoryBuilder
void	addToResult (boost::shared_ptr< const TrajectorySeed > const &seed, TempTrajectory &traj, TrajectoryContainer &result, bool inOut=false) const

void	addToResult (TempTrajectory const &traj, TempTrajectoryContainer &result, bool inOut=false) const

virtual bool	analyzeMeasurementsDebugger (Trajectory &traj, const std::vector< TrajectoryMeasurement > &meas, const MeasurementTrackerEvent theMeasurementTracker, const Propagator theForwardPropagator, const Chi2MeasurementEstimatorBase theEstimator, const TransientTrackingRecHitBuilder theTTRHBuilder) const

virtual bool	analyzeMeasurementsDebugger (TempTrajectory &traj, const std::vector< TrajectoryMeasurement > &meas, const MeasurementTrackerEvent theMeasurementTracker, const Propagator theForwardPropagator, const Chi2MeasurementEstimatorBase theEstimator, const TransientTrackingRecHitBuilder theTTRHBuilder) const

const Propagator *	backwardPropagator (const TrajectorySeed &seed) const

TempTrajectory	createStartingTrajectory (const TrajectorySeed &seed) const

virtual void	fillSeedHistoDebugger (std::vector< TrajectoryMeasurement >::iterator begin, std::vector< TrajectoryMeasurement >::iterator end) const

StateAndLayers	findStateAndLayers (const TrajectorySeed &seed, const TempTrajectory &traj) const

StateAndLayers	findStateAndLayers (const TempTrajectory &traj) const

const Propagator *	forwardPropagator (const TrajectorySeed &seed) const

void	moveToResult (TempTrajectory &&traj, TempTrajectoryContainer &result, bool inOut=false) const

bool	qualityFilter (const TempTrajectory &traj, bool inOut=false) const

void	setData (const MeasurementTrackerEvent *data)

bool	toBeContinued (TempTrajectory &traj, bool inOut=false) const

Protected Attributes
bool	theAlwaysUseInvalidHits

bool	theIntermediateCleaning

float	theLostHitPenalty

int	theMaxCand
	set Event for the internal MeasurementTracker data member More...

Protected Attributes inherited from BaseCkfTrajectoryBuilder
const Chi2MeasurementEstimatorBase *	theEstimator

const MeasurementTrackerEvent *	theMeasurementTracker

const NavigationSchool *	theNavigationSchool = 0

const Propagator *	thePropagatorAlong

const Propagator *	thePropagatorOpposite

const TransientTrackingRecHitBuilder *	theTTRHBuilder

const TrajectoryStateUpdator *	theUpdator

Additional Inherited Members
Protected Types inherited from BaseCkfTrajectoryBuilder
typedef TrackingComponentsRecord	Chi2MeasurementEstimatorRecord

typedef FreeTrajectoryState	FTS

typedef std::pair< TSOS, std::vector< const DetLayer * > >	StateAndLayers

typedef TrajectoryMeasurement	TM

typedef TrajectoryStateOnSurface	TSOS

Static Protected Member Functions inherited from BaseCkfTrajectoryBuilder
static TrajectoryFilter *	createTrajectoryFilter (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)

Detailed Description

Definition at line 34 of file CkfTrajectoryBuilder.h.

Member Typedef Documentation

typedef std::vector<TempTrajectory> CkfTrajectoryBuilder::TempTrajectoryContainer

Definition at line 39 of file CkfTrajectoryBuilder.h.

typedef std::vector<Trajectory> CkfTrajectoryBuilder::TrajectoryContainer

Definition at line 38 of file CkfTrajectoryBuilder.h.

Constructor & Destructor Documentation

CkfTrajectoryBuilder::CkfTrajectoryBuilder	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	iC
	)

Definition at line 30 of file CkfTrajectoryBuilder.cc.

                                                                                                :
   CkfTrajectoryBuilder(conf,
                        BaseCkfTrajectoryBuilder::createTrajectoryFilter(conf.getParameter<edm::ParameterSet>("trajectoryFilter"), iC))
 {}

CkfTrajectoryBuilder::CkfTrajectoryBuilder	(	const edm::ParameterSet &	conf,
		TrajectoryFilter *	filter
	)

Definition at line 35 of file CkfTrajectoryBuilder.cc.

References edm::ParameterSet::getParameter(), theAlwaysUseInvalidHits, theIntermediateCleaning, theLostHitPenalty, and theMaxCand.

                                                                                                :
   BaseCkfTrajectoryBuilder(conf, filter)
 {
   theMaxCand              = conf.getParameter<int>("maxCand");
   theLostHitPenalty       = conf.getParameter<double>("lostHitPenalty");
   theIntermediateCleaning = conf.getParameter<bool>("intermediateCleaning");
   theAlwaysUseInvalidHits = conf.getParameter<bool>("alwaysUseInvalidHits");
   /*
     theSharedSeedCheck = conf.getParameter<bool>("SharedSeedCheck");
     std::stringstream ss;
     ss<<"CkfTrajectoryBuilder_"<<conf.getParameter<std::string>("ComponentName")<<"_"<<this;
     theUniqueName = ss.str();
     LogDebug("CkfPattern")<<"my unique name is: "<<theUniqueName;
   */
 }

CkfTrajectoryBuilder::~CkfTrajectoryBuilder ( )

inline

Definition at line 44 of file CkfTrajectoryBuilder.h.

44 {}

Member Function Documentation

TempTrajectory CkfTrajectoryBuilder::buildTrajectories	(	const TrajectorySeed &	seed,
		TrajectoryContainer &	ret,
		const TrajectoryFilter *
	)		const

virtual

limitedCandidates( startingTraj, regionalCondition, result); FIXME: restore regionalCondition

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 148 of file CkfTrajectoryBuilder.cc.

References BaseCkfTrajectoryBuilder::createStartingTrajectory(), Exception, limitedCandidates(), and BaseCkfTrajectoryBuilder::theMeasurementTracker.

Referenced by trajectories().

                                                            {
   if (theMeasurementTracker == 0) {
       throw cms::Exception("LogicError") << "Asking to create trajectories to an un-initialized CkfTrajectoryBuilder.\nYou have to call clone(const MeasurementTrackerEvent *data) and then call trajectories on it instead.\n";
   }
  
   TempTrajectory && startingTraj = createStartingTrajectory( seed );
   
   limitedCandidates(seed, startingTraj, result);
   
   return startingTraj;
 
   /*
   //and remember what you just did
   if (theSharedSeedCheck)  rememberSeedAndTrajectories(seed,result);
   */
   
   // analyseResult(result);
 }

void CkfTrajectoryBuilder::findCompatibleMeasurements	(	const TrajectorySeed &	seed,
		const TempTrajectory &	traj,
		std::vector< TrajectoryMeasurement > &	result
	)		const

protectedvirtual

Reimplemented in MuonCkfTrajectoryBuilder.

Definition at line 322 of file CkfTrajectoryBuilder.cc.

References PrintoutHelper::dumpMeasurements(), TempTrajectory::empty(), TransverseImpactPointExtrapolator::extrapolate(), BaseCkfTrajectoryBuilder::findStateAndLayers(), BaseCkfTrajectoryBuilder::forwardPropagator(), i, TrajectoryStateOnSurface::isValid(), TempTrajectory::lastLayer(), LogDebug, BaseCkfTrajectoryBuilder::theEstimator, BaseCkfTrajectoryBuilder::theMeasurementTracker, tmp, and unlikely.

Referenced by limitedCandidates().

 {
   int invalidHits = 0;
   //Use findStateAndLayers which handles the hitless seed use case
   std::pair<TSOS,std::vector<const DetLayer*> > && stateAndLayers = findStateAndLayers(seed,traj);
   if (stateAndLayers.second.empty()) return;
 
   auto layerBegin = stateAndLayers.second.begin();
   auto layerEnd  = stateAndLayers.second.end();
   LogDebug("CkfPattern")<<"looping on "<< stateAndLayers.second.size()<<" layers.";
   const Propagator *fwdPropagator = forwardPropagator(seed);
   for (auto il = layerBegin;  il != layerEnd; il++) {
 
     LogDebug("CkfPattern")<<"looping on a layer in findCompatibleMeasurements.\n last layer: "<<traj.lastLayer()<<" current layer: "<<(*il);
 
     TSOS stateToUse = stateAndLayers.first;
     //Added protection before asking for the lastLayer on the trajectory
     if unlikely (!traj.empty() && (*il)==traj.lastLayer()) {
     LogDebug("CkfPattern")<<" self propagating in findCompatibleMeasurements.\n from: \n"<<stateToUse;
     //self navigation case
     // go to a middle point first
     TransverseImpactPointExtrapolator middle;
     GlobalPoint center(0,0,0);
     stateToUse = middle.extrapolate(stateToUse, center, *fwdPropagator);
     
     if (!stateToUse.isValid()) continue;
     LogDebug("CkfPattern")<<"to: "<<stateToUse;
       }
     
     LayerMeasurements layerMeasurements(theMeasurementTracker->measurementTracker(), *theMeasurementTracker);
     std::vector<TrajectoryMeasurement> && tmp = layerMeasurements.measurements((**il),stateToUse, *fwdPropagator, *theEstimator);
     
     if ( !tmp.empty()) {
       if ( result.empty()) result.swap(tmp);
       else {
     // keep one dummy TM at the end, skip the others
     result.insert( result.end()-invalidHits, 
                std::make_move_iterator(tmp.begin()), std::make_move_iterator(tmp.end()));
       }
       invalidHits++;
     }
   }
 
   // sort the final result, keep dummy measurements at the end
   if ( result.size() > 1) {
     std::sort( result.begin(), result.end()-invalidHits, TrajMeasLessEstim());
   }
 
   LogDebug("CkfPattern")<<"starting from:\n"
             <<"x: "<<stateAndLayers.first.globalPosition()<<"\n"
             <<"p: "<<stateAndLayers.first.globalMomentum()<<"\n"
             <<PrintoutHelper::dumpMeasurements(result);
 
 #ifdef DEBUG_INVALID
   bool afterInvalid = false;
   for (vector<TM>::const_iterator i=result.begin();
        i!=result.end(); i++) {
     if ( ! i->recHit().isValid()) afterInvalid = true;
     if (afterInvalid && i->recHit().isValid()) {
       edm::LogError("CkfPattern") << "CkfTrajectoryBuilder error: valid hit after invalid!" ;
     }
   }
 #endif
 
   //analyseMeasurements( result, traj);
 
 }

void CkfTrajectoryBuilder::limitedCandidates	(	const TrajectorySeed &	seed,
		TempTrajectory &	startingTraj,
		TrajectoryContainer &	result
	)		const

protected

Definition at line 172 of file CkfTrajectoryBuilder.cc.

References objects.IsoTrackAnalyzer::candidates.

Referenced by buildTrajectories().

 {
   TempTrajectoryContainer candidates;
   candidates.push_back( startingTraj);
   boost::shared_ptr<const TrajectorySeed>  sharedSeed(new TrajectorySeed(seed));
   limitedCandidates(sharedSeed, candidates,result);
 }

void CkfTrajectoryBuilder::limitedCandidates	(	const boost::shared_ptr< const TrajectorySeed > &	sharedSeed,
		TempTrajectoryContainer &	candidates,
		TrajectoryContainer &	result
	)		const

protected

Definition at line 182 of file CkfTrajectoryBuilder.cc.

References a, BaseCkfTrajectoryBuilder::addToResult(), BaseCkfTrajectoryBuilder::analyzeMeasurementsDebugger(), b, TempTrajectory::chiSquared(), IntermediateTrajectoryCleaner::clean(), PrintoutHelper::dumpCandidates(), findCompatibleMeasurements(), BaseCkfTrajectoryBuilder::forwardPropagator(), plotBeamSpotDB::last, LogDebug, TempTrajectory::lostHits(), eostools::move(), theAlwaysUseInvalidHits, BaseCkfTrajectoryBuilder::theEstimator, theIntermediateCleaning, theLostHitPenalty, theMaxCand, BaseCkfTrajectoryBuilder::theMeasurementTracker, BaseCkfTrajectoryBuilder::theTTRHBuilder, BaseCkfTrajectoryBuilder::toBeContinued(), and updateTrajectory().

 {
   unsigned int nIter=1;
   TempTrajectoryContainer newCand; // = TrajectoryContainer();
   newCand.reserve(2*theMaxCand);
 
   
   auto trajCandLess = [&](TempTrajectory const & a, TempTrajectory const & b) {
     return  (a.chiSquared() + a.lostHits()*theLostHitPenalty)  <
     (b.chiSquared() + b.lostHits()*theLostHitPenalty);
   };
   
  
   while ( !candidates.empty()) {
 
     newCand.clear();
     for (auto traj=candidates.begin(); traj!=candidates.end(); traj++) {
       std::vector<TM> meas;
       findCompatibleMeasurements(*sharedSeed, *traj, meas);
 
       // --- method for debugging
       if(!analyzeMeasurementsDebugger(*traj,meas,
                       theMeasurementTracker,
                       forwardPropagator(*sharedSeed),theEstimator,
                       theTTRHBuilder)) return;
       // ---
 
       if ( meas.empty()) {
     addToResult(sharedSeed, *traj, result);
       }
       else {
     std::vector<TM>::const_iterator last;
     if ( theAlwaysUseInvalidHits) last = meas.end();
     else {
       if (meas.front().recHit()->isValid()) {
         last = find_if( meas.begin(), meas.end(), RecHitIsInvalid());
       }
       else last = meas.end();
     }
 
     for(auto itm = meas.begin(); itm != last; itm++) {
       TempTrajectory newTraj = *traj;
       updateTrajectory( newTraj, std::move(*itm));
 
       if ( toBeContinued(newTraj)) {
         newCand.push_back(std::move(newTraj));  std::push_heap(newCand.begin(),newCand.end(),trajCandLess);
       }
       else {
         addToResult(sharedSeed, newTraj, result);
       }
     }
       }
 
 
       /*
       auto trajVal = [&](TempTrajectory const & a) {
         return  a.chiSquared() + a.lostHits()*theLostHitPenalty;
       };
 
       // safe (stable?) logig: always sort, kill exceeding only if worse than last to keep
       // if ((int)newCand.size() > theMaxCand) std::cout << "TrajVal " << theMaxCand  << ' ' << newCand.size() << ' ' <<  trajVal(newCand.front());
       int toCut = int(newCand.size()) - int(theMaxCand);
       if (toCut>0) {
         // move largest "toCut" to the end
         for (int i=0; i<toCut; ++i)
           std::pop_heap(newCand.begin(),newCand.end()-i,trajCandLess);
         auto fval = trajVal(newCand.front());
         // remove till equal to highest to keep
         for (int i=0; i<toCut; ++i) {
            if (fval==trajVal(newCand.back())) break;
            newCand.pop_back();
         }
     //assert((int)newCand.size() >= theMaxCand);
     //std::cout << "; " << newCand.size() << ' ' << trajVal(newCand.front())  << " " << trajVal(newCand.back());
 
     // std::make_heap(newCand.begin(),newCand.end(),trajCandLess);
         // push_heap again the one left
         for (auto iter = newCand.begin()+theMaxCand+1; iter<=newCand.end(); ++iter  )
       std::push_heap(newCand.begin(),iter,trajCandLess);
 
     // std::cout << "; " << newCand.size() << ' ' << trajVal(newCand.front())  << " " << trajVal(newCand.back()) << std::endl;
       }
 
       */
 
       
       // intermedeate login: always sort,  kill all exceeding
       while ((int)newCand.size() > theMaxCand) {
     std::pop_heap(newCand.begin(),newCand.end(),trajCandLess);
     // if ((int)newCand.size() == theMaxCand+1) std::cout << " " << trajVal(newCand.front())  << " " << trajVal(newCand.back()) << std::endl;
     newCand.pop_back();
        }
       
       /*
       //   original logic: sort only if > theMaxCand, kill all exceeding
       if ((int)newCand.size() > theMaxCand) {
     std::sort( newCand.begin(), newCand.end(), TrajCandLess<TempTrajectory>(theLostHitPenalty));
     // std::partial_sort( newCand.begin(), newCand.begin()+theMaxCand, newCand.end(), TrajCandLess<TempTrajectory>(theLostHitPenalty));
     std::cout << "TrajVal " << theMaxCand  << ' ' << newCand.size() << ' '
     << trajVal(newCand.back()) << ' ' << trajVal(newCand[theMaxCand-1]) << ' ' << trajVal(newCand[theMaxCand])  << std::endl;
     newCand.resize(theMaxCand);
       }
       */
 
     } // end loop on candidates
 
     std::sort_heap(newCand.begin(),newCand.end(),trajCandLess);
     if (theIntermediateCleaning) IntermediateTrajectoryCleaner::clean(newCand);
 
     candidates.swap(newCand);
     
     LogDebug("CkfPattern") <<result.size()<<" candidates after "<<nIter++<<" CKF iteration: \n"
                <<PrintoutHelper::dumpCandidates(result)
                <<"\n "<<candidates.size()<<" running candidates are: \n"
                <<PrintoutHelper::dumpCandidates(candidates);
 
   }
 }

void CkfTrajectoryBuilder::rebuildTrajectories	(	TempTrajectory const &	startingTraj,
		const TrajectorySeed &	,
		TrajectoryContainer &	result
	)		const

inlinevirtual

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 57 of file CkfTrajectoryBuilder.h.

58 {}

void CkfTrajectoryBuilder::setEvent_	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprotectedvirtual

Implements BaseCkfTrajectoryBuilder.

Definition at line 58 of file CkfTrajectoryBuilder.cc.

Referenced by MuonCkfTrajectoryBuilder::setEvent_().

58 {

59 }

CkfTrajectoryBuilder::TrajectoryContainer CkfTrajectoryBuilder::trajectories ( const TrajectorySeed & seed ) const

virtual

trajectories building starting from a seed

Implements TrajectoryBuilder.

Definition at line 62 of file CkfTrajectoryBuilder.cc.

References mps_fire::result.

 {  
   TrajectoryContainer result;
   result.reserve(5);
   trajectories(seed, result);
   return result;
 }

void CkfTrajectoryBuilder::trajectories	(	const TrajectorySeed &	seed,
		CkfTrajectoryBuilder::TrajectoryContainer &	result
	)		const

virtual

trajectories building starting from a seed

Reimplemented from TrajectoryBuilder.

Definition at line 129 of file CkfTrajectoryBuilder.cc.

References buildTrajectories().

 {  
   // analyseSeed( seed);
   /*
     if (theSharedSeedCheck){
     TempTrajectoryContainer candidates;
     if (seedAlreadyUsed(seed,candidates))
     {
     //start with those candidates already made before
     limitedCandidates(candidates,result);
     //and quit
     return;
     }
     }
   */
 
   buildTrajectories(seed, result,nullptr);
 }

void CkfTrajectoryBuilder::updateTrajectory	(	TempTrajectory &	traj,
		TM &&	tm
	)		const

protected

Definition at line 305 of file CkfTrajectoryBuilder.cc.

References TempTrajectory::emplace(), eostools::move(), BaseCkfTrajectoryBuilder::theUpdator, and TrajectoryStateUpdator::update().

Referenced by limitedCandidates().

 {
   auto && predictedState = tm.predictedState();
   auto  && hit = tm.recHit();
   if ( hit->isValid()) {
     auto && upState = theUpdator->update( predictedState, *hit);
     traj.emplace( std::move(predictedState), std::move(upState),
          std::move(hit), tm.estimate(), tm.layer()); 
   }
   else {
     traj.emplace( std::move(predictedState), std::move(hit), 0, tm.layer());
   }
 }

Member Data Documentation

bool CkfTrajectoryBuilder::theAlwaysUseInvalidHits

protected

Definition at line 71 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

bool CkfTrajectoryBuilder::theIntermediateCleaning

protected

Tells whether an intermediary cleaning stage should take place during TB.

Definition at line 69 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

float CkfTrajectoryBuilder::theLostHitPenalty

protected

Chi**2 Penalty for each lost hit.

Definition at line 68 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

int CkfTrajectoryBuilder::theMaxCand

protected

set Event for the internal MeasurementTracker data member

    Maximum number of trajectory candidates

to propagate to the next layer.

Definition at line 66 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation