#include <GroupedCkfTrajectoryBuilder.h>

Inheritance diagram for GroupedCkfTrajectoryBuilder:

Public Member Functions
TempTrajectory	buildTrajectories (const TrajectorySeed &seed, TrajectoryContainer &ret, unsigned int &nCandPerSeed, const TrajectoryFilter *) const override
	common part of both public trajectory building methods More...

double	chiSquareCut ()

const Chi2MeasurementEstimatorBase &	estimator () const

	GroupedCkfTrajectoryBuilder (const edm::ParameterSet &conf, edm::ConsumesCollector &iC)
	constructor from ParameterSet More...

float	lostHitPenalty ()

double	mass ()
	Mass hypothesis used for propagation. More...

int	maxCand ()

double	ptCut ()
	Pt cut. More...

void	rebuildSeedingRegion (const TrajectorySeed &, TrajectoryContainer &result) const override

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

TrajectoryContainer	trajectories (const TrajectorySeed &) const override
	set Event for the internal MeasurementTracker data member More...

void	trajectories (const TrajectorySeed &, TrajectoryContainer &ret) const override
	trajectories building starting from a seed, return in an already allocated vector More...

TrajectoryContainer	trajectories (const TrajectorySeed &, const TrackingRegion &) const
	trajectories building starting from a seed with a region More...

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

const TrajectoryStateUpdator &	updator () const

	~GroupedCkfTrajectoryBuilder () override
	destructor More...

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	~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	analyseMeasurements (const std::vector< TM > &meas, const Trajectory &traj) const

virtual void	analyseResult (const TrajectoryContainer &result) const

virtual void	analyseSeed (const TrajectorySeed &seed) const

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

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

Private Types
enum	work_MaxSize_Size_ { work_MaxSize_ = 50 }

Private Member Functions
bool	advanceOneLayer (const TrajectorySeed &seed, TempTrajectory &traj, const TrajectoryFilter regionalCondition, const Propagator propagator, bool inOut, TempTrajectoryContainer &newCand, TempTrajectoryContainer &result) const

TempTrajectory	backwardFit (TempTrajectory &candidate, unsigned int nSeed, const TrajectoryFitter &fitter, std::vector< const TrackingRecHit *> &remainingHits) const

void	groupedIntermediaryClean (TempTrajectoryContainer &theTrajectories) const
	intermediate cleaning in the case of grouped measurements More...

unsigned int	groupedLimitedCandidates (const TrajectorySeed &seed, TempTrajectory const &startingTraj, const TrajectoryFilter regionalCondition, const Propagator propagator, bool inOut, TempTrajectoryContainer &result) const

void	rebuildSeedingRegion (const TrajectorySeed &seed, TempTrajectory const &startingTraj, TempTrajectoryContainer &result) const
	try to find additional hits in seeding region More...

int	rebuildSeedingRegion (const TrajectorySeed &seed, const std::vector< const TrackingRecHit *> &seedHits, TempTrajectory &candidate, TempTrajectoryContainer &result) const

bool	tkxor (bool a, bool b) const

bool	verifyHits (TempTrajectory::DataContainer::const_iterator rbegin, size_t maxDepth, const std::vector< const TrackingRecHit *> &hits) const
	Verifies presence of a RecHits in a range of TrajectoryMeasurements. More...

Static Private Member Functions
static PropagationDirection	oppositeDirection (PropagationDirection dir)
	change of propagation direction More...

Private Attributes
float	maxDPhiForLooperReconstruction

float	maxPt2ForLooperReconstruction

bool	theAlwaysUseInvalid

bool	theBestHitOnly

double	theChiSquareCut

TrajectoryFilter *	theConfigurableCondition

float	theFoundHitBonus

bool	theIntermediateCleaning

bool	theKeepOriginalIfRebuildFails

bool	theLockHits

float	theLostHitPenalty

double	theMass

int	theMaxCand

unsigned int	theMinNrOf2dHitsForRebuild

unsigned int	theMinNrOfHitsForRebuild

double	theptCut

bool	theRequireSeedHitsInRebuild

Additional Inherited Members
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

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)

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

Detailed Description

A highly configurable trajectory builder that allows full exploration of the combinatorial tree of possible continuations, and provides efficient ways of trimming the combinatorial tree.

Definition at line 22 of file GroupedCkfTrajectoryBuilder.h.

Member Enumeration Documentation

◆ work_MaxSize_Size_

enum GroupedCkfTrajectoryBuilder::work_MaxSize_Size_

private

Enumerator
work_MaxSize_

Definition at line 202 of file GroupedCkfTrajectoryBuilder.h.

                           {
     work_MaxSize_ = 50
   };  // if it grows above this number, it is forced to resize to half this amount when cleared

Constructor & Destructor Documentation

◆ GroupedCkfTrajectoryBuilder()

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

constructor from ParameterSet

Definition at line 114 of file GroupedCkfTrajectoryBuilder.cc.

References edm::ParameterSet::getParameter(), SiStripPI::max, maxDPhiForLooperReconstruction, maxPt2ForLooperReconstruction, theAlwaysUseInvalid, theBestHitOnly, theFoundHitBonus, theIntermediateCleaning, theKeepOriginalIfRebuildFails, theLockHits, theLostHitPenalty, theMaxCand, theMinNrOf2dHitsForRebuild, theMinNrOfHitsForRebuild, and theRequireSeedHitsInRebuild.

     : BaseCkfTrajectoryBuilder(conf,
                                iC,
                                BaseCkfTrajectoryBuilder::createTrajectoryFilter(
                                    conf.getParameter<edm::ParameterSet>("trajectoryFilter"), iC),
                                conf.getParameter<bool>("useSameTrajFilter")
                                    ? BaseCkfTrajectoryBuilder::createTrajectoryFilter(
                                          conf.getParameter<edm::ParameterSet>("trajectoryFilter"), iC)
                                    : BaseCkfTrajectoryBuilder::createTrajectoryFilter(
                                          conf.getParameter<edm::ParameterSet>("inOutTrajectoryFilter"), iC)) {
   // fill data members from parameters (eventually data members could be dropped)
   //
   theMaxCand = conf.getParameter<int>("maxCand");
   theLostHitPenalty = conf.getParameter<double>("lostHitPenalty");
   theFoundHitBonus = conf.getParameter<double>("foundHitBonus");
   theIntermediateCleaning = conf.getParameter<bool>("intermediateCleaning");
   theAlwaysUseInvalid = conf.getParameter<bool>("alwaysUseInvalidHits");
   theLockHits = conf.getParameter<bool>("lockHits");
   theBestHitOnly = conf.getParameter<bool>("bestHitOnly");
   theMinNrOf2dHitsForRebuild = 2;
   theRequireSeedHitsInRebuild = conf.getParameter<bool>("requireSeedHitsInRebuild");
   theKeepOriginalIfRebuildFails = conf.getParameter<bool>("keepOriginalIfRebuildFails");
   theMinNrOfHitsForRebuild = max(0, conf.getParameter<int>("minNrOfHitsForRebuild"));
   maxPt2ForLooperReconstruction = conf.getParameter<double>("maxPtForLooperReconstruction");
   maxPt2ForLooperReconstruction *= maxPt2ForLooperReconstruction;
   maxDPhiForLooperReconstruction = conf.getParameter<double>("maxDPhiForLooperReconstruction");
 
   /* ======= B.M. to be ported layer ===========
   bool setOK = thePropagator->setMaxDirectionChange(1.6);
   if (!setOK) 
     cout  << "GroupedCkfTrajectoryBuilder WARNING: "
       << "propagator does not support setMaxDirectionChange" 
       << endl;
   //   addStopCondition(theMinPtStopCondition);
 
   theConfigurableCondition = createAlgo<TrajectoryFilter>(componentConfig("StopCondition"));
   ===================================== */
 }

