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.10 by peiffer, Wed Apr 18 12:53:46 2012 UTC

#	Line 53 | Line 53 | NtupleWriter::NtupleWriter(const edm::Pa
53		doPhotons = iConfig.getParameter<bool>("doPhotons");
54		doMET = iConfig.getParameter<bool>("doMET");
55		doGenInfo = iConfig.getParameter<bool>("doGenInfo");
56	+	doLumiInfo = iConfig.getParameter<bool>("doLumiInfo");
57		doPV = iConfig.getParameter<bool>("doPV");
58		doTopJets = iConfig.getParameter<bool>("doTopJets");
59	+	doTrigger = iConfig.getParameter<bool>("doTrigger");
60
61		// initialization of tree variables
62
#	Line 63 | Line 65 | NtupleWriter::NtupleWriter(const edm::Pa
65		tr->Branch("luminosityBlock",&luminosityBlock);
66		tr->Branch("isRealData",&isRealData);
67		tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
68	<	tr->Branch("beamspot_x0",&beamspot_x0);
69	<	tr->Branch("beamspot_y0",&beamspot_y0);
70	<	tr->Branch("beamspot_z0",&beamspot_z0);
71	<
68	>	if(doLumiInfo){
69	>	tr->Branch("intgRecLumi",&intgRecLumi);
70	>	tr->Branch("intgDelLumi",&intgDelLumi);
71	>	}
72	>	if(doPV){
73	>	tr->Branch("beamspot_x0",&beamspot_x0);
74	>	tr->Branch("beamspot_y0",&beamspot_y0);
75	>	tr->Branch("beamspot_z0",&beamspot_z0);
76	>	}
77		if(doElectrons){
78		electron_sources = iConfig.getParameter<std::vector<std::string> >("electron_sources");
79		for(size_t j=0; j< electron_sources.size(); ++j){
#	Line 125 | Line 132 | NtupleWriter::NtupleWriter(const edm::Pa
132		tr->Branch("genInfo","GenInfo",&genInfo);
133		tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
134		}
135	<
136	<	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
137	<	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
138	<	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
139	<	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
140	<	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
141	<	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
142	<
135	>	if(doTrigger){
136	>	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
137	>	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
138	>	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
139	>	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
140	>	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
141	>	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
142	>	}
143		newrun = true;
144		}
145
#	Line 171 | Line 178 | NtupleWriter::analyze(const edm::Event&
178		}
179		else HBHENoiseFilterResult = false;
180
181	+	// ------------- primary vertices and beamspot  -------------
182	+
183	+	if(doPV){
184	+	for(size_t j=0; j< pv_sources.size(); ++j){
185	+	pvs[j].clear();
186	+
187	+	edm::Handle< std::vector<reco::Vertex> > pv_handle;
188	+	iEvent.getByLabel(pv_sources[j], pv_handle);
189	+	const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product());
190	+
191	+	for (unsigned int i = 0; i <  reco_pvs.size(); ++i) {
192	+	reco::Vertex reco_pv = reco_pvs[i];
193	+
194	+	PrimaryVertex pv;
195	+	pv.x =  reco_pv.x();
196	+	pv.y =  reco_pv.y();
197	+	pv.z =  reco_pv.z();
198	+	pv.nTracks =  reco_pv.nTracks();
199	+	//pv.isValid =  reco_pv.isValid();
200	+	pv.chi2 =  reco_pv.chi2();
201	+	pv.ndof =  reco_pv.ndof();
202	+
203	+	pvs[j].push_back(pv);
204	+	}
205	+	}
206	+
207	+	edm::Handle<reco::BeamSpot> beamSpot;
208	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
209	+	const reco::BeamSpot & bsp = *beamSpot;
210	+
211	+	beamspot_x0 = bsp.x0();
212	+	beamspot_y0 = bsp.y0();
213	+	beamspot_z0 = bsp.z0();
214	+	}
215	+
216		// ------------- electrons -------------
217		if(doElectrons){
218	+
219	+	edm::Handle<reco::ConversionCollection> hConversions;
220	+	iEvent.getByLabel("allConversions", hConversions);
221	+
222	+	edm::Handle<reco::BeamSpot> beamSpot;
223	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
224	+	const reco::BeamSpot & bsp = *beamSpot;
225	+
226		for(size_t j=0; j< electron_sources.size(); ++j){
227		eles[j].clear();
228		edm::Handle< std::vector<pat::Electron> > ele_handle;
#	Line 199 | Line 249 | NtupleWriter::analyze(const edm::Event&
249		ele.chargedHadronIso = pat_ele.chargedHadronIso();
250		ele.trackIso = pat_ele.trackIso();
251		ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
252	<
252	>	ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
253	>	ele.gsfTrack_px= pat_ele.gsfTrack()->px();
254	>	ele.gsfTrack_py= pat_ele.gsfTrack()->py();
255	>	ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
256	>	ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
257	>	ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
258	>	ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
259	>	ele.passconversionveto = !ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position());
260		eles[j].push_back(ele);
261		}
262		}
#	Line 314 | Line 371 | NtupleWriter::analyze(const edm::Event&
371		tau.eta =  pat_tau.eta();
372		tau.phi =  pat_tau.phi();
373		tau.energy =  pat_tau.energy();
374	<
374	>	tau.decayModeFinding = pat_tau.tauID("decayModeFinding")>0.5;
375	>	tau.byVLooseCombinedIsolationDeltaBetaCorr  = pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5;
376	>	tau.byLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5;
377	>	tau.byMediumCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5;
378	>	tau.byTightCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5;
379	>	tau.againstElectronLoose  = pat_tau.tauID("againstElectronLoose")>0.5;
380	>	tau.againstElectronMedium = pat_tau.tauID("againstElectronMedium")>0.5;
381	>	tau.againstElectronTight = pat_tau.tauID("againstElectronTight")>0.5;
382	>	tau.againstElectronMVA  = pat_tau.tauID("againstElectronMVA")>0.5;
383	>	tau.againstMuonLoose = pat_tau.tauID("againstMuonLoose")>0.5;
384	>	tau.againstMuonMedium = pat_tau.tauID("againstMuonMedium")>0.5;
385	>	tau.againstMuonTight = pat_tau.tauID("againstMuonTight")>0.5;
386	>
387	>	reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
388	>	if(!leadPFCand.isNull()){
389	>	tau.leadPFCand_px = leadPFCand->px();
390	>	tau.leadPFCand_py = leadPFCand->py();
391	>	tau.leadPFCand_pz = leadPFCand->pz();
392	>	}
393	>	else{
394	>	tau.leadPFCand_px = 0;
395	>	tau.leadPFCand_py = 0;
396	>	tau.leadPFCand_pz = 0;
397	>	}
398		taus[j].push_back(tau);
399		}
400		}
#	Line 364 | Line 444 | NtupleWriter::analyze(const edm::Event&
444		jet.electronMultiplicity =pat_jet.electronMultiplicity();
445		jet.photonMultiplicity =pat_jet.photonMultiplicity();
446		}
447	+
448	+	jecUnc->setJetEta(pat_jet.eta());
449	+	jecUnc->setJetPt(pat_jet.pt());
450	+	jet.JEC_uncertainty = jecUnc->getUncertainty(true);
451	+
452		jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
453		jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
454		jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
#	Line 414 | Line 499 | NtupleWriter::analyze(const edm::Event&
499		//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
500		//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
501
502	+	jecUnc->setJetEta(pat_topjet.eta());
503	+	jecUnc->setJetPt(pat_topjet.pt());
504	+	topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
505	+
506		topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
507		topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
508		topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
#	Line 487 | Line 576 | NtupleWriter::analyze(const edm::Event&
576		}
577
578		// ------------- trigger -------------
579	<
580	<	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
581	<	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
582	<	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
583	<
584	<	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
585	<	std::string nameProcess = meta->processName();
586	<	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
587	<	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
588	<
589	<	edm::Handle<edm::TriggerResults> trigger;
590	<	iEvent.getByLabel(triggerResultTag, trigger);
591	<	const edm::TriggerResults& trig = *(trigger.product());
592	<
593	<	triggerResults.clear();
594	<	triggerNames.clear();
595	<	L1_prescale.clear();
596	<	HLT_prescale.clear();
597	<
598	<	edm::Service<edm::service::TriggerNamesService> tns;
599	<	std::vector<std::string> triggerNames_all;
600	<	tns->getTrigPaths(trig,triggerNames_all);
601	<
602	<	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
603	<	for(unsigned int i=0; i<trig.size(); ++i){
604	<	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
605	<	for(; it!=trigger_prefixes.end(); ++it){
606	<	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
607	<	}
608	<	if(it==trigger_prefixes.end()) continue;
609	<
610	<	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
611	<	triggerResults.push_back(trig.accept(i));
612	<	if(newrun) triggerNames.push_back(triggerNames_all[i]);
613	<	if(isRealData){
614	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
615	<	L1_prescale.push_back(pre.first);
616	<	HLT_prescale.push_back(pre.second);
617	<	}
618	<	}
619	<	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
620	<	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
621	<	//    }
622	<	newrun=false;
579	>	if(doTrigger){
580	>	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
581	>	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
582	>	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
583	>
584	>	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
585	>	std::string nameProcess = meta->processName();
586	>	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
587	>	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
588	>
589	>	edm::Handle<edm::TriggerResults> trigger;
590	>	iEvent.getByLabel(triggerResultTag, trigger);
591	>	const edm::TriggerResults& trig = *(trigger.product());
592	>
593	>	triggerResults.clear();
594	>	triggerNames.clear();
595	>	L1_prescale.clear();
596	>	HLT_prescale.clear();
597	>
598	>	edm::Service<edm::service::TriggerNamesService> tns;
599	>	std::vector<std::string> triggerNames_all;
600	>	tns->getTrigPaths(trig,triggerNames_all);
601	>
602	>	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
603	>	for(unsigned int i=0; i<trig.size(); ++i){
604	>	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
605	>	for(; it!=trigger_prefixes.end(); ++it){
606	>	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
607	>	}
608	>	if(it==trigger_prefixes.end()) continue;
609	>
610	>	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
611	>	triggerResults.push_back(trig.accept(i));
612	>	if(newrun) triggerNames.push_back(triggerNames_all[i]);
613	>	if(isRealData){
614	>	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
615	>	L1_prescale.push_back(pre.first);
616	>	HLT_prescale.push_back(pre.second);
617	>	//std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
618	>	}
619	>	}
620	>	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
621	>	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
622	>	//    }
623	>	newrun=false;
624	>	}
625
626		// ------------- generator info -------------
627
#	Line 625 | Line 716 | NtupleWriter::analyze(const edm::Event&
716
717		}
718
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();
662	–
719		tr->Fill();
720	<
720	>	if(doLumiInfo)
721	>	previouslumiblockwasfilled=true;
722		}
723
724
#	Line 669 | Line 726 | NtupleWriter::analyze(const edm::Event&
726		void
727		NtupleWriter::beginJob()
728		{
729	+	if(doLumiInfo){
730	+	totalRecLumi=0;
731	+	totalDelLumi=0;
732	+	previouslumiblockwasfilled=false;
733	+	}
734		}
735
736		// ------------ method called once each job just after ending the event loop  ------------
#	Line 684 | Line 746 | NtupleWriter::endJob()
746		void
747		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
748		{
749	<	bool setup_changed = false;
750	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
751	<	newrun=true;
749	>	if(doTrigger){
750	>	bool setup_changed = false;
751	>	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
752	>	newrun=true;
753	>	}
754	>
755	>	if(doJets || doTopJets){
756	>	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
757	>	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
758	>	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
759	>	jecUnc = new JetCorrectionUncertainty(JetCorPar);
760	>	}
761		}
762
763		// ------------ method called when ending the processing of a run  ------------
764		void
765		NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&)
766		{
767	+	if(doLumiInfo)
768	+	std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl;
769		}
770
771		// ------------ method called when starting to processes a luminosity block  ------------
772		void
773	<	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
773	>	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&)
774		{
775	+	if(doLumiInfo){
776	+	edm::Handle<LumiSummary> l;
777	+	lumi.getByLabel("lumiProducer", l);
778	+
779	+	//add lumi of lumi blocks without any event to next lumiblock
780	+	if(previouslumiblockwasfilled){
781	+	intgRecLumi=0;
782	+	intgDelLumi=0;
783	+	}
784	+	previouslumiblockwasfilled=false;
785	+
786	+	if (l.isValid()){;
787	+	intgRecLumi+=l->intgRecLumi()*6.37;
788	+	intgDelLumi+=l->intgDelLumi()*6.37;
789	+	totalRecLumi+=l->intgRecLumi()*6.37;
790	+	totalDelLumi+=l->intgDelLumi()*6.37;
791	+	}
792	+	//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<"   " << l->intgDelLumi()*6.37<<std::endl;
793	+	//std::cout << "summed:  "<< intgRecLumi << "   " << intgDelLumi << std::endl;
794	+	}
795		}
796
797		// ------------ method called when ending the processing of a luminosity block  ------------

Diff Legend

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