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.4 by peiffer, Mon Apr 2 15:10:03 2012 UTC vs.
Revision 1.20 by peiffer, Mon Jun 18 15:53:51 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	+	doJECUncertainty = iConfig.getParameter<bool>("doJECUncertainty");
54	+	doGenTopJets = iConfig.getParameter<bool>("doGenTopJets");
55		doPhotons = iConfig.getParameter<bool>("doPhotons");
56		doMET = iConfig.getParameter<bool>("doMET");
57		doGenInfo = iConfig.getParameter<bool>("doGenInfo");
58	+	doAllGenParticles = iConfig.getParameter<bool>("doAllGenParticles");
59	+	doLumiInfo = iConfig.getParameter<bool>("doLumiInfo");
60		doPV = iConfig.getParameter<bool>("doPV");
61		doTopJets = iConfig.getParameter<bool>("doTopJets");
62	+	doTrigger = iConfig.getParameter<bool>("doTrigger");
63
64		// initialization of tree variables
65
#	Line 62 | Line 67 | NtupleWriter::NtupleWriter(const edm::Pa
67		tr->Branch("event",&event);
68		tr->Branch("luminosityBlock",&luminosityBlock);
69		tr->Branch("isRealData",&isRealData);
70	<	tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
71	<	tr->Branch("beamspot_x0",&beamspot_x0);
67	<	tr->Branch("beamspot_y0",&beamspot_y0);
68	<	tr->Branch("beamspot_z0",&beamspot_z0);
70	>	tr->Branch("rho",&rho);
71	>	rho_source = iConfig.getParameter<edm::InputTag>("rho_source");
72
73	+	//tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
74	+	if(doLumiInfo){
75	+	tr->Branch("intgRecLumi",&intgRecLumi);
76	+	tr->Branch("intgDelLumi",&intgDelLumi);
77	+	}
78	+	if(doPV){
79	+	tr->Branch("beamspot_x0",&beamspot_x0);
80	+	tr->Branch("beamspot_y0",&beamspot_y0);
81	+	tr->Branch("beamspot_z0",&beamspot_z0);
82	+	}
83		if(doElectrons){
84		electron_sources = iConfig.getParameter<std::vector<std::string> >("electron_sources");
85		for(size_t j=0; j< electron_sources.size(); ++j){
#	Line 103 | Line 116 | NtupleWriter::NtupleWriter(const edm::Pa
116		tr->Branch( topjet_sources[j].c_str(), "std::vector<TopJet>", &topjets[j]);
117		}
118		}
119	+	if(doGenTopJets){
120	+	gentopjet_sources = iConfig.getParameter<std::vector<std::string> >("gentopjet_sources");
121	+	gentopjet_ptmin = iConfig.getParameter<double> ("gentopjet_ptmin");
122	+	gentopjet_etamax = iConfig.getParameter<double> ("gentopjet_etamax");
123	+	for(size_t j=0; j< gentopjet_sources.size(); ++j){
124	+	tr->Branch( gentopjet_sources[j].c_str(), "std::vector<TopJet>", &gentopjets[j]);
125	+	}
126	+	}
127		if(doPhotons){
128		photon_sources = iConfig.getParameter<std::vector<std::string> >("photon_sources");
129		for(size_t j=0; j< photon_sources.size(); ++j){
#	Line 125 | Line 146 | NtupleWriter::NtupleWriter(const edm::Pa
146		tr->Branch("genInfo","GenInfo",&genInfo);
147		tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
148		}
149	<
150	<	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
151	<	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
152	<	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
153	<	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
154	<	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
155	<	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
156	<
149	>	if(doTrigger){
150	>	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
151	>	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
152	>	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
153	>	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
154	>	//tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
155	>	//tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
156	>	}
157		newrun = true;
158		}
159
#	Line 164 | Line 185 | NtupleWriter::analyze(const edm::Event&
185		luminosityBlock = iEvent.luminosityBlock();
186		isRealData      = iEvent.isRealData();
187
188	<	if(isRealData){
189	<	edm::Handle<bool> bool_handle;
190	<	iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
191	<	HBHENoiseFilterResult = *(bool_handle.product());
188	>	edm::Handle<double> m_rho;
189	>	iEvent.getByLabel(rho_source,m_rho);
190	>	rho=*m_rho;
191	>
192	>	//    if(isRealData){
193	>	//      edm::Handle<bool> bool_handle;
194	>	//      iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
195	>	//      HBHENoiseFilterResult = *(bool_handle.product());
196	>	//    }
197	>	//    else HBHENoiseFilterResult = false;
198	>
199	>	// ------------- primary vertices and beamspot  -------------
200	>
201	>	if(doPV){
202	>	for(size_t j=0; j< pv_sources.size(); ++j){
203	>	pvs[j].clear();
204	>
205	>	edm::Handle< std::vector<reco::Vertex> > pv_handle;
206	>	iEvent.getByLabel(pv_sources[j], pv_handle);
207	>	const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product());
208	>
209	>	for (unsigned int i = 0; i <  reco_pvs.size(); ++i) {
210	>	reco::Vertex reco_pv = reco_pvs[i];
211	>
212	>	PrimaryVertex pv;
213	>	pv.set_x( reco_pv.x());
214	>	pv.set_y( reco_pv.y());
215	>	pv.set_z( reco_pv.z());
216	>	pv.set_nTracks( reco_pv.nTracks());
217	>	//pv.set_isValid( reco_pv.isValid());
218	>	pv.set_chi2( reco_pv.chi2());
219	>	pv.set_ndof( reco_pv.ndof());
220	>
221	>	pvs[j].push_back(pv);
222	>	}
223	>	}
224	>
225	>	edm::Handle<reco::BeamSpot> beamSpot;
226	>	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
227	>	const reco::BeamSpot & bsp = *beamSpot;
228	>
229	>	beamspot_x0 = bsp.x0();
230	>	beamspot_y0 = bsp.y0();
231	>	beamspot_z0 = bsp.z0();
232	>	}
233	>
234	>	// ------------- generator info -------------
235	>
236	>	if(doGenInfo){
237	>	genInfo.clear_weights();
238	>	genInfo.clear_binningValues();
239	>	genps.clear();
240	>
241	>	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
242	>	iEvent.getByLabel("generator", genEventInfoProduct);
243	>	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
244	>
245	>	for(unsigned int k=0; k<genEventInfo.binningValues().size();++k){
246	>	genInfo.add_binningValue(genEventInfo.binningValues().at(k));
247	>	}
248	>	for(unsigned int k=0; k<genEventInfo.weights().size();++k){
249	>	genInfo.add_weight(genEventInfo.weights().at(k));
250	>	}
251	>	genInfo.set_alphaQCD(genEventInfo.alphaQCD());
252	>	genInfo.set_alphaQED(genEventInfo.alphaQED());
253	>	genInfo.set_qScale(genEventInfo.qScale());
254	>
255	>	const gen::PdfInfo* pdf = genEventInfo.pdf();
256	>	if(pdf){
257	>	genInfo.set_pdf_id1(pdf->id.first);
258	>	genInfo.set_pdf_id2(pdf->id.second);
259	>	genInfo.set_pdf_x1(pdf->x.first);
260	>	genInfo.set_pdf_x2(pdf->x.second);
261	>	genInfo.set_pdf_scalePDF(pdf->scalePDF);
262	>	genInfo.set_pdf_xPDF1(pdf->xPDF.first);
263	>	genInfo.set_pdf_xPDF2(pdf->xPDF.second);
264	>	}
265	>	else{
266	>	genInfo.set_pdf_id1(-999);
267	>	genInfo.set_pdf_id2(-999);
268	>	genInfo.set_pdf_x1(-999);
269	>	genInfo.set_pdf_x2(-999);
270	>	genInfo.set_pdf_scalePDF(-999);
271	>	genInfo.set_pdf_xPDF1(-999);
272	>	genInfo.set_pdf_xPDF2(-999);
273	>	}
274	>
275	>	edm::Handle<std::vector<PileupSummaryInfo> > pus;
276	>	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
277	>	genInfo.set_pileup_NumInteractions_intime(0);
278	>	genInfo.set_pileup_NumInteractions_ootbefore(0);
279	>	genInfo.set_pileup_NumInteractions_ootafter(0);
280	>	if(pus.isValid()){
281	>	genInfo.set_pileup_TrueNumInteractions ( (float) pus->at(0).getTrueNumInteractions());
282	>	for(size_t i=0; i<pus->size(); ++i){
283	>	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
284	>	genInfo.set_pileup_NumInteractions_intime( genInfo.pileup_NumInteractions_intime() + pus->at(i).getPU_NumInteractions());
285	>	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
286	>	genInfo.set_pileup_NumInteractions_ootbefore( genInfo.pileup_NumInteractions_ootbefore() + pus->at(i).getPU_NumInteractions());
287	>	}
288	>	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
289	>	genInfo.set_pileup_NumInteractions_ootafter( genInfo.pileup_NumInteractions_ootafter() + pus->at(i).getPU_NumInteractions());
290	>	}
291	>	}
292	>	}
293	>
294	>	edm::Handle<reco::GenParticleCollection> genPartColl;
295	>	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
296	>	int index=-1;
297	>	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
298	>	index++;
299	>
300	>	//write out only top quarks and status 3 particles (works fine only for MadGraph)
301	>	if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){
302	>	GenParticle genp;
303	>	genp.set_charge(iter->charge());
304	>	genp.set_pt(iter->p4().pt());
305	>	genp.set_eta(iter->p4().eta());
306	>	genp.set_phi(iter->p4().phi());
307	>	genp.set_energy(iter->p4().E());
308	>	genp.set_index(index);
309	>	genp.set_status( iter->status());
310	>	genp.set_pdgId( iter->pdgId());
311	>
312	>	genp.set_mother1(-1);
313	>	genp.set_mother2(-1);
314	>	genp.set_daughter1(-1);
315	>	genp.set_daughter2(-1);
316	>
317	>	int nm=iter->numberOfMothers();
318	>	int nd=iter->numberOfDaughters();
319	>
320	>
321	>	if (nm>0) genp.set_mother1( iter->motherRef(0).key());
322	>	if (nm>1) genp.set_mother2( iter->motherRef(1).key());
323	>	if (nd>0) genp.set_daughter1( iter->daughterRef(0).key());
324	>	if (nd>1) genp.set_daughter2( iter->daughterRef(1).key());
325	>
326	>	genps.push_back(genp);
327	>	}
328	>	}
329		}
172	–	else HBHENoiseFilterResult = false;
330
331		// ------------- electrons -------------
332		if(doElectrons){
333	+
334	+	//      edm::Handle<reco::ConversionCollection> hConversions;
335	+	//      iEvent.getByLabel("allConversions", hConversions);
336	+
337	+	//      edm::Handle<reco::BeamSpot> beamSpot;
338	+	//      iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
339	+	//      const reco::BeamSpot & bsp = *beamSpot;
340	+
341		for(size_t j=0; j< electron_sources.size(); ++j){
342		eles[j].clear();
343		edm::Handle< std::vector<pat::Electron> > ele_handle;
#	Line 183 | Line 348 | NtupleWriter::analyze(const edm::Event&
348		pat::Electron pat_ele = pat_electrons[i];
349		Electron ele;
350
351	<	ele.charge =  pat_ele.charge();
352	<	ele.pt =  pat_ele.pt();
353	<	ele.eta =  pat_ele.eta();
354	<	ele.phi =  pat_ele.phi();
355	<	ele.energy =  pat_ele.energy();
356	<	ele.vertex_x = pat_ele.vertex().x();
357	<	ele.vertex_y = pat_ele.vertex().y();
358	<	ele.vertex_z = pat_ele.vertex().z();
359	<	ele.supercluster_eta = pat_ele.superCluster()->eta();
360	<	ele.supercluster_phi = pat_ele.superCluster()->phi();
361	<	ele.dB = pat_ele.dB();
362	<	//ele.particleIso = pat_ele.particleIso();
363	<	ele.neutralHadronIso = pat_ele.neutralHadronIso();
364	<	ele.chargedHadronIso = pat_ele.chargedHadronIso();
365	<	ele.trackIso = pat_ele.trackIso();
366	<	ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
351	>	ele.set_charge( pat_ele.charge());
352	>	ele.set_pt( pat_ele.pt());
353	>	ele.set_eta( pat_ele.eta());
354	>	ele.set_phi( pat_ele.phi());
355	>	ele.set_energy( pat_ele.energy());
356	>	ele.set_vertex_x(pat_ele.vertex().x());
357	>	ele.set_vertex_y(pat_ele.vertex().y());
358	>	ele.set_vertex_z(pat_ele.vertex().z());
359	>	ele.set_supercluster_eta(pat_ele.superCluster()->eta());
360	>	ele.set_supercluster_phi(pat_ele.superCluster()->phi());
361	>	ele.set_dB(pat_ele.dB());
362	>	//ele.set_particleIso(pat_ele.particleIso());
363	>	ele.set_neutralHadronIso(pat_ele.neutralHadronIso());
364	>	ele.set_chargedHadronIso(pat_ele.chargedHadronIso());
365	>	ele.set_trackIso(pat_ele.trackIso());
366	>	ele.set_photonIso(pat_ele.photonIso());
367	>	ele.set_puChargedHadronIso(pat_ele.puChargedHadronIso());
368	>	ele.set_gsfTrack_trackerExpectedHitsInner_numberOfLostHits(pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits());
369	>	ele.set_gsfTrack_px( pat_ele.gsfTrack()->px());
370	>	ele.set_gsfTrack_py( pat_ele.gsfTrack()->py());
371	>	ele.set_gsfTrack_pz( pat_ele.gsfTrack()->pz());
372	>	ele.set_gsfTrack_vx( pat_ele.gsfTrack()->vx());
373	>	ele.set_gsfTrack_vy( pat_ele.gsfTrack()->vy());
374	>	ele.set_gsfTrack_vz( pat_ele.gsfTrack()->vz());
375	>	//ele.set_passconversionveto(!ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()));
376	>	ele.set_passconversionveto(pat_ele.passConversionVeto());
377	>	ele.set_dEtaIn(pat_ele.deltaEtaSuperClusterTrackAtVtx());
378	>	ele.set_dPhiIn(pat_ele.deltaPhiSuperClusterTrackAtVtx());
379	>	ele.set_sigmaIEtaIEta(pat_ele.sigmaIetaIeta());
380	>	ele.set_HoverE(pat_ele.hadronicOverEm());
381	>	ele.set_fbrem(pat_ele.fbrem());
382	>	ele.set_EoverPIn(pat_ele.eSuperClusterOverP());
383	>	ele.set_EcalEnergy(pat_ele.ecalEnergy());
384	>	ele.set_mvaTrigV0(pat_ele.electronID("mvaTrigV0"));
385	>	ele.set_mvaNonTrigV0(pat_ele.electronID("mvaNonTrigV0"));
386
387		eles[j].push_back(ele);
388		}
#	Line 218 | Line 402 | NtupleWriter::analyze(const edm::Event&
402		pat::Muon pat_mu = pat_muons[i];
403
404		Muon mu;
405	<	mu.charge =  pat_mu.charge();
406	<	mu.pt =  pat_mu.pt();
407	<	mu.eta =  pat_mu.eta();
408	<	mu.phi =  pat_mu.phi();
409	<	mu.energy =  pat_mu.energy();
410	<	mu.vertex_x = pat_mu.vertex().x();
411	<	mu.vertex_y = pat_mu.vertex().y();
412	<	mu.vertex_z = pat_mu.vertex().z();
413	<	mu.dB = pat_mu.dB();
414	<	//mu.particleIso = pat_mu.particleIso();
415	<	mu.neutralHadronIso = pat_mu.neutralHadronIso();
416	<	mu.chargedHadronIso = pat_mu.chargedHadronIso();
417	<	mu.trackIso = pat_mu.trackIso();
418	<	mu.puChargedHadronIso = pat_mu.puChargedHadronIso();
419	<	mu.isGlobalMuon = pat_mu.isGlobalMuon();
420	<	mu.isStandAloneMuon = pat_mu.isStandAloneMuon();
421	<	mu.isTrackerMuon = pat_mu.isTrackerMuon();
422	<	mu.numberOfMatchedStations = pat_mu.numberOfMatchedStations();
405	>	mu.set_charge( pat_mu.charge());
406	>	mu.set_pt( pat_mu.pt());
407	>	mu.set_eta( pat_mu.eta());
408	>	mu.set_phi( pat_mu.phi());
409	>	mu.set_energy( pat_mu.energy());
410	>	mu.set_vertex_x ( pat_mu.vertex().x());
411	>	mu.set_vertex_y ( pat_mu.vertex().y());
412	>	mu.set_vertex_z ( pat_mu.vertex().z());
413	>	mu.set_dB ( pat_mu.dB());
414	>	//mu.particleIso ( pat_mu.particleIso());
415	>	mu.set_neutralHadronIso ( pat_mu.neutralHadronIso());
416	>	mu.set_chargedHadronIso ( pat_mu.chargedHadronIso());
417	>	mu.set_trackIso ( pat_mu.trackIso());
418	>	mu.set_photonIso ( pat_mu.photonIso());
419	>	mu.set_puChargedHadronIso ( pat_mu.puChargedHadronIso());
420	>	mu.set_isGlobalMuon ( pat_mu.isGlobalMuon());
421	>	mu.set_isStandAloneMuon ( pat_mu.isStandAloneMuon());
422	>	mu.set_isTrackerMuon ( pat_mu.isTrackerMuon());
423	>	mu.set_numberOfMatchedStations ( pat_mu.numberOfMatchedStations());
424		reco::TrackRef globalTrack = pat_mu.globalTrack();
425		if(!globalTrack.isNull()){
426	<	mu.globalTrack_chi2 = globalTrack->chi2();
427	<	mu.globalTrack_ndof = globalTrack->ndof();
428	<	mu.globalTrack_d0 = globalTrack->d0();
429	<	mu.globalTrack_d0Error = globalTrack->d0Error();
430	<	mu.globalTrack_numberOfValidHits = globalTrack->numberOfValidHits();
431	<	mu.globalTrack_numberOfLostHits = globalTrack->numberOfLostHits();
426	>	mu.set_globalTrack_chi2 ( globalTrack->chi2());
427	>	mu.set_globalTrack_ndof ( globalTrack->ndof());
428	>	mu.set_globalTrack_d0 ( globalTrack->d0());
429	>	mu.set_globalTrack_d0Error ( globalTrack->d0Error());
430	>	mu.set_globalTrack_numberOfValidHits ( globalTrack->numberOfValidHits());
431	>	mu.set_globalTrack_numberOfLostHits ( globalTrack->numberOfLostHits());
432		}
433		else{
434	<	mu.globalTrack_chi2 = 0;
435	<	mu.globalTrack_ndof = 0;
436	<	mu.globalTrack_d0 = 0;
437	<	mu.globalTrack_d0Error = 0;
438	<	mu.globalTrack_numberOfValidHits = 0;
439	<	mu.globalTrack_numberOfLostHits = 0;
434	>	mu.set_globalTrack_chi2 ( 0);
435	>	mu.set_globalTrack_ndof ( 0);
436	>	mu.set_globalTrack_d0 ( 0);
437	>	mu.set_globalTrack_d0Error ( 0);
438	>	mu.set_globalTrack_numberOfValidHits ( 0);
439	>	mu.set_globalTrack_numberOfLostHits ( 0);
440		}
441		reco::TrackRef innerTrack = pat_mu.innerTrack();
442		if(!innerTrack.isNull()){
443	<	mu.innerTrack_chi2 = innerTrack->chi2();
444	<	mu.innerTrack_ndof = innerTrack->ndof();
445	<	mu.innerTrack_d0 = innerTrack->d0();
446	<	mu.innerTrack_d0Error = innerTrack->d0Error();
447	<	mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits();
448	<	mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits();
443	>	mu.set_innerTrack_chi2 ( innerTrack->chi2());
444	>	mu.set_innerTrack_ndof ( innerTrack->ndof());
445	>	mu.set_innerTrack_d0 ( innerTrack->d0());
446	>	mu.set_innerTrack_d0Error ( innerTrack->d0Error());
447	>	mu.set_innerTrack_numberOfValidHits ( innerTrack->numberOfValidHits());
448	>	mu.set_innerTrack_numberOfLostHits ( innerTrack->numberOfLostHits());
449	>	mu.set_innerTrack_trackerLayersWithMeasurement ( innerTrack->hitPattern().trackerLayersWithMeasurement());
450	>	mu.set_innerTrack_numberOfValidPixelHits ( innerTrack->hitPattern().numberOfValidPixelHits());
451		}
452		else{
453	<	mu.innerTrack_chi2 = 0;
454	<	mu.innerTrack_ndof = 0;
455	<	mu.innerTrack_d0 = 0;
456	<	mu.innerTrack_d0Error = 0;
457	<	mu.innerTrack_numberOfValidHits = 0;
458	<	mu.innerTrack_numberOfLostHits = 0;
453	>	mu.set_innerTrack_chi2 ( 0);
454	>	mu.set_innerTrack_ndof ( 0);
455	>	mu.set_innerTrack_d0 ( 0);
456	>	mu.set_innerTrack_d0Error ( 0);
457	>	mu.set_innerTrack_numberOfValidHits ( 0);
458	>	mu.set_innerTrack_numberOfLostHits ( 0);
459	>	mu.set_innerTrack_trackerLayersWithMeasurement ( 0);
460	>	mu.set_innerTrack_numberOfValidPixelHits ( 0);
461		}
462		reco::TrackRef outerTrack = pat_mu.outerTrack();
463		if(!outerTrack.isNull()){
464	<	mu.outerTrack_chi2 = outerTrack->chi2();
465	<	mu.outerTrack_ndof = outerTrack->ndof();
466	<	mu.outerTrack_d0 = outerTrack->d0();
467	<	mu.outerTrack_d0Error = outerTrack->d0Error();
468	<	mu.outerTrack_numberOfValidHits = outerTrack->numberOfValidHits();
469	<	mu.outerTrack_numberOfLostHits = outerTrack->numberOfLostHits();
464	>	mu.set_outerTrack_chi2 ( outerTrack->chi2());
465	>	mu.set_outerTrack_ndof ( outerTrack->ndof());
466	>	mu.set_outerTrack_d0 ( outerTrack->d0());
467	>	mu.set_outerTrack_d0Error ( outerTrack->d0Error());
468	>	mu.set_outerTrack_numberOfValidHits ( outerTrack->numberOfValidHits());
469	>	mu.set_outerTrack_numberOfLostHits ( outerTrack->numberOfLostHits());
470		}
471		else{
472	<	mu.outerTrack_chi2 = 0;
473	<	mu.outerTrack_ndof = 0;
474	<	mu.outerTrack_d0 = 0;
475	<	mu.outerTrack_d0Error = 0;
476	<	mu.outerTrack_numberOfValidHits = 0;
477	<	mu.outerTrack_numberOfLostHits = 0;
472	>	mu.set_outerTrack_chi2 ( 0);
473	>	mu.set_outerTrack_ndof ( 0);
474	>	mu.set_outerTrack_d0 ( 0);
475	>	mu.set_outerTrack_d0Error ( 0);
476	>	mu.set_outerTrack_numberOfValidHits ( 0);
477	>	mu.set_outerTrack_numberOfLostHits ( 0);
478		}
479
480		mus[j].push_back(mu);
#	Line 309 | Line 498 | NtupleWriter::analyze(const edm::Event&
498		if(fabs(pat_tau.eta()) > tau_etamax) continue;
499
500		Tau tau;
501	<	tau.charge =  pat_tau.charge();
502	<	tau.pt =  pat_tau.pt();
503	<	tau.eta =  pat_tau.eta();
504	<	tau.phi =  pat_tau.phi();
505	<	tau.energy =  pat_tau.energy();
506	<
501	>	tau.set_charge( pat_tau.charge());
502	>	tau.set_pt( pat_tau.pt());
503	>	tau.set_eta( pat_tau.eta());
504	>	tau.set_phi( pat_tau.phi());
505	>	tau.set_energy( pat_tau.energy());
506	>	tau.set_decayModeFinding ( pat_tau.tauID("decayModeFinding")>0.5);
507	>	tau.set_byVLooseCombinedIsolationDeltaBetaCorr  ( pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5);
508	>	tau.set_byLooseCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5);
509	>	tau.set_byMediumCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5);
510	>	tau.set_byTightCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5);
511	>	tau.set_againstElectronLoose  ( pat_tau.tauID("againstElectronLoose")>0.5);
512	>	tau.set_againstElectronMedium ( pat_tau.tauID("againstElectronMedium")>0.5);
513	>	tau.set_againstElectronTight ( pat_tau.tauID("againstElectronTight")>0.5);
514	>	tau.set_againstElectronMVA  ( pat_tau.tauID("againstElectronMVA")>0.5);
515	>	tau.set_againstMuonLoose ( pat_tau.tauID("againstMuonLoose")>0.5);
516	>	tau.set_againstMuonMedium ( pat_tau.tauID("againstMuonMedium")>0.5);
517	>	tau.set_againstMuonTight ( pat_tau.tauID("againstMuonTight")>0.5);
518	>
519	>	//       reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
520	>	//       if(!leadPFCand.isNull()){
521	>	//         tau.set_leadPFCand_px ( leadPFCand->px());
522	>	//         tau.set_leadPFCand_py ( leadPFCand->py());
523	>	//         tau.set_leadPFCand_pz ( leadPFCand->pz());
524	>	//       }
525	>	//       else{
526	>	//         tau.set_leadPFCand_px ( 0);
527	>	//         tau.set_leadPFCand_py ( 0);
528	>	//         tau.set_leadPFCand_pz ( 0);
529	>	//       }
530		taus[j].push_back(tau);
531		}
532		}
#	Line 341 | Line 553 | NtupleWriter::analyze(const edm::Event&
553		//       }
554
555		Jet jet;
556	<	jet.charge = pat_jet.charge();
557	<	jet.pt = pat_jet.pt();
558	<	jet.eta = pat_jet.eta();
559	<	jet.phi = pat_jet.phi();
560	<	jet.energy = pat_jet.energy();
561	<	jet.numberOfDaughters =pat_jet.numberOfDaughters();
556	>	jet.set_charge(pat_jet.charge());
557	>	jet.set_pt(pat_jet.pt());
558	>	jet.set_eta(pat_jet.eta());
559	>	jet.set_phi(pat_jet.phi());
560	>	jet.set_energy(pat_jet.energy());
561	>	jet.set_numberOfDaughters (pat_jet.numberOfDaughters());
562		const reco::TrackRefVector&  jettracks = pat_jet.associatedTracks();
563	<	jet.nTracks = jettracks.size();
564	<	jet.jetArea = pat_jet.jetArea();
565	<	jet.pileup = pat_jet.pileup();
563	>	jet.set_nTracks ( jettracks.size());
564	>	jet.set_jetArea(pat_jet.jetArea());
565	>	jet.set_pileup(pat_jet.pileup());
566		if(pat_jet.isPFJet()){
567	<	jet.neutralEmEnergyFraction =pat_jet.neutralEmEnergyFraction();
568	<	jet.neutralHadronEnergyFraction =pat_jet.neutralHadronEnergyFraction();
569	<	jet.chargedEmEnergyFraction =pat_jet.chargedEmEnergyFraction();
570	<	jet.chargedHadronEnergyFraction =pat_jet.chargedHadronEnergyFraction();
571	<	jet.muonEnergyFraction =pat_jet.muonEnergyFraction();
572	<	jet.photonEnergyFraction =pat_jet.photonEnergyFraction();
573	<	jet.chargedMultiplicity =pat_jet.chargedMultiplicity();
574	<	jet.neutralMultiplicity =pat_jet.neutralMultiplicity();
575	<	jet.muonMultiplicity =pat_jet.muonMultiplicity();
576	<	jet.electronMultiplicity =pat_jet.electronMultiplicity();
577	<	jet.photonMultiplicity =pat_jet.photonMultiplicity();
578	<	}
579	<	jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
580	<	jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
581	<	jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
582	<	jet.btag_combinedSecondaryVertexMVA=pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
583	<	jet.btag_jetBProbability=pat_jet.bDiscriminator("jetBProbabilityBJetTags");
584	<	jet.btag_jetProbability=pat_jet.bDiscriminator("jetProbabilityBJetTags");
585	<
567	>	jet.set_neutralEmEnergyFraction (pat_jet.neutralEmEnergyFraction());
568	>	jet.set_neutralHadronEnergyFraction (pat_jet.neutralHadronEnergyFraction());
569	>	jet.set_chargedEmEnergyFraction (pat_jet.chargedEmEnergyFraction());
570	>	jet.set_chargedHadronEnergyFraction (pat_jet.chargedHadronEnergyFraction());
571	>	jet.set_muonEnergyFraction (pat_jet.muonEnergyFraction());
572	>	jet.set_photonEnergyFraction (pat_jet.photonEnergyFraction());
573	>	jet.set_chargedMultiplicity (pat_jet.chargedMultiplicity());
574	>	jet.set_neutralMultiplicity (pat_jet.neutralMultiplicity());
575	>	jet.set_muonMultiplicity (pat_jet.muonMultiplicity());
576	>	jet.set_electronMultiplicity (pat_jet.electronMultiplicity());
577	>	jet.set_photonMultiplicity (pat_jet.photonMultiplicity());
578	>	}
579	>	if(doJECUncertainty){
580	>	jecUnc->setJetEta(pat_jet.eta());
581	>	jecUnc->setJetPt(pat_jet.pt());
582	>	jet.set_JEC_uncertainty(jecUnc->getUncertainty(true));
583	>	}
584	>	jet.set_JEC_factor_raw(pat_jet.jecFactor("Uncorrected"));
585	>
586	>	jet.set_btag_simpleSecondaryVertexHighEff(pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
587	>	jet.set_btag_simpleSecondaryVertexHighPur(pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
588	>	jet.set_btag_combinedSecondaryVertex(pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags"));
589	>	jet.set_btag_combinedSecondaryVertexMVA(pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
590	>	jet.set_btag_jetBProbability(pat_jet.bDiscriminator("jetBProbabilityBJetTags"));
591	>	jet.set_btag_jetProbability(pat_jet.bDiscriminator("jetProbabilityBJetTags"));
592	>
593	>	const reco::GenJet *genj = pat_jet.genJet();
594	>	if(genj){
595	>	jet.set_genjet_pt(genj->pt());
596	>	jet.set_genjet_eta(genj->eta());
597	>	jet.set_genjet_phi(genj->phi());
598	>	jet.set_genjet_energy(genj->energy());
599	>	if(doAllGenParticles){
600	>	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
601	>	for(unsigned int l = 0; l<jetgenps.size(); ++l){
602	>	for(unsigned int k=0; k< genps.size(); ++k){
603	>	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
604	>	jet.add_genparticles_index(genps[k].index());
605	>	break;
606	>	}
607	>	}
608	>	}
609	>	if(jet.genparticles_indices().size()!= jetgenps.size())
610	>	std::cout << "WARNING: Found only " << jet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this jet"<<std::endl;
611	>	}
612	>	}
613		jets[j].push_back(jet);
614		}
615		}
#	Line 387 | Line 626 | NtupleWriter::analyze(const edm::Event&
626		iEvent.getByLabel(topjet_sources[j], pat_topjets);
627
628		for (unsigned int i = 0; i < pat_topjets->size(); i++) {
629	+
630		const pat::Jet  pat_topjet =  * dynamic_cast<pat::Jet const *>(&pat_topjets->at(i));
631		if(pat_topjet.pt() < topjet_ptmin) continue;
632		if(fabs(pat_topjet.eta()) > topjet_etamax) continue;
633
634		TopJet topjet;
635	<	topjet.charge = pat_topjet.charge();
636	<	topjet.pt = pat_topjet.pt();
637	<	topjet.eta = pat_topjet.eta();
638	<	topjet.phi = pat_topjet.phi();
639	<	topjet.energy = pat_topjet.energy();
640	<	topjet.numberOfDaughters =pat_topjet.numberOfDaughters();
635	>	topjet.set_charge(pat_topjet.charge());
636	>	topjet.set_pt(pat_topjet.pt());
637	>	topjet.set_eta(pat_topjet.eta());
638	>	topjet.set_phi(pat_topjet.phi());
639	>	topjet.set_energy(pat_topjet.energy());
640	>	topjet.set_numberOfDaughters(pat_topjet.numberOfDaughters());
641		const reco::TrackRefVector&  topjettracks = pat_topjet.associatedTracks();
642	<	topjet.nTracks = topjettracks.size();
643	<	topjet.jetArea = pat_topjet.jetArea();
644	<	topjet.pileup = pat_topjet.pileup();
645	<	//       topjet.neutralEmEnergyFraction =pat_topjet.neutralEmEnergyFraction();
646	<	//       topjet.neutralHadronEnergyFraction =pat_topjet.neutralHadronEnergyFraction();
647	<	//       topjet.chargedEmEnergyFraction =pat_topjet.chargedEmEnergyFraction();
648	<	//       topjet.chargedHadronEnergyFraction =pat_topjet.chargedHadronEnergyFraction();
649	<	//       topjet.muonEnergyFraction =pat_topjet.muonEnergyFraction();
650	<	//       topjet.photonEnergyFraction =pat_topjet.photonEnergyFraction();
651	<	//       topjet.chargedMultiplicity =pat_topjet.chargedMultiplicity();
652	<	//       topjet.neutralMultiplicity =pat_topjet.neutralMultiplicity();
653	<	//       topjet.muonMultiplicity =pat_topjet.muonMultiplicity();
654	<	//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
655	<	//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
656	<
657	<	topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
658	<	topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
659	<	topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
660	<	topjet.btag_combinedSecondaryVertexMVA=pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
661	<	topjet.btag_jetBProbability=pat_topjet.bDiscriminator("jetBProbabilityBJetTags");
662	<	topjet.btag_jetProbability=pat_topjet.bDiscriminator("jetProbabilityBJetTags");
642	>	topjet.set_nTracks( topjettracks.size());
643	>	topjet.set_jetArea( pat_topjet.jetArea());
644	>	topjet.set_pileup( pat_topjet.pileup());
645	>	//       topjet.set_neutralEmEnergyFraction(pat_topjet.neutralEmEnergyFraction());
646	>	//       topjet.set_neutralHadronEnergyFraction(pat_topjet.neutralHadronEnergyFraction());
647	>	//       topjet.set_chargedEmEnergyFraction(pat_topjet.chargedEmEnergyFraction());
648	>	//       topjet.set_chargedHadronEnergyFraction(pat_topjet.chargedHadronEnergyFraction());
649	>	//       topjet.set_muonEnergyFraction(pat_topjet.muonEnergyFraction());
650	>	//       topjet.set_photonEnergyFraction(pat_topjet.photonEnergyFraction());
651	>	//       topjet.set_chargedMultiplicity(pat_topjet.chargedMultiplicity());
652	>	//       topjet.set_neutralMultiplicity(pat_topjet.neutralMultiplicity());
653	>	//       topjet.set_muonMultiplicity(pat_topjet.muonMultiplicity());
654	>	//       topjet.set_electronMultiplicity(pat_topjet.electronMultiplicity());
655	>	//       topjet.set_photonMultiplicity(pat_topjet.photonMultiplicity());
656	>	if(doJECUncertainty){
657	>	jecUnc->setJetEta(pat_topjet.eta());
658	>	jecUnc->setJetPt(pat_topjet.pt());
659	>	topjet.set_JEC_uncertainty( jecUnc->getUncertainty(true));
660	>	}
661	>	topjet.set_JEC_factor_raw( pat_topjet.jecFactor("Uncorrected"));
662	>
663	>	topjet.set_btag_simpleSecondaryVertexHighEff(pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
664	>	topjet.set_btag_simpleSecondaryVertexHighPur(pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
665	>	topjet.set_btag_combinedSecondaryVertex(pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags"));
666	>	topjet.set_btag_combinedSecondaryVertexMVA(pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
667	>	topjet.set_btag_jetBProbability(pat_topjet.bDiscriminator("jetBProbabilityBJetTags"));
668	>	topjet.set_btag_jetProbability(pat_topjet.bDiscriminator("jetProbabilityBJetTags"));
669	>
670	>	/*
671	>	const reco::GenJet *genj = pat_topjet.genJet();
672	>	if(genj){
673	>	topjet.set_genjet_pt ( genj->pt());
674	>	topjet.set_genjet_eta ( genj->eta());
675	>	topjet.set_genjet_phi ( genj->phi());
676	>	topjet.set_genjet_energy ( genj->energy());
677	>	if(doAllGenParticles){
678	>	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
679	>	for(unsigned int l = 0; l<jetgenps.size(); ++l){
680	>	for(unsigned int k=0; k< genps.size(); ++k){
681	>	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
682	>	topjet.add_genparticles_index(genps[k].index());
683	>	break;
684	>	}
685	>	}
686	>	}
687	>	if(topjet.genparticles_indices().size()!= jetgenps.size())
688	>	std::cout << "WARNING: Found only " << topjet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this topjet"<<std::endl;
689	>	}
690	>	}
691	>	*/
692
693		for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) {
694		Particle subjet_v4;
695	<	subjet_v4.pt = pat_topjet.daughter(k)->p4().pt();
696	<	subjet_v4.eta = pat_topjet.daughter(k)->p4().eta();
697	<	subjet_v4.phi = pat_topjet.daughter(k)->p4().phi();
698	<	subjet_v4.energy = pat_topjet.daughter(k)->p4().E();
699	<	topjet.subjets.push_back(subjet_v4);
695	>	subjet_v4.set_pt(pat_topjet.daughter(k)->p4().pt());
696	>	subjet_v4.set_eta(pat_topjet.daughter(k)->p4().eta());
697	>	subjet_v4.set_phi(pat_topjet.daughter(k)->p4().phi());
698	>	subjet_v4.set_energy(pat_topjet.daughter(k)->p4().E());
699	>	topjet.add_subjet(subjet_v4);
700		}
701		topjets[j].push_back(topjet);
702		}
703		}
704		}
705
706	+
707	+	// ------------- generator top jets -------------
708	+	if(doGenTopJets){
709	+	for(size_t j=0; j< gentopjet_sources.size(); ++j){
710	+
711	+	gentopjets[j].clear();
712	+
713	+	edm::Handle<reco::BasicJetCollection> reco_gentopjets;
714	+	//edm::Handle<std::vector<reco::Jet> > reco_gentopjets;
715	+	iEvent.getByLabel(gentopjet_sources[j], reco_gentopjets);
716	+
717	+	for (unsigned int i = 0; i < reco_gentopjets->size(); i++) {
718	+
719	+	const reco::BasicJet  reco_gentopjet =  reco_gentopjets->at(i);
720	+	if(reco_gentopjet.pt() < gentopjet_ptmin) continue;
721	+	if(fabs(reco_gentopjet.eta()) > gentopjet_etamax) continue;
722	+
723	+	TopJet gentopjet;
724	+	gentopjet.set_charge(reco_gentopjet.charge());
725	+	gentopjet.set_pt(reco_gentopjet.pt());
726	+	gentopjet.set_eta(reco_gentopjet.eta());
727	+	gentopjet.set_phi(reco_gentopjet.phi());
728	+	gentopjet.set_energy(reco_gentopjet.energy());
729	+	gentopjet.set_numberOfDaughters(reco_gentopjet.numberOfDaughters());
730	+
731	+	for (unsigned int k = 0; k < reco_gentopjet.numberOfDaughters(); k++) {
732	+	Particle subjet_v4;
733	+	subjet_v4.set_pt(reco_gentopjet.daughter(k)->p4().pt());
734	+	subjet_v4.set_eta(reco_gentopjet.daughter(k)->p4().eta());
735	+	subjet_v4.set_phi(reco_gentopjet.daughter(k)->p4().phi());
736	+	subjet_v4.set_energy(reco_gentopjet.daughter(k)->p4().E());
737	+	gentopjet.add_subjet(subjet_v4);
738	+	}
739	+	gentopjets[j].push_back(gentopjet);
740	+	}
741	+	}
742	+	}
743	+
744		// ------------- photons -------------
745		if(doPhotons){
746		for(size_t j=0; j< photon_sources.size(); ++j){
#	Line 446 | Line 753 | NtupleWriter::analyze(const edm::Event&
753		for (unsigned int i = 0; i < pat_photons.size(); ++i) {
754		pat::Photon pat_photon = pat_photons[i];
755		Photon ph;
756	<	ph.charge = 0;
757	<	ph.pt =  pat_photon.pt();
758	<	ph.eta =  pat_photon.eta();
759	<	ph.phi =  pat_photon.phi();
760	<	ph.energy =  pat_photon.energy();
761	<	ph.vertex_x = pat_photon.vertex().x();
762	<	ph.vertex_y = pat_photon.vertex().y();
763	<	ph.vertex_z = pat_photon.vertex().z();
764	<	ph.supercluster_eta = pat_photon.superCluster()->eta();
765	<	ph.supercluster_phi = pat_photon.superCluster()->phi();
766	<	//       ph.neutralHadronIso = pat_photon.neutralHadronIso();
767	<	//       ph.chargedHadronIso = pat_photon.chargedHadronIso();
768	<	ph.trackIso = pat_photon.trackIso();
756	>	ph.set_charge(0);
757	>	ph.set_pt( pat_photon.pt());
758	>	ph.set_eta( pat_photon.eta());
759	>	ph.set_phi( pat_photon.phi());
760	>	ph.set_energy( pat_photon.energy());
761	>	ph.set_vertex_x(pat_photon.vertex().x());
762	>	ph.set_vertex_y(pat_photon.vertex().y());
763	>	ph.set_vertex_z(pat_photon.vertex().z());
764	>	ph.set_supercluster_eta(pat_photon.superCluster()->eta());
765	>	ph.set_supercluster_phi(pat_photon.superCluster()->phi());
766	>	//       ph.set_neutralHadronIso(pat_photon.neutralHadronIso());
767	>	//       ph.set_chargedHadronIso(pat_photon.chargedHadronIso());
768	>	ph.set_trackIso(pat_photon.trackIso());
769		phs[j].push_back(ph);
770		}
771		}
#	Line 478 | Line 785 | NtupleWriter::analyze(const edm::Event&
785		else{
786		pat::MET pat_met = pat_mets[0];
787
788	<	met[j].pt=pat_met.pt();
789	<	met[j].phi=pat_met.phi();
790	<	met[j].mEtSig= pat_met.mEtSig();
788	>	met[j].set_pt(pat_met.pt());
789	>	met[j].set_phi(pat_met.phi());
790	>	met[j].set_mEtSig(pat_met.mEtSig());
791		}
792
793		}
794		}
795
796		// ------------- trigger -------------
797	<
798	<	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
799	<	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
800	<	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
494	<
495	<	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
496	<	std::string nameProcess = meta->processName();
497	<	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
498	<	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
499	<
500	<	edm::Handle<edm::TriggerResults> trigger;
501	<	iEvent.getByLabel(triggerResultTag, trigger);
502	<	const edm::TriggerResults& trig = *(trigger.product());
503	<
504	<	triggerResults.clear();
505	<	triggerNames.clear();
506	<	L1_prescale.clear();
507	<	HLT_prescale.clear();
508	<
509	<	edm::Service<edm::service::TriggerNamesService> tns;
510	<	std::vector<std::string> triggerNames_all;
511	<	tns->getTrigPaths(trig,triggerNames_all);
512	<
513	<	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
514	<	for(unsigned int i=0; i<trig.size(); ++i){
515	<	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
516	<	for(; it!=trigger_prefixes.end(); ++it){
517	<	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
518	<	}
519	<	if(it==trigger_prefixes.end()) continue;
520	<
521	<	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
522	<	triggerResults.push_back(trig.accept(i));
523	<	if(newrun) triggerNames.push_back(triggerNames_all[i]);
524	<	if(isRealData){
525	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
526	<	L1_prescale.push_back(pre.first);
527	<	HLT_prescale.push_back(pre.second);
528	<	}
529	<	}
530	<	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
531	<	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
532	<	//    }
533	<	newrun=false;
534	<
535	<	// ------------- generator info -------------
536	<
537	<	if(doGenInfo){
538	<	genInfo.weights.clear();
539	<	genInfo.binningValues.clear();
540	<	genps.clear();
541	<
542	<	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
543	<	iEvent.getByLabel("generator", genEventInfoProduct);
544	<	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
545	<
546	<	genInfo.binningValues = genEventInfo.binningValues();
547	<	genInfo.weights = genEventInfo.weights();
548	<	genInfo.alphaQCD = genEventInfo.alphaQCD();
549	<	genInfo.alphaQED = genEventInfo.alphaQED();
550	<	genInfo.qScale = genEventInfo.qScale();
797	>	if(doTrigger){
798	>	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
799	>	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
800	>	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
801
802	<	const gen::PdfInfo* pdf = genEventInfo.pdf();
803	<	if(pdf){
804	<	genInfo.pdf_id1=pdf->id.first;
805	<	genInfo.pdf_id2=pdf->id.second;
806	<	genInfo.pdf_x1=pdf->x.first;
807	<	genInfo.pdf_x2=pdf->x.second;
808	<	genInfo.pdf_scalePDF=pdf->scalePDF;
809	<	genInfo.pdf_xPDF1=pdf->xPDF.first;
810	<	genInfo.pdf_xPDF2=pdf->xPDF.second;
811	<	}
812	<	else{
813	<	genInfo.pdf_id1=-999;
814	<	genInfo.pdf_id2=-999;
815	<	genInfo.pdf_x1=-999;
816	<	genInfo.pdf_x2=-999;
817	<	genInfo.pdf_scalePDF=-999;
818	<	genInfo.pdf_xPDF1=-999;
819	<	genInfo.pdf_xPDF2=-999;
820	<	}
821	<
822	<	edm::Handle<std::vector<PileupSummaryInfo> > pus;
823	<	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
824	<	genInfo.pileup_NumInteractions_intime=0;
825	<	genInfo.pileup_NumInteractions_ootbefore=0;
826	<	genInfo.pileup_NumInteractions_ootafter=0;
827	<	if(pus.isValid()){
828	<	genInfo.pileup_TrueNumInteractions = (float) pus->at(0).getTrueNumInteractions();
829	<	for(size_t i=0; i<pus->size(); ++i){
830	<	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
831	<	genInfo.pileup_NumInteractions_intime += pus->at(i).getPU_NumInteractions();
832	<	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
833	<	genInfo.pileup_NumInteractions_ootbefore += pus->at(i).getPU_NumInteractions();
834	<	}
835	<	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
836	<	genInfo.pileup_NumInteractions_ootafter += pus->at(i).getPU_NumInteractions();
837	<	}
838	<	}
839	<	}
840	<
841	<	edm::Handle<reco::GenParticleCollection> genPartColl;
592	<	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
593	<	int index=-1;
594	<	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
595	<	index++;
596	<
597	<	//write out only top quarks and status 3 particles (works fine only for MadGraph)
598	<	if(abs(iter->pdgId())==6 || iter->status()==3){
599	<	GenParticle genp;
600	<	genp.charge = iter->charge();;
601	<	genp.pt = iter->p4().pt();
602	<	genp.eta = iter->p4().eta();
603	<	genp.phi = iter->p4().phi();
604	<	genp.energy = iter->p4().E();
605	<	genp.index =index;
606	<	genp.status = iter->status();
607	<	genp.pdgId = iter->pdgId();
608	<
609	<	genp.mother1=-1;
610	<	genp.mother2=-1;
611	<	genp.daughter1=-1;
612	<	genp.daughter2=-1;
613	<
614	<	int nm=iter->numberOfMothers();
615	<	int nd=iter->numberOfDaughters();
616	<
617	<	if (nm>0) genp.mother1 = iter->motherRef(0).key();
618	<	if (nm>1) genp.mother2 = iter->motherRef(nm-1).key();
619	<	if (nd>0) genp.daughter1 = iter->daughterRef(0).key();
620	<	if (nd>1) genp.daughter2 = iter->daughterRef(nd-1).key();
621	<
622	<	genps.push_back(genp);
623	<	}
624	<	}
625	<
802	>	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
803	>	std::string nameProcess = meta->processName();
804	>	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
805	>	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
806	>
807	>	edm::Handle<edm::TriggerResults> trigger;
808	>	iEvent.getByLabel(triggerResultTag, trigger);
809	>	const edm::TriggerResults& trig = *(trigger.product());
810	>
811	>	triggerResults.clear();
812	>	triggerNames.clear();
813	>	//      L1_prescale.clear();
814	>	//      HLT_prescale.clear();
815	>
816	>	edm::Service<edm::service::TriggerNamesService> tns;
817	>	std::vector<std::string> triggerNames_all;
818	>	tns->getTrigPaths(trig,triggerNames_all);
819	>
820	>	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
821	>	for(unsigned int i=0; i<trig.size(); ++i){
822	>	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
823	>	for(; it!=trigger_prefixes.end(); ++it){
824	>	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
825	>	}
826	>	if(it==trigger_prefixes.end()) continue;
827	>
828	>	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
829	>	triggerResults.push_back(trig.accept(i));
830	>	if(newrun) triggerNames.push_back(triggerNames_all[i]);
831	>	//        if(isRealData){
832	>	//       std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
833	>	//       L1_prescale.push_back(pre.first);
834	>	//       HLT_prescale.push_back(pre.second);
835	>	//       //std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
836	>	//        }
837	>	}
838	>	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
839	>	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
840	>	//    }
841	>	newrun=false;
842		}
843
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();
844
845		tr->Fill();
846	<
846	>	if(doLumiInfo)
847	>	previouslumiblockwasfilled=true;
848		}
849
850
#	Line 669 | Line 852 | NtupleWriter::analyze(const edm::Event&
852		void
853		NtupleWriter::beginJob()
854		{
855	+	if(doLumiInfo){
856	+	totalRecLumi=0;
857	+	totalDelLumi=0;
858	+	previouslumiblockwasfilled=false;
859	+	}
860		}
861
862		// ------------ method called once each job just after ending the event loop  ------------
#	Line 684 | Line 872 | NtupleWriter::endJob()
872		void
873		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
874		{
875	<	bool setup_changed = false;
876	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
877	<	newrun=true;
875	>	if(doTrigger){
876	>	//bool setup_changed = false;
877	>	//hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
878	>	newrun=true;
879	>	}
880	>
881	>	if(doJets || doTopJets){
882	>	if(doJECUncertainty){
883	>	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
884	>	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
885	>	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
886	>	jecUnc = new JetCorrectionUncertainty(JetCorPar);
887	>	}
888	>	}
889		}
890
891		// ------------ method called when ending the processing of a run  ------------
892		void
893		NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&)
894		{
895	+	if(doLumiInfo)
896	+	std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl;
897		}
898
899		// ------------ method called when starting to processes a luminosity block  ------------
900		void
901	<	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
901	>	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&)
902		{
903	+	if(doLumiInfo){
904	+	edm::Handle<LumiSummary> l;
905	+	lumi.getByLabel("lumiProducer", l);
906	+
907	+	//add lumi of lumi blocks without any event to next lumiblock
908	+	if(previouslumiblockwasfilled){
909	+	intgRecLumi=0;
910	+	intgDelLumi=0;
911	+	}
912	+	previouslumiblockwasfilled=false;
913	+
914	+	if (l.isValid()){;
915	+	intgRecLumi+=l->intgRecLumi()*6.37;
916	+	intgDelLumi+=l->intgDelLumi()*6.37;
917	+	totalRecLumi+=l->intgRecLumi()*6.37;
918	+	totalDelLumi+=l->intgDelLumi()*6.37;
919	+	}
920	+	//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<"   " << l->intgDelLumi()*6.37<<std::endl;
921	+	//std::cout << "summed:  "<< intgRecLumi << "   " << intgDelLumi << std::endl;
922	+	}
923		}
924
925		// ------------ method called when ending the processing of a luminosity block  ------------

Diff Legend

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