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.5 by peiffer, Thu Apr 5 09:48:20 2012 UTC vs.
Revision 1.11 by peiffer, Thu Apr 19 09:51:01 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	+	doAllGenParticles = iConfig.getParameter<bool>("doAllGenParticles");
57	+	doLumiInfo = iConfig.getParameter<bool>("doLumiInfo");
58		doPV = iConfig.getParameter<bool>("doPV");
59		doTopJets = iConfig.getParameter<bool>("doTopJets");
60	+	doTrigger = iConfig.getParameter<bool>("doTrigger");
61
62		// initialization of tree variables
63
#	Line 63 | Line 66 | NtupleWriter::NtupleWriter(const edm::Pa
66		tr->Branch("luminosityBlock",&luminosityBlock);
67		tr->Branch("isRealData",&isRealData);
68		tr->Branch("HBHENoiseFilterResult",&HBHENoiseFilterResult);
69	<	tr->Branch("beamspot_x0",&beamspot_x0);
70	<	tr->Branch("beamspot_y0",&beamspot_y0);
71	<	tr->Branch("beamspot_z0",&beamspot_z0);
72	<
69	>	if(doLumiInfo){
70	>	tr->Branch("intgRecLumi",&intgRecLumi);
71	>	tr->Branch("intgDelLumi",&intgDelLumi);
72	>	}
73	>	if(doPV){
74	>	tr->Branch("beamspot_x0",&beamspot_x0);
75	>	tr->Branch("beamspot_y0",&beamspot_y0);
76	>	tr->Branch("beamspot_z0",&beamspot_z0);
77	>	}
78		if(doElectrons){
79		electron_sources = iConfig.getParameter<std::vector<std::string> >("electron_sources");
80		for(size_t j=0; j< electron_sources.size(); ++j){
#	Line 125 | Line 133 | NtupleWriter::NtupleWriter(const edm::Pa
133		tr->Branch("genInfo","GenInfo",&genInfo);
134		tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
135		}
136	<
137	<	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
138	<	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
139	<	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
140	<	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
141	<	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
142	<	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
143	<
136	>	if(doTrigger){
137	>	trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
138	>	//tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
139	>	tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);
140	>	tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
141	>	tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
142	>	tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
143	>	}
144		newrun = true;
145		}
146
#	Line 196 | Line 204 | NtupleWriter::analyze(const edm::Event&
204		pvs[j].push_back(pv);
205		}
206		}
207	+
208	+	edm::Handle<reco::BeamSpot> beamSpot;
209	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
210	+	const reco::BeamSpot & bsp = *beamSpot;
211	+
212	+	beamspot_x0 = bsp.x0();
213	+	beamspot_y0 = bsp.y0();
214	+	beamspot_z0 = bsp.z0();
215		}
200	–
201	–	edm::Handle<reco::BeamSpot> beamSpot;
202	–	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
203	–	const reco::BeamSpot & bsp = *beamSpot;
204	–
205	–	beamspot_x0 = bsp.x0();
206	–	beamspot_y0 = bsp.y0();
207	–	beamspot_z0 = bsp.z0();
216
217		// ------------- electrons -------------
218		if(doElectrons){
219	+
220	+	edm::Handle<reco::ConversionCollection> hConversions;
221	+	iEvent.getByLabel("allConversions", hConversions);
222	+
223	+	edm::Handle<reco::BeamSpot> beamSpot;
224	+	iEvent.getByLabel(edm::InputTag("offlineBeamSpot"), beamSpot);
225	+	const reco::BeamSpot & bsp = *beamSpot;
226	+
227		for(size_t j=0; j< electron_sources.size(); ++j){
228		eles[j].clear();
229		edm::Handle< std::vector<pat::Electron> > ele_handle;
#	Line 241 | Line 257 | NtupleWriter::analyze(const edm::Event&
257		ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
258		ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
259		ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
260	+	ele.passconversionveto = !ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position());
261	+	ele.dEtaIn=pat_ele.deltaEtaSuperClusterTrackAtVtx();
262	+	ele.dPhiIn=pat_ele.deltaPhiSuperClusterTrackAtVtx();
263	+	ele.sigmaIEtaIEta=pat_ele.sigmaIetaIeta();
264	+	ele.HoverE=pat_ele.hadronicOverEm();
265	+	ele.fbrem=pat_ele.fbrem();
266	+	ele.EoverPIn=pat_ele.eSuperClusterOverP();
267	+	ele.EcalEnergy=pat_ele.ecalEnergy();
268	+	ele.mvaTrigV0=pat_ele.electronID("mvaTrigV0");
269	+	ele.mvaNonTrigV0=pat_ele.electronID("mvaNonTrigV0");
270	+
271		eles[j].push_back(ele);
272		}
273		}
#	Line 302 | Line 329 | NtupleWriter::analyze(const edm::Event&
329		mu.innerTrack_d0Error = innerTrack->d0Error();
330		mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits();
331		mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits();
332	+	mu.innerTrack_trackerLayersWithMeasurement = innerTrack->hitPattern().trackerLayersWithMeasurement();
333	+	mu.innerTrack_numberOfValidPixelHits = innerTrack->hitPattern().numberOfValidPixelHits();
334		}
335		else{
336		mu.innerTrack_chi2 = 0;
#	Line 310 | Line 339 | NtupleWriter::analyze(const edm::Event&
339		mu.innerTrack_d0Error = 0;
340		mu.innerTrack_numberOfValidHits = 0;
341		mu.innerTrack_numberOfLostHits = 0;
342	+	mu.innerTrack_trackerLayersWithMeasurement = 0;
343	+	mu.innerTrack_numberOfValidPixelHits = 0;
344		}
345		reco::TrackRef outerTrack = pat_mu.outerTrack();
346		if(!outerTrack.isNull()){
#	Line 355 | Line 386 | NtupleWriter::analyze(const edm::Event&
386		tau.eta =  pat_tau.eta();
387		tau.phi =  pat_tau.phi();
388		tau.energy =  pat_tau.energy();
389	<
389	>	tau.decayModeFinding = pat_tau.tauID("decayModeFinding")>0.5;
390	>	tau.byVLooseCombinedIsolationDeltaBetaCorr  = pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5;
391	>	tau.byLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5;
392	>	tau.byMediumCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5;
393	>	tau.byTightCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5;
394	>	tau.againstElectronLoose  = pat_tau.tauID("againstElectronLoose")>0.5;
395	>	tau.againstElectronMedium = pat_tau.tauID("againstElectronMedium")>0.5;
396	>	tau.againstElectronTight = pat_tau.tauID("againstElectronTight")>0.5;
397	>	tau.againstElectronMVA  = pat_tau.tauID("againstElectronMVA")>0.5;
398	>	tau.againstMuonLoose = pat_tau.tauID("againstMuonLoose")>0.5;
399	>	tau.againstMuonMedium = pat_tau.tauID("againstMuonMedium")>0.5;
400	>	tau.againstMuonTight = pat_tau.tauID("againstMuonTight")>0.5;
401	>
402	>	reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
403	>	if(!leadPFCand.isNull()){
404	>	tau.leadPFCand_px = leadPFCand->px();
405	>	tau.leadPFCand_py = leadPFCand->py();
406	>	tau.leadPFCand_pz = leadPFCand->pz();
407	>	}
408	>	else{
409	>	tau.leadPFCand_px = 0;
410	>	tau.leadPFCand_py = 0;
411	>	tau.leadPFCand_pz = 0;
412	>	}
413		taus[j].push_back(tau);
414		}
415		}
#	Line 537 | Line 591 | NtupleWriter::analyze(const edm::Event&
591		}
592
593		// ------------- trigger -------------
594	<
595	<	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
596	<	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
597	<	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
598	<
599	<	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
600	<	std::string nameProcess = meta->processName();
601	<	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
602	<	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
603	<
604	<	edm::Handle<edm::TriggerResults> trigger;
605	<	iEvent.getByLabel(triggerResultTag, trigger);
606	<	const edm::TriggerResults& trig = *(trigger.product());
607	<
608	<	triggerResults.clear();
609	<	triggerNames.clear();
610	<	L1_prescale.clear();
611	<	HLT_prescale.clear();
612	<
613	<	edm::Service<edm::service::TriggerNamesService> tns;
614	<	std::vector<std::string> triggerNames_all;
615	<	tns->getTrigPaths(trig,triggerNames_all);
616	<
617	<	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
618	<	for(unsigned int i=0; i<trig.size(); ++i){
619	<	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
620	<	for(; it!=trigger_prefixes.end(); ++it){
621	<	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
622	<	}
623	<	if(it==trigger_prefixes.end()) continue;
624	<
625	<	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
626	<	triggerResults.push_back(trig.accept(i));
627	<	if(newrun) triggerNames.push_back(triggerNames_all[i]);
628	<	if(isRealData){
629	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
630	<	L1_prescale.push_back(pre.first);
631	<	HLT_prescale.push_back(pre.second);
632	<	}
633	<	}
634	<	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
635	<	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
636	<	//    }
637	<	newrun=false;
594	>	if(doTrigger){
595	>	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
596	>	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
597	>	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
598	>
599	>	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
600	>	std::string nameProcess = meta->processName();
601	>	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
602	>	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
603	>
604	>	edm::Handle<edm::TriggerResults> trigger;
605	>	iEvent.getByLabel(triggerResultTag, trigger);
606	>	const edm::TriggerResults& trig = *(trigger.product());
607	>
608	>	triggerResults.clear();
609	>	triggerNames.clear();
610	>	L1_prescale.clear();
611	>	HLT_prescale.clear();
612	>
613	>	edm::Service<edm::service::TriggerNamesService> tns;
614	>	std::vector<std::string> triggerNames_all;
615	>	tns->getTrigPaths(trig,triggerNames_all);
616	>
617	>	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
618	>	for(unsigned int i=0; i<trig.size(); ++i){
619	>	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
620	>	for(; it!=trigger_prefixes.end(); ++it){
621	>	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
622	>	}
623	>	if(it==trigger_prefixes.end()) continue;
624	>
625	>	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
626	>	triggerResults.push_back(trig.accept(i));
627	>	if(newrun) triggerNames.push_back(triggerNames_all[i]);
628	>	if(isRealData){
629	>	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
630	>	L1_prescale.push_back(pre.first);
631	>	HLT_prescale.push_back(pre.second);
632	>	//std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
633	>	}
634	>	}
635	>	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
636	>	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
637	>	//    }
638	>	newrun=false;
639	>	}
640
641		// ------------- generator info -------------
642
#	Line 645 | Line 701 | NtupleWriter::analyze(const edm::Event&
701		index++;
702
703		//write out only top quarks and status 3 particles (works fine only for MadGraph)
704	<	if(abs(iter->pdgId())==6 || iter->status()==3){
704	>	if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){
705		GenParticle genp;
706		genp.charge = iter->charge();;
707		genp.pt = iter->p4().pt();
#	Line 675 | Line 731 | NtupleWriter::analyze(const edm::Event&
731
732		}
733
678	–
734		tr->Fill();
735	<
735	>	if(doLumiInfo)
736	>	previouslumiblockwasfilled=true;
737		}
738
739
#	Line 685 | Line 741 | NtupleWriter::analyze(const edm::Event&
741		void
742		NtupleWriter::beginJob()
743		{
744	+	if(doLumiInfo){
745	+	totalRecLumi=0;
746	+	totalDelLumi=0;
747	+	previouslumiblockwasfilled=false;
748	+	}
749		}
750
751		// ------------ method called once each job just after ending the event loop  ------------
#	Line 700 | Line 761 | NtupleWriter::endJob()
761		void
762		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
763		{
764	<	bool setup_changed = false;
765	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
766	<	newrun=true;
767	<
768	<	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
708	<	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
709	<	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
710	<	jecUnc = new JetCorrectionUncertainty(JetCorPar);
764	>	if(doTrigger){
765	>	bool setup_changed = false;
766	>	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
767	>	newrun=true;
768	>	}
769
770	+	if(doJets || doTopJets){
771	+	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
772	+	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
773	+	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
774	+	jecUnc = new JetCorrectionUncertainty(JetCorPar);
775	+	}
776		}
777
778		// ------------ method called when ending the processing of a run  ------------
779		void
780		NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&)
781		{
782	+	if(doLumiInfo)
783	+	std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl;
784		}
785
786		// ------------ method called when starting to processes a luminosity block  ------------
787		void
788	<	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
788	>	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&)
789		{
790	+	if(doLumiInfo){
791	+	edm::Handle<LumiSummary> l;
792	+	lumi.getByLabel("lumiProducer", l);
793	+
794	+	//add lumi of lumi blocks without any event to next lumiblock
795	+	if(previouslumiblockwasfilled){
796	+	intgRecLumi=0;
797	+	intgDelLumi=0;
798	+	}
799	+	previouslumiblockwasfilled=false;
800	+
801	+	if (l.isValid()){;
802	+	intgRecLumi+=l->intgRecLumi()*6.37;
803	+	intgDelLumi+=l->intgDelLumi()*6.37;
804	+	totalRecLumi+=l->intgRecLumi()*6.37;
805	+	totalDelLumi+=l->intgDelLumi()*6.37;
806	+	}
807	+	//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<"   " << l->intgDelLumi()*6.37<<std::endl;
808	+	//std::cout << "summed:  "<< intgRecLumi << "   " << intgDelLumi << std::endl;
809	+	}
810		}
811
812		// ------------ method called when ending the processing of a luminosity block  ------------

Diff Legend

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