#include <HcalNoiseMonitor.h>

Inheritance diagram for HcalNoiseMonitor:

Public Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &s)

void	beginRun (const edm::Run &run, const edm::EventSetup &c)

void	cleanup ()

	HcalNoiseMonitor (const edm::ParameterSet &ps)

void	reset ()

void	setup ()

void	unpack (const FEDRawData &raw, const HcalElectronicsMap &emap)

	~HcalNoiseMonitor ()

Public Member Functions inherited from HcalBaseDQMonitor
	HcalBaseDQMonitor (const edm::ParameterSet &ps)

	HcalBaseDQMonitor ()

virtual	~HcalBaseDQMonitor ()

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
double	CalculateRMS8Max (double Charge[10])

double	DualNominalFitSingleTry (double Charge[10], int Offset, int Distance)

double	PerformDualNominalFit (double Charge[10])

double	PerformLinearFit (double Charge[10])

double	PerformNominalFit (double Charge[10])

TriangleFitResult	PerformTriangleFit (double Charge[10])

void	ReadHcalPulse ()

Private Attributes
std::vector< double >	CumulativeIdealPulse

MonitorElement *	hBadCountHPD

MonitorElement *	hBadE2E10RBX

MonitorElement *	hBadNoOtherCountHPD

MonitorElement *	hBadZeroRBX

MonitorElement *	hE2OverE10Digi

MonitorElement *	hE2OverE10Digi5

MonitorElement *	hE2OverE10RBX

EtaPhiHists	hFailIsolationEtaPhi

EtaPhiHists	hFailLinearEtaPhi

EtaPhiHists	hFailRMSMaxEtaPhi

EtaPhiHists	hFailTriangleEtaPhi

MonitorElement *	hHcalNoiseCategory

MonitorElement *	hHPDHitCount

MonitorElement *	hLambdaLinearVsTotalCharge

MonitorElement *	hLambdaRMS8MaxVsTotalCharge

MonitorElement *	hLinearChi2

MonitorElement *	hLinearTestStatistics

edm::InputTag	hltresultsLabel_

MonitorElement *	hMaxZeros

MonitorElement *	hNominalChi2

MonitorElement *	hRBXHitCount

MonitorElement *	hRMS8OverMax

MonitorElement *	hRMS8OverMaxTestStatistics

MonitorElement *	hTotalZeros

MonitorElement *	hTriangleLeftSlopeVsTS4

MonitorElement *	hTriangleRightSlopeVsTS4

MonitorElement *	hTS4TS5RelativeDifference

MonitorElement *	hTS4TS5RelativeDifferenceVsCharge

double	mE2E10MinEnergy

int	mMaxADCZeros

double	mMaxE2E10

int	mMaxHPDHitCount

int	mMaxHPDNoOtherHitCount

double	mMinE2E10

double	mTotalZeroMinEnergy

int	mTrianglePeakTS

int	period_

edm::InputTag	rawdataLabel_

bool	setupDone_

edm::EDGetTokenT < HBHEDigiCollection >	tok_hbhe_

edm::EDGetTokenT < HBHERecHitCollection >	tok_hbherec_

edm::EDGetTokenT < reco::HcalNoiseRBXCollection >	tok_noise_

std::vector< std::string >	triggers_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from HcalBaseDQMonitor
virtual void	beginJob ()

virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)

virtual void	endJob (void)

virtual void	endLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)

virtual void	endRun (const edm::Run &run, const edm::EventSetup &c)

void	getLogicalMap (const edm::EventSetup &c)

bool	IsAllowedCalibType ()

bool	LumiInOrder (int lumisec)

void	SetupEtaPhiHists (EtaPhiHists &hh, std::string Name, std::string Units)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes inherited from HcalBaseDQMonitor
std::vector< int >	AllowedCalibTypes_

int	badChannelStatusMask_

int	currentLS

int	currenttype_

DQMStore *	dbe_

int	debug_

bool	enableCleanup_

bool	eventAllowed_

bool	HBpresent_

bool	HEpresent_

bool	HFpresent_

bool	HOpresent_

int	ievt_

std::map< unsigned int, int >	KnownBadCells_

int	levt_

HcalLogicalMap *	logicalMap_

bool	makeDiagnostics_

MonitorElement *	meIevt_

MonitorElement *	meLevt_

bool	mergeRuns_

MonitorElement *	meTevt_

MonitorElement *	meTevtHist_

bool	needLogicalMap_

int	NLumiBlocks_

bool	Online_

std::string	prefixME_

MonitorElement *	ProblemsCurrentLB

MonitorElement *	ProblemsVsLB

MonitorElement *	ProblemsVsLB_HB

MonitorElement *	ProblemsVsLB_HBHEHF

MonitorElement *	ProblemsVsLB_HE

MonitorElement *	ProblemsVsLB_HF

MonitorElement *	ProblemsVsLB_HO

bool	skipOutOfOrderLS_

std::string	subdir_

int	tevt_

Detailed Description

Definition at line 16 of file HcalNoiseMonitor.h.

Constructor & Destructor Documentation

HcalNoiseMonitor::HcalNoiseMonitor ( const edm::ParameterSet & ps )

Definition at line 25 of file HcalNoiseMonitor.cc.

 {
    Online_                = ps.getUntrackedParameter<bool>("online",false);
    mergeRuns_             = ps.getUntrackedParameter<bool>("mergeRuns",false);
    enableCleanup_         = ps.getUntrackedParameter<bool>("enableCleanup",false);
    debug_                 = ps.getUntrackedParameter<int>("debug",0);
    prefixME_              = ps.getUntrackedParameter<std::string>("subSystemFolder","Hcal/");
    if(prefixME_.substr(prefixME_.size()-1,prefixME_.size())!="/")
       prefixME_.append("/");
    subdir_                = ps.getUntrackedParameter<std::string>("TaskFolder","NoiseMonitor_Hcal");
    if(subdir_.size()>0 && subdir_.substr(subdir_.size()-1,subdir_.size())!="/")
       subdir_.append("/");
    subdir_=prefixME_+subdir_;
    AllowedCalibTypes_     = ps.getUntrackedParameter<std::vector<int> > ("AllowedCalibTypes");
    skipOutOfOrderLS_      = ps.getUntrackedParameter<bool>("skipOutOfOrderLS",false);
    NLumiBlocks_           = ps.getUntrackedParameter<int>("NLumiBlocks",4000);
    makeDiagnostics_       = ps.getUntrackedParameter<bool>("makeDiagnostics",false);
 
    triggers_=ps.getUntrackedParameter<std::vector<std::string> >("nzsHLTnames");
       //["HLT_HcalPhiSym","HLT_HcalNoise_8E29]
    period_=ps.getUntrackedParameter<int>("NoiseeventPeriod",4096); //4096
    rawdataLabel_          = ps.getUntrackedParameter<edm::InputTag>("RawDataLabel");
    hltresultsLabel_       = ps.getUntrackedParameter<edm::InputTag>("HLTResultsLabel");
    tok_hbhe_ = consumes<HBHEDigiCollection>(ps.getUntrackedParameter<edm::InputTag>("hbheDigiLabel"));
    tok_hbherec_ = consumes<HBHERecHitCollection>(ps.getUntrackedParameter<edm::InputTag>("hbheRechitLabel"));
    tok_noise_  = consumes<reco::HcalNoiseRBXCollection>(ps.getUntrackedParameter<edm::InputTag>("noiseLabel"));
 
    mTrianglePeakTS        = 4;   // for now...
 
    mE2E10MinEnergy        = ps.getUntrackedParameter<double>("E2E10MinEnergy");
    mMinE2E10              = ps.getUntrackedParameter<double>("MinE2E10");
    mMaxE2E10              = ps.getUntrackedParameter<double>("MaxE2E10");
    mMaxHPDHitCount        = ps.getUntrackedParameter<int>("MaxHPDHitCount");
    mMaxHPDNoOtherHitCount = ps.getUntrackedParameter<int>("MaxHPDNoOtherHitCount");
    mMaxADCZeros           = ps.getUntrackedParameter<int>("MaxADCZeros");
    mTotalZeroMinEnergy    = ps.getUntrackedParameter<double>("TotalZeroMinEnergy");
    setupDone_ = false;
 }

