L1MuDTWedgeSorter Class Reference

#include <L1MuDTWedgeSorter.h>

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 ()
	reset Wedge Sorter More...
void	run ()
	run Wedge Sorter More...
const std::vector< const L1MuDTTrack * > &	tracks () const
	return vector of muon candidates More...
	~L1MuDTWedgeSorter ()
	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 43 of file L1MuDTWedgeSorter.h.

Constructor & Destructor Documentation

L1MuDTWedgeSorter()

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::~L1MuDTWedgeSorter

(

)

destructor

Definition at line 58 of file L1MuDTWedgeSorter.cc.

{}

Member Function Documentation

anyTrack()

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().

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

  return false;
}

id()

int L1MuDTWedgeSorter::id ( void  ) const

inline

return Wedge Sorter identifier (0-11)

Definition at line 52 of file L1MuDTWedgeSorter.h.

References m_wsid.

{ return m_wsid; }

neighbour()

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().

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

print()

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.

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

reset()

void L1MuDTWedgeSorter::reset

(

void

)

reset Wedge Sorter

Definition at line 138 of file L1MuDTWedgeSorter.cc.

References m_TrackCands.

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

run()

void L1MuDTWedgeSorter::run

(

)

run Wedge Sorter

Definition at line 67 of file L1MuDTWedgeSorter.cc.

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

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

runCOL()

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 HLT_2022v11_cff::cands, gather_cfg::cout, L1MuDTTFConfig::Debug(), neighbour(), and L1MuDTSecProcId::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<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();
        }
      }
    }
  }
}

tracks()

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

inline

return vector of muon candidates

Definition at line 64 of file L1MuDTWedgeSorter.h.

References m_TrackCands.

Referenced by L1MuDTMuonSorter::run().

{ return m_TrackCands; }

Member Data Documentation

m_tf

const L1MuDTTrackFinder& L1MuDTWedgeSorter::m_tf

private

Definition at line 77 of file L1MuDTWedgeSorter.h.

Referenced by run().

m_TrackCands

std::vector<const L1MuDTTrack*> L1MuDTWedgeSorter::m_TrackCands

private

Definition at line 80 of file L1MuDTWedgeSorter.h.

Referenced by anyTrack(), L1MuDTWedgeSorter(), print(), reset(), run(), and tracks().

m_wsid

int L1MuDTWedgeSorter::m_wsid

private

Definition at line 78 of file L1MuDTWedgeSorter.h.

Referenced by id(), print(), and run().