CkfTrajectoryBuilder Class Reference

#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, 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, std::unique_ptr< TrajectoryFilter > filter, std::unique_ptr< TrajectoryFilter > inOutFilter=0)
	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 ()

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 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
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 std::unique_ptr< 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,
		std::unique_ptr< TrajectoryFilter >	filter
	)

Definition at line 35 of file CkfTrajectoryBuilder.cc.

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

                                                                                                             :
  BaseCkfTrajectoryBuilder(conf, 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 ( )

inlineoverride

Definition at line 44 of file CkfTrajectoryBuilder.h.

References buildTrajectories(), SurveyInfoScenario_cff::seed, and trajectories().

{}

Member Function Documentation

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 149 of file CkfTrajectoryBuilder.cc.

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

Referenced by trajectories(), and ~CkfTrajectoryBuilder().

                                                           {
  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);
}

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

protectedvirtual

Reimplemented in MuonCkfTrajectoryBuilder.

Definition at line 332 of file CkfTrajectoryBuilder.cc.

References PrintoutHelper::dumpMeasurements(), TempTrajectory::empty(), TransverseImpactPointExtrapolator::extrapolate(), BaseCkfTrajectoryBuilder::findStateAndLayers(), BaseCkfTrajectoryBuilder::forwardPropagator(), mps_fire::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);

}

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

protected

Definition at line 174 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));
  return limitedCandidates(sharedSeed, candidates,result);
}

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

protected

Definition at line 184 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;
  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;
}

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

inlineoverridevirtual

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 58 of file CkfTrajectoryBuilder.h.

                                                            {}

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

                                                                                       {  
}

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

overridevirtual

trajectories building starting from a seed

Implements TrajectoryBuilder.

Definition at line 62 of file CkfTrajectoryBuilder.cc.

References mps_fire::result.

Referenced by ~CkfTrajectoryBuilder().

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

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

overridevirtual

trajectories building starting from a seed

Reimplemented from TrajectoryBuilder.

Definition at line 129 of file CkfTrajectoryBuilder.cc.

References buildTrajectories(), and 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);
}

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

protected

Definition at line 315 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 72 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 70 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

float CkfTrajectoryBuilder::theLostHitPenalty

protected

Chi**2 Penalty for each lost hit.

Definition at line 69 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 67 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().