HcalNoiseMonitor::~HcalNoiseMonitor ( )

Definition at line 64 of file HcalNoiseMonitor.cc.

64 {}

Member Function Documentation

void HcalNoiseMonitor::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	s
	)

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 208 of file HcalNoiseMonitor.cc.

References HcalCoderDb::adc2fC(), reco::HcalNoiseRBX::allChargeHighest2TS(), reco::HcalNoiseRBX::allChargeTotal(), HcalBaseDQMonitor::analyze(), reco::HcalNoiseHPD::big5ChargeHighest2TS(), reco::HcalNoiseHPD::big5ChargeTotal(), reco::HcalNoiseHPD::bigChargeHighest2TS(), reco::HcalNoiseHPD::bigChargeTotal(), CalculateRMS8Max(), gather_cfg::cout, HcalBaseDQMonitor::dbe_, HcalBaseDQMonitor::debug_, EtaPhiHists::depth, alignCSCRings::e, MonitorElement::Fill(), edm::EventSetup::get(), edm::Event::getByToken(), hBadCountHPD, hBadE2E10RBX, hBadNoOtherCountHPD, hBadZeroRBX, HcalCaloFlagLabels::HBHEFlatNoise, HcalCaloFlagLabels::HBHEIsolatedNoise, HcalCaloFlagLabels::HBHESpikeNoise, HcalCaloFlagLabels::HBHETriangleNoise, hE2OverE10Digi, hE2OverE10Digi5, hE2OverE10RBX, hFailIsolationEtaPhi, hFailLinearEtaPhi, hFailRMSMaxEtaPhi, hFailTriangleEtaPhi, hHcalNoiseCategory, hHPDHitCount, hLambdaLinearVsTotalCharge, hLambdaRMS8MaxVsTotalCharge, hLinearChi2, hLinearTestStatistics, hMaxZeros, hNominalChi2, reco::HcalNoiseRBX::HPDs(), hRBXHitCount, hRMS8OverMax, hRMS8OverMaxTestStatistics, hTotalZeros, hTriangleLeftSlopeVsTS4, hTriangleRightSlopeVsTS4, hTS4TS5RelativeDifference, hTS4TS5RelativeDifferenceVsCharge, i, reco::HcalNoiseRBX::idnumber(), reco::HcalNoiseHPD::idnumber(), getDQMSummary::iter, TriangleFitResult::LeftSlope, fff_deleter::log, reco::HcalNoiseRBX::maxZeros(), mE2E10MinEnergy, mMaxADCZeros, mMaxE2E10, mMaxHPDHitCount, mMaxHPDNoOtherHitCount, mMinE2E10, mTotalZeroMinEnergy, NULL, reco::HcalNoiseRBX::numRecHits(), reco::HcalNoiseHPD::numRecHits(), HcalCalibrations::pedestal(), PerformLinearFit(), PerformNominalFit(), PerformTriangleFit(), reco::HcalNoiseRBX::recHitEnergy(), reco::HcalNoiseHPD::recHitEnergy(), TriangleFitResult::RightSlope, tok_hbhe_, tok_hbherec_, tok_noise_, and reco::HcalNoiseRBX::totalZeros().

 {
    edm::Handle<HBHEDigiCollection> hHBHEDigis;
    iEvent.getByToken(tok_hbhe_,hHBHEDigis);
 
    edm::ESHandle<HcalDbService> hConditions;
    iSetup.get<HcalDbRecord>().get(hConditions);
 
    edm::Handle<HBHERecHitCollection> hRecHits;
    iEvent.getByToken(tok_hbherec_, hRecHits);
 
    edm::Handle<reco::HcalNoiseRBXCollection> hRBXCollection;
    iEvent.getByToken(tok_noise_,hRBXCollection);
 
    HcalBaseDQMonitor::analyze(iEvent, iSetup);
 
    if(dbe_ == NULL)
    {
       if(debug_ > 0)
          std::cout << "HcalNoiseMonitor::processEvent DQMStore not instantiated!!!"<< std::endl;
       return;
    }
 
    // loop over digis
    for(HBHEDigiCollection::const_iterator iter = hHBHEDigis->begin(); iter != hHBHEDigis->end(); iter++)
    {
       HcalDetId id = iter->id();
       const HcalCalibrations &Calibrations = hConditions->getHcalCalibrations(id);
       const HcalQIECoder *ChannelCoder = hConditions->getHcalCoder(id);
       const HcalQIEShape *Shape = hConditions->getHcalShape(ChannelCoder);
       HcalCoderDb Coder(*ChannelCoder, *Shape);
       CaloSamples Tool;
       Coder.adc2fC(*iter, Tool);
 
       // int ieta = id.ieta();
       // int iphi = id.iphi();
       // int depth = id.depth();
 
       double Charge[10] = {0};
       for(int i = 0; i < iter->size(); i++)
          Charge[i] = Tool[i] - Calibrations.pedestal(iter->sample(i).capid());
 
       double TotalCharge = 0;
       for(int i = 0; i < 10; i++)
          TotalCharge = TotalCharge + Charge[i];
 
       if(TotalCharge > 20)
       {
          double NominalChi2 = 10000000;
          NominalChi2 = PerformNominalFit(Charge);
          
          double LinearChi2 = PerformLinearFit(Charge);
          double RMS8Max = CalculateRMS8Max(Charge);
          TriangleFitResult TriangleResult = PerformTriangleFit(Charge);
       
          double TS4LeftSlope = 100000;
          double TS4RightSlope = 100000;
          
          if(TriangleResult.LeftSlope > 1e-5)
             TS4LeftSlope = Charge[4] / fabs(TriangleResult.LeftSlope);
          if(TriangleResult.RightSlope < -1e-5)
             TS4RightSlope = Charge[4] / fabs(TriangleResult.RightSlope);
 
          if(TS4LeftSlope < -1000 || TS4LeftSlope > 1000)
             TS4LeftSlope = 1000;
          if(TS4RightSlope < -1000 || TS4RightSlope > 1000)
             TS4RightSlope = 1000;
 
          hNominalChi2->Fill(NominalChi2);
          hLinearChi2->Fill(LinearChi2);
          hLinearTestStatistics->Fill(log(LinearChi2) - log(NominalChi2));
          hRMS8OverMax->Fill(RMS8Max);
          hRMS8OverMaxTestStatistics->Fill(log(RMS8Max) - log(NominalChi2));
 
          hLambdaLinearVsTotalCharge->Fill(log(LinearChi2) - log(NominalChi2), TotalCharge);
          hLambdaRMS8MaxVsTotalCharge->Fill(log(RMS8Max) - log(NominalChi2), TotalCharge);
          hTriangleLeftSlopeVsTS4->Fill(TS4LeftSlope, Charge[4]);
          hTriangleRightSlopeVsTS4->Fill(TS4RightSlope, Charge[4]);
       }
 
       if(Charge[4] + Charge[5] > 1e-5)
       {
          hTS4TS5RelativeDifference->Fill((Charge[4] - Charge[5]) / (Charge[4] + Charge[5]));
          hTS4TS5RelativeDifferenceVsCharge->Fill(TotalCharge, (Charge[4] - Charge[5]) / (Charge[4] + Charge[5]));
       }
    }
 
    // loop over rechits - noise bits (fit-based, isolation)
    for(HBHERecHitCollection::const_iterator iter = hRecHits->begin(); iter != hRecHits->end(); iter++)
    {
       HcalDetId id = iter->id();
 
       int ieta = id.ieta();
       int iphi = id.iphi();
       int depth = id.depth();
 
       if(iter->flagField(HcalCaloFlagLabels::HBHEFlatNoise) == 1)
          hFailLinearEtaPhi.depth[depth-1]->Fill(ieta, iphi);
 
       if(iter->flagField(HcalCaloFlagLabels::HBHESpikeNoise) == 1)
          hFailRMSMaxEtaPhi.depth[depth-1]->Fill(ieta, iphi);
       
       if(iter->flagField(HcalCaloFlagLabels::HBHETriangleNoise) == 1)
          hFailTriangleEtaPhi.depth[depth-1]->Fill(ieta, iphi);
 
       if(iter->flagField(HcalCaloFlagLabels::HBHEIsolatedNoise) == 1)
          hFailIsolationEtaPhi.depth[depth-1]->Fill(ieta, iphi);
    }
 
    // Code analagous to Yifei's
    for(reco::HcalNoiseRBXCollection::const_iterator rbx = hRBXCollection->begin();
       rbx != hRBXCollection->end(); rbx++)
    {
       const reco::HcalNoiseRBX RBX = *rbx;
 
       int NumberRBXHits = RBX.numRecHits(1.5);
       double RBXEnergy = RBX.recHitEnergy(1.5);
       double RBXE2 = RBX.allChargeHighest2TS();
       double RBXE10 = RBX.allChargeTotal();
 
       std::vector<reco::HcalNoiseHPD> HPDs = RBX.HPDs();
       
       int RBXID = RBX.idnumber();
 
       if(RBXEnergy > mTotalZeroMinEnergy && RBX.totalZeros() >= mMaxADCZeros)
          hBadZeroRBX->Fill(RBXID);
       if(RBXEnergy > mE2E10MinEnergy && RBXE10 > 1e-5 && (RBXE2 / RBXE10 > mMaxE2E10 || RBXE2 / RBXE10 < mMinE2E10))
          hBadE2E10RBX->Fill(RBXID);
       for(std::vector<reco::HcalNoiseHPD>::const_iterator hpd = HPDs.begin(); hpd != HPDs.end(); hpd++)
       {
          reco::HcalNoiseHPD HPD = *hpd;
          int HPDHitCount = HPD.numRecHits(1.5);
          if(HPDHitCount >= mMaxHPDHitCount)
             hBadCountHPD->Fill(HPD.idnumber());
          if(HPDHitCount == NumberRBXHits && HPDHitCount >= mMaxHPDNoOtherHitCount)
             hBadNoOtherCountHPD->Fill(HPD.idnumber());
       }
       
       if(NumberRBXHits == 0 || RBXEnergy <= 10)
          continue;
 
       hRBXHitCount->Fill(NumberRBXHits);
 
       hMaxZeros->Fill(RBX.maxZeros());
       hTotalZeros->Fill(RBX.totalZeros());
    
       double HighestHPDEnergy = 0;
       int HighestHPDHits = 0;
 
       for(std::vector<reco::HcalNoiseHPD>::const_iterator hpd = HPDs.begin(); hpd != HPDs.end(); hpd++)
       {
          reco::HcalNoiseHPD HPD = *hpd;
 
          if(HPD.recHitEnergy(1.5) > HighestHPDEnergy)
          {
             HighestHPDEnergy = HPD.recHitEnergy(1.5);
             HighestHPDHits = HPD.numRecHits(1.5);
          }
 
          if(HPD.numRecHits(5) < 1)
             continue;
 
          if(HPD.bigChargeTotal() > 1e-5)
             hE2OverE10Digi->Fill(HPD.bigChargeHighest2TS() / HPD.bigChargeTotal());
          if(HPD.big5ChargeTotal() > 1e-5)
             hE2OverE10Digi5->Fill(HPD.big5ChargeHighest2TS() / HPD.big5ChargeTotal());
 
          hHPDHitCount->Fill(HPD.numRecHits(1.5));
       }
 
       int NoiseCategory = 0;
       bool IsRBXNoise = false;
       //      bool IsHPDNoise = false;
       //      bool IsHPDIonFeedback = false;
       //      bool IsHPDDischarge = false;
 
       if(RBXEnergy > 1e-5 && HighestHPDEnergy / RBXEnergy > 0.98)
       {
     //         IsHPDNoise = true;
 
          if(HighestHPDHits >= 9)
          {
        //            IsHPDDischarge = true;
             NoiseCategory = 7;
          }
          else
          {
        //            IsHPDIonFeedback = true;
             NoiseCategory = 8;
          }
       }
       else
       {
          IsRBXNoise = true;
          NoiseCategory = 1;
 
          if(RBXE10 > 1e-5)
          {
             if(RBXE2 / RBXE10 < 0.33)
                NoiseCategory = 2;
             else if(RBXE2 / RBXE10 < 0.8)
                NoiseCategory = 3;
             else if(RBXE2 / RBXE10 > 0.8 && NumberRBXHits > 10)
                NoiseCategory = 4;
             else if(RBXE2 / RBXE10 > 0.8 && NumberRBXHits < 10)  // [hic]
                NoiseCategory = 5;
          }
       }
 
       hHcalNoiseCategory->Fill(NoiseCategory);
 
       if(IsRBXNoise == true && RBXE10 > 1e-5)
          hE2OverE10RBX->Fill(RBXE2 / RBXE10);
    }
 
    return;
 }

