#include <HcalNoiseAlgo.h>

Public Member Functions
bool	CheckPassFilter (double Charge, double Discriminant, std::vector< std::pair< double, double > > &Cuts, int Side)
	CommonHcalNoiseRBXData (const reco::HcalNoiseRBX &rbx, double minRecHitE, double minLowHitE, double minHighHitE, double TS4TS5EnergyThreshold, std::vector< std::pair< double, double > > &TS4TS5UpperCut, std::vector< std::pair< double, double > > &TS4TS5LowerCut)
double	e10ts (void) const
double	e2ts (void) const
double	energy (void) const
double	highEHitTimeSqrd (void) const
double	HPDEMF (void) const
double	lowEHitTimeSqrd (void) const
double	maxHighEHitTime (void) const
double	maxLowEHitTime (void) const
double	minHighEHitTime (void) const
double	minLowEHitTime (void) const
int	numHighEHits (void) const
int	numHPDHits (void) const
int	numHPDNoOtherHits (void) const
int	numLowEHits (void) const
int	numRBXHits (void) const
int	numZeros (void) const
bool	PassTS4TS5 (void) const
double	ratio (void) const
double	RBXEMF (void) const
edm::RefVector < CaloTowerCollection >	rbxTowers (void) const
bool	validRatio (void) const
	~CommonHcalNoiseRBXData ()
Private Attributes
double	e10ts_
double	e2ts_
double	energy_
double	highEHitTimeSqrd_
double	HPDEMF_
double	lowEHitTimeSqrd_
double	maxHighEHitTime_
double	maxLowEHitTime_
double	minHighEHitTime_
double	minLowEHitTime_
int	numHighEHits_
int	numHPDHits_
int	numHPDNoOtherHits_
int	numLowEHits_
int	numRBXHits_
int	numZeros_
double	RBXEMF_
edm::RefVector < CaloTowerCollection >	rbxtowers_
bool	TS4TS5Decision_

Detailed Description

Definition at line 11 of file HcalNoiseAlgo.h.

Constructor & Destructor Documentation

CommonHcalNoiseRBXData::CommonHcalNoiseRBXData	(	const reco::HcalNoiseRBX &	rbx,
		double	minRecHitE,
		double	minLowHitE,
		double	minHighHitE,
		double	TS4TS5EnergyThreshold,
		std::vector< std::pair< double, double > > &	TS4TS5UpperCut,
		std::vector< std::pair< double, double > > &	TS4TS5LowerCut
	)

Definition at line 3 of file HcalNoiseAlgo.cc.

