ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/HbbAnalysis/plugins/HbbTreeMaker.cc

Comparing UserCode/HbbAnalysis/plugins/HbbTreeMaker.cc (file contents):
Revision 1.1 by amagnan, Thu Sep 17 19:39:51 2009 UTC vs.
Revision 1.5 by amagnan, Wed Feb 10 13:50:17 2010 UTC

#	Line 6 | Line 6
6		#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
7		#include "DataFormats/MuonReco/interface/Muon.h"
8		#include "DataFormats/MuonReco/interface/MuonFwd.h"
9	+	#include "DataFormats/MuonReco/interface/MuonSelectors.h"
10		#include "DataFormats/VertexReco/interface/Vertex.h"
11		#include "DataFormats/HLTReco/interface/TriggerEvent.h"
12		#include "DataFormats/TrackReco/interface/TrackFwd.h"
#	Line 27 | Line 28
28		#include "UserCode/HbbAnalysis/interface/Jet.hh"
29		#include "UserCode/HbbAnalysis/interface/Met.hh"
30		#include "UserCode/HbbAnalysis/interface/Trigger.hh"
31	+	#include "UserCode/HbbAnalysis/interface/Vertex.hh"
32
33		#include "UserCode/HbbAnalysis/plugins/HbbTreeMaker.hh"
34
#	Line 34 | Line 36 | using namespace HbbAnalysis;
36
37		HbbTreeMaker::HbbTreeMaker(const edm::ParameterSet & pset):
38		debug_(pset.getParameter<int>("DEBUG")),
39	+	processData_(false),
40		flavour_(pset.getParameter<unsigned int>("JetFlavour")),
41		doGen_(pset.getParameter<bool>("DOGEN")),
42		genParticleSrc_(pset.getParameter<edm::InputTag>("GenParticles")),
#	Line 67 | Line 70 | HbbTreeMaker::~HbbTreeMaker(){//destruct
70
71
72
73	<	void HbbTreeMaker::beginJob(const edm::EventSetup&){//beginJob
73	>	void HbbTreeMaker::beginJob(){//beginJob
74
75
76		edm::Service<TFileService> lFileService;
#	Line 81 | Line 84 | void HbbTreeMaker::beginJob(const edm::E
84		if (debug_) std::cout << "Initialising JetFlavour : " << std::endl;
85
86		lDir = lFileService->mkdir("JetFlavours");
84	–
87		jetFlav_.Initialise(lDir, debug_, flavour_);
88
89		}//beginJob
90
91		void HbbTreeMaker::endJob(){//endJob
92	<	jetFlav_.printSummary();
92	>	if (!processData_) jetFlav_.printSummary();
93
94		//tree_->Write();
95		//delete tree_;
#	Line 105 | Line 107 | void HbbTreeMaker::analyze(const edm::Ev
107
108		event_->Clear();
109		event_->event(aEvt.id().event());
110	+	processData_ = aEvt.isRealData();
111	+
112	+	event_->run(aEvt.run());
113	+	event_->lumiBlock(aEvt.luminosityBlock());
114
115		edm::Handle<reco::GenParticleCollection> lGenParticles;
116		try {
117		aEvt.getByLabel(genParticleSrc_,lGenParticles);
118		if (debug_) std::cout << "** ngenParticles = " << lGenParticles->size() << std::endl;
119		} catch(cms::Exception& e)  {
120	<	std::cout << "AMM: Collection genParticles not available! Exception : " << e.what() << ". " << std::endl;
120	>	if (!processData_) std::cout << "AMM: Collection genParticles not available! Exception : " << e.what() << ". " << std::endl;
121		}
122
123	<	if (doGen_) HbbParticles(lGenParticles,event_->particles());
123	>	if (doGen_ && !processData_) HbbParticles(lGenParticles,event_->particles());
124
125	<	unsigned int lNPartons = jetFlav_.fillPartons(lGenParticles);
125	>	unsigned int lNPartons = 0;
126	>	if (!processData_) lNPartons = jetFlav_.fillPartons(lGenParticles);
127
128	<	if (debug_) std::cout << "--- Number of partons = " << lNPartons << "." << std::endl;
128	>	if (debug_ && !processData_) std::cout << "--- Number of partons = " << lNPartons << "." << std::endl;
129
130
131		edm::Handle<std::vector<reco::Vertex> > lRecoVertices;
#	Line 132 | Line 139 | void HbbTreeMaker::analyze(const edm::Ev
139		std::cout << "AMM: Collection " << vertexSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
140		}
141
142	+	HbbVertices(lRecoVertices,event_->vertices());
143	+
144		edm::Handle<std::vector<pat::Electron> > lElectronCollection;
145
146		try {
#	Line 159 | Line 168 | void HbbTreeMaker::analyze(const edm::Ev
168		std::cout << "AMM: Collection " << muonSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
169		}
170
171	<	HbbMuons(lMuonCollection,event_->muons());
171	>	HbbMuons(lMuonCollection,lRecoVertices,event_->muons());
172
173
174	<	edm::Handle<std::vector<pat::Tau> > lTauCollection;
174	>	if (!( caloTauSrc_.label()=="" && caloTauSrc_.instance()=="" )) {
175	>	edm::Handle<std::vector<pat::Tau> > lTauCollection;
176
177	<	try {
178	<	aEvt.getByLabel(caloTauSrc_,lTauCollection);
179	<	if (!lTauCollection.isValid()){
180	<	edm::LogInfo("ERROR")<< "Error! Can't get caloTau by label. ";
181	<	}
182	<	if (debug_) std::cout << "** caloTaucollection = " << lTauCollection->size() << " elements." << std::endl;
183	<	} catch(cms::Exception& e)  {
184	<	std::cout << "AMM: Collection " << caloTauSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
185	<	}
177	>	try {
178	>	aEvt.getByLabel(caloTauSrc_,lTauCollection);
179	>	if (!lTauCollection.isValid()){
180	>	edm::LogInfo("ERROR")<< "Error! Can't get caloTau by label. ";
181	>	}
182	>	if (debug_) std::cout << "** caloTaucollection = " << lTauCollection->size() << " elements." << std::endl;
183	>	} catch(cms::Exception& e)  {
184	>	std::cout << "AMM: Collection " << caloTauSrc_  << " not available! Exception : " << e.what() << ". " << std::endl;
185	>	}
186
187	<	HbbTaus(lTauCollection,lRecoVertices,event_->caloTaus());
187	>	HbbTaus(lTauCollection,lRecoVertices,event_->caloTaus());
188	>	}
189
190		edm::Handle<std::vector<pat::Tau> > lPFTauCollection;
191
#	Line 298 | Line 309 | void HbbTreeMaker::analyze(const edm::Ev
309
310
311		void HbbTreeMaker::HbbElectrons(const edm::Handle<std::vector<pat::Electron> > & aCol,
312	<	std::vector<HbbAnalysis::Electron> & aVec)
312	>	std::vector<HbbAnalysis::Electron> & aVec)
313		{//HbbElectrons
314
315		if (aCol.isValid()){
#	Line 312 | Line 323 | void HbbTreeMaker::HbbElectrons(const ed
323		//if (debug_ > 1) std::cout << "**** Ele #" << iEle << ", pT,eta,phi =  " << (*iter).pt() << " " << (*iter).eta() << " " << (*iter).phi() << std::endl;
324
325		HbbAnalysis::GenVars lGen;
326	<	if ((*iter).genLepton()){
326	>	if (!processData_ && (*iter).genLepton()){
327		lGen.valid = true;
328	+	lGen.E = (*iter).genLepton()->energy();
329		lGen.pT = (*iter).genLepton()->pt();
330		lGen.eta = (*iter).genLepton()->eta();
331		lGen.phi = (*iter).genLepton()->phi();
#	Line 327 | Line 339 | void HbbTreeMaker::HbbElectrons(const ed
339		}
340		else {
341		lGen.valid = false;
342	+	lGen.E = 0;
343		lGen.pT = 0;
344		lGen.eta = 0;
345		lGen.phi = 0;
#	Line 340 | Line 353 | void HbbTreeMaker::HbbElectrons(const ed
353		}
354
355		HbbAnalysis::BaseVars lReco;
356	+	lReco.E = (*iter).energy();
357		lReco.pT = (*iter).pt();
358		lReco.eta = (*iter).eta();
359		lReco.phi = (*iter).phi();
#	Line 379 | Line 393 | void HbbTreeMaker::HbbElectrons(const ed
393
394
395		void HbbTreeMaker::HbbMuons(const edm::Handle<std::vector<pat::Muon> > & aCol,
396	<	std::vector<HbbAnalysis::Muon> & aVec)
396	>	const edm::Handle<std::vector<reco::Vertex> > & aRecoVertices,
397	>	std::vector<HbbAnalysis::Muon> & aVec)
398		{//HbbMuons
399
400		if (aCol.isValid()){
#	Line 393 | Line 408 | void HbbTreeMaker::HbbMuons(const edm::H
408		const reco::Muon* recoMuon = dynamic_cast<const reco::Muon*>((*iter).originalObject());
409
410		HbbAnalysis::GenVars lGen;
411	<	if ((*iter).genLepton()){
411	>	if (!processData_ && (*iter).genLepton()){
412		lGen.valid = true;
413	+	lGen.E = (*iter).genLepton()->energy();
414		lGen.pT = (*iter).genLepton()->pt();
415		lGen.eta = (*iter).genLepton()->eta();
416		lGen.phi = (*iter).genLepton()->phi();
#	Line 408 | Line 424 | void HbbTreeMaker::HbbMuons(const edm::H
424		}
425		else {
426		lGen.valid = false;
427	+	lGen.E = 0;
428		lGen.pT = 0;
429		lGen.eta = 0;
430		lGen.phi = 0;
#	Line 421 | Line 438 | void HbbTreeMaker::HbbMuons(const edm::H
438		}
439
440		HbbAnalysis::BaseVars lReco;
441	+	lReco.E = (*iter).energy();
442		lReco.pT = (*iter).pt();
443		lReco.eta = (*iter).eta();
444		lReco.phi = (*iter).phi();
#	Line 429 | Line 447 | void HbbTreeMaker::HbbMuons(const edm::H
447		lReco.vy = (*iter).vy();
448		lReco.vz = (*iter).vz();
449
450	+	HbbAnalysis::MuTrkVars lTrk;
451	+
452	+	reco::TrackRef lTrackerTrk = (*iter).innerTrack();
453	+	if ( lTrackerTrk.isAvailable() && lTrackerTrk.isNonnull() ) {
454	+	if ( aRecoVertices->size() >= 1 ) {
455	+	const reco::Vertex& thePrimaryEventVertex = (*aRecoVertices->begin());
456	+	lTrk.IPd0 = -lTrackerTrk->dxy(thePrimaryEventVertex.position());
457	+	lTrk.IPdz = lTrackerTrk->dz(thePrimaryEventVertex.position());
458	+	}
459	+	else {
460	+	lTrk.IPd0 = 0;
461	+	lTrk.IPdz = 0;
462	+	}
463	+
464	+	lTrk.nHits =  lTrackerTrk->numberOfValidHits();
465	+	}
466	+	else {
467	+	lTrk.IPd0 = 0;
468	+	lTrk.IPdz = 0;
469	+	lTrk.nHits = 0;
470	+	}
471	+
472		HbbAnalysis::MuIsoVars lIsoR03;
473		lIsoR03.sumPt = recoMuon->isolationR03().sumPt;
474		lIsoR03.emEt = recoMuon->isolationR03().emEt;
#	Line 450 | Line 490 | void HbbTreeMaker::HbbMuons(const edm::H
490		else if (recoMuon->isCaloMuon()) lID.type = 4;
491		else lID.type = 0;
492
493	<	if (recoMuon->isGood(reco::Muon::AllGlobalMuons)) lID.ids.push_back(1);
494	<	if (recoMuon->isGood(reco::Muon::AllStandAloneMuons)) lID.ids.push_back(2);
495	<	if (recoMuon->isGood(reco::Muon::AllTrackerMuons)) lID.ids.push_back(3);
496	<	if (recoMuon->isGood(reco::Muon::TrackerMuonArbitrated)) lID.ids.push_back(4);
497	<	if (recoMuon->isGood(reco::Muon::AllArbitrated)) lID.ids.push_back(5);
498	<	if (recoMuon->isGood(reco::Muon::GlobalMuonPromptTight)) lID.ids.push_back(6);
499	<	if (recoMuon->isGood(reco::Muon::TMLastStationLoose)) lID.ids.push_back(7);
500	<	if (recoMuon->isGood(reco::Muon::TMLastStationTight)) lID.ids.push_back(8);
501	<	if (recoMuon->isGood(reco::Muon::TM2DCompatibilityLoose)) lID.ids.push_back(9);
502	<	if (recoMuon->isGood(reco::Muon::TM2DCompatibilityTight)) lID.ids.push_back(10);
503	<	if (recoMuon->isGood(reco::Muon::TMOneStationLoose)) lID.ids.push_back(11);
504	<	if (recoMuon->isGood(reco::Muon::TMOneStationTight)) lID.ids.push_back(12);
505	<	if (recoMuon->isGood(reco::Muon::TMLastStationOptimizedLowPtLoose)) lID.ids.push_back(13);
506	<	if (recoMuon->isGood(reco::Muon::TMLastStationOptimizedLowPtTight)) lID.ids.push_back(14);
493	>	if (muon::isGoodMuon(*recoMuon,muon::AllGlobalMuons)) lID.ids.push_back(1);
494	>	if (muon::isGoodMuon(*recoMuon,muon::AllStandAloneMuons)) lID.ids.push_back(2);
495	>	if (muon::isGoodMuon(*recoMuon,muon::AllTrackerMuons)) lID.ids.push_back(3);
496	>	if (muon::isGoodMuon(*recoMuon,muon::TrackerMuonArbitrated)) lID.ids.push_back(4);
497	>	if (muon::isGoodMuon(*recoMuon,muon::AllArbitrated)) lID.ids.push_back(5);
498	>	if (muon::isGoodMuon(*recoMuon,muon::GlobalMuonPromptTight)) lID.ids.push_back(6);
499	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationLoose)) lID.ids.push_back(7);
500	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationTight)) lID.ids.push_back(8);
501	>	if (muon::isGoodMuon(*recoMuon,muon::TM2DCompatibilityLoose)) lID.ids.push_back(9);
502	>	if (muon::isGoodMuon(*recoMuon,muon::TM2DCompatibilityTight)) lID.ids.push_back(10);
503	>	if (muon::isGoodMuon(*recoMuon,muon::TMOneStationLoose)) lID.ids.push_back(11);
504	>	if (muon::isGoodMuon(*recoMuon,muon::TMOneStationTight)) lID.ids.push_back(12);
505	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationOptimizedLowPtLoose)) lID.ids.push_back(13);
506	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationOptimizedLowPtTight)) lID.ids.push_back(14);
507	>	if (muon::isGoodMuon(*recoMuon,muon::GMTkChiCompatibility)) lID.ids.push_back(15);
508	>	if (muon::isGoodMuon(*recoMuon,muon::GMStaChiCompatibility)) lID.ids.push_back(16);
509	>	if (muon::isGoodMuon(*recoMuon,muon::GMTkKinkTight)) lID.ids.push_back(17);
510	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationAngLoose)) lID.ids.push_back(18);
511	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationAngTight)) lID.ids.push_back(19);
512	>	if (muon::isGoodMuon(*recoMuon,muon::TMOneStationAngLoose)) lID.ids.push_back(20);
513	>	if (muon::isGoodMuon(*recoMuon,muon::TMOneStationAngTight)) lID.ids.push_back(21);
514	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationOptimizedBarrelLowPtLoose)) lID.ids.push_back(22);
515	>	if (muon::isGoodMuon(*recoMuon,muon::TMLastStationOptimizedBarrelLowPtTight)) lID.ids.push_back(23);
516
517		lID.caloCompat = recoMuon->caloCompatibility();
518	<	lID.segCompat = recoMuon->segmentCompatibility();
518	>	lID.segCompat = muon::segmentCompatibility(*recoMuon);
519		lID.nChambers = recoMuon->numberOfChambers();
520		lID.nMatchesLoose = recoMuon->numberOfMatches(reco::Muon::NoArbitration);
521		lID.nMatchesMedium = recoMuon->numberOfMatches(reco::Muon::SegmentArbitration);
522		lID.nMatchesTight = recoMuon->numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
523
524	<	HbbAnalysis::Muon lObj(lGen,lReco,lIsoR03,lIsoR05,lID);
524	>	HbbAnalysis::Muon lObj(lGen,lReco,lTrk,lIsoR03,lIsoR05,lID);
525		aVec.push_back(lObj);
526		iEle++;
527		}
#	Line 482 | Line 531 | void HbbTreeMaker::HbbMuons(const edm::H
531		}//HbbMuons
532
533		void HbbTreeMaker::HbbTaus(const edm::Handle<std::vector<pat::Tau> > & aCol,
534	<	const edm::Handle<std::vector<reco::Vertex> > & aRecoVertices,
535	<	std::vector<HbbAnalysis::Tau> & aVec)
534	>	const edm::Handle<std::vector<reco::Vertex> > & aRecoVertices,
535	>	std::vector<HbbAnalysis::Tau> & aVec)
536		{//HbbTaus
537
538		if (aCol.isValid()){
#	Line 497 | Line 546 | void HbbTreeMaker::HbbTaus(const edm::Ha
546		//if (debug_ > 1) std::cout << "**** Ele #" << iEle << ", pT,eta,phi =  " << (*iter).pt() << " " << (*iter).eta() << " " << (*iter).phi() << std::endl;
547
548		HbbAnalysis::GenVars lGen;
549	<	if ((*iter).genLepton()){
549	>	if (!processData_ && (*iter).genLepton()){
550		lGen.valid = true;
551	+	lGen.E = (*iter).genLepton()->energy();
552		lGen.pT = (*iter).genLepton()->pt();
553		lGen.eta = (*iter).genLepton()->eta();
554		lGen.phi = (*iter).genLepton()->phi();
#	Line 512 | Line 562 | void HbbTreeMaker::HbbTaus(const edm::Ha
562		}
563		else {
564		lGen.valid = false;
565	+	lGen.E = 0;
566		lGen.pT = 0;
567		lGen.eta = 0;
568		lGen.phi = 0;
#	Line 526 | Line 577 | void HbbTreeMaker::HbbTaus(const edm::Ha
577
578
579		HbbAnalysis::GenVars lGenJet;
580	<	if ((*iter).genJet()){
580	>	if (!processData_ && (*iter).genJet()){
581		lGenJet.valid = true;
582	+	lGenJet.E = (*iter).genJet()->energy();
583		lGenJet.pT = (*iter).genJet()->pt();
584		lGenJet.eta = (*iter).genJet()->eta();
585		lGenJet.phi = (*iter).genJet()->phi();
#	Line 541 | Line 593 | void HbbTreeMaker::HbbTaus(const edm::Ha
593		}
594		else {
595		lGenJet.valid = false;
596	+	lGenJet.E = 0;
597		lGenJet.pT = 0;
598		lGenJet.eta = 0;
599		lGenJet.phi = 0;
#	Line 554 | Line 607 | void HbbTreeMaker::HbbTaus(const edm::Ha
607		}
608
609		HbbAnalysis::BaseVars lReco;
610	+	lReco.E = (*iter).energy();
611		lReco.pT = (*iter).pt();
612		lReco.eta = (*iter).eta();
613		lReco.phi = (*iter).phi();
#	Line 641 | Line 695 | void HbbTreeMaker::HbbTaus(const edm::Ha
695		const std::vector<std::pair<std::string,float> > &  lIDs = (*iter).tauIDs();
696		bool lPrint = false;
697		//a few warning if additional discriminants are found:
698	<	if ((isPF && lIDs.size() != 7) ||
698	>	if ((isPF && lIDs.size() != 16) ||
699		(isCalo && lIDs.size() != 3))
700		lPrint = true;
701
702		if (lPrint) {
703	<	std::cout << "!!!!!!! Discriminants changed, please update histograms !!!!!!!" << std::endl;
703	>	std::cout << "!!!!!!! Discriminants changed, please update tree !!!!!!!" << std::endl;
704		std::cout << "--- isCaloTau = " << isCalo << ", isPFTau = " << isPF << std::endl;
705		std::cout << "------ ID names = " << std::endl;
706		}
707
708
655	–	HbbAnalysis::PFTauIDVars lpfId;
709		HbbAnalysis::CaloTauIDVars lcaloId;
710	+	lcaloId.byIsolation = 0;
711	+	lcaloId.byLeadingTrackFinding = 0;
712	+	lcaloId.byLeadingTrackPtCut = 0;
713	+
714	+	HbbAnalysis::PFTauIDVars lpfId;
715	+	lpfId.byLeadingTrackFinding = 0;
716	+	lpfId.byLeadingTrackPtCut = 0;
717	+	lpfId.byTrackIsolation = 0;
718	+	lpfId.byECALIsolation = 0;
719	+	lpfId.byIsolation = 0;
720	+	lpfId.againstElectron = 0;
721	+	lpfId.againstMuon = 0;
722	+	lpfId.byIsolationUsingLeadingPion = 0;
723	+	lpfId.byTaNC = 0;
724	+	lpfId.byTaNCfrHalfPercent = 0;
725	+	lpfId.byTaNCfrOnePercent = 0;
726	+	lpfId.byTaNCfrQuarterPercent = 0;
727	+	lpfId.byTaNCfrTenthPercent = 0;
728	+	lpfId.ecalIsolationUsingLeadingPion = 0;
729	+	lpfId.leadingPionPtCut = 0;
730	+	lpfId.trackIsolationUsingLeadingPion = 0;
731	+
732	+
733
734		for (unsigned int id(0); id<lIDs.size(); id++){
735
#	Line 666 | Line 742 | void HbbTreeMaker::HbbTaus(const edm::Ha
742		if (isPF) {
743		if (lName.find("leadingTrackFinding") != lName.npos) lpfId.byLeadingTrackFinding = lDiscri;
744		if (lName.find("leadingTrackPtCut") != lName.npos) lpfId.byLeadingTrackPtCut = lDiscri;
745	<	if (lName.find("trackIsolation") != lName.npos) lpfId.byTrackIsolation = lDiscri;
746	<	if (lName.find("ecalIsolation") != lName.npos) lpfId.byECALIsolation = lDiscri;
747	<	if (lName.find("byIsolation") != lName.npos) lpfId.byIsolation = lDiscri;
745	>	if (lName.find("trackIsolationUsingLeadingPion") != lName.npos) lpfId.trackIsolationUsingLeadingPion = lDiscri;
746	>	if (lName.find("trackIsolation") != lName.npos &&
747	>	lName.find("trackIsolationUsingLeadingPion") == lName.npos) lpfId.byTrackIsolation = lDiscri;
748	>	if (lName.find("ecalIsolationUsingLeadingPion") != lName.npos) lpfId.ecalIsolationUsingLeadingPion = lDiscri;
749	>	if (lName.find("ecalIsolation") != lName.npos &&
750	>	lName.find("ecalIsolationUsingLeadingPion") == lName.npos) lpfId.byECALIsolation = lDiscri;
751	>	if (lName.find("byIsolationUsingLeadingPion") != lName.npos) lpfId.byIsolationUsingLeadingPion = lDiscri;
752	>	if (lName.find("byIsolation") != lName.npos &&
753	>	lName.find("byIsolationUsingLeadingPion") == lName.npos) lpfId.byIsolation = lDiscri;
754		if (lName.find("againstElectron") != lName.npos) lpfId.againstElectron = lDiscri;
755		if (lName.find("againstMuon") != lName.npos) lpfId.againstMuon = lDiscri;
756	+	if (lName.find("byTaNCfrHalfPercent") != lName.npos) lpfId.byTaNCfrHalfPercent = lDiscri;
757	+	if (lName.find("byTaNCfrOnePercent") != lName.npos) lpfId.byTaNCfrOnePercent = lDiscri;
758	+	if (lName.find("byTaNCfrQuarterPercent") != lName.npos) lpfId.byTaNCfrQuarterPercent = lDiscri;
759	+	if (lName.find("byTaNCfrTenthPercent") != lName.npos) lpfId.byTaNCfrTenthPercent = lDiscri;
760	+	if (lName.find("byTaNC") != lName.npos &&
761	+	lName.find("byTaNCfr") == lName.npos) lpfId.byTaNC = lDiscri;
762	+	if (lName.find("leadingPionPtCut") != lName.npos) lpfId.leadingPionPtCut = lDiscri;
763		}
764		if (isCalo){
765		if (lName.find("byIsolation") != lName.npos) lcaloId.byIsolation = lDiscri;
#	Line 719 | Line 808 | void HbbTreeMaker::HbbTaus(const edm::Ha
808		HbbAnalysis::PFTauCandVars lNeutr;
809		lNeutr.nSigCands = (*iter).signalPFNeutrHadrCands().size();
810		lNeutr.nIsoCands = (*iter).isolationPFNeutrHadrCands().size();
811	<	lNeutr.isolationPtSum = 0;
811	>	lNeutr.isolationPtSum = (*iter).neutralHadronIso();
812
813		HbbAnalysis::PFTauCandVars lGamma;
814		lGamma.nSigCands = (*iter).signalPFGammaCands().size();
#	Line 773 | Line 862 | void HbbTreeMaker::HbbJets(const edm::Ha
862		//if (debug_ > 1) std::cout << "**** Ele #" << iEle << ", pT,eta,phi =  " << (*iter).pt() << " " << (*iter).eta() << " " << (*iter).phi() << std::endl;
863
864		HbbAnalysis::GenVars lGen;
865	<	if ((*iter).genParton()){
865	>	if (!processData_ && (*iter).genParton()){
866		lGen.valid = true;
867	+	lGen.E = (*iter).genParton()->energy();
868		lGen.pT = (*iter).genParton()->pt();
869		lGen.eta = (*iter).genParton()->eta();
870		lGen.phi = (*iter).genParton()->phi();
#	Line 788 | Line 878 | void HbbTreeMaker::HbbJets(const edm::Ha
878		}
879		else {
880		lGen.valid = false;
881	+	lGen.E = 0;
882		lGen.pT = 0;
883		lGen.eta = 0;
884		lGen.phi = 0;
#	Line 802 | Line 893 | void HbbTreeMaker::HbbJets(const edm::Ha
893
894
895		HbbAnalysis::GenVars lGenJet;
896	<	if ((*iter).genJet()){
896	>	if (!processData_ && (*iter).genJet()){
897		lGenJet.valid = true;
898	+	lGenJet.E = (*iter).genJet()->energy();
899		lGenJet.pT = (*iter).genJet()->pt();
900		lGenJet.eta = (*iter).genJet()->eta();
901		lGenJet.phi = (*iter).genJet()->phi();
#	Line 817 | Line 909 | void HbbTreeMaker::HbbJets(const edm::Ha
909		}
910		else {
911		lGenJet.valid = false;
912	+	lGenJet.E = 0;
913		lGenJet.pT = 0;
914		lGenJet.eta = 0;
915		lGenJet.phi = 0;
#	Line 830 | Line 923 | void HbbTreeMaker::HbbJets(const edm::Ha
923		}
924
925		HbbAnalysis::BaseVars lReco;
926	+	lReco.E = (*iter).energy();
927		lReco.pT = (*iter).pt();
928		lReco.eta = (*iter).eta();
929		lReco.phi = (*iter).phi();
#	Line 839 | Line 933 | void HbbTreeMaker::HbbJets(const edm::Ha
933		lReco.vz = (*iter).vz();
934
935		unsigned int lFlav = 0;
936	<	if (aJetFlav.nPartons()) {
936	>	if (!processData_ && aJetFlav.nPartons()) {
937		lFlav = aJetFlav.partonMatchingGenJet((*iter),aGenParticles,0.4).second;
938		}
939
#	Line 848 | Line 942 | void HbbTreeMaker::HbbJets(const edm::Ha
942		lCommon.partonFlavour = (*iter).partonFlavour();
943		lCommon.nAssociatedTracks = ((*iter).associatedTracks()).size();
944		lCommon.rawpT = (*iter).pt();
945	<	if ((*iter).hasJetCorrFactors())
946	<	lCommon.rawpT = (*iter).pt()/((*iter).jetCorrFactors().scaleDefault());
945	>	if ((*iter).hasCorrFactors())
946	>	lCommon.rawpT = (*iter).pt()/((*iter).corrFactor((*iter).corrStep()));
947		//lCommon.rawEta = (*iter).;
948		//lCommon.rawPhi = (*iter).;
949		//    p_hasJetCorrFactors->Fill(aJet.hasJetCorrFactors());
#	Line 861 | Line 955 | void HbbTreeMaker::HbbJets(const edm::Ha
955		lBtag.bProba = (*iter).bDiscriminator("jetBProbabilityBJetTags");
956		lBtag.probability = (*iter).bDiscriminator("jetProbabilityBJetTags");
957		lBtag.sSV = (*iter).bDiscriminator("simpleSecondaryVertexBJetTags");
958	<	lBtag.softElectron = (*iter).bDiscriminator("softElectronBJetTags");
958	>	lBtag.softElectronByPt = (*iter).bDiscriminator("softElectronByPtBJetTags");
959	>	lBtag.softElectronByIP3d = (*iter).bDiscriminator("softElectronByIP3dBJetTags");
960		lBtag.softMuon = (*iter).bDiscriminator("softMuonBJetTags");
961	<	lBtag.softMuonNoIP = (*iter).bDiscriminator("softMuonNoIPBJetTags");
961	>	lBtag.softMuonByPt = (*iter).bDiscriminator("softMuonByPtBJetTags");
962	>	lBtag.softMuonByIP3d = (*iter).bDiscriminator("softMuonByIP3dBJetTags");
963		lBtag.tCHE = (*iter).bDiscriminator("trackCountingHighEffBJetTags");
964		lBtag.tCHP = (*iter).bDiscriminator("trackCountingHighPurBJetTags");
965	<
965	>
966	>
967		bool isCalo = (*iter).isCaloJet();
968		bool isPF = (*iter).isPFJet();
969
970		assert (isCalo == !isPF);
971		if (isCalo) {
972	+	HbbAnalysis::JetIDVars lId;
973	+	lId.fHPD = (*iter).jetID().fHPD;
974	+	lId.fRBX = (*iter).jetID().fRBX;
975	+	lId.n90Hits = (*iter).jetID().n90Hits;
976	+
977		HbbAnalysis::CaloJetVars lCalo;
978		lCalo.maxEInEmTowers = (*iter).maxEInEmTowers();
979		lCalo.maxEInHadTowers = (*iter).maxEInHadTowers();
#	Line 888 | Line 990 | void HbbTreeMaker::HbbJets(const edm::Ha
990		lCalo.n90 = (*iter).n90();
991		lCalo.n60 = (*iter).n60();
992
993	<	HbbAnalysis::Jet lObj(lGen,lGenJet,lReco,lCommon,lCalo,lBtag);
993	>	HbbAnalysis::Jet lObj(lGen,lGenJet,lReco,lCommon,lCalo,lBtag,lId);
994		aVec.push_back(lObj);
995
996		}
#	Line 914 | Line 1016 | void HbbTreeMaker::HbbJets(const edm::Ha
1016
1017		}
1018
1019	+
1020	+
1021		iEle++;
1022		}//loop on element
1023		}//non empty
#	Line 939 | Line 1043 | void HbbTreeMaker::HbbMet(const edm::Han
1043
1044		const reco::GenMET *lGenMET = lMet.genMET();
1045
1046	<	if (lGenMET){
1046	>	if (!processData_ && lGenMET){
1047		lGen.mET = lGenMET->pt();
1048		lGen.mEx = lGenMET->px();
1049		lGen.mEy = lGenMET->py();
#	Line 999 | Line 1103 | void HbbTreeMaker::HbbParticles(const ed
1103
1104		HbbAnalysis::MCVars lMC;
1105		lMC.index = mccount;
1106	+	lMC.E = p.energy();
1107		lMC.pT = p.pt();
1108		lMC.eta = p.eta();
1109		lMC.phi = p.phi();
#	Line 1050 | Line 1155 | void HbbTreeMaker::HbbParticles(const ed
1155
1156
1157		}//genparticles
1158	+
1159	+
1160	+
1161	+
1162	+
1163	+	void HbbTreeMaker::HbbVertices(const edm::Handle<std::vector<reco::Vertex> > & aCol,
1164	+	std::vector<HbbAnalysis::Vertex> & aVec)
1165	+	{
1166	+
1167	+	for (std::vector<reco::Vertex>::const_iterator iter = aCol->begin();
1168	+	iter != aCol->end();
1169	+	iter++)
1170	+	{
1171	+
1172	+	if (!((*iter).isValid()) || (*iter).isFake()) continue;
1173	+
1174	+	HbbAnalysis::VertexVars lVtx;
1175	+
1176	+	if ((*iter).tracksSize() > 0) {
1177	+	for (std::vector<reco::TrackBaseRef>::const_iterator lTrk = (*iter).tracks_begin();
1178	+	lTrk != (*iter).tracks_end();
1179	+	lTrk++) {
1180	+	lVtx.trackWeights.push_back((*iter).trackWeight(*lTrk));
1181	+	}
1182	+	}
1183	+
1184	+	if (lVtx.trackWeights.size() != (*iter).tracksSize()) {
1185	+	std::cout<< " -- Problem with tracks, size is not as expected ! "
1186	+	<< std::endl
1187	+	<< " --- Size of recoVertex tracks = " << (*iter).tracksSize()
1188	+	<< std::endl
1189	+	<< " --- Size of trackWeights = " << lVtx.trackWeights.size()
1190	+	<< std::endl;
1191	+	}
1192	+
1193	+	lVtx.chi2 = (*iter).chi2();
1194	+	lVtx.ndof = (*iter).ndof();
1195	+	lVtx.x = (*iter).x();
1196	+	lVtx.y = (*iter).y();
1197	+	lVtx.z = (*iter).z();
1198	+	lVtx.xError = (*iter).xError();
1199	+	lVtx.yError = (*iter).yError();
1200	+	lVtx.zError = (*iter).zError();
1201	+	lVtx.cov01 = (*iter).covariance(0,1);
1202	+	lVtx.cov02 = (*iter).covariance(0,2);
1203	+	lVtx.cov12 = (*iter).covariance(1,2);
1204	+
1205	+	HbbAnalysis::Vertex lObj(lVtx);
1206	+	aVec.push_back(lObj);
1207	+	}
1208	+
1209	+	}

Diff Legend

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