void HcalNoiseMonitor::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 79 of file HcalNoiseMonitor.cc.

References HcalBaseDQMonitor::beginRun(), gather_cfg::cout, HcalBaseDQMonitor::debug_, HcalBaseDQMonitor::mergeRuns_, reset(), setup(), and HcalBaseDQMonitor::tevt_.

 {
    if(debug_ > 1)
       std::cout <<"HcalNoiseMonitor::beginRun"<< std::endl;
 
    HcalBaseDQMonitor::beginRun(run,c);
 
    if(tevt_ == 0)
       setup();
 
    if(mergeRuns_ == false)
       reset();
 
    return;
 }

double HcalNoiseMonitor::CalculateRMS8Max ( double Charge[10] )

private

Definition at line 688 of file HcalNoiseMonitor.cc.

References alignCSCRings::e, i, RMS, python.multivaluedict::sort(), and mathSSE::sqrt().

Referenced by analyze().

 {
    //
    // CalculateRMS8Max
    //
    // returns "RMS" divided by the largest charge in the time slices
    //    "RMS" is calculated using all but the two largest time slices.
    //    The "RMS" is not quite the actual RMS (see note below), but the value is only
    //    used for determining max values, and is not quoted as the actual RMS anywhere.
    //
 
    int DigiSize = 10;
 
    // Copy Charge vector again, since we are passing references around
    std::vector<double> TempCharge(Charge, Charge + 10);
 
    // Sort TempCharge vector from smallest to largest charge
    sort(TempCharge.begin(), TempCharge.end());
 
    double Total = 0;
    double Total2 = 0;
    for(int i = 0; i < DigiSize - 2; i++)
    {
       Total = Total + TempCharge[i];
       Total2 = Total2 + TempCharge[i] * TempCharge[i];
    }
 
    // This isn't quite the RMS (both Total2 and Total*Total need to be
    // divided by an extra (DigiSize-2) within the sqrt to get the RMS.)
    // We're only using this value for relative comparisons, though; we
    // aren't explicitly interpreting it as the RMS.  It might be nice
    // to either change the calculation or rename the variable in the future, though.
 
    double RMS = sqrt(Total2 - Total * Total / (DigiSize - 2));
 
    double RMS8Max = 99999;
    if(TempCharge[DigiSize-1] > 1e-5)
       RMS8Max = RMS / TempCharge[DigiSize-1];
    if(RMS8Max < 1e-5)   // protection against zero
       RMS8Max = 1e-5;
 
    return RMS8Max;
 }

