#include <L1MuDTWedgeSorter.h>

Inheritance diagram for L1MuDTWedgeSorter:

Public Member Functions
int	id () const
	return Wedge Sorter identifier (0-11) More...

	L1MuDTWedgeSorter (const L1MuDTTrackFinder &, int id)
	constructor More...

void	print () const
	print results after sorting More...

void	reset () override
	reset Wedge Sorter More...

void	run () override
	run Wedge Sorter More...

const std::vector< const L1MuDTTrack * > &	tracks () const
	return vector of muon candidates More...

	~L1MuDTWedgeSorter () override
	destructor More...

Public Member Functions inherited from L1AbstractProcessor
virtual void	run (const edm::EventSetup &c)

virtual void	run (const edm::EventSetup &c)

virtual	~L1AbstractProcessor ()
	destructor More...

virtual	~L1AbstractProcessor ()
	destructor More...

Private Member Functions
bool	anyTrack () const
	are there any non-empty muon candidates in the Wedge Sorter? More...

void	runCOL (std::vector< L1MuDTTrack * > &) const
	run the Cancel Out Logic of the wedge sorter More...

Static Private Member Functions
static bool	neighbour (const L1MuDTSecProcId &spid1, const L1MuDTSecProcId &spid2)
	find out if two Sector Processors are neighbours in the same wedge More...

Private Attributes
const L1MuDTTrackFinder &	m_tf

std::vector< const L1MuDTTrack * >	m_TrackCands

int	m_wsid

Detailed Description

Wedge Sorter:

A Wedge Sorter receives 2 muon candidates from each of the 6 Sector Processors of a wedge and forwards the 2 highest rank candidates per wedge to the DT Muon Sorter

N. Neumeister CERN EP

Definition at line 45 of file L1MuDTWedgeSorter.h.

Constructor & Destructor Documentation

L1MuDTWedgeSorter::L1MuDTWedgeSorter	(	const L1MuDTTrackFinder &	tf,
		int	id
	)

constructor

Definition at line 50 of file L1MuDTWedgeSorter.cc.

References m_TrackCands.

                                                                         : m_tf(tf), m_wsid(id), m_TrackCands(2) {
   m_TrackCands.reserve(2);
 }

L1MuDTWedgeSorter::~L1MuDTWedgeSorter ( )

override

destructor

Definition at line 58 of file L1MuDTWedgeSorter.cc.

58 {}

Member Function Documentation

bool L1MuDTWedgeSorter::anyTrack ( ) const

private

are there any non-empty muon candidates in the Wedge Sorter?

Definition at line 163 of file L1MuDTWedgeSorter.cc.

References m_TrackCands.

Referenced by print(), and tracks().

                                        {
   vector<const L1MuDTTrack*>::const_iterator iter = m_TrackCands.begin();
   while (iter != m_TrackCands.end()) {
     if (*iter && !(*iter)->empty())
       return true;
     iter++;
   }
 
   return false;
 }

int L1MuDTWedgeSorter::id ( void ) const

inline

return Wedge Sorter identifier (0-11)

Definition at line 54 of file L1MuDTWedgeSorter.h.

References m_wsid, print(), reset(), and run().

54 { return m_wsid; }

L1MuDTWedgeSorter::m_wsid

int m_wsid

Definition: L1MuDTWedgeSorter.h:80

bool L1MuDTWedgeSorter::neighbour	(	const L1MuDTSecProcId &	spid1,
		const L1MuDTSecProcId &	spid2
	)

staticprivate

find out if two Sector Processors are neighbours in the same wedge

Definition at line 239 of file L1MuDTWedgeSorter.cc.

References L1MuDTSecProcId::sector(), hgcalTopologyTester_cfi::sector1, hgcalTopologyTester_cfi::sector2, and L1MuDTSecProcId::wheel().

Referenced by runCOL(), and tracks().

                                                                                             {
   // neighbour definition:
   // wheel 1 :  -2,  -1,  +1,  +1,  +2
   // wheel 2 :  -3,  -2,  -1,  +2,  +3
 
   bool neigh = false;
 
   int sector1 = spid1.sector();
   int wheel1 = spid1.wheel();
 
   int sector2 = spid2.sector();
   int wheel2 = spid2.wheel();
 
   if (sector1 == sector2) {
     if ((wheel1 == -2 && wheel2 == -3) || (wheel1 == -1 && wheel2 == -2) || (wheel1 == +1 && wheel2 == -1) ||
         (wheel1 == +1 && wheel2 == +2) || (wheel1 == +2 && wheel2 == +3))
       neigh = true;
   }
 
   return neigh;
 }

void L1MuDTWedgeSorter::print ( void ) const

print results after sorting

Definition at line 148 of file L1MuDTWedgeSorter.cc.

References anyTrack(), gather_cfg::cout, m_TrackCands, and m_wsid.

Referenced by id().

                                     {
   if (anyTrack()) {
     cout << "Muon candidates found in Wedge Sorter " << m_wsid << " : " << endl;
     vector<const L1MuDTTrack*>::const_iterator iter = m_TrackCands.begin();
     while (iter != m_TrackCands.end()) {
       if (*iter)
         cout << *(*iter) << " found in " << (*iter)->spid() << endl;
       iter++;
     }
   }
 }

void L1MuDTWedgeSorter::reset ( void )

overridevirtual

reset Wedge Sorter

Implements L1AbstractProcessor.

Definition at line 138 of file L1MuDTWedgeSorter.cc.

References m_TrackCands.