◆ ~GroupedCkfTrajectoryBuilder()

GroupedCkfTrajectoryBuilder::~GroupedCkfTrajectoryBuilder ( )

inlineoverride

destructor

Definition at line 28 of file GroupedCkfTrajectoryBuilder.h.

28 {}

Member Function Documentation

◆ advanceOneLayer()

bool GroupedCkfTrajectoryBuilder::advanceOneLayer	(	const TrajectorySeed &	seed,
		TempTrajectory &	traj,
		const TrajectoryFilter *	regionalCondition,
		const Propagator *	propagator,
		bool	inOut,
		TempTrajectoryContainer &	newCand,
		TempTrajectoryContainer &	result
	)		const

private

Definition at line 477 of file GroupedCkfTrajectoryBuilder.cc.

Referenced by groupedLimitedCandidates().

                                                                                          {
   std::pair<TSOS, std::vector<const DetLayer*> >&& stateAndLayers = findStateAndLayers(seed, traj);
 
   if (maxPt2ForLooperReconstruction > 0) {
     if (
         //stateAndLayers.second.size()==0 &&
         traj.lastLayer()->location() == 0) {
       float pt2 = stateAndLayers.first.globalMomentum().perp2();
       if (pt2 < maxPt2ForLooperReconstruction && pt2 > (0.3f * 0.3f))
         stateAndLayers.second.push_back(traj.lastLayer());
     }
   }
 
   auto layerBegin = stateAndLayers.second.begin();
   auto layerEnd = stateAndLayers.second.end();
 
   //   if (nl.empty()) {
   //     addToResult(traj,result,inOut);
   //     return false;
   //   }
 
 #ifdef EDM_ML_DEBUG
   LogDebug("CkfPattern") << whatIsTheNextStep(traj, stateAndLayers);
 #endif
 
   bool foundSegments(false);
   bool foundNewCandidates(false);
   for (auto il = layerBegin; il != layerEnd; il++) {
     TSOS stateToUse = stateAndLayers.first;
 
     double dPhiCacheForLoopersReconstruction(0);
     if UNLIKELY (!traj.empty() && (*il) == traj.lastLayer()) {
       if (maxPt2ForLooperReconstruction > 0) {
         // ------ For loopers reconstruction
         //cout<<" self propagating in advanceOneLayer (for loopers) \n";
         const BarrelDetLayer* sbdl = dynamic_cast<const BarrelDetLayer*>(traj.lastLayer());
         if (sbdl) {
           HelixBarrelCylinderCrossing cylinderCrossing(stateToUse.globalPosition(),
                                                        stateToUse.globalMomentum(),
                                                        stateToUse.transverseCurvature(),
                                                        propagator->propagationDirection(),
                                                        sbdl->specificSurface());
           if (!cylinderCrossing.hasSolution())
             continue;
           GlobalPoint starting = stateToUse.globalPosition();
           GlobalPoint target1 = cylinderCrossing.position1();
           GlobalPoint target2 = cylinderCrossing.position2();
 
           GlobalPoint farther =
               fabs(starting.phi() - target1.phi()) > fabs(starting.phi() - target2.phi()) ? target1 : target2;
 
           const Bounds& bounds(sbdl->specificSurface().bounds());
           float length = 0.5f * bounds.length();
 
           /*
           cout << "starting: " << starting << endl;
           cout << "target1: " << target1 << endl;
           cout << "target2: " << target2 << endl;
           cout << "dphi: " << (target1.phi()-target2.phi()) << endl;
         cout << "length: " << length << endl;
         */
 
           /*
           float deltaZ = bounds.thickness()/2.f/fabs(tan(stateToUse.globalDirection().theta()) ) ;
           if(stateToUse.hasError())
           deltaZ += 3*sqrt(stateToUse.cartesianError().position().czz());
           if( fabs(farther.z()) > length + deltaZ ) continue;
         */
           if (fabs(farther.z()) * 0.95f > length)
             continue;
 
           Geom::Phi<float> tmpDphi = target1.phi() - target2.phi();
           if (std::abs(tmpDphi) > maxDPhiForLooperReconstruction)
             continue;
           GlobalPoint target(0.5f * (target1.basicVector() + target2.basicVector()));
           //cout << "target: " << target << endl;
 
           TransverseImpactPointExtrapolator extrapolator;
           stateToUse = extrapolator.extrapolate(stateToUse, target, *propagator);
           if (!stateToUse.isValid())
             continue;  //SK: consider trying the original? probably not
 
           //dPhiCacheForLoopersReconstruction = fabs(target1.phi()-target2.phi())*2.;
           dPhiCacheForLoopersReconstruction = std::abs(tmpDphi);
           traj.incrementLoops();
         } else {  // not barrel
           continue;
         }
       } else {  // loopers not requested (why else???)
                 // ------ For cosmics reconstruction
         LogDebug("CkfPattern") << " self propagating in advanceOneLayer.\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, *(forwardPropagator(seed)));
 
         if (!stateToUse.isValid())
           continue;
         LogDebug("CkfPattern") << "to: " << stateToUse;
       }
     }  // last layer...
 
     //unsigned int maxCandidates = theMaxCand > 21 ? theMaxCand*2 : 42; //limit the number of returned segments
     LayerMeasurements layerMeasurements(theMeasurementTracker->measurementTracker(), *theMeasurementTracker);
     TrajectorySegmentBuilder layerBuilder(
         &layerMeasurements, **il, *propagator, *theUpdator, *theEstimator, theLockHits, theBestHitOnly, theMaxCand);
 
 #ifdef EDM_ML_DEBUG
     LogDebug("CkfPattern") << whatIsTheStateToUse(stateAndLayers.first, stateToUse, *il);
 #endif
 
     auto&& segments = layerBuilder.segments(stateToUse);
 
     LogDebug("CkfPattern") << "GCTB: number of segments = " << segments.size();
 
     if (!segments.empty())
       foundSegments = true;
 
     for (auto is = segments.begin(); is != segments.end(); is++) {
       //
       // assume "invalid hit only" segment is last in list
       //
       auto const& measurements = is->measurements();
       if (!theAlwaysUseInvalid && is != segments.begin() && measurements.size() == 1 &&
           (measurements.front().recHit()->getType() == TrackingRecHit::missing))
         break;
 
       //----  avoid to add the same hits more than once in the trajectory ----
       bool toBeRejected(false);
       for (auto revIt = measurements.rbegin(); revIt != measurements.rend(); --revIt) {
         // int tmpCounter(0);
         for (auto newTrajMeasIt = traj.measurements().rbegin(); newTrajMeasIt != traj.measurements().rend();
              --newTrajMeasIt) {
           //if(tmpCounter==2) break;
           if (revIt->recHitR().geographicalId() == newTrajMeasIt->recHitR().geographicalId() &&
               (revIt->recHitR().geographicalId() != DetId(0))) {
             toBeRejected = true;
             goto rejected;  //break;  // see http://stackoverflow.com/questions/1257744/can-i-use-break-to-exit-multiple-nested-for-loops
           }
           // tmpCounter++;
         }
       }
 
     rejected:;  // http://xkcd.com/292/
       if (toBeRejected) {
 #ifdef VI_DEBUG
         cout << "WARNING: neglect candidate because it contains the same hit twice \n";
         cout << "-- discarded track's pt,eta,#found/lost: "
              << traj.lastMeasurement().updatedState().globalMomentum().perp() << " , "
              << traj.lastMeasurement().updatedState().globalMomentum().eta() << " , " << traj.foundHits() << '/'
              << traj.lostHits() << "\n";
 #endif
         traj.setDPhiCacheForLoopersReconstruction(dPhiCacheForLoopersReconstruction);
         continue;  //Are we sure about this????
       }
       // ------------------------
 
       //
       // create new candidate
       //
       TempTrajectory newTraj(traj);
       traj.setDPhiCacheForLoopersReconstruction(dPhiCacheForLoopersReconstruction);
       newTraj.join(*is);
 
       //std::cout << "DEBUG: newTraj after push found,lost: "
       //      << newTraj.foundHits() << " , "
       //      << newTraj.lostHits() << " , "
       //      << newTraj.measurements().size() << std::endl;
 
       //GIO// for ( vector<TM>::const_iterator im=measurements.begin();
       //GIO//        im!=measurements.end(); im++ )  newTraj.push(*im);
       //if ( toBeContinued(newTraj,regionalCondition) ) { TOBE FIXED
       if (toBeContinued(newTraj, inOut)) {
         // Have added one more hit to track candidate
 
         LogDebug("CkfPattern") << "GCTB: adding updated trajectory to candidates: inOut=" << inOut
                                << " hits=" << newTraj.foundHits();
 
         newTraj.setStopReason(StopReason::NOT_STOPPED);
         newCand.push_back(std::move(newTraj));
         foundNewCandidates = true;
       } else {
         // Have finished building this track. Check if it passes cuts.
 
         LogDebug("CkfPattern") << "GCTB: adding completed trajectory to results if passes cuts: inOut=" << inOut
                                << " hits=" << newTraj.foundHits();
         moveToResult(std::move(newTraj), result, inOut);
       }
     }  // loop over segs
   }    // loop over layers
 
   if (!foundSegments) {
     LogDebug("CkfPattern") << "GCTB: adding input trajectory to result";
     if (!stateAndLayers.second.empty())
       traj.setStopReason(StopReason::NO_SEGMENTS_FOR_VALID_LAYERS);
     addToResult(traj, result, inOut);
   }
   return foundNewCandidates;
 }