void HcalNoiseMonitor::cleanup ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 70 of file HcalNoiseMonitor.cc.

References HcalBaseDQMonitor::dbe_, DQMStore::removeContents(), DQMStore::setCurrentFolder(), and HcalBaseDQMonitor::subdir_.

 {
    if(dbe_)
    {
       dbe_->setCurrentFolder(subdir_);
       dbe_->removeContents();
    }
 }

double HcalNoiseMonitor::DualNominalFitSingleTry	(	double	Charge[10],
		int	Offset,
		int	Distance
	)

private

Definition at line 540 of file HcalNoiseMonitor.cc.

References CumulativeIdealPulse, alignCSCRings::e, and j.

Referenced by PerformDualNominalFit().

 {
    //
    // Does a fit to dual signal pulse hypothesis given offset and distance of the two target pulses
    //
    // The only parameters to fit here are the two pulse heights of in-time and out-of-time components
    //    since offset is given
    // The calculation here is based from writing down the Chi2 formula and minimize against the two parameters,
    //    ie., Chi2 = Sum{((T[i] - a1 * F1[i] - a2 * F2[i]) / (Sigma[i]))^2}, where T[i] is the input pulse shape,
    //    and F1[i], F2[i] are the two ideal pulse components
    //
 
    int DigiSize = 10;
 
    if(Offset < 0 || Offset + 250 >= (int)CumulativeIdealPulse.size())
       return 1000000;
    if(CumulativeIdealPulse[Offset+250] - CumulativeIdealPulse[Offset] < 1e-5)
       return 1000000;
 
    static std::vector<double> F1;
    static std::vector<double> F2;
 
    F1.resize(DigiSize);
    F2.resize(DigiSize);
 
    double SumF1F1 = 0;
    double SumF1F2 = 0;
    double SumF2F2 = 0;
    double SumTF1 = 0;
    double SumTF2 = 0;
 
    double Error = 0;
 
    for(int j = 0; j < DigiSize; j++)
    {
       // this is the TS value for in-time component - no problem we can do a subtraction directly
       F1[j] = CumulativeIdealPulse[Offset+j*25+25] - CumulativeIdealPulse[Offset+j*25];
 
       // However for the out-of-time component the index might go out-of-bound.
       // Let's protect against this.
 
       int OffsetTemp = Offset + j * 25 + Distance;
       
       double C1 = 0;   // lower-indexed value in the cumulative pulse shape
       double C2 = 0;   // higher-indexed value in the cumulative pulse shape
       
       if(OffsetTemp + 25 < (int)CumulativeIdealPulse.size() && OffsetTemp + 25 >= 0)
          C1 = CumulativeIdealPulse[OffsetTemp+25];
       if(OffsetTemp + 25 >= (int)CumulativeIdealPulse.size())
          C1 = CumulativeIdealPulse[CumulativeIdealPulse.size()-1];
       if(OffsetTemp < (int)CumulativeIdealPulse.size() && OffsetTemp >= 0)
          C2 = CumulativeIdealPulse[OffsetTemp];
       if(OffsetTemp >= (int)CumulativeIdealPulse.size())
          C2 = CumulativeIdealPulse[CumulativeIdealPulse.size()-1];
       F2[j] = C1 - C2;
 
       Error = Charge[j];
       if(Error < 1)
          Error = 1;
 
       SumF1F1 += F1[j] * F1[j] / Error;
       SumF1F2 += F1[j] * F2[j] / Error; 
       SumF2F2 += F2[j] * F2[j] / Error;
       SumTF1  += F1[j] * Charge[j] / Error; 
       SumTF2  += F2[j] * Charge[j] / Error; 
    }
 
    double Height = (SumF1F2 * SumTF2 - SumF2F2 * SumTF1) / (SumF1F2 * SumF1F2 - SumF1F1 * SumF2F2);
    double Height2 = (SumF1F2 * SumTF1 - SumF1F1 * SumTF2) / (SumF1F2 * SumF1F2 - SumF1F1 * SumF2F2);
 
    double Chi2 = 0;
    for(int j = 0; j < DigiSize; j++)
    {
       double Error = Charge[j];
       if(Error < 1)
          Error = 1;
 
       double Residual = Height * F1[j] + Height2 * F2[j] - Charge[j];  
       Chi2 += Residual * Residual / Error;                             
    } 
 
    // Safety protection in case of zero
    if(Chi2 < 1e-5)
       Chi2 = 1e-5;
 
    return Chi2;
 }

