HcalSeverityLevelComputer Class Reference

#include <HcalSeverityLevelComputer.h>

Classes
class	HcalSeverityDefinition

Public Member Functions
bool	dropChannel (const uint32_t &mystatus) const
int	getSeverityLevel (const DetId &myid, const uint32_t &myflag, const uint32_t &mystatus) const
	HcalSeverityLevelComputer (const edm::ParameterSet &)
bool	recoveredRecHit (const DetId &myid, const uint32_t &myflag) const
	~HcalSeverityLevelComputer ()

Private Member Functions
bool	getChStBit (HcalSeverityDefinition &mydef, const std::string &mybit)
bool	getRecHitFlag (HcalSeverityDefinition &mydef, const std::string &mybit, int phase_)
void	setAllRHMasks (const unsigned bitnumber, HcalSeverityDefinition &mydef)
void	setBit (const unsigned bitnumber, uint32_t &where)

Private Attributes
HcalSeverityDefinition *	DropChannel_
HcalSeverityDefinition *	RecoveredRecHit_
std::vector< HcalSeverityDefinition >	SevDef

Friends
std::ostream &	operator<< (std::ostream &s, const HcalSeverityLevelComputer::HcalSeverityDefinition &def)

Detailed Description

Definition at line 24 of file HcalSeverityLevelComputer.h.

Constructor & Destructor Documentation

HcalSeverityLevelComputer()

HcalSeverityLevelComputer::HcalSeverityLevelComputer

(

const edm::ParameterSet &

iConfig

)

Definition at line 185 of file HcalSeverityLevelComputer.cc.

                                                                                   {
  // 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

References DropChannel_, relativeConstraints::empty, getChStBit(), edm::ParameterSet::getParameter(), getRecHitFlag(), dqmdumpme::k, hydjet2DefaultParameters_cff::myParameters, RecoveredRecHit_, SevDef, HcalSeverityLevelComputer::HcalSeverityDefinition::sevLevel, and AlCaHLTBitMon_QueryRunRegistry::string.

~HcalSeverityLevelComputer()

HcalSeverityLevelComputer::~HcalSeverityLevelComputer

(

)

Definition at line 299 of file HcalSeverityLevelComputer.cc.

                                                      {
  delete DropChannel_;
  delete RecoveredRecHit_;
}

References DropChannel_, and RecoveredRecHit_.

Member Function Documentation

dropChannel()

bool HcalSeverityLevelComputer::dropChannel

(

const uint32_t &

mystatus

)

const

Definition at line 395 of file HcalSeverityLevelComputer.cc.

                                                                          {
  if (DropChannel_->chStatusMask & mystatus)
    return true;
 
  return false;
}

References HcalSeverityLevelComputer::HcalSeverityDefinition::chStatusMask, and DropChannel_.

Referenced by reco::HcalNoiseInfoProducer::filldigis(), HcalHF_PETalgorithm::HFSetFlagFromPET(), HcalHFStatusBitFromRecHits::hfSetFlagFromRecHits(), CaloTowersCreationAlgo::makeHcalDropChMap(), ZdcHitReconstructor::produce(), HcalHitReconstructor::produce(), and HFPhase1Reconstructor::produce().

getChStBit()

bool HcalSeverityLevelComputer::getChStBit ( HcalSeverityDefinition &  mydef, const std::string &  mybit  )

private

Definition at line 9 of file HcalSeverityLevelComputer.cc.

                                                                                                {
  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;
}

References HcalSeverityLevelComputer::HcalSeverityDefinition::chStatusMask, HcalChannelStatus::HcalBadLaserSignal, HcalChannelStatus::HcalCellCaloTowerMask, HcalChannelStatus::HcalCellCaloTowerProb, HcalChannelStatus::HcalCellDead, HcalChannelStatus::HcalCellExcludeFromHBHENoiseSummary, HcalChannelStatus::HcalCellExcludeFromHBHENoiseSummaryR45, HcalChannelStatus::HcalCellHot, HcalChannelStatus::HcalCellMask, HcalChannelStatus::HcalCellOff, HcalChannelStatus::HcalCellStabErr, HcalChannelStatus::HcalCellTimErr, HcalChannelStatus::HcalCellTrigMask, and setBit().

Referenced by HcalSeverityLevelComputer().

getRecHitFlag()

bool HcalSeverityLevelComputer::getRecHitFlag ( HcalSeverityDefinition &  mydef, const std::string &  mybit, int  phase_  )

private

Definition at line 42 of file HcalSeverityLevelComputer.cc.

                                                                                                              {
  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;
}

References HcalCaloFlagLabels::ADCSaturationBit, HcalCaloFlagLabels::AddedSimHcalNoise, HcalSeverityLevelComputer::HcalSeverityDefinition::CalibFlagMask, HcalCaloFlagLabels::CalibrationBit, HcalCaloFlagLabels::Fraction2TS, HcalSeverityLevelComputer::HcalSeverityDefinition::HBHEFlagMask, HcalPhase1FlagLabels::HBHEFlatNoise, HcalCaloFlagLabels::HBHEFlatNoise, HcalPhase1FlagLabels::HBHEHpdHitMultiplicity, HcalCaloFlagLabels::HBHEHpdHitMultiplicity, HcalPhase1FlagLabels::HBHEIsolatedNoise, HcalCaloFlagLabels::HBHEIsolatedNoise, HcalPhase1FlagLabels::HBHENegativeNoise, HcalCaloFlagLabels::HBHENegativeNoise, HcalPhase1FlagLabels::HBHEOOTPU, HcalCaloFlagLabels::HBHEOOTPU, HcalPhase1FlagLabels::HBHEPulseFitBit, HcalCaloFlagLabels::HBHEPulseFitBit, HcalCaloFlagLabels::HBHEPulseShape, HcalPhase1FlagLabels::HBHESpikeNoise, HcalCaloFlagLabels::HBHESpikeNoise, HcalCaloFlagLabels::HBHETimingShapedCutsBits, HcalCaloFlagLabels::HBHETimingTrustBits, HcalCaloFlagLabels::HBHETriangleNoise, HcalPhase1FlagLabels::HBHETS4TS5Noise, HcalCaloFlagLabels::HBHETS4TS5Noise, HcalPhase1FlagLabels::HFAnomalousHit, HcalCaloFlagLabels::HFDigiTime, HcalSeverityLevelComputer::HcalSeverityDefinition::HFFlagMask, HcalCaloFlagLabels::HFInTimeWindow, HcalPhase1FlagLabels::HFLongShort, HcalCaloFlagLabels::HFLongShort, HcalPhase1FlagLabels::HFPET, HcalCaloFlagLabels::HFPET, HcalPhase1FlagLabels::HFS8S1Ratio, HcalCaloFlagLabels::HFS8S1Ratio, HcalPhase1FlagLabels::HFSignalAsymmetry, HcalCaloFlagLabels::HFTimingTrustBits, HcalCaloFlagLabels::HOBit, HcalSeverityLevelComputer::HcalSeverityDefinition::HOFlagMask, HcalCaloFlagLabels::HSCP_ExpFit, HcalCaloFlagLabels::HSCP_FracLeader, HcalCaloFlagLabels::HSCP_OuterEnergy, HcalCaloFlagLabels::HSCP_R1R2, HcalCaloFlagLabels::PresampleADC, setAllRHMasks(), setBit(), HcalCaloFlagLabels::TimingAddedBit, HcalCaloFlagLabels::TimingErrorBit, HcalPhase1FlagLabels::TimingFromTDC, HcalCaloFlagLabels::TimingSubtractedBit, HcalPhase1FlagLabels::UserDefinedBit0, HcalCaloFlagLabels::UserDefinedBit0, HcalCaloFlagLabels::ZDCBit, and HcalSeverityLevelComputer::HcalSeverityDefinition::ZDCFlagMask.

Referenced by HcalSeverityLevelComputer().

getSeverityLevel()

int HcalSeverityLevelComputer::getSeverityLevel	(	const DetId &	myid,
		const uint32_t &	myflag,
		const uint32_t &	mystatus
	)		const

Definition at line 304 of file HcalSeverityLevelComputer.cc.

                                                                                {
  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
}

References HcalGenericDetId::genericSubdet(), HcalGenericDetId::HcalGenBarrel, HcalGenericDetId::HcalGenCalibration, HcalGenericDetId::HcalGenEndcap, HcalGenericDetId::HcalGenForward, HcalGenericDetId::HcalGenOuter, HcalGenericDetId::HcalGenZDC, mps_fire::i, dqmiolumiharvest::j, and SevDef.

Referenced by AlCaHOCalibProducer::fillHOStore(), reco::HcalNoiseInfoProducer::fillrechits(), CaloTowersCreationAlgo::hcalChanStatusForCaloTower(), HcalRecHitsAnalyzer::hcalSevLvl(), HcalHF_PETalgorithm::HFSetFlagFromPET(), HcalHF_S9S1algorithm::HFSetFlagFromS9S1(), HcalHitSelection::skim(), PFRecHitQTestHCALChannel::test(), and ObjectValidator::validHit().

recoveredRecHit()

bool HcalSeverityLevelComputer::recoveredRecHit	(	const DetId &	myid,
		const uint32_t &	myflag
	)		const

Definition at line 363 of file HcalSeverityLevelComputer.cc.

                                                                                               {
  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;
}

References HcalSeverityLevelComputer::HcalSeverityDefinition::CalibFlagMask, HcalGenericDetId::genericSubdet(), HcalSeverityLevelComputer::HcalSeverityDefinition::HBHEFlagMask, HcalGenericDetId::HcalGenBarrel, HcalGenericDetId::HcalGenCalibration, HcalGenericDetId::HcalGenEndcap, HcalGenericDetId::HcalGenForward, HcalGenericDetId::HcalGenOuter, HcalGenericDetId::HcalGenZDC, HcalSeverityLevelComputer::HcalSeverityDefinition::HFFlagMask, HcalSeverityLevelComputer::HcalSeverityDefinition::HOFlagMask, RecoveredRecHit_, and HcalSeverityLevelComputer::HcalSeverityDefinition::ZDCFlagMask.

Referenced by reco::HcalNoiseInfoProducer::fillrechits(), CaloTowersCreationAlgo::hcalChanStatusForCaloTower(), and ObjectValidator::validHit().

setAllRHMasks()

void HcalSeverityLevelComputer::setAllRHMasks ( const unsigned  bitnumber, HcalSeverityDefinition &  mydef  )

private

Definition at line 407 of file HcalSeverityLevelComputer.cc.

                                                                                                     {
  setBit(bitnumber, mydef.HBHEFlagMask);
  setBit(bitnumber, mydef.HOFlagMask);
  setBit(bitnumber, mydef.HFFlagMask);
  setBit(bitnumber, mydef.ZDCFlagMask);
  setBit(bitnumber, mydef.CalibFlagMask);
}

References HcalSeverityLevelComputer::HcalSeverityDefinition::CalibFlagMask, HcalSeverityLevelComputer::HcalSeverityDefinition::HBHEFlagMask, HcalSeverityLevelComputer::HcalSeverityDefinition::HFFlagMask, HcalSeverityLevelComputer::HcalSeverityDefinition::HOFlagMask, setBit(), and HcalSeverityLevelComputer::HcalSeverityDefinition::ZDCFlagMask.

Referenced by getRecHitFlag().

setBit()

void HcalSeverityLevelComputer::setBit ( const unsigned  bitnumber, uint32_t &  where  )

private

Definition at line 402 of file HcalSeverityLevelComputer.cc.

                                                                                {
  uint32_t statadd = 0x1 << (bitnumber);
  where = where | statadd;
}

Referenced by getChStBit(), getRecHitFlag(), and setAllRHMasks().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  s, const HcalSeverityLevelComputer::HcalSeverityDefinition &  def  )

friend

Definition at line 415 of file HcalSeverityLevelComputer.cc.

                                                                                                  {
  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;
}

Member Data Documentation

DropChannel_

HcalSeverityDefinition* HcalSeverityLevelComputer::DropChannel_

private

Definition at line 56 of file HcalSeverityLevelComputer.h.

Referenced by dropChannel(), HcalSeverityLevelComputer(), and ~HcalSeverityLevelComputer().

RecoveredRecHit_

HcalSeverityDefinition* HcalSeverityLevelComputer::RecoveredRecHit_

private

Definition at line 55 of file HcalSeverityLevelComputer.h.

Referenced by HcalSeverityLevelComputer(), recoveredRecHit(), and ~HcalSeverityLevelComputer().

SevDef

std::vector<HcalSeverityDefinition> HcalSeverityLevelComputer::SevDef

private

Definition at line 54 of file HcalSeverityLevelComputer.h.

Referenced by getSeverityLevel(), and HcalSeverityLevelComputer().