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