TrackCleaner Class Reference

#include <TrackCleaner.h>

Inheritance diagram for TrackCleaner:

Public Member Functions
TracksWithRecHits	cleanTracks (const TracksWithRecHits &tracksWithRecHits) const override
	TrackCleaner (const TrackerTopology *tTopo)
	~TrackCleaner () override
Public Member Functions inherited from PixelTrackCleaner
virtual void	cleanTracks (TracksWithTTRHs &tracksWithRecHits) const
bool	fast () const
virtual	~PixelTrackCleaner ()

Private Member Functions
bool	areSame (const TrackingRecHit *a, const TrackingRecHit *b) const
bool	canBeMerged (const std::vector< const TrackingRecHit * > &recHitsA, const std::vector< const TrackingRecHit * > &recHitsB) const
bool	isCompatible (const DetId &i1, const DetId &i2) const
std::vector< const TrackingRecHit * >	ttrhs (const SeedingHitSet &h) const

Private Attributes
const TrackerTopology *	tTopo_

Additional Inherited Members
Public Types inherited from PixelTrackCleaner
using	Record = TrajectoryFilter::Record
typedef pixeltrackfitting::TracksWithRecHits	TracksWithRecHits
using	TracksWithTTRHs = pixeltrackfitting::TracksWithTTRHs
Protected Member Functions inherited from PixelTrackCleaner
	PixelTrackCleaner (bool fast=false)

Detailed Description

Definition at line 15 of file TrackCleaner.h.

Constructor & Destructor Documentation

TrackCleaner()

TrackCleaner::TrackCleaner ( const TrackerTopology *  tTopo )

explicit

Definition at line 73 of file TrackCleaner.cc.

: tTopo_(tTopo) {}

~TrackCleaner()

TrackCleaner::~TrackCleaner ( )

override

Definition at line 76 of file TrackCleaner.cc.

{}

Member Function Documentation

areSame()

bool TrackCleaner::areSame ( const TrackingRecHit *  a, const TrackingRecHit *  b  ) const

private

Definition at line 79 of file TrackCleaner.cc.

                                                                                 {
  if (a->geographicalId() != b->geographicalId())
    return false;
 
  if (fabs(a->localPosition().x() - b->localPosition().x()) < 1e-5 &&
      fabs(a->localPosition().y() - b->localPosition().y()) < 1e-5)
    return true;
  else
    return false;
}

References a, b, and MillePedeFileConverter_cfg::e.

Referenced by canBeMerged(), and cleanTracks().

canBeMerged()

bool TrackCleaner::canBeMerged ( const std::vector< const TrackingRecHit * > &  recHitsA, const std::vector< const TrackingRecHit * > &  recHitsB  ) const

private

Definition at line 135 of file TrackCleaner.cc.

                                                                                     {
  bool ok = true;
 
  for (vector<const TrackingRecHit *>::const_iterator recHitA = recHitsA.begin(); recHitA != recHitsA.end(); recHitA++)
    for (vector<const TrackingRecHit *>::const_iterator recHitB = recHitsB.begin(); recHitB != recHitsB.end();
         recHitB++)
      if (!areSame(*recHitA, *recHitB))
        if (!isCompatible((*recHitA)->geographicalId(), (*recHitB)->geographicalId()))
          ok = false;
 
  return ok;
}

References areSame(), isCompatible(), and convertSQLiteXML::ok.

Referenced by cleanTracks().

cleanTracks()

TracksWithRecHits TrackCleaner::cleanTracks ( const TracksWithRecHits &  tracksWithRecHits ) const

overridevirtual

Reimplemented from PixelTrackCleaner.

