#include <TrajectoryCleanerBySharedHits.h>

Inheritance diagram for TrajectoryCleanerBySharedHits:

Public Types
typedef std::vector< Trajectory * >	TrajectoryPointerContainer

Public Types inherited from TrajectoryCleaner
typedef TrackingComponentsRecord	Record

typedef std::vector< Trajectory >	TrajectoryContainer

typedef TrajectoryContainer::iterator	TrajectoryIterator

typedef std::vector< Trajectory * >	TrajectoryPointerContainer

typedef TrajectoryPointerContainer::iterator	TrajectoryPointerIterator

Public Member Functions
virtual void	clean (TrajectoryPointerContainer &) const

	TrajectoryCleanerBySharedHits ()

	TrajectoryCleanerBySharedHits (const edm::ParameterSet &iConfig)

virtual	~TrajectoryCleanerBySharedHits ()

Public Member Functions inherited from TrajectoryCleaner
virtual void	clean (TrajectoryContainer &) const

	TrajectoryCleaner ()

	TrajectoryCleaner (edm::ParameterSet &iConfig)

virtual	~TrajectoryCleaner ()

Private Attributes
bool	allowSharedFirstHit

double	missingHitPenalty_

double	theFraction

double	validHitBonus_

Detailed Description

A concrete TrajectoryCleaner that considers two trajectories to be mutually exclusive if they share more than some fraction of their hits. The "best" trajectory of each set of mutually exclusive ones is kept, the others are eliminated. The goodness of a track is defined in terms of Chi^2, number of reconstructed hits, and number of lost hits.

Definition at line 16 of file TrajectoryCleanerBySharedHits.h.

Member Typedef Documentation

typedef std::vector<Trajectory*> TrajectoryCleanerBySharedHits::TrajectoryPointerContainer

Definition at line 20 of file TrajectoryCleanerBySharedHits.h.

Constructor & Destructor Documentation

TrajectoryCleanerBySharedHits::TrajectoryCleanerBySharedHits ( )

inline

Definition at line 22 of file TrajectoryCleanerBySharedHits.h.

                                   :
     theFraction(0.19),
     validHitBonus_(5.0),
     missingHitPenalty_(20.0),
     allowSharedFirstHit(true){}

TrajectoryCleanerBySharedHits::TrajectoryCleanerBySharedHits ( const edm::ParameterSet & iConfig )

inline

Definition at line 27 of file TrajectoryCleanerBySharedHits.h.

                                                                  :
     theFraction(iConfig.getParameter<double>("fractionShared")),
     validHitBonus_(iConfig.getParameter<double>("ValidHitBonus")),
     missingHitPenalty_(iConfig.getParameter<double>("MissingHitPenalty")),
     allowSharedFirstHit(iConfig.getParameter<bool>("allowSharedFirstHit")){}

virtual TrajectoryCleanerBySharedHits::~TrajectoryCleanerBySharedHits ( )

inlinevirtual

Definition at line 33 of file TrajectoryCleanerBySharedHits.h.

33 {};

Member Function Documentation

void TrajectoryCleanerBySharedHits::clean ( TrajectoryPointerContainer & tc ) const

virtual

Implements TrajectoryCleaner.

Definition at line 41 of file TrajectoryCleanerBySharedHits.cc.

References HLT_25ns14e33_v1_cff::allowSharedFirstHit, alongMomentum, gather_cfg::cout, DEBUG_PRINT, TrackingRecHit::geographicalId(), TrackingRecHit::hit(), Trajectory::invalidate(), TrackingRecHit::isValid(), Trajectory::lostHits(), min(), TrackingRecHit::sharesInput(), and TrackingRecHit::some.

