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, const TrajectoryFilter *) const
	CkfTrajectoryBuilder (const edm::ParameterSet &conf, edm::ConsumesCollector &iC)
	CkfTrajectoryBuilder (const edm::ParameterSet &conf, TrajectoryFilter *filter)
void	rebuildTrajectories (TempTrajectory const &startingTraj, const TrajectorySeed &, TrajectoryContainer &result) const
virtual TrajectoryContainer	trajectories (const TrajectorySeed &seed) const
	trajectories building starting from a seed More...
virtual void	trajectories (const TrajectorySeed &seed, TrajectoryContainer &ret) const
	trajectories building starting from a seed More...
	~CkfTrajectoryBuilder ()
Public Member Functions inherited from BaseCkfTrajectoryBuilder
	BaseCkfTrajectoryBuilder (const edm::ParameterSet &conf, TrajectoryFilter *filter, TrajectoryFilter *inOutFilter=0)
	BaseCkfTrajectoryBuilder (const BaseCkfTrajectoryBuilder &)=delete
const TransientTrackingRecHitBuilder *	hitBuilder () const
BaseCkfTrajectoryBuilder &	operator= (const BaseCkfTrajectoryBuilder &)=delete
virtual void	setDebugger (CkfDebugger *dbg) const
virtual void	setEvent (const edm::Event &event) const
void	setEvent (const edm::Event &iEvent, const edm::EventSetup &iSetup, const MeasurementTrackerEvent *data)
void	setNavigationSchool (NavigationSchool const *nv)
virtual void	unset () const
virtual	~BaseCkfTrajectoryBuilder ()
Public Member Functions inherited from TrajectoryBuilder
virtual void	rebuildSeedingRegion (const TrajectorySeed &, TrajectoryContainer &result) const
virtual	~TrajectoryBuilder ()

Protected Member Functions
virtual void	findCompatibleMeasurements (const TrajectorySeed &seed, const TempTrajectory &traj, std::vector< TrajectoryMeasurement > &result) const
void	limitedCandidates (const TrajectorySeed &seed, TempTrajectory &startingTraj, TrajectoryContainer &result) const
void	limitedCandidates (const boost::shared_ptr< const TrajectorySeed > &sharedSeed, TempTrajectoryContainer &candidates, TrajectoryContainer &result) const
void	setEvent_ (const edm::Event &iEvent, const edm::EventSetup &iSetup) override
void	updateTrajectory (TempTrajectory &traj, TM &&tm) const
Protected Member Functions inherited from BaseCkfTrajectoryBuilder
void	addToResult (boost::shared_ptr< const TrajectorySeed > const &seed, TempTrajectory &traj, TrajectoryContainer &result, bool inOut=false) const
void	addToResult (TempTrajectory const &traj, TempTrajectoryContainer &result, bool inOut=false) const
virtual bool	analyzeMeasurementsDebugger (Trajectory &traj, const std::vector< TrajectoryMeasurement > &meas, const MeasurementTrackerEvent *theMeasurementTracker, const Propagator *theForwardPropagator, const Chi2MeasurementEstimatorBase *theEstimator, const TransientTrackingRecHitBuilder *theTTRHBuilder) const
virtual bool	analyzeMeasurementsDebugger (TempTrajectory &traj, const std::vector< TrajectoryMeasurement > &meas, const MeasurementTrackerEvent *theMeasurementTracker, const Propagator *theForwardPropagator, const Chi2MeasurementEstimatorBase *theEstimator, const TransientTrackingRecHitBuilder *theTTRHBuilder) const
const Propagator *	backwardPropagator (const TrajectorySeed &seed) const
TempTrajectory	createStartingTrajectory (const TrajectorySeed &seed) const
virtual void	fillSeedHistoDebugger (std::vector< TrajectoryMeasurement >::iterator begin, std::vector< TrajectoryMeasurement >::iterator end) const
StateAndLayers	findStateAndLayers (const TrajectorySeed &seed, const TempTrajectory &traj) const
StateAndLayers	findStateAndLayers (const TempTrajectory &traj) const
const Propagator *	forwardPropagator (const TrajectorySeed &seed) const
void	moveToResult (TempTrajectory &&traj, TempTrajectoryContainer &result, bool inOut=false) const
bool	qualityFilter (const TempTrajectory &traj, bool inOut=false) const
void	setData (const MeasurementTrackerEvent *data)
bool	toBeContinued (TempTrajectory &traj, bool inOut=false) const

