Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:25:48 

0001 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSeverityLevelComputer.h"
0002 #include "CondFormats/HcalObjects/interface/HcalChannelStatus.h"
0003 #include "DataFormats/METReco/interface/HcalCaloFlagLabels.h"
0004 #include "DataFormats/METReco/interface/HcalPhase1FlagLabels.h"
0005 #include "DataFormats/HcalDetId/interface/HcalGenericDetId.h"
0006 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0007 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0008 
0009 bool HcalSeverityLevelComputer::getChStBit(HcalSeverityDefinition& mydef, const std::string& mybit) {
0010   if (mybit == "HcalCellOff")
0011     setBit(HcalChannelStatus::HcalCellOff, mydef.chStatusMask);
0012   else if (mybit == "HcalCellMask")
0013     setBit(HcalChannelStatus::HcalCellMask, mydef.chStatusMask);
0014   else if (mybit == "HcalCellDead")
0015     setBit(HcalChannelStatus::HcalCellDead, mydef.chStatusMask);
0016   else if (mybit == "HcalCellHot")
0017     setBit(HcalChannelStatus::HcalCellHot, mydef.chStatusMask);
0018   else if (mybit == "HcalCellStabErr")
0019     setBit(HcalChannelStatus::HcalCellStabErr, mydef.chStatusMask);
0020   else if (mybit == "HcalCellTimErr")
0021     setBit(HcalChannelStatus::HcalCellTimErr, mydef.chStatusMask);
0022   else if (mybit == "HcalCellTrigMask")
0023     setBit(HcalChannelStatus::HcalCellTrigMask, mydef.chStatusMask);
0024   else if (mybit == "HcalCellCaloTowerMask")
0025     setBit(HcalChannelStatus::HcalCellCaloTowerMask, mydef.chStatusMask);
0026   else if (mybit == "HcalCellCaloTowerProb")
0027     setBit(HcalChannelStatus::HcalCellCaloTowerProb, mydef.chStatusMask);
0028   else if (mybit == "HcalCellExcludeFromHBHENoiseSummary")
0029     setBit(HcalChannelStatus::HcalCellExcludeFromHBHENoiseSummary, mydef.chStatusMask);
0030   else if (mybit == "HcalCellExcludeFromHBHENoiseSummaryR45")
0031     setBit(HcalChannelStatus::HcalCellExcludeFromHBHENoiseSummaryR45, mydef.chStatusMask);
0032   else if (mybit == "HcalBadLaserSignal")
0033     setBit(HcalChannelStatus::HcalBadLaserSignal, mydef.chStatusMask);
0034   else {  // error: unrecognized channel status name
0035     edm::LogWarning("HcalSeverityLevelComputer")
0036         << "HcalSeverityLevelComputer: Error: ChannelStatusFlag >>" << mybit << "<< unknown. Ignoring.";
0037     return false;
0038   }
0039   return true;
0040 }
0041 
0042 bool HcalSeverityLevelComputer::getRecHitFlag(HcalSeverityDefinition& mydef, const std::string& mybit, int phase) {
0043   if (phase == 1)  // Phase 1 Rechit flags
0044   {
0045     // HB, HE ++++++++++++++++++++
0046     if (mybit == "HBHEHpdHitMultiplicity")
0047       setBit(HcalPhase1FlagLabels::HBHEHpdHitMultiplicity, mydef.HBHEFlagMask);
0048     else if (mybit == "HBHEIsolatedNoise")
0049       setBit(HcalPhase1FlagLabels::HBHEIsolatedNoise, mydef.HBHEFlagMask);
0050     else if (mybit == "HBHEFlatNoise")
0051       setBit(HcalPhase1FlagLabels::HBHEFlatNoise, mydef.HBHEFlagMask);
0052     else if (mybit == "HBHESpikeNoise")
0053       setBit(HcalPhase1FlagLabels::HBHESpikeNoise, mydef.HBHEFlagMask);
0054     else if (mybit == "HBHETS4TS5Noise")
0055       setBit(HcalPhase1FlagLabels::HBHETS4TS5Noise, mydef.HBHEFlagMask);
0056     else if (mybit == "HBHENegativeNoise")
0057       setBit(HcalPhase1FlagLabels::HBHENegativeNoise, mydef.HBHEFlagMask);
0058     else if (mybit == "HBHEPulseFitBit")
0059       setBit(HcalPhase1FlagLabels::HBHEPulseFitBit, mydef.HBHEFlagMask);
0060     else if (mybit == "HBHEOOTPU")
0061       setBit(HcalPhase1FlagLabels::HBHEOOTPU, mydef.HBHEFlagMask);
0062 
0063     // HF ++++++++++++++++++++
0064     else if (mybit == "HFLongShort")
0065       setBit(HcalPhase1FlagLabels::HFLongShort, mydef.HFFlagMask);
0066     else if (mybit == "HFS8S1Ratio")
0067       setBit(HcalPhase1FlagLabels::HFS8S1Ratio, mydef.HFFlagMask);
0068     else if (mybit == "HFPET")
0069       setBit(HcalPhase1FlagLabels::HFPET, mydef.HFFlagMask);
0070     else if (mybit == "HFSignalAsymmetry")
0071       setBit(HcalPhase1FlagLabels::HFSignalAsymmetry, mydef.HFFlagMask);
0072     else if (mybit == "HFAnomalousHit")
0073       setBit(HcalPhase1FlagLabels::HFAnomalousHit, mydef.HFFlagMask);
0074 
0075     // Common subdetector bits ++++++++++++++++++++++
0076     else if (mybit == "TimingFromTDC")
0077       setAllRHMasks(HcalPhase1FlagLabels::TimingFromTDC, mydef);
0078     else if (mybit == "UserDefinedBit0")
0079       setAllRHMasks(HcalPhase1FlagLabels::UserDefinedBit0, mydef);
0080 
0081     // unknown -------------------
0082     else {
0083       // error: unrecognized flag name
0084       edm::LogWarning("HcalSeverityLevelComputer")
0085           << "HcalSeverityLevelComputer: Error: RecHitFlag >>" << mybit << "<< unknown. Ignoring.";
0086       return false;
0087     }
0088   } else  // Phase 0 Rechit flags
0089   {
0090     // HB, HE ++++++++++++++++++++
0091     if (mybit == "HBHEHpdHitMultiplicity")
0092       setBit(HcalCaloFlagLabels::HBHEHpdHitMultiplicity, mydef.HBHEFlagMask);
0093     else if (mybit == "HBHEPulseShape")
0094       setBit(HcalCaloFlagLabels::HBHEPulseShape, mydef.HBHEFlagMask);
0095     else if (mybit == "HSCP_R1R2")
0096       setBit(HcalCaloFlagLabels::HSCP_R1R2, mydef.HBHEFlagMask);
0097     else if (mybit == "HSCP_FracLeader")
0098       setBit(HcalCaloFlagLabels::HSCP_FracLeader, mydef.HBHEFlagMask);
0099     else if (mybit == "HSCP_OuterEnergy")
0100       setBit(HcalCaloFlagLabels::HSCP_OuterEnergy, mydef.HBHEFlagMask);
0101     else if (mybit == "HSCP_ExpFit")
0102       setBit(HcalCaloFlagLabels::HSCP_ExpFit, mydef.HBHEFlagMask);
0103     else if (mybit == "HBHEFlatNoise")
0104       setBit(HcalCaloFlagLabels::HBHEFlatNoise, mydef.HBHEFlagMask);
0105     else if (mybit == "HBHESpikeNoise")
0106       setBit(HcalCaloFlagLabels::HBHESpikeNoise, mydef.HBHEFlagMask);
0107     else if (mybit == "HBHETriangleNoise")
0108       setBit(HcalCaloFlagLabels::HBHETriangleNoise, mydef.HBHEFlagMask);
0109     else if (mybit == "HBHETS4TS5Noise")
0110       setBit(HcalCaloFlagLabels::HBHETS4TS5Noise, mydef.HBHEFlagMask);
0111     else if (mybit == "HBHENegativeNoise")
0112       setBit(HcalCaloFlagLabels::HBHENegativeNoise, mydef.HBHEFlagMask);
0113     else if (mybit == "HBHEPulseFitBit")
0114       setBit(HcalCaloFlagLabels::HBHEPulseFitBit, mydef.HBHEFlagMask);
0115     else if (mybit == "HBHEOOTPU")
0116       setBit(HcalCaloFlagLabels::HBHEOOTPU, mydef.HBHEFlagMask);
0117 
0118     // These are multi-bit counters; we may have to revisit how to set them in the SLComputer in the future
0119     else if (mybit == "HBHETimingTrustBits")
0120       setBit(HcalCaloFlagLabels::HBHETimingTrustBits, mydef.HBHEFlagMask);
0121     else if (mybit == "HBHETimingShapedCutsBits")
0122       setBit(HcalCaloFlagLabels::HBHETimingShapedCutsBits, mydef.HBHEFlagMask);
0123     else if (mybit == "HBHEIsolatedNoise")
0124       setBit(HcalCaloFlagLabels::HBHEIsolatedNoise, mydef.HBHEFlagMask);
0125 
0126     // HO ++++++++++++++++++++
0127     else if (mybit == "HOBit")
0128       setBit(HcalCaloFlagLabels::HOBit, mydef.HOFlagMask);
0129 
0130     // HF ++++++++++++++++++++
0131     else if (mybit == "HFLongShort")
0132       setBit(HcalCaloFlagLabels::HFLongShort, mydef.HFFlagMask);
0133     else if (mybit == "HFDigiTime")
0134       setBit(HcalCaloFlagLabels::HFDigiTime, mydef.HFFlagMask);
0135     else if (mybit == "HFInTimeWindow")
0136       setBit(HcalCaloFlagLabels::HFInTimeWindow, mydef.HFFlagMask);
0137     else if (mybit == "HFS8S1Ratio")
0138       setBit(HcalCaloFlagLabels::HFS8S1Ratio, mydef.HFFlagMask);
0139     else if (mybit == "HFPET")
0140       setBit(HcalCaloFlagLabels::HFPET, mydef.HFFlagMask);
0141     else if (mybit == "HFTimingTrustBits")
0142       setBit(HcalCaloFlagLabels::HFTimingTrustBits, mydef.HFFlagMask);  // multi-bit counter
0143 
0144     // ZDC ++++++++++++++++++++
0145     else if (mybit == "ZDCBit")
0146       setBit(HcalCaloFlagLabels::ZDCBit, mydef.ZDCFlagMask);
0147 
0148     // Calib ++++++++++++++++++++
0149     else if (mybit == "CalibrationBit")
0150       setBit(HcalCaloFlagLabels::CalibrationBit, mydef.CalibFlagMask);
0151 
0152     // Common subdetector bits ++++++++++++++++++++++
0153     else if (mybit == "TimingSubtractedBit")
0154       setAllRHMasks(HcalCaloFlagLabels::TimingSubtractedBit, mydef);
0155     else if (mybit == "TimingAddedBit")
0156       setAllRHMasks(HcalCaloFlagLabels::TimingAddedBit, mydef);
0157     else if (mybit == "TimingErrorBit")
0158       setAllRHMasks(HcalCaloFlagLabels::TimingErrorBit, mydef);
0159     else if (mybit == "ADCSaturationBit")
0160       setAllRHMasks(HcalCaloFlagLabels::ADCSaturationBit, mydef);
0161     else if (mybit == "AddedSimHcalNoise")
0162       setAllRHMasks(HcalCaloFlagLabels::AddedSimHcalNoise, mydef);
0163 
0164     else if (mybit == "UserDefinedBit0")
0165       setAllRHMasks(HcalCaloFlagLabels::UserDefinedBit0, mydef);
0166 
0167     // additional defined diagnostic bits; not currently used for rejection
0168     else if (mybit == "PresampleADC")
0169       setAllRHMasks(HcalCaloFlagLabels::PresampleADC, mydef);
0170     else if (mybit == "Fraction2TS")
0171       setAllRHMasks(HcalCaloFlagLabels::Fraction2TS,
0172                     mydef);  // should deprecate this at some point; it's been replaced by PresampleADC
0173 
0174     // unknown -------------------
0175     else {
0176       // error: unrecognized flag name
0177       edm::LogWarning("HcalSeverityLevelComputer")
0178           << "HcalSeverityLevelComputer: Error: RecHitFlag >>" << mybit << "<< unknown. Ignoring.";
0179       return false;
0180     }
0181   }
0182   return true;
0183 }
0184 
0185 HcalSeverityLevelComputer::HcalSeverityLevelComputer(const edm::ParameterSet& iConfig) {
0186   // initialize: get the levels and masks from the cfg:
0187   typedef std::vector<edm::ParameterSet> myParameters;
0188   myParameters myLevels = iConfig.getParameter<myParameters>((std::string) "SeverityLevels");
0189 
0190   unsigned int phase_ = iConfig.getParameter<unsigned int>("phase");
0191 
0192   // now run through the parameter set vector:
0193   for (myParameters::iterator itLevels = myLevels.begin(); itLevels != myLevels.end(); ++itLevels) {
0194     // create the basic object
0195     HcalSeverityDefinition mydef;
0196 
0197     // get the level:
0198     mydef.sevLevel = itLevels->getParameter<int>("Level");
0199 
0200     // get the RecHitFlags:
0201     std::vector<std::string> myRecHitFlags = itLevels->getParameter<std::vector<std::string> >("RecHitFlags");
0202 
0203     // get channel statuses:
0204     std::vector<std::string> myChStatuses = itLevels->getParameter<std::vector<std::string> >("ChannelStatus");
0205 
0206     // now translate the RecHitFlags and the ChannelStatuses into a mask each:
0207     // create counters for invalid flags to be able to catch cases where a definition consists only of invalid bit names:
0208     unsigned int bvalid = 0;
0209     unsigned int bnonempty = 0;
0210     // channel status:
0211     for (unsigned k = 0; k < myChStatuses.size(); k++) {
0212       if (myChStatuses[k].empty())
0213         break;  // empty string
0214       bnonempty++;
0215       bvalid += getChStBit(mydef, myChStatuses[k]);
0216     }
0217     // RecHitFlag:
0218     //      HBHEStatusFlag, HOStatusFlag, HFStatusFlag, ZDCStatusFlag, CalibrationFlag
0219     for (unsigned k = 0; k < myRecHitFlags.size(); k++) {
0220       if (myRecHitFlags[k].empty())
0221         break;  // empty string
0222       bnonempty++;
0223       bvalid += getRecHitFlag(mydef, myRecHitFlags[k], phase_);
0224     }
0225 
0226     //      std::cout << "Made Severity Level:" << std::endl;
0227     //      std::cout << mydef << std::endl;
0228 
0229     // case where definition is made entirely out of invalid flags but not empty strings
0230     if ((!bvalid) && (bnonempty)) {
0231       edm::LogWarning("HcalSeverityLevelComputer") << "Warning: level " << mydef.sevLevel
0232                                                    << " consists of invalid definitions only: "
0233                                                    //       << myRecHitFlags << "; " << myChStatuses
0234                                                    << " Ignoring definition.";
0235       continue;
0236     }
0237 
0238     // finally, append the masks to the mask vectors, sorting them according to level
0239     std::vector<HcalSeverityDefinition>::iterator it = SevDef.begin();
0240 
0241     do {
0242       if (it == SevDef.end()) {
0243         SevDef.push_back(mydef);
0244         break;
0245       }
0246 
0247       if (it->sevLevel == mydef.sevLevel) {
0248         edm::LogWarning("HcalSeverityLevelComputer") << "HcalSeverityLevelComputer: Warning: level " << mydef.sevLevel
0249                                                      << " already defined. Ignoring new definition.";
0250         break;
0251       }
0252 
0253       if (it->sevLevel < mydef.sevLevel)
0254         if (((it + 1) == SevDef.end()) || ((it + 1)->sevLevel > mydef.sevLevel)) {
0255           SevDef.insert(it + 1, mydef);
0256           break;
0257         }
0258 
0259       it++;
0260     } while (it != SevDef.end());
0261 
0262   }  //for (myParameters::iterator itLevels=myLevels.begin(); itLevels != myLevels.end(); ++itLevels)
0263 
0264   edm::LogInfo("HcalSeverityLevelComputer") << "HcalSeverityLevelComputer - Summary of Severity Levels:" << std::endl;
0265   for (std::vector<HcalSeverityDefinition>::iterator it = SevDef.begin(); it != SevDef.end(); it++) {
0266     // debug: write the levels definitions on screen:
0267     edm::LogInfo("HcalSeverityLevelComputer") << (*it) << std::endl;
0268   }
0269 
0270   //
0271   // Now make the definition for recoveredRecHit
0272   //
0273   std::vector<std::string> myRecovered = iConfig.getParameter<std::vector<std::string> >("RecoveredRecHitBits");
0274   RecoveredRecHit_ = new HcalSeverityDefinition();
0275   for (unsigned k = 0; k < myRecovered.size(); k++) {
0276     if (myRecovered[k].empty())
0277       break;
0278     getRecHitFlag((*RecoveredRecHit_), myRecovered[k], phase_);
0279   }
0280 
0281   //
0282   // Now make the definition for dropChannel
0283   //
0284   std::vector<std::string> myDrop = iConfig.getParameter<std::vector<std::string> >("DropChannelStatusBits");
0285   DropChannel_ = new HcalSeverityDefinition();
0286   for (unsigned k = 0; k < myDrop.size(); k++) {
0287     if (myDrop[k].empty())
0288       break;
0289     getChStBit((*DropChannel_), myDrop[k]);
0290   }
0291 
0292   edm::LogInfo("HcalSeverityLevelComputer") << "HcalSeverityLevelComputer - Summary for Recovered RecHit bits: \n"
0293                                             << (*RecoveredRecHit_) << std::endl
0294                                             << "HcalSeverityLevelComputer - Summary for Drop the Channel bits: \n"
0295                                             << (*DropChannel_) << std::endl;
0296 
0297 }  // HcalSeverityLevelComputer::HcalSeverityLevelComputer
0298 
0299 HcalSeverityLevelComputer::~HcalSeverityLevelComputer() {
0300   delete DropChannel_;
0301   delete RecoveredRecHit_;
0302 }
0303 
0304 int HcalSeverityLevelComputer::getSeverityLevel(const DetId& myid,
0305                                                 const uint32_t& myflag,
0306                                                 const uint32_t& mystatus) const {
0307   uint32_t myRecHitMask;
0308   HcalGenericDetId myId(myid);
0309   HcalGenericDetId::HcalGenericSubdetector mysubdet = myId.genericSubdet();
0310 
0311   // for (unsigned i=(SevDef.size()-1); i >= 0; i--) // Wrong
0312   // Since i is unsigned, i >= 0 is always true,
0313   // and the loop termination condition is never reached.
0314   // We offset the loop index by one to fix this.
0315   for (size_t j = (SevDef.size()); j > 0; j--) {
0316     size_t i = j - 1;
0317     switch (mysubdet) {
0318       case HcalGenericDetId::HcalGenBarrel:
0319       case HcalGenericDetId::HcalGenEndcap:
0320         myRecHitMask = SevDef[i].HBHEFlagMask;
0321         break;
0322       case HcalGenericDetId::HcalGenOuter:
0323         myRecHitMask = SevDef[i].HOFlagMask;
0324         break;
0325       case HcalGenericDetId::HcalGenForward:
0326         myRecHitMask = SevDef[i].HFFlagMask;
0327         break;
0328       case HcalGenericDetId::HcalGenZDC:
0329         myRecHitMask = SevDef[i].ZDCFlagMask;
0330         break;
0331       case HcalGenericDetId::HcalGenCalibration:
0332         myRecHitMask = SevDef[i].CalibFlagMask;
0333         break;
0334       default:
0335         myRecHitMask = 0;
0336     }
0337 
0338     // for debugging:
0339     //      std::cout << std::hex << " SLD: RHMask 0x" << myRecHitMask
0340     //      << " chstmask 0x" << SevDef[i].chStatusMask
0341     //      << " RHmask & myflag 0x" << (myRecHitMask&myflag)
0342     //      << " chstmask & mystatus 0x" << (SevDef[i].chStatusMask&mystatus)
0343     //      << std::dec << " level = " << SevDef[i].sevLevel << std::endl;
0344 
0345     // true if:
0346     // rechitmask empty and chstatusmask empty
0347     // rechitmask empty and chstatusmask&mychstat true
0348     // chstatusmask empty and rechitmask&myflag true
0349     // rechitmask&myflag true OR chstatusmask&mychstat true
0350 
0351     //      if ( ( ( (!myRecHitMask) || (myRecHitMask & myflag) ) &&
0352     if ((((!SevDef[i].HBHEFlagMask && !SevDef[i].HOFlagMask && !SevDef[i].HFFlagMask && !SevDef[i].ZDCFlagMask &&
0353            !SevDef[i].CalibFlagMask) ||
0354           (myRecHitMask & myflag)) &&
0355          ((!SevDef[i].chStatusMask) || (SevDef[i].chStatusMask & mystatus))) ||
0356         ((myRecHitMask & myflag) || (SevDef[i].chStatusMask & mystatus)))
0357       return SevDef[i].sevLevel;
0358   }
0359 
0360   return -100;  // default value, if no definition applies
0361 }
0362 
0363 bool HcalSeverityLevelComputer::recoveredRecHit(const DetId& myid, const uint32_t& myflag) const {
0364   uint32_t myRecHitMask;
0365   HcalGenericDetId myId(myid);
0366   HcalGenericDetId::HcalGenericSubdetector mysubdet = myId.genericSubdet();
0367 
0368   switch (mysubdet) {
0369     case HcalGenericDetId::HcalGenBarrel:
0370     case HcalGenericDetId::HcalGenEndcap:
0371       myRecHitMask = RecoveredRecHit_->HBHEFlagMask;
0372       break;
0373     case HcalGenericDetId::HcalGenOuter:
0374       myRecHitMask = RecoveredRecHit_->HOFlagMask;
0375       break;
0376     case HcalGenericDetId::HcalGenForward:
0377       myRecHitMask = RecoveredRecHit_->HFFlagMask;
0378       break;
0379     case HcalGenericDetId::HcalGenZDC:
0380       myRecHitMask = RecoveredRecHit_->ZDCFlagMask;
0381       break;
0382     case HcalGenericDetId::HcalGenCalibration:
0383       myRecHitMask = RecoveredRecHit_->CalibFlagMask;
0384       break;
0385     default:
0386       myRecHitMask = 0;
0387   }
0388 
0389   if (myRecHitMask & myflag)
0390     return true;
0391 
0392   return false;
0393 }
0394 
0395 bool HcalSeverityLevelComputer::dropChannel(const uint32_t& mystatus) const {
0396   if (DropChannel_->chStatusMask & mystatus)
0397     return true;
0398 
0399   return false;
0400 }
0401 
0402 void HcalSeverityLevelComputer::setBit(const unsigned bitnumber, uint32_t& where) {
0403   uint32_t statadd = 0x1 << (bitnumber);
0404   where = where | statadd;
0405 }
0406 
0407 void HcalSeverityLevelComputer::setAllRHMasks(const unsigned bitnumber, HcalSeverityDefinition& mydef) {
0408   setBit(bitnumber, mydef.HBHEFlagMask);
0409   setBit(bitnumber, mydef.HOFlagMask);
0410   setBit(bitnumber, mydef.HFFlagMask);
0411   setBit(bitnumber, mydef.ZDCFlagMask);
0412   setBit(bitnumber, mydef.CalibFlagMask);
0413 }
0414 
0415 std::ostream& operator<<(std::ostream& s, const HcalSeverityLevelComputer::HcalSeverityDefinition& def) {
0416   s << "Hcal Severity Level Definition, Level = " << def.sevLevel << std::endl;
0417   s << std::hex << std::showbase;
0418   s << "  channel status mask = " << def.chStatusMask << std::endl;
0419   s << "  HBHEFlagMask        = " << def.HBHEFlagMask << std::endl;
0420   s << "  HOFlagMask          = " << def.HOFlagMask << std::endl;
0421   s << "  HFFlagMask          = " << def.HFFlagMask << std::endl;
0422   s << "  ZDCFlagMask         = " << def.ZDCFlagMask << std::endl;
0423   s << "  CalibFlagMask       = " << def.CalibFlagMask << std::dec << std::noshowbase << std::endl;
0424   return s;
0425 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!