#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, unsigned int &nCandPerSeed, const TrajectoryFilter *) const override

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

	CkfTrajectoryBuilder (const edm::ParameterSet &conf, edm::ConsumesCollector iC, std::unique_ptr< TrajectoryFilter > filter)

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

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

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

	~CkfTrajectoryBuilder () override

Public Member Functions inherited from BaseCkfTrajectoryBuilder
	BaseCkfTrajectoryBuilder (const edm::ParameterSet &conf, edm::ConsumesCollector iC, std::unique_ptr< TrajectoryFilter > filter, std::unique_ptr< TrajectoryFilter > inOutFilter=nullptr)

	BaseCkfTrajectoryBuilder (const BaseCkfTrajectoryBuilder &)=delete

const TransientTrackingRecHitBuilder *	hitBuilder () const

BaseCkfTrajectoryBuilder &	operator= (const BaseCkfTrajectoryBuilder &)=delete

virtual void	setDebugger (CkfDebugger *dbg) const

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

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

void	setNavigationSchool (NavigationSchool const *nv)

void	unset () const override

	~BaseCkfTrajectoryBuilder () override

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

virtual	~TrajectoryBuilder ()

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

Static Public Member Functions inherited from BaseCkfTrajectoryBuilder
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

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

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

unsigned int	limitedCandidates (const std::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 (std::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

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 = nullptr

const MeasurementTrackerEvent *	theMeasurementTracker = nullptr

const NavigationSchool *	theNavigationSchool = nullptr

const Propagator *	thePropagatorAlong = nullptr

const Propagator *	thePropagatorOpposite = nullptr

const TransientTrackingRecHitBuilder *	theTTRHBuilder = nullptr

const TrajectoryStateUpdator *	theUpdator = nullptr

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 std::unique_ptr< TrajectoryFilter >	createTrajectoryFilter (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)

Detailed Description

Definition at line 33 of file CkfTrajectoryBuilder.h.

Member Typedef Documentation

◆ TempTrajectoryContainer

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

Definition at line 36 of file CkfTrajectoryBuilder.h.

◆ TrajectoryContainer

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

Definition at line 35 of file CkfTrajectoryBuilder.h.

Constructor & Destructor Documentation

◆ CkfTrajectoryBuilder() [1/2]

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

Definition at line 31 of file CkfTrajectoryBuilder.cc.

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

◆ CkfTrajectoryBuilder() [2/2]

CkfTrajectoryBuilder::CkfTrajectoryBuilder	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector	iC,
		std::unique_ptr< TrajectoryFilter >	filter
	)

Definition at line 37 of file CkfTrajectoryBuilder.cc.

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

     : BaseCkfTrajectoryBuilder(conf, iC, std::move(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::~CkfTrajectoryBuilder ( )

inlineoverride

Definition at line 43 of file CkfTrajectoryBuilder.h.

43 {}

Member Function Documentation

◆ buildTrajectories()

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

overridevirtual

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

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 160 of file CkfTrajectoryBuilder.cc.

References BaseCkfTrajectoryBuilder::createStartingTrajectory(), Exception, limitedCandidates(), mps_fire::result, fileCollector::seed, and BaseCkfTrajectoryBuilder::theMeasurementTracker.

Referenced by trajectories().

                                                                                       {
   if (theMeasurementTracker == nullptr) {
     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);
 
   nCandPerSeed = limitedCandidates(seed, startingTraj, result);
 
   return startingTraj;
 
   /*
   //and remember what you just did
   if (theSharedSeedCheck)  rememberSeedAndTrajectories(seed,result);
   */
 
   // analyseResult(result);
 }

◆ fillPSetDescription()

void CkfTrajectoryBuilder::fillPSetDescription ( edm::ParameterSetDescription & iDesc )

static

Definition at line 54 of file CkfTrajectoryBuilder.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), and BaseCkfTrajectoryBuilder::fillPSetDescription().

Referenced by MuonCkfTrajectoryBuilder::fillPSetDescription().

                                                                                 {
   BaseCkfTrajectoryBuilder::fillPSetDescription(iDesc);
   iDesc.add<int>("maxCand", 5);
   iDesc.add<double>("lostHitPenalty", 30.);
   iDesc.add<bool>("intermediateCleaning", true);
   iDesc.add<bool>("alwaysUseInvalidHits", true);
 
   edm::ParameterSetDescription psdTF;
   psdTF.addNode(edm::PluginDescription<TrajectoryFilterFactory>("ComponentType", true));
   iDesc.add<edm::ParameterSetDescription>("trajectoryFilter", psdTF);
 }

◆ findCompatibleMeasurements()

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

protectedvirtual

Reimplemented in MuonCkfTrajectoryBuilder.

Definition at line 329 of file CkfTrajectoryBuilder.cc.

References PrintoutHelper::dumpMeasurements(), TempTrajectory::empty(), TransverseImpactPointExtrapolator::extrapolate(), BaseCkfTrajectoryBuilder::findStateAndLayers(), BaseCkfTrajectoryBuilder::forwardPropagator(), mps_fire::i, TrajectoryStateOnSurface::isValid(), TempTrajectory::lastLayer(), LogDebug, mps_fire::result, fileCollector::seed, jetsAK4_CHS_cff::sort, BaseCkfTrajectoryBuilder::theEstimator, BaseCkfTrajectoryBuilder::theMeasurementTracker, createJobs::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);
 }