◆ analyseMeasurements()

virtual void GroupedCkfTrajectoryBuilder::analyseMeasurements	(	const std::vector< TM > &	meas,
		const Trajectory &	traj
	)		const

inlineprotectedvirtual

Definition at line 96 of file GroupedCkfTrajectoryBuilder.h.

96 {}

◆ analyseResult()

virtual void GroupedCkfTrajectoryBuilder::analyseResult ( const TrajectoryContainer & result ) const

inlineprotectedvirtual

Definition at line 97 of file GroupedCkfTrajectoryBuilder.h.

Referenced by buildTrajectories().

97 {}

◆ analyseSeed()

virtual void GroupedCkfTrajectoryBuilder::analyseSeed ( const TrajectorySeed & seed ) const

inlineprotectedvirtual

Definition at line 94 of file GroupedCkfTrajectoryBuilder.h.

Referenced by buildTrajectories().

94 {}

◆ backwardFit()

TempTrajectory GroupedCkfTrajectoryBuilder::backwardFit	(	TempTrajectory &	candidate,
		unsigned int	nSeed,
		const TrajectoryFitter &	fitter,
		std::vector< const TrackingRecHit *> &	remainingHits
	)		const

private

Definition at line 1014 of file GroupedCkfTrajectoryBuilder.cc.

References TempTrajectory::direction(), Trajectory::direction(), PrintoutHelper::dumpMeasurement(), PrintoutHelper::dumpMeasurements(), Trajectory::firstMeasurement(), TrajectoryFitter::fitOne(), TempTrajectory::foundHits(), Trajectory::isValid(), LIKELY, LogDebug, SiStripPI::max, TempTrajectory::measurements(), Trajectory::measurements(), ALCARECOTkAlBeamHalo_cff::nHitMin, TempTrajectory::nLoops(), Trajectory::nLoops(), oppositeDirection(), Trajectory::push(), Trajectory::recHits(), TrajectoryStateOnSurface::rescaleError(), TempTrajectory::setNLoops(), Trajectory::setNLoops(), cmsutils::bqueue< T >::size(), theMinNrOfHitsForRebuild, UNLIKELY, and TrajectoryMeasurement::updatedState().

