#include <HBHENegativeFlag.h>

Public Member Functions
	HBHENegativeFlagSetter ()

	HBHENegativeFlagSetter (double minimumChargeThreshold, double tS4TS5ChargeThreshold, int first, int last, std::vector< double > threshold, std::vector< double > cut)

void	setBXInfo (const BunchXParameter *info, unsigned length)

void	setHBHEPileupCorrection (boost::shared_ptr< AbsOOTPileupCorrection > corr)

void	setPulseShapeFlags (HBHERecHit &hbhe, const HBHEDataFrame &digi, const HcalCoder &coder, const HcalCalibrations &calib)

	~HBHENegativeFlagSetter ()

Private Member Functions
bool	checkPassFilter (double charge, double discriminant, std::vector< std::pair< double, double > > &cuts, int side)

Private Attributes
boost::shared_ptr < AbsOOTPileupCorrection >	hbhePileupCorr_

const BunchXParameter *	mBunchCrossingInfo

std::vector< std::pair< double, double > >	mCut

int	mFirst

int	mLast

unsigned	mLengthBunchCrossingInfo

double	mMinimumChargeThreshold

double	mTS4TS5ChargeThreshold

Detailed Description

Definition at line 24 of file HBHENegativeFlag.h.

Constructor & Destructor Documentation

HBHENegativeFlagSetter::HBHENegativeFlagSetter ( )

Definition at line 28 of file HBHENegativeFlag.cc.

References mBunchCrossingInfo, mFirst, mLast, mLengthBunchCrossingInfo, mMinimumChargeThreshold, mTS4TS5ChargeThreshold, and NULL.

 {
    //
    // Argumentless constructor; should not be used
    // 
    // If arguments not properly specified for the constructor, I don't think
    // we'd trust the flagging algorithm.
    // Set the minimum charge threshold large enough so that nothing will be flagged.
    // 
 
    mMinimumChargeThreshold = 99999999;
    mTS4TS5ChargeThreshold = 99999999;
    mFirst = 4;
    mLast = 6;
    mBunchCrossingInfo = NULL;
    mLengthBunchCrossingInfo = 0;
 }

HBHENegativeFlagSetter::HBHENegativeFlagSetter	(	double	minimumChargeThreshold,
		double	tS4TS5ChargeThreshold,
		int	first,
		int	last,
		std::vector< double >	threshold,
		std::vector< double >	cut
	)

Definition at line 46 of file HBHENegativeFlag.cc.

References first, i, prof2calltree::last, mBunchCrossingInfo, mCut, mFirst, min(), mLast, mLengthBunchCrossingInfo, mMinimumChargeThreshold, mTS4TS5ChargeThreshold, NULL, python.multivaluedict::sort(), and std::swap().

 {
    //
    // The constructor that should be used
    //
    // Copies various thresholds and limits and parameters to the class for future use.
    //
 
    mMinimumChargeThreshold = minimumChargeThreshold;
    mTS4TS5ChargeThreshold = tS4TS5ChargeThreshold;
    mFirst = first;
    mLast = last;
 
    if(mLast < mFirst)   // sanity protection
       std::swap(mFirst, mLast);
 
    mBunchCrossingInfo = NULL;
    mLengthBunchCrossingInfo = 0;
 
    for(int i = 0; i < (int)std::min(threshold.size(), cut.size()); i++)
       mCut.push_back(std::pair<double, double>(threshold[i], cut[i]));
    std::sort(mCut.begin(), mCut.end());
 }

HBHENegativeFlagSetter::~HBHENegativeFlagSetter ( )

Definition at line 72 of file HBHENegativeFlag.cc.

 {
    // Dummy destructor - there's nothing to destruct by hand here
 }

Member Function Documentation

bool HBHENegativeFlagSetter::checkPassFilter	(	double	charge,
		double	discriminant,
		std::vector< std::pair< double, double > > &	cuts,
		int	side
	)

private

Definition at line 151 of file HBHENegativeFlag.cc.

