#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
virtual void	clean (TempTrajectoryContainer &) const

virtual void	clean (TrajectoryContainer &) const

void	clean (TrajectoryPointerContainer &) const override

virtual void	clean (TrajectoryPointerContainer &) const=0

	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 15 of file TrajectoryCleanerBySharedHits.h.

Member Typedef Documentation

◆ TrajectoryPointerContainer

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

Definition at line 17 of file TrajectoryCleanerBySharedHits.h.

Constructor & Destructor Documentation

◆ TrajectoryCleanerBySharedHits() [1/2]

TrajectoryCleanerBySharedHits::TrajectoryCleanerBySharedHits ( )

inline

Definition at line 19 of file TrajectoryCleanerBySharedHits.h.

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

◆ TrajectoryCleanerBySharedHits() [2/2]

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

inline

Definition at line 21 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::~TrajectoryCleanerBySharedHits ( )

inlineoverride

Definition at line 27 of file TrajectoryCleanerBySharedHits.h.

27 {};

Member Function Documentation

◆ clean() [1/4]

void TrajectoryCleaner::clean

Definition at line 5 of file TrajectoryCleaner.cc.

                                                             {
   edm::LogError("TrajectoryCleaner") << "not implemented for TempTrajectory";
   assert(false);
 }

◆ clean() [2/4]

void TrajectoryCleaner::clean

Definition at line 10 of file TrajectoryCleaner.cc.

                                                            {
   TrajectoryPointerContainer thePointerContainer;
   thePointerContainer.reserve(tc.size());
   for (TrajectoryCleaner::TrajectoryIterator it = tc.begin(); it != tc.end(); it++) {
     thePointerContainer.push_back(&(*it));
   }
  
   clean(thePointerContainer);
 }

◆ clean() [3/4]

void TrajectoryCleanerBySharedHits::clean ( TrajectoryPointerContainer & tc ) const

overridevirtual

Implements TrajectoryCleaner.

Definition at line 42 of file TrajectoryCleanerBySharedHits.cc.

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