#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 ( const TrackerTopology * tTopo )

explicit

Definition at line 75 of file TrackCleaner.cc.

                                                       : tTopo_(tTopo)
 {
 }

TrackCleaner::~TrackCleaner ( )

override

Definition at line 80 of file TrackCleaner.cc.

81 {

82 }

Member Function Documentation

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

private

Definition at line 85 of file TrackCleaner.cc.

References MillePedeFileConverter_cfg::e, TrackingRecHit::geographicalId(), TrackingRecHit::localPosition(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by canBeMerged(), and cleanTracks().

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

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

private

Definition at line 143 of file TrackCleaner.cc.

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

Referenced by cleanTracks(), and isCompatible().

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

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

overridevirtual

Reimplemented from PixelTrackCleaner.

Definition at line 162 of file TrackCleaner.cc.

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

Referenced by canBeMerged().

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

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

private

Definition at line 99 of file TrackCleaner.cc.

References funct::abs(), canBeMerged(), constexpr, runTauDisplay::dr, PVValHelper::dz, createfilelist::int, SiStripPI::max, PixelSubdetector::PixelBarrel, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), TrackerTopology::pxfBlade(), TrackerTopology::pxfDisk(), TrackerTopology::pxfModule(), TrackerTopology::pxfPanel(), TrackerTopology::pxfSide(), DetId::subdetId(), and tTopo_.

Referenced by canBeMerged().

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

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

private

Member Data Documentation

const TrackerTopology* TrackCleaner::tTopo_

private

Definition at line 34 of file TrackCleaner.h.

Referenced by cleanTracks(), and isCompatible().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation