CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
GctErrorAnalyzer.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: GctErrorAnalyzer
4 // Class: GctErrorAnalyzer
5 //
13 //
14 // Original Author: Jad Marrouche
15 // Created: Wed May 20 14:19:23 CEST 2009
16 // $Id: GctErrorAnalyzer.cc,v 1.2 2010/04/30 21:21:34 jad Exp $
17 //
18 //
19 
20 // system include files
21 #include <memory>
22 
23 // user include files
24 #include "FWCore/Framework/interface/Frameworkfwd.h"
25 #include "FWCore/Framework/interface/EDAnalyzer.h"
26 #include "FWCore/Framework/interface/Event.h"
27 #include "FWCore/Framework/interface/MakerMacros.h"
28 #include "FWCore/ParameterSet/interface/ParameterSet.h"
29 #include "FWCore/MessageLogger/interface/MessageLogger.h"
30 #include "FWCore/Utilities/interface/InputTag.h"
31 #include "FWCore/ServiceRegistry/interface/Service.h"
32 //TFile maker include
33 #include "CommonTools/UtilAlgos/interface/TFileService.h"
34 //ROOT includes
35 #include "TH1.h"
36 #include "TH2.h"
37 #include "TAxis.h"
38 //RCT and GCT DataFormat Collections
39 #include "DataFormats/L1GlobalCaloTrigger/interface/L1GctCollections.h"
40 #include "DataFormats/L1CaloTrigger/interface/L1CaloCollections.h"
41 //GctErrorAnalyzer includes
42 #include "L1Trigger/L1GctAnalyzer/interface/GctErrorAnalyzerDefinitions.h"
43 #include "L1Trigger/L1GctAnalyzer/interface/compareCands.h"
44 #include "L1Trigger/L1GctAnalyzer/interface/compareRingSums.h"
45 #include "L1Trigger/L1GctAnalyzer/interface/compareBitCounts.h"
46 #include "L1Trigger/L1GctAnalyzer/interface/compareTotalEnergySums.h"
47 #include "L1Trigger/L1GctAnalyzer/interface/compareMissingEnergySums.h"
48 //STL includes
49 #include <string>
50 #include <vector>
51 #include <sstream>
52 #include <algorithm>
53 
54 //
55 // class declaration
56 //
57 
58 class GctErrorAnalyzer : public edm::EDAnalyzer {
59 
60 private:
61  GctErrorAnalyzer();
62  GctErrorAnalyzer(const GctErrorAnalyzer &);
63  GctErrorAnalyzer operator=(const GctErrorAnalyzer &);
64  void plotRCTRegions(const edm::Handle<L1CaloRegionCollection> &caloRegions);
65  void plotIsoEm(const edm::Handle<L1GctEmCandCollection> &data, const edm::Handle<L1GctEmCandCollection> &emu);
66  void plotNonIsoEm(const edm::Handle<L1GctEmCandCollection> &data, const edm::Handle<L1GctEmCandCollection> &emu);
67  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);
68  void plotCenJets(const edm::Handle<L1GctJetCandCollection> &data, const edm::Handle<L1GctJetCandCollection> &emu);
69  void plotTauJets(const edm::Handle<L1GctJetCandCollection> &data, const edm::Handle<L1GctJetCandCollection> &emu);
70  void plotForJets(const edm::Handle<L1GctJetCandCollection> &data, const edm::Handle<L1GctJetCandCollection> &emu);
71  void plotIntJets(const edm::Handle<L1GctInternJetDataCollection> &emu);
72  static bool sortJets (const jetData &jet1, const jetData &jet2); //define this as static as it doesn't need a GctErrorAnalyzer object
73  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);
74  void plotHFRingSums(const edm::Handle<L1GctHFRingEtSumsCollection> &data, const edm::Handle<L1GctHFRingEtSumsCollection> &emu);
75  void plotHFBitCounts(const edm::Handle<L1GctHFBitCountsCollection> &hfBitCountsD, const edm::Handle<L1GctHFBitCountsCollection> &hfBitCountsE);
76  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);
77  void plotTotalE(const edm::Handle<L1GctEtTotalCollection> &totalEtD, const edm::Handle<L1GctEtTotalCollection> &totalEtE);
78  void plotTotalH(const edm::Handle<L1GctEtHadCollection> &totalHtD, const edm::Handle<L1GctEtHadCollection> &totalHtE);
79  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);
80  void plotMissingEt(const edm::Handle<L1GctEtMissCollection> &missingEtD, const edm::Handle<L1GctEtMissCollection> &missingEtE);
81  void plotMissingHt(const edm::Handle<L1GctHtMissCollection> &missingHtD, const edm::Handle<L1GctHtMissCollection> &missingHtE);
82  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);
83  template<class T> bool checkCollections(const T &collection, const unsigned int &constraint, const std::string &label);
84 
85 public:
86  explicit GctErrorAnalyzer(const edm::ParameterSet&);
87  ~GctErrorAnalyzer();
88 
89 private:
90  virtual void beginJob() ;
91  virtual void analyze(const edm::Event&, const edm::EventSetup&);
92  virtual void endJob() ;
93 
94  // ----------member data ---------------------------
95  //the following flags select what we'd like to plot and whether or not we want error information
96  bool doRCT_;
97  bool doEg_;
98  bool doIsoDebug_;
99  bool doNonIsoDebug_;
100  bool doJets_;
101  bool doCenJetsDebug_;
102  bool doTauJetsDebug_;
103  bool doForJetsDebug_;
104  bool doHF_;
105  bool doRingSumDebug_;
106  bool doBitCountDebug_;
107  bool doTotalEnergySums_;
108  bool doTotalEtDebug_;
109  bool doTotalHtDebug_;
110  bool doMissingEnergySums_;
111  bool doMissingETDebug_;
112  bool doMissingHTDebug_;
113  bool doExtraMissingHTDebug_;
114  //the following flags configure whether or not we want multiple BX behaviour for
115  //1. RCT regions
116  //2. Emulator output
117  //3. Hardware output
118  bool doRCTMBx_;
119  bool doEmuMBx_;
120  bool doGCTMBx_;
121  //the following values select the definition of the "triggered" Bx i.e. where to define Bx=0
122  int RCTTrigBx_;
123  int EmuTrigBx_;
124  int GCTTrigBx_;
125  //the following flags contain the location of the hardware and emulator digis
126  edm::InputTag dataTag_;
127  edm::InputTag emuTag_;
128  //the following is a string which dictates whether or not we want to use the lab or full system parameters
129  std::string useSys_;
130 
131  //the following declares a struct to hold the MBX Info to make it easy to pass the information around
132  GctErrorAnalyzerMBxInfo MBxInfo;
133 
134  // histograms
135  //RCT Regions
136  TH2I *RCT_EtEtaPhi_, *RCT_TvEtaPhi_, *RCT_FgEtaPhi_, *RCT_OfEtaPhi_;
137  //isoEg
138  TH1I *isoEgD_Rank_, *isoEgE_Rank_;
139  TH2I *isoEgD_EtEtaPhi_, *isoEgE_EtEtaPhi_;
140  TH2I *isoEgD_OccEtaPhi_, *isoEgE_OccEtaPhi_;
141  TH1I *isoEg_errorFlag_;
142  //Global Error Histograms
143  TH1I *isoEgD_GlobalError_Rank_;
144  TH1I *isoEgE_GlobalError_Rank_;
145  TH2I *isoEgD_GlobalError_EtEtaPhi_;
146  TH2I *isoEgE_GlobalError_EtEtaPhi_;
147  //nonIsoEg
148  TH1I *nonIsoEgD_Rank_, *nonIsoEgE_Rank_;
149  TH2I *nonIsoEgD_EtEtaPhi_, *nonIsoEgE_EtEtaPhi_;
150  TH2I *nonIsoEgD_OccEtaPhi_, *nonIsoEgE_OccEtaPhi_;
151  TH1I *nonIsoEg_errorFlag_;
152  //Global Error Histograms
153  TH1I *nonIsoEgD_GlobalError_Rank_;
154  TH1I *nonIsoEgE_GlobalError_Rank_;
155  TH2I *nonIsoEgD_GlobalError_EtEtaPhi_;
156  TH2I *nonIsoEgE_GlobalError_EtEtaPhi_;
157  //cenJet
158  TH1I *cenJetD_Rank_, *cenJetE_Rank_;
159  TH2I *cenJetD_EtEtaPhi_, *cenJetE_EtEtaPhi_;
160  TH2I *cenJetD_OccEtaPhi_, *cenJetE_OccEtaPhi_;
161  TH1I *cenJet_errorFlag_;
162  //Global Error Histograms
163  TH1I *cenJetD_GlobalError_Rank_;
164  TH1I *cenJetE_GlobalError_Rank_;
165  TH2I *cenJetD_GlobalError_EtEtaPhi_;
166  TH2I *cenJetE_GlobalError_EtEtaPhi_;
167  //tauJet
168  TH1I *tauJetD_Rank_, *tauJetE_Rank_;
169  TH2I *tauJetD_EtEtaPhi_, *tauJetE_EtEtaPhi_;
170  TH2I *tauJetD_OccEtaPhi_, *tauJetE_OccEtaPhi_;
171  TH1I *tauJet_errorFlag_;
172  //Global Error Histograms
173  TH1I *tauJetD_GlobalError_Rank_;
174  TH1I *tauJetE_GlobalError_Rank_;
175  TH2I *tauJetD_GlobalError_EtEtaPhi_;
176  TH2I *tauJetE_GlobalError_EtEtaPhi_;
177  //forJet
178  TH1I *forJetD_Rank_, *forJetE_Rank_;
179  TH2I *forJetD_EtEtaPhi_, *forJetE_EtEtaPhi_;
180  TH2I *forJetD_OccEtaPhi_, *forJetE_OccEtaPhi_;
181  TH1I *forJet_errorFlag_;
182  //Global Error Histograms
183  TH1I *forJetD_GlobalError_Rank_;
184  TH1I *forJetE_GlobalError_Rank_;
185  TH2I *forJetD_GlobalError_EtEtaPhi_;
186  TH2I *forJetE_GlobalError_EtEtaPhi_;
187  //intJet
188  TH2I *intJetEtEtaPhiE_;
189  TH1I *intJetE_Et_;
190  TH1I *intJetE_Of_;
191  TH1I *intJetE_Jet1Et_;
192  TH1I *intJetE_Jet2Et_;
193  TH1I *intJetE_Jet3Et_;
194  TH1I *intJetE_Jet4Et_;
195  //ringSums
196  TH1I *hfRingSumD_1pos_, *hfRingSumD_1neg_, *hfRingSumD_2pos_, *hfRingSumD_2neg_;
197  TH1I *hfRingSumE_1pos_, *hfRingSumE_1neg_, *hfRingSumE_2pos_, *hfRingSumE_2neg_;
198  TH1I *hfRingSum_errorFlag_;
199  //bitcounts
200  TH1I *hfBitCountD_1pos_, *hfBitCountD_1neg_, *hfBitCountD_2pos_, *hfBitCountD_2neg_;
201  TH1I *hfBitCountE_1pos_, *hfBitCountE_1neg_, *hfBitCountE_2pos_, *hfBitCountE_2neg_;
202  TH1I *hfBitCount_errorFlag_;
203  //totalEt
204  TH1I *totalEtD_, *totalEtE_;
205  TH1I *totalEtD_Of_, *totalEtE_Of_;
206  TH1I *totalEt_errorFlag_;
207  //ET GlobalError Histograms
208  //TH1I *totalEtD_GlobalError_, *totalEtE_GlobalError_;
209  //TH1I *totalEtD_GlobalError_Of_, *totalEtE_GlobalError_Of_;
210  //totalHt
211  TH1I *totalHtD_, *totalHtE_;
212  TH1I *totalHtD_Of_, *totalHtE_Of_;
213  TH1I *totalHt_errorFlag_;
214  //HT GlobalError Histograms
215  //TH1I *totalHtD_GlobalError_, *totalHtE_GlobalError_;
216  //TH1I *totalHtD_GlobalError_Of_, *totalHtE_GlobalError_Of_;
217  //missingET
218  TH1I *missingEtD_, *missingEtE_;
219  TH1I *missingEtD_Of_, *missingEtE_Of_;
220  TH1I *missingEtD_Phi_, *missingEtE_Phi_;
221  TH1I *missingEt_errorFlag_;
222  //missingHT
223  TH1I *missingHtD_, *missingHtE_;
224  TH1I *missingHtD_Of_, *missingHtE_Of_;
225  TH1I *missingHtD_Phi_, *missingHtE_Phi_;
226  TH1I *missingHt_errorFlag_;
227  TH1I *missingHtD_HtXPosLeaf1, *missingHtD_HtXPosLeaf2, *missingHtD_HtXPosLeaf3, *missingHtD_HtXNegLeaf1, *missingHtD_HtXNegLeaf2, *missingHtD_HtXNegLeaf3;
228  TH1I *missingHtD_HtYPosLeaf1, *missingHtD_HtYPosLeaf2, *missingHtD_HtYPosLeaf3, *missingHtD_HtYNegLeaf1, *missingHtD_HtYNegLeaf2, *missingHtD_HtYNegLeaf3;
229 
230  //error flags to decide whether or not to print debug info
231  bool isIsoError;
232  bool isNonIsoError;
233  bool isCenJetError;
234  bool isTauJetError;
235  bool isForJetError;
236  bool isRingSumError;
237  bool isBitCountError;
238  bool isTotalEError;
239  bool isTotalHError;
240  bool isMissingEError;
241  bool isMissingHError;
242 
243  //Directories - put this here because we want to
244  //add directories dynamically to this folder
245  //depending on the errors we find
246  std::vector<TFileDirectory> errorHistCat;
247 
248  //the event number
249  unsigned int eventNumber;
250 
251  const unsigned int * RCT_REGION_QUANTA;
252 
253 };
254 
255 //
256 // constants, enums and typedefs
257 // use in conjunction with the templated bits
258 typedef compareCands< edm::Handle<L1GctEmCandCollection> > compareEG;
259 typedef compareCands< edm::Handle<L1GctJetCandCollection> > compareJets;
260 typedef compareTotalEnergySums< edm::Handle<L1GctEtTotalCollection> > compareTotalE;
261 typedef compareTotalEnergySums< edm::Handle<L1GctEtHadCollection> > compareTotalH;
262 typedef compareMissingEnergySums< edm::Handle<L1GctEtMissCollection> > compareMissingE;
263 typedef compareMissingEnergySums< edm::Handle<L1GctHtMissCollection> > compareMissingH;
264 //
265 // static data member definitions
266 //
267 
268 //
269 // constructors and destructor
270 //
271 GctErrorAnalyzer::GctErrorAnalyzer(const edm::ParameterSet& iConfig) :
272  doRCT_( iConfig.getUntrackedParameter<bool>("doRCT", true) ),
273  doEg_( iConfig.getUntrackedParameter<bool>("doEg", true) ),
274  doIsoDebug_( iConfig.getUntrackedParameter<bool>("doIsoDebug", true) ),
275  doNonIsoDebug_( iConfig.getUntrackedParameter<bool>("doNonIsoDebug", true) ),
276  doJets_( iConfig.getUntrackedParameter<bool>("doJets", true) ),
277  doCenJetsDebug_( iConfig.getUntrackedParameter<bool>("doCenJetsDebug", true) ),
278  doTauJetsDebug_( iConfig.getUntrackedParameter<bool>("doTauJetsDebug", true) ),
279  doForJetsDebug_( iConfig.getUntrackedParameter<bool>("doForJetsDebug", true) ),
280  doHF_( iConfig.getUntrackedParameter<bool>("doHF", true) ),
281  doRingSumDebug_( iConfig.getUntrackedParameter<bool>("doRingSumDebug", true) ),
282  doBitCountDebug_( iConfig.getUntrackedParameter<bool>("doBitCountDebug", true) ),
283  doTotalEnergySums_( iConfig.getUntrackedParameter<bool>("doTotalEnergySums", true) ),
284  doTotalEtDebug_( iConfig.getUntrackedParameter<bool>("doTotalEtDebug", true) ),
285  doTotalHtDebug_( iConfig.getUntrackedParameter<bool>("doTotalHtDebug", true) ),
286  doMissingEnergySums_( iConfig.getUntrackedParameter<bool>("doMissingEnergySums", true) ),
287  doMissingETDebug_( iConfig.getUntrackedParameter<bool>("doMissingETDebug", true) ),
288  doMissingHTDebug_( iConfig.getUntrackedParameter<bool>("doMissingHTDebug", true) ),
289  doExtraMissingHTDebug_( iConfig.getUntrackedParameter<bool>("doExtraMissingHTDebug", false) ),
290  doRCTMBx_( iConfig.getUntrackedParameter<bool>("doRCTMBx", false)),
291  doEmuMBx_( iConfig.getUntrackedParameter<bool>("doEmuMBx", false)),
292  doGCTMBx_( iConfig.getUntrackedParameter<bool>("doGCTMBx", false)),
293  RCTTrigBx_( iConfig.getUntrackedParameter<int>("RCTTrigBx", 0)),
294  EmuTrigBx_( iConfig.getUntrackedParameter<int>("EmuTrigBx", 0)),
295  GCTTrigBx_( iConfig.getUntrackedParameter<int>("GCTTrigBx", 0)),
296  dataTag_( iConfig.getUntrackedParameter<edm::InputTag>("dataTag", edm::InputTag("gctDigis")) ),
297  emuTag_( iConfig.getUntrackedParameter<edm::InputTag>("emuTag", edm::InputTag("gctEmuDigis")) ),
298  useSys_( iConfig.getUntrackedParameter<std::string>("useSys","P5"))
299 {
300  //now do what ever initialization is needed
301  //make the root file
302  edm::Service<TFileService> fs;
303 
304  //to try to make this look more elegant
305  //make a string for each folder we'd like for the Data and Emulator Histograms
306  std::vector<std::string> quantities;
307  quantities.push_back("IsoEm");
308  quantities.push_back("NonIsoEM");
309  quantities.push_back("CenJets");
310  quantities.push_back("TauJets");
311  quantities.push_back("ForJets");
312  quantities.push_back("HFRingSums");
313  quantities.push_back("HFBitCounts");
314  quantities.push_back("TotalESums");
315  quantities.push_back("MissingESums");
316 
317  //make the Emulator Histogram directory
318  TFileDirectory emuHist = fs->mkdir("EmulatorHistograms");
319  std::vector<TFileDirectory> emuHistCat;
320 
321  //make the Data Histogram directory
322  TFileDirectory dataHist = fs->mkdir("DataHistograms");
323  std::vector<TFileDirectory> dataHistCat;
324 
325  //make the ErrorFlags directory
326  TFileDirectory errorHistFlags = fs->mkdir("ErrorHistograms_Flags");
327 
328  //make the ErrorDebug directory
329  TFileDirectory errorHistDetails = fs->mkdir("ErrorHistograms_Details");
330 
331  for(unsigned int i=0;i<quantities.size();i++) {
332  //fill the data and emulator folders with the directories
333  emuHistCat.push_back(emuHist.mkdir(quantities.at(i)));
334  dataHistCat.push_back(dataHist.mkdir(quantities.at(i)));
335  }
336 
337  //add a folder for RCT Regions - which only exist in data
338  dataHistCat.push_back(dataHist.mkdir("RCTRegions"));
339  //and add a folder for the Intermediate Jets - which only exist in emulator
340  emuHistCat.push_back(emuHist.mkdir("IntJets"));
341 
342  //Fill the ErrorDebug folder with the directories
343  errorHistCat.push_back(errorHistDetails.mkdir("EM"));
344  errorHistCat.push_back(errorHistDetails.mkdir("Jets"));
345  errorHistCat.push_back(errorHistDetails.mkdir("HF"));
346  errorHistCat.push_back(errorHistDetails.mkdir("TotalE"));
347  errorHistCat.push_back(errorHistDetails.mkdir("MissingE"));
348 
349  //BOOK HISTOGRAMS
350  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);
351  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);
352  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);
353  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);
354  //isoEg
355  isoEgD_Rank_ = dataHistCat.at(0).make<TH1I>("isoEgD_Rank", "isoEgD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
356  isoEgE_Rank_ = emuHistCat.at(0).make<TH1I>("isoEgE_Rank", "isoEgE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
357  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);
358  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);
359  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);
360  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);
361  isoEg_errorFlag_ = errorHistFlags.make<TH1I>("isoEg_errorFlag", "isoEg_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
362  //Global isoEg Error
363  isoEgD_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("isoEgD_GlobalError_Rank", "isoEgD_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
364  isoEgE_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("isoEgE_GlobalError_Rank", "isoEgE_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
365  isoEgD_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("isoEgD_GlobalError_EtEtaPhi", "isoEgD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
366  isoEgE_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("isoEgE_GlobalError_EtEtaPhi", "isoEgE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
367  //nonIsoEg
368  nonIsoEgD_Rank_ = dataHistCat.at(1).make<TH1I>("nonIsoEgD_Rank", "nonIsoEgD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
369  nonIsoEgE_Rank_ = emuHistCat.at(1).make<TH1I>("nonIsoEgE_Rank", "nonIsoEgE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
370  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);
371  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);
372  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);
373  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);
374  nonIsoEg_errorFlag_ = errorHistFlags.make<TH1I>("nonIsoEg_errorFlag", "nonIsoEg_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
375  //Global nonIsoEg Error
376  nonIsoEgD_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("nonIsoEgD_GlobalError_Rank", "nonIsoEgD_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
377  nonIsoEgE_GlobalError_Rank_ = errorHistCat.at(0).make<TH1I>("nonIsoEgE_GlobalError_Rank", "nonIsoEgE_GlobalError_Rank;Rank;Number of Events", 64, -0.5, 63.5);
378  nonIsoEgD_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("nonIsoEgD_GlobalError_EtEtaPhi", "nonIsoEgD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
379  nonIsoEgE_GlobalError_EtEtaPhi_ = errorHistCat.at(0).make<TH2I>("nonIsoEgE_GlobalError_EtEtaPhi", "nonIsoEgE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
380  //CenJets
381  cenJetD_Rank_ = dataHistCat.at(2).make<TH1I>("cenJetD_Rank", "cenJetD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
382  cenJetE_Rank_ = emuHistCat.at(2).make<TH1I>("cenJetE_Rank", "cenJetE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
383  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);
384  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);
385  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);
386  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);
387  cenJet_errorFlag_ = errorHistFlags.make<TH1I>("cenJet_errorFlag", "cenJet_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
388  //Global CenJet Error
389  cenJetD_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("cenJetD_GlobalError_Rank", "cenJetD_GlobalError_Rank", 64, -0.5, 63.5);
390  cenJetE_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("cenJetE_GlobalError_Rank", "cenJetE_GlobalError_Rank", 64, -0.5, 63.5);
391  cenJetD_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("cenJetD_GlobalError_EtEtaPhi", "cenJetD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
392  cenJetE_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("cenJetE_GlobalError_EtEtaPhi", "cenJetE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
393  //TauJets
394  tauJetD_Rank_ = dataHistCat.at(3).make<TH1I>("tauJetD_Rank", "tauJetD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
395  tauJetE_Rank_ = emuHistCat.at(3).make<TH1I>("tauJetE_Rank", "tauJetE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
396  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);
397  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);
398  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);
399  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);
400  tauJet_errorFlag_ = errorHistFlags.make<TH1I>("tauJet_errorFlag", "tauJet_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
401  //Global TauJet Error
402  tauJetD_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("tauJetD_GlobalError_Rank", "tauJetD_GlobalError_Rank", 64, -0.5, 63.5);
403  tauJetE_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("tauJetE_GlobalError_Rank", "tauJetE_GlobalError_Rank", 64, -0.5, 63.5);
404  tauJetD_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("tauJetD_GlobalError_EtEtaPhi", "tauJetD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
405  tauJetE_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("tauJetE_GlobalError_EtEtaPhi", "tauJetE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
406  //ForJets
407  forJetD_Rank_ = dataHistCat.at(4).make<TH1I>("forJetD_Rank", "forJetD_Rank;Rank;Number of Events", 64, -0.5, 63.5);
408  forJetE_Rank_ = emuHistCat.at(4).make<TH1I>("forJetE_Rank", "forJetE_Rank;Rank;Number of Events", 64, -0.5, 63.5);
409  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);
410  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);
411  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);
412  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);
413  forJet_errorFlag_ = errorHistFlags.make<TH1I>("forJet_errorFlag", "forJet_errorFlag;Status;Number of Candidates", 3, -0.5, 2.5);
414  //Global ForJet Error
415  forJetD_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("forJetD_GlobalError_Rank", "forJetD_GlobalError_Rank", 64, -0.5, 63.5);
416  forJetE_GlobalError_Rank_ = errorHistCat.at(1).make<TH1I>("forJetE_GlobalError_Rank", "forJetE_GlobalError_Rank", 64, -0.5, 63.5);
417  forJetD_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("forJetD_GlobalError_EtEtaPhi", "forJetD_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
418  forJetE_GlobalError_EtEtaPhi_ = errorHistCat.at(1).make<TH2I>("forJetE_GlobalError_EtEtaPhi", "forJetE_GlobalError_EtEtaPhi", 22, -0.5, 21.5, 18, -0.5, 17.5);
419  //IntJets
420  intJetEtEtaPhiE_ = emuHistCat.at(9).make<TH2I>("intJetEtEtaPhiE_", "intJetEtEtaPhiE_;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
421  intJetE_Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Et", "intJetE_Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
422  intJetE_Of_ = emuHistCat.at(9).make<TH1I>("intJetE_Of", "intJetE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
423  intJetE_Jet1Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet1Et", "intJetE_Jet1Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
424  intJetE_Jet2Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet2Et", "intJetE_Jet2Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
425  intJetE_Jet3Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet3Et", "intJetE_Jet3Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
426  intJetE_Jet4Et_ = emuHistCat.at(9).make<TH1I>("intJetE_Jet4Et", "intJetE_Jet4Et;E_{T};Number of Events", 1024, -0.5, 1023.5);
427  //HFRing Sums
428  hfRingSumD_1pos_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_1+", "hfRingSumD_1+;Rank;Number of Events", 8, -0.5, 7.5);
429  hfRingSumD_1neg_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_1-", "hfRingSumD_1-;Rank;Number of Events", 8, -0.5, 7.5);
430  hfRingSumD_2pos_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_2+", "hfRingSumD_2+;Rank;Number of Events", 8, -0.5, 7.5);
431  hfRingSumD_2neg_ = dataHistCat.at(5).make<TH1I>("hfRingSumD_2-", "hfRingSumD_2-;Rank;Number of Events", 8, -0.5, 7.5);
432  hfRingSumE_1pos_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_1+", "hfRingSumE_1+;Rank;Number of Events", 8, -0.5, 7.5);
433  hfRingSumE_1neg_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_1-", "hfRingSumE_1-;Rank;Number of Events", 8, -0.5, 7.5);
434  hfRingSumE_2pos_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_2+", "hfRingSumE_2+;Rank;Number of Events", 8, -0.5, 7.5);
435  hfRingSumE_2neg_ = emuHistCat.at(5).make<TH1I>("hfRingSumE_2-", "hfRingSumE_2-;Rank;Number of Events", 8, -0.5, 7.5);
436  hfRingSum_errorFlag_ = errorHistFlags.make<TH1I>("hfRingSum_errorFlag","hfRingSum_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
437  //HFRing BitCounts
438  hfBitCountD_1pos_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_1+", "hfBitCountD_1+;Rank;Number of Events", 8, -0.5, 7.5);
439  hfBitCountD_1neg_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_1-", "hfBitCountD_1-;Rank;Number of Events", 8, -0.5, 7.5);
440  hfBitCountD_2pos_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_2+", "hfBitCountD_2+;Rank;Number of Events", 8, -0.5, 7.5);
441  hfBitCountD_2neg_ = dataHistCat.at(6).make<TH1I>("hfBitCountD_2-", "hfBitCountD_2-;Rank;Number of Events", 8, -0.5, 7.5);
442  hfBitCountE_1pos_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_1+", "hfBitCountE_1+;Rank;Number of Events", 8, -0.5, 7.5);
443  hfBitCountE_1neg_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_1-", "hfBitCountE_1-;Rank;Number of Events", 8, -0.5, 7.5);
444  hfBitCountE_2pos_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_2+", "hfBitCountE_2+;Rank;Number of Events", 8, -0.5, 7.5);
445  hfBitCountE_2neg_ = emuHistCat.at(6).make<TH1I>("hfBitCountE_2-", "hfBitCountE_2-;Rank;Number of Events", 8, -0.5, 7.5);
446  hfBitCount_errorFlag_ = errorHistFlags.make<TH1I>("hfBitCount_errorFlag","hfBitCount_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
447  //Total ET
448  totalEtD_ = dataHistCat.at(7).make<TH1I>("totalEtD", "totalEtD;E_{T};Number of Events", 2048, -0.5, 2047.5);
449  totalEtD_Of_ = dataHistCat.at(7).make<TH1I>("totalEtD_Of", "totalEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
450  totalEtE_ = emuHistCat.at(7).make<TH1I>("totalEtE", "totalEtE;E_{T};Number of Events", 2048, -0.5, 2047.5);
451  totalEtE_Of_ = emuHistCat.at(7).make<TH1I>("totalEtE_Of", "totalEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
452  totalEt_errorFlag_ = errorHistFlags.make<TH1I>("totalEt_errorFlag","totalEt_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
453  //Book the Global ET Error histograms in the errorHistCat
454  //totalEtD_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalEtD_GlobalError", "totalEtD_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
455  //totalEtE_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalEtE_GlobalError", "totalEtE_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
456  //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);
457  //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);
458  //Total HT
459  totalHtD_ = dataHistCat.at(7).make<TH1I>("totalHtD", "totalHtD;H_{T};Number of Events", 2048, -0.5, 2047.5);
460  totalHtD_Of_ = dataHistCat.at(7).make<TH1I>("totalHtD_Of", "totalHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
461  totalHtE_ = emuHistCat.at(7).make<TH1I>("totalHtE", "totalHtE;H_{T};Number of Events", 2048, -0.5, 2047.5);
462  totalHtE_Of_ = emuHistCat.at(7).make<TH1I>("totalHtE_Of", "totalHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
463  totalHt_errorFlag_ = errorHistFlags.make<TH1I>("totalHt_errorFlag","totalHt_errorFlag;Status;Number of Candidates",2,-0.5,1.5);
464  //Book the Global HT Error histograms in the errorHistCat
465  //totalHtD_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalHtD_GlobalError", "totalHtD_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
466  //totalHtE_GlobalError_ = errorHistCat.at(3).make<TH1I>("totalHtE_GlobalError", "totalHtE_GlobalError;E_{T};Number of Events", 1024, -0.5, 1023.5);
467  //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);
468  //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);
469  //MissingEt
470  missingEtD_ = dataHistCat.at(8).make<TH1I>("missingEtD", "missingEtD;Missing E_{T};Number of Events", 1024, -0.5, 1023.5);
471  missingEtD_Of_ = dataHistCat.at(8).make<TH1I>("missingEtD_Of", "missingEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
472  missingEtD_Phi_ = dataHistCat.at(8).make<TH1I>("missingEtD_Phi", "missingEtD_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
473  missingEtE_ = emuHistCat.at(8).make<TH1I>("missingEtE", "missingEtE;Missing E_{T};Number of Events", 1024, -0.5, 1023.5);
474  missingEtE_Of_ = emuHistCat.at(8).make<TH1I>("missingEtE_Of", "missingEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
475  missingEtE_Phi_ = emuHistCat.at(8).make<TH1I>("missingEtE_Phi", "missingEtE_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
476  missingEt_errorFlag_ = errorHistFlags.make<TH1I>("missingEt_errorFlag","missingEt_errorFlag;Status;Number of Candidates",4,-0.5,3.5);
477  //MissingHt
478  missingHtD_ = dataHistCat.at(8).make<TH1I>("missingHtD", "missingHtD;Missing H_{T};Number of Events", 1024, -0.5, 1023.5);
479  missingHtD_Of_ = dataHistCat.at(8).make<TH1I>("missingHtD_Of", "missingHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
480  missingHtD_Phi_ = dataHistCat.at(8).make<TH1I>("missingHtD_Phi", "missingHtD_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
481  missingHtE_ = emuHistCat.at(8).make<TH1I>("missingHtE", "missingHtE;Missing H_{T};Number of Events", 1024, -0.5, 1023.5);
482  missingHtE_Of_ = emuHistCat.at(8).make<TH1I>("missingHtE_Of", "missingHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
483  missingHtE_Phi_ = emuHistCat.at(8).make<TH1I>("missingHtE_Phi", "missingHtE_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
484  missingHt_errorFlag_ = errorHistFlags.make<TH1I>("missingHt_errorFlag","missingHt_errorFlag;Status;Number of Candidates",4,-0.5,3.5);
485  //Additional MissingHt Debug histograms
486  missingHtD_HtXPosLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXPosLeaf1", "missingHtD;Missing H_{T} X PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
487  missingHtD_HtXPosLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXPosLeaf2", "missingHtD;Missing H_{T} X PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
488  missingHtD_HtXPosLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXPosLeaf3", "missingHtD;Missing H_{T} X PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
489  missingHtD_HtXNegLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXNegLeaf1", "missingHtD;Missing H_{T} X NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
490  missingHtD_HtXNegLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXNegLeaf2", "missingHtD;Missing H_{T} X NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
491  missingHtD_HtXNegLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtXNegLeaf3", "missingHtD;Missing H_{T} X NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);
492 
493  missingHtD_HtYPosLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYPosLeaf1", "missingHtD;Missing H_{T} Y PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
494  missingHtD_HtYPosLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYPosLeaf2", "missingHtD;Missing H_{T} Y PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
495  missingHtD_HtYPosLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYPosLeaf3", "missingHtD;Missing H_{T} Y PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
496  missingHtD_HtYNegLeaf1 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYNegLeaf1", "missingHtD;Missing H_{T} Y NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
497  missingHtD_HtYNegLeaf2 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYNegLeaf2", "missingHtD;Missing H_{T} Y NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
498  missingHtD_HtYNegLeaf3 = dataHistCat.at(8).make<TH1I>("missingHtD_HtYNegLeaf3", "missingHtD;Missing H_{T} Y NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);
499 
500  //Annotate the labels of the error flags
501  //For the electrons and jets
502  std::vector<std::string> errorFlagLabels;
503  errorFlagLabels.push_back("Matched");
504  errorFlagLabels.push_back("Unmatched Data Cand");
505  errorFlagLabels.push_back("Unmatched Emul Cand");
506 
507  for(unsigned int i=0;i<errorFlagLabels.size();i++) {
508  isoEg_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
509  nonIsoEg_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
510  cenJet_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
511  tauJet_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
512  forJet_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
513  }
514  errorFlagLabels.clear();
515 
516  //For the Total Energy Sums and HF
517  errorFlagLabels.push_back("Matched");
518  errorFlagLabels.push_back("Unmatched");
519 
520  for(unsigned int i=0;i<errorFlagLabels.size();i++) {
521  hfRingSum_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
522  hfBitCount_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
523  totalEt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
524  totalHt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
525  }
526  errorFlagLabels.clear();
527 
528  //For the Missing Energy Sums
529  errorFlagLabels.push_back("Matched");
530  errorFlagLabels.push_back("Matched Mag");
531  errorFlagLabels.push_back("Matched Phi");
532  errorFlagLabels.push_back("Unmatched");
533 
534  for(unsigned int i=0;i<errorFlagLabels.size();i++) {
535  missingEt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
536  missingHt_errorFlag_->GetXaxis()->SetBinLabel(i+1,errorFlagLabels.at(i).c_str());
537  }
538 
539  //initialise - set all flags to false as they will be set on an event-by-event basis
540  isIsoError=0;
541  isNonIsoError=0;
542  isCenJetError=0;
543  isTauJetError=0;
544  isForJetError=0;
545  isRingSumError=0;
546  isBitCountError=0;
547  isTotalEError=0;
548  isTotalHError=0;
549  isMissingEError=0;
550  isMissingHError=0;
551 
552  //fill the struct of MBXinformation. It is easier to pass this information to the respective functions as used below this way
553  MBxInfo.RCTTrigBx = RCTTrigBx_;
554  MBxInfo.EmuTrigBx = EmuTrigBx_;
555  MBxInfo.GCTTrigBx = GCTTrigBx_;
556 
557  //set the parameters according to the system chosen
558  if(useSys_ == "P5") {
559  RCT_REGION_QUANTA = &RCT_REGION_QUANTA_P5;
560  }
561  else if(useSys_ == "Lab") {
562  RCT_REGION_QUANTA = &RCT_REGION_QUANTA_LAB;
563  }
564  else {
565  edm::LogWarning("ChosenSystem") << " " << "The system you chose to use (" << useSys_ << ") was not recognised. Defaulting to the full system geometry";
566  RCT_REGION_QUANTA = &RCT_REGION_QUANTA_P5;
567  }
568 
569 }
570 
571 
572 GctErrorAnalyzer::~GctErrorAnalyzer()
573 {
574 
575  // do anything here that needs to be done at desctruction time
576  // (e.g. close files, deallocate resources etc.)
577 
578 }
579 
580 
581 //
582 // member functions
583 //
584 
585 // ------------ method called to for each event ------------
586 void
587 GctErrorAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
588 {
589  using namespace edm;
590  using namespace std;
591 
592  Handle<L1CaloRegionCollection> caloRegions;
593  Handle<L1CaloEmCollection> emRegions;
594 
595  Handle<L1GctEmCandCollection> nonIsoEgD;
596  Handle<L1GctEmCandCollection> nonIsoEgE;
597  Handle<L1GctEmCandCollection> isoEgD;
598  Handle<L1GctEmCandCollection> isoEgE;
599 
600  Handle<L1GctJetCandCollection> cenJetsD;
601  Handle<L1GctJetCandCollection> cenJetsE;
602  Handle<L1GctJetCandCollection> forJetsD;
603  Handle<L1GctJetCandCollection> forJetsE;
604  Handle<L1GctJetCandCollection> tauJetsD;
605  Handle<L1GctJetCandCollection> tauJetsE;
606 
607  Handle<L1GctInternJetDataCollection> intJetsE;
608 
609  Handle<L1GctHFRingEtSumsCollection> hfRingSumsD;
610  Handle<L1GctHFRingEtSumsCollection> hfRingSumsE;
611 
612  Handle<L1GctHFBitCountsCollection> hfBitCountsD;
613  Handle<L1GctHFBitCountsCollection> hfBitCountsE;
614 
615  Handle<L1GctEtTotalCollection> totalEtD;
616  Handle<L1GctEtTotalCollection> totalEtE;
617 
618  Handle<L1GctEtHadCollection> totalHtD;
619  Handle<L1GctEtHadCollection> totalHtE;
620 
621  Handle<L1GctEtMissCollection> missingEtD;
622  Handle<L1GctEtMissCollection> missingEtE;
623 
624  Handle<L1GctHtMissCollection> missingHtD;
625  Handle<L1GctHtMissCollection> missingHtE;
626 
627  Handle<L1GctInternHtMissCollection> intHtMissD;
628 
629  //we need this for all user cases...
630  iEvent.getByLabel(dataTag_.label(), caloRegions);
631 
632  //in order to allow the debug folders to have a unique name (so that when jobs are split in crab, we can merge)
633  //use the eventnum in the folder name
634  eventNumber = iEvent.id().event();
635 
636  if(doRCT_) {
637  if(checkCollections(caloRegions, *RCT_REGION_QUANTA, "RCT CaloRegions")) plotRCTRegions(caloRegions);
638  }
639 
640  if(doEg_) {
641  iEvent.getByLabel(dataTag_.label(),"nonIsoEm", nonIsoEgD);
642  iEvent.getByLabel(emuTag_.label(), "nonIsoEm", nonIsoEgE);
643 
644  iEvent.getByLabel(dataTag_.label(), "isoEm", isoEgD);
645  iEvent.getByLabel(emuTag_.label(), "isoEm", isoEgE);
646 
647  isIsoError=0;
648  isNonIsoError=0;
649 
650  if(checkCollections(isoEgD, GCT_OBJECT_QUANTA, "Iso e/g Data") && checkCollections(isoEgE, GCT_OBJECT_QUANTA, "Iso e/g Emulator")) {
651  plotIsoEm(isoEgD, isoEgE);
652  compareEG isoCompare(isoEgD, isoEgE, MBxInfo);
653  isIsoError = isoCompare.doCompare(isoEg_errorFlag_, isoEgD_GlobalError_Rank_, isoEgD_GlobalError_EtEtaPhi_, isoEgE_GlobalError_Rank_, isoEgE_GlobalError_EtEtaPhi_);
654  }
655 
656  if(checkCollections(nonIsoEgD, GCT_OBJECT_QUANTA, "NonIso e/g Data") && checkCollections(nonIsoEgE, GCT_OBJECT_QUANTA, "NonIso e/g Emulator")) {
657  plotNonIsoEm(nonIsoEgD, nonIsoEgE);
658  compareEG nonIsoCompare(nonIsoEgD, nonIsoEgE, MBxInfo);
659  isNonIsoError = nonIsoCompare.doCompare(nonIsoEg_errorFlag_, nonIsoEgD_GlobalError_Rank_, nonIsoEgD_GlobalError_EtEtaPhi_, nonIsoEgE_GlobalError_Rank_, nonIsoEgE_GlobalError_EtEtaPhi_);
660  }
661 
662  if( (isIsoError && doIsoDebug_) || (isNonIsoError && doNonIsoDebug_) ) {
663  iEvent.getByLabel(dataTag_.label(), emRegions);
664  if(checkCollections(emRegions, RCT_EM_OBJECT_QUANTA, "RCT EMRegions")) plotEGErrors(isoEgD, isoEgE, nonIsoEgD, nonIsoEgE, emRegions);
665  }
666  }
667 
668  if(doJets_) {
669  iEvent.getByLabel(emuTag_.label(), "cenJets", cenJetsE);
670  iEvent.getByLabel(dataTag_.label(), "cenJets", cenJetsD);
671 
672  iEvent.getByLabel(emuTag_.label(), "forJets", forJetsE);
673  iEvent.getByLabel(dataTag_.label(), "forJets", forJetsD);
674 
675  iEvent.getByLabel(emuTag_.label(), "tauJets", tauJetsE);
676  iEvent.getByLabel(dataTag_.label(), "tauJets", tauJetsD);
677 
678  iEvent.getByLabel(emuTag_.label(), intJetsE);
679 
680  isCenJetError=0;
681  isTauJetError=0;
682  isForJetError=0;
683 
684  //Central Jets
685  if(checkCollections(cenJetsD, GCT_OBJECT_QUANTA, "Central Jets Data") && checkCollections(cenJetsE, GCT_OBJECT_QUANTA, "Central Jets Emulator")) {
686  plotCenJets(cenJetsD, cenJetsE);
687  compareJets cenJetsCompare(cenJetsD, cenJetsE, MBxInfo);
688  isCenJetError = cenJetsCompare.doCompare(cenJet_errorFlag_, cenJetD_GlobalError_Rank_, cenJetD_GlobalError_EtEtaPhi_, cenJetE_GlobalError_Rank_, cenJetE_GlobalError_EtEtaPhi_);
689  }
690 
691  //Tau Jets
692  if(checkCollections(tauJetsD, GCT_OBJECT_QUANTA, "Tau Jets Data") && checkCollections(tauJetsE, GCT_OBJECT_QUANTA, "Tau Jets Emulator")) {
693  plotTauJets(tauJetsD, tauJetsE);
694  compareJets tauJetsCompare(tauJetsD, tauJetsE, MBxInfo);
695  isTauJetError = tauJetsCompare.doCompare(tauJet_errorFlag_, tauJetD_GlobalError_Rank_, tauJetD_GlobalError_EtEtaPhi_, tauJetE_GlobalError_Rank_, tauJetE_GlobalError_EtEtaPhi_);
696  }
697 
698  //For Jets
699  if(checkCollections(forJetsD, GCT_OBJECT_QUANTA, "Forward Jets Data") && checkCollections(forJetsE, GCT_OBJECT_QUANTA, "Forward Jets Emulator")) {
700  plotForJets(forJetsD, forJetsE);
701  compareJets forJetsCompare(forJetsD, forJetsE, MBxInfo);
702  isForJetError = forJetsCompare.doCompare(forJet_errorFlag_, forJetD_GlobalError_Rank_, forJetD_GlobalError_EtEtaPhi_, forJetE_GlobalError_Rank_, forJetE_GlobalError_EtEtaPhi_);
703  }
704 
705  //Emulator Intermediate Jets
706  if(checkCollections(intJetsE, NUM_INT_JETS, "Intermediate Jets Emulator")) plotIntJets(intJetsE);
707 
708  if( (isCenJetError && doCenJetsDebug_) || (isTauJetError && doTauJetsDebug_) || (isForJetError && doForJetsDebug_) ) {
709  plotJetErrors(cenJetsD, cenJetsE, tauJetsD, tauJetsE, forJetsD, forJetsE, caloRegions);
710  }
711  }
712 
713  if(doHF_) {
714  iEvent.getByLabel(dataTag_.label(), hfRingSumsD);
715  iEvent.getByLabel(emuTag_.label(), hfRingSumsE);
716 
717  iEvent.getByLabel(dataTag_.label(), hfBitCountsD);
718  iEvent.getByLabel(emuTag_.label(), hfBitCountsE);
719 
720  isRingSumError=0;
721  isBitCountError=0;
722 
723  if(checkCollections(hfRingSumsD, GCT_SUMS_QUANTA, "HF Ring Sums Data") && checkCollections(hfRingSumsE, GCT_SUMS_QUANTA, "HF Ring Sums Emulator")) {
724  plotHFRingSums(hfRingSumsD, hfRingSumsE);
725  compareRingSums HFRingSums(hfRingSumsD, hfRingSumsE, MBxInfo);
726  isRingSumError = HFRingSums.doCompare(hfRingSum_errorFlag_);
727  }
728 
729  if(checkCollections(hfBitCountsD, GCT_SUMS_QUANTA, "HF Bit Counts Data") && checkCollections(hfBitCountsE, GCT_SUMS_QUANTA, "HF Bit Counts Emulator")) {
730  plotHFBitCounts(hfBitCountsD, hfBitCountsE);
731  compareBitCounts HFBitCounts(hfBitCountsD, hfBitCountsE, MBxInfo);
732  isBitCountError = HFBitCounts.doCompare(hfBitCount_errorFlag_);
733  }
734 
735  if( (isRingSumError && doRingSumDebug_) || (isBitCountError && doBitCountDebug_) ) {
736  plotHFErrors(hfRingSumsD, hfRingSumsE, hfBitCountsD, hfBitCountsE, caloRegions);
737  }
738  }
739 
740  if(doTotalEnergySums_) {
741  iEvent.getByLabel(dataTag_.label(), totalEtD);
742  iEvent.getByLabel(emuTag_.label(), totalEtE);
743 
744  iEvent.getByLabel(dataTag_.label(), totalHtD);
745  iEvent.getByLabel(emuTag_.label(), totalHtE);
746 
747  isTotalEError=0;
748  isTotalHError=0;
749 
750  if(checkCollections(totalEtD, GCT_SUMS_QUANTA, "Total Et Data") && checkCollections(totalEtE, GCT_SUMS_QUANTA, "Total Et Emulator")) {
751  plotTotalE(totalEtD, totalEtE);
752  compareTotalE compareET(totalEtD, totalEtE, MBxInfo);
753  isTotalEError = compareET.doCompare(totalEt_errorFlag_);
754  }
755 
756  if(checkCollections(totalHtD, GCT_SUMS_QUANTA, "Total Ht Data") && checkCollections(totalHtE, GCT_SUMS_QUANTA, "Total Ht Emulator")) {
757  plotTotalH(totalHtD, totalHtE);
758  compareTotalH compareHT(totalHtD, totalHtE, MBxInfo);
759  isTotalHError = compareHT.doCompare(totalHt_errorFlag_);
760  }
761 
762  if((isTotalEError && doTotalEtDebug_) || (isTotalHError && doTotalHtDebug_)) {
763  plotTotalEErrors(totalEtD, totalEtE, totalHtD, totalHtE, caloRegions);
764  }
765 
766  }
767 
768  if(doMissingEnergySums_) {
769 
770  iEvent.getByLabel(dataTag_.label(), missingEtD);
771  iEvent.getByLabel(emuTag_.label(), missingEtE);
772 
773  iEvent.getByLabel(dataTag_.label(), missingHtD);
774  iEvent.getByLabel(emuTag_.label(), missingHtE);
775 
776  isMissingEError=0;
777  isMissingHError=0;
778 
779  if(checkCollections(missingEtD, GCT_SUMS_QUANTA, "Missing Et Data") && checkCollections(missingEtE, GCT_SUMS_QUANTA, "Missing Et Emulator")) {
780  plotMissingEt(missingEtD, missingEtE);
781  compareMissingE compareMET(missingEtD, missingEtE, MBxInfo);
782  isMissingEError = compareMET.doCompare(missingEt_errorFlag_);
783  }
784 
785  if(checkCollections(missingHtD, GCT_SUMS_QUANTA, "Missing Ht Data") && checkCollections(missingHtE, GCT_SUMS_QUANTA, "Missing Ht Emulator")) {
786  plotMissingHt(missingHtD, missingHtE);
787  compareMissingH compareMHT(missingHtD, missingHtE, MBxInfo);
788  isMissingHError = compareMHT.doCompare(missingHt_errorFlag_);
789 
790  //added 19/03/2010 for intermediate information on MissingHt quantities in the data
791  if(doExtraMissingHTDebug_) {
792  iEvent.getByLabel(dataTag_.label(), "", intHtMissD);
793  if(checkCollections(intHtMissD, GCT_INT_HTMISS_QUANTA, "Internal Missing Ht Data")) {
794  for(unsigned int i=0; i<intHtMissD->size(); i++) {
795  if(doGCTMBx_ || intHtMissD->at(i).bx() == GCTTrigBx_) {
796  if(!intHtMissD->at(i).overflow()) {
797  //the capBlock 0x301 is the input pipeline at the wheel for positive eta, whereas 0x701 is for negative eta
798  if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXPosLeaf1->Fill(intHtMissD->at(i).htx());
799  if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXPosLeaf2->Fill(intHtMissD->at(i).htx());
800  if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXPosLeaf3->Fill(intHtMissD->at(i).htx());
801  if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXNegLeaf1->Fill(intHtMissD->at(i).htx());
802  if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXNegLeaf2->Fill(intHtMissD->at(i).htx());
803  if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHtx()) missingHtD_HtXNegLeaf3->Fill(intHtMissD->at(i).htx());
804 
805  if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHty()) missingHtD_HtYPosLeaf1->Fill(intHtMissD->at(i).hty());
806  if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHty()) missingHtD_HtYPosLeaf2->Fill(intHtMissD->at(i).hty());
807  if(intHtMissD->at(i).capBlock() == 0x301 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHty()) missingHtD_HtYPosLeaf3->Fill(intHtMissD->at(i).hty());
808  if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 0 && intHtMissD->at(i).isThereHty()) missingHtD_HtYNegLeaf1->Fill(intHtMissD->at(i).hty());
809  if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 1 && intHtMissD->at(i).isThereHty()) missingHtD_HtYNegLeaf2->Fill(intHtMissD->at(i).hty());
810  if(intHtMissD->at(i).capBlock() == 0x701 && intHtMissD->at(i).capIndex() == 2 && intHtMissD->at(i).isThereHty()) missingHtD_HtYNegLeaf3->Fill(intHtMissD->at(i).hty());
811  }
812  }
813  }
814  }
815  }
816  }
817 
818  if((isMissingEError && doMissingETDebug_) || (isMissingHError && doMissingHTDebug_)) {
819  plotMissingEErrors(missingEtD, missingEtE, missingHtD, missingHtE, caloRegions, intJetsE, intHtMissD);
820  }
821 
822  }
823 
824 }
825 
826 
827 // ------------ method called once each job just before starting event loop ------------
828 void
829 GctErrorAnalyzer::beginJob()
830 {
831 }
832 
833 // ------------ method called once each job just after ending the event loop ------------
834 void
835 GctErrorAnalyzer::endJob() {
836 }
837 
838 void
839 GctErrorAnalyzer::plotRCTRegions(const edm::Handle<L1CaloRegionCollection> &caloRegions) {
840  //if more than one Bx is readout per event, then caloRegions->size() will be some multiple of 396
841  for(unsigned int i=0;i < caloRegions->size();i++) {
842  //if the RCTMBx flag is set to true, write out all the info into the same histogram
843  //otherwise only the RCTTrigBx will be written out - could skip (RCT_REGION_QUANTA-1) events here to speed things up...
844  if(doRCTMBx_ || caloRegions->at(i).bx() == RCTTrigBx_) {
845  if(caloRegions->at(i).et()>0) RCT_EtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
846  if(caloRegions->at(i).tauVeto()) RCT_TvEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
847  if(caloRegions->at(i).fineGrain()) RCT_FgEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
848  if(caloRegions->at(i).overFlow()) RCT_OfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
849  }
850  }
851 }
852 
853 void
854 GctErrorAnalyzer::plotIsoEm(const edm::Handle<L1GctEmCandCollection> &isoEgD, const edm::Handle<L1GctEmCandCollection> &isoEgE) {
855  //loop over all the data candidates - if multiple bx, then this should be a multiple of GCT_OBJECT_QUANTA
856  for (unsigned int i=0; i < isoEgD->size(); i++) {
857  //if the GCTMBx flag is set, plot all Bx for this quantity, otherwise only plot Bx = GCTTrigBx_
858  if(doGCTMBx_ || isoEgD->at(i).bx() == GCTTrigBx_) {
859  isoEgD_Rank_->Fill(isoEgD->at(i).rank());
860  if(isoEgD->at(i).rank()>0) {
861  isoEgD_EtEtaPhi_->Fill(isoEgD->at(i).regionId().ieta(), isoEgD->at(i).regionId().iphi(), isoEgD->at(i).rank());
862  isoEgD_OccEtaPhi_->Fill(isoEgD->at(i).regionId().ieta(), isoEgD->at(i).regionId().iphi());
863  }
864  }
865  }
866  //now repeat for the emulator candidates
867  for(unsigned int i=0; i < isoEgE->size(); i++) {
868  if(doEmuMBx_ || isoEgE->at(i).bx() == EmuTrigBx_) {
869  isoEgE_Rank_->Fill(isoEgE->at(i).rank());
870  if(isoEgE->at(i).rank()>0) {
871  isoEgE_EtEtaPhi_->Fill(isoEgE->at(i).regionId().ieta(), isoEgE->at(i).regionId().iphi(), isoEgE->at(i).rank());
872  isoEgE_OccEtaPhi_->Fill(isoEgE->at(i).regionId().ieta(), isoEgE->at(i).regionId().iphi());
873  }
874  }
875  }
876 }
877 
878 void
879 GctErrorAnalyzer::plotNonIsoEm(const edm::Handle<L1GctEmCandCollection> &nonIsoEgD, const edm::Handle<L1GctEmCandCollection> &nonIsoEgE) {
880  //loop over all the data candidates - if multiple bx, then this should be a multiple of GCT_OBJECT_QUANTA
881  for (unsigned int i=0; i < nonIsoEgD->size(); i++) {
882  //if the GCTMBx flag is set, plot all Bx for this quantity, otherwise only plot Bx = GCTTrigBx_
883  if(doGCTMBx_ || nonIsoEgD->at(i).bx() == GCTTrigBx_) {
884  nonIsoEgD_Rank_->Fill(nonIsoEgD->at(i).rank());
885  if(nonIsoEgD->at(i).rank()>0) {
886  nonIsoEgD_EtEtaPhi_->Fill(nonIsoEgD->at(i).regionId().ieta(), nonIsoEgD->at(i).regionId().iphi(), nonIsoEgD->at(i).rank());
887  nonIsoEgD_OccEtaPhi_->Fill(nonIsoEgD->at(i).regionId().ieta(), nonIsoEgD->at(i).regionId().iphi());
888  }
889  }
890  }
891  //now repeat for the emulator candidates
892  for(unsigned int i=0; i < nonIsoEgE->size(); i++) {
893  if(doEmuMBx_ || nonIsoEgE->at(i).bx() == EmuTrigBx_) {
894  nonIsoEgE_Rank_->Fill(nonIsoEgE->at(i).rank());
895  if(nonIsoEgE->at(i).rank()>0) {
896  nonIsoEgE_EtEtaPhi_->Fill(nonIsoEgE->at(i).regionId().ieta(), nonIsoEgE->at(i).regionId().iphi(), nonIsoEgE->at(i).rank());
897  nonIsoEgE_OccEtaPhi_->Fill(nonIsoEgE->at(i).regionId().ieta(), nonIsoEgE->at(i).regionId().iphi());
898  }
899  }
900  }
901 }
902 
903 void
904 GctErrorAnalyzer::plotEGErrors(const edm::Handle<L1GctEmCandCollection> &isoEgD, const edm::Handle<L1GctEmCandCollection> &isoEgE, const edm::Handle<L1GctEmCandCollection> &nonIsoEgD, const edm::Handle<L1GctEmCandCollection> &nonIsoEgE, const edm::Handle<L1CaloEmCollection> &emRegions) {
905 
906  std::string errorDirName = "err_";
907  if(isIsoError) errorDirName.append("I");
908  if(isNonIsoError) errorDirName.append("N");
909  std::stringstream caseNumber;
910  caseNumber << eventNumber;
911  errorDirName.append(caseNumber.str());
912  TFileDirectory errorDir = errorHistCat.at(0).mkdir(errorDirName);
913 
914  TH2I *errorEmRegionIsoEtEtaPhi_ = errorDir.make<TH2I>("errorEmRegionIsoEtEtaPhi", "errorEmRegionIsoEtEtaPhi;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
915  TH2I *errorEmRegionNonIsoEtEtaPhi_ = errorDir.make<TH2I>("errorEmRegionNonIsoEtEtaPhi", "errorEmRegionNonIsoEtEtaPhi;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
916  TH2I *errorIsoEtEtaPhiD_ = errorDir.make<TH2I>("errorIsoEtEtaPhiD", "errorIsoEtEtaPhiD;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
917  TH2I *errorNonIsoEtEtaPhiD_ = errorDir.make<TH2I>("errorNonIsoEtEtaPhiD", "errorNonIsoEtEtaPhiD;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
918  TH2I *errorIsoEtEtaPhiE_ = errorDir.make<TH2I>("errorIsoEtEtaPhiE", "errorIsoEtEtaPhiE;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
919  TH2I *errorNonIsoEtEtaPhiE_ = errorDir.make<TH2I>("errorNonIsoEtEtaPhiE", "errorNonIsoEtEtaPhiE;#eta (GCT Units);#phi (GCT Units)",22, -0.5, 21.5, 18, -0.5, 17.5);
920 
921  //fill the EM input collection
922  //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
923  //this assumes that comparison is done on the central Bx i.e. RctBx=0 corresponds to GctBx=0, and EmuBx=0 takes RctBx=0
924  for(unsigned int i=0;i < emRegions->size();i++) {
925  if(emRegions->at(i).bx() == RCTTrigBx_) {
926  if(emRegions->at(i).isolated()) {
927  if(emRegions->at(i).rank()>0) errorEmRegionIsoEtEtaPhi_->Fill(emRegions->at(i).regionId().ieta(),emRegions->at(i).regionId().iphi(),emRegions->at(i).rank());
928  }
929  else{
930  if(emRegions->at(i).rank()>0) errorEmRegionNonIsoEtEtaPhi_->Fill(emRegions->at(i).regionId().ieta(),emRegions->at(i).regionId().iphi(),emRegions->at(i).rank());
931  }
932  }
933  }
934 
935  //no need to have the rank plot, because you can't have two electrons in the same place (eta,phi), in the same event...
936  //in this case, since we're actually comparing the GCTTrigBx_ with the EmuTrigBx_, we plot these individually
937  for(unsigned int i=0; i < isoEgD->size(); i++) {
938  if(isoEgD->at(i).bx() == GCTTrigBx_) {
939  if(isoEgD->at(i).rank()>0) errorIsoEtEtaPhiD_->Fill(isoEgD->at(i).regionId().ieta(),isoEgD->at(i).regionId().iphi(),isoEgD->at(i).rank());
940  }
941  }
942  for(unsigned int i=0; i < nonIsoEgD->size(); i++) {
943  if(nonIsoEgD->at(i).bx() == GCTTrigBx_) {
944  if(nonIsoEgD->at(i).rank()>0) errorNonIsoEtEtaPhiD_->Fill(nonIsoEgD->at(i).regionId().ieta(),nonIsoEgD->at(i).regionId().iphi(),nonIsoEgD->at(i).rank());
945  }
946  }
947 
948  //now for the emulator candidates
949  for(unsigned int i=0; i < isoEgE->size(); i++) {
950  if(isoEgE->at(i).bx() == EmuTrigBx_) {
951  if(isoEgE->at(i).rank()>0) errorIsoEtEtaPhiE_->Fill(isoEgE->at(i).regionId().ieta(),isoEgE->at(i).regionId().iphi(),isoEgE->at(i).rank());
952  }
953  }
954  for(unsigned int i=0; i < nonIsoEgE->size(); i++) {
955  if(nonIsoEgE->at(i).bx() == EmuTrigBx_) {
956  if(nonIsoEgE->at(i).rank()>0) errorNonIsoEtEtaPhiE_->Fill(nonIsoEgE->at(i).regionId().ieta(),nonIsoEgE->at(i).regionId().iphi(),nonIsoEgE->at(i).rank());
957  }
958  }
959 }
960 
961 void
962 GctErrorAnalyzer::plotCenJets(const edm::Handle<L1GctJetCandCollection> &cenJetsD, const edm::Handle<L1GctJetCandCollection> &cenJetsE) {
963 
964  for (unsigned int i=0; i < cenJetsD->size(); i++) {
965  if(doGCTMBx_ || cenJetsD->at(i).bx() == GCTTrigBx_) {
966  cenJetD_Rank_->Fill(cenJetsD->at(i).rank());
967  if(cenJetsD->at(i).rank()>0) {
968  cenJetD_EtEtaPhi_->Fill(cenJetsD->at(i).regionId().ieta(),cenJetsD->at(i).regionId().iphi(),cenJetsD->at(i).rank());
969  cenJetD_OccEtaPhi_->Fill(cenJetsD->at(i).regionId().ieta(),cenJetsD->at(i).regionId().iphi());
970  }
971  }
972  }
973 
974  for(unsigned int i=0; i < cenJetsE->size(); i++) {
975  if(doEmuMBx_ || cenJetsE->at(i).bx() == EmuTrigBx_) {
976  cenJetE_Rank_->Fill(cenJetsE->at(i).rank());
977  if(cenJetsE->at(i).rank()>0) {
978  cenJetE_EtEtaPhi_->Fill(cenJetsE->at(i).regionId().ieta(),cenJetsE->at(i).regionId().iphi(),cenJetsE->at(i).rank());
979  cenJetE_OccEtaPhi_->Fill(cenJetsE->at(i).regionId().ieta(),cenJetsE->at(i).regionId().iphi());
980  }
981  }
982  }
983 }
984 
985 void
986 GctErrorAnalyzer::plotTauJets(const edm::Handle<L1GctJetCandCollection> &tauJetsD, const edm::Handle<L1GctJetCandCollection> &tauJetsE) {
987 
988  for (unsigned int i=0; i < tauJetsD->size(); i++) {
989  if(doGCTMBx_ || tauJetsD->at(i).bx() == GCTTrigBx_) {
990  tauJetD_Rank_->Fill(tauJetsD->at(i).rank());
991  if(tauJetsD->at(i).rank()>0) {
992  tauJetD_EtEtaPhi_->Fill(tauJetsD->at(i).regionId().ieta(),tauJetsD->at(i).regionId().iphi(),tauJetsD->at(i).rank());
993  tauJetD_OccEtaPhi_->Fill(tauJetsD->at(i).regionId().ieta(),tauJetsD->at(i).regionId().iphi());
994  }
995  }
996  }
997 
998  for(unsigned int i=0; i < tauJetsE->size(); i++) {
999  if(doEmuMBx_ || tauJetsE->at(i).bx() == EmuTrigBx_) {
1000  tauJetE_Rank_->Fill(tauJetsE->at(i).rank());
1001  if(tauJetsE->at(i).rank()>0) {
1002  tauJetE_EtEtaPhi_->Fill(tauJetsE->at(i).regionId().ieta(),tauJetsE->at(i).regionId().iphi(),tauJetsE->at(i).rank());
1003  tauJetE_OccEtaPhi_->Fill(tauJetsE->at(i).regionId().ieta(),tauJetsE->at(i).regionId().iphi());
1004  }
1005  }
1006  }
1007 }
1008 
1009 void
1010 GctErrorAnalyzer::plotForJets(const edm::Handle<L1GctJetCandCollection> &forJetsD, const edm::Handle<L1GctJetCandCollection> &forJetsE) {
1011 
1012  for (unsigned int i=0; i < forJetsD->size(); i++) {
1013  if(doGCTMBx_ || forJetsD->at(i).bx() == GCTTrigBx_) {
1014  forJetD_Rank_->Fill(forJetsD->at(i).rank());
1015  if(forJetsD->at(i).rank()>0) {
1016  forJetD_EtEtaPhi_->Fill(forJetsD->at(i).regionId().ieta(),forJetsD->at(i).regionId().iphi(),forJetsD->at(i).rank());
1017  forJetD_OccEtaPhi_->Fill(forJetsD->at(i).regionId().ieta(),forJetsD->at(i).regionId().iphi());
1018  }
1019  }
1020  }
1021 
1022  for(unsigned int i=0; i < forJetsE->size(); i++) {
1023  if(doEmuMBx_ || forJetsE->at(i).bx() == EmuTrigBx_) {
1024  forJetE_Rank_->Fill(forJetsE->at(i).rank());
1025  if(forJetsE->at(i).rank()>0) {
1026  forJetE_EtEtaPhi_->Fill(forJetsE->at(i).regionId().ieta(),forJetsE->at(i).regionId().iphi(),forJetsE->at(i).rank());
1027  forJetE_OccEtaPhi_->Fill(forJetsE->at(i).regionId().ieta(),forJetsE->at(i).regionId().iphi());
1028  }
1029  }
1030  }
1031 }
1032 
1033 void
1034 GctErrorAnalyzer::plotIntJets(const edm::Handle<L1GctInternJetDataCollection> &intJetsE) {
1035 
1036  jetData intJet;
1037  std::vector<jetData> intJetCollection(NUM_INT_JETS); //define fixed size for the vector to avoid reallocation (i.e. max size possible)
1038 
1039  //since we don't read out the intermediate (i.e. leaf card) jets, we can only plot the emulator distributions
1040  //the 1st-4th jet Et will prove useful in understanding and motivating cuts on individual jets in HT and MHT.
1041  for(unsigned int i=0; i < intJetsE->size(); i++) {
1042 
1043  if(doEmuMBx_ || intJetsE->at(i).bx() == EmuTrigBx_) {
1044 
1045  //the intermediate jets are not sorted in terms of Et so
1046  //in order to do this independently of the data format,
1047  //copy to a user defined struct and sort that way
1048  intJet.et = intJetsE->at(i).et();
1049  intJet.phi = intJetsE->at(i).phi();
1050  intJet.eta = intJetsE->at(i).eta();
1051  intJetCollection.at(i % NUM_INT_JETS) = intJet;
1052 
1053  //remember, if the event has 1 overflowed jet, then we fill the internal jet dist overflow histogram
1054  //and skip the event - there is no point looking at the leading jet distributions etc for an event
1055  //with an overflowed jet - this will imply HT, ET, MET and MHT all overflow too.
1056  if(intJetsE->at(i).oflow()) {
1057  intJetE_Of_->Fill(intJetsE->at(i).oflow());
1058  return;
1059  }
1060 
1061  //plot the (et,eta,phi) distribution of the intermediate jets (for non-zero et)
1062  if(intJetsE->at(i).et()) intJetEtEtaPhiE_->Fill(intJetsE->at(i).regionId().ieta(),intJetsE->at(i).regionId().iphi(),intJetsE->at(i).et());
1063 
1064  }
1065  }
1066 
1067  //if we get this far, there are no jets with an overflow bit so fill the overflow histogram and
1068  //sort the intJetCollection according to the rule defined in sortJets (i.e. largest et first)
1069  intJetE_Of_->Fill(0);
1070  std::sort(intJetCollection.begin(), intJetCollection.end(), sortJets);
1071 
1072  std::vector<TH1I *> leadingJetDist(4);
1073  leadingJetDist.at(0) = intJetE_Jet1Et_;
1074  leadingJetDist.at(1) = intJetE_Jet2Et_;
1075  leadingJetDist.at(2) = intJetE_Jet3Et_;
1076  leadingJetDist.at(3) = intJetE_Jet4Et_;
1077 
1078  unsigned int i=0;
1079  unsigned int j=0;
1080  unsigned int currentEt=0;
1081  while(intJetCollection.at(i).et > 0) {
1082 
1083  if(j < leadingJetDist.size()) {
1084  if(i == 0) {
1085  leadingJetDist.at(j)->Fill(intJetCollection.at(i).et);
1086  currentEt = intJetCollection.at(i).et;
1087  j++;
1088  } else {
1089  if(intJetCollection.at(i).et < currentEt) {
1090  leadingJetDist.at(j)->Fill(intJetCollection.at(i).et);
1091  currentEt = intJetCollection.at(i).et;
1092  j++;
1093  }
1094  }
1095  }
1096 
1097  intJetE_Et_->Fill(intJetCollection.at(i).et);
1098  i++;
1099  }
1100  return;
1101 
1102 }
1103 
1104 bool
1105 GctErrorAnalyzer::sortJets(const jetData &jet1, const jetData &jet2) {
1106  return jet1.et > jet2.et;
1107 }
1108 
1109 template<class T>
1110 bool
1111 GctErrorAnalyzer::checkCollections(const T &collection, const unsigned int &constraint, const std::string &label) {
1112 
1113  //unfortunately, the dataformats are not consistent with the name() method (i.e. some have it, others don't)
1114  //and a typeof() function doesn't exist in ANSI C++, so to identify the templated type, we pass a std::string
1115 
1116  if(!collection.isValid()) {
1117  edm::LogWarning("DataNotFound") << " Could not find " << label << " label";
1118  return false;
1119  }
1120  if(collection->size() % constraint != 0 || collection->size() == 0) {
1121  edm::LogWarning("CollectionSizeError") << " " << label << " collection size is " << collection->size() << ", expected multiple of " << constraint;
1122  return false;
1123  }
1124 
1125  return true;
1126 }
1127 
1128 void
1129 GctErrorAnalyzer::plotJetErrors(const edm::Handle<L1GctJetCandCollection> &cenJetsD, const edm::Handle<L1GctJetCandCollection> &cenJetsE, const edm::Handle<L1GctJetCandCollection> &tauJetsD, const edm::Handle<L1GctJetCandCollection> &tauJetsE, const edm::Handle<L1GctJetCandCollection> &forJetsD, const edm::Handle<L1GctJetCandCollection> &forJetsE, const edm::Handle<L1CaloRegionCollection> &caloRegions) {
1130 
1131  std::string errorDirName = "err_";
1132  if(isCenJetError) errorDirName.append("C");
1133  if(isTauJetError) errorDirName.append("T");
1134  if(isForJetError) errorDirName.append("F");
1135  std::stringstream caseNumber;
1136  caseNumber << eventNumber;
1137  errorDirName.append(caseNumber.str());
1138  TFileDirectory errorDir = errorHistCat.at(1).mkdir(errorDirName);
1139 
1140  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1141  TH2I *errorRegionTvEtaPhi_ = errorDir.make<TH2I>("errorRegionTvEtaPhi", "errorRegionTvEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1142  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1143 
1144  //make sure to only plot the caloRegion bx which corresponds to the data vs emulator comparison
1145  for(unsigned int i=0;i<caloRegions->size();i++) {
1146  if(caloRegions->at(i).bx() == RCTTrigBx_) {
1147  if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
1148  if(caloRegions->at(i).tauVeto()) errorRegionTvEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
1149  if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
1150  }
1151  }
1152 
1153  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);
1154  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);
1155  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);
1156  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);
1157  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);
1158  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);
1159 
1160  //first plot the data candiates for the Trigger Bx that this error corresponds to
1161  for(unsigned int i=0; i < cenJetsD->size(); i++) {
1162  if(cenJetsD->at(i).bx() == GCTTrigBx_) {
1163  if(cenJetsD->at(i).rank()>0) cenJet_errorEtEtaPhiData_->Fill(cenJetsD->at(i).regionId().ieta(),cenJetsD->at(i).regionId().iphi(),cenJetsD->at(i).rank());
1164  }
1165  }
1166  for(unsigned int i=0; i < tauJetsD->size(); i++) {
1167  if(tauJetsD->at(i).bx() == GCTTrigBx_) {
1168  if(tauJetsD->at(i).rank()>0) tauJet_errorEtEtaPhiData_->Fill(tauJetsD->at(i).regionId().ieta(),tauJetsD->at(i).regionId().iphi(),tauJetsD->at(i).rank());
1169  }
1170  }
1171  for(unsigned int i=0; i < forJetsD->size(); i++) {
1172  if(forJetsD->at(i).bx() == GCTTrigBx_) {
1173  if(forJetsD->at(i).rank()>0) forJet_errorEtEtaPhiData_->Fill(forJetsD->at(i).regionId().ieta(),forJetsD->at(i).regionId().iphi(),forJetsD->at(i).rank());
1174  }
1175  }
1176 
1177  //now the emulator candidates
1178  for(unsigned int i=0; i < cenJetsE->size(); i++) {
1179  if(cenJetsE->at(i).bx() == EmuTrigBx_) {
1180  if(cenJetsE->at(i).rank()>0) cenJet_errorEtEtaPhiEmu_->Fill(cenJetsE->at(i).regionId().ieta(),cenJetsE->at(i).regionId().iphi(),cenJetsE->at(i).rank());
1181  }
1182  }
1183  for(unsigned int i=0; i < tauJetsE->size(); i++) {
1184  if(tauJetsE->at(i).bx() == EmuTrigBx_) {
1185  if(tauJetsE->at(i).rank()>0) tauJet_errorEtEtaPhiEmu_->Fill(tauJetsE->at(i).regionId().ieta(),tauJetsE->at(i).regionId().iphi(),tauJetsE->at(i).rank());
1186  }
1187  }
1188  for(unsigned int i=0; i < forJetsE->size(); i++) {
1189  if(forJetsE->at(i).bx() == EmuTrigBx_) {
1190  if(forJetsE->at(i).rank()>0) forJet_errorEtEtaPhiEmu_->Fill(forJetsE->at(i).regionId().ieta(),forJetsE->at(i).regionId().iphi(),forJetsE->at(i).rank());
1191  }
1192  }
1193 
1194 }
1195 
1196 void
1197 GctErrorAnalyzer::plotHFRingSums(const edm::Handle<L1GctHFRingEtSumsCollection> &hfRingSumsD, const edm::Handle<L1GctHFRingEtSumsCollection> &hfRingSumsE) {
1198 
1199  for(unsigned int i=0; i < hfRingSumsD->size(); i++) {
1200  if(doGCTMBx_ || hfRingSumsD->at(i).bx() == GCTTrigBx_) {
1201  //there are 4 rings - just fill the histograms
1202  hfRingSumD_1pos_->Fill(hfRingSumsD->at(i).etSum(0));
1203  hfRingSumD_1neg_->Fill(hfRingSumsD->at(i).etSum(1));
1204  hfRingSumD_2pos_->Fill(hfRingSumsD->at(i).etSum(2));
1205  hfRingSumD_2neg_->Fill(hfRingSumsD->at(i).etSum(3));
1206  }
1207  }
1208 
1209  for(unsigned int i=0; i < hfRingSumsE->size(); i++) {
1210  if(doEmuMBx_ || hfRingSumsE->at(i).bx() == EmuTrigBx_) {
1211  hfRingSumE_1pos_->Fill(hfRingSumsE->at(i).etSum(0));
1212  hfRingSumE_1neg_->Fill(hfRingSumsE->at(i).etSum(1));
1213  hfRingSumE_2pos_->Fill(hfRingSumsE->at(i).etSum(2));
1214  hfRingSumE_2neg_->Fill(hfRingSumsE->at(i).etSum(3));
1215  }
1216  }
1217 }
1218 
1219 void
1220 GctErrorAnalyzer::plotHFBitCounts(const edm::Handle<L1GctHFBitCountsCollection> &hfBitCountsD, const edm::Handle<L1GctHFBitCountsCollection> &hfBitCountsE) {
1221 
1222  for(unsigned int i=0; i < hfBitCountsD->size(); i++) {
1223  if(doGCTMBx_ || hfBitCountsD->at(i).bx() == GCTTrigBx_) {
1224  //there are 4 rings - just fill the histograms
1225  hfBitCountD_1pos_->Fill(hfBitCountsD->at(i).bitCount(0));
1226  hfBitCountD_1neg_->Fill(hfBitCountsD->at(i).bitCount(1));
1227  hfBitCountD_2pos_->Fill(hfBitCountsD->at(i).bitCount(2));
1228  hfBitCountD_2neg_->Fill(hfBitCountsD->at(i).bitCount(3));
1229  }
1230  }
1231  for(unsigned int i=0; i < hfBitCountsE->size(); i++) {
1232  if(doEmuMBx_ || hfBitCountsE->at(i).bx() == EmuTrigBx_) {
1233  hfBitCountE_1pos_->Fill(hfBitCountsE->at(i).bitCount(0));
1234  hfBitCountE_1neg_->Fill(hfBitCountsE->at(i).bitCount(1));
1235  hfBitCountE_2pos_->Fill(hfBitCountsE->at(i).bitCount(2));
1236  hfBitCountE_2neg_->Fill(hfBitCountsE->at(i).bitCount(3));
1237  }
1238  }
1239 }
1240 
1241 void
1242 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) {
1243 
1244  std::string errorDirName = "err_";
1245  if(isRingSumError) errorDirName.append("R");
1246  if(isBitCountError) errorDirName.append("B");
1247  std::stringstream caseNumber;
1248  caseNumber << eventNumber;
1249  errorDirName.append(caseNumber.str());
1250  TFileDirectory errorDir = errorHistCat.at(2).mkdir(errorDirName);
1251 
1252  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1253  TH2I *errorRegionFgEtaPhi_ = errorDir.make<TH2I>("errorRegionFgEtaPhi", "errorRegionFgEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1254  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1255 
1256  TH1I *errorHFRingSumD_1pos_ = errorDir.make<TH1I>("errorHFRingSumD_1+", "errorHFRingSumD_1+;Rank;Number of Events", 8, -0.5, 7.5);
1257  TH1I *errorHFRingSumD_2pos_ = errorDir.make<TH1I>("errorHFRingSumD_2+", "errorHFRingSumD_2+;Rank;Number of Events", 8, -0.5, 7.5);
1258  TH1I *errorHFRingSumD_1neg_ = errorDir.make<TH1I>("errorHFRingSumD_1-", "errorHFRingSumD_1-;Rank;Number of Events", 8, -0.5, 7.5);
1259  TH1I *errorHFRingSumD_2neg_ = errorDir.make<TH1I>("errorHFRingSumD_2-", "errorHFRingSumD_2-;Rank;Number of Events", 8, -0.5, 7.5);
1260  TH1I *errorHFRingSumE_1pos_ = errorDir.make<TH1I>("errorHFRingSumE_1+", "errorHFRingSumE_1+;Rank;Number of Events", 8, -0.5, 7.5);
1261  TH1I *errorHFRingSumE_2pos_ = errorDir.make<TH1I>("errorHFRingSumE_2+", "errorHFRingSumE_2+;Rank;Number of Events", 8, -0.5, 7.5);
1262  TH1I *errorHFRingSumE_1neg_ = errorDir.make<TH1I>("errorHFRingSumE_1-", "errorHFRingSumE_1-;Rank;Number of Events", 8, -0.5, 7.5);
1263  TH1I *errorHFRingSumE_2neg_ = errorDir.make<TH1I>("errorHFRingSumE_2-", "errorHFRingSumE_2-;Rank;Number of Events", 8, -0.5, 7.5);
1264 
1265  TH1I *errorHFBitCountD_1pos_ = errorDir.make<TH1I>("errorHFBitCountD_1+", "errorHFBitCountD_1+;Rank;Number of Events", 8, -0.5, 7.5);
1266  TH1I *errorHFBitCountD_2pos_ = errorDir.make<TH1I>("errorHFBitCountD_2+", "errorHFBitCountD_2+;Rank;Number of Events", 8, -0.5, 7.5);
1267  TH1I *errorHFBitCountD_1neg_ = errorDir.make<TH1I>("errorHFBitCountD_1-", "errorHFBitCountD_1-;Rank;Number of Events", 8, -0.5, 7.5);
1268  TH1I *errorHFBitCountD_2neg_ = errorDir.make<TH1I>("errorHFBitCountD_2-", "errorHFBitCountD_2-;Rank;Number of Events", 8, -0.5, 7.5);
1269  TH1I *errorHFBitCountE_1pos_ = errorDir.make<TH1I>("errorHFBitCountE_1+", "errorHFBitCountE_1+;Rank;Number of Events", 8, -0.5, 7.5);
1270  TH1I *errorHFBitCountE_2pos_ = errorDir.make<TH1I>("errorHFBitCountE_2+", "errorHFBitCountE_2+;Rank;Number of Events", 8, -0.5, 7.5);
1271  TH1I *errorHFBitCountE_1neg_ = errorDir.make<TH1I>("errorHFBitCountE_1-", "errorHFBitCountE_1-;Rank;Number of Events", 8, -0.5, 7.5);
1272  TH1I *errorHFBitCountE_2neg_ = errorDir.make<TH1I>("errorHFBitCountE_2-", "errorHFBitCountE_2-;Rank;Number of Events", 8, -0.5, 7.5);
1273 
1274  for(unsigned int i=0;i<caloRegions->size();i++) {
1275  if(caloRegions->at(i).bx() == RCTTrigBx_) {
1276  if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
1277  if(caloRegions->at(i).fineGrain()) errorRegionFgEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
1278  if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
1279  }
1280  }
1281 
1282  for(unsigned int i=0; i < hfRingSumsD->size(); i++) {
1283  if(hfRingSumsD->at(i).bx() == GCTTrigBx_) {
1284  errorHFRingSumD_1pos_->Fill(hfRingSumsD->at(i).etSum(0));
1285  errorHFRingSumD_1neg_->Fill(hfRingSumsD->at(i).etSum(1));
1286  errorHFRingSumD_2pos_->Fill(hfRingSumsD->at(i).etSum(2));
1287  errorHFRingSumD_2neg_->Fill(hfRingSumsD->at(i).etSum(3));
1288  }
1289  }
1290  for(unsigned int i=0; i < hfRingSumsE->size(); i++) {
1291  if(hfRingSumsE->at(i).bx() == EmuTrigBx_) {
1292  errorHFRingSumE_1pos_->Fill(hfRingSumsE->at(i).etSum(0));
1293  errorHFRingSumE_1neg_->Fill(hfRingSumsE->at(i).etSum(1));
1294  errorHFRingSumE_2pos_->Fill(hfRingSumsE->at(i).etSum(2));
1295  errorHFRingSumE_2neg_->Fill(hfRingSumsE->at(i).etSum(3));
1296  }
1297  }
1298 
1299  for(unsigned int i=0; i < hfBitCountsD->size(); i++) {
1300  if(hfBitCountsD->at(i).bx() == GCTTrigBx_) {
1301  errorHFBitCountD_1pos_->Fill(hfBitCountsD->at(i).bitCount(0));
1302  errorHFBitCountD_1neg_->Fill(hfBitCountsD->at(i).bitCount(1));
1303  errorHFBitCountD_2pos_->Fill(hfBitCountsD->at(i).bitCount(2));
1304  errorHFBitCountD_2neg_->Fill(hfBitCountsD->at(i).bitCount(3));
1305  }
1306  }
1307  for(unsigned int i=0; i < hfBitCountsE->size(); i++) {
1308  if(hfBitCountsE->at(i).bx() == EmuTrigBx_) {
1309  errorHFBitCountE_1pos_->Fill(hfBitCountsE->at(i).bitCount(0));
1310  errorHFBitCountE_1neg_->Fill(hfBitCountsE->at(i).bitCount(1));
1311  errorHFBitCountE_2pos_->Fill(hfBitCountsE->at(i).bitCount(2));
1312  errorHFBitCountE_2neg_->Fill(hfBitCountsE->at(i).bitCount(3));
1313  }
1314  }
1315 }
1316 
1317 void
1318 GctErrorAnalyzer::plotTotalE(const edm::Handle<L1GctEtTotalCollection> &totalEtD, const edm::Handle<L1GctEtTotalCollection> &totalEtE) {
1319 
1320  for(unsigned int i=0; i < totalEtD->size(); i++) {
1321  if(doGCTMBx_ || totalEtD->at(i).bx() == GCTTrigBx_) {
1322  totalEtD_Of_->Fill(totalEtD->at(i).overFlow());
1323  if(!totalEtD->at(i).overFlow()) totalEtD_->Fill(totalEtD->at(i).et());
1324  }
1325  }
1326  for(unsigned int i=0; i < totalEtE->size(); i++) {
1327  if(doEmuMBx_ || totalEtE->at(i).bx() == EmuTrigBx_) {
1328  totalEtE_Of_->Fill(totalEtE->at(i).overFlow());
1329  if(!totalEtE->at(i).overFlow()) totalEtE_->Fill(totalEtE->at(i).et());
1330  }
1331  }
1332 }
1333 
1334 void
1335 GctErrorAnalyzer::plotTotalH(const edm::Handle<L1GctEtHadCollection> &totalHtD, const edm::Handle<L1GctEtHadCollection> &totalHtE) {
1336 
1337  for(unsigned int i=0; i < totalHtD->size(); i++) {
1338  if(doGCTMBx_ || totalHtD->at(i).bx() == GCTTrigBx_) {
1339  totalHtD_Of_->Fill(totalHtD->at(i).overFlow());
1340  if(!totalHtD->at(i).overFlow()) totalHtD_->Fill(totalHtD->at(i).et());
1341  }
1342  }
1343  for(unsigned int i=0; i < totalHtE->size(); i++) {
1344  if(doEmuMBx_ || totalHtE->at(i).bx() == EmuTrigBx_) {
1345  totalHtE_Of_->Fill(totalHtE->at(i).overFlow());
1346  if(!totalHtE->at(i).overFlow()) totalHtE_->Fill(totalHtE->at(i).et());
1347  }
1348  }
1349 }
1350 
1351 void
1352 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) {
1353 
1354  std::string errorDirName = "err_";
1355  if(isTotalEError) errorDirName.append("E");
1356  if(isTotalHError) errorDirName.append("H");
1357  std::stringstream caseNumber;
1358  caseNumber << eventNumber;
1359  errorDirName.append(caseNumber.str());
1360  TFileDirectory errorDir = errorHistCat.at(3).mkdir(errorDirName);
1361 
1362  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1363  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1364  TH1I *errorTotalEtD_ = errorDir.make<TH1I>("errorTotalEtD", "errorTotalEtD;E_{T};Number of Events", 1024, -0.5, 1023.5);
1365  TH1I *errorTotalEtD_Of_ = errorDir.make<TH1I>("errorTotalEtD_Of", "errorTotalEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1366  TH1I *errorTotalEtE_ = errorDir.make<TH1I>("errorTotalEtE", "errorTotalEtE;E_{T};Number of Events", 1024, -0.5, 1023.5);
1367  TH1I *errorTotalEtE_Of_ = errorDir.make<TH1I>("errorTotalEtE_Of", "errorTotalEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1368  TH1I *errorTotalHtD_ = errorDir.make<TH1I>("errorTotalHtD", "errorTotalHtD;E_{T};Number of Events", 1024, -0.5, 1023.5);
1369  TH1I *errorTotalHtD_Of_ = errorDir.make<TH1I>("errorTotalHtD_Of", "errorTotalHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1370  TH1I *errorTotalHtE_ = errorDir.make<TH1I>("errorTotalHtE", "errorTotalHtE;E_{T};Number of Events", 1024, -0.5, 1023.5);
1371  TH1I *errorTotalHtE_Of_ = errorDir.make<TH1I>("errorTotalHtE_Of", "errorTotalHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1372 
1373  //plot the region ET and OF bits
1374  for(unsigned int i=0;i<caloRegions->size();i++) {
1375  if(caloRegions->at(i).bx() == RCTTrigBx_) {
1376  if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
1377  if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
1378  }
1379  }
1380  //now plot the error ET
1381  for(unsigned int i=0; i < totalEtD->size(); i++) {
1382  if(totalEtD->at(i).bx() == GCTTrigBx_) {
1383  errorTotalEtD_Of_->Fill(totalEtD->at(i).overFlow());
1384  if(!totalEtD->at(i).overFlow()) errorTotalEtD_->Fill(totalEtD->at(i).et());
1385  }
1386  }
1387  for(unsigned int i=0; i < totalEtE->size(); i++) {
1388  if(totalEtE->at(i).bx() == EmuTrigBx_) {
1389  errorTotalEtE_Of_->Fill(totalEtE->at(i).overFlow());
1390  if(!totalEtE->at(i).overFlow()) errorTotalEtE_->Fill(totalEtE->at(i).et());
1391  }
1392  }
1393  //and now the error HT
1394  for(unsigned int i=0; i < totalHtD->size(); i++) {
1395  if(totalHtD->at(i).bx() == GCTTrigBx_) {
1396  errorTotalHtD_Of_->Fill(totalHtD->at(i).overFlow());
1397  if(!totalHtD->at(i).overFlow()) errorTotalHtD_->Fill(totalHtD->at(i).et());
1398  }
1399  }
1400  for(unsigned int i=0; i < totalHtE->size(); i++) {
1401  if(totalHtE->at(i).bx() == EmuTrigBx_) {
1402  errorTotalHtE_Of_->Fill(totalHtE->at(i).overFlow());
1403  if(!totalHtE->at(i).overFlow()) errorTotalHtE_->Fill(totalHtE->at(i).et());
1404  }
1405  }
1406 }
1407 
1408 void
1409 GctErrorAnalyzer::plotMissingEt(const edm::Handle<L1GctEtMissCollection> &missingEtD, const edm::Handle<L1GctEtMissCollection> &missingEtE) {
1410 
1411  for(unsigned int i=0; i < missingEtD->size(); i++) {
1412  if(doGCTMBx_ || missingEtD->at(i).bx() == GCTTrigBx_) {
1413  missingEtD_Of_->Fill(missingEtD->at(i).overFlow());
1414  if(!missingEtD->at(i).overFlow() && missingEtD->at(i).et()>0) {
1415  missingEtD_->Fill(missingEtD->at(i).et());
1416  missingEtD_Phi_->Fill(missingEtD->at(i).phi());
1417  }
1418  }
1419  }
1420 
1421  for(unsigned int i=0; i < missingEtE->size(); i++) {
1422  if(doEmuMBx_ || missingEtE->at(i).bx() == EmuTrigBx_) {
1423  missingEtE_Of_->Fill(missingEtE->at(i).overFlow());
1424  if(!missingEtE->at(i).overFlow() && missingEtE->at(i).et()) {
1425  missingEtE_->Fill(missingEtE->at(i).et());
1426  missingEtE_Phi_->Fill(missingEtE->at(i).phi());
1427  }
1428  }
1429  }
1430 }
1431 
1432 void
1433 GctErrorAnalyzer::plotMissingHt(const edm::Handle<L1GctHtMissCollection> &missingHtD, const edm::Handle<L1GctHtMissCollection> &missingHtE) {
1434 
1435  for(unsigned int i=0; i < missingHtD->size(); i++) {
1436  if(doGCTMBx_ || missingHtD->at(i).bx() == GCTTrigBx_) {
1437  missingHtD_Of_->Fill(missingHtD->at(i).overFlow());
1438  if(!missingHtD->at(i).overFlow() && missingHtD->at(i).et()>0) {
1439  missingHtD_->Fill(missingHtD->at(i).et());
1440  missingHtD_Phi_->Fill(missingHtD->at(i).phi());
1441  }
1442  }
1443  }
1444 
1445  for(unsigned int i=0; i < missingHtE->size(); i++) {
1446  if(doEmuMBx_ || missingHtE->at(i).bx() == EmuTrigBx_) {
1447  missingHtE_Of_->Fill(missingHtE->at(i).overFlow());
1448  if(!missingHtE->at(i).overFlow() && missingHtE->at(i).et()>0) {
1449  missingHtE_->Fill(missingHtE->at(i).et());
1450  missingHtE_Phi_->Fill(missingHtE->at(i).phi());
1451  }
1452  }
1453  }
1454 }
1455 
1456 void
1457 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> &intJetsE, const edm::Handle<L1GctInternHtMissCollection> intMissingHtD) {
1458 
1459  std::string errorDirName = "err_";
1460  if(isMissingEError) errorDirName.append("E");
1461  if(isMissingHError) errorDirName.append("H");
1462 
1463  //added 05.03.2010 to highlight overflow errors in the missing energy sum calculation
1464  for(unsigned int i=0; i < missingHtE->size(); i++) {
1465  if(missingHtE->at(i).bx() == EmuTrigBx_) {
1466  for(unsigned int j=0; j < missingHtD->size(); j++) {
1467  if(missingHtD->at(j).bx() == GCTTrigBx_) {
1468  if(missingHtD->at(j).overFlow() != missingHtE->at(i).overFlow()) errorDirName.append("O");
1469  }
1470  }
1471  }
1472  }
1473 
1474  std::stringstream caseNumber;
1475  caseNumber << eventNumber;
1476  errorDirName.append(caseNumber.str());
1477  TFileDirectory errorDir = errorHistCat.at(4).mkdir(errorDirName);
1478 
1479  TH2I *errorRegionEtEtaPhi_ = errorDir.make<TH2I>("errorRegionEtEtaPhi", "errorRegionEtEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1480  TH2I *errorRegionOfEtaPhi_ = errorDir.make<TH2I>("errorRegionOfEtaPhi", "errorRegionOfEtaPhi;#eta (GCT Units);#phi (GCT Units)", 22, -0.5, 21.5, 18, -0.5, 17.5);
1481  TH1I *errorMissingEtD_ = errorDir.make<TH1I>("errorMissingEtD", "errorMissingEtD;E_{T};Number of Events", 1024, -0.5, 1023.5);
1482  TH1I *errorMissingEtD_Of_ = errorDir.make<TH1I>("errorMissingEtD_Of", "errorMissingEtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1483  TH1I *errorMissingEtD_Phi_= errorDir.make<TH1I>("errorMissingEtD_Phi", "errorMissingEtD_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
1484  TH1I *errorMissingEtE_ = errorDir.make<TH1I>("errorMissingEtE", "errorMissingEtE;E_{T};Number of Events", 1024, -0.5, 1023.5);
1485  TH1I *errorMissingEtE_Of_ = errorDir.make<TH1I>("errorMissingEtE_Of", "errorMissingEtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1486  TH1I *errorMissingEtE_Phi_ = errorDir.make<TH1I>("errorMissingEtE_Phi", "errorMissingEtE_Phi;Missing E_{T} #phi;Number of Events", 72, -0.5, 71.5);
1487  TH1I *errorMissingHtD_ = errorDir.make<TH1I>("errorMissingHtD", "errorMissingHtD;H_{T};Number of Events", 1024, -0.5, 1023.5);
1488  TH1I *errorMissingHtD_Of_ = errorDir.make<TH1I>("errorMissingHtD_Of", "errorMissingHtD_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1489  TH1I *errorMissingHtD_Phi_= errorDir.make<TH1I>("errorMissingHtD_Phi", "errorMissingHtD_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
1490  TH1I *errorMissingHtE_ = errorDir.make<TH1I>("errorMissingHtE", "errorMissingHtE;H_{T};Number of Events", 1024, -0.5, 1023.5);
1491  TH1I *errorMissingHtE_Of_ = errorDir.make<TH1I>("errorMissingHtE_Of", "errorMissingHtE_Of;Overflow Bit Status;Number of Events", 2, -0.5, 1.5);
1492  TH1I *errorMissingHtE_Phi_ = errorDir.make<TH1I>("errorMissingHtE_Phi", "errorMissingHtE_Phi;Missing H_{T} #phi;Number of Events", 72, -0.5, 71.5);
1493 
1494  //Added 19.03.2010 to provide additional information in the case of missingHt failures
1495  //1. The MHT from both wheel inputs (i.e. the leaf cards)
1496  //2. The emulator jet et,eta,phi for all jets found in an event
1497  if(doExtraMissingHTDebug_) {
1498  if(checkCollections(intMissingHtD, GCT_INT_HTMISS_QUANTA, "Internal Missing Ht Data")) {
1499 
1500  TH1I *errorMissingHtD_HtXPosLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtXPosLeaf1", "missingHtD;Missing H_{T} X PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
1501  TH1I *errorMissingHtD_HtXPosLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtXPosLeaf2", "missingHtD;Missing H_{T} X PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
1502  TH1I *errorMissingHtD_HtXPosLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtXPosLeaf3", "missingHtD;Missing H_{T} X PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
1503  TH1I *errorMissingHtD_HtXNegLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtXNegLeaf1", "missingHtD;Missing H_{T} X NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
1504  TH1I *errorMissingHtD_HtXNegLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtXNegLeaf2", "missingHtD;Missing H_{T} X NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
1505  TH1I *errorMissingHtD_HtXNegLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtXNegLeaf3", "missingHtD;Missing H_{T} X NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);
1506 
1507  TH1I *errorMissingHtD_HtYPosLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtYPosLeaf1", "missingHtD;Missing H_{T} Y PosLeaf1;Number of Events", 4096, -2048.5, 2047.5);
1508  TH1I *errorMissingHtD_HtYPosLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtYPosLeaf2", "missingHtD;Missing H_{T} Y PosLeaf2;Number of Events", 4096, -2048.5, 2047.5);
1509  TH1I *errorMissingHtD_HtYPosLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtYPosLeaf3", "missingHtD;Missing H_{T} Y PosLeaf3;Number of Events", 4096, -2048.5, 2047.5);
1510  TH1I *errorMissingHtD_HtYNegLeaf1 = errorDir.make<TH1I>("errorMissingHtD_HtYNegLeaf1", "missingHtD;Missing H_{T} Y NegLeaf1;Number of Events", 4096, -2048.5, 2047.5);
1511  TH1I *errorMissingHtD_HtYNegLeaf2 = errorDir.make<TH1I>("errorMissingHtD_HtYNegLeaf2", "missingHtD;Missing H_{T} Y NegLeaf2;Number of Events", 4096, -2048.5, 2047.5);
1512  TH1I *errorMissingHtD_HtYNegLeaf3 = errorDir.make<TH1I>("errorMissingHtD_HtYNegLeaf3", "missingHtD;Missing H_{T} Y NegLeaf3;Number of Events", 4096, -2048.5, 2047.5);
1513 
1514  for(unsigned int i=0; i<intMissingHtD->size(); i++) {
1515  if(intMissingHtD->at(i).bx() == GCTTrigBx_) {
1516  if(!intMissingHtD->at(i).overflow()) {
1517 
1518  if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXPosLeaf1->Fill(intMissingHtD->at(i).htx());
1519  if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXPosLeaf2->Fill(intMissingHtD->at(i).htx());
1520  if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXPosLeaf3->Fill(intMissingHtD->at(i).htx());
1521  if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXNegLeaf1->Fill(intMissingHtD->at(i).htx());
1522  if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXNegLeaf2->Fill(intMissingHtD->at(i).htx());
1523  if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHtx()) errorMissingHtD_HtXNegLeaf3->Fill(intMissingHtD->at(i).htx());
1524 
1525  if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYPosLeaf1->Fill(intMissingHtD->at(i).hty());
1526  if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYPosLeaf2->Fill(intMissingHtD->at(i).hty());
1527  if(intMissingHtD->at(i).capBlock() == 0x301 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYPosLeaf3->Fill(intMissingHtD->at(i).hty());
1528  if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 0 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYNegLeaf1->Fill(intMissingHtD->at(i).hty());
1529  if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 1 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYNegLeaf2->Fill(intMissingHtD->at(i).hty());
1530  if(intMissingHtD->at(i).capBlock() == 0x701 && intMissingHtD->at(i).capIndex() == 2 && intMissingHtD->at(i).isThereHty()) errorMissingHtD_HtYNegLeaf3->Fill(intMissingHtD->at(i).hty());
1531  }
1532  }
1533  }
1534  }
1535  }
1536 
1537  if(checkCollections(intJetsE, NUM_INT_JETS, "Intermediate Jets Emulator")) {
1538  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);
1539 
1540  for(unsigned int i=0; i < intJetsE->size(); i++) {
1541  if(intJetsE->at(i).bx() == EmuTrigBx_) {
1542  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());
1543  }
1544  }
1545  }
1546 
1547  for(unsigned int i=0;i<caloRegions->size();i++) {
1548  if(caloRegions->at(i).bx() == RCTTrigBx_) {
1549  if(caloRegions->at(i).et()>0) errorRegionEtEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi(),caloRegions->at(i).et());
1550  if(caloRegions->at(i).overFlow()) errorRegionOfEtaPhi_->Fill(caloRegions->at(i).gctEta(),caloRegions->at(i).gctPhi());
1551  }
1552  }
1553 
1554  //plot the data candidates relating to this mismatch
1555  for(unsigned int i=0; i < missingEtD->size(); i++) {
1556  if(missingEtD->at(i).bx() == GCTTrigBx_) {
1557  errorMissingEtD_Of_->Fill(missingEtD->at(i).overFlow());
1558  if(!missingEtD->at(i).overFlow()) {
1559  errorMissingEtD_->Fill(missingEtD->at(i).et());
1560  errorMissingEtD_Phi_->Fill(missingEtD->at(i).phi());
1561  }
1562  }
1563  }
1564  for(unsigned int i=0; i < missingHtD->size(); i++) {
1565  if(missingHtD->at(i).bx() == GCTTrigBx_) {
1566  errorMissingHtD_Of_->Fill(missingHtD->at(i).overFlow());
1567  if(!missingHtD->at(i).overFlow()) {
1568  errorMissingHtD_->Fill(missingHtD->at(i).et());
1569  errorMissingHtD_Phi_->Fill(missingHtD->at(i).phi());
1570  }
1571  }
1572  }
1573  //and now for the emulator candidates
1574  for(unsigned int i=0; i < missingEtE->size(); i++) {
1575  if(missingEtE->at(i).bx() == EmuTrigBx_) {
1576  errorMissingEtE_Of_->Fill(missingEtE->at(i).overFlow());
1577  if(!missingEtE->at(i).overFlow()) {
1578  errorMissingEtE_->Fill(missingEtE->at(i).et());
1579  errorMissingEtE_Phi_->Fill(missingEtE->at(i).phi());
1580  }
1581  }
1582  }
1583  for(unsigned int i=0; i < missingHtE->size(); i++) {
1584  if(missingHtE->at(i).bx() == EmuTrigBx_) {
1585  errorMissingHtE_Of_->Fill(missingHtE->at(i).overFlow());
1586  if(!missingHtE->at(i).overFlow()) { //to see what values the emulator outputs despite the o/f bit being set comment out this statement
1587  errorMissingHtE_->Fill(missingHtE->at(i).et());
1588  errorMissingHtE_Phi_->Fill(missingHtE->at(i).phi());
1589  }
1590  }
1591  }
1592 }
1593 
1594 //define this as a plug-in
1595 DEFINE_FWK_MODULE(GctErrorAnalyzer);
GctErrorAnalyzer::plotHFErrors
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)
Definition: GctErrorAnalyzer.cc:1242
GctErrorAnalyzer::eventNumber
unsigned int eventNumber
Definition: GctErrorAnalyzer.cc:249
edm::EventID::event
EventNumber_t event() const
Definition: EventID.h:44
i
int i
Definition: DBlmapReader.cc:9
GctErrorAnalyzer::tauJetD_GlobalError_Rank_
TH1I * tauJetD_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:173
GctErrorAnalyzer::plotMissingHt
void plotMissingHt(const edm::Handle< L1GctHtMissCollection > &missingHtD, const edm::Handle< L1GctHtMissCollection > &missingHtE)
Definition: GctErrorAnalyzer.cc:1433
compareTotalEnergySums::doCompare
bool doCompare(TH1I *errorFlag_hist_)
Definition: compareTotalEnergySums.h:51
GctErrorAnalyzer::MBxInfo
GctErrorAnalyzerMBxInfo MBxInfo
Definition: GctErrorAnalyzer.cc:132
GctErrorAnalyzer::nonIsoEgE_GlobalError_Rank_
TH1I * nonIsoEgE_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:154
GctErrorAnalyzer::isoEgD_GlobalError_EtEtaPhi_
TH2I * isoEgD_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:145
GctErrorAnalyzer::forJetE_GlobalError_EtEtaPhi_
TH2I * forJetE_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:186
GctErrorAnalyzer::plotHFBitCounts
void plotHFBitCounts(const edm::Handle< L1GctHFBitCountsCollection > &hfBitCountsD, const edm::Handle< L1GctHFBitCountsCollection > &hfBitCountsE)
Definition: GctErrorAnalyzer.cc:1220
GctErrorAnalyzer::cenJetD_GlobalError_EtEtaPhi_
TH2I * cenJetD_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:165
GCT_SUMS_QUANTA
const unsigned int GCT_SUMS_QUANTA
Definition: GctErrorAnalyzerDefinitions.h:5
GctErrorAnalyzer::sortJets
static bool sortJets(const jetData &jet1, const jetData &jet2)
Definition: GctErrorAnalyzer.cc:1105
GctErrorAnalyzer::plotForJets
void plotForJets(const edm::Handle< L1GctJetCandCollection > &data, const edm::Handle< L1GctJetCandCollection > &emu)
Definition: GctErrorAnalyzer.cc:1010
GctErrorAnalyzer::plotJetErrors
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)
Definition: GctErrorAnalyzer.cc:1129
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
compareMissingH
compareMissingEnergySums< edm::Handle< L1GctHtMissCollection > > compareMissingH
Definition: GctErrorAnalyzer.cc:263
GctErrorAnalyzer::nonIsoEgD_GlobalError_Rank_
TH1I * nonIsoEgD_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:153
GctErrorAnalyzer::cenJetE_GlobalError_EtEtaPhi_
TH2I * cenJetE_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:166
GctErrorAnalyzer::plotCenJets
void plotCenJets(const edm::Handle< L1GctJetCandCollection > &data, const edm::Handle< L1GctJetCandCollection > &emu)
Definition: GctErrorAnalyzer.cc:962
compareEG
compareCands< edm::Handle< L1GctEmCandCollection > > compareEG
Definition: GctErrorAnalyzer.cc:258
compareRingSums::doCompare
bool doCompare(TH1I *errorFlag_hist_)
Definition: compareRingSums.cc:30
compareCands::doCompare
bool doCompare(TH1I *errorFlag_hist_, TH1I *mismatchD_Rank, TH2I *mismatchD_EtEtaPhi, TH1I *mismatchE_Rank, TH2I *mismatchE_EtEtaPhi)
Definition: compareCands.h:50
GctErrorAnalyzer::plotTotalH
void plotTotalH(const edm::Handle< L1GctEtHadCollection > &totalHtD, const edm::Handle< L1GctEtHadCollection > &totalHtE)
Definition: GctErrorAnalyzer.cc:1335
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
GctErrorAnalyzer::forJetD_GlobalError_EtEtaPhi_
TH2I * forJetD_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:185
RCT_REGION_QUANTA_LAB
const unsigned int RCT_REGION_QUANTA_LAB
Definition: GctErrorAnalyzerDefinitions.h:8
compareTotalE
compareTotalEnergySums< edm::Handle< L1GctEtTotalCollection > > compareTotalE
Definition: GctErrorAnalyzer.cc:260
GctErrorAnalyzer::plotEGErrors
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)
Definition: GctErrorAnalyzer.cc:904
GctErrorAnalyzer::plotTotalE
void plotTotalE(const edm::Handle< L1GctEtTotalCollection > &totalEtD, const edm::Handle< L1GctEtTotalCollection > &totalEtE)
Definition: GctErrorAnalyzer.cc:1318
iEvent
int iEvent
Definition: GenABIO.cc:243
GctErrorAnalyzer::plotTotalEErrors
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)
Definition: GctErrorAnalyzer.cc:1352
GctErrorAnalyzer::plotIsoEm
void plotIsoEm(const edm::Handle< L1GctEmCandCollection > &data, const edm::Handle< L1GctEmCandCollection > &emu)
Definition: GctErrorAnalyzer.cc:854
GctErrorAnalyzer::plotNonIsoEm
void plotNonIsoEm(const edm::Handle< L1GctEmCandCollection > &data, const edm::Handle< L1GctEmCandCollection > &emu)
Definition: GctErrorAnalyzer.cc:879
GctErrorAnalyzer::operator=
GctErrorAnalyzer operator=(const GctErrorAnalyzer &)
compareJets
compareCands< edm::Handle< L1GctJetCandCollection > > compareJets
Definition: GctErrorAnalyzer.cc:259
GctErrorAnalyzer::plotTauJets
void plotTauJets(const edm::Handle< L1GctJetCandCollection > &data, const edm::Handle< L1GctJetCandCollection > &emu)
Definition: GctErrorAnalyzer.cc:986
compareTotalH
compareTotalEnergySums< edm::Handle< L1GctEtHadCollection > > compareTotalH
Definition: GctErrorAnalyzer.cc:261
GctErrorAnalyzer::plotHFRingSums
void plotHFRingSums(const edm::Handle< L1GctHFRingEtSumsCollection > &data, const edm::Handle< L1GctHFRingEtSumsCollection > &emu)
Definition: GctErrorAnalyzer.cc:1197
j
int j
Definition: DBlmapReader.cc:9
GctErrorAnalyzer::plotRCTRegions
void plotRCTRegions(const edm::Handle< L1CaloRegionCollection > &caloRegions)
Definition: GctErrorAnalyzer.cc:839
GctErrorAnalyzer::cenJetE_GlobalError_Rank_
TH1I * cenJetE_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:164
GctErrorAnalyzer::plotIntJets
void plotIntJets(const edm::Handle< L1GctInternJetDataCollection > &emu)
Definition: GctErrorAnalyzer.cc:1034
GctErrorAnalyzer::emuTag_
edm::InputTag emuTag_
Definition: GctErrorAnalyzer.cc:127
GCT_OBJECT_QUANTA
const unsigned int GCT_OBJECT_QUANTA
Definition: GctErrorAnalyzerDefinitions.h:4
compareMissingE
compareMissingEnergySums< edm::Handle< L1GctEtMissCollection > > compareMissingE
Definition: GctErrorAnalyzer.cc:262
RCT_EM_OBJECT_QUANTA
const unsigned int RCT_EM_OBJECT_QUANTA
Definition: GctErrorAnalyzerDefinitions.h:9
GctErrorAnalyzer::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: GctErrorAnalyzer.cc:587
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:361
GctErrorAnalyzer::tauJetE_GlobalError_EtEtaPhi_
TH2I * tauJetE_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:176
GctErrorAnalyzer::nonIsoEgE_GlobalError_EtEtaPhi_
TH2I * nonIsoEgE_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:156
GctErrorAnalyzer::forJetE_GlobalError_Rank_
TH1I * forJetE_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:184
TFileDirectory::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileDirectory.cc:162
GctErrorAnalyzer::plotMissingEt
void plotMissingEt(const edm::Handle< L1GctEtMissCollection > &missingEtD, const edm::Handle< L1GctEtMissCollection > &missingEtE)
Definition: GctErrorAnalyzer.cc:1409
GctErrorAnalyzer::plotMissingEErrors
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)
Definition: GctErrorAnalyzer.cc:1457
GctErrorAnalyzer::cenJetD_GlobalError_Rank_
TH1I * cenJetD_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:163
GctErrorAnalyzer::isoEgE_GlobalError_EtEtaPhi_
TH2I * isoEgE_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:146
GctErrorAnalyzer::dataTag_
edm::InputTag dataTag_
Definition: GctErrorAnalyzer.cc:126
GctErrorAnalyzer::endJob
virtual void endJob()
Definition: GctErrorAnalyzer.cc:835
GctErrorAnalyzer::checkCollections
bool checkCollections(const T &collection, const unsigned int &constraint, const std::string &label)
Definition: GctErrorAnalyzer.cc:1111
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:56
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:82
GctErrorAnalyzer::forJetD_GlobalError_Rank_
TH1I * forJetD_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:183
GctErrorAnalyzer::errorHistCat
std::vector< TFileDirectory > errorHistCat
Definition: GctErrorAnalyzer.cc:246
RCT_REGION_QUANTA_P5
const unsigned int RCT_REGION_QUANTA_P5
Definition: GctErrorAnalyzerDefinitions.h:7
TFileDirectory::make
T * make() const
make new ROOT object
Definition: TFileDirectory.h:55
GctErrorAnalyzer::tauJetE_GlobalError_Rank_
TH1I * tauJetE_GlobalError_Rank_
Definition: GctErrorAnalyzer.cc:174
NUM_INT_JETS
const unsigned int NUM_INT_JETS
Definition: GctErrorAnalyzerDefinitions.h:11
GctErrorAnalyzer::nonIsoEgD_GlobalError_EtEtaPhi_
TH2I * nonIsoEgD_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:155
compareMissingEnergySums::doCompare
bool doCompare(TH1I *errorFlag_hist_)
Definition: compareMissingEnergySums.h:51
GCT_INT_HTMISS_QUANTA
const unsigned int GCT_INT_HTMISS_QUANTA
Definition: GctErrorAnalyzerDefinitions.h:6
T
long double T
Definition: Basic3DVectorLD.h:59
GctErrorAnalyzer::tauJetD_GlobalError_EtEtaPhi_
TH2I * tauJetD_GlobalError_EtEtaPhi_
Definition: GctErrorAnalyzer.cc:175
compareBitCounts::doCompare
bool doCompare(TH1I *errorFlag_hist_)
Definition: compareBitCounts.cc:30
GctErrorAnalyzer::RCT_REGION_QUANTA
const unsigned int * RCT_REGION_QUANTA
Definition: GctErrorAnalyzer.cc:251
GctErrorAnalyzer::beginJob
virtual void beginJob()
Definition: GctErrorAnalyzer.cc:829
Generated for CMSSW Reference Manual by doxygen 1.8.5