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