Definition at line 150 of file TrackCleaner.cc.

                                                                                  {
  // Local copy
  TracksWithRecHits tracks = tracks_;
 
  typedef map<const TrackingRecHit *, vector<unsigned int>, HitComparator> RecHitMap;
 
  vector<bool> keep(tracks.size(), true);
 
  int changes;
 
  LogTrace("MinBiasTracking") << " [TrackCleaner] initial tracks : " << tracks.size();
 
  for (unsigned int i = 0; i < tracks.size(); i++)
    LogTrace("TrackCleaner") << "   Track #" << i << " : " << HitInfo::getInfo(tracks[i].second, tTopo_);
 
  do {
    changes = 0;
 
    RecHitMap recHitMap;
 
    /*
  LogTrace("MinBiasTracking")
    << " [TrackCleaner] fill rechit map";
*/
 
    // Fill the rechit map
    for (unsigned int i = 0; i < tracks.size(); i++)
      if (keep[i]) {
        for (vector<const TrackingRecHit *>::const_iterator recHit = tracks[i].second.begin();
             recHit != tracks[i].second.end();
             recHit++)
          recHitMap[*recHit].push_back(i);
      }
 
    // Look at each track
    typedef map<unsigned int, int, less<unsigned int> > TrackMap;
 
    for (unsigned int i = 0; i < tracks.size(); i++) {
      // Skip if 'i' already removed
      if (!keep[i])
        continue;
 
      /*
 
    bool addedNewHit = false;
    do
    {
*/
      TrackMap trackMap;
 
      // Go trough all rechits of this track
      for (vector<const TrackingRecHit *>::const_iterator recHit = tracks[i].second.begin();
           recHit != tracks[i].second.end();
           recHit++) {
        // Get tracks sharing this rechit
        vector<unsigned int> sharing = recHitMap[*recHit];
 
        for (vector<unsigned int>::iterator j = sharing.begin(); j != sharing.end(); j++)
          if (i < *j)
            trackMap[*j]++;
      }
 
      // Check for tracks with shared rechits
      for (TrackMap::iterator sharing = trackMap.begin(); sharing != trackMap.end(); sharing++) {
        unsigned int j = (*sharing).first;
        if (!keep[i] || !keep[j])
          continue;
 
        if (tracks[i].second.size() >= 3) {  // triplet tracks
          if ((*sharing).second > min(int(tracks[i].second.size()),
                                      int(tracks[j].second.size())) /
                                      2) {                          // more than min(hits1,hits2)/2 rechits are shared
            if (canBeMerged(tracks[i].second, tracks[j].second)) {  // no common layer
              // merge tracks, add separate hits of the second to the first one
              for (vector<const TrackingRecHit *>::const_iterator recHit = tracks[j].second.begin();
                   recHit != tracks[j].second.end();
                   recHit++) {
                bool ok = true;
                for (vector<const TrackingRecHit *>::const_iterator recHitA = tracks[i].second.begin();
                     recHitA != tracks[i].second.end();
                     recHitA++)
                  if (areSame(*recHit, *recHitA))
                    ok = false;
 
                if (ok) {
                  tracks[i].second.push_back(*recHit);
                  recHitMap[*recHit].push_back(i);
 
                  sort(tracks[i].second.begin(), tracks[i].second.end(), HitComparatorByRadius(tTopo_));
 
                  //addedNewHit = true;
                }
              }
 
              LogTrace("TrackCleaner") << "   Merge #" << i << " #" << j << ", first now has "
                                       << tracks[i].second.size();
 
              // Remove second track
              keep[j] = false;
 
              changes++;
            } else {  // there is a common layer, keep smaller impact
              if (fabs(tracks[i].first->d0()) < fabs(tracks[j].first->d0()))
                keep[j] = false;
              else
                keep[i] = false;
 
              LogTrace("TrackCleaner") << "   Clash #" << i << " #" << j << " keep lower d0 " << tracks[i].first->d0()
                                       << " " << tracks[j].first->d0() << ", keep #"
                                       << (keep[i] ? i : (keep[j] ? j : 9999));
 
              changes++;
            }
          } else {  // note more than 50%, but at least two are shared
            if ((*sharing).second > 1) {
              if (tracks[i].second.size() != tracks[j].second.size()) {  // keep longer
                if (tracks[i].second.size() > tracks[j].second.size())
                  keep[j] = false;
                else
                  keep[i] = false;
                changes++;
 
                LogTrace("TrackCleaner") << "   Sharing " << (*sharing).second << " remove by size";
              } else {  // keep smaller impact
                if (fabs(tracks[i].first->d0()) < fabs(tracks[j].first->d0()))
                  keep[j] = false;
                else
                  keep[i] = false;
                changes++;
 
                LogTrace("TrackCleaner") << "   Sharing " << (*sharing).second << " remove by d0";
              }
            }
          }
        } else {  // pair tracks
          if ((*sharing).second > 0) {
            // Remove second track
            keep[j] = false;
 
            changes++;
          }
        }
      }
      /*
    }
    while(addedNewHit);
*/
    }
  } while (changes > 0);
 
  // Final copy
  TracksWithRecHits cleaned;
 
  for (unsigned int i = 0; i < tracks.size(); i++)
    if (keep[i])
      cleaned.push_back(tracks[i]);
    else
      delete tracks_[i].first;
 
  LogTrace("MinBiasTracking") << " [TrackCleaner] cleaned tracks : " << cleaned.size();
 
  for (unsigned int i = 0; i < cleaned.size(); i++)
    LogTrace("TrackCleaner") << "   Track #" << i << " : " << HitInfo::getInfo(cleaned[i].second, tTopo_);
 
  return cleaned;
}