Referenced by rebuildSeedingRegion().

                                                                                                                {
   //
   // clear array of non-fitted hits
   //
   remainingHits.clear();
 
   LogDebug("CkfPattern") << "nSeed " << nSeed << endl
                          << "Old traj direction = " << candidate.direction() << endl
                          << PrintoutHelper::dumpMeasurements(candidate.measurements());
 
   //
   // backward fit trajectory.
   // (Will try to fit only hits outside the seeding region. However,
   // if there are not enough of these, it will also use the seeding hits).
   //
   //   const unsigned int nHitAllMin(5);
   //   const unsigned int nHit2dMin(2);
   unsigned int nHit(0);  // number of valid hits after seeding region
   //unsigned int nHit2d(0);  // number of valid hits after seeding region with 2D info
   // use all hits except the first n (from seed), but require minimum
   // specified in configuration.
   //  Swapped over next two lines.
   unsigned int nHitMin = std::max(candidate.foundHits() - nSeed, theMinNrOfHitsForRebuild);
   //  unsigned int nHitMin = oldMeasurements.size()-nSeed;
   // we want to rebuild only if the number of VALID measurements excluding the seed measurements is higher than the cut
   if UNLIKELY (nHitMin < theMinNrOfHitsForRebuild)
     return TempTrajectory();
 
   LogDebug("CkfPattern") /* << "nHitMin " << nHitMin*/ << "Sizes: " << candidate.measurements().size() << " / ";
   //
   // create input trajectory for backward fit
   //
   Trajectory fwdTraj(oppositeDirection(candidate.direction()));
   fwdTraj.setNLoops(candidate.nLoops());
   //const TrajectorySeed seed = TrajectorySeed(PTrajectoryStateOnDet(), TrajectorySeed::recHitContainer(), oppositeDirection(candidate.direction()));
   //Trajectory fwdTraj(seed, oppositeDirection(candidate.direction()));
 
   const DetLayer* bwdDetLayer[candidate.measurements().size()];
   int nl = 0;
   for (auto const& tm : candidate.measurements()) {
     const TrackingRecHit* hit = tm.recHitR().hit();
     //
     // add hits until required number is reached
     //
     if (nHit < nHitMin) {  //|| nHit2d<theMinNrOf2dHitsForRebuild ) {
       fwdTraj.push(tm);
       bwdDetLayer[nl++] = tm.layer();
       //
       // count valid / 2D hits
       //
       if LIKELY (hit->isValid()) {
         nHit++;
         //if ( hit.isMatched() ||
         //     hit.det().detUnits().front()->type().module()==pixel )
         //nHit2d++;
       }
     }
     //if (nHit==nHitMin) lastBwdDetLayer=im->layer();
     //
     // keep remaining (valid) hits for verification
     //
     else if (hit->isValid()) {
       //std::cout << "Adding a remaining hit" << std::endl;
       remainingHits.push_back(hit);
     }
   }
   //
   // Fit only if required number of valid hits can be used
   //
   if UNLIKELY (nHit < nHitMin)
     return TempTrajectory();
 
   //
   // Do the backward fit (important: start from scaled, not random cov. matrix!)
   //
   TrajectoryStateOnSurface firstTsos(fwdTraj.firstMeasurement().updatedState());
   //cout << "firstTsos "<< firstTsos << endl;
   firstTsos.rescaleError(10.);
   //TrajectoryContainer bwdFitted(fitter.fit(fwdTraj.seed(),fwdTraj.recHits(),firstTsos));
   Trajectory&& bwdFitted =
       fitter.fitOne(TrajectorySeed({}, {}, oppositeDirection(candidate.direction())), fwdTraj.recHits(), firstTsos);
   if UNLIKELY (!bwdFitted.isValid())
     return TempTrajectory();
 
   LogDebug("CkfPattern") << "Obtained bwdFitted trajectory with measurement size " << bwdFitted.measurements().size();
   TempTrajectory fitted(fwdTraj.direction(), nSeed);
   fitted.setNLoops(fwdTraj.nLoops());
   vector<TM> const& tmsbf = bwdFitted.measurements();
   int iDetLayer = 0;
   //this is ugly but the TM in the fitted track do not contain the DetLayer.
   //So we have to cache the detLayer pointers and replug them in.
   //For the backward building it would be enaugh to cache the last DetLayer,
   //but for the intermediary cleaning we need all
   for (vector<TM>::const_iterator im = tmsbf.begin(); im != tmsbf.end(); im++) {
     fitted.emplace((*im).forwardPredictedState(),
                    (*im).backwardPredictedState(),
                    (*im).updatedState(),
                    (*im).recHit(),
                    (*im).estimate(),
                    bwdDetLayer[iDetLayer]);
 
     LogDebug("CkfPattern") << PrintoutHelper::dumpMeasurement(*im);
     iDetLayer++;
   }
   /*
     TM lastMeas = bwdFitted.front().lastMeasurement();
     fitted.pop();
     fitted.push(TM(lastMeas.forwardPredictedState(), 
     lastMeas.backwardPredictedState(), 
     lastMeas.updatedState(),
     lastMeas.recHit(),
     lastMeas.estimate(),
     lastBwdDetLayer));
   */
 
   return fitted;
 }

◆ buildTrajectories()

TempTrajectory GroupedCkfTrajectoryBuilder::buildTrajectories	(	const TrajectorySeed &	seed,
		GroupedCkfTrajectoryBuilder::TrajectoryContainer &	result,
		unsigned int &	nCandPerSeed,
		const TrajectoryFilter *	regionalCondition
	)		const

overridevirtual

common part of both public trajectory building methods

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 262 of file GroupedCkfTrajectoryBuilder.cc.

References analyseResult(), analyseSeed(), HltBtagPostValidation_cff::c, FastTrajectoryCleaner::clean(), runTheMatrix::const, gather_cfg::cout, BaseCkfTrajectoryBuilder::createStartingTrajectory(), Exception, BaseCkfTrajectoryBuilder::forwardPropagator(), groupedLimitedCandidates(), trackerHitRTTI::isFromDet(), trackerHitRTTI::isUndef(), LogDebug, mps_fire::result, fileCollector::seed, theFoundHitBonus, theLostHitPenalty, BaseCkfTrajectoryBuilder::theMeasurementTracker, and work_MaxSize_.

Referenced by trajectories().

                                                                                                                {
   if (theMeasurementTracker == nullptr) {
     throw cms::Exception("LogicError")
         << "Asking to create trajectories to an un-initialized GroupedCkfTrajectoryBuilder.\nYou have to call "
            "clone(const MeasurementTrackerEvent *data) and then call trajectories on it instead.\n";
   }
 
   statCount.seed();
   //
   // Build trajectory outwards from seed
   //
 
   analyseSeed(seed);
 
   TempTrajectory const& startingTraj = createStartingTrajectory(seed);
 
   work_.clear();
   const bool inOut = true;
   nCandPerSeed = groupedLimitedCandidates(seed, startingTraj, regionalCondition, forwardPropagator(seed), inOut, work_);
   if (work_.empty())
     return startingTraj;
 
   // cleaning now done here...
   FastTrajectoryCleaner cleaner(theFoundHitBonus, theLostHitPenalty);
   cleaner.clean(work_);
 
   std::shared_ptr<const TrajectorySeed> pseed(new TrajectorySeed(seed));
   for (auto const& it : work_)
     if (it.isValid()) {
       result.push_back(it.toTrajectory());
       result.back().setSharedSeed(pseed);
     }
   work_.clear();
   if (work_.capacity() > work_MaxSize_) {
     TempTrajectoryContainer().swap(work_);
     work_.reserve(work_MaxSize_ / 2);
   }
 
   analyseResult(result);
 
   LogDebug("CkfPattern") << "GroupedCkfTrajectoryBuilder: returning result of size " << result.size();
   statCount.traj(result.size());
 
 #ifdef VI_DEBUG
   int kt = 0;
   for (auto const& traj : result) {
     int chit[7] = {};
     for (auto const& tm : traj.measurements()) {
       auto const& hit = tm.recHitR();
       if (!hit.isValid())
         ++chit[0];
       if (hit.det() == nullptr)
         ++chit[1];
       if (trackerHitRTTI::isUndef(hit))
         continue;
       if (hit.dimension() != 2) {
         ++chit[2];
       } else if (trackerHitRTTI::isFromDet(hit)) {
         auto const& thit = static_cast<BaseTrackerRecHit const&>(hit);
         auto const& clus = thit.firstClusterRef();
         if (clus.isPixel())
           ++chit[3];
         else if (thit.isMatched()) {
           ++chit[4];
         } else if (thit.isProjected()) {
           ++chit[5];
         } else {
           ++chit[6];
         }
       }
     }
 
     std::cout << "ckf " << kt++ << ": ";
     for (auto c : chit)
       std::cout << c << '/';
     std::cout << std::endl;
   }
 #endif
 
   return startingTraj;
 }

◆ chiSquareCut()

double GroupedCkfTrajectoryBuilder::chiSquareCut ( )

inline

Chi**2 Cut on the new Trajectory Measurements to consider

Definition at line 74 of file GroupedCkfTrajectoryBuilder.h.

74 { return theChiSquareCut; }

GroupedCkfTrajectoryBuilder::theChiSquareCut

double theChiSquareCut

Definition: GroupedCkfTrajectoryBuilder.h:166

◆ estimator()

const Chi2MeasurementEstimatorBase& GroupedCkfTrajectoryBuilder::estimator ( void ) const

inline

Definition at line 69 of file GroupedCkfTrajectoryBuilder.h.

