| 50 |
|
doMuons = iConfig.getParameter<bool>("doMuons"); |
| 51 |
|
doTaus = iConfig.getParameter<bool>("doTaus"); |
| 52 |
|
doJets = iConfig.getParameter<bool>("doJets"); |
| 53 |
+ |
doGenTopJets = iConfig.getParameter<bool>("doGenTopJets"); |
| 54 |
|
doPhotons = iConfig.getParameter<bool>("doPhotons"); |
| 55 |
|
doMET = iConfig.getParameter<bool>("doMET"); |
| 56 |
|
doGenInfo = iConfig.getParameter<bool>("doGenInfo"); |
| 57 |
+ |
doAllGenParticles = iConfig.getParameter<bool>("doAllGenParticles"); |
| 58 |
+ |
doLumiInfo = iConfig.getParameter<bool>("doLumiInfo"); |
| 59 |
|
doPV = iConfig.getParameter<bool>("doPV"); |
| 60 |
|
doTopJets = iConfig.getParameter<bool>("doTopJets"); |
| 61 |
+ |
doTrigger = iConfig.getParameter<bool>("doTrigger"); |
| 62 |
|
|
| 63 |
|
// initialization of tree variables |
| 64 |
|
|
| 67 |
|
tr->Branch("luminosityBlock",&luminosityBlock); |
| 68 |
|
tr->Branch("isRealData",&isRealData); |
| 69 |
|
tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult); |
| 70 |
< |
tr->Branch("beamspot_x0",&beamspot_x0); |
| 71 |
< |
tr->Branch("beamspot_y0",&beamspot_y0); |
| 72 |
< |
tr->Branch("beamspot_z0",&beamspot_z0); |
| 73 |
< |
|
| 70 |
> |
if(doLumiInfo){ |
| 71 |
> |
tr->Branch("intgRecLumi",&intgRecLumi); |
| 72 |
> |
tr->Branch("intgDelLumi",&intgDelLumi); |
| 73 |
> |
} |
| 74 |
> |
if(doPV){ |
| 75 |
> |
tr->Branch("beamspot_x0",&beamspot_x0); |
| 76 |
> |
tr->Branch("beamspot_y0",&beamspot_y0); |
| 77 |
> |
tr->Branch("beamspot_z0",&beamspot_z0); |
| 78 |
> |
} |
| 79 |
|
if(doElectrons){ |
| 80 |
|
electron_sources = iConfig.getParameter<std::vector<std::string> >("electron_sources"); |
| 81 |
|
for(size_t j=0; j< electron_sources.size(); ++j){ |
| 112 |
|
tr->Branch( topjet_sources[j].c_str(), "std::vector<TopJet>", &topjets[j]); |
| 113 |
|
} |
| 114 |
|
} |
| 115 |
+ |
if(doGenTopJets){ |
| 116 |
+ |
gentopjet_sources = iConfig.getParameter<std::vector<std::string> >("gentopjet_sources"); |
| 117 |
+ |
gentopjet_ptmin = iConfig.getParameter<double> ("gentopjet_ptmin"); |
| 118 |
+ |
gentopjet_etamax = iConfig.getParameter<double> ("gentopjet_etamax"); |
| 119 |
+ |
for(size_t j=0; j< gentopjet_sources.size(); ++j){ |
| 120 |
+ |
tr->Branch( gentopjet_sources[j].c_str(), "std::vector<TopJet>", &gentopjets[j]); |
| 121 |
+ |
} |
| 122 |
+ |
} |
| 123 |
|
if(doPhotons){ |
| 124 |
|
photon_sources = iConfig.getParameter<std::vector<std::string> >("photon_sources"); |
| 125 |
|
for(size_t j=0; j< photon_sources.size(); ++j){ |
| 142 |
|
tr->Branch("genInfo","GenInfo",&genInfo); |
| 143 |
|
tr->Branch("GenParticles","std::vector<GenParticle>", &genps); |
| 144 |
|
} |
| 145 |
< |
|
| 146 |
< |
trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes"); |
| 147 |
< |
//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults); |
| 148 |
< |
tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames); |
| 149 |
< |
tr->Branch("triggerResults", "std::vector<bool>", &triggerResults); |
| 150 |
< |
tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale); |
| 151 |
< |
tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale); |
| 152 |
< |
|
| 145 |
> |
if(doTrigger){ |
| 146 |
> |
trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes"); |
| 147 |
> |
//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults); |
| 148 |
> |
tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames); |
| 149 |
> |
tr->Branch("triggerResults", "std::vector<bool>", &triggerResults); |
| 150 |
> |
tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale); |
| 151 |
> |
tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale); |
| 152 |
> |
} |
| 153 |
|
newrun = true; |
| 154 |
|
} |
| 155 |
|
|
| 188 |
|
} |
| 189 |
|
else HBHENoiseFilterResult = false; |
| 190 |
|
|
| 191 |
+ |
// ------------- primary vertices and beamspot ------------- |
| 192 |
+ |
|
| 193 |
+ |
if(doPV){ |
| 194 |
+ |
for(size_t j=0; j< pv_sources.size(); ++j){ |
| 195 |
+ |
pvs[j].clear(); |
| 196 |
+ |
|
| 197 |
+ |
edm::Handle< std::vector<reco::Vertex> > pv_handle; |
| 198 |
+ |
iEvent.getByLabel(pv_sources[j], pv_handle); |
| 199 |
+ |
const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product()); |
| 200 |
+ |
|
| 201 |
+ |
for (unsigned int i = 0; i < reco_pvs.size(); ++i) { |
| 202 |
+ |
reco::Vertex reco_pv = reco_pvs[i]; |
| 203 |
+ |
|
| 204 |
+ |
PrimaryVertex pv; |
| 205 |
+ |
pv.x = reco_pv.x(); |
| 206 |
+ |
pv.y = reco_pv.y(); |
| 207 |
+ |
pv.z = reco_pv.z(); |
| 208 |
+ |
pv.nTracks = reco_pv.nTracks(); |
| 209 |
+ |
//pv.isValid = reco_pv.isValid(); |
| 210 |
+ |
pv.chi2 = reco_pv.chi2(); |
| 211 |
+ |
pv.ndof = reco_pv.ndof(); |
| 212 |
+ |
|
| 213 |
+ |
pvs[j].push_back(pv); |
| 214 |
+ |
} |
| 215 |
+ |
} |
| 216 |
+ |
|
| 217 |
+ |
edm::Handle<reco::BeamSpot> beamSpot; |
| 218 |
+ |
iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot); |
| 219 |
+ |
const reco::BeamSpot & bsp = *beamSpot; |
| 220 |
+ |
|
| 221 |
+ |
beamspot_x0 = bsp.x0(); |
| 222 |
+ |
beamspot_y0 = bsp.y0(); |
| 223 |
+ |
beamspot_z0 = bsp.z0(); |
| 224 |
+ |
} |
| 225 |
+ |
|
| 226 |
|
// ------------- electrons ------------- |
| 227 |
|
if(doElectrons){ |
| 228 |
+ |
|
| 229 |
+ |
edm::Handle<reco::ConversionCollection> hConversions; |
| 230 |
+ |
iEvent.getByLabel("allConversions", hConversions); |
| 231 |
+ |
|
| 232 |
+ |
edm::Handle<reco::BeamSpot> beamSpot; |
| 233 |
+ |
iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot); |
| 234 |
+ |
const reco::BeamSpot & bsp = *beamSpot; |
| 235 |
+ |
|
| 236 |
|
for(size_t j=0; j< electron_sources.size(); ++j){ |
| 237 |
|
eles[j].clear(); |
| 238 |
|
edm::Handle< std::vector<pat::Electron> > ele_handle; |
| 258 |
|
ele.neutralHadronIso = pat_ele.neutralHadronIso(); |
| 259 |
|
ele.chargedHadronIso = pat_ele.chargedHadronIso(); |
| 260 |
|
ele.trackIso = pat_ele.trackIso(); |
| 261 |
+ |
ele.photonIso = pat_ele.photonIso(); |
| 262 |
|
ele.puChargedHadronIso = pat_ele.puChargedHadronIso(); |
| 263 |
+ |
ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits(); |
| 264 |
+ |
ele.gsfTrack_px= pat_ele.gsfTrack()->px(); |
| 265 |
+ |
ele.gsfTrack_py= pat_ele.gsfTrack()->py(); |
| 266 |
+ |
ele.gsfTrack_pz= pat_ele.gsfTrack()->pz(); |
| 267 |
+ |
ele.gsfTrack_vx= pat_ele.gsfTrack()->vx(); |
| 268 |
+ |
ele.gsfTrack_vy= pat_ele.gsfTrack()->vy(); |
| 269 |
+ |
ele.gsfTrack_vz= pat_ele.gsfTrack()->vz(); |
| 270 |
+ |
ele.passconversionveto = !ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()); |
| 271 |
+ |
ele.dEtaIn=pat_ele.deltaEtaSuperClusterTrackAtVtx(); |
| 272 |
+ |
ele.dPhiIn=pat_ele.deltaPhiSuperClusterTrackAtVtx(); |
| 273 |
+ |
ele.sigmaIEtaIEta=pat_ele.sigmaIetaIeta(); |
| 274 |
+ |
ele.HoverE=pat_ele.hadronicOverEm(); |
| 275 |
+ |
ele.fbrem=pat_ele.fbrem(); |
| 276 |
+ |
ele.EoverPIn=pat_ele.eSuperClusterOverP(); |
| 277 |
+ |
ele.EcalEnergy=pat_ele.ecalEnergy(); |
| 278 |
+ |
//ele.mvaTrigV0=pat_ele.electronID("mvaTrigV0"); |
| 279 |
+ |
//ele.mvaNonTrigV0=pat_ele.electronID("mvaNonTrigV0"); |
| 280 |
|
|
| 281 |
|
eles[j].push_back(ele); |
| 282 |
|
} |
| 309 |
|
mu.neutralHadronIso = pat_mu.neutralHadronIso(); |
| 310 |
|
mu.chargedHadronIso = pat_mu.chargedHadronIso(); |
| 311 |
|
mu.trackIso = pat_mu.trackIso(); |
| 312 |
+ |
mu.photonIso = pat_mu.photonIso(); |
| 313 |
|
mu.puChargedHadronIso = pat_mu.puChargedHadronIso(); |
| 314 |
|
mu.isGlobalMuon = pat_mu.isGlobalMuon(); |
| 315 |
|
mu.isStandAloneMuon = pat_mu.isStandAloneMuon(); |
| 340 |
|
mu.innerTrack_d0Error = innerTrack->d0Error(); |
| 341 |
|
mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits(); |
| 342 |
|
mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits(); |
| 343 |
+ |
mu.innerTrack_trackerLayersWithMeasurement = innerTrack->hitPattern().trackerLayersWithMeasurement(); |
| 344 |
+ |
mu.innerTrack_numberOfValidPixelHits = innerTrack->hitPattern().numberOfValidPixelHits(); |
| 345 |
|
} |
| 346 |
|
else{ |
| 347 |
|
mu.innerTrack_chi2 = 0; |
| 350 |
|
mu.innerTrack_d0Error = 0; |
| 351 |
|
mu.innerTrack_numberOfValidHits = 0; |
| 352 |
|
mu.innerTrack_numberOfLostHits = 0; |
| 353 |
+ |
mu.innerTrack_trackerLayersWithMeasurement = 0; |
| 354 |
+ |
mu.innerTrack_numberOfValidPixelHits = 0; |
| 355 |
|
} |
| 356 |
|
reco::TrackRef outerTrack = pat_mu.outerTrack(); |
| 357 |
|
if(!outerTrack.isNull()){ |
| 397 |
|
tau.eta = pat_tau.eta(); |
| 398 |
|
tau.phi = pat_tau.phi(); |
| 399 |
|
tau.energy = pat_tau.energy(); |
| 400 |
< |
|
| 400 |
> |
tau.decayModeFinding = pat_tau.tauID("decayModeFinding")>0.5; |
| 401 |
> |
tau.byVLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5; |
| 402 |
> |
tau.byLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5; |
| 403 |
> |
tau.byMediumCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5; |
| 404 |
> |
tau.byTightCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5; |
| 405 |
> |
tau.againstElectronLoose = pat_tau.tauID("againstElectronLoose")>0.5; |
| 406 |
> |
tau.againstElectronMedium = pat_tau.tauID("againstElectronMedium")>0.5; |
| 407 |
> |
tau.againstElectronTight = pat_tau.tauID("againstElectronTight")>0.5; |
| 408 |
> |
tau.againstElectronMVA = pat_tau.tauID("againstElectronMVA")>0.5; |
| 409 |
> |
tau.againstMuonLoose = pat_tau.tauID("againstMuonLoose")>0.5; |
| 410 |
> |
tau.againstMuonMedium = pat_tau.tauID("againstMuonMedium")>0.5; |
| 411 |
> |
tau.againstMuonTight = pat_tau.tauID("againstMuonTight")>0.5; |
| 412 |
> |
|
| 413 |
> |
reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand(); |
| 414 |
> |
if(!leadPFCand.isNull()){ |
| 415 |
> |
tau.leadPFCand_px = leadPFCand->px(); |
| 416 |
> |
tau.leadPFCand_py = leadPFCand->py(); |
| 417 |
> |
tau.leadPFCand_pz = leadPFCand->pz(); |
| 418 |
> |
} |
| 419 |
> |
else{ |
| 420 |
> |
tau.leadPFCand_px = 0; |
| 421 |
> |
tau.leadPFCand_py = 0; |
| 422 |
> |
tau.leadPFCand_pz = 0; |
| 423 |
> |
} |
| 424 |
|
taus[j].push_back(tau); |
| 425 |
|
} |
| 426 |
|
} |
| 470 |
|
jet.electronMultiplicity =pat_jet.electronMultiplicity(); |
| 471 |
|
jet.photonMultiplicity =pat_jet.photonMultiplicity(); |
| 472 |
|
} |
| 473 |
+ |
|
| 474 |
+ |
jecUnc->setJetEta(pat_jet.eta()); |
| 475 |
+ |
jecUnc->setJetPt(pat_jet.pt()); |
| 476 |
+ |
jet.JEC_uncertainty = jecUnc->getUncertainty(true); |
| 477 |
+ |
jet.JEC_factor_raw = pat_jet.jecFactor("Uncorrected"); |
| 478 |
+ |
|
| 479 |
|
jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"); |
| 480 |
|
jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"); |
| 481 |
|
jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags"); |
| 483 |
|
jet.btag_jetBProbability=pat_jet.bDiscriminator("jetBProbabilityBJetTags"); |
| 484 |
|
jet.btag_jetProbability=pat_jet.bDiscriminator("jetProbabilityBJetTags"); |
| 485 |
|
|
| 486 |
+ |
const reco::GenJet *genj = pat_jet.genJet(); |
| 487 |
+ |
if(genj){ |
| 488 |
+ |
jet.genjet_pt = genj->pt(); |
| 489 |
+ |
jet.genjet_eta = genj->eta(); |
| 490 |
+ |
jet.genjet_phi = genj->phi(); |
| 491 |
+ |
jet.genjet_energy = genj->energy(); |
| 492 |
+ |
} |
| 493 |
+ |
|
| 494 |
|
jets[j].push_back(jet); |
| 495 |
|
} |
| 496 |
|
} |
| 507 |
|
iEvent.getByLabel(topjet_sources[j], pat_topjets); |
| 508 |
|
|
| 509 |
|
for (unsigned int i = 0; i < pat_topjets->size(); i++) { |
| 510 |
+ |
|
| 511 |
|
const pat::Jet pat_topjet = * dynamic_cast<pat::Jet const *>(&pat_topjets->at(i)); |
| 512 |
|
if(pat_topjet.pt() < topjet_ptmin) continue; |
| 513 |
|
if(fabs(pat_topjet.eta()) > topjet_etamax) continue; |
| 535 |
|
// topjet.electronMultiplicity =pat_topjet.electronMultiplicity(); |
| 536 |
|
// topjet.photonMultiplicity =pat_topjet.photonMultiplicity(); |
| 537 |
|
|
| 538 |
+ |
jecUnc->setJetEta(pat_topjet.eta()); |
| 539 |
+ |
jecUnc->setJetPt(pat_topjet.pt()); |
| 540 |
+ |
topjet.JEC_uncertainty = jecUnc->getUncertainty(true); |
| 541 |
+ |
topjet.JEC_factor_raw = pat_topjet.jecFactor("Uncorrected"); |
| 542 |
+ |
|
| 543 |
|
topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"); |
| 544 |
|
topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"); |
| 545 |
|
topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags"); |
| 547 |
|
topjet.btag_jetBProbability=pat_topjet.bDiscriminator("jetBProbabilityBJetTags"); |
| 548 |
|
topjet.btag_jetProbability=pat_topjet.bDiscriminator("jetProbabilityBJetTags"); |
| 549 |
|
|
| 550 |
+ |
const reco::GenJet *genj = pat_topjet.genJet(); |
| 551 |
+ |
if(genj){ |
| 552 |
+ |
topjet.genjet_pt = genj->pt(); |
| 553 |
+ |
topjet.genjet_eta = genj->eta(); |
| 554 |
+ |
topjet.genjet_phi = genj->phi(); |
| 555 |
+ |
topjet.genjet_energy = genj->energy(); |
| 556 |
+ |
} |
| 557 |
+ |
|
| 558 |
|
for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) { |
| 559 |
|
Particle subjet_v4; |
| 560 |
|
subjet_v4.pt = pat_topjet.daughter(k)->p4().pt(); |
| 568 |
|
} |
| 569 |
|
} |
| 570 |
|
|
| 571 |
+ |
|
| 572 |
+ |
// ------------- generator top jets ------------- |
| 573 |
+ |
if(doGenTopJets){ |
| 574 |
+ |
for(size_t j=0; j< gentopjet_sources.size(); ++j){ |
| 575 |
+ |
|
| 576 |
+ |
gentopjets[j].clear(); |
| 577 |
+ |
|
| 578 |
+ |
edm::Handle<reco::BasicJetCollection> reco_gentopjets; |
| 579 |
+ |
//edm::Handle<std::vector<reco::Jet> > reco_gentopjets; |
| 580 |
+ |
iEvent.getByLabel(gentopjet_sources[j], reco_gentopjets); |
| 581 |
+ |
|
| 582 |
+ |
for (unsigned int i = 0; i < reco_gentopjets->size(); i++) { |
| 583 |
+ |
|
| 584 |
+ |
const reco::BasicJet reco_gentopjet = reco_gentopjets->at(i); |
| 585 |
+ |
if(reco_gentopjet.pt() < gentopjet_ptmin) continue; |
| 586 |
+ |
if(fabs(reco_gentopjet.eta()) > gentopjet_etamax) continue; |
| 587 |
+ |
|
| 588 |
+ |
TopJet gentopjet; |
| 589 |
+ |
gentopjet.charge = reco_gentopjet.charge(); |
| 590 |
+ |
gentopjet.pt = reco_gentopjet.pt(); |
| 591 |
+ |
gentopjet.eta = reco_gentopjet.eta(); |
| 592 |
+ |
gentopjet.phi = reco_gentopjet.phi(); |
| 593 |
+ |
gentopjet.energy = reco_gentopjet.energy(); |
| 594 |
+ |
gentopjet.numberOfDaughters =reco_gentopjet.numberOfDaughters(); |
| 595 |
+ |
|
| 596 |
+ |
for (unsigned int k = 0; k < reco_gentopjet.numberOfDaughters(); k++) { |
| 597 |
+ |
Particle subjet_v4; |
| 598 |
+ |
subjet_v4.pt = reco_gentopjet.daughter(k)->p4().pt(); |
| 599 |
+ |
subjet_v4.eta = reco_gentopjet.daughter(k)->p4().eta(); |
| 600 |
+ |
subjet_v4.phi = reco_gentopjet.daughter(k)->p4().phi(); |
| 601 |
+ |
subjet_v4.energy = reco_gentopjet.daughter(k)->p4().E(); |
| 602 |
+ |
gentopjet.subjets.push_back(subjet_v4); |
| 603 |
+ |
} |
| 604 |
+ |
gentopjets[j].push_back(gentopjet); |
| 605 |
+ |
} |
| 606 |
+ |
} |
| 607 |
+ |
} |
| 608 |
+ |
|
| 609 |
|
// ------------- photons ------------- |
| 610 |
|
if(doPhotons){ |
| 611 |
|
for(size_t j=0; j< photon_sources.size(); ++j){ |
| 659 |
|
} |
| 660 |
|
|
| 661 |
|
// ------------- trigger ------------- |
| 662 |
< |
|
| 663 |
< |
edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD"); |
| 664 |
< |
edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent; |
| 665 |
< |
iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent ); |
| 666 |
< |
|
| 667 |
< |
const edm::Provenance *meta = dummy_TriggerEvent.provenance(); |
| 668 |
< |
std::string nameProcess = meta->processName(); |
| 669 |
< |
edm::InputTag triggerResultTag = edm::InputTag("TriggerResults"); |
| 670 |
< |
triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess ); |
| 671 |
< |
|
| 672 |
< |
edm::Handle<edm::TriggerResults> trigger; |
| 673 |
< |
iEvent.getByLabel(triggerResultTag, trigger); |
| 674 |
< |
const edm::TriggerResults& trig = *(trigger.product()); |
| 675 |
< |
|
| 676 |
< |
triggerResults.clear(); |
| 677 |
< |
triggerNames.clear(); |
| 678 |
< |
L1_prescale.clear(); |
| 679 |
< |
HLT_prescale.clear(); |
| 680 |
< |
|
| 681 |
< |
edm::Service<edm::service::TriggerNamesService> tns; |
| 682 |
< |
std::vector<std::string> triggerNames_all; |
| 683 |
< |
tns->getTrigPaths(trig,triggerNames_all); |
| 684 |
< |
|
| 685 |
< |
if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl; |
| 686 |
< |
for(unsigned int i=0; i<trig.size(); ++i){ |
| 687 |
< |
std::vector<std::string>::const_iterator it = trigger_prefixes.begin(); |
| 688 |
< |
for(; it!=trigger_prefixes.end(); ++it){ |
| 689 |
< |
if(triggerNames_all[i].substr(0, it->size()) == *it)break; |
| 690 |
< |
} |
| 691 |
< |
if(it==trigger_prefixes.end()) continue; |
| 692 |
< |
|
| 693 |
< |
//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i))); |
| 694 |
< |
triggerResults.push_back(trig.accept(i)); |
| 695 |
< |
if(newrun) triggerNames.push_back(triggerNames_all[i]); |
| 696 |
< |
if(isRealData){ |
| 697 |
< |
std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]); |
| 698 |
< |
L1_prescale.push_back(pre.first); |
| 699 |
< |
HLT_prescale.push_back(pre.second); |
| 700 |
< |
} |
| 701 |
< |
} |
| 702 |
< |
// for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){ |
| 703 |
< |
// std::cout << (*iter).first << " " << (*iter).second << std::endl; |
| 704 |
< |
// } |
| 705 |
< |
newrun=false; |
| 662 |
> |
if(doTrigger){ |
| 663 |
> |
edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD"); |
| 664 |
> |
edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent; |
| 665 |
> |
iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent ); |
| 666 |
> |
|
| 667 |
> |
const edm::Provenance *meta = dummy_TriggerEvent.provenance(); |
| 668 |
> |
std::string nameProcess = meta->processName(); |
| 669 |
> |
edm::InputTag triggerResultTag = edm::InputTag("TriggerResults"); |
| 670 |
> |
triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess ); |
| 671 |
> |
|
| 672 |
> |
edm::Handle<edm::TriggerResults> trigger; |
| 673 |
> |
iEvent.getByLabel(triggerResultTag, trigger); |
| 674 |
> |
const edm::TriggerResults& trig = *(trigger.product()); |
| 675 |
> |
|
| 676 |
> |
triggerResults.clear(); |
| 677 |
> |
triggerNames.clear(); |
| 678 |
> |
L1_prescale.clear(); |
| 679 |
> |
HLT_prescale.clear(); |
| 680 |
> |
|
| 681 |
> |
edm::Service<edm::service::TriggerNamesService> tns; |
| 682 |
> |
std::vector<std::string> triggerNames_all; |
| 683 |
> |
tns->getTrigPaths(trig,triggerNames_all); |
| 684 |
> |
|
| 685 |
> |
if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl; |
| 686 |
> |
for(unsigned int i=0; i<trig.size(); ++i){ |
| 687 |
> |
std::vector<std::string>::const_iterator it = trigger_prefixes.begin(); |
| 688 |
> |
for(; it!=trigger_prefixes.end(); ++it){ |
| 689 |
> |
if(triggerNames_all[i].substr(0, it->size()) == *it)break; |
| 690 |
> |
} |
| 691 |
> |
if(it==trigger_prefixes.end()) continue; |
| 692 |
> |
|
| 693 |
> |
//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i))); |
| 694 |
> |
triggerResults.push_back(trig.accept(i)); |
| 695 |
> |
if(newrun) triggerNames.push_back(triggerNames_all[i]); |
| 696 |
> |
if(isRealData){ |
| 697 |
> |
std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]); |
| 698 |
> |
L1_prescale.push_back(pre.first); |
| 699 |
> |
HLT_prescale.push_back(pre.second); |
| 700 |
> |
//std::cout << triggerNames_all[i] << " " << pre.first << " " <<pre.second << " " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl; |
| 701 |
> |
} |
| 702 |
> |
} |
| 703 |
> |
// for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){ |
| 704 |
> |
// std::cout << (*iter).first << " " << (*iter).second << std::endl; |
| 705 |
> |
// } |
| 706 |
> |
newrun=false; |
| 707 |
> |
} |
| 708 |
|
|
| 709 |
|
// ------------- generator info ------------- |
| 710 |
|
|
| 769 |
|
index++; |
| 770 |
|
|
| 771 |
|
//write out only top quarks and status 3 particles (works fine only for MadGraph) |
| 772 |
< |
if(abs(iter->pdgId())==6 || iter->status()==3){ |
| 772 |
> |
if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){ |
| 773 |
|
GenParticle genp; |
| 774 |
|
genp.charge = iter->charge();; |
| 775 |
|
genp.pt = iter->p4().pt(); |
| 787 |
|
|
| 788 |
|
int nm=iter->numberOfMothers(); |
| 789 |
|
int nd=iter->numberOfDaughters(); |
| 790 |
+ |
|
| 791 |
|
|
| 792 |
|
if (nm>0) genp.mother1 = iter->motherRef(0).key(); |
| 793 |
< |
if (nm>1) genp.mother2 = iter->motherRef(nm-1).key(); |
| 793 |
> |
if (nm>1) genp.mother2 = iter->motherRef(1).key(); |
| 794 |
|
if (nd>0) genp.daughter1 = iter->daughterRef(0).key(); |
| 795 |
< |
if (nd>1) genp.daughter2 = iter->daughterRef(nd-1).key(); |
| 796 |
< |
|
| 795 |
> |
if (nd>1) genp.daughter2 = iter->daughterRef(1).key(); |
| 796 |
> |
//std::cout << genp.index <<" pdgId = " << genp.pdgId << " mo1 = " << genp.mother1 << " mo2 = " << genp.mother2 <<" da1 = " << genp.daughter1 << " da2 = " << genp.daughter2 <<std::endl; |
| 797 |
|
genps.push_back(genp); |
| 798 |
|
} |
| 799 |
|
} |
| 800 |
|
|
| 801 |
|
} |
| 802 |
|
|
| 628 |
– |
// ------------- primary vertices and beamspot ------------- |
| 629 |
– |
|
| 630 |
– |
if(doPV){ |
| 631 |
– |
for(size_t j=0; j< pv_sources.size(); ++j){ |
| 632 |
– |
pvs[j].clear(); |
| 633 |
– |
|
| 634 |
– |
edm::Handle< std::vector<reco::Vertex> > pv_handle; |
| 635 |
– |
iEvent.getByLabel(pv_sources[j], pv_handle); |
| 636 |
– |
const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product()); |
| 637 |
– |
|
| 638 |
– |
for (unsigned int i = 0; i < reco_pvs.size(); ++i) { |
| 639 |
– |
reco::Vertex reco_pv = reco_pvs[i]; |
| 640 |
– |
|
| 641 |
– |
PrimaryVertex pv; |
| 642 |
– |
pv.x = reco_pv.x(); |
| 643 |
– |
pv.y = reco_pv.y(); |
| 644 |
– |
pv.z = reco_pv.z(); |
| 645 |
– |
pv.nTracks = reco_pv.nTracks(); |
| 646 |
– |
//pv.isValid = reco_pv.isValid(); |
| 647 |
– |
pv.chi2 = reco_pv.chi2(); |
| 648 |
– |
pv.ndof = reco_pv.ndof(); |
| 649 |
– |
|
| 650 |
– |
pvs[j].push_back(pv); |
| 651 |
– |
} |
| 652 |
– |
} |
| 653 |
– |
} |
| 654 |
– |
|
| 655 |
– |
edm::Handle<reco::BeamSpot> beamSpot; |
| 656 |
– |
iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot); |
| 657 |
– |
const reco::BeamSpot & bsp = *beamSpot; |
| 658 |
– |
|
| 659 |
– |
beamspot_x0 = bsp.x0(); |
| 660 |
– |
beamspot_y0 = bsp.y0(); |
| 661 |
– |
beamspot_z0 = bsp.z0(); |
| 662 |
– |
|
| 803 |
|
tr->Fill(); |
| 804 |
< |
|
| 804 |
> |
if(doLumiInfo) |
| 805 |
> |
previouslumiblockwasfilled=true; |
| 806 |
|
} |
| 807 |
|
|
| 808 |
|
|
| 810 |
|
void |
| 811 |
|
NtupleWriter::beginJob() |
| 812 |
|
{ |
| 813 |
+ |
if(doLumiInfo){ |
| 814 |
+ |
totalRecLumi=0; |
| 815 |
+ |
totalDelLumi=0; |
| 816 |
+ |
previouslumiblockwasfilled=false; |
| 817 |
+ |
} |
| 818 |
|
} |
| 819 |
|
|
| 820 |
|
// ------------ method called once each job just after ending the event loop ------------ |
| 830 |
|
void |
| 831 |
|
NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) |
| 832 |
|
{ |
| 833 |
< |
bool setup_changed = false; |
| 834 |
< |
hlt_cfg.init(iRun, iSetup, "HLT", setup_changed); |
| 835 |
< |
newrun=true; |
| 833 |
> |
if(doTrigger){ |
| 834 |
> |
bool setup_changed = false; |
| 835 |
> |
hlt_cfg.init(iRun, iSetup, "HLT", setup_changed); |
| 836 |
> |
newrun=true; |
| 837 |
> |
} |
| 838 |
> |
|
| 839 |
> |
if(doJets || doTopJets){ |
| 840 |
> |
edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl; |
| 841 |
> |
iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl); |
| 842 |
> |
JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"]; |
| 843 |
> |
jecUnc = new JetCorrectionUncertainty(JetCorPar); |
| 844 |
> |
} |
| 845 |
|
} |
| 846 |
|
|
| 847 |
|
// ------------ method called when ending the processing of a run ------------ |
| 848 |
|
void |
| 849 |
|
NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&) |
| 850 |
|
{ |
| 851 |
+ |
if(doLumiInfo) |
| 852 |
+ |
std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl; |
| 853 |
|
} |
| 854 |
|
|
| 855 |
|
// ------------ method called when starting to processes a luminosity block ------------ |
| 856 |
|
void |
| 857 |
< |
NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) |
| 857 |
> |
NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&) |
| 858 |
|
{ |
| 859 |
+ |
if(doLumiInfo){ |
| 860 |
+ |
edm::Handle<LumiSummary> l; |
| 861 |
+ |
lumi.getByLabel("lumiProducer", l); |
| 862 |
+ |
|
| 863 |
+ |
//add lumi of lumi blocks without any event to next lumiblock |
| 864 |
+ |
if(previouslumiblockwasfilled){ |
| 865 |
+ |
intgRecLumi=0; |
| 866 |
+ |
intgDelLumi=0; |
| 867 |
+ |
} |
| 868 |
+ |
previouslumiblockwasfilled=false; |
| 869 |
+ |
|
| 870 |
+ |
if (l.isValid()){; |
| 871 |
+ |
intgRecLumi+=l->intgRecLumi()*6.37; |
| 872 |
+ |
intgDelLumi+=l->intgDelLumi()*6.37; |
| 873 |
+ |
totalRecLumi+=l->intgRecLumi()*6.37; |
| 874 |
+ |
totalDelLumi+=l->intgDelLumi()*6.37; |
| 875 |
+ |
} |
| 876 |
+ |
//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<" " << l->intgDelLumi()*6.37<<std::endl; |
| 877 |
+ |
//std::cout << "summed: "<< intgRecLumi << " " << intgDelLumi << std::endl; |
| 878 |
+ |
} |
| 879 |
|
} |
| 880 |
|
|
| 881 |
|
// ------------ method called when ending the processing of a luminosity block ------------ |
