#include <TrajectoryCleanerBySharedHits.h>

Inheritance diagram for TrajectoryCleanerBySharedHits:

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

Public Types inherited from TrajectoryCleaner
typedef TrackingComponentsRecord	Record

using	TempTrajectoryContainer = std::vector< TempTrajectory >

typedef std::vector< Trajectory >	TrajectoryContainer

typedef TrajectoryContainer::iterator	TrajectoryIterator

typedef std::vector< Trajectory * >	TrajectoryPointerContainer

typedef TrajectoryPointerContainer::iterator	TrajectoryPointerIterator

Public Member Functions
void	clean (TrajectoryPointerContainer &) const override

	TrajectoryCleanerBySharedHits ()

	TrajectoryCleanerBySharedHits (const edm::ParameterSet &iConfig)

	~TrajectoryCleanerBySharedHits () override

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

virtual void	clean (TrajectoryContainer &) const

	TrajectoryCleaner ()

	TrajectoryCleaner (edm::ParameterSet &iConfig)

virtual	~TrajectoryCleaner ()

Private Attributes
bool	allowSharedFirstHit

float	missingHitPenalty_

float	theFraction

float	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")){}

TrajectoryCleanerBySharedHits::~TrajectoryCleanerBySharedHits ( )

inlineoverride

Definition at line 33 of file TrajectoryCleanerBySharedHits.h.

References TrajectoryCleaner::clean(), and clean().

33 {};

Member Function Documentation

void TrajectoryCleanerBySharedHits::clean ( TrajectoryPointerContainer & tc ) const

overridevirtual

Implements TrajectoryCleaner.

Definition at line 41 of file TrajectoryCleanerBySharedHits.cc.

References conversionTrackCandidates_cfi::allowSharedFirstHit, alongMomentum, gather_cfg::cout, DEBUG_PRINT, TrackingRecHit::geographicalId(), TrackingRecHit::hit(), Trajectory::invalidate(), min(), rpcPointValidation_cfi::recHit, offlineSlimmedPrimaryVertices_cfi::score, TrackingRecHit::sharesInput(), TrackingRecHit::some, and protons_cff::t.

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

 {
   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 (auto const & it : tc) {
     DEBUG_PRINT(std::cout << "  Processing trajectory " << it << " (" << it->foundHits() << " valid hits)" << std::endl);
     auto const & pd = it->measurements();
     for (auto const & im : pd) {
       auto 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 (auto const & itt : tc) {
     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 (auto const & im : pd) {
     auto 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
 
      auto score = [&](Trajectory const&t)->float {
             // possible variant under study
             // auto ns = t.foundHits()-t.trailingFoundHits();
             //auto penalty =  0.8f*missingHitPenalty_;
             // return validHitBonus_*(t.foundHits()-0.2f*t.cccBadHits())  - penalty*t.lostHits() - t.chiSquared();
          // classical score
          return validHitBonus_*t.foundHits()  - missingHitPenalty_*t.lostHits() - t.chiSquared();
      };
 
       // check for duplicated tracks
       if(!theTrajMap.empty() > 0){
     for(auto const & imapp : theTrajMap) {
       if(imapp.second > 0 ){  // at least 1 hits in common!!!
         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;
           auto score1 = score(*itt);
           auto score2 = score(*imapp.first);
           badtraj = (score1 > score2) ? imapp.first : itt;
           badtraj->invalidate();  // invalidate this trajectory
         }
       }
     }
       } 
     }
   }
 }