ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/UHHAnalysis/NtupleWriter/src/NtupleWriter.cc
(Generate patch)

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.7 by peiffer, Wed Apr 11 15:32:13 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 125 | Line 126 | NtupleWriter::NtupleWriter(const edm::Pa
126      tr->Branch("genInfo","GenInfo",&genInfo);
127      tr->Branch("GenParticles","std::vector<GenParticle>", &genps);
128    }
129 <
130 <  trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
131 <  //tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
132 <  tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);  
133 <  tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
134 <  tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
135 <  tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
136 <
129 >  if(doTrigger){
130 >    trigger_prefixes = iConfig.getParameter<std::vector<std::string> >("trigger_prefixes");
131 >    //tr->Branch("triggerResults","std::map<std::string, bool>",&triggerResults);
132 >    tr->Branch("triggerNames", "std::vector<std::string>", &triggerNames);  
133 >    tr->Branch("triggerResults", "std::vector<bool>", &triggerResults);
134 >    tr->Branch("L1_prescale", "std::vector<int>", &L1_prescale);
135 >    tr->Branch("HLT_prescale", "std::vector<int>", &HLT_prescale);
136 >  }
137    newrun = true;
138   }
139  
# Line 171 | Line 172 | NtupleWriter::analyze(const edm::Event&
172     }
173     else HBHENoiseFilterResult = false;
174  
175 +   // ------------- primary vertices and beamspot  -------------
176 +
177 +   if(doPV){
178 +     for(size_t j=0; j< pv_sources.size(); ++j){
179 +       pvs[j].clear();
180 +      
181 +       edm::Handle< std::vector<reco::Vertex> > pv_handle;
182 +       iEvent.getByLabel(pv_sources[j], pv_handle);
183 +       const std::vector<reco::Vertex>& reco_pvs = *(pv_handle.product());
184 +      
185 +       for (unsigned int i = 0; i <  reco_pvs.size(); ++i) {
186 +         reco::Vertex reco_pv = reco_pvs[i];
187 +
188 +         PrimaryVertex pv;
189 +         pv.x =  reco_pv.x();
190 +         pv.y =  reco_pv.y();
191 +         pv.z =  reco_pv.z();
192 +         pv.nTracks =  reco_pv.nTracks();
193 +         //pv.isValid =  reco_pv.isValid();
194 +         pv.chi2 =  reco_pv.chi2();
195 +         pv.ndof =  reco_pv.ndof();      
196 +
197 +         pvs[j].push_back(pv);
198 +       }
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     // ------------- electrons -------------  
211     if(doElectrons){
212       for(size_t j=0; j< electron_sources.size(); ++j){
# Line 199 | Line 235 | NtupleWriter::analyze(const edm::Event&
235           ele.chargedHadronIso = pat_ele.chargedHadronIso();
236           ele.trackIso = pat_ele.trackIso();
237           ele.puChargedHadronIso = pat_ele.puChargedHadronIso();
238 <
238 >         ele.gsfTrack_trackerExpectedHitsInner_numberOfLostHits = pat_ele.gsfTrack()->trackerExpectedHitsInner().numberOfLostHits();
239 >         ele.gsfTrack_px= pat_ele.gsfTrack()->px();
240 >         ele.gsfTrack_py= pat_ele.gsfTrack()->py();
241 >         ele.gsfTrack_pz= pat_ele.gsfTrack()->pz();
242 >         ele.gsfTrack_vx= pat_ele.gsfTrack()->vx();
243 >         ele.gsfTrack_vy= pat_ele.gsfTrack()->vy();
244 >         ele.gsfTrack_vz= pat_ele.gsfTrack()->vz();
245           eles[j].push_back(ele);
246         }
247       }
# Line 364 | Line 406 | NtupleWriter::analyze(const edm::Event&
406             jet.electronMultiplicity =pat_jet.electronMultiplicity();
407             jet.photonMultiplicity =pat_jet.photonMultiplicity();
408           }
409 +
410 +         jecUnc->setJetEta(pat_jet.eta());
411 +         jecUnc->setJetPt(pat_jet.pt());
412 +         jet.JEC_uncertainty = jecUnc->getUncertainty(true);
413 +
414           jet.btag_simpleSecondaryVertexHighEff=pat_jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
415           jet.btag_simpleSecondaryVertexHighPur=pat_jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
416           jet.btag_combinedSecondaryVertex=pat_jet.bDiscriminator("combinedSecondaryVertexBJetTags");
# Line 414 | Line 461 | NtupleWriter::analyze(const edm::Event&
461   //       topjet.electronMultiplicity =pat_topjet.electronMultiplicity();
462   //       topjet.photonMultiplicity =pat_topjet.photonMultiplicity();
463  
464 +         jecUnc->setJetEta(pat_topjet.eta());
465 +         jecUnc->setJetPt(pat_topjet.pt());
466 +         topjet.JEC_uncertainty = jecUnc->getUncertainty(true);
467 +
468           topjet.btag_simpleSecondaryVertexHighEff=pat_topjet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags");
469           topjet.btag_simpleSecondaryVertexHighPur=pat_topjet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags");
470           topjet.btag_combinedSecondaryVertex=pat_topjet.bDiscriminator("combinedSecondaryVertexBJetTags");
# Line 487 | Line 538 | NtupleWriter::analyze(const edm::Event&
538     }
539  
540     // ------------- trigger -------------
541 <  
542 <   edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
543 <   edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
544 <   iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
545 <  
546 <   const edm::Provenance *meta = dummy_TriggerEvent.provenance();
547 <   std::string nameProcess = meta->processName();
548 <   edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
549 <   triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
550 <  
551 <   edm::Handle<edm::TriggerResults> trigger;
552 <   iEvent.getByLabel(triggerResultTag, trigger);
553 <   const edm::TriggerResults& trig = *(trigger.product());
554 <  
555 <   triggerResults.clear();
556 <   triggerNames.clear();
557 <   L1_prescale.clear();
558 <   HLT_prescale.clear();
559 <
560 <   edm::Service<edm::service::TriggerNamesService> tns;
561 <   std::vector<std::string> triggerNames_all;
562 <   tns->getTrigPaths(trig,triggerNames_all);
563 <
564 <   if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
565 <   for(unsigned int i=0; i<trig.size(); ++i){
566 <     std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
567 <     for(; it!=trigger_prefixes.end(); ++it){
568 <       if(triggerNames_all[i].substr(0, it->size()) == *it)break;
569 <     }
570 <     if(it==trigger_prefixes.end()) continue;
571 <
572 <     //triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
573 <     triggerResults.push_back(trig.accept(i));
574 <     if(newrun) triggerNames.push_back(triggerNames_all[i]);
575 <     if(isRealData){
576 <       std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
577 <       L1_prescale.push_back(pre.first);
578 <       HLT_prescale.push_back(pre.second);
579 <     }
580 <   }
581 < //    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
582 < //      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
583 < //    }
584 <   newrun=false;
541 >   if(doTrigger){
542 >     edm::InputTag triggerEvent = edm::InputTag("hltTriggerSummaryAOD");
543 >     edm::Handle< trigger::TriggerEvent > dummy_TriggerEvent;
544 >     iEvent.getByLabel( edm::InputTag(triggerEvent.label(), triggerEvent.instance()), dummy_TriggerEvent );
545 >    
546 >     const edm::Provenance *meta = dummy_TriggerEvent.provenance();
547 >     std::string nameProcess = meta->processName();
548 >     edm::InputTag triggerResultTag = edm::InputTag("TriggerResults");
549 >     triggerResultTag = edm::InputTag( triggerResultTag.label(), triggerResultTag.instance(), nameProcess );
550 >    
551 >     edm::Handle<edm::TriggerResults> trigger;
552 >     iEvent.getByLabel(triggerResultTag, trigger);
553 >     const edm::TriggerResults& trig = *(trigger.product());
554 >    
555 >     triggerResults.clear();
556 >     triggerNames.clear();
557 >     L1_prescale.clear();
558 >     HLT_prescale.clear();
559 >    
560 >     edm::Service<edm::service::TriggerNamesService> tns;
561 >     std::vector<std::string> triggerNames_all;
562 >     tns->getTrigPaths(trig,triggerNames_all);
563 >    
564 >     if (trig.size()!=triggerNames_all.size()) std::cout <<"ERROR: length of names and paths not the same: "<<triggerNames_all.size()<<","<<trig.size()<< std::endl;
565 >     for(unsigned int i=0; i<trig.size(); ++i){
566 >       std::vector<std::string>::const_iterator it = trigger_prefixes.begin();
567 >       for(; it!=trigger_prefixes.end(); ++it){
568 >         if(triggerNames_all[i].substr(0, it->size()) == *it)break;
569 >       }
570 >       if(it==trigger_prefixes.end()) continue;
571 >      
572 >       //triggerResults.insert(std::pair<std::string, bool>(triggerNames[i],trig.accept(i)));
573 >       triggerResults.push_back(trig.accept(i));
574 >       if(newrun) triggerNames.push_back(triggerNames_all[i]);
575 >       if(isRealData){
576 >         std::pair<int, int> pre=hlt_cfg.prescaleValues(iEvent, iSetup, triggerNames_all[i]);
577 >         L1_prescale.push_back(pre.first);
578 >         HLT_prescale.push_back(pre.second);
579 >       }
580 >     }
581 >     //    for(std::map<std::string, bool>::const_iterator iter = triggerResults.begin(); iter!=triggerResults.end(); iter++){
582 >     //      std::cout << (*iter).first << "   " << (*iter).second << std::endl;
583 >     //    }
584 >     newrun=false;
585 >   }
586  
587     // ------------- generator info -------------
588    
# Line 625 | Line 677 | NtupleWriter::analyze(const edm::Event&
677  
678     }
679  
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();
680  
681     tr->Fill();
682  
# Line 684 | Line 702 | NtupleWriter::endJob()
702   void
703   NtupleWriter::beginRun(edm::Run const& iRun, edm::EventSetup const&  iSetup)
704   {
705 <  bool setup_changed = false;
706 <  hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
707 <  newrun=true;
705 >  if(doTrigger){
706 >    bool setup_changed = false;
707 >    hlt_cfg.init(iRun, iSetup, "HLT", setup_changed);
708 >    newrun=true;
709 >  }
710 >
711 >  if(doJets || doTopJets){
712 >    edm::ESHandle<JetCorrectorParametersCollection> JetCorParColl;
713 >    iSetup.get<JetCorrectionsRecord>().get("AK5PF",JetCorParColl);
714 >    JetCorrectorParameters const & JetCorPar = (*JetCorParColl)["Uncertainty"];
715 >    jecUnc = new JetCorrectionUncertainty(JetCorPar);
716 >  }
717   }
718  
719   // ------------ method called when ending the processing of a run  ------------

Diff Legend

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