Referenced by InOutConversionTrackFinder::tracks(), and OutInConversionTrackFinder::tracks().

 {
   if (tc.size() <= 1) return; // nothing to clean
 
   auto & theRecHitMap = theMaps.theRecHitMap;
 
   theRecHitMap.clear(10*tc.size());           // set 10*tc.size() active buckets
                                               // numbers are not optimized
 
   DEBUG_PRINT(std::cout << "Filling RecHit map" << std::endl);
   for (TrajectoryPointerContainer::iterator
      it = tc.begin(); it != tc.end(); ++it) {
     DEBUG_PRINT(std::cout << "  Processing trajectory " << *it << " (" << (*it)->foundHits() << " valid hits)" << std::endl);
     const Trajectory::DataContainer & pd = (*it)->measurements();
     for (Trajectory::DataContainer::const_iterator im = pd.begin();
          im != pd.end(); im++) {
       const TransientTrackingRecHit* theRecHit = &(*(*im).recHit());
       if (theRecHit->isValid()) {
         DEBUG_PRINT(std::cout << "    Added hit " << theRecHit << " for trajectory " << *it << std::endl);
         theRecHitMap.insert(theRecHit, *it);
       }
     }
   }
   DEBUG_PRINT(theRecHitMap.dump());
 
   DEBUG_PRINT(std::cout << "Using RecHit map" << std::endl);
   // for each trajectory fill theTrajMap
   auto & theTrajMap = theMaps.theTrajMap; 
   for (TrajectoryCleaner::TrajectoryPointerIterator
      itt = tc.begin(); itt != tc.end(); ++itt) {
     if((*itt)->isValid()){  
       DEBUG_PRINT(std::cout << "  Processing trajectory " << *itt << " (" << (*itt)->foundHits() << " valid hits)" << std::endl);
       theTrajMap.clear();
       const Trajectory::DataContainer & pd = (*itt)->measurements();
       for (Trajectory::DataContainer::const_iterator im = pd.begin();
        im != pd.end(); ++im) {
     //RC const TransientTrackingRecHit* theRecHit = ((*im).recHit());
     const TransientTrackingRecHit* theRecHit = &(*(*im).recHit());
         if (theRecHit->isValid()) {
           DEBUG_PRINT(std::cout << "    Searching for overlaps on hit " << theRecHit << " for trajectory " << *itt << std::endl);
           for (RecHitMap::value_iterator ivec = theRecHitMap.values(theRecHit);
                 ivec.good(); ++ivec) {
               if (*ivec != *itt){
                 if ((*ivec)->isValid()){
                     theTrajMap[*ivec]++;
                 }
               }
           }
     }
       }
       //end filling theTrajMap
 
       // check for duplicated tracks
       if(!theTrajMap.empty() > 0){
     for(TrajMap::iterator imapp = theTrajMap.begin(); 
         imapp != theTrajMap.end(); ++imapp){
       if((*imapp).second > 0 ){
         int innerHit = 0;
         if ( allowSharedFirstHit ) {
           const TrajectoryMeasurement & innerMeasure1 = ( (*itt)->direction() == alongMomentum ) ? 
         (*itt)->firstMeasurement() : (*itt)->lastMeasurement();
           const TransientTrackingRecHit* h1 = &(*(innerMeasure1).recHit());
           const TrajectoryMeasurement & innerMeasure2 = ( (*imapp).first->direction() == alongMomentum ) ? 
         (*imapp).first->firstMeasurement() : (*imapp).first->lastMeasurement();
           const TransientTrackingRecHit* h2 = &(*(innerMeasure2).recHit());
           if ( (h1 == h2) || ((h1->geographicalId() == h2->geographicalId()) && 
                   (h1->hit()->sharesInput(h2->hit(), TrackingRecHit::some))) ) {
         innerHit = 1;
           }
         }
         int nhit1 = (*itt)->foundHits();
         int nhit2 = (*imapp).first->foundHits();
         if( ((*imapp).second - innerHit) >= ( (min(nhit1, nhit2)-innerHit) * theFraction) ){
           Trajectory* badtraj;
           double score1 = validHitBonus_*nhit1 - missingHitPenalty_*(*itt)->lostHits() - (*itt)->chiSquared();
           double score2 = validHitBonus_*nhit2 - missingHitPenalty_*(*imapp).first->lostHits() - (*imapp).first->chiSquared();
           badtraj = (score1 > score2) ? (*imapp).first : *itt;
           badtraj->invalidate();  // invalidate this trajectory
         }
       }
     }
       } 
     }
   }
 }