---

TrackCleaner Class Reference

#include <RecoPixelVertexing/PixelLowPtUtilities/interface/TrackCleaner.h>

Inheritance diagram for TrackCleaner:

List of all members.

Public Member Functions
virtual TracksWithRecHits	cleanTracks (const TracksWithRecHits &tracksWithRecHits)
	TrackCleaner (const edm::ParameterSet &ps)
virtual	~TrackCleaner ()
Private Member Functions
int	getLayer (const DetId &id)
bool	hasCommonDetUnit (std::vector< const TrackingRecHit * > recHitsA, std::vector< const TrackingRecHit * > recHitsB, std::vector< DetId > detIds)
bool	hasCommonLayer (std::vector< const TrackingRecHit * > recHitsA, std::vector< const TrackingRecHit * > recHitsB, std::vector< int > detLayers)

---

Detailed Description

Definition at line 14 of file TrackCleaner.h.

---

Constructor & Destructor Documentation

TrackCleaner::TrackCleaner

(

const edm::ParameterSet &

ps

)

Definition at line 37 of file TrackCleaner.cc.

{
}

TrackCleaner::~TrackCleaner

(

)

[virtual]

Definition at line 42 of file TrackCleaner.cc.

{
}

---

Member Function Documentation

TracksWithRecHits TrackCleaner::cleanTracks

(

const TracksWithRecHits &

tracksWithRecHits

)

[virtual]

Definition at line 105 of file TrackCleaner.cc.

References find(), first, HitInfo::getInfo(), getLayer(), hasCommonLayer(), i, j, keep, LogTrace, min, edm::second(), and tracks.

{
  LogTrace("MinBiasTracking")
    << " [TrackCleaner]";

  // 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("MinBiasTracking")
    << "   Track #" << i << " : " << HitInfo::getInfo(tracks[i].second);

  do
  {
  changes = 0;

  RecHitMap recHitMap;

  // 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;

    TrackMap trackMap;
    vector<DetId> detIds;
    vector<int> detLayers;

    // 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]++;

      // Fill detLayers vector
      detIds.push_back((*recHit)->geographicalId());
      detLayers.push_back(getLayer((*recHit)->geographicalId()));
    }

    // 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(tracks[i].second.size(),
                                   tracks[j].second.size())/2)
        { // more than min(hits1,hits2)/2 rechits are shared

          if(!hasCommonLayer(tracks[i].second,tracks[j].second,detLayers))
          { 
            // 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++)
              if(find(tracks[i].second.begin(),
                      tracks[i].second.end(),*recHit) == tracks[i].second.end())
                tracks[i].second.push_back(*recHit);

            LogTrace("MinBiasTracking") << " merge " << i << " " << j;
  
            // Remove second track
            keep[j] = false;
  
           changes++;
          }
          else
          { // remove track with higher impact / chi2
            if(tracks[i].first->chi2() < tracks[j].first->chi2())
              keep[j] = false;
            else
              keep[i] = false;

            LogTrace("MinBiasTracking") << " merge + keep lower chi2 " << i << " " << j;
  
            changes++;
          }
        }
        else
        {
          if((*sharing).second > 1)
          {
            if(tracks[i].second.size() != tracks[j].second.size())
            {
              if(tracks[i].second.size() > tracks[j].second.size()) 
                keep[j] = false; else keep[i] = false; 
              changes++;
            LogTrace("MinBiasTracking") << " sharing " << (*sharing).second << " remove by size";
            }
            else
            { 
              if(tracks[i].first->chi2() < tracks[j].first->chi2())
                keep[j] = false; else keep[i] = false; 
              changes++;
            LogTrace("MinBiasTracking") << " sharing " << (*sharing).second << " remove by chi2";
            } 
          }
        }
      }
      else
      { // pair tracks
        if((*sharing).second > 0)
        {
          // Remove second track
          keep[j] = false;
  
          changes++;
        }
      }
    }
  }
  }
  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("MinBiasTracking")
    << "   Track #" << i << " : " << HitInfo::getInfo(cleaned[i].second);

  return cleaned;
}

int TrackCleaner::getLayer

(

const DetId &

id

)

[private]

Definition at line 47 of file TrackCleaner.cc.

References PXFDetId::disk(), PXBDetId::ladder(), PXBDetId::layer(), PXFDetId::panel(), and PixelSubdetector::PixelBarrel.

Referenced by cleanTracks().

{
  if(id.subdetId() == int(PixelSubdetector::PixelBarrel))
  {
    PXBDetId pid(id);
    return 0 + ((pid.layer() - 1)*2) + ((pid.ladder() - 1)%2);
  } 
  else
  {
    PXFDetId pid(id);
    return 6 + ((pid.disk()  - 1)*2) + ((pid.panel()  - 1)%2);
  } 
}

bool TrackCleaner::hasCommonDetUnit	(	std::vector< const TrackingRecHit * >	recHitsA,
		std::vector< const TrackingRecHit * >	recHitsB,
		std::vector< DetId >	detIds
	)			[private]

bool TrackCleaner::hasCommonLayer	(	std::vector< const TrackingRecHit * >	recHitsA,
		std::vector< const TrackingRecHit * >	recHitsB,
		std::vector< int >	detLayers
	)			[private]

Referenced by cleanTracks().

---

The documentation for this class was generated from the following files:

• RecoPixelVertexing/PixelLowPtUtilities/interface/TrackCleaner.h
• RecoPixelVertexing/PixelLowPtUtilities/src/TrackCleaner.cc

---