CMS 3D CMS Logo

Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes

GctErrorAnalyzer Class Reference

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

Inheritance diagram for GctErrorAnalyzer:
edm::EDAnalyzer

List of all members.

Public Member Functions

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

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< TFileDirectoryerrorHistCat
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_

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 
) [private, virtual]

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_, compareRingSums::doCompare(), compareMissingEnergySums< T >::doCompare(), compareTotalEnergySums< T >::doCompare(), compareBitCounts::doCompare(), compareCands< 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  ) [private, virtual]

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  ) [private, virtual]

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(), and RCTTrigBx_.

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(), and RCTTrigBx_.

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(), and RCTTrigBx_.

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, and RCTTrigBx_.

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(), and RCTTrigBx_.

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 
) [static, private]

Definition at line 1105 of file GctErrorAnalyzer.cc.

References jetData::et.

Referenced by plotIntJets().

                                                                   {
  return jet1.et > jet2.et;
}

Member Data Documentation

Definition at line 161 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 159 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

Definition at line 165 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 163 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 160 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

Definition at line 158 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

Definition at line 159 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

Definition at line 166 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 164 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 160 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

Definition at line 158 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotCenJets().

Definition at line 126 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 106 of file GctErrorAnalyzer.cc.

Referenced by analyze().

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().

Definition at line 113 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and plotMissingEErrors().

Definition at line 103 of file GctErrorAnalyzer.cc.

Referenced by analyze().

bool GctErrorAnalyzer::doHF_ [private]

Definition at line 104 of file GctErrorAnalyzer.cc.

Referenced by analyze().

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().

Definition at line 110 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 111 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 112 of file GctErrorAnalyzer.cc.

Referenced by analyze().

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().

Definition at line 118 of file GctErrorAnalyzer.cc.

Referenced by plotRCTRegions().

Definition at line 105 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 102 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 107 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 108 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 109 of file GctErrorAnalyzer.cc.

Referenced by analyze().

Definition at line 127 of file GctErrorAnalyzer.cc.

Referenced by analyze().

unsigned int GctErrorAnalyzer::eventNumber [private]

Definition at line 181 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 179 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

Definition at line 185 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 183 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 180 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

Definition at line 178 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

Definition at line 179 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

Definition at line 186 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 184 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 180 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

Definition at line 178 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotForJets().

Definition at line 202 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 200 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 201 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFBitCounts().

Definition at line 198 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 196 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 197 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotHFRingSums().

Definition at line 189 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 191 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 192 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 193 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 194 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 190 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 188 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIntJets().

Definition at line 237 of file GctErrorAnalyzer.cc.

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

Definition at line 233 of file GctErrorAnalyzer.cc.

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

Definition at line 235 of file GctErrorAnalyzer.cc.

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

Definition at line 231 of file GctErrorAnalyzer.cc.

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

Definition at line 240 of file GctErrorAnalyzer.cc.

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

Definition at line 241 of file GctErrorAnalyzer.cc.

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

Definition at line 232 of file GctErrorAnalyzer.cc.

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

Definition at line 141 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 139 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

Definition at line 145 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 143 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 140 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

Definition at line 138 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

Definition at line 139 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

Definition at line 146 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 144 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 140 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

Definition at line 138 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotIsoEm().

Definition at line 236 of file GctErrorAnalyzer.cc.

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

Definition at line 234 of file GctErrorAnalyzer.cc.

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

Definition at line 238 of file GctErrorAnalyzer.cc.

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

Definition at line 239 of file GctErrorAnalyzer.cc.

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

Definition at line 132 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 221 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 218 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

Definition at line 219 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

Definition at line 220 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

Definition at line 218 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

Definition at line 219 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

Definition at line 220 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingEt().

Definition at line 226 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 223 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 227 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 228 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 224 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

Definition at line 225 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

Definition at line 223 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

Definition at line 224 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

Definition at line 225 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotMissingHt().

Definition at line 151 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 149 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

Definition at line 155 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 153 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 150 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

Definition at line 148 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

Definition at line 149 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

Definition at line 156 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 154 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 150 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

Definition at line 148 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotNonIsoEm().

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

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().

Definition at line 136 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotRCTRegions().

Definition at line 171 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 169 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

Definition at line 175 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 173 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 170 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

Definition at line 168 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

Definition at line 169 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

Definition at line 176 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 174 of file GctErrorAnalyzer.cc.

Referenced by analyze(), and GctErrorAnalyzer().

Definition at line 170 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

Definition at line 168 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTauJets().

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().

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().

Definition at line 205 of file GctErrorAnalyzer.cc.

Referenced by GctErrorAnalyzer(), and plotTotalE().

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().

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().

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().