#include <L1TdeRCT.h>

Inheritance diagram for L1TdeRCT:

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

virtual	~L1TdeRCT ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

	EDConsumerBase ()

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &)

virtual 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)

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

void	readFEDVector (MonitorElement *, const edm::EventSetup &)

Protected Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Private Attributes
int	doubleThreshold_

edm::EDGetTokenT < EcalTrigPrimDigiCollection >	ecalTPGData_

MonitorElement *	fedVectorMonitorLS_

MonitorElement *	fedVectorMonitorRUN_

int	filterTriggerType_
	filter TriggerType More...

edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	gtDigisLabel_

std::string	gtEGAlgoName_

edm::EDGetTokenT < HcalTrigPrimDigiCollection >	hcalTPGData_

std::string	histFolder_

std::ofstream	logFile_

bool	monitorDaemon_

int	nev_

int	notrigCount

std::string	outputFile_

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_

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 edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 50 of file L1TdeRCT.h.

Constructor & Destructor Documentation

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

Definition at line 99 of file L1TdeRCT.cc.

References gather_cfg::cout, edm::ParameterSet::getUntrackedParameter(), histFolder_, outputFile_, 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") )),
    gtEGAlgoName_ ( ps.getParameter< std::string >("gtEGAlgoName") ),
    doubleThreshold_ ( ps.getParameter< int >("doubleThreshold") ),
    filterTriggerType_ (ps.getParameter< int >("filterTriggerType") )
 {
 
   singlechannelhistos_ = ps.getUntrackedParameter < bool > ("singlechannelhistos", 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;
 
   outputFile_ =
       ps.getUntrackedParameter < std::string > ("outputFile", "");
   if (outputFile_.size() != 0) {
     if(verbose_) std::
   cout << "L1T Monitoring histograms will be saved to " <<
   outputFile_.c_str() << std::endl;
   }
 
   bool disable =
       ps.getUntrackedParameter < bool > ("disableROOToutput", false);
   if (disable) {
     outputFile_ = "";
   }
 
   histFolder_
     = ps.getUntrackedParameter<std::string>("HistFolder", "L1TEMU/L1TdeRCT");
 }

L1TdeRCT::~L1TdeRCT ( )

virtual

Definition at line 141 of file L1TdeRCT.cc.

142 {

143 }

Member Function Documentation

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

protectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 149 of file L1TdeRCT.cc.

 {
   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 doEm = true; FIXME gcc461: variable 'doEm' set but not used
   // bool doHd = true; FIXME gcc461: variable 'doHd' set but not used
   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 ;
     // doHd = false;
   }
 
 //  if ( doHd ) {
   if (!rgnEmul.isValid()) {
     edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection";
     // doHd = false;
     if (verbose_)std::cout << "Can not find rgnEmul!" << std::endl ;
   }
 
 
   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 ;
     // doEm = false;
   }
 
 //  if ( doEm ) {
 
   if (!emEmul.isValid()) {
     edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection";
     if (verbose_)std::cout << "Can not find emEmul!" << std::endl ;
     // doEm = false;
     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(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++)
   {
 //     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::beginLuminosityBlock	(	const edm::LuminosityBlock &	ls,
		const edm::EventSetup &	es
	)

protectedvirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 1901 of file L1TdeRCT.cc.

References fedVectorMonitorLS_, and readFEDVector().

 {
   readFEDVector(fedVectorMonitorLS_,es);
 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 1233 of file L1TdeRCT.cc.

 {
   // 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",
           ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData");
 
   trigEffThreshOcc_ =
     ibooker.book2D("trigEffThreshOcc", "Rank occupancy >= 2x trig thresh",
           ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
   trigEffTriggThreshOcc_ =
     ibooker.book2D("trigEffTriggThreshOcc", "Rank occupancy >= 2x trig thresh, triggered",
           ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   ibooker.setCurrentFolder(histFolder_+"/IsoEm");
 
   rctIsoEmEff1_ =
     ibooker.book2D("rctIsoEmEff1", "rctIsoEmEff1", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmEff1oneD_ =
     ibooker.book1D("rctIsoEmEff1oneD", "rctIsoEmEff1oneD",
         CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEff2_ =
     ibooker.book2D("rctIsoEmEff2", "rctIsoEmEff2, energy matching required", 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", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmIneff2oneD_ =
     ibooker.book1D("rctIsoEmIneff2oneD", "rctIsoEmIneff2oneD, energy matching required",
         CHNLBINS, CHNLMIN, CHNLMAX);
 
 
   rctIsoEmIneff_ =
     ibooker.book2D("rctIsoEmIneff", "rctIsoEmIneff", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmIneff1D_ =
     ibooker.book1D("rctIsoEmIneff1D", "rctIsoEmIneff1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmOvereff_ =
     ibooker.book2D("rctIsoEmOvereff", "rctIsoEmOvereff", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmOvereff1D_ =
     ibooker.book1D("rctIsoEmOvereff1D", "rctIsoEmOvereff1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   ibooker.setCurrentFolder(histFolder_+"/IsoEm/ServiceData");
 
   rctIsoEmDataOcc_ =
     ibooker.book2D("rctIsoEmDataOcc", "rctIsoEmDataOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmDataOcc1D_ =
     ibooker.book1D("rctIsoEmDataOcc1D", "rctIsoEmDataOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEmulOcc_ =
     ibooker.book2D("rctIsoEmEmulOcc", "rctIsoEmEmulOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmEmulOcc1D_ =
     ibooker.book1D("rctIsoEmEmulOcc1D", "rctIsoEmEmulOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEff1Occ_ =
     ibooker.book2D("rctIsoEmEff1Occ", "rctIsoEmEff1Occ", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmEff1Occ1D_ =
     ibooker.book1D("rctIsoEmEff1Occ1D", "rctIsoEmEff1Occ1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmEff2Occ_ =
     ibooker.book2D("rctIsoEmEff2Occ", "rctIsoEmEff2Occ", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmEff2Occ1D_ =
     ibooker.book1D("rctIsoEmEff2Occ1D", "rctIsoEmEff2Occ1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmIneff2Occ_ =
     ibooker.book2D("rctIsoEmIneff2Occ", "rctIsoEmIneff2Occ", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmIneff2Occ1D_ =
     ibooker.book1D("rctIsoEmIneff2Occ1D", "rctIsoEmIneff2Occ1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmIneffOcc_ =
     ibooker.book2D("rctIsoEmIneffOcc", "rctIsoEmIneffOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmIneffOcc1D_ =
     ibooker.book1D("rctIsoEmIneffOcc1D", "rctIsoEmIneffOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctIsoEmOvereffOcc_ =
     ibooker.book2D("rctIsoEmOvereffOcc", "rctIsoEmOvereffOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctIsoEmOvereffOcc1D_ =
     ibooker.book1D("rctIsoEmOvereffOcc1D", "rctIsoEmOvereffOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
 
   ibooker.setCurrentFolder(histFolder_+"/NisoEm");
   rctNisoEmEff1_ =
     ibooker.book2D("rctNisoEmEff1", "rctNisoEmEff1", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmEff1oneD_ =
     ibooker.book1D("rctNisoEmEff1oneD", "rctNisoEmEff1oneD",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEff2_ =
     ibooker.book2D("rctNisoEmEff2", "rctNisoEmEff2, energy matching required", 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", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmIneff2oneD_ =
     ibooker.book1D("rctNisoEmIneff2oneD", "rctNisoEmIneff2oneD, energy matching required",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
 
   rctNisoEmIneff_ =
     ibooker.book2D("rctNisoEmIneff", "rctNisoEmIneff", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmIneff1D_ =
     ibooker.book1D("rctNisoEmIneff1D", "rctNisoEmIneff1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmOvereff_ =
     ibooker.book2D("rctNisoEmOvereff", "rctNisoEmOvereff", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmOvereff1D_ =
     ibooker.book1D("rctNisoEmOvereff1D", "rctNisoEmOvereff1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   ibooker.setCurrentFolder(histFolder_+"/NisoEm/ServiceData");
 
   rctNisoEmDataOcc_ =
     ibooker.book2D("rctNisoEmDataOcc", "rctNisoEmDataOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmDataOcc1D_ =
     ibooker.book1D("rctNisoEmDataOcc1D", "rctNisoEmDataOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEmulOcc_ =
     ibooker.book2D("rctNisoEmEmulOcc", "rctNisoEmEmulOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmEmulOcc1D_ =
     ibooker.book1D("rctNisoEmEmulOcc1D", "rctNisoEmEmulOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEff1Occ_ =
     ibooker.book2D("rctNisoEmEff1Occ", "rctNisoEmEff1Occ", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmEff1Occ1D_ =
     ibooker.book1D("rctNisoEmEff1Occ1D", "rctNisoEmEff1Occ1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmEff2Occ_ =
     ibooker.book2D("rctNisoEmEff2Occ", "rctNisoEmEff2Occ", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmEff2Occ1D_ =
     ibooker.book1D("rctNisoEmEff2Occ1D", "rctNisoEmEff2Occ1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmIneff2Occ_ =
     ibooker.book2D("rctNisoEmIneff2Occ", "rctNisoEmIneff2Occ", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmIneff2Occ1D_ =
     ibooker.book1D("rctNisoEmIneff2Occ1D", "rctNisoEmIneff2Occ1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmIneffOcc_ =
     ibooker.book2D("rctNisoEmIneffOcc", "rctNisoEmIneffOcc", ETABINS, ETAMIN,
         ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctNisoEmIneffOcc1D_ =
     ibooker.book1D("rctNisoEmIneffOcc1D", "rctNisoEmIneffOcc1D",
                     CHNLBINS, CHNLMIN, CHNLMAX);
 
   rctNisoEmOvereffOcc_ =
     ibooker.book2D("rctNisoEmOvereffOcc", "rctNisoEmOvereffOcc", 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",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctRegIneff2D_ =
     ibooker.book2D("rctRegIneff2D", "2D region inefficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctRegOvereff2D_ =
     ibooker.book2D("rctRegOvereff2D", "2D region overefficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctRegSpEff2D_ =
     ibooker.book2D("rctRegSpEff2D", "2D region efficiency, energy matching required",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctRegSpIneff2D_ =
     ibooker.book2D("rctRegSpIneff2D", "2D region inefficiency, energy matching required",
       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",
       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",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitOverFlowIneff2D_ =
     ibooker.book2D("rctBitOverFlowIneff2D", "2D overflow bit inefficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitOverFlowOvereff2D_ =
     ibooker.book2D("rctBitOverFlowOvereff2D", "2D overflow bit overefficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitTauVetoEff2D_ =
     ibooker.book2D("rctBitTauVetoEff2D", "2D tau veto bit efficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitTauVetoIneff2D_ =
     ibooker.book2D("rctBitTauVetoIneff2D", "2D tau veto bit inefficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitTauVetoOvereff2D_ =
     ibooker.book2D("rctBitTauVetoOvereff2D", "2D tau veto bit overefficiency",
       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",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitHfPlusTauIneff2D_ =
     ibooker.book2D("rctBitHfPlusTauIneff2D", "2D HfPlusTau bit inefficiency",
       ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
 
   rctBitHfPlusTauOvereff2D_ =
     ibooker.book2D("rctBitHfPlusTauOvereff2D", "2D HfPlusTau bit overefficiency",
       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",
       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",
       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",
       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);
   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_->getTH2F()->GetXaxis()->SetBinLabel(i+1,fed);
     fedVectorMonitorLS_->getTH2F()->GetXaxis()->SetBinLabel(i+1,fed);
   }
   fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(1,"OUT");
   fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(2,"IN");
   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);
 }

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

protected

Definition at line 1222 of file L1TdeRCT.cc.

References 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 1212 of file L1TdeRCT.cc.

References 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,"");
 
 }

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

protectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 145 of file L1TdeRCT.cc.

                                                              {
   //
 }

void L1TdeRCT::readFEDVector	(	MonitorElement *	histogram,
		const edm::EventSetup &	es
	)

protected

Definition at line 1906 of file L1TdeRCT.cc.

References crateFED, spr::find(), edm::EventSetup::get(), i, RunInfo::m_fed_in, edm::ESHandle< class >::product(), MonitorElement::setBinContent(), and edmLumisInFiles::summary.

Referenced by beginLuminosityBlock(), and bookHistograms().

 {
   // adding fed mask into channel mask
   edm::ESHandle<RunInfo> sum;
   es.get<RunInfoRcd>().get(sum);
   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
}