Referenced by id().

                               {
   vector<const L1MuDTTrack*>::iterator iter;
   for (iter = m_TrackCands.begin(); iter != m_TrackCands.end(); iter++) {
     *iter = nullptr;
   }
 }

void L1MuDTWedgeSorter::run ( )

overridevirtual

run Wedge Sorter

Reimplemented from L1AbstractProcessor.

Definition at line 67 of file L1MuDTWedgeSorter.cc.

References L1MuDTTrack::address(), gather_cfg::cout, L1MuDTTFConfig::Debug(), L1MuDTTrack::empty(), m_tf, m_TrackCands, m_wsid, contentValuesFiles::number, L1MuDTTrack::rank(), runCOL(), L1MuDTTrackFinder::sp(), L1MuDTSectorProcessor::track(), and makeMuonMisalignmentScenario::wheel.

Referenced by id().

                             {
   // get track candidates from Sector Processors
   vector<L1MuDTTrack*> wedgecands;
   wedgecands.reserve(12);
 
   int sector = m_wsid;
   for (int wheel = -3; wheel <= 3; wheel++) {
     if (wheel == 0)
       continue;
     L1MuDTSecProcId tmpspid(wheel, sector);
     for (int number = 0; number < 2; number++) {
       const L1MuDTTrack* cand = m_tf.sp(tmpspid)->track(number);
       if (cand && !cand->empty()) {
         // remove tracks which where found in wheel 0 and
         // which didn't cross wheel boundaries (SP -1)
         bool reject = false;
         if (wheel == -1) {
           reject = true;
           for (int stat = 2; stat <= 4; stat++) {
             int adr = cand->address(stat);
             // check addresses : 0,1,4,5,8,9 (own wheel)
             if (adr != 15)
               reject &= ((adr / 2) % 2 == 0);
           }
         }
         if (!reject)
           wedgecands.push_back(const_cast<L1MuDTTrack*>(cand));
       }
     }
   }
 
   // print input data
   if (L1MuDTTFConfig::Debug(5)) {
     cout << "Wedge Sorter " << m_wsid << " input: " << wedgecands.size() << endl;
     vector<L1MuDTTrack*>::const_iterator iter;
     for (iter = wedgecands.begin(); iter != wedgecands.end(); iter++) {
       if (*iter)
         (*iter)->print();
     }
   }
 
   // print input data
   runCOL(wedgecands);
 
   // remove disabled candidates
   vector<L1MuDTTrack*>::iterator it = wedgecands.begin();
   while (it != wedgecands.end()) {
     if (*it && (*it)->empty()) {
       wedgecands.erase(it);
       it = wedgecands.begin();
       continue;
     }
     it++;
   }
 
   // sort candidates by pt and quality and copy the 2 best candidates
   partial_sort_copy(wedgecands.begin(), wedgecands.end(), m_TrackCands.begin(), m_TrackCands.end(), L1MuDTTrack::rank);
 
   if (L1MuDTTFConfig::Debug(4)) {
     cout << "Wedge Sorter " << m_wsid << " output: " << endl;
     vector<const L1MuDTTrack*>::const_iterator iter;
     for (iter = m_TrackCands.begin(); iter != m_TrackCands.end(); iter++) {
       if (*iter)
         (*iter)->print();
     }
   }
 }

void L1MuDTWedgeSorter::runCOL ( std::vector< L1MuDTTrack * > & cands ) const

private

run the Cancel Out Logic of the wedge sorter

Definition at line 177 of file L1MuDTWedgeSorter.cc.

References gather_cfg::cout, L1MuDTTFConfig::Debug(), neighbour(), and L1MuDTSecProcId::wheel().

Referenced by run(), and tracks().

                                                                 {
   // compare candidates which were found in nearby wheels:
   // if 2 candidates have at least one track segment in common
   // disable the one with lower quality;
   // compare addresses from stations 2, 3 and 4
 
   typedef vector<L1MuDTTrack*>::iterator TI;
   for (TI iter1 = cands.begin(); iter1 != cands.end(); iter1++) {
     if (*iter1 == nullptr)
       continue;
     if ((*iter1)->empty())
       continue;
     L1MuDTSecProcId sp1 = (*iter1)->spid();
     int qual1 = (*iter1)->quality();
     for (TI iter2 = cands.begin(); iter2 != cands.end(); iter2++) {
       if (*iter2 == nullptr)
         continue;
       if (*iter1 == *iter2)
         continue;
       if ((*iter2)->empty())
         continue;
       L1MuDTSecProcId sp2 = (*iter2)->spid();
       int qual2 = (*iter2)->quality();
       if (sp1 == sp2)
         continue;
       if (!neighbour(sp1, sp2))
         continue;
       int adr_shift = (sp2.wheel() == -1) ? 0 : 2;
       int countTS = 0;
       for (int stat = 2; stat <= 4; stat++) {
         int adr1 = (*iter1)->address(stat);
         int adr2 = (*iter2)->address(stat);
         if (adr1 == 15 || adr2 == 15)
           continue;
         if ((adr2 / 2) % 2 == 1)
           continue;
         if (adr1 == adr2 + adr_shift)
           countTS++;
       }
       if (countTS > 0) {
         if (qual1 < qual2) {
           if (L1MuDTTFConfig::Debug(5)) {
             cout << "Wedge Sorter cancel : ";
             (*iter1)->print();
           }
           (*iter1)->disable();
           break;
         } else {
           if (L1MuDTTFConfig::Debug(5)) {
             cout << "Wedge Sorter cancel : ";
             (*iter2)->print();
           }
           (*iter2)->disable();
         }
       }
     }
   }
 }