Protected Attributes
bool	theAlwaysUseInvalidHits
bool	theIntermediateCleaning
float	theLostHitPenalty
int	theMaxCand
	set Event for the internal MeasurementTracker data member More...
Protected Attributes inherited from BaseCkfTrajectoryBuilder
const Chi2MeasurementEstimatorBase *	theEstimator
const MeasurementTrackerEvent *	theMeasurementTracker
const NavigationSchool *	theNavigationSchool = 0
const Propagator *	thePropagatorAlong
const Propagator *	thePropagatorOpposite
const TransientTrackingRecHitBuilder *	theTTRHBuilder
const TrajectoryStateUpdator *	theUpdator

Additional Inherited Members
Protected Types inherited from BaseCkfTrajectoryBuilder
typedef TrackingComponentsRecord	Chi2MeasurementEstimatorRecord
typedef FreeTrajectoryState	FTS
typedef std::pair< TSOS, std::vector< const DetLayer * > >	StateAndLayers
typedef TrajectoryMeasurement	TM
typedef TrajectoryStateOnSurface	TSOS
Static Protected Member Functions inherited from BaseCkfTrajectoryBuilder
static TrajectoryFilter *	createTrajectoryFilter (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)

Detailed Description

Definition at line 34 of file CkfTrajectoryBuilder.h.

Member Typedef Documentation

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

Definition at line 39 of file CkfTrajectoryBuilder.h.

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

Definition at line 38 of file CkfTrajectoryBuilder.h.

Constructor & Destructor Documentation

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

Definition at line 30 of file CkfTrajectoryBuilder.cc.

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

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

Definition at line 35 of file CkfTrajectoryBuilder.cc.

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

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

CkfTrajectoryBuilder::~CkfTrajectoryBuilder ( )

inline

Definition at line 44 of file CkfTrajectoryBuilder.h.

{}

Member Function Documentation

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

virtual

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

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 148 of file CkfTrajectoryBuilder.cc.

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

Referenced by trajectories().

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

  /*
  //and remember what you just did
  if (theSharedSeedCheck)  rememberSeedAndTrajectories(seed,result);
  */
  
  // analyseResult(result);
}

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

protectedvirtual

Reimplemented in MuonCkfTrajectoryBuilder.

Definition at line 322 of file CkfTrajectoryBuilder.cc.

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

Referenced by limitedCandidates().

{
  int invalidHits = 0;
  //Use findStateAndLayers which handles the hitless seed use case
  std::pair<TSOS,std::vector<const DetLayer*> > && stateAndLayers = findStateAndLayers(seed,traj);
  if (stateAndLayers.second.empty()) return;

  auto layerBegin = stateAndLayers.second.begin();
  auto layerEnd  = stateAndLayers.second.end();
  LogDebug("CkfPattern")<<"looping on "<< stateAndLayers.second.size()<<" layers.";
  const Propagator *fwdPropagator = forwardPropagator(seed);
  for (auto il = layerBegin;  il != layerEnd; il++) {

    LogDebug("CkfPattern")<<"looping on a layer in findCompatibleMeasurements.\n last layer: "<<traj.lastLayer()<<" current layer: "<<(*il);

    TSOS stateToUse = stateAndLayers.first;
    //Added protection before asking for the lastLayer on the trajectory
    if unlikely (!traj.empty() && (*il)==traj.lastLayer()) {
    LogDebug("CkfPattern")<<" self propagating in findCompatibleMeasurements.\n from: \n"<<stateToUse;
    //self navigation case
    // go to a middle point first
    TransverseImpactPointExtrapolator middle;
    GlobalPoint center(0,0,0);
    stateToUse = middle.extrapolate(stateToUse, center, *fwdPropagator);
    
    if (!stateToUse.isValid()) continue;
    LogDebug("CkfPattern")<<"to: "<<stateToUse;
      }
    
    LayerMeasurements layerMeasurements(theMeasurementTracker->measurementTracker(), *theMeasurementTracker);
    std::vector<TrajectoryMeasurement> && tmp = layerMeasurements.measurements((**il),stateToUse, *fwdPropagator, *theEstimator);
    
    if ( !tmp.empty()) {
      if ( result.empty()) result.swap(tmp);
      else {
    // keep one dummy TM at the end, skip the others
    result.insert( result.end()-invalidHits, 
               std::make_move_iterator(tmp.begin()), std::make_move_iterator(tmp.end()));
      }
      invalidHits++;
    }
  }

  // sort the final result, keep dummy measurements at the end
  if ( result.size() > 1) {
    std::sort( result.begin(), result.end()-invalidHits, TrajMeasLessEstim());
  }

  LogDebug("CkfPattern")<<"starting from:\n"
            <<"x: "<<stateAndLayers.first.globalPosition()<<"\n"
            <<"p: "<<stateAndLayers.first.globalMomentum()<<"\n"
            <<PrintoutHelper::dumpMeasurements(result);

#ifdef DEBUG_INVALID
  bool afterInvalid = false;
  for (vector<TM>::const_iterator i=result.begin();
       i!=result.end(); i++) {
    if ( ! i->recHit().isValid()) afterInvalid = true;
    if (afterInvalid && i->recHit().isValid()) {
      edm::LogError("CkfPattern") << "CkfTrajectoryBuilder error: valid hit after invalid!" ;
    }
  }
#endif

  //analyseMeasurements( result, traj);

}

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

protected

Definition at line 172 of file CkfTrajectoryBuilder.cc.

References objects.IsoTrackAnalyzer::candidates.

Referenced by buildTrajectories().

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

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

protected

Definition at line 182 of file CkfTrajectoryBuilder.cc.

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