◆ limitedCandidates() [1/2]

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

protected

Definition at line 186 of file CkfTrajectoryBuilder.cc.

References HLT_2022v15_cff::candidates, mps_fire::result, and fileCollector::seed.

Referenced by buildTrajectories().

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

◆ limitedCandidates() [2/2]

unsigned int CkfTrajectoryBuilder::limitedCandidates	(	const std::shared_ptr< const TrajectorySeed > &	sharedSeed,
		TempTrajectoryContainer &	candidates,
		TrajectoryContainer &	result
	)		const

protected

Definition at line 195 of file CkfTrajectoryBuilder.cc.

References a, BaseCkfTrajectoryBuilder::addToResult(), BaseCkfTrajectoryBuilder::analyzeMeasurementsDebugger(), b, HLT_2022v15_cff::candidates, IntermediateTrajectoryCleaner::clean(), PrintoutHelper::dumpCandidates(), findCompatibleMeasurements(), BaseCkfTrajectoryBuilder::forwardPropagator(), dqmdumpme::last, LogDebug, eostools::move(), mps_fire::result, theAlwaysUseInvalidHits, BaseCkfTrajectoryBuilder::theEstimator, theIntermediateCleaning, theLostHitPenalty, theMaxCand, BaseCkfTrajectoryBuilder::theMeasurementTracker, BaseCkfTrajectoryBuilder::theTTRHBuilder, BaseCkfTrajectoryBuilder::toBeContinued(), and updateTrajectory().

                                                                                         {
   unsigned int nIter = 1;
   unsigned int nCands = 0;  // ignore startingTraj
   unsigned int prevNewCandSize = 0;
   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 nCands;
       // ---
 
       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(), [](auto const& meas) { return !meas.recHit()->isValid(); });
           } 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);
           }
         }
       }
 
       // account only new candidates, i.e.
       // - 1 candidate -> 1 candidate, don't increase count
       // - 1 candidate -> 2 candidates, increase count by 1
       nCands += newCand.size() - prevNewCandSize;
       prevNewCandSize = newCand.size();
 
       /*
       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);
   }
   return nCands;
 }

◆ rebuildTrajectories()

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

inlineoverridevirtual

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 58 of file CkfTrajectoryBuilder.h.

60 {}

◆ setEvent_()

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

overrideprotectedvirtual

Implements BaseCkfTrajectoryBuilder.

Definition at line 73 of file CkfTrajectoryBuilder.cc.

Referenced by MuonCkfTrajectoryBuilder::setEvent_().

73 {}

◆ trajectories() [1/2]

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

overridevirtual

trajectories building starting from a seed

Implements TrajectoryBuilder.

Definition at line 75 of file CkfTrajectoryBuilder.cc.

References mps_fire::result, and fileCollector::seed.

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

◆ trajectories() [2/2]

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

overridevirtual

trajectories building starting from a seed

Reimplemented from TrajectoryBuilder.

Definition at line 140 of file CkfTrajectoryBuilder.cc.

References buildTrajectories(), mps_fire::result, fileCollector::seed, and createJobs::tmp.

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

◆ updateTrajectory()

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

protected

Definition at line 318 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(predictedState, std::move(upState), hit, tm.estimate(), tm.layer());
   } else {
     traj.emplace(predictedState, hit, 0, tm.layer());
   }
 }

Member Data Documentation

◆ theAlwaysUseInvalidHits

bool CkfTrajectoryBuilder::theAlwaysUseInvalidHits

protected

Definition at line 71 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

◆ theIntermediateCleaning

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

◆ theLostHitPenalty

float CkfTrajectoryBuilder::theLostHitPenalty

protected

Chi**2 Penalty for each lost hit.

Definition at line 68 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

◆ theMaxCand

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

Static Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ TempTrajectoryContainer

◆ TrajectoryContainer

Constructor & Destructor Documentation

◆ CkfTrajectoryBuilder() [1/2]

◆ CkfTrajectoryBuilder() [2/2]

◆ ~CkfTrajectoryBuilder()

Member Function Documentation

◆ buildTrajectories()

◆ fillPSetDescription()

◆ findCompatibleMeasurements()

◆ limitedCandidates() [1/2]

◆ limitedCandidates() [2/2]

◆ rebuildTrajectories()

◆ setEvent_()

◆ trajectories() [1/2]

◆ trajectories() [2/2]

◆ updateTrajectory()

Member Data Documentation

◆ theAlwaysUseInvalidHits

◆ theIntermediateCleaning

◆ theLostHitPenalty

◆ theMaxCand