References areSame(), canBeMerged(), first, HitInfo::getInfo(), mps_fire::i, dqmiolumiharvest::j, runTheMatrix::keep, LogTrace, min(), convertSQLiteXML::ok, rpcPointValidation_cfi::recHit, edm::second(), jetUpdater_cfi::sort, tracks, and tTopo_.

isCompatible()

bool TrackCleaner::isCompatible ( const DetId &  i1, const DetId &  i2  ) const

private

Definition at line 91 of file TrackCleaner.cc.

                                                                      {
  // different subdet
  if (i1.subdetId() != i2.subdetId())
    return true;
 
  if (i1.subdetId() == int(PixelSubdetector::PixelBarrel)) {  // barrel
 
    if (tTopo_->pxbLayer(i1) != tTopo_->pxbLayer(i2))
      return true;
 
    int dphi = abs(int(tTopo_->pxbLadder(i1) - tTopo_->pxbLadder(i2)));
    //FIXME: non-phase-0 wrap-around is wrong (sh/be 12, 28, 44, 64 in phase-1)
    // the harm is somewhat minimal with some excess of duplicates.
    constexpr int max[4] = {20, 32, 44, 64};
    auto aLayer = tTopo_->pxbLayer(i1) - 1;
    assert(aLayer < 4);
    if (dphi > max[aLayer] / 2)
      dphi = max[aLayer] - dphi;
 
    int dz = abs(int(tTopo_->pxbModule(i1) - tTopo_->pxbModule(i2)));
 
    if (dphi == 1 && dz <= 1)
      return true;
  } else {  // endcap
 
    if (tTopo_->pxfSide(i1) != tTopo_->pxfSide(i2) || tTopo_->pxfDisk(i1) != tTopo_->pxfDisk(i2))
      return true;
 
    int dphi = abs(int(tTopo_->pxfBlade(i1) - tTopo_->pxfBlade(i2)));
    constexpr int max = 24;  //FIXME: non-phase-0 wrap-around is wrong
    if (dphi > max / 2)
      dphi = max - dphi;
 
    int dr = abs(int(((tTopo_->pxfModule(i1) - 1) * 2 + (tTopo_->pxfPanel(i1) - 1)) -
                     ((tTopo_->pxfModule(i2) - 1) * 2 + (tTopo_->pxfPanel(i2) - 1))));
 
    if (dphi <= 1 && dr <= 1 && !(dphi == 0 && dr == 0))
      return true;
  }
 
  return false;
}

References funct::abs(), cms::cuda::assert(), flavorHistoryFilter_cfi::dr, PVValHelper::dz, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, createfilelist::int, SiStripPI::max, PixelSubdetector::PixelBarrel, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), TrackerTopology::pxfBlade(), TrackerTopology::pxfDisk(), TrackerTopology::pxfModule(), TrackerTopology::pxfPanel(), TrackerTopology::pxfSide(), and tTopo_.

Referenced by canBeMerged().

ttrhs()

std::vector<const TrackingRecHit *> TrackCleaner::ttrhs ( const SeedingHitSet &  h ) const

private

Member Data Documentation

tTopo_

const TrackerTopology* TrackCleaner::tTopo_

private

Definition at line 30 of file TrackCleaner.h.

Referenced by cleanTracks(), and isCompatible().