double HcalNoiseMonitor::PerformDualNominalFit ( double Charge[10] )

private

Definition at line 492 of file HcalNoiseMonitor.cc.

References CumulativeIdealPulse, DualNominalFitSingleTry(), i, and gen::k.

 {
    //
    // Perform dual nominal fit and returns the chi2
    //
    // In this function we do a scan over possible "distance" (number of time slices between two components)
    //    and overall offset for the two components; first coarse, then finer
    // All the fitting is done in the DualNominalFitSingleTry function
    //                  
    
    double OverallMinimumChi2 = 1000000;
 
    int AvailableDistance[] = {-100, -75, -50, 50, 75, 100};
 
    // loop over possible pulse distances between two components
    for(int k = 0; k < 6; k++)
    {
       double SingleMinimumChi2 = 1000000;
       int MinOffset = 0;
 
       // scan coarsely through different offsets and find the minimum
       for(int i = 0; i + 250 < (int)CumulativeIdealPulse.size(); i += 10)
       {
          double Chi2 = DualNominalFitSingleTry(Charge, i, AvailableDistance[k]);
 
          if(Chi2 < SingleMinimumChi2)
          {
             SingleMinimumChi2 = Chi2;
             MinOffset = i;
          }
       }
 
       // around the minimum, scan finer for better a better minimum
       for(int i = MinOffset - 15; i + 250 < (int)CumulativeIdealPulse.size() && i < MinOffset + 15; i++)
       {
          double Chi2 = DualNominalFitSingleTry(Charge, i, AvailableDistance[k]);
          if(Chi2 < SingleMinimumChi2)
             SingleMinimumChi2 = Chi2;
       }
 
       // update overall minimum chi2
       if(SingleMinimumChi2 < OverallMinimumChi2)
          OverallMinimumChi2 = SingleMinimumChi2;
    }
 
    return OverallMinimumChi2;
 }

double HcalNoiseMonitor::PerformLinearFit ( double Charge[10] )

private

Definition at line 628 of file HcalNoiseMonitor.cc.

References alignCSCRings::e, and i.

Referenced by analyze().

 {
    //
    // Performs a straight-line fit over all time slices, and returns the chi2 value
    //
    // The calculation here is based from writing down the formula for chi2 and minimize
    //    with respect to the parameters in the fit, ie., slope and intercept of the straight line
    // By doing two differentiation, we will get two equations, and the best parameters are determined by these
    //
 
    int DigiSize = 10;
 
    double SumTS2OverTi = 0;
    double SumTSOverTi = 0;
    double SumOverTi = 0;
    double SumTiTS = 0;
    double SumTi = 0;
 
    double Error2 = 0;
    for(int i = 0; i < DigiSize; i++)
    {
       Error2 = Charge[i];
       if(Charge[i] < 1)
          Error2 = 1;
 
       SumTS2OverTi += 1.* i * i / Error2;
       SumTSOverTi  += 1.* i / Error2;
       SumOverTi    += 1. / Error2;
       SumTiTS      += Charge[i] * i / Error2;
       SumTi        += Charge[i] / Error2;
    }
 
    double CM1 = SumTS2OverTi;   // Coefficient in front of slope in equation 1
    double CM2 = SumTSOverTi;   // Coefficient in front of slope in equation 2
    double CD1 = SumTSOverTi;   // Coefficient in front of intercept in equation 1
    double CD2 = SumOverTi;   // Coefficient in front of intercept in equation 2
    double C1 = SumTiTS;   // Constant coefficient in equation 1
    double C2 = SumTi;   // Constant coefficient in equation 2
 
    double Slope = (C1 * CD2 - C2 * CD1) / (CM1 * CD2 - CM2 * CD1);
    double Intercept = (C1 * CM2 - C2 * CM1) / (CD1 * CM2 - CD2 * CM1);
 
    // now that the best parameters are found, calculate chi2 from those
    double Chi2 = 0;
    for(int i = 0; i < DigiSize; i++)
    {
       double Deviation = Slope * i + Intercept - Charge[i];
       double Error2 = Charge[i];
       if(Charge[i] < 1)
          Error2 = 1;
       Chi2 += Deviation * Deviation / Error2;  
    }
 
    // safety protection in case of perfect fit
    if(Chi2 < 1e-5)
       Chi2 = 1e-5;
 
    return Chi2;
 }

double HcalNoiseMonitor::PerformNominalFit ( double Charge[10] )

private

Definition at line 426 of file HcalNoiseMonitor.cc.

References CumulativeIdealPulse, alignCSCRings::e, F(), i, and j.

Referenced by analyze().

 {
    //
    // Performs a fit to the ideal pulse shape.  Returns best chi2
    //
    // A scan over different timing offset (for the ideal pulse) is carried out,
    //    and for each offset setting a one-parameter fit is performed
    //
 
    int DigiSize = 10;
 
    double MinimumChi2 = 100000;
 
    double F = 0;
 
    double SumF2 = 0;
    double SumTF = 0;
    double SumT2 = 0;
 
    for(int i = 0; i + 250 < (int)CumulativeIdealPulse.size(); i++)
    {
       if(CumulativeIdealPulse[i+250] - CumulativeIdealPulse[i] < 1e-5)
          continue;
 
       SumF2 = 0;
       SumTF = 0;
       SumT2 = 0;
 
       for(int j = 0; j < DigiSize; j++)
       {
          // get ideal pulse component for this time slice....
          F = CumulativeIdealPulse[i+j*25+25] - CumulativeIdealPulse[i+j*25];
 
          double Error2 = Charge[j];
          if(Error2 < 1)
             Error2 = 1;
 
          // ...and increment various summations
          SumF2 += F * F / Error2;
          SumTF += F * Charge[j] / Error2;
          SumT2 += Charge[j] * Charge[j] / Error2;
       }
 
       /* chi2= sum((Charge[j]-aF)^2/|Charge[j]|
          ( |Charge[j]| = assumed sigma^2 for Charge[j]; a bit wonky for Charge[j]<1 )
          chi2 = sum(|Charge[j]|) - 2*sum(aF*Charge[j]/|Charge[j]|) +sum( a^2*F^2/|Charge[j]|)
          chi2 minimimized when d(chi2)/da = 0:
          a = sum(F*Charge[j])/sum(F^2)
          ...
          chi2= sum(|Q[j]|) - sum(Q[j]/|Q[j]|*F)*sum(Q[j]/|Q[j]|*F)/sum(F^2/|Q[j]|), where Q = Charge
          chi2 = SumT2 - SumTF*SumTF/SumF2
       */
       
       double Chi2 = SumT2 - SumTF * SumTF / SumF2;
 
       if(Chi2 < MinimumChi2)
          MinimumChi2 = Chi2;
    }
 
    // safety protection in case of perfect fit - don't want the log(...) to explode
    if(MinimumChi2 < 1e-5)
       MinimumChi2 = 1e-5;
 
    return MinimumChi2;
 }

