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

Comparing UserCode/CmsHi/JetAnalysis/src/HiJetResponseAnalyzer.cc (file contents):
Revision 1.5 by yilmaz, Wed Sep 29 15:59:10 2010 UTC vs.
Revision 1.7 by yilmaz, Thu Oct 21 11:26:40 2010 UTC

# Line 42 | Line 42
42  
43   #include "CommonTools/UtilAlgos/interface/TFileService.h"
44   #include "FWCore/ServiceRegistry/interface/Service.h"
45 <
45 > #include "DataFormats/Math/interface/deltaR.h"
46  
47   #include "TTree.h"
48  
# Line 72 | Line 72 | struct JRA{
72     float weight;
73   };
74  
75 +
76 + struct JRAV{
77 +
78 +  float jtpt;
79 +  float jtcorpt;
80 +  float refpt;
81 +  float refcorpt;
82 +  float jteta;
83 +  float refeta;
84 +  float jtphi;
85 +  float refphi;
86 +
87 + };
88 +
89   //
90   // class declaration
91   //
92 + bool compareCorPt(JRAV a, JRAV b) {return a.jtcorpt > b.jtcorpt;}
93 + bool comparePt(JRAV a, JRAV b) {return a.jtpt > b.jtpt;}
94  
95   class HiJetResponseAnalyzer : public edm::EDAnalyzer {
96     public:
# Line 87 | Line 103 | class HiJetResponseAnalyzer : public edm
103        virtual void analyze(const edm::Event&, const edm::EventSetup&);
104        virtual void endJob() ;
105     bool selectJet(int i);
90 –
106        // ----------member data ---------------------------
107  
108 <   bool usePat_;
109 <   bool doMC_;
110 <   bool filterJets_;
111 <   bool diJetsOnly_;
112 <   bool matchDiJets_;
108 >  bool usePat_;
109 >  bool doMC_;
110 >  bool filterJets_;
111 >  bool diJetsOnly_;
112 >  bool matchDiJets_;
113 >  bool matchPatGen_;
114 >  bool matchNew_;
115 >  bool sortJets_;
116 >  bool correctJets_;
117  
118 +  double matchR_;  
119     double genPtMin_;
120     double ptMin_;
121     double emfMin_;
# Line 103 | Line 123 | class HiJetResponseAnalyzer : public edm
123     double n90hitMin_;
124  
125     edm::InputTag jetTag_;
126 +  edm::InputTag matchTag_;
127  
128     JRA jra_;
129     TTree* t;
# Line 112 | Line 133 | class HiJetResponseAnalyzer : public edm
133  
134     edm::Handle<reco::JetView> jets;
135     edm::Handle<pat::JetCollection> patjets;
136 +  edm::Handle<reco::JetView> matchedJets;
137  
138     edm::Service<TFileService> fs;
139  
140   };
141  
142   bool HiJetResponseAnalyzer::selectJet(int i){
121 –  
143     const reco::Jet& jet = (*jets)[i];
123 –  
144     if(usePat_){
125 –      //      cout<<"a"<<endl;
145        const pat::Jet& patjet = (*patjets)[i];
127 –      //      cout<<"b"<<endl;
128 –      
146        if(patjet.emEnergyFraction() <= emfMin_) return false;
130 –      //      cout<<"c"<<endl;
131 –
147        if(patjet.jetID().n90Hits <= n90hitMin_) return false;
133 –      //      cout<<"d"<<endl;
134 –
148        if(doMC_){
149          
150        }
# Line 139 | Line 152 | bool HiJetResponseAnalyzer::selectJet(in
152     }
153  
154     return true;
142 –
155   }
156  
157  
146 –
158   //
159   // constants, enums and typedefs
160   //
# Line 159 | Line 170 | HiJetResponseAnalyzer::HiJetResponseAnal
170  
171   {
172     //now do what ever initialization is needed
173 +  matchR_ = iConfig.getUntrackedParameter<double>("matchR",0.25);
174  
175     ptMin_ = iConfig.getUntrackedParameter<double>("ptMin",0);
176 <   genPtMin_ = iConfig.getUntrackedParameter<double>("genPtMin",0);
177 <   emfMin_ = iConfig.getUntrackedParameter<double>("emfMin",0);
178 <   n90Min_ = iConfig.getUntrackedParameter<double>("n90Min",0);
179 <   n90hitMin_ = iConfig.getUntrackedParameter<double>("n90hitMin",0);
176 >   genPtMin_ = iConfig.getUntrackedParameter<double>("genPtMin",20);
177 >   emfMin_ = iConfig.getUntrackedParameter<double>("emfMin",0.01);
178 >   n90Min_ = iConfig.getUntrackedParameter<double>("n90Min",1);
179 >   n90hitMin_ = iConfig.getUntrackedParameter<double>("n90hitMin",1);
180  
181     filterJets_ = iConfig.getUntrackedParameter<bool>("filterJets",true);
182 <   diJetsOnly_ = iConfig.getUntrackedParameter<bool>("diJetsOnly",true);
183 <   matchDiJets_ = iConfig.getUntrackedParameter<bool>("usePat",true);
182 >   diJetsOnly_ = iConfig.getUntrackedParameter<bool>("diJetsOnly",false);
183 >   matchDiJets_ = iConfig.getUntrackedParameter<bool>("matchDiJets",false);
184 >   matchPatGen_ = iConfig.getUntrackedParameter<bool>("matchPatGen",false);
185 >
186 >   matchNew_ = iConfig.getUntrackedParameter<bool>("matchNew",false);
187 >
188     usePat_ = iConfig.getUntrackedParameter<bool>("usePat",true);
189     doMC_ = iConfig.getUntrackedParameter<bool>("doMC",true);
174 –   jetTag_ = iConfig.getUntrackedParameter<edm::InputTag>("src",edm::InputTag("selectedPatJets"));
190  
191 +   sortJets_ = iConfig.getUntrackedParameter<bool>("sortJets",true);
192 +   correctJets_ = iConfig.getUntrackedParameter<bool>("correctJets",false);
193 +
194 +   jetTag_ = iConfig.getUntrackedParameter<edm::InputTag>("src",edm::InputTag("selectedPatJets"));
195 +   matchTag_ = iConfig.getUntrackedParameter<edm::InputTag>("match",edm::InputTag("selectedPatJets"));
196   }
197  
198  
# Line 197 | Line 217 | HiJetResponseAnalyzer::analyze(const edm
217  
218     iEvent.getByLabel(jetTag_,jets);
219     if(usePat_)iEvent.getByLabel(jetTag_,patjets);
220 +   if(matchNew_)iEvent.getByLabel(matchTag_,matchedJets);
221 +
222 +   std::vector<JRAV> jraV;
223  
201 –   jra_.nref = 0;
224     for(unsigned int j = 0 ; j < jets->size(); ++j){
225 <      
226 <      //      const pat::Jet& jet = (*jets)[j];
227 <      if(filterJets_ && !selectJet(j)) continue;
228 <
229 <      const reco::Jet& jet = (*jets)[j];      
230 <
231 <      jra_.jtpt[jra_.nref] = jet.pt();
232 <      jra_.jteta[jra_.nref] = jet.eta();
233 <      jra_.jtphi[jra_.nref] = jet.phi();
234 <      jra_.jtcorpt[jra_.nref] = jet.pt();
225 >     if(filterJets_ && !selectJet(j)) continue;
226 >     const reco::Jet& jet = (*jets)[j];
227 >     JRAV jv;
228 >     jv.jtpt = jet.pt();
229 >     jv.jteta = jet.eta();
230 >     jv.jtphi = jet.phi();
231 >     jv.jtcorpt = jet.pt();
232 >
233 >     if(usePat_){
234 >       const pat::Jet& patjet = (*patjets)[j];
235 >
236 >       jv.jtpt = patjet.correctedJet("raw").pt();
237 >       jv.jtcorpt = patjet.pt();
238 >
239 >       if(doMC_ && matchPatGen_ && patjet.genJet() != 0){
240 >         if(patjet.genJet()->pt() < genPtMin_) continue;
241 >         jv.refpt = patjet.genJet()->pt();
242 >         jv.refeta = patjet.genJet()->eta();
243 >         jv.refphi = patjet.genJet()->phi();
244 >
245 >       }else{
246 >         jv.refpt = -99;
247 >         jv.refeta = -99;
248 >         jv.refphi = -99;
249 >       }
250 >     }
251 >
252 >     if(matchNew_){
253 >       for(unsigned int m = 0 ; m < matchedJets->size(); ++m){
254 >         const reco::Jet& match = (*matchedJets)[m];
255 >         double dr = reco::deltaR(jet.eta(),jet.phi(),match.eta(),match.phi());
256 >         if(dr < matchR_){
257 >           jv.refcorpt = -99;
258 >           jv.refpt = match.pt();
259 >           jv.refeta = match.eta();
260 >           jv.refphi = match.phi();
261 >         }
262 >       }
263 >     }
264 >     jraV.push_back(jv);
265 >   }
266  
267 <      if(usePat_){
268 <         const pat::Jet& patjet = (*patjets)[j];
267 >   if(sortJets_){
268 >     if(usePat_ || correctJets_) std::sort(jraV.begin(),jraV.end(),compareCorPt);
269 >     else std::sort(jraV.begin(),jraV.end(),comparePt);
270 >   }
271  
272 <         jra_.jtpt[jra_.nref] = patjet.correctedJet("raw").pt();
273 <         jra_.jtcorpt[jra_.nref] = patjet.pt();
274 <        
275 <         if(doMC_ && patjet.genJet() != 0){        
276 <            if(patjet.genJet()->pt() < genPtMin_) continue;
277 <            jra_.refpt[jra_.nref] = patjet.genJet()->pt();
278 <            jra_.refeta[jra_.nref] = patjet.genJet()->eta();
279 <            jra_.refphi[jra_.nref] = patjet.genJet()->phi();
280 <                            
226 <         }else{
227 <            jra_.refpt[jra_.nref] = -99;
228 <            jra_.refeta[jra_.nref] = -99;
229 <            jra_.refphi[jra_.nref] = -99;
230 <         }
231 <      }
232 <      
233 <      jra_.nref++;
234 <      
272 >   for(unsigned int i = 0; i < jraV.size(); ++i){
273 >     JRAV& jv = jraV[i];
274 >     jra_.jtpt[i] = jv.jtpt;
275 >     jra_.jteta[i] = jv.jteta;
276 >     jra_.jtphi[i] = jv.jtphi;
277 >     jra_.jtcorpt[i] = jv.jtcorpt;
278 >     jra_.refpt[i] = jv.refpt;
279 >     jra_.refeta[i] = jv.refeta;
280 >     jra_.refphi[i] = jv.refphi;
281     }
282 +   jra_.nref = jraV.size();
283  
284     t->Fill();
285  
# Line 251 | Line 298 | HiJetResponseAnalyzer::beginJob()
298     t->Branch("jtpt",jra_.jtpt,"jtpt[nref]/F");
299     t->Branch("jtcorpt",jra_.jtcorpt,"jtcorpt[nref]/F");
300     t->Branch("refpt",jra_.refpt,"refpt[nref]/F");
301 +   t->Branch("refcorpt",jra_.refpt,"refcorpt[nref]/F");
302     t->Branch("jteta",jra_.jteta,"jteta[nref]/F");
303     t->Branch("refeta",jra_.refeta,"refeta[nref]/F");
304     t->Branch("jtphi",jra_.jtphi,"jtphi[nref]/F");

Diff Legend

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