References Reconstruction_Data_cff::cuts, first, i, and MessageLogger_cff::limit.

Referenced by setPulseShapeFlags().

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

void HBHENegativeFlagSetter::setBXInfo	(	const BunchXParameter *	info,
		unsigned	length
	)

Definition at line 145 of file HBHENegativeFlag.cc.

References info(), mBunchCrossingInfo, and mLengthBunchCrossingInfo.

 {
    mBunchCrossingInfo = info;
    mLengthBunchCrossingInfo = length;
 }

void HBHENegativeFlagSetter::setHBHEPileupCorrection ( boost::shared_ptr< AbsOOTPileupCorrection > corr )

Definition at line 140 of file HBHENegativeFlag.cc.

References corr, and hbhePileupCorr_.

Referenced by HcalHitReconstructor::HcalHitReconstructor().

 {
     hbhePileupCorr_ = corr;
 }

void HBHENegativeFlagSetter::setPulseShapeFlags	(	HBHERecHit &	hbhe,
		const HBHEDataFrame &	digi,
		const HcalCoder &	coder,
		const HcalCalibrations &	calib
	)

Definition at line 77 of file HBHENegativeFlag.cc.

References HcalCoder::adc2fC(), checkPassFilter(), fwrapper::cs, HcalCaloFlagLabels::HBHENegativeNoise, hbhePileupCorr_, i, HBHEDataFrame::id(), CaloSamples::MAXSAMPLES, mBunchCrossingInfo, mCut, mFirst, min(), mLast, mLengthBunchCrossingInfo, mMinimumChargeThreshold, n, HcalCalibrations::pedestal(), HcalCalibrations::respcorrgain(), CaloRecHit::setFlagField(), and CaloSamples::size().

Referenced by HcalHitReconstructor::produce().

 {
    //
    // Decide if a digi/pulse is good or bad using negative energy discriminants
    //
    // SetPulseShapeFlags determines the total charge in the digi.
    // If the charge is above the minimum threshold, the code then
    // runs the flag-setting algorithms to determine whether the
    // flags should be set.
    //
 
    if(hbhePileupCorr_)
    {
       CaloSamples cs;
       coder.adc2fC(digi,cs);
       const int nRead = cs.size();
 
       double inputCharge[CaloSamples::MAXSAMPLES];
       double gains[CaloSamples::MAXSAMPLES];
       double CorrectedEnergy[CaloSamples::MAXSAMPLES];
 
       for(int i = 0; i < nRead; i++)
       {
          const int capid = digi[i].capid();
          inputCharge[i] = cs[i] - calib.pedestal(capid);
          gains[i] = calib.respcorrgain(capid);
       }
 
       double ChargeInWindow = 0;
       for(int i = mFirst; i <= mLast && i < CaloSamples::MAXSAMPLES; i++)
          ChargeInWindow = ChargeInWindow + inputCharge[i];
       if(ChargeInWindow < mMinimumChargeThreshold)
          return;
 
       const bool UseGain = hbhePileupCorr_->inputIsEnergy();
       if(UseGain == true)
          for(int i = 0; i < nRead; i++)
             inputCharge[i] = inputCharge[i] * gains[i];
 
       bool pulseShapeCorrApplied = false;
       bool leakCorrApplied = false;
       bool readjustTiming = false;
 
       int n = std::min(mLast + 1, CaloSamples::MAXSAMPLES) - mFirst;
 
       hbhePileupCorr_->apply(digi.id(), inputCharge, nRead,
             mBunchCrossingInfo, mLengthBunchCrossingInfo, mFirst, n,
             CorrectedEnergy, CaloSamples::MAXSAMPLES,
             &pulseShapeCorrApplied, &leakCorrApplied,
             &readjustTiming);
 
       for(int i = mFirst; i <= mLast; i++)
       {
          bool decision = checkPassFilter(ChargeInWindow, CorrectedEnergy[i], mCut, -1);
          if(decision == false)
             hbhe.setFlagField(1, HcalCaloFlagLabels::HBHENegativeNoise);
       }
    }
 }