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.13 by peiffer, Thu Apr 19 14:47:13 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 171 | Line 179 | NtupleWriter::analyze(const edm::Event&
179		}
180		else HBHENoiseFilterResult = false;
181
182	+	// ------------- primary vertices and beamspot  -------------
183	+
184	+	if(doPV){
185	+	for(size_t j=0; j< pv_sources.size(); ++j){
186	+	pvs[j].clear();
187	+
188	+	edm::Handle< std::vector<reco::Vertex> > pv_handle;
189	+	iEvent.getByLabel(pv_sources[j], pv_handle);
190	+	const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product());
191	+
192	+	for (unsigned int i = 0; i <  reco_pvs.size(); ++i) {
193	+	reco::Vertex reco_pv = reco_pvs[i];
194	+
195	+	PrimaryVertex pv;
196	+	pv.x =  reco_pv.x();
197	+	pv.y =  reco_pv.y();
198	+	pv.z =  reco_pv.z();
199	+	pv.nTracks =  reco_pv.nTracks();
200	+	//pv.isValid =  reco_pv.isValid();
201	+	pv.chi2 =  reco_pv.chi2();
202	+	pv.ndof =  reco_pv.ndof();
203	+
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	+	}
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 198 | Line 249 | NtupleWriter::analyze(const edm::Event&
249		ele.neutralHadronIso = pat_ele.neutralHadronIso();
250		ele.chargedHadronIso = pat_ele.chargedHadronIso();
251		ele.trackIso = pat_ele.trackIso();
252	+	ele.photonIso = pat_ele.photonIso();
253		ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
254	+	ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
255	+	ele.gsfTrack_px= pat_ele.gsfTrack()->px();
256	+	ele.gsfTrack_py= pat_ele.gsfTrack()->py();
257	+	ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
258	+	ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
259	+	ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
260	+	ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
261	+	ele.passconversionveto = !ConversionTools::hasMatchedConversion(pat_ele,hConversions,bsp.position());
262	+	ele.dEtaIn=pat_ele.deltaEtaSuperClusterTrackAtVtx();
263	+	ele.dPhiIn=pat_ele.deltaPhiSuperClusterTrackAtVtx();
264	+	ele.sigmaIEtaIEta=pat_ele.sigmaIetaIeta();
265	+	ele.HoverE=pat_ele.hadronicOverEm();
266	+	ele.fbrem=pat_ele.fbrem();
267	+	ele.EoverPIn=pat_ele.eSuperClusterOverP();
268	+	ele.EcalEnergy=pat_ele.ecalEnergy();
269	+	ele.mvaTrigV0=pat_ele.electronID("mvaTrigV0");
270	+	ele.mvaNonTrigV0=pat_ele.electronID("mvaNonTrigV0");
271
272		eles[j].push_back(ele);
273		}
#	Line 231 | Line 300 | NtupleWriter::analyze(const edm::Event&
300		mu.neutralHadronIso = pat_mu.neutralHadronIso();
301		mu.chargedHadronIso = pat_mu.chargedHadronIso();
302		mu.trackIso = pat_mu.trackIso();
303	+	mu.photonIso = pat_mu.photonIso();
304		mu.puChargedHadronIso = pat_mu.puChargedHadronIso();
305		mu.isGlobalMuon = pat_mu.isGlobalMuon();
306		mu.isStandAloneMuon = pat_mu.isStandAloneMuon();
#	Line 261 | Line 331 | NtupleWriter::analyze(const edm::Event&
331		mu.innerTrack_d0Error = innerTrack->d0Error();
332		mu.innerTrack_numberOfValidHits = innerTrack->numberOfValidHits();
333		mu.innerTrack_numberOfLostHits = innerTrack->numberOfLostHits();
334	+	mu.innerTrack_trackerLayersWithMeasurement = innerTrack->hitPattern().trackerLayersWithMeasurement();
335	+	mu.innerTrack_numberOfValidPixelHits = innerTrack->hitPattern().numberOfValidPixelHits();
336		}
337		else{
338		mu.innerTrack_chi2 = 0;
#	Line 269 | Line 341 | NtupleWriter::analyze(const edm::Event&
341		mu.innerTrack_d0Error = 0;
342		mu.innerTrack_numberOfValidHits = 0;
343		mu.innerTrack_numberOfLostHits = 0;
344	+	mu.innerTrack_trackerLayersWithMeasurement = 0;
345	+	mu.innerTrack_numberOfValidPixelHits = 0;
346		}
347		reco::TrackRef outerTrack = pat_mu.outerTrack();
348		if(!outerTrack.isNull()){
#	Line 314 | Line 388 | NtupleWriter::analyze(const edm::Event&
388		tau.eta =  pat_tau.eta();
389		tau.phi =  pat_tau.phi();
390		tau.energy =  pat_tau.energy();
391	<
391	>	tau.decayModeFinding = pat_tau.tauID("decayModeFinding")>0.5;
392	>	tau.byVLooseCombinedIsolationDeltaBetaCorr  = pat_tau.tauID("byVLooseCombinedIsolationDeltaBetaCorr")>0.5;
393	>	tau.byLooseCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byLooseCombinedIsolationDeltaBetaCorr")>0.5;
394	>	tau.byMediumCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byMediumCombinedIsolationDeltaBetaCorr")>0.5;
395	>	tau.byTightCombinedIsolationDeltaBetaCorr = pat_tau.tauID("byTightCombinedIsolationDeltaBetaCorr")>0.5;
396	>	tau.againstElectronLoose  = pat_tau.tauID("againstElectronLoose")>0.5;
397	>	tau.againstElectronMedium = pat_tau.tauID("againstElectronMedium")>0.5;
398	>	tau.againstElectronTight = pat_tau.tauID("againstElectronTight")>0.5;
399	>	tau.againstElectronMVA  = pat_tau.tauID("againstElectronMVA")>0.5;
400	>	tau.againstMuonLoose = pat_tau.tauID("againstMuonLoose")>0.5;
401	>	tau.againstMuonMedium = pat_tau.tauID("againstMuonMedium")>0.5;
402	>	tau.againstMuonTight = pat_tau.tauID("againstMuonTight")>0.5;
403	>
404	>	reco::PFCandidateRef leadPFCand = pat_tau.leadPFCand();
405	>	if(!leadPFCand.isNull()){
406	>	tau.leadPFCand_px = leadPFCand->px();
407	>	tau.leadPFCand_py = leadPFCand->py();
408	>	tau.leadPFCand_pz = leadPFCand->pz();
409	>	}
410	>	else{
411	>	tau.leadPFCand_px = 0;
412	>	tau.leadPFCand_py = 0;
413	>	tau.leadPFCand_pz = 0;
414	>	}
415		taus[j].push_back(tau);
416		}
417		}
#	Line 364 | Line 461 | NtupleWriter::analyze(const edm::Event&
461		jet.electronMultiplicity =pat_jet.electronMultiplicity();
462		jet.photonMultiplicity =pat_jet.photonMultiplicity();
463		}
464	+
465	+	jecUnc->setJetEta(pat_jet.eta());
466	+	jecUnc->setJetPt(pat_jet.pt());
467	+	jet.JEC_uncertainty = jecUnc->getUncertainty(true);
468	+	jet.JEC_factor_raw = pat_jet.jecFactor("Uncorrected");
469	+
470		jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
471		jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
472		jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
#	Line 371 | Line 474 | NtupleWriter::analyze(const edm::Event&
474		jet.btag_jetBProbability=pat_jet.bDiscriminator("jetBProbabilityBJetTags");
475		jet.btag_jetProbability=pat_jet.bDiscriminator("jetProbabilityBJetTags");
476
477	+	const reco::GenJet *genj = pat_jet.genJet();
478	+	if(genj){
479	+	jet.genjet_pt = genj->pt();
480	+	jet.genjet_eta = genj->eta();
481	+	jet.genjet_phi = genj->phi();
482	+	jet.genjet_energy = genj->energy();
483	+	}
484	+
485		jets[j].push_back(jet);
486		}
487		}
#	Line 414 | Line 525 | NtupleWriter::analyze(const edm::Event&
525		//       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
526		//       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
527
528	+	jecUnc->setJetEta(pat_topjet.eta());
529	+	jecUnc->setJetPt(pat_topjet.pt());
530	+	topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
531	+	topjet.JEC_factor_raw = pat_topjet.jecFactor("Uncorrected");
532	+
533		topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
534		topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
535		topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
#	Line 421 | Line 537 | NtupleWriter::analyze(const edm::Event&
537		topjet.btag_jetBProbability=pat_topjet.bDiscriminator("jetBProbabilityBJetTags");
538		topjet.btag_jetProbability=pat_topjet.bDiscriminator("jetProbabilityBJetTags");
539
540	+	const reco::GenJet *genj = pat_topjet.genJet();
541	+	if(genj){
542	+	topjet.genjet_pt = genj->pt();
543	+	topjet.genjet_eta = genj->eta();
544	+	topjet.genjet_phi = genj->phi();
545	+	topjet.genjet_energy = genj->energy();
546	+	}
547	+
548		for (unsigned int k = 0; k < pat_topjet.numberOfDaughters(); k++) {
549		Particle subjet_v4;
550		subjet_v4.pt = pat_topjet.daughter(k)->p4().pt();
#	Line 487 | Line 611 | NtupleWriter::analyze(const edm::Event&
611		}
612
613		// ------------- trigger -------------
614	<
615	<	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
616	<	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
617	<	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
618	<
619	<	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
620	<	std::string nameProcess = meta->processName();
621	<	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
622	<	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
623	<
624	<	edm::Handle<edm::TriggerResults> trigger;
625	<	iEvent.getByLabel(triggerResultTag, trigger);
626	<	const edm::TriggerResults& trig = *(trigger.product());
627	<
628	<	triggerResults.clear();
629	<	triggerNames.clear();
630	<	L1_prescale.clear();
631	<	HLT_prescale.clear();
632	<
633	<	edm::Service<edm::service::TriggerNamesService> tns;
634	<	std::vector<std::string> triggerNames_all;
635	<	tns->getTrigPaths(trig,triggerNames_all);
636	<
637	<	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
638	<	for(unsigned int i=0; i<trig.size(); ++i){
639	<	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
640	<	for(; it!=trigger_prefixes.end(); ++it){
641	<	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
642	<	}
643	<	if(it==trigger_prefixes.end()) continue;
644	<
645	<	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
646	<	triggerResults.push_back(trig.accept(i));
647	<	if(newrun) triggerNames.push_back(triggerNames_all[i]);
648	<	if(isRealData){
649	<	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
650	<	L1_prescale.push_back(pre.first);
651	<	HLT_prescale.push_back(pre.second);
652	<	}
653	<	}
654	<	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
655	<	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
656	<	//    }
657	<	newrun=false;
614	>	if(doTrigger){
615	>	edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
616	>	edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
617	>	iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
618	>
619	>	const edm::Provenance *meta = dummy_TriggerEvent.provenance();
620	>	std::string nameProcess = meta->processName();
621	>	edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
622	>	triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
623	>
624	>	edm::Handle<edm::TriggerResults> trigger;
625	>	iEvent.getByLabel(triggerResultTag, trigger);
626	>	const edm::TriggerResults& trig = *(trigger.product());
627	>
628	>	triggerResults.clear();
629	>	triggerNames.clear();
630	>	L1_prescale.clear();
631	>	HLT_prescale.clear();
632	>
633	>	edm::Service<edm::service::TriggerNamesService> tns;
634	>	std::vector<std::string> triggerNames_all;
635	>	tns->getTrigPaths(trig,triggerNames_all);
636	>
637	>	if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
638	>	for(unsigned int i=0; i<trig.size(); ++i){
639	>	std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
640	>	for(; it!=trigger_prefixes.end(); ++it){
641	>	if(triggerNames_all[i].substr(0, it->size()) == *it)break;
642	>	}
643	>	if(it==trigger_prefixes.end()) continue;
644	>
645	>	//triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
646	>	triggerResults.push_back(trig.accept(i));
647	>	if(newrun) triggerNames.push_back(triggerNames_all[i]);
648	>	if(isRealData){
649	>	std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
650	>	L1_prescale.push_back(pre.first);
651	>	HLT_prescale.push_back(pre.second);
652	>	//std::cout <<  triggerNames_all[i] << " " << pre.first << " " <<pre.second << "   " << hlt_cfg.prescaleValue(iEvent, iSetup, triggerNames_all[i]) << std::endl;
653	>	}
654	>	}
655	>	//    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
656	>	//      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
657	>	//    }
658	>	newrun=false;
659	>	}
660
661		// ------------- generator info -------------
662
#	Line 595 | Line 721 | NtupleWriter::analyze(const edm::Event&
721		index++;
722
723		//write out only top quarks and status 3 particles (works fine only for MadGraph)
724	<	if(abs(iter->pdgId())==6 || iter->status()==3){
724	>	if(abs(iter->pdgId())==6 || iter->status()==3 || doAllGenParticles){
725		GenParticle genp;
726		genp.charge = iter->charge();;
727		genp.pt = iter->p4().pt();
#	Line 625 | Line 751 | NtupleWriter::analyze(const edm::Event&
751
752		}
753
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	–
754		tr->Fill();
755	<
755	>	if(doLumiInfo)
756	>	previouslumiblockwasfilled=true;
757		}
758
759
#	Line 669 | Line 761 | NtupleWriter::analyze(const edm::Event&
761		void
762		NtupleWriter::beginJob()
763		{
764	+	if(doLumiInfo){
765	+	totalRecLumi=0;
766	+	totalDelLumi=0;
767	+	previouslumiblockwasfilled=false;
768	+	}
769		}
770
771		// ------------ method called once each job just after ending the event loop  ------------
#	Line 684 | Line 781 | NtupleWriter::endJob()
781		void
782		NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
783		{
784	<	bool setup_changed = false;
785	<	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
786	<	newrun=true;
784	>	if(doTrigger){
785	>	bool setup_changed = false;
786	>	hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
787	>	newrun=true;
788	>	}
789	>
790	>	if(doJets || doTopJets){
791	>	edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
792	>	iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
793	>	JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
794	>	jecUnc = new JetCorrectionUncertainty(JetCorPar);
795	>	}
796		}
797
798		// ------------ method called when ending the processing of a run  ------------
799		void
800		NtupleWriter::endRun(edm::Run const&, edm::EventSetup const&)
801		{
802	+	if(doLumiInfo)
803	+	std::cout << "total integ. luminosity: " << totalDelLumi <<"(del) " << totalRecLumi << "(rec)" << std::endl;
804		}
805
806		// ------------ method called when starting to processes a luminosity block  ------------
807		void
808	<	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
808	>	NtupleWriter::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const&)
809		{
810	+	if(doLumiInfo){
811	+	edm::Handle<LumiSummary> l;
812	+	lumi.getByLabel("lumiProducer", l);
813	+
814	+	//add lumi of lumi blocks without any event to next lumiblock
815	+	if(previouslumiblockwasfilled){
816	+	intgRecLumi=0;
817	+	intgDelLumi=0;
818	+	}
819	+	previouslumiblockwasfilled=false;
820	+
821	+	if (l.isValid()){;
822	+	intgRecLumi+=l->intgRecLumi()*6.37;
823	+	intgDelLumi+=l->intgDelLumi()*6.37;
824	+	totalRecLumi+=l->intgRecLumi()*6.37;
825	+	totalDelLumi+=l->intgDelLumi()*6.37;
826	+	}
827	+	//std::cout << "this lb: " <<l->intgRecLumi()*6.37 <<"   " << l->intgDelLumi()*6.37<<std::endl;
828	+	//std::cout << "summed:  "<< intgRecLumi << "   " << intgDelLumi << std::endl;
829	+	}
830		}
831
832		// ------------ method called when ending the processing of a luminosity block  ------------

Diff Legend

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