#include <L1TdeRCT.h>

Inheritance diagram for L1TdeRCT:

Public Member Functions
	L1TdeRCT (const edm::ParameterSet &ps)

	~L1TdeRCT () override

Public Member Functions inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< l1tderct::Empty > >
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) override

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

	DQMOneEDAnalyzer ()

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

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

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::Accumulator, Args...>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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

std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override

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

void	DivideME1D (MonitorElement numerator, MonitorElement denominator, MonitorElement *result)

void	DivideME2D (MonitorElement numerator, MonitorElement denominator, MonitorElement *result)

std::shared_ptr< l1tderct::Empty >	globalBeginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) const override

void	globalEndLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) final

void	readFEDVector (MonitorElement *, const edm::EventSetup &, const bool isLumitransition=true) const

Protected Member Functions inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< l1tderct::Empty > >
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

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

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Private Attributes
std::string	dataInputTagName_

int	doubleThreshold_

edm::EDGetTokenT < EcalTrigPrimDigiCollection >	ecalTPGData_

MonitorElement *	fedVectorMonitorLS_

MonitorElement *	fedVectorMonitorRUN_

int	filterTriggerType_
	filter TriggerType More...

edm::EDGetTokenT < L1CaloEmCollection >	gctSourceData_emData_

edm::EDGetTokenT < L1CaloRegionCollection >	gctSourceData_rgnData_

edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	gtDigisLabel_

std::string	gtEGAlgoName_

edm::EDGetTokenT < HcalTrigPrimDigiCollection >	hcalTPGData_

std::string	histFolder_

int	nev_

int	notrigCount

bool	perLSsaving_

MonitorElement *	rctBitDataHfPlusTau2D_

MonitorElement *	rctBitDataMip2D_

MonitorElement *	rctBitDataOverFlow2D_

MonitorElement *	rctBitDataQuiet2D_

MonitorElement *	rctBitDataTauVeto2D_

MonitorElement *	rctBitEmulHfPlusTau2D_

MonitorElement *	rctBitEmulMip2D_

MonitorElement *	rctBitEmulOverFlow2D_

MonitorElement *	rctBitEmulQuiet2D_

MonitorElement *	rctBitEmulTauVeto2D_

MonitorElement *	rctBitHfPlusTauEff2D_

MonitorElement *	rctBitHfPlusTauIneff2D_

MonitorElement *	rctBitHfPlusTauOvereff2D_

MonitorElement *	rctBitMatchedHfPlusTau2D_

MonitorElement *	rctBitMatchedMip2D_

MonitorElement *	rctBitMatchedOverFlow2D_

MonitorElement *	rctBitMatchedQuiet2D_

MonitorElement *	rctBitMatchedTauVeto2D_

MonitorElement *	rctBitMipEff2D_

MonitorElement *	rctBitMipIneff2D_

MonitorElement *	rctBitMipOvereff2D_

MonitorElement *	rctBitOverFlowEff2D_

MonitorElement *	rctBitOverFlowIneff2D_

MonitorElement *	rctBitOverFlowOvereff2D_

MonitorElement *	rctBitTauVetoEff2D_

MonitorElement *	rctBitTauVetoIneff2D_

MonitorElement *	rctBitTauVetoOvereff2D_

MonitorElement *	rctBitUnmatchedDataHfPlusTau2D_

MonitorElement *	rctBitUnmatchedDataMip2D_

MonitorElement *	rctBitUnmatchedDataOverFlow2D_

MonitorElement *	rctBitUnmatchedDataQuiet2D_

MonitorElement *	rctBitUnmatchedDataTauVeto2D_

MonitorElement *	rctBitUnmatchedEmulHfPlusTau2D_

MonitorElement *	rctBitUnmatchedEmulMip2D_

MonitorElement *	rctBitUnmatchedEmulOverFlow2D_

MonitorElement *	rctBitUnmatchedEmulQuiet2D_

MonitorElement *	rctBitUnmatchedEmulTauVeto2D_

MonitorElement *	rctInputTPGEcalOcc_

MonitorElement *	rctInputTPGEcalOccNoCut_

MonitorElement *	rctInputTPGEcalRank_

MonitorElement *	rctInputTPGHcalOcc_

MonitorElement *	rctInputTPGHcalRank_

MonitorElement *	rctInputTPGHcalSample_

MonitorElement *	rctIsoEffChannel_ [396]

MonitorElement *	rctIsoEmBitDiff_

MonitorElement *	rctIsoEmBitOff_

MonitorElement *	rctIsoEmBitOn_

MonitorElement *	rctIsoEmDataOcc1D_

MonitorElement *	rctIsoEmDataOcc_

MonitorElement *	rctIsoEmEff1_

MonitorElement *	rctIsoEmEff1Occ1D_

MonitorElement *	rctIsoEmEff1Occ_

MonitorElement *	rctIsoEmEff1oneD_

MonitorElement *	rctIsoEmEff2_

MonitorElement *	rctIsoEmEff2Occ1D_

MonitorElement *	rctIsoEmEff2Occ_

MonitorElement *	rctIsoEmEff2oneD_

MonitorElement *	rctIsoEmEmulOcc1D_

MonitorElement *	rctIsoEmEmulOcc_

MonitorElement *	rctIsoEmIneff1D_

MonitorElement *	rctIsoEmIneff2_

MonitorElement *	rctIsoEmIneff2Occ1D_

MonitorElement *	rctIsoEmIneff2Occ_

MonitorElement *	rctIsoEmIneff2oneD_

MonitorElement *	rctIsoEmIneff_

MonitorElement *	rctIsoEmIneffOcc1D_

MonitorElement *	rctIsoEmIneffOcc_

MonitorElement *	rctIsoEmOvereff1D_

MonitorElement *	rctIsoEmOvereff_

MonitorElement *	rctIsoEmOvereffOcc1D_

MonitorElement *	rctIsoEmOvereffOcc_

MonitorElement *	rctIsoIneffChannel_ [396]

MonitorElement *	rctIsoOvereffChannel_ [396]

MonitorElement *	rctNisoEffChannel_ [396]

MonitorElement *	rctNIsoEmBitDiff_

MonitorElement *	rctNIsoEmBitOff_

MonitorElement *	rctNIsoEmBitOn_

MonitorElement *	rctNisoEmDataOcc1D_

MonitorElement *	rctNisoEmDataOcc_

MonitorElement *	rctNisoEmEff1_

MonitorElement *	rctNisoEmEff1Occ1D_

MonitorElement *	rctNisoEmEff1Occ_

MonitorElement *	rctNisoEmEff1oneD_

MonitorElement *	rctNisoEmEff2_

MonitorElement *	rctNisoEmEff2Occ1D_

MonitorElement *	rctNisoEmEff2Occ_

MonitorElement *	rctNisoEmEff2oneD_

MonitorElement *	rctNisoEmEmulOcc1D_

MonitorElement *	rctNisoEmEmulOcc_

MonitorElement *	rctNisoEmIneff1D_

MonitorElement *	rctNisoEmIneff2_

MonitorElement *	rctNisoEmIneff2Occ1D_

MonitorElement *	rctNisoEmIneff2Occ_

MonitorElement *	rctNisoEmIneff2oneD_

MonitorElement *	rctNisoEmIneff_

MonitorElement *	rctNisoEmIneffOcc1D_

MonitorElement *	rctNisoEmIneffOcc_

MonitorElement *	rctNisoEmOvereff1D_

MonitorElement *	rctNisoEmOvereff_

MonitorElement *	rctNisoEmOvereffOcc1D_

MonitorElement *	rctNisoEmOvereffOcc_

MonitorElement *	rctNisoIneffChannel_ [396]

MonitorElement *	rctNisoOvereffChannel_ [396]

MonitorElement *	rctRegBitDiff_

MonitorElement *	rctRegBitOff_

MonitorElement *	rctRegBitOn_

MonitorElement *	rctRegDataOcc1D_

MonitorElement *	rctRegDataOcc2D_

MonitorElement *	rctRegEff1D_

MonitorElement *	rctRegEff2D_

MonitorElement *	rctRegEffChannel_ [396]

MonitorElement *	rctRegEmulOcc1D_

MonitorElement *	rctRegEmulOcc2D_

MonitorElement *	rctRegIneff1D_

MonitorElement *	rctRegIneff2D_

MonitorElement *	rctRegIneffChannel_ [396]

MonitorElement *	rctRegMatchedOcc1D_

MonitorElement *	rctRegMatchedOcc2D_

MonitorElement *	rctRegOvereff1D_

MonitorElement *	rctRegOvereff2D_

MonitorElement *	rctRegOvereffChannel_ [396]

MonitorElement *	rctRegSpEff1D_

MonitorElement *	rctRegSpEff2D_

MonitorElement *	rctRegSpEffOcc1D_

MonitorElement *	rctRegSpEffOcc2D_

MonitorElement *	rctRegSpIneff1D_

MonitorElement *	rctRegSpIneff2D_

MonitorElement *	rctRegSpIneffOcc1D_

MonitorElement *	rctRegSpIneffOcc2D_

MonitorElement *	rctRegUnmatchedDataOcc1D_

MonitorElement *	rctRegUnmatchedDataOcc2D_

MonitorElement *	rctRegUnmatchedEmulOcc1D_

MonitorElement *	rctRegUnmatchedEmulOcc2D_

edm::EDGetTokenT < L1CaloEmCollection >	rctSourceData_emData_

edm::EDGetTokenT < L1CaloRegionCollection >	rctSourceData_rgnData_

edm::EDGetTokenT < L1CaloEmCollection >	rctSourceEmul_emEmul_

edm::EDGetTokenT < L1CaloRegionCollection >	rctSourceEmul_rgnEmul_

edm::ESGetToken< RunInfo, RunInfoRcd >	runInfolumiToken_

edm::ESGetToken< RunInfo, RunInfoRcd >	runInfoToken_

int	selectBX_

bool	singlechannelhistos_

int	trigCount

MonitorElement *	trigEff_ [396]

MonitorElement *	trigEffOcc_ [396]

MonitorElement *	trigEffThresh_

MonitorElement *	trigEffThreshOcc_

MonitorElement *	trigEffTriggOcc_ [396]

MonitorElement *	trigEffTriggThreshOcc_

MonitorElement *	triggerAlgoNumbers_

MonitorElement *	triggerType_

bool	verbose_

Static Private Attributes
static const int	crateFED [108]

Additional Inherited Members
Public Types inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< l1tderct::Empty > >
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes inherited from DQMOneEDAnalyzer< edm::LuminosityBlockCache< l1tderct::Empty > >
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 50 of file L1TdeRCT.h.

Constructor & Destructor Documentation

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

Definition at line 80 of file L1TdeRCT.cc.

References gather_cfg::cout, edm::ParameterSet::getUntrackedParameter(), histFolder_, perLSsaving_, singlechannelhistos_, AlCaHLTBitMon_QueryRunRegistry::string, and verbose_.

     : rctSourceEmul_rgnEmul_(consumes<L1CaloRegionCollection>(ps.getParameter<InputTag>("rctSourceEmul"))),
       rctSourceEmul_emEmul_(consumes<L1CaloEmCollection>(ps.getParameter<InputTag>("rctSourceEmul"))),
       rctSourceData_rgnData_(consumes<L1CaloRegionCollection>(ps.getParameter<InputTag>("rctSourceData"))),
       rctSourceData_emData_(consumes<L1CaloEmCollection>(ps.getParameter<InputTag>("rctSourceData"))),
       ecalTPGData_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<InputTag>("ecalTPGData"))),
       hcalTPGData_(consumes<HcalTrigPrimDigiCollection>(ps.getParameter<InputTag>("hcalTPGData"))),
       gtDigisLabel_(consumes<L1GlobalTriggerReadoutRecord>(ps.getParameter<InputTag>("gtDigisLabel"))),
       runInfoToken_(esConsumes<edm::Transition::BeginRun>()),
       runInfolumiToken_(esConsumes<edm::Transition::BeginLuminosityBlock>()),
       gtEGAlgoName_(ps.getParameter<std::string>("gtEGAlgoName")),
       doubleThreshold_(ps.getParameter<int>("doubleThreshold")),
       filterTriggerType_(ps.getParameter<int>("filterTriggerType")),
       selectBX_(ps.getUntrackedParameter<int>("selectBX", 2)),
       dataInputTagName_(ps.getParameter<InputTag>("rctSourceData").label()) {
   singlechannelhistos_ = ps.getUntrackedParameter<bool>("singlechannelhistos", false);
 
   perLSsaving_ = (ps.getUntrackedParameter<bool>("perLSsaving", false));
 
   if (singlechannelhistos_)
     if (verbose_)
       std::cout << "L1TdeRCT: single channels histos ON" << std::endl;
 
   // verbosity switch
   verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
 
   if (verbose_)
     std::cout << "L1TdeRCT: constructor...." << std::endl;
 
   histFolder_ = ps.getUntrackedParameter<std::string>("HistFolder", "L1TEMU/L1TdeRCT");
 }

L1TdeRCT::~L1TdeRCT ( )

override

Definition at line 112 of file L1TdeRCT.cc.

112 {}

Member Function Documentation

void L1TdeRCT::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	c
	)

overrideprotectedvirtual

Reimplemented from DQMOneEDAnalyzer< edm::LuminosityBlockCache< l1tderct::Empty > >.

Definition at line 114 of file L1TdeRCT.cc.

