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.17 by peiffer, Tue May 22 09:32:31 2012 UTC vs.
Revision 1.24 by peiffer, Wed Jun 5 14:13:58 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	+	doGenJets = iConfig.getParameter<bool>("doGenJets");
57	+	doJECUncertainty = iConfig.getParameter<bool>("doJECUncertainty");
58		doGenTopJets = iConfig.getParameter<bool>("doGenTopJets");
59		doPhotons = iConfig.getParameter<bool>("doPhotons");
60		doMET = iConfig.getParameter<bool>("doMET");
#	Line 59 | Line 64 | NtupleWriter::NtupleWriter(const edm::Pa
64		doPV = iConfig.getParameter<bool>("doPV");
65		doTopJets = iConfig.getParameter<bool>("doTopJets");
66		doTrigger = iConfig.getParameter<bool>("doTrigger");
67	<
67	>	SVComputer_  = iConfig.getUntrackedParameter<edm::InputTag>("svComputer",edm::InputTag("combinedSecondaryVertex"));
68	>	doTagInfos = iConfig.getUntrackedParameter<bool>("doTagInfos",false);
69		// initialization of tree variables
70
71		tr->Branch("run",&run);
72		tr->Branch("event",&event);
73		tr->Branch("luminosityBlock",&luminosityBlock);
74		tr->Branch("isRealData",&isRealData);
75	+	tr->Branch("rho",&rho);
76	+	rho_source = iConfig.getParameter<edm::InputTag>("rho_source");
77	+
78		//tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
79		if(doLumiInfo){
80		tr->Branch("intgRecLumi",&intgRecLumi);
#	Line 104 | Line 113 | NtupleWriter::NtupleWriter(const edm::Pa
113		tr->Branch( jet_sources[j].c_str(), "std::vector<Jet>", &jets[j]);
114		}
115		}
116	+	if(doGenJets){
117	+	genjet_sources = iConfig.getParameter<std::vector<std::string> >("genjet_sources");
118	+	genjet_ptmin = iConfig.getParameter<double> ("genjet_ptmin");
119	+	genjet_etamax = iConfig.getParameter<double> ("genjet_etamax");
120	+	for(size_t j=0; j< genjet_sources.size(); ++j){
121	+	tr->Branch( genjet_sources[j].c_str(), "std::vector<Particle>", &genjets[j]);
122	+	}
123	+	}
124		if(doTopJets){
125		topjet_sources = iConfig.getParameter<std::vector<std::string> >("topjet_sources");
126		topjet_ptmin = iConfig.getParameter<double> ("topjet_ptmin");
#	Line 139 | Line 156 | NtupleWriter::NtupleWriter(const edm::Pa
156		}
157		}
158		if(doGenInfo){
159	+	genparticle_source= iConfig.getParameter<edm::InputTag>("genparticle_source");
160		tr->Branch("genInfo","GenInfo",&genInfo);
161		tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
162		}
#	Line 181 | Line 199 | NtupleWriter::analyze(const edm::Event&
199		luminosityBlock = iEvent.luminosityBlock();
200		isRealData      = iEvent.isRealData();
201
202	+	edm::Handle<double> m_rho;
203	+	iEvent.getByLabel(rho_source,m_rho);
204	+	rho=*m_rho;
205	+
206		//    if(isRealData){
207		//      edm::Handle<bool> bool_handle;
208		//      iEvent.getByLabel(edm::InputTag("HBHENoiseFilterResultProducer","HBHENoiseFilterResult"),bool_handle);
#	Line 284 | Line 306 | NtupleWriter::analyze(const edm::Event&
306		}
307
308		edm::Handle<reco::GenParticleCollection> genPartColl;
309	<	iEvent.getByLabel(edm::InputTag("genParticles"), genPartColl);
309	>	iEvent.getByLabel(genparticle_source, genPartColl);
310		int index=-1;
311		for(reco::GenParticleCollection::const_iterator iter = genPartColl->begin(); iter != genPartColl->end(); ++ iter){
312		index++;
#	Line 323 | Line 345 | NtupleWriter::analyze(const edm::Event&
345		// ------------- electrons -------------
346		if(doElectrons){
347
348	<	edm::Handle<reco::ConversionCollection> hConversions;
349	<	iEvent.getByLabel("allConversions", hConversions);
348	>	//      edm::Handle<reco::ConversionCollection> hConversions;
349	>	//      iEvent.getByLabel("allConversions", hConversions);
350
351	<	edm::Handle<reco::BeamSpot> beamSpot;
352	<	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
353	<	const reco::BeamSpot & bsp = *beamSpot;
351	>	//      edm::Handle<reco::BeamSpot> beamSpot;
352	>	//      iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
353	>	//      const reco::BeamSpot & bsp = *beamSpot;
354
355		for(size_t j=0; j< electron_sources.size(); ++j){
356		eles[j].clear();
#	Line 364 | Line 386 | NtupleWriter::analyze(const edm::Event&
386		ele.set_gsfTrack_vx( pat_ele.gsfTrack()->vx());
387		ele.set_gsfTrack_vy( pat_ele.gsfTrack()->vy());
388		ele.set_gsfTrack_vz( pat_ele.gsfTrack()->vz());
389	<	ele.set_passconversionveto(!ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()));
389	>	//ele.set_passconversionveto(!ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position()));
390	>	ele.set_passconversionveto(pat_ele.passConversionVeto());
391		ele.set_dEtaIn(pat_ele.deltaEtaSuperClusterTrackAtVtx());
392		ele.set_dPhiIn(pat_ele.deltaPhiSuperClusterTrackAtVtx());
393		ele.set_sigmaIEtaIEta(pat_ele.sigmaIetaIeta());
#	Line 372 | Line 395 | NtupleWriter::analyze(const edm::Event&
395		ele.set_fbrem(pat_ele.fbrem());
396		ele.set_EoverPIn(pat_ele.eSuperClusterOverP());
397		ele.set_EcalEnergy(pat_ele.ecalEnergy());
398	<	//ele.set_mvaTrigV0(pat_ele.electronID("mvaTrigV0"));
399	<	//ele.set_mvaNonTrigV0(pat_ele.electronID("mvaNonTrigV0"));
398	>	ele.set_mvaTrigV0(pat_ele.electronID("mvaTrigV0"));
399	>	ele.set_mvaNonTrigV0(pat_ele.electronID("mvaNonTrigV0"));
400	>	float AEff03 = 0.00;
401	>	if(isRealData){
402	>	AEff03 = ElectronEffectiveArea::GetElectronEffectiveArea(ElectronEffectiveArea::kEleGammaAndNeutralHadronIso03, pat_ele.superCluster()->eta(), ElectronEffectiveArea::kEleEAData2011);
403	>	}else{
404	>	AEff03 = ElectronEffectiveArea::GetElectronEffectiveArea(ElectronEffectiveArea::kEleGammaAndNeutralHadronIso03, pat_ele.superCluster()->eta(), ElectronEffectiveArea::kEleEAFall11MC);
405	>	}
406	>	ele.set_AEff(AEff03);
407
408		eles[j].push_back(ele);
409		}
#	Line 409 | Line 439 | NtupleWriter::analyze(const edm::Event&
439		mu.set_photonIso ( pat_mu.photonIso());
440		mu.set_puChargedHadronIso ( pat_mu.puChargedHadronIso());
441		mu.set_isGlobalMuon ( pat_mu.isGlobalMuon());
442	+	mu.set_isPFMuon ( pat_mu.isPFMuon());
443		mu.set_isStandAloneMuon ( pat_mu.isStandAloneMuon());
444		mu.set_isTrackerMuon ( pat_mu.isTrackerMuon());
445		mu.set_numberOfMatchedStations ( pat_mu.numberOfMatchedStations());
#	Line 420 | Line 451 | NtupleWriter::analyze(const edm::Event&
451		mu.set_globalTrack_d0Error ( globalTrack->d0Error());
452		mu.set_globalTrack_numberOfValidHits ( globalTrack->numberOfValidHits());
453		mu.set_globalTrack_numberOfLostHits ( globalTrack->numberOfLostHits());
454	+	mu.set_globalTrack_numberOfValidMuonHits(globalTrack->hitPattern().numberOfValidMuonHits() );
455		}
456		else{
457		mu.set_globalTrack_chi2 ( 0);
#	Line 507 | Line 539 | NtupleWriter::analyze(const edm::Event&
539		tau.set_againstMuonMedium ( pat_tau.tauID("againstMuonMedium")>0.5);
540		tau.set_againstMuonTight ( pat_tau.tauID("againstMuonTight")>0.5);
541
542	<	reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
543	<	if(!leadPFCand.isNull()){
544	<	tau.set_leadPFCand_px ( leadPFCand->px());
545	<	tau.set_leadPFCand_py ( leadPFCand->py());
546	<	tau.set_leadPFCand_pz ( leadPFCand->pz());
547	<	}
548	<	else{
549	<	tau.set_leadPFCand_px ( 0);
550	<	tau.set_leadPFCand_py ( 0);
551	<	tau.set_leadPFCand_pz ( 0);
552	<	}
542	>	//       reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
543	>	//       if(!leadPFCand.isNull()){
544	>	//         tau.set_leadPFCand_px ( leadPFCand->px());
545	>	//         tau.set_leadPFCand_py ( leadPFCand->py());
546	>	//         tau.set_leadPFCand_pz ( leadPFCand->pz());
547	>	//       }
548	>	//       else{
549	>	//         tau.set_leadPFCand_px ( 0);
550	>	//         tau.set_leadPFCand_py ( 0);
551	>	//         tau.set_leadPFCand_pz ( 0);
552	>	//       }
553		taus[j].push_back(tau);
554		}
555		}
#	Line 567 | Line 599 | NtupleWriter::analyze(const edm::Event&
599		jet.set_electronMultiplicity (pat_jet.electronMultiplicity());
600		jet.set_photonMultiplicity (pat_jet.photonMultiplicity());
601		}
602	<
603	<	jecUnc->setJetEta(pat_jet.eta());
604	<	jecUnc->setJetPt(pat_jet.pt());
605	<	jet.set_JEC_uncertainty(jecUnc->getUncertainty(true));
602	>	if(doJECUncertainty){
603	>	jecUnc->setJetEta(pat_jet.eta());
604	>	jecUnc->setJetPt(pat_jet.pt());
605	>	jet.set_JEC_uncertainty(jecUnc->getUncertainty(true));
606	>	}
607		jet.set_JEC_factor_raw(pat_jet.jecFactor("Uncorrected"));
608	<
608	>
609		jet.set_btag_simpleSecondaryVertexHighEff(pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
610		jet.set_btag_simpleSecondaryVertexHighPur(pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
611		jet.set_btag_combinedSecondaryVertex(pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags"));
#	Line 580 | Line 613 | NtupleWriter::analyze(const edm::Event&
613		jet.set_btag_jetBProbability(pat_jet.bDiscriminator("jetBProbabilityBJetTags"));
614		jet.set_btag_jetProbability(pat_jet.bDiscriminator("jetProbabilityBJetTags"));
615
616	+
617		const reco::GenJet *genj = pat_jet.genJet();
618		if(genj){
619		jet.set_genjet_pt(genj->pt());
#	Line 599 | Line 633 | NtupleWriter::analyze(const edm::Event&
633		if(jet.genparticles_indices().size()!= jetgenps.size())
634		std::cout << "WARNING: Found only " << jet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this jet"<<std::endl;
635		}
636	+
637		}
638	+
639		jets[j].push_back(jet);
640		}
641		}
642		}
643
644	+	//-------------- gen jets -------------
645	+
646	+	if(doGenJets){
647	+	for(size_t j=0; j< genjet_sources.size(); ++j){
648	+
649	+	genjets[j].clear();
650	+
651	+	edm::Handle< std::vector<reco::GenJet> > genjet_handle;
652	+	iEvent.getByLabel(genjet_sources[j], genjet_handle);
653	+	const std::vector<reco::GenJet>& gen_jets = *(genjet_handle.product());
654	+
655	+	for (unsigned int i = 0; i < gen_jets.size(); ++i) {
656	+	pat::Jet gen_jet = gen_jets[i];
657	+	if(gen_jet.pt() < genjet_ptmin) continue;
658	+	if(fabs(gen_jet.eta()) > genjet_etamax) continue;
659	+
660	+	Particle jet;
661	+	jet.set_charge(gen_jet.charge());
662	+	jet.set_pt(gen_jet.pt());
663	+	jet.set_eta(gen_jet.eta());
664	+	jet.set_phi(gen_jet.phi());
665	+	jet.set_energy(gen_jet.energy());
666	+
667	+	genjets[j].push_back(jet);
668	+
669	+	}
670	+	}
671	+	}
672	+
673		// ------------- top jets -------------
674		if(doTopJets){
675		for(size_t j=0; j< topjet_sources.size(); ++j){
#	Line 643 | Line 708 | NtupleWriter::analyze(const edm::Event&
708		//       topjet.set_muonMultiplicity(pat_topjet.muonMultiplicity());
709		//       topjet.set_electronMultiplicity(pat_topjet.electronMultiplicity());
710		//       topjet.set_photonMultiplicity(pat_topjet.photonMultiplicity());
711	<
712	<	jecUnc->setJetEta(pat_topjet.eta());
713	<	jecUnc->setJetPt(pat_topjet.pt());
714	<	topjet.set_JEC_uncertainty( jecUnc->getUncertainty(true));
711	>	if(doJECUncertainty){
712	>	jecUnc->setJetEta(pat_topjet.eta());
713	>	jecUnc->setJetPt(pat_topjet.pt());
714	>	topjet.set_JEC_uncertainty( jecUnc->getUncertainty(true));
715	>	}
716		topjet.set_JEC_factor_raw( pat_topjet.jecFactor("Uncorrected"));
717
718		topjet.set_btag_simpleSecondaryVertexHighEff(pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
#	Line 656 | Line 722 | NtupleWriter::analyze(const edm::Event&
722		topjet.set_btag_jetBProbability(pat_topjet.bDiscriminator("jetBProbabilityBJetTags"));
723		topjet.set_btag_jetProbability(pat_topjet.bDiscriminator("jetProbabilityBJetTags"));
724
725	+	/*
726		const reco::GenJet *genj = pat_topjet.genJet();
727		if(genj){
728		topjet.set_genjet_pt ( genj->pt());
#	Line 676 | Line 743 | NtupleWriter::analyze(const edm::Event&
743		std::cout << "WARNING: Found only " << topjet.genparticles_indices().size() << " from " << jetgenps.size() << " gen particles of this topjet"<<std::endl;
744		}
745		}
746	+	*/
747
748		for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) {
749		Particle subjet_v4;
750	<	subjet_v4.set_pt(pat_topjet.daughter(k)->p4().pt());
751	<	subjet_v4.set_eta(pat_topjet.daughter(k)->p4().eta());
752	<	subjet_v4.set_phi(pat_topjet.daughter(k)->p4().phi());
753	<	subjet_v4.set_energy(pat_topjet.daughter(k)->p4().E());
754	<	topjet.add_subjet(subjet_v4);
750	>
751	>	reco::Candidate const * subjetd =  pat_topjet.daughter(k);
752	>	pat::Jet const * patsubjetd = dynamic_cast<pat::Jet const *>(subjetd);
753	>	if(patsubjetd)
754	>	{
755	>	subjet_v4.set_pt(patsubjetd->correctedP4(0).pt());
756	>	subjet_v4.set_eta(patsubjetd->correctedP4(0).eta());
757	>	subjet_v4.set_phi(patsubjetd->correctedP4(0).phi());
758	>	subjet_v4.set_energy(patsubjetd->correctedP4(0).E());
759	>	topjet.add_subjet(subjet_v4);
760	>	//btag info
761	>	topjet.add_subFlavour(patsubjetd->partonFlavour());
762	>	topjet.add_subCSV(patsubjetd->bDiscriminator("combinedSecondaryVertexBJetTags"));
763	>	if (doTagInfos)
764	>	{
765	>	//ip tag info
766	>	reco::TaggingVariableList tvlIP=patsubjetd->tagInfoTrackIP("impactParameter")->taggingVariables();
767	>	topjet.add_subTrackMomentum(tvlIP.getList(reco::btau::trackMomentum,false));
768	>	topjet.add_subTrackEta(tvlIP.getList(reco::btau::trackEta,false));
769	>	topjet.add_subTrackEtaRel(tvlIP.getList(reco::btau::trackEtaRel,false));
770	>	topjet.add_subTrackDeltaR(tvlIP.getList(reco::btau::trackDeltaR,false));
771	>	topjet.add_subTrackSip3dVal(tvlIP.getList(reco::btau::trackSip3dVal,false));
772	>	topjet.add_subTrackSip3dSig(tvlIP.getList(reco::btau::trackSip3dSig,false));
773	>	topjet.add_subTrackSip2dVal(tvlIP.getList(reco::btau::trackSip2dVal,false));
774	>	topjet.add_subTrackSip2dSig(tvlIP.getList(reco::btau::trackSip2dSig,false));
775	>	topjet.add_subTrackDecayLenVal(tvlIP.getList(reco::btau::trackDecayLenVal,false));
776	>	topjet.add_subTrackChi2(tvlIP.getList(reco::btau::trackChi2,false));
777	>	topjet.add_subTrackNTotalHits(tvlIP.getList(reco::btau::trackNTotalHits,false));
778	>	topjet.add_subTrackNPixelHits(tvlIP.getList(reco::btau::trackNPixelHits,false));
779	>	topjet.add_subTrackPtRel(tvlIP.getList(reco::btau::trackPtRel,false));
780	>	topjet.add_subTrackPPar(tvlIP.getList(reco::btau::trackPPar,false));
781	>	topjet.add_subTrackPtRatio(tvlIP.getList(reco::btau::trackPtRatio,false));
782	>	topjet.add_subTrackPParRatio(tvlIP.getList(reco::btau::trackPParRatio,false));
783	>	topjet.add_subTrackJetDistVal(tvlIP.getList(reco::btau::trackJetDistVal,false));
784	>	topjet.add_subTrackJetDistSig(tvlIP.getList(reco::btau::trackJetDistSig,false));
785	>	topjet.add_subTrackGhostTrackDistVal(tvlIP.getList(reco::btau::trackGhostTrackDistVal,false));
786	>	topjet.add_subTrackGhostTrackDistSig(tvlIP.getList(reco::btau::trackGhostTrackDistSig,false));
787	>	topjet.add_subTrackGhostTrackWeight(tvlIP.getList(reco::btau::trackGhostTrackWeight,false));
788	>	//sv tag info
789	>	reco::TaggingVariableList tvlSV=patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->taggingVariables();
790	>	topjet.add_subFlightDistance2dVal(tvlSV.getList(reco::btau::flightDistance2dVal,false));
791	>	topjet.add_subFlightDistance2dSig(tvlSV.getList(reco::btau::flightDistance2dSig,false));
792	>	topjet.add_subFlightDistance3dVal(tvlSV.getList(reco::btau::flightDistance3dVal,false));
793	>	topjet.add_subFlightDistance3dSig(tvlSV.getList(reco::btau::flightDistance3dSig,false));
794	>	topjet.add_subVertexJetDeltaR(tvlSV.getList(reco::btau::vertexJetDeltaR,false));
795	>	topjet.add_subJetNSecondaryVertices(tvlSV.get(reco::btau::jetNSecondaryVertices,-9999));
796	>	topjet.add_subVertexNTracks(tvlSV.get(reco::btau::vertexNTracks,-9999));
797	>	std::vector<TLorentzVector> vp4; vp4.clear();
798	>	std::vector<float> vchi2; vchi2.clear();
799	>	std::vector<float> vndof; vndof.clear();
800	>	std::vector<float> vchi2ndof; vchi2ndof.clear();
801	>	std::vector<float> vtrsize; vtrsize.clear();
802	>	for(unsigned int i=0; i<patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->nVertices(); i++)
803	>	{
804	>	ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > p4 = patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).p4();
805	>	vp4.push_back(TLorentzVector(p4.px(),p4.py(),p4.pz(),p4.e()));
806	>	vchi2.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).chi2());
807	>	vndof.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).ndof());
808	>	vchi2ndof.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).normalizedChi2());
809	>	vtrsize.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex")->secondaryVertex(i).tracksSize());
810	>	}
811	>	topjet.add_subSecondaryVertex(vp4);
812	>	topjet.add_subVertexChi2(vchi2);
813	>	topjet.add_subVertexNdof(vndof);
814	>	topjet.add_subVertexNormalizedChi2(vchi2ndof);
815	>	topjet.add_subVertexTracksSize(vtrsize);
816	>	//try computer
817	>	edm::ESHandle<JetTagComputer> computerHandle;
818	>	iSetup.get<JetTagComputerRecord>().get( SVComputer_.label(), computerHandle );
819	>	const GenericMVAJetTagComputer *computer = dynamic_cast<const GenericMVAJetTagComputer*>( computerHandle.product() );
820	>	if(computer)
821	>	{
822	>	computer->passEventSetup(iSetup);
823	>	std::vector<const reco::BaseTagInfo*>  baseTagInfos;
824	>	baseTagInfos.push_back(patsubjetd->tagInfoTrackIP("impactParameter") );
825	>	baseTagInfos.push_back(patsubjetd->tagInfoSecondaryVertex("secondaryVertex") );
826	>	JetTagComputer::TagInfoHelper helper(baseTagInfos);
827	>	reco::TaggingVariableList vars = computer->taggingVariables(helper);
828	>	topjet.add_subVertexMassJTC(vars.get(reco::btau::vertexMass,-9999));
829	>	topjet.add_subVertexCategoryJTC(vars.get(reco::btau::vertexCategory,-9999));
830	>	topjet.add_subVertexEnergyRatioJTC(vars.get(reco::btau::vertexEnergyRatio,-9999));
831	>	topjet.add_subTrackSip3dSigAboveCharmJTC(vars.get(reco::btau::trackSip3dSigAboveCharm,-9999));
832	>	}
833	>	}
834	>	}
835	>	else
836	>	{
837	>	//filling only standard information in case the subjet has not been pat-tified during the pattuples production
838	>	subjet_v4.set_pt(pat_topjet.daughter(k)->p4().pt());
839	>	subjet_v4.set_eta(pat_topjet.daughter(k)->p4().eta());
840	>	subjet_v4.set_phi(pat_topjet.daughter(k)->p4().phi());
841	>	subjet_v4.set_energy(pat_topjet.daughter(k)->p4().E());
842	>	topjet.add_subjet(subjet_v4);
843	>	}
844	>
845	>
846		}
847		topjets[j].push_back(topjet);
848		}
849		}
850		}
851	<
852	<
851	>
852	>
853		// ------------- generator top jets -------------
854		if(doGenTopJets){
855		for(size_t j=0; j< gentopjet_sources.size(); ++j){
856
857		gentopjets[j].clear();
858	<
858	>
859		edm::Handle<reco::BasicJetCollection> reco_gentopjets;
860		//edm::Handle<std::vector<reco::Jet> > reco_gentopjets;
861		iEvent.getByLabel(gentopjet_sources[j], reco_gentopjets);
#	Line 860 | Line 1019 | void
1019		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
1020		{
1021		if(doTrigger){
1022	<	bool setup_changed = false;
1023	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
1022	>	//bool setup_changed = false;
1023	>	//hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
1024		newrun=true;
1025		}
1026
1027		if(doJets || doTopJets){
1028	<	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
1029	<	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
1030	<	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
1031	<	jecUnc = new JetCorrectionUncertainty(JetCorPar);
1028	>	if(doJECUncertainty){
1029	>	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
1030	>	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
1031	>	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
1032	>	jecUnc = new JetCorrectionUncertainty(JetCorPar);
1033	>	}
1034		}
1035		}
1036

Diff Legend

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