ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/UHHAnalysis/NtupleWriter/src/NtupleWriter.cc

Comparing UserCode/UHHAnalysis/NtupleWriter/src/NtupleWriter.cc (file contents):
Revision 1.14 by peiffer, Mon Apr 23 14:26:23 2012 UTC vs.
Revision 1.18 by peiffer, Wed May 30 13:20:08 2012 UTC

#	Line 66 | Line 66 | NtupleWriter::NtupleWriter(const edm::Pa
66		tr->Branch("event",&event);
67		tr->Branch("luminosityBlock",&luminosityBlock);
68		tr->Branch("isRealData",&isRealData);
69	<	tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
69	>	tr->Branch("rho",&rho);
70	>	rho_source = iConfig.getParameter<edm::InputTag>("rho_source");
71	>
72	>	//tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
73		if(doLumiInfo){
74		tr->Branch("intgRecLumi",&intgRecLumi);
75		tr->Branch("intgDelLumi",&intgDelLumi);
#	Line 147 | Line 150 | NtupleWriter::NtupleWriter(const edm::Pa
150		//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
151		tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
152		tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
153	<	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
154	<	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
153	>	//tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
154	>	//tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
155		}
156		newrun = true;
157		}
#	Line 181 | Line 184 | NtupleWriter::analyze(const edm::Event&
184		luminosityBlock = iEvent.luminosityBlock();
185		isRealData      = iEvent.isRealData();
186
187	<	if(isRealData){
188	<	edm::Handle<bool> bool_handle;
189	<	iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
190	<	HBHENoiseFilterResult = *(bool_handle.product());
191	<	}
192	<	else HBHENoiseFilterResult = false;
187	>	edm::Handle<double> m_rho;
188	>	iEvent.getByLabel(rho_source,m_rho);
189	>	rho=*m_rho;
190	>
191	>	//    if(isRealData){
192	>	//      edm::Handle<bool> bool_handle;
193	>	//      iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
194	>	//      HBHENoiseFilterResult = *(bool_handle.product());
195	>	//    }
196	>	//    else HBHENoiseFilterResult = false;
197
198		// ------------- primary vertices and beamspot  -------------
199
#	Line 202 | Line 209 | NtupleWriter::analyze(const edm::Event&
209		reco::Vertex reco_pv = reco_pvs[i];
210
211		PrimaryVertex pv;
212	<	pv.x =  reco_pv.x();
213	<	pv.y =  reco_pv.y();
214	<	pv.z =  reco_pv.z();
215	<	pv.nTracks =  reco_pv.nTracks();
216	<	//pv.isValid =  reco_pv.isValid();
217	<	pv.chi2 =  reco_pv.chi2();
218	<	pv.ndof =  reco_pv.ndof();
212	>	pv.set_x( reco_pv.x());
213	>	pv.set_y( reco_pv.y());
214	>	pv.set_z( reco_pv.z());
215	>	pv.set_nTracks( reco_pv.nTracks());
216	>	//pv.set_isValid( reco_pv.isValid());
217	>	pv.set_chi2( reco_pv.chi2());
218	>	pv.set_ndof( reco_pv.ndof());
219
220		pvs[j].push_back(pv);
221		}
#	Line 223 | Line 230 | NtupleWriter::analyze(const edm::Event&
230		beamspot_z0 = bsp.z0();
231		}
232
233	+	// ------------- generator info -------------
234	+
235	+	if(doGenInfo){
236	+	genInfo.clear_weights();
237	+	genInfo.clear_binningValues();
238	+	genps.clear();
239	+
240	+	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
241	+	iEvent.getByLabel("generator", genEventInfoProduct);
242	+	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
243	+
244	+	for(unsigned int k=0; k<genEventInfo.binningValues().size();++k){
245	+	genInfo.add_binningValue(genEventInfo.binningValues().at(k));
246	+	}
247	+	for(unsigned int k=0; k<genEventInfo.weights().size();++k){
248	+	genInfo.add_weight(genEventInfo.weights().at(k));
249	+	}
250	+	genInfo.set_alphaQCD(genEventInfo.alphaQCD());
251	+	genInfo.set_alphaQED(genEventInfo.alphaQED());
252	+	genInfo.set_qScale(genEventInfo.qScale());
253	+
254	+	const gen::PdfInfo* pdf = genEventInfo.pdf();
255	+	if(pdf){
256	+	genInfo.set_pdf_id1(pdf->id.first);
257	+	genInfo.set_pdf_id2(pdf->id.second);
258	+	genInfo.set_pdf_x1(pdf->x.first);
259	+	genInfo.set_pdf_x2(pdf->x.second);
260	+	genInfo.set_pdf_scalePDF(pdf->scalePDF);
261	+	genInfo.set_pdf_xPDF1(pdf->xPDF.first);
262	+	genInfo.set_pdf_xPDF2(pdf->xPDF.second);
263	+	}
264	+	else{
265	+	genInfo.set_pdf_id1(-999);
266	+	genInfo.set_pdf_id2(-999);
267	+	genInfo.set_pdf_x1(-999);
268	+	genInfo.set_pdf_x2(-999);
269	+	genInfo.set_pdf_scalePDF(-999);
270	+	genInfo.set_pdf_xPDF1(-999);
271	+	genInfo.set_pdf_xPDF2(-999);
272	+	}
273	+
274	+	edm::Handle<std::vector<PileupSummaryInfo> > pus;
275	+	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
276	+	genInfo.set_pileup_NumInteractions_intime(0);
277	+	genInfo.set_pileup_NumInteractions_ootbefore(0);
278	+	genInfo.set_pileup_NumInteractions_ootafter(0);
279	+	if(pus.isValid()){
280	+	genInfo.set_pileup_TrueNumInteractions ( (float) pus->at(0).getTrueNumInteractions());
281	+	for(size_t i=0; i<pus->size(); ++i){
282	+	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
283	+	genInfo.set_pileup_NumInteractions_intime( genInfo.pileup_NumInteractions_intime() + pus->at(i).getPU_NumInteractions());
284	+	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
285	+	genInfo.set_pileup_NumInteractions_ootbefore( genInfo.pileup_NumInteractions_ootbefore() + pus->at(i).getPU_NumInteractions());
286	+	}
287	+	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
288	+	genInfo.set_pileup_NumInteractions_ootafter( genInfo.pileup_NumInteractions_ootafter() + pus->at(i).getPU_NumInteractions());
289	+	}
290	+	}
291	+	}
292	+
293	+	edm::Handle<reco::GenParticleCollection> genPartColl;
294	+	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
295	+	int index=-1;
296	+	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
297	+	index++;
298	+
299	+	//write out only top quarks and status 3 particles (works fine only for MadGraph)
300	+	if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){
301	+	GenParticle genp;
302	+	genp.set_charge(iter->charge());
303	+	genp.set_pt(iter->p4().pt());
304	+	genp.set_eta(iter->p4().eta());
305	+	genp.set_phi(iter->p4().phi());
306	+	genp.set_energy(iter->p4().E());
307	+	genp.set_index(index);
308	+	genp.set_status( iter->status());
309	+	genp.set_pdgId( iter->pdgId());
310	+
311	+	genp.set_mother1(-1);
312	+	genp.set_mother2(-1);
313	+	genp.set_daughter1(-1);
314	+	genp.set_daughter2(-1);
315	+
316	+	int nm=iter->numberOfMothers();
317	+	int nd=iter->numberOfDaughters();
318	+
319	+
320	+	if (nm>0) genp.set_mother1( iter->motherRef(0).key());
321	+	if (nm>1) genp.set_mother2( iter->motherRef(1).key());
322	+	if (nd>0) genp.set_daughter1( iter->daughterRef(0).key());
323	+	if (nd>1) genp.set_daughter2( iter->daughterRef(1).key());
324	+
325	+	genps.push_back(genp);
326	+	}
327	+	}
328	+	}
329	+
330		// ------------- electrons -------------
331		if(doElectrons){
332
#	Line 243 | Line 347 | NtupleWriter::analyze(const edm::Event&
347		pat::Electron pat_ele = pat_electrons[i];
348		Electron ele;
349
350	<	ele.charge =  pat_ele.charge();
351	<	ele.pt =  pat_ele.pt();
352	<	ele.eta =  pat_ele.eta();
353	<	ele.phi =  pat_ele.phi();
354	<	ele.energy =  pat_ele.energy();
355	<	ele.vertex_x = pat_ele.vertex().x();
356	<	ele.vertex_y = pat_ele.vertex().y();
357	<	ele.vertex_z = pat_ele.vertex().z();
358	<	ele.supercluster_eta = pat_ele.superCluster()->eta();
359	<	ele.supercluster_phi = pat_ele.superCluster()->phi();
360	<	ele.dB = pat_ele.dB();
361	<	//ele.particleIso = pat_ele.particleIso();
362	<	ele.neutralHadronIso = pat_ele.neutralHadronIso();
363	<	ele.chargedHadronIso = pat_ele.chargedHadronIso();
364	<	ele.trackIso = pat_ele.trackIso();
365	<	ele.photonIso = pat_ele.photonIso();
366	<	ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
367	<	ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
368	<	ele.gsfTrack_px= pat_ele.gsfTrack()->px();
369	<	ele.gsfTrack_py= pat_ele.gsfTrack()->py();
370	<	ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
371	<	ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
372	<	ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
373	<	ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
374	<	ele.passconversionveto = !ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position());
375	<	ele.dEtaIn=pat_ele.deltaEtaSuperClusterTrackAtVtx();
376	<	ele.dPhiIn=pat_ele.deltaPhiSuperClusterTrackAtVtx();
377	<	ele.sigmaIEtaIEta=pat_ele.sigmaIetaIeta();
378	<	ele.HoverE=pat_ele.hadronicOverEm();
379	<	ele.fbrem=pat_ele.fbrem();
380	<	ele.EoverPIn=pat_ele.eSuperClusterOverP();
381	<	ele.EcalEnergy=pat_ele.ecalEnergy();
382	<	//ele.mvaTrigV0=pat_ele.electronID("mvaTrigV0");
383	<	//ele.mvaNonTrigV0=pat_ele.electronID("mvaNonTrigV0");
350	>	ele.set_charge( pat_ele.charge());
351	>	ele.set_pt( pat_ele.pt());
352	>	ele.set_eta( pat_ele.eta());
353	>	ele.set_phi( pat_ele.phi());
354	>	ele.set_energy( pat_ele.energy());
355	>	ele.set_vertex_x(pat_ele.vertex().x());
356	>	ele.set_vertex_y(pat_ele.vertex().y());
357	>	ele.set_vertex_z(pat_ele.vertex().z());
358	>	ele.set_supercluster_eta(pat_ele.superCluster()->eta());
359	>	ele.set_supercluster_phi(pat_ele.superCluster()->phi());
360	>	ele.set_dB(pat_ele.dB());
361	>	//ele.set_particleIso(pat_ele.particleIso());
362	>	ele.set_neutralHadronIso(pat_ele.neutralHadronIso());
363	>	ele.set_chargedHadronIso(pat_ele.chargedHadronIso());
364	>	ele.set_trackIso(pat_ele.trackIso());
365	>	ele.set_photonIso(pat_ele.photonIso());
366	>	ele.set_puChargedHadronIso(pat_ele.puChargedHadronIso());
367	>	ele.set_gsfTrack_trackerExpectedHitsInner_numberOfLostHits(pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits());
368	>	ele.set_gsfTrack_px( pat_ele.gsfTrack()->px());
369	>	ele.set_gsfTrack_py( pat_ele.gsfTrack()->py());
370	>	ele.set_gsfTrack_pz( pat_ele.gsfTrack()->pz());
371	>	ele.set_gsfTrack_vx( pat_ele.gsfTrack()->vx());
372	>	ele.set_gsfTrack_vy( pat_ele.gsfTrack()->vy());
373	>	ele.set_gsfTrack_vz( pat_ele.gsfTrack()->vz());
374	>	ele.set_passconversionveto(!ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()));
375	>	ele.set_dEtaIn(pat_ele.deltaEtaSuperClusterTrackAtVtx());
376	>	ele.set_dPhiIn(pat_ele.deltaPhiSuperClusterTrackAtVtx());
377	>	ele.set_sigmaIEtaIEta(pat_ele.sigmaIetaIeta());
378	>	ele.set_HoverE(pat_ele.hadronicOverEm());
379	>	ele.set_fbrem(pat_ele.fbrem());
380	>	ele.set_EoverPIn(pat_ele.eSuperClusterOverP());
381	>	ele.set_EcalEnergy(pat_ele.ecalEnergy());
382	>	//ele.set_mvaTrigV0(pat_ele.electronID("mvaTrigV0"));
383	>	//ele.set_mvaNonTrigV0(pat_ele.electronID("mvaNonTrigV0"));
384
385		eles[j].push_back(ele);
386		}
#	Line 296 | Line 400 | NtupleWriter::analyze(const edm::Event&
400		pat::Muon pat_mu = pat_muons[i];
401
402		Muon mu;
403	<	mu.charge =  pat_mu.charge();
404	<	mu.pt =  pat_mu.pt();
405	<	mu.eta =  pat_mu.eta();
406	<	mu.phi =  pat_mu.phi();
407	<	mu.energy =  pat_mu.energy();
408	<	mu.vertex_x = pat_mu.vertex().x();
409	<	mu.vertex_y = pat_mu.vertex().y();
410	<	mu.vertex_z = pat_mu.vertex().z();
411	<	mu.dB = pat_mu.dB();
412	<	//mu.particleIso = pat_mu.particleIso();
413	<	mu.neutralHadronIso = pat_mu.neutralHadronIso();
414	<	mu.chargedHadronIso = pat_mu.chargedHadronIso();
415	<	mu.trackIso = pat_mu.trackIso();
416	<	mu.photonIso = pat_mu.photonIso();
417	<	mu.puChargedHadronIso = pat_mu.puChargedHadronIso();
418	<	mu.isGlobalMuon = pat_mu.isGlobalMuon();
419	<	mu.isStandAloneMuon = pat_mu.isStandAloneMuon();
420	<	mu.isTrackerMuon = pat_mu.isTrackerMuon();
421	<	mu.numberOfMatchedStations = pat_mu.numberOfMatchedStations();
403	>	mu.set_charge( pat_mu.charge());
404	>	mu.set_pt( pat_mu.pt());
405	>	mu.set_eta( pat_mu.eta());
406	>	mu.set_phi( pat_mu.phi());
407	>	mu.set_energy( pat_mu.energy());
408	>	mu.set_vertex_x ( pat_mu.vertex().x());
409	>	mu.set_vertex_y ( pat_mu.vertex().y());
410	>	mu.set_vertex_z ( pat_mu.vertex().z());
411	>	mu.set_dB ( pat_mu.dB());
412	>	//mu.particleIso ( pat_mu.particleIso());
413	>	mu.set_neutralHadronIso ( pat_mu.neutralHadronIso());
414	>	mu.set_chargedHadronIso ( pat_mu.chargedHadronIso());
415	>	mu.set_trackIso ( pat_mu.trackIso());
416	>	mu.set_photonIso ( pat_mu.photonIso());
417	>	mu.set_puChargedHadronIso ( pat_mu.puChargedHadronIso());
418	>	mu.set_isGlobalMuon ( pat_mu.isGlobalMuon());
419	>	mu.set_isStandAloneMuon ( pat_mu.isStandAloneMuon());
420	>	mu.set_isTrackerMuon ( pat_mu.isTrackerMuon());
421	>	mu.set_numberOfMatchedStations ( pat_mu.numberOfMatchedStations());
422		reco::TrackRef globalTrack = pat_mu.globalTrack();
423		if(!globalTrack.isNull()){
424	<	mu.globalTrack_chi2 = globalTrack->chi2();
425	<	mu.globalTrack_ndof = globalTrack->ndof();
426	<	mu.globalTrack_d0 = globalTrack->d0();
427	<	mu.globalTrack_d0Error = globalTrack->d0Error();
428	<	mu.globalTrack_numberOfValidHits = globalTrack->numberOfValidHits();
429	<	mu.globalTrack_numberOfLostHits = globalTrack->numberOfLostHits();
424	>	mu.set_globalTrack_chi2 ( globalTrack->chi2());
425	>	mu.set_globalTrack_ndof ( globalTrack->ndof());
426	>	mu.set_globalTrack_d0 ( globalTrack->d0());
427	>	mu.set_globalTrack_d0Error ( globalTrack->d0Error());
428	>	mu.set_globalTrack_numberOfValidHits ( globalTrack->numberOfValidHits());
429	>	mu.set_globalTrack_numberOfLostHits ( globalTrack->numberOfLostHits());
430		}
431		else{
432	<	mu.globalTrack_chi2 = 0;
433	<	mu.globalTrack_ndof = 0;
434	<	mu.globalTrack_d0 = 0;
435	<	mu.globalTrack_d0Error = 0;
436	<	mu.globalTrack_numberOfValidHits = 0;
437	<	mu.globalTrack_numberOfLostHits = 0;
432	>	mu.set_globalTrack_chi2 ( 0);
433	>	mu.set_globalTrack_ndof ( 0);
434	>	mu.set_globalTrack_d0 ( 0);
435	>	mu.set_globalTrack_d0Error ( 0);
436	>	mu.set_globalTrack_numberOfValidHits ( 0);
437	>	mu.set_globalTrack_numberOfLostHits ( 0);
438		}
439		reco::TrackRef innerTrack = pat_mu.innerTrack();
440		if(!innerTrack.isNull()){
441	<	mu.innerTrack_chi2 = innerTrack->chi2();
442	<	mu.innerTrack_ndof = innerTrack->ndof();
443	<	mu.innerTrack_d0 = innerTrack->d0();
444	<	mu.innerTrack_d0Error = innerTrack->d0Error();
445	<	mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits();
446	<	mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits();
447	<	mu.innerTrack_trackerLayersWithMeasurement = innerTrack->hitPattern().trackerLayersWithMeasurement();
448	<	mu.innerTrack_numberOfValidPixelHits = innerTrack->hitPattern().numberOfValidPixelHits();
441	>	mu.set_innerTrack_chi2 ( innerTrack->chi2());
442	>	mu.set_innerTrack_ndof ( innerTrack->ndof());
443	>	mu.set_innerTrack_d0 ( innerTrack->d0());
444	>	mu.set_innerTrack_d0Error ( innerTrack->d0Error());
445	>	mu.set_innerTrack_numberOfValidHits ( innerTrack->numberOfValidHits());
446	>	mu.set_innerTrack_numberOfLostHits ( innerTrack->numberOfLostHits());
447	>	mu.set_innerTrack_trackerLayersWithMeasurement ( innerTrack->hitPattern().trackerLayersWithMeasurement());
448	>	mu.set_innerTrack_numberOfValidPixelHits ( innerTrack->hitPattern().numberOfValidPixelHits());
449		}
450		else{
451	<	mu.innerTrack_chi2 = 0;
452	<	mu.innerTrack_ndof = 0;
453	<	mu.innerTrack_d0 = 0;
454	<	mu.innerTrack_d0Error = 0;
455	<	mu.innerTrack_numberOfValidHits = 0;
456	<	mu.innerTrack_numberOfLostHits = 0;
457	<	mu.innerTrack_trackerLayersWithMeasurement = 0;
458	<	mu.innerTrack_numberOfValidPixelHits = 0;
451	>	mu.set_innerTrack_chi2 ( 0);
452	>	mu.set_innerTrack_ndof ( 0);
453	>	mu.set_innerTrack_d0 ( 0);
454	>	mu.set_innerTrack_d0Error ( 0);
455	>	mu.set_innerTrack_numberOfValidHits ( 0);
456	>	mu.set_innerTrack_numberOfLostHits ( 0);
457	>	mu.set_innerTrack_trackerLayersWithMeasurement ( 0);
458	>	mu.set_innerTrack_numberOfValidPixelHits ( 0);
459		}
460		reco::TrackRef outerTrack = pat_mu.outerTrack();
461		if(!outerTrack.isNull()){
462	<	mu.outerTrack_chi2 = outerTrack->chi2();
463	<	mu.outerTrack_ndof = outerTrack->ndof();
464	<	mu.outerTrack_d0 = outerTrack->d0();
465	<	mu.outerTrack_d0Error = outerTrack->d0Error();
466	<	mu.outerTrack_numberOfValidHits = outerTrack->numberOfValidHits();
467	<	mu.outerTrack_numberOfLostHits = outerTrack->numberOfLostHits();
462	>	mu.set_outerTrack_chi2 ( outerTrack->chi2());
463	>	mu.set_outerTrack_ndof ( outerTrack->ndof());
464	>	mu.set_outerTrack_d0 ( outerTrack->d0());
465	>	mu.set_outerTrack_d0Error ( outerTrack->d0Error());
466	>	mu.set_outerTrack_numberOfValidHits ( outerTrack->numberOfValidHits());
467	>	mu.set_outerTrack_numberOfLostHits ( outerTrack->numberOfLostHits());
468		}
469		else{
470	<	mu.outerTrack_chi2 = 0;
471	<	mu.outerTrack_ndof = 0;
472	<	mu.outerTrack_d0 = 0;
473	<	mu.outerTrack_d0Error = 0;
474	<	mu.outerTrack_numberOfValidHits = 0;
475	<	mu.outerTrack_numberOfLostHits = 0;
470	>	mu.set_outerTrack_chi2 ( 0);
471	>	mu.set_outerTrack_ndof ( 0);
472	>	mu.set_outerTrack_d0 ( 0);
473	>	mu.set_outerTrack_d0Error ( 0);
474	>	mu.set_outerTrack_numberOfValidHits ( 0);
475	>	mu.set_outerTrack_numberOfLostHits ( 0);
476		}
477
478		mus[j].push_back(mu);
#	Line 392 | Line 496 | NtupleWriter::analyze(const edm::Event&
496		if(fabs(pat_tau.eta()) > tau_etamax) continue;
497
498		Tau tau;
499	<	tau.charge =  pat_tau.charge();
500	<	tau.pt =  pat_tau.pt();
501	<	tau.eta =  pat_tau.eta();
502	<	tau.phi =  pat_tau.phi();
503	<	tau.energy =  pat_tau.energy();
504	<	tau.decayModeFinding = pat_tau.tauID("decayModeFinding")>0.5;
505	<	tau.byVLooseCombinedIsolationDeltaBetaCorr  = pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5;
506	<	tau.byLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5;
507	<	tau.byMediumCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5;
508	<	tau.byTightCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5;
509	<	tau.againstElectronLoose  = pat_tau.tauID("againstElectronLoose")>0.5;
510	<	tau.againstElectronMedium = pat_tau.tauID("againstElectronMedium")>0.5;
511	<	tau.againstElectronTight = pat_tau.tauID("againstElectronTight")>0.5;
512	<	tau.againstElectronMVA  = pat_tau.tauID("againstElectronMVA")>0.5;
513	<	tau.againstMuonLoose = pat_tau.tauID("againstMuonLoose")>0.5;
514	<	tau.againstMuonMedium = pat_tau.tauID("againstMuonMedium")>0.5;
515	<	tau.againstMuonTight = pat_tau.tauID("againstMuonTight")>0.5;
499	>	tau.set_charge( pat_tau.charge());
500	>	tau.set_pt( pat_tau.pt());
501	>	tau.set_eta( pat_tau.eta());
502	>	tau.set_phi( pat_tau.phi());
503	>	tau.set_energy( pat_tau.energy());
504	>	tau.set_decayModeFinding ( pat_tau.tauID("decayModeFinding")>0.5);
505	>	tau.set_byVLooseCombinedIsolationDeltaBetaCorr  ( pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5);
506	>	tau.set_byLooseCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5);
507	>	tau.set_byMediumCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5);
508	>	tau.set_byTightCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5);
509	>	tau.set_againstElectronLoose  ( pat_tau.tauID("againstElectronLoose")>0.5);
510	>	tau.set_againstElectronMedium ( pat_tau.tauID("againstElectronMedium")>0.5);
511	>	tau.set_againstElectronTight ( pat_tau.tauID("againstElectronTight")>0.5);
512	>	tau.set_againstElectronMVA  ( pat_tau.tauID("againstElectronMVA")>0.5);
513	>	tau.set_againstMuonLoose ( pat_tau.tauID("againstMuonLoose")>0.5);
514	>	tau.set_againstMuonMedium ( pat_tau.tauID("againstMuonMedium")>0.5);
515	>	tau.set_againstMuonTight ( pat_tau.tauID("againstMuonTight")>0.5);
516
517		reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
518		if(!leadPFCand.isNull()){
519	<	tau.leadPFCand_px = leadPFCand->px();
520	<	tau.leadPFCand_py = leadPFCand->py();
521	<	tau.leadPFCand_pz = leadPFCand->pz();
519	>	tau.set_leadPFCand_px ( leadPFCand->px());
520	>	tau.set_leadPFCand_py ( leadPFCand->py());
521	>	tau.set_leadPFCand_pz ( leadPFCand->pz());
522		}
523		else{
524	<	tau.leadPFCand_px = 0;
525	<	tau.leadPFCand_py = 0;
526	<	tau.leadPFCand_pz = 0;
524	>	tau.set_leadPFCand_px ( 0);
525	>	tau.set_leadPFCand_py ( 0);
526	>	tau.set_leadPFCand_pz ( 0);
527		}
528		taus[j].push_back(tau);
529		}
#	Line 447 | Line 551 | NtupleWriter::analyze(const edm::Event&
551		//       }
552
553		Jet jet;
554	<	jet.charge = pat_jet.charge();
555	<	jet.pt = pat_jet.pt();
556	<	jet.eta = pat_jet.eta();
557	<	jet.phi = pat_jet.phi();
558	<	jet.energy = pat_jet.energy();
559	<	jet.numberOfDaughters =pat_jet.numberOfDaughters();
554	>	jet.set_charge(pat_jet.charge());
555	>	jet.set_pt(pat_jet.pt());
556	>	jet.set_eta(pat_jet.eta());
557	>	jet.set_phi(pat_jet.phi());
558	>	jet.set_energy(pat_jet.energy());
559	>	jet.set_numberOfDaughters (pat_jet.numberOfDaughters());
560		const reco::TrackRefVector&  jettracks = pat_jet.associatedTracks();
561	<	jet.nTracks = jettracks.size();
562	<	jet.jetArea = pat_jet.jetArea();
563	<	jet.pileup = pat_jet.pileup();
561	>	jet.set_nTracks ( jettracks.size());
562	>	jet.set_jetArea(pat_jet.jetArea());
563	>	jet.set_pileup(pat_jet.pileup());
564		if(pat_jet.isPFJet()){
565	<	jet.neutralEmEnergyFraction =pat_jet.neutralEmEnergyFraction();
566	<	jet.neutralHadronEnergyFraction =pat_jet.neutralHadronEnergyFraction();
567	<	jet.chargedEmEnergyFraction =pat_jet.chargedEmEnergyFraction();
568	<	jet.chargedHadronEnergyFraction =pat_jet.chargedHadronEnergyFraction();
569	<	jet.muonEnergyFraction =pat_jet.muonEnergyFraction();
570	<	jet.photonEnergyFraction =pat_jet.photonEnergyFraction();
571	<	jet.chargedMultiplicity =pat_jet.chargedMultiplicity();
572	<	jet.neutralMultiplicity =pat_jet.neutralMultiplicity();
573	<	jet.muonMultiplicity =pat_jet.muonMultiplicity();
574	<	jet.electronMultiplicity =pat_jet.electronMultiplicity();
575	<	jet.photonMultiplicity =pat_jet.photonMultiplicity();
565	>	jet.set_neutralEmEnergyFraction (pat_jet.neutralEmEnergyFraction());
566	>	jet.set_neutralHadronEnergyFraction (pat_jet.neutralHadronEnergyFraction());
567	>	jet.set_chargedEmEnergyFraction (pat_jet.chargedEmEnergyFraction());
568	>	jet.set_chargedHadronEnergyFraction (pat_jet.chargedHadronEnergyFraction());
569	>	jet.set_muonEnergyFraction (pat_jet.muonEnergyFraction());
570	>	jet.set_photonEnergyFraction (pat_jet.photonEnergyFraction());
571	>	jet.set_chargedMultiplicity (pat_jet.chargedMultiplicity());
572	>	jet.set_neutralMultiplicity (pat_jet.neutralMultiplicity());
573	>	jet.set_muonMultiplicity (pat_jet.muonMultiplicity());
574	>	jet.set_electronMultiplicity (pat_jet.electronMultiplicity());
575	>	jet.set_photonMultiplicity (pat_jet.photonMultiplicity());
576		}
577
578		jecUnc->setJetEta(pat_jet.eta());
579		jecUnc->setJetPt(pat_jet.pt());
580	<	jet.JEC_uncertainty = jecUnc->getUncertainty(true);
581	<	jet.JEC_factor_raw = pat_jet.jecFactor("Uncorrected");
580	>	jet.set_JEC_uncertainty(jecUnc->getUncertainty(true));
581	>	jet.set_JEC_factor_raw(pat_jet.jecFactor("Uncorrected"));
582
583	<	jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
584	<	jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
585	<	jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
586	<	jet.btag_combinedSecondaryVertexMVA=pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
587	<	jet.btag_jetBProbability=pat_jet.bDiscriminator("jetBProbabilityBJetTags");
588	<	jet.btag_jetProbability=pat_jet.bDiscriminator("jetProbabilityBJetTags");
583	>	jet.set_btag_simpleSecondaryVertexHighEff(pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
584	>	jet.set_btag_simpleSecondaryVertexHighPur(pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
585	>	jet.set_btag_combinedSecondaryVertex(pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags"));
586	>	jet.set_btag_combinedSecondaryVertexMVA(pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
587	>	jet.set_btag_jetBProbability(pat_jet.bDiscriminator("jetBProbabilityBJetTags"));
588	>	jet.set_btag_jetProbability(pat_jet.bDiscriminator("jetProbabilityBJetTags"));
589
590		const reco::GenJet *genj = pat_jet.genJet();
591		if(genj){
592	<	jet.genjet_pt = genj->pt();
593	<	jet.genjet_eta = genj->eta();
594	<	jet.genjet_phi = genj->phi();
595	<	jet.genjet_energy = genj->energy();
592	>	jet.set_genjet_pt(genj->pt());
593	>	jet.set_genjet_eta(genj->eta());
594	>	jet.set_genjet_phi(genj->phi());
595	>	jet.set_genjet_energy(genj->energy());
596	>	if(doAllGenParticles){
597	>	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
598	>	for(unsigned int l = 0; l<jetgenps.size(); ++l){
599	>	for(unsigned int k=0; k< genps.size(); ++k){
600	>	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
601	>	jet.add_genparticles_index(genps[k].index());
602	>	break;
603	>	}
604	>	}
605	>	}
606	>	if(jet.genparticles_indices().size()!= jetgenps.size())
607	>	std::cout << "WARNING: Found only " << jet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this jet"<<std::endl;
608	>	}
609		}
493	–
610		jets[j].push_back(jet);
611		}
612		}
#	Line 513 | Line 629 | NtupleWriter::analyze(const edm::Event&
629		if(fabs(pat_topjet.eta()) > topjet_etamax) continue;
630
631		TopJet topjet;
632	<	topjet.charge = pat_topjet.charge();
633	<	topjet.pt = pat_topjet.pt();
634	<	topjet.eta = pat_topjet.eta();
635	<	topjet.phi = pat_topjet.phi();
636	<	topjet.energy = pat_topjet.energy();
637	<	topjet.numberOfDaughters =pat_topjet.numberOfDaughters();
632	>	topjet.set_charge(pat_topjet.charge());
633	>	topjet.set_pt(pat_topjet.pt());
634	>	topjet.set_eta(pat_topjet.eta());
635	>	topjet.set_phi(pat_topjet.phi());
636	>	topjet.set_energy(pat_topjet.energy());
637	>	topjet.set_numberOfDaughters(pat_topjet.numberOfDaughters());
638		const reco::TrackRefVector&  topjettracks = pat_topjet.associatedTracks();
639	<	topjet.nTracks = topjettracks.size();
640	<	topjet.jetArea = pat_topjet.jetArea();
641	<	topjet.pileup = pat_topjet.pileup();
642	<	//       topjet.neutralEmEnergyFraction =pat_topjet.neutralEmEnergyFraction();
643	<	//       topjet.neutralHadronEnergyFraction =pat_topjet.neutralHadronEnergyFraction();
644	<	//       topjet.chargedEmEnergyFraction =pat_topjet.chargedEmEnergyFraction();
645	<	//       topjet.chargedHadronEnergyFraction =pat_topjet.chargedHadronEnergyFraction();
646	<	//       topjet.muonEnergyFraction =pat_topjet.muonEnergyFraction();
647	<	//       topjet.photonEnergyFraction =pat_topjet.photonEnergyFraction();
648	<	//       topjet.chargedMultiplicity =pat_topjet.chargedMultiplicity();
649	<	//       topjet.neutralMultiplicity =pat_topjet.neutralMultiplicity();
650	<	//       topjet.muonMultiplicity =pat_topjet.muonMultiplicity();
651	<	//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
652	<	//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
639	>	topjet.set_nTracks( topjettracks.size());
640	>	topjet.set_jetArea( pat_topjet.jetArea());
641	>	topjet.set_pileup( pat_topjet.pileup());
642	>	//       topjet.set_neutralEmEnergyFraction(pat_topjet.neutralEmEnergyFraction());
643	>	//       topjet.set_neutralHadronEnergyFraction(pat_topjet.neutralHadronEnergyFraction());
644	>	//       topjet.set_chargedEmEnergyFraction(pat_topjet.chargedEmEnergyFraction());
645	>	//       topjet.set_chargedHadronEnergyFraction(pat_topjet.chargedHadronEnergyFraction());
646	>	//       topjet.set_muonEnergyFraction(pat_topjet.muonEnergyFraction());
647	>	//       topjet.set_photonEnergyFraction(pat_topjet.photonEnergyFraction());
648	>	//       topjet.set_chargedMultiplicity(pat_topjet.chargedMultiplicity());
649	>	//       topjet.set_neutralMultiplicity(pat_topjet.neutralMultiplicity());
650	>	//       topjet.set_muonMultiplicity(pat_topjet.muonMultiplicity());
651	>	//       topjet.set_electronMultiplicity(pat_topjet.electronMultiplicity());
652	>	//       topjet.set_photonMultiplicity(pat_topjet.photonMultiplicity());
653
654		jecUnc->setJetEta(pat_topjet.eta());
655		jecUnc->setJetPt(pat_topjet.pt());
656	<	topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
657	<	topjet.JEC_factor_raw = pat_topjet.jecFactor("Uncorrected");
656	>	topjet.set_JEC_uncertainty( jecUnc->getUncertainty(true));
657	>	topjet.set_JEC_factor_raw( pat_topjet.jecFactor("Uncorrected"));
658
659	<	topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
660	<	topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
661	<	topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
662	<	topjet.btag_combinedSecondaryVertexMVA=pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
663	<	topjet.btag_jetBProbability=pat_topjet.bDiscriminator("jetBProbabilityBJetTags");
664	<	topjet.btag_jetProbability=pat_topjet.bDiscriminator("jetProbabilityBJetTags");
659	>	topjet.set_btag_simpleSecondaryVertexHighEff(pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
660	>	topjet.set_btag_simpleSecondaryVertexHighPur(pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
661	>	topjet.set_btag_combinedSecondaryVertex(pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags"));
662	>	topjet.set_btag_combinedSecondaryVertexMVA(pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
663	>	topjet.set_btag_jetBProbability(pat_topjet.bDiscriminator("jetBProbabilityBJetTags"));
664	>	topjet.set_btag_jetProbability(pat_topjet.bDiscriminator("jetProbabilityBJetTags"));
665
666		const reco::GenJet *genj = pat_topjet.genJet();
667		if(genj){
668	<	topjet.genjet_pt = genj->pt();
669	<	topjet.genjet_eta = genj->eta();
670	<	topjet.genjet_phi = genj->phi();
671	<	topjet.genjet_energy = genj->energy();
668	>	topjet.set_genjet_pt ( genj->pt());
669	>	topjet.set_genjet_eta ( genj->eta());
670	>	topjet.set_genjet_phi ( genj->phi());
671	>	topjet.set_genjet_energy ( genj->energy());
672	>	if(doAllGenParticles){
673	>	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
674	>	for(unsigned int l = 0; l<jetgenps.size(); ++l){
675	>	for(unsigned int k=0; k< genps.size(); ++k){
676	>	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
677	>	topjet.add_genparticles_index(genps[k].index());
678	>	break;
679	>	}
680	>	}
681	>	}
682	>	if(topjet.genparticles_indices().size()!= jetgenps.size())
683	>	std::cout << "WARNING: Found only " << topjet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this topjet"<<std::endl;
684	>	}
685		}
686
687		for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) {
688		Particle subjet_v4;
689	<	subjet_v4.pt = pat_topjet.daughter(k)->p4().pt();
690	<	subjet_v4.eta = pat_topjet.daughter(k)->p4().eta();
691	<	subjet_v4.phi = pat_topjet.daughter(k)->p4().phi();
692	<	subjet_v4.energy = pat_topjet.daughter(k)->p4().E();
693	<	topjet.subjets.push_back(subjet_v4);
689	>	subjet_v4.set_pt(pat_topjet.daughter(k)->p4().pt());
690	>	subjet_v4.set_eta(pat_topjet.daughter(k)->p4().eta());
691	>	subjet_v4.set_phi(pat_topjet.daughter(k)->p4().phi());
692	>	subjet_v4.set_energy(pat_topjet.daughter(k)->p4().E());
693	>	topjet.add_subjet(subjet_v4);
694		}
695		topjets[j].push_back(topjet);
696		}
#	Line 586 | Line 715 | NtupleWriter::analyze(const edm::Event&
715		if(fabs(reco_gentopjet.eta()) > gentopjet_etamax) continue;
716
717		TopJet gentopjet;
718	<	gentopjet.charge = reco_gentopjet.charge();
719	<	gentopjet.pt = reco_gentopjet.pt();
720	<	gentopjet.eta = reco_gentopjet.eta();
721	<	gentopjet.phi = reco_gentopjet.phi();
722	<	gentopjet.energy = reco_gentopjet.energy();
723	<	gentopjet.numberOfDaughters =reco_gentopjet.numberOfDaughters();
718	>	gentopjet.set_charge(reco_gentopjet.charge());
719	>	gentopjet.set_pt(reco_gentopjet.pt());
720	>	gentopjet.set_eta(reco_gentopjet.eta());
721	>	gentopjet.set_phi(reco_gentopjet.phi());
722	>	gentopjet.set_energy(reco_gentopjet.energy());
723	>	gentopjet.set_numberOfDaughters(reco_gentopjet.numberOfDaughters());
724
725		for (unsigned int k = 0; k < reco_gentopjet.numberOfDaughters(); k++) {
726		Particle subjet_v4;
727	<	subjet_v4.pt = reco_gentopjet.daughter(k)->p4().pt();
728	<	subjet_v4.eta = reco_gentopjet.daughter(k)->p4().eta();
729	<	subjet_v4.phi = reco_gentopjet.daughter(k)->p4().phi();
730	<	subjet_v4.energy = reco_gentopjet.daughter(k)->p4().E();
731	<	gentopjet.subjets.push_back(subjet_v4);
727	>	subjet_v4.set_pt(reco_gentopjet.daughter(k)->p4().pt());
728	>	subjet_v4.set_eta(reco_gentopjet.daughter(k)->p4().eta());
729	>	subjet_v4.set_phi(reco_gentopjet.daughter(k)->p4().phi());
730	>	subjet_v4.set_energy(reco_gentopjet.daughter(k)->p4().E());
731	>	gentopjet.add_subjet(subjet_v4);
732		}
733		gentopjets[j].push_back(gentopjet);
734		}
#	Line 618 | Line 747 | NtupleWriter::analyze(const edm::Event&
747		for (unsigned int i = 0; i < pat_photons.size(); ++i) {
748		pat::Photon pat_photon = pat_photons[i];
749		Photon ph;
750	<	ph.charge = 0;
751	<	ph.pt =  pat_photon.pt();
752	<	ph.eta =  pat_photon.eta();
753	<	ph.phi =  pat_photon.phi();
754	<	ph.energy =  pat_photon.energy();
755	<	ph.vertex_x = pat_photon.vertex().x();
756	<	ph.vertex_y = pat_photon.vertex().y();
757	<	ph.vertex_z = pat_photon.vertex().z();
758	<	ph.supercluster_eta = pat_photon.superCluster()->eta();
759	<	ph.supercluster_phi = pat_photon.superCluster()->phi();
760	<	//       ph.neutralHadronIso = pat_photon.neutralHadronIso();
761	<	//       ph.chargedHadronIso = pat_photon.chargedHadronIso();
762	<	ph.trackIso = pat_photon.trackIso();
750	>	ph.set_charge(0);
751	>	ph.set_pt( pat_photon.pt());
752	>	ph.set_eta( pat_photon.eta());
753	>	ph.set_phi( pat_photon.phi());
754	>	ph.set_energy( pat_photon.energy());
755	>	ph.set_vertex_x(pat_photon.vertex().x());
756	>	ph.set_vertex_y(pat_photon.vertex().y());
757	>	ph.set_vertex_z(pat_photon.vertex().z());
758	>	ph.set_supercluster_eta(pat_photon.superCluster()->eta());
759	>	ph.set_supercluster_phi(pat_photon.superCluster()->phi());
760	>	//       ph.set_neutralHadronIso(pat_photon.neutralHadronIso());
761	>	//       ph.set_chargedHadronIso(pat_photon.chargedHadronIso());
762	>	ph.set_trackIso(pat_photon.trackIso());
763		phs[j].push_back(ph);
764		}
765		}
#	Line 650 | Line 779 | NtupleWriter::analyze(const edm::Event&
779		else{
780		pat::MET pat_met = pat_mets[0];
781
782	<	met[j].pt=pat_met.pt();
783	<	met[j].phi=pat_met.phi();
784	<	met[j].mEtSig= pat_met.mEtSig();
782	>	met[j].set_pt(pat_met.pt());
783	>	met[j].set_phi(pat_met.phi());
784	>	met[j].set_mEtSig(pat_met.mEtSig());
785		}
786
787		}
#	Line 675 | Line 804 | NtupleWriter::analyze(const edm::Event&
804
805		triggerResults.clear();
806		triggerNames.clear();
807	<	L1_prescale.clear();
808	<	HLT_prescale.clear();
807	>	//      L1_prescale.clear();
808	>	//      HLT_prescale.clear();
809
810		edm::Service<edm::service::TriggerNamesService> tns;
811		std::vector<std::string> triggerNames_all;
#	Line 693 | Line 822 | NtupleWriter::analyze(const edm::Event&
822		//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
823		triggerResults.push_back(trig.accept(i));
824		if(newrun) triggerNames.push_back(triggerNames_all[i]);
825	<	if(isRealData){
826	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
827	<	L1_prescale.push_back(pre.first);
828	<	HLT_prescale.push_back(pre.second);
829	<	//std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
830	<	}
825	>	//        if(isRealData){
826	>	//       std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
827	>	//       L1_prescale.push_back(pre.first);
828	>	//       HLT_prescale.push_back(pre.second);
829	>	//       //std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
830	>	//        }
831		}
832		//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
833		//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
#	Line 706 | Line 835 | NtupleWriter::analyze(const edm::Event&
835		newrun=false;
836		}
837
709	–	// ------------- generator info -------------
710	–
711	–	if(doGenInfo){
712	–	genInfo.weights.clear();
713	–	genInfo.binningValues.clear();
714	–	genps.clear();
715	–
716	–	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
717	–	iEvent.getByLabel("generator", genEventInfoProduct);
718	–	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
719	–
720	–	genInfo.binningValues = genEventInfo.binningValues();
721	–	genInfo.weights = genEventInfo.weights();
722	–	genInfo.alphaQCD = genEventInfo.alphaQCD();
723	–	genInfo.alphaQED = genEventInfo.alphaQED();
724	–	genInfo.qScale = genEventInfo.qScale();
725	–
726	–	const gen::PdfInfo* pdf = genEventInfo.pdf();
727	–	if(pdf){
728	–	genInfo.pdf_id1=pdf->id.first;
729	–	genInfo.pdf_id2=pdf->id.second;
730	–	genInfo.pdf_x1=pdf->x.first;
731	–	genInfo.pdf_x2=pdf->x.second;
732	–	genInfo.pdf_scalePDF=pdf->scalePDF;
733	–	genInfo.pdf_xPDF1=pdf->xPDF.first;
734	–	genInfo.pdf_xPDF2=pdf->xPDF.second;
735	–	}
736	–	else{
737	–	genInfo.pdf_id1=-999;
738	–	genInfo.pdf_id2=-999;
739	–	genInfo.pdf_x1=-999;
740	–	genInfo.pdf_x2=-999;
741	–	genInfo.pdf_scalePDF=-999;
742	–	genInfo.pdf_xPDF1=-999;
743	–	genInfo.pdf_xPDF2=-999;
744	–	}
745	–
746	–	edm::Handle<std::vector<PileupSummaryInfo> > pus;
747	–	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
748	–	genInfo.pileup_NumInteractions_intime=0;
749	–	genInfo.pileup_NumInteractions_ootbefore=0;
750	–	genInfo.pileup_NumInteractions_ootafter=0;
751	–	if(pus.isValid()){
752	–	genInfo.pileup_TrueNumInteractions = (float) pus->at(0).getTrueNumInteractions();
753	–	for(size_t i=0; i<pus->size(); ++i){
754	–	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
755	–	genInfo.pileup_NumInteractions_intime += pus->at(i).getPU_NumInteractions();
756	–	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
757	–	genInfo.pileup_NumInteractions_ootbefore += pus->at(i).getPU_NumInteractions();
758	–	}
759	–	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
760	–	genInfo.pileup_NumInteractions_ootafter += pus->at(i).getPU_NumInteractions();
761	–	}
762	–	}
763	–	}
764	–
765	–	edm::Handle<reco::GenParticleCollection> genPartColl;
766	–	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
767	–	int index=-1;
768	–	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
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 || doAllGenParticles){
773	–	GenParticle genp;
774	–	genp.charge = iter->charge();;
775	–	genp.pt = iter->p4().pt();
776	–	genp.eta = iter->p4().eta();
777	–	genp.phi = iter->p4().phi();
778	–	genp.energy = iter->p4().E();
779	–	genp.index =index;
780	–	genp.status = iter->status();
781	–	genp.pdgId = iter->pdgId();
782	–
783	–	genp.mother1=-1;
784	–	genp.mother2=-1;
785	–	genp.daughter1=-1;
786	–	genp.daughter2=-1;
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(1).key();
794	–	if (nd>0) genp.daughter1 = iter->daughterRef(0).key();
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	–	}
838
839		tr->Fill();
840		if(doLumiInfo)

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines