GctErrorAnalyzer Class Reference

#include <L1Trigger/L1GctAnalyzer/src/GctErrorAnalyzer.cc>

Inheritance diagram for GctErrorAnalyzer:

Public Member Functions
	GctErrorAnalyzer (const edm::ParameterSet &)
	~GctErrorAnalyzer ()
Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()
ProductHolderIndex	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndex > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndex > &) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
template<class T >
bool	checkCollections (const T &collection, const unsigned int &constraint, const std::string &label)
virtual void	endJob ()
	GctErrorAnalyzer ()
	GctErrorAnalyzer (const GctErrorAnalyzer &)
GctErrorAnalyzer	operator= (const GctErrorAnalyzer &)
void	plotCenJets (const edm::Handle< L1GctJetCandCollection > &data, const edm::Handle< L1GctJetCandCollection > &emu)
void	plotEGErrors (const edm::Handle< L1GctEmCandCollection > &dataiso, const edm::Handle< L1GctEmCandCollection > &emuiso, const edm::Handle< L1GctEmCandCollection > &datanoniso, const edm::Handle< L1GctEmCandCollection > &emunoniso, const edm::Handle< L1CaloEmCollection > &regions)
void	plotForJets (const edm::Handle< L1GctJetCandCollection > &data, const edm::Handle< L1GctJetCandCollection > &emu)
void	plotHFBitCounts (const edm::Handle< L1GctHFBitCountsCollection > &hfBitCountsD, const edm::Handle< L1GctHFBitCountsCollection > &hfBitCountsE)
void	plotHFErrors (const edm::Handle< L1GctHFRingEtSumsCollection > &hfRingSumsD, const edm::Handle< L1GctHFRingEtSumsCollection > &hfRingSumsE, const edm::Handle< L1GctHFBitCountsCollection > &hfBitCountsD, const edm::Handle< L1GctHFBitCountsCollection > &hfBitCountsE, const edm::Handle< L1CaloRegionCollection > &caloRegions)
void	plotHFRingSums (const edm::Handle< L1GctHFRingEtSumsCollection > &data, const edm::Handle< L1GctHFRingEtSumsCollection > &emu)
void	plotIntJets (const edm::Handle< L1GctInternJetDataCollection > &emu)
void	plotIsoEm (const edm::Handle< L1GctEmCandCollection > &data, const edm::Handle< L1GctEmCandCollection > &emu)
void	plotJetErrors (const edm::Handle< L1GctJetCandCollection > &cendata, const edm::Handle< L1GctJetCandCollection > &cenemu, const edm::Handle< L1GctJetCandCollection > &taudata, const edm::Handle< L1GctJetCandCollection > &tauemu, const edm::Handle< L1GctJetCandCollection > &fordata, const edm::Handle< L1GctJetCandCollection > &foremu, const edm::Handle< L1CaloRegionCollection > &regions)
void	plotMissingEErrors (const edm::Handle< L1GctEtMissCollection > &missingEtD, const edm::Handle< L1GctEtMissCollection > &missingEtE, const edm::Handle< L1GctHtMissCollection > &missingHtD, const edm::Handle< L1GctHtMissCollection > &missingHtE, edm::Handle< L1CaloRegionCollection > &caloRegions, const edm::Handle< L1GctInternJetDataCollection > &intjetsemu, const edm::Handle< L1GctInternHtMissCollection > intMissingHtD)
void	plotMissingEt (const edm::Handle< L1GctEtMissCollection > &missingEtD, const edm::Handle< L1GctEtMissCollection > &missingEtE)
void	plotMissingHt (const edm::Handle< L1GctHtMissCollection > &missingHtD, const edm::Handle< L1GctHtMissCollection > &missingHtE)
void	plotNonIsoEm (const edm::Handle< L1GctEmCandCollection > &data, const edm::Handle< L1GctEmCandCollection > &emu)
void	plotRCTRegions (const edm::Handle< L1CaloRegionCollection > &caloRegions)
void	plotTauJets (const edm::Handle< L1GctJetCandCollection > &data, const edm::Handle< L1GctJetCandCollection > &emu)
void	plotTotalE (const edm::Handle< L1GctEtTotalCollection > &totalEtD, const edm::Handle< L1GctEtTotalCollection > &totalEtE)
void	plotTotalEErrors (const edm::Handle< L1GctEtTotalCollection > &totalEtD, const edm::Handle< L1GctEtTotalCollection > &totalEtE, const edm::Handle< L1GctEtHadCollection > &totalHtD, const edm::Handle< L1GctEtHadCollection > &totalHtE, const edm::Handle< L1CaloRegionCollection > &caloRegions)
void	plotTotalH (const edm::Handle< L1GctEtHadCollection > &totalHtD, const edm::Handle< L1GctEtHadCollection > &totalHtE)

Static Private Member Functions
static bool	sortJets (const jetData &jet1, const jetData &jet2)

Private Attributes
TH1I *	cenJet_errorFlag_
TH2I *	cenJetD_EtEtaPhi_
TH2I *	cenJetD_GlobalError_EtEtaPhi_
TH1I *	cenJetD_GlobalError_Rank_
TH2I *	cenJetD_OccEtaPhi_
TH1I *	cenJetD_Rank_
TH2I *	cenJetE_EtEtaPhi_
TH2I *	cenJetE_GlobalError_EtEtaPhi_
TH1I *	cenJetE_GlobalError_Rank_
TH2I *	cenJetE_OccEtaPhi_
TH1I *	cenJetE_Rank_
edm::InputTag	dataTag_
bool	doBitCountDebug_
bool	doCenJetsDebug_
bool	doEg_
bool	doEmuMBx_
bool	doExtraMissingHTDebug_
bool	doForJetsDebug_
bool	doGCTMBx_
bool	doHF_
bool	doIsoDebug_
bool	doJets_
bool	doMissingEnergySums_
bool	doMissingETDebug_
bool	doMissingHTDebug_
bool	doNonIsoDebug_
bool	doRCT_
bool	doRCTMBx_
bool	doRingSumDebug_
bool	doTauJetsDebug_
bool	doTotalEnergySums_
bool	doTotalEtDebug_
bool	doTotalHtDebug_
edm::InputTag	emuTag_
int	EmuTrigBx_
std::vector< TFileDirectory >	errorHistCat
unsigned int	eventNumber
TH1I *	forJet_errorFlag_
TH2I *	forJetD_EtEtaPhi_
TH2I *	forJetD_GlobalError_EtEtaPhi_
TH1I *	forJetD_GlobalError_Rank_
TH2I *	forJetD_OccEtaPhi_
TH1I *	forJetD_Rank_
TH2I *	forJetE_EtEtaPhi_
TH2I *	forJetE_GlobalError_EtEtaPhi_
TH1I *	forJetE_GlobalError_Rank_
TH2I *	forJetE_OccEtaPhi_
TH1I *	forJetE_Rank_
int	GCTTrigBx_
TH1I *	hfBitCount_errorFlag_
TH1I *	hfBitCountD_1neg_
TH1I *	hfBitCountD_1pos_
TH1I *	hfBitCountD_2neg_
TH1I *	hfBitCountD_2pos_
TH1I *	hfBitCountE_1neg_
TH1I *	hfBitCountE_1pos_
TH1I *	hfBitCountE_2neg_
TH1I *	hfBitCountE_2pos_
TH1I *	hfRingSum_errorFlag_
TH1I *	hfRingSumD_1neg_
TH1I *	hfRingSumD_1pos_
TH1I *	hfRingSumD_2neg_
TH1I *	hfRingSumD_2pos_
TH1I *	hfRingSumE_1neg_
TH1I *	hfRingSumE_1pos_
TH1I *	hfRingSumE_2neg_
TH1I *	hfRingSumE_2pos_
TH1I *	intJetE_Et_
TH1I *	intJetE_Jet1Et_
TH1I *	intJetE_Jet2Et_
TH1I *	intJetE_Jet3Et_
TH1I *	intJetE_Jet4Et_
TH1I *	intJetE_Of_
TH2I *	intJetEtEtaPhiE_
bool	isBitCountError
bool	isCenJetError
bool	isForJetError
bool	isIsoError
bool	isMissingEError
bool	isMissingHError
bool	isNonIsoError
TH1I *	isoEg_errorFlag_
TH2I *	isoEgD_EtEtaPhi_
TH2I *	isoEgD_GlobalError_EtEtaPhi_
TH1I *	isoEgD_GlobalError_Rank_
TH2I *	isoEgD_OccEtaPhi_
TH1I *	isoEgD_Rank_
TH2I *	isoEgE_EtEtaPhi_
TH2I *	isoEgE_GlobalError_EtEtaPhi_
TH1I *	isoEgE_GlobalError_Rank_
TH2I *	isoEgE_OccEtaPhi_
TH1I *	isoEgE_Rank_
bool	isRingSumError
bool	isTauJetError
bool	isTotalEError
bool	isTotalHError
GctErrorAnalyzerMBxInfo	MBxInfo
TH1I *	missingEt_errorFlag_
TH1I *	missingEtD_
TH1I *	missingEtD_Of_
TH1I *	missingEtD_Phi_
TH1I *	missingEtE_
TH1I *	missingEtE_Of_
TH1I *	missingEtE_Phi_
TH1I *	missingHt_errorFlag_
TH1I *	missingHtD_
TH1I *	missingHtD_HtXNegLeaf1
TH1I *	missingHtD_HtXNegLeaf2
TH1I *	missingHtD_HtXNegLeaf3
TH1I *	missingHtD_HtXPosLeaf1
TH1I *	missingHtD_HtXPosLeaf2
TH1I *	missingHtD_HtXPosLeaf3
TH1I *	missingHtD_HtYNegLeaf1
TH1I *	missingHtD_HtYNegLeaf2
TH1I *	missingHtD_HtYNegLeaf3
TH1I *	missingHtD_HtYPosLeaf1
TH1I *	missingHtD_HtYPosLeaf2
TH1I *	missingHtD_HtYPosLeaf3
TH1I *	missingHtD_Of_
TH1I *	missingHtD_Phi_
TH1I *	missingHtE_
TH1I *	missingHtE_Of_
TH1I *	missingHtE_Phi_
TH1I *	nonIsoEg_errorFlag_
TH2I *	nonIsoEgD_EtEtaPhi_
TH2I *	nonIsoEgD_GlobalError_EtEtaPhi_
TH1I *	nonIsoEgD_GlobalError_Rank_
TH2I *	nonIsoEgD_OccEtaPhi_
TH1I *	nonIsoEgD_Rank_
TH2I *	nonIsoEgE_EtEtaPhi_
TH2I *	nonIsoEgE_GlobalError_EtEtaPhi_
TH1I *	nonIsoEgE_GlobalError_Rank_
TH2I *	nonIsoEgE_OccEtaPhi_
TH1I *	nonIsoEgE_Rank_
TH2I *	RCT_EtEtaPhi_
TH2I *	RCT_FgEtaPhi_
TH2I *	RCT_OfEtaPhi_
const unsigned int *	RCT_REGION_QUANTA
TH2I *	RCT_TvEtaPhi_
int	RCTTrigBx_
TH1I *	tauJet_errorFlag_
TH2I *	tauJetD_EtEtaPhi_
TH2I *	tauJetD_GlobalError_EtEtaPhi_
TH1I *	tauJetD_GlobalError_Rank_
TH2I *	tauJetD_OccEtaPhi_
TH1I *	tauJetD_Rank_
TH2I *	tauJetE_EtEtaPhi_
TH2I *	tauJetE_GlobalError_EtEtaPhi_
TH1I *	tauJetE_GlobalError_Rank_
TH2I *	tauJetE_OccEtaPhi_
TH1I *	tauJetE_Rank_
TH1I *	totalEt_errorFlag_
TH1I *	totalEtD_
TH1I *	totalEtD_Of_
TH1I *	totalEtE_
TH1I *	totalEtE_Of_
TH1I *	totalHt_errorFlag_
TH1I *	totalHtD_
TH1I *	totalHtD_Of_
TH1I *	totalHtE_
TH1I *	totalHtE_Of_
std::string	useSys_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
typedef WorkerT< EDAnalyzer >	WorkerType
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)
Protected Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
CurrentProcessingContext const *	currentContext () const
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)

Detailed Description

Description: Tool to debug the GCT with useful output

Implementation: <Notes on="" implementation>="">

Definition at line 58 of file GctErrorAnalyzer.cc.

Constructor & Destructor Documentation

GctErrorAnalyzer::GctErrorAnalyzer ( )

private

GctErrorAnalyzer::GctErrorAnalyzer ( const GctErrorAnalyzer &  )

private

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

explicit

Definition at line 271 of file GctErrorAnalyzer.cc.