References BaseCkfTrajectoryBuilder::theEstimator.

Referenced by rebuildSeedingRegion().

69 { return *theEstimator; }

BaseCkfTrajectoryBuilder::theEstimator

const Chi2MeasurementEstimatorBase * theEstimator

Definition: BaseCkfTrajectoryBuilder.h:180

◆ fillPSetDescription()

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

static

Definition at line 153 of file GroupedCkfTrajectoryBuilder.cc.

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

                                                                                        {
   BaseCkfTrajectoryBuilder::fillPSetDescription(iDesc);
 
   iDesc.add<bool>("useSameTrajFilter", true);
   iDesc.add<int>("maxCand", 5);
   iDesc.add<double>("lostHitPenalty", 30.);
   iDesc.add<double>("foundHitBonus", 10.);
   iDesc.add<bool>("intermediateCleaning", true);
   iDesc.add<bool>("alwaysUseInvalidHits", true);
   iDesc.add<bool>("lockHits", true);
   iDesc.add<bool>("bestHitOnly", true);
   iDesc.add<bool>("requireSeedHitsInRebuild", true);
   iDesc.add<bool>("keepOriginalIfRebuildFails", false);
   iDesc.add<int>("minNrOfHitsForRebuild", 5);
   iDesc.add<double>("maxPtForLooperReconstruction", 0.);
   iDesc.add<double>("maxDPhiForLooperReconstruction", 2.0);
 
   edm::ParameterSetDescription psdTJ1;
   psdTJ1.addNode(edm::PluginDescription<TrajectoryFilterFactory>("ComponentType", true));
   iDesc.add<edm::ParameterSetDescription>("trajectoryFilter", psdTJ1);
 
   edm::ParameterSetDescription psdTJ2;
   psdTJ2.addNode(edm::PluginDescription<TrajectoryFilterFactory>("ComponentType", true));
   iDesc.add<edm::ParameterSetDescription>("inOutTrajectoryFilter", psdTJ2);
 }

◆ groupedIntermediaryClean()

void GroupedCkfTrajectoryBuilder::groupedIntermediaryClean ( TempTrajectoryContainer & theTrajectories ) const

private

intermediate cleaning in the case of grouped measurements

