File indexing completed on 2023-03-17 11:12:09
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022 #include <memory>
0023
0024
0025 #include "FWCore/Framework/interface/Frameworkfwd.h"
0026 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0027
0028 #include "FWCore/Framework/interface/Event.h"
0029 #include "FWCore/Framework/interface/MakerMacros.h"
0030
0031 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0032
0033 #include "FWCore/ServiceRegistry/interface/Service.h"
0034 #include "CommonTools/UtilAlgos/interface/TFileService.h"
0035
0036 #include "DataFormats/L1TGlobal/interface/GlobalAlgBlk.h"
0037 #include "DataFormats/L1TGlobal/interface/GlobalExtBlk.h"
0038 #include "DataFormats/L1Trigger/interface/Muon.h"
0039 #include "DataFormats/L1Trigger/interface/EGamma.h"
0040 #include "DataFormats/L1Trigger/interface/Tau.h"
0041 #include "DataFormats/L1Trigger/interface/Jet.h"
0042 #include "DataFormats/L1Trigger/interface/EtSum.h"
0043
0044 #include "TH1F.h"
0045 #include "TH2F.h"
0046
0047
0048
0049
0050
0051 namespace l1t {
0052
0053 class L1TGlobalAnalyzer : public edm::one::EDAnalyzer<> {
0054 public:
0055 explicit L1TGlobalAnalyzer(const edm::ParameterSet&);
0056 ~L1TGlobalAnalyzer() override;
0057
0058 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0059
0060 private:
0061 void beginJob() override;
0062 void analyze(const edm::Event&, const edm::EventSetup&) override;
0063 void endJob() override;
0064
0065
0066
0067
0068
0069
0070
0071 edm::EDGetToken m_gmuToken;
0072 edm::EDGetToken m_dmxEGToken;
0073 edm::EDGetToken m_dmxTauToken;
0074 edm::EDGetToken m_dmxJetToken;
0075 edm::EDGetToken m_dmxSumToken;
0076 edm::EDGetToken m_muToken;
0077 edm::EDGetToken m_egToken;
0078 edm::EDGetToken m_tauToken;
0079 edm::EDGetToken m_jetToken;
0080 edm::EDGetToken m_sumToken;
0081
0082 edm::EDGetToken m_gtAlgToken;
0083 edm::EDGetToken m_emulGtAlgToken;
0084 edm::EDGetToken m_emulDxAlgToken;
0085
0086 bool m_dogMUs;
0087 bool m_doDmxEGs;
0088 bool m_doDmxTaus;
0089 bool m_doDmxJets;
0090 bool m_doDmxSums;
0091 bool m_doMUs;
0092 bool m_doEGs;
0093 bool m_doTaus;
0094 bool m_doJets;
0095 bool m_doSums;
0096
0097 bool m_doGtAlg;
0098 bool m_doEmulGtAlg;
0099 bool m_doEmulDxAlg;
0100
0101 bool doText_;
0102 bool doHistos_;
0103
0104 enum ObjectType {
0105 MU = 0x1,
0106 EG = 0x2,
0107 Tau = 0x3,
0108 Jet = 0x4,
0109 Sum = 0x5,
0110 DmxEG = 0x6,
0111 DmxTau = 0x7,
0112 DmxJet = 0x8,
0113 DmxSum = 0x9,
0114 GtAlg = 0xA,
0115 EmulGtAlg = 0xB,
0116 gMU = 0xC
0117 };
0118
0119 std::vector<ObjectType> types_;
0120 std::vector<std::string> typeStr_;
0121
0122 std::map<ObjectType, TFileDirectory> dirs_;
0123 std::map<ObjectType, TH1F*> het_;
0124 std::map<ObjectType, TH1F*> heta_;
0125 std::map<ObjectType, TH1F*> hphi_;
0126 std::map<ObjectType, TH1F*> hbx_;
0127 std::map<ObjectType, TH2F*> hetaphi_;
0128
0129 TFileDirectory evtDispDir_;
0130 TFileDirectory algDir_;
0131 TFileDirectory dmxVGtDir_;
0132 TH1F* hAlgoBits_;
0133 TH1F* hEmulGtAlgoBits_;
0134 TH1F* hEmulDxAlgoBits_;
0135 TH2F* hAlgoBitsEmulGtVsHw_;
0136 TH2F* hAlgoBitsEmulDxVsHw_;
0137 TH2F* hGmtVsGTMUEt_;
0138 TH2F* hGmtVsGTMUEta_;
0139 TH2F* hGmtVsGTMUPhi_;
0140 TH2F* hDmxVsGTEGEt_;
0141 TH2F* hDmxVsGTEGEta_;
0142 TH2F* hDmxVsGTEGPhi_;
0143 TH2F* hDmxVsGTTauEt_;
0144 TH2F* hDmxVsGTTauEta_;
0145 TH2F* hDmxVsGTTauPhi_;
0146 TH2F* hDmxVsGTJetEt_;
0147 TH2F* hDmxVsGTJetEta_;
0148 TH2F* hDmxVsGTJetPhi_;
0149 TH2F* hDmxVsGTSumEt_ETT_;
0150 TH2F* hDmxVsGTSumEt_ETTem_;
0151 TH2F* hDmxVsGTSumEt_HTT_;
0152 TH2F* hDmxVsGTSumEt_ETM_;
0153 TH2F* hDmxVsGTSumPhi_ETM_;
0154 TH2F* hDmxVsGTSumEt_ETMHF_;
0155 TH2F* hDmxVsGTSumPhi_ETMHF_;
0156 TH2F* hDmxVsGTSumEt_HTM_;
0157 TH2F* hDmxVsGTSumPhi_HTM_;
0158 TH2F* hDmxVsGTSumEt_HFP0_;
0159 TH2F* hDmxVsGTSumEt_HFM0_;
0160 TH2F* hDmxVsGTSumEt_HFP1_;
0161 TH2F* hDmxVsGTSumEt_HFM1_;
0162 };
0163
0164
0165
0166
0167
0168
0169
0170
0171
0172
0173
0174
0175 L1TGlobalAnalyzer::L1TGlobalAnalyzer(const edm::ParameterSet& iConfig)
0176 : doText_(iConfig.getUntrackedParameter<bool>("doText", true)),
0177 doHistos_(iConfig.getUntrackedParameter<bool>("doHistos", true)) {
0178
0179
0180
0181 edm::InputTag nullTag("None");
0182
0183 edm::InputTag gmuTag = iConfig.getParameter<edm::InputTag>("gmuToken");
0184 m_gmuToken = consumes<l1t::MuonBxCollection>(gmuTag);
0185 m_dogMUs = !(gmuTag == nullTag);
0186
0187 edm::InputTag dmxEGTag = iConfig.getParameter<edm::InputTag>("dmxEGToken");
0188 m_dmxEGToken = consumes<l1t::EGammaBxCollection>(dmxEGTag);
0189 m_doDmxEGs = !(dmxEGTag == nullTag);
0190
0191 edm::InputTag dmxTauTag = iConfig.getParameter<edm::InputTag>("dmxTauToken");
0192 m_dmxTauToken = consumes<l1t::TauBxCollection>(dmxTauTag);
0193 m_doDmxTaus = !(dmxTauTag == nullTag);
0194
0195 edm::InputTag dmxJetTag = iConfig.getParameter<edm::InputTag>("dmxJetToken");
0196 m_dmxJetToken = consumes<l1t::JetBxCollection>(dmxJetTag);
0197 m_doDmxJets = !(dmxJetTag == nullTag);
0198
0199 edm::InputTag dmxSumTag = iConfig.getParameter<edm::InputTag>("dmxEtSumToken");
0200 m_dmxSumToken = consumes<l1t::EtSumBxCollection>(dmxSumTag);
0201 m_doDmxSums = !(dmxSumTag == nullTag);
0202
0203 edm::InputTag muTag = iConfig.getParameter<edm::InputTag>("muToken");
0204 m_muToken = consumes<l1t::MuonBxCollection>(muTag);
0205 m_doMUs = !(muTag == nullTag);
0206
0207 edm::InputTag egTag = iConfig.getParameter<edm::InputTag>("egToken");
0208 m_egToken = consumes<l1t::EGammaBxCollection>(egTag);
0209 m_doEGs = !(egTag == nullTag);
0210
0211 edm::InputTag tauTag = iConfig.getParameter<edm::InputTag>("tauToken");
0212 m_tauToken = consumes<l1t::TauBxCollection>(tauTag);
0213 m_doTaus = !(tauTag == nullTag);
0214
0215 edm::InputTag jetTag = iConfig.getParameter<edm::InputTag>("jetToken");
0216 m_jetToken = consumes<l1t::JetBxCollection>(jetTag);
0217 m_doJets = !(jetTag == nullTag);
0218
0219 edm::InputTag sumTag = iConfig.getParameter<edm::InputTag>("etSumToken");
0220 m_sumToken = consumes<l1t::EtSumBxCollection>(sumTag);
0221 m_doSums = !(sumTag == nullTag);
0222
0223 edm::InputTag gtAlgTag = iConfig.getParameter<edm::InputTag>("gtAlgToken");
0224 m_gtAlgToken = consumes<GlobalAlgBlkBxCollection>(gtAlgTag);
0225 m_doGtAlg = !(gtAlgTag == nullTag);
0226
0227 edm::InputTag emulGtAlgTag = iConfig.getParameter<edm::InputTag>("emulGtAlgToken");
0228 m_emulGtAlgToken = consumes<GlobalAlgBlkBxCollection>(emulGtAlgTag);
0229 m_doEmulGtAlg = !(emulGtAlgTag == nullTag);
0230
0231 edm::InputTag emulDxAlgTag = iConfig.getParameter<edm::InputTag>("emulDxAlgToken");
0232 m_emulDxAlgToken = consumes<GlobalAlgBlkBxCollection>(emulDxAlgTag);
0233 m_doEmulDxAlg = !(emulDxAlgTag == nullTag);
0234
0235 types_.push_back(gMU);
0236 types_.push_back(DmxEG);
0237 types_.push_back(DmxTau);
0238 types_.push_back(DmxJet);
0239 types_.push_back(DmxSum);
0240 types_.push_back(MU);
0241 types_.push_back(EG);
0242 types_.push_back(Tau);
0243 types_.push_back(Jet);
0244 types_.push_back(Sum);
0245
0246 typeStr_.push_back("gmtmu");
0247 typeStr_.push_back("dmxeg");
0248 typeStr_.push_back("dmxtau");
0249 typeStr_.push_back("dmxjet");
0250 typeStr_.push_back("dmxsum");
0251 typeStr_.push_back("mu");
0252 typeStr_.push_back("eg");
0253 typeStr_.push_back("tau");
0254 typeStr_.push_back("jet");
0255 typeStr_.push_back("sum");
0256 }
0257
0258 L1TGlobalAnalyzer::~L1TGlobalAnalyzer() {
0259
0260
0261 }
0262
0263
0264
0265
0266
0267
0268 void L1TGlobalAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0269 using namespace edm;
0270
0271 std::stringstream text;
0272
0273
0274 if (m_dogMUs) {
0275 Handle<BXVector<l1t::Muon> > gmuons;
0276 iEvent.getByToken(m_gmuToken, gmuons);
0277
0278 for (int ibx = gmuons->getFirstBX(); ibx <= gmuons->getLastBX(); ++ibx) {
0279 for (auto itr = gmuons->begin(ibx); itr != gmuons->end(ibx); ++itr) {
0280 hbx_.at(gMU)->Fill(ibx);
0281 het_.at(gMU)->Fill(itr->hwPt());
0282 heta_.at(gMU)->Fill(itr->hwEtaAtVtx());
0283 hphi_.at(gMU)->Fill(itr->hwPhiAtVtx());
0284 hetaphi_.at(gMU)->Fill(itr->hwEtaAtVtx(), itr->hwPhiAtVtx(), itr->hwPt());
0285
0286 text << "Muon : "
0287 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEtaAtVtx()
0288 << " iphi=" << itr->hwPhiAtVtx() << std::endl;
0289 }
0290 }
0291 }
0292
0293
0294 if (m_doDmxEGs) {
0295 Handle<BXVector<l1t::EGamma> > dmxegs;
0296 iEvent.getByToken(m_dmxEGToken, dmxegs);
0297
0298 for (int ibx = dmxegs->getFirstBX(); ibx <= dmxegs->getLastBX(); ++ibx) {
0299 for (auto itr = dmxegs->begin(ibx); itr != dmxegs->end(ibx); ++itr) {
0300 hbx_.at(DmxEG)->Fill(ibx);
0301 het_.at(DmxEG)->Fill(itr->hwPt());
0302 heta_.at(DmxEG)->Fill(itr->hwEta());
0303 hphi_.at(DmxEG)->Fill(itr->hwPhi());
0304 hetaphi_.at(DmxEG)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0305
0306 text << "Dmx EG : "
0307 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi()
0308 << std::endl;
0309 }
0310 }
0311 }
0312
0313
0314 if (m_doDmxTaus) {
0315 Handle<BXVector<l1t::Tau> > dmxtaus;
0316 iEvent.getByToken(m_dmxTauToken, dmxtaus);
0317
0318 for (int ibx = dmxtaus->getFirstBX(); ibx <= dmxtaus->getLastBX(); ++ibx) {
0319 for (auto itr = dmxtaus->begin(ibx); itr != dmxtaus->end(ibx); ++itr) {
0320 hbx_.at(DmxTau)->Fill(ibx);
0321 het_.at(DmxTau)->Fill(itr->hwPt());
0322 heta_.at(DmxTau)->Fill(itr->hwEta());
0323 hphi_.at(DmxTau)->Fill(itr->hwPhi());
0324 hetaphi_.at(DmxTau)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0325
0326 text << "Dmx Tau : "
0327 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi()
0328 << std::endl;
0329 }
0330 }
0331 }
0332
0333
0334 if (m_doDmxJets) {
0335 Handle<BXVector<l1t::Jet> > dmxjets;
0336 iEvent.getByToken(m_dmxJetToken, dmxjets);
0337
0338 for (int ibx = dmxjets->getFirstBX(); ibx <= dmxjets->getLastBX(); ++ibx) {
0339 for (auto itr = dmxjets->begin(ibx); itr != dmxjets->end(ibx); ++itr) {
0340 hbx_.at(DmxJet)->Fill(ibx);
0341 het_.at(DmxJet)->Fill(itr->hwPt());
0342 heta_.at(DmxJet)->Fill(itr->hwEta());
0343 hphi_.at(DmxJet)->Fill(itr->hwPhi());
0344 hetaphi_.at(DmxJet)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0345
0346 text << "Dmx Jet : "
0347 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi()
0348 << std::endl;
0349 }
0350 }
0351 }
0352
0353
0354 if (m_doDmxSums) {
0355 Handle<BXVector<l1t::EtSum> > dmxsums;
0356 iEvent.getByToken(m_dmxSumToken, dmxsums);
0357
0358 for (int ibx = dmxsums->getFirstBX(); ibx <= dmxsums->getLastBX(); ++ibx) {
0359 for (auto itr = dmxsums->begin(ibx); itr != dmxsums->end(ibx); ++itr) {
0360 hbx_.at(DmxSum)->Fill(ibx);
0361 het_.at(DmxSum)->Fill(itr->hwPt());
0362 heta_.at(DmxSum)->Fill(itr->hwEta());
0363 hphi_.at(DmxSum)->Fill(itr->hwPhi());
0364 hetaphi_.at(DmxSum)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0365
0366 text << "Dmx Sum : "
0367 << " type=" << itr->getType() << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta()
0368 << " iphi=" << itr->hwPhi() << std::endl;
0369 }
0370 }
0371 }
0372
0373
0374 if (m_doMUs) {
0375 Handle<BXVector<l1t::Muon> > muons;
0376 iEvent.getByToken(m_muToken, muons);
0377
0378 for (int ibx = muons->getFirstBX(); ibx <= muons->getLastBX(); ++ibx) {
0379 for (auto itr = muons->begin(ibx); itr != muons->end(ibx); ++itr) {
0380 hbx_.at(MU)->Fill(ibx);
0381 het_.at(MU)->Fill(itr->hwPt());
0382 heta_.at(MU)->Fill(itr->hwEtaAtVtx());
0383 hphi_.at(MU)->Fill(itr->hwPhiAtVtx());
0384 hetaphi_.at(MU)->Fill(itr->hwEtaAtVtx(), itr->hwPhiAtVtx(), itr->hwPt());
0385
0386 text << "Muon : "
0387 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEtaAtVtx()
0388 << " iphi=" << itr->hwPhiAtVtx() << std::endl;
0389 }
0390 }
0391 }
0392
0393
0394 if (m_doEGs) {
0395 Handle<BXVector<l1t::EGamma> > egs;
0396 iEvent.getByToken(m_egToken, egs);
0397
0398 for (int ibx = egs->getFirstBX(); ibx <= egs->getLastBX(); ++ibx) {
0399 for (auto itr = egs->begin(ibx); itr != egs->end(ibx); ++itr) {
0400 hbx_.at(EG)->Fill(ibx);
0401 het_.at(EG)->Fill(itr->hwPt());
0402 heta_.at(EG)->Fill(itr->hwEta());
0403 hphi_.at(EG)->Fill(itr->hwPhi());
0404 hetaphi_.at(EG)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0405
0406 text << "EG : "
0407 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi()
0408 << std::endl;
0409 }
0410 }
0411 }
0412
0413
0414 if (m_doTaus) {
0415 Handle<BXVector<l1t::Tau> > taus;
0416 iEvent.getByToken(m_tauToken, taus);
0417
0418 for (int ibx = taus->getFirstBX(); ibx <= taus->getLastBX(); ++ibx) {
0419 for (auto itr = taus->begin(ibx); itr != taus->end(ibx); ++itr) {
0420 hbx_.at(Tau)->Fill(ibx);
0421 het_.at(Tau)->Fill(itr->hwPt());
0422 heta_.at(Tau)->Fill(itr->hwEta());
0423 hphi_.at(Tau)->Fill(itr->hwPhi());
0424 hetaphi_.at(Tau)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0425
0426 text << "Tau : "
0427 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi()
0428 << std::endl;
0429 }
0430 }
0431 }
0432
0433
0434 if (m_doJets) {
0435 Handle<BXVector<l1t::Jet> > jets;
0436 iEvent.getByToken(m_jetToken, jets);
0437
0438 for (int ibx = jets->getFirstBX(); ibx <= jets->getLastBX(); ++ibx) {
0439 for (auto itr = jets->begin(ibx); itr != jets->end(ibx); ++itr) {
0440 hbx_.at(Jet)->Fill(ibx);
0441 het_.at(Jet)->Fill(itr->hwPt());
0442 heta_.at(Jet)->Fill(itr->hwEta());
0443 hphi_.at(Jet)->Fill(itr->hwPhi());
0444 hetaphi_.at(Jet)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0445
0446 text << "Jet : "
0447 << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta() << " iphi=" << itr->hwPhi()
0448 << std::endl;
0449 }
0450 }
0451 }
0452
0453
0454 if (m_doSums) {
0455 Handle<BXVector<l1t::EtSum> > sums;
0456 iEvent.getByToken(m_sumToken, sums);
0457
0458 for (int ibx = sums->getFirstBX(); ibx <= sums->getLastBX(); ++ibx) {
0459 for (auto itr = sums->begin(ibx); itr != sums->end(ibx); ++itr) {
0460 hbx_.at(Sum)->Fill(ibx);
0461 het_.at(Sum)->Fill(itr->hwPt());
0462 heta_.at(Sum)->Fill(itr->hwEta());
0463 hphi_.at(Sum)->Fill(itr->hwPhi());
0464 hetaphi_.at(Sum)->Fill(itr->hwEta(), itr->hwPhi(), itr->hwPt());
0465 text << "Sum : "
0466 << " type=" << itr->getType() << " BX=" << ibx << " ipt=" << itr->hwPt() << " ieta=" << itr->hwEta()
0467 << " iphi=" << itr->hwPhi() << std::endl;
0468 }
0469 }
0470 }
0471
0472
0473 if (m_doGtAlg) {
0474 Handle<BXVector<GlobalAlgBlk> > algs;
0475 iEvent.getByToken(m_gtAlgToken, algs);
0476
0477 for (int ibx = algs->getFirstBX(); ibx <= algs->getLastBX(); ++ibx) {
0478 for (auto itr = algs->begin(ibx); itr != algs->end(ibx); ++itr) {
0479 for (int algBit = 0; algBit < 128;
0480 algBit++) {
0481 if (itr->getAlgoDecisionFinal(algBit)) {
0482 hAlgoBits_->Fill(algBit);
0483 text << "HW Fired Alg Bit : " << algBit << std::endl;
0484 }
0485 }
0486 }
0487 }
0488 }
0489
0490
0491 if (m_doEmulGtAlg) {
0492 Handle<BXVector<GlobalAlgBlk> > emulGtAlgs;
0493 iEvent.getByToken(m_emulGtAlgToken, emulGtAlgs);
0494
0495 for (int ibx = emulGtAlgs->getFirstBX(); ibx <= emulGtAlgs->getLastBX(); ++ibx) {
0496 for (auto itr = emulGtAlgs->begin(ibx); itr != emulGtAlgs->end(ibx); ++itr) {
0497 for (int algBit = 0; algBit < 128;
0498 algBit++) {
0499 if (itr->getAlgoDecisionFinal(algBit)) {
0500 hEmulGtAlgoBits_->Fill(algBit);
0501 text << "Emul w/ GTInput Fired Alg Bit : " << algBit << std::endl;
0502 }
0503 }
0504 }
0505 }
0506 }
0507
0508
0509 if (m_doEmulDxAlg) {
0510 Handle<BXVector<GlobalAlgBlk> > emulDxAlgs;
0511 iEvent.getByToken(m_emulDxAlgToken, emulDxAlgs);
0512
0513 for (int ibx = emulDxAlgs->getFirstBX(); ibx <= emulDxAlgs->getLastBX(); ++ibx) {
0514 for (auto itr = emulDxAlgs->begin(ibx); itr != emulDxAlgs->end(ibx); ++itr) {
0515 for (int algBit = 0; algBit < 128;
0516 algBit++) {
0517 if (itr->getAlgoDecisionFinal(algBit)) {
0518 hEmulDxAlgoBits_->Fill(algBit);
0519 text << "Emul w/ Demux output Fired Alg Bit : " << algBit << std::endl;
0520 }
0521 }
0522 }
0523 }
0524 }
0525
0526
0527 if (m_doMUs & m_dogMUs) {
0528 Handle<BXVector<l1t::Muon> > mus;
0529 iEvent.getByToken(m_muToken, mus);
0530
0531 Handle<BXVector<l1t::Muon> > gmtmus;
0532 iEvent.getByToken(m_gmuToken, gmtmus);
0533
0534 for (int ibx = mus->getFirstBX(); ibx <= mus->getLastBX(); ++ibx) {
0535
0536 for (unsigned int igtMU = 0; igtMU < mus->size(ibx); igtMU++) {
0537 double gtMUEt = mus->at(ibx, igtMU).hwPt();
0538 double gmtMUEt = 0.0;
0539 if (gmtmus->size(ibx) > igtMU)
0540 gmtMUEt = gmtmus->at(ibx, igtMU).hwPt();
0541 hGmtVsGTMUEt_->Fill(gtMUEt, gmtMUEt);
0542
0543 double gtMUEta = mus->at(ibx, igtMU).hwEtaAtVtx();
0544 double gmtMUEta = 0.0;
0545 if (gmtmus->size(ibx) > igtMU)
0546 gmtMUEta = gmtmus->at(ibx, igtMU).hwEtaAtVtx();
0547 hGmtVsGTMUEta_->Fill(gtMUEta, gmtMUEta);
0548
0549 double gtMUPhi = mus->at(ibx, igtMU).hwPhiAtVtx();
0550 double gmtMUPhi = 0.0;
0551 if (gmtmus->size(ibx) > igtMU)
0552 gmtMUPhi = gmtmus->at(ibx, igtMU).hwPhiAtVtx();
0553 hGmtVsGTMUPhi_->Fill(gtMUPhi, gmtMUPhi);
0554 }
0555
0556 for (unsigned int igmtMU = mus->size(ibx); igmtMU < gmtmus->size(ibx); igmtMU++) {
0557 double gtMUEt = 0.0;
0558 double gmtMUEt = gmtmus->at(ibx, igmtMU).hwPt();
0559 hGmtVsGTMUEt_->Fill(gtMUEt, gmtMUEt);
0560
0561 double gtMUEta = 0.0;
0562 double gmtMUEta = gmtmus->at(ibx, igmtMU).hwEtaAtVtx();
0563 hGmtVsGTMUEta_->Fill(gtMUEta, gmtMUEta);
0564
0565 double gtMUPhi = 0.0;
0566 double gmtMUPhi = gmtmus->at(ibx, igmtMU).hwPhiAtVtx();
0567 hGmtVsGTMUPhi_->Fill(gtMUPhi, gmtMUPhi);
0568 }
0569 }
0570 }
0571
0572
0573 if (m_doEGs & m_doDmxEGs) {
0574 Handle<BXVector<l1t::EGamma> > egs;
0575 iEvent.getByToken(m_egToken, egs);
0576
0577 Handle<BXVector<l1t::EGamma> > dmxegs;
0578 iEvent.getByToken(m_dmxEGToken, dmxegs);
0579
0580 for (int ibx = egs->getFirstBX(); ibx <= egs->getLastBX(); ++ibx) {
0581
0582 for (unsigned int igtEG = 0; igtEG < egs->size(ibx); igtEG++) {
0583 double gtEGEt = egs->at(ibx, igtEG).hwPt();
0584 double dmxEGEt = 0.0;
0585 if (dmxegs->size(ibx) > igtEG)
0586 dmxEGEt = dmxegs->at(ibx, igtEG).hwPt();
0587 hDmxVsGTEGEt_->Fill(gtEGEt, dmxEGEt);
0588
0589 double gtEGEta = egs->at(ibx, igtEG).hwEta();
0590 double dmxEGEta = 0.0;
0591 if (dmxegs->size(ibx) > igtEG)
0592 dmxEGEta = dmxegs->at(ibx, igtEG).hwEta();
0593 hDmxVsGTEGEta_->Fill(gtEGEta, dmxEGEta);
0594
0595 double gtEGPhi = egs->at(ibx, igtEG).hwPhi();
0596 double dmxEGPhi = 0.0;
0597 if (dmxegs->size(ibx) > igtEG)
0598 dmxEGPhi = dmxegs->at(ibx, igtEG).hwPhi();
0599 hDmxVsGTEGPhi_->Fill(gtEGPhi, dmxEGPhi);
0600 }
0601
0602 for (unsigned int idmEG = egs->size(ibx); idmEG < dmxegs->size(ibx); idmEG++) {
0603 double gtEGEt = 0.0;
0604 double dmxEGEt = dmxegs->at(ibx, idmEG).hwPt();
0605 hDmxVsGTEGEt_->Fill(gtEGEt, dmxEGEt);
0606
0607 double gtEGEta = 0.0;
0608 double dmxEGEta = dmxegs->at(ibx, idmEG).hwEta();
0609 hDmxVsGTEGEta_->Fill(gtEGEta, dmxEGEta);
0610
0611 double gtEGPhi = 0.0;
0612 double dmxEGPhi = dmxegs->at(ibx, idmEG).hwPhi();
0613 hDmxVsGTEGPhi_->Fill(gtEGPhi, dmxEGPhi);
0614 }
0615 }
0616 }
0617
0618
0619 if (m_doTaus & m_doDmxTaus) {
0620 Handle<BXVector<l1t::Tau> > taus;
0621 iEvent.getByToken(m_tauToken, taus);
0622
0623 Handle<BXVector<l1t::Tau> > dmxtaus;
0624 iEvent.getByToken(m_dmxTauToken, dmxtaus);
0625
0626 for (int ibx = taus->getFirstBX(); ibx <= taus->getLastBX(); ++ibx) {
0627
0628 for (unsigned int igtTau = 0; igtTau < taus->size(ibx); igtTau++) {
0629 double gtTauEt = taus->at(ibx, igtTau).hwPt();
0630 double dmxTauEt = 0.0;
0631 if (dmxtaus->size(ibx) > igtTau)
0632 dmxTauEt = dmxtaus->at(ibx, igtTau).hwPt();
0633 hDmxVsGTTauEt_->Fill(gtTauEt, dmxTauEt);
0634
0635 double gtTauEta = taus->at(ibx, igtTau).hwEta();
0636 double dmxTauEta = 0.0;
0637 if (dmxtaus->size(ibx) > igtTau)
0638 dmxTauEta = dmxtaus->at(ibx, igtTau).hwEta();
0639 hDmxVsGTTauEta_->Fill(gtTauEta, dmxTauEta);
0640
0641 double gtTauPhi = taus->at(ibx, igtTau).hwPhi();
0642 double dmxTauPhi = 0.0;
0643 if (dmxtaus->size(ibx) > igtTau)
0644 dmxTauPhi = dmxtaus->at(ibx, igtTau).hwPhi();
0645 hDmxVsGTTauPhi_->Fill(gtTauPhi, dmxTauPhi);
0646 }
0647
0648 for (unsigned int idmTau = taus->size(ibx); idmTau < dmxtaus->size(ibx); idmTau++) {
0649 double gtTauEt = 0.0;
0650 double dmxTauEt = dmxtaus->at(ibx, idmTau).hwPt();
0651 hDmxVsGTTauEt_->Fill(gtTauEt, dmxTauEt);
0652
0653 double gtTauEta = 0.0;
0654 double dmxTauEta = dmxtaus->at(ibx, idmTau).hwEta();
0655 hDmxVsGTTauEta_->Fill(gtTauEta, dmxTauEta);
0656
0657 double gtTauPhi = 0.0;
0658 double dmxTauPhi = dmxtaus->at(ibx, idmTau).hwPhi();
0659 hDmxVsGTTauPhi_->Fill(gtTauPhi, dmxTauPhi);
0660 }
0661 }
0662 }
0663
0664
0665 if (m_doJets & m_doDmxJets) {
0666 Handle<BXVector<l1t::Jet> > jets;
0667 iEvent.getByToken(m_jetToken, jets);
0668
0669 Handle<BXVector<l1t::Jet> > dmxjets;
0670 iEvent.getByToken(m_dmxJetToken, dmxjets);
0671
0672 for (int ibx = jets->getFirstBX(); ibx <= jets->getLastBX(); ++ibx) {
0673
0674 for (unsigned int igtJ = 0; igtJ < jets->size(ibx); igtJ++) {
0675 double gtJetEt = jets->at(ibx, igtJ).hwPt();
0676 double dmxJetEt = 0.0;
0677 if (dmxjets->size(ibx) > igtJ)
0678 dmxJetEt = dmxjets->at(ibx, igtJ).hwPt();
0679 hDmxVsGTJetEt_->Fill(gtJetEt, dmxJetEt);
0680
0681 double gtJetEta = jets->at(ibx, igtJ).hwEta();
0682 double dmxJetEta = 0.0;
0683 if (dmxjets->size(ibx) > igtJ)
0684 dmxJetEta = dmxjets->at(ibx, igtJ).hwEta();
0685 hDmxVsGTJetEta_->Fill(gtJetEta, dmxJetEta);
0686
0687 double gtJetPhi = jets->at(ibx, igtJ).hwPhi();
0688 double dmxJetPhi = 0.0;
0689 if (dmxjets->size(ibx) > igtJ)
0690 dmxJetPhi = dmxjets->at(ibx, igtJ).hwPhi();
0691 hDmxVsGTJetPhi_->Fill(gtJetPhi, dmxJetPhi);
0692 }
0693
0694 for (unsigned int idmJ = jets->size(ibx); idmJ < dmxjets->size(ibx); idmJ++) {
0695 double gtJetEt = 0.0;
0696 double dmxJetEt = dmxjets->at(ibx, idmJ).hwPt();
0697 hDmxVsGTJetEt_->Fill(gtJetEt, dmxJetEt);
0698
0699 double gtJetEta = 0.0;
0700 double dmxJetEta = dmxjets->at(ibx, idmJ).hwEta();
0701 hDmxVsGTJetEta_->Fill(gtJetEta, dmxJetEta);
0702
0703 double gtJetPhi = 0.0;
0704 double dmxJetPhi = dmxjets->at(ibx, idmJ).hwPhi();
0705 hDmxVsGTJetPhi_->Fill(gtJetPhi, dmxJetPhi);
0706 }
0707 }
0708 }
0709
0710
0711 if (m_doSums & m_doDmxSums) {
0712 Handle<BXVector<l1t::EtSum> > sums;
0713 iEvent.getByToken(m_sumToken, sums);
0714
0715 Handle<BXVector<l1t::EtSum> > dmxSums;
0716 iEvent.getByToken(m_dmxSumToken, dmxSums);
0717
0718 for (int ibx = sums->getFirstBX(); ibx <= sums->getLastBX(); ++ibx) {
0719
0720 for (unsigned int igtS = 0; igtS < sums->size(ibx); igtS++) {
0721 double gtSumEt = sums->at(ibx, igtS).hwPt();
0722 double dmxSumEt = 0.0;
0723 if (dmxSums->size(ibx) > igtS)
0724 dmxSumEt = dmxSums->at(ibx, igtS).hwPt();
0725
0726 double gtSumPhi = sums->at(ibx, igtS).hwPhi();
0727 double dmxSumPhi = 0.0;
0728 if (dmxSums->size(ibx) > igtS)
0729 dmxSumPhi = dmxSums->at(ibx, igtS).hwPhi();
0730
0731 if (sums->at(ibx, igtS).getType() == dmxSums->at(ibx, igtS).getType()) {
0732 switch (sums->at(ibx, igtS).getType()) {
0733 case l1t::EtSum::EtSumType::kTotalEt:
0734 hDmxVsGTSumEt_ETT_->Fill(gtSumEt, dmxSumEt);
0735
0736 break;
0737 case l1t::EtSum::EtSumType::kTotalEtEm:
0738 hDmxVsGTSumEt_ETTem_->Fill(gtSumEt, dmxSumEt);
0739
0740 break;
0741 case l1t::EtSum::EtSumType::kTotalHt:
0742 hDmxVsGTSumEt_HTT_->Fill(gtSumEt, dmxSumEt);
0743
0744 break;
0745 case l1t::EtSum::EtSumType::kMissingEt:
0746 hDmxVsGTSumEt_ETM_->Fill(gtSumEt, dmxSumEt);
0747 hDmxVsGTSumPhi_ETM_->Fill(gtSumPhi, dmxSumPhi);
0748 break;
0749 case l1t::EtSum::EtSumType::kMissingEtHF:
0750 hDmxVsGTSumEt_ETMHF_->Fill(gtSumEt, dmxSumEt);
0751 hDmxVsGTSumPhi_ETMHF_->Fill(gtSumPhi, dmxSumPhi);
0752 break;
0753 case l1t::EtSum::EtSumType::kMissingHt:
0754 hDmxVsGTSumEt_HTM_->Fill(gtSumEt, dmxSumEt);
0755 hDmxVsGTSumPhi_HTM_->Fill(gtSumPhi, dmxSumPhi);
0756 break;
0757 case l1t::EtSum::EtSumType::kMinBiasHFP0:
0758 hDmxVsGTSumEt_HFP0_->Fill(gtSumEt, dmxSumEt);
0759 break;
0760 case l1t::EtSum::EtSumType::kMinBiasHFM0:
0761 hDmxVsGTSumEt_HFM0_->Fill(gtSumEt, dmxSumEt);
0762 break;
0763 case l1t::EtSum::EtSumType::kMinBiasHFP1:
0764 hDmxVsGTSumEt_HFP1_->Fill(gtSumEt, dmxSumEt);
0765 break;
0766 case l1t::EtSum::EtSumType::kMinBiasHFM1:
0767 hDmxVsGTSumEt_HFM1_->Fill(gtSumEt, dmxSumEt);
0768 break;
0769 default:
0770 break;
0771 }
0772 } else {
0773 text << "WARNING: EtSum Types do not line up between DeMux and uGT " << std::endl;
0774 }
0775 }
0776
0777 for (unsigned int idmS = sums->size(ibx); idmS < dmxSums->size(ibx); idmS++) {
0778 double gtSumEt = -1.0;
0779 double dmxSumEt = dmxSums->at(ibx, idmS).hwPt();
0780
0781 double gtSumPhi = -1.0;
0782 double dmxSumPhi = dmxSums->at(ibx, idmS).hwPhi();
0783
0784 switch (dmxSums->at(ibx, idmS).getType()) {
0785 case l1t::EtSum::EtSumType::kTotalEt:
0786 hDmxVsGTSumEt_ETT_->Fill(gtSumEt, dmxSumEt);
0787
0788 break;
0789 case l1t::EtSum::EtSumType::kTotalEtEm:
0790 hDmxVsGTSumEt_ETTem_->Fill(gtSumEt, dmxSumEt);
0791
0792 break;
0793 case l1t::EtSum::EtSumType::kTotalHt:
0794 hDmxVsGTSumEt_HTT_->Fill(gtSumEt, dmxSumEt);
0795
0796 break;
0797 case l1t::EtSum::EtSumType::kMissingEt:
0798 hDmxVsGTSumEt_ETM_->Fill(gtSumEt, dmxSumEt);
0799 hDmxVsGTSumPhi_ETM_->Fill(gtSumPhi, dmxSumPhi);
0800 break;
0801 case l1t::EtSum::EtSumType::kMissingEtHF:
0802 hDmxVsGTSumEt_ETMHF_->Fill(gtSumEt, dmxSumEt);
0803 hDmxVsGTSumPhi_ETMHF_->Fill(gtSumPhi, dmxSumPhi);
0804 break;
0805 case l1t::EtSum::EtSumType::kMissingHt:
0806 hDmxVsGTSumEt_HTM_->Fill(gtSumEt, dmxSumEt);
0807 hDmxVsGTSumPhi_HTM_->Fill(gtSumPhi, dmxSumPhi);
0808 break;
0809 default:
0810 break;
0811 }
0812 }
0813 }
0814 }
0815
0816
0817 if (m_doGtAlg && m_doEmulGtAlg) {
0818 Handle<BXVector<GlobalAlgBlk> > hwalgs;
0819 iEvent.getByToken(m_gtAlgToken, hwalgs);
0820
0821 Handle<BXVector<GlobalAlgBlk> > emulAlgs;
0822 iEvent.getByToken(m_emulGtAlgToken, emulAlgs);
0823
0824
0825 int ibx = 0;
0826
0827 auto itr = hwalgs->begin(ibx);
0828 auto itr_emul = emulAlgs->begin(ibx);
0829
0830 for (int algBit = 0; algBit < 128;
0831 algBit++) {
0832 bool hw = itr->getAlgoDecisionFinal(algBit);
0833 bool em = itr_emul->getAlgoDecisionFinal(algBit);
0834 if (hw & em) {
0835 hAlgoBitsEmulGtVsHw_->Fill(algBit, algBit);
0836 } else if (hw & !em) {
0837 hAlgoBitsEmulGtVsHw_->Fill(algBit, -1.0);
0838 text << "WARNING: HW Fnd Alg Bit " << algBit << " but emulation did not " << std::endl;
0839 } else if (!hw & em) {
0840 hAlgoBitsEmulGtVsHw_->Fill(-1.0, algBit);
0841 text << "WARNING: Emul. Fnd Alg Bit " << algBit << " but hardware did not " << std::endl;
0842 }
0843 }
0844
0845
0846 }
0847
0848
0849 if (m_doGtAlg && m_doEmulDxAlg) {
0850 Handle<BXVector<GlobalAlgBlk> > hwalgs;
0851 iEvent.getByToken(m_gtAlgToken, hwalgs);
0852
0853 Handle<BXVector<GlobalAlgBlk> > emulAlgs;
0854 iEvent.getByToken(m_emulDxAlgToken, emulAlgs);
0855
0856
0857 int ibx = 0;
0858
0859 auto itr = hwalgs->begin(ibx);
0860 auto itr_emul = emulAlgs->begin(ibx);
0861
0862 for (int algBit = 0; algBit < 128;
0863 algBit++) {
0864 bool hw = itr->getAlgoDecisionFinal(algBit);
0865 bool em = itr_emul->getAlgoDecisionFinal(algBit);
0866 if (hw & em) {
0867 hAlgoBitsEmulDxVsHw_->Fill(algBit, algBit);
0868 } else if (hw & !em) {
0869 hAlgoBitsEmulDxVsHw_->Fill(algBit, -1.0);
0870 } else if (!hw & em) {
0871 hAlgoBitsEmulDxVsHw_->Fill(-1.0, algBit);
0872 }
0873 }
0874
0875
0876 }
0877
0878 if (doText_)
0879 edm::LogInfo("L1TGlobalEvents") << text.str();
0880 }
0881
0882
0883 void L1TGlobalAnalyzer::beginJob() {
0884 edm::Service<TFileService> fs;
0885
0886 auto itr = types_.cbegin();
0887 auto str = typeStr_.cbegin();
0888
0889 for (; itr != types_.end(); ++itr, ++str) {
0890 if (*itr == Jet || *itr == DmxJet || *itr == Sum || *itr == DmxSum || *itr == DmxEG || *itr == EG ||
0891 *itr == DmxTau || *itr == Tau) {
0892 double etmax = 99.5;
0893 if (*itr == Jet || *itr == DmxJet || *itr == Sum || *itr == DmxSum)
0894 etmax = 499.5;
0895
0896 dirs_.insert(std::pair<ObjectType, TFileDirectory>(*itr, fs->mkdir(*str)));
0897
0898 het_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("et", "", 500, -0.5, etmax)));
0899
0900 hbx_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("bx", "", 11, -5.5, 5.5)));
0901
0902 heta_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("eta", "", 229, -114.5, 114.5)));
0903 hphi_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("phi", "", 144, -0.5, 143.5)));
0904 hetaphi_.insert(std::pair<ObjectType, TH2F*>(
0905 *itr, dirs_.at(*itr).make<TH2F>("etaphi", "", 229, -114.5, 114.5, 144, -0.5, 143.5)));
0906 } else if (*itr == MU || *itr == gMU) {
0907 double etmax = 511.5;
0908 dirs_.insert(std::pair<ObjectType, TFileDirectory>(*itr, fs->mkdir(*str)));
0909
0910 het_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("et", "", 512, -0.5, etmax)));
0911
0912 hbx_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("bx", "", 11, -5.5, 5.5)));
0913
0914 heta_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("eta", "", 549, -224.5, 224.5)));
0915 hphi_.insert(std::pair<ObjectType, TH1F*>(*itr, dirs_.at(*itr).make<TH1F>("phi", "", 576, -0.5, 575.5)));
0916 hetaphi_.insert(std::pair<ObjectType, TH2F*>(
0917 *itr, dirs_.at(*itr).make<TH2F>("etaphi", "", 549, -224.5, 224.5, 576, -0.5, 575.5)));
0918 }
0919 }
0920
0921 algDir_ = fs->mkdir("Algorithms");
0922 hAlgoBits_ = algDir_.make<TH1F>("hAlgoBits", "Algorithm Bits", 100, -0.5, 99.5);
0923 hEmulGtAlgoBits_ = algDir_.make<TH1F>("hEmulGtAlgoBits", "GT Emulated Algorithm Bits", 100, -0.5, 99.5);
0924 hAlgoBitsEmulGtVsHw_ = algDir_.make<TH2F>(
0925 "hAlgoBitsEmulGtVsHw", "Algorithm Bits (GT) Emulation vs Hardware", 129, -1.5, 127.5, 129, -1.5, 127.5);
0926 hEmulDxAlgoBits_ = algDir_.make<TH1F>("hEmulDxAlgoBits", "Dx Emulated Algorithm Bits", 100, -0.5, 99.5);
0927 hAlgoBitsEmulDxVsHw_ = algDir_.make<TH2F>(
0928 "hAlgoBitsEmulDxVsHw", "Algorithm Bits (Dx) Emulation vs Hardware", 129, -1.5, 127.5, 129, -1.5, 127.5);
0929
0930 dmxVGtDir_ = fs->mkdir("SourceVsGT");
0931
0932 hGmtVsGTMUEt_ =
0933 dmxVGtDir_.make<TH2F>("hGmtVsGTMUEt", "Gmt MU Et versus GT MU Et", 512, -0.5, 511.5, 512, -0.5, 511.5);
0934 hGmtVsGTMUEta_ =
0935 dmxVGtDir_.make<TH2F>("hGmtVsGTMUEta", "Gmt MU Eta versus GT MU Eta", 549, -224.5, 224.5, 549, -224.5, 224.5);
0936 hGmtVsGTMUPhi_ =
0937 dmxVGtDir_.make<TH2F>("hGmtVsGTMUPhi", "Gmt MU Phi versus GT MU Phi", 576, -0.5, 575.5, 576, -0.5, 575.5);
0938
0939 hDmxVsGTEGEt_ =
0940 dmxVGtDir_.make<TH2F>("hDmxVsGTEGEt", "Dmx EG Et versus GT EG Et", 500, -0.5, 499.5, 500, -0.5, 499.5);
0941 hDmxVsGTEGEta_ =
0942 dmxVGtDir_.make<TH2F>("hDmxVsGTEGEta", "Dmx EG Eta versus GT EG Eta", 229, -114.5, 114.5, 229, -114.5, 114.5);
0943 hDmxVsGTEGPhi_ =
0944 dmxVGtDir_.make<TH2F>("hDmxVsGTEGPhi", "Dmx EG Phi versus GT EG Phi", 144, -0.5, 143.5, 144, -0.5, 143.5);
0945
0946 hDmxVsGTTauEt_ =
0947 dmxVGtDir_.make<TH2F>("hDmxVsGTTauEt", "Dmx Tau Et versus GT Tau Et", 500, -0.5, 499.5, 500, -0.5, 499.5);
0948 hDmxVsGTTauEta_ = dmxVGtDir_.make<TH2F>(
0949 "hDmxVsGTTauEta", "Dmx Tau Eta versus GT Tau Eta", 229, -114.5, 114.5, 229, -114.5, 114.5);
0950 hDmxVsGTTauPhi_ =
0951 dmxVGtDir_.make<TH2F>("hDmxVsGTTauPhi", "Dmx Tau Phi versus GT Tau Phi", 144, -0.5, 143.5, 144, -0.5, 143.5);
0952
0953 hDmxVsGTJetEt_ =
0954 dmxVGtDir_.make<TH2F>("hDmxVsGTJetEt", "Dmx Jet Et versus GT Jet Et", 500, -0.5, 499.5, 500, -0.5, 499.5);
0955 hDmxVsGTJetEta_ = dmxVGtDir_.make<TH2F>(
0956 "hDmxVsGTJetEta", "Dmx Jet Eta versus GT Jet Eta", 229, -114.5, 114.5, 229, -114.5, 114.5);
0957 hDmxVsGTJetPhi_ =
0958 dmxVGtDir_.make<TH2F>("hDmxVsGTJetPhi", "Dmx Jet Phi versus GT Jet Phi", 144, -0.5, 143.5, 144, -0.5, 143.5);
0959
0960 hDmxVsGTSumEt_ETT_ =
0961 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETT", "Dmx ETT versus GT ETT", 256, -0.5, 2047.5, 256, -0.5, 2047.5);
0962 hDmxVsGTSumEt_ETTem_ =
0963 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETTem", "Dmx ETTem versus GT ETTem", 256, -0.5, 2047.5, 256, -0.5, 2047.5);
0964 hDmxVsGTSumEt_HTT_ =
0965 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HTT", "Dmx HTT versus GT HTT", 256, -0.5, 2047.5, 256, -0.5, 2047.5);
0966 hDmxVsGTSumEt_ETM_ =
0967 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETM", "Dmx ETM versus GT ETM", 500, -0.5, 499.5, 500, -0.5, 499.5);
0968 hDmxVsGTSumPhi_ETM_ = dmxVGtDir_.make<TH2F>(
0969 "hDmxVsGTSumPhi_ETM", "Dmx ETM Phi versus GT ETM Phi", 144, -0.5, 143.5, 144, -0.5, 143.5);
0970 hDmxVsGTSumEt_ETMHF_ =
0971 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_ETMHF", "Dmx ETMHF versus GT ETMHF", 500, -0.5, 499.5, 500, -0.5, 499.5);
0972 hDmxVsGTSumPhi_ETMHF_ = dmxVGtDir_.make<TH2F>(
0973 "hDmxVsGTSumPhi_ETMHF", "Dmx ETMHF Phi versus GT ETMHF Phi", 144, -0.5, 143.5, 144, -0.5, 143.5);
0974 hDmxVsGTSumEt_HTM_ =
0975 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HTM", "Dmx HTM versus GT HTM", 500, -0.5, 499.5, 500, -0.5, 499.5);
0976 hDmxVsGTSumPhi_HTM_ = dmxVGtDir_.make<TH2F>(
0977 "hDmxVsGTSumPhi_HTM", "Dmx HTM Phi versus GT HTM Phi", 144, -0.5, 143.5, 144, -0.5, 143.5);
0978
0979 hDmxVsGTSumEt_HFP0_ =
0980 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFP0", "Dmx versus GT HFP0", 16, -0.5, 15.5, 16, -0.5, 15.5);
0981 hDmxVsGTSumEt_HFM0_ =
0982 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFM0", "Dmx versus GT HFM0", 16, -0.5, 15.5, 16, -0.5, 15.5);
0983 hDmxVsGTSumEt_HFP1_ =
0984 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFP1", "Dmx versus GT HFP1", 16, -0.5, 15.5, 16, -0.5, 15.5);
0985 hDmxVsGTSumEt_HFM1_ =
0986 dmxVGtDir_.make<TH2F>("hDmxVsGTSumEt_HFM1", "Dmx versus GT HFM1", 16, -0.5, 15.5, 16, -0.5, 15.5);
0987 }
0988
0989
0990 void L1TGlobalAnalyzer::endJob() {}
0991
0992
0993
0994
0995
0996
0997
0998
0999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025 void L1TGlobalAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1026
1027
1028 edm::ParameterSetDescription desc;
1029 desc.setUnknown();
1030 descriptions.addDefault(desc);
1031 }
1032
1033 }
1034
1035 using namespace l1t;
1036
1037
1038 DEFINE_FWK_MODULE(L1TGlobalAnalyzer);