TrajectoryCleanerBySharedHits Class Reference

#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 (TrajectoryPointerContainer &) const=0
virtual void	clean (TrajectoryContainer &) const
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 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.

      : 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.

{};

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]

virtual void TrajectoryCleaner::clean

clean() [3/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() [4/4]

void TrajectoryCleanerBySharedHits::clean ( TrajectoryPointerContainer &  tc ) const

overridevirtual

Implements TrajectoryCleaner.

Definition at line 42 of file TrajectoryCleanerBySharedHits.cc.

References HLT_2024v12_cff::allowSharedFirstHit, alongMomentum, gather_cfg::cout, DEBUG_PRINT, TrackingRecHit::geographicalId(), TrackingRecHit::hit(), Trajectory::invalidate(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, SiStripPI::min, mkfit::Config::missingHitPenalty_, rpcPointValidation_cfi::recHit, offlineSlimmedPrimaryVertices_cfi::score, TrackingRecHit::sharesInput(), TrackingRecHit::some, submitPVValidationJobs::t, and mkfit::Config::validHitBonus_.

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

Member Data Documentation

allowSharedFirstHit

bool TrajectoryCleanerBySharedHits::allowSharedFirstHit

private

Definition at line 36 of file TrajectoryCleanerBySharedHits.h.

missingHitPenalty_

float TrajectoryCleanerBySharedHits::missingHitPenalty_

private

Definition at line 35 of file TrajectoryCleanerBySharedHits.h.

theFraction

float TrajectoryCleanerBySharedHits::theFraction

private

Definition at line 33 of file TrajectoryCleanerBySharedHits.h.

validHitBonus_

float TrajectoryCleanerBySharedHits::validHitBonus_

private

Definition at line 34 of file TrajectoryCleanerBySharedHits.h.