test
CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
L1TGlobalAnalyzer.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: L1Trigger/L1TGloba
4 // Class: L1TGlobalAnalyzer
5 //
13 //
14 // Original Author: James Brooke
15 // Created: Tue, 11 Mar 2014 14:55:45 GMT
16 //
17 // Modifying Author: Brian Winer
18 // Created: Tue, 10 Mar 2015 based off L1TCaloAnalyzer
19 //
20 
21 
22 // system include files
23 #include <memory>
24 
25 // user include files
26 #include "FWCore/Framework/interface/Frameworkfwd.h"
27 #include "FWCore/Framework/interface/EDAnalyzer.h"
28 
29 #include "FWCore/Framework/interface/Event.h"
30 #include "FWCore/Framework/interface/MakerMacros.h"
31 
32 #include "FWCore/ParameterSet/interface/ParameterSet.h"
33 
34 #include "FWCore/ServiceRegistry/interface/Service.h"
35 #include "CommonTools/UtilAlgos/interface/TFileService.h"
36 
37 #include "DataFormats/L1TGlobal/interface/GlobalAlgBlk.h"
38 #include "DataFormats/L1TGlobal/interface/GlobalExtBlk.h"
39 #include "DataFormats/L1Trigger/interface/Muon.h"
40 #include "DataFormats/L1Trigger/interface/EGamma.h"
41 #include "DataFormats/L1Trigger/interface/Tau.h"
42 #include "DataFormats/L1Trigger/interface/Jet.h"
43 #include "DataFormats/L1Trigger/interface/EtSum.h"
44 
45 #include "TH1F.h"
46 #include "TH2F.h"
47 
48 //
49 // class declaration
50 //
51 
52 namespace l1t {
53 
54 class L1TGlobalAnalyzer : public edm::EDAnalyzer {
55 public:
56  explicit L1TGlobalAnalyzer(const edm::ParameterSet&);
57  ~L1TGlobalAnalyzer();
58 
59  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
60 
61 
62 private:
63  virtual void beginJob() override;
64  virtual void analyze(const edm::Event&, const edm::EventSetup&) override;
65  virtual void endJob() override;
66 
67  //virtual void beginRun(edm::Run const&, edm::EventSetup const&) override;
68  //virtual void endRun(edm::Run const&, edm::EventSetup const&) override;
69  //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
70  //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
71 
72  // ----------member data ---------------------------
73  edm::EDGetToken m_gmuToken;
74  edm::EDGetToken m_dmxEGToken;
75  edm::EDGetToken m_dmxTauToken;
76  edm::EDGetToken m_dmxJetToken;
77  edm::EDGetToken m_dmxSumToken;
78  edm::EDGetToken m_muToken;
79  edm::EDGetToken m_egToken;
80  edm::EDGetToken m_tauToken;
81  edm::EDGetToken m_jetToken;
82  edm::EDGetToken m_sumToken;
83 
84  edm::EDGetToken m_gtAlgToken;
85  edm::EDGetToken m_emulGtAlgToken;
86  edm::EDGetToken m_emulDxAlgToken;
87 
88  bool m_dogMUs;
89  bool m_doDmxEGs;
90  bool m_doDmxTaus;
91  bool m_doDmxJets;
92  bool m_doDmxSums;
93  bool m_doMUs;
94  bool m_doEGs;
95  bool m_doTaus;
96  bool m_doJets;
97  bool m_doSums;
98 
99  bool m_doGtAlg;
100  bool m_doEmulGtAlg;
101  bool m_doEmulDxAlg;
102 
103  bool doText_;
104  bool doHistos_;
105 
106  enum ObjectType{
107  MU=0x1,
108  EG=0x2,
109  Tau=0x3,
110  Jet=0x4,
111  Sum=0x5,
112  DmxEG=0x6,
113  DmxTau=0x7,
114  DmxJet=0x8,
115  DmxSum=0x9,
116  GtAlg=0xA,
117  EmulGtAlg=0xB,
118  gMU = 0xC
119  };
120 
121  std::vector< ObjectType > types_;
122  std::vector< std::string > typeStr_;
123 
124  std::map< ObjectType, TFileDirectory > dirs_;
125  std::map< ObjectType, TH1F* > het_;
126  std::map< ObjectType, TH1F* > heta_;
127  std::map< ObjectType, TH1F* > hphi_;
128  std::map< ObjectType, TH1F* > hbx_;
129  std::map< ObjectType, TH2F* > hetaphi_;
130 
131  TFileDirectory evtDispDir_;
132  TFileDirectory algDir_;
133  TFileDirectory dmxVGtDir_;
134  TH1F* hAlgoBits_;
135  TH1F* hEmulGtAlgoBits_;
136  TH1F* hEmulDxAlgoBits_;
137  TH2F* hAlgoBitsEmulGtVsHw_;
138  TH2F* hAlgoBitsEmulDxVsHw_;
139  TH2F* hGmtVsGTMUEt_;
140  TH2F* hGmtVsGTMUEta_;
141  TH2F* hGmtVsGTMUPhi_;
142  TH2F* hDmxVsGTEGEt_;
143  TH2F* hDmxVsGTEGEta_;
144  TH2F* hDmxVsGTEGPhi_;
145  TH2F* hDmxVsGTTauEt_;
146  TH2F* hDmxVsGTTauEta_;
147  TH2F* hDmxVsGTTauPhi_;
148  TH2F* hDmxVsGTJetEt_;
149  TH2F* hDmxVsGTJetEta_;
150  TH2F* hDmxVsGTJetPhi_;
151  TH2F* hDmxVsGTSumEt_ETT_;
152  TH2F* hDmxVsGTSumEt_ETTem_;
153  TH2F* hDmxVsGTSumEt_HTT_;
154  TH2F* hDmxVsGTSumEt_ETM_;
155  TH2F* hDmxVsGTSumPhi_ETM_;
156  TH2F* hDmxVsGTSumEt_ETMHF_;
157  TH2F* hDmxVsGTSumPhi_ETMHF_;
158  TH2F* hDmxVsGTSumEt_HTM_;
159  TH2F* hDmxVsGTSumPhi_HTM_;
160  TH2F* hDmxVsGTSumEt_HFP0_;
161  TH2F* hDmxVsGTSumEt_HFM0_;
162  TH2F* hDmxVsGTSumEt_HFP1_;
163  TH2F* hDmxVsGTSumEt_HFM1_;
164 
165 };
166 
167 //
168 // constants, enums and typedefs
169 //
170 
171 //
172 // static data member definitions
173 //
174 
175 //
176 // constructors and destructor
177 //
178  L1TGlobalAnalyzer::L1TGlobalAnalyzer(const edm::ParameterSet& iConfig) :
179  doText_(iConfig.getUntrackedParameter<bool>("doText", true)),
180  doHistos_(iConfig.getUntrackedParameter<bool>("doHistos", true))
181 {
182  //now do what ever initialization is needed
183 
184  // register what you consume and keep token for later access:
185  edm::InputTag nullTag("None");
186 
187 
188  edm::InputTag gmuTag = iConfig.getParameter<edm::InputTag>("gmuToken");
189  m_gmuToken = consumes<l1t::MuonBxCollection>(gmuTag);
190  m_dogMUs = !(gmuTag==nullTag);
191 
192  edm::InputTag dmxEGTag = iConfig.getParameter<edm::InputTag>("dmxEGToken");
193  m_dmxEGToken = consumes<l1t::EGammaBxCollection>(dmxEGTag);
194  m_doDmxEGs = !(dmxEGTag==nullTag);
195 
196  edm::InputTag dmxTauTag = iConfig.getParameter<edm::InputTag>("dmxTauToken");
197  m_dmxTauToken = consumes<l1t::TauBxCollection>(dmxTauTag);
198  m_doDmxTaus = !(dmxTauTag==nullTag);
199 
200  edm::InputTag dmxJetTag = iConfig.getParameter<edm::InputTag>("dmxJetToken");
201  m_dmxJetToken = consumes<l1t::JetBxCollection>(dmxJetTag);
202  m_doDmxJets = !(dmxJetTag==nullTag);
203 
204  edm::InputTag dmxSumTag = iConfig.getParameter<edm::InputTag>("dmxEtSumToken");
205  m_dmxSumToken = consumes<l1t::EtSumBxCollection>(dmxSumTag);
206  m_doDmxSums = !(dmxSumTag==nullTag);
207 
208  edm::InputTag muTag = iConfig.getParameter<edm::InputTag>("muToken");
209  m_muToken = consumes<l1t::MuonBxCollection>(muTag);
210  m_doMUs = !(muTag==nullTag);
211 
212  edm::InputTag egTag = iConfig.getParameter<edm::InputTag>("egToken");
213  m_egToken = consumes<l1t::EGammaBxCollection>(egTag);
214  m_doEGs = !(egTag==nullTag);
215 
216  edm::InputTag tauTag = iConfig.getParameter<edm::InputTag>("tauToken");
217  m_tauToken = consumes<l1t::TauBxCollection>(tauTag);
218  m_doTaus = !(tauTag==nullTag);
219 
220  edm::InputTag jetTag = iConfig.getParameter<edm::InputTag>("jetToken");
221  m_jetToken = consumes<l1t::JetBxCollection>(jetTag);
222  m_doJets = !(jetTag==nullTag);
223 
224  edm::InputTag sumTag = iConfig.getParameter<edm::InputTag>("etSumToken");
225  m_sumToken = consumes<l1t::EtSumBxCollection>(sumTag);
226  m_doSums = !(sumTag==nullTag);
227 
228  edm::InputTag gtAlgTag = iConfig.getParameter<edm::InputTag>("gtAlgToken");
229  m_gtAlgToken = consumes<GlobalAlgBlkBxCollection>(gtAlgTag);
230  m_doGtAlg = !(gtAlgTag==nullTag);
231 
232  edm::InputTag emulGtAlgTag = iConfig.getParameter<edm::InputTag>("emulGtAlgToken");
233  m_emulGtAlgToken = consumes<GlobalAlgBlkBxCollection>(emulGtAlgTag);
234  m_doEmulGtAlg = !(emulGtAlgTag==nullTag);
235 
236  edm::InputTag emulDxAlgTag = iConfig.getParameter<edm::InputTag>("emulDxAlgToken");
237  m_emulDxAlgToken = consumes<GlobalAlgBlkBxCollection>(emulDxAlgTag);
238  m_doEmulDxAlg = !(emulDxAlgTag==nullTag);
239 
240  types_.push_back( gMU );
241  types_.push_back( DmxEG );
242  types_.push_back( DmxTau );
243  types_.push_back( DmxJet );
244  types_.push_back( DmxSum );
245  types_.push_back( MU );
246  types_.push_back( EG );
247  types_.push_back( Tau );
248  types_.push_back( Jet );
249  types_.push_back( Sum );
250 
251  typeStr_.push_back( "gmtmu" );
252  typeStr_.push_back( "dmxeg" );
253  typeStr_.push_back( "dmxtau" );
254  typeStr_.push_back( "dmxjet" );
255  typeStr_.push_back( "dmxsum" );
256  typeStr_.push_back( "mu" );
257  typeStr_.push_back( "eg" );
258  typeStr_.push_back( "tau" );
259  typeStr_.push_back( "jet" );
260  typeStr_.push_back( "sum" );
261 
262 }
263 
264 
265 L1TGlobalAnalyzer::~L1TGlobalAnalyzer()
266 {
267 
268  // do anything here that needs to be done at desctruction time
269  // (e.g. close files, deallocate resources etc.)
270 
271 }
272 
273 
274 //
275 // member functions
276 //
277 
278 // ------------ method called for each event ------------
279 void
280 L1TGlobalAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
281 {
282  using namespace edm;
283 
284  std::stringstream text;
285 
286  // get gmt Muons
287  if (m_dogMUs) {
288  Handle< BXVector<l1t::Muon> > gmuons;
289  iEvent.getByToken(m_gmuToken,gmuons);
290 
291  for ( int ibx=gmuons->getFirstBX(); ibx<=gmuons->getLastBX(); ++ibx) {
292 
293  for ( auto itr = gmuons->begin(ibx); itr != gmuons->end(ibx); ++itr ) {
294  hbx_.at(gMU)->Fill( ibx );
295  het_.at(gMU)->Fill( itr->hwPt() );
296  heta_.at(gMU)->Fill( itr->hwEta() );
297  hphi_.at(gMU)->Fill( itr->hwPhi() );
298  hetaphi_.at(gMU)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
299 
300  text << "Muon : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
301 
302  }
303 
304  }
305 
306  }
307 
308 
309  // get EG
310  if (m_doDmxEGs) {
311  Handle< BXVector<l1t::EGamma> > dmxegs;
312  iEvent.getByToken(m_dmxEGToken,dmxegs);
313 
314  for ( int ibx=dmxegs->getFirstBX(); ibx<=dmxegs->getLastBX(); ++ibx) {
315 
316  for ( auto itr = dmxegs->begin(ibx); itr != dmxegs->end(ibx); ++itr ) {
317  hbx_.at(DmxEG)->Fill( ibx );
318  het_.at(DmxEG)->Fill( itr->hwPt() );
319  heta_.at(DmxEG)->Fill( itr->hwEta() );
320  hphi_.at(DmxEG)->Fill( itr->hwPhi() );
321  hetaphi_.at(DmxEG)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
322 
323  text << "Dmx EG : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
324 
325 
326 
327  }
328 
329  }
330 
331  }
332 
333  // get tau
334  if (m_doDmxTaus) {
335  Handle< BXVector<l1t::Tau> > dmxtaus;
336  iEvent.getByToken(m_dmxTauToken,dmxtaus);
337 
338  for ( int ibx=dmxtaus->getFirstBX(); ibx<=dmxtaus->getLastBX(); ++ibx) {
339 
340  for ( auto itr = dmxtaus->begin(ibx); itr != dmxtaus->end(ibx); ++itr ) {
341  hbx_.at(DmxTau)->Fill( ibx );
342  het_.at(DmxTau)->Fill( itr->hwPt() );
343  heta_.at(DmxTau)->Fill( itr->hwEta() );
344  hphi_.at(DmxTau)->Fill( itr->hwPhi() );
345  hetaphi_.at(DmxTau)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
346 
347  text << "Dmx Tau : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
348 
349  }
350 
351  }
352 
353  }
354 
355  // get jet
356  if (m_doDmxJets) {
357  Handle< BXVector<l1t::Jet> > dmxjets;
358  iEvent.getByToken(m_dmxJetToken,dmxjets);
359 
360  for ( int ibx=dmxjets->getFirstBX(); ibx<=dmxjets->getLastBX(); ++ibx) {
361 
362  for ( auto itr = dmxjets->begin(ibx); itr != dmxjets->end(ibx); ++itr ) {
363  hbx_.at(DmxJet)->Fill( ibx );
364  het_.at(DmxJet)->Fill( itr->hwPt() );
365  heta_.at(DmxJet)->Fill( itr->hwEta() );
366  hphi_.at(DmxJet)->Fill( itr->hwPhi() );
367  hetaphi_.at(DmxJet)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
368 
369  text << "Dmx Jet : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
370 
371  }
372 
373  }
374 
375  }
376 
377  // get sums
378  if (m_doDmxSums) {
379  Handle< BXVector<l1t::EtSum> > dmxsums;
380  iEvent.getByToken(m_dmxSumToken,dmxsums);
381 
382  for ( int ibx=dmxsums->getFirstBX(); ibx<=dmxsums->getLastBX(); ++ibx) {
383 
384  for ( auto itr = dmxsums->begin(ibx); itr != dmxsums->end(ibx); ++itr ) {
385  hbx_.at(DmxSum)->Fill( ibx );
386  het_.at(DmxSum)->Fill( itr->hwPt() );
387  heta_.at(DmxSum)->Fill( itr->hwEta() );
388  hphi_.at(DmxSum)->Fill( itr->hwPhi() );
389  hetaphi_.at(DmxSum)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
390 
391  text << "Dmx Sum : " << " type=" << itr->getType() << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
392 
393  }
394 
395  }
396 
397  }
398 
399 
400  // get Muons
401  if (m_doMUs) {
402  Handle< BXVector<l1t::Muon> > muons;
403  iEvent.getByToken(m_muToken,muons);
404 
405  for ( int ibx=muons->getFirstBX(); ibx<=muons->getLastBX(); ++ibx) {
406 
407  for ( auto itr = muons->begin(ibx); itr != muons->end(ibx); ++itr ) {
408  hbx_.at(MU)->Fill( ibx );
409  het_.at(MU)->Fill( itr->hwPt() );
410  heta_.at(MU)->Fill( itr->hwEta() );
411  hphi_.at(MU)->Fill( itr->hwPhi() );
412  hetaphi_.at(MU)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
413 
414  text << "Muon : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
415 
416  }
417 
418  }
419 
420  }
421 
422 
423 
424  // get EG
425  if (m_doEGs) {
426  Handle< BXVector<l1t::EGamma> > egs;
427  iEvent.getByToken(m_egToken,egs);
428 
429  for ( int ibx=egs->getFirstBX(); ibx<=egs->getLastBX(); ++ibx) {
430 
431  for ( auto itr = egs->begin(ibx); itr != egs->end(ibx); ++itr ) {
432  hbx_.at(EG)->Fill( ibx );
433  het_.at(EG)->Fill( itr->hwPt() );
434  heta_.at(EG)->Fill( itr->hwEta() );
435  hphi_.at(EG)->Fill( itr->hwPhi() );
436  hetaphi_.at(EG)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
437 
438  text << "EG : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
439 
440  }
441 
442  }
443 
444  }
445 
446  // get tau
447  if (m_doTaus) {
448  Handle< BXVector<l1t::Tau> > taus;
449  iEvent.getByToken(m_tauToken,taus);
450 
451  for ( int ibx=taus->getFirstBX(); ibx<=taus->getLastBX(); ++ibx) {
452 
453  for ( auto itr = taus->begin(ibx); itr != taus->end(ibx); ++itr ) {
454  hbx_.at(Tau)->Fill( ibx );
455  het_.at(Tau)->Fill( itr->hwPt() );
456  heta_.at(Tau)->Fill( itr->hwEta() );
457  hphi_.at(Tau)->Fill( itr->hwPhi() );
458  hetaphi_.at(Tau)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
459 
460  text << "Tau : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
461 
462  }
463 
464  }
465 
466  }
467 
468  // get jet
469  if (m_doJets) {
470  Handle< BXVector<l1t::Jet> > jets;
471  iEvent.getByToken(m_jetToken,jets);
472 
473  for ( int ibx=jets->getFirstBX(); ibx<=jets->getLastBX(); ++ibx) {
474 
475  for ( auto itr = jets->begin(ibx); itr != jets->end(ibx); ++itr ) {
476  hbx_.at(Jet)->Fill( ibx );
477  het_.at(Jet)->Fill( itr->hwPt() );
478  heta_.at(Jet)->Fill( itr->hwEta() );
479  hphi_.at(Jet)->Fill( itr->hwPhi() );
480  hetaphi_.at(Jet)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
481 
482  text << "Jet : " << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
483 
484  }
485 
486  }
487 
488  }
489 
490  // get sums
491  if (m_doSums) {
492  Handle< BXVector<l1t::EtSum> > sums;
493  iEvent.getByToken(m_sumToken,sums);
494 
495  for ( int ibx=sums->getFirstBX(); ibx<=sums->getLastBX(); ++ibx) {
496 
497  for ( auto itr = sums->begin(ibx); itr != sums->end(ibx); ++itr ) {
498 
499  hbx_.at(Sum)->Fill( ibx );
500  het_.at(Sum)->Fill( itr->hwPt() );
501  heta_.at(Sum)->Fill( itr->hwEta() );
502  hphi_.at(Sum)->Fill( itr->hwPhi() );
503  hetaphi_.at(Sum)->Fill( itr->hwEta(), itr->hwPhi(), itr->hwPt() );
504  text << "Sum : " << " type=" << itr->getType() << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi() << std::endl;
505  }
506 
507  }
508 
509  }
510 
511  //Algorithm Bits
512  if (m_doGtAlg) {
513  Handle< BXVector<GlobalAlgBlk> > algs;
514  iEvent.getByToken(m_gtAlgToken,algs);
515 
516  for ( int ibx=algs->getFirstBX(); ibx<=algs->getLastBX(); ++ibx) {
517 
518  for ( auto itr = algs->begin(ibx); itr != algs->end(ibx); ++itr ) {
519 
520  for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
521  if(itr->getAlgoDecisionFinal(algBit)) {
522  hAlgoBits_->Fill(algBit);
523  text << "HW Fired Alg Bit : " << algBit << std::endl;
524  }
525  }
526  }
527 
528  }
529 
530  }
531 
532  //Algorithm Bits (Emulation seeded by GT input)
533  if (m_doEmulGtAlg) {
534  Handle< BXVector<GlobalAlgBlk> > emulGtAlgs;
535  iEvent.getByToken(m_emulGtAlgToken,emulGtAlgs);
536 
537  for ( int ibx=emulGtAlgs->getFirstBX(); ibx<=emulGtAlgs->getLastBX(); ++ibx) {
538 
539  for ( auto itr = emulGtAlgs->begin(ibx); itr != emulGtAlgs->end(ibx); ++itr ) {
540 
541  for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
542  if(itr->getAlgoDecisionFinal(algBit)) {
543  hEmulGtAlgoBits_->Fill(algBit);
544  text << "Emul w/ GTInput Fired Alg Bit : " << algBit << std::endl;
545  }
546  }
547  }
548 
549  }
550 
551  }
552 
553  //Algorithm Bits (Emulation seeded by Demux Output)
554  if (m_doEmulDxAlg) {
555  Handle< BXVector<GlobalAlgBlk> > emulDxAlgs;
556  iEvent.getByToken(m_emulDxAlgToken,emulDxAlgs);
557 
558  for ( int ibx=emulDxAlgs->getFirstBX(); ibx<=emulDxAlgs->getLastBX(); ++ibx) {
559 
560  for ( auto itr = emulDxAlgs->begin(ibx); itr != emulDxAlgs->end(ibx); ++itr ) {
561 
562  for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
563  if(itr->getAlgoDecisionFinal(algBit)) {
564  hEmulDxAlgoBits_->Fill(algBit);
565  text << "Emul w/ Demux output Fired Alg Bit : " << algBit << std::endl;
566  }
567  }
568  }
569 
570  }
571 
572  }
573 
574 
575  // Mu (gmt vs GT)
576  if (m_doMUs & m_dogMUs) {
577  Handle< BXVector<l1t::Muon> > mus;
578  iEvent.getByToken(m_muToken,mus);
579 
580  Handle< BXVector<l1t::Muon> > gmtmus;
581  iEvent.getByToken(m_gmuToken,gmtmus);
582 
583  for ( int ibx=mus->getFirstBX(); ibx<=mus->getLastBX(); ++ibx) {
584 
585  // Cycle through all GT MUs
586  for (unsigned int igtMU=0; igtMU<mus->size(ibx); igtMU++) {
587 
588  double gtMUEt = mus->at(ibx,igtMU).hwPt();
589  double gmtMUEt = 0.0;
590  if(gmtmus->size(ibx)>igtMU) gmtMUEt = gmtmus->at(ibx,igtMU).hwPt();
591  hGmtVsGTMUEt_->Fill(gtMUEt,gmtMUEt);
592 
593  double gtMUEta = mus->at(ibx,igtMU).hwEta();
594  double gmtMUEta = 0.0;
595  if(gmtmus->size(ibx)>igtMU) gmtMUEta = gmtmus->at(ibx,igtMU).hwEta();
596  hGmtVsGTMUEta_->Fill(gtMUEta,gmtMUEta);
597 
598  double gtMUPhi = mus->at(ibx,igtMU).hwPhi();
599  double gmtMUPhi = 0.0;
600  if(gmtmus->size(ibx)>igtMU) gmtMUPhi = gmtmus->at(ibx,igtMU).hwPhi();
601  hGmtVsGTMUPhi_->Fill(gtMUPhi,gmtMUPhi);
602 
603 
604 
605  }
606  // if there are extra MUs in the dmx record them
607  for (unsigned int igmtMU=mus->size(ibx); igmtMU<gmtmus->size(ibx); igmtMU++) {
608 
609 
610  double gtMUEt = 0.0; //no GT jet exists
611  double gmtMUEt = gmtmus->at(ibx,igmtMU).hwPt();
612  hGmtVsGTMUEt_->Fill(gtMUEt,gmtMUEt);
613 
614  double gtMUEta = 0.0;
615  double gmtMUEta = gmtmus->at(ibx,igmtMU).hwEta();
616  hGmtVsGTMUEta_->Fill(gtMUEta,gmtMUEta);
617 
618  double gtMUPhi = 0.0;
619  double gmtMUPhi = gmtmus->at(ibx,igmtMU).hwPhi();
620  hGmtVsGTMUPhi_->Fill(gtMUPhi,gmtMUPhi);
621 
622  }
623 
624  }
625 
626  }
627 
628 
629  // EG (Dmx vs GT)
630  if (m_doEGs & m_doDmxEGs) {
631  Handle< BXVector<l1t::EGamma> > egs;
632  iEvent.getByToken(m_egToken,egs);
633 
634  Handle< BXVector<l1t::EGamma> > dmxegs;
635  iEvent.getByToken(m_dmxEGToken,dmxegs);
636 
637  for ( int ibx=egs->getFirstBX(); ibx<=egs->getLastBX(); ++ibx) {
638 
639  // Cycle through all GT egs
640  for (unsigned int igtEG=0; igtEG<egs->size(ibx); igtEG++) {
641 
642  double gtEGEt = egs->at(ibx,igtEG).hwPt();
643  double dmxEGEt = 0.0;
644  if(dmxegs->size(ibx)>igtEG) dmxEGEt = dmxegs->at(ibx,igtEG).hwPt();
645  hDmxVsGTEGEt_->Fill(gtEGEt,dmxEGEt);
646 
647  double gtEGEta = egs->at(ibx,igtEG).hwEta();
648  double dmxEGEta = 0.0;
649  if(dmxegs->size(ibx)>igtEG) dmxEGEta = dmxegs->at(ibx,igtEG).hwEta();
650  hDmxVsGTEGEta_->Fill(gtEGEta,dmxEGEta);
651 
652  double gtEGPhi = egs->at(ibx,igtEG).hwPhi();
653  double dmxEGPhi = 0.0;
654  if(dmxegs->size(ibx)>igtEG) dmxEGPhi = dmxegs->at(ibx,igtEG).hwPhi();
655  hDmxVsGTEGPhi_->Fill(gtEGPhi,dmxEGPhi);
656 
657 
658 
659  }
660  // if there are extra egs in the dmx record them
661  for (unsigned int idmEG=egs->size(ibx); idmEG<dmxegs->size(ibx); idmEG++) {
662 
663 
664  double gtEGEt = 0.0; //no GT jet exists
665  double dmxEGEt = dmxegs->at(ibx,idmEG).hwPt();
666  hDmxVsGTEGEt_->Fill(gtEGEt,dmxEGEt);
667 
668  double gtEGEta = 0.0;
669  double dmxEGEta = dmxegs->at(ibx,idmEG).hwEta();
670  hDmxVsGTEGEta_->Fill(gtEGEta,dmxEGEta);
671 
672  double gtEGPhi = 0.0;
673  double dmxEGPhi = dmxegs->at(ibx,idmEG).hwPhi();
674  hDmxVsGTEGPhi_->Fill(gtEGPhi,dmxEGPhi);
675 
676  }
677 
678  }
679 
680  }
681 
682 
683  // Tau (Dmx vs GT)
684  if (m_doTaus & m_doDmxTaus) {
685  Handle< BXVector<l1t::Tau> > taus;
686  iEvent.getByToken(m_tauToken,taus);
687 
688  Handle< BXVector<l1t::Tau> > dmxtaus;
689  iEvent.getByToken(m_dmxTauToken,dmxtaus);
690 
691  for ( int ibx=taus->getFirstBX(); ibx<=taus->getLastBX(); ++ibx) {
692 
693  // Cycle through all GT taus
694  for (unsigned int igtTau=0; igtTau<taus->size(ibx); igtTau++) {
695 
696  double gtTauEt = taus->at(ibx,igtTau).hwPt();
697  double dmxTauEt = 0.0;
698  if(dmxtaus->size(ibx)>igtTau) dmxTauEt = dmxtaus->at(ibx,igtTau).hwPt();
699  hDmxVsGTTauEt_->Fill(gtTauEt,dmxTauEt);
700 
701  double gtTauEta = taus->at(ibx,igtTau).hwEta();
702  double dmxTauEta = 0.0;
703  if(dmxtaus->size(ibx)>igtTau) dmxTauEta = dmxtaus->at(ibx,igtTau).hwEta();
704  hDmxVsGTTauEta_->Fill(gtTauEta,dmxTauEta);
705 
706  double gtTauPhi = taus->at(ibx,igtTau).hwPhi();
707  double dmxTauPhi = 0.0;
708  if(dmxtaus->size(ibx)>igtTau) dmxTauPhi = dmxtaus->at(ibx,igtTau).hwPhi();
709  hDmxVsGTTauPhi_->Fill(gtTauPhi,dmxTauPhi);
710 
711 
712 
713  }
714  // if there are extra taus in the dmx record them
715  for (unsigned int idmTau=taus->size(ibx); idmTau<dmxtaus->size(ibx); idmTau++) {
716 
717 
718  double gtTauEt = 0.0; //no GT jet exists
719  double dmxTauEt = dmxtaus->at(ibx,idmTau).hwPt();
720  hDmxVsGTTauEt_->Fill(gtTauEt,dmxTauEt);
721 
722  double gtTauEta = 0.0;
723  double dmxTauEta = dmxtaus->at(ibx,idmTau).hwEta();
724  hDmxVsGTTauEta_->Fill(gtTauEta,dmxTauEta);
725 
726  double gtTauPhi = 0.0;
727  double dmxTauPhi = dmxtaus->at(ibx,idmTau).hwPhi();
728  hDmxVsGTTauPhi_->Fill(gtTauPhi,dmxTauPhi);
729 
730  }
731 
732  }
733 
734  }
735 
736 
737 
738  // Jets (Dmx vs GT)
739  if (m_doJets & m_doDmxJets) {
740  Handle< BXVector<l1t::Jet> > jets;
741  iEvent.getByToken(m_jetToken,jets);
742 
743  Handle< BXVector<l1t::Jet> > dmxjets;
744  iEvent.getByToken(m_dmxJetToken,dmxjets);
745 
746  for ( int ibx=jets->getFirstBX(); ibx<=jets->getLastBX(); ++ibx) {
747 
748  // Cycle through all GT jets
749  for (unsigned int igtJ=0; igtJ<jets->size(ibx); igtJ++) {
750 
751  double gtJetEt = jets->at(ibx,igtJ).hwPt();
752  double dmxJetEt = 0.0;
753  if(dmxjets->size(ibx)>igtJ) dmxJetEt = dmxjets->at(ibx,igtJ).hwPt();
754  hDmxVsGTJetEt_->Fill(gtJetEt,dmxJetEt);
755 
756  double gtJetEta = jets->at(ibx,igtJ).hwEta();
757  double dmxJetEta = 0.0;
758  if(dmxjets->size(ibx)>igtJ) dmxJetEta = dmxjets->at(ibx,igtJ).hwEta();
759  hDmxVsGTJetEta_->Fill(gtJetEta,dmxJetEta);
760 
761  double gtJetPhi = jets->at(ibx,igtJ).hwPhi();
762  double dmxJetPhi = 0.0;
763  if(dmxjets->size(ibx)>igtJ) dmxJetPhi = dmxjets->at(ibx,igtJ).hwPhi();
764  hDmxVsGTJetPhi_->Fill(gtJetPhi,dmxJetPhi);
765 
766 
767 
768  }
769  // if there are extra jets in the dmx record them
770  for (unsigned int idmJ=jets->size(ibx); idmJ<dmxjets->size(ibx); idmJ++) {
771 
772 
773  double gtJetEt = 0.0; //no GT jet exists
774  double dmxJetEt = dmxjets->at(ibx,idmJ).hwPt();
775  hDmxVsGTJetEt_->Fill(gtJetEt,dmxJetEt);
776 
777  double gtJetEta = 0.0;
778  double dmxJetEta = dmxjets->at(ibx,idmJ).hwEta();
779  hDmxVsGTJetEta_->Fill(gtJetEta,dmxJetEta);
780 
781  double gtJetPhi = 0.0;
782  double dmxJetPhi = dmxjets->at(ibx,idmJ).hwPhi();
783  hDmxVsGTJetPhi_->Fill(gtJetPhi,dmxJetPhi);
784 
785  }
786 
787  }
788 
789  }
790 
791  // Sums (Dmx vs GT)
792  if (m_doSums & m_doDmxSums) {
793  Handle< BXVector<l1t::EtSum> > sums;
794  iEvent.getByToken(m_sumToken,sums);
795 
796  Handle< BXVector<l1t::EtSum> > dmxSums;
797  iEvent.getByToken(m_dmxSumToken,dmxSums);
798 
799  for ( int ibx=sums->getFirstBX(); ibx<=sums->getLastBX(); ++ibx) {
800 
801  // Cycle through all GT sums
802  for (unsigned int igtS=0; igtS<sums->size(ibx); igtS++) {
803 
804  double gtSumEt = sums->at(ibx,igtS).hwPt();
805  double dmxSumEt = 0.0;
806  if(dmxSums->size(ibx)>igtS) dmxSumEt = dmxSums->at(ibx,igtS).hwPt();
807 
808  double gtSumPhi = sums->at(ibx,igtS).hwPhi();
809  double dmxSumPhi = 0.0;
810  if(dmxSums->size(ibx)>igtS) dmxSumPhi = dmxSums->at(ibx,igtS).hwPhi();
811 
812  if(sums->at(ibx,igtS).getType() == dmxSums->at(ibx,igtS).getType()) {
813  switch(sums->at(ibx,igtS).getType()) {
814  case l1t::EtSum::EtSumType::kTotalEt:
815  hDmxVsGTSumEt_ETT_->Fill(gtSumEt,dmxSumEt);
816 
817  break;
818  case l1t::EtSum::EtSumType::kTotalEtEm:
819  hDmxVsGTSumEt_ETTem_->Fill(gtSumEt,dmxSumEt);
820 
821  break;
822  case l1t::EtSum::EtSumType::kTotalHt:
823  hDmxVsGTSumEt_HTT_->Fill(gtSumEt,dmxSumEt);
824 
825  break;
826  case l1t::EtSum::EtSumType::kMissingEt:
827  hDmxVsGTSumEt_ETM_->Fill(gtSumEt,dmxSumEt);
828  hDmxVsGTSumPhi_ETM_->Fill(gtSumPhi,dmxSumPhi);
829  break;
830  case l1t::EtSum::EtSumType::kMissingEtHF:
831  hDmxVsGTSumEt_ETMHF_->Fill(gtSumEt,dmxSumEt);
832  hDmxVsGTSumPhi_ETMHF_->Fill(gtSumPhi,dmxSumPhi);
833  break;
834  case l1t::EtSum::EtSumType::kMissingHt:
835  hDmxVsGTSumEt_HTM_->Fill(gtSumEt,dmxSumEt);
836  hDmxVsGTSumPhi_HTM_->Fill(gtSumPhi,dmxSumPhi);
837  break;
838  case l1t::EtSum::EtSumType::kMinBiasHFP0:
839  hDmxVsGTSumEt_HFP0_->Fill(gtSumEt,dmxSumEt);
840  break;
841  case l1t::EtSum::EtSumType::kMinBiasHFM0:
842  hDmxVsGTSumEt_HFM0_->Fill(gtSumEt,dmxSumEt);
843  break;
844  case l1t::EtSum::EtSumType::kMinBiasHFP1:
845  hDmxVsGTSumEt_HFP1_->Fill(gtSumEt,dmxSumEt);
846  break;
847  case l1t::EtSum::EtSumType::kMinBiasHFM1:
848  hDmxVsGTSumEt_HFM1_->Fill(gtSumEt,dmxSumEt);
849  break;
850  default:
851  break;
852  }
853  } else {
854  text << "WARNING: EtSum Types do not line up between DeMux and uGT " << std::endl;
855  }
856  }
857  // if there are extra sumss in the dmx record them...should not be any...but let's check
858  for (unsigned int idmS=sums->size(ibx); idmS<dmxSums->size(ibx); idmS++) {
859 
860 
861  double gtSumEt = -1.0; //no GT jet exists
862  double dmxSumEt = dmxSums->at(ibx,idmS).hwPt();
863 
864  double gtSumPhi = -1.0;
865  double dmxSumPhi = dmxSums->at(ibx,idmS).hwPhi();
866 
867  switch(dmxSums->at(ibx,idmS).getType()) {
868  case l1t::EtSum::EtSumType::kTotalEt:
869  hDmxVsGTSumEt_ETT_->Fill(gtSumEt,dmxSumEt);
870 
871  break;
872  case l1t::EtSum::EtSumType::kTotalEtEm:
873  hDmxVsGTSumEt_ETTem_->Fill(gtSumEt,dmxSumEt);
874 
875  break;
876  case l1t::EtSum::EtSumType::kTotalHt:
877  hDmxVsGTSumEt_HTT_->Fill(gtSumEt,dmxSumEt);
878 
879  break;
880  case l1t::EtSum::EtSumType::kMissingEt:
881  hDmxVsGTSumEt_ETM_->Fill(gtSumEt,dmxSumEt);
882  hDmxVsGTSumPhi_ETM_->Fill(gtSumPhi,dmxSumPhi);
883  break;
884  case l1t::EtSum::EtSumType::kMissingEtHF:
885  hDmxVsGTSumEt_ETMHF_->Fill(gtSumEt,dmxSumEt);
886  hDmxVsGTSumPhi_ETMHF_->Fill(gtSumPhi,dmxSumPhi);
887  break;
888  case l1t::EtSum::EtSumType::kMissingHt:
889  hDmxVsGTSumEt_HTM_->Fill(gtSumEt,dmxSumEt);
890  hDmxVsGTSumPhi_HTM_->Fill(gtSumPhi,dmxSumPhi);
891  break;
892  default:
893  break;
894  }
895 
896  }
897 
898  }
899 
900  }
901 
902 
903  //Algorithm Bits (Emulation vs HW)
904  if (m_doGtAlg && m_doEmulGtAlg) {
905  Handle< BXVector<GlobalAlgBlk> > hwalgs;
906  iEvent.getByToken(m_gtAlgToken,hwalgs);
907 
908  Handle< BXVector<GlobalAlgBlk> > emulAlgs;
909  iEvent.getByToken(m_emulGtAlgToken,emulAlgs);
910 
911 
912  //for ( int ibx=hwalgs->getFirstBX(); ibx<=hwalgs->getLastBX(); ++ibx) {
913  int ibx=0;
914 
915  auto itr = hwalgs->begin(ibx);
916  auto itr_emul = emulAlgs->begin(ibx);
917 
918  for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
919  bool hw = itr->getAlgoDecisionFinal(algBit);
920  bool em = itr_emul->getAlgoDecisionFinal(algBit);
921  if(hw & em) {
922  hAlgoBitsEmulGtVsHw_->Fill(algBit,algBit);
923  }else if(hw & !em) {
924  hAlgoBitsEmulGtVsHw_->Fill(algBit,-1.0);
925  text << "WARNING: HW Fnd Alg Bit " << algBit << " but emulation did not " << std::endl;
926  }else if(!hw & em) {
927  hAlgoBitsEmulGtVsHw_->Fill(-1.0,algBit);
928  text << "WARNING: Emul. Fnd Alg Bit " << algBit << " but hardware did not " << std::endl;
929  }
930  }
931 
932  // }
933 
934  }
935 
936  //Algorithm Bits (Emulation vs HW)
937  if (m_doGtAlg && m_doEmulDxAlg) {
938  Handle< BXVector<GlobalAlgBlk> > hwalgs;
939  iEvent.getByToken(m_gtAlgToken,hwalgs);
940 
941  Handle< BXVector<GlobalAlgBlk> > emulAlgs;
942  iEvent.getByToken(m_emulDxAlgToken,emulAlgs);
943 
944 
945  //for ( int ibx=hwalgs->getFirstBX(); ibx<=hwalgs->getLastBX(); ++ibx) {
946  int ibx=0;
947 
948  auto itr = hwalgs->begin(ibx);
949  auto itr_emul = emulAlgs->begin(ibx);
950 
951  for(int algBit=0; algBit<128; algBit++) { //Fix Me: Should access size of algo vector...need method in GlobalAlgBlk class
952  bool hw = itr->getAlgoDecisionFinal(algBit);
953  bool em = itr_emul->getAlgoDecisionFinal(algBit);
954  if(hw & em) {
955  hAlgoBitsEmulDxVsHw_->Fill(algBit,algBit);
956  }else if(hw & !em) {
957  hAlgoBitsEmulDxVsHw_->Fill(algBit,-1.0);
958  }else if(!hw & em) {
959  hAlgoBitsEmulDxVsHw_->Fill(-1.0,algBit);
960  }
961  }
962 
963  // }
964 
965  }
966 
967 
968 
969 
970  if (doText_) edm::LogInfo("L1TGlobalEvents") << text.str();
971 
972 }
973 
974 
975 
976 // ------------ method called once each job just before starting event loop ------------
977 void
978 L1TGlobalAnalyzer::beginJob()
979 {
980 
981  edm::Service<TFileService> fs;
982 
983  auto itr = types_.cbegin();
984  auto str = typeStr_.cbegin();
985 
986  for (; itr!=types_.end(); ++itr, ++str ) {
987 
988  if (*itr==Jet || *itr==DmxJet || *itr==Sum || *itr==DmxSum || *itr==DmxEG || *itr==EG || *itr==DmxTau || *itr==Tau) {
989  double etmax=99.5;
990  if (*itr==Jet || *itr==DmxJet || *itr==Sum || *itr==DmxSum) etmax=499.5;
991 
992  dirs_.insert( std::pair< ObjectType, TFileDirectory >(*itr, fs->mkdir(*str) ) );
993 
994  het_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("et", "", 500, -0.5, etmax) ));
995 
996  hbx_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("bx", "", 11, -5.5, 5.5) ));
997 
998 
999  heta_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("eta", "", 229, -114.5, 114.5) ));
1000  hphi_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("phi", "", 144, -0.5, 143.5) ));
1001  hetaphi_.insert( std::pair< ObjectType, TH2F* >(*itr, dirs_.at(*itr).make<TH2F>("etaphi", "", 229, -114.5, 114.5, 144, -0.5, 143.5) ));
1002  } else if( *itr==MU || *itr==gMU) {
1003  double etmax = 511.5;
1004  dirs_.insert( std::pair< ObjectType, TFileDirectory >(*itr, fs->mkdir(*str) ) );
1005 
1006  het_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("et", "", 512, -0.5, etmax) ));
1007 
1008  hbx_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("bx", "", 11, -5.5, 5.5) ));
1009 
1010 
1011  heta_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("eta", "", 549, -224.5, 224.5) ));
1012  hphi_.insert( std::pair< ObjectType, TH1F* >(*itr, dirs_.at(*itr).make<TH1F>("phi", "", 576, -0.5, 575.5) ));
1013  hetaphi_.insert( std::pair< ObjectType, TH2F* >(*itr, dirs_.at(*itr).make<TH2F>("etaphi", "", 549, -224.5, 224.5, 576, -0.5, 575.5) ));
1014 
1015  }
1016 
1017 
1018 
1019  }
1020 
1021  algDir_ = fs->mkdir("Algorithms");
1022  hAlgoBits_ = algDir_.make<TH1F>("hAlgoBits","Algorithm Bits",100, -0.5,99.5);
1023  hEmulGtAlgoBits_ = algDir_.make<TH1F>("hEmulGtAlgoBits","GT Emulated Algorithm Bits",100, -0.5,99.5);
1024  hAlgoBitsEmulGtVsHw_ = algDir_.make<TH2F>("hAlgoBitsEmulGtVsHw","Algorithm Bits (GT) Emulation vs Hardware",129, -1.5,127.5,129,-1.5,127.5);
1025  hEmulDxAlgoBits_ = algDir_.make<TH1F>("hEmulDxAlgoBits","Dx Emulated Algorithm Bits",100, -0.5,99.5);
1026  hAlgoBitsEmulDxVsHw_ = algDir_.make<TH2F>("hAlgoBitsEmulDxVsHw","Algorithm Bits (Dx) Emulation vs Hardware",129, -1.5,127.5,129,-1.5,127.5);
1027 
1028  dmxVGtDir_ = fs->mkdir("SourceVsGT");
1029 
1030  hGmtVsGTMUEt_ = dmxVGtDir_.make<TH2F>("hGmtVsGTMUEt", "Gmt MU Et versus GT MU Et", 512,-0.5,511.5,512,-0.5,511.5);
1031  hGmtVsGTMUEta_ = dmxVGtDir_.make<TH2F>("hGmtVsGTMUEta","Gmt MU Eta versus GT MU Eta",549, -224.5, 224.5,549, -224.5, 224.5);
1032  hGmtVsGTMUPhi_ = dmxVGtDir_.make<TH2F>("hGmtVsGTMUPhi","Gmt MU Phi versus GT MU Phi",576, -0.5, 575.5,576, -0.5, 575.5);
1033 
1034  hDmxVsGTEGEt_ = dmxVGtDir_.make<TH2F>("hDmxVsGTEGEt","Dmx EG Et versus GT EG Et", 500,-0.5,499.5,500,-0.5,499.5);
1035  hDmxVsGTEGEta_ = dmxVGtDir_.make<TH2F>("hDmxVsGTEGEta","Dmx EG Eta versus GT EG Eta",229,-114.5,114.5,229,-114.5,114.5);
1036  hDmxVsGTEGPhi_ = dmxVGtDir_.make<TH2F>("hDmxVsGTEGPhi","Dmx EG Phi versus GT EG Phi",144,-0.5,143.5,144,-0.5,143.5);
1037 
1038  hDmxVsGTTauEt_ = dmxVGtDir_.make<TH2F>("hDmxVsGTTauEt","Dmx Tau Et versus GT Tau Et", 500,-0.5,499.5,500,-0.5,499.5);
1039  hDmxVsGTTauEta_ = dmxVGtDir_.make<TH2F>("hDmxVsGTTauEta","Dmx Tau Eta versus GT Tau Eta",229,-114.5,114.5,229,-114.5,114.5);
1040  hDmxVsGTTauPhi_ = dmxVGtDir_.make<TH2F>("hDmxVsGTTauPhi","Dmx Tau Phi versus GT Tau Phi",144,-0.5,143.5,144,-0.5,143.5);
1041 
1042  hDmxVsGTJetEt_ = dmxVGtDir_.make<TH2F>("hDmxVsGTJetEt","Dmx Jet Et versus GT Jet Et", 500,-0.5,499.5,500,-0.5,499.5);
1043  hDmxVsGTJetEta_ = dmxVGtDir_.make<TH2F>("hDmxVsGTJetEta","Dmx Jet Eta versus GT Jet Eta",229,-114.5,114.5,229,-114.5,114.5);
1044  hDmxVsGTJetPhi_ = dmxVGtDir_.make<TH2F>("hDmxVsGTJetPhi","Dmx Jet Phi versus GT Jet Phi",144,-0.5,143.5,144,-0.5,143.5);
1045 
1046  hDmxVsGTSumEt_ETT_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETT","Dmx ETT versus GT ETT",256,-0.5,2047.5,256,-0.5,2047.5);
1047  hDmxVsGTSumEt_ETTem_= dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETTem","Dmx ETTem versus GT ETTem",256,-0.5,2047.5,256,-0.5,2047.5);
1048  hDmxVsGTSumEt_HTT_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HTT","Dmx HTT versus GT HTT",256,-0.5,2047.5,256,-0.5,2047.5);
1049  hDmxVsGTSumEt_ETM_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETM","Dmx ETM versus GT ETM",500,-0.5,499.5,500,-0.5,499.5);
1050  hDmxVsGTSumPhi_ETM_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumPhi_ETM","Dmx ETM Phi versus GT ETM Phi",144,-0.5,143.5,144,-0.5,143.5);
1051  hDmxVsGTSumEt_ETMHF_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETMHF","Dmx ETMHF versus GT ETMHF",500,-0.5,499.5,500,-0.5,499.5);
1052  hDmxVsGTSumPhi_ETMHF_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumPhi_ETMHF","Dmx ETMHF Phi versus GT ETMHF Phi",144,-0.5,143.5,144,-0.5,143.5);
1053  hDmxVsGTSumEt_HTM_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HTM","Dmx HTM versus GT HTM",500,-0.5,499.5,500,-0.5,499.5);
1054  hDmxVsGTSumPhi_HTM_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumPhi_HTM","Dmx HTM Phi versus GT HTM Phi",144,-0.5,143.5,144,-0.5,143.5);
1055 
1056  hDmxVsGTSumEt_HFP0_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFP0","Dmx versus GT HFP0",16,-0.5,15.5,16,-0.5,15.5);
1057  hDmxVsGTSumEt_HFM0_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFM0","Dmx versus GT HFM0",16,-0.5,15.5,16,-0.5,15.5);
1058  hDmxVsGTSumEt_HFP1_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFP1","Dmx versus GT HFP1",16,-0.5,15.5,16,-0.5,15.5);
1059  hDmxVsGTSumEt_HFM1_ = dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFM1","Dmx versus GT HFM1",16,-0.5,15.5,16,-0.5,15.5);
1060 
1061 
1062 
1063 }
1064 
1065 // ------------ method called once each job just after ending the event loop ------------
1066 void
1067 L1TGlobalAnalyzer::endJob()
1068 {
1069 }
1070 
1071 // ------------ method called when starting to processes a run ------------
1072 /*
1073 void
1074 L1TGlobalAnalyzer::beginRun(edm::Run const&, edm::EventSetup const&)
1075 {
1076 }
1077 */
1078 
1079 // ------------ method called when ending the processing of a run ------------
1080 /*
1081 void
1082 L1TGlobalAnalyzer::endRun(edm::Run const&, edm::EventSetup const&)
1083 {
1084 }
1085 */
1086 
1087 // ------------ method called when starting to processes a luminosity block ------------
1088 /*
1089 void
1090 L1TGlobalAnalyzer::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
1091 {
1092 }
1093 */
1094 
1095 // ------------ method called when ending the processing of a luminosity block ------------
1096 /*
1097 void
1098 L1TGlobalAnalyzer::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
1099 {
1100 }
1101 */
1102 
1103 // ------------ method fills 'descriptions' with the allowed parameters for the module ------------
1104 void
1105 L1TGlobalAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1106  //The following says we do not know what parameters are allowed so do no validation
1107  // Please change this to state exactly what you do use, even if it is no parameters
1108  edm::ParameterSetDescription desc;
1109  desc.setUnknown();
1110  descriptions.addDefault(desc);
1111 }
1112 
1113 }
1114 
1115 using namespace l1t;
1116 
1117 //define this as a plug-in
1118 DEFINE_FWK_MODULE(L1TGlobalAnalyzer);
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
l1t::L1TGlobalAnalyzer::m_emulDxAlgToken
edm::EDGetToken m_emulDxAlgToken
Definition: L1TGlobalAnalyzer.cc:86
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:462
l1t::L1TGlobalAnalyzer::m_dmxEGToken
edm::EDGetToken m_dmxEGToken
Definition: L1TGlobalAnalyzer.cc:74
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
l1t::Tau
Definition: Tau.h:16
l1t::L1TGlobalAnalyzer::hetaphi_
std::map< ObjectType, TH2F * > hetaphi_
Definition: L1TGlobalAnalyzer.cc:129
l1t::L1TGlobalAnalyzer::m_emulGtAlgToken
edm::EDGetToken m_emulGtAlgToken
Definition: L1TGlobalAnalyzer.cc:85
l1t::L1TGlobalAnalyzer::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: L1TGlobalAnalyzer.cc:280
l1t::Jet
Definition: Jet.h:16
iEvent
int iEvent
Definition: GenABIO.cc:230
edm::ConfigurationDescriptions::addDefault
void addDefault(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:99
l1t::L1TGlobalAnalyzer::hbx_
std::map< ObjectType, TH1F * > hbx_
Definition: L1TGlobalAnalyzer.cc:128
l1t::L1TGlobalAnalyzer::het_
std::map< ObjectType, TH1F * > het_
Definition: L1TGlobalAnalyzer.cc:125
fwrapper::jets
vector< PseudoJet > jets
Definition: fastjetfortran_madfks.cc:42
l1t::L1TGlobalAnalyzer::m_gmuToken
edm::EDGetToken m_gmuToken
Definition: L1TGlobalAnalyzer.cc:73
l1t::L1TGlobalAnalyzer::m_dmxTauToken
edm::EDGetToken m_dmxTauToken
Definition: L1TGlobalAnalyzer.cc:75
runonSM.text
tuple text
Definition: runonSM.py:42
TFileDirectory::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileDirectory.h:59
l1t::L1TGlobalAnalyzer::m_gtAlgToken
edm::EDGetToken m_gtAlgToken
Definition: L1TGlobalAnalyzer.cc:84
l1t::L1TGlobalAnalyzer::L1TGlobalAnalyzer
L1TGlobalAnalyzer(const edm::ParameterSet &)
Definition: L1TGlobalAnalyzer.cc:178
l1t::L1TGlobalAnalyzer::m_sumToken
edm::EDGetToken m_sumToken
Definition: L1TGlobalAnalyzer.cc:82
l1t::L1TGlobalAnalyzer::typeStr_
std::vector< std::string > typeStr_
Definition: L1TGlobalAnalyzer.cc:122
TFileService::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileService.h:69
l1t::L1TGlobalAnalyzer::beginJob
virtual void beginJob() override
Definition: L1TGlobalAnalyzer.cc:978
l1t::L1TGlobalAnalyzer::m_dmxSumToken
edm::EDGetToken m_dmxSumToken
Definition: L1TGlobalAnalyzer.cc:77
l1t::L1TGlobalAnalyzer::m_tauToken
edm::EDGetToken m_tauToken
Definition: L1TGlobalAnalyzer.cc:80
l1t::L1TGlobalAnalyzer::heta_
std::map< ObjectType, TH1F * > heta_
Definition: L1TGlobalAnalyzer.cc:126
l1t::L1TGlobalAnalyzer::hphi_
std::map< ObjectType, TH1F * > hphi_
Definition: L1TGlobalAnalyzer.cc:127
l1t::L1TGlobalAnalyzer::dirs_
std::map< ObjectType, TFileDirectory > dirs_
Definition: L1TGlobalAnalyzer.cc:124
patZpeak.muons
tuple muons
Definition: patZpeak.py:38
l1t::L1TGlobalAnalyzer::m_jetToken
edm::EDGetToken m_jetToken
Definition: L1TGlobalAnalyzer.cc:81
l1t::L1TGlobalAnalyzer::m_dmxJetToken
edm::EDGetToken m_dmxJetToken
Definition: L1TGlobalAnalyzer.cc:76
l1t::L1TGlobalAnalyzer::types_
std::vector< ObjectType > types_
Definition: L1TGlobalAnalyzer.cc:121
l1t::L1TGlobalAnalyzer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: L1TGlobalAnalyzer.cc:1105
l1t::L1TGlobalAnalyzer::endJob
virtual void endJob() override
Definition: L1TGlobalAnalyzer.cc:1067
Generated for CMSSW Reference Manual by doxygen 1.8.5