References gather_cfg::cout, DivideME1D(), DivideME2D(), doubleThreshold_, ecalTPGData_, edm::EventBase::experimentType(), dqm::impl::MonitorElement::Fill(), filterTriggerType_, newFWLiteAna::found, edm::Event::getByToken(), gtDigisLabel_, gtEGAlgoName_, hcalTPGData_, mps_fire::i, edm::EventBase::isRealData(), edm::HandleBase::isValid(), dqmiolumiharvest::j, isotrackApplyRegressor::k, dqmiodumpmetadata::n, nev_, notrigCount, PHIBINS, rctBitDataHfPlusTau2D_, rctBitDataMip2D_, rctBitDataOverFlow2D_, rctBitDataQuiet2D_, rctBitDataTauVeto2D_, rctBitEmulHfPlusTau2D_, rctBitEmulMip2D_, rctBitEmulOverFlow2D_, rctBitEmulQuiet2D_, rctBitEmulTauVeto2D_, rctBitHfPlusTauEff2D_, rctBitHfPlusTauIneff2D_, rctBitHfPlusTauOvereff2D_, rctBitMatchedHfPlusTau2D_, rctBitMatchedMip2D_, rctBitMatchedOverFlow2D_, rctBitMatchedQuiet2D_, rctBitMatchedTauVeto2D_, rctBitMipEff2D_, rctBitMipIneff2D_, rctBitMipOvereff2D_, rctBitOverFlowEff2D_, rctBitOverFlowIneff2D_, rctBitOverFlowOvereff2D_, rctBitTauVetoEff2D_, rctBitTauVetoIneff2D_, rctBitTauVetoOvereff2D_, rctBitUnmatchedDataHfPlusTau2D_, rctBitUnmatchedDataMip2D_, rctBitUnmatchedDataOverFlow2D_, rctBitUnmatchedDataQuiet2D_, rctBitUnmatchedDataTauVeto2D_, rctBitUnmatchedEmulHfPlusTau2D_, rctBitUnmatchedEmulMip2D_, rctBitUnmatchedEmulOverFlow2D_, rctBitUnmatchedEmulQuiet2D_, rctBitUnmatchedEmulTauVeto2D_, rctInputTPGEcalOcc_, rctInputTPGEcalOccNoCut_, rctInputTPGEcalRank_, rctInputTPGHcalOcc_, rctInputTPGHcalRank_, rctInputTPGHcalSample_, rctIsoEffChannel_, rctIsoEmBitDiff_, rctIsoEmBitOff_, rctIsoEmBitOn_, rctIsoEmDataOcc1D_, rctIsoEmDataOcc_, rctIsoEmEff1_, rctIsoEmEff1Occ1D_, rctIsoEmEff1Occ_, rctIsoEmEff1oneD_, rctIsoEmEff2_, rctIsoEmEff2Occ1D_, rctIsoEmEff2Occ_, rctIsoEmEff2oneD_, rctIsoEmEmulOcc1D_, rctIsoEmEmulOcc_, rctIsoEmIneff1D_, rctIsoEmIneff2_, rctIsoEmIneff2Occ1D_, rctIsoEmIneff2Occ_, rctIsoEmIneff2oneD_, rctIsoEmIneff_, rctIsoEmIneffOcc1D_, rctIsoEmIneffOcc_, rctIsoEmOvereff1D_, rctIsoEmOvereff_, rctIsoEmOvereffOcc1D_, rctIsoEmOvereffOcc_, rctIsoIneffChannel_, rctIsoOvereffChannel_, rctNisoEffChannel_, rctNIsoEmBitDiff_, rctNIsoEmBitOff_, rctNIsoEmBitOn_, rctNisoEmDataOcc1D_, rctNisoEmDataOcc_, rctNisoEmEff1_, rctNisoEmEff1Occ1D_, rctNisoEmEff1Occ_, rctNisoEmEff1oneD_, rctNisoEmEff2_, rctNisoEmEff2Occ1D_, rctNisoEmEff2Occ_, rctNisoEmEff2oneD_, rctNisoEmEmulOcc1D_, rctNisoEmEmulOcc_, rctNisoEmIneff1D_, rctNisoEmIneff2_, rctNisoEmIneff2Occ1D_, rctNisoEmIneff2Occ_, rctNisoEmIneff2oneD_, rctNisoEmIneff_, rctNisoEmIneffOcc1D_, rctNisoEmIneffOcc_, rctNisoEmOvereff1D_, rctNisoEmOvereff_, rctNisoEmOvereffOcc1D_, rctNisoEmOvereffOcc_, rctNisoIneffChannel_, rctNisoOvereffChannel_, rctRegBitDiff_, rctRegBitOff_, rctRegBitOn_, rctRegDataOcc1D_, rctRegDataOcc2D_, rctRegEff1D_, rctRegEff2D_, rctRegEffChannel_, rctRegEmulOcc1D_, rctRegEmulOcc2D_, rctRegIneff1D_, rctRegIneff2D_, rctRegIneffChannel_, rctRegMatchedOcc1D_, rctRegMatchedOcc2D_, rctRegOvereff1D_, rctRegOvereff2D_, rctRegOvereffChannel_, rctRegSpEff1D_, rctRegSpEff2D_, rctRegSpEffOcc1D_, rctRegSpEffOcc2D_, rctRegSpIneff1D_, rctRegSpIneff2D_, rctRegSpIneffOcc1D_, rctRegSpIneffOcc2D_, rctRegUnmatchedDataOcc1D_, rctRegUnmatchedDataOcc2D_, rctRegUnmatchedEmulOcc1D_, rctRegUnmatchedEmulOcc2D_, rctSourceData_emData_, rctSourceData_rgnData_, rctSourceEmul_emEmul_, rctSourceEmul_rgnEmul_, selectBX_, singlechannelhistos_, trigCount, trigEff_, trigEffOcc_, trigEffThresh_, trigEffThreshOcc_, trigEffTriggOcc_, trigEffTriggThreshOcc_, triggerAlgoNumbers_, HLT_FULL_cff::triggerType, triggerType_, and verbose_.

                                                           {
   nev_++;
   if (verbose_) {
     std::cout << "L1TdeRCT: analyze...." << std::endl;
   }
 
   // filter according trigger type
   //  enum ExperimentType {
   //        Undefined          =  0,
   //        PhysicsTrigger     =  1,
   //        CalibrationTrigger =  2,
   //        RandomTrigger      =  3,
   //        Reserved           =  4,
   //        TracedEvent        =  5,
   //        TestTrigger        =  6,
   //        ErrorTrigger       = 15
 
   // fill a histogram with the trigger type, for normalization fill also last bin
   // ErrorTrigger + 1
   double triggerType = static_cast<double>(e.experimentType()) + 0.001;
   double triggerTypeLast = static_cast<double>(edm::EventAuxiliary::ExperimentType::ErrorTrigger) + 0.001;
   triggerType_->Fill(triggerType);
   triggerType_->Fill(triggerTypeLast + 1);
 
   // filter only if trigger type is greater than 0, negative values disable filtering
   if (filterTriggerType_ >= 0) {
     // now filter, for real data only
     if (e.isRealData()) {
       if (!(e.experimentType() == filterTriggerType_)) {
         edm::LogInfo("L1TdeRCT") << "\n Event of TriggerType " << e.experimentType() << " rejected" << std::endl;
         return;
       }
     }
   }
 
   // for GT decision word
   edm::Handle<L1GlobalTriggerReadoutRecord> gtRecord;
 
   // get GT decision word
   e.getByToken(gtDigisLabel_, gtRecord);
   const DecisionWord dWord =
       gtRecord->decisionWord();  // this will get the decision word *before* masking disabled bits
   int effEGThresholdBitNumber = 999;
   if (gtEGAlgoName_ == "L1_SingleEG1") {
     effEGThresholdBitNumber = 46;
   }
   if (gtEGAlgoName_ == "L1_SingleEG5_0001") {
     effEGThresholdBitNumber = 47;
   }
   if (gtEGAlgoName_ == "L1_SingleEG8_0001") {
     effEGThresholdBitNumber = 48;
   }
   if (gtEGAlgoName_ == "L1_SingleEG10_0001") {
     effEGThresholdBitNumber = 49;
   }
   if (gtEGAlgoName_ == "L1_SingleEG12_0001") {
     effEGThresholdBitNumber = 50;
   }
   if (gtEGAlgoName_ == "L1_SingleEG15_0001") {
     effEGThresholdBitNumber = 51;
   }
   if (gtEGAlgoName_ == "L1_SingleEG20_0001") {
     effEGThresholdBitNumber = 52;
   }
 
   int algoBitNumber = 0;
   bool triggered = false;
   bool independent_triggered = false;
   DecisionWord::const_iterator algoItr;
   for (algoItr = dWord.begin(); algoItr != dWord.end(); algoItr++) {
     if (*algoItr) {
       triggerAlgoNumbers_->Fill(algoBitNumber);
       if (algoBitNumber == effEGThresholdBitNumber) {
         triggered = true;  // Fill triggered events (numerator) here!
       }
       if (algoBitNumber <= 45 || algoBitNumber >= 53) {
         independent_triggered = true;  // use the muon path only !
       }
     }
     algoBitNumber++;
   }
 
   if (triggered)
     trigCount++;
   else
     notrigCount++;
 
   // get TPGs
   edm::Handle<EcalTrigPrimDigiCollection> ecalTpData;
   edm::Handle<HcalTrigPrimDigiCollection> hcalTpData;
 
   // Get the RCT digis
   edm::Handle<L1CaloEmCollection> emData;
   edm::Handle<L1CaloRegionCollection> rgnData;
 
   // Get the RCT digis
   edm::Handle<L1CaloEmCollection> emEmul;
   edm::Handle<L1CaloRegionCollection> rgnEmul;
 
   bool doEcal = true;
   bool doHcal = true;
 
   // TPG, first try:
   e.getByToken(ecalTPGData_, ecalTpData);
   e.getByToken(hcalTPGData_, hcalTpData);
 
   if (!ecalTpData.isValid()) {
     edm::LogInfo("TPG DataNotFound") << "can't find EcalTrigPrimDigiCollection";
     if (verbose_)
       std::cout << "Can not find ecalTpData!" << std::endl;
 
     doEcal = false;
   }
 
   if (doEcal) {
     for (EcalTrigPrimDigiCollection::const_iterator iEcalTp = ecalTpData->begin(); iEcalTp != ecalTpData->end();
          iEcalTp++) {
       if (iEcalTp->compressedEt() > 0) {
         rctInputTPGEcalRank_->Fill(1. * (iEcalTp->compressedEt()));
 
         if (iEcalTp->id().ieta() > 0) {
           rctInputTPGEcalOccNoCut_->Fill(1. * (iEcalTp->id().ieta()) - 0.5, iEcalTp->id().iphi());
           if (iEcalTp->compressedEt() > 3)
             rctInputTPGEcalOcc_->Fill(1. * (iEcalTp->id().ieta()) - 0.5, iEcalTp->id().iphi());
         } else {
           rctInputTPGEcalOccNoCut_->Fill(1. * (iEcalTp->id().ieta()) + 0.5, iEcalTp->id().iphi());
           if (iEcalTp->compressedEt() > 3)
             rctInputTPGEcalOcc_->Fill(1. * (iEcalTp->id().ieta()) + 0.5, iEcalTp->id().iphi());
         }
 
         if (verbose_)
           std::cout << " ECAL data: Energy: " << iEcalTp->compressedEt() << " eta " << iEcalTp->id().ieta() << " phi "
                     << iEcalTp->id().iphi() << std::endl;
       }
     }
   }
 
   if (!hcalTpData.isValid()) {
     edm::LogInfo("TPG DataNotFound") << "can't find HcalTrigPrimDigiCollection";
     if (verbose_)
       std::cout << "Can not find hcalTpData!" << std::endl;
 
     doHcal = false;
   }
 
   if (doHcal) {
     for (HcalTrigPrimDigiCollection::const_iterator iHcalTp = hcalTpData->begin(); iHcalTp != hcalTpData->end();
          iHcalTp++) {
       int highSample = 0;
       int highEt = 0;
 
       for (int nSample = 0; nSample < 10; nSample++) {
         if (iHcalTp->sample(nSample).compressedEt() != 0) {
           if (verbose_)
             std::cout << "HCAL data: Et " << iHcalTp->sample(nSample).compressedEt() << "  fg "
                       << iHcalTp->sample(nSample).fineGrain() << "  ieta " << iHcalTp->id().ieta() << "  iphi "
                       << iHcalTp->id().iphi() << "  sample " << nSample << std::endl;
           if (iHcalTp->sample(nSample).compressedEt() > highEt) {
             highSample = nSample;
             highEt = iHcalTp->sample(nSample).compressedEt();
           }
         }
       }
 
       if (highEt != 0) {
         if (iHcalTp->id().ieta() > 0)
           rctInputTPGHcalOcc_->Fill(1. * (iHcalTp->id().ieta()) - 0.5, iHcalTp->id().iphi());
         else
           rctInputTPGHcalOcc_->Fill(1. * (iHcalTp->id().ieta()) + 0.5, iHcalTp->id().iphi());
         rctInputTPGHcalSample_->Fill(highSample, highEt);
         rctInputTPGHcalRank_->Fill(highEt);
       }
     }
   }
 
   e.getByToken(rctSourceData_rgnData_, rgnData);
   e.getByToken(rctSourceEmul_rgnEmul_, rgnEmul);
 
   if (!rgnData.isValid()) {
     edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection";
     if (verbose_)
       std::cout << "Can not find rgnData!" << std::endl;
     return;
   }
 
   if (!rgnEmul.isValid()) {
     edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection";
     if (verbose_)
       std::cout << "Can not find rgnEmul!" << std::endl;
     return;
   }
 
   e.getByToken(rctSourceData_emData_, emData);
   e.getByToken(rctSourceEmul_emEmul_, emEmul);
 
   if (!emData.isValid()) {
     edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection";
     if (verbose_)
       std::cout << "Can not find emData!" << std::endl;
     return;
   }
 
   if (!emEmul.isValid()) {
     edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection";
     if (verbose_)
       std::cout << "Can not find emEmul!" << std::endl;
     return;
   }
 
   // Isolated and non-isolated EM
 
   // StepI: Reset
 
   int nelectrIsoData = 0;
   int nelectrNisoData = 0;
   int nelectrIsoEmul = 0;
   int nelectrNisoEmul = 0;
 
   int electronDataRank[2][PhiEtaMax] = {{0}};
   int electronDataEta[2][PhiEtaMax] = {{0}};
   int electronDataPhi[2][PhiEtaMax] = {{0}};
   int electronEmulRank[2][PhiEtaMax] = {{0}};
   int electronEmulEta[2][PhiEtaMax] = {{0}};
   int electronEmulPhi[2][PhiEtaMax] = {{0}};
 
   // region/bit arrays
   int nRegionData = 0;
   int nRegionEmul = 0;
 
   int regionDataRank[PhiEtaMax] = {0};
   int regionDataEta[PhiEtaMax] = {0};
   int regionDataPhi[PhiEtaMax] = {0};
 
   bool regionDataOverFlow[PhiEtaMax] = {false};
   bool regionDataTauVeto[PhiEtaMax] = {false};
   bool regionDataMip[PhiEtaMax] = {false};
   bool regionDataQuiet[PhiEtaMax] = {false};
   bool regionDataHfPlusTau[PhiEtaMax] = {false};
 
   int regionEmulRank[PhiEtaMax] = {0};
   int regionEmulEta[PhiEtaMax] = {0};
   int regionEmulPhi[PhiEtaMax] = {0};
 
   bool regionEmulOverFlow[PhiEtaMax] = {false};
   bool regionEmulTauVeto[PhiEtaMax] = {false};
   bool regionEmulMip[PhiEtaMax] = {false};
   bool regionEmulQuiet[PhiEtaMax] = {false};
   bool regionEmulHfPlusTau[PhiEtaMax] = {false};
 
   // StepII: fill variables
 
   for (L1CaloEmCollection::const_iterator iem = emEmul->begin(); iem != emEmul->end(); iem++) {
     if (iem->rank() >= 1) {
       if (iem->isolated()) {
         rctIsoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
 
         // to  show bad channles in the 2D efficiency plots
         rctIsoEmIneffOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
         rctIsoEmEff1Occ_->Fill(iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
 
         int channel;
 
         channel = PHIBINS * iem->regionId().ieta() + iem->regionId().iphi();
         rctIsoEmEmulOcc1D_->Fill(channel);
         electronEmulRank[0][nelectrIsoEmul] = iem->rank();
         electronEmulEta[0][nelectrIsoEmul] = iem->regionId().ieta();
         electronEmulPhi[0][nelectrIsoEmul] = iem->regionId().iphi();
         nelectrIsoEmul++;
       }
 
       else {
         rctNisoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
 
         // to  show bad channles in the 2D efficiency plots
         rctNisoEmIneffOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
         rctNisoEmEff1Occ_->Fill(iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
 
         int channel;
         //
 
         channel = PHIBINS * iem->regionId().ieta() + iem->regionId().iphi();
         rctNisoEmEmulOcc1D_->Fill(channel);
         electronEmulRank[1][nelectrNisoEmul] = iem->rank();
         electronEmulEta[1][nelectrNisoEmul] = iem->regionId().ieta();
         electronEmulPhi[1][nelectrNisoEmul] = iem->regionId().iphi();
         nelectrNisoEmul++;
       }
     }
   }
 
   for (L1CaloEmCollection::const_iterator iem = emData->begin(); iem != emData->end(); iem++) {
     if (selectBX_ != -1 && selectBX_ != iem->bx())
       continue;
 
     if (iem->rank() >= 1) {
       if (iem->isolated()) {
         rctIsoEmDataOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
 
         // new stuff to avoid 0's in emulator 2D //
         // rctIsoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(),0.01);
         rctIsoEmOvereffOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
 
         int channel;
 
         channel = PHIBINS * iem->regionId().ieta() + iem->regionId().iphi();
         rctIsoEmDataOcc1D_->Fill(channel);
 
         // new stuff to avoid 0's
         // rctIsoEmEmulOcc1D_->Fill(channel);
 
         electronDataRank[0][nelectrIsoData] = iem->rank();
         electronDataEta[0][nelectrIsoData] = iem->regionId().ieta();
         electronDataPhi[0][nelectrIsoData] = iem->regionId().iphi();
         nelectrIsoData++;
       }
 
       else {
         rctNisoEmDataOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
 
         // new stuff to avoid 0's in emulator 2D //
         // rctNisoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(),0.01);
         rctNisoEmOvereffOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
 
         int channel;
 
         channel = PHIBINS * iem->regionId().ieta() + iem->regionId().iphi();
         rctNisoEmDataOcc1D_->Fill(channel);
 
         // new stuff to avoid 0's
         // rctNisoEmEmulOcc1D_->Fill(channel);
 
         electronDataRank[1][nelectrNisoData] = iem->rank();
         electronDataEta[1][nelectrNisoData] = iem->regionId().ieta();
         electronDataPhi[1][nelectrNisoData] = iem->regionId().iphi();
         nelectrNisoData++;
       }
     }
   }
 
   // fill region/bit arrays for emulator
   for (L1CaloRegionCollection::const_iterator ireg = rgnEmul->begin(); ireg != rgnEmul->end(); ireg++) {
     //     std::cout << "Emul: " << nRegionEmul << " " << ireg->gctEta() << " " << ireg->gctPhi() << std::endl;
     if (ireg->overFlow())
       rctBitEmulOverFlow2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->tauVeto())
       rctBitEmulTauVeto2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->mip())
       rctBitEmulMip2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->quiet())
       rctBitEmulQuiet2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->fineGrain())
       rctBitEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->et() > 0) {
       rctRegEmulOcc1D_->Fill(PHIBINS * ireg->gctEta() + ireg->gctPhi());
       rctRegEmulOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     }
 
     // to show bad channels in 2D efficiency plots:
     if (ireg->overFlow()) {
       rctBitUnmatchedEmulOverFlow2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       rctBitMatchedOverFlow2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     }
 
     if (ireg->tauVeto()) {
       rctBitUnmatchedEmulTauVeto2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       rctBitMatchedTauVeto2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     }
 
     if (ireg->mip()) {
       rctBitUnmatchedEmulMip2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       rctBitMatchedMip2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     }
 
     if (ireg->quiet()) {
       rctBitUnmatchedEmulQuiet2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       rctBitMatchedQuiet2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     }
 
     if (ireg->fineGrain()) {
       rctBitUnmatchedEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       rctBitMatchedHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     }
 
     if (ireg->et() > 0) {
       rctRegUnmatchedEmulOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       rctRegMatchedOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
       /*      rctRegDeltaEtOcc2D_->Fill       (ireg->gctEta(), ireg->gctPhi(), 0.01); */
     }
 
     nRegionEmul = PHIBINS * ireg->gctEta() + ireg->gctPhi();
 
     regionEmulRank[nRegionEmul] = ireg->et();
     regionEmulEta[nRegionEmul] = ireg->gctEta();
     regionEmulPhi[nRegionEmul] = ireg->gctPhi();
     regionEmulOverFlow[nRegionEmul] = ireg->overFlow();
     regionEmulTauVeto[nRegionEmul] = ireg->tauVeto();
     regionEmulMip[nRegionEmul] = ireg->mip();
     regionEmulQuiet[nRegionEmul] = ireg->quiet();
     regionEmulHfPlusTau[nRegionEmul] = ireg->fineGrain();
   }
   // fill region/bit arrays for hardware
   for (L1CaloRegionCollection::const_iterator ireg = rgnData->begin(); ireg != rgnData->end(); ireg++) {
     if (selectBX_ != -1 && selectBX_ != ireg->bx())
       continue;
 
     //     std::cout << "Data: " << nRegionData << " " << ireg->gctEta() << " " << ireg->gctPhi() << std::endl;
     if (ireg->overFlow())
       rctBitDataOverFlow2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->tauVeto())
       rctBitDataTauVeto2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->mip())
       rctBitDataMip2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->quiet())
       rctBitDataQuiet2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->fineGrain())
       rctBitDataHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     if (ireg->et() > 0) {
       rctRegDataOcc1D_->Fill(PHIBINS * ireg->gctEta() + ireg->gctPhi());
       rctRegDataOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi());
     }
     // to show bad channels in 2D inefficiency:
     // if(ireg->overFlow())  rctBitEmulOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     // if(ireg->tauVeto())   rctBitEmulTauVeto2D_  ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     // if(ireg->mip())       rctBitEmulMip2D_      ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     // if(ireg->quiet())     rctBitEmulQuiet2D_    ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     // if(ireg->fineGrain()) rctBitEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     // if(ireg->et() > 0)    rctRegEmulOcc2D_      ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     if (ireg->overFlow())
       rctBitUnmatchedDataOverFlow2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     if (ireg->tauVeto())
       rctBitUnmatchedDataTauVeto2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     if (ireg->mip())
       rctBitUnmatchedDataMip2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     if (ireg->quiet())
       rctBitUnmatchedDataQuiet2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     if (ireg->fineGrain())
       rctBitUnmatchedDataHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
     if (ireg->et() > 0)
       rctRegUnmatchedDataOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
 
     nRegionData = PHIBINS * ireg->gctEta() + ireg->gctPhi();
 
     regionDataRank[nRegionData] = ireg->et();
     regionDataEta[nRegionData] = ireg->gctEta();
     regionDataPhi[nRegionData] = ireg->gctPhi();
     regionDataOverFlow[nRegionData] = ireg->overFlow();
     regionDataTauVeto[nRegionData] = ireg->tauVeto();
     regionDataMip[nRegionData] = ireg->mip();
     regionDataQuiet[nRegionData] = ireg->quiet();
     regionDataHfPlusTau[nRegionData] = ireg->fineGrain();
   }
 
   if (verbose_) {
     std::cout << "I found Data! Iso: " << nelectrIsoData << " Niso: " << nelectrNisoData << std::endl;
     for (int i = 0; i < nelectrIsoData; i++)
       std::cout << " Iso Energy " << electronDataRank[0][i] << " eta " << electronDataEta[0][i] << " phi "
                 << electronDataPhi[0][i] << std::endl;
     for (int i = 0; i < nelectrNisoData; i++)
       std::cout << " Niso Energy " << electronDataRank[1][i] << " eta " << electronDataEta[1][i] << " phi "
                 << electronDataPhi[1][i] << std::endl;
 
     std::cout << "I found Emul! Iso: " << nelectrIsoEmul << " Niso: " << nelectrNisoEmul << std::endl;
     for (int i = 0; i < nelectrIsoEmul; i++)
       std::cout << " Iso Energy " << electronEmulRank[0][i] << " eta " << electronEmulEta[0][i] << " phi "
                 << electronEmulPhi[0][i] << std::endl;
     for (int i = 0; i < nelectrNisoEmul; i++)
       std::cout << " Niso Energy " << electronEmulRank[1][i] << " eta " << electronEmulEta[1][i] << " phi "
                 << electronEmulPhi[1][i] << std::endl;
 
     std::cout << "I found Data! Regions: " << PhiEtaMax << std::endl;
     for (int i = 0; i < (int)PhiEtaMax; i++)
       if (regionDataRank[i] != 0)
         std::cout << " Energy " << regionDataRank[i] << " eta " << regionDataEta[i] << " phi " << regionDataPhi[i]
                   << std::endl;
 
     std::cout << "I found Emul! Regions: " << PhiEtaMax << std::endl;
     for (int i = 0; i < (int)PhiEtaMax; i++)
       if (regionEmulRank[i] != 0)
         std::cout << " Energy " << regionEmulRank[i] << " eta " << regionEmulEta[i] << " phi " << regionEmulPhi[i]
                   << std::endl;
   }
 
   // StepIII: calculate and fill
 
   for (int k = 0; k < 2; k++) {
     int nelectrE, nelectrD;
 
     if (k == 0) {
       nelectrE = nelectrIsoEmul;
       nelectrD = nelectrIsoData;
     }
 
     else {
       nelectrE = nelectrNisoEmul;
       nelectrD = nelectrNisoData;
     }
 
     for (int i = 0; i < nelectrE; i++) {
       //bool triggered = l1SingleEG2; //false; //HACK until true trigger implimented
       double trigThresh = doubleThreshold_;  //ditto
       if (singlechannelhistos_) {
         int chnl = PHIBINS * electronEmulEta[k][i] + electronEmulPhi[k][i];
         if (k == 1 && independent_triggered) {  //non-iso
           //std::cout << "eta " << electronEmulEta[k][i] << " phi " << electronEmulPhi[k][i] << " with rank " <<  electronEmulRank[k][i] << std::endl;
           trigEffOcc_[chnl]->Fill(electronEmulRank[k][i]);
           //        }
           if (triggered)
             trigEffTriggOcc_[chnl]->Fill(electronEmulRank[k][i]);
         }
       }
       //find number of objects with rank above 2x trigger threshold
       //and number after requiring a trigger too
       if (electronEmulRank[k][i] >= trigThresh) {
         if (k == 1 && independent_triggered) {  //non-iso
           trigEffThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i]);
           trigEffTriggThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.01);
           //        }
           if (triggered)
             trigEffTriggThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
         }
       }
 
       Bool_t found = kFALSE;
 
       for (int j = 0; j < nelectrD; j++) {
         if (electronEmulEta[k][i] == electronDataEta[k][j] && electronEmulPhi[k][i] == electronDataPhi[k][j]) {
           if (k == 0) {
             rctIsoEmEff1Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
             // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99
 
             int chnl;
 
             chnl = PHIBINS * electronEmulEta[k][i] + electronEmulPhi[k][i];
             rctIsoEmEff1Occ1D_->Fill(chnl);
             if (singlechannelhistos_) {
               int energy_difference;
 
               energy_difference = (electronEmulRank[k][i] - electronDataRank[k][j]);
               rctIsoEffChannel_[chnl]->Fill(energy_difference);
             }
 
             if (electronEmulRank[k][i] == electronDataRank[k][j]) {
               rctIsoEmEff2Occ1D_->Fill(chnl);
               rctIsoEmEff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98012);
               // Weight is for ROOT; should just exceed 0.99
               // NOTE: Weight is different for eff 2 because this isn't filled initially
               // for current definition of Eff2 and Ineff2 we need to add additional
               // factor 0.99 since we divide over eff1 which is 0.99001 e.g. we use 0.99001**2 !
               rctIsoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.0099);
             } else {
               rctIsoEmIneff2Occ1D_->Fill(chnl);
               rctIsoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.9801);
               //Check for the bit that is different and store it
               bitset<8> bitDifference(electronEmulRank[k][i] ^ electronDataRank[k][j]);
               for (size_t n = 0; n < bitDifference.size(); n++) {
                 if (n < 4) {
                   rctIsoEmBitDiff_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i] + n * 0.25, bitDifference[n]);
                 }
                 if (n >= 4) {
                   rctIsoEmBitDiff_->Fill(
                       electronEmulEta[k][i] + 0.5, electronEmulPhi[k][i] + (n - 4) * 0.25, bitDifference[n]);
                 }
               }
             }
           }
 
           else {
             rctNisoEmEff1Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
             // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99
 
             int chnl;
 
             chnl = PHIBINS * electronEmulEta[k][i] + electronEmulPhi[k][i];
             rctNisoEmEff1Occ1D_->Fill(chnl);
             if (singlechannelhistos_) {
               int energy_difference;
 
               energy_difference = (electronEmulRank[k][i] - electronDataRank[k][j]);
               rctNisoEffChannel_[chnl]->Fill(energy_difference);
             }
 
             if (electronEmulRank[k][i] == electronDataRank[k][j]) {
               rctNisoEmEff2Occ1D_->Fill(chnl);
               rctNisoEmEff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98012);
               // Weight is for ROOT; should just exceed 0.99
               // NOTE: Weight is different for eff 2 because this isn't filled initially
               // see comments fo Iso
               rctNisoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.0099);
             } else {
               rctNisoEmIneff2Occ1D_->Fill(chnl);
               rctNisoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.9801);
               //Check for the bit that is different and store it
               bitset<8> bitDifference(electronEmulRank[k][i] ^ electronDataRank[k][j]);
               for (size_t n = 0; n < bitDifference.size(); n++) {
                 if (n < 4) {
                   rctNIsoEmBitDiff_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i] + n * 0.25, bitDifference[n]);
                 }
                 if (n >= 4) {
                   rctNIsoEmBitDiff_->Fill(
                       electronEmulEta[k][i] + 0.5, electronEmulPhi[k][i] + (n - 4) * 0.25, bitDifference[n]);
                 }
               }
             }
           }
 
           found = kTRUE;
         }
       }
 
       if (found == kFALSE) {
         if (k == 0) {
           rctIsoEmIneffOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98);
           // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
 
           int chnl;
 
           //Store the bit map for the emulator
           bitset<8> bit(electronEmulRank[k][i]);
           for (size_t n = 0; n < bit.size(); n++) {
             if (n < 4) {
               rctIsoEmBitOff_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i] + n * 0.25, bit[n]);
             }
             if (n >= 4) {
               rctIsoEmBitOff_->Fill(electronEmulEta[k][i] + 0.5, electronEmulPhi[k][i] + (n - 4) * 0.25, bit[n]);
             }
           }
 
           chnl = PHIBINS * electronEmulEta[k][i] + electronEmulPhi[k][i];
           rctIsoEmIneffOcc1D_->Fill(chnl);
           if (singlechannelhistos_) {
             rctIsoIneffChannel_[chnl]->Fill(electronEmulRank[k][i]);
           }
         }
 
         else {
           rctNisoEmIneffOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98);
           // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
 
           int chnl;
 
           chnl = PHIBINS * electronEmulEta[k][i] + electronEmulPhi[k][i];
           rctNisoEmIneffOcc1D_->Fill(chnl);
 
           //Store the bit map for the emulator
           bitset<8> bit(electronEmulRank[k][i]);
           for (size_t n = 0; n < bit.size(); n++) {
             if (n < 4) {
               rctNIsoEmBitOff_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i] + n * 0.25, bit[n]);
             }
             if (n >= 4) {
               rctNIsoEmBitOff_->Fill(electronEmulEta[k][i] + 0.5, electronEmulPhi[k][i] + (n - 4) * 0.25, bit[n]);
             }
           }
 
           if (singlechannelhistos_) {
             rctNisoIneffChannel_[chnl]->Fill(electronEmulRank[k][i]);
           }
         }
       }
     }
 
     DivideME1D(rctIsoEmEff1Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmEff1oneD_);
     DivideME2D(rctIsoEmEff1Occ_, rctIsoEmEmulOcc_, rctIsoEmEff1_);
     //    DivideME1D(rctIsoEmEff2Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmEff2oneD_);
     //    DivideME2D(rctIsoEmEff2Occ_, rctIsoEmEmulOcc_, rctIsoEmEff2_) ;
     DivideME1D(rctIsoEmEff2Occ1D_, rctIsoEmEff1Occ1D_, rctIsoEmEff2oneD_);
     DivideME2D(rctIsoEmEff2Occ_, rctIsoEmEff1Occ_, rctIsoEmEff2_);
     //    DivideME1D(rctIsoEmIneff2Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmIneff2oneD_);
     //    DivideME2D(rctIsoEmIneff2Occ_, rctIsoEmEmulOcc_, rctIsoEmIneff2_) ;
     DivideME1D(rctIsoEmIneff2Occ1D_, rctIsoEmEff1Occ1D_, rctIsoEmIneff2oneD_);
     DivideME2D(rctIsoEmIneff2Occ_, rctIsoEmEff1Occ_, rctIsoEmIneff2_);
 
     DivideME1D(rctNisoEmEff1Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmEff1oneD_);
     DivideME2D(rctNisoEmEff1Occ_, rctNisoEmEmulOcc_, rctNisoEmEff1_);
     //    DivideME1D(rctNisoEmEff2Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmEff2oneD_);
     //    DivideME2D(rctNisoEmEff2Occ_, rctNisoEmEmulOcc_, rctNisoEmEff2_);
     DivideME1D(rctNisoEmEff2Occ1D_, rctNisoEmEff1Occ1D_, rctNisoEmEff2oneD_);
     DivideME2D(rctNisoEmEff2Occ_, rctNisoEmEff1Occ_, rctNisoEmEff2_);
     //    DivideME1D(rctNisoEmIneff2Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmIneff2oneD_);
     //    DivideME2D(rctNisoEmIneff2Occ_, rctNisoEmEmulOcc_, rctNisoEmIneff2_);
     DivideME1D(rctNisoEmIneff2Occ1D_, rctNisoEmEff1Occ1D_, rctNisoEmIneff2oneD_);
     DivideME2D(rctNisoEmIneff2Occ_, rctNisoEmEff1Occ_, rctNisoEmIneff2_);
 
     DivideME1D(rctIsoEmIneffOcc1D_, rctIsoEmEmulOcc1D_, rctIsoEmIneff1D_);
     DivideME2D(rctIsoEmIneffOcc_, rctIsoEmEmulOcc_, rctIsoEmIneff_);
     DivideME1D(rctNisoEmIneffOcc1D_, rctNisoEmEmulOcc1D_, rctNisoEmIneff1D_);
     DivideME2D(rctNisoEmIneffOcc_, rctNisoEmEmulOcc_, rctNisoEmIneff_);
 
     DivideME2D(trigEffTriggThreshOcc_, trigEffThreshOcc_, trigEffThresh_);
     if (singlechannelhistos_) {
       for (int i = 0; i < nelectrE; i++) {
         int chnl = PHIBINS * electronEmulEta[k][i] + electronEmulPhi[k][i];
         DivideME1D(trigEffTriggOcc_[chnl], trigEffOcc_[chnl], trigEff_[chnl]);
       }
     }
 
     for (int i = 0; i < nelectrD; i++) {
       Bool_t found = kFALSE;
 
       for (int j = 0; j < nelectrE; j++) {
         if (electronEmulEta[k][j] == electronDataEta[k][i] && electronEmulPhi[k][j] == electronDataPhi[k][i]) {
           found = kTRUE;
         }
       }
 
       if (found == kFALSE) {
         if (k == 0) {
           rctIsoEmOvereffOcc_->Fill(electronDataEta[k][i], electronDataPhi[k][i], 0.98);
           // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
 
           int chnl;
 
           //Store the bit map for the emulator
           bitset<8> bit(electronDataRank[k][i]);
           for (size_t n = 0; n < bit.size(); n++) {
             if (n < 4) {
               rctIsoEmBitOn_->Fill(electronDataEta[k][i], electronDataPhi[k][i] + n * 0.25, bit[n]);
             }
             if (n >= 4) {
               rctIsoEmBitOn_->Fill(electronDataEta[k][i] + 0.5, electronDataPhi[k][i] + (n - 4) * 0.25, bit[n]);
             }
           }
 
           chnl = PHIBINS * electronDataEta[k][i] + electronDataPhi[k][i];
           rctIsoEmOvereffOcc1D_->Fill(chnl);
 
           if (singlechannelhistos_) {
             rctIsoOvereffChannel_[chnl]->Fill(electronDataRank[k][i]);
           }
         }
 
         else {
           rctNisoEmOvereffOcc_->Fill(electronDataEta[k][i], electronDataPhi[k][i], 0.98);
           // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
 
           int chnl;
 
           //Store the bit map for the emulator
           bitset<8> bit(electronDataRank[k][i]);
           for (size_t n = 0; n < bit.size(); n++) {
             if (n < 4) {
               rctNIsoEmBitOn_->Fill(electronDataEta[k][i], electronDataPhi[k][i] + n * 0.25, bit[n]);
             }
             if (n >= 4) {
               rctNIsoEmBitOn_->Fill(electronDataEta[k][i] + 0.5, electronDataPhi[k][i] + (n - 4) * 0.25, bit[n]);
             }
           }
 
           chnl = PHIBINS * electronDataEta[k][i] + electronDataPhi[k][i];
           rctNisoEmOvereffOcc1D_->Fill(chnl);
 
           if (singlechannelhistos_) {
             rctNisoOvereffChannel_[chnl]->Fill(electronDataRank[k][i]);
           }
         }
       }
     }
   }
 
   // we try new definition of overefficiency:
   DivideME1D(rctIsoEmOvereffOcc1D_, rctIsoEmDataOcc1D_, rctIsoEmOvereff1D_);
   DivideME2D(rctIsoEmOvereffOcc_, rctIsoEmDataOcc_, rctIsoEmOvereff_);
   DivideME1D(rctNisoEmOvereffOcc1D_, rctNisoEmDataOcc1D_, rctNisoEmOvereff1D_);
   DivideME2D(rctNisoEmOvereffOcc_, rctNisoEmDataOcc_, rctNisoEmOvereff_);
 
   // calculate region/bit information
   for (unsigned int i = 0; i < (int)PhiEtaMax; i++) {
     Bool_t regFound = kFALSE;
     Bool_t overFlowFound = kFALSE;
     Bool_t tauVetoFound = kFALSE;
     Bool_t mipFound = kFALSE;
     Bool_t quietFound = kFALSE;
     Bool_t hfPlusTauFound = kFALSE;
 
     //       for(int j = 0; j < nRegionData; j++)
     //    {
     //         if(regionEmulEta[i] == regionDataEta[j] &&
     //            regionEmulPhi[i] == regionDataPhi[j])
     //         {
     if (regionDataRank[i] >= 1 && regionEmulRank[i] >= 1) {
       int chnl;
 
       chnl = PHIBINS * regionEmulEta[i] + regionEmulPhi[i];
       rctRegMatchedOcc1D_->Fill(chnl);
       rctRegMatchedOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
       // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99
 
       if (singlechannelhistos_)
         rctRegEffChannel_[chnl]->Fill(regionEmulRank[i] - regionDataRank[i]);
 
       // see comments for Iso Eff2
 
       if (regionEmulRank[i] == regionDataRank[i]) {
         rctRegSpEffOcc1D_->Fill(chnl);
         //             rctRegSpEffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.99001);
         rctRegSpEffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98012);
         rctRegSpIneffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.0099);
       } else {
         rctRegSpIneffOcc1D_->Fill(chnl);
         rctRegSpIneffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.9801);
 
         bitset<10> bitDifference(regionEmulRank[i] ^ regionDataRank[i]);
         for (size_t n = 0; n < bitDifference.size(); n++) {
           if (n < 5) {
             rctRegBitDiff_->Fill(regionEmulEta[i], regionEmulPhi[i] + n * 0.2, bitDifference[n]);
           }
           if (n >= 5) {
             rctRegBitDiff_->Fill(regionEmulEta[i] + 0.5, regionEmulPhi[i] + (n - 5) * 0.2, bitDifference[n]);
           }
         }
       }
       // Weight is for ROOT; should just exceed 0.99
       // NOTE: Weight is different for eff 2 because this isn't filled initially
 
       regFound = kTRUE;
     }
 
     if (regionEmulOverFlow[i] == true && regionDataOverFlow[i] == true) {
       rctBitMatchedOverFlow2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
       overFlowFound = kTRUE;
     }
 
     if (regionEmulTauVeto[i] == true && regionDataTauVeto[i] == true) {
       rctBitMatchedTauVeto2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
       tauVetoFound = kTRUE;
     }
 
     if (regionEmulMip[i] == true && regionDataMip[i] == true) {
       rctBitMatchedMip2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
       mipFound = kTRUE;
     }
 
     if (regionEmulQuiet[i] == true && regionDataQuiet[i] == true) {
       rctBitMatchedQuiet2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
       quietFound = kTRUE;
     }
 
     if (regionEmulHfPlusTau[i] == true && regionDataHfPlusTau[i] == true) {
       rctBitMatchedHfPlusTau2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
       hfPlusTauFound = kTRUE;
     }
 
     //         }
     //       }
 
     if (regFound == kFALSE && regionEmulRank[i] >= 1) {
       int chnl;
 
       bitset<10> bit(regionEmulRank[i]);
       for (size_t n = 0; n < bit.size(); n++) {
         if (n < 5) {
           rctRegBitOff_->Fill(regionEmulEta[i], regionEmulPhi[i] + n * 0.2, bit[n]);
         }
         if (n >= 5) {
           rctRegBitOff_->Fill(regionEmulEta[i] + 0.5, regionEmulPhi[i] + (n - 5) * 0.2, bit[n]);
         }
       }
 
       chnl = PHIBINS * regionEmulEta[i] + regionEmulPhi[i];
       rctRegUnmatchedEmulOcc1D_->Fill(chnl);
       rctRegUnmatchedEmulOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
       // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
 
       if (singlechannelhistos_)
         rctRegIneffChannel_[chnl]->Fill(regionEmulRank[i]);
     }
 
     if (overFlowFound == kFALSE && regionEmulOverFlow[i] == true) {
       rctBitUnmatchedEmulOverFlow2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
     }
 
     if (tauVetoFound == kFALSE && regionEmulTauVeto[i] == true) {
       rctBitUnmatchedEmulTauVeto2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
     }
 
     if (mipFound == kFALSE && regionEmulMip[i] == true) {
       rctBitUnmatchedEmulMip2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
     }
 
     if (quietFound == kFALSE && regionEmulQuiet[i] == true) {
       rctBitUnmatchedEmulQuiet2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
     }
 
     if (hfPlusTauFound == kFALSE && regionEmulHfPlusTau[i] == true) {
       rctBitUnmatchedEmulHfPlusTau2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
     }
   }
 
   DivideME1D(rctRegMatchedOcc1D_, rctRegEmulOcc1D_, rctRegEff1D_);
   DivideME2D(rctRegMatchedOcc2D_, rctRegEmulOcc2D_, rctRegEff2D_);
   //      DivideME1D(rctRegSpEffOcc1D_, rctRegEmulOcc1D_, rctRegSpEff1D_);
   //      DivideME2D(rctRegSpEffOcc2D_, rctRegEmulOcc2D_, rctRegSpEff2D_);
   DivideME1D(rctRegSpEffOcc1D_, rctRegMatchedOcc1D_, rctRegSpEff1D_);
   DivideME2D(rctRegSpEffOcc2D_, rctRegMatchedOcc2D_, rctRegSpEff2D_);
   //      DivideME1D(rctRegSpIneffOcc1D_, rctRegEmulOcc1D_, rctRegSpIneff1D_);
   //      DivideME2D(rctRegSpIneffOcc2D_, rctRegEmulOcc2D_, rctRegSpIneff2D_);
   DivideME1D(rctRegSpIneffOcc1D_, rctRegMatchedOcc1D_, rctRegSpIneff1D_);
   DivideME2D(rctRegSpIneffOcc2D_, rctRegMatchedOcc2D_, rctRegSpIneff2D_);
   DivideME2D(rctBitMatchedOverFlow2D_, rctBitEmulOverFlow2D_, rctBitOverFlowEff2D_);
   DivideME2D(rctBitMatchedTauVeto2D_, rctBitEmulTauVeto2D_, rctBitTauVetoEff2D_);
   DivideME2D(rctBitMatchedMip2D_, rctBitEmulMip2D_, rctBitMipEff2D_);
   // QUIETBIT: To add quiet bit information, uncomment following line:
   // DivideME2D (rctBitMatchedQuiet2D_, rctBitEmulQuiet2D_, rctBitQuietEff2D_);
   DivideME2D(rctBitMatchedHfPlusTau2D_, rctBitEmulHfPlusTau2D_, rctBitHfPlusTauEff2D_);
 
   DivideME1D(rctRegUnmatchedEmulOcc1D_, rctRegEmulOcc1D_, rctRegIneff1D_);
   DivideME2D(rctRegUnmatchedEmulOcc2D_, rctRegEmulOcc2D_, rctRegIneff2D_);
   DivideME2D(rctBitUnmatchedEmulOverFlow2D_, rctBitEmulOverFlow2D_, rctBitOverFlowIneff2D_);
   DivideME2D(rctBitUnmatchedEmulTauVeto2D_, rctBitEmulTauVeto2D_, rctBitTauVetoIneff2D_);
   DivideME2D(rctBitUnmatchedEmulMip2D_, rctBitEmulMip2D_, rctBitMipIneff2D_);
   // QUIETBIT: To add quiet bit information, uncomment the following line:
   // DivideME2D (rctBitUnmatchedEmulQuiet2D_, rctBitEmulQuiet2D_, rctBitQuietIneff2D_);
   DivideME2D(rctBitUnmatchedEmulHfPlusTau2D_, rctBitEmulHfPlusTau2D_, rctBitHfPlusTauIneff2D_);
 
   // for(int i = 0; i < nRegionData; i++)
   for (int i = 0; i < (int)PhiEtaMax; i++) {
     Bool_t regFound = kFALSE;
     Bool_t overFlowFound = kFALSE;
     Bool_t tauVetoFound = kFALSE;
     Bool_t mipFound = kFALSE;
     Bool_t quietFound = kFALSE;
     Bool_t hfPlusTauFound = kFALSE;
 
     //       for(int j = 0; j < nRegionEmul; j++)
     //      {
     //         if(regionEmulEta[j] == regionDataEta[i] &&
     //            regionEmulPhi[j] == regionDataPhi[i])
     //         {
 
     if (regionEmulRank[i] >= 1 && regionDataRank[i] >= 1)
       regFound = kTRUE;
 
     if (regionDataOverFlow[i] == true && regionEmulOverFlow[i] == true)
       overFlowFound = kTRUE;
 
     if (regionDataTauVeto[i] == true && regionEmulTauVeto[i] == true)
       tauVetoFound = kTRUE;
 
     if (regionDataMip[i] == true && regionEmulMip[i] == true)
       mipFound = kTRUE;
 
     if (regionDataQuiet[i] == true && regionEmulQuiet[i] == true)
       quietFound = kTRUE;
 
     if (regionDataHfPlusTau[i] == true && regionEmulHfPlusTau[i] == true)
       hfPlusTauFound = kTRUE;
     //         }
     //       }
 
     if (regFound == kFALSE && regionDataRank[i] >= 1) {
       int chnl;
 
       bitset<10> bit(regionDataRank[i]);
       for (size_t n = 0; n < bit.size(); n++) {
         if (n < 5) {
           rctRegBitOn_->Fill(regionDataEta[i], regionDataPhi[i] + n * 0.2, bit[n]);
         }
         if (n >= 5) {
           rctRegBitOn_->Fill(regionDataEta[i] + 0.5, regionDataPhi[i] + (n - 5) * 0.2, bit[n]);
         }
       }
 
       chnl = PHIBINS * regionDataEta[i] + regionDataPhi[i];
       rctRegUnmatchedDataOcc1D_->Fill(chnl);
       rctRegUnmatchedDataOcc2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
       // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
 
       // we try a new definition of overefficiency:
       // DivideME1D(rctRegUnmatchedDataOcc1D_, rctRegDataOcc1D_, rctRegOvereff1D_);
       // DivideME2D(rctRegUnmatchedDataOcc2D_, rctRegDataOcc2D_, rctRegOvereff2D_);
 
       if (singlechannelhistos_)
         rctRegOvereffChannel_[chnl]->Fill(regionDataRank[i]);
     }
 
     if (overFlowFound == kFALSE && regionDataOverFlow[i] == true) {
       rctBitUnmatchedDataOverFlow2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
     }
 
     if (tauVetoFound == kFALSE && regionDataTauVeto[i] == true) {
       rctBitUnmatchedDataTauVeto2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
     }
 
     if (mipFound == kFALSE && regionDataMip[i] == true) {
       rctBitUnmatchedDataMip2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
     }
 
     if (quietFound == kFALSE && regionDataQuiet[i] == true) {
       rctBitUnmatchedDataQuiet2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
     }
 
     if (hfPlusTauFound == kFALSE && regionDataHfPlusTau[i] == true) {
       rctBitUnmatchedDataHfPlusTau2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
     }
   }
 
   // we try a new definition of overefficiency:
   DivideME1D(rctRegUnmatchedDataOcc1D_, rctRegDataOcc1D_, rctRegOvereff1D_);
   DivideME2D(rctRegUnmatchedDataOcc2D_, rctRegDataOcc2D_, rctRegOvereff2D_);
   DivideME2D(rctBitUnmatchedDataOverFlow2D_, rctBitDataOverFlow2D_, rctBitOverFlowOvereff2D_);
   DivideME2D(rctBitUnmatchedDataTauVeto2D_, rctBitDataTauVeto2D_, rctBitTauVetoOvereff2D_);
   DivideME2D(rctBitUnmatchedDataMip2D_, rctBitDataMip2D_, rctBitMipOvereff2D_);
   // QUIETBIT: To add quiet bit information, uncomment following 2 lines:
   // DivideME2D (rctBitUnmatchedDataQuiet2D_, rctBitDataQuiet2D_,
   // rctBitQuietOvereff2D_);
   DivideME2D(rctBitUnmatchedDataHfPlusTau2D_, rctBitDataHfPlusTau2D_, rctBitHfPlusTauOvereff2D_);
 }

