File indexing completed on 2024-04-06 12:08:10
0001 #include "DQM/Physics/src/TopSingleLeptonDQM_miniAOD.h"
0002 #include "DataFormats/BTauReco/interface/JetTag.h"
0003 #include "DataFormats/JetReco/interface/CaloJet.h"
0004 #include "DataFormats/JetReco/interface/PFJet.h"
0005 #include "DataFormats/Math/interface/deltaR.h"
0006 #include "JetMETCorrections/Objects/interface/JetCorrectionsRecord.h"
0007 #include <iostream>
0008 #include <memory>
0009
0010 #include "FWCore/Framework/interface/ConsumesCollector.h"
0011 #include "FWCore/Framework/interface/EDConsumerBase.h"
0012 #include "FWCore/Utilities/interface/EDGetToken.h"
0013
0014 #include "DataFormats/PatCandidates/interface/Muon.h"
0015 #include "DataFormats/PatCandidates/interface/Electron.h"
0016 #include "DataFormats/PatCandidates/interface/Jet.h"
0017 #include "DataFormats/PatCandidates/interface/MET.h"
0018
0019 using namespace std;
0020
0021 namespace TopSingleLepton_miniAOD {
0022
0023
0024
0025 static const unsigned int MAXJETS = 4;
0026
0027
0028 static const double WMASS = 80.4;
0029
0030 MonitorEnsemble::MonitorEnsemble(const char* label, const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC)
0031 : label_(label),
0032 elecIso_(nullptr),
0033 elecSelect_(nullptr),
0034 pvSelect_(nullptr),
0035 muonIso_(nullptr),
0036 muonSelect_(nullptr),
0037 jetIDSelect_(nullptr),
0038 jetSelect(nullptr),
0039 includeBTag_(false),
0040 lowerEdge_(-1.),
0041 upperEdge_(-1.),
0042 logged_(0) {
0043
0044 edm::ParameterSet sources = cfg.getParameter<edm::ParameterSet>("sources");
0045
0046
0047
0048 muons_ = iC.consumes<edm::View<pat::Muon>>(sources.getParameter<edm::InputTag>("muons"));
0049
0050 elecs_ = iC.consumes<edm::View<pat::Electron>>(sources.getParameter<edm::InputTag>("elecs"));
0051 pvs_ = iC.consumes<edm::View<reco::Vertex>>(sources.getParameter<edm::InputTag>("pvs"));
0052 jets_ = iC.consumes<edm::View<pat::Jet>>(sources.getParameter<edm::InputTag>("jets"));
0053 for (edm::InputTag const& tag : sources.getParameter<std::vector<edm::InputTag>>("mets"))
0054 mets_.push_back(iC.consumes<edm::View<pat::MET>>(tag));
0055
0056
0057 if (cfg.existsAs<edm::ParameterSet>("elecExtras")) {
0058 edm::ParameterSet elecExtras = cfg.getParameter<edm::ParameterSet>("elecExtras");
0059
0060
0061 if (elecExtras.existsAs<std::string>("select")) {
0062 elecSelect_ =
0063 std::make_unique<StringCutObjectSelector<pat::Electron>>(elecExtras.getParameter<std::string>("select"));
0064 }
0065
0066
0067 if (elecExtras.existsAs<std::string>("isolation")) {
0068 elecIso_ =
0069 std::make_unique<StringCutObjectSelector<pat::Electron>>(elecExtras.getParameter<std::string>("isolation"));
0070 }
0071
0072 if (elecExtras.existsAs<std::string>("rho")) {
0073 rhoTag = elecExtras.getParameter<edm::InputTag>("rho");
0074 }
0075
0076
0077 if (elecExtras.existsAs<edm::ParameterSet>("electronId")) {
0078 edm::ParameterSet elecId = elecExtras.getParameter<edm::ParameterSet>("electronId");
0079 electronId_ = iC.consumes<edm::ValueMap<float>>(elecId.getParameter<edm::InputTag>("src"));
0080 eidCutValue_ = elecId.getParameter<double>("cutValue");
0081 }
0082 }
0083
0084 if (cfg.existsAs<edm::ParameterSet>("pvExtras")) {
0085 edm::ParameterSet pvExtras = cfg.getParameter<edm::ParameterSet>("pvExtras");
0086
0087
0088 if (pvExtras.existsAs<std::string>("select")) {
0089 pvSelect_ =
0090 std::make_unique<StringCutObjectSelector<reco::Vertex>>(pvExtras.getParameter<std::string>("select"));
0091 }
0092 }
0093
0094 if (cfg.existsAs<edm::ParameterSet>("muonExtras")) {
0095 edm::ParameterSet muonExtras = cfg.getParameter<edm::ParameterSet>("muonExtras");
0096
0097
0098 if (muonExtras.existsAs<std::string>("select")) {
0099 muonSelect_ =
0100 std::make_unique<StringCutObjectSelector<pat::Muon>>(muonExtras.getParameter<std::string>("select"));
0101 }
0102
0103
0104 if (muonExtras.existsAs<std::string>("isolation")) {
0105 muonIso_ =
0106 std::make_unique<StringCutObjectSelector<pat::Muon>>(muonExtras.getParameter<std::string>("isolation"));
0107 }
0108 }
0109
0110
0111
0112 if (cfg.existsAs<edm::ParameterSet>("jetExtras")) {
0113 edm::ParameterSet jetExtras = cfg.getParameter<edm::ParameterSet>("jetExtras");
0114
0115 if (jetExtras.existsAs<edm::ParameterSet>("jetID")) {
0116 edm::ParameterSet jetID = jetExtras.getParameter<edm::ParameterSet>("jetID");
0117 jetIDLabel_ = iC.consumes<reco::JetIDValueMap>(jetID.getParameter<edm::InputTag>("label"));
0118 jetIDSelect_ =
0119 std::make_unique<StringCutObjectSelector<reco::JetID>>(jetID.getParameter<std::string>("select"));
0120 }
0121
0122
0123
0124 if (jetExtras.existsAs<std::string>("select")) {
0125 jetSelect_ = jetExtras.getParameter<std::string>("select");
0126 jetSelect = std::make_unique<StringCutObjectSelector<pat::Jet>>(jetSelect_);
0127 }
0128 }
0129
0130
0131 if (cfg.existsAs<edm::ParameterSet>("triggerExtras")) {
0132 edm::ParameterSet triggerExtras = cfg.getParameter<edm::ParameterSet>("triggerExtras");
0133 triggerTable_ = iC.consumes<edm::TriggerResults>(triggerExtras.getParameter<edm::InputTag>("src"));
0134 triggerPaths_ = triggerExtras.getParameter<std::vector<std::string>>("paths");
0135 }
0136
0137
0138
0139
0140 if (cfg.existsAs<edm::ParameterSet>("massExtras")) {
0141 edm::ParameterSet massExtras = cfg.getParameter<edm::ParameterSet>("massExtras");
0142 lowerEdge_ = massExtras.getParameter<double>("lowerEdge");
0143 upperEdge_ = massExtras.getParameter<double>("upperEdge");
0144 }
0145
0146
0147
0148
0149
0150 verbosity_ = STANDARD;
0151 if (cfg.existsAs<edm::ParameterSet>("monitoring")) {
0152 edm::ParameterSet monitoring = cfg.getParameter<edm::ParameterSet>("monitoring");
0153 if (monitoring.getParameter<std::string>("verbosity") == "DEBUG")
0154 verbosity_ = DEBUG;
0155 if (monitoring.getParameter<std::string>("verbosity") == "VERBOSE")
0156 verbosity_ = VERBOSE;
0157 if (monitoring.getParameter<std::string>("verbosity") == "STANDARD")
0158 verbosity_ = STANDARD;
0159 }
0160
0161 directory_ = cfg.getParameter<std::string>("directory");
0162
0163 }
0164
0165 void MonitorEnsemble::book(DQMStore::IBooker& ibooker) {
0166
0167 std::string current(directory_);
0168 current += label_;
0169 ibooker.setCurrentFolder(current);
0170
0171
0172
0173
0174
0175
0176
0177
0178
0179
0180 hists_["pvMult_"] = ibooker.book1D("PvMult", "N_{good pvs}", 50, 0., 50.);
0181
0182 hists_["muonPt_"] = ibooker.book1D("MuonPt", "pt(#mu TightId, TightIso)", 40, 0., 200.);
0183
0184 hists_["muonMult_"] = ibooker.book1D("MuonMult", "N_{loose}(#mu)", 10, 0., 10.);
0185
0186
0187
0188
0189 hists_["muonMultTight_"] = ibooker.book1D("MuonMultTight", "N_{TightIso,TightId}(#mu)", 10, 0., 10.);
0190
0191
0192 hists_["elecPt_"] = ibooker.book1D("ElecPt", "pt(e TightId, TightIso)", 40, 0., 200.);
0193
0194
0195
0196
0197
0198 hists_["jetMult_"] = ibooker.book1D("JetMult", "N_{30}(jet)", 10, 0., 10.);
0199 hists_["jetLooseMult_"] = ibooker.book1D("JetLooseMult", "N_{30,loose}(jet)", 10, 0., 10.);
0200
0201
0202
0203
0204
0205
0206
0207
0208 hists_["slimmedMETs_"] = ibooker.book1D("slimmedMETs", "MET_{slimmed}", 40, 0., 200.);
0209
0210 hists_["massW_"] = ibooker.book1D("MassW", "M(W)", 60, 0., 300.);
0211
0212 hists_["massTop_"] = ibooker.book1D("MassTop", "M(Top)", 50, 0., 500.);
0213
0214 hists_["massBTop_"] = ibooker.book1D("MassBTop", "M(Top, 1 b-tag)", 50, 0., 500.);
0215
0216 triggerBinLabels(std::string("trigger"), triggerPaths_);
0217
0218 if (verbosity_ == STANDARD)
0219 return;
0220
0221
0222
0223 hists_["muonEta_"] = ibooker.book1D("MuonEta", "#eta(#mu TightId,TightIso)", 30, -3., 3.);
0224
0225 hists_["muonPhi_"] = ibooker.book1D("MuonPhi", "#phi(#mu TightId,TightIso)", 40, -4., 4.);
0226 hists_["muonRelIso_"] = ibooker.book1D("MuonRelIso", "Iso_{Rel}(#mu TightId) (#Delta#beta Corrected)", 50, 0., 1.);
0227
0228
0229 hists_["elecEta_"] = ibooker.book1D("ElecEta", "#eta(e TightId, TightIso)", 30, -3., 3.);
0230 hists_["elecPhi_"] = ibooker.book1D("ElecPhi", "#phi(e TightId, TightIso)", 40, -4., 4.);
0231
0232 hists_["elecRelIso_"] = ibooker.book1D("ElecRelIso", "Iso_{Rel}(e TightId)", 50, 0., 1.);
0233
0234 hists_["elecMultTight_"] = ibooker.book1D("ElecMultTight", "N_{TightIso,TightId}(e)", 10, 0., 10.);
0235
0236
0237
0238
0239
0240
0241
0242
0243
0244
0245 hists_["jet1Eta_"] = ibooker.book1D("Jet1Eta", "#eta_{30,loose}(jet1)", 60, -3., 3.);
0246
0247 hists_["jet1Pt_"] = ibooker.book1D("Jet1Pt", "pt_{30,loose}(jet1)", 60, 0., 300.);
0248
0249 hists_["jet2Eta_"] = ibooker.book1D("Jet2Eta", "#eta_{30,loose}(jet2)", 60, -3., 3.);
0250
0251 hists_["jet2Pt_"] = ibooker.book1D("Jet2Pt", "pt_{30,loose}(jet2)", 60, 0., 300.);
0252
0253 hists_["jet3Eta_"] = ibooker.book1D("Jet3Eta", "#eta_{30,loose}(jet3)", 60, -3., 3.);
0254
0255 hists_["jet3Pt_"] = ibooker.book1D("Jet3Pt", "pt_{30,loose}(jet3)", 60, 0., 300.);
0256
0257 hists_["jet4Eta_"] = ibooker.book1D("Jet4Eta", "#eta_{30,loose}(jet4)", 60, -3., 3.);
0258
0259 hists_["jet4Pt_"] = ibooker.book1D("Jet4Pt", "pt_{30,loose}(jet4)", 60, 0., 300.);
0260
0261
0262 hists_["slimmedMETsPuppi_"] = ibooker.book1D("slimmedMETsPuppi", "MET_{slimmedPuppi}", 40, 0., 200.);
0263
0264 hists_["muonDelZ_"] = ibooker.book1D("MuonDelZ", "d_{z}(#mu)", 50, -25., 25.);
0265
0266 hists_["muonDelXY_"] = ibooker.book2D("MuonDelXY", "d_{xy}(#mu)", 50, -0.1, 0.1, 50, -0.1, 0.1);
0267
0268
0269 hists_["muonDelXY_"]->setAxisTitle("x [cm]", 1);
0270 hists_["muonDelXY_"]->setAxisTitle("y [cm]", 2);
0271
0272 if (verbosity_ == VERBOSE)
0273 return;
0274
0275
0276
0277
0278 hists_["muonChHadIso_"] = ibooker.book1D("MuonChHadIsoComp", "ChHad_{IsoComponent}(#mu TightId)", 50, 0., 5.);
0279
0280
0281 hists_["muonNeHadIso_"] = ibooker.book1D("MuonNeHadIsoComp", "NeHad_{IsoComponent}(#mu TightId)", 50, 0., 5.);
0282
0283
0284 hists_["muonPhIso_"] = ibooker.book1D("MuonPhIsoComp", "Photon_{IsoComponent}(#mu TightId)", 50, 0., 5.);
0285
0286
0287 hists_["elecChHadIso_"] = ibooker.book1D("ElectronChHadIsoComp", "ChHad_{IsoComponent}(e TightId)", 50, 0., 5.);
0288
0289
0290 hists_["elecNeHadIso_"] = ibooker.book1D("ElectronNeHadIsoComp", "NeHad_{IsoComponent}(e TightId)", 50, 0., 5.);
0291
0292
0293 hists_["elecPhIso_"] = ibooker.book1D("ElectronPhIsoComp", "Photon_{IsoComponent}(e TightId)", 50, 0., 5.);
0294
0295
0296
0297
0298
0299
0300
0301
0302
0303
0304
0305
0306
0307
0308 hists_["jetMultBDeepJetM_"] = ibooker.book1D("JetMultBDeepJetM", "N_{30}(DeepJetM)", 10, 0., 10.);
0309
0310 hists_["jetBDeepJet_"] = ibooker.book1D("JetDiscDeepJet", "BJet Disc_{DeepJet}(JET)", 100, -1., 2.);
0311
0312
0313
0314
0315
0316
0317
0318
0319
0320 hists_["eventLogger_"] = ibooker.book2D("EventLogger", "Logged Events", 9, 0., 9., 10, 0., 10.);
0321
0322
0323 hists_["eventLogger_"]->getTH1()->SetOption("TEXT");
0324 hists_["eventLogger_"]->setBinLabel(1, "Run", 1);
0325 hists_["eventLogger_"]->setBinLabel(2, "Block", 1);
0326 hists_["eventLogger_"]->setBinLabel(3, "Event", 1);
0327 hists_["eventLogger_"]->setBinLabel(4, "pt_{L2L3}(jet1)", 1);
0328 hists_["eventLogger_"]->setBinLabel(5, "pt_{L2L3}(jet2)", 1);
0329 hists_["eventLogger_"]->setBinLabel(6, "pt_{L2L3}(jet3)", 1);
0330 hists_["eventLogger_"]->setBinLabel(7, "pt_{L2L3}(jet4)", 1);
0331 hists_["eventLogger_"]->setBinLabel(8, "M_{W}", 1);
0332 hists_["eventLogger_"]->setBinLabel(9, "M_{Top}", 1);
0333 hists_["eventLogger_"]->setAxisTitle("logged evts", 2);
0334 return;
0335 }
0336
0337 void MonitorEnsemble::fill(const edm::Event& event, const edm::EventSetup& setup) {
0338
0339 edm::Handle<edm::TriggerResults> triggerTable;
0340
0341 if (!triggerTable_.isUninitialized()) {
0342 if (!event.getByToken(triggerTable_, triggerTable))
0343 return;
0344 }
0345
0346
0347
0348
0349
0350
0351
0352
0353
0354 edm::Handle<edm::View<reco::Vertex>> pvs;
0355 if (!event.getByToken(pvs_, pvs))
0356 return;
0357 const reco::Vertex& pver = pvs->front();
0358
0359 unsigned int pvMult = 0;
0360 if (pvs.isValid()) {
0361 for (edm::View<reco::Vertex>::const_iterator pv = pvs->begin(); pv != pvs->end(); ++pv) {
0362 bool isGood =
0363 (!(pv->isFake()) && (pv->ndof() > 4.0) && (abs(pv->z()) < 24.0) && (abs(pv->position().Rho()) < 2.0));
0364 if (!isGood)
0365 continue;
0366 pvMult++;
0367 }
0368
0369 }
0370
0371 fill("pvMult_", pvMult);
0372
0373
0374
0375
0376
0377
0378
0379
0380
0381
0382
0383
0384
0385
0386
0387
0388
0389
0390
0391
0392
0393
0394
0395
0396
0397
0398 edm::Handle<edm::View<pat::Electron>> elecs;
0399 if (!event.getByToken(elecs_, elecs))
0400 return;
0401
0402 edm::Handle<double> _rhoHandle;
0403 event.getByLabel(rhoTag, _rhoHandle);
0404
0405
0406
0407 edm::Handle<edm::ValueMap<float>> electronId;
0408 if (!electronId_.isUninitialized()) {
0409 if (!event.getByToken(electronId_, electronId))
0410 return;
0411 }
0412
0413
0414 unsigned int eMultIso = 0, eMult = 0;
0415 std::vector<const pat::Electron*> isoElecs;
0416
0417 for (edm::View<pat::Electron>::const_iterator elec = elecs->begin(); elec != elecs->end(); ++elec) {
0418 if (true) {
0419 if (!elecSelect_ || (*elecSelect_)(*elec)) {
0420 double el_ChHadIso = elec->pfIsolationVariables().sumChargedHadronPt;
0421 double el_NeHadIso = elec->pfIsolationVariables().sumNeutralHadronEt;
0422 double el_PhIso = elec->pfIsolationVariables().sumPhotonEt;
0423
0424 double rho = _rhoHandle.isValid() ? (float)(*_rhoHandle) : 0;
0425 double absEta = abs(elec->superCluster()->eta());
0426 double eA = 0;
0427 if (absEta < 1.000)
0428 eA = 0.1703;
0429 else if (absEta < 1.479)
0430 eA = 0.1715;
0431 else if (absEta < 2.000)
0432 eA = 0.1213;
0433 else if (absEta < 2.200)
0434 eA = 0.1230;
0435 else if (absEta < 2.300)
0436 eA = 0.1635;
0437 else if (absEta < 2.400)
0438 eA = 0.1937;
0439 else if (absEta < 5.000)
0440 eA = 0.2393;
0441
0442 double el_pfRelIso = (el_ChHadIso + max(0., el_NeHadIso + el_PhIso - rho * eA)) / elec->pt();
0443
0444 ++eMult;
0445
0446 if (eMult == 1) {
0447 fill("elecRelIso_", el_pfRelIso);
0448 fill("elecChHadIso_", el_ChHadIso);
0449 fill("elecNeHadIso_", el_NeHadIso);
0450 fill("elecPhIso_", el_PhIso);
0451 }
0452
0453
0454
0455
0456 if (!((el_pfRelIso < 0.0588 && absEta < 1.479) || (el_pfRelIso < 0.0571 && absEta > 1.479)))
0457 continue;
0458 ++eMultIso;
0459
0460 if (eMultIso == 1) {
0461
0462 fill("elecPt_", elec->pt());
0463 fill("elecEta_", elec->eta());
0464 fill("elecPhi_", elec->phi());
0465 }
0466 }
0467 }
0468 }
0469
0470 fill("elecMultTight_", eMultIso);
0471
0472
0473
0474
0475
0476
0477
0478
0479
0480
0481 unsigned int mMult = 0, mTight = 0, mTightId = 0;
0482
0483 edm::Handle<edm::View<pat::Muon>> muons;
0484 edm::View<pat::Muon>::const_iterator muonit;
0485
0486 if (!event.getByToken(muons_, muons))
0487 return;
0488
0489 for (edm::View<pat::Muon>::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
0490
0491 if (muon->isGlobalMuon()) {
0492 fill("muonDelZ_", muon->innerTrack()->vz());
0493 fill("muonDelXY_", muon->innerTrack()->vx(), muon->innerTrack()->vy());
0494
0495
0496 if (!muonSelect_ || (*muonSelect_)(*muon)) {
0497
0498 ++mMult;
0499
0500 double chHadPt = muon->pfIsolationR04().sumChargedHadronPt;
0501 double neHadEt = muon->pfIsolationR04().sumNeutralHadronEt;
0502 double phoEt = muon->pfIsolationR04().sumPhotonEt;
0503
0504 double pfRelIso = (chHadPt + max(0., neHadEt + phoEt - 0.5 * muon->pfIsolationR04().sumPUPt)) /
0505 muon->pt();
0506
0507 if (!(muon->isGlobalMuon() && muon->isPFMuon() && muon->globalTrack()->normalizedChi2() < 10. &&
0508 muon->globalTrack()->hitPattern().numberOfValidMuonHits() > 0 && muon->numberOfMatchedStations() > 1 &&
0509 fabs(muon->muonBestTrack()->dxy(pver.position())) < 0.2 &&
0510 fabs(muon->muonBestTrack()->dz(pver.position())) < 0.5 &&
0511 muon->innerTrack()->hitPattern().numberOfValidPixelHits() > 0 &&
0512 muon->innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5))
0513 continue;
0514
0515 if (mTightId == 0) {
0516
0517 fill("muonRelIso_", pfRelIso);
0518 fill("muonChHadIso_", chHadPt);
0519 fill("muonNeHadIso_", neHadEt);
0520 fill("muonPhIso_", phoEt);
0521
0522 }
0523
0524 if (!(pfRelIso < 0.15))
0525 continue;
0526
0527 if (mTight == 0) {
0528
0529
0530 fill("muonPt_", muon->pt());
0531 fill("muonEta_", muon->eta());
0532 fill("muonPhi_", muon->phi());
0533 }
0534 mTight++;
0535 mTightId++;
0536 }
0537 }
0538 }
0539 fill("muonMult_", mMult);
0540 fill("muonMultTight_", mTight);
0541
0542
0543
0544
0545
0546
0547
0548
0549
0550
0551 std::vector<pat::Jet> correctedJets;
0552 std::vector<double> JetTagValues;
0553 unsigned int mult = 0, loosemult = 0, multBDeepJetM = 0;
0554
0555 edm::Handle<edm::View<pat::Jet>> jets;
0556 if (!event.getByToken(jets_, jets)) {
0557 return;
0558 }
0559
0560 for (edm::View<pat::Jet>::const_iterator jet = jets->begin(); jet != jets->end(); ++jet) {
0561
0562
0563
0564 const pat::Jet& sel = *jet;
0565
0566 if (!(*jetSelect)(sel))
0567 continue;
0568
0569
0570
0571 const pat::Jet& monitorJet = *jet;
0572
0573 ++mult;
0574
0575 if (monitorJet.chargedHadronEnergyFraction() > 0 && monitorJet.chargedMultiplicity() > 0 &&
0576 monitorJet.chargedEmEnergyFraction() < 0.99 && monitorJet.neutralHadronEnergyFraction() < 0.99 &&
0577 monitorJet.neutralEmEnergyFraction() < 0.99 &&
0578 (monitorJet.chargedMultiplicity() + monitorJet.neutralMultiplicity()) > 1) {
0579 correctedJets.push_back(monitorJet);
0580 ++loosemult;
0581
0582 double discriminator = monitorJet.bDiscriminator("pfDeepFlavourJetTags:probb") +
0583 monitorJet.bDiscriminator("pfDeepFlavourJetTags:probbb") +
0584 monitorJet.bDiscriminator("pfDeepFlavourJetTags:problepb");
0585
0586 fill("jetBDeepJet_", discriminator);
0587 if (discriminator > 0.2435)
0588 ++multBDeepJetM;
0589
0590
0591
0592 JetTagValues.push_back(discriminator);
0593
0594
0595 if (loosemult == 1) {
0596
0597
0598 fill("jet1Pt_", monitorJet.pt());
0599
0600 fill("jet1Eta_", monitorJet.eta());
0601 };
0602 if (loosemult == 2) {
0603 fill("jet2Pt_", monitorJet.pt());
0604
0605 fill("jet2Eta_", monitorJet.eta());
0606 }
0607 if (loosemult == 3) {
0608 fill("jet3Pt_", monitorJet.pt());
0609
0610 fill("jet3Eta_", monitorJet.eta());
0611 }
0612 if (loosemult == 4) {
0613 fill("jet4Pt_", monitorJet.pt());
0614
0615 fill("jet4Eta_", monitorJet.eta());
0616 }
0617 }
0618 }
0619 fill("jetMult_", mult);
0620 fill("jetLooseMult_", loosemult);
0621 fill("jetMultBDeepJetM_", multBDeepJetM);
0622
0623
0624
0625
0626
0627
0628
0629
0630
0631
0632 for (std::vector<edm::EDGetTokenT<edm::View<pat::MET>>>::const_iterator met_ = mets_.begin(); met_ != mets_.end();
0633 ++met_) {
0634 edm::Handle<edm::View<pat::MET>> met;
0635 if (!event.getByToken(*met_, met))
0636 continue;
0637 if (met->begin() != met->end()) {
0638 unsigned int idx = met_ - mets_.begin();
0639 if (idx == 0)
0640 fill("slimmedMETs_", met->begin()->et());
0641 if (idx == 2)
0642 fill("slimmedMETsPuppi_", met->begin()->et());
0643 }
0644 }
0645
0646
0647
0648
0649
0650
0651
0652
0653
0654
0655
0656 Calculate_miniAOD eventKinematics(MAXJETS, WMASS);
0657 double wMass = eventKinematics.massWBoson(correctedJets);
0658 double topMass = eventKinematics.massTopQuark(correctedJets);
0659 if (wMass >= 0 && topMass >= 0) {
0660 fill("massW_", wMass);
0661 fill("massTop_", topMass);
0662 }
0663
0664
0665
0666
0667 if (correctedJets.size() != JetTagValues.size())
0668 return;
0669
0670 double btopMass = eventKinematics.massBTopQuark(correctedJets, JetTagValues, 0.2435);
0671
0672 if (btopMass >= 0)
0673 fill("massBTop_", btopMass);
0674
0675
0676 if ((lowerEdge_ == -1. && upperEdge_ == -1.) || (lowerEdge_ < wMass && wMass < upperEdge_)) {
0677 if (!triggerTable_.isUninitialized())
0678 fill(event, *triggerTable, "trigger", triggerPaths_);
0679 if (logged_ <= hists_.find("eventLogger_")->second->getNbinsY()) {
0680
0681
0682 fill("eventLogger_", 0.5, logged_ + 0.5, event.eventAuxiliary().run());
0683 fill("eventLogger_", 1.5, logged_ + 0.5, event.eventAuxiliary().luminosityBlock());
0684 fill("eventLogger_", 2.5, logged_ + 0.5, event.eventAuxiliary().event());
0685
0686 if (!correctedJets.empty())
0687 fill("eventLogger_", 3.5, logged_ + 0.5, correctedJets[0].pt());
0688 if (correctedJets.size() > 1)
0689 fill("eventLogger_", 4.5, logged_ + 0.5, correctedJets[1].pt());
0690 if (correctedJets.size() > 2)
0691 fill("eventLogger_", 5.5, logged_ + 0.5, correctedJets[2].pt());
0692 if (correctedJets.size() > 3)
0693 fill("eventLogger_", 6.5, logged_ + 0.5, correctedJets[3].pt());
0694 fill("eventLogger_", 7.5, logged_ + 0.5, wMass);
0695 fill("eventLogger_", 8.5, logged_ + 0.5, topMass);
0696 ++logged_;
0697 }
0698 }
0699 }
0700 }
0701
0702 TopSingleLeptonDQM_miniAOD::TopSingleLeptonDQM_miniAOD(const edm::ParameterSet& cfg)
0703 : vertexSelect_(nullptr),
0704 beamspot_(""),
0705 beamspotSelect_(nullptr),
0706 MuonStep(nullptr),
0707 ElectronStep(nullptr),
0708 PvStep(nullptr),
0709 METStep(nullptr) {
0710 JetSteps.clear();
0711
0712
0713 edm::ParameterSet presel = cfg.getParameter<edm::ParameterSet>("preselection");
0714 if (presel.existsAs<edm::ParameterSet>("trigger")) {
0715 edm::ParameterSet trigger = presel.getParameter<edm::ParameterSet>("trigger");
0716 triggerTable__ = consumes<edm::TriggerResults>(trigger.getParameter<edm::InputTag>("src"));
0717 triggerPaths_ = trigger.getParameter<std::vector<std::string>>("select");
0718 }
0719 if (presel.existsAs<edm::ParameterSet>("beamspot")) {
0720 edm::ParameterSet beamspot = presel.getParameter<edm::ParameterSet>("beamspot");
0721 beamspot_ = beamspot.getParameter<edm::InputTag>("src");
0722 beamspot__ = consumes<reco::BeamSpot>(beamspot.getParameter<edm::InputTag>("src"));
0723 beamspotSelect_ =
0724 std::make_unique<StringCutObjectSelector<reco::BeamSpot>>(beamspot.getParameter<std::string>("select"));
0725 }
0726
0727
0728 sel_ = cfg.getParameter<std::vector<edm::ParameterSet>>("selection");
0729 setup_ = cfg.getParameter<edm::ParameterSet>("setup");
0730 for (unsigned int i = 0; i < sel_.size(); ++i) {
0731 selectionOrder_.push_back(sel_.at(i).getParameter<std::string>("label"));
0732 selection_[selectionStep(selectionOrder_.back())] =
0733 std::make_pair(sel_.at(i),
0734 std::make_unique<TopSingleLepton_miniAOD::MonitorEnsemble>(
0735 selectionStep(selectionOrder_.back()).c_str(), setup_, consumesCollector()));
0736 }
0737 for (std::vector<std::string>::const_iterator selIt = selectionOrder_.begin(); selIt != selectionOrder_.end();
0738 ++selIt) {
0739 std::string key = selectionStep(*selIt), type = objectType(*selIt);
0740 if (selection_.find(key) != selection_.end()) {
0741 if (type == "muons") {
0742 MuonStep = std::make_unique<SelectionStep<pat::Muon>>(selection_[key].first, consumesCollector());
0743 }
0744 if (type == "elecs") {
0745 ElectronStep = std::make_unique<SelectionStep<pat::Electron>>(selection_[key].first, consumesCollector());
0746 }
0747 if (type == "pvs") {
0748 PvStep = std::make_unique<SelectionStep<reco::Vertex>>(selection_[key].first, consumesCollector());
0749 }
0750 if (type == "jets") {
0751 JetSteps.push_back(std::make_unique<SelectionStep<pat::Jet>>(selection_[key].first, consumesCollector()));
0752 }
0753
0754 if (type == "met") {
0755 METStep = std::make_unique<SelectionStep<pat::MET>>(selection_[key].first, consumesCollector());
0756 }
0757 }
0758 }
0759 }
0760 void TopSingleLeptonDQM_miniAOD::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) {
0761 for (auto selIt = selection_.begin(); selIt != selection_.end(); ++selIt) {
0762 selIt->second.second->book(ibooker);
0763 }
0764 }
0765 void TopSingleLeptonDQM_miniAOD::analyze(const edm::Event& event, const edm::EventSetup& setup) {
0766 if (!triggerTable__.isUninitialized()) {
0767 edm::Handle<edm::TriggerResults> triggerTable;
0768 if (!event.getByToken(triggerTable__, triggerTable))
0769 return;
0770 if (!accept(event, *triggerTable, triggerPaths_))
0771 return;
0772 }
0773 if (!beamspot__.isUninitialized()) {
0774 edm::Handle<reco::BeamSpot> beamspot;
0775 if (!event.getByToken(beamspot__, beamspot))
0776 return;
0777 if (!(*beamspotSelect_)(*beamspot))
0778 return;
0779 }
0780
0781 unsigned int nJetSteps = -1;
0782
0783 for (std::vector<std::string>::const_iterator selIt = selectionOrder_.begin(); selIt != selectionOrder_.end();
0784 ++selIt) {
0785 std::string key = selectionStep(*selIt), type = objectType(*selIt);
0786 if (selection_.find(key) != selection_.end()) {
0787 if (type == "empty") {
0788 selection_[key].second->fill(event, setup);
0789 }
0790 if (type == "muons" && MuonStep != nullptr) {
0791 if (MuonStep->select(event)) {
0792 selection_[key].second->fill(event, setup);
0793 } else
0794 break;
0795 }
0796
0797 if (type == "elecs" && ElectronStep != nullptr) {
0798 if (ElectronStep->select(event)) {
0799 selection_[key].second->fill(event, setup);
0800 } else
0801 break;
0802 }
0803
0804 if (type == "pvs" && PvStep != nullptr) {
0805 if (PvStep->selectVertex(event)) {
0806 selection_[key].second->fill(event, setup);
0807 } else
0808 break;
0809 }
0810
0811 if (type == "jets") {
0812 nJetSteps++;
0813 if (JetSteps[nJetSteps] != nullptr) {
0814 if (JetSteps[nJetSteps]->select(event, setup)) {
0815 selection_[key].second->fill(event, setup);
0816 } else
0817 break;
0818 }
0819 }
0820
0821 if (type == "met" && METStep != nullptr) {
0822 if (METStep->select(event)) {
0823 selection_[key].second->fill(event, setup);
0824 } else
0825 break;
0826 }
0827 }
0828 }
0829 }
0830
0831
0832
0833
0834