TriangleFitResult HcalNoiseMonitor::PerformTriangleFit ( double Charge[10] )

private

Definition at line 732 of file HcalNoiseMonitor.cc.

References TriangleFitResult::Chi2, i, TriangleFitResult::LeftSlope, mTrianglePeakTS, query::result, and TriangleFitResult::RightSlope.

Referenced by analyze().

 {
    //
    // Perform a "triangle fit", and extract the slopes
    //
    // Left-hand side and right-hand side are not correlated to each other - do them separately
    //
 
    TriangleFitResult result;
    result.Chi2 = 0;
    result.LeftSlope = 0;
    result.RightSlope = 0;
 
    int DigiSize = 10;
 
    // right side, starting from TS4
    double MinimumRightChi2 = 1000000;
    double Numerator = 0;
    double Denominator = 0;
 
    for(int iTS = mTrianglePeakTS + 2; iTS <= DigiSize; iTS++)   // the place where first TS center in flat line
    {
       // fit a straight line to the triangle part
       Numerator = 0;
       Denominator = 0;
 
       for(int i = mTrianglePeakTS + 1; i < iTS; i++)
       {
          Numerator += (i - mTrianglePeakTS) * (Charge[i] - Charge[mTrianglePeakTS]);
          Denominator += (i - mTrianglePeakTS) * (i - mTrianglePeakTS);
       }
 
       double BestSlope = Numerator / Denominator;
       if(BestSlope > 0)
          BestSlope = 0;
 
       // check if the slope is reasonable
       if(iTS != DigiSize)
       {
          if(BestSlope > -1 * Charge[mTrianglePeakTS] / (iTS - mTrianglePeakTS))
             BestSlope = -1 * Charge[mTrianglePeakTS] / (iTS - mTrianglePeakTS);
          if(BestSlope < -1 * Charge[mTrianglePeakTS] / (iTS - 1 - mTrianglePeakTS))
             BestSlope = -1 * Charge[mTrianglePeakTS] / (iTS - 1 - mTrianglePeakTS);
       }
       else
       {
          if(BestSlope < -1 * Charge[mTrianglePeakTS] / (iTS - 1 - mTrianglePeakTS)) 
             BestSlope = -1 * Charge[mTrianglePeakTS] / (iTS - 1 - mTrianglePeakTS);
       }
 
       // calculate partial chi2
 
       // The shape I'm fitting is more like a tent than a triangle.
       // After the end of triangle edge assume a flat line
 
       double Chi2 = 0;
       for(int i = mTrianglePeakTS + 1; i < iTS; i++)
          Chi2 += (Charge[mTrianglePeakTS] - Charge[i] + (i - mTrianglePeakTS) * BestSlope)
             * (Charge[mTrianglePeakTS] - Charge[i] + (i - mTrianglePeakTS) * BestSlope);
       for(int i = iTS; i < DigiSize; i++)    // Assumes fit line = 0 for iTS > fit
          Chi2 += Charge[i] * Charge[i];
 
       if(Chi2 < MinimumRightChi2)
       {
          MinimumRightChi2 = Chi2;
          result.RightSlope = BestSlope;
       }
    }   // end of right-hand side loop
 
    // left side
    double MinimumLeftChi2 = 1000000;
 
    for(int iTS = 0; iTS < (int)mTrianglePeakTS; iTS++)   // the first time after linear fit ends
    {
       // fit a straight line to the triangle part
       Numerator = 0;
       Denominator = 0;
       for(int i = iTS; i < (int)mTrianglePeakTS; i++)
       {
          Numerator = Numerator + (i - mTrianglePeakTS) * (Charge[i] - Charge[mTrianglePeakTS]);
          Denominator = Denominator + (i - mTrianglePeakTS) * (i - mTrianglePeakTS);
       }
 
       double BestSlope = Numerator / Denominator;
       if(BestSlope < 0)
          BestSlope = 0;
 
       // check slope
       if(iTS != 0)
       {
          if(BestSlope > Charge[mTrianglePeakTS] / (mTrianglePeakTS - iTS))
             BestSlope = Charge[mTrianglePeakTS] / (mTrianglePeakTS - iTS);
          if(BestSlope < Charge[mTrianglePeakTS] / (mTrianglePeakTS + 1 - iTS))
             BestSlope = Charge[mTrianglePeakTS] / (mTrianglePeakTS + 1 - iTS);
       }
       else
       {
          if(BestSlope > Charge[mTrianglePeakTS] / (mTrianglePeakTS - iTS))
             BestSlope = Charge[mTrianglePeakTS] / (mTrianglePeakTS - iTS);
       }
 
       // calculate minimum chi2
       double Chi2 = 0;
       for(int i = 0; i < iTS; i++)
          Chi2 += Charge[i] * Charge[i];
       for(int i = iTS; i < (int)mTrianglePeakTS; i++)
          Chi2 += (Charge[mTrianglePeakTS] - Charge[i] + (i - mTrianglePeakTS) * BestSlope)
             * (Charge[mTrianglePeakTS] - Charge[i] + (i - mTrianglePeakTS) * BestSlope);
 
       if(MinimumLeftChi2 > Chi2)
       {
          MinimumLeftChi2 = Chi2;
          result.LeftSlope = BestSlope;
       }
    }   // end of left-hand side loop
 
    result.Chi2 = MinimumLeftChi2 + MinimumRightChi2;
 
    return result;
 }

void HcalNoiseMonitor::ReadHcalPulse ( )

private

Definition at line 853 of file HcalNoiseMonitor.cc.

References HcalPulseShape::at(), CumulativeIdealPulse, HcalPulseShapes::hbShape(), and i.

Referenced by setup().

 {
    std::vector<double> PulseShape;
 
    HcalPulseShapes Shapes;
    HcalPulseShapes::Shape HPDShape = Shapes.hbShape();
 
    PulseShape.reserve(350);
    for(int i = 0; i < 200; i++)
       PulseShape.push_back(HPDShape.at(i));
    PulseShape.insert(PulseShape.begin(), 150, 0);   // Safety margin of a lot of zeros in the beginning
 
    CumulativeIdealPulse.reserve(350);
    CumulativeIdealPulse.clear();
    CumulativeIdealPulse.push_back(0);
    for(unsigned int i = 1; i < PulseShape.size(); i++)
       CumulativeIdealPulse.push_back(CumulativeIdealPulse[i-1] + PulseShape[i]);
 }

