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.6 by peiffer, Wed Apr 11 15:15:44 2012 UTC vs.
Revision 1.17 by peiffer, Tue May 22 09:32:31 2012 UTC

#	Line 50 | Line 50 | NtupleWriter::NtupleWriter(const edm::Pa
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");
#	Line 63 | 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);
70	<	tr->Branch("beamspot_x0",&beamspot_x0);
71	<	tr->Branch("beamspot_y0",&beamspot_y0);
72	<	tr->Branch("beamspot_z0",&beamspot_z0);
73	<
69	>	//tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
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){
#	Line 104 | Line 112 | NtupleWriter::NtupleWriter(const edm::Pa
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){
#	Line 131 | Line 147 | NtupleWriter::NtupleWriter(const edm::Pa
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);
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		}
#	Line 165 | Line 181 | NtupleWriter::analyze(const edm::Event&
181		luminosityBlock = iEvent.luminosityBlock();
182		isRealData      = iEvent.isRealData();
183
184	<	if(isRealData){
185	<	edm::Handle<bool> bool_handle;
186	<	iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
187	<	HBHENoiseFilterResult = *(bool_handle.product());
188	<	}
189	<	else HBHENoiseFilterResult = false;
184	>	//    if(isRealData){
185	>	//      edm::Handle<bool> bool_handle;
186	>	//      iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
187	>	//      HBHENoiseFilterResult = *(bool_handle.product());
188	>	//    }
189	>	//    else HBHENoiseFilterResult = false;
190
191		// ------------- primary vertices and beamspot  -------------
192
#	Line 186 | Line 202 | NtupleWriter::analyze(const edm::Event&
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();
205	>	pv.set_x( reco_pv.x());
206	>	pv.set_y( reco_pv.y());
207	>	pv.set_z( reco_pv.z());
208	>	pv.set_nTracks( reco_pv.nTracks());
209	>	//pv.set_isValid( reco_pv.isValid());
210	>	pv.set_chi2( reco_pv.chi2());
211	>	pv.set_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	+	// ------------- generator info -------------
227
228	<	edm::Handle<reco::BeamSpot> beamSpot;
229	<	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
230	<	const reco::BeamSpot & bsp = *beamSpot;
231	<
232	<	beamspot_x0 = bsp.x0();
233	<	beamspot_y0 = bsp.y0();
234	<	beamspot_z0 = bsp.z0();
228	>	if(doGenInfo){
229	>	genInfo.clear_weights();
230	>	genInfo.clear_binningValues();
231	>	genps.clear();
232	>
233	>	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
234	>	iEvent.getByLabel("generator", genEventInfoProduct);
235	>	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
236	>
237	>	for(unsigned int k=0; k<genEventInfo.binningValues().size();++k){
238	>	genInfo.add_binningValue(genEventInfo.binningValues().at(k));
239	>	}
240	>	for(unsigned int k=0; k<genEventInfo.weights().size();++k){
241	>	genInfo.add_weight(genEventInfo.weights().at(k));
242	>	}
243	>	genInfo.set_alphaQCD(genEventInfo.alphaQCD());
244	>	genInfo.set_alphaQED(genEventInfo.alphaQED());
245	>	genInfo.set_qScale(genEventInfo.qScale());
246	>
247	>	const gen::PdfInfo* pdf = genEventInfo.pdf();
248	>	if(pdf){
249	>	genInfo.set_pdf_id1(pdf->id.first);
250	>	genInfo.set_pdf_id2(pdf->id.second);
251	>	genInfo.set_pdf_x1(pdf->x.first);
252	>	genInfo.set_pdf_x2(pdf->x.second);
253	>	genInfo.set_pdf_scalePDF(pdf->scalePDF);
254	>	genInfo.set_pdf_xPDF1(pdf->xPDF.first);
255	>	genInfo.set_pdf_xPDF2(pdf->xPDF.second);
256	>	}
257	>	else{
258	>	genInfo.set_pdf_id1(-999);
259	>	genInfo.set_pdf_id2(-999);
260	>	genInfo.set_pdf_x1(-999);
261	>	genInfo.set_pdf_x2(-999);
262	>	genInfo.set_pdf_scalePDF(-999);
263	>	genInfo.set_pdf_xPDF1(-999);
264	>	genInfo.set_pdf_xPDF2(-999);
265	>	}
266	>
267	>	edm::Handle<std::vector<PileupSummaryInfo> > pus;
268	>	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
269	>	genInfo.set_pileup_NumInteractions_intime(0);
270	>	genInfo.set_pileup_NumInteractions_ootbefore(0);
271	>	genInfo.set_pileup_NumInteractions_ootafter(0);
272	>	if(pus.isValid()){
273	>	genInfo.set_pileup_TrueNumInteractions ( (float) pus->at(0).getTrueNumInteractions());
274	>	for(size_t i=0; i<pus->size(); ++i){
275	>	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
276	>	genInfo.set_pileup_NumInteractions_intime( genInfo.pileup_NumInteractions_intime() + pus->at(i).getPU_NumInteractions());
277	>	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
278	>	genInfo.set_pileup_NumInteractions_ootbefore( genInfo.pileup_NumInteractions_ootbefore() + pus->at(i).getPU_NumInteractions());
279	>	}
280	>	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
281	>	genInfo.set_pileup_NumInteractions_ootafter( genInfo.pileup_NumInteractions_ootafter() + pus->at(i).getPU_NumInteractions());
282	>	}
283	>	}
284	>	}
285	>
286	>	edm::Handle<reco::GenParticleCollection> genPartColl;
287	>	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
288	>	int index=-1;
289	>	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
290	>	index++;
291	>
292	>	//write out only top quarks and status 3 particles (works fine only for MadGraph)
293	>	if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){
294	>	GenParticle genp;
295	>	genp.set_charge(iter->charge());
296	>	genp.set_pt(iter->p4().pt());
297	>	genp.set_eta(iter->p4().eta());
298	>	genp.set_phi(iter->p4().phi());
299	>	genp.set_energy(iter->p4().E());
300	>	genp.set_index(index);
301	>	genp.set_status( iter->status());
302	>	genp.set_pdgId( iter->pdgId());
303	>
304	>	genp.set_mother1(-1);
305	>	genp.set_mother2(-1);
306	>	genp.set_daughter1(-1);
307	>	genp.set_daughter2(-1);
308	>
309	>	int nm=iter->numberOfMothers();
310	>	int nd=iter->numberOfDaughters();
311	>
312	>
313	>	if (nm>0) genp.set_mother1( iter->motherRef(0).key());
314	>	if (nm>1) genp.set_mother2( iter->motherRef(1).key());
315	>	if (nd>0) genp.set_daughter1( iter->daughterRef(0).key());
316	>	if (nd>1) genp.set_daughter2( iter->daughterRef(1).key());
317	>
318	>	genps.push_back(genp);
319	>	}
320	>	}
321	>	}
322
323		// ------------- electrons -------------
324		if(doElectrons){
325	+
326	+	edm::Handle<reco::ConversionCollection> hConversions;
327	+	iEvent.getByLabel("allConversions", hConversions);
328	+
329	+	edm::Handle<reco::BeamSpot> beamSpot;
330	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
331	+	const reco::BeamSpot & bsp = *beamSpot;
332	+
333		for(size_t j=0; j< electron_sources.size(); ++j){
334		eles[j].clear();
335		edm::Handle< std::vector<pat::Electron> > ele_handle;
#	Line 219 | Line 340 | NtupleWriter::analyze(const edm::Event&
340		pat::Electron pat_ele = pat_electrons[i];
341		Electron ele;
342
343	<	ele.charge =  pat_ele.charge();
344	<	ele.pt =  pat_ele.pt();
345	<	ele.eta =  pat_ele.eta();
346	<	ele.phi =  pat_ele.phi();
347	<	ele.energy =  pat_ele.energy();
348	<	ele.vertex_x = pat_ele.vertex().x();
349	<	ele.vertex_y = pat_ele.vertex().y();
350	<	ele.vertex_z = pat_ele.vertex().z();
351	<	ele.supercluster_eta = pat_ele.superCluster()->eta();
352	<	ele.supercluster_phi = pat_ele.superCluster()->phi();
353	<	ele.dB = pat_ele.dB();
354	<	//ele.particleIso = pat_ele.particleIso();
355	<	ele.neutralHadronIso = pat_ele.neutralHadronIso();
356	<	ele.chargedHadronIso = pat_ele.chargedHadronIso();
357	<	ele.trackIso = pat_ele.trackIso();
358	<	ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
359	<	ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
360	<	ele.gsfTrack_px= pat_ele.gsfTrack()->px();
361	<	ele.gsfTrack_py= pat_ele.gsfTrack()->py();
362	<	ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
363	<	ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
364	<	ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
365	<	ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
343	>	ele.set_charge( pat_ele.charge());
344	>	ele.set_pt( pat_ele.pt());
345	>	ele.set_eta( pat_ele.eta());
346	>	ele.set_phi( pat_ele.phi());
347	>	ele.set_energy( pat_ele.energy());
348	>	ele.set_vertex_x(pat_ele.vertex().x());
349	>	ele.set_vertex_y(pat_ele.vertex().y());
350	>	ele.set_vertex_z(pat_ele.vertex().z());
351	>	ele.set_supercluster_eta(pat_ele.superCluster()->eta());
352	>	ele.set_supercluster_phi(pat_ele.superCluster()->phi());
353	>	ele.set_dB(pat_ele.dB());
354	>	//ele.set_particleIso(pat_ele.particleIso());
355	>	ele.set_neutralHadronIso(pat_ele.neutralHadronIso());
356	>	ele.set_chargedHadronIso(pat_ele.chargedHadronIso());
357	>	ele.set_trackIso(pat_ele.trackIso());
358	>	ele.set_photonIso(pat_ele.photonIso());
359	>	ele.set_puChargedHadronIso(pat_ele.puChargedHadronIso());
360	>	ele.set_gsfTrack_trackerExpectedHitsInner_numberOfLostHits(pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits());
361	>	ele.set_gsfTrack_px( pat_ele.gsfTrack()->px());
362	>	ele.set_gsfTrack_py( pat_ele.gsfTrack()->py());
363	>	ele.set_gsfTrack_pz( pat_ele.gsfTrack()->pz());
364	>	ele.set_gsfTrack_vx( pat_ele.gsfTrack()->vx());
365	>	ele.set_gsfTrack_vy( pat_ele.gsfTrack()->vy());
366	>	ele.set_gsfTrack_vz( pat_ele.gsfTrack()->vz());
367	>	ele.set_passconversionveto(!ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()));
368	>	ele.set_dEtaIn(pat_ele.deltaEtaSuperClusterTrackAtVtx());
369	>	ele.set_dPhiIn(pat_ele.deltaPhiSuperClusterTrackAtVtx());
370	>	ele.set_sigmaIEtaIEta(pat_ele.sigmaIetaIeta());
371	>	ele.set_HoverE(pat_ele.hadronicOverEm());
372	>	ele.set_fbrem(pat_ele.fbrem());
373	>	ele.set_EoverPIn(pat_ele.eSuperClusterOverP());
374	>	ele.set_EcalEnergy(pat_ele.ecalEnergy());
375	>	//ele.set_mvaTrigV0(pat_ele.electronID("mvaTrigV0"));
376	>	//ele.set_mvaNonTrigV0(pat_ele.electronID("mvaNonTrigV0"));
377	>
378		eles[j].push_back(ele);
379		}
380		}
#	Line 260 | Line 393 | NtupleWriter::analyze(const edm::Event&
393		pat::Muon pat_mu = pat_muons[i];
394
395		Muon mu;
396	<	mu.charge =  pat_mu.charge();
397	<	mu.pt =  pat_mu.pt();
398	<	mu.eta =  pat_mu.eta();
399	<	mu.phi =  pat_mu.phi();
400	<	mu.energy =  pat_mu.energy();
401	<	mu.vertex_x = pat_mu.vertex().x();
402	<	mu.vertex_y = pat_mu.vertex().y();
403	<	mu.vertex_z = pat_mu.vertex().z();
404	<	mu.dB = pat_mu.dB();
405	<	//mu.particleIso = pat_mu.particleIso();
406	<	mu.neutralHadronIso = pat_mu.neutralHadronIso();
407	<	mu.chargedHadronIso = pat_mu.chargedHadronIso();
408	<	mu.trackIso = pat_mu.trackIso();
409	<	mu.puChargedHadronIso = pat_mu.puChargedHadronIso();
410	<	mu.isGlobalMuon = pat_mu.isGlobalMuon();
411	<	mu.isStandAloneMuon = pat_mu.isStandAloneMuon();
412	<	mu.isTrackerMuon = pat_mu.isTrackerMuon();
413	<	mu.numberOfMatchedStations = pat_mu.numberOfMatchedStations();
396	>	mu.set_charge( pat_mu.charge());
397	>	mu.set_pt( pat_mu.pt());
398	>	mu.set_eta( pat_mu.eta());
399	>	mu.set_phi( pat_mu.phi());
400	>	mu.set_energy( pat_mu.energy());
401	>	mu.set_vertex_x ( pat_mu.vertex().x());
402	>	mu.set_vertex_y ( pat_mu.vertex().y());
403	>	mu.set_vertex_z ( pat_mu.vertex().z());
404	>	mu.set_dB ( pat_mu.dB());
405	>	//mu.particleIso ( pat_mu.particleIso());
406	>	mu.set_neutralHadronIso ( pat_mu.neutralHadronIso());
407	>	mu.set_chargedHadronIso ( pat_mu.chargedHadronIso());
408	>	mu.set_trackIso ( pat_mu.trackIso());
409	>	mu.set_photonIso ( pat_mu.photonIso());
410	>	mu.set_puChargedHadronIso ( pat_mu.puChargedHadronIso());
411	>	mu.set_isGlobalMuon ( pat_mu.isGlobalMuon());
412	>	mu.set_isStandAloneMuon ( pat_mu.isStandAloneMuon());
413	>	mu.set_isTrackerMuon ( pat_mu.isTrackerMuon());
414	>	mu.set_numberOfMatchedStations ( pat_mu.numberOfMatchedStations());
415		reco::TrackRef globalTrack = pat_mu.globalTrack();
416		if(!globalTrack.isNull()){
417	<	mu.globalTrack_chi2 = globalTrack->chi2();
418	<	mu.globalTrack_ndof = globalTrack->ndof();
419	<	mu.globalTrack_d0 = globalTrack->d0();
420	<	mu.globalTrack_d0Error = globalTrack->d0Error();
421	<	mu.globalTrack_numberOfValidHits = globalTrack->numberOfValidHits();
422	<	mu.globalTrack_numberOfLostHits = globalTrack->numberOfLostHits();
417	>	mu.set_globalTrack_chi2 ( globalTrack->chi2());
418	>	mu.set_globalTrack_ndof ( globalTrack->ndof());
419	>	mu.set_globalTrack_d0 ( globalTrack->d0());
420	>	mu.set_globalTrack_d0Error ( globalTrack->d0Error());
421	>	mu.set_globalTrack_numberOfValidHits ( globalTrack->numberOfValidHits());
422	>	mu.set_globalTrack_numberOfLostHits ( globalTrack->numberOfLostHits());
423		}
424		else{
425	<	mu.globalTrack_chi2 = 0;
426	<	mu.globalTrack_ndof = 0;
427	<	mu.globalTrack_d0 = 0;
428	<	mu.globalTrack_d0Error = 0;
429	<	mu.globalTrack_numberOfValidHits = 0;
430	<	mu.globalTrack_numberOfLostHits = 0;
425	>	mu.set_globalTrack_chi2 ( 0);
426	>	mu.set_globalTrack_ndof ( 0);
427	>	mu.set_globalTrack_d0 ( 0);
428	>	mu.set_globalTrack_d0Error ( 0);
429	>	mu.set_globalTrack_numberOfValidHits ( 0);
430	>	mu.set_globalTrack_numberOfLostHits ( 0);
431		}
432		reco::TrackRef innerTrack = pat_mu.innerTrack();
433		if(!innerTrack.isNull()){
434	<	mu.innerTrack_chi2 = innerTrack->chi2();
435	<	mu.innerTrack_ndof = innerTrack->ndof();
436	<	mu.innerTrack_d0 = innerTrack->d0();
437	<	mu.innerTrack_d0Error = innerTrack->d0Error();
438	<	mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits();
439	<	mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits();
434	>	mu.set_innerTrack_chi2 ( innerTrack->chi2());
435	>	mu.set_innerTrack_ndof ( innerTrack->ndof());
436	>	mu.set_innerTrack_d0 ( innerTrack->d0());
437	>	mu.set_innerTrack_d0Error ( innerTrack->d0Error());
438	>	mu.set_innerTrack_numberOfValidHits ( innerTrack->numberOfValidHits());
439	>	mu.set_innerTrack_numberOfLostHits ( innerTrack->numberOfLostHits());
440	>	mu.set_innerTrack_trackerLayersWithMeasurement ( innerTrack->hitPattern().trackerLayersWithMeasurement());
441	>	mu.set_innerTrack_numberOfValidPixelHits ( innerTrack->hitPattern().numberOfValidPixelHits());
442		}
443		else{
444	<	mu.innerTrack_chi2 = 0;
445	<	mu.innerTrack_ndof = 0;
446	<	mu.innerTrack_d0 = 0;
447	<	mu.innerTrack_d0Error = 0;
448	<	mu.innerTrack_numberOfValidHits = 0;
449	<	mu.innerTrack_numberOfLostHits = 0;
444	>	mu.set_innerTrack_chi2 ( 0);
445	>	mu.set_innerTrack_ndof ( 0);
446	>	mu.set_innerTrack_d0 ( 0);
447	>	mu.set_innerTrack_d0Error ( 0);
448	>	mu.set_innerTrack_numberOfValidHits ( 0);
449	>	mu.set_innerTrack_numberOfLostHits ( 0);
450	>	mu.set_innerTrack_trackerLayersWithMeasurement ( 0);
451	>	mu.set_innerTrack_numberOfValidPixelHits ( 0);
452		}
453		reco::TrackRef outerTrack = pat_mu.outerTrack();
454		if(!outerTrack.isNull()){
455	<	mu.outerTrack_chi2 = outerTrack->chi2();
456	<	mu.outerTrack_ndof = outerTrack->ndof();
457	<	mu.outerTrack_d0 = outerTrack->d0();
458	<	mu.outerTrack_d0Error = outerTrack->d0Error();
459	<	mu.outerTrack_numberOfValidHits = outerTrack->numberOfValidHits();
460	<	mu.outerTrack_numberOfLostHits = outerTrack->numberOfLostHits();
455	>	mu.set_outerTrack_chi2 ( outerTrack->chi2());
456	>	mu.set_outerTrack_ndof ( outerTrack->ndof());
457	>	mu.set_outerTrack_d0 ( outerTrack->d0());
458	>	mu.set_outerTrack_d0Error ( outerTrack->d0Error());
459	>	mu.set_outerTrack_numberOfValidHits ( outerTrack->numberOfValidHits());
460	>	mu.set_outerTrack_numberOfLostHits ( outerTrack->numberOfLostHits());
461		}
462		else{
463	<	mu.outerTrack_chi2 = 0;
464	<	mu.outerTrack_ndof = 0;
465	<	mu.outerTrack_d0 = 0;
466	<	mu.outerTrack_d0Error = 0;
467	<	mu.outerTrack_numberOfValidHits = 0;
468	<	mu.outerTrack_numberOfLostHits = 0;
463	>	mu.set_outerTrack_chi2 ( 0);
464	>	mu.set_outerTrack_ndof ( 0);
465	>	mu.set_outerTrack_d0 ( 0);
466	>	mu.set_outerTrack_d0Error ( 0);
467	>	mu.set_outerTrack_numberOfValidHits ( 0);
468	>	mu.set_outerTrack_numberOfLostHits ( 0);
469		}
470
471		mus[j].push_back(mu);
#	Line 351 | Line 489 | NtupleWriter::analyze(const edm::Event&
489		if(fabs(pat_tau.eta()) > tau_etamax) continue;
490
491		Tau tau;
492	<	tau.charge =  pat_tau.charge();
493	<	tau.pt =  pat_tau.pt();
494	<	tau.eta =  pat_tau.eta();
495	<	tau.phi =  pat_tau.phi();
496	<	tau.energy =  pat_tau.energy();
497	<
492	>	tau.set_charge( pat_tau.charge());
493	>	tau.set_pt( pat_tau.pt());
494	>	tau.set_eta( pat_tau.eta());
495	>	tau.set_phi( pat_tau.phi());
496	>	tau.set_energy( pat_tau.energy());
497	>	tau.set_decayModeFinding ( pat_tau.tauID("decayModeFinding")>0.5);
498	>	tau.set_byVLooseCombinedIsolationDeltaBetaCorr  ( pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5);
499	>	tau.set_byLooseCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5);
500	>	tau.set_byMediumCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5);
501	>	tau.set_byTightCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5);
502	>	tau.set_againstElectronLoose  ( pat_tau.tauID("againstElectronLoose")>0.5);
503	>	tau.set_againstElectronMedium ( pat_tau.tauID("againstElectronMedium")>0.5);
504	>	tau.set_againstElectronTight ( pat_tau.tauID("againstElectronTight")>0.5);
505	>	tau.set_againstElectronMVA  ( pat_tau.tauID("againstElectronMVA")>0.5);
506	>	tau.set_againstMuonLoose ( pat_tau.tauID("againstMuonLoose")>0.5);
507	>	tau.set_againstMuonMedium ( pat_tau.tauID("againstMuonMedium")>0.5);
508	>	tau.set_againstMuonTight ( pat_tau.tauID("againstMuonTight")>0.5);
509	>
510	>	reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
511	>	if(!leadPFCand.isNull()){
512	>	tau.set_leadPFCand_px ( leadPFCand->px());
513	>	tau.set_leadPFCand_py ( leadPFCand->py());
514	>	tau.set_leadPFCand_pz ( leadPFCand->pz());
515	>	}
516	>	else{
517	>	tau.set_leadPFCand_px ( 0);
518	>	tau.set_leadPFCand_py ( 0);
519	>	tau.set_leadPFCand_pz ( 0);
520	>	}
521		taus[j].push_back(tau);
522		}
523		}
#	Line 383 | Line 544 | NtupleWriter::analyze(const edm::Event&
544		//       }
545
546		Jet jet;
547	<	jet.charge = pat_jet.charge();
548	<	jet.pt = pat_jet.pt();
549	<	jet.eta = pat_jet.eta();
550	<	jet.phi = pat_jet.phi();
551	<	jet.energy = pat_jet.energy();
552	<	jet.numberOfDaughters =pat_jet.numberOfDaughters();
547	>	jet.set_charge(pat_jet.charge());
548	>	jet.set_pt(pat_jet.pt());
549	>	jet.set_eta(pat_jet.eta());
550	>	jet.set_phi(pat_jet.phi());
551	>	jet.set_energy(pat_jet.energy());
552	>	jet.set_numberOfDaughters (pat_jet.numberOfDaughters());
553		const reco::TrackRefVector&  jettracks = pat_jet.associatedTracks();
554	<	jet.nTracks = jettracks.size();
555	<	jet.jetArea = pat_jet.jetArea();
556	<	jet.pileup = pat_jet.pileup();
554	>	jet.set_nTracks ( jettracks.size());
555	>	jet.set_jetArea(pat_jet.jetArea());
556	>	jet.set_pileup(pat_jet.pileup());
557		if(pat_jet.isPFJet()){
558	<	jet.neutralEmEnergyFraction =pat_jet.neutralEmEnergyFraction();
559	<	jet.neutralHadronEnergyFraction =pat_jet.neutralHadronEnergyFraction();
560	<	jet.chargedEmEnergyFraction =pat_jet.chargedEmEnergyFraction();
561	<	jet.chargedHadronEnergyFraction =pat_jet.chargedHadronEnergyFraction();
562	<	jet.muonEnergyFraction =pat_jet.muonEnergyFraction();
563	<	jet.photonEnergyFraction =pat_jet.photonEnergyFraction();
564	<	jet.chargedMultiplicity =pat_jet.chargedMultiplicity();
565	<	jet.neutralMultiplicity =pat_jet.neutralMultiplicity();
566	<	jet.muonMultiplicity =pat_jet.muonMultiplicity();
567	<	jet.electronMultiplicity =pat_jet.electronMultiplicity();
568	<	jet.photonMultiplicity =pat_jet.photonMultiplicity();
558	>	jet.set_neutralEmEnergyFraction (pat_jet.neutralEmEnergyFraction());
559	>	jet.set_neutralHadronEnergyFraction (pat_jet.neutralHadronEnergyFraction());
560	>	jet.set_chargedEmEnergyFraction (pat_jet.chargedEmEnergyFraction());
561	>	jet.set_chargedHadronEnergyFraction (pat_jet.chargedHadronEnergyFraction());
562	>	jet.set_muonEnergyFraction (pat_jet.muonEnergyFraction());
563	>	jet.set_photonEnergyFraction (pat_jet.photonEnergyFraction());
564	>	jet.set_chargedMultiplicity (pat_jet.chargedMultiplicity());
565	>	jet.set_neutralMultiplicity (pat_jet.neutralMultiplicity());
566	>	jet.set_muonMultiplicity (pat_jet.muonMultiplicity());
567	>	jet.set_electronMultiplicity (pat_jet.electronMultiplicity());
568	>	jet.set_photonMultiplicity (pat_jet.photonMultiplicity());
569		}
570
571		jecUnc->setJetEta(pat_jet.eta());
572		jecUnc->setJetPt(pat_jet.pt());
573	<	jet.JEC_uncertainty = jecUnc->getUncertainty(true);
574	<
414	<	jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
415	<	jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
416	<	jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
417	<	jet.btag_combinedSecondaryVertexMVA=pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
418	<	jet.btag_jetBProbability=pat_jet.bDiscriminator("jetBProbabilityBJetTags");
419	<	jet.btag_jetProbability=pat_jet.bDiscriminator("jetProbabilityBJetTags");
573	>	jet.set_JEC_uncertainty(jecUnc->getUncertainty(true));
574	>	jet.set_JEC_factor_raw(pat_jet.jecFactor("Uncorrected"));
575
576	+	jet.set_btag_simpleSecondaryVertexHighEff(pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
577	+	jet.set_btag_simpleSecondaryVertexHighPur(pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
578	+	jet.set_btag_combinedSecondaryVertex(pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags"));
579	+	jet.set_btag_combinedSecondaryVertexMVA(pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
580	+	jet.set_btag_jetBProbability(pat_jet.bDiscriminator("jetBProbabilityBJetTags"));
581	+	jet.set_btag_jetProbability(pat_jet.bDiscriminator("jetProbabilityBJetTags"));
582	+
583	+	const reco::GenJet *genj = pat_jet.genJet();
584	+	if(genj){
585	+	jet.set_genjet_pt(genj->pt());
586	+	jet.set_genjet_eta(genj->eta());
587	+	jet.set_genjet_phi(genj->phi());
588	+	jet.set_genjet_energy(genj->energy());
589	+	if(doAllGenParticles){
590	+	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
591	+	for(unsigned int l = 0; l<jetgenps.size(); ++l){
592	+	for(unsigned int k=0; k< genps.size(); ++k){
593	+	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
594	+	jet.add_genparticles_index(genps[k].index());
595	+	break;
596	+	}
597	+	}
598	+	}
599	+	if(jet.genparticles_indices().size()!= jetgenps.size())
600	+	std::cout << "WARNING: Found only " << jet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this jet"<<std::endl;
601	+	}
602	+	}
603		jets[j].push_back(jet);
604		}
605		}
#	Line 434 | Line 616 | NtupleWriter::analyze(const edm::Event&
616		iEvent.getByLabel(topjet_sources[j], pat_topjets);
617
618		for (unsigned int i = 0; i < pat_topjets->size(); i++) {
619	+
620		const pat::Jet  pat_topjet =  * dynamic_cast<pat::Jet const *>(&pat_topjets->at(i));
621		if(pat_topjet.pt() < topjet_ptmin) continue;
622		if(fabs(pat_topjet.eta()) > topjet_etamax) continue;
623
624		TopJet topjet;
625	<	topjet.charge = pat_topjet.charge();
626	<	topjet.pt = pat_topjet.pt();
627	<	topjet.eta = pat_topjet.eta();
628	<	topjet.phi = pat_topjet.phi();
629	<	topjet.energy = pat_topjet.energy();
630	<	topjet.numberOfDaughters =pat_topjet.numberOfDaughters();
625	>	topjet.set_charge(pat_topjet.charge());
626	>	topjet.set_pt(pat_topjet.pt());
627	>	topjet.set_eta(pat_topjet.eta());
628	>	topjet.set_phi(pat_topjet.phi());
629	>	topjet.set_energy(pat_topjet.energy());
630	>	topjet.set_numberOfDaughters(pat_topjet.numberOfDaughters());
631		const reco::TrackRefVector&  topjettracks = pat_topjet.associatedTracks();
632	<	topjet.nTracks = topjettracks.size();
633	<	topjet.jetArea = pat_topjet.jetArea();
634	<	topjet.pileup = pat_topjet.pileup();
635	<	//       topjet.neutralEmEnergyFraction =pat_topjet.neutralEmEnergyFraction();
636	<	//       topjet.neutralHadronEnergyFraction =pat_topjet.neutralHadronEnergyFraction();
637	<	//       topjet.chargedEmEnergyFraction =pat_topjet.chargedEmEnergyFraction();
638	<	//       topjet.chargedHadronEnergyFraction =pat_topjet.chargedHadronEnergyFraction();
639	<	//       topjet.muonEnergyFraction =pat_topjet.muonEnergyFraction();
640	<	//       topjet.photonEnergyFraction =pat_topjet.photonEnergyFraction();
641	<	//       topjet.chargedMultiplicity =pat_topjet.chargedMultiplicity();
642	<	//       topjet.neutralMultiplicity =pat_topjet.neutralMultiplicity();
643	<	//       topjet.muonMultiplicity =pat_topjet.muonMultiplicity();
644	<	//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
645	<	//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
632	>	topjet.set_nTracks( topjettracks.size());
633	>	topjet.set_jetArea( pat_topjet.jetArea());
634	>	topjet.set_pileup( pat_topjet.pileup());
635	>	//       topjet.set_neutralEmEnergyFraction(pat_topjet.neutralEmEnergyFraction());
636	>	//       topjet.set_neutralHadronEnergyFraction(pat_topjet.neutralHadronEnergyFraction());
637	>	//       topjet.set_chargedEmEnergyFraction(pat_topjet.chargedEmEnergyFraction());
638	>	//       topjet.set_chargedHadronEnergyFraction(pat_topjet.chargedHadronEnergyFraction());
639	>	//       topjet.set_muonEnergyFraction(pat_topjet.muonEnergyFraction());
640	>	//       topjet.set_photonEnergyFraction(pat_topjet.photonEnergyFraction());
641	>	//       topjet.set_chargedMultiplicity(pat_topjet.chargedMultiplicity());
642	>	//       topjet.set_neutralMultiplicity(pat_topjet.neutralMultiplicity());
643	>	//       topjet.set_muonMultiplicity(pat_topjet.muonMultiplicity());
644	>	//       topjet.set_electronMultiplicity(pat_topjet.electronMultiplicity());
645	>	//       topjet.set_photonMultiplicity(pat_topjet.photonMultiplicity());
646
647		jecUnc->setJetEta(pat_topjet.eta());
648		jecUnc->setJetPt(pat_topjet.pt());
649	<	topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
649	>	topjet.set_JEC_uncertainty( jecUnc->getUncertainty(true));
650	>	topjet.set_JEC_factor_raw( pat_topjet.jecFactor("Uncorrected"));
651
652	<	topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
653	<	topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
654	<	topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
655	<	topjet.btag_combinedSecondaryVertexMVA=pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
656	<	topjet.btag_jetBProbability=pat_topjet.bDiscriminator("jetBProbabilityBJetTags");
657	<	topjet.btag_jetProbability=pat_topjet.bDiscriminator("jetProbabilityBJetTags");
652	>	topjet.set_btag_simpleSecondaryVertexHighEff(pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
653	>	topjet.set_btag_simpleSecondaryVertexHighPur(pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
654	>	topjet.set_btag_combinedSecondaryVertex(pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags"));
655	>	topjet.set_btag_combinedSecondaryVertexMVA(pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
656	>	topjet.set_btag_jetBProbability(pat_topjet.bDiscriminator("jetBProbabilityBJetTags"));
657	>	topjet.set_btag_jetProbability(pat_topjet.bDiscriminator("jetProbabilityBJetTags"));
658	>
659	>	const reco::GenJet *genj = pat_topjet.genJet();
660	>	if(genj){
661	>	topjet.set_genjet_pt ( genj->pt());
662	>	topjet.set_genjet_eta ( genj->eta());
663	>	topjet.set_genjet_phi ( genj->phi());
664	>	topjet.set_genjet_energy ( genj->energy());
665	>	if(doAllGenParticles){
666	>	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
667	>	for(unsigned int l = 0; l<jetgenps.size(); ++l){
668	>	for(unsigned int k=0; k< genps.size(); ++k){
669	>	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
670	>	topjet.add_genparticles_index(genps[k].index());
671	>	break;
672	>	}
673	>	}
674	>	}
675	>	if(topjet.genparticles_indices().size()!= jetgenps.size())
676	>	std::cout << "WARNING: Found only " << topjet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this topjet"<<std::endl;
677	>	}
678	>	}
679
680		for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) {
681		Particle subjet_v4;
682	<	subjet_v4.pt = pat_topjet.daughter(k)->p4().pt();
683	<	subjet_v4.eta = pat_topjet.daughter(k)->p4().eta();
684	<	subjet_v4.phi = pat_topjet.daughter(k)->p4().phi();
685	<	subjet_v4.energy = pat_topjet.daughter(k)->p4().E();
686	<	topjet.subjets.push_back(subjet_v4);
682	>	subjet_v4.set_pt(pat_topjet.daughter(k)->p4().pt());
683	>	subjet_v4.set_eta(pat_topjet.daughter(k)->p4().eta());
684	>	subjet_v4.set_phi(pat_topjet.daughter(k)->p4().phi());
685	>	subjet_v4.set_energy(pat_topjet.daughter(k)->p4().E());
686	>	topjet.add_subjet(subjet_v4);
687		}
688		topjets[j].push_back(topjet);
689		}
690		}
691		}
692
693	+
694	+	// ------------- generator top jets -------------
695	+	if(doGenTopJets){
696	+	for(size_t j=0; j< gentopjet_sources.size(); ++j){
697	+
698	+	gentopjets[j].clear();
699	+
700	+	edm::Handle<reco::BasicJetCollection> reco_gentopjets;
701	+	//edm::Handle<std::vector<reco::Jet> > reco_gentopjets;
702	+	iEvent.getByLabel(gentopjet_sources[j], reco_gentopjets);
703	+
704	+	for (unsigned int i = 0; i < reco_gentopjets->size(); i++) {
705	+
706	+	const reco::BasicJet  reco_gentopjet =  reco_gentopjets->at(i);
707	+	if(reco_gentopjet.pt() < gentopjet_ptmin) continue;
708	+	if(fabs(reco_gentopjet.eta()) > gentopjet_etamax) continue;
709	+
710	+	TopJet gentopjet;
711	+	gentopjet.set_charge(reco_gentopjet.charge());
712	+	gentopjet.set_pt(reco_gentopjet.pt());
713	+	gentopjet.set_eta(reco_gentopjet.eta());
714	+	gentopjet.set_phi(reco_gentopjet.phi());
715	+	gentopjet.set_energy(reco_gentopjet.energy());
716	+	gentopjet.set_numberOfDaughters(reco_gentopjet.numberOfDaughters());
717	+
718	+	for (unsigned int k = 0; k < reco_gentopjet.numberOfDaughters(); k++) {
719	+	Particle subjet_v4;
720	+	subjet_v4.set_pt(reco_gentopjet.daughter(k)->p4().pt());
721	+	subjet_v4.set_eta(reco_gentopjet.daughter(k)->p4().eta());
722	+	subjet_v4.set_phi(reco_gentopjet.daughter(k)->p4().phi());
723	+	subjet_v4.set_energy(reco_gentopjet.daughter(k)->p4().E());
724	+	gentopjet.add_subjet(subjet_v4);
725	+	}
726	+	gentopjets[j].push_back(gentopjet);
727	+	}
728	+	}
729	+	}
730	+
731		// ------------- photons -------------
732		if(doPhotons){
733		for(size_t j=0; j< photon_sources.size(); ++j){
#	Line 497 | Line 740 | NtupleWriter::analyze(const edm::Event&
740		for (unsigned int i = 0; i < pat_photons.size(); ++i) {
741		pat::Photon pat_photon = pat_photons[i];
742		Photon ph;
743	<	ph.charge = 0;
744	<	ph.pt =  pat_photon.pt();
745	<	ph.eta =  pat_photon.eta();
746	<	ph.phi =  pat_photon.phi();
747	<	ph.energy =  pat_photon.energy();
748	<	ph.vertex_x = pat_photon.vertex().x();
749	<	ph.vertex_y = pat_photon.vertex().y();
750	<	ph.vertex_z = pat_photon.vertex().z();
751	<	ph.supercluster_eta = pat_photon.superCluster()->eta();
752	<	ph.supercluster_phi = pat_photon.superCluster()->phi();
753	<	//       ph.neutralHadronIso = pat_photon.neutralHadronIso();
754	<	//       ph.chargedHadronIso = pat_photon.chargedHadronIso();
755	<	ph.trackIso = pat_photon.trackIso();
743	>	ph.set_charge(0);
744	>	ph.set_pt( pat_photon.pt());
745	>	ph.set_eta( pat_photon.eta());
746	>	ph.set_phi( pat_photon.phi());
747	>	ph.set_energy( pat_photon.energy());
748	>	ph.set_vertex_x(pat_photon.vertex().x());
749	>	ph.set_vertex_y(pat_photon.vertex().y());
750	>	ph.set_vertex_z(pat_photon.vertex().z());
751	>	ph.set_supercluster_eta(pat_photon.superCluster()->eta());
752	>	ph.set_supercluster_phi(pat_photon.superCluster()->phi());
753	>	//       ph.set_neutralHadronIso(pat_photon.neutralHadronIso());
754	>	//       ph.set_chargedHadronIso(pat_photon.chargedHadronIso());
755	>	ph.set_trackIso(pat_photon.trackIso());
756		phs[j].push_back(ph);
757		}
758		}
#	Line 529 | Line 772 | NtupleWriter::analyze(const edm::Event&
772		else{
773		pat::MET pat_met = pat_mets[0];
774
775	<	met[j].pt=pat_met.pt();
776	<	met[j].phi=pat_met.phi();
777	<	met[j].mEtSig= pat_met.mEtSig();
775	>	met[j].set_pt(pat_met.pt());
776	>	met[j].set_phi(pat_met.phi());
777	>	met[j].set_mEtSig(pat_met.mEtSig());
778		}
779
780		}
#	Line 554 | Line 797 | NtupleWriter::analyze(const edm::Event&
797
798		triggerResults.clear();
799		triggerNames.clear();
800	<	L1_prescale.clear();
801	<	HLT_prescale.clear();
800	>	//      L1_prescale.clear();
801	>	//      HLT_prescale.clear();
802
803		edm::Service<edm::service::TriggerNamesService> tns;
804		std::vector<std::string> triggerNames_all;
#	Line 572 | Line 815 | NtupleWriter::analyze(const edm::Event&
815		//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
816		triggerResults.push_back(trig.accept(i));
817		if(newrun) triggerNames.push_back(triggerNames_all[i]);
818	<	if(isRealData){
819	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
820	<	L1_prescale.push_back(pre.first);
821	<	HLT_prescale.push_back(pre.second);
822	<	}
818	>	//        if(isRealData){
819	>	//       std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
820	>	//       L1_prescale.push_back(pre.first);
821	>	//       HLT_prescale.push_back(pre.second);
822	>	//       //std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
823	>	//        }
824		}
825		//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
826		//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
#	Line 584 | Line 828 | NtupleWriter::analyze(const edm::Event&
828		newrun=false;
829		}
830
587	–	// ------------- generator info -------------
588	–
589	–	if(doGenInfo){
590	–	genInfo.weights.clear();
591	–	genInfo.binningValues.clear();
592	–	genps.clear();
593	–
594	–	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
595	–	iEvent.getByLabel("generator", genEventInfoProduct);
596	–	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
597	–
598	–	genInfo.binningValues = genEventInfo.binningValues();
599	–	genInfo.weights = genEventInfo.weights();
600	–	genInfo.alphaQCD = genEventInfo.alphaQCD();
601	–	genInfo.alphaQED = genEventInfo.alphaQED();
602	–	genInfo.qScale = genEventInfo.qScale();
603	–
604	–	const gen::PdfInfo* pdf = genEventInfo.pdf();
605	–	if(pdf){
606	–	genInfo.pdf_id1=pdf->id.first;
607	–	genInfo.pdf_id2=pdf->id.second;
608	–	genInfo.pdf_x1=pdf->x.first;
609	–	genInfo.pdf_x2=pdf->x.second;
610	–	genInfo.pdf_scalePDF=pdf->scalePDF;
611	–	genInfo.pdf_xPDF1=pdf->xPDF.first;
612	–	genInfo.pdf_xPDF2=pdf->xPDF.second;
613	–	}
614	–	else{
615	–	genInfo.pdf_id1=-999;
616	–	genInfo.pdf_id2=-999;
617	–	genInfo.pdf_x1=-999;
618	–	genInfo.pdf_x2=-999;
619	–	genInfo.pdf_scalePDF=-999;
620	–	genInfo.pdf_xPDF1=-999;
621	–	genInfo.pdf_xPDF2=-999;
622	–	}
623	–
624	–	edm::Handle<std::vector<PileupSummaryInfo> > pus;
625	–	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
626	–	genInfo.pileup_NumInteractions_intime=0;
627	–	genInfo.pileup_NumInteractions_ootbefore=0;
628	–	genInfo.pileup_NumInteractions_ootafter=0;
629	–	if(pus.isValid()){
630	–	genInfo.pileup_TrueNumInteractions = (float) pus->at(0).getTrueNumInteractions();
631	–	for(size_t i=0; i<pus->size(); ++i){
632	–	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
633	–	genInfo.pileup_NumInteractions_intime += pus->at(i).getPU_NumInteractions();
634	–	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
635	–	genInfo.pileup_NumInteractions_ootbefore += pus->at(i).getPU_NumInteractions();
636	–	}
637	–	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
638	–	genInfo.pileup_NumInteractions_ootafter += pus->at(i).getPU_NumInteractions();
639	–	}
640	–	}
641	–	}
642	–
643	–	edm::Handle<reco::GenParticleCollection> genPartColl;
644	–	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
645	–	int index=-1;
646	–	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
647	–	index++;
648	–
649	–	//write out only top quarks and status 3 particles (works fine only for MadGraph)
650	–	if(abs(iter->pdgId())==6 || iter->status()==3){
651	–	GenParticle genp;
652	–	genp.charge = iter->charge();;
653	–	genp.pt = iter->p4().pt();
654	–	genp.eta = iter->p4().eta();
655	–	genp.phi = iter->p4().phi();
656	–	genp.energy = iter->p4().E();
657	–	genp.index =index;
658	–	genp.status = iter->status();
659	–	genp.pdgId = iter->pdgId();
660	–
661	–	genp.mother1=-1;
662	–	genp.mother2=-1;
663	–	genp.daughter1=-1;
664	–	genp.daughter2=-1;
665	–
666	–	int nm=iter->numberOfMothers();
667	–	int nd=iter->numberOfDaughters();
668	–
669	–	if (nm>0) genp.mother1 = iter->motherRef(0).key();
670	–	if (nm>1) genp.mother2 = iter->motherRef(nm-1).key();
671	–	if (nd>0) genp.daughter1 = iter->daughterRef(0).key();
672	–	if (nd>1) genp.daughter2 = iter->daughterRef(nd-1).key();
673	–
674	–	genps.push_back(genp);
675	–	}
676	–	}
677	–
678	–	}
679	–
831
832		tr->Fill();
833	<
833	>	if(doLumiInfo)
834	>	previouslumiblockwasfilled=true;
835		}
836
837
#	Line 687 | Line 839 | NtupleWriter::analyze(const edm::Event&
839		void
840		NtupleWriter::beginJob()
841		{
842	+	if(doLumiInfo){
843	+	totalRecLumi=0;
844	+	totalDelLumi=0;
845	+	previouslumiblockwasfilled=false;
846	+	}
847		}
848
849		// ------------ method called once each job just after ending the event loop  ------------
#	Line 702 | Line 859 | NtupleWriter::endJob()
859		void
860		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
861		{
862	<	bool setup_changed = false;
863	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
864	<	newrun=true;
865	<
866	<	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
710	<	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
711	<	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
712	<	jecUnc = new JetCorrectionUncertainty(JetCorPar);
862	>	if(doTrigger){
863	>	bool setup_changed = false;
864	>	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
865	>	newrun=true;
866	>	}
867
868	+	if(doJets || doTopJets){
869	+	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
870	+	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
871	+	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
872	+	jecUnc = new JetCorrectionUncertainty(JetCorPar);
873	+	}
874		}
875
876		// ------------ method called when ending the processing of a run  ------------
877		void
878		NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&)
879		{
880	+	if(doLumiInfo)
881	+	std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl;
882		}
883
884		// ------------ method called when starting to processes a luminosity block  ------------
885		void
886	<	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
886	>	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&)
887		{
888	+	if(doLumiInfo){
889	+	edm::Handle<LumiSummary> l;
890	+	lumi.getByLabel("lumiProducer", l);
891	+
892	+	//add lumi of lumi blocks without any event to next lumiblock
893	+	if(previouslumiblockwasfilled){
894	+	intgRecLumi=0;
895	+	intgDelLumi=0;
896	+	}
897	+	previouslumiblockwasfilled=false;
898	+
899	+	if (l.isValid()){;
900	+	intgRecLumi+=l->intgRecLumi()*6.37;
901	+	intgDelLumi+=l->intgDelLumi()*6.37;
902	+	totalRecLumi+=l->intgRecLumi()*6.37;
903	+	totalDelLumi+=l->intgDelLumi()*6.37;
904	+	}
905	+	//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<"   " << l->intgDelLumi()*6.37<<std::endl;
906	+	//std::cout << "summed:  "<< intgRecLumi << "   " << intgDelLumi << std::endl;
907	+	}
908		}
909
910		// ------------ method called when ending the processing of a luminosity block  ------------

Diff Legend

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