#include <HcalNoiseRates.h>

Inheritance diagram for HcalNoiseRates:

Public Member Functions
	HcalNoiseRates (const edm::ParameterSet &)

	~HcalNoiseRates () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

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

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

Private Attributes
MonitorElement *	hLumiBlockCount_

MonitorElement *	hNoise_maxHPDHits_

MonitorElement *	hNoise_maxHPDNoOtherHits_

MonitorElement *	hNoise_maxZeros_

MonitorElement *	hRBXEnergy_

MonitorElement *	hRBXEnergyType1_

MonitorElement *	hRBXEnergyType2_

MonitorElement *	hRBXEnergyType3_

MonitorElement *	hRBXNHits_

MonitorElement *	iNNumChannels_

MonitorElement *	iNSumE_

MonitorElement *	iNSumEt_

std::map< int, int >	lumiCountMap_

double	minHitEnergy_

double	minRBXEnergy_

MonitorElement *	nNNumChannels_

MonitorElement *	nNSumE_

MonitorElement *	nNSumEt_

edm::EDGetTokenT < HcalNoiseSummary >	noisetoken_

std::string	outputFile_

edm::InputTag	rbxCollName_

MonitorElement *	sNNumChannels_

MonitorElement *	sNSumE_

MonitorElement *	sNSumEt_

edm::EDGetTokenT < reco::HcalNoiseRBXCollection >	tok_rbx_

bool	useAllHistos_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr < DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 42 of file HcalNoiseRates.h.

Constructor & Destructor Documentation

HcalNoiseRates::HcalNoiseRates ( const edm::ParameterSet & iConfig )

explicit

Definition at line 17 of file HcalNoiseRates.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), minHitEnergy_, minRBXEnergy_, noisetoken_, outputFile_, rbxCollName_, AlCaHLTBitMon_QueryRunRegistry::string, tok_rbx_, and useAllHistos_.

                                                              {
   // DQM ROOT output
   outputFile_ = iConfig.getUntrackedParameter<std::string>("outputFile", "myfile.root");
 
   // set parameters
   rbxCollName_ = iConfig.getUntrackedParameter<edm::InputTag>("rbxCollName");
   tok_rbx_ = consumes<reco::HcalNoiseRBXCollection>(rbxCollName_);
   minRBXEnergy_ = iConfig.getUntrackedParameter<double>("minRBXEnergy");
   minHitEnergy_ = iConfig.getUntrackedParameter<double>("minHitEnergy");
 
   useAllHistos_ = iConfig.getUntrackedParameter<bool>("useAllHistos", false);
 
   // Hcal Noise Summary
   noisetoken_ = consumes<HcalNoiseSummary>(iConfig.getParameter<edm::InputTag>("noiselabel"));
 }

HcalNoiseRates::~HcalNoiseRates ( )

override

Definition at line 96 of file HcalNoiseRates.cc.

96 {}

Member Function Documentation

void HcalNoiseRates::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	evSetup
	)

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 103 of file HcalNoiseRates.cc.

                                                                                  {
   // get the lumi section
   int lumiSection = iEvent.luminosityBlock();
   lumiCountMap_[lumiSection]++;
 
   // get the RBX Noise collection
   edm::Handle<reco::HcalNoiseRBXCollection> handle;
   iEvent.getByToken(tok_rbx_, handle);
   if (!handle.isValid()) {
     throw edm::Exception(edm::errors::ProductNotFound)
         << " could not find HcalNoiseRBXCollection named " << rbxCollName_ << ".\n";
     return;
   }
 
   // get the Noise summary object
   edm::Handle<HcalNoiseSummary> summary_h;
   iEvent.getByToken(noisetoken_, summary_h);
   if (!summary_h.isValid()) {
     throw edm::Exception(edm::errors::ProductNotFound) << " could not find HcalNoiseSummary.\n";
     return;
   }
   const HcalNoiseSummary summary = *summary_h;
 
   // Fill the Noise Summary histograms
   nNNumChannels_->Fill(summary.numNegativeNoiseChannels());
   nNSumE_->Fill(summary.NegativeNoiseSumE());
   nNSumEt_->Fill(summary.NegativeNoiseSumEt());
 
   sNNumChannels_->Fill(summary.numSpikeNoiseChannels());
   sNSumE_->Fill(summary.spikeNoiseSumE());
   sNSumEt_->Fill(summary.spikeNoiseSumEt());
 
   iNNumChannels_->Fill(summary.numIsolatedNoiseChannels());
   iNSumE_->Fill(summary.isolatedNoiseSumE());
   iNSumEt_->Fill(summary.isolatedNoiseSumEt());
 
   hNoise_maxZeros_->Fill(summary.maxZeros());
   hNoise_maxHPDHits_->Fill(summary.maxHPDHits());
   hNoise_maxHPDNoOtherHits_->Fill(summary.maxHPDNoOtherHits());
 
   // loop over the RBXs and fill the histograms
   for (reco::HcalNoiseRBXCollection::const_iterator it = handle->begin(); it != handle->end(); ++it) {
     const reco::HcalNoiseRBX &rbx = (*it);
 
     double energy = rbx.recHitEnergy(minHitEnergy_);
 
     int nhits = rbx.numRecHits(minHitEnergy_);
 
     if (energy < minRBXEnergy_)
       continue;
 
     hRBXEnergy_->Fill(energy);
 
     if (nhits <= 9)
       hRBXEnergyType1_->Fill(energy);
     else if (nhits <= 18)
       hRBXEnergyType2_->Fill(energy);
     else
       hRBXEnergyType3_->Fill(energy);
 
     hRBXNHits_->Fill(nhits);
 
   }  // done looping over RBXs
 }

void HcalNoiseRates::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 33 of file HcalNoiseRates.cc.

References dqm::implementation::IBooker::book1D(), timingPdfMaker::histo, hLumiBlockCount_, hNoise_maxHPDHits_, hNoise_maxHPDNoOtherHits_, hNoise_maxZeros_, hRBXEnergy_, hRBXEnergyType1_, hRBXEnergyType2_, hRBXEnergyType3_, hRBXNHits_, iNNumChannels_, iNSumE_, iNSumEt_, nNNumChannels_, nNSumE_, nNSumEt_, dqm::implementation::NavigatorBase::setCurrentFolder(), sNNumChannels_, sNSumE_, sNSumEt_, and useAllHistos_.

 {
   ibooker.setCurrentFolder("HcalNoiseRatesD/HcalNoiseRatesTask");
 
   Char_t histo[100];
 
   // book histograms
 
   // Lumi block is not drawn; the rest are
   if (useAllHistos_) {
     sprintf(histo, "hLumiBlockCount");
     hLumiBlockCount_ = ibooker.book1D(histo, histo, 1, -0.5, 0.5);
   }
 
   sprintf(histo, "hRBXEnergy");
   hRBXEnergy_ = ibooker.book1D(histo, histo, 300, 0, 3000);
 
   sprintf(histo, "hRBXEnergyType1");
   hRBXEnergyType1_ = ibooker.book1D(histo, histo, 300, 0, 3000);
 
   sprintf(histo, "hRBXEnergyType2");
   hRBXEnergyType2_ = ibooker.book1D(histo, histo, 300, 0, 3000);
 
   sprintf(histo, "hRBXEnergyType3");
   hRBXEnergyType3_ = ibooker.book1D(histo, histo, 300, 0, 3000);
 
   sprintf(histo, "hRBXNHits");
   hRBXNHits_ = ibooker.book1D(histo, histo, 73, -0.5, 72.5);
 
   // HcalNoiseSummary
 
   sprintf(histo, "nNNumChannels");
   nNNumChannels_ = ibooker.book1D(histo, histo, 100, 0, 100);
   sprintf(histo, "nNSumE");
   nNSumE_ = ibooker.book1D(histo, histo, 100, 0, 5000);
   sprintf(histo, "nNSumEt");
   nNSumEt_ = ibooker.book1D(histo, histo, 100, 0, 2000);
 
   sprintf(histo, "sNNumChannels");
   sNNumChannels_ = ibooker.book1D(histo, histo, 100, 0, 100);
   sprintf(histo, "sNSumE");
   sNSumE_ = ibooker.book1D(histo, histo, 100, 0, 5000);
   sprintf(histo, "sNSumEt");
   sNSumEt_ = ibooker.book1D(histo, histo, 100, 0, 2000);
 
   sprintf(histo, "iNNumChannels");
   iNNumChannels_ = ibooker.book1D(histo, histo, 100, 0, 100);
   sprintf(histo, "iNSumE");
   iNSumE_ = ibooker.book1D(histo, histo, 100, 0, 5000);
   sprintf(histo, "iNSumEt");
   iNSumEt_ = ibooker.book1D(histo, histo, 100, 0, 2000);
 
   sprintf(histo, "hNoise_maxZeros");
   hNoise_maxZeros_ = ibooker.book1D(histo, histo, 80, 0, 80);
   sprintf(histo, "hNoise_maxHPDHits");
   hNoise_maxHPDHits_ = ibooker.book1D(histo, histo, 20, 0, 20);
   sprintf(histo, "hNoise_maxHPDNoOtherHits");
   hNoise_maxHPDNoOtherHits_ = ibooker.book1D(histo, histo, 20, 0, 20);
 }