void HcalNoiseMonitor::reset ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 66 of file HcalNoiseMonitor.cc.

Referenced by beginRun().

67 {

68 }

void HcalNoiseMonitor::setup ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 96 of file HcalNoiseMonitor.cc.

References DQMStore::book1D(), DQMStore::book2D(), gather_cfg::cout, HcalBaseDQMonitor::dbe_, HcalBaseDQMonitor::debug_, hBadCountHPD, hBadE2E10RBX, hBadNoOtherCountHPD, hBadZeroRBX, hE2OverE10Digi, hE2OverE10Digi5, hE2OverE10RBX, hFailIsolationEtaPhi, hFailLinearEtaPhi, hFailRMSMaxEtaPhi, hFailTriangleEtaPhi, hHcalNoiseCategory, hHPDHitCount, hLambdaLinearVsTotalCharge, hLambdaRMS8MaxVsTotalCharge, hLinearChi2, hLinearTestStatistics, hMaxZeros, hNominalChi2, hRBXHitCount, hRMS8OverMax, hRMS8OverMaxTestStatistics, hTotalZeros, hTriangleLeftSlopeVsTS4, hTriangleRightSlopeVsTS4, hTS4TS5RelativeDifference, hTS4TS5RelativeDifferenceVsCharge, ReadHcalPulse(), MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), DQMStore::setCurrentFolder(), HcalBaseDQMonitor::setup(), setupDone_, HcalBaseDQMonitor::SetupEtaPhiHists(), and HcalBaseDQMonitor::subdir_.

Referenced by beginRun().

 {
    if (setupDone_)
      return;
    setupDone_ = true;
    HcalBaseDQMonitor::setup();
 
    if(debug_ > 1)
       std::cout << "<HcalNoiseMonitor::setup> Creating histograms" << std::endl;
 
    if(dbe_)
    {
       dbe_->setCurrentFolder(subdir_);
 
       // Fit-based
       dbe_->setCurrentFolder(subdir_ + "DoubleChi2/");
 
       hNominalChi2 = dbe_->book1D("Nominal_fit_chi2", "Nominal fit chi2, total charge > 20 fC", 100, 0, 200);
       hNominalChi2->setAxisTitle("Nominal fit #chi^{2}", 1);
 
       hLinearChi2 = dbe_->book1D("Linear_fit_chi2", "Linear fit chi2, total charge > 20 fC", 100, 0, 200);
       hLinearChi2->setAxisTitle("Linear fit #chi^{2}", 1);
       
       hLinearTestStatistics = dbe_->book1D("Lambda_linear", "#Lambda_{linear}, total charge > 20 fC", 100, -10, 10);
       hLinearTestStatistics->setAxisTitle("#Lambda_{linear}", 1);
 
       hRMS8OverMax = dbe_->book1D("RMS8_over_Max", "RMS8/max, total charge > 20 fC", 100, 0, 2);
       hRMS8OverMax->setAxisTitle("RMS8/max", 1);
 
       hRMS8OverMaxTestStatistics = dbe_->book1D("Lambda_RMS8_over_max", "#Lambda_{RMS8/Max}, total charge > 20 fC",
          100, -30, 10);
       hRMS8OverMaxTestStatistics->setAxisTitle("#Lambda_{RMS8/Max}", 1);
 
       hLambdaLinearVsTotalCharge = dbe_->book2D("Lambda_linear_vs_total_charge", "#Lambda_{Linear}",
          50, -5, 5, 25, 0, 500);
       hLambdaLinearVsTotalCharge->setAxisTitle("#Lambda_{linear}", 1);
       hLambdaLinearVsTotalCharge->setAxisTitle("Total charge", 2);
 
       hLambdaRMS8MaxVsTotalCharge = dbe_->book2D("Lambda_RMS8Max_vs_total_charge", "#Lambda_{RMS8/Max}",
          50, -15, 5, 25, 0, 500);
       hLambdaRMS8MaxVsTotalCharge->setAxisTitle("#Lambda_{RMS8/Max}", 1);
       hLambdaRMS8MaxVsTotalCharge->setAxisTitle("Total charge", 2);
 
       hTriangleLeftSlopeVsTS4 = dbe_->book2D("Triangle_fit_left_slope",
          "Triangle fit left distance vs. TS4", 50, 0, 10, 25, 0, 500);
       hTriangleLeftSlopeVsTS4->setAxisTitle("Left slope", 1);
       hTriangleLeftSlopeVsTS4->setAxisTitle("Peak time slice", 2);
 
       hTriangleRightSlopeVsTS4 = dbe_->book2D("Triangle_fit_right_slope",
          "Triangle fit right distance vs. peak time slice", 50, 0, 10, 25, 0, 500);
       hTriangleRightSlopeVsTS4->setAxisTitle("Left slope", 1);
       hTriangleRightSlopeVsTS4->setAxisTitle("Peak time slice", 2);
 
       SetupEtaPhiHists(hFailLinearEtaPhi, "Fail_linear_Eta_Phi_Map", "");
       SetupEtaPhiHists(hFailRMSMaxEtaPhi, "Fail_RMS8Max_Eta_Phi_Map", "");
       SetupEtaPhiHists(hFailTriangleEtaPhi, "Fail_triangle_Eta_Phi_Map", "");
 
       // High-level isolation filter
       dbe_->setCurrentFolder(subdir_ + "IsolationVariable/");
 
       SetupEtaPhiHists(hFailIsolationEtaPhi, "Fail_isolation_Eta_Phi_Map", "");
       
       // TS4 vs. TS5 variable
       dbe_->setCurrentFolder(subdir_ + "TS4TS5Variable/");
       
       hTS4TS5RelativeDifference = dbe_->book1D("TS4_TS5_relative_difference",
          "(TS4-TS5)/(TS4+TS5), total charge > 20 fC", 100, -1, 1);
       hTS4TS5RelativeDifference->setAxisTitle("(TS4 - TS5) / (TS4 + TS5)", 1);
 
       hTS4TS5RelativeDifferenceVsCharge = dbe_->book2D("TS4_TS5_relative_difference_charge",
          "(TS4-TS5)/(TS4+TS5) vs. Charge", 25, 0, 400, 75, -1, 1);
       hTS4TS5RelativeDifferenceVsCharge->setAxisTitle("Charge", 1);
       hTS4TS5RelativeDifferenceVsCharge->setAxisTitle("(TS4 - TS5) / (TS4 + TS5)", 2);
 
       // Noise summary object
       dbe_->setCurrentFolder(subdir_ + "NoiseMonitoring/");
    
       hMaxZeros = dbe_->book1D("Max_Zeros", "Max zeros", 15, -0.5, 14.5);
       
       hTotalZeros = dbe_->book1D("Total_Zeros", "Total zeros", 15, -0.5, 14.5);
       
       hE2OverE10Digi = dbe_->book1D("E2OverE10Digi", "E2/E10 of the highest digi in an HPD", 100, 0, 2);
       
       hE2OverE10Digi5 = dbe_->book1D("E2OverE10Digi5", "E2/E10 of the highest 5 digi in an HPD", 100, 0, 2);
       
       hE2OverE10RBX = dbe_->book1D("E2OverE10RBX", "E2/E10 of RBX", 100, 0, 2);
       
       hHPDHitCount = dbe_->book1D("HPDHitCount", "HPD hit count (1.5 GeV)", 19, -0.5, 18.5);
       
       hRBXHitCount = dbe_->book1D("RBXHitCount", "Number of hits in RBX", 74, -0.5, 73.5);
 
       hHcalNoiseCategory = dbe_->book1D("Hcal_noise_category", "Hcal noise category", 10, 0.5, 10.5);
       hHcalNoiseCategory->setBinLabel(1, "RBX noise", 1);
       hHcalNoiseCategory->setBinLabel(2, "RBX pedestal flatter", 1);
       hHcalNoiseCategory->setBinLabel(3, "RBX pedestal sharper", 1);
       hHcalNoiseCategory->setBinLabel(4, "RBX flash large hit count", 1);
       hHcalNoiseCategory->setBinLabel(5, "RBX flash small hit count", 1);
       hHcalNoiseCategory->setBinLabel(7, "HPD discharge", 1);
       hHcalNoiseCategory->setBinLabel(8, "HPD ion feedback", 1);
 
       hBadZeroRBX = dbe_->book1D("BadZeroRBX", "RBX with bad ADC zero counts", 72, 0.5, 72.5);
       hBadCountHPD = dbe_->book1D("BadCountHPD", "HPD with bad hit counts", 72 * 4, 0.5, 72 * 4 + 0.5);
       hBadNoOtherCountHPD = dbe_->book1D("BadNoOtherCountHPD", "HPD with bad \"no other\" hit counts", 72 * 4, 0.5, 72 * 4 + 0.5);
       hBadE2E10RBX = dbe_->book1D("BadE2E10RBX", "RBX with bad E2/E10 value", 72, 0.5, 72.5);
    }
 
    ReadHcalPulse();
 
    return;
 }