void L1TdeRCT::bookHistograms	(	DQMStore::IBooker &	ibooker,
		const edm::Run &	run,
		const edm::EventSetup &	es
	)

overrideprotectedvirtual

Implements DQMOneEDAnalyzer< edm::LuminosityBlockCache< l1tderct::Empty > >.

Definition at line 1138 of file L1TdeRCT.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), crateFED, dataInputTagName_, ETABINS, ETAMAX, ETAMIN, fedVectorMonitorLS_, fedVectorMonitorRUN_, dqm::impl::MonitorElement::getTH2F(), histFolder_, mps_fire::i, dqmiolumiharvest::j, visualization-live-secondInstance_cfg::m, mergeVDriftHistosByStation::name, nev_, notrigCount, perLSsaving_, PHIBINS, PHIMAX, PHIMIN, rctBitDataHfPlusTau2D_, rctBitDataMip2D_, rctBitDataOverFlow2D_, rctBitDataQuiet2D_, rctBitDataTauVeto2D_, rctBitEmulHfPlusTau2D_, rctBitEmulMip2D_, rctBitEmulOverFlow2D_, rctBitEmulQuiet2D_, rctBitEmulTauVeto2D_, rctBitHfPlusTauEff2D_, rctBitHfPlusTauIneff2D_, rctBitHfPlusTauOvereff2D_, rctBitMatchedHfPlusTau2D_, rctBitMatchedMip2D_, rctBitMatchedOverFlow2D_, rctBitMatchedQuiet2D_, rctBitMatchedTauVeto2D_, rctBitMipEff2D_, rctBitMipIneff2D_, rctBitMipOvereff2D_, rctBitOverFlowEff2D_, rctBitOverFlowIneff2D_, rctBitOverFlowOvereff2D_, rctBitTauVetoEff2D_, rctBitTauVetoIneff2D_, rctBitTauVetoOvereff2D_, rctBitUnmatchedDataHfPlusTau2D_, rctBitUnmatchedDataMip2D_, rctBitUnmatchedDataOverFlow2D_, rctBitUnmatchedDataQuiet2D_, rctBitUnmatchedDataTauVeto2D_, rctBitUnmatchedEmulHfPlusTau2D_, rctBitUnmatchedEmulMip2D_, rctBitUnmatchedEmulOverFlow2D_, rctBitUnmatchedEmulQuiet2D_, rctBitUnmatchedEmulTauVeto2D_, rctInputTPGEcalOcc_, rctInputTPGEcalOccNoCut_, rctInputTPGEcalRank_, rctInputTPGHcalOcc_, rctInputTPGHcalRank_, rctInputTPGHcalSample_, rctIsoEffChannel_, rctIsoEmBitDiff_, rctIsoEmBitOff_, rctIsoEmBitOn_, rctIsoEmDataOcc1D_, rctIsoEmDataOcc_, rctIsoEmEff1_, rctIsoEmEff1Occ1D_, rctIsoEmEff1Occ_, rctIsoEmEff1oneD_, rctIsoEmEff2_, rctIsoEmEff2Occ1D_, rctIsoEmEff2Occ_, rctIsoEmEff2oneD_, rctIsoEmEmulOcc1D_, rctIsoEmEmulOcc_, rctIsoEmIneff1D_, rctIsoEmIneff2_, rctIsoEmIneff2Occ1D_, rctIsoEmIneff2Occ_, rctIsoEmIneff2oneD_, rctIsoEmIneff_, rctIsoEmIneffOcc1D_, rctIsoEmIneffOcc_, rctIsoEmOvereff1D_, rctIsoEmOvereff_, rctIsoEmOvereffOcc1D_, rctIsoEmOvereffOcc_, rctIsoIneffChannel_, rctIsoOvereffChannel_, rctNisoEffChannel_, rctNIsoEmBitDiff_, rctNIsoEmBitOff_, rctNIsoEmBitOn_, rctNisoEmDataOcc1D_, rctNisoEmDataOcc_, rctNisoEmEff1_, rctNisoEmEff1Occ1D_, rctNisoEmEff1Occ_, rctNisoEmEff1oneD_, rctNisoEmEff2_, rctNisoEmEff2Occ1D_, rctNisoEmEff2Occ_, rctNisoEmEff2oneD_, rctNisoEmEmulOcc1D_, rctNisoEmEmulOcc_, rctNisoEmIneff1D_, rctNisoEmIneff2_, rctNisoEmIneff2Occ1D_, rctNisoEmIneff2Occ_, rctNisoEmIneff2oneD_, rctNisoEmIneff_, rctNisoEmIneffOcc1D_, rctNisoEmIneffOcc_, rctNisoEmOvereff1D_, rctNisoEmOvereff_, rctNisoEmOvereffOcc1D_, rctNisoEmOvereffOcc_, rctNisoIneffChannel_, rctNisoOvereffChannel_, rctRegBitDiff_, rctRegBitOff_, rctRegBitOn_, rctRegDataOcc1D_, rctRegDataOcc2D_, rctRegEff1D_, rctRegEff2D_, rctRegEffChannel_, rctRegEmulOcc1D_, rctRegEmulOcc2D_, rctRegIneff1D_, rctRegIneff2D_, rctRegIneffChannel_, rctRegMatchedOcc1D_, rctRegMatchedOcc2D_, rctRegOvereff1D_, rctRegOvereff2D_, rctRegOvereffChannel_, rctRegSpEff1D_, rctRegSpEff2D_, rctRegSpEffOcc1D_, rctRegSpEffOcc2D_, rctRegSpIneff1D_, rctRegSpIneff2D_, rctRegSpIneffOcc1D_, rctRegSpIneffOcc2D_, rctRegUnmatchedDataOcc1D_, rctRegUnmatchedDataOcc2D_, rctRegUnmatchedEmulOcc1D_, rctRegUnmatchedEmulOcc2D_, readFEDVector(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), singlechannelhistos_, trigCount, trigEff_, trigEffOcc_, trigEffThresh_, trigEffThreshOcc_, trigEffTriggOcc_, trigEffTriggThreshOcc_, triggerAlgoNumbers_, and triggerType_.

                                                                                                   {
   // get hold of back-end interface
   nev_ = 0;
   //DQMStore *dbe = 0;
   //dbe = Service < DQMStore > ().operator->();
 
   //if (dbe) {
   //  dbe->setCurrentFolder(histFolder_);
   //  dbe->rmdir(histFolder_);
   //}
 
   //if (dbe) {
 
   ibooker.setCurrentFolder(histFolder_);
 
   triggerType_ = ibooker.book1D("TriggerType", "TriggerType", 17, -0.5, 16.5);
 
   triggerAlgoNumbers_ = ibooker.book1D("gtTriggerAlgoNumbers", "gtTriggerAlgoNumbers", 128, -0.5, 127.5);
 
   rctInputTPGEcalOcc_ = ibooker.book2D(
       "rctInputTPGEcalOcc", "rctInputTPGEcalOcc", TPGETABINS, TPGETAMIN, TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);
 
   rctInputTPGEcalOccNoCut_ = ibooker.book2D("rctInputTPGEcalOccNoCut",
                                             "rctInputTPGEcalOccNoCut",
                                             TPGETABINS,
                                             TPGETAMIN,
                                             TPGETAMAX,
                                             TPGPHIBINS,
                                             TPGPHIMIN,
                                             TPGPHIMAX);
 
   rctInputTPGEcalRank_ = ibooker.book1D("rctInputTPGEcalRank", "rctInputTPGEcalRank", TPGRANK, TPGRANKMIN, TPGRANKMAX);
 
   rctInputTPGHcalOcc_ = ibooker.book2D(
       "rctInputTPGHcalOcc", "rctInputTPGHcalOcc", TPGETABINS, TPGETAMIN, TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);
 
   rctInputTPGHcalSample_ = ibooker.book1D("rctInputTPGHcalSample", "rctInputTPGHcalSample", 10, -0.5, 9.5);
 
   rctInputTPGHcalRank_ = ibooker.book1D("rctInputTPGHcalRank", "rctInputTPGHcalRank", TPGRANK, TPGRANKMIN, TPGRANKMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/EffCurves/NisoEm/");
 
   trigEffThresh_ = ibooker.book2D("trigEffThresh",
                                   "Rank occupancy >= 2x trig thresh (source: " + dataInputTagName_ + ")",
                                   ETABINS,
                                   ETAMIN,
                                   ETAMAX,
                                   PHIBINS,
                                   PHIMIN,
                                   PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/EffCurves/NisoEm/ServiceData");
 
   trigEffThreshOcc_ = ibooker.book2D("trigEffThreshOcc",
                                      "Rank occupancy >= 2x trig thresh (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
   trigEffTriggThreshOcc_ =
       ibooker.book2D("trigEffTriggThreshOcc",
                      "Rank occupancy >= 2x trig thresh, triggered (source: " + dataInputTagName_ + ")",
                      ETABINS,
                      ETAMIN,
                      ETAMAX,
                      PHIBINS,
                      PHIMIN,
                      PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/IsoEm");
 
   rctIsoEmEff1_ = ibooker.book2D("rctIsoEmEff1",
                                  "rctIsoEmEff1 (source: " + dataInputTagName_ + ")",
                                  ETABINS,
                                  ETAMIN,
                                  ETAMAX,
                                  PHIBINS,
                                  PHIMIN,
                                  PHIMAX);
 
   rctIsoEmEff1oneD_ = ibooker.book1D("rctIsoEmEff1oneD", "rctIsoEmEff1oneD", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEff2_ = ibooker.book2D("rctIsoEmEff2",
                                  "rctIsoEmEff2, energy matching required (source: " + dataInputTagName_ + ")",
                                  ETABINS,
                                  ETAMIN,
                                  ETAMAX,
                                  PHIBINS,
                                  PHIMIN,
                                  PHIMAX);
 
   rctIsoEmEff2oneD_ =
       ibooker.book1D("rctIsoEmEff2oneD", "rctIsoEmEff2oneD, energy matching required", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmIneff2_ = ibooker.book2D("rctIsoEmIneff2",
                                    "rctIsoEmIneff2, energy matching required (source: " + dataInputTagName_ + ")",
                                    ETABINS,
                                    ETAMIN,
                                    ETAMAX,
                                    PHIBINS,
                                    PHIMIN,
                                    PHIMAX);
 
   rctIsoEmIneff2oneD_ =
       ibooker.book1D("rctIsoEmIneff2oneD", "rctIsoEmIneff2oneD, energy matching required", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmIneff_ = ibooker.book2D("rctIsoEmIneff",
                                   "rctIsoEmIneff (source: " + dataInputTagName_ + ")",
                                   ETABINS,
                                   ETAMIN,
                                   ETAMAX,
                                   PHIBINS,
                                   PHIMIN,
                                   PHIMAX);
 
   rctIsoEmIneff1D_ = ibooker.book1D("rctIsoEmIneff1D", "rctIsoEmIneff1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmOvereff_ = ibooker.book2D("rctIsoEmOvereff",
                                     "rctIsoEmOvereff (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctIsoEmOvereff1D_ = ibooker.book1D("rctIsoEmOvereff1D", "rctIsoEmOvereff1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/IsoEm/ServiceData");
 
   rctIsoEmDataOcc_ = ibooker.book2D("rctIsoEmDataOcc",
                                     "rctIsoEmDataOcc (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctIsoEmDataOcc1D_ = ibooker.book1D("rctIsoEmDataOcc1D", "rctIsoEmDataOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEmulOcc_ = ibooker.book2D("rctIsoEmEmulOcc",
                                     "rctIsoEmEmulOcc (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctIsoEmEmulOcc1D_ = ibooker.book1D("rctIsoEmEmulOcc1D", "rctIsoEmEmulOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEff1Occ_ = ibooker.book2D("rctIsoEmEff1Occ",
                                     "rctIsoEmEff1Occ (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctIsoEmEff1Occ1D_ = ibooker.book1D("rctIsoEmEff1Occ1D", "rctIsoEmEff1Occ1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEff2Occ_ = ibooker.book2D("rctIsoEmEff2Occ",
                                     "rctIsoEmEff2Occ (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctIsoEmEff2Occ1D_ = ibooker.book1D("rctIsoEmEff2Occ1D", "rctIsoEmEff2Occ1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmIneff2Occ_ = ibooker.book2D("rctIsoEmIneff2Occ",
                                       "rctIsoEmIneff2Occ (source: " + dataInputTagName_ + ")",
                                       ETABINS,
                                       ETAMIN,
                                       ETAMAX,
                                       PHIBINS,
                                       PHIMIN,
                                       PHIMAX);
 
   rctIsoEmIneff2Occ1D_ = ibooker.book1D("rctIsoEmIneff2Occ1D", "rctIsoEmIneff2Occ1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmIneffOcc_ = ibooker.book2D("rctIsoEmIneffOcc",
                                      "rctIsoEmIneffOcc (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctIsoEmIneffOcc1D_ = ibooker.book1D("rctIsoEmIneffOcc1D", "rctIsoEmIneffOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmOvereffOcc_ = ibooker.book2D("rctIsoEmOvereffOcc",
                                        "rctIsoEmOvereffOcc (source: " + dataInputTagName_ + ")",
                                        ETABINS,
                                        ETAMIN,
                                        ETAMAX,
                                        PHIBINS,
                                        PHIMIN,
                                        PHIMAX);
 
   rctIsoEmOvereffOcc1D_ = ibooker.book1D("rctIsoEmOvereffOcc1D", "rctIsoEmOvereffOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/NisoEm");
   rctNisoEmEff1_ = ibooker.book2D("rctNisoEmEff1",
                                   "rctNisoEmEff1 (source: " + dataInputTagName_ + ")",
                                   ETABINS,
                                   ETAMIN,
                                   ETAMAX,
                                   PHIBINS,
                                   PHIMIN,
                                   PHIMAX);
 
   rctNisoEmEff1oneD_ = ibooker.book1D("rctNisoEmEff1oneD", "rctNisoEmEff1oneD", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEff2_ = ibooker.book2D("rctNisoEmEff2",
                                   "rctNisoEmEff2, energy matching required (source: " + dataInputTagName_ + ")",
                                   ETABINS,
                                   ETAMIN,
                                   ETAMAX,
                                   PHIBINS,
                                   PHIMIN,
                                   PHIMAX);
 
   rctNisoEmEff2oneD_ =
       ibooker.book1D("rctNisoEmEff2oneD", "rctNisoEmEff2oneD, energy matching required", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmIneff2_ = ibooker.book2D("rctNisoEmIneff2",
                                     "rctNisoEmIneff2, energy matching required (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctNisoEmIneff2oneD_ = ibooker.book1D(
       "rctNisoEmIneff2oneD", "rctNisoEmIneff2oneD, energy matching required", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmIneff_ = ibooker.book2D("rctNisoEmIneff",
                                    "rctNisoEmIneff (source: " + dataInputTagName_ + ")",
                                    ETABINS,
                                    ETAMIN,
                                    ETAMAX,
                                    PHIBINS,
                                    PHIMIN,
                                    PHIMAX);
 
   rctNisoEmIneff1D_ = ibooker.book1D("rctNisoEmIneff1D", "rctNisoEmIneff1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmOvereff_ = ibooker.book2D("rctNisoEmOvereff",
                                      "rctNisoEmOvereff (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctNisoEmOvereff1D_ = ibooker.book1D("rctNisoEmOvereff1D", "rctNisoEmOvereff1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/NisoEm/ServiceData");
 
   rctNisoEmDataOcc_ = ibooker.book2D("rctNisoEmDataOcc",
                                      "rctNisoEmDataOcc (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctNisoEmDataOcc1D_ = ibooker.book1D("rctNisoEmDataOcc1D", "rctNisoEmDataOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEmulOcc_ = ibooker.book2D("rctNisoEmEmulOcc",
                                      "rctNisoEmEmulOcc (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctNisoEmEmulOcc1D_ = ibooker.book1D("rctNisoEmEmulOcc1D", "rctNisoEmEmulOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEff1Occ_ = ibooker.book2D("rctNisoEmEff1Occ",
                                      "rctNisoEmEff1Occ (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctNisoEmEff1Occ1D_ = ibooker.book1D("rctNisoEmEff1Occ1D", "rctNisoEmEff1Occ1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEff2Occ_ = ibooker.book2D("rctNisoEmEff2Occ",
                                      "rctNisoEmEff2Occ (source: " + dataInputTagName_ + ")",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctNisoEmEff2Occ1D_ = ibooker.book1D("rctNisoEmEff2Occ1D", "rctNisoEmEff2Occ1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmIneff2Occ_ = ibooker.book2D("rctNisoEmIneff2Occ",
                                        "rctNisoEmIneff2Occ (source: " + dataInputTagName_ + ")",
                                        ETABINS,
                                        ETAMIN,
                                        ETAMAX,
                                        PHIBINS,
                                        PHIMIN,
                                        PHIMAX);
 
   rctNisoEmIneff2Occ1D_ = ibooker.book1D("rctNisoEmIneff2Occ1D", "rctNisoEmIneff2Occ1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmIneffOcc_ = ibooker.book2D("rctNisoEmIneffOcc",
                                       "rctNisoEmIneffOcc (source: " + dataInputTagName_ + ")",
                                       ETABINS,
                                       ETAMIN,
                                       ETAMAX,
                                       PHIBINS,
                                       PHIMIN,
                                       PHIMAX);
 
   rctNisoEmIneffOcc1D_ = ibooker.book1D("rctNisoEmIneffOcc1D", "rctNisoEmIneffOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmOvereffOcc_ = ibooker.book2D("rctNisoEmOvereffOcc",
                                         "rctNisoEmOvereffOcc (source: " + dataInputTagName_ + ")",
                                         ETABINS,
                                         ETAMIN,
                                         ETAMAX,
                                         PHIBINS,
                                         PHIMIN,
                                         PHIMAX);
 
   rctNisoEmOvereffOcc1D_ = ibooker.book1D("rctNisoEmOvereffOcc1D", "rctNisoEmOvereffOcc1D", CHNLBINS, CHNLMIN, CHNLMAX);
 
   // region information
   ibooker.setCurrentFolder(histFolder_ + "/RegionData");
 
   rctRegEff1D_ = ibooker.book1D("rctRegEff1D", "1D region efficiency", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegIneff1D_ = ibooker.book1D("rctRegIneff1D", "1D region inefficiency", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegOvereff1D_ = ibooker.book1D("rctRegOvereff1D", "1D region overefficiency", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegSpEff1D_ =
       ibooker.book1D("rctRegSpEff1D", "1D region efficiency, energy matching required", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegSpIneff1D_ =
       ibooker.book1D("rctRegSpIneff1D", "1D region inefficiency, energy matching required", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegEff2D_ = ibooker.book2D("rctRegEff2D",
                                 "2D region efficiency (source: " + dataInputTagName_ + ")",
                                 ETABINS,
                                 ETAMIN,
                                 ETAMAX,
                                 PHIBINS,
                                 PHIMIN,
                                 PHIMAX);
 
   rctRegIneff2D_ = ibooker.book2D("rctRegIneff2D",
                                   "2D region inefficiency (source: " + dataInputTagName_ + ")",
                                   ETABINS,
                                   ETAMIN,
                                   ETAMAX,
                                   PHIBINS,
                                   PHIMIN,
                                   PHIMAX);
 
   rctRegOvereff2D_ = ibooker.book2D("rctRegOvereff2D",
                                     "2D region overefficiency (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctRegSpEff2D_ = ibooker.book2D("rctRegSpEff2D",
                                   "2D region efficiency, energy matching required (source: " + dataInputTagName_ + ")",
                                   ETABINS,
                                   ETAMIN,
                                   ETAMAX,
                                   PHIBINS,
                                   PHIMIN,
                                   PHIMAX);
 
   rctRegSpIneff2D_ =
       ibooker.book2D("rctRegSpIneff2D",
                      "2D region inefficiency, energy matching required (source: " + dataInputTagName_ + ")",
                      ETABINS,
                      ETAMIN,
                      ETAMAX,
                      PHIBINS,
                      PHIMIN,
                      PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/RegionData/ServiceData");
 
   rctRegDataOcc1D_ = ibooker.book1D("rctRegDataOcc1D", "1D region occupancy from data", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegEmulOcc1D_ = ibooker.book1D("rctRegEmulOcc1D", "1D region occupancy from emulator", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegMatchedOcc1D_ =
       ibooker.book1D("rctRegMatchedOcc1D", "1D region occupancy for matched hits", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegUnmatchedDataOcc1D_ = ibooker.book1D(
       "rctRegUnmatchedDataOcc1D", "1D region occupancy for unmatched hardware hits", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegUnmatchedEmulOcc1D_ = ibooker.book1D(
       "rctRegUnmatchedEmulOcc1D", "1D region occupancy for unmatched emulator hits", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegSpEffOcc1D_ = ibooker.book1D(
       "rctRegSpEffOcc1D", "1D region occupancy for \\Delta E_{T} efficiency", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegSpIneffOcc1D_ = ibooker.book1D(
       "rctRegSpIneffOcc1D", "1D region occupancy for \\Delta E_{T} efficiency ", CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctRegDataOcc2D_ = ibooker.book2D("rctRegDataOcc2D",
                                     "2D region occupancy from hardware (source: " + dataInputTagName_ + ")",
                                     ETABINS,
                                     ETAMIN,
                                     ETAMAX,
                                     PHIBINS,
                                     PHIMIN,
                                     PHIMAX);
 
   rctRegEmulOcc2D_ = ibooker.book2D(
       "rctRegEmulOcc2D", "2D region occupancy from emulator", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctRegMatchedOcc2D_ = ibooker.book2D(
       "rctRegMatchedOcc2D", "2D region occupancy for matched hits", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctRegUnmatchedDataOcc2D_ = ibooker.book2D("rctRegUnmatchedDataOcc2D",
                                              "2D region occupancy for unmatched hardware hits",
                                              ETABINS,
                                              ETAMIN,
                                              ETAMAX,
                                              PHIBINS,
                                              PHIMIN,
                                              PHIMAX);
 
   rctRegUnmatchedEmulOcc2D_ = ibooker.book2D("rctRegUnmatchedEmulOcc2D",
                                              "2D region occupancy for unmatched emulator hits",
                                              ETABINS,
                                              ETAMIN,
                                              ETAMAX,
                                              PHIBINS,
                                              PHIMIN,
                                              PHIMAX);
 
   //    rctRegDeltaEt2D_ =
   //      dbe->book2D("rctRegDeltaEt2D", " \\Delta E_{T}  for each channel",
   //      CHNLBINS, CHNLMIN, CHNLMAX, 100, -50., 50.);
 
   rctRegSpEffOcc2D_ = ibooker.book2D("rctRegSpEffOcc2D",
                                      "2D region occupancy for \\Delta E_{T} efficiency",
                                      ETABINS,
                                      ETAMIN,
                                      ETAMAX,
                                      PHIBINS,
                                      PHIMIN,
                                      PHIMAX);
 
   rctRegSpIneffOcc2D_ = ibooker.book2D("rctRegSpIneffOcc2D",
                                        "2D region occupancy for \\Delta E_{T} inefficiency",
                                        ETABINS,
                                        ETAMIN,
                                        ETAMAX,
                                        PHIBINS,
                                        PHIMIN,
                                        PHIMAX);
 
   // bit information
   ibooker.setCurrentFolder(histFolder_ + "/BitData");
 
   rctBitOverFlowEff2D_ = ibooker.book2D("rctBitOverFlowEff2D",
                                         "2D overflow bit efficiency (source: " + dataInputTagName_ + ")",
                                         ETABINS,
                                         ETAMIN,
                                         ETAMAX,
                                         PHIBINS,
                                         PHIMIN,
                                         PHIMAX);
 
   rctBitOverFlowIneff2D_ = ibooker.book2D("rctBitOverFlowIneff2D",
                                           "2D overflow bit inefficiency (source: " + dataInputTagName_ + ")",
                                           ETABINS,
                                           ETAMIN,
                                           ETAMAX,
                                           PHIBINS,
                                           PHIMIN,
                                           PHIMAX);
 
   rctBitOverFlowOvereff2D_ = ibooker.book2D("rctBitOverFlowOvereff2D",
                                             "2D overflow bit overefficiency (source: " + dataInputTagName_ + ")",
                                             ETABINS,
                                             ETAMIN,
                                             ETAMAX,
                                             PHIBINS,
                                             PHIMIN,
                                             PHIMAX);
 
   rctBitTauVetoEff2D_ = ibooker.book2D("rctBitTauVetoEff2D",
                                        "2D tau veto bit efficiency (source: " + dataInputTagName_ + ")",
                                        ETABINS,
                                        ETAMIN,
                                        ETAMAX,
                                        PHIBINS,
                                        PHIMIN,
                                        PHIMAX);
 
   rctBitTauVetoIneff2D_ = ibooker.book2D("rctBitTauVetoIneff2D",
                                          "2D tau veto bit inefficiency (source: " + dataInputTagName_ + ")",
                                          ETABINS,
                                          ETAMIN,
                                          ETAMAX,
                                          PHIBINS,
                                          PHIMIN,
                                          PHIMAX);
 
   rctBitTauVetoOvereff2D_ = ibooker.book2D("rctBitTauVetoOvereff2D",
                                            "2D tau veto bit overefficiency (source: " + dataInputTagName_ + ")",
                                            ETABINS,
                                            ETAMIN,
                                            ETAMAX,
                                            PHIBINS,
                                            PHIMIN,
                                            PHIMAX);
 
   rctBitMipEff2D_ =
       ibooker.book2D("rctBitMipEff2D", "2D mip bit efficiency", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitMipIneff2D_ =
       ibooker.book2D("rctBitMipIneff2D", "2D mip bit inefficiency", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitMipOvereff2D_ = ibooker.book2D(
       "rctBitMipOvereff2D", "2D mip bit overefficiency", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   // QUIETBIT: To add quiet bit information, uncomment following 11 lines:
   // rctBitQuietEff2D_ =
   // dbe->book2D("rctBitQuietEff2D", "2D quiet bit efficiency",
   // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   // rctBitQuietIneff2D_ =
   // dbe->book2D("rctBitQuietIneff2D", "2D quiet bit inefficiency",
   // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   // rctBitQuietOvereff2D_ =
   // dbe->book2D("rctBitQuietOvereff2D", "2D quiet bit overefficiency",
   // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitHfPlusTauEff2D_ = ibooker.book2D("rctBitHfPlusTauEff2D",
                                          "2D HfPlusTau bit efficiency (source: " + dataInputTagName_ + ")",
                                          ETABINS,
                                          ETAMIN,
                                          ETAMAX,
                                          PHIBINS,
                                          PHIMIN,
                                          PHIMAX);
 
   rctBitHfPlusTauIneff2D_ = ibooker.book2D("rctBitHfPlusTauIneff2D",
                                            "2D HfPlusTau bit inefficiency (source: " + dataInputTagName_ + ")",
                                            ETABINS,
                                            ETAMIN,
                                            ETAMAX,
                                            PHIBINS,
                                            PHIMIN,
                                            PHIMAX);
 
   rctBitHfPlusTauOvereff2D_ = ibooker.book2D("rctBitHfPlusTauOvereff2D",
                                              "2D HfPlusTau bit overefficiency (source: " + dataInputTagName_ + ")",
                                              ETABINS,
                                              ETAMIN,
                                              ETAMAX,
                                              PHIBINS,
                                              PHIMIN,
                                              PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/BitData/ServiceData");
 
   rctBitEmulOverFlow2D_ = ibooker.book2D(
       "rctBitEmulOverFlow2D", "2D overflow bit from emulator", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitDataOverFlow2D_ = ibooker.book2D("rctBitDataOverFlow2D",
                                          "2D overflow bit from hardware (source: " + dataInputTagName_ + ")",
                                          ETABINS,
                                          ETAMIN,
                                          ETAMAX,
                                          PHIBINS,
                                          PHIMIN,
                                          PHIMAX);
 
   rctBitMatchedOverFlow2D_ = ibooker.book2D(
       "rctBitMatchedOverFlow2D", "2D overflow bit for matched hits", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitUnmatchedEmulOverFlow2D_ = ibooker.book2D("rctBitUnmatchedEmulOverFlow2D",
                                                   "2D overflow bit for unmatched emulator hits",
                                                   ETABINS,
                                                   ETAMIN,
                                                   ETAMAX,
                                                   PHIBINS,
                                                   PHIMIN,
                                                   PHIMAX);
 
   rctBitUnmatchedDataOverFlow2D_ = ibooker.book2D("rctBitUnmatchedDataOverFlow2D",
                                                   "2D overflow bit for unmatched hardware hits",
                                                   ETABINS,
                                                   ETAMIN,
                                                   ETAMAX,
                                                   PHIBINS,
                                                   PHIMIN,
                                                   PHIMAX);
 
   rctBitEmulTauVeto2D_ = ibooker.book2D(
       "rctBitEmulTauVeto2D", "2D tau veto bit from emulator", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitDataTauVeto2D_ = ibooker.book2D("rctBitDataTauVeto2D",
                                         "2D tau veto bit from hardware (source: " + dataInputTagName_ + ")",
                                         ETABINS,
                                         ETAMIN,
                                         ETAMAX,
                                         PHIBINS,
                                         PHIMIN,
                                         PHIMAX);
 
   rctBitMatchedTauVeto2D_ = ibooker.book2D(
       "rctBitMatchedTauVeto2D", "2D tau veto bit for matched hits", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitUnmatchedEmulTauVeto2D_ = ibooker.book2D("rctBitUnmatchedEmulTauVeto2D",
                                                  "2D tau veto bit for unmatched emulator hits",
                                                  ETABINS,
                                                  ETAMIN,
                                                  ETAMAX,
                                                  PHIBINS,
                                                  PHIMIN,
                                                  PHIMAX);
 
   rctBitUnmatchedDataTauVeto2D_ = ibooker.book2D("rctBitUnmatchedDataTauVeto2D",
                                                  "2D tau veto bit for unmatched hardware hits",
                                                  ETABINS,
                                                  ETAMIN,
                                                  ETAMAX,
                                                  PHIBINS,
                                                  PHIMIN,
                                                  PHIMAX);
 
   rctBitEmulMip2D_ =
       ibooker.book2D("rctBitEmulMip2D", "2D mip bit from emulator", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitDataMip2D_ =
       ibooker.book2D("rctBitDataMip2D", "2D mip bit from hardware", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitMatchedMip2D_ = ibooker.book2D(
       "rctBitMatchedMip2D", "2D mip bit for matched hits", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitUnmatchedEmulMip2D_ = ibooker.book2D("rctBitUnmatchedEmulMip2D",
                                              "2D mip bit for unmatched emulator hits",
                                              ETABINS,
                                              ETAMIN,
                                              ETAMAX,
                                              PHIBINS,
                                              PHIMIN,
                                              PHIMAX);
 
   rctBitUnmatchedDataMip2D_ = ibooker.book2D("rctBitUnmatchedDataMip2D",
                                              "2D mip bit for unmatched hardware hits",
                                              ETABINS,
                                              ETAMIN,
                                              ETAMAX,
                                              PHIBINS,
                                              PHIMIN,
                                              PHIMAX);
 
   rctBitEmulQuiet2D_ = ibooker.book2D(
       "rctBitEmulQuiet2D", "2D quiet bit from emulator", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitDataQuiet2D_ = ibooker.book2D(
       "rctBitDataQuiet2D", "2D quiet bit from hardware", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitMatchedQuiet2D_ = ibooker.book2D(
       "rctBitMatchedQuiet2D", "2D quiet bit for matched hits", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitUnmatchedEmulQuiet2D_ = ibooker.book2D("rctBitUnmatchedEmulQuiet2D",
                                                "2D quiet bit for unmatched emulator hits",
                                                ETABINS,
                                                ETAMIN,
                                                ETAMAX,
                                                PHIBINS,
                                                PHIMIN,
                                                PHIMAX);
 
   rctBitUnmatchedDataQuiet2D_ = ibooker.book2D("rctBitUnmatchedDataQuiet2D",
                                                "2D quiet bit for unmatched hardware hits",
                                                ETABINS,
                                                ETAMIN,
                                                ETAMAX,
                                                PHIBINS,
                                                PHIMIN,
                                                PHIMAX);
 
   rctBitEmulHfPlusTau2D_ = ibooker.book2D(
       "rctBitEmulHfPlusTau2D", "2D HfPlusTau bit from emulator", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitDataHfPlusTau2D_ = ibooker.book2D("rctBitDataHfPlusTau2D",
                                           "2D HfPlusTau bit from hardware (source: " + dataInputTagName_ + ")",
                                           ETABINS,
                                           ETAMIN,
                                           ETAMAX,
                                           PHIBINS,
                                           PHIMIN,
                                           PHIMAX);
 
   rctBitMatchedHfPlusTau2D_ = ibooker.book2D(
       "rctBitMatchedHfPlusTau2D", "2D HfPlusTau bit for matched hits", ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitUnmatchedEmulHfPlusTau2D_ = ibooker.book2D("rctBitUnmatchedEmulHfPlusTau2D",
                                                    "2D HfPlusTau bit for unmatched emulator hits",
                                                    ETABINS,
                                                    ETAMIN,
                                                    ETAMAX,
                                                    PHIBINS,
                                                    PHIMIN,
                                                    PHIMAX);
 
   rctBitUnmatchedDataHfPlusTau2D_ = ibooker.book2D("rctBitUnmatchedDataHfPlusTau2D",
                                                    "2D HfPlusTau bit for unmatched hardware hits",
                                                    ETABINS,
                                                    ETAMIN,
                                                    ETAMAX,
                                                    PHIBINS,
                                                    PHIMIN,
                                                    PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/BitMon");
   rctRegBitOn_ = ibooker.book2D("rctRegBitOn",
                                 "Monitoring for Bits Stuck On",
                                 BITETABINS,
                                 BITETAMIN,
                                 BITETAMAX,
                                 BITRPHIBINS,
                                 BITRPHIMIN,
                                 BITRPHIMAX);
 
   rctRegBitOff_ = ibooker.book2D("rctRegBitOff",
                                  "Monitoring for Bits Stuck Off",
                                  BITETABINS,
                                  BITETAMIN,
                                  BITETAMAX,
                                  BITRPHIBINS,
                                  BITRPHIMIN,
                                  BITRPHIMAX);
 
   rctRegBitDiff_ = ibooker.book2D("rctRegBitDiff",
                                   "Monitoring for Bits Difference",
                                   BITETABINS,
                                   BITETAMIN,
                                   BITETAMAX,
                                   BITRPHIBINS,
                                   BITRPHIMIN,
                                   BITRPHIMAX);
 
   rctIsoEmBitOn_ = ibooker.book2D("rctIsoEmBitOn",
                                   "Monitoring for Bits Stuck On",
                                   BITETABINS,
                                   BITETAMIN,
                                   BITETAMAX,
                                   BITPHIBINS,
                                   BITPHIMIN,
                                   BITPHIMAX);
 
   rctIsoEmBitOff_ = ibooker.book2D("rctIsoEmBitOff",
                                    "Monitoring for Bits Stuck Off",
                                    BITETABINS,
                                    BITETAMIN,
                                    BITETAMAX,
                                    BITPHIBINS,
                                    BITPHIMIN,
                                    BITPHIMAX);
 
   rctIsoEmBitDiff_ = ibooker.book2D("rctIsoEmBitDiff",
                                     "Monitoring for Bits Difference",
                                     BITETABINS,
                                     BITETAMIN,
                                     BITETAMAX,
                                     BITPHIBINS,
                                     BITPHIMIN,
                                     BITPHIMAX);
 
   rctNIsoEmBitOn_ = ibooker.book2D("rctNIsoEmBitOn",
                                    "Monitoring for Bits Stuck On",
                                    BITETABINS,
                                    BITETAMIN,
                                    BITETAMAX,
                                    BITPHIBINS,
                                    BITPHIMIN,
                                    BITPHIMAX);
 
   rctNIsoEmBitOff_ = ibooker.book2D("rctNIsoEmBitOff",
                                     "Monitoring for Bits Stuck Off",
                                     BITETABINS,
                                     BITETAMIN,
                                     BITETAMAX,
                                     BITPHIBINS,
                                     BITPHIMIN,
                                     BITPHIMAX);
 
   rctNIsoEmBitDiff_ = ibooker.book2D("rctNIsoEmBitDiff",
                                      "Monitoring for Bits Difference",
                                      BITETABINS,
                                      BITETAMIN,
                                      BITETAMAX,
                                      BITPHIBINS,
                                      BITPHIMIN,
                                      BITPHIMAX);
 
   ibooker.setCurrentFolder(histFolder_ + "/DBData");
   fedVectorMonitorRUN_ = ibooker.book2D("rctFedVectorMonitorRUN", "FED Vector Monitor Per Run", 108, 0, 108, 2, 0, 2);
   if (!perLSsaving_)
     fedVectorMonitorLS_ = ibooker.book2D("rctFedVectorMonitorLS", "FED Vector Monitor Per LS", 108, 0, 108, 2, 0, 2);
 
   for (unsigned int i = 0; i < 108; ++i) {
     char fed[10];
     sprintf(fed, "%d", crateFED[i]);
     fedVectorMonitorRUN_->setBinLabel(i + 1, fed);
     if (!perLSsaving_)
       fedVectorMonitorLS_->setBinLabel(i + 1, fed);
   }
   fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(1, "OUT");
   fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(2, "IN");
   if (!perLSsaving_) {
     fedVectorMonitorLS_->getTH2F()->GetYaxis()->SetBinLabel(1, "OUT");
     fedVectorMonitorLS_->getTH2F()->GetYaxis()->SetBinLabel(2, "IN");
   }
 
   // for single channels
 
   if (singlechannelhistos_) {
     for (int m = 0; m < 12; m++) {
       if (m == 0)
         ibooker.setCurrentFolder(histFolder_ + "/IsoEm/ServiceData/Eff1SnglChnls");
       if (m == 1)
         ibooker.setCurrentFolder(histFolder_ + "/NisoEm/ServiceData/Eff1SnglChnls");
       if (m == 2)
         ibooker.setCurrentFolder(histFolder_ + "/RegionData/ServiceData/EffSnglChnls");
       if (m == 3)
         ibooker.setCurrentFolder(histFolder_ + "/IsoEm/ServiceData/IneffSnglChnls");
       if (m == 4)
         ibooker.setCurrentFolder(histFolder_ + "/NisoEm/ServiceData/IneffSnglChnls");
       if (m == 5)
         ibooker.setCurrentFolder(histFolder_ + "/RegionData/ServiceData/IneffSnglChnls");
       if (m == 6)
         ibooker.setCurrentFolder(histFolder_ + "/IsoEm/ServiceData/OvereffSnglChnls");
       if (m == 7)
         ibooker.setCurrentFolder(histFolder_ + "/NisoEm/ServiceData/OvereffSnglChnls");
       if (m == 8)
         ibooker.setCurrentFolder(histFolder_ + "/RegionData/ServiceData/OvereffSnglChnls");
       if (m == 9)
         ibooker.setCurrentFolder(histFolder_ + "/EffCurves/NisoEm/ServiceData/SingleChannels");
       if (m == 10)
         ibooker.setCurrentFolder(histFolder_ + "/EffCurves/NisoEm/ServiceData/SingleChannels");
       if (m == 11)
         ibooker.setCurrentFolder(histFolder_ + "/EffCurves/NisoEm/ServiceData/SingleChannels");
 
       for (int i = 0; i < ETAMAX; i++) {
         for (int j = 0; j < PHIMAX; j++) {
           char name[80], channel[80] = {""};
 
           if (m == 0)
             strcpy(name, "(Eemul-Edata)Chnl");
           if (m == 1)
             strcpy(name, "(Eemul-Edata)Chnl");
           if (m == 2)
             strcpy(name, "(Eemul-Edata)Chnl");
           if (m == 3)
             strcpy(name, "EemulChnl");
           if (m == 4)
             strcpy(name, "EemulChnl");
           if (m == 5)
             strcpy(name, "EemulChnl");
           if (m == 6)
             strcpy(name, "EdataChnl");
           if (m == 7)
             strcpy(name, "EdataChnl");
           if (m == 8)
             strcpy(name, "EdataChnl");
           if (m == 9)
             strcpy(name, "EemulChnlEff");
           if (m == 10)
             strcpy(name, "EemulChnlTrig");
           if (m == 11)
             strcpy(name, "EemulChnl");
 
           if (i < 10 && j < 10)
             sprintf(channel, "_0%d0%d", i, j);
           else if (i < 10)
             sprintf(channel, "_0%d%d", i, j);
           else if (j < 10)
             sprintf(channel, "_%d0%d", i, j);
           else
             sprintf(channel, "_%d%d", i, j);
           strcat(name, channel);
 
           int chnl = PHIBINS * i + j;
 
           if (m == 0)
             rctIsoEffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 1)
             rctNisoEffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 2)
             rctRegEffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 3)
             rctIsoIneffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 4)
             rctNisoIneffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 5)
             rctRegIneffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 6)
             rctIsoOvereffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 7)
             rctNisoOvereffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 8)
             rctRegOvereffChannel_[chnl] = ibooker.book1D(name, name, DEBINS, DEMIN, DEMAX);
           if (m == 9)
             trigEff_[chnl] = ibooker.book1D(name, name, ELBINS, ELMIN, ELMAX);
           if (m == 10)
             trigEffOcc_[chnl] = ibooker.book1D(name, name, ELBINS, ELMIN, ELMAX);
           if (m == 11)
             trigEffTriggOcc_[chnl] = ibooker.book1D(name, name, ELBINS, ELMIN, ELMAX);
         }
       }
     }
   }
 
   //end of single channels
 
   notrigCount = 0;
   trigCount = 0;
 
   readFEDVector(fedVectorMonitorRUN_, es, false);
 }

void L1TdeRCT::DivideME1D	(	MonitorElement *	numerator,
		MonitorElement *	denominator,
		MonitorElement *	result
	)

protected

Definition at line 1130 of file L1TdeRCT.cc.

References dqm::impl::MonitorElement::getTH1F(), and pileupDistInMC::num.

Referenced by analyze().

                                                                                                         {
   TH1F* num = numerator->getTH1F();
   TH1F* den = denominator->getTH1F();
   TH1F* res = result->getTH1F();
 
   res->Divide(num, den, 1, 1, "");
 }

void L1TdeRCT::DivideME2D	(	MonitorElement *	numerator,
		MonitorElement *	denominator,
		MonitorElement *	result
	)

protected

Definition at line 1122 of file L1TdeRCT.cc.

References dqm::impl::MonitorElement::getTH2F(), and pileupDistInMC::num.

Referenced by analyze().

                                                                                                         {
   TH2F* num = numerator->getTH2F();
   TH2F* den = denominator->getTH2F();
   TH2F* res = result->getTH2F();
 
   res->Divide(num, den, 1, 1, "");
 }

std::shared_ptr< l1tderct::Empty > L1TdeRCT::globalBeginLuminosityBlock	(	const edm::LuminosityBlock &	ls,
		const edm::EventSetup &	es
	)		const

overrideprotected

Definition at line 2090 of file L1TdeRCT.cc.

References fedVectorMonitorLS_, perLSsaving_, and readFEDVector().

                                                                                                      {
   if (!perLSsaving_)
     readFEDVector(fedVectorMonitorLS_, es);
   return std::shared_ptr<l1tderct::Empty>();
 }

void L1TdeRCT::globalEndLuminosityBlock	(	const edm::LuminosityBlock &	,
		const edm::EventSetup &
	)

inlinefinalprotected

Definition at line 66 of file L1TdeRCT.h.

66 {}

void L1TdeRCT::readFEDVector	(	MonitorElement *	,
		const edm::EventSetup &	,
		const bool	isLumitransition = `true`
	)		const

protected

Definition at line 2097 of file L1TdeRCT.cc.

References crateFED, spr::find(), edm::EventSetup::getHandle(), mps_fire::i, RunInfo::m_fed_in, runInfolumiToken_, runInfoToken_, dqm::impl::MonitorElement::setBinContent(), and edmLumisInFiles::summary.

Referenced by bookHistograms(), and globalBeginLuminosityBlock().

                                                                                                                   {
   // adding fed mask into channel mask
   //edm::ESHandle<RunInfo> sum;
   //es.get<RunInfoRcd>().get(sum);
   const auto& sum = isLumitransition ? es.getHandle(runInfolumiToken_) : es.getHandle(runInfoToken_);
   const RunInfo* summary = sum.product();
 
   std::vector<int> caloFeds;  // pare down the feds to the intresting ones
 
   const std::vector<int> Feds = summary->m_fed_in;
   for (std::vector<int>::const_iterator cf = Feds.begin(); cf != Feds.end(); ++cf) {
     int fedNum = *cf;
     if ((fedNum > 600 && fedNum < 724) || fedNum == 1118 || fedNum == 1120 || fedNum == 1122)
       caloFeds.push_back(fedNum);
   }
 
   for (unsigned int i = 0; i < 108; ++i) {
     std::vector<int>::iterator fv = std::find(caloFeds.begin(), caloFeds.end(), crateFED[i]);
     if (fv != caloFeds.end()) {
       histogram->setBinContent(i + 1, 2, 1);
       histogram->setBinContent(i + 1, 1, 0);
     } else {
       histogram->setBinContent(i + 1, 2, 0);
       histogram->setBinContent(i + 1, 1, 1);
     }
   }
 }

Member Data Documentation

const int L1TdeRCT::crateFED

staticprivate

Initial value:

= {
    613, 614, 603, 702, 718, 1118, 611, 612, 602, 700, 718, 1118, 627, 610, 601, 716, 722, 1122,
    625, 626, 609, 714, 722, 1122, 623, 624, 608, 712, 722, 1122, 621, 622, 607, 710, 720, 1120,
    619, 620, 606, 708, 720, 1120, 617, 618, 605, 706, 720, 1120, 615, 616, 604, 704, 718, 1118,
    631, 632, 648, 703, 719, 1118, 629, 630, 647, 701, 719, 1118, 645, 628, 646, 717, 723, 1122,
    643, 644, 654, 715, 723, 1122, 641, 642, 653, 713, 723, 1122, 639, 640, 652, 711, 721, 1120,
    637, 638, 651, 709, 721, 1120, 635, 636, 650, 707, 721, 1120, 633, 634, 649, 705, 719, 1118}

Definition at line 250 of file L1TdeRCT.h.

Referenced by bookHistograms(), and readFEDVector().

std::string L1TdeRCT::dataInputTagName_

private

Definition at line 279 of file L1TdeRCT.h.

Referenced by bookHistograms().

int L1TdeRCT::doubleThreshold_

private

Definition at line 273 of file L1TdeRCT.h.

Referenced by analyze().

edm::EDGetTokenT<EcalTrigPrimDigiCollection> L1TdeRCT::ecalTPGData_

private