RPCTrigger/src/RPCTBMuon.cc

0001 //---------------------------------------------------------------------------
0002 #include "L1Trigger/RPCTrigger/interface/RPCTBMuon.h"
0003 #ifndef _STAND_ALONE
0004 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0005 #endif  // _STAND_ALONE
0006 #include "L1Trigger/RPCTrigger/interface/RPCException.h"
0007
0008 #include <sstream>
0009 #include <iomanip>
0010 #include <iostream>
0011
0012 using namespace std;
0013 //---------------------------------------------------------------------------
0014 RPCTBMuon::RPCTBMuon() : RPCMuon() {
0015   m_Killed = false;
0016
0017   m_GBData = 0;
0018
0019   m_EtaAddress = 0;
0020   m_PhiAddress = 0;
0021
0022   m_muonBitsType = mbtUnset;
0023 }
0024 //---------------------------------------------------------------------------
0025 RPCTBMuon::RPCTBMuon(int ptCode, int quality, int sign, int patternNum, unsigned short firedPlanes)
0026     : RPCMuon(ptCode, quality, sign, patternNum, firedPlanes) {
0027   m_Killed = false;
0028
0029   m_GBData = 0;
0030
0031   m_EtaAddress = 0;
0032   m_PhiAddress = 0;
0033
0034   m_muonBitsType = mbtUnset;
0035 }
0036
0037 RPCTBMuon::RPCTBMuon(int ptCode, int quality, int sign, MuonBitsType muonBitsType)
0038     : RPCMuon(ptCode, quality, sign, 0, 0) {
0039   m_Killed = false;
0040
0041   m_GBData = 0;
0042
0043   m_EtaAddress = 0;
0044   m_PhiAddress = 0;
0045
0046   m_muonBitsType = muonBitsType;
0047 }
0048
0049 /**
0050 *
0051 * \brief Gives debuging info in human readable format (1) or technicall format (2)
0052 * \note Possible debugFormat codes (1,2) are defined in RPCTrigger constructor
0053 *
0054 */
0055 std::string RPCTBMuon::printDebugInfo(int debugFormat) const {
0056   std::ostringstream sDebugInfo;
0057   if (debugFormat == 1) {  // Human readable
0058
0059     sDebugInfo << "TBMuon: code: " << getPtCode() << " etaAddr: " << getEtaAddr() << " phiAddr: " << getPhiAddr()
0060                << " sgAddr: " << getSegmentAddr() << " scAddr: " << getSectorAddr() << " gbData: " << getGBData();
0061
0062   } else {  //technicall
0063     sDebugInfo << "TBMuon pt " << getPtCode() << " ql " << getQuality() << " sgn " << getSign() << " tw " << getTower()
0064                << " sc " << getLogSector() << " sg " << getLogSegment() << " phi " << getPhiAddr() << " eta "
0065                << getEtaAddr() << " gbD " << getGBData() << " bits " << toBits(mbtFSBOut);
0066   }
0067
0068   return sDebugInfo.str();
0069 }
0070 //---------------------------------------------------------------------------
0071 // Simple setters and getters
0072
0073 ///Combined quality and ptCode, 8 bits [7...6 m_Quality, 5...1 m_PtCode, 0 sign], used in GhoustBusters
0074 int RPCTBMuon::getCode() const {
0075   // 1 bit, 0 - negative, 1 - positive.
0076   unsigned int signLocal = 0;
0077   if (m_Sign == 0)
0078     signLocal = 1;  // invert
0079   return (m_Quality << 6 | m_PtCode << 1 | signLocal);
0080 }
0081
0082 ///Sets combined code: 8 bits [7...5 m_Quality, 4...0 m_PtCode].
0083 void RPCTBMuon::setCode(int code) {
0084   m_Quality = (code & (3 << 5)) >> 5;
0085   m_PtCode = code & 31;
0086 }
0087
0088 void RPCTBMuon::setPhiAddr(int phiAddr) { m_PhiAddress = phiAddr; }
0089
0090 void RPCTBMuon::setSectorAddr(int sectorAddr) { m_PhiAddress = m_PhiAddress | sectorAddr << 4; }
0091
0092 void RPCTBMuon::setEtaAddr(int etaAddr) { m_EtaAddress = etaAddr; }
0093
0094 void RPCTBMuon::setAddress(int etaAddr, int phiAddr) {
0095   m_EtaAddress = etaAddr;
0096   m_PhiAddress = phiAddr;
0097 }
0098
0099 void RPCTBMuon::setAddress(int tbNumber, int tbTower, int phiAddr) {
0100   m_EtaAddress = (tbNumber << 2) | tbTower;
0101   m_PhiAddress = phiAddr;
0102 }
0103
0104 void RPCTBMuon::setGBData(unsigned int gbData) { m_GBData = gbData; }
0105
0106 int RPCTBMuon::getEtaAddr() const { return m_EtaAddress; }
0107
0108 int RPCTBMuon::getPhiAddr() const { return m_PhiAddress; }
0109
0110 int RPCTBMuon::getSegmentAddr() const { return m_PhiAddress & 15; }
0111
0112 int RPCTBMuon::getSectorAddr() const { return (m_PhiAddress & 0xF0) >> 4; }
0113
0114 int RPCTBMuon::getContinSegmAddr() const { return getSectorAddr() * 12 + getSegmentAddr(); }
0115
0116 void RPCTBMuon::setCodeAndPhiAddr(int code, int phiAddr) {
0117   setCode(code);
0118   m_PhiAddress = phiAddr;
0119 }
0120
0121 void RPCTBMuon::setCodeAndEtaAddr(int code, int etaAddr) {
0122   setCode(code);
0123   m_EtaAddress = etaAddr;
0124 }
0125
0126 int RPCTBMuon::getGBData() const { return m_GBData; }
0127
0128 std::string RPCTBMuon::getGBDataBitStr() const {
0129   std::string str = "00";
0130   if (m_GBData == 1)
0131     str = "01";
0132   else if (m_GBData == 2)
0133     str = "10";
0134   else if (m_GBData == 3)
0135     str = "11";
0136   return str;
0137 }
0138
0139 void RPCTBMuon::setGBDataKilledFirst() { m_GBData = m_GBData | 1; }
0140
0141 void RPCTBMuon::setGBDataKilledLast() { m_GBData = m_GBData | 2; }
0142
0143 bool RPCTBMuon::gBDataKilledFirst() const { return (m_GBData & 1); }
0144
0145 bool RPCTBMuon::gBDataKilledLast() const { return (m_GBData & 2); }
0146
0147 //---------------------------------------------------------------------------
0148 void RPCTBMuon::kill() { m_Killed = true; }
0149
0150 /** @return true = was non-empty muon and was killed
0151   * false = was not killed or is zero */
0152 bool RPCTBMuon::wasKilled() const {
0153   if (m_PtCode > 0 && m_Killed)
0154     return true;
0155   else
0156     return false;
0157 }
0158
0159 /** @return true = was no-zero muon and was not killed
0160   * false = is killed or is zero */
0161 bool RPCTBMuon::isLive() const {
0162   if (m_PtCode > 0 && !m_Killed)
0163     return true;
0164   else
0165     return false;
0166 }
0167
0168 //---------------------------------------------------------------------------
0169 #ifndef _STAND_ALONE
0170 RPCTBMuon::RPCTBMuon(const RPCPacMuon& pacMuon) : RPCMuon(pacMuon) {
0171   m_Killed = false;
0172
0173   m_GBData = 0;
0174
0175   m_EtaAddress = 0;
0176   m_PhiAddress = 0;
0177   m_muonBitsType = mbtUnset;
0178 }
0179 #endif  //_STAND_ALONE
0180 //---------------------------------------------------------------------------
0181
0182 unsigned int RPCTBMuon::toBits(RPCTBMuon::MuonBitsType muonBitsType) const {
0183   if (muonBitsType == mbtPACOut) {
0184     return PACOut::toBits(*this);
0185   } else if (muonBitsType == mbtTBSortOut) {
0186     return TBOut::toBits(*this);
0187   } else if (muonBitsType == mbtTCSortOut) {
0188     return TCOut::toBits(*this);
0189   } else if (muonBitsType == mbtHSBOut) {
0190     return HSBOut::toBits(*this);
0191   } else if (muonBitsType == mbtFSBOut) {
0192     return FSBOut::toBits(*this);
0193   } else {
0194     throw RPCException("unknown value of muonBitsType");
0195     //edm::LogError("RPCTrigger")<<"unknown value of where: " + where;
0196   }
0197   return 0;
0198 }
0199
0200 void RPCTBMuon::fromBits(RPCTBMuon::MuonBitsType muonBitsType, unsigned int value) {
0201   if (muonBitsType == mbtPACOut) {
0202     PACOut::fromBits(*this, value);
0203   } else if (muonBitsType == mbtTBSortOut) {
0204     TBOut::fromBits(*this, value);
0205   } else if (muonBitsType == mbtTCSortOut) {
0206     TCOut::fromBits(*this, value);
0207   } else if (muonBitsType == mbtHSBOut) {
0208     HSBOut::fromBits(*this, value);
0209   } else if (muonBitsType == mbtFSBOut) {
0210     FSBOut::fromBits(*this, value);
0211   } else {
0212     RPCException("unknown value of muonBitsType");
0213     //edm::LogError("RPCTrigger")<< "unknown value of where: " + where;
0214   }
0215 }
0216
0217 void RPCTBMuon::PACOut::fromBits(RPCTBMuon& muon, unsigned int value) {
0218   unsigned int shift = 0;
0219   muon.m_Sign = (value & (m_signBitsMask << shift)) >> shift;
0220   shift += m_signBitsCnt;
0221   muon.m_PtCode = (value & (m_ptBitsMask << shift)) >> shift;
0222   shift += m_ptBitsCnt;
0223   muon.m_Quality = (value & (m_qualBitsMask << shift)) >> shift;
0224 }
0225
0226 unsigned int RPCTBMuon::PACOut::toBits(const RPCTBMuon& muon) {
0227   unsigned int value = 0;
0228   unsigned int shift = 0;
0229   value = (muon.m_Sign << shift);
0230   shift += m_signBitsCnt;
0231   value = value | (muon.m_PtCode << shift);
0232   shift += m_ptBitsCnt;
0233   value = value | (muon.m_Quality << shift);
0234
0235   return value;
0236 }
0237
0238 //-----------------------
0239 void RPCTBMuon::TBOut::fromBits(RPCTBMuon& muon, unsigned int value) {
0240   unsigned int shift = 0;
0241   muon.m_Sign = (value & (m_signBitsMask << shift)) >> shift;
0242   shift += m_signBitsCnt;
0243   muon.m_PtCode = (value & (m_ptBitsMask << shift)) >> shift;
0244   shift += m_ptBitsCnt;
0245   muon.m_Quality = (value & (m_qualBitsMask << shift)) >> shift;
0246   shift += m_qualBitsCnt;
0247   muon.m_PhiAddress = (value & (m_phiBitsMask << shift)) >> shift;
0248   shift += m_phiBitsCnt;
0249   muon.m_EtaAddress = (value & (m_etaBitsMask << shift)) >> shift;
0250   shift += m_etaBitsCnt;
0251   muon.m_GBData = (value & (m_gbDataBitsMask << shift)) >> shift;
0252 }
0253
0254 unsigned int RPCTBMuon::TBOut::toBits(const RPCTBMuon& muon) {
0255   unsigned int value = 0;
0256   unsigned int shift = 0;
0257   value = (muon.m_Sign << shift);
0258   shift += m_signBitsCnt;
0259   value = value | (muon.m_PtCode << shift);
0260   shift += m_ptBitsCnt;
0261   value = value | (muon.m_Quality << shift);
0262   shift += m_qualBitsCnt;
0263   value = value | (muon.m_PhiAddress << shift);
0264   shift += m_phiBitsCnt;
0265   value = value | (muon.m_EtaAddress << shift);
0266   shift += m_etaBitsCnt;
0267   value = value | (muon.m_GBData << shift);
0268   return value;
0269 }
0270
0271 //-----------------------
0272 void RPCTBMuon::TCOut::fromBits(RPCTBMuon& muon, unsigned int value) {
0273   unsigned int shift = 0;
0274   muon.m_Sign = (value & (m_signBitsMask << shift)) >> shift;
0275   shift += m_signBitsCnt;
0276   muon.m_PtCode = (value & (m_ptBitsMask << shift)) >> shift;
0277   shift += m_ptBitsCnt;
0278   muon.m_Quality = (value & (m_qualBitsMask << shift)) >> shift;
0279   shift += m_qualBitsCnt;
0280   muon.m_PhiAddress = (value & (m_phiBitsMask << shift)) >> shift;
0281   shift += m_phiBitsCnt;
0282   muon.m_EtaAddress = (value & (m_etaBitsMask << shift)) >> shift;
0283   shift += m_etaBitsCnt;
0284   muon.m_GBData = (value & (m_gbDataBitsMask << shift)) >> shift;
0285 }
0286
0287 unsigned int RPCTBMuon::TCOut::toBits(const RPCTBMuon& muon) {
0288   unsigned int value = 0;
0289   unsigned int shift = 0;
0290   value = (muon.m_Sign << shift);
0291   shift += m_signBitsCnt;
0292   value = value | (muon.m_PtCode << shift);
0293   shift += m_ptBitsCnt;
0294   value = value | (muon.m_Quality << shift);
0295   shift += m_qualBitsCnt;
0296   value = value | (muon.m_PhiAddress << shift);
0297   shift += m_phiBitsCnt;
0298   value = value | (muon.m_EtaAddress << shift);
0299   shift += m_etaBitsCnt;
0300   value = value | (muon.m_GBData << shift);
0301   return value;
0302 }
0303 //-------------------------------
0304
0305 unsigned int RPCTBMuon::HSBOut::toBits(const RPCTBMuon& muon) {
0306   unsigned int value = 0;
0307
0308   unsigned int shift = 0;
0309   value = value | (muon.m_Sign << shift);
0310   shift += m_signBitsCnt;
0311   // value = (muon.m_Sign<<shift);       shift += m_signBitsCnt;
0312   value = value | (muon.m_PtCode << shift);
0313   shift += m_ptBitsCnt;
0314   value = value | (muon.m_Quality << shift);
0315   shift += m_qualBitsCnt;
0316   value = value | (muon.m_PhiAddress << shift);
0317   shift += m_phiBitsCnt;
0318   value = value | (muon.m_EtaAddress << shift);
0319
0320   return value;
0321 }
0322
0323 void RPCTBMuon::HSBOut::fromBits(RPCTBMuon& muon, unsigned int value) {
0324   unsigned int shift = 0;
0325   muon.m_Sign = (value & (m_signBitsMask << shift)) >> shift;
0326   shift += m_signBitsCnt;
0327   muon.m_PtCode = (value & (m_ptBitsMask << shift)) >> shift;
0328   shift += m_ptBitsCnt;
0329   muon.m_Quality = (value & (m_qualBitsMask << shift)) >> shift;
0330   shift += m_qualBitsCnt;
0331   muon.m_PhiAddress = (value & (m_phiBitsMask << shift)) >> shift;
0332   shift += m_phiBitsCnt;
0333   muon.m_EtaAddress = (value & (m_etaBitsMask << shift)) >> shift;
0334 }
0335
0336 unsigned int RPCTBMuon::FSBOut::toBits(const RPCTBMuon& muon) {
0337   unsigned int value = 0;
0338
0339   unsigned int shift = 0;
0340   //bita are reversed, to be zero when cable not connected
0341   unsigned int ptCode = (~(muon.m_PtCode)) & m_ptBitsMask;
0342   unsigned int quality = (~(muon.m_Quality)) & m_qualBitsMask;
0343
0344   value = value | muon.m_PhiAddress;
0345   shift += m_phiBitsCnt;
0346   value = value | (ptCode << shift);
0347   shift += m_ptBitsCnt;
0348   value = value | (quality << shift);
0349   shift += m_qualBitsCnt;
0350
0351   //+1 beacouse H/F bits, unused in RPC:
0352   value = value | (muon.m_EtaAddress << shift);
0353   shift += m_etaBitsCnt + 1;
0354   value = value | (muon.m_Sign << shift);
0355
0356   return value;
0357 }
0358
0359 void RPCTBMuon::FSBOut::fromBits(RPCTBMuon& muon, unsigned int value) {
0360   unsigned int shift = 0;
0361   muon.m_PhiAddress = value & m_phiBitsMask;
0362   shift += m_phiBitsCnt;
0363   muon.m_PtCode = (value & (m_ptBitsMask << shift)) >> shift;
0364   shift += m_ptBitsCnt;
0365   muon.m_Quality = (value & (m_qualBitsMask << shift)) >> shift;
0366   shift += m_qualBitsCnt;
0367
0368   //+1 beacouse H/F bits, unused in RPC:
0369   muon.m_EtaAddress = (value & (m_etaBitsMask << shift)) >> shift;
0370   shift += m_etaBitsCnt + 1;
0371   muon.m_Sign = (value & (m_signBitsMask << shift)) >> shift;
0372
0373   muon.m_PtCode = (~(muon.m_PtCode)) & m_ptBitsMask;
0374   muon.m_Quality = (~(muon.m_Quality)) & m_qualBitsMask;
0375 }
0376
0377 std::string RPCTBMuon::toString(int format) const {
0378   ostringstream ostr;
0379   if (format == 0) {
0380     ostr << "qu " << m_Quality << ", pt " << setw(2) << m_PtCode << ", sig " << m_Sign << ", phi " << setw(3)
0381          << m_PhiAddress << ", eta " << setw(2) << m_EtaAddress;
0382   } else if (format == 1) {
0383     ostr << " " << m_Quality << " " << setw(2) << m_PtCode << " " << m_Sign << " " << setw(3) << m_PhiAddress << " "
0384          << setw(2) << m_EtaAddress;
0385   } else if (format == 2) {
0386     ostr << " " << m_Quality << " " << setw(2) << m_PtCode << " " << m_Sign;
0387   }
0388
0389   return ostr.str();
0390 }