ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/CmsHi/JetAnalysis/src/HiInclusiveJetAnalyzer.cc

Comparing UserCode/CmsHi/JetAnalysis/src/HiInclusiveJetAnalyzer.cc (file contents):
Revision 1.9 by yilmaz, Sun Apr 22 19:12:44 2012 UTC vs.
Revision 1.14 by yilmaz, Thu May 10 16:08:29 2012 UTC

#	Line 24 | Line 24
24		#include "DataFormats/JetReco/interface/CaloJetCollection.h"
25		#include "SimDataFormats/HiGenData/interface/GenHIEvent.h"
26		#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
27	+	#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
28		#include "DataFormats/JetReco/interface/GenJetCollection.h"
29		#include "DataFormats/VertexReco/interface/Vertex.h"
30		#include "DataFormats/Math/interface/deltaPhi.h"
#	Line 48 | Line 49 | HiInclusiveJetAnalyzer::HiInclusiveJetAn
49		vtxTag_ = iConfig.getUntrackedParameter<edm::InputTag>("vtxTag",edm::InputTag("hiSelectedVertex"));
50
51		isMC_ = iConfig.getUntrackedParameter<bool>("isMC",false);
52	+	doTrigger_ = iConfig.getUntrackedParameter<bool>("doTrigger",false);
53
54		if(isMC_){
55		genjetTag_ = iConfig.getParameter<InputTag>("genjetTag");
#	Line 61 | Line 63 | HiInclusiveJetAnalyzer::HiInclusiveJetAn
63		usePat_ = iConfig.getUntrackedParameter<bool>("usePAT",true);
64
65		doLifeTimeTagging_ = iConfig.getUntrackedParameter<bool>("doLifeTimeTagging",false);
66	+	doLifeTimeTaggingExtras_ = iConfig.getUntrackedParameter<bool>("doLifeTimeTaggingExtras",true);
67	+	saveBfragments_  = iConfig.getUntrackedParameter<bool>("saveBfragments",false);
68	+
69		pfCandidateLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("pfCandidateLabel",edm::InputTag("particleFlowTmp"));
70
71	<	if(!isMC_){
71	>	if(doTrigger_){
72		L1gtReadout_ = iConfig.getParameter<edm::InputTag>("L1gtReadout");
73		hltResName_ = iConfig.getUntrackedParameter<string>("hltTrgResults","TriggerResults::HLT");
74
#	Line 80 | Line 85 | HiInclusiveJetAnalyzer::HiInclusiveJetAn
85		}
86
87		cout<<" jet collection : "<<jetTag_<<endl;
88	+	doSubEvent_ = 0;
89	+
90		if(isMC_){
91		cout<<" genjet collection : "<<genjetTag_<<endl;
92		genPtMin_ = iConfig.getUntrackedParameter<double>("genPtMin",0);
93	+	doSubEvent_ = iConfig.getUntrackedParameter<bool>("doSubEvent",1);
94		}
95
96
#	Line 142 | Line 150 | HiInclusiveJetAnalyzer::beginJob() {
150		t->Branch("discr_tcHighEff",jets_.discr_tcHighEff,"discr_tcHighEff[nref]/F");
151		t->Branch("discr_tcHighPur",jets_.discr_tcHighPur,"discr_tcHighPur[nref]/F");
152
153	<	t->Branch("nsvtx",    jets_.nsvtx,    "nsvtx[nref]/b");
154	<	t->Branch("svtxntrk", jets_.svtxntrk, "svtxntrk[nref]/b");
153	>	t->Branch("nsvtx",    jets_.nsvtx,    "nsvtx[nref]/I");
154	>	t->Branch("svtxntrk", jets_.svtxntrk, "svtxntrk[nref]/I");
155		t->Branch("svtxdl",   jets_.svtxdl,   "svtxdl[nref]/F");
156		t->Branch("svtxdls",  jets_.svtxdls,  "svtxdls[nref]/F");
157		t->Branch("svtxm",    jets_.svtxm,    "svtxm[nref]/F");
158		t->Branch("svtxpt",   jets_.svtxpt,   "svtxpt[nref]/F");
159
160	<	t->Branch("nIPtracks",jets_.nIPtracks,"nIPTracks[nref]/b");
161	<	t->Branch("nselIPtracks",jets_.nselIPtracks,"nselIPTracks[nref]/b");
160	>	t->Branch("nIPtrk",jets_.nIPtrk,"nIPtrk[nref]/I");
161	>	t->Branch("nselIPtrk",jets_.nselIPtrk,"nselIPtrk[nref]/I");
162	>
163	>	if (doLifeTimeTaggingExtras_) {
164	>	t->Branch("nIP",&jets_.nIP,"nIP/I");
165	>	t->Branch("ipJetIndex",jets_.ipJetIndex,"ipJetIndex[nIP]/I");
166	>	t->Branch("ipPt",jets_.ipPt,"ipPt[nIP]/F");
167	>	t->Branch("ipProb0",jets_.ipProb0,"ipProb0[nIP]/F");
168	>	t->Branch("ipProb1",jets_.ipProb1,"ipProb1[nIP]/F");
169	>	t->Branch("ip2d",jets_.ip2d,"ip2d[nIP]/F");
170	>	t->Branch("ip2dSig",jets_.ip2dSig,"ip2dSig[nIP]/F");
171	>	t->Branch("ip3d",jets_.ip3d,"ip3d[nIP]/F");
172	>	t->Branch("ip3dSig",jets_.ip3dSig,"ip3dSig[nIP]/F");
173	>	t->Branch("ipDist2Jet",jets_.ipDist2Jet,"ipDist2Jet[nIP]/F");
174	>	t->Branch("ipDist2JetSig",jets_.ipDist2JetSig,"ipDist2JetSig[nIP]/F");
175	>	t->Branch("ipClosest2Jet",jets_.ipClosest2Jet,"ipClosest2Jet[nIP]/F");
176	>
177	>	}
178
179		t->Branch("mue",     jets_.mue,     "mue[nref]/F");
180		t->Branch("mupt",    jets_.mupt,    "mupt[nref]/F");
#	Line 162 | Line 186 | HiInclusiveJetAnalyzer::beginJob() {
186		}
187
188		if(isMC_){
189	+	t->Branch("beamId1",&jets_.beamId1,"beamId1/I");
190	+	t->Branch("beamId2",&jets_.beamId2,"beamId2/I");
191	+
192		t->Branch("pthat",&jets_.pthat,"pthat/F");
193
194		// Only matched gen jets
#	Line 185 | Line 212 | HiInclusiveJetAnalyzer::beginJob() {
212		t->Branch("genphi",jets_.genphi,"genphi[ngen]/F");
213		t->Branch("gendphijt",jets_.gendphijt,"gendphijt[ngen]/F");
214		t->Branch("gendrjt",jets_.gendrjt,"gendrjt[ngen]/F");
215	+
216	+	if(doSubEvent_){
217	+	t->Branch("gensubid",jets_.gensubid,"gensubid[ngen]/I");
218	+	}
219	+
220	+	if(saveBfragments_  ) {
221	+	t->Branch("bMult",&jets_.bMult,"bMult/I");
222	+	t->Branch("bJetIndex",jets_.bJetIndex,"bJetIndex[bMult]/I");
223	+	t->Branch("bStatus",jets_.bStatus,"bStatus[bMult]/I");
224	+	t->Branch("bVx",jets_.bVx,"bVx[bMult]/F");
225	+	t->Branch("bVy",jets_.bVy,"bVy[bMult]/F");
226	+	t->Branch("bVz",jets_.bVz,"bVz[bMult]/F");
227	+	t->Branch("bPt",jets_.bPt,"bPt[bMult]/F");
228	+	t->Branch("bEta",jets_.bEta,"bEta[bMult]/F");
229	+	t->Branch("bPhi",jets_.bPhi,"bPhi[bMult]/F");
230	+	t->Branch("bPdg",jets_.bPdg,"bPdg[bMult]/I");
231	+	t->Branch("bChg",jets_.bChg,"bChg[bMult]/I");
232	+	}
233	+
234		}
235		/*
236		if(!isMC_){
#	Line 238 | Line 284 | HiInclusiveJetAnalyzer::analyze(const Ev
284
285
286
241	–	//double jetPtMin = 35.;
242	–
287
288		// loop the events
289
#	Line 281 | Line 325 | HiInclusiveJetAnalyzer::analyze(const Ev
325		for(unsigned int j = 0 ; j < jets->size(); ++j){
326		const reco::Jet& jet = (*jets)[j];
327
328	<	//cout<<" jet pt "<<jet.pt()<<endl;
285	<	//if(jet.pt() < jetPtMin) continue;
328	>
329		if (useJEC_ && usePat_){
330		jets_.rawpt[jets_.nref]=(*patjets)[j].correctedJet("Uncorrected").pt();
331		}
#	Line 310 | Line 353 | HiInclusiveJetAnalyzer::analyze(const Ev
353		jets_.discr_tcHighPur[jets_.nref] = (*patjets)[j].bDiscriminator("akPu3PFTrackCountingHighPurBJetTags");
354		}
355		else{
356	<	cout<<" you fail at btagging "<<endl;
356	>	cout<<" b-tagging variables not filled for this collection, turn of doLifeTimeTagging "<<endl;
357		}
358	<
358	>
359		const reco::SecondaryVertexTagInfo& tagInfoSV=*(*patjets)[j].tagInfoSecondaryVertex();
360	+
361	+	jets_.nsvtx[jets_.nref]     = tagInfoSV.nVertices();
362	+
363		if (tagInfoSV.nVertices()>0) {
318	–	Measurement1D m1D = tagInfoSV.flightDistance(0);
319	–	jets_.nsvtx[jets_.nref]     = tagInfoSV.nVertices();
364		jets_.svtxntrk[jets_.nref]  = tagInfoSV.nVertexTracks(0);
365	+	// this is the 3d flight distance, for 2-D use (0,true)
366	+	Measurement1D m1D = tagInfoSV.flightDistance(0);
367		jets_.svtxdl[jets_.nref]    = m1D.value();
368		jets_.svtxdls[jets_.nref]   = m1D.significance();
369
370	<	const reco::Vertex& svtx = tagInfoSV.secondaryVertex(0);
371	<
370	>	const reco::Vertex& svtx = tagInfoSV.secondaryVertex(0);
371	>	//cout<<" SV:  vx: "<<svtx.x()<<" vy "<<svtx.y()<<" vz "<<svtx.z()<<endl;
372	>	//cout<<" PV:  vx: "<<jet.vx()<<" vy "<<jet.vy()<<" vz "<<jet.vz()<<endl;
373		jets_.svtxm[jets_.nref]    = svtx.p4().mass();
374	<	jets_.svtxpt[jets_.nref]   = svtx.p4().pt();
375	<
329	<	}
330	<	else {
331	<	jets_.nsvtx[jets_.nref]    =   0;
332	<	jets_.svtxntrk[jets_.nref] =   0;
333	<	jets_.svtxdl[jets_.nref]   = 0.0;
334	<	jets_.svtxdls[jets_.nref]  = 0.0;
335	<	jets_.svtxm[jets_.nref]    = 0.0;
336	<	jets_.svtxpt[jets_.nref]   = 0.0;
374	>	jets_.svtxpt[jets_.nref]   = svtx.p4().pt();
375	>	//cout<<" chi2 "<<svtx.chi2()<<" ndof "<<svtx.ndof()<<endl;
376		}
377	+
378		const reco::TrackIPTagInfo& tagInfoIP=*(*patjets)[j].tagInfoTrackIP();
379	+
380	+	jets_.nIPtrk[jets_.nref] = tagInfoIP.tracks().size();
381	+	jets_.nselIPtrk[jets_.nref] = tagInfoIP.selectedTracks().size();
382
383	<	jets_.nIPtracks[jets_.nref] = tagInfoIP.tracks().size();
341	<	jets_.nselIPtracks[jets_.nref] = tagInfoIP.selectedTracks().size();
383	>	if (doLifeTimeTaggingExtras_) {
384
385	<	// would be nice to save the info for the tracks, but requires a more sophisticated tree
386	<	/*
387	<	//cout << "Jet pt: " << tagInfoIP.jet()->pt() << endl;
388	<	cout << "Tot tracks: " << tagInfoIP.tracks().size() << endl;
389	<	TrackRefVector selTracks=tagInfoIP.selectedTracks();
390	<	int n=selTracks.size();
391	<	cout << "Sel tracks: " << n << endl;
392	<	// false      cout << " Pt  \t d len \t jet dist \t p3d \t p2d\t ip3d \t ip2d " << endl;
393	<	GlobalPoint pv(tagInfoIP.primaryVertex()->position().x(),tagInfoIP.primaryVertex()->position().y(),tagInfoIP.primaryVertex()->position().z());
394	<	cout << pv << " vs " << tagInfoIP.primaryVertex()->position()   << endl;
395	<	for(int j=0;j< n;j++)
396	<	{
397	<	TrackIPTagInfo::TrackIPData data = tagInfoIP.impactParameterData()[j];
398	<	cout << selTracks[j]->pt() << "\t";
399	<	cout << tagInfoIP.probabilities(0)[j] << "\t";
400	<	cout << tagInfoIP.probabilities(1)[j] << "\t";
401	<	cout << data.ip3d.value() << "\t";
402	<	cout << data.ip3d.significance() << "\t";
403	<	cout << data.distanceToJetAxis.value() << "\t";
404	<	cout << data.distanceToJetAxis.significance() << "\t";
405	<	cout << data.distanceToGhostTrack.value() << "\t";
364	<	cout << data.distanceToGhostTrack.significance() << "\t";
365	<	cout << data.closestToJetAxis << "\t";
366	<	cout << (data.closestToJetAxis - pv).mag() << "\t";
367	<	cout << data.closestToGhostTrack << "\t";
368	<	cout << (data.closestToGhostTrack - pv).mag() << "\t";
369	<	cout << data.ip2d.value() << "\t";
370	<	cout << data.ip2d.significance() <<  endl;
371	<	}
372	<	*/
385	>	TrackRefVector selTracks=tagInfoIP.selectedTracks();
386	>
387	>	GlobalPoint pv(tagInfoIP.primaryVertex()->position().x(),tagInfoIP.primaryVertex()->position().y(),tagInfoIP.primaryVertex()->position().z());
388	>
389	>	for(int it=0;it<jets_.nselIPtrk[jets_.nref] ;it++)
390	>	{
391	>	jets_.ipJetIndex[jets_.nIP + it]= jets_.nref;
392	>	TrackIPTagInfo::TrackIPData data = tagInfoIP.impactParameterData()[it];
393	>	jets_.ipPt[jets_.nIP + it] = selTracks[it]->pt();
394	>	jets_.ipProb0[jets_.nIP + it] = tagInfoIP.probabilities(0)[it];
395	>	jets_.ipProb1[jets_.nIP + it] = tagInfoIP.probabilities(1)[it];
396	>	jets_.ip2d[jets_.nIP + it] = data.ip2d.value();
397	>	jets_.ip2dSig[jets_.nIP + it] = data.ip2d.significance();
398	>	jets_.ip3d[jets_.nIP + it] = data.ip3d.value();
399	>	jets_.ip3dSig[jets_.nIP + it] = data.ip3d.significance();
400	>	jets_.ipDist2Jet[jets_.nIP + it] = data.distanceToJetAxis.value();
401	>	jets_.ipDist2JetSig[jets_.nIP + it] = data.distanceToJetAxis.significance();
402	>	jets_.ipClosest2Jet[jets_.nIP + it] = (data.closestToJetAxis - pv).mag();  //decay length
403	>	}
404	>
405	>	jets_.nIP += jets_.nselIPtrk[jets_.nref];
406
407	+	}
408	+
409		const reco::PFCandidateCollection *pfCandidateColl = &(*pfCandidates);
410		int pfMuonIndex = getPFJetMuon(jet, pfCandidateColl);
411		if(pfMuonIndex >=0){
#	Line 383 | Line 418 | HiInclusiveJetAnalyzer::analyze(const Ev
418		jets_.muptrel[jets_.nref] =  getPtRel(muon, jet);
419		jets_.muchg[jets_.nref]   =  muon.charge();
420		}
386	–	else{
387	–	jets_.mupt[jets_.nref]    =  0.0;
388	–	jets_.mueta[jets_.nref]   =  0.0;
389	–	jets_.muphi[jets_.nref]   =  0.0;
390	–	jets_.mue[jets_.nref]     =  0.0;
391	–	jets_.mudr[jets_.nref]    =  9.9;
392	–	jets_.muptrel[jets_.nref] =  0.0;
393	–	jets_.muchg[jets_.nref]   = 0;
394	–	}
421		}
422
423		jets_.jtpt[jets_.nref] = jet.pt();
#	Line 401 | Line 427 | HiInclusiveJetAnalyzer::analyze(const Ev
427		jets_.jtpu[jets_.nref] = jet.pileup();
428
429		if(isMC_ && usePat_){
430	<	jets_.refparton_flavorForB[jets_.nref] = (*patjets)[j].partonFlavour();
431	<	const reco::GenJet* genjet = (*patjets)[j].genJet();
430	>
431	>	const reco::GenJet * genjet = (*patjets)[j].genJet();
432
433		if(genjet){
434		jets_.refpt[jets_.nref] = genjet->pt();
#	Line 420 | Line 446 | HiInclusiveJetAnalyzer::analyze(const Ev
446		jets_.refdrjt[jets_.nref] = -999.;
447		}
448
449	<	// matched partons
450	<	const reco::GenParticle * parton = (*patjets)[j].genParton();
451	<	if(parton){
452	<	jets_.refparton_pt[jets_.nref] = parton->pt();
453	<	jets_.refparton_flavor[jets_.nref] = parton->pdgId();
449	>	jets_.refparton_flavorForB[jets_.nref] = (*patjets)[j].partonFlavour();
450	>
451	>	// matched partons
452	>	const reco::GenParticle & parton = *(*patjets)[j].genParton();
453	>
454	>	if((*patjets)[j].genParton()){
455	>	jets_.refparton_pt[jets_.nref] = parton.pt();
456	>	jets_.refparton_flavor[jets_.nref] = parton.pdgId();
457	>
458	>	if(saveBfragments_ && abs(jets_.refparton_flavorForB[jets_.nref])==5){
459	>
460	>	usedStringPts.clear();
461	>
462	>	// uncomment this if you want to know the ugly truth about parton matching -matt
463	>	//if(jet.pt() > 50 &&abs(parton.pdgId())!=5 && parton.pdgId()!=21)
464	>	// cout<<" Identified as a b, but doesn't match b or gluon, id = "<<parton.pdgId()<<endl;
465	>
466	>	jets_.bJetIndex[jets_.bMult] = jets_.nref;
467	>	jets_.bStatus[jets_.bMult] = parton.status();
468	>	jets_.bVx[jets_.bMult] = parton.vx();
469	>	jets_.bVy[jets_.bMult] = parton.vy();
470	>	jets_.bVz[jets_.bMult] = parton.vz();
471	>	jets_.bPt[jets_.bMult] = parton.pt();
472	>	jets_.bEta[jets_.bMult] = parton.eta();
473	>	jets_.bPhi[jets_.bMult] = parton.phi();
474	>	jets_.bPdg[jets_.bMult] = parton.pdgId();
475	>	jets_.bChg[jets_.bMult] = parton.charge();
476	>	jets_.bMult++;
477	>	saveDaughters(parton);
478	>	}
479	>
480	>
481		} else {
482	<	jets_.refparton_pt[jets_.nref] = -999;
483	<	jets_.refparton_flavor[jets_.nref] = -999;
482	>	jets_.refparton_pt[jets_.nref] = -999;
483	>	jets_.refparton_flavor[jets_.nref] = -999;
484		}
485	+
486	+
487		}
488
489		jets_.nref++;
#	Line 439 | Line 494 | HiInclusiveJetAnalyzer::analyze(const Ev
494
495		if(isMC_){
496
497	+	edm::Handle<HepMCProduct> hepMCProduct;
498	+	iEvent.getByLabel(eventInfoTag_,hepMCProduct);
499	+	const HepMC::GenEvent* MCEvt = hepMCProduct->GetEvent();
500	+	std::pair<HepMC::GenParticle*,HepMC::GenParticle*> beamParticles = MCEvt->beam_particles();
501	+	jets_.beamId1 = beamParticles.first->pdg_id();
502	+	jets_.beamId2 = beamParticles.second->pdg_id();
503	+
504		edm::Handle<GenEventInfoProduct> hEventInfo;
505		iEvent.getByLabel(eventInfoTag_,hEventInfo);
506		//jets_.pthat = hEventInfo->binningValues()[0];
#	Line 463 | Line 525 | HiInclusiveJetAnalyzer::analyze(const Ev
525		jets_.genphi[jets_.ngen] = genjet.phi();
526		jets_.geny[jets_.ngen] = genjet.eta();
527
528	+	if(doSubEvent_){
529	+	const GenParticle* gencon = genjet.getGenConstituent(0);
530	+	jets_.gensubid[jets_.ngen] = gencon->collisionId();
531	+	}
532
533		// find matching patJet if there is one
534
#	Line 493 | Line 559 | HiInclusiveJetAnalyzer::analyze(const Ev
559
560		}
561		t->Fill();
562	+	memset(&jets_,0,sizeof jets_);
563		}
564
565
#	Line 643 | Line 710 | HiInclusiveJetAnalyzer::getPtRel(const r
710
711		return (pTrel2 > 0) ? std::sqrt(pTrel2) : 0.0;
712		}
713	+
714	+	// Recursive function, but this version gets called only the first time
715	+	void
716	+	HiInclusiveJetAnalyzer::saveDaughters(const reco::GenParticle &gen){
717	+
718	+	for(unsigned i=0;i<gen.numberOfDaughters();i++){
719	+	const reco::Candidate & daughter = *gen.daughter(i);
720	+	double daughterPt = daughter.pt();
721	+	if(daughterPt<1.) continue;
722	+	double daughterEta = daughter.eta();
723	+	if(fabs(daughterEta)>3.) continue;
724	+	int daughterPdgId = daughter.pdgId();
725	+	int daughterStatus = daughter.status();
726	+	// Special case when b->b+string, both b and string contain all daughters, so only take the string
727	+	if(gen.pdgId()==daughterPdgId && gen.status()==3 && daughterStatus==2) continue;
728	+
729	+	// cheesy way of finding strings which were already used
730	+	if(daughter.pdgId()==92){
731	+	for(unsigned ist=0;ist<usedStringPts.size();ist++){
732	+	if(fabs(daughter.pt() - usedStringPts[ist]) < 0.0001) return;
733	+	}
734	+	usedStringPts.push_back(daughter.pt());
735	+	}
736	+	jets_.bJetIndex[jets_.bMult] = jets_.nref;
737	+	jets_.bStatus[jets_.bMult] = daughterStatus;
738	+	jets_.bVx[jets_.bMult] = daughter.vx();
739	+	jets_.bVy[jets_.bMult] = daughter.vy();
740	+	jets_.bVz[jets_.bMult] = daughter.vz();
741	+	jets_.bPt[jets_.bMult] = daughterPt;
742	+	jets_.bEta[jets_.bMult] = daughterEta;
743	+	jets_.bPhi[jets_.bMult] = daughter.phi();
744	+	jets_.bPdg[jets_.bMult] = daughterPdgId;
745	+	jets_.bChg[jets_.bMult] = daughter.charge();
746	+	jets_.bMult++;
747	+	saveDaughters(daughter);
748	+	}
749	+	}
750	+
751	+	// This version called for all subsequent calls
752	+	void
753	+	HiInclusiveJetAnalyzer::saveDaughters(const reco::Candidate &gen){
754	+
755	+	for(unsigned i=0;i<gen.numberOfDaughters();i++){
756	+	const reco::Candidate & daughter = *gen.daughter(i);
757	+	double daughterPt = daughter.pt();
758	+	if(daughterPt<1.) continue;
759	+	double daughterEta = daughter.eta();
760	+	if(fabs(daughterEta)>3.) continue;
761	+	int daughterPdgId = daughter.pdgId();
762	+	int daughterStatus = daughter.status();
763	+	// Special case when b->b+string, both b and string contain all daughters, so only take the string
764	+	if(gen.pdgId()==daughterPdgId && gen.status()==3 && daughterStatus==2) continue;
765	+
766	+	// cheesy way of finding strings which were already used
767	+	if(daughter.pdgId()==92){
768	+	for(unsigned ist=0;ist<usedStringPts.size();ist++){
769	+	if(fabs(daughter.pt() - usedStringPts[ist]) < 0.0001) return;
770	+	}
771	+	usedStringPts.push_back(daughter.pt());
772	+	}
773	+
774	+	jets_.bJetIndex[jets_.bMult] = jets_.nref;
775	+	jets_.bStatus[jets_.bMult] = daughterStatus;
776	+	jets_.bVx[jets_.bMult] = daughter.vx();
777	+	jets_.bVy[jets_.bMult] = daughter.vy();
778	+	jets_.bVz[jets_.bMult] = daughter.vz();
779	+	jets_.bPt[jets_.bMult] = daughterPt;
780	+	jets_.bEta[jets_.bMult] = daughterEta;
781	+	jets_.bPhi[jets_.bMult] = daughter.phi();
782	+	jets_.bPdg[jets_.bMult] = daughterPdgId;
783	+	jets_.bChg[jets_.bMult] = daughter.charge();
784	+	jets_.bMult++;
785	+	saveDaughters(daughter);
786	+	}
787	+	}
788
789		DEFINE_FWK_MODULE(HiInclusiveJetAnalyzer);

Diff Legend

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