#include <L1MuBMWedgeSorter.h>

Inheritance diagram for L1MuBMWedgeSorter:

Public Member Functions
bool	anyMuonCands () const
	return number of muon candidates More...

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

	L1MuBMWedgeSorter (const L1MuBMTrackFinder &, int id)
	constructor More...

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

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

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

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

virtual	~L1MuBMWedgeSorter ()
	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< L1MuBMTrack * > &) const
	run the Cancel Out Logic of the wedge sorter More...

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

Private Attributes
const L1MuBMTrackFinder &	m_tf

std::vector< const L1MuBMTrack * >	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 BM Muon Sorter

N. Neumeister CERN EP

Definition at line 45 of file L1MuBMWedgeSorter.h.

Constructor & Destructor Documentation

L1MuBMWedgeSorter::L1MuBMWedgeSorter	(	const L1MuBMTrackFinder &	tf,
		int	id
	)

constructor

Definition at line 50 of file L1MuBMWedgeSorter.cc.

References m_TrackCands.

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

L1MuBMWedgeSorter::~L1MuBMWedgeSorter ( )

virtual

destructor

Definition at line 62 of file L1MuBMWedgeSorter.cc.

                                       {
 
 }

Member Function Documentation

bool L1MuBMWedgeSorter::anyMuonCands ( ) const

inline

return number of muon candidates

Definition at line 71 of file L1MuBMWedgeSorter.h.

References anyTrack().

71 { return anyTrack(); }

L1MuBMWedgeSorter::anyTrack

bool anyTrack() const

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

Definition: L1MuBMWedgeSorter.cc:177

bool L1MuBMWedgeSorter::anyTrack ( ) const

private

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

Definition at line 177 of file L1MuBMWedgeSorter.cc.

References m_TrackCands.

Referenced by anyMuonCands(), and print().

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

int L1MuBMWedgeSorter::id ( void ) const

inline

return Wedge Sorter identifier (0-11)

Definition at line 56 of file L1MuBMWedgeSorter.h.

References m_wsid.

56 { return m_wsid; }

L1MuBMWedgeSorter::m_wsid

int m_wsid

Definition: L1MuBMWedgeSorter.h:87

bool L1MuBMWedgeSorter::neighbour	(	const L1MuBMSecProcId &	spid1,
		const L1MuBMSecProcId &	spid2
	)

staticprivate

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

Definition at line 247 of file L1MuBMWedgeSorter.cc.

References L1MuBMSecProcId::sector(), and L1MuBMSecProcId::wheel().

Referenced by runCOL().

                                                                 {
 
   // 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 L1MuBMWedgeSorter::print ( void ) const

print results after sorting

Definition at line 159 of file L1MuBMWedgeSorter.cc.

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

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

void L1MuBMWedgeSorter::reset ( void )

virtual

reset Wedge Sorter

Implements L1AbstractProcessor.

Definition at line 146 of file L1MuBMWedgeSorter.cc.

References m_TrackCands.

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

void L1MuBMWedgeSorter::run ( void )

virtual

run Wedge Sorter

Reimplemented from L1AbstractProcessor.

Definition at line 74 of file L1MuBMWedgeSorter.cc.

References L1MuBMTrack::address(), gather_cfg::cout, L1MuBMTFConfig::Debug(), L1MuBMTrack::empty(), m_tf, m_TrackCands, m_wsid, contentValuesFiles::number, runCOL(), L1MuBMTrackFinder::sp(), and L1MuBMSectorProcessor::track().

                             {
 
   // get track candidates from Sector Processors
   vector<L1MuBMTrack*> wedgecands;
   wedgecands.reserve(12);
 
   int sector = m_wsid;
   for ( int wheel = -3; wheel <= 3; wheel++ ) {
     if ( wheel == 0 ) continue;
     L1MuBMSecProcId tmpspid(wheel,sector);
     for ( int number = 0; number < 2; number++ ) {
       const L1MuBMTrack* 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<L1MuBMTrack*>(cand));
       }
     }
   }
 
   // print input data
   if ( L1MuBMTFConfig::Debug(5) ) {
     cout << "Wedge Sorter " << m_wsid << " input: "
          << wedgecands.size() << endl;
     vector<L1MuBMTrack*>::const_iterator iter;
     for ( iter = wedgecands.begin(); iter != wedgecands.end(); iter++ ) {
       if (*iter ) (*iter)->print();
     }
   }
 
   // print input data
   runCOL(wedgecands);
 
   // remove disabled candidates
   vector<L1MuBMTrack*>::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(),
                      L1MuBMTrack::Rank() );
 
   if ( L1MuBMTFConfig::Debug(4) ) {
     cout << "Wedge Sorter " << m_wsid << " output: " << endl;
     vector<const L1MuBMTrack*>::const_iterator iter;
     for ( iter  = m_TrackCands.begin();
           iter != m_TrackCands.end(); iter++ ) {
       if (*iter) (*iter)->print();
     }
   }
 
 }

void L1MuBMWedgeSorter::runCOL ( std::vector< L1MuBMTrack * > & cands ) const

private

run the Cancel Out Logic of the wedge sorter

Definition at line 193 of file L1MuBMWedgeSorter.cc.

References gather_cfg::cout, L1MuBMTFConfig::Debug(), neighbour(), and L1MuBMSecProcId::wheel().

Referenced by run().

                                                                 {
 
   // 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<L1MuBMTrack*>::iterator TI;
   for ( TI iter1 = cands.begin(); iter1 != cands.end(); iter1++ ) {
     if ( *iter1 == 0 ) continue;
     if ( (*iter1)->empty() ) continue;
     L1MuBMSecProcId sp1 = (*iter1)->spid();
     int qual1 = (*iter1)->quality();
     for ( TI iter2 = cands.begin(); iter2 != cands.end(); iter2++ ) {
       if ( *iter2 == 0 ) continue;
       if ( *iter1 == *iter2 ) continue;
       if ( (*iter2)->empty() ) continue;
       L1MuBMSecProcId 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 ( L1MuBMTFConfig::Debug(5) ) {
             cout << "Wedge Sorter cancel : "; (*iter1)->print();
           }
           (*iter1)->disable();
           break;
         }
         else {
           if ( L1MuBMTFConfig::Debug(5) ) {
             cout << "Wedge Sorter cancel : "; (*iter2)->print();
           }
          (*iter2)->disable();
         }
       }
     }
   }
 
 }