HcalSeverityLevelComputer.cc

Go to the documentation of this file.

#include "RecoLocalCalo/HcalRecAlgos/interface/HcalSeverityLevelComputer.h"
#include "CondFormats/HcalObjects/interface/HcalChannelStatus.h"
#include "DataFormats/METReco/interface/HcalCaloFlagLabels.h"
#include "DataFormats/METReco/interface/HcalPhase1FlagLabels.h"
#include "DataFormats/HcalDetId/interface/HcalGenericDetId.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

bool HcalSeverityLevelComputer::getChStBit(HcalSeverityDefinition& mydef, const std::string& mybit) {
  if (mybit == "HcalCellOff")
    setBit(HcalChannelStatus::HcalCellOff, mydef.chStatusMask);
  else if (mybit == "HcalCellMask")
    setBit(HcalChannelStatus::HcalCellMask, mydef.chStatusMask);
  else if (mybit == "HcalCellDead")
    setBit(HcalChannelStatus::HcalCellDead, mydef.chStatusMask);
  else if (mybit == "HcalCellHot")
    setBit(HcalChannelStatus::HcalCellHot, mydef.chStatusMask);
  else if (mybit == "HcalCellStabErr")
    setBit(HcalChannelStatus::HcalCellStabErr, mydef.chStatusMask);
  else if (mybit == "HcalCellTimErr")
    setBit(HcalChannelStatus::HcalCellTimErr, mydef.chStatusMask);
  else if (mybit == "HcalCellTrigMask")
    setBit(HcalChannelStatus::HcalCellTrigMask, mydef.chStatusMask);
  else if (mybit == "HcalCellCaloTowerMask")
    setBit(HcalChannelStatus::HcalCellCaloTowerMask, mydef.chStatusMask);
  else if (mybit == "HcalCellCaloTowerProb")
    setBit(HcalChannelStatus::HcalCellCaloTowerProb, mydef.chStatusMask);
  else if (mybit == "HcalCellExcludeFromHBHENoiseSummary")
    setBit(HcalChannelStatus::HcalCellExcludeFromHBHENoiseSummary, mydef.chStatusMask);
  else if (mybit == "HcalCellExcludeFromHBHENoiseSummaryR45")
    setBit(HcalChannelStatus::HcalCellExcludeFromHBHENoiseSummaryR45, mydef.chStatusMask);
  else if (mybit == "HcalBadLaserSignal")
    setBit(HcalChannelStatus::HcalBadLaserSignal, mydef.chStatusMask);
  else {  // error: unrecognized channel status name
    edm::LogWarning("HcalSeverityLevelComputer")
        << "HcalSeverityLevelComputer: Error: ChannelStatusFlag >>" << mybit << "<< unknown. Ignoring.";
    return false;
  }
  return true;
}

