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.5 by peiffer, Thu Apr 5 09:48:20 2012 UTC vs.
Revision 1.23 by eusai, Fri Apr 5 13:23:16 2013 UTC

#	Line 17 | Line 17
17		//
18		//
19
20	<	#include "UHHAnalysis//NtupleWriter/interface/NtupleWriter.h"
21	<
22	<
20	>	#include "UHHAnalysis/NtupleWriter/interface/NtupleWriter.h"
21	>	#include "RecoBTau/JetTagComputer/interface/GenericMVAJetTagComputer.h"
22	>	#include "RecoBTau/JetTagComputer/interface/GenericMVAJetTagComputerWrapper.h"
23	>	#include "RecoBTau/JetTagComputer/interface/JetTagComputer.h"
24	>	#include "RecoBTau/JetTagComputer/interface/JetTagComputerRecord.h"
25	>	#include "RecoBTag/SecondaryVertex/interface/CombinedSVComputer.h"
26
27		//
28		// constants, enums and typedefs
#	Line 50 | Line 53 | NtupleWriter::NtupleWriter(const edm::Pa
53		doMuons = iConfig.getParameter<bool>("doMuons");
54		doTaus = iConfig.getParameter<bool>("doTaus");
55		doJets = iConfig.getParameter<bool>("doJets");
56	+	doJECUncertainty = iConfig.getParameter<bool>("doJECUncertainty");
57	+	doGenTopJets = iConfig.getParameter<bool>("doGenTopJets");
58		doPhotons = iConfig.getParameter<bool>("doPhotons");
59		doMET = iConfig.getParameter<bool>("doMET");
60		doGenInfo = iConfig.getParameter<bool>("doGenInfo");
61	+	doAllGenParticles = iConfig.getParameter<bool>("doAllGenParticles");
62	+	doLumiInfo = iConfig.getParameter<bool>("doLumiInfo");
63		doPV = iConfig.getParameter<bool>("doPV");
64		doTopJets = iConfig.getParameter<bool>("doTopJets");
65	<
65	>	doTrigger = iConfig.getParameter<bool>("doTrigger");
66	>	SVComputer_  = iConfig.getUntrackedParameter<edm::InputTag>("svComputer",edm::InputTag("combinedSecondaryVertex"));
67	>	doTagInfos = iConfig.getUntrackedParameter<bool>("doTagInfos",false);
68		// initialization of tree variables
69
70		tr->Branch("run",&run);
71		tr->Branch("event",&event);
72		tr->Branch("luminosityBlock",&luminosityBlock);
73		tr->Branch("isRealData",&isRealData);
74	<	tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
75	<	tr->Branch("beamspot_x0",&beamspot_x0);
67	<	tr->Branch("beamspot_y0",&beamspot_y0);
68	<	tr->Branch("beamspot_z0",&beamspot_z0);
74	>	tr->Branch("rho",&rho);
75	>	rho_source = iConfig.getParameter<edm::InputTag>("rho_source");
76
77	+	//tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
78	+	if(doLumiInfo){
79	+	tr->Branch("intgRecLumi",&intgRecLumi);
80	+	tr->Branch("intgDelLumi",&intgDelLumi);
81	+	}
82	+	if(doPV){
83	+	tr->Branch("beamspot_x0",&beamspot_x0);
84	+	tr->Branch("beamspot_y0",&beamspot_y0);
85	+	tr->Branch("beamspot_z0",&beamspot_z0);
86	+	}
87		if(doElectrons){
88		electron_sources = iConfig.getParameter<std::vector<std::string> >("electron_sources");
89		for(size_t j=0; j< electron_sources.size(); ++j){
#	Line 103 | Line 120 | NtupleWriter::NtupleWriter(const edm::Pa
120		tr->Branch( topjet_sources[j].c_str(), "std::vector<TopJet>", &topjets[j]);
121		}
122		}
123	+	if(doGenTopJets){
124	+	gentopjet_sources = iConfig.getParameter<std::vector<std::string> >("gentopjet_sources");
125	+	gentopjet_ptmin = iConfig.getParameter<double> ("gentopjet_ptmin");
126	+	gentopjet_etamax = iConfig.getParameter<double> ("gentopjet_etamax");
127	+	for(size_t j=0; j< gentopjet_sources.size(); ++j){
128	+	tr->Branch( gentopjet_sources[j].c_str(), "std::vector<TopJet>", &gentopjets[j]);
129	+	}
130	+	}
131		if(doPhotons){
132		photon_sources = iConfig.getParameter<std::vector<std::string> >("photon_sources");
133		for(size_t j=0; j< photon_sources.size(); ++j){
#	Line 122 | Line 147 | NtupleWriter::NtupleWriter(const edm::Pa
147		}
148		}
149		if(doGenInfo){
150	+	genparticle_source= iConfig.getParameter<edm::InputTag>("genparticle_source");
151		tr->Branch("genInfo","GenInfo",&genInfo);
152		tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
153		}
154	<
155	<	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
156	<	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
157	<	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
158	<	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
159	<	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
160	<	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
161	<
154	>	if(doTrigger){
155	>	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
156	>	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
157	>	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
158	>	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
159	>	//tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
160	>	//tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
161	>	}
162		newrun = true;
163		}
164
#	Line 164 | Line 190 | NtupleWriter::analyze(const edm::Event&
190		luminosityBlock = iEvent.luminosityBlock();
191		isRealData      = iEvent.isRealData();
192
193	<	if(isRealData){
194	<	edm::Handle<bool> bool_handle;
195	<	iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
196	<	HBHENoiseFilterResult = *(bool_handle.product());
197	<	}
198	<	else HBHENoiseFilterResult = false;
193	>	edm::Handle<double> m_rho;
194	>	iEvent.getByLabel(rho_source,m_rho);
195	>	rho=*m_rho;
196	>
197	>	//    if(isRealData){
198	>	//      edm::Handle<bool> bool_handle;
199	>	//      iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
200	>	//      HBHENoiseFilterResult = *(bool_handle.product());
201	>	//    }
202	>	//    else HBHENoiseFilterResult = false;
203
204		// ------------- primary vertices and beamspot  -------------
205
#	Line 185 | Line 215 | NtupleWriter::analyze(const edm::Event&
215		reco::Vertex reco_pv = reco_pvs[i];
216
217		PrimaryVertex pv;
218	<	pv.x =  reco_pv.x();
219	<	pv.y =  reco_pv.y();
220	<	pv.z =  reco_pv.z();
221	<	pv.nTracks =  reco_pv.nTracks();
222	<	//pv.isValid =  reco_pv.isValid();
223	<	pv.chi2 =  reco_pv.chi2();
224	<	pv.ndof =  reco_pv.ndof();
218	>	pv.set_x( reco_pv.x());
219	>	pv.set_y( reco_pv.y());
220	>	pv.set_z( reco_pv.z());
221	>	pv.set_nTracks( reco_pv.nTracks());
222	>	//pv.set_isValid( reco_pv.isValid());
223	>	pv.set_chi2( reco_pv.chi2());
224	>	pv.set_ndof( reco_pv.ndof());
225
226		pvs[j].push_back(pv);
227		}
228		}
229	+
230	+	edm::Handle<reco::BeamSpot> beamSpot;
231	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
232	+	const reco::BeamSpot & bsp = *beamSpot;
233	+
234	+	beamspot_x0 = bsp.x0();
235	+	beamspot_y0 = bsp.y0();
236	+	beamspot_z0 = bsp.z0();
237		}
238	+
239	+	// ------------- generator info -------------
240
241	<	edm::Handle<reco::BeamSpot> beamSpot;
242	<	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
243	<	const reco::BeamSpot & bsp = *beamSpot;
244	<
245	<	beamspot_x0 = bsp.x0();
246	<	beamspot_y0 = bsp.y0();
247	<	beamspot_z0 = bsp.z0();
241	>	if(doGenInfo){
242	>	genInfo.clear_weights();
243	>	genInfo.clear_binningValues();
244	>	genps.clear();
245	>
246	>	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
247	>	iEvent.getByLabel("generator", genEventInfoProduct);
248	>	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
249	>
250	>	for(unsigned int k=0; k<genEventInfo.binningValues().size();++k){
251	>	genInfo.add_binningValue(genEventInfo.binningValues().at(k));
252	>	}
253	>	for(unsigned int k=0; k<genEventInfo.weights().size();++k){
254	>	genInfo.add_weight(genEventInfo.weights().at(k));
255	>	}
256	>	genInfo.set_alphaQCD(genEventInfo.alphaQCD());
257	>	genInfo.set_alphaQED(genEventInfo.alphaQED());
258	>	genInfo.set_qScale(genEventInfo.qScale());
259	>
260	>	const gen::PdfInfo* pdf = genEventInfo.pdf();
261	>	if(pdf){
262	>	genInfo.set_pdf_id1(pdf->id.first);
263	>	genInfo.set_pdf_id2(pdf->id.second);
264	>	genInfo.set_pdf_x1(pdf->x.first);
265	>	genInfo.set_pdf_x2(pdf->x.second);
266	>	genInfo.set_pdf_scalePDF(pdf->scalePDF);
267	>	genInfo.set_pdf_xPDF1(pdf->xPDF.first);
268	>	genInfo.set_pdf_xPDF2(pdf->xPDF.second);
269	>	}
270	>	else{
271	>	genInfo.set_pdf_id1(-999);
272	>	genInfo.set_pdf_id2(-999);
273	>	genInfo.set_pdf_x1(-999);
274	>	genInfo.set_pdf_x2(-999);
275	>	genInfo.set_pdf_scalePDF(-999);
276	>	genInfo.set_pdf_xPDF1(-999);
277	>	genInfo.set_pdf_xPDF2(-999);
278	>	}
279	>
280	>	edm::Handle<std::vector<PileupSummaryInfo> > pus;
281	>	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
282	>	genInfo.set_pileup_NumInteractions_intime(0);
283	>	genInfo.set_pileup_NumInteractions_ootbefore(0);
284	>	genInfo.set_pileup_NumInteractions_ootafter(0);
285	>	if(pus.isValid()){
286	>	genInfo.set_pileup_TrueNumInteractions ( (float) pus->at(0).getTrueNumInteractions());
287	>	for(size_t i=0; i<pus->size(); ++i){
288	>	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
289	>	genInfo.set_pileup_NumInteractions_intime( genInfo.pileup_NumInteractions_intime() + pus->at(i).getPU_NumInteractions());
290	>	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
291	>	genInfo.set_pileup_NumInteractions_ootbefore( genInfo.pileup_NumInteractions_ootbefore() + pus->at(i).getPU_NumInteractions());
292	>	}
293	>	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
294	>	genInfo.set_pileup_NumInteractions_ootafter( genInfo.pileup_NumInteractions_ootafter() + pus->at(i).getPU_NumInteractions());
295	>	}
296	>	}
297	>	}
298	>
299	>	edm::Handle<reco::GenParticleCollection> genPartColl;
300	>	iEvent.getByLabel(genparticle_source, genPartColl);
301	>	int index=-1;
302	>	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
303	>	index++;
304	>
305	>	//write out only top quarks and status 3 particles (works fine only for MadGraph)
306	>	if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){
307	>	GenParticle genp;
308	>	genp.set_charge(iter->charge());
309	>	genp.set_pt(iter->p4().pt());
310	>	genp.set_eta(iter->p4().eta());
311	>	genp.set_phi(iter->p4().phi());
312	>	genp.set_energy(iter->p4().E());
313	>	genp.set_index(index);
314	>	genp.set_status( iter->status());
315	>	genp.set_pdgId( iter->pdgId());
316	>
317	>	genp.set_mother1(-1);
318	>	genp.set_mother2(-1);
319	>	genp.set_daughter1(-1);
320	>	genp.set_daughter2(-1);
321	>
322	>	int nm=iter->numberOfMothers();
323	>	int nd=iter->numberOfDaughters();
324	>
325	>
326	>	if (nm>0) genp.set_mother1( iter->motherRef(0).key());
327	>	if (nm>1) genp.set_mother2( iter->motherRef(1).key());
328	>	if (nd>0) genp.set_daughter1( iter->daughterRef(0).key());
329	>	if (nd>1) genp.set_daughter2( iter->daughterRef(1).key());
330	>
331	>	genps.push_back(genp);
332	>	}
333	>	}
334	>	}
335
336		// ------------- electrons -------------
337		if(doElectrons){
338	+
339	+	//      edm::Handle<reco::ConversionCollection> hConversions;
340	+	//      iEvent.getByLabel("allConversions", hConversions);
341	+
342	+	//      edm::Handle<reco::BeamSpot> beamSpot;
343	+	//      iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
344	+	//      const reco::BeamSpot & bsp = *beamSpot;
345	+
346		for(size_t j=0; j< electron_sources.size(); ++j){
347		eles[j].clear();
348		edm::Handle< std::vector<pat::Electron> > ele_handle;
#	Line 218 | Line 353 | NtupleWriter::analyze(const edm::Event&
353		pat::Electron pat_ele = pat_electrons[i];
354		Electron ele;
355
356	<	ele.charge =  pat_ele.charge();
357	<	ele.pt =  pat_ele.pt();
358	<	ele.eta =  pat_ele.eta();
359	<	ele.phi =  pat_ele.phi();
360	<	ele.energy =  pat_ele.energy();
361	<	ele.vertex_x = pat_ele.vertex().x();
362	<	ele.vertex_y = pat_ele.vertex().y();
363	<	ele.vertex_z = pat_ele.vertex().z();
364	<	ele.supercluster_eta = pat_ele.superCluster()->eta();
365	<	ele.supercluster_phi = pat_ele.superCluster()->phi();
366	<	ele.dB = pat_ele.dB();
367	<	//ele.particleIso = pat_ele.particleIso();
368	<	ele.neutralHadronIso = pat_ele.neutralHadronIso();
369	<	ele.chargedHadronIso = pat_ele.chargedHadronIso();
370	<	ele.trackIso = pat_ele.trackIso();
371	<	ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
372	<	ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
373	<	ele.gsfTrack_px= pat_ele.gsfTrack()->px();
374	<	ele.gsfTrack_py= pat_ele.gsfTrack()->py();
375	<	ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
376	<	ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
377	<	ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
378	<	ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
356	>	ele.set_charge( pat_ele.charge());
357	>	ele.set_pt( pat_ele.pt());
358	>	ele.set_eta( pat_ele.eta());
359	>	ele.set_phi( pat_ele.phi());
360	>	ele.set_energy( pat_ele.energy());
361	>	ele.set_vertex_x(pat_ele.vertex().x());
362	>	ele.set_vertex_y(pat_ele.vertex().y());
363	>	ele.set_vertex_z(pat_ele.vertex().z());
364	>	ele.set_supercluster_eta(pat_ele.superCluster()->eta());
365	>	ele.set_supercluster_phi(pat_ele.superCluster()->phi());
366	>	ele.set_dB(pat_ele.dB());
367	>	//ele.set_particleIso(pat_ele.particleIso());
368	>	ele.set_neutralHadronIso(pat_ele.neutralHadronIso());
369	>	ele.set_chargedHadronIso(pat_ele.chargedHadronIso());
370	>	ele.set_trackIso(pat_ele.trackIso());
371	>	ele.set_photonIso(pat_ele.photonIso());
372	>	ele.set_puChargedHadronIso(pat_ele.puChargedHadronIso());
373	>	ele.set_gsfTrack_trackerExpectedHitsInner_numberOfLostHits(pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits());
374	>	ele.set_gsfTrack_px( pat_ele.gsfTrack()->px());
375	>	ele.set_gsfTrack_py( pat_ele.gsfTrack()->py());
376	>	ele.set_gsfTrack_pz( pat_ele.gsfTrack()->pz());
377	>	ele.set_gsfTrack_vx( pat_ele.gsfTrack()->vx());
378	>	ele.set_gsfTrack_vy( pat_ele.gsfTrack()->vy());
379	>	ele.set_gsfTrack_vz( pat_ele.gsfTrack()->vz());
380	>	//ele.set_passconversionveto(!ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()));
381	>	ele.set_passconversionveto(pat_ele.passConversionVeto());
382	>	ele.set_dEtaIn(pat_ele.deltaEtaSuperClusterTrackAtVtx());
383	>	ele.set_dPhiIn(pat_ele.deltaPhiSuperClusterTrackAtVtx());
384	>	ele.set_sigmaIEtaIEta(pat_ele.sigmaIetaIeta());
385	>	ele.set_HoverE(pat_ele.hadronicOverEm());
386	>	ele.set_fbrem(pat_ele.fbrem());
387	>	ele.set_EoverPIn(pat_ele.eSuperClusterOverP());
388	>	ele.set_EcalEnergy(pat_ele.ecalEnergy());
389	>	ele.set_mvaTrigV0(pat_ele.electronID("mvaTrigV0"));
390	>	ele.set_mvaNonTrigV0(pat_ele.electronID("mvaNonTrigV0"));
391	>	float AEff03 = 0.00;
392	>	if(isRealData){
393	>	AEff03 = ElectronEffectiveArea::GetElectronEffectiveArea(ElectronEffectiveArea::kEleGammaAndNeutralHadronIso03, pat_ele.superCluster()->eta(), ElectronEffectiveArea::kEleEAData2011);
394	>	}else{
395	>	AEff03 = ElectronEffectiveArea::GetElectronEffectiveArea(ElectronEffectiveArea::kEleGammaAndNeutralHadronIso03, pat_ele.superCluster()->eta(), ElectronEffectiveArea::kEleEAFall11MC);
396	>	}
397	>	ele.set_AEff(AEff03);
398	>
399		eles[j].push_back(ele);
400		}
401		}
#	Line 259 | Line 414 | NtupleWriter::analyze(const edm::Event&
414		pat::Muon pat_mu = pat_muons[i];
415
416		Muon mu;
417	<	mu.charge =  pat_mu.charge();
418	<	mu.pt =  pat_mu.pt();
419	<	mu.eta =  pat_mu.eta();
420	<	mu.phi =  pat_mu.phi();
421	<	mu.energy =  pat_mu.energy();
422	<	mu.vertex_x = pat_mu.vertex().x();
423	<	mu.vertex_y = pat_mu.vertex().y();
424	<	mu.vertex_z = pat_mu.vertex().z();
425	<	mu.dB = pat_mu.dB();
426	<	//mu.particleIso = pat_mu.particleIso();
427	<	mu.neutralHadronIso = pat_mu.neutralHadronIso();
428	<	mu.chargedHadronIso = pat_mu.chargedHadronIso();
429	<	mu.trackIso = pat_mu.trackIso();
430	<	mu.puChargedHadronIso = pat_mu.puChargedHadronIso();
431	<	mu.isGlobalMuon = pat_mu.isGlobalMuon();
432	<	mu.isStandAloneMuon = pat_mu.isStandAloneMuon();
433	<	mu.isTrackerMuon = pat_mu.isTrackerMuon();
434	<	mu.numberOfMatchedStations = pat_mu.numberOfMatchedStations();
417	>	mu.set_charge( pat_mu.charge());
418	>	mu.set_pt( pat_mu.pt());
419	>	mu.set_eta( pat_mu.eta());
420	>	mu.set_phi( pat_mu.phi());
421	>	mu.set_energy( pat_mu.energy());
422	>	mu.set_vertex_x ( pat_mu.vertex().x());
423	>	mu.set_vertex_y ( pat_mu.vertex().y());
424	>	mu.set_vertex_z ( pat_mu.vertex().z());
425	>	mu.set_dB ( pat_mu.dB());
426	>	//mu.particleIso ( pat_mu.particleIso());
427	>	mu.set_neutralHadronIso ( pat_mu.neutralHadronIso());
428	>	mu.set_chargedHadronIso ( pat_mu.chargedHadronIso());
429	>	mu.set_trackIso ( pat_mu.trackIso());
430	>	mu.set_photonIso ( pat_mu.photonIso());
431	>	mu.set_puChargedHadronIso ( pat_mu.puChargedHadronIso());
432	>	mu.set_isGlobalMuon ( pat_mu.isGlobalMuon());
433	>	mu.set_isPFMuon ( pat_mu.isPFMuon());
434	>	mu.set_isStandAloneMuon ( pat_mu.isStandAloneMuon());
435	>	mu.set_isTrackerMuon ( pat_mu.isTrackerMuon());
436	>	mu.set_numberOfMatchedStations ( pat_mu.numberOfMatchedStations());
437		reco::TrackRef globalTrack = pat_mu.globalTrack();
438		if(!globalTrack.isNull()){
439	<	mu.globalTrack_chi2 = globalTrack->chi2();
440	<	mu.globalTrack_ndof = globalTrack->ndof();
441	<	mu.globalTrack_d0 = globalTrack->d0();
442	<	mu.globalTrack_d0Error = globalTrack->d0Error();
443	<	mu.globalTrack_numberOfValidHits = globalTrack->numberOfValidHits();
444	<	mu.globalTrack_numberOfLostHits = globalTrack->numberOfLostHits();
439	>	mu.set_globalTrack_chi2 ( globalTrack->chi2());
440	>	mu.set_globalTrack_ndof ( globalTrack->ndof());
441	>	mu.set_globalTrack_d0 ( globalTrack->d0());
442	>	mu.set_globalTrack_d0Error ( globalTrack->d0Error());
443	>	mu.set_globalTrack_numberOfValidHits ( globalTrack->numberOfValidHits());
444	>	mu.set_globalTrack_numberOfLostHits ( globalTrack->numberOfLostHits());
445	>	mu.set_globalTrack_numberOfValidMuonHits(globalTrack->hitPattern().numberOfValidMuonHits() );
446		}
447		else{
448	<	mu.globalTrack_chi2 = 0;
449	<	mu.globalTrack_ndof = 0;
450	<	mu.globalTrack_d0 = 0;
451	<	mu.globalTrack_d0Error = 0;
452	<	mu.globalTrack_numberOfValidHits = 0;
453	<	mu.globalTrack_numberOfLostHits = 0;
448	>	mu.set_globalTrack_chi2 ( 0);
449	>	mu.set_globalTrack_ndof ( 0);
450	>	mu.set_globalTrack_d0 ( 0);
451	>	mu.set_globalTrack_d0Error ( 0);
452	>	mu.set_globalTrack_numberOfValidHits ( 0);
453	>	mu.set_globalTrack_numberOfLostHits ( 0);
454		}
455		reco::TrackRef innerTrack = pat_mu.innerTrack();
456		if(!innerTrack.isNull()){
457	<	mu.innerTrack_chi2 = innerTrack->chi2();
458	<	mu.innerTrack_ndof = innerTrack->ndof();
459	<	mu.innerTrack_d0 = innerTrack->d0();
460	<	mu.innerTrack_d0Error = innerTrack->d0Error();
461	<	mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits();
462	<	mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits();
457	>	mu.set_innerTrack_chi2 ( innerTrack->chi2());
458	>	mu.set_innerTrack_ndof ( innerTrack->ndof());
459	>	mu.set_innerTrack_d0 ( innerTrack->d0());
460	>	mu.set_innerTrack_d0Error ( innerTrack->d0Error());
461	>	mu.set_innerTrack_numberOfValidHits ( innerTrack->numberOfValidHits());
462	>	mu.set_innerTrack_numberOfLostHits ( innerTrack->numberOfLostHits());
463	>	mu.set_innerTrack_trackerLayersWithMeasurement ( innerTrack->hitPattern().trackerLayersWithMeasurement());
464	>	mu.set_innerTrack_numberOfValidPixelHits ( innerTrack->hitPattern().numberOfValidPixelHits());
465		}
466		else{
467	<	mu.innerTrack_chi2 = 0;
468	<	mu.innerTrack_ndof = 0;
469	<	mu.innerTrack_d0 = 0;
470	<	mu.innerTrack_d0Error = 0;
471	<	mu.innerTrack_numberOfValidHits = 0;
472	<	mu.innerTrack_numberOfLostHits = 0;
467	>	mu.set_innerTrack_chi2 ( 0);
468	>	mu.set_innerTrack_ndof ( 0);
469	>	mu.set_innerTrack_d0 ( 0);
470	>	mu.set_innerTrack_d0Error ( 0);
471	>	mu.set_innerTrack_numberOfValidHits ( 0);
472	>	mu.set_innerTrack_numberOfLostHits ( 0);
473	>	mu.set_innerTrack_trackerLayersWithMeasurement ( 0);
474	>	mu.set_innerTrack_numberOfValidPixelHits ( 0);
475		}
476		reco::TrackRef outerTrack = pat_mu.outerTrack();
477		if(!outerTrack.isNull()){
478	<	mu.outerTrack_chi2 = outerTrack->chi2();
479	<	mu.outerTrack_ndof = outerTrack->ndof();
480	<	mu.outerTrack_d0 = outerTrack->d0();
481	<	mu.outerTrack_d0Error = outerTrack->d0Error();
482	<	mu.outerTrack_numberOfValidHits = outerTrack->numberOfValidHits();
483	<	mu.outerTrack_numberOfLostHits = outerTrack->numberOfLostHits();
478	>	mu.set_outerTrack_chi2 ( outerTrack->chi2());
479	>	mu.set_outerTrack_ndof ( outerTrack->ndof());
480	>	mu.set_outerTrack_d0 ( outerTrack->d0());
481	>	mu.set_outerTrack_d0Error ( outerTrack->d0Error());
482	>	mu.set_outerTrack_numberOfValidHits ( outerTrack->numberOfValidHits());
483	>	mu.set_outerTrack_numberOfLostHits ( outerTrack->numberOfLostHits());
484		}
485		else{
486	<	mu.outerTrack_chi2 = 0;
487	<	mu.outerTrack_ndof = 0;
488	<	mu.outerTrack_d0 = 0;
489	<	mu.outerTrack_d0Error = 0;
490	<	mu.outerTrack_numberOfValidHits = 0;
491	<	mu.outerTrack_numberOfLostHits = 0;
486	>	mu.set_outerTrack_chi2 ( 0);
487	>	mu.set_outerTrack_ndof ( 0);
488	>	mu.set_outerTrack_d0 ( 0);
489	>	mu.set_outerTrack_d0Error ( 0);
490	>	mu.set_outerTrack_numberOfValidHits ( 0);
491	>	mu.set_outerTrack_numberOfLostHits ( 0);
492		}
493
494		mus[j].push_back(mu);
#	Line 350 | Line 512 | NtupleWriter::analyze(const edm::Event&
512		if(fabs(pat_tau.eta()) > tau_etamax) continue;
513
514		Tau tau;
515	<	tau.charge =  pat_tau.charge();
516	<	tau.pt =  pat_tau.pt();
517	<	tau.eta =  pat_tau.eta();
518	<	tau.phi =  pat_tau.phi();
519	<	tau.energy =  pat_tau.energy();
520	<
515	>	tau.set_charge( pat_tau.charge());
516	>	tau.set_pt( pat_tau.pt());
517	>	tau.set_eta( pat_tau.eta());
518	>	tau.set_phi( pat_tau.phi());
519	>	tau.set_energy( pat_tau.energy());
520	>	tau.set_decayModeFinding ( pat_tau.tauID("decayModeFinding")>0.5);
521	>	tau.set_byVLooseCombinedIsolationDeltaBetaCorr  ( pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5);
522	>	tau.set_byLooseCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5);
523	>	tau.set_byMediumCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5);
524	>	tau.set_byTightCombinedIsolationDeltaBetaCorr ( pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5);
525	>	tau.set_againstElectronLoose  ( pat_tau.tauID("againstElectronLoose")>0.5);
526	>	tau.set_againstElectronMedium ( pat_tau.tauID("againstElectronMedium")>0.5);
527	>	tau.set_againstElectronTight ( pat_tau.tauID("againstElectronTight")>0.5);
528	>	tau.set_againstElectronMVA  ( pat_tau.tauID("againstElectronMVA")>0.5);
529	>	tau.set_againstMuonLoose ( pat_tau.tauID("againstMuonLoose")>0.5);
530	>	tau.set_againstMuonMedium ( pat_tau.tauID("againstMuonMedium")>0.5);
531	>	tau.set_againstMuonTight ( pat_tau.tauID("againstMuonTight")>0.5);
532	>
533	>	//       reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
534	>	//       if(!leadPFCand.isNull()){
535	>	//         tau.set_leadPFCand_px ( leadPFCand->px());
536	>	//         tau.set_leadPFCand_py ( leadPFCand->py());
537	>	//         tau.set_leadPFCand_pz ( leadPFCand->pz());
538	>	//       }
539	>	//       else{
540	>	//         tau.set_leadPFCand_px ( 0);
541	>	//         tau.set_leadPFCand_py ( 0);
542	>	//         tau.set_leadPFCand_pz ( 0);
543	>	//       }
544		taus[j].push_back(tau);
545		}
546		}
#	Line 382 | Line 567 | NtupleWriter::analyze(const edm::Event&
567		//       }
568
569		Jet jet;
570	<	jet.charge = pat_jet.charge();
571	<	jet.pt = pat_jet.pt();
572	<	jet.eta = pat_jet.eta();
573	<	jet.phi = pat_jet.phi();
574	<	jet.energy = pat_jet.energy();
575	<	jet.numberOfDaughters =pat_jet.numberOfDaughters();
570	>	jet.set_charge(pat_jet.charge());
571	>	jet.set_pt(pat_jet.pt());
572	>	jet.set_eta(pat_jet.eta());
573	>	jet.set_phi(pat_jet.phi());
574	>	jet.set_energy(pat_jet.energy());
575	>	jet.set_numberOfDaughters (pat_jet.numberOfDaughters());
576		const reco::TrackRefVector&  jettracks = pat_jet.associatedTracks();
577	<	jet.nTracks = jettracks.size();
578	<	jet.jetArea = pat_jet.jetArea();
579	<	jet.pileup = pat_jet.pileup();
577	>	jet.set_nTracks ( jettracks.size());
578	>	jet.set_jetArea(pat_jet.jetArea());
579	>	jet.set_pileup(pat_jet.pileup());
580		if(pat_jet.isPFJet()){
581	<	jet.neutralEmEnergyFraction =pat_jet.neutralEmEnergyFraction();
582	<	jet.neutralHadronEnergyFraction =pat_jet.neutralHadronEnergyFraction();
583	<	jet.chargedEmEnergyFraction =pat_jet.chargedEmEnergyFraction();
584	<	jet.chargedHadronEnergyFraction =pat_jet.chargedHadronEnergyFraction();
585	<	jet.muonEnergyFraction =pat_jet.muonEnergyFraction();
586	<	jet.photonEnergyFraction =pat_jet.photonEnergyFraction();
587	<	jet.chargedMultiplicity =pat_jet.chargedMultiplicity();
588	<	jet.neutralMultiplicity =pat_jet.neutralMultiplicity();
589	<	jet.muonMultiplicity =pat_jet.muonMultiplicity();
590	<	jet.electronMultiplicity =pat_jet.electronMultiplicity();
591	<	jet.photonMultiplicity =pat_jet.photonMultiplicity();
592	<	}
593	<
594	<	jecUnc->setJetEta(pat_jet.eta());
595	<	jecUnc->setJetPt(pat_jet.pt());
596	<	jet.JEC_uncertainty = jecUnc->getUncertainty(true);
597	<
598	<	jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
599	<	jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
600	<	jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
601	<	jet.btag_combinedSecondaryVertexMVA=pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
602	<	jet.btag_jetBProbability=pat_jet.bDiscriminator("jetBProbabilityBJetTags");
603	<	jet.btag_jetProbability=pat_jet.bDiscriminator("jetProbabilityBJetTags");
581	>	jet.set_neutralEmEnergyFraction (pat_jet.neutralEmEnergyFraction());
582	>	jet.set_neutralHadronEnergyFraction (pat_jet.neutralHadronEnergyFraction());
583	>	jet.set_chargedEmEnergyFraction (pat_jet.chargedEmEnergyFraction());
584	>	jet.set_chargedHadronEnergyFraction (pat_jet.chargedHadronEnergyFraction());
585	>	jet.set_muonEnergyFraction (pat_jet.muonEnergyFraction());
586	>	jet.set_photonEnergyFraction (pat_jet.photonEnergyFraction());
587	>	jet.set_chargedMultiplicity (pat_jet.chargedMultiplicity());
588	>	jet.set_neutralMultiplicity (pat_jet.neutralMultiplicity());
589	>	jet.set_muonMultiplicity (pat_jet.muonMultiplicity());
590	>	jet.set_electronMultiplicity (pat_jet.electronMultiplicity());
591	>	jet.set_photonMultiplicity (pat_jet.photonMultiplicity());
592	>	}
593	>	if(doJECUncertainty){
594	>	jecUnc->setJetEta(pat_jet.eta());
595	>	jecUnc->setJetPt(pat_jet.pt());
596	>	jet.set_JEC_uncertainty(jecUnc->getUncertainty(true));
597	>	}
598	>	jet.set_JEC_factor_raw(pat_jet.jecFactor("Uncorrected"));
599	>
600	>	jet.set_btag_simpleSecondaryVertexHighEff(pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
601	>	jet.set_btag_simpleSecondaryVertexHighPur(pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
602	>	jet.set_btag_combinedSecondaryVertex(pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags"));
603	>	jet.set_btag_combinedSecondaryVertexMVA(pat_jet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
604	>	jet.set_btag_jetBProbability(pat_jet.bDiscriminator("jetBProbabilityBJetTags"));
605	>	jet.set_btag_jetProbability(pat_jet.bDiscriminator("jetProbabilityBJetTags"));
606
607	+
608	+	const reco::GenJet *genj = pat_jet.genJet();
609	+	if(genj){
610	+	jet.set_genjet_pt(genj->pt());
611	+	jet.set_genjet_eta(genj->eta());
612	+	jet.set_genjet_phi(genj->phi());
613	+	jet.set_genjet_energy(genj->energy());
614	+	if(doAllGenParticles){
615	+	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
616	+	for(unsigned int l = 0; l<jetgenps.size(); ++l){
617	+	for(unsigned int k=0; k< genps.size(); ++k){
618	+	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
619	+	jet.add_genparticles_index(genps[k].index());
620	+	break;
621	+	}
622	+	}
623	+	}
624	+	if(jet.genparticles_indices().size()!= jetgenps.size())
625	+	std::cout << "WARNING: Found only " << jet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this jet"<<std::endl;
626	+	}
627	+
628	+	}
629	+
630		jets[j].push_back(jet);
631		}
632		}
#	Line 433 | Line 643 | NtupleWriter::analyze(const edm::Event&
643		iEvent.getByLabel(topjet_sources[j], pat_topjets);
644
645		for (unsigned int i = 0; i < pat_topjets->size(); i++) {
646	+
647		const pat::Jet  pat_topjet =  * dynamic_cast<pat::Jet const *>(&pat_topjets->at(i));
648		if(pat_topjet.pt() < topjet_ptmin) continue;
649		if(fabs(pat_topjet.eta()) > topjet_etamax) continue;
650
651		TopJet topjet;
652	<	topjet.charge = pat_topjet.charge();
653	<	topjet.pt = pat_topjet.pt();
654	<	topjet.eta = pat_topjet.eta();
655	<	topjet.phi = pat_topjet.phi();
656	<	topjet.energy = pat_topjet.energy();
657	<	topjet.numberOfDaughters =pat_topjet.numberOfDaughters();
652	>	topjet.set_charge(pat_topjet.charge());
653	>	topjet.set_pt(pat_topjet.pt());
654	>	topjet.set_eta(pat_topjet.eta());
655	>	topjet.set_phi(pat_topjet.phi());
656	>	topjet.set_energy(pat_topjet.energy());
657	>	topjet.set_numberOfDaughters(pat_topjet.numberOfDaughters());
658		const reco::TrackRefVector&  topjettracks = pat_topjet.associatedTracks();
659	<	topjet.nTracks = topjettracks.size();
660	<	topjet.jetArea = pat_topjet.jetArea();
661	<	topjet.pileup = pat_topjet.pileup();
662	<	//       topjet.neutralEmEnergyFraction =pat_topjet.neutralEmEnergyFraction();
663	<	//       topjet.neutralHadronEnergyFraction =pat_topjet.neutralHadronEnergyFraction();
664	<	//       topjet.chargedEmEnergyFraction =pat_topjet.chargedEmEnergyFraction();
665	<	//       topjet.chargedHadronEnergyFraction =pat_topjet.chargedHadronEnergyFraction();
666	<	//       topjet.muonEnergyFraction =pat_topjet.muonEnergyFraction();
667	<	//       topjet.photonEnergyFraction =pat_topjet.photonEnergyFraction();
668	<	//       topjet.chargedMultiplicity =pat_topjet.chargedMultiplicity();
669	<	//       topjet.neutralMultiplicity =pat_topjet.neutralMultiplicity();
670	<	//       topjet.muonMultiplicity =pat_topjet.muonMultiplicity();
671	<	//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
672	<	//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
673	<
674	<	jecUnc->setJetEta(pat_topjet.eta());
675	<	jecUnc->setJetPt(pat_topjet.pt());
676	<	topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
677	<
678	<	topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
679	<	topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
680	<	topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
681	<	topjet.btag_combinedSecondaryVertexMVA=pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags");
682	<	topjet.btag_jetBProbability=pat_topjet.bDiscriminator("jetBProbabilityBJetTags");
683	<	topjet.btag_jetProbability=pat_topjet.bDiscriminator("jetProbabilityBJetTags");
659	>	topjet.set_nTracks( topjettracks.size());
660	>	topjet.set_jetArea( pat_topjet.jetArea());
661	>	topjet.set_pileup( pat_topjet.pileup());
662	>	//       topjet.set_neutralEmEnergyFraction(pat_topjet.neutralEmEnergyFraction());
663	>	//       topjet.set_neutralHadronEnergyFraction(pat_topjet.neutralHadronEnergyFraction());
664	>	//       topjet.set_chargedEmEnergyFraction(pat_topjet.chargedEmEnergyFraction());
665	>	//       topjet.set_chargedHadronEnergyFraction(pat_topjet.chargedHadronEnergyFraction());
666	>	//       topjet.set_muonEnergyFraction(pat_topjet.muonEnergyFraction());
667	>	//       topjet.set_photonEnergyFraction(pat_topjet.photonEnergyFraction());
668	>	//       topjet.set_chargedMultiplicity(pat_topjet.chargedMultiplicity());
669	>	//       topjet.set_neutralMultiplicity(pat_topjet.neutralMultiplicity());
670	>	//       topjet.set_muonMultiplicity(pat_topjet.muonMultiplicity());
671	>	//       topjet.set_electronMultiplicity(pat_topjet.electronMultiplicity());
672	>	//       topjet.set_photonMultiplicity(pat_topjet.photonMultiplicity());
673	>	if(doJECUncertainty){
674	>	jecUnc->setJetEta(pat_topjet.eta());
675	>	jecUnc->setJetPt(pat_topjet.pt());
676	>	topjet.set_JEC_uncertainty( jecUnc->getUncertainty(true));
677	>	}
678	>	topjet.set_JEC_factor_raw( pat_topjet.jecFactor("Uncorrected"));
679	>
680	>	topjet.set_btag_simpleSecondaryVertexHighEff(pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
681	>	topjet.set_btag_simpleSecondaryVertexHighPur(pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
682	>	topjet.set_btag_combinedSecondaryVertex(pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags"));
683	>	topjet.set_btag_combinedSecondaryVertexMVA(pat_topjet.bDiscriminator("combinedSecondaryVertexMVABJetTags"));
684	>	topjet.set_btag_jetBProbability(pat_topjet.bDiscriminator("jetBProbabilityBJetTags"));
685	>	topjet.set_btag_jetProbability(pat_topjet.bDiscriminator("jetProbabilityBJetTags"));
686	>
687	>	/*
688	>	const reco::GenJet *genj = pat_topjet.genJet();
689	>	if(genj){
690	>	topjet.set_genjet_pt ( genj->pt());
691	>	topjet.set_genjet_eta ( genj->eta());
692	>	topjet.set_genjet_phi ( genj->phi());
693	>	topjet.set_genjet_energy ( genj->energy());
694	>	if(doAllGenParticles){
695	>	std::vector<const reco::GenParticle * > jetgenps = genj->getGenConstituents();
696	>	for(unsigned int l = 0; l<jetgenps.size(); ++l){
697	>	for(unsigned int k=0; k< genps.size(); ++k){
698	>	if(jetgenps[l]->pt() == genps[k].pt() && jetgenps[l]->pdgId() == genps[k].pdgId()){
699	>	topjet.add_genparticles_index(genps[k].index());
700	>	break;
701	>	}
702	>	}
703	>	}
704	>	if(topjet.genparticles_indices().size()!= jetgenps.size())
705	>	std::cout << "WARNING: Found only " << topjet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this topjet"<<std::endl;
706	>	}
707	>	}
708	>	*/
709
710		for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) {
711		Particle subjet_v4;
712	<	subjet_v4.pt = pat_topjet.daughter(k)->p4().pt();
713	<	subjet_v4.eta = pat_topjet.daughter(k)->p4().eta();
714	<	subjet_v4.phi = pat_topjet.daughter(k)->p4().phi();
715	<	subjet_v4.energy = pat_topjet.daughter(k)->p4().E();
716	<	topjet.subjets.push_back(subjet_v4);
712	>
713	>	reco::Candidate const * subjetd =  pat_topjet.daughter(k);
714	>	pat::Jet const * patsubjetd = dynamic_cast<pat::Jet const *>(subjetd);
715	>	if(patsubjetd)
716	>	{
717	>	subjet_v4.set_pt(patsubjetd->correctedP4(0).pt());
718	>	subjet_v4.set_eta(patsubjetd->correctedP4(0).eta());
719	>	subjet_v4.set_phi(patsubjetd->correctedP4(0).phi());
720	>	subjet_v4.set_energy(patsubjetd->correctedP4(0).E());
721	>	topjet.add_subjet(subjet_v4);
722	>	//btag info
723	>	topjet.add_subFlavour(patsubjetd->partonFlavour());
724	>	topjet.add_subCSV(patsubjetd->bDiscriminator("combinedSecondaryVertexBJetTags"));
725	>	if (doTagInfos)
726	>	{
727	>	//ip tag info
728	>	reco::TaggingVariableList tvlIP=patsubjetd->tagInfoTrackIP("impactParameter")->taggingVariables();
729	>	topjet.add_subTrackMomentum(tvlIP.getList(reco::btau::trackMomentum,false));
730	>	topjet.add_subTrackEta(tvlIP.getList(reco::btau::trackEta,false));
731	>	topjet.add_subTrackEtaRel(tvlIP.getList(reco::btau::trackEtaRel,false));
732	>	topjet.add_subTrackDeltaR(tvlIP.getList(reco::btau::trackDeltaR,false));
733	>	topjet.add_subTrackSip3dVal(tvlIP.getList(reco::btau::trackSip3dVal,false));
734	>	topjet.add_subTrackSip3dSig(tvlIP.getList(reco::btau::trackSip3dSig,false));
735	>	topjet.add_subTrackSip2dVal(tvlIP.getList(reco::btau::trackSip2dVal,false));
736	>	topjet.add_subTrackSip2dSig(tvlIP.getList(reco::btau::trackSip2dSig,false));
737	>	topjet.add_subTrackDecayLenVal(tvlIP.getList(reco::btau::trackDecayLenVal,false));
738	>	topjet.add_subTrackChi2(tvlIP.getList(reco::btau::trackChi2,false));
739	>	topjet.add_subTrackNTotalHits(tvlIP.getList(reco::btau::trackNTotalHits,false));
740	>	topjet.add_subTrackNPixelHits(tvlIP.getList(reco::btau::trackNPixelHits,false));
741	>	topjet.add_subTrackPtRel(tvlIP.getList(reco::btau::trackPtRel,false));
742	>	topjet.add_subTrackPPar(tvlIP.getList(reco::btau::trackPPar,false));
743	>	topjet.add_subTrackPtRatio(tvlIP.getList(reco::btau::trackPtRatio,false));
744	>	topjet.add_subTrackPParRatio(tvlIP.getList(reco::btau::trackPParRatio,false));
745	>	topjet.add_subTrackJetDistVal(tvlIP.getList(reco::btau::trackJetDistVal,false));
746	>	topjet.add_subTrackJetDistSig(tvlIP.getList(reco::btau::trackJetDistSig,false));
747	>	topjet.add_subTrackGhostTrackDistVal(tvlIP.getList(reco::btau::trackGhostTrackDistVal,false));
748	>	topjet.add_subTrackGhostTrackDistSig(tvlIP.getList(reco::btau::trackGhostTrackDistSig,false));
749	>	topjet.add_subTrackGhostTrackWeight(tvlIP.getList(reco::btau::trackGhostTrackWeight,false));
750	>	//sv tag info
751	>	reco::TaggingVariableList tvlSV=patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->taggingVariables();
752	>	topjet.add_subFlightDistance2dVal(tvlSV.getList(reco::btau::flightDistance2dVal,false));
753	>	topjet.add_subFlightDistance2dSig(tvlSV.getList(reco::btau::flightDistance2dSig,false));
754	>	topjet.add_subFlightDistance3dVal(tvlSV.getList(reco::btau::flightDistance3dVal,false));
755	>	topjet.add_subFlightDistance3dSig(tvlSV.getList(reco::btau::flightDistance3dSig,false));
756	>	topjet.add_subVertexJetDeltaR(tvlSV.getList(reco::btau::vertexJetDeltaR,false));
757	>	topjet.add_subJetNSecondaryVertices(tvlSV.get(reco::btau::jetNSecondaryVertices,-9999));
758	>	topjet.add_subVertexNTracks(tvlSV.get(reco::btau::vertexNTracks,-9999));
759	>	std::vector<TLorentzVector> vp4; vp4.clear();
760	>	std::vector<float> vchi2; vchi2.clear();
761	>	std::vector<float> vndof; vndof.clear();
762	>	std::vector<float> vchi2ndof; vchi2ndof.clear();
763	>	std::vector<float> vtrsize; vtrsize.clear();
764	>	for(unsigned int i=0; i<patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->nVertices(); i++)
765	>	{
766	>	ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > p4 = patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).p4();
767	>	vp4.push_back(TLorentzVector(p4.px(),p4.py(),p4.pz(),p4.e()));
768	>	vchi2.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).chi2());
769	>	vndof.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).ndof());
770	>	vchi2ndof.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).normalizedChi2());
771	>	vtrsize.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).tracksSize());
772	>	}
773	>	topjet.add_subSecondaryVertex(vp4);
774	>	topjet.add_subVertexChi2(vchi2);
775	>	topjet.add_subVertexNdof(vndof);
776	>	topjet.add_subVertexNormalizedChi2(vchi2ndof);
777	>	topjet.add_subVertexTracksSize(vtrsize);
778	>	//try computer
779	>	edm::ESHandle<JetTagComputer> computerHandle;
780	>	iSetup.get<JetTagComputerRecord>().get( SVComputer_.label(), computerHandle );
781	>	const GenericMVAJetTagComputer *computer = dynamic_cast<const GenericMVAJetTagComputer*>( computerHandle.product() );
782	>	if(computer)
783	>	{
784	>	computer->passEventSetup(iSetup);
785	>	std::vector<const reco::BaseTagInfo*>  baseTagInfos;
786	>	baseTagInfos.push_back(patsubjetd->tagInfoTrackIP("impactParameter") );
787	>	baseTagInfos.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex") );
788	>	JetTagComputer::TagInfoHelper helper(baseTagInfos);
789	>	reco::TaggingVariableList vars = computer->taggingVariables(helper);
790	>	topjet.add_subVertexMassJTC(vars.get(reco::btau::vertexMass,-9999));
791	>	topjet.add_subVertexCategoryJTC(vars.get(reco::btau::vertexCategory,-9999));
792	>	topjet.add_subVertexEnergyRatioJTC(vars.get(reco::btau::vertexEnergyRatio,-9999));
793	>	topjet.add_subTrackSip3dSigAboveCharmJTC(vars.get(reco::btau::trackSip3dSigAboveCharm,-9999));
794	>	}
795	>	}
796	>	}
797	>	else
798	>	{
799	>	//filling only standard information in case the subjet has not been pat-tified during the pattuples production
800	>	subjet_v4.set_pt(pat_topjet.daughter(k)->p4().pt());
801	>	subjet_v4.set_eta(pat_topjet.daughter(k)->p4().eta());
802	>	subjet_v4.set_phi(pat_topjet.daughter(k)->p4().phi());
803	>	subjet_v4.set_energy(pat_topjet.daughter(k)->p4().E());
804	>	topjet.add_subjet(subjet_v4);
805	>	}
806	>
807	>
808		}
809		topjets[j].push_back(topjet);
810		}
811		}
812		}
813	+
814	+
815	+	// ------------- generator top jets -------------
816	+	if(doGenTopJets){
817	+	for(size_t j=0; j< gentopjet_sources.size(); ++j){
818	+
819	+	gentopjets[j].clear();
820	+
821	+	edm::Handle<reco::BasicJetCollection> reco_gentopjets;
822	+	//edm::Handle<std::vector<reco::Jet> > reco_gentopjets;
823	+	iEvent.getByLabel(gentopjet_sources[j], reco_gentopjets);
824	+
825	+	for (unsigned int i = 0; i < reco_gentopjets->size(); i++) {
826	+
827	+	const reco::BasicJet  reco_gentopjet =  reco_gentopjets->at(i);
828	+	if(reco_gentopjet.pt() < gentopjet_ptmin) continue;
829	+	if(fabs(reco_gentopjet.eta()) > gentopjet_etamax) continue;
830	+
831	+	TopJet gentopjet;
832	+	gentopjet.set_charge(reco_gentopjet.charge());
833	+	gentopjet.set_pt(reco_gentopjet.pt());
834	+	gentopjet.set_eta(reco_gentopjet.eta());
835	+	gentopjet.set_phi(reco_gentopjet.phi());
836	+	gentopjet.set_energy(reco_gentopjet.energy());
837	+	gentopjet.set_numberOfDaughters(reco_gentopjet.numberOfDaughters());
838	+
839	+	for (unsigned int k = 0; k < reco_gentopjet.numberOfDaughters(); k++) {
840	+	Particle subjet_v4;
841	+	subjet_v4.set_pt(reco_gentopjet.daughter(k)->p4().pt());
842	+	subjet_v4.set_eta(reco_gentopjet.daughter(k)->p4().eta());
843	+	subjet_v4.set_phi(reco_gentopjet.daughter(k)->p4().phi());
844	+	subjet_v4.set_energy(reco_gentopjet.daughter(k)->p4().E());
845	+	gentopjet.add_subjet(subjet_v4);
846	+	}
847	+	gentopjets[j].push_back(gentopjet);
848	+	}
849	+	}
850	+	}
851
852		// ------------- photons -------------
853		if(doPhotons){
#	Line 496 | Line 861 | NtupleWriter::analyze(const edm::Event&
861		for (unsigned int i = 0; i < pat_photons.size(); ++i) {
862		pat::Photon pat_photon = pat_photons[i];
863		Photon ph;
864	<	ph.charge = 0;
865	<	ph.pt =  pat_photon.pt();
866	<	ph.eta =  pat_photon.eta();
867	<	ph.phi =  pat_photon.phi();
868	<	ph.energy =  pat_photon.energy();
869	<	ph.vertex_x = pat_photon.vertex().x();
870	<	ph.vertex_y = pat_photon.vertex().y();
871	<	ph.vertex_z = pat_photon.vertex().z();
872	<	ph.supercluster_eta = pat_photon.superCluster()->eta();
873	<	ph.supercluster_phi = pat_photon.superCluster()->phi();
874	<	//       ph.neutralHadronIso = pat_photon.neutralHadronIso();
875	<	//       ph.chargedHadronIso = pat_photon.chargedHadronIso();
876	<	ph.trackIso = pat_photon.trackIso();
864	>	ph.set_charge(0);
865	>	ph.set_pt( pat_photon.pt());
866	>	ph.set_eta( pat_photon.eta());
867	>	ph.set_phi( pat_photon.phi());
868	>	ph.set_energy( pat_photon.energy());
869	>	ph.set_vertex_x(pat_photon.vertex().x());
870	>	ph.set_vertex_y(pat_photon.vertex().y());
871	>	ph.set_vertex_z(pat_photon.vertex().z());
872	>	ph.set_supercluster_eta(pat_photon.superCluster()->eta());
873	>	ph.set_supercluster_phi(pat_photon.superCluster()->phi());
874	>	//       ph.set_neutralHadronIso(pat_photon.neutralHadronIso());
875	>	//       ph.set_chargedHadronIso(pat_photon.chargedHadronIso());
876	>	ph.set_trackIso(pat_photon.trackIso());
877		phs[j].push_back(ph);
878		}
879		}
#	Line 528 | Line 893 | NtupleWriter::analyze(const edm::Event&
893		else{
894		pat::MET pat_met = pat_mets[0];
895
896	<	met[j].pt=pat_met.pt();
897	<	met[j].phi=pat_met.phi();
898	<	met[j].mEtSig= pat_met.mEtSig();
896	>	met[j].set_pt(pat_met.pt());
897	>	met[j].set_phi(pat_met.phi());
898	>	met[j].set_mEtSig(pat_met.mEtSig());
899		}
900
901		}
902		}
903
904		// ------------- trigger -------------
905	<
906	<	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
907	<	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
908	<	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
544	<
545	<	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
546	<	std::string nameProcess = meta->processName();
547	<	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
548	<	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
549	<
550	<	edm::Handle<edm::TriggerResults> trigger;
551	<	iEvent.getByLabel(triggerResultTag, trigger);
552	<	const edm::TriggerResults& trig = *(trigger.product());
553	<
554	<	triggerResults.clear();
555	<	triggerNames.clear();
556	<	L1_prescale.clear();
557	<	HLT_prescale.clear();
558	<
559	<	edm::Service<edm::service::TriggerNamesService> tns;
560	<	std::vector<std::string> triggerNames_all;
561	<	tns->getTrigPaths(trig,triggerNames_all);
562	<
563	<	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
564	<	for(unsigned int i=0; i<trig.size(); ++i){
565	<	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
566	<	for(; it!=trigger_prefixes.end(); ++it){
567	<	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
568	<	}
569	<	if(it==trigger_prefixes.end()) continue;
570	<
571	<	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
572	<	triggerResults.push_back(trig.accept(i));
573	<	if(newrun) triggerNames.push_back(triggerNames_all[i]);
574	<	if(isRealData){
575	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
576	<	L1_prescale.push_back(pre.first);
577	<	HLT_prescale.push_back(pre.second);
578	<	}
579	<	}
580	<	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
581	<	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
582	<	//    }
583	<	newrun=false;
584	<
585	<	// ------------- generator info -------------
586	<
587	<	if(doGenInfo){
588	<	genInfo.weights.clear();
589	<	genInfo.binningValues.clear();
590	<	genps.clear();
591	<
592	<	edm::Handle<GenEventInfoProduct> genEventInfoProduct;
593	<	iEvent.getByLabel("generator", genEventInfoProduct);
594	<	const GenEventInfoProduct& genEventInfo = *(genEventInfoProduct.product());
595	<
596	<	genInfo.binningValues = genEventInfo.binningValues();
597	<	genInfo.weights = genEventInfo.weights();
598	<	genInfo.alphaQCD = genEventInfo.alphaQCD();
599	<	genInfo.alphaQED = genEventInfo.alphaQED();
600	<	genInfo.qScale = genEventInfo.qScale();
905	>	if(doTrigger){
906	>	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
907	>	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
908	>	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
909
910	<	const gen::PdfInfo* pdf = genEventInfo.pdf();
911	<	if(pdf){
912	<	genInfo.pdf_id1=pdf->id.first;
913	<	genInfo.pdf_id2=pdf->id.second;
914	<	genInfo.pdf_x1=pdf->x.first;
915	<	genInfo.pdf_x2=pdf->x.second;
916	<	genInfo.pdf_scalePDF=pdf->scalePDF;
917	<	genInfo.pdf_xPDF1=pdf->xPDF.first;
918	<	genInfo.pdf_xPDF2=pdf->xPDF.second;
919	<	}
920	<	else{
921	<	genInfo.pdf_id1=-999;
922	<	genInfo.pdf_id2=-999;
923	<	genInfo.pdf_x1=-999;
924	<	genInfo.pdf_x2=-999;
925	<	genInfo.pdf_scalePDF=-999;
926	<	genInfo.pdf_xPDF1=-999;
927	<	genInfo.pdf_xPDF2=-999;
928	<	}
929	<
930	<	edm::Handle<std::vector<PileupSummaryInfo> > pus;
931	<	iEvent.getByLabel(edm::InputTag("addPileupInfo"), pus);
932	<	genInfo.pileup_NumInteractions_intime=0;
933	<	genInfo.pileup_NumInteractions_ootbefore=0;
934	<	genInfo.pileup_NumInteractions_ootafter=0;
935	<	if(pus.isValid()){
936	<	genInfo.pileup_TrueNumInteractions = (float) pus->at(0).getTrueNumInteractions();
937	<	for(size_t i=0; i<pus->size(); ++i){
938	<	if(pus->at(i).getBunchCrossing() == 0) // intime pileup
939	<	genInfo.pileup_NumInteractions_intime += pus->at(i).getPU_NumInteractions();
940	<	else if(pus->at(i).getBunchCrossing() == -1){ // oot pileup before
941	<	genInfo.pileup_NumInteractions_ootbefore += pus->at(i).getPU_NumInteractions();
942	<	}
943	<	else if(pus->at(i).getBunchCrossing() == +1){ // oot pileup before
944	<	genInfo.pileup_NumInteractions_ootafter += pus->at(i).getPU_NumInteractions();
945	<	}
946	<	}
947	<	}
948	<
949	<	edm::Handle<reco::GenParticleCollection> genPartColl;
642	<	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
643	<	int index=-1;
644	<	for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
645	<	index++;
646	<
647	<	//write out only top quarks and status 3 particles (works fine only for MadGraph)
648	<	if(abs(iter->pdgId())==6 || iter->status()==3){
649	<	GenParticle genp;
650	<	genp.charge = iter->charge();;
651	<	genp.pt = iter->p4().pt();
652	<	genp.eta = iter->p4().eta();
653	<	genp.phi = iter->p4().phi();
654	<	genp.energy = iter->p4().E();
655	<	genp.index =index;
656	<	genp.status = iter->status();
657	<	genp.pdgId = iter->pdgId();
658	<
659	<	genp.mother1=-1;
660	<	genp.mother2=-1;
661	<	genp.daughter1=-1;
662	<	genp.daughter2=-1;
663	<
664	<	int nm=iter->numberOfMothers();
665	<	int nd=iter->numberOfDaughters();
666	<
667	<	if (nm>0) genp.mother1 = iter->motherRef(0).key();
668	<	if (nm>1) genp.mother2 = iter->motherRef(nm-1).key();
669	<	if (nd>0) genp.daughter1 = iter->daughterRef(0).key();
670	<	if (nd>1) genp.daughter2 = iter->daughterRef(nd-1).key();
671	<
672	<	genps.push_back(genp);
673	<	}
674	<	}
675	<
910	>	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
911	>	std::string nameProcess = meta->processName();
912	>	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
913	>	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
914	>
915	>	edm::Handle<edm::TriggerResults> trigger;
916	>	iEvent.getByLabel(triggerResultTag, trigger);
917	>	const edm::TriggerResults& trig = *(trigger.product());
918	>
919	>	triggerResults.clear();
920	>	triggerNames.clear();
921	>	//      L1_prescale.clear();
922	>	//      HLT_prescale.clear();
923	>
924	>	edm::Service<edm::service::TriggerNamesService> tns;
925	>	std::vector<std::string> triggerNames_all;
926	>	tns->getTrigPaths(trig,triggerNames_all);
927	>
928	>	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
929	>	for(unsigned int i=0; i<trig.size(); ++i){
930	>	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
931	>	for(; it!=trigger_prefixes.end(); ++it){
932	>	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
933	>	}
934	>	if(it==trigger_prefixes.end()) continue;
935	>
936	>	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
937	>	triggerResults.push_back(trig.accept(i));
938	>	if(newrun) triggerNames.push_back(triggerNames_all[i]);
939	>	//        if(isRealData){
940	>	//       std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
941	>	//       L1_prescale.push_back(pre.first);
942	>	//       HLT_prescale.push_back(pre.second);
943	>	//       //std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
944	>	//        }
945	>	}
946	>	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
947	>	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
948	>	//    }
949	>	newrun=false;
950		}
951
952
953		tr->Fill();
954	<
954	>	if(doLumiInfo)
955	>	previouslumiblockwasfilled=true;
956		}
957
958
#	Line 685 | Line 960 | NtupleWriter::analyze(const edm::Event&
960		void
961		NtupleWriter::beginJob()
962		{
963	+	if(doLumiInfo){
964	+	totalRecLumi=0;
965	+	totalDelLumi=0;
966	+	previouslumiblockwasfilled=false;
967	+	}
968		}
969
970		// ------------ method called once each job just after ending the event loop  ------------
#	Line 700 | Line 980 | NtupleWriter::endJob()
980		void
981		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
982		{
983	<	bool setup_changed = false;
984	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
985	<	newrun=true;
986	<
987	<	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
708	<	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
709	<	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
710	<	jecUnc = new JetCorrectionUncertainty(JetCorPar);
983	>	if(doTrigger){
984	>	//bool setup_changed = false;
985	>	//hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
986	>	newrun=true;
987	>	}
988
989	+	if(doJets || doTopJets){
990	+	if(doJECUncertainty){
991	+	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
992	+	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
993	+	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
994	+	jecUnc = new JetCorrectionUncertainty(JetCorPar);
995	+	}
996	+	}
997		}
998
999		// ------------ method called when ending the processing of a run  ------------
1000		void
1001		NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&)
1002		{
1003	+	if(doLumiInfo)
1004	+	std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl;
1005		}
1006
1007		// ------------ method called when starting to processes a luminosity block  ------------
1008		void
1009	<	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
1009	>	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&)
1010		{
1011	+	if(doLumiInfo){
1012	+	edm::Handle<LumiSummary> l;
1013	+	lumi.getByLabel("lumiProducer", l);
1014	+
1015	+	//add lumi of lumi blocks without any event to next lumiblock
1016	+	if(previouslumiblockwasfilled){
1017	+	intgRecLumi=0;
1018	+	intgDelLumi=0;
1019	+	}
1020	+	previouslumiblockwasfilled=false;
1021	+
1022	+	if (l.isValid()){;
1023	+	intgRecLumi+=l->intgRecLumi()*6.37;
1024	+	intgDelLumi+=l->intgDelLumi()*6.37;
1025	+	totalRecLumi+=l->intgRecLumi()*6.37;
1026	+	totalDelLumi+=l->intgDelLumi()*6.37;
1027	+	}
1028	+	//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<"   " << l->intgDelLumi()*6.37<<std::endl;
1029	+	//std::cout << "summed:  "<< intgRecLumi << "   " << intgDelLumi << std::endl;
1030	+	}
1031		}
1032
1033		// ------------ method called when ending the processing of a luminosity block  ------------

Diff Legend

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