{
  // energy
  energy_ = rbx.recHitEnergy(minRecHitE); 

  // ratio
  e2ts_ = rbx.allChargeHighest2TS();
  e10ts_ = rbx.allChargeTotal();

  // TS4TS5
  TS4TS5Decision_ = true;
  if(energy_ > TS4TS5EnergyThreshold)   // check filter
  {
     std::vector<float> AllCharge = rbx.allCharge();
     double BaseCharge = AllCharge[4] + AllCharge[5];
     if(BaseCharge < 1)
        BaseCharge = 1;
     double TS4TS5 = (AllCharge[4] - AllCharge[5]) / BaseCharge;

     if(CheckPassFilter(BaseCharge, TS4TS5, TS4TS5UpperCut, 1) == false)
        TS4TS5Decision_ = false;
     if(CheckPassFilter(BaseCharge, TS4TS5, TS4TS5LowerCut, -1) == false)
        TS4TS5Decision_ = false;
  }
  else
     TS4TS5Decision_ = true;

  // # of hits
  numHPDHits_ = 0;
  for(std::vector<reco::HcalNoiseHPD>::const_iterator it1=rbx.HPDsBegin(); it1!=rbx.HPDsEnd(); ++it1) {
    int nhpdhits=it1->numRecHits(minRecHitE);
    if(numHPDHits_ < nhpdhits) numHPDHits_ = nhpdhits;
  }
  numRBXHits_ = rbx.numRecHits(minRecHitE);
  numHPDNoOtherHits_ = (numHPDHits_ == numRBXHits_) ? numHPDHits_ : 0;    

  // # of ADC zeros
  numZeros_ = rbx.totalZeros();

  // timing
  minLowEHitTime_ = minHighEHitTime_ = 99999.;
  maxLowEHitTime_ = maxHighEHitTime_ = -99999.;
  lowEHitTimeSqrd_ = highEHitTimeSqrd_ = 0;
  numLowEHits_ = numHighEHits_ = 0;
  for(std::vector<reco::HcalNoiseHPD>::const_iterator it1=rbx.HPDsBegin(); it1!=rbx.HPDsEnd(); ++it1) {
    edm::RefVector<HBHERecHitCollection> rechits=it1->recHits();
    for(edm::RefVector<HBHERecHitCollection>::const_iterator it2=rechits.begin(); it2!=rechits.end(); ++it2) {
      float energy=(*it2)->energy();
      float time=(*it2)->time();
      if(energy>=minLowHitE) {
        if(minLowEHitTime_ > time) minLowEHitTime_ = time;
        if(maxLowEHitTime_ < time) maxLowEHitTime_ = time;
        lowEHitTimeSqrd_ += time*time;
        ++numLowEHits_;
      }
      if(energy>=minHighHitE) {
        if(minHighEHitTime_ > time) minHighEHitTime_ = time;
        if(maxHighEHitTime_ < time) maxHighEHitTime_ = time;
        highEHitTimeSqrd_ += time*time;
        ++numHighEHits_;
      }
    }
  }

  // emf
  HPDEMF_ = 999.;
  for(std::vector<reco::HcalNoiseHPD>::const_iterator it1=rbx.HPDsBegin(); it1!=rbx.HPDsEnd(); ++it1) {
    double eme=it1->caloTowerEmE();
    double hade=it1->recHitEnergy(minRecHitE);
    double emf=(eme+hade)==0 ? 999 : eme/(eme+hade);
    if(HPDEMF_ > emf) emf = HPDEMF_;
  }
  double eme=rbx.caloTowerEmE();
  RBXEMF_ = (eme+energy_)==0 ? 999 : eme/(eme+energy_);

  // calotowers
  rbxtowers_.clear();
  JoinCaloTowerRefVectorsWithoutDuplicates join;
  for(std::vector<reco::HcalNoiseHPD>::const_iterator it1=rbx.HPDsBegin(); it1!=rbx.HPDsEnd(); ++it1) {
    join(rbxtowers_, it1->caloTowers());
  }

  return;
}

CommonHcalNoiseRBXData::~CommonHcalNoiseRBXData ( ) [inline]

Definition at line 17 of file HcalNoiseAlgo.h.

{}

Member Function Documentation

bool CommonHcalNoiseRBXData::CheckPassFilter	(	double	Charge,
		double	Discriminant,
		std::vector< std::pair< double, double > > &	Cuts,
		int	Side
	)

Definition at line 280 of file HcalNoiseAlgo.cc.

References first, i, and MessageLogger_cff::limit.

Referenced by CommonHcalNoiseRBXData().

{
   //
   // Checks whether Discriminant value passes Cuts for the specified Charge.  True if pulse is good.
   //
   // The "Cuts" pairs are assumed to be sorted in terms of size from small to large,
   //    where each "pair" = (Charge, Discriminant)
   // "Side" is either positive or negative, which determines whether to discard the pulse if discriminant
   //    is greater or smaller than the cut value
   //

   if(Cuts.size() == 0)   // safety check that there are some cuts defined
      return true;

   if(Charge <= Cuts[0].first)   // too small to cut on
      return true;

   int IndexLargerThanCharge = -1;   // find the range it is falling in
   for(int i = 1; i < (int)Cuts.size(); i++)
   {
      if(Cuts[i].first > Charge)
      {
         IndexLargerThanCharge = i;
         break;
      }
   }

   double limit = 1000000;

   if(IndexLargerThanCharge == -1)   // if charge is greater than the last entry, assume flat line
      limit = Cuts[Cuts.size()-1].second;
   else   // otherwise, do a linear interpolation to find the cut position
   {
      double C1 = Cuts[IndexLargerThanCharge].first;
      double C2 = Cuts[IndexLargerThanCharge-1].first;
      double L1 = Cuts[IndexLargerThanCharge].second;
      double L2 = Cuts[IndexLargerThanCharge-1].second;

      limit = (Charge - C1) / (C2 - C1) * (L2 - L1) + L1;
   }

   if(Side > 0 && Discriminant > limit)
      return false;
   if(Side < 0 && Discriminant < limit)
      return false;

   return true;
}