References cenJet_errorFlag_, cenJetD_EtEtaPhi_, cenJetD_GlobalError_EtEtaPhi_, cenJetD_GlobalError_Rank_, cenJetD_OccEtaPhi_, cenJetD_Rank_, cenJetE_EtEtaPhi_, cenJetE_GlobalError_EtEtaPhi_, cenJetE_GlobalError_Rank_, cenJetE_OccEtaPhi_, cenJetE_Rank_, GctErrorAnalyzerMBxInfo::EmuTrigBx, EmuTrigBx_, errorHistCat, forJet_errorFlag_, forJetD_EtEtaPhi_, forJetD_GlobalError_EtEtaPhi_, forJetD_GlobalError_Rank_, forJetD_OccEtaPhi_, forJetD_Rank_, forJetE_EtEtaPhi_, forJetE_GlobalError_EtEtaPhi_, forJetE_GlobalError_Rank_, forJetE_OccEtaPhi_, forJetE_Rank_, GctErrorAnalyzerMBxInfo::GCTTrigBx, GCTTrigBx_, hfBitCount_errorFlag_, hfBitCountD_1neg_, hfBitCountD_1pos_, hfBitCountD_2neg_, hfBitCountD_2pos_, hfBitCountE_1neg_, hfBitCountE_1pos_, hfBitCountE_2neg_, hfBitCountE_2pos_, hfRingSum_errorFlag_, hfRingSumD_1neg_, hfRingSumD_1pos_, hfRingSumD_2neg_, hfRingSumD_2pos_, hfRingSumE_1neg_, hfRingSumE_1pos_, hfRingSumE_2neg_, hfRingSumE_2pos_, i, intJetE_Et_, intJetE_Jet1Et_, intJetE_Jet2Et_, intJetE_Jet3Et_, intJetE_Jet4Et_, intJetE_Of_, intJetEtEtaPhiE_, isBitCountError, isCenJetError, isForJetError, isIsoError, isMissingEError, isMissingHError, isNonIsoError, isoEg_errorFlag_, isoEgD_EtEtaPhi_, isoEgD_GlobalError_EtEtaPhi_, isoEgD_GlobalError_Rank_, isoEgD_OccEtaPhi_, isoEgD_Rank_, isoEgE_EtEtaPhi_, isoEgE_GlobalError_EtEtaPhi_, isoEgE_GlobalError_Rank_, isoEgE_OccEtaPhi_, isoEgE_Rank_, isRingSumError, isTauJetError, isTotalEError, isTotalHError, TFileDirectory::make(), MBxInfo, missingEt_errorFlag_, missingEtD_, missingEtD_Of_, missingEtD_Phi_, missingEtE_, missingEtE_Of_, missingEtE_Phi_, missingHt_errorFlag_, missingHtD_, missingHtD_HtXNegLeaf1, missingHtD_HtXNegLeaf2, missingHtD_HtXNegLeaf3, missingHtD_HtXPosLeaf1, missingHtD_HtXPosLeaf2, missingHtD_HtXPosLeaf3, missingHtD_HtYNegLeaf1, missingHtD_HtYNegLeaf2, missingHtD_HtYNegLeaf3, missingHtD_HtYPosLeaf1, missingHtD_HtYPosLeaf2, missingHtD_HtYPosLeaf3, missingHtD_Of_, missingHtD_Phi_, missingHtE_, missingHtE_Of_, missingHtE_Phi_, TFileDirectory::mkdir(), nonIsoEg_errorFlag_, nonIsoEgD_EtEtaPhi_, nonIsoEgD_GlobalError_EtEtaPhi_, nonIsoEgD_GlobalError_Rank_, nonIsoEgD_OccEtaPhi_, nonIsoEgD_Rank_, nonIsoEgE_EtEtaPhi_, nonIsoEgE_GlobalError_EtEtaPhi_, nonIsoEgE_GlobalError_Rank_, nonIsoEgE_OccEtaPhi_, nonIsoEgE_Rank_, RCT_EtEtaPhi_, RCT_FgEtaPhi_, RCT_OfEtaPhi_, RCT_REGION_QUANTA, RCT_REGION_QUANTA_LAB, RCT_REGION_QUANTA_P5, RCT_TvEtaPhi_, GctErrorAnalyzerMBxInfo::RCTTrigBx, RCTTrigBx_, tauJet_errorFlag_, tauJetD_EtEtaPhi_, tauJetD_GlobalError_EtEtaPhi_, tauJetD_GlobalError_Rank_, tauJetD_OccEtaPhi_, tauJetD_Rank_, tauJetE_EtEtaPhi_, tauJetE_GlobalError_EtEtaPhi_, tauJetE_GlobalError_Rank_, tauJetE_OccEtaPhi_, tauJetE_Rank_, totalEt_errorFlag_, totalEtD_, totalEtD_Of_, totalEtE_, totalEtE_Of_, totalHt_errorFlag_, totalHtD_, totalHtD_Of_, totalHtE_, totalHtE_Of_, and useSys_.

                                                                 :
  doRCT_( iConfig.getUntrackedParameter<bool>("doRCT", true) ),
  doEg_( iConfig.getUntrackedParameter<bool>("doEg", true) ),
  doIsoDebug_( iConfig.getUntrackedParameter<bool>("doIsoDebug", true) ),
  doNonIsoDebug_( iConfig.getUntrackedParameter<bool>("doNonIsoDebug", true) ),
  doJets_( iConfig.getUntrackedParameter<bool>("doJets", true) ),
  doCenJetsDebug_( iConfig.getUntrackedParameter<bool>("doCenJetsDebug", true) ),
  doTauJetsDebug_( iConfig.getUntrackedParameter<bool>("doTauJetsDebug", true) ),
  doForJetsDebug_( iConfig.getUntrackedParameter<bool>("doForJetsDebug", true) ),
  doHF_( iConfig.getUntrackedParameter<bool>("doHF", true) ),
  doRingSumDebug_( iConfig.getUntrackedParameter<bool>("doRingSumDebug", true) ),
  doBitCountDebug_( iConfig.getUntrackedParameter<bool>("doBitCountDebug", true) ),
  doTotalEnergySums_( iConfig.getUntrackedParameter<bool>("doTotalEnergySums", true) ),
  doTotalEtDebug_( iConfig.getUntrackedParameter<bool>("doTotalEtDebug", true) ),
  doTotalHtDebug_( iConfig.getUntrackedParameter<bool>("doTotalHtDebug", true) ),
  doMissingEnergySums_( iConfig.getUntrackedParameter<bool>("doMissingEnergySums", true) ),
  doMissingETDebug_( iConfig.getUntrackedParameter<bool>("doMissingETDebug", true) ),
  doMissingHTDebug_( iConfig.getUntrackedParameter<bool>("doMissingHTDebug", true) ),
  doExtraMissingHTDebug_( iConfig.getUntrackedParameter<bool>("doExtraMissingHTDebug", false) ),
  doRCTMBx_( iConfig.getUntrackedParameter<bool>("doRCTMBx", false)),
  doEmuMBx_( iConfig.getUntrackedParameter<bool>("doEmuMBx", false)),
  doGCTMBx_( iConfig.getUntrackedParameter<bool>("doGCTMBx", false)),
  RCTTrigBx_( iConfig.getUntrackedParameter<int>("RCTTrigBx", 0)),
  EmuTrigBx_( iConfig.getUntrackedParameter<int>("EmuTrigBx", 0)),
  GCTTrigBx_( iConfig.getUntrackedParameter<int>("GCTTrigBx", 0)),
  dataTag_( iConfig.getUntrackedParameter<edm::InputTag>("dataTag", edm::InputTag("gctDigis")) ),
  emuTag_( iConfig.getUntrackedParameter<edm::InputTag>("emuTag", edm::InputTag("gctEmuDigis")) ),
  useSys_( iConfig.getUntrackedParameter<std::string>("useSys","P5"))
{
  //now do what ever initialization is needed
  //make the root file
  edm::Service<TFileService> fs;

  //to try to make this look more elegant
  //make a string for each folder we'd like for the Data and Emulator Histograms
  std::vector<std::string> quantities;
  quantities.push_back("IsoEm");
  quantities.push_back("NonIsoEM");
  quantities.push_back("CenJets");
  quantities.push_back("TauJets");
  quantities.push_back("ForJets");
  quantities.push_back("HFRingSums");
  quantities.push_back("HFBitCounts");
  quantities.push_back("TotalESums");
  quantities.push_back("MissingESums");

  //make the Emulator Histogram directory
  TFileDirectory emuHist = fs->mkdir("EmulatorHistograms");
  std::vector<TFileDirectory> emuHistCat;

  //make the Data Histogram directory
  TFileDirectory dataHist =  fs->mkdir("DataHistograms");
  std::vector<TFileDirectory> dataHistCat;

  //make the ErrorFlags directory
  TFileDirectory errorHistFlags =  fs->mkdir("ErrorHistograms_Flags");

  //make the ErrorDebug directory
  TFileDirectory errorHistDetails =  fs->mkdir("ErrorHistograms_Details");

  for(unsigned int i=0;i<quantities.size();i++) {
    //fill the data and emulator folders with the directories
    emuHistCat.push_back(emuHist.mkdir(quantities.at(i)));
    dataHistCat.push_back(dataHist.mkdir(quantities.at(i)));
  }
  
  //add a folder for RCT Regions - which only exist in data
  dataHistCat.push_back(dataHist.mkdir("RCTRegions"));
  //and add a folder for the Intermediate Jets - which only exist in emulator
  emuHistCat.push_back(emuHist.mkdir("IntJets"));

  //Fill the ErrorDebug folder with the directories
  errorHistCat.push_back(errorHistDetails.mkdir("EM"));
  errorHistCat.push_back(errorHistDetails.mkdir("Jets"));
  errorHistCat.push_back(errorHistDetails.mkdir("HF"));
  errorHistCat.push_back(errorHistDetails.mkdir("TotalE"));
  errorHistCat.push_back(errorHistDetails.mkdir("MissingE"));

  //BOOK HISTOGRAMS
  RCT_EtEtaPhi_ = dataHistCat.at(9).make<TH2I>("RCT_EtEtaPhi", "RCT_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  RCT_TvEtaPhi_ = dataHistCat.at(9).make<TH2I>("RCT_TvEtaPhi", "RCT_TvEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  RCT_FgEtaPhi_ = dataHistCat.at(9).make<TH2I>("RCT_FgEtaPhi", "RCT_FgEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  RCT_OfEtaPhi_ = dataHistCat.at(9).make<TH2I>("RCT_OfEtEtaPhi", "RCT_OfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  //isoEg
  isoEgD_Rank_ = dataHistCat.at(0).make<TH1I>("isoEgD_Rank", "isoEgD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  isoEgE_Rank_ = emuHistCat.at(0).make<TH1I>("isoEgE_Rank", "isoEgE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  isoEgD_EtEtaPhi_ = dataHistCat.at(0).make<TH2I>("isoEgD_EtEtaPhi", "isoEgD_EtEtaPhi;#eta (GCT Units);#phi(GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  isoEgE_EtEtaPhi_ = emuHistCat.at(0).make<TH2I>("isoEgE_EtEtaPhi", "isoEgE_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  isoEgD_OccEtaPhi_ = dataHistCat.at(0).make<TH2I>("isoEgD_OccEtaPhi", "isoEgD_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  isoEgE_OccEtaPhi_ = emuHistCat.at(0).make<TH2I>("isoEgE_OccEtaPhi", "isoEgE_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  isoEg_errorFlag_ = errorHistFlags.make<TH1I>("isoEg_errorFlag", "isoEg_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
  //Global isoEg Error   
  isoEgD_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("isoEgD_GlobalError_Rank", "isoEgD_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  isoEgE_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("isoEgE_GlobalError_Rank", "isoEgE_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  isoEgD_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("isoEgD_GlobalError_EtEtaPhi", "isoEgD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  isoEgE_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("isoEgE_GlobalError_EtEtaPhi", "isoEgE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  //nonIsoEg
  nonIsoEgD_Rank_ = dataHistCat.at(1).make<TH1I>("nonIsoEgD_Rank", "nonIsoEgD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  nonIsoEgE_Rank_ = emuHistCat.at(1).make<TH1I>("nonIsoEgE_Rank", "nonIsoEgE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  nonIsoEgD_EtEtaPhi_ = dataHistCat.at(1).make<TH2I>("nonIsoEgD_EtEtaPhi", "nonIsoEgD_EtEtaPhi;#eta (GCT Units);#phi(GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  nonIsoEgE_EtEtaPhi_ = emuHistCat.at(1).make<TH2I>("nonIsoEgE_EtEtaPhi", "nonIsoEgE_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  nonIsoEgD_OccEtaPhi_ = dataHistCat.at(1).make<TH2I>("nonIsoEgD_OccEtaPhi", "nonIsoEgD_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  nonIsoEgE_OccEtaPhi_ = emuHistCat.at(1).make<TH2I>("nonIsoEgE_OccEtaPhi", "nonIsoEgE_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  nonIsoEg_errorFlag_ = errorHistFlags.make<TH1I>("nonIsoEg_errorFlag", "nonIsoEg_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
  //Global nonIsoEg Error
  nonIsoEgD_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("nonIsoEgD_GlobalError_Rank", "nonIsoEgD_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  nonIsoEgE_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("nonIsoEgE_GlobalError_Rank", "nonIsoEgE_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  nonIsoEgD_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("nonIsoEgD_GlobalError_EtEtaPhi", "nonIsoEgD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  nonIsoEgE_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("nonIsoEgE_GlobalError_EtEtaPhi", "nonIsoEgE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5); 
  //CenJets
  cenJetD_Rank_ = dataHistCat.at(2).make<TH1I>("cenJetD_Rank", "cenJetD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  cenJetE_Rank_ = emuHistCat.at(2).make<TH1I>("cenJetE_Rank", "cenJetE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  cenJetD_EtEtaPhi_ = dataHistCat.at(2).make<TH2I>("cenJetD_EtEtaPhi", "cenJetD_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  cenJetE_EtEtaPhi_ = emuHistCat.at(2).make<TH2I>("cenJetE_EtEtaPhi", "cenJetE_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  cenJetD_OccEtaPhi_ = dataHistCat.at(2).make<TH2I>("cenJetD_OccEtaPhi", "cenJetD_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  cenJetE_OccEtaPhi_ = emuHistCat.at(2).make<TH2I>("cenJetE_OccEtaPhi", "cenJetE_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  cenJet_errorFlag_ = errorHistFlags.make<TH1I>("cenJet_errorFlag", "cenJet_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
  //Global CenJet Error
  cenJetD_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("cenJetD_GlobalError_Rank", "cenJetD_GlobalError_Rank", 64, -0.5, 63.5);
  cenJetE_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("cenJetE_GlobalError_Rank", "cenJetE_GlobalError_Rank", 64, -0.5, 63.5);
  cenJetD_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("cenJetD_GlobalError_EtEtaPhi", "cenJetD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  cenJetE_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("cenJetE_GlobalError_EtEtaPhi", "cenJetE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  //TauJets
  tauJetD_Rank_ = dataHistCat.at(3).make<TH1I>("tauJetD_Rank", "tauJetD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  tauJetE_Rank_ = emuHistCat.at(3).make<TH1I>("tauJetE_Rank", "tauJetE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  tauJetD_EtEtaPhi_ = dataHistCat.at(3).make<TH2I>("tauJetD_EtEtaPhi", "tauJetD_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  tauJetE_EtEtaPhi_ = emuHistCat.at(3).make<TH2I>("tauJetE_EtEtaPhi", "tauJetE_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  tauJetD_OccEtaPhi_ = dataHistCat.at(3).make<TH2I>("tauJetD_OccEtaPhi", "tauJetD_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  tauJetE_OccEtaPhi_ = emuHistCat.at(3).make<TH2I>("tauJetE_OccEtaPhi", "tauJetE_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  tauJet_errorFlag_ = errorHistFlags.make<TH1I>("tauJet_errorFlag", "tauJet_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
  //Global TauJet Error
  tauJetD_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("tauJetD_GlobalError_Rank", "tauJetD_GlobalError_Rank", 64, -0.5, 63.5);
  tauJetE_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("tauJetE_GlobalError_Rank", "tauJetE_GlobalError_Rank", 64, -0.5, 63.5);
  tauJetD_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("tauJetD_GlobalError_EtEtaPhi", "tauJetD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  tauJetE_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("tauJetE_GlobalError_EtEtaPhi", "tauJetE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  //ForJets
  forJetD_Rank_ = dataHistCat.at(4).make<TH1I>("forJetD_Rank", "forJetD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  forJetE_Rank_ = emuHistCat.at(4).make<TH1I>("forJetE_Rank", "forJetE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
  forJetD_EtEtaPhi_ = dataHistCat.at(4).make<TH2I>("forJetD_EtEtaPhi", "forJetD_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  forJetE_EtEtaPhi_ = emuHistCat.at(4).make<TH2I>("forJetE_EtEtaPhi", "forJetE_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  forJetD_OccEtaPhi_ = dataHistCat.at(4).make<TH2I>("forJetD_OccEtaPhi", "forJetD_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  forJetE_OccEtaPhi_ = emuHistCat.at(4).make<TH2I>("forJetE_OccEtaPhi", "forJetE_OccEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  forJet_errorFlag_ = errorHistFlags.make<TH1I>("forJet_errorFlag", "forJet_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
  //Global ForJet Error
  forJetD_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("forJetD_GlobalError_Rank", "forJetD_GlobalError_Rank", 64, -0.5, 63.5);
  forJetE_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("forJetE_GlobalError_Rank", "forJetE_GlobalError_Rank", 64, -0.5, 63.5);
  forJetD_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("forJetD_GlobalError_EtEtaPhi", "forJetD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  forJetE_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("forJetE_GlobalError_EtEtaPhi", "forJetE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
  //IntJets
  intJetEtEtaPhiE_ = emuHistCat.at(9).make<TH2I>("intJetEtEtaPhiE_", "intJetEtEtaPhiE_;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  intJetE_Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Et", "intJetE_Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
  intJetE_Of_ = emuHistCat.at(9).make<TH1I>("intJetE_Of", "intJetE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  intJetE_Jet1Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet1Et", "intJetE_Jet1Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
  intJetE_Jet2Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet2Et", "intJetE_Jet2Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
  intJetE_Jet3Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet3Et", "intJetE_Jet3Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
  intJetE_Jet4Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet4Et", "intJetE_Jet4Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
  //HFRing Sums
  hfRingSumD_1pos_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_1+", "hfRingSumD_1+;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumD_1neg_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_1-", "hfRingSumD_1-;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumD_2pos_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_2+", "hfRingSumD_2+;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumD_2neg_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_2-", "hfRingSumD_2-;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumE_1pos_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_1+", "hfRingSumE_1+;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumE_1neg_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_1-", "hfRingSumE_1-;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumE_2pos_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_2+", "hfRingSumE_2+;Rank;Number of Events", 8, -0.5, 7.5);
  hfRingSumE_2neg_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_2-", "hfRingSumE_2-;Rank;Number of Events", 8, -0.5, 7.5);   
  hfRingSum_errorFlag_ = errorHistFlags.make<TH1I>("hfRingSum_errorFlag","hfRingSum_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
  //HFRing BitCounts
  hfBitCountD_1pos_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_1+", "hfBitCountD_1+;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountD_1neg_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_1-", "hfBitCountD_1-;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountD_2pos_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_2+", "hfBitCountD_2+;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountD_2neg_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_2-", "hfBitCountD_2-;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountE_1pos_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_1+", "hfBitCountE_1+;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountE_1neg_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_1-", "hfBitCountE_1-;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountE_2pos_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_2+", "hfBitCountE_2+;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCountE_2neg_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_2-", "hfBitCountE_2-;Rank;Number of Events", 8, -0.5, 7.5);
  hfBitCount_errorFlag_ = errorHistFlags.make<TH1I>("hfBitCount_errorFlag","hfBitCount_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
  //Total ET
  totalEtD_ = dataHistCat.at(7).make<TH1I>("totalEtD", "totalEtD;E_{T};Number of Events", 2048, -0.5, 2047.5);
  totalEtD_Of_ = dataHistCat.at(7).make<TH1I>("totalEtD_Of", "totalEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  totalEtE_ = emuHistCat.at(7).make<TH1I>("totalEtE", "totalEtE;E_{T};Number of Events", 2048, -0.5, 2047.5);
  totalEtE_Of_ = emuHistCat.at(7).make<TH1I>("totalEtE_Of", "totalEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  totalEt_errorFlag_ = errorHistFlags.make<TH1I>("totalEt_errorFlag","totalEt_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
  //Book the Global ET Error histograms in the errorHistCat   
  //totalEtD_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalEtD_GlobalError", "totalEtD_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
  //totalEtE_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalEtE_GlobalError", "totalEtE_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
  //totalEtD_GlobalError_Of_ = errorHistCat.at(3).make<TH1I>("totalEtD_GlobalError_Of", "totalEtD_GlobalError_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  //totalEtE_GlobalError_Of_ = errorHistCat.at(3).make<TH1I>("totalEtE_GlobalError_Of", "totalEtE_GlobalError_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  //Total HT
  totalHtD_ = dataHistCat.at(7).make<TH1I>("totalHtD", "totalHtD;H_{T};Number of Events", 2048, -0.5, 2047.5);
  totalHtD_Of_ = dataHistCat.at(7).make<TH1I>("totalHtD_Of", "totalHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  totalHtE_ = emuHistCat.at(7).make<TH1I>("totalHtE", "totalHtE;H_{T};Number of Events", 2048, -0.5, 2047.5);
  totalHtE_Of_ = emuHistCat.at(7).make<TH1I>("totalHtE_Of", "totalHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  totalHt_errorFlag_ = errorHistFlags.make<TH1I>("totalHt_errorFlag","totalHt_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
  //Book the Global HT Error histograms in the errorHistCat
  //totalHtD_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalHtD_GlobalError", "totalHtD_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
  //totalHtE_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalHtE_GlobalError", "totalHtE_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
  //totalHtD_GlobalError_Of_ = errorHistCat.at(3).make<TH1I>("totalHtD_GlobalError_Of", "totalHtD_GlobalError_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  //totalHtE_GlobalError_Of_ = errorHistCat.at(3).make<TH1I>("totalHtE_GlobalError_Of", "totalHtE_GlobalError_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  //MissingEt
  missingEtD_ = dataHistCat.at(8).make<TH1I>("missingEtD", "missingEtD;Missing E_{T};Number of Events", 1024, -0.5, 1023.5);
  missingEtD_Of_ = dataHistCat.at(8).make<TH1I>("missingEtD_Of", "missingEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  missingEtD_Phi_ = dataHistCat.at(8).make<TH1I>("missingEtD_Phi", "missingEtD_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
  missingEtE_ = emuHistCat.at(8).make<TH1I>("missingEtE", "missingEtE;Missing E_{T};Number of Events", 1024, -0.5, 1023.5);
  missingEtE_Of_ = emuHistCat.at(8).make<TH1I>("missingEtE_Of", "missingEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  missingEtE_Phi_ = emuHistCat.at(8).make<TH1I>("missingEtE_Phi", "missingEtE_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
  missingEt_errorFlag_ = errorHistFlags.make<TH1I>("missingEt_errorFlag","missingEt_errorFlag;Status;Number of Candidates",4,-0.5,3.5); 
  //MissingHt
  missingHtD_ = dataHistCat.at(8).make<TH1I>("missingHtD", "missingHtD;Missing H_{T};Number of Events", 1024, -0.5, 1023.5);
  missingHtD_Of_ = dataHistCat.at(8).make<TH1I>("missingHtD_Of", "missingHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  missingHtD_Phi_ = dataHistCat.at(8).make<TH1I>("missingHtD_Phi", "missingHtD_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
  missingHtE_ = emuHistCat.at(8).make<TH1I>("missingHtE", "missingHtE;Missing H_{T};Number of Events", 1024, -0.5, 1023.5);
  missingHtE_Of_ = emuHistCat.at(8).make<TH1I>("missingHtE_Of", "missingHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  missingHtE_Phi_ = emuHistCat.at(8).make<TH1I>("missingHtE_Phi", "missingHtE_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
  missingHt_errorFlag_ = errorHistFlags.make<TH1I>("missingHt_errorFlag","missingHt_errorFlag;Status;Number of Candidates",4,-0.5,3.5);
  //Additional MissingHt Debug histograms
  missingHtD_HtXPosLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXPosLeaf1", "missingHtD;Missing H_{T} X PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtXPosLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXPosLeaf2", "missingHtD;Missing H_{T} X PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtXPosLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXPosLeaf3", "missingHtD;Missing H_{T} X PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtXNegLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXNegLeaf1", "missingHtD;Missing H_{T} X NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtXNegLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXNegLeaf2", "missingHtD;Missing H_{T} X NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtXNegLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXNegLeaf3", "missingHtD;Missing H_{T} X NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);

  missingHtD_HtYPosLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYPosLeaf1", "missingHtD;Missing H_{T} Y PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtYPosLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYPosLeaf2", "missingHtD;Missing H_{T} Y PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtYPosLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYPosLeaf3", "missingHtD;Missing H_{T} Y PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtYNegLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYNegLeaf1", "missingHtD;Missing H_{T} Y NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtYNegLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYNegLeaf2", "missingHtD;Missing H_{T} Y NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
  missingHtD_HtYNegLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYNegLeaf3", "missingHtD;Missing H_{T} Y NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);

  //Annotate the labels of the error flags
  //For the electrons and jets
  std::vector<std::string> errorFlagLabels;
  errorFlagLabels.push_back("Matched");
  errorFlagLabels.push_back("Unmatched Data Cand");
  errorFlagLabels.push_back("Unmatched Emul Cand");
   
  for(unsigned int i=0;i<errorFlagLabels.size();i++) {
    isoEg_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    nonIsoEg_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    cenJet_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    tauJet_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    forJet_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
  }
  errorFlagLabels.clear();
   
  //For the Total Energy Sums and HF
  errorFlagLabels.push_back("Matched");
  errorFlagLabels.push_back("Unmatched");

  for(unsigned int i=0;i<errorFlagLabels.size();i++) {
    hfRingSum_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    hfBitCount_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    totalEt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    totalHt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
  }
  errorFlagLabels.clear();

  //For the Missing Energy Sums
  errorFlagLabels.push_back("Matched");
  errorFlagLabels.push_back("Matched Mag");
  errorFlagLabels.push_back("Matched Phi");
  errorFlagLabels.push_back("Unmatched");

  for(unsigned int i=0;i<errorFlagLabels.size();i++) {
    missingEt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
    missingHt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
  }

  //initialise - set all flags to false as they will be set on an event-by-event basis
  isIsoError=0;
  isNonIsoError=0;
  isCenJetError=0; 
  isTauJetError=0;
  isForJetError=0;
  isRingSumError=0;
  isBitCountError=0;
  isTotalEError=0;
  isTotalHError=0;
  isMissingEError=0;
  isMissingHError=0;

  //fill the struct of MBXinformation. It is easier to pass this information to the respective functions as used below this way
  MBxInfo.RCTTrigBx = RCTTrigBx_;
  MBxInfo.EmuTrigBx = EmuTrigBx_;
  MBxInfo.GCTTrigBx = GCTTrigBx_;

  //set the parameters according to the system chosen
  if(useSys_ == "P5") {
    RCT_REGION_QUANTA = &RCT_REGION_QUANTA_P5;
  }
  else if(useSys_ == "Lab") {
    RCT_REGION_QUANTA = &RCT_REGION_QUANTA_LAB;
  }
  else {
    edm::LogWarning("ChosenSystem") << " " << "The system you chose to use (" << useSys_ << ") was not recognised. Defaulting to the full system geometry";
    RCT_REGION_QUANTA = &RCT_REGION_QUANTA_P5;
  }

}

GctErrorAnalyzer::~GctErrorAnalyzer

(

)

Definition at line 572 of file GctErrorAnalyzer.cc.

{
 
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)

}

Member Function Documentation

void GctErrorAnalyzer::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 587 of file GctErrorAnalyzer.cc.

References cenJet_errorFlag_, cenJetD_GlobalError_EtEtaPhi_, cenJetD_GlobalError_Rank_, cenJetE_GlobalError_EtEtaPhi_, cenJetE_GlobalError_Rank_, checkCollections(), dataTag_, doBitCountDebug_, doCenJetsDebug_, compareCands< T >::doCompare(), compareRingSums::doCompare(), compareBitCounts::doCompare(), compareTotalEnergySums< T >::doCompare(), compareMissingEnergySums< T >::doCompare(), doEg_, doExtraMissingHTDebug_, doForJetsDebug_, doGCTMBx_, doHF_, doIsoDebug_, doJets_, doMissingEnergySums_, doMissingETDebug_, doMissingHTDebug_, doNonIsoDebug_, doRCT_, doRingSumDebug_, doTauJetsDebug_, doTotalEnergySums_, doTotalEtDebug_, doTotalHtDebug_, emuTag_, edm::EventID::event(), eventNumber, forJet_errorFlag_, forJetD_GlobalError_EtEtaPhi_, forJetD_GlobalError_Rank_, forJetE_GlobalError_EtEtaPhi_, forJetE_GlobalError_Rank_, GCT_INT_HTMISS_QUANTA, GCT_OBJECT_QUANTA, GCT_SUMS_QUANTA, GCTTrigBx_, edm::Event::getByLabel(), hfBitCount_errorFlag_, hfRingSum_errorFlag_, i, edm::EventBase::id(), isBitCountError, isCenJetError, isForJetError, isIsoError, isMissingEError, isMissingHError, isNonIsoError, isoEg_errorFlag_, isoEgD_GlobalError_EtEtaPhi_, isoEgD_GlobalError_Rank_, isoEgE_GlobalError_EtEtaPhi_, isoEgE_GlobalError_Rank_, isRingSumError, isTauJetError, isTotalEError, isTotalHError, edm::InputTag::label(), MBxInfo, missingEt_errorFlag_, missingHt_errorFlag_, missingHtD_HtXNegLeaf1, missingHtD_HtXNegLeaf2, missingHtD_HtXNegLeaf3, missingHtD_HtXPosLeaf1, missingHtD_HtXPosLeaf2, missingHtD_HtXPosLeaf3, missingHtD_HtYNegLeaf1, missingHtD_HtYNegLeaf2, missingHtD_HtYNegLeaf3, missingHtD_HtYPosLeaf1, missingHtD_HtYPosLeaf2, missingHtD_HtYPosLeaf3, nonIsoEg_errorFlag_, nonIsoEgD_GlobalError_EtEtaPhi_, nonIsoEgD_GlobalError_Rank_, nonIsoEgE_GlobalError_EtEtaPhi_, nonIsoEgE_GlobalError_Rank_, NUM_INT_JETS, plotCenJets(), plotEGErrors(), plotForJets(), plotHFBitCounts(), plotHFErrors(), plotHFRingSums(), plotIntJets(), plotIsoEm(), plotJetErrors(), plotMissingEErrors(), plotMissingEt(), plotMissingHt(), plotNonIsoEm(), plotRCTRegions(), plotTauJets(), plotTotalE(), plotTotalEErrors(), plotTotalH(), RCT_EM_OBJECT_QUANTA, RCT_REGION_QUANTA, tauJet_errorFlag_, tauJetD_GlobalError_EtEtaPhi_, tauJetD_GlobalError_Rank_, tauJetE_GlobalError_EtEtaPhi_, tauJetE_GlobalError_Rank_, totalEt_errorFlag_, and totalHt_errorFlag_.

{
  using namespace edm;
  using namespace std;

  Handle<L1CaloRegionCollection> caloRegions; 
  Handle<L1CaloEmCollection> emRegions;

  Handle<L1GctEmCandCollection> nonIsoEgD; 
  Handle<L1GctEmCandCollection> nonIsoEgE;
  Handle<L1GctEmCandCollection> isoEgD; 
  Handle<L1GctEmCandCollection> isoEgE;

  Handle<L1GctJetCandCollection> cenJetsD; 
  Handle<L1GctJetCandCollection> cenJetsE; 
  Handle<L1GctJetCandCollection> forJetsD; 
  Handle<L1GctJetCandCollection> forJetsE; 
  Handle<L1GctJetCandCollection> tauJetsD; 
  Handle<L1GctJetCandCollection> tauJetsE;

  Handle<L1GctInternJetDataCollection> intJetsE;

  Handle<L1GctHFRingEtSumsCollection> hfRingSumsD;
  Handle<L1GctHFRingEtSumsCollection> hfRingSumsE;

  Handle<L1GctHFBitCountsCollection> hfBitCountsD;
  Handle<L1GctHFBitCountsCollection> hfBitCountsE;

  Handle<L1GctEtTotalCollection> totalEtD;
  Handle<L1GctEtTotalCollection> totalEtE;

  Handle<L1GctEtHadCollection> totalHtD;
  Handle<L1GctEtHadCollection> totalHtE;

  Handle<L1GctEtMissCollection> missingEtD;
  Handle<L1GctEtMissCollection> missingEtE;

  Handle<L1GctHtMissCollection> missingHtD;
  Handle<L1GctHtMissCollection> missingHtE;

  Handle<L1GctInternHtMissCollection> intHtMissD;

  //we need this for all user cases...
  iEvent.getByLabel(dataTag_.label(), caloRegions);

  //in order to allow the debug folders to have a unique name (so that when jobs are split in crab, we can merge) 
  //use the eventnum in the folder name
  eventNumber = iEvent.id().event();

  if(doRCT_) {
    if(checkCollections(caloRegions, *RCT_REGION_QUANTA, "RCT CaloRegions")) plotRCTRegions(caloRegions);
  }

  if(doEg_) {
    iEvent.getByLabel(dataTag_.label(),"nonIsoEm", nonIsoEgD);
    iEvent.getByLabel(emuTag_.label(), "nonIsoEm", nonIsoEgE);

    iEvent.getByLabel(dataTag_.label(), "isoEm", isoEgD);
    iEvent.getByLabel(emuTag_.label(), "isoEm", isoEgE);

    isIsoError=0;
    isNonIsoError=0;

    if(checkCollections(isoEgD, GCT_OBJECT_QUANTA, "Iso e/g Data") && checkCollections(isoEgE, GCT_OBJECT_QUANTA, "Iso e/g Emulator")) {
      plotIsoEm(isoEgD, isoEgE);
      compareEG isoCompare(isoEgD, isoEgE, MBxInfo);
      isIsoError = isoCompare.doCompare(isoEg_errorFlag_, isoEgD_GlobalError_Rank_, isoEgD_GlobalError_EtEtaPhi_, isoEgE_GlobalError_Rank_, isoEgE_GlobalError_EtEtaPhi_);
    }
    
    if(checkCollections(nonIsoEgD, GCT_OBJECT_QUANTA, "NonIso e/g Data") && checkCollections(nonIsoEgE, GCT_OBJECT_QUANTA, "NonIso e/g Emulator")) {
      plotNonIsoEm(nonIsoEgD, nonIsoEgE);
      compareEG nonIsoCompare(nonIsoEgD, nonIsoEgE, MBxInfo);
      isNonIsoError = nonIsoCompare.doCompare(nonIsoEg_errorFlag_, nonIsoEgD_GlobalError_Rank_, nonIsoEgD_GlobalError_EtEtaPhi_, nonIsoEgE_GlobalError_Rank_, nonIsoEgE_GlobalError_EtEtaPhi_);
    }

    if( (isIsoError && doIsoDebug_) || (isNonIsoError && doNonIsoDebug_) ) {
      iEvent.getByLabel(dataTag_.label(), emRegions);
      if(checkCollections(emRegions, RCT_EM_OBJECT_QUANTA, "RCT EMRegions")) plotEGErrors(isoEgD, isoEgE, nonIsoEgD, nonIsoEgE, emRegions);
    } 
  }

  if(doJets_) {
    iEvent.getByLabel(emuTag_.label(), "cenJets", cenJetsE);
    iEvent.getByLabel(dataTag_.label(), "cenJets", cenJetsD);

    iEvent.getByLabel(emuTag_.label(), "forJets", forJetsE);
    iEvent.getByLabel(dataTag_.label(), "forJets", forJetsD);

    iEvent.getByLabel(emuTag_.label(), "tauJets", tauJetsE);
    iEvent.getByLabel(dataTag_.label(), "tauJets", tauJetsD);

    iEvent.getByLabel(emuTag_.label(), intJetsE); 

    isCenJetError=0;
    isTauJetError=0;
    isForJetError=0;

    //Central Jets
    if(checkCollections(cenJetsD, GCT_OBJECT_QUANTA, "Central Jets Data") && checkCollections(cenJetsE, GCT_OBJECT_QUANTA, "Central Jets Emulator")) {
      plotCenJets(cenJetsD, cenJetsE);
      compareJets cenJetsCompare(cenJetsD, cenJetsE, MBxInfo);
      isCenJetError = cenJetsCompare.doCompare(cenJet_errorFlag_, cenJetD_GlobalError_Rank_, cenJetD_GlobalError_EtEtaPhi_, cenJetE_GlobalError_Rank_, cenJetE_GlobalError_EtEtaPhi_);
    }

    //Tau Jets
    if(checkCollections(tauJetsD, GCT_OBJECT_QUANTA, "Tau Jets Data") && checkCollections(tauJetsE, GCT_OBJECT_QUANTA, "Tau Jets Emulator")) {
      plotTauJets(tauJetsD, tauJetsE);
      compareJets tauJetsCompare(tauJetsD, tauJetsE, MBxInfo);
      isTauJetError = tauJetsCompare.doCompare(tauJet_errorFlag_, tauJetD_GlobalError_Rank_, tauJetD_GlobalError_EtEtaPhi_, tauJetE_GlobalError_Rank_, tauJetE_GlobalError_EtEtaPhi_);
    }

    //For Jets
    if(checkCollections(forJetsD, GCT_OBJECT_QUANTA, "Forward Jets Data") && checkCollections(forJetsE, GCT_OBJECT_QUANTA, "Forward Jets Emulator")) {
      plotForJets(forJetsD, forJetsE);
      compareJets forJetsCompare(forJetsD, forJetsE, MBxInfo);
      isForJetError = forJetsCompare.doCompare(forJet_errorFlag_, forJetD_GlobalError_Rank_, forJetD_GlobalError_EtEtaPhi_, forJetE_GlobalError_Rank_, forJetE_GlobalError_EtEtaPhi_); 
    }

    //Emulator Intermediate Jets
    if(checkCollections(intJetsE, NUM_INT_JETS, "Intermediate Jets Emulator")) plotIntJets(intJetsE);

    if( (isCenJetError && doCenJetsDebug_) || (isTauJetError && doTauJetsDebug_) || (isForJetError && doForJetsDebug_) ) {
      plotJetErrors(cenJetsD, cenJetsE, tauJetsD, tauJetsE, forJetsD, forJetsE, caloRegions);
    }  
  }

  if(doHF_) {
    iEvent.getByLabel(dataTag_.label(), hfRingSumsD);
    iEvent.getByLabel(emuTag_.label(), hfRingSumsE);

    iEvent.getByLabel(dataTag_.label(), hfBitCountsD);
    iEvent.getByLabel(emuTag_.label(), hfBitCountsE);
    
    isRingSumError=0;
    isBitCountError=0;
    
    if(checkCollections(hfRingSumsD, GCT_SUMS_QUANTA, "HF Ring Sums Data") && checkCollections(hfRingSumsE, GCT_SUMS_QUANTA, "HF Ring Sums Emulator")) {
      plotHFRingSums(hfRingSumsD, hfRingSumsE);
      compareRingSums HFRingSums(hfRingSumsD, hfRingSumsE, MBxInfo);
      isRingSumError = HFRingSums.doCompare(hfRingSum_errorFlag_);
    }

    if(checkCollections(hfBitCountsD, GCT_SUMS_QUANTA, "HF Bit Counts Data") && checkCollections(hfBitCountsE, GCT_SUMS_QUANTA, "HF Bit Counts Emulator")) {
      plotHFBitCounts(hfBitCountsD, hfBitCountsE);
      compareBitCounts HFBitCounts(hfBitCountsD, hfBitCountsE, MBxInfo);
      isBitCountError = HFBitCounts.doCompare(hfBitCount_errorFlag_); 
    }

    if( (isRingSumError && doRingSumDebug_) || (isBitCountError && doBitCountDebug_) ) {
      plotHFErrors(hfRingSumsD, hfRingSumsE, hfBitCountsD, hfBitCountsE, caloRegions);
    }
  }

  if(doTotalEnergySums_) {
    iEvent.getByLabel(dataTag_.label(), totalEtD);
    iEvent.getByLabel(emuTag_.label(), totalEtE);

    iEvent.getByLabel(dataTag_.label(), totalHtD);
    iEvent.getByLabel(emuTag_.label(), totalHtE);

    isTotalEError=0;
    isTotalHError=0;

    if(checkCollections(totalEtD, GCT_SUMS_QUANTA, "Total Et Data") && checkCollections(totalEtE, GCT_SUMS_QUANTA, "Total Et Emulator")) {
      plotTotalE(totalEtD, totalEtE);   
      compareTotalE compareET(totalEtD, totalEtE, MBxInfo);
      isTotalEError = compareET.doCompare(totalEt_errorFlag_);
    }

    if(checkCollections(totalHtD, GCT_SUMS_QUANTA, "Total Ht Data") && checkCollections(totalHtE, GCT_SUMS_QUANTA, "Total Ht Emulator")) {
      plotTotalH(totalHtD, totalHtE);
      compareTotalH compareHT(totalHtD, totalHtE, MBxInfo);
      isTotalHError = compareHT.doCompare(totalHt_errorFlag_);  
    }

    if((isTotalEError && doTotalEtDebug_) || (isTotalHError && doTotalHtDebug_)) {
      plotTotalEErrors(totalEtD, totalEtE, totalHtD, totalHtE, caloRegions);
    }

  }

  if(doMissingEnergySums_) {

    iEvent.getByLabel(dataTag_.label(), missingEtD);
    iEvent.getByLabel(emuTag_.label(), missingEtE);

    iEvent.getByLabel(dataTag_.label(), missingHtD);
    iEvent.getByLabel(emuTag_.label(), missingHtE);
    
    isMissingEError=0;
    isMissingHError=0;
    
    if(checkCollections(missingEtD, GCT_SUMS_QUANTA, "Missing Et Data") && checkCollections(missingEtE, GCT_SUMS_QUANTA, "Missing Et Emulator")) {
      plotMissingEt(missingEtD, missingEtE);
      compareMissingE compareMET(missingEtD, missingEtE, MBxInfo);
      isMissingEError = compareMET.doCompare(missingEt_errorFlag_);
    }

    if(checkCollections(missingHtD, GCT_SUMS_QUANTA, "Missing Ht Data") && checkCollections(missingHtE, GCT_SUMS_QUANTA, "Missing Ht Emulator")) {
      plotMissingHt(missingHtD, missingHtE);
      compareMissingH compareMHT(missingHtD, missingHtE, MBxInfo);
      isMissingHError = compareMHT.doCompare(missingHt_errorFlag_);

      //added 19/03/2010 for intermediate information on MissingHt quantities in the data
      if(doExtraMissingHTDebug_) {
    iEvent.getByLabel(dataTag_.label(), "", intHtMissD);
    if(checkCollections(intHtMissD, GCT_INT_HTMISS_QUANTA, "Internal Missing Ht Data")) {
      for(unsigned int i=0; i<intHtMissD->size(); i++) {
        if(doGCTMBx_ || intHtMissD->at(i).bx() == GCTTrigBx_) {
          if(!intHtMissD->at(i).overflow()) {
        //the capBlock 0x301 is the input pipeline at the wheel for positive eta, whereas 0x701 is for negative eta
        if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXPosLeaf1->Fill(intHtMissD->at(i).htx());
        if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXPosLeaf2->Fill(intHtMissD->at(i).htx());
        if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXPosLeaf3->Fill(intHtMissD->at(i).htx());
        if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXNegLeaf1->Fill(intHtMissD->at(i).htx());
        if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXNegLeaf2->Fill(intHtMissD->at(i).htx());
        if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXNegLeaf3->Fill(intHtMissD->at(i).htx());
        
        if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHty()) missingHtD_HtYPosLeaf1->Fill(intHtMissD->at(i).hty());
        if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHty()) missingHtD_HtYPosLeaf2->Fill(intHtMissD->at(i).hty());
        if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHty()) missingHtD_HtYPosLeaf3->Fill(intHtMissD->at(i).hty());
        if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHty()) missingHtD_HtYNegLeaf1->Fill(intHtMissD->at(i).hty());
        if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHty()) missingHtD_HtYNegLeaf2->Fill(intHtMissD->at(i).hty());
        if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHty()) missingHtD_HtYNegLeaf3->Fill(intHtMissD->at(i).hty());       
          }
        }
      }
    }
      }
    }

    if((isMissingEError && doMissingETDebug_) || (isMissingHError && doMissingHTDebug_)) {
      plotMissingEErrors(missingEtD, missingEtE, missingHtD, missingHtE, caloRegions, intJetsE, intHtMissD);
    }

  }

}

void GctErrorAnalyzer::beginJob ( void  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 829 of file GctErrorAnalyzer.cc.

{
}

template<class T >

bool GctErrorAnalyzer::checkCollections ( const T &  collection, const unsigned int &  constraint, const std::string &  label  )

private

Definition at line 1111 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and plotMissingEErrors().

                                                                                                              {

  //unfortunately, the dataformats are not consistent with the name() method (i.e. some have it, others don't)
  //and a typeof() function doesn't exist in ANSI C++, so to identify the templated type, we pass a std::string

  if(!collection.isValid()) {
    edm::LogWarning("DataNotFound") << " Could not find " << label << " label";
    return false;
  }
  if(collection->size() % constraint != 0 || collection->size() == 0) {
    edm::LogWarning("CollectionSizeError") << " " << label << " collection size is " << collection->size() << ", expected multiple of " << constraint;
    return false;
  }

  return true;
}

void GctErrorAnalyzer::endJob ( void  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 835 of file GctErrorAnalyzer.cc.

                         {
}

GctErrorAnalyzer GctErrorAnalyzer::operator= ( const GctErrorAnalyzer &  )

private

void GctErrorAnalyzer::plotCenJets ( const edm::Handle< L1GctJetCandCollection > &  data, const edm::Handle< L1GctJetCandCollection > &  emu  )

private

Definition at line 962 of file GctErrorAnalyzer.cc.

References cenJetD_EtEtaPhi_, cenJetD_OccEtaPhi_, cenJetD_Rank_, cenJetE_EtEtaPhi_, cenJetE_OccEtaPhi_, cenJetE_Rank_, doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, and i.

Referenced by analyze().

                                                                                                                                  {

  for (unsigned int i=0; i < cenJetsD->size(); i++) {
    if(doGCTMBx_ || cenJetsD->at(i).bx() == GCTTrigBx_) {
      cenJetD_Rank_->Fill(cenJetsD->at(i).rank());
      if(cenJetsD->at(i).rank()>0) {
    cenJetD_EtEtaPhi_->Fill(cenJetsD->at(i).regionId().ieta(),cenJetsD->at(i).regionId().iphi(),cenJetsD->at(i).rank());
    cenJetD_OccEtaPhi_->Fill(cenJetsD->at(i).regionId().ieta(),cenJetsD->at(i).regionId().iphi());
      }
    }
  }

  for(unsigned int i=0;  i < cenJetsE->size(); i++) {
    if(doEmuMBx_ || cenJetsE->at(i).bx() == EmuTrigBx_) {
      cenJetE_Rank_->Fill(cenJetsE->at(i).rank());
      if(cenJetsE->at(i).rank()>0) {
        cenJetE_EtEtaPhi_->Fill(cenJetsE->at(i).regionId().ieta(),cenJetsE->at(i).regionId().iphi(),cenJetsE->at(i).rank());
        cenJetE_OccEtaPhi_->Fill(cenJetsE->at(i).regionId().ieta(),cenJetsE->at(i).regionId().iphi());
      }
    }
  }
}

void GctErrorAnalyzer::plotEGErrors ( const edm::Handle< L1GctEmCandCollection > &  dataiso, const edm::Handle< L1GctEmCandCollection > &  emuiso, const edm::Handle< L1GctEmCandCollection > &  datanoniso, const edm::Handle< L1GctEmCandCollection > &  emunoniso, const edm::Handle< L1CaloEmCollection > &  regions  )

private

Definition at line 904 of file GctErrorAnalyzer.cc.

References EmuTrigBx_, errorHistCat, eventNumber, GCTTrigBx_, i, isIsoError, isNonIsoError, TFileDirectory::make(), RCTTrigBx_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                                                                                                                                                                                                                                                                                   {

  std::string errorDirName = "err_";
  if(isIsoError) errorDirName.append("I"); 
  if(isNonIsoError) errorDirName.append("N"); 
  std::stringstream caseNumber;
  caseNumber << eventNumber;
  errorDirName.append(caseNumber.str());
  TFileDirectory errorDir = errorHistCat.at(0).mkdir(errorDirName);

  TH2I *errorEmRegionIsoEtEtaPhi_ = errorDir.make<TH2I>("errorEmRegionIsoEtEtaPhi", "errorEmRegionIsoEtEtaPhi;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorEmRegionNonIsoEtEtaPhi_ = errorDir.make<TH2I>("errorEmRegionNonIsoEtEtaPhi", "errorEmRegionNonIsoEtEtaPhi;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorIsoEtEtaPhiD_ = errorDir.make<TH2I>("errorIsoEtEtaPhiD", "errorIsoEtEtaPhiD;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorNonIsoEtEtaPhiD_ = errorDir.make<TH2I>("errorNonIsoEtEtaPhiD", "errorNonIsoEtEtaPhiD;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorIsoEtEtaPhiE_ = errorDir.make<TH2I>("errorIsoEtEtaPhiE", "errorIsoEtEtaPhiE;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorNonIsoEtEtaPhiE_ = errorDir.make<TH2I>("errorNonIsoEtEtaPhiE", "errorNonIsoEtEtaPhiE;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);

  //fill the EM input collection
  //should only fill the correct bx for emRegions - and since this is showing an error in the comparison, we should plot the input to this comparison i.e. Bx=RCTTrigBx
  //this assumes that comparison is done on the central Bx i.e. RctBx=0 corresponds to GctBx=0, and EmuBx=0 takes RctBx=0
  for(unsigned int i=0;i < emRegions->size();i++) {
    if(emRegions->at(i).bx() == RCTTrigBx_) {
      if(emRegions->at(i).isolated()) {
    if(emRegions->at(i).rank()>0) errorEmRegionIsoEtEtaPhi_->Fill(emRegions->at(i).regionId().ieta(),emRegions->at(i).regionId().iphi(),emRegions->at(i).rank());
      }
      else{
    if(emRegions->at(i).rank()>0) errorEmRegionNonIsoEtEtaPhi_->Fill(emRegions->at(i).regionId().ieta(),emRegions->at(i).regionId().iphi(),emRegions->at(i).rank());
      }
    }
  }
      
  //no need to have the rank plot, because you can't have two electrons in the same place (eta,phi), in the same event...
  //in this case, since we're actually comparing the GCTTrigBx_ with the EmuTrigBx_, we plot these individually
  for(unsigned int i=0; i < isoEgD->size(); i++) {
    if(isoEgD->at(i).bx() == GCTTrigBx_) {
      if(isoEgD->at(i).rank()>0) errorIsoEtEtaPhiD_->Fill(isoEgD->at(i).regionId().ieta(),isoEgD->at(i).regionId().iphi(),isoEgD->at(i).rank());
    }
  }
  for(unsigned int i=0; i < nonIsoEgD->size(); i++) {
    if(nonIsoEgD->at(i).bx() == GCTTrigBx_) {
      if(nonIsoEgD->at(i).rank()>0) errorNonIsoEtEtaPhiD_->Fill(nonIsoEgD->at(i).regionId().ieta(),nonIsoEgD->at(i).regionId().iphi(),nonIsoEgD->at(i).rank());
    }
  }

  //now for the emulator candidates
  for(unsigned int i=0; i < isoEgE->size(); i++) {
    if(isoEgE->at(i).bx() == EmuTrigBx_) {
      if(isoEgE->at(i).rank()>0) errorIsoEtEtaPhiE_->Fill(isoEgE->at(i).regionId().ieta(),isoEgE->at(i).regionId().iphi(),isoEgE->at(i).rank());
    }
  }
  for(unsigned int i=0; i < nonIsoEgE->size(); i++) {
    if(nonIsoEgE->at(i).bx() == EmuTrigBx_) {
      if(nonIsoEgE->at(i).rank()>0) errorNonIsoEtEtaPhiE_->Fill(nonIsoEgE->at(i).regionId().ieta(),nonIsoEgE->at(i).regionId().iphi(),nonIsoEgE->at(i).rank());
    }
  }
}

void GctErrorAnalyzer::plotForJets ( const edm::Handle< L1GctJetCandCollection > &  data, const edm::Handle< L1GctJetCandCollection > &  emu  )

private

Definition at line 1010 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, forJetD_EtEtaPhi_, forJetD_OccEtaPhi_, forJetD_Rank_, forJetE_EtEtaPhi_, forJetE_OccEtaPhi_, forJetE_Rank_, GCTTrigBx_, and i.

Referenced by analyze().

                                                                                                                                  {

  for (unsigned int i=0; i < forJetsD->size(); i++) {
    if(doGCTMBx_ || forJetsD->at(i).bx() == GCTTrigBx_) {
      forJetD_Rank_->Fill(forJetsD->at(i).rank());
      if(forJetsD->at(i).rank()>0) {
        forJetD_EtEtaPhi_->Fill(forJetsD->at(i).regionId().ieta(),forJetsD->at(i).regionId().iphi(),forJetsD->at(i).rank());
        forJetD_OccEtaPhi_->Fill(forJetsD->at(i).regionId().ieta(),forJetsD->at(i).regionId().iphi());
      }
    }
  }

  for(unsigned int i=0; i < forJetsE->size(); i++) {
    if(doEmuMBx_ || forJetsE->at(i).bx() == EmuTrigBx_) {
      forJetE_Rank_->Fill(forJetsE->at(i).rank());
      if(forJetsE->at(i).rank()>0) {
        forJetE_EtEtaPhi_->Fill(forJetsE->at(i).regionId().ieta(),forJetsE->at(i).regionId().iphi(),forJetsE->at(i).rank());
        forJetE_OccEtaPhi_->Fill(forJetsE->at(i).regionId().ieta(),forJetsE->at(i).regionId().iphi());
      }
    }
  }
}

void GctErrorAnalyzer::plotHFBitCounts ( const edm::Handle< L1GctHFBitCountsCollection > &  hfBitCountsD, const edm::Handle< L1GctHFBitCountsCollection > &  hfBitCountsE  )

private

Definition at line 1220 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, hfBitCountD_1neg_, hfBitCountD_1pos_, hfBitCountD_2neg_, hfBitCountD_2pos_, hfBitCountE_1neg_, hfBitCountE_1pos_, hfBitCountE_2neg_, hfBitCountE_2pos_, and i.

Referenced by analyze().

                                                                                                                                                      {

  for(unsigned int i=0; i < hfBitCountsD->size(); i++) {
    if(doGCTMBx_ || hfBitCountsD->at(i).bx() == GCTTrigBx_) {
      //there are 4 rings - just fill the histograms
      hfBitCountD_1pos_->Fill(hfBitCountsD->at(i).bitCount(0));
      hfBitCountD_1neg_->Fill(hfBitCountsD->at(i).bitCount(1));
      hfBitCountD_2pos_->Fill(hfBitCountsD->at(i).bitCount(2));
      hfBitCountD_2neg_->Fill(hfBitCountsD->at(i).bitCount(3));
    }
  }
  for(unsigned int i=0; i < hfBitCountsE->size(); i++) {
    if(doEmuMBx_ || hfBitCountsE->at(i).bx() == EmuTrigBx_) {
      hfBitCountE_1pos_->Fill(hfBitCountsE->at(i).bitCount(0));
      hfBitCountE_1neg_->Fill(hfBitCountsE->at(i).bitCount(1));
      hfBitCountE_2pos_->Fill(hfBitCountsE->at(i).bitCount(2));
      hfBitCountE_2neg_->Fill(hfBitCountsE->at(i).bitCount(3));
    }
  }
}

void GctErrorAnalyzer::plotHFErrors ( const edm::Handle< L1GctHFRingEtSumsCollection > &  hfRingSumsD, const edm::Handle< L1GctHFRingEtSumsCollection > &  hfRingSumsE, const edm::Handle< L1GctHFBitCountsCollection > &  hfBitCountsD, const edm::Handle< L1GctHFBitCountsCollection > &  hfBitCountsE, const edm::Handle< L1CaloRegionCollection > &  caloRegions  )

private

Definition at line 1242 of file GctErrorAnalyzer.cc.

References EmuTrigBx_, errorHistCat, eventNumber, GCTTrigBx_, i, isBitCountError, isRingSumError, TFileDirectory::make(), RCTTrigBx_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                                                                                                                                                                                                                                                                                                                               {

  std::string errorDirName = "err_";
  if(isRingSumError) errorDirName.append("R"); 
  if(isBitCountError) errorDirName.append("B"); 
  std::stringstream caseNumber;
  caseNumber << eventNumber;
  errorDirName.append(caseNumber.str());
  TFileDirectory errorDir = errorHistCat.at(2).mkdir(errorDirName);

  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorRegionFgEtaPhi_ = errorDir.make<TH2I>("errorRegionFgEtaPhi", "errorRegionFgEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);

  TH1I *errorHFRingSumD_1pos_ = errorDir.make<TH1I>("errorHFRingSumD_1+", "errorHFRingSumD_1+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumD_2pos_ = errorDir.make<TH1I>("errorHFRingSumD_2+", "errorHFRingSumD_2+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumD_1neg_ = errorDir.make<TH1I>("errorHFRingSumD_1-", "errorHFRingSumD_1-;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumD_2neg_ = errorDir.make<TH1I>("errorHFRingSumD_2-", "errorHFRingSumD_2-;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumE_1pos_ = errorDir.make<TH1I>("errorHFRingSumE_1+", "errorHFRingSumE_1+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumE_2pos_ = errorDir.make<TH1I>("errorHFRingSumE_2+", "errorHFRingSumE_2+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumE_1neg_ = errorDir.make<TH1I>("errorHFRingSumE_1-", "errorHFRingSumE_1-;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFRingSumE_2neg_ = errorDir.make<TH1I>("errorHFRingSumE_2-", "errorHFRingSumE_2-;Rank;Number of Events", 8, -0.5, 7.5);

  TH1I *errorHFBitCountD_1pos_ = errorDir.make<TH1I>("errorHFBitCountD_1+", "errorHFBitCountD_1+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountD_2pos_ = errorDir.make<TH1I>("errorHFBitCountD_2+", "errorHFBitCountD_2+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountD_1neg_ = errorDir.make<TH1I>("errorHFBitCountD_1-", "errorHFBitCountD_1-;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountD_2neg_ = errorDir.make<TH1I>("errorHFBitCountD_2-", "errorHFBitCountD_2-;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountE_1pos_ = errorDir.make<TH1I>("errorHFBitCountE_1+", "errorHFBitCountE_1+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountE_2pos_ = errorDir.make<TH1I>("errorHFBitCountE_2+", "errorHFBitCountE_2+;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountE_1neg_ = errorDir.make<TH1I>("errorHFBitCountE_1-", "errorHFBitCountE_1-;Rank;Number of Events", 8, -0.5, 7.5);
  TH1I *errorHFBitCountE_2neg_ = errorDir.make<TH1I>("errorHFBitCountE_2-", "errorHFBitCountE_2-;Rank;Number of Events", 8, -0.5, 7.5);

  for(unsigned int i=0;i<caloRegions->size();i++) {
    if(caloRegions->at(i).bx() == RCTTrigBx_) {
      if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
      if(caloRegions->at(i).fineGrain()) errorRegionFgEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
      if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
    }
  }
       
  for(unsigned int i=0; i < hfRingSumsD->size(); i++) {
    if(hfRingSumsD->at(i).bx() == GCTTrigBx_) {
      errorHFRingSumD_1pos_->Fill(hfRingSumsD->at(i).etSum(0));
      errorHFRingSumD_1neg_->Fill(hfRingSumsD->at(i).etSum(1));
      errorHFRingSumD_2pos_->Fill(hfRingSumsD->at(i).etSum(2));
      errorHFRingSumD_2neg_->Fill(hfRingSumsD->at(i).etSum(3));
    }
  }
  for(unsigned int i=0; i < hfRingSumsE->size(); i++) {
    if(hfRingSumsE->at(i).bx() == EmuTrigBx_) {
      errorHFRingSumE_1pos_->Fill(hfRingSumsE->at(i).etSum(0));
      errorHFRingSumE_1neg_->Fill(hfRingSumsE->at(i).etSum(1));
      errorHFRingSumE_2pos_->Fill(hfRingSumsE->at(i).etSum(2));
      errorHFRingSumE_2neg_->Fill(hfRingSumsE->at(i).etSum(3));
    }
  }

  for(unsigned int i=0; i < hfBitCountsD->size(); i++) {
    if(hfBitCountsD->at(i).bx() == GCTTrigBx_) {
      errorHFBitCountD_1pos_->Fill(hfBitCountsD->at(i).bitCount(0));
      errorHFBitCountD_1neg_->Fill(hfBitCountsD->at(i).bitCount(1));
      errorHFBitCountD_2pos_->Fill(hfBitCountsD->at(i).bitCount(2));
      errorHFBitCountD_2neg_->Fill(hfBitCountsD->at(i).bitCount(3));
    }
  }
  for(unsigned int i=0; i < hfBitCountsE->size(); i++) {
    if(hfBitCountsE->at(i).bx() == EmuTrigBx_) {
      errorHFBitCountE_1pos_->Fill(hfBitCountsE->at(i).bitCount(0));
      errorHFBitCountE_1neg_->Fill(hfBitCountsE->at(i).bitCount(1));
      errorHFBitCountE_2pos_->Fill(hfBitCountsE->at(i).bitCount(2));
      errorHFBitCountE_2neg_->Fill(hfBitCountsE->at(i).bitCount(3));
    }
  }
}

void GctErrorAnalyzer::plotHFRingSums ( const edm::Handle< L1GctHFRingEtSumsCollection > &  data, const edm::Handle< L1GctHFRingEtSumsCollection > &  emu  )

private

Definition at line 1197 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, hfRingSumD_1neg_, hfRingSumD_1pos_, hfRingSumD_2neg_, hfRingSumD_2pos_, hfRingSumE_1neg_, hfRingSumE_1pos_, hfRingSumE_2neg_, hfRingSumE_2pos_, and i.

Referenced by analyze().

                                                                                                                                                     {

  for(unsigned int i=0; i < hfRingSumsD->size(); i++) {
    if(doGCTMBx_ || hfRingSumsD->at(i).bx() == GCTTrigBx_) {
      //there are 4 rings - just fill the histograms
      hfRingSumD_1pos_->Fill(hfRingSumsD->at(i).etSum(0));
      hfRingSumD_1neg_->Fill(hfRingSumsD->at(i).etSum(1));
      hfRingSumD_2pos_->Fill(hfRingSumsD->at(i).etSum(2));
      hfRingSumD_2neg_->Fill(hfRingSumsD->at(i).etSum(3));
    }
  }

  for(unsigned int i=0; i < hfRingSumsE->size(); i++) {
    if(doEmuMBx_ || hfRingSumsE->at(i).bx() == EmuTrigBx_) {
      hfRingSumE_1pos_->Fill(hfRingSumsE->at(i).etSum(0));
      hfRingSumE_1neg_->Fill(hfRingSumsE->at(i).etSum(1));
      hfRingSumE_2pos_->Fill(hfRingSumsE->at(i).etSum(2));
      hfRingSumE_2neg_->Fill(hfRingSumsE->at(i).etSum(3));
    }
  }
}

void GctErrorAnalyzer::plotIntJets ( const edm::Handle< L1GctInternJetDataCollection > &  emu )

private

Definition at line 1034 of file GctErrorAnalyzer.cc.

References doEmuMBx_, EmuTrigBx_, jetData::et, jetData::eta, i, intJetE_Et_, intJetE_Jet1Et_, intJetE_Jet2Et_, intJetE_Jet3Et_, intJetE_Jet4Et_, intJetE_Of_, intJetEtEtaPhiE_, j, NUM_INT_JETS, jetData::phi, python.multivaluedict::sort(), and sortJets().

Referenced by analyze().

                                                                                     {

  jetData intJet;
  std::vector<jetData> intJetCollection(NUM_INT_JETS); //define fixed size for the vector to avoid reallocation (i.e. max size possible)

  //since we don't read out the intermediate (i.e. leaf card) jets, we can only plot the emulator distributions
  //the 1st-4th jet Et will prove useful in understanding and motivating cuts on individual jets in HT and MHT.
  for(unsigned int i=0; i < intJetsE->size(); i++) {

    if(doEmuMBx_ || intJetsE->at(i).bx() == EmuTrigBx_) {

      //the intermediate jets are not sorted in terms of Et so
      //in order to do this independently of the data format,
      //copy to a user defined struct and sort that way
      intJet.et = intJetsE->at(i).et();
      intJet.phi = intJetsE->at(i).phi();
      intJet.eta = intJetsE->at(i).eta();
      intJetCollection.at(i % NUM_INT_JETS) = intJet;

      //remember, if the event has 1 overflowed jet, then we fill the internal jet dist overflow histogram
      //and skip the event - there is no point looking at the leading jet distributions etc for an event
      //with an overflowed jet - this will imply HT, ET, MET and MHT all overflow too.
      if(intJetsE->at(i).oflow()) {
    intJetE_Of_->Fill(intJetsE->at(i).oflow());
    return;
      }

      //plot the (et,eta,phi) distribution of the intermediate jets (for non-zero et)
      if(intJetsE->at(i).et()) intJetEtEtaPhiE_->Fill(intJetsE->at(i).regionId().ieta(),intJetsE->at(i).regionId().iphi(),intJetsE->at(i).et());

    }
  }

  //if we get this far, there are no jets with an overflow bit so fill the overflow histogram and
  //sort the intJetCollection according to the rule defined in sortJets (i.e. largest et first)
  intJetE_Of_->Fill(0);
  std::sort(intJetCollection.begin(), intJetCollection.end(), sortJets);

  std::vector<TH1I *> leadingJetDist(4);
  leadingJetDist.at(0) = intJetE_Jet1Et_;
  leadingJetDist.at(1) = intJetE_Jet2Et_;
  leadingJetDist.at(2) = intJetE_Jet3Et_;
  leadingJetDist.at(3) = intJetE_Jet4Et_;

  unsigned int i=0;
  unsigned int j=0;
  unsigned int currentEt=0;
  while(intJetCollection.at(i).et > 0) {

    if(j < leadingJetDist.size()) {
      if(i == 0) {
    leadingJetDist.at(j)->Fill(intJetCollection.at(i).et);
    currentEt = intJetCollection.at(i).et;
    j++;
      } else {
    if(intJetCollection.at(i).et < currentEt) {
      leadingJetDist.at(j)->Fill(intJetCollection.at(i).et);
      currentEt = intJetCollection.at(i).et;
      j++;
    }
      }
    }

    intJetE_Et_->Fill(intJetCollection.at(i).et);
    i++;
  }
  return;

}

void GctErrorAnalyzer::plotIsoEm ( const edm::Handle< L1GctEmCandCollection > &  data, const edm::Handle< L1GctEmCandCollection > &  emu  )

private

Definition at line 854 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, isoEgD_EtEtaPhi_, isoEgD_OccEtaPhi_, isoEgD_Rank_, isoEgE_EtEtaPhi_, isoEgE_OccEtaPhi_, and isoEgE_Rank_.

Referenced by analyze().

                                                                                                                          {
  //loop over all the data candidates - if multiple bx, then this should be a multiple of GCT_OBJECT_QUANTA
  for (unsigned int i=0; i < isoEgD->size(); i++) {
    //if the GCTMBx flag is set, plot all Bx for this quantity, otherwise only plot Bx = GCTTrigBx_
    if(doGCTMBx_ || isoEgD->at(i).bx() == GCTTrigBx_) {
      isoEgD_Rank_->Fill(isoEgD->at(i).rank());
      if(isoEgD->at(i).rank()>0) {
        isoEgD_EtEtaPhi_->Fill(isoEgD->at(i).regionId().ieta(), isoEgD->at(i).regionId().iphi(), isoEgD->at(i).rank());
        isoEgD_OccEtaPhi_->Fill(isoEgD->at(i).regionId().ieta(), isoEgD->at(i).regionId().iphi());
      }
    }
  }
  //now repeat for the emulator candidates
  for(unsigned int i=0; i < isoEgE->size(); i++) {
    if(doEmuMBx_ || isoEgE->at(i).bx() == EmuTrigBx_) {
      isoEgE_Rank_->Fill(isoEgE->at(i).rank());
      if(isoEgE->at(i).rank()>0) {
        isoEgE_EtEtaPhi_->Fill(isoEgE->at(i).regionId().ieta(), isoEgE->at(i).regionId().iphi(), isoEgE->at(i).rank());
        isoEgE_OccEtaPhi_->Fill(isoEgE->at(i).regionId().ieta(), isoEgE->at(i).regionId().iphi());
      }
    }
  }
}

void GctErrorAnalyzer::plotJetErrors ( const edm::Handle< L1GctJetCandCollection > &  cendata, const edm::Handle< L1GctJetCandCollection > &  cenemu, const edm::Handle< L1GctJetCandCollection > &  taudata, const edm::Handle< L1GctJetCandCollection > &  tauemu, const edm::Handle< L1GctJetCandCollection > &  fordata, const edm::Handle< L1GctJetCandCollection > &  foremu, const edm::Handle< L1CaloRegionCollection > &  regions  )

private

Definition at line 1129 of file GctErrorAnalyzer.cc.

References EmuTrigBx_, errorHistCat, eventNumber, GCTTrigBx_, i, isCenJetError, isForJetError, isTauJetError, TFileDirectory::make(), RCTTrigBx_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                                                                                                                                                                                                                                                                                                                                                                                                      {

  std::string errorDirName = "err_";
  if(isCenJetError) errorDirName.append("C"); 
  if(isTauJetError) errorDirName.append("T"); 
  if(isForJetError) errorDirName.append("F"); 
  std::stringstream caseNumber;
  caseNumber << eventNumber;
  errorDirName.append(caseNumber.str());
  TFileDirectory errorDir = errorHistCat.at(1).mkdir(errorDirName);

  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorRegionTvEtaPhi_ = errorDir.make<TH2I>("errorRegionTvEtaPhi", "errorRegionTvEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);

  //make sure to only plot the caloRegion bx which corresponds to the data vs emulator comparison
  for(unsigned int i=0;i<caloRegions->size();i++) {
    if(caloRegions->at(i).bx() == RCTTrigBx_) {
      if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
      if(caloRegions->at(i).tauVeto()) errorRegionTvEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
      if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
    }
  }
      
  TH2I *cenJet_errorEtEtaPhiData_ = errorDir.make<TH2I>("cenJet_errorEtEtaPhiData", "cenJet_errorEtEtaPhiData;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5); 
  TH2I *cenJet_errorEtEtaPhiEmu_ = errorDir.make<TH2I>("cenJet_errorEtEtaPhiEmu", "cenJet_errorEtEtaPhiEmu;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *tauJet_errorEtEtaPhiData_ = errorDir.make<TH2I>("tauJet_errorEtEtaPhiData", "tauJet_errorEtEtaPhiData;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *tauJet_errorEtEtaPhiEmu_ = errorDir.make<TH2I>("tauJet_errorEtEtaPhiEmu", "tauJet_errorEtEtaPhiEmu;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *forJet_errorEtEtaPhiData_ = errorDir.make<TH2I>("forJet_errorEtEtaPhiData", "forJet_errorEtEtaPhiData;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *forJet_errorEtEtaPhiEmu_ = errorDir.make<TH2I>("forJet_errorEtEtaPhiEmu", "forJet_errorEtEtaPhiEmu;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
        
  //first plot the data candiates for the Trigger Bx that this error corresponds to
  for(unsigned int i=0; i < cenJetsD->size(); i++) {
    if(cenJetsD->at(i).bx() == GCTTrigBx_) {
      if(cenJetsD->at(i).rank()>0) cenJet_errorEtEtaPhiData_->Fill(cenJetsD->at(i).regionId().ieta(),cenJetsD->at(i).regionId().iphi(),cenJetsD->at(i).rank());
    }
  }
  for(unsigned int i=0; i < tauJetsD->size(); i++) {
    if(tauJetsD->at(i).bx() == GCTTrigBx_) {
      if(tauJetsD->at(i).rank()>0) tauJet_errorEtEtaPhiData_->Fill(tauJetsD->at(i).regionId().ieta(),tauJetsD->at(i).regionId().iphi(),tauJetsD->at(i).rank());
    }
  }
  for(unsigned int i=0; i < forJetsD->size(); i++) {
    if(forJetsD->at(i).bx() == GCTTrigBx_) {
      if(forJetsD->at(i).rank()>0) forJet_errorEtEtaPhiData_->Fill(forJetsD->at(i).regionId().ieta(),forJetsD->at(i).regionId().iphi(),forJetsD->at(i).rank());
    }
  }

  //now the emulator candidates
  for(unsigned int i=0; i < cenJetsE->size(); i++) {
    if(cenJetsE->at(i).bx() == EmuTrigBx_) {
      if(cenJetsE->at(i).rank()>0) cenJet_errorEtEtaPhiEmu_->Fill(cenJetsE->at(i).regionId().ieta(),cenJetsE->at(i).regionId().iphi(),cenJetsE->at(i).rank());
    }
  }
  for(unsigned int i=0; i < tauJetsE->size(); i++) {
    if(tauJetsE->at(i).bx() == EmuTrigBx_) {
      if(tauJetsE->at(i).rank()>0) tauJet_errorEtEtaPhiEmu_->Fill(tauJetsE->at(i).regionId().ieta(),tauJetsE->at(i).regionId().iphi(),tauJetsE->at(i).rank());
    }
  }
  for(unsigned int i=0; i < forJetsE->size(); i++) {
    if(forJetsE->at(i).bx() == EmuTrigBx_) {
      if(forJetsE->at(i).rank()>0) forJet_errorEtEtaPhiEmu_->Fill(forJetsE->at(i).regionId().ieta(),forJetsE->at(i).regionId().iphi(),forJetsE->at(i).rank());
    }
  }

}

void GctErrorAnalyzer::plotMissingEErrors ( const edm::Handle< L1GctEtMissCollection > &  missingEtD, const edm::Handle< L1GctEtMissCollection > &  missingEtE, const edm::Handle< L1GctHtMissCollection > &  missingHtD, const edm::Handle< L1GctHtMissCollection > &  missingHtE, edm::Handle< L1CaloRegionCollection > &  caloRegions, const edm::Handle< L1GctInternJetDataCollection > &  intjetsemu, const edm::Handle< L1GctInternHtMissCollection >  intMissingHtD  )

private

Definition at line 1457 of file GctErrorAnalyzer.cc.

References checkCollections(), doExtraMissingHTDebug_, EmuTrigBx_, errorHistCat, eventNumber, GCT_INT_HTMISS_QUANTA, GCTTrigBx_, i, isMissingEError, isMissingHError, j, TFileDirectory::make(), NUM_INT_JETS, RCTTrigBx_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                                                                                                                                                                                                                                                                                                                                                                                                                        {

  std::string errorDirName = "err_"; 
  if(isMissingEError) errorDirName.append("E");
  if(isMissingHError) errorDirName.append("H");

  //added 05.03.2010 to highlight overflow errors in the missing energy sum calculation
  for(unsigned int i=0; i < missingHtE->size(); i++) {
    if(missingHtE->at(i).bx() == EmuTrigBx_) {
      for(unsigned int j=0; j < missingHtD->size(); j++) {
    if(missingHtD->at(j).bx() == GCTTrigBx_) {
      if(missingHtD->at(j).overFlow() != missingHtE->at(i).overFlow()) errorDirName.append("O");
    }
      }  
    }
  }

  std::stringstream caseNumber;
  caseNumber << eventNumber;
  errorDirName.append(caseNumber.str());
  TFileDirectory errorDir = errorHistCat.at(4).mkdir(errorDirName);

  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH1I *errorMissingEtD_ = errorDir.make<TH1I>("errorMissingEtD", "errorMissingEtD;E_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorMissingEtD_Of_ = errorDir.make<TH1I>("errorMissingEtD_Of", "errorMissingEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorMissingEtD_Phi_= errorDir.make<TH1I>("errorMissingEtD_Phi", "errorMissingEtD_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
  TH1I *errorMissingEtE_ = errorDir.make<TH1I>("errorMissingEtE", "errorMissingEtE;E_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorMissingEtE_Of_ = errorDir.make<TH1I>("errorMissingEtE_Of", "errorMissingEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorMissingEtE_Phi_ = errorDir.make<TH1I>("errorMissingEtE_Phi", "errorMissingEtE_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
  TH1I *errorMissingHtD_ = errorDir.make<TH1I>("errorMissingHtD", "errorMissingHtD;H_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorMissingHtD_Of_ = errorDir.make<TH1I>("errorMissingHtD_Of", "errorMissingHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorMissingHtD_Phi_= errorDir.make<TH1I>("errorMissingHtD_Phi", "errorMissingHtD_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
  TH1I *errorMissingHtE_ = errorDir.make<TH1I>("errorMissingHtE", "errorMissingHtE;H_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorMissingHtE_Of_ = errorDir.make<TH1I>("errorMissingHtE_Of", "errorMissingHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorMissingHtE_Phi_ = errorDir.make<TH1I>("errorMissingHtE_Phi", "errorMissingHtE_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);

  //Added 19.03.2010 to provide additional information in the case of missingHt failures
  //1. The MHT from both wheel inputs (i.e. the leaf cards)
  //2. The emulator jet et,eta,phi for all jets found in an event
  if(doExtraMissingHTDebug_) {
    if(checkCollections(intMissingHtD, GCT_INT_HTMISS_QUANTA, "Internal Missing Ht Data")) {

      TH1I *errorMissingHtD_HtXPosLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtXPosLeaf1", "missingHtD;Missing H_{T} X PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtXPosLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtXPosLeaf2", "missingHtD;Missing H_{T} X PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtXPosLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtXPosLeaf3", "missingHtD;Missing H_{T} X PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtXNegLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtXNegLeaf1", "missingHtD;Missing H_{T} X NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtXNegLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtXNegLeaf2", "missingHtD;Missing H_{T} X NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtXNegLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtXNegLeaf3", "missingHtD;Missing H_{T} X NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);

      TH1I *errorMissingHtD_HtYPosLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtYPosLeaf1", "missingHtD;Missing H_{T} Y PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtYPosLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtYPosLeaf2", "missingHtD;Missing H_{T} Y PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtYPosLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtYPosLeaf3", "missingHtD;Missing H_{T} Y PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtYNegLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtYNegLeaf1", "missingHtD;Missing H_{T} Y NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtYNegLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtYNegLeaf2", "missingHtD;Missing H_{T} Y NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
      TH1I *errorMissingHtD_HtYNegLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtYNegLeaf3", "missingHtD;Missing H_{T} Y NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);

      for(unsigned int i=0; i<intMissingHtD->size(); i++) {
    if(intMissingHtD->at(i).bx() == GCTTrigBx_) {
      if(!intMissingHtD->at(i).overflow()) {
      
        if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXPosLeaf1->Fill(intMissingHtD->at(i).htx());
        if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXPosLeaf2->Fill(intMissingHtD->at(i).htx());
        if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXPosLeaf3->Fill(intMissingHtD->at(i).htx());
        if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXNegLeaf1->Fill(intMissingHtD->at(i).htx());
        if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXNegLeaf2->Fill(intMissingHtD->at(i).htx());
        if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXNegLeaf3->Fill(intMissingHtD->at(i).htx());
      
        if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYPosLeaf1->Fill(intMissingHtD->at(i).hty());
        if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYPosLeaf2->Fill(intMissingHtD->at(i).hty());
        if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYPosLeaf3->Fill(intMissingHtD->at(i).hty());
        if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYNegLeaf1->Fill(intMissingHtD->at(i).hty());
        if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYNegLeaf2->Fill(intMissingHtD->at(i).hty());
        if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYNegLeaf3->Fill(intMissingHtD->at(i).hty());
      }
    }
      }
    }
  }
  
  if(checkCollections(intJetsE, NUM_INT_JETS, "Intermediate Jets Emulator")) {
    TH2I *errorIntJetsE_EtEtaPhi = errorDir.make<TH2I>("errorIntJetsE_EtEtaPhi", "errorIntJetsE_EtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
    
    for(unsigned int i=0; i < intJetsE->size(); i++) {
      if(intJetsE->at(i).bx() == EmuTrigBx_) {
    if(!intJetsE->at(i).oflow() && intJetsE->at(i).et()) errorIntJetsE_EtEtaPhi->Fill(intJetsE->at(i).regionId().ieta(),intJetsE->at(i).regionId().iphi(),intJetsE->at(i).et());
      }
    }
  }

  for(unsigned int i=0;i<caloRegions->size();i++) {
    if(caloRegions->at(i).bx() == RCTTrigBx_) {
      if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
      if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
    }
  }

  //plot the data candidates relating to this mismatch
  for(unsigned int i=0; i < missingEtD->size(); i++) {
    if(missingEtD->at(i).bx() == GCTTrigBx_) {
      errorMissingEtD_Of_->Fill(missingEtD->at(i).overFlow());
      if(!missingEtD->at(i).overFlow()) {
    errorMissingEtD_->Fill(missingEtD->at(i).et());
    errorMissingEtD_Phi_->Fill(missingEtD->at(i).phi());
      }
    }
  }
  for(unsigned int i=0; i < missingHtD->size(); i++) {
    if(missingHtD->at(i).bx() == GCTTrigBx_) {
      errorMissingHtD_Of_->Fill(missingHtD->at(i).overFlow());
      if(!missingHtD->at(i).overFlow()) {
    errorMissingHtD_->Fill(missingHtD->at(i).et());
    errorMissingHtD_Phi_->Fill(missingHtD->at(i).phi());
      }
    }
  }
  //and now for the emulator candidates
  for(unsigned int i=0; i < missingEtE->size(); i++) {
    if(missingEtE->at(i).bx() == EmuTrigBx_) {
      errorMissingEtE_Of_->Fill(missingEtE->at(i).overFlow());
      if(!missingEtE->at(i).overFlow()) {
    errorMissingEtE_->Fill(missingEtE->at(i).et());
    errorMissingEtE_Phi_->Fill(missingEtE->at(i).phi());
      }
    }
  }
  for(unsigned int i=0; i < missingHtE->size(); i++) {
    if(missingHtE->at(i).bx() == EmuTrigBx_) {
      errorMissingHtE_Of_->Fill(missingHtE->at(i).overFlow());
      if(!missingHtE->at(i).overFlow()) { //to see what values the emulator outputs despite the o/f bit being set comment out this statement
    errorMissingHtE_->Fill(missingHtE->at(i).et());
    errorMissingHtE_Phi_->Fill(missingHtE->at(i).phi());      
      }
    }
  }
}

void GctErrorAnalyzer::plotMissingEt ( const edm::Handle< L1GctEtMissCollection > &  missingEtD, const edm::Handle< L1GctEtMissCollection > &  missingEtE  )

private

Definition at line 1409 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, missingEtD_, missingEtD_Of_, missingEtD_Phi_, missingEtE_, missingEtE_Of_, and missingEtE_Phi_.

Referenced by analyze().

                                                                                                                                      {

  for(unsigned int i=0; i < missingEtD->size(); i++) {
    if(doGCTMBx_ || missingEtD->at(i).bx() == GCTTrigBx_) {    
      missingEtD_Of_->Fill(missingEtD->at(i).overFlow());
      if(!missingEtD->at(i).overFlow() && missingEtD->at(i).et()>0) { 
        missingEtD_->Fill(missingEtD->at(i).et());
        missingEtD_Phi_->Fill(missingEtD->at(i).phi());
      }
    }
  }
  
  for(unsigned int i=0; i < missingEtE->size(); i++) {
    if(doEmuMBx_ || missingEtE->at(i).bx() == EmuTrigBx_) {
      missingEtE_Of_->Fill(missingEtE->at(i).overFlow());
      if(!missingEtE->at(i).overFlow() && missingEtE->at(i).et()) {
        missingEtE_->Fill(missingEtE->at(i).et());
        missingEtE_Phi_->Fill(missingEtE->at(i).phi());
      }
    }
  }
}

void GctErrorAnalyzer::plotMissingHt ( const edm::Handle< L1GctHtMissCollection > &  missingHtD, const edm::Handle< L1GctHtMissCollection > &  missingHtE  )

private

Definition at line 1433 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, missingHtD_, missingHtD_Of_, missingHtD_Phi_, missingHtE_, missingHtE_Of_, and missingHtE_Phi_.

Referenced by analyze().

                                                                                                                                      {

  for(unsigned int i=0; i < missingHtD->size(); i++) {
    if(doGCTMBx_ || missingHtD->at(i).bx() == GCTTrigBx_) {
      missingHtD_Of_->Fill(missingHtD->at(i).overFlow());
      if(!missingHtD->at(i).overFlow() && missingHtD->at(i).et()>0) {
        missingHtD_->Fill(missingHtD->at(i).et());
        missingHtD_Phi_->Fill(missingHtD->at(i).phi());
      }
    }
  }

  for(unsigned int i=0; i < missingHtE->size(); i++) {
    if(doEmuMBx_ || missingHtE->at(i).bx() == EmuTrigBx_) {
      missingHtE_Of_->Fill(missingHtE->at(i).overFlow());
      if(!missingHtE->at(i).overFlow() && missingHtE->at(i).et()>0) {
        missingHtE_->Fill(missingHtE->at(i).et());
        missingHtE_Phi_->Fill(missingHtE->at(i).phi());
      }
    }
  }
}

void GctErrorAnalyzer::plotNonIsoEm ( const edm::Handle< L1GctEmCandCollection > &  data, const edm::Handle< L1GctEmCandCollection > &  emu  )

private

Definition at line 879 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, nonIsoEgD_EtEtaPhi_, nonIsoEgD_OccEtaPhi_, nonIsoEgD_Rank_, nonIsoEgE_EtEtaPhi_, nonIsoEgE_OccEtaPhi_, and nonIsoEgE_Rank_.

Referenced by analyze().

                                                                                                                                   {
  //loop over all the data candidates - if multiple bx, then this should be a multiple of GCT_OBJECT_QUANTA
  for (unsigned int i=0; i < nonIsoEgD->size(); i++) {
    //if the GCTMBx flag is set, plot all Bx for this quantity, otherwise only plot Bx = GCTTrigBx_
    if(doGCTMBx_ || nonIsoEgD->at(i).bx() == GCTTrigBx_) {
      nonIsoEgD_Rank_->Fill(nonIsoEgD->at(i).rank());
      if(nonIsoEgD->at(i).rank()>0) {
        nonIsoEgD_EtEtaPhi_->Fill(nonIsoEgD->at(i).regionId().ieta(), nonIsoEgD->at(i).regionId().iphi(), nonIsoEgD->at(i).rank());
        nonIsoEgD_OccEtaPhi_->Fill(nonIsoEgD->at(i).regionId().ieta(), nonIsoEgD->at(i).regionId().iphi());
      }
    }
  }
  //now repeat for the emulator candidates
  for(unsigned int i=0; i < nonIsoEgE->size(); i++) {
    if(doEmuMBx_ || nonIsoEgE->at(i).bx() == EmuTrigBx_) {
      nonIsoEgE_Rank_->Fill(nonIsoEgE->at(i).rank());
      if(nonIsoEgE->at(i).rank()>0) {
        nonIsoEgE_EtEtaPhi_->Fill(nonIsoEgE->at(i).regionId().ieta(), nonIsoEgE->at(i).regionId().iphi(), nonIsoEgE->at(i).rank());
        nonIsoEgE_OccEtaPhi_->Fill(nonIsoEgE->at(i).regionId().ieta(), nonIsoEgE->at(i).regionId().iphi());
      }
    }
  }
}

void GctErrorAnalyzer::plotRCTRegions ( const edm::Handle< L1CaloRegionCollection > &  caloRegions )

private

Definition at line 839 of file GctErrorAnalyzer.cc.

References doRCTMBx_, i, RCT_EtEtaPhi_, RCT_FgEtaPhi_, RCT_OfEtaPhi_, RCT_TvEtaPhi_, and RCTTrigBx_.

Referenced by analyze().

                                                                                     {
  //if more than one Bx is readout per event, then caloRegions->size() will be some multiple of 396
  for(unsigned int i=0;i < caloRegions->size();i++) {
    //if the RCTMBx flag is set to true, write out all the info into the same histogram
    //otherwise only the RCTTrigBx will be written out - could skip (RCT_REGION_QUANTA-1) events here to speed things up...
    if(doRCTMBx_ || caloRegions->at(i).bx() == RCTTrigBx_) {
      if(caloRegions->at(i).et()>0) RCT_EtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
      if(caloRegions->at(i).tauVeto()) RCT_TvEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
      if(caloRegions->at(i).fineGrain()) RCT_FgEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
      if(caloRegions->at(i).overFlow()) RCT_OfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
    }
  }
}

void GctErrorAnalyzer::plotTauJets ( const edm::Handle< L1GctJetCandCollection > &  data, const edm::Handle< L1GctJetCandCollection > &  emu  )

private

Definition at line 986 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, tauJetD_EtEtaPhi_, tauJetD_OccEtaPhi_, tauJetD_Rank_, tauJetE_EtEtaPhi_, tauJetE_OccEtaPhi_, and tauJetE_Rank_.

Referenced by analyze().

                                                                                                                                  {

  for (unsigned int i=0; i < tauJetsD->size(); i++) {
    if(doGCTMBx_ || tauJetsD->at(i).bx() == GCTTrigBx_) {
      tauJetD_Rank_->Fill(tauJetsD->at(i).rank());
      if(tauJetsD->at(i).rank()>0) {
        tauJetD_EtEtaPhi_->Fill(tauJetsD->at(i).regionId().ieta(),tauJetsD->at(i).regionId().iphi(),tauJetsD->at(i).rank());
        tauJetD_OccEtaPhi_->Fill(tauJetsD->at(i).regionId().ieta(),tauJetsD->at(i).regionId().iphi());
      }
    }
  }

  for(unsigned int i=0; i < tauJetsE->size(); i++) {
    if(doEmuMBx_ || tauJetsE->at(i).bx() == EmuTrigBx_) {
      tauJetE_Rank_->Fill(tauJetsE->at(i).rank());
      if(tauJetsE->at(i).rank()>0) {
        tauJetE_EtEtaPhi_->Fill(tauJetsE->at(i).regionId().ieta(),tauJetsE->at(i).regionId().iphi(),tauJetsE->at(i).rank());
        tauJetE_OccEtaPhi_->Fill(tauJetsE->at(i).regionId().ieta(),tauJetsE->at(i).regionId().iphi());
      }
    }
  }
}

void GctErrorAnalyzer::plotTotalE ( const edm::Handle< L1GctEtTotalCollection > &  totalEtD, const edm::Handle< L1GctEtTotalCollection > &  totalEtE  )

private

Definition at line 1318 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, totalEtD_, totalEtD_Of_, totalEtE_, and totalEtE_Of_.

Referenced by analyze().

                                                                                                                                 {

  for(unsigned int i=0; i < totalEtD->size(); i++) {
    if(doGCTMBx_ || totalEtD->at(i).bx() == GCTTrigBx_) {
      totalEtD_Of_->Fill(totalEtD->at(i).overFlow());
      if(!totalEtD->at(i).overFlow()) totalEtD_->Fill(totalEtD->at(i).et());      
    }
  }
  for(unsigned int i=0; i < totalEtE->size(); i++) {
    if(doEmuMBx_ || totalEtE->at(i).bx() == EmuTrigBx_) {
      totalEtE_Of_->Fill(totalEtE->at(i).overFlow());
      if(!totalEtE->at(i).overFlow()) totalEtE_->Fill(totalEtE->at(i).et());
    } 
  }
}

void GctErrorAnalyzer::plotTotalEErrors ( const edm::Handle< L1GctEtTotalCollection > &  totalEtD, const edm::Handle< L1GctEtTotalCollection > &  totalEtE, const edm::Handle< L1GctEtHadCollection > &  totalHtD, const edm::Handle< L1GctEtHadCollection > &  totalHtE, const edm::Handle< L1CaloRegionCollection > &  caloRegions  )

private

Definition at line 1352 of file GctErrorAnalyzer.cc.

References EmuTrigBx_, errorHistCat, eventNumber, GCTTrigBx_, i, isTotalEError, isTotalHError, TFileDirectory::make(), RCTTrigBx_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by analyze().

                                                                                                                                                                                                                                                                                               {

  std::string errorDirName = "err_";
  if(isTotalEError) errorDirName.append("E");
  if(isTotalHError) errorDirName.append("H");
  std::stringstream caseNumber;
  caseNumber << eventNumber;
  errorDirName.append(caseNumber.str());
  TFileDirectory errorDir = errorHistCat.at(3).mkdir(errorDirName);

  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
  TH1I *errorTotalEtD_ = errorDir.make<TH1I>("errorTotalEtD", "errorTotalEtD;E_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorTotalEtD_Of_ = errorDir.make<TH1I>("errorTotalEtD_Of", "errorTotalEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorTotalEtE_ = errorDir.make<TH1I>("errorTotalEtE", "errorTotalEtE;E_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorTotalEtE_Of_ = errorDir.make<TH1I>("errorTotalEtE_Of", "errorTotalEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorTotalHtD_ = errorDir.make<TH1I>("errorTotalHtD", "errorTotalHtD;E_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorTotalHtD_Of_ = errorDir.make<TH1I>("errorTotalHtD_Of", "errorTotalHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
  TH1I *errorTotalHtE_ = errorDir.make<TH1I>("errorTotalHtE", "errorTotalHtE;E_{T};Number of Events", 1024, -0.5, 1023.5);
  TH1I *errorTotalHtE_Of_ = errorDir.make<TH1I>("errorTotalHtE_Of", "errorTotalHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
      
  //plot the region ET and OF bits
  for(unsigned int i=0;i<caloRegions->size();i++) {
    if(caloRegions->at(i).bx() == RCTTrigBx_) {
      if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
      if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
    }
  }
  //now plot the error ET
  for(unsigned int i=0; i < totalEtD->size(); i++) {
    if(totalEtD->at(i).bx() == GCTTrigBx_) {
      errorTotalEtD_Of_->Fill(totalEtD->at(i).overFlow());
      if(!totalEtD->at(i).overFlow()) errorTotalEtD_->Fill(totalEtD->at(i).et());
    }
  }
  for(unsigned int i=0; i < totalEtE->size(); i++) {
    if(totalEtE->at(i).bx() == EmuTrigBx_) {
      errorTotalEtE_Of_->Fill(totalEtE->at(i).overFlow());      
      if(!totalEtE->at(i).overFlow()) errorTotalEtE_->Fill(totalEtE->at(i).et());
    } 
  }
  //and now the error HT
  for(unsigned int i=0; i < totalHtD->size(); i++) {
    if(totalHtD->at(i).bx() == GCTTrigBx_) {
      errorTotalHtD_Of_->Fill(totalHtD->at(i).overFlow());
      if(!totalHtD->at(i).overFlow()) errorTotalHtD_->Fill(totalHtD->at(i).et());
    }
  }
  for(unsigned int i=0; i < totalHtE->size(); i++) {
    if(totalHtE->at(i).bx() == EmuTrigBx_) {
      errorTotalHtE_Of_->Fill(totalHtE->at(i).overFlow());
      if(!totalHtE->at(i).overFlow()) errorTotalHtE_->Fill(totalHtE->at(i).et());
    }
  }
}

void GctErrorAnalyzer::plotTotalH ( const edm::Handle< L1GctEtHadCollection > &  totalHtD, const edm::Handle< L1GctEtHadCollection > &  totalHtE  )

private

Definition at line 1335 of file GctErrorAnalyzer.cc.

References doEmuMBx_, doGCTMBx_, EmuTrigBx_, GCTTrigBx_, i, totalHtD_, totalHtD_Of_, totalHtE_, and totalHtE_Of_.

Referenced by analyze().

                                                                                                                             {

  for(unsigned int i=0; i < totalHtD->size(); i++) {
    if(doGCTMBx_ || totalHtD->at(i).bx() == GCTTrigBx_) {
      totalHtD_Of_->Fill(totalHtD->at(i).overFlow());
      if(!totalHtD->at(i).overFlow()) totalHtD_->Fill(totalHtD->at(i).et());
    }
  }
  for(unsigned int i=0; i < totalHtE->size(); i++) {
    if(doEmuMBx_ || totalHtE->at(i).bx() == EmuTrigBx_) {
      totalHtE_Of_->Fill(totalHtE->at(i).overFlow());
      if(!totalHtE->at(i).overFlow()) totalHtE_->Fill(totalHtE->at(i).et());
    }
  }
}

bool GctErrorAnalyzer::sortJets ( const jetData &  jet1, const jetData &  jet2  )

staticprivate

Definition at line 1105 of file GctErrorAnalyzer.cc.

References jetData::et.

Referenced by plotIntJets().

                                                                   {
  return jet1.et > jet2.et;
}

Member Data Documentation

TH1I* GctErrorAnalyzer::cenJet_errorFlag_

private

Definition at line 161 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::cenJetD_EtEtaPhi_

private

Definition at line 159 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

TH2I* GctErrorAnalyzer::cenJetD_GlobalError_EtEtaPhi_

private

Definition at line 165 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::cenJetD_GlobalError_Rank_

private

Definition at line 163 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::cenJetD_OccEtaPhi_

private

Definition at line 160 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

TH1I* GctErrorAnalyzer::cenJetD_Rank_

private

Definition at line 158 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

TH2I * GctErrorAnalyzer::cenJetE_EtEtaPhi_

private

Definition at line 159 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

TH2I* GctErrorAnalyzer::cenJetE_GlobalError_EtEtaPhi_

private

Definition at line 166 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::cenJetE_GlobalError_Rank_

private

Definition at line 164 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I * GctErrorAnalyzer::cenJetE_OccEtaPhi_

private

Definition at line 160 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

TH1I * GctErrorAnalyzer::cenJetE_Rank_

private

Definition at line 158 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

edm::InputTag GctErrorAnalyzer::dataTag_

private

Definition at line 126 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doBitCountDebug_

private

Definition at line 106 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doCenJetsDebug_

private

Definition at line 101 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doEg_

private

Definition at line 97 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doEmuMBx_

private

Definition at line 119 of file GctErrorAnalyzer.cc.

Referenced by plotCenJets(), plotForJets(), plotHFBitCounts(), plotHFRingSums(), plotIntJets(), plotIsoEm(), plotMissingEt(), plotMissingHt(), plotNonIsoEm(), plotTauJets(), plotTotalE(), and plotTotalH().

bool GctErrorAnalyzer::doExtraMissingHTDebug_

private

Definition at line 113 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and plotMissingEErrors().

bool GctErrorAnalyzer::doForJetsDebug_

private

Definition at line 103 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doGCTMBx_

private

Definition at line 120 of file GctErrorAnalyzer.cc.

Referenced by analyze(), plotCenJets(), plotForJets(), plotHFBitCounts(), plotHFRingSums(), plotIsoEm(), plotMissingEt(), plotMissingHt(), plotNonIsoEm(), plotTauJets(), plotTotalE(), and plotTotalH().

bool GctErrorAnalyzer::doHF_

private

Definition at line 104 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doIsoDebug_

private

Definition at line 98 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doJets_

private

Definition at line 100 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doMissingEnergySums_

private

Definition at line 110 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doMissingETDebug_

private

Definition at line 111 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doMissingHTDebug_

private

Definition at line 112 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doNonIsoDebug_

private

Definition at line 99 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doRCT_

private

Definition at line 96 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doRCTMBx_

private

Definition at line 118 of file GctErrorAnalyzer.cc.

Referenced by plotRCTRegions().

bool GctErrorAnalyzer::doRingSumDebug_

private

Definition at line 105 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doTauJetsDebug_

private

Definition at line 102 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doTotalEnergySums_

private

Definition at line 107 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doTotalEtDebug_

private

Definition at line 108 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doTotalHtDebug_

private

Definition at line 109 of file GctErrorAnalyzer.cc.

Referenced by analyze().

edm::InputTag GctErrorAnalyzer::emuTag_

private

Definition at line 127 of file GctErrorAnalyzer.cc.

Referenced by analyze().

int GctErrorAnalyzer::EmuTrigBx_

private

Definition at line 123 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), plotCenJets(), plotEGErrors(), plotForJets(), plotHFBitCounts(), plotHFErrors(), plotHFRingSums(), plotIntJets(), plotIsoEm(), plotJetErrors(), plotMissingEErrors(), plotMissingEt(), plotMissingHt(), plotNonIsoEm(), plotTauJets(), plotTotalE(), plotTotalEErrors(), and plotTotalH().

std::vector<TFileDirectory> GctErrorAnalyzer::errorHistCat

private

Definition at line 246 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), plotEGErrors(), plotHFErrors(), plotJetErrors(), plotMissingEErrors(), and plotTotalEErrors().

unsigned int GctErrorAnalyzer::eventNumber

private

Definition at line 249 of file GctErrorAnalyzer.cc.

Referenced by analyze(), plotEGErrors(), plotHFErrors(), plotJetErrors(), plotMissingEErrors(), plotTotalEErrors(), and Vispa.Plugins.EdmBrowser.EdmDataAccessor.EdmDataAccessor::setFilterBranches().

TH1I* GctErrorAnalyzer::forJet_errorFlag_

private

Definition at line 181 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::forJetD_EtEtaPhi_

private

Definition at line 179 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

TH2I* GctErrorAnalyzer::forJetD_GlobalError_EtEtaPhi_

private

Definition at line 185 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::forJetD_GlobalError_Rank_

private

Definition at line 183 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::forJetD_OccEtaPhi_

private

Definition at line 180 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

TH1I* GctErrorAnalyzer::forJetD_Rank_

private

Definition at line 178 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

TH2I * GctErrorAnalyzer::forJetE_EtEtaPhi_

private

Definition at line 179 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

TH2I* GctErrorAnalyzer::forJetE_GlobalError_EtEtaPhi_

private

Definition at line 186 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::forJetE_GlobalError_Rank_

private

Definition at line 184 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I * GctErrorAnalyzer::forJetE_OccEtaPhi_

private

Definition at line 180 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

TH1I * GctErrorAnalyzer::forJetE_Rank_

private

Definition at line 178 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

int GctErrorAnalyzer::GCTTrigBx_

private

Definition at line 124 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), plotCenJets(), plotEGErrors(), plotForJets(), plotHFBitCounts(), plotHFErrors(), plotHFRingSums(), plotIsoEm(), plotJetErrors(), plotMissingEErrors(), plotMissingEt(), plotMissingHt(), plotNonIsoEm(), plotTauJets(), plotTotalE(), plotTotalEErrors(), and plotTotalH().

TH1I* GctErrorAnalyzer::hfBitCount_errorFlag_

private

Definition at line 202 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::hfBitCountD_1neg_

private

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I* GctErrorAnalyzer::hfBitCountD_1pos_

private

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I * GctErrorAnalyzer::hfBitCountD_2neg_

private

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I * GctErrorAnalyzer::hfBitCountD_2pos_

private

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I * GctErrorAnalyzer::hfBitCountE_1neg_

private

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I* GctErrorAnalyzer::hfBitCountE_1pos_

private

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I * GctErrorAnalyzer::hfBitCountE_2neg_

private

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I * GctErrorAnalyzer::hfBitCountE_2pos_

private

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

TH1I* GctErrorAnalyzer::hfRingSum_errorFlag_

private

Definition at line 198 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::hfRingSumD_1neg_

private

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I* GctErrorAnalyzer::hfRingSumD_1pos_

private

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I * GctErrorAnalyzer::hfRingSumD_2neg_

private

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I * GctErrorAnalyzer::hfRingSumD_2pos_

private

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I * GctErrorAnalyzer::hfRingSumE_1neg_

private

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I* GctErrorAnalyzer::hfRingSumE_1pos_

private

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I * GctErrorAnalyzer::hfRingSumE_2neg_

private

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I * GctErrorAnalyzer::hfRingSumE_2pos_

private

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

TH1I* GctErrorAnalyzer::intJetE_Et_

private

Definition at line 189 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

TH1I* GctErrorAnalyzer::intJetE_Jet1Et_

private

Definition at line 191 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

TH1I* GctErrorAnalyzer::intJetE_Jet2Et_

private

Definition at line 192 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

TH1I* GctErrorAnalyzer::intJetE_Jet3Et_

private

Definition at line 193 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

TH1I* GctErrorAnalyzer::intJetE_Jet4Et_

private

Definition at line 194 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

TH1I* GctErrorAnalyzer::intJetE_Of_

private

Definition at line 190 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

TH2I* GctErrorAnalyzer::intJetEtEtaPhiE_

private

Definition at line 188 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

bool GctErrorAnalyzer::isBitCountError

private

Definition at line 237 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotHFErrors().

bool GctErrorAnalyzer::isCenJetError

private

Definition at line 233 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotJetErrors().

bool GctErrorAnalyzer::isForJetError

private

Definition at line 235 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotJetErrors().

bool GctErrorAnalyzer::isIsoError

private

Definition at line 231 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotEGErrors().

bool GctErrorAnalyzer::isMissingEError

private

Definition at line 240 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotMissingEErrors().

bool GctErrorAnalyzer::isMissingHError

private

Definition at line 241 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotMissingEErrors().

bool GctErrorAnalyzer::isNonIsoError

private

Definition at line 232 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotEGErrors().

TH1I* GctErrorAnalyzer::isoEg_errorFlag_

private

Definition at line 141 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::isoEgD_EtEtaPhi_

private

Definition at line 139 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

TH2I* GctErrorAnalyzer::isoEgD_GlobalError_EtEtaPhi_

private

Definition at line 145 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::isoEgD_GlobalError_Rank_

private

Definition at line 143 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::isoEgD_OccEtaPhi_

private

Definition at line 140 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

TH1I* GctErrorAnalyzer::isoEgD_Rank_

private

Definition at line 138 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

TH2I * GctErrorAnalyzer::isoEgE_EtEtaPhi_

private

Definition at line 139 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

TH2I* GctErrorAnalyzer::isoEgE_GlobalError_EtEtaPhi_

private

Definition at line 146 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::isoEgE_GlobalError_Rank_

private

Definition at line 144 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I * GctErrorAnalyzer::isoEgE_OccEtaPhi_

private

Definition at line 140 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

TH1I * GctErrorAnalyzer::isoEgE_Rank_

private

Definition at line 138 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

bool GctErrorAnalyzer::isRingSumError

private

Definition at line 236 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotHFErrors().

bool GctErrorAnalyzer::isTauJetError

private

Definition at line 234 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotJetErrors().

bool GctErrorAnalyzer::isTotalEError

private

Definition at line 238 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotTotalEErrors().

bool GctErrorAnalyzer::isTotalHError

private

Definition at line 239 of file GctErrorAnalyzer.cc.

Referenced by analyze(), GctErrorAnalyzer(), and plotTotalEErrors().

GctErrorAnalyzerMBxInfo GctErrorAnalyzer::MBxInfo

private

Definition at line 132 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::missingEt_errorFlag_

private

Definition at line 221 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::missingEtD_

private

Definition at line 218 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

TH1I* GctErrorAnalyzer::missingEtD_Of_

private

Definition at line 219 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

TH1I* GctErrorAnalyzer::missingEtD_Phi_

private

Definition at line 220 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

TH1I * GctErrorAnalyzer::missingEtE_

private

Definition at line 218 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

TH1I * GctErrorAnalyzer::missingEtE_Of_

private

Definition at line 219 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

TH1I * GctErrorAnalyzer::missingEtE_Phi_

private

Definition at line 220 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

TH1I* GctErrorAnalyzer::missingHt_errorFlag_

private

Definition at line 226 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::missingHtD_

private

Definition at line 223 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

TH1I * GctErrorAnalyzer::missingHtD_HtXNegLeaf1

private

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtXNegLeaf2

private

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtXNegLeaf3

private

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::missingHtD_HtXPosLeaf1

private

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtXPosLeaf2

private

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtXPosLeaf3

private

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtYNegLeaf1

private

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtYNegLeaf2

private

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtYNegLeaf3

private

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::missingHtD_HtYPosLeaf1

private

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtYPosLeaf2

private

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I * GctErrorAnalyzer::missingHtD_HtYPosLeaf3

private

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::missingHtD_Of_

private

Definition at line 224 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

TH1I* GctErrorAnalyzer::missingHtD_Phi_

private

Definition at line 225 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

TH1I * GctErrorAnalyzer::missingHtE_

private

Definition at line 223 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

TH1I * GctErrorAnalyzer::missingHtE_Of_

private

Definition at line 224 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

TH1I * GctErrorAnalyzer::missingHtE_Phi_

private

Definition at line 225 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

TH1I* GctErrorAnalyzer::nonIsoEg_errorFlag_

private

Definition at line 151 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::nonIsoEgD_EtEtaPhi_

private

Definition at line 149 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

TH2I* GctErrorAnalyzer::nonIsoEgD_GlobalError_EtEtaPhi_

private

Definition at line 155 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::nonIsoEgD_GlobalError_Rank_

private

Definition at line 153 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::nonIsoEgD_OccEtaPhi_

private

Definition at line 150 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

TH1I* GctErrorAnalyzer::nonIsoEgD_Rank_

private

Definition at line 148 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

TH2I * GctErrorAnalyzer::nonIsoEgE_EtEtaPhi_

private

Definition at line 149 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

TH2I* GctErrorAnalyzer::nonIsoEgE_GlobalError_EtEtaPhi_

private

Definition at line 156 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::nonIsoEgE_GlobalError_Rank_

private

Definition at line 154 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I * GctErrorAnalyzer::nonIsoEgE_OccEtaPhi_

private

Definition at line 150 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

TH1I * GctErrorAnalyzer::nonIsoEgE_Rank_

private

Definition at line 148 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

TH2I* GctErrorAnalyzer::RCT_EtEtaPhi_

private

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

TH2I * GctErrorAnalyzer::RCT_FgEtaPhi_

private

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

TH2I * GctErrorAnalyzer::RCT_OfEtaPhi_

private

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

const unsigned int* GctErrorAnalyzer::RCT_REGION_QUANTA

private

Definition at line 251 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I * GctErrorAnalyzer::RCT_TvEtaPhi_

private

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

int GctErrorAnalyzer::RCTTrigBx_

private

Definition at line 122 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), plotEGErrors(), plotHFErrors(), plotJetErrors(), plotMissingEErrors(), plotRCTRegions(), and plotTotalEErrors().

TH1I* GctErrorAnalyzer::tauJet_errorFlag_

private

Definition at line 171 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::tauJetD_EtEtaPhi_

private

Definition at line 169 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

TH2I* GctErrorAnalyzer::tauJetD_GlobalError_EtEtaPhi_

private

Definition at line 175 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::tauJetD_GlobalError_Rank_

private

Definition at line 173 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I* GctErrorAnalyzer::tauJetD_OccEtaPhi_

private

Definition at line 170 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

TH1I* GctErrorAnalyzer::tauJetD_Rank_

private

Definition at line 168 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

TH2I * GctErrorAnalyzer::tauJetE_EtEtaPhi_

private

Definition at line 169 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

TH2I* GctErrorAnalyzer::tauJetE_GlobalError_EtEtaPhi_

private

Definition at line 176 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::tauJetE_GlobalError_Rank_

private

Definition at line 174 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH2I * GctErrorAnalyzer::tauJetE_OccEtaPhi_

private

Definition at line 170 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

TH1I * GctErrorAnalyzer::tauJetE_Rank_

private

Definition at line 168 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

TH1I* GctErrorAnalyzer::totalEt_errorFlag_

private

Definition at line 206 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::totalEtD_

private

Definition at line 204 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalE().

TH1I* GctErrorAnalyzer::totalEtD_Of_

private

Definition at line 205 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalE().

TH1I * GctErrorAnalyzer::totalEtE_

private

Definition at line 204 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalE().

TH1I * GctErrorAnalyzer::totalEtE_Of_

private

Definition at line 205 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalE().

TH1I* GctErrorAnalyzer::totalHt_errorFlag_

private

Definition at line 213 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

TH1I* GctErrorAnalyzer::totalHtD_

private

Definition at line 211 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalH().

TH1I* GctErrorAnalyzer::totalHtD_Of_

private

Definition at line 212 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalH().

TH1I * GctErrorAnalyzer::totalHtE_

private

Definition at line 211 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalH().

TH1I * GctErrorAnalyzer::totalHtE_Of_

private

Definition at line 212 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalH().

std::string GctErrorAnalyzer::useSys_

private

Definition at line 129 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer().