RPCTBGhostBuster Class Reference

#include <RPCTBGhostBuster.h>

Public Member Functions
L1RpcTBMuonsVec	gBEta (L1RpcTBMuonsVec2 &gbPhiMuonsVec2) const
L1RpcTBMuonsVec	gBPhi (L1RpcTBMuonsVec &pacMuonsVec) const
L1RpcTBMuonsVec	run (L1RpcTBMuonsVec2 &pacMuonsVec2) const

Detailed Description

Peformes the Trigger Board Ghost Buster and sorter algorithms. Because the class does not keep any data and GB is the same for every TB, there might be one and the same object of this class for all TBs.

Author

Karol Bunkowski (Warsaw)

Definition at line 13 of file RPCTBGhostBuster.h.

Member Function Documentation

gBEta()

L1RpcTBMuonsVec RPCTBGhostBuster::gBEta

(

L1RpcTBMuonsVec2 &

gbPhiMuonsVec2

)

const

Parameters

gbPhiMuonsVec2

size() should be equal to 4 (max number of m_tower in TB). Performs the Eta Goustbuster - between muons from diferent towers. Calls RPCTBMuon::setPhiAddr() for each alive muon.

Returns

always 4 muons.

Definition at line 123 of file RPCTBGhostBuster.cc.

                                                                              {
  //-----  killing ghosts ---------------------------------------
  for (unsigned int iMuVec = 0; iMuVec < gbPhiMuonsVec2.size() - 1; iMuVec++) {
    for (unsigned int iMu = 0; iMu < gbPhiMuonsVec2[iMuVec].size(); iMu++) {
      if (gbPhiMuonsVec2[iMuVec][iMu].getCode() == 0)
        break;  //because muons are sorted
 
      for (unsigned int iMuNext = 0; iMuNext < gbPhiMuonsVec2[iMuVec + 1].size(); iMuNext++) {
        if (abs(gbPhiMuonsVec2[iMuVec][iMu].getPhiAddr() - gbPhiMuonsVec2[iMuVec + 1][iMuNext].getPhiAddr()) <= 1) {
          //comparing with next:
          if (gbPhiMuonsVec2[iMuVec][iMu].getCode() < gbPhiMuonsVec2[iMuVec + 1][iMuNext].getCode()) {
            gbPhiMuonsVec2[iMuVec][iMu].kill();
          } else {
            gbPhiMuonsVec2[iMuVec + 1][iMuNext].kill();
          }
        }
      }
    }
  }
 
  //---------sorting-----------------------------------------
  /*  multiset<RPCTBMuon, RPCTBMuon::TMuonMore> liveMuonsSet;
  for(unsigned int iMuVec = 0; iMuVec < gbPhiMuonsVec2.size(); iMuVec++)
  for(unsigned int iMu = 0; iMu < gbPhiMuonsVec2[iMuVec].size(); iMu++)
      if(gbPhiMuonsVec2[iMuVec][iMu].isLive()) {
        gbPhiMuonsVec2[iMuVec][iMu].setEtaAddr(iMuVec);
        liveMuonsSet.insert(gbPhiMuonsVec2[iMuVec][iMu]);
      }
  L1RpcTBMuonsVec outputMuons(liveMuonsSet.begin(), liveMuonsSet.end()); */
 
  L1RpcTBMuonsVec outputMuons;
  for (unsigned int iMuVec = 0; iMuVec < gbPhiMuonsVec2.size(); iMuVec++)
    for (unsigned int iMu = 0; iMu < gbPhiMuonsVec2[iMuVec].size(); iMu++)
      if (gbPhiMuonsVec2[iMuVec][iMu].isLive()) {
        gbPhiMuonsVec2[iMuVec][iMu].setEtaAddr(iMuVec);
        outputMuons.push_back(gbPhiMuonsVec2[iMuVec][iMu]);
      }
  sort(outputMuons.begin(), outputMuons.end(), RPCTBMuon::TMuonMore());
 
  //-------setting size to m_GBETA_OUT_MUONS_CNT----------------
  while (outputMuons.size() < RPCConst::m_GBETA_OUT_MUONS_CNT)
    outputMuons.push_back(RPCTBMuon());
  while (outputMuons.size() > RPCConst::m_GBETA_OUT_MUONS_CNT)
    outputMuons.pop_back();
 
  return outputMuons;

References funct::abs(), and RPCConst::m_GBETA_OUT_MUONS_CNT.

gBPhi()

L1RpcTBMuonsVec RPCTBGhostBuster::gBPhi

(

L1RpcTBMuonsVec &

pacMuonsVec

)

const

Parameters

pacMuonsVec

pacMuonsVec.size() should be equal to 12 (Segment in given TB count) or 0, Performs Phi Goustbuster - between muons in one sector of the same m_tower.

Returns

if pacMuonsVec has size = 0, returns L1RpcTBMuonsVec with size 0, otherwise returns vector of size = 4. Calls RPCTBMuon::setPhiAddr() for each alive muon.

Definition at line 50 of file RPCTBGhostBuster.cc.

                                                                          {
  if (pacMuonsVec.empty())
    return L1RpcTBMuonsVec();          //empty vector;
                                       //--------- killing ghosts ---------------------------------------
  pacMuonsVec.push_back(RPCTBMuon());  //adding  empty muon to the end,
 
  for (unsigned int iMu = 0; iMu < RPCConst::m_SEGMENTS_IN_SECTOR_CNT; iMu++) {
    if (pacMuonsVec[iMu].getCode() == 0)
      ;
    else if (pacMuonsVec[iMu].getCode() < pacMuonsVec[iMu + 1].getCode())
      pacMuonsVec[iMu].kill();
    else if (pacMuonsVec[iMu].getCode() == pacMuonsVec[iMu + 1].getCode()) {
      if (pacMuonsVec[iMu].wasKilled())
        pacMuonsVec[iMu + 1].kill();
      else
        pacMuonsVec[iMu].kill();
    } else  //>
      pacMuonsVec[iMu + 1].kill();
  }
 
  pacMuonsVec.pop_back();  //removing empty muon from the end,
 
  //-------setting the m_GBData ----------------------------------
  if (pacMuonsVec[0].isLive())
    pacMuonsVec[0].setGBDataKilledFirst();
  else if (pacMuonsVec[0].wasKilled())
    for (unsigned int iMu = 0; iMu < RPCConst::m_SEGMENTS_IN_SECTOR_CNT; iMu++) {
      if (pacMuonsVec[iMu].isLive()) {
        pacMuonsVec[iMu].setGBDataKilledFirst();
        break;
      }
    }
 
  if (pacMuonsVec[RPCConst::m_SEGMENTS_IN_SECTOR_CNT - 1].isLive())
    pacMuonsVec[RPCConst::m_SEGMENTS_IN_SECTOR_CNT - 1].setGBDataKilledLast();
  else if (pacMuonsVec[RPCConst::m_SEGMENTS_IN_SECTOR_CNT - 1].wasKilled())
    for (int iMu = RPCConst::m_SEGMENTS_IN_SECTOR_CNT - 1; iMu >= 0; iMu--) {
      if (pacMuonsVec[iMu].isLive()) {
        pacMuonsVec[iMu].setGBDataKilledLast();
        break;
      }
    }
  //-------------sorting ------------------------------------------
  /*
  multiset<RPCTBMuon, RPCTBMuon::TMuonMore> liveMuonsSet;
  for(int iMu = 0; iMu < m_SEGMENTS_IN_SECTOR_CNT; iMu++) {
    if(pacMuonsVec[iMu].isLive()) {
      pacMuonsVec[iMu].setPhiAddr(iMu);
      liveMuonsSet.insert(pacMuonsVec[iMu]);
    }
  }
  L1RpcTBMuonsVec outputMuons(liveMuonsSet.begin(), liveMuonsSet.end());*/
 
  L1RpcTBMuonsVec outputMuons;
  for (unsigned int iMu = 0; iMu < RPCConst::m_SEGMENTS_IN_SECTOR_CNT; iMu++) {
    if (pacMuonsVec[iMu].isLive()) {
      pacMuonsVec[iMu].setPhiAddr(iMu);
      outputMuons.push_back(pacMuonsVec[iMu]);
    }
  }
  sort(outputMuons.begin(), outputMuons.end(), RPCTBMuon::TMuonMore());
 
  //-------setting size to m_GBPHI_OUT_MUONS_CNT----------------
  while (outputMuons.size() < RPCConst::m_GBPHI_OUT_MUONS_CNT)
    outputMuons.push_back(RPCTBMuon());
  while (outputMuons.size() > RPCConst::m_GBPHI_OUT_MUONS_CNT)
    outputMuons.pop_back();
 
  return outputMuons;

References RPCConst::m_GBPHI_OUT_MUONS_CNT, and RPCConst::m_SEGMENTS_IN_SECTOR_CNT.

run()

L1RpcTBMuonsVec RPCTBGhostBuster::run

(

L1RpcTBMuonsVec2 &

pacMuonsVec2

)

const

Calls gBPhi and gBEta.

Parameters

pacMuonsVec2

pacMuonsVec2[0..3][0..11] (4 Towers x 12 Segments (PACs) ), if pacMuonsVec2[i].size() == 0, means no nonempty muon.

Returns

always 4 muons.

Definition at line 14 of file RPCTBGhostBuster.cc.

                                                                          {
  L1RpcTBMuonsVec2 gbPhiMuonsVec2;
  for (unsigned int iTow = 0; iTow < pacMuonsVec2.size(); iTow++) {
    gbPhiMuonsVec2.push_back(gBPhi(pacMuonsVec2[iTow]));
  }
 
  return gBEta(gbPhiMuonsVec2);

Referenced by RPCTriggerBoard::runTBGB().