im1->recHit()->hit()->sharesInput(im2->recHit()->hit(), TrackingRecHit::all) ) {

Definition at line 719 of file GroupedCkfTrajectoryBuilder.cc.

References ntuplemaker::fill, align_cfg::firstValid, TempTrajectory::isValid(), hgcalTBTopologyTester_cfi::layers, cmsutils::bqueue< T >::rbegin(), cmsutils::bqueue< T >::rend(), TrackingRecHit::some, submitPVValidationJobs::t, and tkxor().

Referenced by groupedLimitedCandidates().

                                                                                                          {
   //if (theTrajectories.empty()) return TrajectoryContainer();
   //TrajectoryContainer result;
   if (theTrajectories.empty())
     return;
   //RecHitEqualByChannels recHitEqualByChannels(false, false);
   LayersInTraj layers[theTrajectories.size()];
   int ntraj = 0;
   for (auto& t : theTrajectories) {
     if (t.isValid() && t.lastMeasurement().recHitR().isValid())
       layers[ntraj++].fill(t);
   }
 
   if (ntraj < 2)
     return;
 
   for (int ifirst = 0; ifirst != ntraj - 1; ++ifirst) {
     auto firstTraj = layers[ifirst].traj;
     if (!firstTraj->isValid())
       continue;
     const TempTrajectory::DataContainer& firstMeasurements = firstTraj->measurements();
 
     int firstLayerSize = layers[ifirst].tot;
     if (firstLayerSize < 4)
       continue;
     auto const& firstLayers = layers[ifirst].layers;
 
     for (int isecond = ifirst + 1; isecond != ntraj; ++isecond) {
       auto secondTraj = layers[isecond].traj;
       if (!secondTraj->isValid())
         continue;
 
       const TempTrajectory::DataContainer& secondMeasurements = secondTraj->measurements();
 
       int secondLayerSize = layers[isecond].tot;
       //
       // only candidates using the same last 3 layers are compared
       //
       if (firstLayerSize != secondLayerSize)
         continue;  // V.I.  why equal???
       auto const& secondLayers = layers[isecond].layers;
       if (firstLayers[0] != secondLayers[0] || firstLayers[1] != secondLayers[1] || firstLayers[2] != secondLayers[2])
         continue;
 
       TempTrajectory::DataContainer::const_iterator im1 = firstMeasurements.rbegin();
       TempTrajectory::DataContainer::const_iterator im2 = secondMeasurements.rbegin();
       //
       // check for identical hits in the last layer
       //
       bool unequal(false);
       const DetLayer* layerPtr = firstLayers[0];
       while (im1 != firstMeasurements.rend() && im2 != secondMeasurements.rend()) {
         if (im1->layer() != layerPtr || im2->layer() != layerPtr)
           break;
         if (!(im1->recHit()->isValid()) || !(im2->recHit()->isValid()) ||
             !im1->recHit()->hit()->sharesInput(im2->recHit()->hit(), TrackingRecHit::some)) {
           unequal = true;
           break;
         }
         --im1;
         --im2;
       }
       if (im1 == firstMeasurements.rend() || im2 == secondMeasurements.rend() || im1->layer() == layerPtr ||
           im2->layer() == layerPtr || unequal)
         continue;
       //
       // check for invalid hits in the layer -2
       // compare only candidates with invalid / valid combination
       //
       layerPtr = firstLayers[1];
       bool firstValid(true);
       while (im1 != firstMeasurements.rend() && im1->layer() == layerPtr) {
         if (!im1->recHit()->isValid())
           firstValid = false;
         --im1;
       }
       bool secondValid(true);
       while (im2 != secondMeasurements.rend() && im2->layer() == layerPtr) {
         if (!im2->recHit()->isValid())
           secondValid = false;
         --im2;
       }
       if (!tkxor(firstValid, secondValid))
         continue;
       //
       // ask for identical hits in layer -3
       //
       unequal = false;
       layerPtr = firstLayers[2];
       while (im1 != firstMeasurements.rend() && im2 != secondMeasurements.rend()) {
         if (im1->layer() != layerPtr || im2->layer() != layerPtr)
           break;
         if (!(im1->recHit()->isValid()) || !(im2->recHit()->isValid()) ||
             !im1->recHit()->hit()->sharesInput(im2->recHit()->hit(), TrackingRecHit::some)) {
           unequal = true;
           break;
         }
         --im1;
         --im2;
       }
       if (im1 == firstMeasurements.rend() || im2 == secondMeasurements.rend() || im1->layer() == layerPtr ||
           im2->layer() == layerPtr || unequal)
         continue;
 
       if (!firstValid) {
         firstTraj->invalidate();
         break;
       } else {
         secondTraj->invalidate();  // V.I. why break?
         break;
       }
     }  // second
   }    // first
        /*
   for (TempTrajectoryContainer::const_iterator it = theTrajectories.begin();
        it != theTrajectories.end(); it++) {
     if(it->isValid()) result.push_back( *it);
   }
 
   return result;
 */
   theTrajectories.erase(
       std::remove_if(theTrajectories.begin(), theTrajectories.end(), std::not_fn(&TempTrajectory::isValid)),
       theTrajectories.end());
 }

◆ groupedLimitedCandidates()

unsigned int GroupedCkfTrajectoryBuilder::groupedLimitedCandidates	(	const TrajectorySeed &	seed,
		TempTrajectory const &	startingTraj,
		const TrajectoryFilter *	regionalCondition,
		const Propagator *	propagator,
		bool	inOut,
		TempTrajectoryContainer &	result
	)		const

private

Definition at line 347 of file GroupedCkfTrajectoryBuilder.cc.

References advanceOneLayer(), HLT_2023v12_cff::candidates, IntermediateTrajectoryCleaner::clean(), PrintoutHelper::dumpCandidates(), groupedIntermediaryClean(), LogDebug, TrackCandidateProducer_cfi::propagator, mps_fire::result, fileCollector::seed, theFoundHitBonus, theIntermediateCleaning, theLostHitPenalty, and theMaxCand.

Referenced by buildTrajectories(), and rebuildSeedingRegion().

                                                                                                           {
   unsigned int nIter = 1;
   unsigned int nCands = 0;  // ignore startingTraj
   unsigned int prevNewCandSize = 0;
   TempTrajectoryContainer candidates;
   TempTrajectoryContainer newCand;
   candidates.push_back(startingTraj);
 
   while (!candidates.empty()) {
     newCand.clear();
     for (TempTrajectoryContainer::iterator traj = candidates.begin(); traj != candidates.end(); traj++) {
       if (!advanceOneLayer(seed, *traj, regionalCondition, propagator, inOut, newCand, result)) {
         LogDebug("CkfPattern") << "GCTB: terminating after advanceOneLayer==false";
         continue;
       }
 
       LogDebug("CkfPattern") << "newCand(1): after advanced one layer:\n" << PrintoutHelper::dumpCandidates(newCand);
       // 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();
 
       if ((int)newCand.size() > theMaxCand) {
         //ShowCand()(newCand);
 
         std::nth_element(newCand.begin(),
                          newCand.begin() + theMaxCand,
                          newCand.end(),
                          GroupedTrajCandLess(theLostHitPenalty, theFoundHitBonus));
         newCand.erase(newCand.begin() + theMaxCand, newCand.end());
       }
       LogDebug("CkfPattern") << "newCand(2): after removing extra candidates.\n"
                              << PrintoutHelper::dumpCandidates(newCand);
     }
 
     LogDebug("CkfPattern") << "newCand.size() at end = " << newCand.size();
     /*
     if (theIntermediateCleaning) {
       candidates.clear();
       candidates = groupedIntermediaryClean(newCand);
     } else {
       candidates.swap(newCand);
     }
 */
     if (theIntermediateCleaning) {
 #ifdef STANDARD_INTERMEDIARYCLEAN
       IntermediateTrajectoryCleaner::clean(newCand);
 #else
       groupedIntermediaryClean(newCand);
 #endif
     }
     candidates.swap(newCand);
 
     LogDebug("CkfPattern") << "candidates(3): " << result.size() << " candidates after " << nIter++
                            << " groupedCKF iteration: \n"
                            << PrintoutHelper::dumpCandidates(result) << "\n " << candidates.size()
                            << " running candidates are: \n"
                            << PrintoutHelper::dumpCandidates(candidates);
   }
 
   return nCands;
 }

◆ lostHitPenalty()

float GroupedCkfTrajectoryBuilder::lostHitPenalty ( )

inline

Chi**2 Penalty for each lost hit.

Definition at line 80 of file GroupedCkfTrajectoryBuilder.h.

80 { return theLostHitPenalty; }

GroupedCkfTrajectoryBuilder::theLostHitPenalty

float theLostHitPenalty

Definition: GroupedCkfTrajectoryBuilder.h:174

◆ mass()

double GroupedCkfTrajectoryBuilder::mass ( )

inline

Mass hypothesis used for propagation.

Definition at line 89 of file GroupedCkfTrajectoryBuilder.h.

Referenced by Particle.Particle::__str__(), and DiObject.DiMuon::__str__().

89 { return theMass; }

GroupedCkfTrajectoryBuilder::theMass

double theMass

Definition: GroupedCkfTrajectoryBuilder.h:170

◆ maxCand()

int GroupedCkfTrajectoryBuilder::maxCand ( )

inline

Maximum number of trajectory candidates to propagate to the next layer.

Definition at line 77 of file GroupedCkfTrajectoryBuilder.h.

77 { return theMaxCand; }

GroupedCkfTrajectoryBuilder::theMaxCand

int theMaxCand

Definition: GroupedCkfTrajectoryBuilder.h:172

◆ oppositeDirection()

static PropagationDirection GroupedCkfTrajectoryBuilder::oppositeDirection ( PropagationDirection dir )

inlinestaticprivate

change of propagation direction

Definition at line 152 of file GroupedCkfTrajectoryBuilder.h.

References alongMomentum, DeadROC_duringRun::dir, and oppositeToMomentum.

Referenced by backwardFit().

                                                                                  {
     if (dir == alongMomentum)
       return oppositeToMomentum;
     if (dir == oppositeToMomentum)
       return alongMomentum;
     return dir;
   }

◆ ptCut()

double GroupedCkfTrajectoryBuilder::ptCut ( )

inline

Pt cut.

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

Definition at line 86 of file GroupedCkfTrajectoryBuilder.h.

86 { return theptCut; }

GroupedCkfTrajectoryBuilder::theptCut

double theptCut

Definition: GroupedCkfTrajectoryBuilder.h:168

◆ rebuildSeedingRegion() [1/3]

void GroupedCkfTrajectoryBuilder::rebuildSeedingRegion	(	const TrajectorySeed &	seed,
		TrajectoryContainer &	result
	)		const

overridevirtual

trajectories re-building in the seeding region. It looks for additional measurements in the seeding region of the intial trajectories. Only valid trajectories are returned. Invalid ones are dropped from the input collection.

Reimplemented from TrajectoryBuilder.

Definition at line 221 of file GroupedCkfTrajectoryBuilder.cc.

References BaseCkfTrajectoryBuilder::createStartingTrajectory(), rebuildTrajectories(), mps_fire::result, and fileCollector::seed.

Referenced by rebuildSeedingRegion(), and rebuildTrajectories().

                                                                                                                     {
   TempTrajectory const& startingTraj = createStartingTrajectory(seed);
   rebuildTrajectories(startingTraj, seed, result);
 }

◆ rebuildSeedingRegion() [2/3]

void GroupedCkfTrajectoryBuilder::rebuildSeedingRegion	(	const TrajectorySeed &	seed,
		TempTrajectory const &	startingTraj,
		TempTrajectoryContainer &	result
	)		const

private

try to find additional hits in seeding region

Definition at line 847 of file GroupedCkfTrajectoryBuilder.cc.

References backwardFit(), BaseCkfTrajectoryBuilder::backwardPropagator(), runTheMatrix::const, estimator(), BaseCkfTrajectoryBuilder::hitBuilder(), mps_fire::i, TempTrajectory::isValid(), LogDebug, eostools::move(), rebuildSeedingRegion(), mps_fire::result, fileCollector::seed, theKeepOriginalIfRebuildFails, UNLIKELY, and updator().

                                                                                               {
   //
   // Rebuilding of trajectories. Candidates are taken from result,
   // which will be replaced with the solutions after rebuild
   // (assume vector::swap is more efficient than building new container)
   //
   LogDebug("CkfPattern") << "Starting to rebuild " << result.size() << " tracks";
   //
   // Fitter (need to create it here since the propagation direction
   // might change between different starting trajectories)
   //
   auto hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(hitBuilder())->cloner();
   KFTrajectoryFitter fitter(backwardPropagator(seed), &updator(), &estimator(), 3, nullptr, &hitCloner);
   //
   std::vector<const TrackingRecHit*> seedHits;
 
   unsigned int nSeed = seed.nHits();
   //seedHits.reserve(nSeed);
   TempTrajectoryContainer rebuiltTrajectories;
 
   for (TempTrajectoryContainer::iterator it = result.begin(); it != result.end(); it++) {
     // Refit - keep existing trajectory in case fit is not possible
     // or fails
     //
 
     auto&& reFitted = backwardFit(*it, nSeed, fitter, seedHits);
     if UNLIKELY (!reFitted.isValid()) {
       rebuiltTrajectories.push_back(std::move(*it));
       LogDebug("CkfPattern") << "RebuildSeedingRegion skipped as backward fit failed";
       //                << "after reFitted.size() " << reFitted.size();
       continue;
     }
     //LogDebug("CkfPattern")<<"after reFitted.size() " << reFitted.size();
     //
     // Rebuild seeding part. In case it fails: keep initial trajectory
     // (better to drop it??)
     //
     int nRebuilt = rebuildSeedingRegion(seed, seedHits, reFitted, rebuiltTrajectories);
     // Loop over the last nRebuilt trajectories and propagate back the
     // real cause that stopped the original in-out trajectory, since
     // that's the one we want to monitor
     for (size_t i = rebuiltTrajectories.size() - 1; i < rebuiltTrajectories.size() - nRebuilt - 1; --i) {
       rebuiltTrajectories[i].setStopReason(it->stopReason());
     }
 
     if (nRebuilt == 0 && !theKeepOriginalIfRebuildFails)
       it->invalidate();  // won't use original in-out track
 
     if (nRebuilt < 0)
       rebuiltTrajectories.push_back(std::move(*it));
   }
   //
   // Replace input trajectories with new ones
   //
   result.swap(rebuiltTrajectories);
   result.erase(std::remove_if(result.begin(), result.end(), std::not_fn(&TempTrajectory::isValid)), result.end());
 }

◆ rebuildSeedingRegion() [3/3]

int GroupedCkfTrajectoryBuilder::rebuildSeedingRegion	(	const TrajectorySeed &	seed,
		const std::vector< const TrackingRecHit *> &	seedHits,
		TempTrajectory &	candidate,
		TempTrajectoryContainer &	result
	)		const

private

Definition at line 907 of file GroupedCkfTrajectoryBuilder.cc.

References BaseCkfTrajectoryBuilder::backwardPropagator(), gather_cfg::cout, TempTrajectory::direction(), PrintoutHelper::dumpCandidates(), PrintoutHelper::dumpMeasurements(), groupedLimitedCandidates(), LogDebug, TempTrajectory::measurements(), TempTrajectory::push(), mps_fire::result, fileCollector::seed, TempTrajectory::setNLoops(), cmsutils::bqueue< T >::size(), theRequireSeedHitsInRebuild, and verifyHits().

                                                                                              {
   //
   // Starting from track found by in-out tracking phase, extrapolate it inwards through
   // the seeding region if possible in towards smaller Tracker radii, searching for additional
   // hits.
   // The resulting trajectories are returned in result,
   // the count is the return value.
   //
   TempTrajectoryContainer rebuiltTrajectories;
 #ifdef DBG2_GCTB
   /*  const LayerFinderByDet layerFinder;
   if ( !seedHits.empty() && seedHits.front().isValid() ) {
     DetLayer* seedLayer = layerFinder(seedHits.front().det());
     cout << "Seed hit at " << seedHits.front().globalPosition()
      << " " << seedLayer << endl;
     cout << "Started from " 
      << candidate.lastMeasurement().updatedState().globalPosition().perp() << " "
      << candidate.lastMeasurement().updatedState().globalPosition().z() << endl;
     pair<bool,TrajectoryStateOnSurface> layerComp(false,TrajectoryStateOnSurface());
     if ( seedLayer ) layerComp =
       seedLayer->compatible(candidate.lastMeasurement().updatedState(),
                   propagator(),estimator());
     pair<bool,TrajectoryStateOnSurface> detComp =
       seedHits.front().det().compatible(candidate.lastMeasurement().updatedState(),
                     propagator(),estimator());
     cout << "  layer compatibility = " << layerComp.first;
     cout << "  det compatibility = " << detComp.first;
     if ( detComp.first ) {
       cout << "  estimate = " 
        << estimator().estimate(detComp.second,seedHits.front()).second ;
     }
     cout << endl;
   }*/
   cout << "Before backward building: #measurements = " << candidate.measurements().size();  //<< endl;;
 #endif
   //
   // Use standard building with standard cuts. Maybe better to use different
   // cuts from "forward" building (e.g. no check on nr. of invalid hits)?
   //
   const bool inOut = false;
   groupedLimitedCandidates(seed, candidate, nullptr, backwardPropagator(seed), inOut, rebuiltTrajectories);
 
   LogDebug("CkfPattern") << " After backward building: " << PrintoutHelper::dumpCandidates(rebuiltTrajectories);
 
   //
   // Check & count resulting candidates
   //
   int nrOfTrajectories(0);
   bool orig_ok = false;
   //const RecHitEqualByChannels recHitEqual(false,false);
   //vector<TM> oldMeasurements(candidate.measurements());
   for (TempTrajectoryContainer::iterator it = rebuiltTrajectories.begin(); it != rebuiltTrajectories.end(); it++) {
     TempTrajectory::DataContainer newMeasurements(it->measurements());
     //
     // Verify presence of seeding hits?
     //
     if (theRequireSeedHitsInRebuild) {
       orig_ok = true;
       // no hits found (and possibly some invalid hits discarded): drop track
       if (newMeasurements.size() <= candidate.measurements().size()) {
         LogDebug("CkfPattern") << "newMeasurements.size()<=candidate.measurements().size()";
         continue;
       }
       // verify presence of hits
       //GIO//if ( !verifyHits(newMeasurements.begin()+candidate.measurements().size(),
       //GIO//              newMeasurements.end(),seedHits) ){
       if (!verifyHits(newMeasurements.rbegin(), newMeasurements.size() - candidate.measurements().size(), seedHits)) {
         LogDebug("CkfPattern") << "seed hits not found in rebuild";
         continue;
       }
     }
     //
     // construct final trajectory in the right order
     //
     // save & count result
     nrOfTrajectories++;
     result.emplace_back(seed.direction(), seed.nHits());
     TempTrajectory& reversedTrajectory = result.back();
     reversedTrajectory.setNLoops(it->nLoops());
     for (TempTrajectory::DataContainer::const_iterator im = newMeasurements.rbegin(), ed = newMeasurements.rend();
          im != ed;
          --im) {
       reversedTrajectory.push(*im);
     }
 
     LogDebug("CkgPattern") << "New traj direction = " << reversedTrajectory.direction() << "\n"
                            << PrintoutHelper::dumpMeasurements(reversedTrajectory.measurements());
   }  // rebuiltTrajectories
 
   // If nrOfTrajectories = 0 and orig_ok = true, this means that a track was actually found on the
   // out-in step (meeting those requirements) but did not have the seed hits in it.
   // In this case when we return we will go ahead and use the original in-out track.
 
   // If nrOfTrajectories = 0 and orig_ok = false, this means that the out-in step failed to
   // find any track.  Two cases are a technical failure in fitting the original seed hits or
   // because the track did not meet the out-in criteria (which may be stronger than the out-in
   // criteria).  In this case we will NOT allow the original in-out track to be used.
 
   if ((nrOfTrajectories == 0) && orig_ok) {
     nrOfTrajectories = -1;
   }
   return nrOfTrajectories;
 }

◆ rebuildTrajectories()

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

overridevirtual

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 226 of file GroupedCkfTrajectoryBuilder.cc.

References FastTrajectoryCleaner::clean(), eostools::move(), rebuildSeedingRegion(), mps_fire::result, fileCollector::seed, theFoundHitBonus, theLostHitPenalty, and edmIntegrityCheck::work.

Referenced by rebuildSeedingRegion().

                                                                                          {
   TempTrajectoryContainer work;
 
   TrajectoryContainer final;
 
   // better the seed to be always the same...
   std::shared_ptr<const TrajectorySeed> sharedSeed;
   if (result.empty())
     sharedSeed.reset(new TrajectorySeed(seed));
   else
     sharedSeed = result.front().sharedSeed();
 
   work.reserve(result.size());
   for (auto&& traj : result)
     if (traj.isValid())
       work.emplace_back(std::move(traj));
 
   rebuildSeedingRegion(seed, startingTraj, work);
 
   // we clean here now
   FastTrajectoryCleaner cleaner(theFoundHitBonus, theLostHitPenalty, false);
   cleaner.clean(work);
 
   for (auto const& it : work)
     if (it.isValid()) {
       final.push_back(it.toTrajectory());
       final.back().setSharedSeed(sharedSeed);
     }
 
   result.swap(final);
 
   statCount.rebuilt(result.size());
 }

◆ setEvent_()

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

overrideprotectedvirtual

Implements BaseCkfTrajectoryBuilder.

Definition at line 186 of file GroupedCkfTrajectoryBuilder.cc.

186 {}

◆ tkxor()

bool GroupedCkfTrajectoryBuilder::tkxor	(	bool	a,
		bool	b
	)		const

inlineprivate

Definition at line 106 of file GroupedCkfTrajectoryBuilder.h.

References a, and b.

Referenced by groupedIntermediaryClean().

106 { return (a || b) && !(a && b); }

b

double b

Definition: hdecay.h:118

a

double a

Definition: hdecay.h:119

◆ trajectories() [1/4]

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

overridevirtual

set Event for the internal MeasurementTracker data member

trajectories building starting from a seed

Implements TrajectoryBuilder.

Definition at line 188 of file GroupedCkfTrajectoryBuilder.cc.

References buildTrajectories(), runTheMatrix::ret, fileCollector::seed, and createJobs::tmp.

                                       {
   TrajectoryContainer ret;
   ret.reserve(10);
   unsigned int tmp;
   buildTrajectories(seed, ret, tmp, nullptr);
   return ret;
 }

◆ trajectories() [2/4]

void GroupedCkfTrajectoryBuilder::trajectories	(	const TrajectorySeed &	seed,
		GroupedCkfTrajectoryBuilder::TrajectoryContainer &	ret
	)		const

overridevirtual

trajectories building starting from a seed, return in an already allocated vector

Reimplemented from TrajectoryBuilder.

Definition at line 207 of file GroupedCkfTrajectoryBuilder.cc.

References buildTrajectories(), runTheMatrix::ret, fileCollector::seed, and createJobs::tmp.

                                                                                                           {
   unsigned int tmp;
   buildTrajectories(seed, ret, tmp, nullptr);
 }

◆ trajectories() [3/4]

GroupedCkfTrajectoryBuilder::TrajectoryContainer GroupedCkfTrajectoryBuilder::trajectories	(	const TrajectorySeed &	seed,
		const TrackingRegion &	region
	)		const

trajectories building starting from a seed with a region

Definition at line 197 of file GroupedCkfTrajectoryBuilder.cc.

References buildTrajectories(), HLT_2023v12_cff::region, runTheMatrix::ret, fileCollector::seed, and createJobs::tmp.

                                                                     {
   TrajectoryContainer ret;
   ret.reserve(10);
   unsigned int tmp;
   RegionalTrajectoryFilter regionalCondition(region);
   buildTrajectories(seed, ret, tmp, &regionalCondition);
   return ret;
 }

◆ trajectories() [4/4]

void GroupedCkfTrajectoryBuilder::trajectories	(	const TrajectorySeed &	seed,
		GroupedCkfTrajectoryBuilder::TrajectoryContainer &	ret,
		const TrackingRegion &	region
	)		const

trajectories building starting from a seed with a region

Definition at line 213 of file GroupedCkfTrajectoryBuilder.cc.

References buildTrajectories(), HLT_2023v12_cff::region, runTheMatrix::ret, fileCollector::seed, and createJobs::tmp.

                                                                                    {
   RegionalTrajectoryFilter regionalCondition(region);
   unsigned int tmp;
   buildTrajectories(seed, ret, tmp, &regionalCondition);
 }

◆ updator()

const TrajectoryStateUpdator& GroupedCkfTrajectoryBuilder::updator ( ) const

inline

Definition at line 68 of file GroupedCkfTrajectoryBuilder.h.

References BaseCkfTrajectoryBuilder::theUpdator.

Referenced by rebuildSeedingRegion().

68 { return *theUpdator; }

BaseCkfTrajectoryBuilder::theUpdator

const TrajectoryStateUpdator * theUpdator

Definition: BaseCkfTrajectoryBuilder.h:177

◆ verifyHits()

bool GroupedCkfTrajectoryBuilder::verifyHits	(	TempTrajectory::DataContainer::const_iterator	rbegin,
		size_t	maxDepth,
		const std::vector< const TrackingRecHit *> &	hits
	)		const

private

Verifies presence of a RecHits in a range of TrajectoryMeasurements.

Definition at line 1135 of file GroupedCkfTrajectoryBuilder.cc.

References hfClusterShapes_cfi::hits, LogDebug, HLT_2023v12_cff::maxDepth, and TrackingRecHit::some.

Referenced by rebuildSeedingRegion().

                                                                                                  {
   //
   // verify presence of the seeding hits
   //
   LogDebug("CkfPattern") << "Checking for " << hits.size() << " hits in " << maxDepth << " measurements" << endl;
 
   auto rend = rbegin;
   while (maxDepth > 0) {
     --maxDepth;
     --rend;
   }
   for (auto ir = hits.begin(); ir != hits.end(); ir++) {
     // assume that all seeding hits are valid!
     bool foundHit(false);
     for (auto im = rbegin; im != rend; --im) {
       if (im->recHit()->isValid() && (*ir)->sharesInput(im->recHit()->hit(), TrackingRecHit::some)) {
         foundHit = true;
         break;
       }
     }
     if (!foundHit)
       return false;
   }
   return true;
 }