ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/UHHAnalysis/NtupleWriter/src/NtupleWriter.cc

Comparing UserCode/UHHAnalysis/NtupleWriter/src/NtupleWriter.cc (file contents):
Revision 1.4 by peiffer, Mon Apr 2 15:10:03 2012 UTC vs.
Revision 1.9 by peiffer, Mon Apr 16 15:42:09 2012 UTC

#	Line 55 | Line 55 | NtupleWriter::NtupleWriter(const edm::Pa
55		doGenInfo = iConfig.getParameter<bool>("doGenInfo");
56		doPV = iConfig.getParameter<bool>("doPV");
57		doTopJets = iConfig.getParameter<bool>("doTopJets");
58	+	doTrigger = iConfig.getParameter<bool>("doTrigger");
59
60		// initialization of tree variables
61
#	Line 63 | Line 64 | NtupleWriter::NtupleWriter(const edm::Pa
64		tr->Branch("luminosityBlock",&luminosityBlock);
65		tr->Branch("isRealData",&isRealData);
66		tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
67	<	tr->Branch("beamspot_x0",&beamspot_x0);
68	<	tr->Branch("beamspot_y0",&beamspot_y0);
69	<	tr->Branch("beamspot_z0",&beamspot_z0);
70	<
67	>	if(doPV){
68	>	tr->Branch("beamspot_x0",&beamspot_x0);
69	>	tr->Branch("beamspot_y0",&beamspot_y0);
70	>	tr->Branch("beamspot_z0",&beamspot_z0);
71	>	}
72		if(doElectrons){
73		electron_sources = iConfig.getParameter<std::vector<std::string> >("electron_sources");
74		for(size_t j=0; j< electron_sources.size(); ++j){
#	Line 125 | Line 127 | NtupleWriter::NtupleWriter(const edm::Pa
127		tr->Branch("genInfo","GenInfo",&genInfo);
128		tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
129		}
130	<
131	<	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
132	<	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
133	<	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
134	<	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
135	<	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
136	<	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
137	<
130	>	if(doTrigger){
131	>	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
132	>	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
133	>	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
134	>	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
135	>	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
136	>	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
137	>	}
138		newrun = true;
139		}
140
#	Line 171 | Line 173 | NtupleWriter::analyze(const edm::Event&
173		}
174		else HBHENoiseFilterResult = false;
175
176	+	// ------------- primary vertices and beamspot  -------------
177	+
178	+	if(doPV){
179	+	for(size_t j=0; j< pv_sources.size(); ++j){
180	+	pvs[j].clear();
181	+
182	+	edm::Handle< std::vector<reco::Vertex> > pv_handle;
183	+	iEvent.getByLabel(pv_sources[j], pv_handle);
184	+	const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product());
185	+
186	+	for (unsigned int i = 0; i <  reco_pvs.size(); ++i) {
187	+	reco::Vertex reco_pv = reco_pvs[i];
188	+
189	+	PrimaryVertex pv;
190	+	pv.x =  reco_pv.x();
191	+	pv.y =  reco_pv.y();
192	+	pv.z =  reco_pv.z();
193	+	pv.nTracks =  reco_pv.nTracks();
194	+	//pv.isValid =  reco_pv.isValid();
195	+	pv.chi2 =  reco_pv.chi2();
196	+	pv.ndof =  reco_pv.ndof();
197	+
198	+	pvs[j].push_back(pv);
199	+	}
200	+	}
201	+
202	+	edm::Handle<reco::BeamSpot> beamSpot;
203	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
204	+	const reco::BeamSpot & bsp = *beamSpot;
205	+
206	+	beamspot_x0 = bsp.x0();
207	+	beamspot_y0 = bsp.y0();
208	+	beamspot_z0 = bsp.z0();
209	+	}
210	+
211		// ------------- electrons -------------
212		if(doElectrons){
213		for(size_t j=0; j< electron_sources.size(); ++j){
#	Line 199 | Line 236 | NtupleWriter::analyze(const edm::Event&
236		ele.chargedHadronIso = pat_ele.chargedHadronIso();
237		ele.trackIso = pat_ele.trackIso();
238		ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
239	<
239	>	ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
240	>	ele.gsfTrack_px= pat_ele.gsfTrack()->px();
241	>	ele.gsfTrack_py= pat_ele.gsfTrack()->py();
242	>	ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
243	>	ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
244	>	ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
245	>	ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
246		eles[j].push_back(ele);
247		}
248		}
#	Line 314 | Line 357 | NtupleWriter::analyze(const edm::Event&
357		tau.eta =  pat_tau.eta();
358		tau.phi =  pat_tau.phi();
359		tau.energy =  pat_tau.energy();
360	<
360	>	tau.decayModeFinding = pat_tau.tauID("decayModeFinding")>0.5;
361	>	tau.byVLooseCombinedIsolationDeltaBetaCorr  = pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5;
362	>	tau.byLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5;
363	>	tau.byMediumCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5;
364	>	tau.byTightCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5;
365	>	tau.againstElectronLoose  = pat_tau.tauID("againstElectronLoose")>0.5;
366	>	tau.againstElectronMedium = pat_tau.tauID("againstElectronMedium")>0.5;
367	>	tau.againstElectronTight = pat_tau.tauID("againstElectronTight")>0.5;
368	>	tau.againstElectronMVA  = pat_tau.tauID("againstElectronMVA")>0.5;
369	>	tau.againstMuonLoose = pat_tau.tauID("againstMuonLoose")>0.5;
370	>	tau.againstMuonMedium = pat_tau.tauID("againstMuonMedium")>0.5;
371	>	tau.againstMuonTight = pat_tau.tauID("againstMuonTight")>0.5;
372	>
373		taus[j].push_back(tau);
374		}
375		}
#	Line 364 | Line 419 | NtupleWriter::analyze(const edm::Event&
419		jet.electronMultiplicity =pat_jet.electronMultiplicity();
420		jet.photonMultiplicity =pat_jet.photonMultiplicity();
421		}
422	+
423	+	jecUnc->setJetEta(pat_jet.eta());
424	+	jecUnc->setJetPt(pat_jet.pt());
425	+	jet.JEC_uncertainty = jecUnc->getUncertainty(true);
426	+
427		jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
428		jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
429		jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
#	Line 414 | Line 474 | NtupleWriter::analyze(const edm::Event&
474		//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
475		//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
476
477	+	jecUnc->setJetEta(pat_topjet.eta());
478	+	jecUnc->setJetPt(pat_topjet.pt());
479	+	topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
480	+
481		topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
482		topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
483		topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
#	Line 487 | Line 551 | NtupleWriter::analyze(const edm::Event&
551		}
552
553		// ------------- trigger -------------
554	<
555	<	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
556	<	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
557	<	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
558	<
559	<	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
560	<	std::string nameProcess = meta->processName();
561	<	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
562	<	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
563	<
564	<	edm::Handle<edm::TriggerResults> trigger;
565	<	iEvent.getByLabel(triggerResultTag, trigger);
566	<	const edm::TriggerResults& trig = *(trigger.product());
567	<
568	<	triggerResults.clear();
569	<	triggerNames.clear();
570	<	L1_prescale.clear();
571	<	HLT_prescale.clear();
572	<
573	<	edm::Service<edm::service::TriggerNamesService> tns;
574	<	std::vector<std::string> triggerNames_all;
575	<	tns->getTrigPaths(trig,triggerNames_all);
576	<
577	<	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
578	<	for(unsigned int i=0; i<trig.size(); ++i){
579	<	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
580	<	for(; it!=trigger_prefixes.end(); ++it){
581	<	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
582	<	}
583	<	if(it==trigger_prefixes.end()) continue;
584	<
585	<	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
586	<	triggerResults.push_back(trig.accept(i));
587	<	if(newrun) triggerNames.push_back(triggerNames_all[i]);
588	<	if(isRealData){
589	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
590	<	L1_prescale.push_back(pre.first);
591	<	HLT_prescale.push_back(pre.second);
592	<	}
593	<	}
594	<	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
595	<	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
596	<	//    }
597	<	newrun=false;
554	>	if(doTrigger){
555	>	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
556	>	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
557	>	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
558	>
559	>	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
560	>	std::string nameProcess = meta->processName();
561	>	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
562	>	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
563	>
564	>	edm::Handle<edm::TriggerResults> trigger;
565	>	iEvent.getByLabel(triggerResultTag, trigger);
566	>	const edm::TriggerResults& trig = *(trigger.product());
567	>
568	>	triggerResults.clear();
569	>	triggerNames.clear();
570	>	L1_prescale.clear();
571	>	HLT_prescale.clear();
572	>
573	>	edm::Service<edm::service::TriggerNamesService> tns;
574	>	std::vector<std::string> triggerNames_all;
575	>	tns->getTrigPaths(trig,triggerNames_all);
576	>
577	>	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
578	>	for(unsigned int i=0; i<trig.size(); ++i){
579	>	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
580	>	for(; it!=trigger_prefixes.end(); ++it){
581	>	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
582	>	}
583	>	if(it==trigger_prefixes.end()) continue;
584	>
585	>	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
586	>	triggerResults.push_back(trig.accept(i));
587	>	if(newrun) triggerNames.push_back(triggerNames_all[i]);
588	>	if(isRealData){
589	>	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
590	>	L1_prescale.push_back(pre.first);
591	>	HLT_prescale.push_back(pre.second);
592	>	}
593	>	}
594	>	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
595	>	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
596	>	//    }
597	>	newrun=false;
598	>	}
599
600		// ------------- generator info -------------
601
#	Line 625 | Line 690 | NtupleWriter::analyze(const edm::Event&
690
691		}
692
628	–	// ------------- primary vertices and beamspot  -------------
629	–
630	–	if(doPV){
631	–	for(size_t j=0; j< pv_sources.size(); ++j){
632	–	pvs[j].clear();
633	–
634	–	edm::Handle< std::vector<reco::Vertex> > pv_handle;
635	–	iEvent.getByLabel(pv_sources[j], pv_handle);
636	–	const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product());
637	–
638	–	for (unsigned int i = 0; i <  reco_pvs.size(); ++i) {
639	–	reco::Vertex reco_pv = reco_pvs[i];
640	–
641	–	PrimaryVertex pv;
642	–	pv.x =  reco_pv.x();
643	–	pv.y =  reco_pv.y();
644	–	pv.z =  reco_pv.z();
645	–	pv.nTracks =  reco_pv.nTracks();
646	–	//pv.isValid =  reco_pv.isValid();
647	–	pv.chi2 =  reco_pv.chi2();
648	–	pv.ndof =  reco_pv.ndof();
649	–
650	–	pvs[j].push_back(pv);
651	–	}
652	–	}
653	–	}
654	–
655	–	edm::Handle<reco::BeamSpot> beamSpot;
656	–	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
657	–	const reco::BeamSpot & bsp = *beamSpot;
658	–
659	–	beamspot_x0 = bsp.x0();
660	–	beamspot_y0 = bsp.y0();
661	–	beamspot_z0 = bsp.z0();
693
694		tr->Fill();
695
#	Line 684 | Line 715 | NtupleWriter::endJob()
715		void
716		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
717		{
718	<	bool setup_changed = false;
719	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
720	<	newrun=true;
718	>	if(doTrigger){
719	>	bool setup_changed = false;
720	>	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
721	>	newrun=true;
722	>	}
723	>
724	>	if(doJets || doTopJets){
725	>	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
726	>	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
727	>	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
728	>	jecUnc = new JetCorrectionUncertainty(JetCorPar);
729	>	}
730		}
731
732		// ------------ method called when ending the processing of a run  ------------

Diff Legend

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