Reference Manual

Go to the documentation of this file.
00001 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSeverityLevelComputer.h"
00002 #include "CondFormats/HcalObjects/interface/HcalChannelStatus.h"
00003 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalCaloFlagLabels.h"
00004 #include "DataFormats/HcalDetId/interface/HcalGenericDetId.h"
00005 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00006 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00007 
00008 
00009 bool HcalSeverityLevelComputer::getChStBit(HcalSeverityDefinition& mydef, 
00010                                            const std::string& mybit)
00011 {
00012   if (mybit == "HcalCellOff") setBit(HcalChannelStatus::HcalCellOff, mydef.chStatusMask);
00013   else if (mybit == "HcalCellMask") setBit(HcalChannelStatus::HcalCellMask, mydef.chStatusMask);
00014   else if (mybit == "HcalCellDead") setBit(HcalChannelStatus::HcalCellDead, mydef.chStatusMask);
00015   else if (mybit == "HcalCellHot") setBit(HcalChannelStatus::HcalCellHot, mydef.chStatusMask);
00016   else if (mybit == "HcalCellStabErr") setBit(HcalChannelStatus::HcalCellStabErr, mydef.chStatusMask);
00017   else if (mybit == "HcalCellTimErr") setBit(HcalChannelStatus::HcalCellTimErr, mydef.chStatusMask);
00018   else if (mybit == "HcalCellTrigMask") setBit(HcalChannelStatus::HcalCellTrigMask, mydef.chStatusMask);
00019   else if (mybit == "HcalCellCaloTowerMask") setBit(HcalChannelStatus::HcalCellCaloTowerMask, mydef.chStatusMask);
00020   else if (mybit == "HcalCellCaloTowerProb") setBit(HcalChannelStatus::HcalCellCaloTowerProb, mydef.chStatusMask);
00021   else 
00022     { // error: unrecognized channel status name
00023       edm::LogWarning  ("HcalSeverityLevelComputer") 
00024         << "HcalSeverityLevelComputer: Error: ChannelStatusFlag >>" << mybit 
00025         << "<< unknown. Ignoring.";
00026       return false;
00027     }
00028   return true;
00029 }
00030 
00031 bool HcalSeverityLevelComputer::getRecHitFlag(HcalSeverityDefinition& mydef, 
00032                                               const std::string& mybit)
00033 {
00034   // HB, HE ++++++++++++++++++++
00035   if (mybit == "HBHEHpdHitMultiplicity") setBit(HcalCaloFlagLabels::HBHEHpdHitMultiplicity, mydef.HBHEFlagMask);
00036   else if (mybit == "HBHEPulseShape")    setBit(HcalCaloFlagLabels::HBHEPulseShape, mydef.HBHEFlagMask);
00037   else if (mybit == "HSCP_R1R2")         setBit(HcalCaloFlagLabels::HSCP_R1R2, mydef.HBHEFlagMask);
00038   else if (mybit == "HSCP_FracLeader")   setBit(HcalCaloFlagLabels::HSCP_FracLeader, mydef.HBHEFlagMask);
00039   else if (mybit == "HSCP_OuterEnergy")  setBit(HcalCaloFlagLabels::HSCP_OuterEnergy, mydef.HBHEFlagMask);
00040   else if (mybit == "HSCP_ExpFit")       setBit(HcalCaloFlagLabels::HSCP_ExpFit, mydef.HBHEFlagMask);
00041   else if (mybit == "HBHEFlatNoise")     setBit(HcalCaloFlagLabels::HBHEFlatNoise, mydef.HBHEFlagMask);
00042   else if (mybit == "HBHESpikeNoise")    setBit(HcalCaloFlagLabels::HBHESpikeNoise, mydef.HBHEFlagMask);
00043   else if (mybit == "HBHETriangleNoise") setBit(HcalCaloFlagLabels::HBHETriangleNoise, mydef.HBHEFlagMask);
00044 
00045   // These are multi-bit counters; we may have to revisit how to set them in the SLComputer in the future
00046   else if (mybit=="HBHETimingTrustBits") setBit(HcalCaloFlagLabels::HBHETimingTrustBits, mydef.HBHEFlagMask );
00047   else if (mybit=="HBHETimingShapedCutsBits") setBit(HcalCaloFlagLabels::HBHETimingShapedCutsBits, mydef.HBHEFlagMask);
00048   else if (mybit=="HBHEIsolatedNoise")   setBit(HcalCaloFlagLabels::HBHEIsolatedNoise, mydef.HBHEFlagMask );
00049 
00050   // HO ++++++++++++++++++++
00051   else if (mybit == "HOBit")    setBit(HcalCaloFlagLabels::HOBit, mydef.HOFlagMask);
00052   
00053   // HF ++++++++++++++++++++
00054   else if (mybit == "HFLongShort")    setBit(HcalCaloFlagLabels::HFLongShort, mydef.HFFlagMask);
00055   else if (mybit == "HFDigiTime")    setBit(HcalCaloFlagLabels::HFDigiTime, mydef.HFFlagMask);
00056   else if (mybit == "HFInTimeWindow") setBit(HcalCaloFlagLabels::HFInTimeWindow, mydef.HFFlagMask);
00057   else if (mybit == "HFS8S1Ratio") setBit(HcalCaloFlagLabels::HFS8S1Ratio, mydef.HFFlagMask);
00058   else if (mybit == "HFPET")  setBit(HcalCaloFlagLabels::HFPET, mydef.HFFlagMask);
00059 
00060   // ZDC ++++++++++++++++++++
00061   else if (mybit == "ZDCBit")     setBit(HcalCaloFlagLabels::ZDCBit, mydef.ZDCFlagMask);
00062   
00063   // Calib ++++++++++++++++++++
00064   else if (mybit == "CalibrationBit")     setBit(HcalCaloFlagLabels::CalibrationBit, mydef.CalibFlagMask);
00065 
00066   // Common subdetector bits ++++++++++++++++++++++
00067   else if (mybit == "TimingSubtractedBit")  setAllRHMasks(HcalCaloFlagLabels::TimingSubtractedBit, mydef);
00068   else if (mybit == "TimingAddedBit")       setAllRHMasks(HcalCaloFlagLabels::TimingAddedBit,      mydef);
00069   else if (mybit == "TimingErrorBit")       setAllRHMasks(HcalCaloFlagLabels::TimingErrorBit,      mydef);
00070   else if (mybit == "ADCSaturationBit")     setAllRHMasks(HcalCaloFlagLabels::ADCSaturationBit,    mydef);
00071   else if (mybit == "UserDefinedBit0")      setAllRHMasks(HcalCaloFlagLabels::UserDefinedBit0,     mydef);
00072   else if (mybit == "UserDefinedBit1")      setAllRHMasks(HcalCaloFlagLabels::UserDefinedBit1,     mydef);
00073   else if (mybit == "UserDefinedBit2")      setAllRHMasks(HcalCaloFlagLabels::UserDefinedBit2,     mydef);
00074   // unknown -------------------
00075   else
00076     {
00077       // error: unrecognized flag name
00078       edm::LogWarning  ("HcalSeverityLevelComputer") 
00079         << "HcalSeverityLevelComputer: Error: RecHitFlag >>" << mybit 
00080         << "<< unknown. Ignoring.";
00081       return false;
00082     }
00083   return true;
00084 }
00085 
00086 HcalSeverityLevelComputer::HcalSeverityLevelComputer( const edm::ParameterSet& iConfig)
00087 {
00088   // initialize: get the levels and masks from the cfg:
00089   typedef std::vector< edm::ParameterSet > myParameters;
00090   myParameters myLevels = iConfig.getParameter<myParameters>((std::string)"SeverityLevels");
00091 
00092   // now run through the parameter set vector:
00093   for ( myParameters::iterator itLevels = myLevels.begin(); itLevels != myLevels.end(); ++itLevels)
00094     {
00095       // create the basic object
00096       HcalSeverityDefinition mydef;
00097 
00098       // get the level:
00099       mydef.sevLevel = itLevels->getParameter<int>("Level");
00100 
00101       // get the RecHitFlags:
00102       std::vector<std::string> myRecHitFlags = 
00103         itLevels->getParameter<std::vector <std::string> > ("RecHitFlags");
00104 
00105       // get channel statuses:
00106       std::vector<std::string> myChStatuses = 
00107         itLevels->getParameter<std::vector <std::string> > ("ChannelStatus");
00108 
00109       // now translate the RecHitFlags and the ChannelStatuses into a mask each:
00110       // create counters for invalid flags to be able to catch cases where a definition consists only of invalid bit names:
00111       unsigned int bvalid = 0;
00112       unsigned int bnonempty = 0;      
00113       // channel status:
00114       for (unsigned k=0; k < myChStatuses.size(); k++)
00115         {
00116           if (myChStatuses[k].empty()) break; // empty string
00117           bnonempty++;
00118           bvalid+=getChStBit(mydef, myChStatuses[k]);
00119         }
00120       // RecHitFlag:
00121       //      HBHEStatusFlag, HOStatusFlag, HFStatusFlag, ZDCStatusFlag, CalibrationFlag
00122       for (unsigned k=0; k < myRecHitFlags.size(); k++)
00123         {
00124           if (myRecHitFlags[k].empty()) break; // empty string
00125           bnonempty++;
00126           bvalid+=getRecHitFlag(mydef, myRecHitFlags[k]);
00127         }
00128 
00129       //      std::cout << "Made Severity Level:" << std::endl;
00130       //      std::cout << mydef << std::endl;
00131 
00132       // case where definition is made entirely out of invalid flags but not empty strings
00133       if ((!bvalid) && (bnonempty)) 
00134         {
00135           edm::LogWarning ("HcalSeverityLevelComputer") 
00136             << "Warning: level " << mydef.sevLevel
00137             << " consists of invalid definitions only: "
00138             //      << myRecHitFlags << "; " << myChStatuses
00139             << " Ignoring definition.";
00140           continue;
00141         }
00142 
00143       // finally, append the masks to the mask vectors, sorting them according to level   
00144       std::vector<HcalSeverityDefinition>::iterator it = SevDef.begin();
00145 
00146       do
00147         {
00148           if (it == SevDef.end()) { SevDef.push_back(mydef); break; }
00149           
00150           if (it->sevLevel == mydef.sevLevel)
00151             {
00152               edm::LogWarning  ("HcalSeverityLevelComputer") 
00153                 << "HcalSeverityLevelComputer: Warning: level " << mydef.sevLevel 
00154                 << " already defined. Ignoring new definition.";
00155               break;
00156             }
00157 
00158           if (it->sevLevel < mydef.sevLevel) 
00159             if (( (it+1) == SevDef.end()) || ( (it+1)->sevLevel > mydef.sevLevel ))
00160               {
00161                 SevDef.insert(it+1, mydef);
00162                 break;
00163               }
00164 
00165           it++;
00166         }
00167       while(it != SevDef.end());
00168 
00169     } //for (myParameters::iterator itLevels=myLevels.begin(); itLevels != myLevels.end(); ++itLevels)
00170 
00171   edm::LogInfo("HcalSeverityLevelComputer") 
00172     << "HcalSeverityLevelComputer - Summary of Severity Levels:" << std::endl;
00173   for (std::vector<HcalSeverityDefinition>::iterator it = SevDef.begin(); it !=SevDef.end(); it++)
00174     {
00175       // debug: write the levels definitions on screen:
00176       edm::LogInfo("HcalSeverityLevelComputer") 
00177         << (*it) << std::endl;
00178     }
00179 
00180   //
00181   // Now make the definition for recoveredRecHit
00182   //
00183   std::vector<std::string> myRecovered = 
00184         iConfig.getParameter<std::vector <std::string> > ("RecoveredRecHitBits");
00185   RecoveredRecHit_ = new HcalSeverityDefinition();
00186   for (unsigned k=0; k < myRecovered.size(); k++)
00187     {
00188       if (myRecovered[k].empty()) break;
00189       getRecHitFlag( (*RecoveredRecHit_), myRecovered[k]);
00190     }
00191 
00192   //
00193   // Now make the definition for dropChannel
00194   //
00195   std::vector<std::string> myDrop = 
00196         iConfig.getParameter<std::vector <std::string> > ("DropChannelStatusBits");
00197   DropChannel_ = new HcalSeverityDefinition();
00198   for (unsigned k=0; k < myDrop.size(); k++)
00199     {
00200       if (myDrop[k].empty()) break;
00201       getChStBit( (*DropChannel_), myDrop[k]);
00202     }
00203 
00204   edm::LogInfo("HcalSeverityLevelComputer")
00205     << "HcalSeverityLevelComputer - Summary for Recovered RecHit bits: \n"
00206     << (*RecoveredRecHit_) << std::endl
00207     << "HcalSeverityLevelComputer - Summary for Drop the Channel bits: \n"
00208     << (*DropChannel_) << std::endl;
00209 
00210 
00211 } // HcalSeverityLevelComputer::HcalSeverityLevelComputer
00212 
00213 
00214 HcalSeverityLevelComputer::~HcalSeverityLevelComputer() {}
00215 
00216   
00217 int HcalSeverityLevelComputer::getSeverityLevel(const DetId& myid, const uint32_t& myflag, 
00218                                                 const uint32_t& mystatus) const
00219 {
00220   uint32_t myRecHitMask;
00221   HcalGenericDetId myId(myid);
00222   HcalGenericDetId::HcalGenericSubdetector mysubdet = myId.genericSubdet();
00223 
00224   // for (unsigned i=(SevDef.size()-1); i >= 0; i--) // Wrong
00225   // Since i is unsigned, i >= 0 is always true,
00226   // and the loop termination condition is never reached.
00227   // We offset the loop index by one to fix this.
00228   for (size_t j=(SevDef.size()); j > 0; j--)
00229     {
00230       size_t i = j - 1;
00231       switch (mysubdet)
00232         {
00233         case HcalGenericDetId::HcalGenBarrel : case HcalGenericDetId::HcalGenEndcap : 
00234           myRecHitMask = SevDef[i].HBHEFlagMask; break;
00235         case HcalGenericDetId::HcalGenOuter : myRecHitMask = SevDef[i].HOFlagMask; break;
00236         case HcalGenericDetId::HcalGenForward : myRecHitMask = SevDef[i].HFFlagMask; break;
00237         case HcalGenericDetId::HcalGenZDC : myRecHitMask = SevDef[i].ZDCFlagMask; break;
00238         case HcalGenericDetId::HcalGenCalibration : myRecHitMask = SevDef[i].CalibFlagMask; break;
00239         default: myRecHitMask = 0;
00240         }
00241  
00242       // for debugging:     
00243 //      std::cout << std::hex << " SLD: RHMask 0x" << myRecHitMask
00244 //              << " chstmask 0x" << SevDef[i].chStatusMask
00245 //              << " RHmask & myflag 0x" << (myRecHitMask&myflag)
00246 //              << " chstmask & mystatus 0x" << (SevDef[i].chStatusMask&mystatus)
00247 //              << std::dec << " level = " << SevDef[i].sevLevel << std::endl;
00248       
00249       // true if:
00250       // rechitmask empty and chstatusmask empty
00251       // rechitmask empty and chstatusmask&mychstat true
00252       // chstatusmask empty and rechitmask&myflag true
00253       // rechitmask&myflag true OR chstatusmask&mychstat true
00254 
00255 
00256       //      if ( ( ( (!myRecHitMask) || (myRecHitMask & myflag) ) &&
00257       if ( ( ( ( !SevDef[i].HBHEFlagMask 
00258                  && !SevDef[i].HOFlagMask 
00259                  && !SevDef[i].HFFlagMask 
00260                  && !SevDef[i].ZDCFlagMask 
00261                  && !SevDef[i].CalibFlagMask ) 
00262                || (myRecHitMask & myflag) ) 
00263              && ( (!SevDef[i].chStatusMask) || (SevDef[i].chStatusMask & mystatus) ) )
00264            || ( (myRecHitMask & myflag) || (SevDef[i].chStatusMask & mystatus) ) )
00265         return SevDef[i].sevLevel;
00266 
00267     }
00268 
00269   return -100;  // default value, if no definition applies
00270 }
00271   
00272 bool HcalSeverityLevelComputer::recoveredRecHit(const DetId& myid, const uint32_t& myflag) const
00273 {
00274   uint32_t myRecHitMask;
00275   HcalGenericDetId myId(myid);
00276   HcalGenericDetId::HcalGenericSubdetector mysubdet = myId.genericSubdet();
00277 
00278   switch (mysubdet)
00279     {
00280     case HcalGenericDetId::HcalGenBarrel : case HcalGenericDetId::HcalGenEndcap : 
00281       myRecHitMask = RecoveredRecHit_->HBHEFlagMask; break;
00282     case HcalGenericDetId::HcalGenOuter : myRecHitMask = RecoveredRecHit_->HOFlagMask; break;
00283     case HcalGenericDetId::HcalGenForward : myRecHitMask = RecoveredRecHit_->HFFlagMask; break;
00284     case HcalGenericDetId::HcalGenZDC : myRecHitMask = RecoveredRecHit_->ZDCFlagMask; break;
00285     case HcalGenericDetId::HcalGenCalibration : myRecHitMask = RecoveredRecHit_->CalibFlagMask; break;
00286     default: myRecHitMask = 0;
00287     }
00288 
00289   if (myRecHitMask & myflag) 
00290     return true;
00291 
00292   return false;
00293 }
00294 
00295 bool HcalSeverityLevelComputer::dropChannel(const uint32_t& mystatus) const
00296 {
00297   if (DropChannel_->chStatusMask & mystatus)
00298     return true;
00299 
00300   return false;
00301 }
00302 
00303 void HcalSeverityLevelComputer::setBit(const unsigned bitnumber, uint32_t& where) 
00304 {
00305   uint32_t statadd = 0x1<<(bitnumber);
00306   where = where|statadd;
00307 }
00308 
00309 void HcalSeverityLevelComputer::setAllRHMasks(const unsigned bitnumber, HcalSeverityDefinition& mydef)
00310 {
00311   setBit(bitnumber, mydef.HBHEFlagMask);
00312   setBit(bitnumber, mydef.HOFlagMask);
00313   setBit(bitnumber, mydef.HFFlagMask);
00314   setBit(bitnumber, mydef.ZDCFlagMask);
00315   setBit(bitnumber, mydef.CalibFlagMask);
00316 }
00317 
00318 std::ostream& operator<<(std::ostream& s, const HcalSeverityLevelComputer::HcalSeverityDefinition& def)
00319 {
00320   s << "Hcal Severity Level Definition, Level = " << def.sevLevel << std::endl;
00321   s << std::hex << std::showbase;
00322   s << "  channel status mask = " <<  def.chStatusMask << std::endl;
00323   s << "  HBHEFlagMask        = " <<  def.HBHEFlagMask << std::endl;
00324   s << "  HOFlagMask          = " <<  def.HOFlagMask << std::endl;
00325   s << "  HFFlagMask          = " <<  def.HFFlagMask << std::endl;
00326   s << "  ZDCFlagMask         = " <<  def.ZDCFlagMask << std::endl;
00327   s << "  CalibFlagMask       = " <<  def.CalibFlagMask << std::dec << std::noshowbase << std::endl;
00328   return s;
00329 }
/data/refman/pasoursint/CMSSW_4_1_8_patch12/src/RecoLocalCalo/HcalRecAlgos/src/HcalSeverityLevelComputer.cc