{
  unsigned int nIter=1;
  TempTrajectoryContainer newCand; // = TrajectoryContainer();
  newCand.reserve(2*theMaxCand);

  
  auto trajCandLess = [&](TempTrajectory const & a, TempTrajectory const & b) {
    return  (a.chiSquared() + a.lostHits()*theLostHitPenalty)  <
    (b.chiSquared() + b.lostHits()*theLostHitPenalty);
  };
  
 
  while ( !candidates.empty()) {

    newCand.clear();
    for (auto traj=candidates.begin(); traj!=candidates.end(); traj++) {
      std::vector<TM> meas;
      findCompatibleMeasurements(*sharedSeed, *traj, meas);

      // --- method for debugging
      if(!analyzeMeasurementsDebugger(*traj,meas,
                      theMeasurementTracker,
                      forwardPropagator(*sharedSeed),theEstimator,
                      theTTRHBuilder)) return;
      // ---

      if ( meas.empty()) {
    if ( qualityFilter( *traj)) addToResult(sharedSeed, *traj, result);
      }
      else {
    std::vector<TM>::const_iterator last;
    if ( theAlwaysUseInvalidHits) last = meas.end();
    else {
      if (meas.front().recHit()->isValid()) {
        last = find_if( meas.begin(), meas.end(), RecHitIsInvalid());
      }
      else last = meas.end();
    }

    for(auto itm = meas.begin(); itm != last; itm++) {
      TempTrajectory newTraj = *traj;
      updateTrajectory( newTraj, std::move(*itm));

      if ( toBeContinued(newTraj)) {
        newCand.push_back(std::move(newTraj));  std::push_heap(newCand.begin(),newCand.end(),trajCandLess);
      }
      else {
        if ( qualityFilter(newTraj))  addToResult(sharedSeed, newTraj, result);
      }
    }
      }


      /*
      auto trajVal = [&](TempTrajectory const & a) {
        return  a.chiSquared() + a.lostHits()*theLostHitPenalty;
      };

      // safe (stable?) logig: always sort, kill exceeding only if worse than last to keep
      // if ((int)newCand.size() > theMaxCand) std::cout << "TrajVal " << theMaxCand  << ' ' << newCand.size() << ' ' <<  trajVal(newCand.front());
      int toCut = int(newCand.size()) - int(theMaxCand);
      if (toCut>0) {
        // move largest "toCut" to the end
        for (int i=0; i<toCut; ++i)
          std::pop_heap(newCand.begin(),newCand.end()-i,trajCandLess);
        auto fval = trajVal(newCand.front());
        // remove till equal to highest to keep
        for (int i=0; i<toCut; ++i) {
           if (fval==trajVal(newCand.back())) break;
           newCand.pop_back();
        }
    //assert((int)newCand.size() >= theMaxCand);
    //std::cout << "; " << newCand.size() << ' ' << trajVal(newCand.front())  << " " << trajVal(newCand.back());

    // std::make_heap(newCand.begin(),newCand.end(),trajCandLess);
        // push_heap again the one left
        for (auto iter = newCand.begin()+theMaxCand+1; iter<=newCand.end(); ++iter  )
      std::push_heap(newCand.begin(),iter,trajCandLess);

    // std::cout << "; " << newCand.size() << ' ' << trajVal(newCand.front())  << " " << trajVal(newCand.back()) << std::endl;
      }

      */

      
      // intermedeate login: always sort,  kill all exceeding
      while ((int)newCand.size() > theMaxCand) {
    std::pop_heap(newCand.begin(),newCand.end(),trajCandLess);
    // if ((int)newCand.size() == theMaxCand+1) std::cout << " " << trajVal(newCand.front())  << " " << trajVal(newCand.back()) << std::endl;
    newCand.pop_back();
       }
      
      /*
      //   original logic: sort only if > theMaxCand, kill all exceeding
      if ((int)newCand.size() > theMaxCand) {
    std::sort( newCand.begin(), newCand.end(), TrajCandLess<TempTrajectory>(theLostHitPenalty));
    // std::partial_sort( newCand.begin(), newCand.begin()+theMaxCand, newCand.end(), TrajCandLess<TempTrajectory>(theLostHitPenalty));
    std::cout << "TrajVal " << theMaxCand  << ' ' << newCand.size() << ' '
    << trajVal(newCand.back()) << ' ' << trajVal(newCand[theMaxCand-1]) << ' ' << trajVal(newCand[theMaxCand])  << std::endl;
    newCand.resize(theMaxCand);
      }
      */

    } // end loop on candidates

    std::sort_heap(newCand.begin(),newCand.end(),trajCandLess);
    if (theIntermediateCleaning) IntermediateTrajectoryCleaner::clean(newCand);

    candidates.swap(newCand);
    
    LogDebug("CkfPattern") <<result.size()<<" candidates after "<<nIter++<<" CKF iteration: \n"
               <<PrintoutHelper::dumpCandidates(result)
               <<"\n "<<candidates.size()<<" running candidates are: \n"
               <<PrintoutHelper::dumpCandidates(candidates);

  }
}

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

inlinevirtual

Reimplemented from BaseCkfTrajectoryBuilder.

Definition at line 57 of file CkfTrajectoryBuilder.h.

                                                   {}

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

virtual

trajectories building starting from a seed

Implements TrajectoryBuilder.

Definition at line 62 of file CkfTrajectoryBuilder.cc.

References query::result.

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

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

virtual

trajectories building starting from a seed

Reimplemented from TrajectoryBuilder.

Definition at line 129 of file CkfTrajectoryBuilder.cc.

References buildTrajectories().

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

  buildTrajectories(seed, result,nullptr);
}

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

protected

Definition at line 305 of file CkfTrajectoryBuilder.cc.

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

Referenced by limitedCandidates().

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

Member Data Documentation

bool CkfTrajectoryBuilder::theAlwaysUseInvalidHits

protected

Definition at line 71 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

bool CkfTrajectoryBuilder::theIntermediateCleaning

protected

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

Definition at line 69 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

float CkfTrajectoryBuilder::theLostHitPenalty

protected

Chi**2 Penalty for each lost hit.

Definition at line 68 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().

int CkfTrajectoryBuilder::theMaxCand

protected

set Event for the internal MeasurementTracker data member

    Maximum number of trajectory candidates 

to propagate to the next layer.

Definition at line 66 of file CkfTrajectoryBuilder.h.

Referenced by CkfTrajectoryBuilder(), and limitedCandidates().