void HcalNoiseMonitor::unpack	(	const FEDRawData &	raw,
		const HcalElectronicsMap &	emap
	)

Member Data Documentation

std::vector<double> HcalNoiseMonitor::CumulativeIdealPulse

private

Definition at line 93 of file HcalNoiseMonitor.h.

Referenced by DualNominalFitSingleTry(), PerformDualNominalFit(), PerformNominalFit(), and ReadHcalPulse().

MonitorElement* HcalNoiseMonitor::hBadCountHPD

private

Definition at line 89 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hBadE2E10RBX

private

Definition at line 91 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hBadNoOtherCountHPD

private

Definition at line 90 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hBadZeroRBX

private

Definition at line 88 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hE2OverE10Digi

private

Definition at line 81 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hE2OverE10Digi5

private

Definition at line 82 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hE2OverE10RBX

private

Definition at line 83 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

EtaPhiHists HcalNoiseMonitor::hFailIsolationEtaPhi

private

Definition at line 72 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

EtaPhiHists HcalNoiseMonitor::hFailLinearEtaPhi

private

Definition at line 67 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

EtaPhiHists HcalNoiseMonitor::hFailRMSMaxEtaPhi

private

Definition at line 68 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

EtaPhiHists HcalNoiseMonitor::hFailTriangleEtaPhi

private

Definition at line 69 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hHcalNoiseCategory

private

Definition at line 86 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hHPDHitCount

private

Definition at line 84 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hLambdaLinearVsTotalCharge

private

Definition at line 62 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hLambdaRMS8MaxVsTotalCharge

private

Definition at line 63 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hLinearChi2

private

Definition at line 57 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hLinearTestStatistics

private

Definition at line 58 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

edm::InputTag HcalNoiseMonitor::hltresultsLabel_

private

Definition at line 49 of file HcalNoiseMonitor.h.

Referenced by HcalNoiseMonitor().

MonitorElement* HcalNoiseMonitor::hMaxZeros

private

Definition at line 79 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hNominalChi2

private

Definition at line 56 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hRBXHitCount

private

Definition at line 85 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hRMS8OverMax

private

Definition at line 59 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hRMS8OverMaxTestStatistics

private

Definition at line 60 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hTotalZeros

private

Definition at line 80 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hTriangleLeftSlopeVsTS4

private

Definition at line 64 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hTriangleRightSlopeVsTS4

private

Definition at line 65 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hTS4TS5RelativeDifference

private

Definition at line 75 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

MonitorElement* HcalNoiseMonitor::hTS4TS5RelativeDifferenceVsCharge

private

Definition at line 76 of file HcalNoiseMonitor.h.

Referenced by analyze(), and setup().

double HcalNoiseMonitor::mE2E10MinEnergy

private

Definition at line 38 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

int HcalNoiseMonitor::mMaxADCZeros

private

Definition at line 43 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

double HcalNoiseMonitor::mMaxE2E10

private

Definition at line 40 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

int HcalNoiseMonitor::mMaxHPDHitCount

private

Definition at line 41 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

int HcalNoiseMonitor::mMaxHPDNoOtherHitCount

private

Definition at line 42 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

double HcalNoiseMonitor::mMinE2E10

private

Definition at line 39 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

double HcalNoiseMonitor::mTotalZeroMinEnergy

private

Definition at line 44 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

int HcalNoiseMonitor::mTrianglePeakTS

private

Definition at line 37 of file HcalNoiseMonitor.h.

Referenced by HcalNoiseMonitor(), and PerformTriangleFit().

int HcalNoiseMonitor::period_

private

Definition at line 33 of file HcalNoiseMonitor.h.

Referenced by HcalNoiseMonitor().

edm::InputTag HcalNoiseMonitor::rawdataLabel_

private

Definition at line 48 of file HcalNoiseMonitor.h.

Referenced by HcalNoiseMonitor().

bool HcalNoiseMonitor::setupDone_

private

Definition at line 34 of file HcalNoiseMonitor.h.

Referenced by HcalNoiseMonitor(), and setup().

edm::EDGetTokenT<HBHEDigiCollection> HcalNoiseMonitor::tok_hbhe_

private

Definition at line 51 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

edm::EDGetTokenT<HBHERecHitCollection> HcalNoiseMonitor::tok_hbherec_

private

Definition at line 52 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

edm::EDGetTokenT<reco::HcalNoiseRBXCollection> HcalNoiseMonitor::tok_noise_

private

Definition at line 53 of file HcalNoiseMonitor.h.

Referenced by analyze(), and HcalNoiseMonitor().

std::vector<std::string> HcalNoiseMonitor::triggers_

private

Definition at line 32 of file HcalNoiseMonitor.h.

Referenced by HcalNoiseMonitor().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation