HcalNoiseSummary.cc

Go to the documentation of this file.

//
// HcalNoiseSummary.cc
//
//    description: implementation of container class of HCAL noise summary
//
//    author: J.P. Chou, Brown
//
 
#include "DataFormats/METReco/interface/HcalNoiseSummary.h"
 
// default constructor
HcalNoiseSummary::HcalNoiseSummary()
    : filterstatus_(0),
      noisetype_(0),
      emenergy_(0.0),
      hadenergy_(0.0),
      trackenergy_(0.0),
      min10_(999999.),
      max10_(-999999.),
      rms10_(0.0),
      min25_(999999.),
      max25_(-999999.),
      rms25_(0.0),
      cnthit10_(0),
      cnthit25_(0),
      mine2ts_(0.),
      mine10ts_(0.),
      maxe2ts_(0.),
      maxe10ts_(0.),
      maxzeros_(0),
      maxhpdhits_(0),
      maxhpdhitsnoother_(0),
      maxrbxhits_(0),
      minhpdemf_(999999.),
      minrbxemf_(999999.),
      nproblemRBXs_(0),
      nisolnoise_(0),
      isolnoisee_(0),
      isolnoiseet_(0),
      nflatnoise_(0),
      flatnoisee_(0),
      flatnoiseet_(0),
      nspikenoise_(0),
      spikenoisee_(0),
      spikenoiseet_(0),
      ntrianglenoise_(0),
      trianglenoisee_(0),
      trianglenoiseet_(0),
      nts4ts5noise_(0),
      ts4ts5noisee_(0),
      ts4ts5noiseet_(0),
      nnegativenoise_(0),
      negativenoisee_(0),
      negativenoiseet_(0),
      rechitCount_(0),
      rechitCount15_(0),
      rechitEnergy_(0),
      rechitEnergy15_(0),
      calibCharge_(0),
      lasmonCharge_(0),
      hasBadRBXTS4TS5_(false),
      hasBadRBXRechitR45Loose_(false),
      hasBadRBXRechitR45Tight_(false),
      goodJetFoundInLowBVRegion_(false),
      calibCountTS45_(0),
      calibCountgt15TS45_(0),
      calibChargeTS45_(0.),
      calibChargegt15TS45_(0.),
      calibCountHF_(0),
      calibChargeHF_(0.),
      hitsInLaserRegion_(0),
      hitsInNonLaserRegion_(0),
      energyInLaserRegion_(0.),
      energyInNonLaserRegion_(0.) {}
 
// destructor
HcalNoiseSummary::~HcalNoiseSummary() {}
 
// accessors
bool HcalNoiseSummary::passLooseNoiseFilter(void) const { return (filterstatus_ & 0xFF) == 0; }
 
bool HcalNoiseSummary::passTightNoiseFilter(void) const { return (filterstatus_ & 0xFF00) == 0; }
 
bool HcalNoiseSummary::passHighLevelNoiseFilter(void) const { return (filterstatus_ & 0xFF0000) == 0; }
 
int HcalNoiseSummary::noiseType(void) const {
  if (maxRBXHits() > 18)
    return 3;
  else if (maxRBXHits() > 8)
    return 2;
  return 1;
}
 
int HcalNoiseSummary::noiseFilterStatus(void) const { return filterstatus_; }
 
float HcalNoiseSummary::eventEMEnergy(void) const { return emenergy_; }
 
float HcalNoiseSummary::eventHadEnergy(void) const { return hadenergy_; }
 
float HcalNoiseSummary::eventTrackEnergy(void) const { return trackenergy_; }
 
float HcalNoiseSummary::eventEMFraction(void) const {
  if (hadenergy_ + emenergy_ == 0.0)
    return -999.;
  else
    return emenergy_ / (hadenergy_ + emenergy_);
}
 
float HcalNoiseSummary::eventChargeFraction(void) const {
  if (hadenergy_ + emenergy_ == 0.0)
    return -999.;
  else
    return trackenergy_ / (hadenergy_ + emenergy_);
}
 
float HcalNoiseSummary::min10GeVHitTime(void) const { return min10_; }
 
float HcalNoiseSummary::max10GeVHitTime(void) const { return max10_; }
 
float HcalNoiseSummary::rms10GeVHitTime(void) const { return cnthit10_ > 0 ? std::sqrt(rms10_ / cnthit10_) : 999; }
 
float HcalNoiseSummary::min25GeVHitTime(void) const { return min25_; }
 
float HcalNoiseSummary::max25GeVHitTime(void) const { return max25_; }
 
float HcalNoiseSummary::rms25GeVHitTime(void) const { return cnthit25_ > 0 ? std::sqrt(rms25_ / cnthit25_) : 999; }
 
int HcalNoiseSummary::num10GeVHits(void) const { return cnthit10_; }
 
int HcalNoiseSummary::num25GeVHits(void) const { return cnthit25_; }
 
float HcalNoiseSummary::minE2TS(void) const { return mine2ts_; }
 
float HcalNoiseSummary::minE10TS(void) const { return mine10ts_; }
 
float HcalNoiseSummary::minE2Over10TS(void) const { return mine10ts_ == 0 ? 999999. : mine2ts_ / mine10ts_; }
 
float HcalNoiseSummary::maxE2TS(void) const { return maxe2ts_; }
 
float HcalNoiseSummary::maxE10TS(void) const { return maxe10ts_; }
 
float HcalNoiseSummary::maxE2Over10TS(void) const { return maxe10ts_ == 0 ? -999999. : maxe2ts_ / maxe10ts_; }
 
int HcalNoiseSummary::maxZeros(void) const { return maxzeros_; }
 
int HcalNoiseSummary::maxHPDHits(void) const { return maxhpdhits_; }
 
int HcalNoiseSummary::maxHPDNoOtherHits(void) const { return maxhpdhitsnoother_; }
 
int HcalNoiseSummary::maxRBXHits(void) const { return maxrbxhits_; }
 
float HcalNoiseSummary::minHPDEMF(void) const { return minhpdemf_; }
 
float HcalNoiseSummary::minRBXEMF(void) const { return minrbxemf_; }
 
int HcalNoiseSummary::numProblematicRBXs(void) const { return nproblemRBXs_; }
 
int HcalNoiseSummary::numIsolatedNoiseChannels(void) const { return nisolnoise_; }
 
float HcalNoiseSummary::isolatedNoiseSumE(void) const { return isolnoisee_; }
 
float HcalNoiseSummary::isolatedNoiseSumEt(void) const { return isolnoiseet_; }
 
int HcalNoiseSummary::numFlatNoiseChannels(void) const { return nflatnoise_; }
 
float HcalNoiseSummary::flatNoiseSumE(void) const { return flatnoisee_; }
 
float HcalNoiseSummary::flatNoiseSumEt(void) const { return flatnoiseet_; }
 
int HcalNoiseSummary::numSpikeNoiseChannels(void) const { return nspikenoise_; }
 
float HcalNoiseSummary::spikeNoiseSumE(void) const { return spikenoisee_; }
 
float HcalNoiseSummary::spikeNoiseSumEt(void) const { return spikenoiseet_; }
 
int HcalNoiseSummary::numTriangleNoiseChannels(void) const { return ntrianglenoise_; }
 
float HcalNoiseSummary::triangleNoiseSumE(void) const { return trianglenoisee_; }
 
float HcalNoiseSummary::triangleNoiseSumEt(void) const { return trianglenoiseet_; }
 
int HcalNoiseSummary::numTS4TS5NoiseChannels(void) const { return nts4ts5noise_; }
 
float HcalNoiseSummary::TS4TS5NoiseSumE(void) const { return ts4ts5noisee_; }
 
float HcalNoiseSummary::TS4TS5NoiseSumEt(void) const { return ts4ts5noiseet_; }
 
int HcalNoiseSummary::numNegativeNoiseChannels(void) const { return nnegativenoise_; }
 
float HcalNoiseSummary::NegativeNoiseSumE(void) const { return negativenoisee_; }
 
float HcalNoiseSummary::NegativeNoiseSumEt(void) const { return negativenoiseet_; }
 
int HcalNoiseSummary::GetRecHitCount(void) const { return rechitCount_; }
 
int HcalNoiseSummary::GetRecHitCount15(void) const { return rechitCount15_; }
 
double HcalNoiseSummary::GetRecHitEnergy(void) const { return rechitEnergy_; }
 
double HcalNoiseSummary::GetRecHitEnergy15(void) const { return rechitEnergy15_; }
 
double HcalNoiseSummary::GetTotalCalibCharge(void) const { return calibCharge_; }
 
double HcalNoiseSummary::GetLaserMonitorCharge(void) const { return lasmonCharge_; }
 
bool HcalNoiseSummary::HasBadRBXTS4TS5(void) const { return hasBadRBXTS4TS5_; }
 
bool HcalNoiseSummary::HasBadRBXRechitR45Loose(void) const { return hasBadRBXRechitR45Loose_; }
 
bool HcalNoiseSummary::HasBadRBXRechitR45Tight(void) const { return hasBadRBXRechitR45Tight_; }
 
bool HcalNoiseSummary::goodJetFoundInLowBVRegion(void) const { return goodJetFoundInLowBVRegion_; }
 
int HcalNoiseSummary::GetCalibCountTS45(void) const { return calibCountTS45_; }
 
int HcalNoiseSummary::GetCalibgt15CountTS45(void) const { return calibCountgt15TS45_; }
 
double HcalNoiseSummary::GetCalibChargeTS45(void) const { return calibChargeTS45_; }
 
double HcalNoiseSummary::GetCalibgt15ChargeTS45(void) const { return calibChargegt15TS45_; }
 
int HcalNoiseSummary::GetCalibCountHF(void) const {
  // calibCountHF_ is the number of HF calibration digis in the event (no charge threshold required when counting these digis)
  return calibCountHF_;
}
 
double HcalNoiseSummary::GetCalibChargeHF(void) const {
  // calibChargeHF_ is the total charge (over all 10 time slices) for all HF calibration digis in the event
  return calibChargeHF_;
}
 
int HcalNoiseSummary::GetHitsInNonLaserRegion(void) const { return hitsInNonLaserRegion_; }
 
double HcalNoiseSummary::GetEnergyInNonLaserRegion(void) const { return energyInNonLaserRegion_; }
 
int HcalNoiseSummary::GetHitsInLaserRegion(void) const { return hitsInLaserRegion_; }
 
double HcalNoiseSummary::GetEnergyInLaserRegion(void) const { return energyInLaserRegion_; }
 
edm::RefVector<reco::CaloJetCollection> HcalNoiseSummary::problematicJets(void) const { return problemjets_; }
 
edm::RefVector<CaloTowerCollection> HcalNoiseSummary::looseNoiseTowers(void) const { return loosenoisetwrs_; }
 
edm::RefVector<CaloTowerCollection> HcalNoiseSummary::tightNoiseTowers(void) const { return tightnoisetwrs_; }
 
edm::RefVector<CaloTowerCollection> HcalNoiseSummary::highLevelNoiseTowers(void) const { return hlnoisetwrs_; }