17 |
|
#include <TH1F.h> |
18 |
|
#include <TCanvas.h> |
19 |
|
#include <TLegend.h> |
20 |
+ |
#include <TMath.h> |
21 |
|
|
22 |
|
#include <iostream> |
23 |
|
#include <iomanip> |
48 |
|
|
49 |
|
vector<string> input = cl.get_vector<string>("input"); |
50 |
|
string treename = cl.get_value<string> ("treename", "t"); |
51 |
< |
double drmax = cl.get_value<double> ("drmax", 0.3); |
52 |
< |
int nptbins = cl.get_value<int> ("nptbins", 50); |
51 |
> |
float drmax = cl.get_value<float> ("drmax", 0.3); |
52 |
> |
int netbins = cl.get_value<int> ("netbins", 50); |
53 |
|
int netabins = cl.get_value<int> ("netabins", 25); |
54 |
|
int nphibins = cl.get_value<int> ("nphibins", 25); |
55 |
< |
double ptmin = cl.get_value<double> ("ptmin", 0.0); |
56 |
< |
double ptmax = cl.get_value<double> ("ptmax", 200.0); |
57 |
< |
double etamin = cl.get_value<double> ("etamin", -5.0); |
58 |
< |
double etamax = cl.get_value<double> ("etamax", 5.0); |
59 |
< |
double phimin = cl.get_value<double> ("phimin", -3.2); |
60 |
< |
double phimax = cl.get_value<double> ("phimax", 3.2); |
55 |
> |
int nemfbins = cl.get_value<int> ("nemfbins", 15); |
56 |
> |
float etmin = cl.get_value<float> ("etmin", 0.0); |
57 |
> |
float etmax = cl.get_value<float> ("etmax", 200.0); |
58 |
> |
float etamin = cl.get_value<float> ("etamin", -5.0); |
59 |
> |
float etamax = cl.get_value<float> ("etamax", 5.0); |
60 |
> |
float phimin = cl.get_value<float> ("phimin", -3.2); |
61 |
> |
float phimax = cl.get_value<float> ("phimax", 3.2); |
62 |
> |
float emfmin = cl.get_value<float> ("emfmin", 0.0); |
63 |
> |
float emfmax = cl.get_value<float> ("emfmax", 1.0); |
64 |
> |
short applyjes = cl.get_value<short> ("applyjes", 0); |
65 |
|
|
66 |
|
if (!cl.check()) return 0; |
67 |
|
cl.print(); |
78 |
|
} |
79 |
|
|
80 |
|
// loop over all input samples |
81 |
< |
vector<TH1F*> ptHistos; |
81 |
> |
vector<TH1F*> etHistos; |
82 |
|
vector<TH1F*> etaHistos; |
83 |
|
vector<TH1F*> phiHistos; |
84 |
+ |
vector<TH1F*> emfHistos; |
85 |
|
for (unsigned int i=0;i<input.size();++i) { |
86 |
|
TFile* f = new TFile(input[i].c_str(),"READ"); |
87 |
|
TTree* t = (TTree*)f->Get(treename.c_str()); |
88 |
|
cout<<jetalgs[i]<<" sample has "<<t->GetEntries()<<" entries."<<endl; |
89 |
|
|
90 |
|
|
91 |
< |
string namePtAll = "PtAll_"+jetalgs[i]; |
92 |
< |
string namePtFake = "PtFake_"+jetalgs[i]; |
93 |
< |
string namePtEff = "PtEff_"+jetalgs[i]; |
94 |
< |
|
95 |
< |
TH1F* hPtAll = new TH1F(namePtAll.c_str(),namePtAll.c_str(), |
96 |
< |
nptbins,ptmin,ptmax); |
97 |
< |
TH1F* hPtFake = new TH1F(namePtFake.c_str(),namePtFake.c_str(), |
98 |
< |
nptbins,ptmin,ptmax); |
99 |
< |
TH1F* hPtEff = new TH1F(namePtEff.c_str(),namePtEff.c_str(), |
100 |
< |
nptbins,ptmin,ptmax); |
101 |
< |
|
102 |
< |
hPtAll->Sumw2(); |
103 |
< |
hPtFake->Sumw2(); |
104 |
< |
hPtEff->Sumw2(); |
91 |
> |
string nameEtAll = "EtAll_"+jetalgs[i]; |
92 |
> |
string nameEtFake = "EtFake_"+jetalgs[i]; |
93 |
> |
string nameEtEff = "EtEff_"+jetalgs[i]; |
94 |
> |
|
95 |
> |
TH1F* hEtAll = new TH1F(nameEtAll.c_str(),nameEtAll.c_str(), |
96 |
> |
netbins,etmin,etmax); |
97 |
> |
TH1F* hEtFake = new TH1F(nameEtFake.c_str(),nameEtFake.c_str(), |
98 |
> |
netbins,etmin,etmax); |
99 |
> |
TH1F* hEtEff = new TH1F(nameEtEff.c_str(),nameEtEff.c_str(), |
100 |
> |
netbins,etmin,etmax); |
101 |
> |
|
102 |
> |
hEtAll->Sumw2(); |
103 |
> |
hEtFake->Sumw2(); |
104 |
> |
hEtEff->Sumw2(); |
105 |
|
|
106 |
|
string nameEtaAll = "EtaAll_"+jetalgs[i]; |
107 |
|
string nameEtaFake = "EtaFake_"+jetalgs[i]; |
133 |
|
hPhiFake->Sumw2(); |
134 |
|
hPhiEff->Sumw2(); |
135 |
|
|
136 |
+ |
string nameEmfAll = "EmfAll_"+jetalgs[i]; |
137 |
+ |
string nameEmfFake = "EmfFake_"+jetalgs[i]; |
138 |
+ |
string nameEmfEff = "EmfEff_"+jetalgs[i]; |
139 |
+ |
|
140 |
+ |
TH1F* hEmfAll = new TH1F(nameEmfAll.c_str(),nameEmfAll.c_str(), |
141 |
+ |
nemfbins,emfmin,emfmax); |
142 |
+ |
TH1F* hEmfFake = new TH1F(nameEmfFake.c_str(),nameEmfFake.c_str(), |
143 |
+ |
nemfbins,emfmin,emfmax); |
144 |
+ |
TH1F* hEmfEff = new TH1F(nameEmfEff.c_str(),nameEmfEff.c_str(), |
145 |
+ |
nemfbins,emfmin,emfmax); |
146 |
+ |
|
147 |
+ |
hEmfAll->Sumw2(); |
148 |
+ |
hEmfFake->Sumw2(); |
149 |
+ |
hEmfEff->Sumw2(); |
150 |
+ |
|
151 |
|
float weight; t->SetBranchAddress("weight",&weight); |
152 |
|
char njt; t->SetBranchAddress("njt", &njt); |
153 |
< |
float jtpt[100]; t->SetBranchAddress("jtpt", jtpt); |
153 |
> |
float jtet[100]; t->SetBranchAddress("jtet", jtet); |
154 |
|
float jteta[100]; t->SetBranchAddress("jteta", jteta); |
155 |
|
float jtphi[100]; t->SetBranchAddress("jtphi", jtphi); |
156 |
+ |
float jtemf[100]; t->SetBranchAddress("jtemf", jtemf); |
157 |
|
float jtgendr[100]; t->SetBranchAddress("jtgendr",jtgendr); |
158 |
< |
|
158 |
> |
float jtjes[100][3]; |
159 |
> |
if (applyjes>0&&t->FindBranch("jtjes")) t->SetBranchAddress("jtjes",jtjes); |
160 |
> |
|
161 |
|
int nevts=t->GetEntries(); |
162 |
|
|
163 |
|
for (int ievt=0;ievt<nevts;ievt++) { |
164 |
|
t->GetEntry(ievt); |
165 |
|
for (int ijt=0;ijt<njt;ijt++) { |
142 |
– |
hPtAll ->Fill(jtpt[ijt], weight); |
143 |
– |
hEtaAll->Fill(jteta[ijt],weight); |
144 |
– |
hPhiAll->Fill(jtphi[ijt],weight); |
166 |
|
|
167 |
< |
if (jtgendr[ijt]<0.0||jtgendr[ijt]>drmax) { |
168 |
< |
hPtFake ->Fill(jtpt[ijt], weight); |
169 |
< |
hEtaFake->Fill(jteta[ijt],weight); |
170 |
< |
hPhiFake->Fill(jtphi[ijt],weight); |
167 |
> |
float dr = jtgendr[ijt]; |
168 |
> |
float et = (applyjes==0) ? jtet[ijt]:jtet[ijt]*jtjes[ijt][applyjes-1]; |
169 |
> |
float eta = jteta[ijt]; |
170 |
> |
float phi = jtphi[ijt]; |
171 |
> |
float emf = jtemf[ijt]; if (TMath::IsNaN(emf)) emf = 0.0; |
172 |
> |
|
173 |
> |
if (et <etmin ||et >etmax) continue; |
174 |
> |
if (eta<etamin||eta>etamax) continue; |
175 |
> |
if (phi<phimin||phi>phimax) continue; |
176 |
> |
if (emf<emfmin||emf>emfmax) continue; |
177 |
> |
|
178 |
> |
hEtAll ->Fill(et, weight); |
179 |
> |
hEtaAll->Fill(eta,weight); |
180 |
> |
hPhiAll->Fill(phi,weight); |
181 |
> |
hEmfAll->Fill(emf,weight); |
182 |
> |
|
183 |
> |
if (dr<0.0||dr>drmax) { |
184 |
> |
hEtFake ->Fill(et, weight); |
185 |
> |
hEtaFake->Fill(eta,weight); |
186 |
> |
hPhiFake->Fill(phi,weight); |
187 |
> |
hEmfFake->Fill(emf,weight); |
188 |
|
} |
189 |
|
} |
190 |
|
} |
191 |
|
|
192 |
< |
hPtEff->Divide(hPtFake,hPtAll,1.0,1.0,"B"); |
193 |
< |
setBinomialErrors(hPtEff,hPtFake,hPtAll); |
194 |
< |
ptHistos.push_back(hPtEff); |
192 |
> |
hEtEff->Divide(hEtFake,hEtAll,1.0,1.0,"B"); |
193 |
> |
setBinomialErrors(hEtEff,hEtFake,hEtAll); |
194 |
> |
etHistos.push_back(hEtEff); |
195 |
|
|
196 |
|
hEtaEff->Divide(hEtaFake,hEtaAll,1.0,1.0,"B"); |
197 |
|
setBinomialErrors(hEtaEff,hEtaFake,hEtaAll); |
200 |
|
hPhiEff->Divide(hPhiFake,hPhiAll,1.0,1.0,"B"); |
201 |
|
setBinomialErrors(hPhiEff,hPhiFake,hPhiAll); |
202 |
|
phiHistos.push_back(hPhiEff); |
203 |
+ |
|
204 |
+ |
hEmfEff->Divide(hEmfFake,hEmfAll,1.0,1.0,"B"); |
205 |
+ |
setBinomialErrors(hEmfEff,hEmfFake,hEmfAll); |
206 |
+ |
emfHistos.push_back(hEmfEff); |
207 |
|
} |
208 |
|
|
209 |
|
|
215 |
|
|
216 |
|
Color_t color; |
217 |
|
|
218 |
+ |
// emf canvas |
219 |
+ |
TCanvas* cEmfEff = new TCanvas("FakeVsEmf", "FakeVsEmf",10,420,400,400); |
220 |
+ |
TLegend* lEmfEff = new TLegend(0.65,0.85-emfHistos.size()*0.05,0.86,0.85); |
221 |
+ |
cEmfEff->cd(); |
222 |
+ |
lEmfEff->SetFillColor(10); |
223 |
+ |
|
224 |
+ |
color = kBlack; |
225 |
+ |
for (unsigned int i=0;i<emfHistos.size();i++) { |
226 |
+ |
TH1F* h = emfHistos[i]; |
227 |
+ |
lEmfEff->AddEntry(h,jetalgs[i].c_str(),"lp"); |
228 |
+ |
h->SetLineWidth(2); |
229 |
+ |
h->SetMarkerColor(color); |
230 |
+ |
h->SetLineColor(color++); |
231 |
+ |
h->SetMarkerStyle(kFullCircle); |
232 |
+ |
h->SetMarkerSize(0.7); |
233 |
+ |
if (i==0) { |
234 |
+ |
h->SetTitle("#epsilon_{FAKE} vs emf"); |
235 |
+ |
h->SetXTitle("jet emf"); |
236 |
+ |
h->SetYTitle("#epsilon_{FAKE}"); |
237 |
+ |
h->Draw("E"); |
238 |
+ |
h->SetMinimum(0.0); |
239 |
+ |
h->SetMaximum(1.05); |
240 |
+ |
} |
241 |
+ |
else h->Draw("ESAME"); |
242 |
+ |
} |
243 |
+ |
lEmfEff->Draw(); |
244 |
+ |
|
245 |
|
// phi canvas |
246 |
|
TCanvas* cPhiEff = new TCanvas("FakeVsPhi", "FakeVsPhi",830,10,400,400); |
247 |
|
TLegend* lPhiEff = new TLegend(0.65,0.85-phiHistos.size()*0.05,0.86,0.85); |
251 |
|
color = kBlack; |
252 |
|
for (unsigned int i=0;i<phiHistos.size();i++) { |
253 |
|
TH1F* h = phiHistos[i]; |
254 |
< |
lPhiEff->AddEntry(h,jetalgs[i].c_str(),"l"); |
254 |
> |
lPhiEff->AddEntry(h,jetalgs[i].c_str(),"lp"); |
255 |
> |
h->SetLineWidth(2); |
256 |
|
h->SetMarkerColor(color); |
257 |
|
h->SetLineColor(color++); |
258 |
|
h->SetMarkerStyle(kFullCircle); |
259 |
< |
h->SetMarkerSize(0.5); |
259 |
> |
h->SetMarkerSize(0.7); |
260 |
|
if (i==0) { |
261 |
< |
h->SetTitle("#epsilon_{fake} vs #phi"); |
261 |
> |
h->SetTitle("#epsilon_{FAKE} vs #phi"); |
262 |
|
h->SetXTitle("jet #phi"); |
263 |
< |
h->SetYTitle("#epsilon_{fake}"); |
263 |
> |
h->SetYTitle("#epsilon_{FAKE}"); |
264 |
|
h->Draw("E"); |
265 |
|
h->SetMinimum(0.0); |
266 |
|
h->SetMaximum(1.05); |
278 |
|
color = kBlack; |
279 |
|
for (unsigned int i=0;i<etaHistos.size();i++) { |
280 |
|
TH1F* h = etaHistos[i]; |
281 |
< |
lEtaEff->AddEntry(h,jetalgs[i].c_str(),"l"); |
281 |
> |
lEtaEff->AddEntry(h,jetalgs[i].c_str(),"lp"); |
282 |
> |
h->SetLineWidth(2); |
283 |
|
h->SetMarkerColor(color); |
284 |
|
h->SetLineColor(color++); |
285 |
|
h->SetMarkerStyle(kFullCircle); |
286 |
< |
h->SetMarkerSize(0.5); |
286 |
> |
h->SetMarkerSize(0.7); |
287 |
|
if (i==0) { |
288 |
< |
h->SetTitle("#epsilon_{fake} vs #eta"); |
288 |
> |
h->SetTitle("#epsilon_{FAKE} vs #eta"); |
289 |
|
h->SetXTitle("jet #eta"); |
290 |
< |
h->SetYTitle("#epsilon_{fake}"); |
290 |
> |
h->SetYTitle("#epsilon_{FAKE}"); |
291 |
|
h->Draw("E"); |
292 |
|
h->SetMinimum(0.0); |
293 |
|
h->SetMaximum(1.05); |
297 |
|
} |
298 |
|
lEtaEff->Draw(); |
299 |
|
|
300 |
< |
// pt canvas |
301 |
< |
TCanvas* cPtEff = new TCanvas("FakeVsPt", "FakeVsPt",10,10,400,400); |
302 |
< |
TLegend* lPtEff = new TLegend(0.65,0.85-ptHistos.size()*0.05,0.86,0.85); |
303 |
< |
cPtEff->cd(); |
304 |
< |
lPtEff->SetFillColor(10); |
300 |
> |
// et canvas |
301 |
> |
TCanvas* cEtEff = new TCanvas("FakeVsEt", "FakeVsEt",10,10,400,400); |
302 |
> |
TLegend* lEtEff = new TLegend(0.65,0.85-etHistos.size()*0.05,0.86,0.85); |
303 |
> |
cEtEff->cd(); |
304 |
> |
lEtEff->SetFillColor(10); |
305 |
|
|
306 |
|
color = kBlack; |
307 |
< |
for (unsigned int i=0;i<ptHistos.size();i++) { |
308 |
< |
TH1F* h = ptHistos[i]; |
309 |
< |
lPtEff->AddEntry(h,jetalgs[i].c_str(),"l"); |
307 |
> |
for (unsigned int i=0;i<etHistos.size();i++) { |
308 |
> |
TH1F* h = etHistos[i]; |
309 |
> |
lEtEff->AddEntry(h,jetalgs[i].c_str(),"lp"); |
310 |
> |
h->SetLineWidth(2); |
311 |
|
h->SetMarkerColor(color); |
312 |
|
h->SetLineColor(color++); |
313 |
|
h->SetMarkerStyle(kFullCircle); |
314 |
< |
h->SetMarkerSize(0.5); |
314 |
> |
h->SetMarkerSize(0.7); |
315 |
|
if (i==0) { |
316 |
< |
h->SetTitle("#epsilon_{fake} vs p_{T}"); |
317 |
< |
h->SetXTitle("jet p_{T} [GeV]"); |
318 |
< |
h->SetYTitle("#epsilon_{fake}"); |
316 |
> |
h->SetTitle("#epsilon_{FAKE} vs E_{T}"); |
317 |
> |
h->SetXTitle("jet E_{T} [GeV]"); |
318 |
> |
h->SetYTitle("#epsilon_{FAKE}"); |
319 |
|
h->Draw("E"); |
320 |
|
h->SetMinimum(0.0); |
321 |
|
h->SetMaximum(1.05); |
322 |
|
} |
323 |
|
else h->Draw("ESAME"); |
324 |
|
} |
325 |
< |
lPtEff->Draw(); |
325 |
> |
lEtEff->Draw(); |
326 |
|
|
327 |
|
app->Run(); |
328 |
|
|
338 |
|
void setBinomialErrors(TH1F* hEff,const TH1F* hFake, const TH1F* hAll) |
339 |
|
{ |
340 |
|
for (int i=1;i<hEff->GetNbinsX();i++) { |
341 |
< |
double nfake = hFake->GetBinContent(i); |
342 |
< |
double nall = hAll ->GetBinContent(i); |
343 |
< |
double eeff = (nall>0.0) ? std::sqrt(nfake/(nall*nall)*(1-nfake/nall)) : 0.0; |
341 |
> |
float nfake = hFake->GetBinContent(i); |
342 |
> |
float nall = hAll ->GetBinContent(i); |
343 |
> |
float eeff = (nall>0.0) ? std::sqrt(nfake/(nall*nall)*(1-nfake/nall)):0.0; |
344 |
|
hEff->SetBinError(i,eeff); |
345 |
|
} |
346 |
|
} |