bool HcalSeverityLevelComputer::getRecHitFlag(HcalSeverityDefinition& mydef, const std::string& mybit, int phase) {
  if (phase == 1)  // Phase 1 Rechit flags
  {
    // HB, HE ++++++++++++++++++++
    if (mybit == "HBHEHpdHitMultiplicity")
      setBit(HcalPhase1FlagLabels::HBHEHpdHitMultiplicity, mydef.HBHEFlagMask);
    else if (mybit == "HBHEIsolatedNoise")
      setBit(HcalPhase1FlagLabels::HBHEIsolatedNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHEFlatNoise")
      setBit(HcalPhase1FlagLabels::HBHEFlatNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHESpikeNoise")
      setBit(HcalPhase1FlagLabels::HBHESpikeNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHETS4TS5Noise")
      setBit(HcalPhase1FlagLabels::HBHETS4TS5Noise, mydef.HBHEFlagMask);
    else if (mybit == "HBHENegativeNoise")
      setBit(HcalPhase1FlagLabels::HBHENegativeNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHEPulseFitBit")
      setBit(HcalPhase1FlagLabels::HBHEPulseFitBit, mydef.HBHEFlagMask);
    else if (mybit == "HBHEOOTPU")
      setBit(HcalPhase1FlagLabels::HBHEOOTPU, mydef.HBHEFlagMask);

    // HF ++++++++++++++++++++
    else if (mybit == "HFLongShort")
      setBit(HcalPhase1FlagLabels::HFLongShort, mydef.HFFlagMask);
    else if (mybit == "HFS8S1Ratio")
      setBit(HcalPhase1FlagLabels::HFS8S1Ratio, mydef.HFFlagMask);
    else if (mybit == "HFPET")
      setBit(HcalPhase1FlagLabels::HFPET, mydef.HFFlagMask);
    else if (mybit == "HFSignalAsymmetry")
      setBit(HcalPhase1FlagLabels::HFSignalAsymmetry, mydef.HFFlagMask);
    else if (mybit == "HFAnomalousHit")
      setBit(HcalPhase1FlagLabels::HFAnomalousHit, mydef.HFFlagMask);

    // Common subdetector bits ++++++++++++++++++++++
    else if (mybit == "TimingFromTDC")
      setAllRHMasks(HcalPhase1FlagLabels::TimingFromTDC, mydef);
    else if (mybit == "UserDefinedBit0")
      setAllRHMasks(HcalPhase1FlagLabels::UserDefinedBit0, mydef);

    // unknown -------------------
    else {
      // error: unrecognized flag name
      edm::LogWarning("HcalSeverityLevelComputer")
          << "HcalSeverityLevelComputer: Error: RecHitFlag >>" << mybit << "<< unknown. Ignoring.";
      return false;
    }
  } else  // Phase 0 Rechit flags
  {
    // HB, HE ++++++++++++++++++++
    if (mybit == "HBHEHpdHitMultiplicity")
      setBit(HcalCaloFlagLabels::HBHEHpdHitMultiplicity, mydef.HBHEFlagMask);
    else if (mybit == "HBHEPulseShape")
      setBit(HcalCaloFlagLabels::HBHEPulseShape, mydef.HBHEFlagMask);
    else if (mybit == "HSCP_R1R2")
      setBit(HcalCaloFlagLabels::HSCP_R1R2, mydef.HBHEFlagMask);
    else if (mybit == "HSCP_FracLeader")
      setBit(HcalCaloFlagLabels::HSCP_FracLeader, mydef.HBHEFlagMask);
    else if (mybit == "HSCP_OuterEnergy")
      setBit(HcalCaloFlagLabels::HSCP_OuterEnergy, mydef.HBHEFlagMask);
    else if (mybit == "HSCP_ExpFit")
      setBit(HcalCaloFlagLabels::HSCP_ExpFit, mydef.HBHEFlagMask);
    else if (mybit == "HBHEFlatNoise")
      setBit(HcalCaloFlagLabels::HBHEFlatNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHESpikeNoise")
      setBit(HcalCaloFlagLabels::HBHESpikeNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHETriangleNoise")
      setBit(HcalCaloFlagLabels::HBHETriangleNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHETS4TS5Noise")
      setBit(HcalCaloFlagLabels::HBHETS4TS5Noise, mydef.HBHEFlagMask);
    else if (mybit == "HBHENegativeNoise")
      setBit(HcalCaloFlagLabels::HBHENegativeNoise, mydef.HBHEFlagMask);
    else if (mybit == "HBHEPulseFitBit")
      setBit(HcalCaloFlagLabels::HBHEPulseFitBit, mydef.HBHEFlagMask);
    else if (mybit == "HBHEOOTPU")
      setBit(HcalCaloFlagLabels::HBHEOOTPU, mydef.HBHEFlagMask);

    // These are multi-bit counters; we may have to revisit how to set them in the SLComputer in the future
    else if (mybit == "HBHETimingTrustBits")
      setBit(HcalCaloFlagLabels::HBHETimingTrustBits, mydef.HBHEFlagMask);
    else if (mybit == "HBHETimingShapedCutsBits")
      setBit(HcalCaloFlagLabels::HBHETimingShapedCutsBits, mydef.HBHEFlagMask);
    else if (mybit == "HBHEIsolatedNoise")
      setBit(HcalCaloFlagLabels::HBHEIsolatedNoise, mydef.HBHEFlagMask);

    // HO ++++++++++++++++++++
    else if (mybit == "HOBit")
      setBit(HcalCaloFlagLabels::HOBit, mydef.HOFlagMask);

    // HF ++++++++++++++++++++
    else if (mybit == "HFLongShort")
      setBit(HcalCaloFlagLabels::HFLongShort, mydef.HFFlagMask);
    else if (mybit == "HFDigiTime")
      setBit(HcalCaloFlagLabels::HFDigiTime, mydef.HFFlagMask);
    else if (mybit == "HFInTimeWindow")
      setBit(HcalCaloFlagLabels::HFInTimeWindow, mydef.HFFlagMask);
    else if (mybit == "HFS8S1Ratio")
      setBit(HcalCaloFlagLabels::HFS8S1Ratio, mydef.HFFlagMask);
    else if (mybit == "HFPET")
      setBit(HcalCaloFlagLabels::HFPET, mydef.HFFlagMask);
    else if (mybit == "HFTimingTrustBits")
      setBit(HcalCaloFlagLabels::HFTimingTrustBits, mydef.HFFlagMask);  // multi-bit counter

    // ZDC ++++++++++++++++++++
    else if (mybit == "ZDCBit")
      setBit(HcalCaloFlagLabels::ZDCBit, mydef.ZDCFlagMask);

    // Calib ++++++++++++++++++++
    else if (mybit == "CalibrationBit")
      setBit(HcalCaloFlagLabels::CalibrationBit, mydef.CalibFlagMask);

    // Common subdetector bits ++++++++++++++++++++++
    else if (mybit == "TimingSubtractedBit")
      setAllRHMasks(HcalCaloFlagLabels::TimingSubtractedBit, mydef);
    else if (mybit == "TimingAddedBit")
      setAllRHMasks(HcalCaloFlagLabels::TimingAddedBit, mydef);
    else if (mybit == "TimingErrorBit")
      setAllRHMasks(HcalCaloFlagLabels::TimingErrorBit, mydef);
    else if (mybit == "ADCSaturationBit")
      setAllRHMasks(HcalCaloFlagLabels::ADCSaturationBit, mydef);
    else if (mybit == "AddedSimHcalNoise")
      setAllRHMasks(HcalCaloFlagLabels::AddedSimHcalNoise, mydef);

    else if (mybit == "UserDefinedBit0")
      setAllRHMasks(HcalCaloFlagLabels::UserDefinedBit0, mydef);

    // additional defined diagnostic bits; not currently used for rejection
    else if (mybit == "PresampleADC")
      setAllRHMasks(HcalCaloFlagLabels::PresampleADC, mydef);
    else if (mybit == "Fraction2TS")
      setAllRHMasks(HcalCaloFlagLabels::Fraction2TS,
                    mydef);  // should deprecate this at some point; it's been replaced by PresampleADC

    // unknown -------------------
    else {
      // error: unrecognized flag name
      edm::LogWarning("HcalSeverityLevelComputer")
          << "HcalSeverityLevelComputer: Error: RecHitFlag >>" << mybit << "<< unknown. Ignoring.";
      return false;
    }
  }
  return true;
}

HcalSeverityLevelComputer::HcalSeverityLevelComputer(const edm::ParameterSet& iConfig) {
  // initialize: get the levels and masks from the cfg:
  typedef std::vector<edm::ParameterSet> myParameters;
  myParameters myLevels = iConfig.getParameter<myParameters>((std::string) "SeverityLevels");

  unsigned int phase_ = iConfig.getParameter<unsigned int>("phase");

  // now run through the parameter set vector:
  for (myParameters::iterator itLevels = myLevels.begin(); itLevels != myLevels.end(); ++itLevels) {
    // create the basic object
    HcalSeverityDefinition mydef;

    // get the level:
    mydef.sevLevel = itLevels->getParameter<int>("Level");

    // get the RecHitFlags:
    std::vector<std::string> myRecHitFlags = itLevels->getParameter<std::vector<std::string> >("RecHitFlags");

    // get channel statuses:
    std::vector<std::string> myChStatuses = itLevels->getParameter<std::vector<std::string> >("ChannelStatus");

    // now translate the RecHitFlags and the ChannelStatuses into a mask each:
    // create counters for invalid flags to be able to catch cases where a definition consists only of invalid bit names:
    unsigned int bvalid = 0;
    unsigned int bnonempty = 0;
    // channel status:
    for (unsigned k = 0; k < myChStatuses.size(); k++) {
      if (myChStatuses[k].empty())
        break;  // empty string
      bnonempty++;
      bvalid += getChStBit(mydef, myChStatuses[k]);
    }
    // RecHitFlag:
    //      HBHEStatusFlag, HOStatusFlag, HFStatusFlag, ZDCStatusFlag, CalibrationFlag
    for (unsigned k = 0; k < myRecHitFlags.size(); k++) {
      if (myRecHitFlags[k].empty())
        break;  // empty string
      bnonempty++;
      bvalid += getRecHitFlag(mydef, myRecHitFlags[k], phase_);
    }

    //      std::cout << "Made Severity Level:" << std::endl;
    //      std::cout << mydef << std::endl;

    // case where definition is made entirely out of invalid flags but not empty strings
    if ((!bvalid) && (bnonempty)) {
      edm::LogWarning("HcalSeverityLevelComputer") << "Warning: level " << mydef.sevLevel
                                                   << " consists of invalid definitions only: "
                                                   //       << myRecHitFlags << "; " << myChStatuses
                                                   << " Ignoring definition.";
      continue;
    }

    // finally, append the masks to the mask vectors, sorting them according to level
    std::vector<HcalSeverityDefinition>::iterator it = SevDef.begin();

    do {
      if (it == SevDef.end()) {
        SevDef.push_back(mydef);
        break;
      }

      if (it->sevLevel == mydef.sevLevel) {
        edm::LogWarning("HcalSeverityLevelComputer") << "HcalSeverityLevelComputer: Warning: level " << mydef.sevLevel
                                                     << " already defined. Ignoring new definition.";
        break;
      }

      if (it->sevLevel < mydef.sevLevel)
        if (((it + 1) == SevDef.end()) || ((it + 1)->sevLevel > mydef.sevLevel)) {
          SevDef.insert(it + 1, mydef);
          break;
        }

      it++;
    } while (it != SevDef.end());

  }  //for (myParameters::iterator itLevels=myLevels.begin(); itLevels != myLevels.end(); ++itLevels)

  edm::LogInfo("HcalSeverityLevelComputer") << "HcalSeverityLevelComputer - Summary of Severity Levels:" << std::endl;
  for (std::vector<HcalSeverityDefinition>::iterator it = SevDef.begin(); it != SevDef.end(); it++) {
    // debug: write the levels definitions on screen:
    edm::LogInfo("HcalSeverityLevelComputer") << (*it) << std::endl;
  }

  //
  // Now make the definition for recoveredRecHit
  //
  std::vector<std::string> myRecovered = iConfig.getParameter<std::vector<std::string> >("RecoveredRecHitBits");
  RecoveredRecHit_ = new HcalSeverityDefinition();
  for (unsigned k = 0; k < myRecovered.size(); k++) {
    if (myRecovered[k].empty())
      break;
    getRecHitFlag((*RecoveredRecHit_), myRecovered[k], phase_);
  }

  //
  // Now make the definition for dropChannel
  //
  std::vector<std::string> myDrop = iConfig.getParameter<std::vector<std::string> >("DropChannelStatusBits");
  DropChannel_ = new HcalSeverityDefinition();
  for (unsigned k = 0; k < myDrop.size(); k++) {
    if (myDrop[k].empty())
      break;
    getChStBit((*DropChannel_), myDrop[k]);
  }

  edm::LogInfo("HcalSeverityLevelComputer") << "HcalSeverityLevelComputer - Summary for Recovered RecHit bits: \n"
                                            << (*RecoveredRecHit_) << std::endl
                                            << "HcalSeverityLevelComputer - Summary for Drop the Channel bits: \n"
                                            << (*DropChannel_) << std::endl;

}  // HcalSeverityLevelComputer::HcalSeverityLevelComputer

HcalSeverityLevelComputer::~HcalSeverityLevelComputer() {
  delete DropChannel_;
  delete RecoveredRecHit_;
}

int HcalSeverityLevelComputer::getSeverityLevel(const DetId& myid,
                                                const uint32_t& myflag,
                                                const uint32_t& mystatus) const {
  uint32_t myRecHitMask;
  HcalGenericDetId myId(myid);
  HcalGenericDetId::HcalGenericSubdetector mysubdet = myId.genericSubdet();

  // for (unsigned i=(SevDef.size()-1); i >= 0; i--) // Wrong
  // Since i is unsigned, i >= 0 is always true,
  // and the loop termination condition is never reached.
  // We offset the loop index by one to fix this.
  for (size_t j = (SevDef.size()); j > 0; j--) {
    size_t i = j - 1;
    switch (mysubdet) {
      case HcalGenericDetId::HcalGenBarrel:
      case HcalGenericDetId::HcalGenEndcap:
        myRecHitMask = SevDef[i].HBHEFlagMask;
        break;
      case HcalGenericDetId::HcalGenOuter:
        myRecHitMask = SevDef[i].HOFlagMask;
        break;
      case HcalGenericDetId::HcalGenForward:
        myRecHitMask = SevDef[i].HFFlagMask;
        break;
      case HcalGenericDetId::HcalGenZDC:
        myRecHitMask = SevDef[i].ZDCFlagMask;
        break;
      case HcalGenericDetId::HcalGenCalibration:
        myRecHitMask = SevDef[i].CalibFlagMask;
        break;
      default:
        myRecHitMask = 0;
    }

    // for debugging:
    //      std::cout << std::hex << " SLD: RHMask 0x" << myRecHitMask
    //      << " chstmask 0x" << SevDef[i].chStatusMask
    //      << " RHmask & myflag 0x" << (myRecHitMask&myflag)
    //      << " chstmask & mystatus 0x" << (SevDef[i].chStatusMask&mystatus)
    //      << std::dec << " level = " << SevDef[i].sevLevel << std::endl;

    // true if:
    // rechitmask empty and chstatusmask empty
    // rechitmask empty and chstatusmask&mychstat true
    // chstatusmask empty and rechitmask&myflag true
    // rechitmask&myflag true OR chstatusmask&mychstat true

    //      if ( ( ( (!myRecHitMask) || (myRecHitMask & myflag) ) &&
    if ((((!SevDef[i].HBHEFlagMask && !SevDef[i].HOFlagMask && !SevDef[i].HFFlagMask && !SevDef[i].ZDCFlagMask &&
           !SevDef[i].CalibFlagMask) ||
          (myRecHitMask & myflag)) &&
         ((!SevDef[i].chStatusMask) || (SevDef[i].chStatusMask & mystatus))) ||
        ((myRecHitMask & myflag) || (SevDef[i].chStatusMask & mystatus)))
      return SevDef[i].sevLevel;
  }

  return -100;  // default value, if no definition applies
}

bool HcalSeverityLevelComputer::recoveredRecHit(const DetId& myid, const uint32_t& myflag) const {
  uint32_t myRecHitMask;
  HcalGenericDetId myId(myid);
  HcalGenericDetId::HcalGenericSubdetector mysubdet = myId.genericSubdet();

  switch (mysubdet) {
    case HcalGenericDetId::HcalGenBarrel:
    case HcalGenericDetId::HcalGenEndcap:
      myRecHitMask = RecoveredRecHit_->HBHEFlagMask;
      break;
    case HcalGenericDetId::HcalGenOuter:
      myRecHitMask = RecoveredRecHit_->HOFlagMask;
      break;
    case HcalGenericDetId::HcalGenForward:
      myRecHitMask = RecoveredRecHit_->HFFlagMask;
      break;
    case HcalGenericDetId::HcalGenZDC:
      myRecHitMask = RecoveredRecHit_->ZDCFlagMask;
      break;
    case HcalGenericDetId::HcalGenCalibration:
      myRecHitMask = RecoveredRecHit_->CalibFlagMask;
      break;
    default:
      myRecHitMask = 0;
  }

  if (myRecHitMask & myflag)
    return true;

  return false;
}

bool HcalSeverityLevelComputer::dropChannel(const uint32_t& mystatus) const {
  if (DropChannel_->chStatusMask & mystatus)
    return true;

  return false;
}

void HcalSeverityLevelComputer::setBit(const unsigned bitnumber, uint32_t& where) {
  uint32_t statadd = 0x1 << (bitnumber);
  where = where | statadd;
}

void HcalSeverityLevelComputer::setAllRHMasks(const unsigned bitnumber, HcalSeverityDefinition& mydef) {
  setBit(bitnumber, mydef.HBHEFlagMask);
  setBit(bitnumber, mydef.HOFlagMask);
  setBit(bitnumber, mydef.HFFlagMask);
  setBit(bitnumber, mydef.ZDCFlagMask);
  setBit(bitnumber, mydef.CalibFlagMask);
}

std::ostream& operator<<(std::ostream& s, const HcalSeverityLevelComputer::HcalSeverityDefinition& def) {
  s << "Hcal Severity Level Definition, Level = " << def.sevLevel << std::endl;
  s << std::hex << std::showbase;
  s << "  channel status mask = " << def.chStatusMask << std::endl;
  s << "  HBHEFlagMask        = " << def.HBHEFlagMask << std::endl;
  s << "  HOFlagMask          = " << def.HOFlagMask << std::endl;
  s << "  HFFlagMask          = " << def.HFFlagMask << std::endl;
  s << "  ZDCFlagMask         = " << def.ZDCFlagMask << std::endl;
  s << "  CalibFlagMask       = " << def.CalibFlagMask << std::dec << std::noshowbase << std::endl;
  return s;
}