]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'feature-movesplit'
[u/mrichter/AliRoot.git] / PWGHF / correlationHF / AliHFDhadronCorrSystUnc.cxx
CommitLineData
62f6d8bf 1/**************************************************************************
2 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17/* $Id: $ */
18
19/////////////////////////////////////////////////////////////
20// class for systematic uncertainties on D meson -hadron correlation distribution
21//
22// Author: A. Rossi, andrea.rossi@cern.ch
10eb02e2 23//
24// Responsible of the values set for the different mesons/datasets
25// D0: in pp (2010 min bias) Fabio Colamaria, fabio.colamaria@ba.infn.it ; p-Pb (2013 min bias): Fabio Colamaria, fabio.colamaria@ba.infn.it, Somnath Kar, somnath.kar@cern.ch
26// D*+: in pp 2010 min. bias and p-Pb 2013 min. bias Sandro Bjelogrlic, sandro.bjelogrlic@cern.ch
27// D+: in pp 2010 min. bias and p-Pb 2013 min. bias Jitendra Kumar, jitendra.kumar@cern.ch
28//
62f6d8bf 29/////////////////////////////////////////////////////////////
30#include <Riostream.h>
31#include "AliHFDhadronCorrSystUnc.h"
32#include <TMath.h>
33#include <TH1D.h>
34#include <TH2D.h>
35#include <TCanvas.h>
36#include <TGraphAsymmErrors.h>
37#include <TNamed.h>
38
39using std::cout;
40using std::endl;
41
42ClassImp(AliHFDhadronCorrSystUnc)
43
44AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc() : TNamed(),
45 fmeson(),
46 fstrmeson(),
47 fstrptAss(),
48 fstrptD(),
49 fhDeltaPhiTemplate(),
50 fhYieldExtraction(),
51 fhBackSubtractionMin(),
52 fhBackSubtractionMax(),
53 fhBeautyFDmin(),
54 fhBeautyFDmax(),
55 fhMCclosureTestMin(),
56 fhMCclosureTestMax(),
57 fhMCcorrectionsMin(),
58 fhMCcorrectionsMax(),
59 fhMCDefficiencyMin(),
60 fhMCDefficiencyMax(),
61 fhSecContaminationMin(),
62 fhSecContaminationMax(),
63 fhTotalMin(),
64 fhTotalMax(),
65 fhTotalNonFDMin(),
66 fhTotalNonFDMax(),
67 fhTotalNonFlatDPhiMin(),
68 fhTotalNonFlatDPhiMax(),
69 fhtotFlatMin(),
70 fhtotFlatMax(),
71 fgrYieldUnc(),
72 fgrBackSubUnc(),
73 fgrMCcorrections(),
74 fgrMCDefficiency(),
75 fgrSecContamination(),
76 fgrMCclosureTest(),
77 fgrBeautyFD(),
78 fgrYieldUncRel(),
79 fgrBackSubUncRel(),
80 fgrMCcorrectionsRel(),
81 fgrMCDefficiencyRel(),
82 fgrSecContaminationRel(),
83 fgrMCclosureTestRel(),
84 fgrBeautyFDRel(),
85 fgrTotal(),
86 fgrTotalRel(),
87 fgrTotalNonFD(),
88 fgrTotalNonFlatDPhi(),
89 fgrTotalNonFlatDPhiRel(),
90 fgrTotalFlatDPhi(),
91 fgrTotalFlatDPhiRel()
92
93{
94 // default constructor
95}
96
97
98AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc(const char* name) :
99 TNamed(name,name),
100 fmeson(),
101 fstrmeson(),
102 fstrptAss(),
103 fstrptD(),
104 fhDeltaPhiTemplate(),
105 fhYieldExtraction(),
106 fhBackSubtractionMin(),
107 fhBackSubtractionMax(),
108 fhBeautyFDmin(),
109 fhBeautyFDmax(),
110 fhMCclosureTestMin(),
111 fhMCclosureTestMax(),
112 fhMCcorrectionsMin(),
113 fhMCcorrectionsMax(),
114 fhMCDefficiencyMin(),
115 fhMCDefficiencyMax(),
116 fhSecContaminationMin(),
117 fhSecContaminationMax(),
118 fhTotalMin(),
119 fhTotalMax(),
120 fhTotalNonFDMin(),
121 fhTotalNonFDMax(),
122 fhTotalNonFlatDPhiMin(),
123 fhTotalNonFlatDPhiMax(),
124 fhtotFlatMin(),
125 fhtotFlatMax(),
126 fgrYieldUnc(),
127 fgrBackSubUnc(),
128 fgrMCcorrections(),
129 fgrMCDefficiency(),
130 fgrSecContamination(),
131 fgrMCclosureTest(),
132 fgrBeautyFD(),
133 fgrYieldUncRel(),
134 fgrBackSubUncRel(),
135 fgrMCcorrectionsRel(),
136 fgrMCDefficiencyRel(),
137 fgrSecContaminationRel(),
138 fgrMCclosureTestRel(),
139 fgrBeautyFDRel(),
140 fgrTotal(),
141 fgrTotalRel(),
142 fgrTotalNonFD(),
143 fgrTotalNonFlatDPhi(),
144 fgrTotalNonFlatDPhiRel(),
145 fgrTotalFlatDPhi(),
146 fgrTotalFlatDPhiRel()
147{
148 // default constructor
149}
150
151
152
153AliHFDhadronCorrSystUnc::~AliHFDhadronCorrSystUnc(){
154 // destructor
155
156 delete fhDeltaPhiTemplate;
157 delete fhYieldExtraction;
158 delete fhBackSubtractionMin;
159 delete fhBackSubtractionMax;
160 delete fhBeautyFDmin;
161 delete fhBeautyFDmax;
162 delete fhMCclosureTestMin;
163 delete fhMCclosureTestMax;
164 delete fhMCcorrectionsMin;
165 delete fhMCcorrectionsMax;
166 delete fhMCDefficiencyMin;
167 delete fhMCDefficiencyMax;
168 delete fhSecContaminationMin;
169 delete fhSecContaminationMax;
170 delete fhTotalMin;
171 delete fhTotalMax;
172 delete fhTotalNonFDMin;
173 delete fhTotalNonFDMax;
174 delete fhTotalNonFlatDPhiMin;
175 delete fhTotalNonFlatDPhiMax;
176 delete fhtotFlatMin;
177 delete fhtotFlatMax;
178 delete fgrYieldUnc;
179 delete fgrBackSubUnc;
180 delete fgrMCcorrections;
181 delete fgrMCDefficiency;
182 delete fgrSecContamination;
183 delete fgrMCclosureTest;
184 delete fgrBeautyFD;
185 delete fgrYieldUncRel;
186 delete fgrBackSubUncRel;
187 delete fgrMCcorrectionsRel;
188 delete fgrMCDefficiencyRel;
189 delete fgrSecContaminationRel;
190 delete fgrMCclosureTestRel;
191 delete fgrBeautyFDRel;
192 delete fgrTotal;
193 delete fgrTotalRel;
194 delete fgrTotalNonFD;
195 delete fgrTotalNonFlatDPhi;
196 delete fgrTotalNonFlatDPhiRel;
197 delete fgrTotalFlatDPhi;
198 delete fgrTotalFlatDPhiRel;
199
200}
201
202
76948b1d 203void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP(){
204 Printf("Loading syst unc for D0 pp2010 3-5 0.3 thr");
62f6d8bf 205 fmeson=0;
206 fstrmeson="Dzero";
207 fstrptAss="ptAsMore03";
208 fstrptD="Dpt3to5";
209 if(!fhDeltaPhiTemplate){
210 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
211 }
212 Double_t x;
213 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
214 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
215 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
216 fhYieldExtraction->SetBinContent(j,0.1);
217 }
218
219 // Background D MESON candidate subtraction (side-band variations, etc.)
220 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
221 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
222 fhBackSubtractionMin->SetBinContent(j,-0.05);
223 }
224
225 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
226 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
227 fhBackSubtractionMax->SetBinContent(j,0.05);
228 }
229
230
231 // MC CORRECTIONS ( associatate track efficiency):
232 // -5% +10% for assoc track eff
233 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
234 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
235 fhMCcorrectionsMin->SetBinContent(j,-0.05);
236 }
237
238 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
239 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
240 fhMCcorrectionsMax->SetBinContent(j,0.10);
241 }
242
243 // MC D EFF CORRECTION
244 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
245 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
246 fhMCDefficiencyMin->SetBinContent(j,-0.05);
247 }
248
249 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
250 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
251 fhMCDefficiencyMax->SetBinContent(j,0.05);
252 }
253
254
255 // Contamination from secondary tracks
256 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
257 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
258 fhSecContaminationMin->SetBinContent(j,-0.05);
259 }
260
261 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
262 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
263 fhSecContaminationMax->SetBinContent(j,0.05);
264 }
265
266
267 // MC CLOSURETEST (D meson efficiency)
268 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
269 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
270 x=fhMCclosureTestMin->GetBinLowEdge(j);
271 fhMCclosureTestMin->SetBinContent(j,-0.08);
272
273 if(-0.4<x&&x<-0.2){
274 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
275 }
276 else if(-0.2<x&&x<-0.1){
277 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
278 }
279 else if(-0.1<x&&x<0.1){
280 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
281 }
282 else if(0.1<x&&x<0.2){
283 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
284 }
285 if(0.2<x&&x<0.4){
286 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
287 }
288 }
289
290 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
291 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
292 // x=fhMCclosureTestMax->GetBinLowEdge(j);
293 fhMCclosureTestMax->SetBinContent(j,0.);
294
295 // if(-0.4<x&&x<-0.2){
296 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
297 // }
298 // else if(-0.2<x&&x<-0.1){
299 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
300 // }
301 // else if(-0.2<x&&x<-0.1){
302 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
303 // }
304 // else if(-0.1<x&&x<0.1){
305 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
306 // }
307 // else if(0.1<x&&x<0.2){
308 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
309 // }
310 // if(0.2<x&&x<0.4){
311 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
312 // }
313
314 }
315
316 // Feed-down
317
318 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
319 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
320 x=fhBeautyFDmin->GetBinLowEdge(j);
321 fhBeautyFDmin->SetBinContent(j,-0.05);
322
323 // if(-0.4<x&&x<-0.2){
324// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
325// }
326// else if(-0.2<x&&x<-0.1){
327// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
328// }
329// else if(-0.2<x&&x<-0.1){
330// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
331// }
332// else if(-0.1<x&&x<0.1){
333// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
334// }
335// else if(0.1<x&&x<0.2){
336// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
337// }
338// if(0.2<x&&x<0.4){
339// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
340// }
341 }
342
343 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
344 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
345 x=fhBeautyFDmax->GetBinLowEdge(j);
346 fhBeautyFDmax->SetBinContent(j,0.03);
347
348// if(-0.4<x&&x<-0.2){
349// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
350// }
351// else if(-0.2<x&&x<-0.1){
352// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
353// }
354// else if(-0.2<x&&x<-0.1){
355// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
356// }
357// else if(-0.1<x&&x<0.1){
358// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
359// }
360// else if(0.1<x&&x<0.2){
361// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
362// }
363// if(0.2<x&&x<0.4){
364// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
365// }
366
367 }
368
369}
370
76948b1d 371void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP(){
372 Printf("Loading syst unc for D0 pp2010 5-8 0.3 thr");
62f6d8bf 373
374 fmeson=0;
375 fstrmeson="Dzero";
376 fstrptAss="ptAsMore03";
377 fstrptD="Dpt5to8";
378 if(!fhDeltaPhiTemplate){
379 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
380 }
381 Double_t x;
382 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
383 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
384 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
385 fhYieldExtraction->SetBinContent(j,0.1);
386 }
387
388 // Background D MESON candidate subtraction (side-band variations, etc.)
389 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
390 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 391 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 392 }
393
394 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
395 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
396 fhBackSubtractionMax->SetBinContent(j,0.05);
397 }
398
399 // MC CORRECTIONS: -5% +10% for assoc track eff
400 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
401 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
402 fhMCcorrectionsMin->SetBinContent(j,-0.05);
403 }
404
405 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
406 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
407 fhMCcorrectionsMax->SetBinContent(j,0.10);
408 }
409
410
411 // MC D EFF CORRECTION
412 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
413 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
414 fhMCDefficiencyMin->SetBinContent(j,-0.05);
415 }
416
417 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
418 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
419 fhMCDefficiencyMax->SetBinContent(j,0.05);
420 }
421
422
423 // Contamination from secondary tracks
424 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
425 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
426 fhSecContaminationMin->SetBinContent(j,-0.05);
427 }
428
429 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
430 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
431 fhSecContaminationMax->SetBinContent(j,0.05);
432 }
433
434 // MC CLOSURETEST (D meson efficiency)
435 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
436 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
437 x=fhMCclosureTestMin->GetBinLowEdge(j);
438 fhMCclosureTestMin->SetBinContent(j,-0.08);
439
440 if(-0.4<x&&x<-0.2){
441 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
442 }
443 else if(-0.2<x&&x<-0.1){
444 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
445 }
446 else if(-0.1<x&&x<0.1){
447 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
448 }
449 else if(0.1<x&&x<0.2){
450 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
451 }
452 if(0.2<x&&x<0.4){
453 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
454 }
455 }
456
457 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
458 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
459 x=fhMCclosureTestMax->GetBinLowEdge(j);
460 fhMCclosureTestMax->SetBinContent(j,0.);
461
462 // if(-0.4<x&&x<-0.2){
463 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
464 // }
465 // else if(-0.2<x&&x<-0.1){
466 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
467 // }
468 // else if(-0.2<x&&x<-0.1){
469 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
470 // }
471 // else if(-0.1<x&&x<0.1){
472 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
473 // }
474 // else if(0.1<x&&x<0.2){
475 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
476 // }
477 // if(0.2<x&&x<0.4){
478 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
479 // }
480
481 }
482
483 // Feed-down
484
485 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
486 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
487 x=fhBeautyFDmin->GetBinLowEdge(j);
488 fhBeautyFDmin->SetBinContent(j,-0.05);
489
490 // if(-0.4<x&&x<-0.2){
491// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
492// }
493// else if(-0.2<x&&x<-0.1){
494// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
495// }
496// else if(-0.2<x&&x<-0.1){
497// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
498// }
499// else if(-0.1<x&&x<0.1){
500// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
501// }
502// else if(0.1<x&&x<0.2){
503// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
504// }
505// if(0.2<x&&x<0.4){
506// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
507// }
508 }
509
510 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
511 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
512 x=fhBeautyFDmax->GetBinLowEdge(j);
513 fhBeautyFDmax->SetBinContent(j,0.03);
514
515// if(-0.4<x&&x<-0.2){
516// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
517// }
518// else if(-0.2<x&&x<-0.1){
519// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
520// }
521// else if(-0.2<x&&x<-0.1){
522// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
523// }
524// else if(-0.1<x&&x<0.1){
525// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
526// }
527// else if(0.1<x&&x<0.2){
528// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
529// }
530// if(0.2<x&&x<0.4){
531// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
532// }
533
534 }
535
536}
537
538
76948b1d 539void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(){
540
541 Printf("Loading syst unc for D0 pp2010 8-16 0.3 thr");
62f6d8bf 542
543 fmeson=0;
544 fstrmeson="Dzero";
545 fstrptAss="ptAsMore03";
546 fstrptD="Dpt8to16";
547 if(!fhDeltaPhiTemplate){
548 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
549 }
550
551 Double_t x;
552 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
553 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
554 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
555 fhYieldExtraction->SetBinContent(j,0.1);
556 }
557
558 // Background D MESON candidate subtraction (side-band variations, etc.)
559 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
560 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 561 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 562 }
563
564 // Background D MESON candidate subtraction (side-band variations, etc.)
565 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
566 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
567 fhBackSubtractionMax->SetBinContent(j,0.05);
568 }
569
570 // MC CORRECTIONS, -5% 10% for assoc track eff
571 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
572 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
573 fhMCcorrectionsMin->SetBinContent(j,-0.05);
574 }
575
576 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
577 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
578 fhMCcorrectionsMax->SetBinContent(j,0.10);
579 }
580
581
582 // MC D EFF CORRECTION
583 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
584 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
585 fhMCDefficiencyMin->SetBinContent(j,-0.05);
586 }
587
588 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
589 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
590 fhMCDefficiencyMax->SetBinContent(j,0.05);
591 }
592
593
594 // Contamination from secondary tracks
595 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
596 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
597 fhSecContaminationMin->SetBinContent(j,-0.05);
598 }
599
600 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
601 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
602 fhSecContaminationMax->SetBinContent(j,0.05);
603 }
604
605 // MC CLOSURETEST (D meson efficiency)
606 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
607 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
608 x=fhMCclosureTestMin->GetBinLowEdge(j);
609 fhMCclosureTestMin->SetBinContent(j,-0.08);
610
611 if(-0.4<x&&x<-0.2){
612 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
613 }
614 else if(-0.2<x&&x<-0.1){
615 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
616 }
617 else if(-0.1<x&&x<0.1){
618 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
619 }
620 else if(0.1<x&&x<0.2){
621 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
622 }
623 if(0.2<x&&x<0.4){
624 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
625 }
626 }
627
628 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
629 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
630 x=fhMCclosureTestMax->GetBinLowEdge(j);
631 fhMCclosureTestMax->SetBinContent(j,0.);
632
633 // if(-0.4<x&&x<-0.2){
634 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
635 // }
636 // else if(-0.2<x&&x<-0.1){
637 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
638 // }
639 // else if(-0.2<x&&x<-0.1){
640 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
641 // }
642 // else if(-0.1<x&&x<0.1){
643 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
644 // }
645 // else if(0.1<x&&x<0.2){
646 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
647 // }
648 // if(0.2<x&&x<0.4){
649 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
650 // }
651
652 }
653
654 // Feed-down
655
656 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
657 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
658 x=fhBeautyFDmin->GetBinLowEdge(j);
659 fhBeautyFDmin->SetBinContent(j,-0.05);
660
661 // if(-0.4<x&&x<-0.2){
662// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
663// }
664// else if(-0.2<x&&x<-0.1){
665// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
666// }
667// else if(-0.2<x&&x<-0.1){
668// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
669// }
670// else if(-0.1<x&&x<0.1){
671// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
672// }
673// else if(0.1<x&&x<0.2){
674// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
675// }
676// if(0.2<x&&x<0.4){
677// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
678// }
679 }
680
681 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
682 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
683 x=fhBeautyFDmax->GetBinLowEdge(j);
684 fhBeautyFDmax->SetBinContent(j,0.03);
685
686// if(-0.4<x&&x<-0.2){
687// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
688// }
689// else if(-0.2<x&&x<-0.1){
690// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
691// }
692// else if(-0.2<x&&x<-0.1){
693// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
694// }
695// else if(-0.1<x&&x<0.1){
696// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
697// }
698// else if(0.1<x&&x<0.2){
699// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
700// }
701// if(0.2<x&&x<0.4){
702// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
703// }
704
705 }
706
707}
708
709
710
711
712//--------------------------------------------------
713void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP(){
76948b1d 714 Printf("Loading syst unc for D*+ pp 2010, 3<pt(D)<5 GeV/c, pt(assoc)>0.3");
62f6d8bf 715 fmeson=1;
716 fstrmeson="Dstar";
717 fstrptAss="ptAsMore03";
718 fstrptD="Dpt3to5";
719 if(!fhDeltaPhiTemplate){
720 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
721 }
722 Double_t x;
723 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
724 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
725 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
726 fhYieldExtraction->SetBinContent(j,0.1);
727 }
728
729 // Background D MESON candidate subtraction (side-band variations, etc.)
730 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
731 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 732 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 733 }
734
735 // Background D MESON candidate subtraction (side-band variations, etc.)
736 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
737 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
738 fhBackSubtractionMax->SetBinContent(j,0.05);
739 }
740
741 // MC CORRECTIONS, -5% 10% for assoc track eff
742 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
743 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
744 fhMCcorrectionsMin->SetBinContent(j,-0.05);
745 }
746
747 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
748 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
749 fhMCcorrectionsMax->SetBinContent(j,0.10);
750 }
751
752
753 // MC D EFF CORRECTION
754 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
755 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
756 fhMCDefficiencyMin->SetBinContent(j,-0.05);
757 }
758
759 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
760 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
761 fhMCDefficiencyMax->SetBinContent(j,0.05);
762 }
763
764
765 // Contamination from secondary tracks
766 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
767 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
768 fhSecContaminationMin->SetBinContent(j,-0.05);
769 }
770
771 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
772 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
773 fhSecContaminationMax->SetBinContent(j,0.05);
774 }
775
776 // MC CLOSURETEST (D meson efficiency)
777 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
778 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
779 x=fhMCclosureTestMin->GetBinLowEdge(j);
780 fhMCclosureTestMin->SetBinContent(j,-0.08);
781
782 if(-0.4<x&&x<-0.2){
783 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
784 }
785 else if(-0.2<x&&x<-0.1){
786 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
787 }
788 else if(-0.1<x&&x<0.1){
789 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
790 }
791 else if(0.1<x&&x<0.2){
792 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
793 }
794 if(0.2<x&&x<0.4){
795 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
796 }
797 }
798
799 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
800 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
801 x=fhMCclosureTestMax->GetBinLowEdge(j);
802 fhMCclosureTestMax->SetBinContent(j,0.);
803
804 // if(-0.4<x&&x<-0.2){
805 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
806 // }
807 // else if(-0.2<x&&x<-0.1){
808 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
809 // }
810 // else if(-0.2<x&&x<-0.1){
811 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
812 // }
813 // else if(-0.1<x&&x<0.1){
814 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
815 // }
816 // else if(0.1<x&&x<0.2){
817 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
818 // }
819 // if(0.2<x&&x<0.4){
820 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
821 // }
822
823 }
824
825 // Feed-down
826
827 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
828 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
829 x=fhBeautyFDmin->GetBinLowEdge(j);
830 fhBeautyFDmin->SetBinContent(j,-0.05);
831
832 // if(-0.4<x&&x<-0.2){
833// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
834// }
835// else if(-0.2<x&&x<-0.1){
836// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
837// }
838// else if(-0.2<x&&x<-0.1){
839// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
840// }
841// else if(-0.1<x&&x<0.1){
842// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
843// }
844// else if(0.1<x&&x<0.2){
845// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
846// }
847// if(0.2<x&&x<0.4){
848// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
849// }
850 }
851
852 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
853 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
854 x=fhBeautyFDmax->GetBinLowEdge(j);
855 fhBeautyFDmax->SetBinContent(j,0.03);
856
857// if(-0.4<x&&x<-0.2){
858// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
859// }
860// else if(-0.2<x&&x<-0.1){
861// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
862// }
863// else if(-0.2<x&&x<-0.1){
864// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
865// }
866// else if(-0.1<x&&x<0.1){
867// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
868// }
869// else if(0.1<x&&x<0.2){
870// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
871// }
872// if(0.2<x&&x<0.4){
873// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
874// }
875
876 }
877
878
879}
880
881void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss03HP(){
76948b1d 882 Printf("Loading syst unc for D*+ pp 2010, 5<pt(D)<8 GeV/c, pt(assoc)>0.3");
62f6d8bf 883 fmeson=1;
884 fstrmeson="Dstar";
885 fstrptAss="ptAsMore03";
886 fstrptD="Dpt5to8";
887 if(!fhDeltaPhiTemplate){
888 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
889 }
890 Double_t x;
891 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
892 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
893 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
894 fhYieldExtraction->SetBinContent(j,0.1);
895 }
896
897 // Background D MESON candidate subtraction (side-band variations, etc.)
898 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
899 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 900 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 901 }
902
903 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
904 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
905 fhBackSubtractionMax->SetBinContent(j,0.05);
906 }
907
908 // MC CORRECTIONS/ -5% 10% for assoc track eff
909 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
910 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
911 fhMCcorrectionsMin->SetBinContent(j,-0.05);
912 }
913
914 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
915 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
916 fhMCcorrectionsMax->SetBinContent(j,0.10);
917 }
918
919 // MC D EFF CORRECTION
920 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
921 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
922 fhMCDefficiencyMin->SetBinContent(j,-0.05);
923 }
924
925 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
926 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
927 fhMCDefficiencyMax->SetBinContent(j,0.05);
928 }
929
930
931 // Contamination from secondary tracks
932 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
933 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
934 fhSecContaminationMin->SetBinContent(j,-0.05);
935 }
936
937 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
938 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
939 fhSecContaminationMax->SetBinContent(j,0.05);
940 }
941
942 // MC CLOSURETEST (D meson efficiency)
943 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
944 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
945 x=fhMCclosureTestMin->GetBinLowEdge(j);
946 fhMCclosureTestMin->SetBinContent(j,-0.08);
947
948 if(-0.4<x&&x<-0.2){
949 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
950 }
951 else if(-0.2<x&&x<-0.1){
952 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
953 }
954 else if(-0.1<x&&x<0.1){
955 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
956 }
957 else if(0.1<x&&x<0.2){
958 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
959 }
960 if(0.2<x&&x<0.4){
961 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
962 }
963 }
964
965 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
966 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
967 x=fhMCclosureTestMax->GetBinLowEdge(j);
968 fhMCclosureTestMax->SetBinContent(j,0.);
969
970 // if(-0.4<x&&x<-0.2){
971 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
972 // }
973 // else if(-0.2<x&&x<-0.1){
974 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
975 // }
976 // else if(-0.2<x&&x<-0.1){
977 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
978 // }
979 // else if(-0.1<x&&x<0.1){
980 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
981 // }
982 // else if(0.1<x&&x<0.2){
983 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
984 // }
985 // if(0.2<x&&x<0.4){
986 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
987 // }
988
989 }
990
991 // Feed-down
992
993 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
994 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
995 x=fhBeautyFDmin->GetBinLowEdge(j);
996 fhBeautyFDmin->SetBinContent(j,-0.05);
997
998 // if(-0.4<x&&x<-0.2){
999// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1000// }
1001// else if(-0.2<x&&x<-0.1){
1002// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1003// }
1004// else if(-0.2<x&&x<-0.1){
1005// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1006// }
1007// else if(-0.1<x&&x<0.1){
1008// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1009// }
1010// else if(0.1<x&&x<0.2){
1011// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1012// }
1013// if(0.2<x&&x<0.4){
1014// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1015// }
1016 }
1017
1018 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1019 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
1020 x=fhBeautyFDmax->GetBinLowEdge(j);
1021 fhBeautyFDmax->SetBinContent(j,0.03);
1022
1023// if(-0.4<x&&x<-0.2){
1024// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1025// }
1026// else if(-0.2<x&&x<-0.1){
1027// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1028// }
1029// else if(-0.2<x&&x<-0.1){
1030// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1031// }
1032// else if(-0.1<x&&x<0.1){
1033// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1034// }
1035// else if(0.1<x&&x<0.2){
1036// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1037// }
1038// if(0.2<x&&x<0.4){
1039// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1040// }
1041
1042 }
1043
1044}
1045
1046
1047
1048void AliHFDhadronCorrSystUnc::InitEmptyHistosFromTemplate(){
1049 if(!fhDeltaPhiTemplate){
1050 Printf("Template histo not set, using standard binning");
1051 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
1052 }
1053 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
1054 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
1055 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1056 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
1057 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1058 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
1059 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1060 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
1061 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1062 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
1063 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
1064 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
1065 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1066}
1067
1068
1069
1070
1071void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss03HP(){
76948b1d 1072 Printf("Loading syst unc for D*+ pp 2010, 8<pt(D)<16 GeV/c, pt(assoc)>0.3");
62f6d8bf 1073 fmeson=1;
1074 fstrmeson="Dstar";
1075 fstrptAss="ptAsMore03";
1076 fstrptD="Dpt8to16";
1077 if(!fhDeltaPhiTemplate){
1078 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
1079 }
1080 Double_t x;
1081 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
1082 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
1083 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
1084 fhYieldExtraction->SetBinContent(j,0.1);
1085 }
1086
1087 // Background D MESON candidate subtraction (side-band variations, etc.)
1088 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
1089 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 1090 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 1091 }
1092
1093 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1094 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
1095 fhBackSubtractionMax->SetBinContent(j,0.05);
1096 }
1097
1098 // MC CORRECTIONS -5% +10% for assoc track eff
1099 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
1100 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
1101 fhMCcorrectionsMin->SetBinContent(j,-0.05);
1102 }
1103
1104 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1105 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
1106 fhMCcorrectionsMax->SetBinContent(j,0.10);
1107 }
1108 // MC D EFF CORRECTION
1109 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
1110 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
1111 fhMCDefficiencyMin->SetBinContent(j,-0.05);
1112 }
1113
1114 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1115 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
1116 fhMCDefficiencyMax->SetBinContent(j,0.05);
1117 }
1118
1119
1120 // Contamination from secondary tracks
1121 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
1122 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
1123 fhSecContaminationMin->SetBinContent(j,-0.05);
1124 }
1125
1126 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1127 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
1128 fhSecContaminationMax->SetBinContent(j,0.05);
1129 }
1130
1131 // MC CLOSURETEST (D meson efficiency)
1132 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
1133 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
1134 x=fhMCclosureTestMin->GetBinLowEdge(j);
1135 fhMCclosureTestMin->SetBinContent(j,-0.08);
1136
1137 if(-0.4<x&&x<-0.2){
1138 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1139 }
1140 else if(-0.2<x&&x<-0.1){
1141 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1142 }
1143 else if(-0.1<x&&x<0.1){
1144 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
1145 }
1146 else if(0.1<x&&x<0.2){
1147 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1148 }
1149 if(0.2<x&&x<0.4){
1150 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1151 }
1152 }
1153
1154 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
1155 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
1156 x=fhMCclosureTestMax->GetBinLowEdge(j);
1157 fhMCclosureTestMax->SetBinContent(j,0.);
1158
1159 // if(-0.4<x&&x<-0.2){
1160 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1161 // }
1162 // else if(-0.2<x&&x<-0.1){
1163 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1164 // }
1165 // else if(-0.2<x&&x<-0.1){
1166 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1167 // }
1168 // else if(-0.1<x&&x<0.1){
1169 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
1170 // }
1171 // else if(0.1<x&&x<0.2){
1172 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1173 // }
1174 // if(0.2<x&&x<0.4){
1175 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1176 // }
1177
1178 }
1179
1180 // Feed-down
1181
1182 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
1183 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
1184 x=fhBeautyFDmin->GetBinLowEdge(j);
1185 fhBeautyFDmin->SetBinContent(j,-0.05);
1186
1187 // if(-0.4<x&&x<-0.2){
1188// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1189// }
1190// else if(-0.2<x&&x<-0.1){
1191// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1192// }
1193// else if(-0.2<x&&x<-0.1){
1194// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1195// }
1196// else if(-0.1<x&&x<0.1){
1197// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1198// }
1199// else if(0.1<x&&x<0.2){
1200// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1201// }
1202// if(0.2<x&&x<0.4){
1203// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1204// }
1205 }
1206
1207 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1208 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
1209 x=fhBeautyFDmax->GetBinLowEdge(j);
1210 fhBeautyFDmax->SetBinContent(j,0.03);
1211
1212// if(-0.4<x&&x<-0.2){
1213// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1214// }
1215// else if(-0.2<x&&x<-0.1){
1216// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1217// }
1218// else if(-0.2<x&&x<-0.1){
1219// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1220// }
1221// else if(-0.1<x&&x<0.1){
1222// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1223// }
1224// else if(0.1<x&&x<0.2){
1225// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1226// }
1227// if(0.2<x&&x<0.4){
1228// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1229// }
1230
1231 }
1232
1233
1234}
1235
1236
1237void AliHFDhadronCorrSystUnc::SetHistoTemplate(TH1D *h,TString strname,Bool_t clone){
1238 if(fhDeltaPhiTemplate)delete fhDeltaPhiTemplate;
1239 if(!clone){
1240 fhDeltaPhiTemplate=h;
1241 }
1242 else{
1243 if(strname.IsNull()){fhDeltaPhiTemplate=(TH1D*)h->Clone("fhDeltaPhiTemplate");
1244 }
1245 else fhDeltaPhiTemplate=(TH1D*)h->Clone(strname.Data());
1246 }
1247}
1248
1249
1250void AliHFDhadronCorrSystUnc::SetHistoYieldExtraction(TH1D *h,TString strname,Bool_t clone){
1251 if(fhYieldExtraction)delete fhYieldExtraction;
1252 if(!clone){
1253 fhYieldExtraction=h;
1254 }
1255 else{
1256 if(strname.IsNull()){fhYieldExtraction=(TH1D*)h->Clone("fhYieldExtraction");
1257 }
1258 else fhYieldExtraction=(TH1D*)h->Clone(strname.Data());
1259 }
1260}
1261
1262void AliHFDhadronCorrSystUnc::SetHistoBackSubtraction(TH1D *hMax,TString strname,Bool_t clone,TH1D *hMin){
1263 if(!hMax){
1264 Printf("No Input Histo for back uncertainty");
1265 return;
1266 }
1267 if(fhBackSubtractionMax)delete fhBackSubtractionMax;
1268 if(!clone){
1269 fhBackSubtractionMax=hMax;
1270 }
1271 else{
1272 if(strname.IsNull()){fhBackSubtractionMax=(TH1D*)hMax->Clone("fhBackSubtractionMax");
1273 }
1274 else fhBackSubtractionMax=(TH1D*)hMax->Clone(strname.Data());
1275 }
1276
1277 if(fhBackSubtractionMin)delete fhBackSubtractionMin;
1278 if(hMin){
1279 if(!clone){
1280 fhBackSubtractionMin=hMin;
1281 }
1282 else{
1283 if(strname.IsNull()){fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1284 }
1285 else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1286 }
1287 }
1288 else{
1289 if(strname.IsNull()){
1290 fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1291 }
1292 else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1293 for(Int_t k=0;k<=fhBackSubtractionMin->GetNbinsX();k++){
1294 fhBackSubtractionMin->SetBinContent(k,-1.*fhBackSubtractionMin->GetBinContent(k));
1295 }
1296 }
1297
1298
1299
1300
1301}
1302
1303
1304void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMax(TH1D *h,TString strname,Bool_t clone){
1305 if(fhMCclosureTestMax)delete fhMCclosureTestMax;
1306 if(!clone){
1307 fhMCclosureTestMax=h;
1308 }
1309 else{
1310 if(strname.IsNull()){fhMCclosureTestMax=(TH1D*)h->Clone("fhMCclosureTestMax");
1311 }
1312 else fhMCclosureTestMax=(TH1D*)h->Clone(strname.Data());
1313 }
1314}
1315
1316void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMin(TH1D *h,TString strname,Bool_t clone){
1317 if(fhMCclosureTestMin)delete fhMCclosureTestMin;
1318 if(!clone){
1319 fhMCclosureTestMin=h;
1320 }
1321 else{
1322 if(strname.IsNull()){fhMCclosureTestMin=(TH1D*)h->Clone("fhMCclosureTestMin");
1323 }
1324 else fhMCclosureTestMin=(TH1D*)h->Clone(strname.Data());
1325 }
1326}
1327
1328
1329void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMin(TH1D *h,TString strname,Bool_t clone){
1330 if(fhMCcorrectionsMin)delete fhMCcorrectionsMin;
1331 if(!clone){
1332 fhMCcorrectionsMin=h;
1333 }
1334 else{
1335 if(strname.IsNull()){fhMCcorrectionsMin=(TH1D*)h->Clone("fhMCcorrectionsMin");
1336 }
1337 else fhMCcorrectionsMin=(TH1D*)h->Clone(strname.Data());
1338 }
1339}
1340
1341
1342void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMax(TH1D *h,TString strname,Bool_t clone){
1343 if(fhMCcorrectionsMax)delete fhMCcorrectionsMax;
1344 if(!clone){
1345 fhMCcorrectionsMax=h;
1346 }
1347 else{
1348 if(strname.IsNull()){fhMCcorrectionsMax=(TH1D*)h->Clone("fhMCcorrectionsMax");
1349 }
1350 else fhMCcorrectionsMax=(TH1D*)h->Clone(strname.Data());
1351 }
1352}
1353
1354
1355void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMin(TH1D *h,TString strname,Bool_t clone){
1356 if(fhMCDefficiencyMin)delete fhMCDefficiencyMin;
1357 if(!clone){
1358 fhMCDefficiencyMin=h;
1359 }
1360 else{
1361 if(strname.IsNull()){fhMCDefficiencyMin=(TH1D*)h->Clone("fhMCDefficiencyMin");
1362 }
1363 else fhMCDefficiencyMin=(TH1D*)h->Clone(strname.Data());
1364 }
1365}
1366
1367
1368void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMax(TH1D *h,TString strname,Bool_t clone){
1369 if(fhMCDefficiencyMax)delete fhMCDefficiencyMax;
1370 if(!clone){
1371 fhMCDefficiencyMax=h;
1372 }
1373 else{
1374 if(strname.IsNull()){fhMCDefficiencyMax=(TH1D*)h->Clone("fhMCDefficiencyMax");
1375 }
1376 else fhMCDefficiencyMax=(TH1D*)h->Clone(strname.Data());
1377 }
1378}
1379
1380
1381void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMin(TH1D *h,TString strname,Bool_t clone){
1382 if(fhSecContaminationMin)delete fhSecContaminationMin;
1383 if(!clone){
1384 fhSecContaminationMin=h;
1385 }
1386 else{
1387 if(strname.IsNull()){fhSecContaminationMin=(TH1D*)h->Clone("fhSecContaminationMin");
1388 }
1389 else fhSecContaminationMin=(TH1D*)h->Clone(strname.Data());
1390 }
1391}
1392
1393
1394void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMax(TH1D *h,TString strname,Bool_t clone){
1395 if(fhSecContaminationMax)delete fhSecContaminationMax;
1396 if(!clone){
1397 fhSecContaminationMax=h;
1398 }
1399 else{
1400 if(strname.IsNull()){fhSecContaminationMax=(TH1D*)h->Clone("fhSecContaminationMax");
1401 }
1402 else fhSecContaminationMax=(TH1D*)h->Clone(strname.Data());
1403 }
1404}
1405
1406
1407void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmin(TH1D *h,TString strname,Bool_t clone){
1408 if(fhBeautyFDmin)delete fhBeautyFDmin;
1409 if(!clone){
1410 fhBeautyFDmin=h;
1411 }
1412 else{
1413 if(strname.IsNull()){fhBeautyFDmin=(TH1D*)h->Clone("fhBeautyFDmin");
1414 }
1415 else fhBeautyFDmin=(TH1D*)h->Clone(strname.Data());
1416 }
1417}
1418
1419
1420void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmax(TH1D *h,TString strname,Bool_t clone){
1421 if(fhBeautyFDmax)delete fhBeautyFDmax;
1422 if(!clone){
1423 fhBeautyFDmax=h;
1424 }
1425 else{
1426 if(strname.IsNull()){fhBeautyFDmax=(TH1D*)h->Clone("fhBeautyFDmax");
1427 }
1428 else fhBeautyFDmax=(TH1D*)h->Clone(strname.Data());
1429 }
1430}
1431
1432
1433
1434
1435
1436void AliHFDhadronCorrSystUnc::BuildTotalUncHisto(){
1437 if(fhTotalMin)delete fhTotalMin;
1438 if(fhTotalMax)delete fhTotalMax;
1439
1440 fhTotalMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMin");
1441 fhTotalMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMax");
1442 Double_t errMin,errMax;
1443
1444 for(Int_t j=1;j<=fhTotalMin->GetNbinsX();j++){
1445 errMin=fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j);
1446 errMin+=fhMCcorrectionsMin->GetBinContent(j)*fhMCcorrectionsMin->GetBinContent(j);
1447 errMin+=fhMCDefficiencyMin->GetBinContent(j)*fhMCDefficiencyMin->GetBinContent(j);
1448 errMin+=fhSecContaminationMin->GetBinContent(j)*fhSecContaminationMin->GetBinContent(j);
1449 errMin+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1450 errMin+=fhBackSubtractionMin->GetBinContent(j)*fhBackSubtractionMin->GetBinContent(j);
1451 errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1452
1453 fhTotalMin->SetBinContent(j,-TMath::Sqrt(errMin));
1454
1455 errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j);
1456 errMax+=fhMCcorrectionsMax->GetBinContent(j)*fhMCcorrectionsMax->GetBinContent(j);
1457 errMax+=fhMCDefficiencyMax->GetBinContent(j)*fhMCDefficiencyMax->GetBinContent(j);
1458 errMax+=fhSecContaminationMax->GetBinContent(j)*fhSecContaminationMax->GetBinContent(j);
1459 errMax+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1460 errMax+=fhBackSubtractionMax->GetBinContent(j)*fhBackSubtractionMax->GetBinContent(j);
1461 errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1462
1463 fhTotalMax->SetBinContent(j,TMath::Sqrt(errMax));
1464
1465
1466 }
1467
1468 fhTotalMin->SetLineColor(kBlack);
1469 fhTotalMin->SetLineWidth(2);
1470 fhTotalMin->SetFillStyle(0);
1471 fhTotalMin->SetFillColor(kBlack);
1472 fhTotalMin->SetMarkerColor(kBlack);
1473 fhTotalMin->SetMarkerStyle(20);
1474
1475 fhTotalMax->SetLineColor(kBlack);
1476 fhTotalMax->SetLineWidth(2);
1477 fhTotalMax->SetFillStyle(0);
1478 fhTotalMax->SetFillColor(kBlack);
1479 fhTotalMax->SetMarkerColor(kBlack);
1480 fhTotalMax->SetMarkerStyle(20);
1481
1482}
1483
1484void AliHFDhadronCorrSystUnc::BuildTotalNonFlatUncHisto(){
1485 if(fhTotalNonFlatDPhiMin)delete fhTotalNonFlatDPhiMin;
1486 if(fhTotalNonFlatDPhiMax)delete fhTotalNonFlatDPhiMax;
1487
1488 fhTotalNonFlatDPhiMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMin");
1489 fhTotalNonFlatDPhiMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMax");
1490 Double_t errMin,errMax,mcClosureMinmax,mcClosureMaxmin;
1491
1492 mcClosureMinmax=fhMCclosureTestMin->GetBinContent(fhMCclosureTestMin->GetMaximumBin());
62f6d8bf 1493 mcClosureMaxmin=fhMCclosureTestMax->GetBinContent(fhMCclosureTestMax->GetMinimumBin());
76948b1d 1494 Printf("MC closure - The max of min is: %f, the min of max is: %f", mcClosureMinmax, mcClosureMaxmin);
62f6d8bf 1495
1496 for(Int_t j=1;j<=fhTotalNonFlatDPhiMin->GetNbinsX();j++){
1497 errMin=(fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j)-mcClosureMinmax*mcClosureMinmax);// Forced to this quadrature subtraction, doing: (fhMCclosureTestMin->GetBinContent(j)-mcClosureMinmax)*(fhMCclosureTestMin->GetBinContent(j)-mcClosureMinmax) gives the wrong result.. of course
1498
1499 errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1500
1501 fhTotalNonFlatDPhiMin->SetBinContent(j,-TMath::Sqrt(errMin));
1502
1503 errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j)-mcClosureMaxmin*mcClosureMaxmin; // Forced to this quadrature subtraction, doing:(fhMCclosureTestMax->GetBinContent(j)-mcClosureMaxmin)*(fhMCclosureTestMax->GetBinContent(j)-mcClosureMaxmin) gives the wrong result.. of course
1504
1505 errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1506
1507 fhTotalNonFlatDPhiMax->SetBinContent(j,TMath::Sqrt(errMax));
1508
1509
1510 }
1511
1512 fhtotFlatMin=(TH1D*)fhTotalMin->Clone("hTotFlatDPhiMin");
1513 fhtotFlatMin->SetTitle("#Delta#phi indipendent");
1514
1515 fhtotFlatMax=(TH1D*)fhTotalMax->Clone("hTotFlatDPhiMax");
1516 fhtotFlatMax->SetTitle("#Delta#phi indipendent");
1517
1518 for(Int_t jfl=1;jfl<=fhtotFlatMin->GetNbinsX();jfl++){
1519 fhtotFlatMin->SetBinContent(jfl,-TMath::Sqrt(fhTotalMin->GetBinContent(jfl)*fhTotalMin->GetBinContent(jfl)-fhTotalNonFlatDPhiMin->GetBinContent(jfl)*fhTotalNonFlatDPhiMin->GetBinContent(jfl)));
1520 fhtotFlatMax->SetBinContent(jfl,TMath::Sqrt(fhTotalMax->GetBinContent(jfl)*fhTotalMax->GetBinContent(jfl)-fhTotalNonFlatDPhiMax->GetBinContent(jfl)*fhTotalNonFlatDPhiMax->GetBinContent(jfl)));
1521 }
1522
1523 fhtotFlatMin->SetLineStyle(2);
1524 fhtotFlatMax->SetLineStyle(2);
1525
1526
1527
1528
1529 fhTotalNonFlatDPhiMin->SetLineColor(kBlue);
1530 fhTotalNonFlatDPhiMin->SetLineWidth(2);
1531 fhTotalNonFlatDPhiMin->SetFillStyle(0);
1532 fhTotalNonFlatDPhiMin->SetFillColor(kBlue);
1533 fhTotalNonFlatDPhiMin->SetMarkerColor(kBlue);
1534 fhTotalNonFlatDPhiMin->SetMarkerStyle(20);
1535
1536 fhTotalNonFlatDPhiMax->SetLineColor(kBlue);
1537 fhTotalNonFlatDPhiMax->SetLineWidth(2);
1538 fhTotalNonFlatDPhiMax->SetFillStyle(0);
1539 fhTotalNonFlatDPhiMax->SetFillColor(kBlue);
1540 fhTotalNonFlatDPhiMax->SetMarkerColor(kBlue);
1541 fhTotalNonFlatDPhiMax->SetMarkerStyle(20);
1542
1543}
1544
1545
1546void AliHFDhadronCorrSystUnc::BuildTotalNonFDUncHisto(){
1547 if(fhTotalNonFDMin)delete fhTotalNonFDMin;
1548 if(fhTotalNonFDMax)delete fhTotalNonFDMax;
1549
1550 fhTotalNonFDMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMin");
1551 fhTotalNonFDMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMax");
1552 Double_t errMin,errMax;
1553
1554 for(Int_t j=1;j<=fhTotalNonFDMin->GetNbinsX();j++){
1555 errMin=fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j);
1556 errMin+=fhMCcorrectionsMin->GetBinContent(j)*fhMCcorrectionsMin->GetBinContent(j);
1557 errMin+=fhMCDefficiencyMin->GetBinContent(j)*fhMCDefficiencyMin->GetBinContent(j);
1558 errMin+=fhSecContaminationMin->GetBinContent(j)*fhSecContaminationMin->GetBinContent(j);
1559 errMin+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1560 errMin+=fhBackSubtractionMin->GetBinContent(j)*fhBackSubtractionMin->GetBinContent(j);
1561
1562 fhTotalNonFDMin->SetBinContent(j,-TMath::Sqrt(errMin));
1563
1564 errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j);
1565 errMax+=fhMCcorrectionsMax->GetBinContent(j)*fhMCcorrectionsMax->GetBinContent(j);
1566 errMax+=fhMCDefficiencyMax->GetBinContent(j)*fhMCDefficiencyMax->GetBinContent(j);
1567 errMax+=fhSecContaminationMax->GetBinContent(j)*fhSecContaminationMax->GetBinContent(j);
1568 errMax+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1569 errMax+=fhBackSubtractionMax->GetBinContent(j)*fhBackSubtractionMax->GetBinContent(j);
1570
1571 fhTotalNonFDMax->SetBinContent(j,TMath::Sqrt(errMax));
1572
1573
1574 }
1575
1576}
1577
76948b1d 1578
62f6d8bf 1579void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010(Int_t meson,Double_t ptD,Double_t minptAss){
76948b1d 1580
62f6d8bf 1581 if(meson==0){
76948b1d 1582
1583 // 0.3 GeV/c
62f6d8bf 1584 if(TMath::Abs(minptAss-0.3)<0.0001){
1585 if(ptD>2&&ptD<5){
76948b1d 1586 InitStandardUncertaintiesPP2010DzeroLowPtAss03HP();
1587 }
1588 else if(ptD>5&&ptD<8){
1589 InitStandardUncertaintiesPP2010DzeroMidPtAss03HP();
1590 }
1591 else if(ptD>8&&ptD<16){
1592 InitStandardUncertaintiesPP2010DzeroHighPtAss03HP();
1593 }
1594 else {
1595 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1596 }
1597 }
1598 // 0.5 GeV/c
1599 else if(TMath::Abs(minptAss-0.5)<0.0001){
1600 if(ptD>3&&ptD<5){
1601 InitStandardUncertaintiesPP2010DzeroLowPtAss05();
1602 }
1603 else if(ptD>5&&ptD<8){
1604 InitStandardUncertaintiesPP2010DzeroMidPtAss05();
1605 }
1606 else if(ptD>8&&ptD<16){
1607 InitStandardUncertaintiesPP2010DzeroHighPtAss05();
1608 }
1609 else {
1610 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1611 }
1612 }
1613 // 1 GeV/c
1614 else if(TMath::Abs(minptAss-1.)<0.0001){
1615 if(ptD>3&&ptD<5){
1616 InitStandardUncertaintiesPP2010DzeroLowPtAss1();
1617 }
1618 else if(ptD>5&&ptD<8){
1619 InitStandardUncertaintiesPP2010DzeroMidPtAss1();
1620
1621 }
1622 else if(ptD>8&&ptD<16){
1623 InitStandardUncertaintiesPP2010DzeroHighPtAss1();
1624 }
1625 else {
1626 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1627 }
1628 }
1629 else {
1630 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1631 }
1632 }
1633 else if(meson==1){
1634 // 0.3 GeV/c
1635 if(TMath::Abs(minptAss-0.3)<0.0001){
1636 if(ptD>3&&ptD<5){
1637 InitStandardUncertaintiesPP2010DstarLowPtAss03HP();
1638 }
1639 else if(ptD>5&&ptD<8){
1640 InitStandardUncertaintiesPP2010DstarMidPtAss03HP();
1641 }
1642 else if(ptD>8&&ptD<16){
1643 InitStandardUncertaintiesPP2010DstarHighPtAss03HP();
1644 }
1645 else {
1646 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1647 }
1648 }
1649 // 0.5 GeV/c
1650 else if(TMath::Abs(minptAss-0.5)<0.0001){
1651 if(ptD>3&&ptD<5){
1652 InitStandardUncertaintiesPP2010DstarLowPtAss05();
1653 }
1654 else if(ptD>5&&ptD<8){
1655 InitStandardUncertaintiesPP2010DstarMidPtAss05();
1656 }
1657 else if(ptD>8&&ptD<16){
1658 InitStandardUncertaintiesPP2010DstarHighPtAss05();
1659 }
1660 else {
1661 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1662 }
1663 }
1664
1665 // 1 GeV/c
1666 else if(TMath::Abs(minptAss-1.)<0.0001){
1667 if(ptD>3&&ptD<5){
1668 InitStandardUncertaintiesPP2010DstarLowPtAss1();
1669 }
1670 else if(ptD>5&&ptD<8){
1671 InitStandardUncertaintiesPP2010DstarMidPtAss1();
1672 }
1673 else if(ptD>8&&ptD<16){
1674 InitStandardUncertaintiesPP2010DstarHighPtAss1();
1675 }
1676 else {
1677 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1678 }
1679 }
1680 else {
1681 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1682 }
1683 }
1684 else if(meson==2){
1685 // 0.3 GeV/c
1686 if(TMath::Abs(minptAss-0.3)<0.0001){
1687 if(ptD>3&&ptD<5){
1688 InitStandardUncertaintiesPP2010DplusLowPtAss03();
1689 }
1690 else if(ptD>5&&ptD<8){
1691 InitStandardUncertaintiesPP2010DplusMidPtAss03();
1692 }
1693 else if(ptD>8&&ptD<16){
1694 InitStandardUncertaintiesPP2010DplusHighPtAss03();
1695 }
1696 else {
1697 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1698 }
1699 }
1700 // 0.5 GeV/c
1701 else if(TMath::Abs(minptAss-0.5)<0.0001){
1702 if(ptD>3&&ptD<5){
1703 InitStandardUncertaintiesPP2010DplusLowPtAss05();
62f6d8bf 1704 }
1705 else if(ptD>5&&ptD<8){
76948b1d 1706 InitStandardUncertaintiesPP2010DplusMidPtAss05();
1707 }
1708 else if(ptD>8&&ptD<16){
1709 InitStandardUncertaintiesPP2010DplusHighPtAss05();
1710 }
1711 else {
1712 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1713 }
1714 }
1715 // 1 GeV/c
1716 else if(TMath::Abs(minptAss-1.)<0.0001){
1717 if(ptD>3&&ptD<5){
c6c4d6bb 1718 InitStandardUncertaintiesPP2010DplusLowPtAss1();
76948b1d 1719 }
1720 else if(ptD>5&&ptD<8){
c6c4d6bb 1721 InitStandardUncertaintiesPP2010DplusMidPtAss1();
76948b1d 1722 }
1723 else if(ptD>8&&ptD<16){
c6c4d6bb 1724 InitStandardUncertaintiesPP2010DplusHighPtAss1();
76948b1d 1725 }
1726 else {
1727 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
62f6d8bf 1728 }
62f6d8bf 1729 }
1730 else {
1731 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1732 }
1733 }
76948b1d 1734 else {
1735 printf("PP:No meson is found Check your input \n");
1736 }
1737}
1738
1739void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013(Int_t meson,Double_t ptD,Double_t minptAss){
1740
1741 if(meson==0){
1742 // 0.3 GeV/c
1743 if(TMath::Abs(minptAss-0.3)<0.0001){
1744 if(ptD>3&&ptD<5){
1745 InitStandardUncertaintiesPPb2013DzeroLowPtAss03();
1746 }
1747 else if(ptD>5&&ptD<8){
1748 InitStandardUncertaintiesPPb2013DzeroMidPtAss03();
1749 }
1750 else if(ptD>8&&ptD<16){
1751 InitStandardUncertaintiesPPb2013DzeroHighPtAss03();
1752 }
1753
1754 else {
1755 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1756 }
1757 }
1758 // 0.5 GeV/c
1759 else if(TMath::Abs(minptAss-0.5)<0.0001){
1760 if(ptD>3&&ptD<5){
1761 InitStandardUncertaintiesPPb2013DzeroLowPtAss05();
1762 }
1763 else if(ptD>5&&ptD<8){
1764 InitStandardUncertaintiesPPb2013DzeroMidPtAss05();
1765 }
1766 else if(ptD>8&&ptD<16){
1767 InitStandardUncertaintiesPPb2013DzeroHighPtAss05();
1768 }
1769
1770 else {
1771 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1772 }
1773 }
1774
1775 // 1 GeV/c
1776 else if(TMath::Abs(minptAss-1.)<0.0001){
1777 if(ptD>3&&ptD<5){
1778 InitStandardUncertaintiesPPb2013DzeroLowPtAss1();
1779 }
1780 else if(ptD>5&&ptD<8){
1781 InitStandardUncertaintiesPPb2013DzeroMidPtAss1();
1782 }
1783 else if(ptD>8&&ptD<16){
1784 InitStandardUncertaintiesPPb2013DzeroHighPtAss1();
1785 }
1786 else {
1787 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1788 }
1789 }
1790 else {
1791 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1792 }
1793 }
62f6d8bf 1794 else if(meson==1){
76948b1d 1795 // 0.3 GeV/c
62f6d8bf 1796 if(TMath::Abs(minptAss-0.3)<0.0001){
76948b1d 1797 if(ptD>3&&ptD<5){
1798 InitStandardUncertaintiesPPb2013DstarLowPtAss03();
62f6d8bf 1799 }
1800 else if(ptD>5&&ptD<8){
76948b1d 1801 InitStandardUncertaintiesPPb2013DstarMidPtAss03();
1802 }
1803 else if(ptD>8&&ptD<16){
1804 InitStandardUncertaintiesPPb2013DstarHighPtAss03();
1805 }
1806 else {
1807 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1808 }
1809 }
1810 // 0.5 GeV/c
1811 else if(TMath::Abs(minptAss-0.5)<0.0001){
1812 if(ptD>3&&ptD<5){
1813 InitStandardUncertaintiesPPb2013DstarLowPtAss05();
1814 }
1815 else if(ptD>5&&ptD<8){
1816 InitStandardUncertaintiesPPb2013DstarMidPtAss05();
1817 }
1818 else if(ptD>8&&ptD<16){
1819 InitStandardUncertaintiesPPb2013DstarHighPtAss05();
1820 }
1821 else {
1822 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1823 }
1824 }
1825 // 1 GeV/c
1826 else if(TMath::Abs(minptAss-1.)<0.0001){
1827 if(ptD>3&&ptD<5){
1828 InitStandardUncertaintiesPPb2013DstarLowPtAss1();
1829 }
1830 else if(ptD>5&&ptD<8){
1831 InitStandardUncertaintiesPPb2013DstarMidPtAss1();
1832 }
1833 else if(ptD>8&&ptD<16){
1834 InitStandardUncertaintiesPPb2013DstarHighPtAss1();
1835 }
1836 else {
1837 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
62f6d8bf 1838 }
62f6d8bf 1839 }
1840 else {
76948b1d 1841 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
62f6d8bf 1842 }
1843 }
1844 else if(meson==2){
76948b1d 1845 // 0.3 GeV/c
62f6d8bf 1846 if(TMath::Abs(minptAss-0.3)<0.0001){
76948b1d 1847 if(ptD>3&&ptD<5){
1848 InitStandardUncertaintiesPPb2013DplusLowPtAss03();
1849 }
1850 else if(ptD>5&&ptD<8){
1851 InitStandardUncertaintiesPPb2013DplusMidPtAss03();
1852 }
1853 else if(ptD>8&&ptD<16){
1854 InitStandardUncertaintiesPPb2013DplusHighPtAss03();
1855 }
1856 else {
1857 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1858 }
1859 }
1860 // 0.5 GeV/c
1861 else if(TMath::Abs(minptAss-0.5)<0.0001){
1862 if(ptD>3&&ptD<5){
1863 InitStandardUncertaintiesPPb2013DplusLowPtAss05();
62f6d8bf 1864 }
1865 else if(ptD>5&&ptD<8){
76948b1d 1866 InitStandardUncertaintiesPPb2013DplusMidPtAss05();
1867 }
1868 else if(ptD>8&&ptD<16){
1869 InitStandardUncertaintiesPPb2013DplusHighPtAss05();
1870 }
1871 else {
1872 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1873 }
1874 }
1875 // 1 GeV/c
1876 else if(TMath::Abs(minptAss-1.)<0.0001){
1877 if(ptD>3&&ptD<5){
1878 InitStandardUncertaintiesPPb2013DplusLowPtAss1();
1879 }
1880 else if(ptD>5&&ptD<8){
1881 InitStandardUncertaintiesPPb2013DplusMidPtAss1();
1882 }
1883 else if(ptD>8&&ptD<16){
1884 InitStandardUncertaintiesPPb2013DplusHighPtAss1();
1885 }
1886 else {
1887 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
62f6d8bf 1888 }
62f6d8bf 1889 }
1890 else {
1891 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1892 }
1893 }
76948b1d 1894 else {
1895 printf("pPb-No meson is found Check your input \n");
1896 }
62f6d8bf 1897}
1898
1899
1900TGraphAsymmErrors* AliHFDhadronCorrSystUnc::GetUncGraphFromHistos(TH1D *hRef,TH1D *hMin,TH1D *hMax){
1901
1902 // Int_t npoints=hMin->GetNbinsX();
1903 Double_t ew=hMin->GetBinWidth(1)/2.;
1904 Double_t value,eyl,eym;
1905
1906 TGraphAsymmErrors *gr=new TGraphAsymmErrors();
1907 for(Int_t j=1;j<=hMin->GetNbinsX();j++){
1908 if(hRef){
1909 value=hRef->GetBinContent(j);
1910 eyl=hMin->GetBinContent(j)*value;
1911 if(eyl<0.)eyl*=-1.;
1912 if(hMax)eym=hMax->GetBinContent(j)*value;
1913 else eym=eyl;
1914 }
1915 else {
1916 value=0.;
1917 eyl=hMin->GetBinContent(j);
1918 if(eyl<0.)eyl*=-1.;
1919 if(hMax)eym=hMax->GetBinContent(j);
1920 else eym=eyl;
1921 }
1922
1923 gr->SetPoint(j-1,hMin->GetBinCenter(j),value);
1924 gr->SetPointError(j-1,ew,ew,eyl,eym);
1925 }
1926
1927 return gr;
1928}
1929
1930void AliHFDhadronCorrSystUnc::BuildGraphsRelUnc(){
1931 if(fgrYieldUncRel)delete fgrYieldUncRel;
1932 if(fgrBackSubUncRel)delete fgrBackSubUncRel;
1933 if(fgrMCcorrectionsRel)delete fgrMCcorrectionsRel;
1934 if(fgrMCDefficiencyRel)delete fgrMCDefficiencyRel;
1935 if(fgrSecContaminationRel)delete fgrSecContaminationRel;
1936 if(fgrMCclosureTestRel)delete fgrMCclosureTestRel;
1937 if(fgrBeautyFDRel)delete fgrBeautyFDRel;
1938
1939 fgrYieldUncRel=GetUncGraphFromHistos(0x0,fhYieldExtraction,0x0);
1940 fgrYieldUncRel->SetName("fgrYieldUncRel");
1941 fgrYieldUncRel->SetTitle("D meson yield");
1942
1943
1944 fgrBackSubUncRel=GetUncGraphFromHistos(0x0,fhBackSubtractionMin,fhBackSubtractionMax);
1945 fgrBackSubUncRel->SetName("fgrBackSubUncRel");
1946 fgrBackSubUncRel->SetTitle("Background D correlation subtraction");
1947
1948
1949
1950 fgrMCcorrectionsRel=GetUncGraphFromHistos(0x0,fhMCcorrectionsMin,fhMCcorrectionsMax);
1951 fgrMCcorrectionsRel->SetName("fgrMCcorrectionsRel");
1952 fgrMCcorrectionsRel->SetTitle("Associated track efficiency");
1953
1954 fgrMCDefficiencyRel=GetUncGraphFromHistos(0x0,fhMCDefficiencyMin,fhMCDefficiencyMax);
1955 fgrMCDefficiencyRel->SetName("fgrMCDefficiencyRel");
1956 fgrMCDefficiencyRel->SetTitle("D meson efficiency");
1957
1958 fgrSecContaminationRel=GetUncGraphFromHistos(0x0,fhSecContaminationMin,fhSecContaminationMax);
1959 fgrSecContaminationRel->SetName("fgrSecContaminationRel");
1960 fgrSecContaminationRel->SetTitle("Secondary contamination");
1961
1962 fgrMCclosureTestRel=GetUncGraphFromHistos(0x0,fhMCclosureTestMin,fhMCclosureTestMax);
1963 fgrMCclosureTestRel->SetName("fgrMCclosureTestRel");
1964 fgrMCclosureTestRel->SetTitle("MC closure test");
1965
1966 fgrBeautyFDRel=GetUncGraphFromHistos(0x0,fhBeautyFDmin,fhBeautyFDmax);
1967 fgrBeautyFDRel->SetName("fgrBeautyFDRel");
1968 fgrBeautyFDRel->SetTitle("Feed-down");
1969
1970 fgrYieldUncRel->SetLineColor(kBlue);
1971 fgrYieldUncRel->SetLineWidth(2);
1972 fgrYieldUncRel->SetFillStyle(3002);
1973 fgrYieldUncRel->SetFillColor(kBlue);
1974 fgrYieldUncRel->SetMarkerColor(kBlue);
1975 fgrYieldUncRel->SetMarkerStyle(20);
1976
1977
1978 fgrBackSubUncRel->SetLineColor(kMagenta);
1979 fgrBackSubUncRel->SetLineWidth(2);
1980 fgrBackSubUncRel->SetFillStyle(3008);
1981 fgrBackSubUncRel->SetFillColor(kMagenta);
1982 fgrBackSubUncRel->SetMarkerColor(kBlue);
1983 fgrBackSubUncRel->SetMarkerStyle(20);
1984
1985
1986 fgrMCcorrectionsRel->SetLineColor(kGreen);
1987 fgrMCcorrectionsRel->SetLineWidth(2);
1988 fgrMCcorrectionsRel->SetFillStyle(3006);
1989 fgrMCcorrectionsRel->SetFillColor(kGreen);
1990 fgrMCcorrectionsRel->SetMarkerColor(kGreen);
1991 fgrMCcorrectionsRel->SetMarkerStyle(22);
1992
1993 fgrMCDefficiencyRel->SetLineColor(kCyan);
1994 fgrMCDefficiencyRel->SetLineWidth(2);
1995 fgrMCDefficiencyRel->SetFillStyle(3004);
1996 fgrMCDefficiencyRel->SetFillColor(kCyan);
1997 fgrMCDefficiencyRel->SetMarkerColor(kCyan);
1998 fgrMCDefficiencyRel->SetMarkerStyle(22);
1999
2000 fgrSecContaminationRel->SetLineColor(kOrange);
2001 fgrSecContaminationRel->SetLineWidth(2);
2002 fgrSecContaminationRel->SetFillStyle(3007);
2003 fgrSecContaminationRel->SetFillColor(kOrange);
2004 fgrSecContaminationRel->SetMarkerColor(kOrange);
2005 fgrSecContaminationRel->SetMarkerStyle(22);
2006
2007 fgrMCclosureTestRel->SetLineColor(kRed);
2008 fgrMCclosureTestRel->SetLineWidth(2);
2009 fgrMCclosureTestRel->SetFillStyle(3005);
2010 fgrMCclosureTestRel->SetFillColor(kRed);
2011 fgrMCclosureTestRel->SetMarkerColor(kRed);
2012 fgrMCclosureTestRel->SetMarkerStyle(26);
2013
2014 fgrBeautyFDRel->SetLineColor(kViolet);
2015 fgrBeautyFDRel->SetLineWidth(2);
2016 fgrBeautyFDRel->SetFillStyle(3021);
2017 fgrBeautyFDRel->SetFillColor(kViolet);
2018 fgrBeautyFDRel->SetMarkerColor(kViolet);
2019 fgrBeautyFDRel->SetMarkerStyle(28);
2020
2021
2022
2023
2024}
2025
2026void AliHFDhadronCorrSystUnc::BuildGraphsUnc(TH1D *hRef){
2027
2028 if(fgrYieldUnc)delete fgrYieldUnc;
2029 if(fgrBackSubUnc)delete fgrBackSubUnc;
2030 if(fgrMCcorrections)delete fgrMCcorrections;
2031 if(fgrMCDefficiency)delete fgrMCDefficiency;
2032 if(fgrSecContamination)delete fgrSecContamination;
2033 if(fgrMCclosureTest)delete fgrMCclosureTest;
2034 if(fgrBeautyFD)delete fgrBeautyFD;
2035 if(fgrTotalRel)delete fgrTotalRel;
2036 if(fgrTotal)delete fgrTotal;
2037 if(fgrTotalNonFlatDPhi)delete fgrTotalNonFlatDPhi;
2038 if(fgrTotalNonFlatDPhiRel)delete fgrTotalNonFlatDPhiRel;
2039 if(fgrTotalFlatDPhi)delete fgrTotalFlatDPhi;
2040 if(fgrTotalFlatDPhiRel)delete fgrTotalFlatDPhiRel;
2041
2042 fgrYieldUnc=GetUncGraphFromHistos(hRef,fhYieldExtraction,0x0);
2043 fgrYieldUnc->SetName("fgrYieldUnc");
2044 fgrYieldUnc->SetTitle("D meson yield");
2045
2046 fgrBackSubUnc=GetUncGraphFromHistos(hRef,fhBackSubtractionMin,fhBackSubtractionMax);
2047 fgrBackSubUnc->SetName("fgrBackSubUnc");
2048 fgrBackSubUnc->SetTitle("Background D correlation subtraction");
2049
2050
2051 fgrMCcorrections=GetUncGraphFromHistos(hRef,fhMCcorrectionsMin,fhMCcorrectionsMax);
2052 fgrMCcorrections->SetName("fgrMCcorrections");
2053 fgrMCcorrections->SetTitle("Associated track efficiency");
2054
2055 fgrMCDefficiency=GetUncGraphFromHistos(hRef,fhMCDefficiencyMin,fhMCDefficiencyMax);
2056 fgrMCDefficiency->SetName("fgrMCDefficiency");
2057 fgrMCDefficiency->SetTitle("D meson efficiency");
2058
2059 fgrSecContamination=GetUncGraphFromHistos(hRef,fhSecContaminationMin,fhSecContaminationMax);
2060 fgrSecContamination->SetName("fgrSecContamination");
2061 fgrSecContamination->SetTitle("Secondary contamination");
2062
2063 fgrMCclosureTest=GetUncGraphFromHistos(hRef,fhMCclosureTestMin,fhMCclosureTestMax);
2064 fgrMCclosureTest->SetName("fgrMCclosureTest");
2065 fgrMCclosureTest->SetTitle("MC closure test");
2066
2067 fgrBeautyFD=GetUncGraphFromHistos(hRef,fhBeautyFDmin,fhBeautyFDmax);
2068 fgrBeautyFD->SetName("fgrBeautyFD");
2069 fgrBeautyFD->SetTitle("Feed-down");
2070
2071 fgrYieldUnc->SetLineColor(kBlue);
2072 fgrYieldUnc->SetLineWidth(2);
2073 fgrYieldUnc->SetFillStyle(0);
2074 fgrYieldUnc->SetFillColor(kBlue);
2075 fgrYieldUnc->SetMarkerColor(kBlue);
2076 fgrYieldUnc->SetMarkerStyle(20);
2077
2078
2079 fgrBackSubUnc->SetLineColor(kMagenta);
2080 fgrBackSubUnc->SetLineWidth(2);
2081 fgrBackSubUnc->SetFillStyle(0);
2082 fgrBackSubUnc->SetFillColor(kMagenta);
2083 fgrBackSubUnc->SetMarkerColor(kBlue);
2084 fgrBackSubUnc->SetMarkerStyle(20);
2085
2086
2087 fgrMCcorrections->SetLineColor(kGreen);
2088 fgrMCcorrections->SetLineWidth(2);
2089 fgrMCcorrections->SetFillStyle(0);
2090 fgrMCcorrections->SetFillColor(kGreen);
2091 fgrMCcorrections->SetMarkerColor(kGreen);
2092 fgrMCcorrections->SetMarkerStyle(22);
2093
2094 fgrMCDefficiency->SetLineColor(kCyan);
2095 fgrMCDefficiency->SetLineWidth(2);
2096 fgrMCDefficiency->SetFillStyle(0);
2097 fgrMCDefficiency->SetFillColor(kCyan);
2098 fgrMCDefficiency->SetMarkerColor(kCyan);
2099 fgrMCDefficiency->SetMarkerStyle(22);
2100
2101 fgrSecContamination->SetLineColor(kOrange);
2102 fgrSecContamination->SetLineWidth(2);
2103 fgrSecContamination->SetFillStyle(0);
2104 fgrSecContamination->SetFillColor(kOrange);
2105 fgrSecContamination->SetMarkerColor(kOrange);
2106 fgrSecContamination->SetMarkerStyle(22);
2107
2108 fgrMCclosureTest->SetLineColor(kRed);
2109 fgrMCclosureTest->SetLineWidth(2);
2110 fgrMCclosureTest->SetFillStyle(0);
2111 fgrMCclosureTest->SetFillColor(kRed);
2112 fgrMCclosureTest->SetMarkerColor(kRed);
2113 fgrMCclosureTest->SetMarkerStyle(26);
2114
2115 fgrBeautyFD->SetLineColor(kViolet);
2116 fgrBeautyFD->SetLineWidth(2);
2117 fgrBeautyFD->SetFillStyle(0);
2118 fgrBeautyFD->SetFillColor(kViolet);
2119 fgrBeautyFD->SetMarkerColor(kViolet);
2120 fgrBeautyFD->SetMarkerStyle(28);
2121
2122 // fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
2123 if(fhTotalMin){
2124 fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
2125 fgrTotalRel->SetLineColor(kBlack);
2126 fgrTotalRel->SetLineWidth(2);
2127 fgrTotalRel->SetFillStyle(0);
2128 // fgrTotalRel->SetFillColor(kRed);
2129 fgrTotalRel->SetMarkerColor(kBlack);
2130 fgrTotalRel->SetMarkerStyle(26);
2131
2132 fgrTotal=GetUncGraphFromHistos(hRef,fhTotalMin,fhTotalMax);
2133 fgrTotal->SetLineColor(kBlack);
2134 fgrTotal->SetLineWidth(2);
2135 fgrTotal->SetFillStyle(0);
2136 fgrTotal->SetFillColor(kRed);
2137 fgrTotal->SetMarkerColor(kBlack);
2138 fgrTotal->SetMarkerStyle(26);
2139 }
2140
2141 if(fhTotalNonFDMin){
2142 fgrTotalNonFD=GetUncGraphFromHistos(hRef,fhTotalNonFDMin,fhTotalNonFDMax);
2143 fgrTotalNonFD->SetLineColor(kBlue);
2144 fgrTotalNonFD->SetLineWidth(2);
2145 fgrTotalNonFD->SetFillStyle(3005);
2146 fgrTotalNonFD->SetFillColor(kBlue);
2147 fgrTotalNonFD->SetMarkerColor(kBlue);
2148 fgrTotalNonFD->SetMarkerStyle(26);
2149 }
2150
2151 if(fhTotalNonFlatDPhiMin){
2152 fgrTotalNonFlatDPhiRel=GetUncGraphFromHistos(0x0,fhTotalNonFlatDPhiMin,fhTotalNonFlatDPhiMax);
2153 fgrTotalNonFlatDPhiRel->SetLineColor(kBlack);
2154 fgrTotalNonFlatDPhiRel->SetLineWidth(2);
2155 fgrTotalNonFlatDPhiRel->SetFillStyle(0);
2156 // fgrTotalRel->SetFillColor(kRed);
2157 fgrTotalNonFlatDPhiRel->SetMarkerColor(kBlack);
2158 fgrTotalNonFlatDPhiRel->SetMarkerStyle(26);
2159
2160 fgrTotalNonFlatDPhi=GetUncGraphFromHistos(hRef,fhTotalNonFlatDPhiMin,fhTotalNonFlatDPhiMax);
2161 fgrTotalNonFlatDPhi->SetLineColor(kBlack);
2162 fgrTotalNonFlatDPhi->SetLineWidth(2);
2163 fgrTotalNonFlatDPhi->SetFillStyle(3005);
2164 fgrTotalNonFlatDPhi->SetFillColor(kRed);
2165 fgrTotalNonFlatDPhi->SetMarkerColor(kBlack);
2166 fgrTotalNonFlatDPhi->SetMarkerStyle(26);
2167
2168 fgrTotalFlatDPhiRel=GetUncGraphFromHistos(0x0,fhtotFlatMin,fhtotFlatMax);
2169 fgrTotalFlatDPhiRel->SetLineColor(kBlack);
2170 fgrTotalFlatDPhiRel->SetLineWidth(2);
2171 fgrTotalFlatDPhiRel->SetFillStyle(0);
2172 // fgrTotalRel->SetFillColor(kRed);
2173 fgrTotalFlatDPhiRel->SetMarkerColor(kBlack);
2174 fgrTotalFlatDPhiRel->SetMarkerStyle(26);
2175
2176 fgrTotalFlatDPhi=GetUncGraphFromHistos(hRef,fhtotFlatMin,fhtotFlatMax);
2177 fgrTotalFlatDPhi->SetLineColor(kBlack);
2178 fgrTotalFlatDPhi->SetLineWidth(2);
2179 fgrTotalFlatDPhi->SetFillStyle(3005);
2180 fgrTotalFlatDPhi->SetFillColor(kBlack);
2181 fgrTotalFlatDPhi->SetMarkerColor(kBlack);
2182 fgrTotalFlatDPhi->SetMarkerStyle(26);
2183 }
2184
2185}
2186
2187
2188TCanvas* AliHFDhadronCorrSystUnc::BuildSystUncertaintyPlotVsDeltaPhi(TH1D *hCorrPlot,Int_t doInit){
2189
2190 if(doInit!=0){
2191 BuildTotalUncHisto();
2192 BuildTotalNonFDUncHisto();
2193 BuildTotalNonFlatUncHisto();
2194 BuildGraphsUnc(hCorrPlot);
2195 BuildGraphsRelUnc();
2196
2197 }
2198
2199 // Easy canva with relative uncertainties
2200 TCanvas *cCanvaRelUnc=new TCanvas("cCanvaRelUnc","cCanvaRelUnc",700,700);
2201 cCanvaRelUnc->cd();
2202 TH2D *hDraw=new TH2D("hDraw","hDraw",32,-TMath::Pi()/2.,3./2.*TMath::Pi(),200,-2.,2.);
2203 hDraw->SetXTitle("#Delta#phi (rad)");
2204 hDraw->SetYTitle("Relative uncertainty");
2205 hDraw->Draw();
2206
2207
2208 fgrYieldUncRel->Draw("E2");
2209 fgrBackSubUncRel->Draw("E2");
2210 fgrMCcorrectionsRel->Draw("E2");
2211 fgrMCDefficiencyRel->Draw("E2");
2212 fgrSecContaminationRel->Draw("E2");
2213 fgrMCclosureTestRel->Draw("E2");
2214 fgrBeautyFDRel->Draw("E2");
2215 // fgrTotalRel->Draw("E2");
2216
2217 fhtotFlatMin->Draw("same");
2218 fhtotFlatMax->Draw("same");
2219
2220 fhTotalMin->Draw("same");
2221 fhTotalMax->Draw("same");
2222
2223 TCanvas *cCanvaFinalPlot=new TCanvas("cCanvaFinalPlot","cCanvaFinalPlot",700,700);
2224 cCanvaFinalPlot->cd();
2225 hCorrPlot->Draw();
2226 // fgrYieldUnc->Draw("pE2");
2227 // fgrBackSubUnc->Draw("pE2");
2228 // fgrMCcorrections->Draw("pE2");
2229 // fgrMCclosureTest->Draw("pE2");
2230 // fgrBeautyFD->Draw("pE2");
2231 fgrTotal->Draw("E2");
2232
2233
2234 TCanvas *cCanvaFinalPlotFD=new TCanvas("cCanvaFinalPlotFD","cCanvaFinalPlotFD",700,700);
2235 cCanvaFinalPlotFD->cd();
2236 hCorrPlot->Draw();
2237 // fgrYieldUnc->Draw("pE2");
2238 // fgrBackSubUnc->Draw("pE2");
2239 // fgrMCcorrections->Draw("pE2");
2240 // fgrMCclosureTest->Draw("pE2");
2241 // fgrBeautyFD->Draw("pE2");
2242 fgrBeautyFD->Draw("E2");
2243 fgrTotalNonFD->Draw("E2");
2244 fgrTotalNonFlatDPhi->Draw("E2");
2245 fgrTotalFlatDPhi->Draw("E2");
2246
2247 return cCanvaFinalPlot;
2248}
2249
2250
2251TH1D* AliHFDhadronCorrSystUnc::GetVariedHisto(const TH1D *hIn,const TGraphAsymmErrors *gr,Int_t minmax){
2252
2253 TH1D *hOut;
2254 if(minmax==0){
2255 hOut=(TH1D*)hIn->Clone(Form("%sVariedMin",hIn->GetName()));
2256 }
2257 else if(minmax==1){
2258 hOut=(TH1D*)hIn->Clone(Form("%sVariedMax",hIn->GetName()));
2259 }
2260 // Int_t np=gr->GetN();
2261 Double_t *x,*y,*ely,*ehy;//*elx,*ehx,
2262 x=gr->GetX();
2263 y=gr->GetY();
2264 // elx=gr->GetEXlow();
2265 // ehx=gr->GetEXhigh();
2266 ely=gr->GetEYlow();
2267 ehy=gr->GetEYhigh();
2268
2269 for(Int_t jp=1;jp<=hIn->GetNbinsX();jp++){
2270 if(TMath::Abs(x[jp-1]-hIn->GetBinCenter(jp))>0.0001){
2271 Printf("Bin Mismatch: this method assumes that the graph has the points in the center of the histo bin centers");
2272 return 0x0;
2273 }
2274 if(TMath::Abs(y[jp-1]-hIn->GetBinContent(jp))>0.0001){
2275 Printf("Value Mismatch: this method relies on the fact that the graph central values are the same as those of the histo");
2276 return 0x0;
2277 }
2278 if(minmax==0){
2279 hOut->SetBinContent(jp,y[jp-1]-ely[jp-1]);
2280 }
2281 else if(minmax==1){
2282 hOut->SetBinContent(jp,y[jp-1]+ehy[jp-1]);
2283 }
2284 hOut->SetBinError(jp,hIn->GetBinError(jp));
2285 }
2286
2287 return hOut;
2288}
2289
2290
2291
2292////////////////////////////////////////////////////////////////////////////////////////////////////////
2293/////
2294///// METHODS WITH UNCERTAINTIES: PP 2010, for kinematic cases approved after HP2013
2295/////
2296////////////////////////////////////////////////////////////////////////////////////////////////////////
2297
2298
2299// START FROM DPLUS FOR PT(ASSOC)>0.3
2300void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2301 fmeson=0;
2302 fstrmeson="Dplus";
2303 fstrptAss="ptAsMore03";
2304 fstrptD="Dpt3to5";
2305 if(!fhDeltaPhiTemplate){
2306 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2307 }
2308 Double_t x;
2309 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2310 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2311 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2312 fhYieldExtraction->SetBinContent(j,0.1);
2313 }
2314
2315 // Background D MESON candidate subtraction (side-band variations, etc.)
2316 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2317 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2318 fhBackSubtractionMin->SetBinContent(j,-0.05);
2319 }
2320
2321 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2322 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2323 fhBackSubtractionMax->SetBinContent(j,0.05);
2324 }
2325
2326
2327 // MC CORRECTIONS ( associatate track efficiency):
2328 // -5% +10% for assoc track eff
2329 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2330 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2331 fhMCcorrectionsMin->SetBinContent(j,-0.05);
2332 }
2333
2334 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2335 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2336 fhMCcorrectionsMax->SetBinContent(j,0.10);
2337 }
2338
2339 // MC D EFF CORRECTION
2340 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2341 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2342 fhMCDefficiencyMin->SetBinContent(j,-0.05);
2343 }
2344
2345 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2346 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2347 fhMCDefficiencyMax->SetBinContent(j,0.05);
2348 }
2349
2350
2351 // Contamination from secondary tracks
2352 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2353 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2354 fhSecContaminationMin->SetBinContent(j,-0.05);
2355 }
2356
2357 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2358 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2359 fhSecContaminationMax->SetBinContent(j,0.05);
2360 }
2361
2362
2363 // MC CLOSURETEST (D meson efficiency)
2364 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2365 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2366 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 2367 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 2368
2369 if(-0.4<x&&x<-0.2){
2370 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2371 }
2372 else if(-0.2<x&&x<-0.1){
2373 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2374 }
2375 else if(-0.1<x&&x<0.1){
2376 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2377 }
2378 else if(0.1<x&&x<0.2){
2379 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2380 }
2381 if(0.2<x&&x<0.4){
2382 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2383 }
2384 }
2385
2386 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2387 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2388 // x=fhMCclosureTestMax->GetBinLowEdge(j);
2389 fhMCclosureTestMax->SetBinContent(j,0.);
2390
2391 // if(-0.4<x&&x<-0.2){
2392 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2393 // }
2394 // else if(-0.2<x&&x<-0.1){
2395 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2396 // }
2397 // else if(-0.2<x&&x<-0.1){
2398 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2399 // }
2400 // else if(-0.1<x&&x<0.1){
2401 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2402 // }
2403 // else if(0.1<x&&x<0.2){
2404 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2405 // }
2406 // if(0.2<x&&x<0.4){
2407 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2408 // }
2409
2410 }
2411
2412 // Feed-down
2413
2414 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2415 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2416 x=fhBeautyFDmin->GetBinLowEdge(j);
2417 fhBeautyFDmin->SetBinContent(j,-0.05);
2418
2419 // if(-0.4<x&&x<-0.2){
2420// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2421// }
2422// else if(-0.2<x&&x<-0.1){
2423// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2424// }
2425// else if(-0.2<x&&x<-0.1){
2426// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2427// }
2428// else if(-0.1<x&&x<0.1){
2429// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2430// }
2431// else if(0.1<x&&x<0.2){
2432// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2433// }
2434// if(0.2<x&&x<0.4){
2435// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2436// }
2437 }
2438
2439 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2440 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2441 x=fhBeautyFDmax->GetBinLowEdge(j);
2442 fhBeautyFDmax->SetBinContent(j,0.03);
2443
2444// if(-0.4<x&&x<-0.2){
2445// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2446// }
2447// else if(-0.2<x&&x<-0.1){
2448// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2449// }
2450// else if(-0.2<x&&x<-0.1){
2451// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2452// }
2453// else if(-0.1<x&&x<0.1){
2454// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2455// }
2456// else if(0.1<x&&x<0.2){
2457// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2458// }
76948b1d 2459// if(0.2<x&&x<0.4){
62f6d8bf 2460// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2461// }
2462
2463 }
2464
2465}
2466
2467void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2468
2469 fmeson=0;
2470 fstrmeson="Dplus";
2471 fstrptAss="ptAsMore03";
2472 fstrptD="Dpt5to8";
2473 if(!fhDeltaPhiTemplate){
2474 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2475 }
2476 Double_t x;
2477 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2478 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2479 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2480 fhYieldExtraction->SetBinContent(j,0.1);
2481 }
2482
2483 // Background D MESON candidate subtraction (side-band variations, etc.)
2484 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2485 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 2486 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 2487 }
2488
2489 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2490 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2491 fhBackSubtractionMax->SetBinContent(j,0.05);
2492 }
2493
2494 // MC CORRECTIONS: -5% +10% for assoc track eff
2495 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2496 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2497 fhMCcorrectionsMin->SetBinContent(j,-0.05);
2498 }
2499
2500 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2501 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2502 fhMCcorrectionsMax->SetBinContent(j,0.10);
2503 }
2504
2505
2506 // MC D EFF CORRECTION
2507 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2508 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2509 fhMCDefficiencyMin->SetBinContent(j,-0.05);
2510 }
2511
2512 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2513 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2514 fhMCDefficiencyMax->SetBinContent(j,0.05);
2515 }
2516
2517
2518 // Contamination from secondary tracks
2519 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2520 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2521 fhSecContaminationMin->SetBinContent(j,-0.05);
2522 }
2523
2524 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2525 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2526 fhSecContaminationMax->SetBinContent(j,0.05);
2527 }
2528
2529 // MC CLOSURETEST (D meson efficiency)
2530 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2531 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2532 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 2533 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 2534
2535 if(-0.4<x&&x<-0.2){
2536 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2537 }
2538 else if(-0.2<x&&x<-0.1){
2539 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2540 }
2541 else if(-0.1<x&&x<0.1){
2542 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2543 }
2544 else if(0.1<x&&x<0.2){
2545 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2546 }
2547 if(0.2<x&&x<0.4){
2548 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2549 }
2550 }
2551
2552 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2553 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2554 x=fhMCclosureTestMax->GetBinLowEdge(j);
2555 fhMCclosureTestMax->SetBinContent(j,0.);
2556
2557 // if(-0.4<x&&x<-0.2){
2558 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2559 // }
2560 // else if(-0.2<x&&x<-0.1){
2561 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2562 // }
2563 // else if(-0.2<x&&x<-0.1){
2564 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2565 // }
2566 // else if(-0.1<x&&x<0.1){
2567 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2568 // }
2569 // else if(0.1<x&&x<0.2){
2570 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2571 // }
2572 // if(0.2<x&&x<0.4){
2573 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2574 // }
2575
2576 }
2577
2578 // Feed-down
2579
2580 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2581 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2582 x=fhBeautyFDmin->GetBinLowEdge(j);
2583 fhBeautyFDmin->SetBinContent(j,-0.05);
2584
2585 // if(-0.4<x&&x<-0.2){
2586// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2587// }
2588// else if(-0.2<x&&x<-0.1){
2589// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2590// }
2591// else if(-0.2<x&&x<-0.1){
2592// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2593// }
2594// else if(-0.1<x&&x<0.1){
2595// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2596// }
2597// else if(0.1<x&&x<0.2){
2598// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2599// }
2600// if(0.2<x&&x<0.4){
2601// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2602// }
2603 }
2604
2605 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2606 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2607 x=fhBeautyFDmax->GetBinLowEdge(j);
2608 fhBeautyFDmax->SetBinContent(j,0.03);
2609
2610// if(-0.4<x&&x<-0.2){
2611// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2612// }
2613// else if(-0.2<x&&x<-0.1){
2614// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2615// }
2616// else if(-0.2<x&&x<-0.1){
2617// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2618// }
2619// else if(-0.1<x&&x<0.1){
2620// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2621// }
2622// else if(0.1<x&&x<0.2){
2623// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2624// }
2625// if(0.2<x&&x<0.4){
2626// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2627// }
2628
2629 }
2630
2631}
2632
2633
2634void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2635
2636 fmeson=0;
2637 fstrmeson="Dplus";
2638 fstrptAss="ptAsMore03";
2639 fstrptD="Dpt8to16";
2640 if(!fhDeltaPhiTemplate){
2641 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2642 }
2643
2644 Double_t x;
2645 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2646 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2647 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2648 fhYieldExtraction->SetBinContent(j,0.1);
2649 }
2650
2651 // Background D MESON candidate subtraction (side-band variations, etc.)
2652 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2653 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 2654 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 2655 }
2656
2657 // Background D MESON candidate subtraction (side-band variations, etc.)
2658 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2659 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2660 fhBackSubtractionMax->SetBinContent(j,0.05);
2661 }
2662
2663 // MC CORRECTIONS, -5% 10% for assoc track eff
2664 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2665 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2666 fhMCcorrectionsMin->SetBinContent(j,-0.05);
2667 }
2668
2669 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2670 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2671 fhMCcorrectionsMax->SetBinContent(j,0.10);
2672 }
2673
2674
2675 // MC D EFF CORRECTION
2676 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2677 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2678 fhMCDefficiencyMin->SetBinContent(j,-0.05);
2679 }
2680
2681 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2682 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2683 fhMCDefficiencyMax->SetBinContent(j,0.05);
2684 }
2685
2686
2687 // Contamination from secondary tracks
2688 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2689 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2690 fhSecContaminationMin->SetBinContent(j,-0.05);
2691 }
2692
2693 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2694 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2695 fhSecContaminationMax->SetBinContent(j,0.05);
2696 }
2697
2698 // MC CLOSURETEST (D meson efficiency)
2699 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2700 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2701 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 2702 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 2703
2704 if(-0.4<x&&x<-0.2){
2705 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2706 }
2707 else if(-0.2<x&&x<-0.1){
2708 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2709 }
2710 else if(-0.1<x&&x<0.1){
2711 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2712 }
2713 else if(0.1<x&&x<0.2){
2714 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2715 }
2716 if(0.2<x&&x<0.4){
2717 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2718 }
2719 }
2720
2721 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2722 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2723 x=fhMCclosureTestMax->GetBinLowEdge(j);
2724 fhMCclosureTestMax->SetBinContent(j,0.);
2725
2726 // if(-0.4<x&&x<-0.2){
2727 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2728 // }
2729 // else if(-0.2<x&&x<-0.1){
2730 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2731 // }
2732 // else if(-0.2<x&&x<-0.1){
2733 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2734 // }
2735 // else if(-0.1<x&&x<0.1){
2736 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2737 // }
2738 // else if(0.1<x&&x<0.2){
2739 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2740 // }
2741 // if(0.2<x&&x<0.4){
2742 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2743 // }
2744
2745 }
2746
2747 // Feed-down
2748
2749 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2750 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2751 x=fhBeautyFDmin->GetBinLowEdge(j);
2752 fhBeautyFDmin->SetBinContent(j,-0.05);
2753
2754 // if(-0.4<x&&x<-0.2){
2755// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2756// }
2757// else if(-0.2<x&&x<-0.1){
2758// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2759// }
2760// else if(-0.2<x&&x<-0.1){
2761// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2762// }
2763// else if(-0.1<x&&x<0.1){
2764// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2765// }
2766// else if(0.1<x&&x<0.2){
2767// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2768// }
2769// if(0.2<x&&x<0.4){
2770// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2771// }
2772 }
2773
2774 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2775 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2776 x=fhBeautyFDmax->GetBinLowEdge(j);
2777 fhBeautyFDmax->SetBinContent(j,0.03);
2778
2779// if(-0.4<x&&x<-0.2){
2780// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2781// }
2782// else if(-0.2<x&&x<-0.1){
2783// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2784// }
2785// else if(-0.2<x&&x<-0.1){
2786// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2787// }
2788// else if(-0.1<x&&x<0.1){
2789// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2790// }
2791// else if(0.1<x&&x<0.2){
2792// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2793// }
2794// if(0.2<x&&x<0.4){
2795// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2796// }
2797
2798 }
2799
2800}
2801
2802
2803
2804//////// HIGHER PT ASS THRESHOLDS
2805
76948b1d 2806void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){
2807 Printf("Setting syst for D0 pp 2010 3-5 0.5 thr");
62f6d8bf 2808 fmeson=0;
2809 fstrmeson="Dzero";
2810 fstrptAss="ptAsMore05";
2811 fstrptD="Dpt3to5";
2812 if(!fhDeltaPhiTemplate){
2813 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2814 }
2815 Double_t x;
2816 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2817 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2818 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2819 fhYieldExtraction->SetBinContent(j,0.1);
2820 }
2821
2822 // Background D MESON candidate subtraction (side-band variations, etc.)
2823 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2824 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2825 fhBackSubtractionMin->SetBinContent(j,-0.05);
2826 }
2827
2828 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2829 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2830 fhBackSubtractionMax->SetBinContent(j,0.05);
2831 }
2832
2833
2834 // MC CORRECTIONS ( associatate track efficiency):
2835 // -5% +10% for assoc track eff
2836 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2837 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2838 fhMCcorrectionsMin->SetBinContent(j,-0.05);
2839 }
2840
2841 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2842 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2843 fhMCcorrectionsMax->SetBinContent(j,0.10);
2844 }
2845
2846 // MC D EFF CORRECTION
2847 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2848 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2849 fhMCDefficiencyMin->SetBinContent(j,-0.05);
2850 }
2851
2852 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2853 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2854 fhMCDefficiencyMax->SetBinContent(j,0.05);
2855 }
2856
2857
2858 // Contamination from secondary tracks
2859 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2860 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2861 fhSecContaminationMin->SetBinContent(j,-0.05);
2862 }
2863
2864 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2865 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2866 fhSecContaminationMax->SetBinContent(j,0.05);
2867 }
2868
2869
2870 // MC CLOSURETEST (D meson efficiency)
2871 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2872 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2873 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 2874 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 2875
2876 if(-0.4<x&&x<-0.2){
2877 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2878 }
2879 else if(-0.2<x&&x<-0.1){
2880 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2881 }
2882 else if(-0.1<x&&x<0.1){
2883 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2884 }
2885 else if(0.1<x&&x<0.2){
2886 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2887 }
2888 if(0.2<x&&x<0.4){
2889 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2890 }
2891 }
2892
2893 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2894 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2895 // x=fhMCclosureTestMax->GetBinLowEdge(j);
2896 fhMCclosureTestMax->SetBinContent(j,0.);
2897
2898 // if(-0.4<x&&x<-0.2){
2899 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2900 // }
2901 // else if(-0.2<x&&x<-0.1){
2902 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2903 // }
2904 // else if(-0.2<x&&x<-0.1){
2905 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2906 // }
2907 // else if(-0.1<x&&x<0.1){
2908 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2909 // }
2910 // else if(0.1<x&&x<0.2){
2911 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2912 // }
2913 // if(0.2<x&&x<0.4){
2914 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2915 // }
2916
2917 }
2918
2919 // Feed-down
2920
2921 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2922 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2923 x=fhBeautyFDmin->GetBinLowEdge(j);
2924 fhBeautyFDmin->SetBinContent(j,-0.05);
2925
2926 // if(-0.4<x&&x<-0.2){
2927// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2928// }
2929// else if(-0.2<x&&x<-0.1){
2930// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2931// }
2932// else if(-0.2<x&&x<-0.1){
2933// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2934// }
2935// else if(-0.1<x&&x<0.1){
2936// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2937// }
2938// else if(0.1<x&&x<0.2){
2939// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2940// }
2941// if(0.2<x&&x<0.4){
2942// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2943// }
2944 }
2945
2946 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2947 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2948 x=fhBeautyFDmax->GetBinLowEdge(j);
2949 fhBeautyFDmax->SetBinContent(j,0.03);
2950
2951// if(-0.4<x&&x<-0.2){
2952// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2953// }
2954// else if(-0.2<x&&x<-0.1){
2955// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2956// }
2957// else if(-0.2<x&&x<-0.1){
2958// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2959// }
2960// else if(-0.1<x&&x<0.1){
2961// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2962// }
2963// else if(0.1<x&&x<0.2){
2964// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2965// }
2966// if(0.2<x&&x<0.4){
2967// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2968// }
2969
2970 }
2971
2972}
2973
76948b1d 2974void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
2975 Printf("Setting syst for D0 pp 2010 5-8 0.5 thr");
62f6d8bf 2976
2977 fmeson=0;
2978 fstrmeson="Dzero";
2979 fstrptAss="ptAsMore05";
2980 fstrptD="Dpt5to8";
2981 if(!fhDeltaPhiTemplate){
2982 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2983 }
2984 Double_t x;
2985 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2986 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2987 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2988 fhYieldExtraction->SetBinContent(j,0.1);
2989 }
2990
2991 // Background D MESON candidate subtraction (side-band variations, etc.)
2992 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2993 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 2994 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 2995 }
2996
2997 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2998 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2999 fhBackSubtractionMax->SetBinContent(j,0.05);
3000 }
3001
3002 // MC CORRECTIONS: -5% +10% for assoc track eff
3003 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3004 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3005 fhMCcorrectionsMin->SetBinContent(j,-0.05);
3006 }
3007
3008 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3009 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3010 fhMCcorrectionsMax->SetBinContent(j,0.10);
3011 }
3012
3013
3014 // MC D EFF CORRECTION
3015 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3016 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3017 fhMCDefficiencyMin->SetBinContent(j,-0.05);
3018 }
3019
3020 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3021 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3022 fhMCDefficiencyMax->SetBinContent(j,0.05);
3023 }
3024
3025
3026 // Contamination from secondary tracks
3027 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3028 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3029 fhSecContaminationMin->SetBinContent(j,-0.05);
3030 }
3031
3032 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3033 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3034 fhSecContaminationMax->SetBinContent(j,0.05);
3035 }
3036
3037 // MC CLOSURETEST (D meson efficiency)
3038 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3039 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3040 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 3041 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 3042
3043 if(-0.4<x&&x<-0.2){
3044 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3045 }
3046 else if(-0.2<x&&x<-0.1){
3047 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3048 }
3049 else if(-0.1<x&&x<0.1){
3050 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3051 }
3052 else if(0.1<x&&x<0.2){
3053 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3054 }
3055 if(0.2<x&&x<0.4){
3056 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3057 }
3058 }
3059
3060 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3061 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3062 x=fhMCclosureTestMax->GetBinLowEdge(j);
3063 fhMCclosureTestMax->SetBinContent(j,0.);
3064
3065 // if(-0.4<x&&x<-0.2){
3066 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3067 // }
3068 // else if(-0.2<x&&x<-0.1){
3069 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3070 // }
3071 // else if(-0.2<x&&x<-0.1){
3072 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3073 // }
3074 // else if(-0.1<x&&x<0.1){
3075 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3076 // }
3077 // else if(0.1<x&&x<0.2){
3078 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3079 // }
3080 // if(0.2<x&&x<0.4){
3081 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3082 // }
3083
3084 }
3085
3086 // Feed-down
3087
3088 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3089 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3090 x=fhBeautyFDmin->GetBinLowEdge(j);
3091 fhBeautyFDmin->SetBinContent(j,-0.05);
3092
3093 // if(-0.4<x&&x<-0.2){
3094// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3095// }
3096// else if(-0.2<x&&x<-0.1){
3097// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3098// }
3099// else if(-0.2<x&&x<-0.1){
3100// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3101// }
3102// else if(-0.1<x&&x<0.1){
3103// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3104// }
3105// else if(0.1<x&&x<0.2){
3106// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3107// }
3108// if(0.2<x&&x<0.4){
3109// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3110// }
3111 }
3112
3113 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3114 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3115 x=fhBeautyFDmax->GetBinLowEdge(j);
3116 fhBeautyFDmax->SetBinContent(j,0.03);
3117
3118// if(-0.4<x&&x<-0.2){
3119// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3120// }
3121// else if(-0.2<x&&x<-0.1){
3122// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3123// }
3124// else if(-0.2<x&&x<-0.1){
3125// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3126// }
3127// else if(-0.1<x&&x<0.1){
3128// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3129// }
3130// else if(0.1<x&&x<0.2){
3131// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3132// }
3133// if(0.2<x&&x<0.4){
3134// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3135// }
3136
3137 }
3138
3139}
3140
3141
76948b1d 3142void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
3143 Printf("Setting syst for D0 pp 2010 8-16 0.5 thr");
62f6d8bf 3144
3145 fmeson=0;
3146 fstrmeson="Dzero";
3147 fstrptAss="ptAsMore05";
3148 fstrptD="Dpt8to16";
3149 if(!fhDeltaPhiTemplate){
3150 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3151 }
3152
3153 Double_t x;
3154 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3155 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3156 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3157 fhYieldExtraction->SetBinContent(j,0.1);
3158 }
3159
3160 // Background D MESON candidate subtraction (side-band variations, etc.)
3161 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3162 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 3163 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 3164 }
3165
3166 // Background D MESON candidate subtraction (side-band variations, etc.)
3167 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3168 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3169 fhBackSubtractionMax->SetBinContent(j,0.05);
3170 }
3171
3172 // MC CORRECTIONS, -5% 10% for assoc track eff
3173 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3174 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3175 fhMCcorrectionsMin->SetBinContent(j,-0.05);
3176 }
3177
3178 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3179 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3180 fhMCcorrectionsMax->SetBinContent(j,0.10);
3181 }
3182
3183
3184 // MC D EFF CORRECTION
3185 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3186 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3187 fhMCDefficiencyMin->SetBinContent(j,-0.05);
3188 }
3189
3190 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3191 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3192 fhMCDefficiencyMax->SetBinContent(j,0.05);
3193 }
3194
3195
3196 // Contamination from secondary tracks
3197 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3198 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3199 fhSecContaminationMin->SetBinContent(j,-0.05);
3200 }
3201
3202 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3203 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3204 fhSecContaminationMax->SetBinContent(j,0.05);
3205 }
3206
3207 // MC CLOSURETEST (D meson efficiency)
3208 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3209 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3210 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 3211 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 3212
3213 if(-0.4<x&&x<-0.2){
3214 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3215 }
3216 else if(-0.2<x&&x<-0.1){
3217 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3218 }
3219 else if(-0.1<x&&x<0.1){
3220 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3221 }
3222 else if(0.1<x&&x<0.2){
3223 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3224 }
3225 if(0.2<x&&x<0.4){
3226 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3227 }
3228 }
3229
3230 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3231 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3232 x=fhMCclosureTestMax->GetBinLowEdge(j);
3233 fhMCclosureTestMax->SetBinContent(j,0.);
3234
3235 // if(-0.4<x&&x<-0.2){
3236 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3237 // }
3238 // else if(-0.2<x&&x<-0.1){
3239 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3240 // }
3241 // else if(-0.2<x&&x<-0.1){
3242 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3243 // }
3244 // else if(-0.1<x&&x<0.1){
3245 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3246 // }
3247 // else if(0.1<x&&x<0.2){
3248 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3249 // }
3250 // if(0.2<x&&x<0.4){
3251 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3252 // }
3253
3254 }
3255
3256 // Feed-down
3257
3258 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3259 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3260 x=fhBeautyFDmin->GetBinLowEdge(j);
3261 fhBeautyFDmin->SetBinContent(j,-0.05);
3262
3263 // if(-0.4<x&&x<-0.2){
3264// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3265// }
3266// else if(-0.2<x&&x<-0.1){
3267// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3268// }
3269// else if(-0.2<x&&x<-0.1){
3270// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3271// }
3272// else if(-0.1<x&&x<0.1){
3273// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3274// }
3275// else if(0.1<x&&x<0.2){
3276// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3277// }
3278// if(0.2<x&&x<0.4){
3279// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3280// }
3281 }
3282
3283 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3284 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3285 x=fhBeautyFDmax->GetBinLowEdge(j);
3286 fhBeautyFDmax->SetBinContent(j,0.03);
3287
3288// if(-0.4<x&&x<-0.2){
3289// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3290// }
3291// else if(-0.2<x&&x<-0.1){
3292// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3293// }
3294// else if(-0.2<x&&x<-0.1){
3295// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3296// }
3297// else if(-0.1<x&&x<0.1){
3298// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3299// }
3300// else if(0.1<x&&x<0.2){
3301// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3302// }
3303// if(0.2<x&&x<0.4){
3304// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3305// }
3306
3307 }
3308
3309}
3310
3311
3312
3313
3314//--------------------------------------------------
76948b1d 3315void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){
3316 Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
62f6d8bf 3317 fmeson=1;
3318 fstrmeson="Dstar";
3319 fstrptAss="ptAsMore05";
3320 fstrptD="Dpt3to5";
3321 if(!fhDeltaPhiTemplate){
3322 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3323 }
3324 Double_t x;
3325 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3326 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3327 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3328 fhYieldExtraction->SetBinContent(j,0.1);
3329 }
3330
3331 // Background D MESON candidate subtraction (side-band variations, etc.)
3332 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3333 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 3334 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 3335 }
3336
3337 // Background D MESON candidate subtraction (side-band variations, etc.)
3338 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3339 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3340 fhBackSubtractionMax->SetBinContent(j,0.05);
3341 }
3342
3343 // MC CORRECTIONS, -5% 10% for assoc track eff
3344 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3345 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3346 fhMCcorrectionsMin->SetBinContent(j,-0.05);
3347 }
3348
3349 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3350 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3351 fhMCcorrectionsMax->SetBinContent(j,0.10);
3352 }
3353
3354
3355 // MC D EFF CORRECTION
3356 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3357 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3358 fhMCDefficiencyMin->SetBinContent(j,-0.05);
3359 }
3360
3361 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3362 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3363 fhMCDefficiencyMax->SetBinContent(j,0.05);
3364 }
3365
3366
3367 // Contamination from secondary tracks
3368 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3369 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3370 fhSecContaminationMin->SetBinContent(j,-0.05);
3371 }
3372
3373 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3374 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3375 fhSecContaminationMax->SetBinContent(j,0.05);
3376 }
3377
3378 // MC CLOSURETEST (D meson efficiency)
3379 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3380 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3381 x=fhMCclosureTestMin->GetBinLowEdge(j);
3382 fhMCclosureTestMin->SetBinContent(j,-0.08);
3383
3384 if(-0.4<x&&x<-0.2){
3385 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3386 }
3387 else if(-0.2<x&&x<-0.1){
3388 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3389 }
3390 else if(-0.1<x&&x<0.1){
3391 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3392 }
3393 else if(0.1<x&&x<0.2){
3394 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3395 }
3396 if(0.2<x&&x<0.4){
3397 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3398 }
3399 }
3400
3401 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3402 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3403 x=fhMCclosureTestMax->GetBinLowEdge(j);
3404 fhMCclosureTestMax->SetBinContent(j,0.);
3405
3406 // if(-0.4<x&&x<-0.2){
3407 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3408 // }
3409 // else if(-0.2<x&&x<-0.1){
3410 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3411 // }
3412 // else if(-0.2<x&&x<-0.1){
3413 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3414 // }
3415 // else if(-0.1<x&&x<0.1){
3416 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3417 // }
3418 // else if(0.1<x&&x<0.2){
3419 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3420 // }
3421 // if(0.2<x&&x<0.4){
3422 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3423 // }
3424
3425 }
3426
3427 // Feed-down
3428
3429 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3430 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3431 x=fhBeautyFDmin->GetBinLowEdge(j);
3432 fhBeautyFDmin->SetBinContent(j,-0.05);
3433
3434 // if(-0.4<x&&x<-0.2){
3435// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3436// }
3437// else if(-0.2<x&&x<-0.1){
3438// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3439// }
3440// else if(-0.2<x&&x<-0.1){
3441// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3442// }
3443// else if(-0.1<x&&x<0.1){
3444// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3445// }
3446// else if(0.1<x&&x<0.2){
3447// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3448// }
3449// if(0.2<x&&x<0.4){
3450// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3451// }
3452 }
3453
3454 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3455 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3456 x=fhBeautyFDmax->GetBinLowEdge(j);
3457 fhBeautyFDmax->SetBinContent(j,0.03);
3458
3459// if(-0.4<x&&x<-0.2){
3460// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3461// }
3462// else if(-0.2<x&&x<-0.1){
3463// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3464// }
3465// else if(-0.2<x&&x<-0.1){
3466// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3467// }
3468// else if(-0.1<x&&x<0.1){
3469// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3470// }
3471// else if(0.1<x&&x<0.2){
3472// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3473// }
3474// if(0.2<x&&x<0.4){
3475// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3476// }
3477
3478 }
3479
3480
3481}
3482
76948b1d 3483void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
3484 Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
62f6d8bf 3485 fmeson=1;
3486 fstrmeson="Dstar";
3487 fstrptAss="ptAsMore05";
3488 fstrptD="Dpt5to8";
3489 if(!fhDeltaPhiTemplate){
3490 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3491 }
3492 Double_t x;
3493 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3494 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3495 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3496 fhYieldExtraction->SetBinContent(j,0.1);
3497 }
3498
3499 // Background D MESON candidate subtraction (side-band variations, etc.)
3500 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3501 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 3502 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 3503 }
3504
3505 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3506 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3507 fhBackSubtractionMax->SetBinContent(j,0.05);
3508 }
3509
3510 // MC CORRECTIONS/ -5% 10% for assoc track eff
3511 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3512 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3513 fhMCcorrectionsMin->SetBinContent(j,-0.05);
3514 }
3515
3516 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3517 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3518 fhMCcorrectionsMax->SetBinContent(j,0.10);
3519 }
3520
3521 // MC D EFF CORRECTION
3522 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3523 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3524 fhMCDefficiencyMin->SetBinContent(j,-0.05);
3525 }
3526
3527 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3528 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3529 fhMCDefficiencyMax->SetBinContent(j,0.05);
3530 }
3531
3532
3533 // Contamination from secondary tracks
3534 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3535 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3536 fhSecContaminationMin->SetBinContent(j,-0.05);
3537 }
3538
3539 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3540 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3541 fhSecContaminationMax->SetBinContent(j,0.05);
3542 }
3543
3544 // MC CLOSURETEST (D meson efficiency)
3545 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3546 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3547 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 3548 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 3549
3550 if(-0.4<x&&x<-0.2){
3551 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3552 }
3553 else if(-0.2<x&&x<-0.1){
3554 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3555 }
3556 else if(-0.1<x&&x<0.1){
3557 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3558 }
3559 else if(0.1<x&&x<0.2){
3560 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3561 }
3562 if(0.2<x&&x<0.4){
3563 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3564 }
3565 }
3566
3567 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3568 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3569 x=fhMCclosureTestMax->GetBinLowEdge(j);
3570 fhMCclosureTestMax->SetBinContent(j,0.);
3571
3572 // if(-0.4<x&&x<-0.2){
3573 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3574 // }
3575 // else if(-0.2<x&&x<-0.1){
3576 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3577 // }
3578 // else if(-0.2<x&&x<-0.1){
3579 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3580 // }
3581 // else if(-0.1<x&&x<0.1){
3582 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3583 // }
3584 // else if(0.1<x&&x<0.2){
3585 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3586 // }
3587 // if(0.2<x&&x<0.4){
3588 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3589 // }
3590
3591 }
3592
3593 // Feed-down
3594
3595 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3596 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3597 x=fhBeautyFDmin->GetBinLowEdge(j);
3598 fhBeautyFDmin->SetBinContent(j,-0.05);
3599
3600 // if(-0.4<x&&x<-0.2){
3601// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3602// }
3603// else if(-0.2<x&&x<-0.1){
3604// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3605// }
3606// else if(-0.2<x&&x<-0.1){
3607// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3608// }
3609// else if(-0.1<x&&x<0.1){
3610// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3611// }
3612// else if(0.1<x&&x<0.2){
3613// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3614// }
3615// if(0.2<x&&x<0.4){
3616// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3617// }
3618 }
3619
3620 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3621 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3622 x=fhBeautyFDmax->GetBinLowEdge(j);
3623 fhBeautyFDmax->SetBinContent(j,0.03);
3624
3625// if(-0.4<x&&x<-0.2){
3626// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3627// }
3628// else if(-0.2<x&&x<-0.1){
3629// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3630// }
3631// else if(-0.2<x&&x<-0.1){
3632// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3633// }
3634// else if(-0.1<x&&x<0.1){
3635// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3636// }
3637// else if(0.1<x&&x<0.2){
3638// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3639// }
3640// if(0.2<x&&x<0.4){
3641// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3642// }
3643
3644 }
3645
3646}
3647
3648
3649
76948b1d 3650void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
3651 Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
62f6d8bf 3652 fmeson=1;
3653 fstrmeson="Dstar";
3654 fstrptAss="ptAsMore05";
3655 fstrptD="Dpt8to16";
3656 if(!fhDeltaPhiTemplate){
3657 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3658 }
3659 Double_t x;
3660 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3661 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3662 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3663 fhYieldExtraction->SetBinContent(j,0.1);
3664 }
3665
3666 // Background D MESON candidate subtraction (side-band variations, etc.)
3667 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3668 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
acd5f443 3669 fhBackSubtractionMin->SetBinContent(j,-0.12);
62f6d8bf 3670 }
76948b1d 3671// check those values
62f6d8bf 3672 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3673 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
acd5f443 3674 fhBackSubtractionMax->SetBinContent(j,0.12); // check this one in particular
62f6d8bf 3675 }
3676
3677 // MC CORRECTIONS -5% +10% for assoc track eff
3678 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3679 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3680 fhMCcorrectionsMin->SetBinContent(j,-0.05);
3681 }
3682
3683 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3684 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3685 fhMCcorrectionsMax->SetBinContent(j,0.10);
3686 }
3687 // MC D EFF CORRECTION
3688 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3689 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3690 fhMCDefficiencyMin->SetBinContent(j,-0.05);
3691 }
3692
3693 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3694 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3695 fhMCDefficiencyMax->SetBinContent(j,0.05);
3696 }
3697
3698
3699 // Contamination from secondary tracks
3700 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3701 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3702 fhSecContaminationMin->SetBinContent(j,-0.05);
3703 }
3704
3705 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3706 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3707 fhSecContaminationMax->SetBinContent(j,0.05);
3708 }
3709
3710 // MC CLOSURETEST (D meson efficiency)
3711 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3712 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3713 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 3714 fhMCclosureTestMin->SetBinContent(j,-0);
62f6d8bf 3715
3716 if(-0.4<x&&x<-0.2){
3717 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3718 }
3719 else if(-0.2<x&&x<-0.1){
3720 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3721 }
3722 else if(-0.1<x&&x<0.1){
3723 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3724 }
3725 else if(0.1<x&&x<0.2){
3726 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3727 }
3728 if(0.2<x&&x<0.4){
3729 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3730 }
3731 }
3732
3733 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3734 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3735 x=fhMCclosureTestMax->GetBinLowEdge(j);
3736 fhMCclosureTestMax->SetBinContent(j,0.);
3737
3738 // if(-0.4<x&&x<-0.2){
3739 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3740 // }
3741 // else if(-0.2<x&&x<-0.1){
3742 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3743 // }
3744 // else if(-0.2<x&&x<-0.1){
3745 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3746 // }
3747 // else if(-0.1<x&&x<0.1){
3748 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3749 // }
3750 // else if(0.1<x&&x<0.2){
3751 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3752 // }
3753 // if(0.2<x&&x<0.4){
3754 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3755 // }
3756
3757 }
3758
3759 // Feed-down
3760
3761 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3762 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3763 x=fhBeautyFDmin->GetBinLowEdge(j);
3764 fhBeautyFDmin->SetBinContent(j,-0.05);
3765
3766 // if(-0.4<x&&x<-0.2){
3767// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3768// }
3769// else if(-0.2<x&&x<-0.1){
3770// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3771// }
3772// else if(-0.2<x&&x<-0.1){
3773// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3774// }
3775// else if(-0.1<x&&x<0.1){
3776// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3777// }
3778// else if(0.1<x&&x<0.2){
3779// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3780// }
3781// if(0.2<x&&x<0.4){
3782// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3783// }
3784 }
3785
3786 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3787 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3788 x=fhBeautyFDmax->GetBinLowEdge(j);
3789 fhBeautyFDmax->SetBinContent(j,0.03);
3790
3791// if(-0.4<x&&x<-0.2){
3792// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3793// }
3794// else if(-0.2<x&&x<-0.1){
3795// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3796// }
3797// else if(-0.2<x&&x<-0.1){
3798// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3799// }
3800// else if(-0.1<x&&x<0.1){
3801// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3802// }
3803// else if(0.1<x&&x<0.2){
3804// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3805// }
3806// if(0.2<x&&x<0.4){
3807// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3808// }
3809
3810 }
3811
3812
3813}
3814
3815
3816
76948b1d 3817void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){
3818 Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3819 fmeson=2;
62f6d8bf 3820 fstrmeson="Dplus";
3821 fstrptAss="ptAsMore05";
3822 fstrptD="Dpt3to5";
3823 if(!fhDeltaPhiTemplate){
3824 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3825 }
3826 Double_t x;
3827 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3828 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3829 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3830 fhYieldExtraction->SetBinContent(j,0.1);
3831 }
3832
3833 // Background D MESON candidate subtraction (side-band variations, etc.)
3834 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3835 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3836 fhBackSubtractionMin->SetBinContent(j,-0.05);
3837 }
3838
3839 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3840 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3841 fhBackSubtractionMax->SetBinContent(j,0.05);
3842 }
3843
3844
3845 // MC CORRECTIONS ( associatate track efficiency):
3846 // -5% +10% for assoc track eff
3847 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3848 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3849 fhMCcorrectionsMin->SetBinContent(j,-0.05);
3850 }
3851
3852 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3853 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3854 fhMCcorrectionsMax->SetBinContent(j,0.10);
3855 }
3856
3857 // MC D EFF CORRECTION
3858 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3859 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3860 fhMCDefficiencyMin->SetBinContent(j,-0.05);
3861 }
3862
3863 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3864 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3865 fhMCDefficiencyMax->SetBinContent(j,0.05);
3866 }
3867
3868
3869 // Contamination from secondary tracks
3870 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3871 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3872 fhSecContaminationMin->SetBinContent(j,-0.05);
3873 }
3874
3875 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3876 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3877 fhSecContaminationMax->SetBinContent(j,0.05);
3878 }
3879
3880
3881 // MC CLOSURETEST (D meson efficiency)
3882 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3883 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3884 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 3885 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 3886
3887 if(-0.4<x&&x<-0.2){
3888 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3889 }
3890 else if(-0.2<x&&x<-0.1){
3891 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3892 }
3893 else if(-0.1<x&&x<0.1){
3894 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3895 }
3896 else if(0.1<x&&x<0.2){
3897 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3898 }
3899 if(0.2<x&&x<0.4){
3900 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3901 }
3902 }
3903
3904 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3905 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3906 // x=fhMCclosureTestMax->GetBinLowEdge(j);
3907 fhMCclosureTestMax->SetBinContent(j,0.);
3908
3909 // if(-0.4<x&&x<-0.2){
3910 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3911 // }
3912 // else if(-0.2<x&&x<-0.1){
3913 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3914 // }
3915 // else if(-0.2<x&&x<-0.1){
3916 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3917 // }
3918 // else if(-0.1<x&&x<0.1){
3919 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3920 // }
3921 // else if(0.1<x&&x<0.2){
3922 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3923 // }
3924 // if(0.2<x&&x<0.4){
3925 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3926 // }
3927
3928 }
3929
3930 // Feed-down
3931
3932 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3933 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3934 x=fhBeautyFDmin->GetBinLowEdge(j);
3935 fhBeautyFDmin->SetBinContent(j,-0.05);
3936
3937 // if(-0.4<x&&x<-0.2){
3938// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3939// }
3940// else if(-0.2<x&&x<-0.1){
3941// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3942// }
3943// else if(-0.2<x&&x<-0.1){
3944// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3945// }
3946// else if(-0.1<x&&x<0.1){
3947// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3948// }
3949// else if(0.1<x&&x<0.2){
3950// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3951// }
3952// if(0.2<x&&x<0.4){
3953// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3954// }
3955 }
3956
3957 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3958 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3959 x=fhBeautyFDmax->GetBinLowEdge(j);
3960 fhBeautyFDmax->SetBinContent(j,0.03);
3961
3962// if(-0.4<x&&x<-0.2){
3963// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3964// }
3965// else if(-0.2<x&&x<-0.1){
3966// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3967// }
3968// else if(-0.2<x&&x<-0.1){
3969// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3970// }
3971// else if(-0.1<x&&x<0.1){
3972// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3973// }
3974// else if(0.1<x&&x<0.2){
3975// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3976// }
3977// if(0.2<x&&x<0.4){
3978// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3979// }
3980
3981 }
3982
3983}
3984
3985void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
76948b1d 3986 Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3987 fmeson=2;
62f6d8bf 3988 fstrmeson="Dplus";
3989 fstrptAss="ptAsMore05";
3990 fstrptD="Dpt5to8";
3991 if(!fhDeltaPhiTemplate){
3992 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3993 }
3994 Double_t x;
3995 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3996 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3997 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3998 fhYieldExtraction->SetBinContent(j,0.1);
3999 }
4000
4001 // Background D MESON candidate subtraction (side-band variations, etc.)
4002 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4003 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 4004 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 4005 }
4006
4007 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4008 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4009 fhBackSubtractionMax->SetBinContent(j,0.05);
4010 }
4011
4012 // MC CORRECTIONS: -5% +10% for assoc track eff
4013 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4014 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4015 fhMCcorrectionsMin->SetBinContent(j,-0.05);
4016 }
4017
4018 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4019 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4020 fhMCcorrectionsMax->SetBinContent(j,0.10);
4021 }
4022
4023
4024 // MC D EFF CORRECTION
4025 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4026 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4027 fhMCDefficiencyMin->SetBinContent(j,-0.05);
4028 }
4029
4030 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4031 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4032 fhMCDefficiencyMax->SetBinContent(j,0.05);
4033 }
4034
4035
4036 // Contamination from secondary tracks
4037 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4038 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4039 fhSecContaminationMin->SetBinContent(j,-0.05);
4040 }
4041
4042 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4043 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4044 fhSecContaminationMax->SetBinContent(j,0.05);
4045 }
4046
4047 // MC CLOSURETEST (D meson efficiency)
4048 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4049 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4050 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 4051 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 4052
4053 if(-0.4<x&&x<-0.2){
4054 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4055 }
4056 else if(-0.2<x&&x<-0.1){
4057 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4058 }
4059 else if(-0.1<x&&x<0.1){
4060 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4061 }
4062 else if(0.1<x&&x<0.2){
4063 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4064 }
4065 if(0.2<x&&x<0.4){
4066 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4067 }
4068 }
4069
4070 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4071 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4072 x=fhMCclosureTestMax->GetBinLowEdge(j);
4073 fhMCclosureTestMax->SetBinContent(j,0.);
4074
4075 // if(-0.4<x&&x<-0.2){
4076 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4077 // }
4078 // else if(-0.2<x&&x<-0.1){
4079 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4080 // }
4081 // else if(-0.2<x&&x<-0.1){
4082 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4083 // }
4084 // else if(-0.1<x&&x<0.1){
4085 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4086 // }
4087 // else if(0.1<x&&x<0.2){
4088 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4089 // }
4090 // if(0.2<x&&x<0.4){
4091 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4092 // }
4093
4094 }
4095
4096 // Feed-down
4097
4098 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4099 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4100 x=fhBeautyFDmin->GetBinLowEdge(j);
4101 fhBeautyFDmin->SetBinContent(j,-0.05);
4102
4103 // if(-0.4<x&&x<-0.2){
4104// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4105// }
4106// else if(-0.2<x&&x<-0.1){
4107// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4108// }
4109// else if(-0.2<x&&x<-0.1){
4110// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4111// }
4112// else if(-0.1<x&&x<0.1){
4113// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4114// }
4115// else if(0.1<x&&x<0.2){
4116// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4117// }
4118// if(0.2<x&&x<0.4){
4119// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4120// }
4121 }
4122
4123 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4124 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4125 x=fhBeautyFDmax->GetBinLowEdge(j);
4126 fhBeautyFDmax->SetBinContent(j,0.03);
4127
4128// if(-0.4<x&&x<-0.2){
4129// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4130// }
4131// else if(-0.2<x&&x<-0.1){
4132// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4133// }
4134// else if(-0.2<x&&x<-0.1){
4135// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4136// }
4137// else if(-0.1<x&&x<0.1){
4138// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4139// }
4140// else if(0.1<x&&x<0.2){
4141// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4142// }
4143// if(0.2<x&&x<0.4){
4144// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4145// }
4146
4147 }
4148
4149}
4150
4151
4152void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
76948b1d 4153 Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
4154 fmeson=2;
62f6d8bf 4155 fstrmeson="Dplus";
4156 fstrptAss="ptAsMore05";
4157 fstrptD="Dpt8to16";
4158 if(!fhDeltaPhiTemplate){
4159 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4160 }
4161
4162 Double_t x;
4163 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4164 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4165 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4166 fhYieldExtraction->SetBinContent(j,0.1);
4167 }
4168
4169 // Background D MESON candidate subtraction (side-band variations, etc.)
4170 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4171 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 4172 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 4173 }
4174
4175 // Background D MESON candidate subtraction (side-band variations, etc.)
4176 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4177 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4178 fhBackSubtractionMax->SetBinContent(j,0.05);
4179 }
4180
4181 // MC CORRECTIONS, -5% 10% for assoc track eff
4182 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4183 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4184 fhMCcorrectionsMin->SetBinContent(j,-0.05);
4185 }
4186
4187 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4188 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4189 fhMCcorrectionsMax->SetBinContent(j,0.10);
4190 }
4191
4192
4193 // MC D EFF CORRECTION
4194 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4195 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4196 fhMCDefficiencyMin->SetBinContent(j,-0.05);
4197 }
4198
4199 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4200 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4201 fhMCDefficiencyMax->SetBinContent(j,0.05);
4202 }
4203
4204
4205 // Contamination from secondary tracks
4206 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4207 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4208 fhSecContaminationMin->SetBinContent(j,-0.05);
4209 }
4210
4211 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4212 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4213 fhSecContaminationMax->SetBinContent(j,0.05);
4214 }
4215
4216 // MC CLOSURETEST (D meson efficiency)
4217 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4218 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4219 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 4220 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 4221
4222 if(-0.4<x&&x<-0.2){
4223 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4224 }
4225 else if(-0.2<x&&x<-0.1){
4226 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4227 }
4228 else if(-0.1<x&&x<0.1){
4229 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4230 }
4231 else if(0.1<x&&x<0.2){
4232 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4233 }
4234 if(0.2<x&&x<0.4){
4235 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4236 }
4237 }
4238
4239 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4240 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4241 x=fhMCclosureTestMax->GetBinLowEdge(j);
4242 fhMCclosureTestMax->SetBinContent(j,0.);
4243
4244 // if(-0.4<x&&x<-0.2){
4245 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4246 // }
4247 // else if(-0.2<x&&x<-0.1){
4248 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4249 // }
4250 // else if(-0.2<x&&x<-0.1){
4251 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4252 // }
4253 // else if(-0.1<x&&x<0.1){
4254 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4255 // }
4256 // else if(0.1<x&&x<0.2){
4257 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4258 // }
4259 // if(0.2<x&&x<0.4){
4260 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4261 // }
4262
4263 }
4264
4265 // Feed-down
4266
4267 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4268 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4269 x=fhBeautyFDmin->GetBinLowEdge(j);
4270 fhBeautyFDmin->SetBinContent(j,-0.05);
4271
4272 // if(-0.4<x&&x<-0.2){
4273// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4274// }
4275// else if(-0.2<x&&x<-0.1){
4276// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4277// }
4278// else if(-0.2<x&&x<-0.1){
4279// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4280// }
4281// else if(-0.1<x&&x<0.1){
4282// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4283// }
4284// else if(0.1<x&&x<0.2){
4285// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4286// }
4287// if(0.2<x&&x<0.4){
4288// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4289// }
4290 }
4291
4292 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4293 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4294 x=fhBeautyFDmax->GetBinLowEdge(j);
4295 fhBeautyFDmax->SetBinContent(j,0.03);
4296
4297// if(-0.4<x&&x<-0.2){
4298// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4299// }
4300// else if(-0.2<x&&x<-0.1){
4301// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4302// }
4303// else if(-0.2<x&&x<-0.1){
4304// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4305// }
4306// else if(-0.1<x&&x<0.1){
4307// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4308// }
4309// else if(0.1<x&&x<0.2){
4310// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4311// }
4312// if(0.2<x&&x<0.4){
4313// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4314// }
4315
4316 }
4317
4318}
4319
4320
4321
4322// pt(assoc)> 1 GeV/c
76948b1d 4323void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){
4324 Printf("Setting uncertainties for Dzero pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
62f6d8bf 4325 fmeson=0;
4326 fstrmeson="Dzero";
4327 fstrptAss="ptAsMore1";
4328 fstrptD="Dpt3to5";
4329 if(!fhDeltaPhiTemplate){
4330 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4331 }
4332 Double_t x;
4333 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4334 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4335 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4336 fhYieldExtraction->SetBinContent(j,0.1);
4337 }
4338
4339 // Background D MESON candidate subtraction (side-band variations, etc.)
4340 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4341 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4342 fhBackSubtractionMin->SetBinContent(j,-0.05);
4343 }
4344
4345 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4346 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4347 fhBackSubtractionMax->SetBinContent(j,0.05);
4348 }
4349
4350
4351 // MC CORRECTIONS ( associatate track efficiency):
4352 // -5% +10% for assoc track eff
4353 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4354 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4355 fhMCcorrectionsMin->SetBinContent(j,-0.05);
4356 }
4357
4358 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4359 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4360 fhMCcorrectionsMax->SetBinContent(j,0.10);
4361 }
4362
4363 // MC D EFF CORRECTION
4364 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4365 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4366 fhMCDefficiencyMin->SetBinContent(j,-0.05);
4367 }
4368
4369 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4370 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4371 fhMCDefficiencyMax->SetBinContent(j,0.05);
4372 }
4373
4374
4375 // Contamination from secondary tracks
4376 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4377 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4378 fhSecContaminationMin->SetBinContent(j,-0.05);
4379 }
4380
4381 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4382 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4383 fhSecContaminationMax->SetBinContent(j,0.05);
4384 }
4385
4386
4387 // MC CLOSURETEST (D meson efficiency)
4388 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4389 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4390 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 4391 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 4392
4393 if(-0.4<x&&x<-0.2){
4394 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4395 }
4396 else if(-0.2<x&&x<-0.1){
4397 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4398 }
4399 else if(-0.1<x&&x<0.1){
4400 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4401 }
4402 else if(0.1<x&&x<0.2){
4403 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4404 }
4405 if(0.2<x&&x<0.4){
4406 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4407 }
4408 }
4409
4410 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4411 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4412 // x=fhMCclosureTestMax->GetBinLowEdge(j);
4413 fhMCclosureTestMax->SetBinContent(j,0.);
4414
4415 // if(-0.4<x&&x<-0.2){
4416 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4417 // }
4418 // else if(-0.2<x&&x<-0.1){
4419 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4420 // }
4421 // else if(-0.2<x&&x<-0.1){
4422 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4423 // }
4424 // else if(-0.1<x&&x<0.1){
4425 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4426 // }
4427 // else if(0.1<x&&x<0.2){
4428 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4429 // }
4430 // if(0.2<x&&x<0.4){
4431 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4432 // }
4433
4434 }
4435
4436 // Feed-down
4437
4438 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4439 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4440 x=fhBeautyFDmin->GetBinLowEdge(j);
4441 fhBeautyFDmin->SetBinContent(j,-0.05);
4442
4443 // if(-0.4<x&&x<-0.2){
4444// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4445// }
4446// else if(-0.2<x&&x<-0.1){
4447// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4448// }
4449// else if(-0.2<x&&x<-0.1){
4450// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4451// }
4452// else if(-0.1<x&&x<0.1){
4453// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4454// }
4455// else if(0.1<x&&x<0.2){
4456// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4457// }
4458// if(0.2<x&&x<0.4){
4459// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4460// }
4461 }
4462
4463 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4464 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4465 x=fhBeautyFDmax->GetBinLowEdge(j);
4466 fhBeautyFDmax->SetBinContent(j,0.03);
4467
4468// if(-0.4<x&&x<-0.2){
4469// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4470// }
4471// else if(-0.2<x&&x<-0.1){
4472// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4473// }
4474// else if(-0.2<x&&x<-0.1){
4475// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4476// }
4477// else if(-0.1<x&&x<0.1){
4478// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4479// }
4480// else if(0.1<x&&x<0.2){
4481// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4482// }
4483// if(0.2<x&&x<0.4){
4484// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4485// }
4486
4487 }
4488
4489}
4490
76948b1d 4491void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){
4492 Printf("Setting uncertainties for Dzero pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
62f6d8bf 4493 fmeson=0;
4494 fstrmeson="Dzero";
4495 fstrptAss="ptAsMore1";
4496 fstrptD="Dpt5to8";
4497 if(!fhDeltaPhiTemplate){
4498 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4499 }
4500 Double_t x;
4501 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4502 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4503 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4504 fhYieldExtraction->SetBinContent(j,0.1);
4505 }
4506
4507 // Background D MESON candidate subtraction (side-band variations, etc.)
4508 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4509 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 4510 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 4511 }
4512
4513 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4514 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4515 fhBackSubtractionMax->SetBinContent(j,0.05);
4516 }
4517
4518 // MC CORRECTIONS: -5% +10% for assoc track eff
4519 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4520 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4521 fhMCcorrectionsMin->SetBinContent(j,-0.05);
4522 }
4523
4524 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4525 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4526 fhMCcorrectionsMax->SetBinContent(j,0.10);
4527 }
4528
4529
4530 // MC D EFF CORRECTION
4531 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4532 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4533 fhMCDefficiencyMin->SetBinContent(j,-0.05);
4534 }
4535
4536 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4537 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4538 fhMCDefficiencyMax->SetBinContent(j,0.05);
4539 }
4540
4541
4542 // Contamination from secondary tracks
4543 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4544 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4545 fhSecContaminationMin->SetBinContent(j,-0.05);
4546 }
4547
4548 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4549 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4550 fhSecContaminationMax->SetBinContent(j,0.05);
4551 }
4552
4553 // MC CLOSURETEST (D meson efficiency)
4554 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4555 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4556 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 4557 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 4558
4559 if(-0.4<x&&x<-0.2){
4560 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4561 }
4562 else if(-0.2<x&&x<-0.1){
4563 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4564 }
4565 else if(-0.1<x&&x<0.1){
4566 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4567 }
4568 else if(0.1<x&&x<0.2){
4569 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4570 }
4571 if(0.2<x&&x<0.4){
4572 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4573 }
4574 }
4575
4576 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4577 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4578 x=fhMCclosureTestMax->GetBinLowEdge(j);
4579 fhMCclosureTestMax->SetBinContent(j,0.);
4580
4581 // if(-0.4<x&&x<-0.2){
4582 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4583 // }
4584 // else if(-0.2<x&&x<-0.1){
4585 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4586 // }
4587 // else if(-0.2<x&&x<-0.1){
4588 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4589 // }
4590 // else if(-0.1<x&&x<0.1){
4591 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4592 // }
4593 // else if(0.1<x&&x<0.2){
4594 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4595 // }
4596 // if(0.2<x&&x<0.4){
4597 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4598 // }
4599
4600 }
4601
4602 // Feed-down
4603
4604 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4605 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4606 x=fhBeautyFDmin->GetBinLowEdge(j);
4607 fhBeautyFDmin->SetBinContent(j,-0.05);
4608
4609 // if(-0.4<x&&x<-0.2){
4610// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4611// }
4612// else if(-0.2<x&&x<-0.1){
4613// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4614// }
4615// else if(-0.2<x&&x<-0.1){
4616// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4617// }
4618// else if(-0.1<x&&x<0.1){
4619// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4620// }
4621// else if(0.1<x&&x<0.2){
4622// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4623// }
4624// if(0.2<x&&x<0.4){
4625// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4626// }
4627 }
4628
4629 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4630 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4631 x=fhBeautyFDmax->GetBinLowEdge(j);
4632 fhBeautyFDmax->SetBinContent(j,0.03);
4633
4634// if(-0.4<x&&x<-0.2){
4635// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4636// }
4637// else if(-0.2<x&&x<-0.1){
4638// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4639// }
4640// else if(-0.2<x&&x<-0.1){
4641// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4642// }
4643// else if(-0.1<x&&x<0.1){
4644// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4645// }
4646// else if(0.1<x&&x<0.2){
4647// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4648// }
4649// if(0.2<x&&x<0.4){
4650// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4651// }
4652
4653 }
4654
4655}
4656
4657
76948b1d 4658void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
4659 Printf("Setting uncertainties for Dzero pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
62f6d8bf 4660 fmeson=0;
4661 fstrmeson="Dzero";
4662 fstrptAss="ptAsMore1";
4663 fstrptD="Dpt8to16";
4664 if(!fhDeltaPhiTemplate){
4665 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4666 }
4667
4668 Double_t x;
4669 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4670 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4671 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4672 fhYieldExtraction->SetBinContent(j,0.1);
4673 }
4674
4675 // Background D MESON candidate subtraction (side-band variations, etc.)
4676 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4677 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 4678 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 4679 }
4680
4681 // Background D MESON candidate subtraction (side-band variations, etc.)
4682 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4683 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4684 fhBackSubtractionMax->SetBinContent(j,0.05);
4685 }
4686
4687 // MC CORRECTIONS, -5% 10% for assoc track eff
4688 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4689 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4690 fhMCcorrectionsMin->SetBinContent(j,-0.05);
4691 }
4692
4693 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4694 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4695 fhMCcorrectionsMax->SetBinContent(j,0.10);
4696 }
4697
4698
4699 // MC D EFF CORRECTION
4700 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4701 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4702 fhMCDefficiencyMin->SetBinContent(j,-0.05);
4703 }
4704
4705 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4706 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4707 fhMCDefficiencyMax->SetBinContent(j,0.05);
4708 }
4709
4710
4711 // Contamination from secondary tracks
4712 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4713 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4714 fhSecContaminationMin->SetBinContent(j,-0.05);
4715 }
4716
4717 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4718 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4719 fhSecContaminationMax->SetBinContent(j,0.05);
4720 }
4721
4722 // MC CLOSURETEST (D meson efficiency)
4723 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4724 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4725 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 4726 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 4727
4728 if(-0.4<x&&x<-0.2){
4729 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4730 }
4731 else if(-0.2<x&&x<-0.1){
4732 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4733 }
4734 else if(-0.1<x&&x<0.1){
4735 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4736 }
4737 else if(0.1<x&&x<0.2){
4738 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4739 }
4740 if(0.2<x&&x<0.4){
4741 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4742 }
4743 }
4744
4745 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4746 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4747 x=fhMCclosureTestMax->GetBinLowEdge(j);
4748 fhMCclosureTestMax->SetBinContent(j,0.);
4749
4750 // if(-0.4<x&&x<-0.2){
4751 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4752 // }
4753 // else if(-0.2<x&&x<-0.1){
4754 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4755 // }
4756 // else if(-0.2<x&&x<-0.1){
4757 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4758 // }
4759 // else if(-0.1<x&&x<0.1){
4760 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4761 // }
4762 // else if(0.1<x&&x<0.2){
4763 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4764 // }
4765 // if(0.2<x&&x<0.4){
4766 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4767 // }
4768
4769 }
4770
4771 // Feed-down
4772
4773 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4774 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4775 x=fhBeautyFDmin->GetBinLowEdge(j);
4776 fhBeautyFDmin->SetBinContent(j,-0.05);
4777
4778 // if(-0.4<x&&x<-0.2){
4779// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4780// }
4781// else if(-0.2<x&&x<-0.1){
4782// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4783// }
4784// else if(-0.2<x&&x<-0.1){
4785// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4786// }
4787// else if(-0.1<x&&x<0.1){
4788// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4789// }
4790// else if(0.1<x&&x<0.2){
4791// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4792// }
4793// if(0.2<x&&x<0.4){
4794// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4795// }
4796 }
4797
4798 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4799 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4800 x=fhBeautyFDmax->GetBinLowEdge(j);
4801 fhBeautyFDmax->SetBinContent(j,0.03);
4802
4803// if(-0.4<x&&x<-0.2){
4804// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4805// }
4806// else if(-0.2<x&&x<-0.1){
4807// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4808// }
4809// else if(-0.2<x&&x<-0.1){
4810// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4811// }
4812// else if(-0.1<x&&x<0.1){
4813// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4814// }
4815// else if(0.1<x&&x<0.2){
4816// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4817// }
4818// if(0.2<x&&x<0.4){
4819// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4820// }
4821
4822 }
4823
4824}
4825
4826
4827
4828
4829//--------------------------------------------------
4830void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
76948b1d 4831 Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
62f6d8bf 4832 fmeson=1;
4833 fstrmeson="Dstar";
4834 fstrptAss="ptAsMore1";
4835 fstrptD="Dpt3to5";
4836 if(!fhDeltaPhiTemplate){
4837 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4838 }
4839 Double_t x;
4840 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4841 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4842 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4843 fhYieldExtraction->SetBinContent(j,0.1);
4844 }
4845
4846 // Background D MESON candidate subtraction (side-band variations, etc.)
4847 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4848 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 4849 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 4850 }
4851
4852 // Background D MESON candidate subtraction (side-band variations, etc.)
4853 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4854 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4855 fhBackSubtractionMax->SetBinContent(j,0.05);
4856 }
4857
4858 // MC CORRECTIONS, -5% 10% for assoc track eff
4859 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4860 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4861 fhMCcorrectionsMin->SetBinContent(j,-0.05);
4862 }
4863
4864 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4865 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4866 fhMCcorrectionsMax->SetBinContent(j,0.10);
4867 }
4868
4869
4870 // MC D EFF CORRECTION
4871 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4872 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4873 fhMCDefficiencyMin->SetBinContent(j,-0.05);
4874 }
4875
4876 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4877 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4878 fhMCDefficiencyMax->SetBinContent(j,0.05);
4879 }
4880
4881
4882 // Contamination from secondary tracks
4883 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4884 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4885 fhSecContaminationMin->SetBinContent(j,-0.05);
4886 }
4887
4888 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4889 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4890 fhSecContaminationMax->SetBinContent(j,0.05);
4891 }
4892
4893 // MC CLOSURETEST (D meson efficiency)
4894 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4895 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4896 x=fhMCclosureTestMin->GetBinLowEdge(j);
4897 fhMCclosureTestMin->SetBinContent(j,-0.08);
4898
4899 if(-0.4<x&&x<-0.2){
4900 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4901 }
4902 else if(-0.2<x&&x<-0.1){
4903 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4904 }
4905 else if(-0.1<x&&x<0.1){
4906 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4907 }
4908 else if(0.1<x&&x<0.2){
4909 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4910 }
4911 if(0.2<x&&x<0.4){
4912 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4913 }
4914 }
4915
4916 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4917 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4918 x=fhMCclosureTestMax->GetBinLowEdge(j);
4919 fhMCclosureTestMax->SetBinContent(j,0.);
4920
4921 // if(-0.4<x&&x<-0.2){
4922 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4923 // }
4924 // else if(-0.2<x&&x<-0.1){
4925 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4926 // }
4927 // else if(-0.2<x&&x<-0.1){
4928 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4929 // }
4930 // else if(-0.1<x&&x<0.1){
4931 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4932 // }
4933 // else if(0.1<x&&x<0.2){
4934 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4935 // }
4936 // if(0.2<x&&x<0.4){
4937 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4938 // }
4939
4940 }
4941
4942 // Feed-down
4943
4944 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4945 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4946 x=fhBeautyFDmin->GetBinLowEdge(j);
4947 fhBeautyFDmin->SetBinContent(j,-0.05);
4948
4949 // if(-0.4<x&&x<-0.2){
4950// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4951// }
4952// else if(-0.2<x&&x<-0.1){
4953// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4954// }
4955// else if(-0.2<x&&x<-0.1){
4956// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4957// }
4958// else if(-0.1<x&&x<0.1){
4959// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4960// }
4961// else if(0.1<x&&x<0.2){
4962// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4963// }
4964// if(0.2<x&&x<0.4){
4965// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4966// }
4967 }
4968
4969 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4970 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4971 x=fhBeautyFDmax->GetBinLowEdge(j);
4972 fhBeautyFDmax->SetBinContent(j,0.03);
4973
4974// if(-0.4<x&&x<-0.2){
4975// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4976// }
4977// else if(-0.2<x&&x<-0.1){
4978// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4979// }
4980// else if(-0.2<x&&x<-0.1){
4981// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4982// }
4983// else if(-0.1<x&&x<0.1){
4984// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4985// }
4986// else if(0.1<x&&x<0.2){
4987// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4988// }
4989// if(0.2<x&&x<0.4){
4990// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4991// }
4992
4993 }
4994
4995
4996}
4997
76948b1d 4998void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){
4999 Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
62f6d8bf 5000 fmeson=1;
5001 fstrmeson="Dstar";
5002 fstrptAss="ptAsMore1";
5003 fstrptD="Dpt5to8";
5004 if(!fhDeltaPhiTemplate){
5005 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5006 }
5007 Double_t x;
5008 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5009 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5010 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5011 fhYieldExtraction->SetBinContent(j,0.1);
5012 }
5013
5014 // Background D MESON candidate subtraction (side-band variations, etc.)
5015 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5016 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 5017 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 5018 }
5019
5020 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5021 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5022 fhBackSubtractionMax->SetBinContent(j,0.05);
5023 }
5024
5025 // MC CORRECTIONS/ -5% 10% for assoc track eff
5026 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5027 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5028 fhMCcorrectionsMin->SetBinContent(j,-0.05);
5029 }
5030
5031 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5032 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5033 fhMCcorrectionsMax->SetBinContent(j,0.10);
5034 }
5035
5036 // MC D EFF CORRECTION
5037 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5038 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5039 fhMCDefficiencyMin->SetBinContent(j,-0.05);
5040 }
5041
5042 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5043 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5044 fhMCDefficiencyMax->SetBinContent(j,0.05);
5045 }
5046
5047
5048 // Contamination from secondary tracks
5049 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5050 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5051 fhSecContaminationMin->SetBinContent(j,-0.05);
5052 }
5053
5054 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5055 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5056 fhSecContaminationMax->SetBinContent(j,0.05);
5057 }
5058
5059 // MC CLOSURETEST (D meson efficiency)
5060 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5061 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5062 x=fhMCclosureTestMin->GetBinLowEdge(j);
5063 fhMCclosureTestMin->SetBinContent(j,-0.08);
5064
5065 if(-0.4<x&&x<-0.2){
5066 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5067 }
5068 else if(-0.2<x&&x<-0.1){
5069 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5070 }
5071 else if(-0.1<x&&x<0.1){
5072 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5073 }
5074 else if(0.1<x&&x<0.2){
5075 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5076 }
5077 if(0.2<x&&x<0.4){
5078 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5079 }
5080 }
5081
5082 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5083 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5084 x=fhMCclosureTestMax->GetBinLowEdge(j);
5085 fhMCclosureTestMax->SetBinContent(j,0.);
5086
5087 // if(-0.4<x&&x<-0.2){
5088 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5089 // }
5090 // else if(-0.2<x&&x<-0.1){
5091 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5092 // }
5093 // else if(-0.2<x&&x<-0.1){
5094 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5095 // }
5096 // else if(-0.1<x&&x<0.1){
5097 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5098 // }
5099 // else if(0.1<x&&x<0.2){
5100 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5101 // }
5102 // if(0.2<x&&x<0.4){
5103 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5104 // }
5105
5106 }
5107
5108 // Feed-down
5109
5110 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5111 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5112 x=fhBeautyFDmin->GetBinLowEdge(j);
5113 fhBeautyFDmin->SetBinContent(j,-0.05);
5114
5115 // if(-0.4<x&&x<-0.2){
5116// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5117// }
5118// else if(-0.2<x&&x<-0.1){
5119// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5120// }
5121// else if(-0.2<x&&x<-0.1){
5122// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5123// }
5124// else if(-0.1<x&&x<0.1){
5125// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5126// }
5127// else if(0.1<x&&x<0.2){
5128// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5129// }
5130// if(0.2<x&&x<0.4){
5131// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5132// }
5133 }
5134
5135 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5136 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5137 x=fhBeautyFDmax->GetBinLowEdge(j);
5138 fhBeautyFDmax->SetBinContent(j,0.03);
5139
5140// if(-0.4<x&&x<-0.2){
5141// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5142// }
5143// else if(-0.2<x&&x<-0.1){
5144// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5145// }
5146// else if(-0.2<x&&x<-0.1){
5147// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5148// }
5149// else if(-0.1<x&&x<0.1){
5150// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5151// }
5152// else if(0.1<x&&x<0.2){
5153// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5154// }
5155// if(0.2<x&&x<0.4){
5156// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5157// }
5158
5159 }
5160
5161}
5162
5163
5164
76948b1d 5165void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){
5166 Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
62f6d8bf 5167 fmeson=1;
5168 fstrmeson="Dstar";
5169 fstrptAss="ptAsMore1";
5170 fstrptD="Dpt8to16";
5171 if(!fhDeltaPhiTemplate){
5172 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5173 }
5174 Double_t x;
5175 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5176 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5177 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5178 fhYieldExtraction->SetBinContent(j,0.1);
5179 }
5180
5181 // Background D MESON candidate subtraction (side-band variations, etc.)
5182 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5183 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
acd5f443 5184 fhBackSubtractionMin->SetBinContent(j,-0.12);
62f6d8bf 5185 }
5186
5187 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5188 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 5189
acd5f443 5190 fhBackSubtractionMax->SetBinContent(j,0.12);
62f6d8bf 5191 }
5192
5193 // MC CORRECTIONS -5% +10% for assoc track eff
5194 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5195 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5196 fhMCcorrectionsMin->SetBinContent(j,-0.05);
5197 }
5198
5199 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5200 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5201 fhMCcorrectionsMax->SetBinContent(j,0.10);
5202 }
5203 // MC D EFF CORRECTION
5204 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5205 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5206 fhMCDefficiencyMin->SetBinContent(j,-0.05);
5207 }
5208
5209 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5210 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5211 fhMCDefficiencyMax->SetBinContent(j,0.05);
5212 }
5213
5214
5215 // Contamination from secondary tracks
5216 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5217 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5218 fhSecContaminationMin->SetBinContent(j,-0.05);
5219 }
5220
5221 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5222 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5223 fhSecContaminationMax->SetBinContent(j,0.05);
5224 }
5225
5226 // MC CLOSURETEST (D meson efficiency)
5227 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5228 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5229 x=fhMCclosureTestMin->GetBinLowEdge(j);
5230 fhMCclosureTestMin->SetBinContent(j,-0.08);
5231
5232 if(-0.4<x&&x<-0.2){
5233 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5234 }
5235 else if(-0.2<x&&x<-0.1){
5236 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5237 }
5238 else if(-0.1<x&&x<0.1){
5239 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5240 }
5241 else if(0.1<x&&x<0.2){
5242 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5243 }
5244 if(0.2<x&&x<0.4){
5245 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5246 }
5247 }
5248
5249 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5250 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5251 x=fhMCclosureTestMax->GetBinLowEdge(j);
5252 fhMCclosureTestMax->SetBinContent(j,0.);
5253
5254 // if(-0.4<x&&x<-0.2){
5255 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5256 // }
5257 // else if(-0.2<x&&x<-0.1){
5258 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5259 // }
5260 // else if(-0.2<x&&x<-0.1){
5261 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5262 // }
5263 // else if(-0.1<x&&x<0.1){
5264 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5265 // }
5266 // else if(0.1<x&&x<0.2){
5267 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5268 // }
5269 // if(0.2<x&&x<0.4){
5270 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5271 // }
5272
5273 }
5274
5275 // Feed-down
5276
5277 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5278 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5279 x=fhBeautyFDmin->GetBinLowEdge(j);
5280 fhBeautyFDmin->SetBinContent(j,-0.05);
5281
5282 // if(-0.4<x&&x<-0.2){
5283// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5284// }
5285// else if(-0.2<x&&x<-0.1){
5286// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5287// }
5288// else if(-0.2<x&&x<-0.1){
5289// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5290// }
5291// else if(-0.1<x&&x<0.1){
5292// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5293// }
5294// else if(0.1<x&&x<0.2){
5295// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5296// }
5297// if(0.2<x&&x<0.4){
5298// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5299// }
5300 }
5301
5302 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5303 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5304 x=fhBeautyFDmax->GetBinLowEdge(j);
5305 fhBeautyFDmax->SetBinContent(j,0.03);
5306
5307// if(-0.4<x&&x<-0.2){
5308// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5309// }
5310// else if(-0.2<x&&x<-0.1){
5311// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5312// }
5313// else if(-0.2<x&&x<-0.1){
5314// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5315// }
5316// else if(-0.1<x&&x<0.1){
5317// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5318// }
5319// else if(0.1<x&&x<0.2){
5320// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5321// }
5322// if(0.2<x&&x<0.4){
5323// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5324// }
5325
5326 }
5327
5328
5329}
5330
5331
5332
76948b1d 5333void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){
5334 Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
5335 fmeson=2;
62f6d8bf 5336 fstrmeson="Dplus";
5337 fstrptAss="ptAsMore1";
5338 fstrptD="Dpt3to5";
5339 if(!fhDeltaPhiTemplate){
5340 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5341 }
5342 Double_t x;
5343 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5344 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5345 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5346 fhYieldExtraction->SetBinContent(j,0.1);
5347 }
5348
5349 // Background D MESON candidate subtraction (side-band variations, etc.)
5350 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5351 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5352 fhBackSubtractionMin->SetBinContent(j,-0.05);
5353 }
5354
5355 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5356 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5357 fhBackSubtractionMax->SetBinContent(j,0.05);
5358 }
5359
5360
5361 // MC CORRECTIONS ( associatate track efficiency):
5362 // -5% +10% for assoc track eff
5363 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5364 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5365 fhMCcorrectionsMin->SetBinContent(j,-0.05);
5366 }
5367
5368 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5369 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5370 fhMCcorrectionsMax->SetBinContent(j,0.10);
5371 }
5372
5373 // MC D EFF CORRECTION
5374 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5375 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5376 fhMCDefficiencyMin->SetBinContent(j,-0.05);
5377 }
5378
5379 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5380 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5381 fhMCDefficiencyMax->SetBinContent(j,0.05);
5382 }
5383
5384
5385 // Contamination from secondary tracks
5386 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5387 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5388 fhSecContaminationMin->SetBinContent(j,-0.05);
5389 }
5390
5391 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5392 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5393 fhSecContaminationMax->SetBinContent(j,0.05);
5394 }
5395
5396
5397 // MC CLOSURETEST (D meson efficiency)
5398 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5399 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5400 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 5401 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 5402
5403 if(-0.4<x&&x<-0.2){
5404 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5405 }
5406 else if(-0.2<x&&x<-0.1){
5407 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5408 }
5409 else if(-0.1<x&&x<0.1){
5410 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5411 }
5412 else if(0.1<x&&x<0.2){
5413 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5414 }
5415 if(0.2<x&&x<0.4){
5416 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5417 }
5418 }
5419
5420 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5421 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5422 // x=fhMCclosureTestMax->GetBinLowEdge(j);
5423 fhMCclosureTestMax->SetBinContent(j,0.);
5424
5425 // if(-0.4<x&&x<-0.2){
5426 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5427 // }
5428 // else if(-0.2<x&&x<-0.1){
5429 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5430 // }
5431 // else if(-0.2<x&&x<-0.1){
5432 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5433 // }
5434 // else if(-0.1<x&&x<0.1){
5435 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5436 // }
5437 // else if(0.1<x&&x<0.2){
5438 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5439 // }
5440 // if(0.2<x&&x<0.4){
5441 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5442 // }
5443
5444 }
5445
5446 // Feed-down
5447
5448 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5449 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5450 x=fhBeautyFDmin->GetBinLowEdge(j);
5451 fhBeautyFDmin->SetBinContent(j,-0.05);
5452
5453 // if(-0.4<x&&x<-0.2){
5454// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5455// }
5456// else if(-0.2<x&&x<-0.1){
5457// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5458// }
5459// else if(-0.2<x&&x<-0.1){
5460// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5461// }
5462// else if(-0.1<x&&x<0.1){
5463// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5464// }
5465// else if(0.1<x&&x<0.2){
5466// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5467// }
5468// if(0.2<x&&x<0.4){
5469// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5470// }
5471 }
5472
5473 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5474 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5475 x=fhBeautyFDmax->GetBinLowEdge(j);
5476 fhBeautyFDmax->SetBinContent(j,0.03);
5477
5478// if(-0.4<x&&x<-0.2){
5479// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5480// }
5481// else if(-0.2<x&&x<-0.1){
5482// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5483// }
5484// else if(-0.2<x&&x<-0.1){
5485// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5486// }
5487// else if(-0.1<x&&x<0.1){
5488// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5489// }
5490// else if(0.1<x&&x<0.2){
5491// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5492// }
5493// if(0.2<x&&x<0.4){
5494// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5495// }
5496
5497 }
5498
5499}
5500
76948b1d 5501void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){
5502 Printf("Setting uncertainties for Dplus pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
5503 fmeson=2;
62f6d8bf 5504 fstrmeson="Dplus";
5505 fstrptAss="ptAsMore1";
5506 fstrptD="Dpt5to8";
5507 if(!fhDeltaPhiTemplate){
5508 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5509 }
5510 Double_t x;
5511 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5512 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5513 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5514 fhYieldExtraction->SetBinContent(j,0.1);
5515 }
5516
5517 // Background D MESON candidate subtraction (side-band variations, etc.)
5518 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5519 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 5520 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 5521 }
5522
5523 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5524 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5525 fhBackSubtractionMax->SetBinContent(j,0.05);
5526 }
5527
5528 // MC CORRECTIONS: -5% +10% for assoc track eff
5529 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5530 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5531 fhMCcorrectionsMin->SetBinContent(j,-0.05);
5532 }
5533
5534 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5535 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5536 fhMCcorrectionsMax->SetBinContent(j,0.10);
5537 }
5538
5539
5540 // MC D EFF CORRECTION
5541 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5542 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5543 fhMCDefficiencyMin->SetBinContent(j,-0.05);
5544 }
5545
5546 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5547 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5548 fhMCDefficiencyMax->SetBinContent(j,0.05);
5549 }
5550
5551
5552 // Contamination from secondary tracks
5553 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5554 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5555 fhSecContaminationMin->SetBinContent(j,-0.05);
5556 }
5557
5558 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5559 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5560 fhSecContaminationMax->SetBinContent(j,0.05);
5561 }
5562
5563 // MC CLOSURETEST (D meson efficiency)
5564 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5565 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5566 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 5567 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 5568
5569 if(-0.4<x&&x<-0.2){
5570 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5571 }
5572 else if(-0.2<x&&x<-0.1){
5573 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5574 }
5575 else if(-0.1<x&&x<0.1){
5576 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5577 }
5578 else if(0.1<x&&x<0.2){
5579 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5580 }
5581 if(0.2<x&&x<0.4){
5582 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5583 }
5584 }
5585
5586 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5587 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5588 x=fhMCclosureTestMax->GetBinLowEdge(j);
5589 fhMCclosureTestMax->SetBinContent(j,0.);
5590
5591 // if(-0.4<x&&x<-0.2){
5592 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5593 // }
5594 // else if(-0.2<x&&x<-0.1){
5595 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5596 // }
5597 // else if(-0.2<x&&x<-0.1){
5598 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5599 // }
5600 // else if(-0.1<x&&x<0.1){
5601 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5602 // }
5603 // else if(0.1<x&&x<0.2){
5604 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5605 // }
5606 // if(0.2<x&&x<0.4){
5607 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5608 // }
5609
5610 }
5611
5612 // Feed-down
5613
5614 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5615 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5616 x=fhBeautyFDmin->GetBinLowEdge(j);
5617 fhBeautyFDmin->SetBinContent(j,-0.05);
5618
5619 // if(-0.4<x&&x<-0.2){
5620// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5621// }
5622// else if(-0.2<x&&x<-0.1){
5623// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5624// }
5625// else if(-0.2<x&&x<-0.1){
5626// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5627// }
5628// else if(-0.1<x&&x<0.1){
5629// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5630// }
5631// else if(0.1<x&&x<0.2){
5632// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5633// }
5634// if(0.2<x&&x<0.4){
5635// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5636// }
5637 }
5638
5639 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5640 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5641 x=fhBeautyFDmax->GetBinLowEdge(j);
5642 fhBeautyFDmax->SetBinContent(j,0.03);
5643
5644// if(-0.4<x&&x<-0.2){
5645// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5646// }
5647// else if(-0.2<x&&x<-0.1){
5648// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5649// }
5650// else if(-0.2<x&&x<-0.1){
5651// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5652// }
5653// else if(-0.1<x&&x<0.1){
5654// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5655// }
5656// else if(0.1<x&&x<0.2){
5657// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5658// }
5659// if(0.2<x&&x<0.4){
5660// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5661// }
5662
5663 }
5664
5665}
5666
5667
76948b1d 5668void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
5669 Printf("Setting uncertainties for Dplus pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5670 fmeson=2;
62f6d8bf 5671 fstrmeson="Dplus";
5672 fstrptAss="ptAsMore1";
5673 fstrptD="Dpt8to16";
5674 if(!fhDeltaPhiTemplate){
5675 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5676 }
5677
5678 Double_t x;
5679 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5680 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5681 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5682 fhYieldExtraction->SetBinContent(j,0.1);
5683 }
5684
5685 // Background D MESON candidate subtraction (side-band variations, etc.)
5686 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5687 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 5688 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 5689 }
5690
5691 // Background D MESON candidate subtraction (side-band variations, etc.)
5692 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5693 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5694 fhBackSubtractionMax->SetBinContent(j,0.05);
5695 }
5696
5697 // MC CORRECTIONS, -5% 10% for assoc track eff
5698 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5699 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5700 fhMCcorrectionsMin->SetBinContent(j,-0.05);
5701 }
5702
5703 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5704 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5705 fhMCcorrectionsMax->SetBinContent(j,0.10);
5706 }
5707
5708
5709 // MC D EFF CORRECTION
5710 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5711 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5712 fhMCDefficiencyMin->SetBinContent(j,-0.05);
5713 }
5714
5715 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5716 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5717 fhMCDefficiencyMax->SetBinContent(j,0.05);
5718 }
5719
5720
5721 // Contamination from secondary tracks
5722 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5723 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5724 fhSecContaminationMin->SetBinContent(j,-0.05);
5725 }
5726
5727 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5728 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5729 fhSecContaminationMax->SetBinContent(j,0.05);
5730 }
5731
5732 // MC CLOSURETEST (D meson efficiency)
5733 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5734 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5735 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 5736 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 5737
5738 if(-0.4<x&&x<-0.2){
5739 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5740 }
5741 else if(-0.2<x&&x<-0.1){
5742 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5743 }
5744 else if(-0.1<x&&x<0.1){
5745 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5746 }
5747 else if(0.1<x&&x<0.2){
5748 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5749 }
5750 if(0.2<x&&x<0.4){
5751 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5752 }
5753 }
5754
5755 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5756 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5757 x=fhMCclosureTestMax->GetBinLowEdge(j);
5758 fhMCclosureTestMax->SetBinContent(j,0.);
5759
5760 // if(-0.4<x&&x<-0.2){
5761 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5762 // }
5763 // else if(-0.2<x&&x<-0.1){
5764 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5765 // }
5766 // else if(-0.2<x&&x<-0.1){
5767 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5768 // }
5769 // else if(-0.1<x&&x<0.1){
5770 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5771 // }
5772 // else if(0.1<x&&x<0.2){
5773 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5774 // }
5775 // if(0.2<x&&x<0.4){
5776 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5777 // }
5778
5779 }
5780
5781 // Feed-down
5782
5783 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5784 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5785 x=fhBeautyFDmin->GetBinLowEdge(j);
5786 fhBeautyFDmin->SetBinContent(j,-0.05);
5787
5788 // if(-0.4<x&&x<-0.2){
5789// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5790// }
5791// else if(-0.2<x&&x<-0.1){
5792// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5793// }
5794// else if(-0.2<x&&x<-0.1){
5795// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5796// }
5797// else if(-0.1<x&&x<0.1){
5798// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5799// }
5800// else if(0.1<x&&x<0.2){
5801// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5802// }
5803// if(0.2<x&&x<0.4){
5804// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5805// }
5806 }
5807
5808 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5809 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5810 x=fhBeautyFDmax->GetBinLowEdge(j);
5811 fhBeautyFDmax->SetBinContent(j,0.03);
5812
5813// if(-0.4<x&&x<-0.2){
5814// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5815// }
5816// else if(-0.2<x&&x<-0.1){
5817// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5818// }
5819// else if(-0.2<x&&x<-0.1){
5820// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5821// }
5822// else if(-0.1<x&&x<0.1){
5823// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5824// }
5825// else if(0.1<x&&x<0.2){
5826// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5827// }
5828// if(0.2<x&&x<0.4){
5829// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5830// }
5831
5832 }
5833
5834}
5835
5836
5837
5838
5839
5840
5841////////////////////////////////////////////////////////////////////////////////////////////////////////
5842/////
5843///// METHODS WITH UNCERTAINTIES: pPb 2013
5844/////
5845////////////////////////////////////////////////////////////////////////////////////////////////////////
5846
5847
5848// pt assoc > 0.3 GeV/c
5849
76948b1d 5850void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
5851 Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
62f6d8bf 5852 fmeson=0;
5853 fstrmeson="Dzero";
5854 fstrptAss="ptAsMore03";
5855 fstrptD="Dpt3to5";
5856 if(!fhDeltaPhiTemplate){
5857 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5858 }
5859 Double_t x;
5860 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5861 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5862 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5863 fhYieldExtraction->SetBinContent(j,0.1);
5864 }
5865
5866 // Background D MESON candidate subtraction (side-band variations, etc.)
5867 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5868 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5869 fhBackSubtractionMin->SetBinContent(j,-0.05);
5870 }
5871
5872 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5873 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5874 fhBackSubtractionMax->SetBinContent(j,0.05);
5875 }
5876
5877
5878 // MC CORRECTIONS ( associatate track efficiency):
5879 // -5% +10% for assoc track eff
5880 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5881 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 5882 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 5883 }
5884
5885 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5886 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 5887 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 5888 }
5889
5890 // MC D EFF CORRECTION
5891 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5892 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5893 fhMCDefficiencyMin->SetBinContent(j,-0.05);
5894 }
5895
5896 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5897 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5898 fhMCDefficiencyMax->SetBinContent(j,0.05);
5899 }
5900
5901
5902 // Contamination from secondary tracks
5903 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5904 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 5905 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 5906 }
5907
5908 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5909 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 5910 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 5911 }
5912
5913
5914 // MC CLOSURETEST (D meson efficiency)
5915 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5916 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5917 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 5918 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 5919
5920 if(-0.4<x&&x<-0.2){
5921 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5922 }
5923 else if(-0.2<x&&x<-0.1){
5924 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5925 }
5926 else if(-0.1<x&&x<0.1){
5927 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5928 }
5929 else if(0.1<x&&x<0.2){
5930 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5931 }
5932 if(0.2<x&&x<0.4){
5933 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5934 }
5935 }
5936
5937 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5938 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5939 // x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 5940 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 5941
5942 // if(-0.4<x&&x<-0.2){
5943 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5944 // }
5945 // else if(-0.2<x&&x<-0.1){
5946 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5947 // }
5948 // else if(-0.2<x&&x<-0.1){
5949 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5950 // }
5951 // else if(-0.1<x&&x<0.1){
5952 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5953 // }
5954 // else if(0.1<x&&x<0.2){
5955 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5956 // }
5957 // if(0.2<x&&x<0.4){
5958 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5959 // }
5960
5961 }
5962
5963 // Feed-down
5964
5965 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5966 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5967 x=fhBeautyFDmin->GetBinLowEdge(j);
5968 fhBeautyFDmin->SetBinContent(j,-0.05);
5969
5970 // if(-0.4<x&&x<-0.2){
5971// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5972// }
5973// else if(-0.2<x&&x<-0.1){
5974// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5975// }
5976// else if(-0.2<x&&x<-0.1){
5977// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5978// }
5979// else if(-0.1<x&&x<0.1){
5980// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5981// }
5982// else if(0.1<x&&x<0.2){
5983// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5984// }
5985// if(0.2<x&&x<0.4){
5986// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5987// }
5988 }
5989
5990 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5991 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5992 x=fhBeautyFDmax->GetBinLowEdge(j);
5993 fhBeautyFDmax->SetBinContent(j,0.03);
5994
5995// if(-0.4<x&&x<-0.2){
5996// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5997// }
5998// else if(-0.2<x&&x<-0.1){
5999// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6000// }
6001// else if(-0.2<x&&x<-0.1){
6002// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6003// }
6004// else if(-0.1<x&&x<0.1){
6005// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6006// }
6007// else if(0.1<x&&x<0.2){
6008// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6009// }
6010// if(0.2<x&&x<0.4){
6011// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6012// }
6013
6014 }
6015
6016}
6017
76948b1d 6018void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
6019 Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
62f6d8bf 6020 fmeson=0;
6021 fstrmeson="Dzero";
6022 fstrptAss="ptAsMore03";
6023 fstrptD="Dpt5to8";
6024 if(!fhDeltaPhiTemplate){
6025 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6026 }
6027 Double_t x;
6028 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6029 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6030 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6031 fhYieldExtraction->SetBinContent(j,0.1);
6032 }
6033
6034 // Background D MESON candidate subtraction (side-band variations, etc.)
6035 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6036 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 6037 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 6038 }
6039
6040 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6041 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6042 fhBackSubtractionMax->SetBinContent(j,0.05);
6043 }
6044
6045 // MC CORRECTIONS: -5% +10% for assoc track eff
6046 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6047 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 6048 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 6049 }
6050
6051 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6052 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 6053 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 6054 }
6055
6056
6057 // MC D EFF CORRECTION
6058 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6059 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6060 fhMCDefficiencyMin->SetBinContent(j,-0.05);
6061 }
6062
6063 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6064 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6065 fhMCDefficiencyMax->SetBinContent(j,0.05);
6066 }
6067
6068
6069 // Contamination from secondary tracks
6070 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6071 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 6072 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 6073 }
6074
6075 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6076 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 6077 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 6078 }
6079
6080 // MC CLOSURETEST (D meson efficiency)
6081 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6082 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6083 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 6084 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 6085
6086 if(-0.4<x&&x<-0.2){
6087 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6088 }
6089 else if(-0.2<x&&x<-0.1){
6090 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6091 }
6092 else if(-0.1<x&&x<0.1){
6093 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6094 }
6095 else if(0.1<x&&x<0.2){
6096 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6097 }
6098 if(0.2<x&&x<0.4){
6099 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6100 }
6101 }
6102
6103 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6104 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6105 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 6106 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 6107
6108 // if(-0.4<x&&x<-0.2){
6109 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6110 // }
6111 // else if(-0.2<x&&x<-0.1){
6112 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6113 // }
6114 // else if(-0.2<x&&x<-0.1){
6115 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6116 // }
6117 // else if(-0.1<x&&x<0.1){
6118 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6119 // }
6120 // else if(0.1<x&&x<0.2){
6121 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6122 // }
6123 // if(0.2<x&&x<0.4){
6124 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6125 // }
6126
6127 }
6128
6129 // Feed-down
6130
6131 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6132 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6133 x=fhBeautyFDmin->GetBinLowEdge(j);
6134 fhBeautyFDmin->SetBinContent(j,-0.05);
6135
6136 // if(-0.4<x&&x<-0.2){
6137// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6138// }
6139// else if(-0.2<x&&x<-0.1){
6140// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6141// }
6142// else if(-0.2<x&&x<-0.1){
6143// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6144// }
6145// else if(-0.1<x&&x<0.1){
6146// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6147// }
6148// else if(0.1<x&&x<0.2){
6149// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6150// }
6151// if(0.2<x&&x<0.4){
6152// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6153// }
6154 }
6155
6156 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6157 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6158 x=fhBeautyFDmax->GetBinLowEdge(j);
6159 fhBeautyFDmax->SetBinContent(j,0.03);
6160
6161// if(-0.4<x&&x<-0.2){
6162// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6163// }
6164// else if(-0.2<x&&x<-0.1){
6165// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6166// }
6167// else if(-0.2<x&&x<-0.1){
6168// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6169// }
6170// else if(-0.1<x&&x<0.1){
6171// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6172// }
6173// else if(0.1<x&&x<0.2){
6174// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6175// }
6176// if(0.2<x&&x<0.4){
6177// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6178// }
6179
6180 }
6181
6182}
6183
6184
76948b1d 6185void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03(){
6186 Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
62f6d8bf 6187 fmeson=0;
6188 fstrmeson="Dzero";
6189 fstrptAss="ptAsMore03";
6190 fstrptD="Dpt8to16";
6191 if(!fhDeltaPhiTemplate){
6192 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6193 }
6194
6195 Double_t x;
6196 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6197 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6198 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6199 fhYieldExtraction->SetBinContent(j,0.1);
6200 }
6201
6202 // Background D MESON candidate subtraction (side-band variations, etc.)
6203 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6204 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 6205 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 6206 }
6207
6208 // Background D MESON candidate subtraction (side-band variations, etc.)
6209 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6210 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6211 fhBackSubtractionMax->SetBinContent(j,0.05);
6212 }
6213
6214 // MC CORRECTIONS, -5% 10% for assoc track eff
6215 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6216 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 6217 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 6218 }
6219
6220 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6221 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 6222 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 6223 }
6224
6225
6226 // MC D EFF CORRECTION
6227 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6228 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6229 fhMCDefficiencyMin->SetBinContent(j,-0.05);
6230 }
6231
6232 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6233 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6234 fhMCDefficiencyMax->SetBinContent(j,0.05);
6235 }
6236
6237
6238 // Contamination from secondary tracks
6239 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6240 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 6241 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 6242 }
6243
6244 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6245 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 6246 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 6247 }
6248
6249 // MC CLOSURETEST (D meson efficiency)
6250 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6251 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6252 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 6253 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 6254
6255 if(-0.4<x&&x<-0.2){
6256 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6257 }
6258 else if(-0.2<x&&x<-0.1){
6259 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6260 }
6261 else if(-0.1<x&&x<0.1){
6262 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6263 }
6264 else if(0.1<x&&x<0.2){
6265 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6266 }
6267 if(0.2<x&&x<0.4){
6268 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6269 }
6270 }
6271
6272 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6273 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6274 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 6275 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 6276
6277 // if(-0.4<x&&x<-0.2){
6278 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6279 // }
6280 // else if(-0.2<x&&x<-0.1){
6281 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6282 // }
6283 // else if(-0.2<x&&x<-0.1){
6284 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6285 // }
6286 // else if(-0.1<x&&x<0.1){
6287 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6288 // }
6289 // else if(0.1<x&&x<0.2){
6290 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6291 // }
6292 // if(0.2<x&&x<0.4){
6293 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6294 // }
6295
6296 }
6297
6298 // Feed-down
6299
6300 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6301 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6302 x=fhBeautyFDmin->GetBinLowEdge(j);
6303 fhBeautyFDmin->SetBinContent(j,-0.05);
6304
6305 // if(-0.4<x&&x<-0.2){
6306// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6307// }
6308// else if(-0.2<x&&x<-0.1){
6309// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6310// }
6311// else if(-0.2<x&&x<-0.1){
6312// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6313// }
6314// else if(-0.1<x&&x<0.1){
6315// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6316// }
6317// else if(0.1<x&&x<0.2){
6318// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6319// }
6320// if(0.2<x&&x<0.4){
6321// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6322// }
6323 }
6324
6325 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6326 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6327 x=fhBeautyFDmax->GetBinLowEdge(j);
6328 fhBeautyFDmax->SetBinContent(j,0.03);
6329
6330// if(-0.4<x&&x<-0.2){
6331// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6332// }
6333// else if(-0.2<x&&x<-0.1){
6334// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6335// }
6336// else if(-0.2<x&&x<-0.1){
6337// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6338// }
6339// else if(-0.1<x&&x<0.1){
6340// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6341// }
6342// else if(0.1<x&&x<0.2){
6343// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6344// }
6345// if(0.2<x&&x<0.4){
6346// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6347// }
6348
6349 }
6350
6351}
6352
6353
6354
6355
6356//--------------------------------------------------
76948b1d 6357void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
6358 Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
62f6d8bf 6359 fmeson=1;
6360 fstrmeson="Dstar";
6361 fstrptAss="ptAsMore03";
6362 fstrptD="Dpt3to5";
6363 if(!fhDeltaPhiTemplate){
6364 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6365 }
6366 Double_t x;
6367 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6368 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6369 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6370 fhYieldExtraction->SetBinContent(j,0.1);
6371 }
6372
6373 // Background D MESON candidate subtraction (side-band variations, etc.)
6374 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6375 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 6376 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 6377 }
6378
6379 // Background D MESON candidate subtraction (side-band variations, etc.)
6380 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6381 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6382 fhBackSubtractionMax->SetBinContent(j,0.05);
6383 }
6384
6385 // MC CORRECTIONS, -5% 10% for assoc track eff
6386 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6387 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 6388 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 6389 }
6390
6391 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6392 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 6393 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 6394 }
6395
6396
6397 // MC D EFF CORRECTION
6398 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6399 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6400 fhMCDefficiencyMin->SetBinContent(j,-0.05);
6401 }
6402
6403 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6404 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6405 fhMCDefficiencyMax->SetBinContent(j,0.05);
6406 }
6407
6408
6409 // Contamination from secondary tracks
6410 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6411 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 6412 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 6413 }
6414
6415 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6416 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 6417 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 6418 }
6419
6420 // MC CLOSURETEST (D meson efficiency)
6421 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6422 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6423 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 6424 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 6425
6426 if(-0.4<x&&x<-0.2){
6427 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6428 }
6429 else if(-0.2<x&&x<-0.1){
6430 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6431 }
6432 else if(-0.1<x&&x<0.1){
6433 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6434 }
6435 else if(0.1<x&&x<0.2){
6436 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6437 }
6438 if(0.2<x&&x<0.4){
6439 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6440 }
6441 }
6442
6443 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6444 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6445 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 6446 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 6447
6448 // if(-0.4<x&&x<-0.2){
6449 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6450 // }
6451 // else if(-0.2<x&&x<-0.1){
6452 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6453 // }
6454 // else if(-0.2<x&&x<-0.1){
6455 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6456 // }
6457 // else if(-0.1<x&&x<0.1){
6458 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6459 // }
6460 // else if(0.1<x&&x<0.2){
6461 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6462 // }
6463 // if(0.2<x&&x<0.4){
6464 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6465 // }
6466
6467 }
6468
6469 // Feed-down
6470
6471 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6472 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6473 x=fhBeautyFDmin->GetBinLowEdge(j);
6474 fhBeautyFDmin->SetBinContent(j,-0.05);
6475
6476 // if(-0.4<x&&x<-0.2){
6477// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6478// }
6479// else if(-0.2<x&&x<-0.1){
6480// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6481// }
6482// else if(-0.2<x&&x<-0.1){
6483// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6484// }
6485// else if(-0.1<x&&x<0.1){
6486// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6487// }
6488// else if(0.1<x&&x<0.2){
6489// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6490// }
6491// if(0.2<x&&x<0.4){
6492// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6493// }
6494 }
6495
6496 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6497 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6498 x=fhBeautyFDmax->GetBinLowEdge(j);
6499 fhBeautyFDmax->SetBinContent(j,0.03);
6500
6501// if(-0.4<x&&x<-0.2){
6502// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6503// }
6504// else if(-0.2<x&&x<-0.1){
6505// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6506// }
6507// else if(-0.2<x&&x<-0.1){
6508// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6509// }
6510// else if(-0.1<x&&x<0.1){
6511// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6512// }
6513// else if(0.1<x&&x<0.2){
6514// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6515// }
6516// if(0.2<x&&x<0.4){
6517// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6518// }
6519
6520 }
6521
6522
6523}
6524
76948b1d 6525void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
6526 Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
62f6d8bf 6527 fmeson=1;
6528 fstrmeson="Dstar";
6529 fstrptAss="ptAsMore03";
6530 fstrptD="Dpt5to8";
6531 if(!fhDeltaPhiTemplate){
6532 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6533 }
6534 Double_t x;
6535 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6536 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6537 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6538 fhYieldExtraction->SetBinContent(j,0.1);
6539 }
6540
6541 // Background D MESON candidate subtraction (side-band variations, etc.)
6542 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6543 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 6544 fhBackSubtractionMin->SetBinContent(j,-0.04);
62f6d8bf 6545 }
6546
6547 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6548 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 6549 fhBackSubtractionMax->SetBinContent(j,0.04);
62f6d8bf 6550 }
6551
6552 // MC CORRECTIONS/ -5% 10% for assoc track eff
6553 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6554 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 6555 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 6556 }
6557
6558 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6559 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 6560 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 6561 }
6562
6563 // MC D EFF CORRECTION
6564 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6565 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 6566 fhMCDefficiencyMin->SetBinContent(j,-0.04);
62f6d8bf 6567 }
6568
6569 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6570 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 6571 fhMCDefficiencyMax->SetBinContent(j,0.04);
62f6d8bf 6572 }
6573
6574
6575 // Contamination from secondary tracks
6576 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6577 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 6578 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 6579 }
6580
6581 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6582 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 6583 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 6584 }
6585
6586 // MC CLOSURETEST (D meson efficiency)
6587 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6588 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6589 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 6590 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 6591
6592 if(-0.4<x&&x<-0.2){
6593 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6594 }
6595 else if(-0.2<x&&x<-0.1){
6596 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6597 }
6598 else if(-0.1<x&&x<0.1){
6599 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6600 }
6601 else if(0.1<x&&x<0.2){
6602 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6603 }
6604 if(0.2<x&&x<0.4){
6605 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6606 }
6607 }
6608
6609 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6610 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6611 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 6612 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 6613
6614 // if(-0.4<x&&x<-0.2){
6615 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6616 // }
6617 // else if(-0.2<x&&x<-0.1){
6618 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6619 // }
6620 // else if(-0.2<x&&x<-0.1){
6621 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6622 // }
6623 // else if(-0.1<x&&x<0.1){
6624 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6625 // }
6626 // else if(0.1<x&&x<0.2){
6627 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6628 // }
6629 // if(0.2<x&&x<0.4){
6630 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6631 // }
6632
6633 }
6634
6635 // Feed-down
6636
6637 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6638 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6639 x=fhBeautyFDmin->GetBinLowEdge(j);
6640 fhBeautyFDmin->SetBinContent(j,-0.05);
6641
6642 // if(-0.4<x&&x<-0.2){
6643// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6644// }
6645// else if(-0.2<x&&x<-0.1){
6646// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6647// }
6648// else if(-0.2<x&&x<-0.1){
6649// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6650// }
6651// else if(-0.1<x&&x<0.1){
6652// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6653// }
6654// else if(0.1<x&&x<0.2){
6655// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6656// }
6657// if(0.2<x&&x<0.4){
6658// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6659// }
6660 }
6661
6662 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6663 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6664 x=fhBeautyFDmax->GetBinLowEdge(j);
6665 fhBeautyFDmax->SetBinContent(j,0.03);
6666
6667// if(-0.4<x&&x<-0.2){
6668// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6669// }
6670// else if(-0.2<x&&x<-0.1){
6671// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6672// }
6673// else if(-0.2<x&&x<-0.1){
6674// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6675// }
6676// else if(-0.1<x&&x<0.1){
6677// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6678// }
6679// else if(0.1<x&&x<0.2){
6680// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6681// }
6682// if(0.2<x&&x<0.4){
6683// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6684// }
6685
6686 }
6687
6688}
6689
6690
6691
76948b1d 6692void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03(){
6693 Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
62f6d8bf 6694 fmeson=1;
6695 fstrmeson="Dstar";
6696 fstrptAss="ptAsMore03";
6697 fstrptD="Dpt8to16";
6698 if(!fhDeltaPhiTemplate){
6699 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6700 }
6701 Double_t x;
6702 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6703 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6704 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6705 fhYieldExtraction->SetBinContent(j,0.1);
6706 }
6707
6708 // Background D MESON candidate subtraction (side-band variations, etc.)
6709 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6710 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 6711 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 6712 }
6713
6714 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6715 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6716 fhBackSubtractionMax->SetBinContent(j,0.05);
6717 }
6718
6719 // MC CORRECTIONS -5% +10% for assoc track eff
6720 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6721 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 6722 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 6723 }
6724
6725 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6726 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 6727 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 6728 }
6729 // MC D EFF CORRECTION
6730 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6731 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 6732 fhMCDefficiencyMin->SetBinContent(j,-0.08);
62f6d8bf 6733 }
6734
6735 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6736 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 6737 fhMCDefficiencyMax->SetBinContent(j,0.08);
62f6d8bf 6738 }
6739
6740
6741 // Contamination from secondary tracks
6742 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6743 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 6744 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 6745 }
6746
6747 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6748 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 6749 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 6750 }
6751
6752 // MC CLOSURETEST (D meson efficiency)
6753 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6754 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6755 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 6756 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 6757
6758 if(-0.4<x&&x<-0.2){
6759 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6760 }
6761 else if(-0.2<x&&x<-0.1){
6762 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6763 }
6764 else if(-0.1<x&&x<0.1){
6765 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6766 }
6767 else if(0.1<x&&x<0.2){
6768 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6769 }
6770 if(0.2<x&&x<0.4){
6771 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6772 }
6773 }
6774
6775 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6776 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6777 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 6778 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 6779
6780 // if(-0.4<x&&x<-0.2){
6781 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6782 // }
6783 // else if(-0.2<x&&x<-0.1){
6784 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6785 // }
6786 // else if(-0.2<x&&x<-0.1){
6787 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6788 // }
6789 // else if(-0.1<x&&x<0.1){
6790 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6791 // }
6792 // else if(0.1<x&&x<0.2){
6793 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6794 // }
6795 // if(0.2<x&&x<0.4){
6796 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6797 // }
6798
6799 }
6800
6801 // Feed-down
6802
6803 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6804 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6805 x=fhBeautyFDmin->GetBinLowEdge(j);
6806 fhBeautyFDmin->SetBinContent(j,-0.05);
6807
6808 // if(-0.4<x&&x<-0.2){
6809// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6810// }
6811// else if(-0.2<x&&x<-0.1){
6812// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6813// }
6814// else if(-0.2<x&&x<-0.1){
6815// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6816// }
6817// else if(-0.1<x&&x<0.1){
6818// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6819// }
6820// else if(0.1<x&&x<0.2){
6821// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6822// }
6823// if(0.2<x&&x<0.4){
6824// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6825// }
6826 }
6827
6828 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6829 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6830 x=fhBeautyFDmax->GetBinLowEdge(j);
6831 fhBeautyFDmax->SetBinContent(j,0.03);
6832
6833// if(-0.4<x&&x<-0.2){
6834// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6835// }
6836// else if(-0.2<x&&x<-0.1){
6837// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6838// }
6839// else if(-0.2<x&&x<-0.1){
6840// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6841// }
6842// else if(-0.1<x&&x<0.1){
6843// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6844// }
6845// else if(0.1<x&&x<0.2){
6846// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6847// }
6848// if(0.2<x&&x<0.4){
6849// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6850// }
6851
6852 }
6853
6854
6855}
6856
6857
6858
6859
76948b1d 6860void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
6861 Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6862 fmeson=2;
62f6d8bf 6863 fstrmeson="Dplus";
6864 fstrptAss="ptAsMore03";
6865 fstrptD="Dpt3to5";
6866 if(!fhDeltaPhiTemplate){
6867 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6868 }
6869 Double_t x;
6870 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6871 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6872 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6873 fhYieldExtraction->SetBinContent(j,0.1);
6874 }
6875
6876 // Background D MESON candidate subtraction (side-band variations, etc.)
6877 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6878 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 6879 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 6880 }
6881
6882 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6883 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 6884 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 6885 }
6886
6887
6888 // MC CORRECTIONS ( associatate track efficiency):
6889 // -5% +10% for assoc track eff
6890 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6891 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 6892 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 6893 }
6894
6895 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6896 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 6897 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 6898 }
6899
6900 // MC D EFF CORRECTION
6901 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6902 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 6903 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 6904 }
6905
6906 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6907 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 6908 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 6909 }
6910
6911
6912 // Contamination from secondary tracks
6913 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6914 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 6915 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 6916 }
6917
6918 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6919 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 6920 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 6921 }
6922
6923
6924 // MC CLOSURETEST (D meson efficiency)
6925 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6926 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6927 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 6928 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 6929
6930 if(-0.4<x&&x<-0.2){
6931 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6932 }
6933 else if(-0.2<x&&x<-0.1){
6934 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6935 }
6936 else if(-0.1<x&&x<0.1){
6937 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6938 }
6939 else if(0.1<x&&x<0.2){
6940 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6941 }
6942 if(0.2<x&&x<0.4){
6943 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6944 }
6945 }
6946
6947 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6948 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6949 // x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 6950 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 6951
6952 // if(-0.4<x&&x<-0.2){
6953 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6954 // }
6955 // else if(-0.2<x&&x<-0.1){
6956 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6957 // }
6958 // else if(-0.2<x&&x<-0.1){
6959 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6960 // }
6961 // else if(-0.1<x&&x<0.1){
6962 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6963 // }
6964 // else if(0.1<x&&x<0.2){
6965 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6966 // }
6967 // if(0.2<x&&x<0.4){
6968 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6969 // }
6970
6971 }
6972
6973 // Feed-down
6974
6975 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6976 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6977 x=fhBeautyFDmin->GetBinLowEdge(j);
6978 fhBeautyFDmin->SetBinContent(j,-0.05);
6979
6980 // if(-0.4<x&&x<-0.2){
6981// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6982// }
6983// else if(-0.2<x&&x<-0.1){
6984// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6985// }
6986// else if(-0.2<x&&x<-0.1){
6987// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6988// }
6989// else if(-0.1<x&&x<0.1){
6990// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6991// }
6992// else if(0.1<x&&x<0.2){
6993// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6994// }
6995// if(0.2<x&&x<0.4){
6996// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6997// }
6998 }
6999
7000 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7001 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7002 x=fhBeautyFDmax->GetBinLowEdge(j);
7003 fhBeautyFDmax->SetBinContent(j,0.03);
7004
7005// if(-0.4<x&&x<-0.2){
7006// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7007// }
7008// else if(-0.2<x&&x<-0.1){
7009// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7010// }
7011// else if(-0.2<x&&x<-0.1){
7012// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7013// }
7014// else if(-0.1<x&&x<0.1){
7015// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7016// }
7017// else if(0.1<x&&x<0.2){
7018// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7019// }
7020// if(0.2<x&&x<0.4){
7021// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7022// }
7023
7024 }
7025
7026}
7027
76948b1d 7028void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
7029 Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
7030 fmeson=2;
62f6d8bf 7031 fstrmeson="Dplus";
7032 fstrptAss="ptAsMore03";
7033 fstrptD="Dpt5to8";
7034 if(!fhDeltaPhiTemplate){
7035 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7036 }
7037 Double_t x;
7038 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7039 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7040 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7041 fhYieldExtraction->SetBinContent(j,0.1);
7042 }
7043
7044 // Background D MESON candidate subtraction (side-band variations, etc.)
7045 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7046 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 7047 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 7048 }
7049
7050 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7051 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 7052 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 7053 }
7054
7055 // MC CORRECTIONS: -5% +10% for assoc track eff
7056 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7057 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 7058 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 7059 }
7060
7061 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7062 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 7063 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 7064 }
7065
7066
7067 // MC D EFF CORRECTION
7068 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7069 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 7070 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 7071 }
7072
7073 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7074 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 7075 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 7076 }
7077
7078
7079 // Contamination from secondary tracks
7080 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7081 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 7082 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 7083 }
7084
7085 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7086 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 7087 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 7088 }
7089
7090 // MC CLOSURETEST (D meson efficiency)
7091 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7092 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7093 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 7094 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 7095
7096 if(-0.4<x&&x<-0.2){
7097 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7098 }
7099 else if(-0.2<x&&x<-0.1){
7100 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7101 }
7102 else if(-0.1<x&&x<0.1){
7103 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7104 }
7105 else if(0.1<x&&x<0.2){
7106 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7107 }
7108 if(0.2<x&&x<0.4){
7109 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7110 }
7111 }
7112
7113 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7114 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7115 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 7116 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 7117
7118 // if(-0.4<x&&x<-0.2){
7119 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7120 // }
7121 // else if(-0.2<x&&x<-0.1){
7122 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7123 // }
7124 // else if(-0.2<x&&x<-0.1){
7125 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7126 // }
7127 // else if(-0.1<x&&x<0.1){
7128 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7129 // }
7130 // else if(0.1<x&&x<0.2){
7131 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7132 // }
7133 // if(0.2<x&&x<0.4){
7134 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7135 // }
7136
7137 }
7138
7139 // Feed-down
7140
7141 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7142 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7143 x=fhBeautyFDmin->GetBinLowEdge(j);
7144 fhBeautyFDmin->SetBinContent(j,-0.05);
7145
7146 // if(-0.4<x&&x<-0.2){
7147// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7148// }
7149// else if(-0.2<x&&x<-0.1){
7150// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7151// }
7152// else if(-0.2<x&&x<-0.1){
7153// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7154// }
7155// else if(-0.1<x&&x<0.1){
7156// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7157// }
7158// else if(0.1<x&&x<0.2){
7159// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7160// }
7161// if(0.2<x&&x<0.4){
7162// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7163// }
7164 }
7165
7166 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7167 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7168 x=fhBeautyFDmax->GetBinLowEdge(j);
7169 fhBeautyFDmax->SetBinContent(j,0.03);
7170
7171// if(-0.4<x&&x<-0.2){
7172// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7173// }
7174// else if(-0.2<x&&x<-0.1){
7175// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7176// }
7177// else if(-0.2<x&&x<-0.1){
7178// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7179// }
7180// else if(-0.1<x&&x<0.1){
7181// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7182// }
7183// else if(0.1<x&&x<0.2){
7184// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7185// }
7186// if(0.2<x&&x<0.4){
7187// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7188// }
7189
7190 }
7191
7192}
7193
7194
76948b1d 7195void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03(){
7196 Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
7197 fmeson=2;
62f6d8bf 7198 fstrmeson="Dplus";
7199 fstrptAss="ptAsMore03";
7200 fstrptD="Dpt8to16";
7201 if(!fhDeltaPhiTemplate){
7202 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7203 }
7204
7205 Double_t x;
7206 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7207 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7208 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7209 fhYieldExtraction->SetBinContent(j,0.1);
7210 }
7211
7212 // Background D MESON candidate subtraction (side-band variations, etc.)
7213 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7214 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 7215 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 7216 }
7217
7218 // Background D MESON candidate subtraction (side-band variations, etc.)
7219 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7220 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 7221 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 7222 }
7223
7224 // MC CORRECTIONS, -5% 10% for assoc track eff
7225 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7226 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 7227 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 7228 }
7229
7230 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7231 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 7232 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 7233 }
7234
7235
7236 // MC D EFF CORRECTION
7237 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7238 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 7239 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 7240 }
7241
7242 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7243 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 7244 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 7245 }
7246
7247
7248 // Contamination from secondary tracks
7249 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7250 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 7251 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 7252 }
7253
7254 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7255 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 7256 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 7257 }
7258
7259 // MC CLOSURETEST (D meson efficiency)
7260 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7261 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7262 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 7263 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 7264
7265 if(-0.4<x&&x<-0.2){
7266 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7267 }
7268 else if(-0.2<x&&x<-0.1){
7269 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7270 }
7271 else if(-0.1<x&&x<0.1){
7272 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7273 }
7274 else if(0.1<x&&x<0.2){
7275 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7276 }
7277 if(0.2<x&&x<0.4){
7278 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7279 }
7280 }
7281
7282 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7283 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7284 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 7285 fhMCclosureTestMax->SetBinContent(j,0.08);
62f6d8bf 7286
7287 // if(-0.4<x&&x<-0.2){
7288 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7289 // }
7290 // else if(-0.2<x&&x<-0.1){
7291 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7292 // }
7293 // else if(-0.2<x&&x<-0.1){
7294 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7295 // }
7296 // else if(-0.1<x&&x<0.1){
7297 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7298 // }
7299 // else if(0.1<x&&x<0.2){
7300 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7301 // }
7302 // if(0.2<x&&x<0.4){
7303 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7304 // }
7305
7306 }
7307
7308 // Feed-down
7309
7310 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7311 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7312 x=fhBeautyFDmin->GetBinLowEdge(j);
7313 fhBeautyFDmin->SetBinContent(j,-0.05);
7314
7315 // if(-0.4<x&&x<-0.2){
7316// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7317// }
7318// else if(-0.2<x&&x<-0.1){
7319// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7320// }
7321// else if(-0.2<x&&x<-0.1){
7322// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7323// }
7324// else if(-0.1<x&&x<0.1){
7325// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7326// }
7327// else if(0.1<x&&x<0.2){
7328// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7329// }
7330// if(0.2<x&&x<0.4){
7331// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7332// }
7333 }
7334
7335 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7336 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7337 x=fhBeautyFDmax->GetBinLowEdge(j);
7338 fhBeautyFDmax->SetBinContent(j,0.03);
7339
7340// if(-0.4<x&&x<-0.2){
7341// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7342// }
7343// else if(-0.2<x&&x<-0.1){
7344// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7345// }
7346// else if(-0.2<x&&x<-0.1){
7347// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7348// }
7349// else if(-0.1<x&&x<0.1){
7350// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7351// }
7352// else if(0.1<x&&x<0.2){
7353// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7354// }
7355// if(0.2<x&&x<0.4){
7356// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7357// }
7358
7359 }
7360
7361}
7362
7363
7364
7365//////// HIGHER PT ASS THRESHOLDS
7366
76948b1d 7367void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
7368 Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
62f6d8bf 7369 fmeson=0;
7370 fstrmeson="Dzero";
7371 fstrptAss="ptAsMore05";
7372 fstrptD="Dpt3to5";
7373 if(!fhDeltaPhiTemplate){
7374 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7375 }
7376 Double_t x;
7377 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7378 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7379 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7380 fhYieldExtraction->SetBinContent(j,0.1);
7381 }
7382
7383 // Background D MESON candidate subtraction (side-band variations, etc.)
7384 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7385 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7386 fhBackSubtractionMin->SetBinContent(j,-0.05);
7387 }
7388
7389 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7390 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7391 fhBackSubtractionMax->SetBinContent(j,0.05);
7392 }
7393
7394
7395 // MC CORRECTIONS ( associatate track efficiency):
7396 // -5% +10% for assoc track eff
7397 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7398 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 7399 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 7400 }
7401
7402 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7403 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 7404 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 7405 }
7406
7407 // MC D EFF CORRECTION
7408 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7409 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7410 fhMCDefficiencyMin->SetBinContent(j,-0.05);
7411 }
7412
7413 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7414 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7415 fhMCDefficiencyMax->SetBinContent(j,0.05);
7416 }
7417
7418
7419 // Contamination from secondary tracks
7420 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7421 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 7422 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 7423 }
7424
7425 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7426 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 7427 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 7428 }
7429
7430
7431 // MC CLOSURETEST (D meson efficiency)
7432 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7433 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7434 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 7435 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 7436
7437 if(-0.4<x&&x<-0.2){
7438 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7439 }
7440 else if(-0.2<x&&x<-0.1){
7441 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7442 }
7443 else if(-0.1<x&&x<0.1){
7444 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7445 }
7446 else if(0.1<x&&x<0.2){
7447 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7448 }
7449 if(0.2<x&&x<0.4){
7450 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7451 }
7452 }
7453
7454 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7455 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7456 // x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 7457 fhMCclosureTestMax->SetBinContent(j,0.07);
62f6d8bf 7458
7459 // if(-0.4<x&&x<-0.2){
7460 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7461 // }
7462 // else if(-0.2<x&&x<-0.1){
7463 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7464 // }
7465 // else if(-0.2<x&&x<-0.1){
7466 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7467 // }
7468 // else if(-0.1<x&&x<0.1){
7469 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7470 // }
7471 // else if(0.1<x&&x<0.2){
7472 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7473 // }
7474 // if(0.2<x&&x<0.4){
7475 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7476 // }
7477
7478 }
7479
7480 // Feed-down
7481
7482 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7483 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7484 x=fhBeautyFDmin->GetBinLowEdge(j);
7485 fhBeautyFDmin->SetBinContent(j,-0.05);
7486
7487 // if(-0.4<x&&x<-0.2){
7488// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7489// }
7490// else if(-0.2<x&&x<-0.1){
7491// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7492// }
7493// else if(-0.2<x&&x<-0.1){
7494// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7495// }
7496// else if(-0.1<x&&x<0.1){
7497// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7498// }
7499// else if(0.1<x&&x<0.2){
7500// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7501// }
7502// if(0.2<x&&x<0.4){
7503// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7504// }
7505 }
7506
7507 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7508 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7509 x=fhBeautyFDmax->GetBinLowEdge(j);
7510 fhBeautyFDmax->SetBinContent(j,0.03);
7511
7512// if(-0.4<x&&x<-0.2){
7513// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7514// }
7515// else if(-0.2<x&&x<-0.1){
7516// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7517// }
7518// else if(-0.2<x&&x<-0.1){
7519// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7520// }
7521// else if(-0.1<x&&x<0.1){
7522// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7523// }
7524// else if(0.1<x&&x<0.2){
7525// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7526// }
7527// if(0.2<x&&x<0.4){
7528// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7529// }
7530
7531 }
7532
7533}
7534
76948b1d 7535void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
7536 Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
62f6d8bf 7537 fmeson=0;
7538 fstrmeson="Dzero";
7539 fstrptAss="ptAsMore05";
7540 fstrptD="Dpt5to8";
7541 if(!fhDeltaPhiTemplate){
7542 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7543 }
7544 Double_t x;
7545 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7546 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7547 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7548 fhYieldExtraction->SetBinContent(j,0.1);
7549 }
7550
7551 // Background D MESON candidate subtraction (side-band variations, etc.)
7552 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7553 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 7554 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 7555 }
7556
7557 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7558 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7559 fhBackSubtractionMax->SetBinContent(j,0.05);
7560 }
7561
7562 // MC CORRECTIONS: -5% +10% for assoc track eff
7563 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7564 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 7565 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 7566 }
7567
7568 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7569 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 7570 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 7571 }
7572
7573
7574 // MC D EFF CORRECTION
7575 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7576 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7577 fhMCDefficiencyMin->SetBinContent(j,-0.05);
7578 }
7579
7580 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7581 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7582 fhMCDefficiencyMax->SetBinContent(j,0.05);
7583 }
7584
7585
7586 // Contamination from secondary tracks
7587 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7588 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 7589 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 7590 }
7591
7592 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7593 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 7594 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 7595 }
7596
7597 // MC CLOSURETEST (D meson efficiency)
7598 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7599 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7600 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 7601 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 7602
7603 if(-0.4<x&&x<-0.2){
7604 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7605 }
7606 else if(-0.2<x&&x<-0.1){
7607 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7608 }
7609 else if(-0.1<x&&x<0.1){
7610 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7611 }
7612 else if(0.1<x&&x<0.2){
7613 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7614 }
7615 if(0.2<x&&x<0.4){
7616 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7617 }
7618 }
7619
7620 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7621 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7622 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 7623 fhMCclosureTestMax->SetBinContent(j,0.07);
62f6d8bf 7624
7625 // if(-0.4<x&&x<-0.2){
7626 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7627 // }
7628 // else if(-0.2<x&&x<-0.1){
7629 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7630 // }
7631 // else if(-0.2<x&&x<-0.1){
7632 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7633 // }
7634 // else if(-0.1<x&&x<0.1){
7635 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7636 // }
7637 // else if(0.1<x&&x<0.2){
7638 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7639 // }
7640 // if(0.2<x&&x<0.4){
7641 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7642 // }
7643
7644 }
7645
7646 // Feed-down
7647
7648 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7649 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7650 x=fhBeautyFDmin->GetBinLowEdge(j);
7651 fhBeautyFDmin->SetBinContent(j,-0.05);
7652
7653 // if(-0.4<x&&x<-0.2){
7654// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7655// }
7656// else if(-0.2<x&&x<-0.1){
7657// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7658// }
7659// else if(-0.2<x&&x<-0.1){
7660// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7661// }
7662// else if(-0.1<x&&x<0.1){
7663// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7664// }
7665// else if(0.1<x&&x<0.2){
7666// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7667// }
7668// if(0.2<x&&x<0.4){
7669// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7670// }
7671 }
7672
7673 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7674 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7675 x=fhBeautyFDmax->GetBinLowEdge(j);
7676 fhBeautyFDmax->SetBinContent(j,0.03);
7677
7678// if(-0.4<x&&x<-0.2){
7679// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7680// }
7681// else if(-0.2<x&&x<-0.1){
7682// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7683// }
7684// else if(-0.2<x&&x<-0.1){
7685// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7686// }
7687// else if(-0.1<x&&x<0.1){
7688// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7689// }
7690// else if(0.1<x&&x<0.2){
7691// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7692// }
7693// if(0.2<x&&x<0.4){
7694// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7695// }
7696
7697 }
7698
7699}
7700
7701
76948b1d 7702void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05(){
7703 Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
62f6d8bf 7704 fmeson=0;
7705 fstrmeson="Dzero";
7706 fstrptAss="ptAsMore05";
7707 fstrptD="Dpt8to16";
7708 if(!fhDeltaPhiTemplate){
7709 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7710 }
7711
7712 Double_t x;
7713 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7714 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7715 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7716 fhYieldExtraction->SetBinContent(j,0.1);
7717 }
7718
7719 // Background D MESON candidate subtraction (side-band variations, etc.)
7720 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7721 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 7722 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 7723 }
7724
7725 // Background D MESON candidate subtraction (side-band variations, etc.)
7726 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7727 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7728 fhBackSubtractionMax->SetBinContent(j,0.05);
7729 }
7730
7731 // MC CORRECTIONS, -5% 10% for assoc track eff
7732 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7733 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 7734 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 7735 }
7736
7737 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7738 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 7739 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 7740 }
7741
7742
7743 // MC D EFF CORRECTION
7744 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7745 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7746 fhMCDefficiencyMin->SetBinContent(j,-0.05);
7747 }
7748
7749 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7750 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7751 fhMCDefficiencyMax->SetBinContent(j,0.05);
7752 }
7753
7754
7755 // Contamination from secondary tracks
7756 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7757 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 7758 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 7759 }
7760
7761 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7762 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 7763 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 7764 }
7765
7766 // MC CLOSURETEST (D meson efficiency)
7767 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7768 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7769 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 7770 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 7771
7772 if(-0.4<x&&x<-0.2){
7773 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7774 }
7775 else if(-0.2<x&&x<-0.1){
7776 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7777 }
7778 else if(-0.1<x&&x<0.1){
7779 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7780 }
7781 else if(0.1<x&&x<0.2){
7782 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7783 }
7784 if(0.2<x&&x<0.4){
7785 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7786 }
7787 }
7788
7789 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7790 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7791 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 7792 fhMCclosureTestMax->SetBinContent(j,0.07);
62f6d8bf 7793
7794 // if(-0.4<x&&x<-0.2){
7795 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7796 // }
7797 // else if(-0.2<x&&x<-0.1){
7798 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7799 // }
7800 // else if(-0.2<x&&x<-0.1){
7801 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7802 // }
7803 // else if(-0.1<x&&x<0.1){
7804 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7805 // }
7806 // else if(0.1<x&&x<0.2){
7807 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7808 // }
7809 // if(0.2<x&&x<0.4){
7810 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7811 // }
7812
7813 }
7814
7815 // Feed-down
7816
7817 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7818 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7819 x=fhBeautyFDmin->GetBinLowEdge(j);
7820 fhBeautyFDmin->SetBinContent(j,-0.05);
7821
7822 // if(-0.4<x&&x<-0.2){
7823// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7824// }
7825// else if(-0.2<x&&x<-0.1){
7826// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7827// }
7828// else if(-0.2<x&&x<-0.1){
7829// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7830// }
7831// else if(-0.1<x&&x<0.1){
7832// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7833// }
7834// else if(0.1<x&&x<0.2){
7835// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7836// }
7837// if(0.2<x&&x<0.4){
7838// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7839// }
7840 }
7841
7842 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7843 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7844 x=fhBeautyFDmax->GetBinLowEdge(j);
7845 fhBeautyFDmax->SetBinContent(j,0.03);
7846
7847// if(-0.4<x&&x<-0.2){
7848// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7849// }
7850// else if(-0.2<x&&x<-0.1){
7851// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7852// }
7853// else if(-0.2<x&&x<-0.1){
7854// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7855// }
7856// else if(-0.1<x&&x<0.1){
7857// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7858// }
7859// else if(0.1<x&&x<0.2){
7860// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7861// }
7862// if(0.2<x&&x<0.4){
7863// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7864// }
7865
7866 }
7867
7868}
7869
7870
7871
7872
7873//--------------------------------------------------
76948b1d 7874void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
7875 Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
62f6d8bf 7876 fmeson=1;
7877 fstrmeson="Dstar";
7878 fstrptAss="ptAsMore05";
7879 fstrptD="Dpt3to5";
7880 if(!fhDeltaPhiTemplate){
7881 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7882 }
7883 Double_t x;
7884 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7885 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7886 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7887 fhYieldExtraction->SetBinContent(j,0.1);
7888 }
7889
7890 // Background D MESON candidate subtraction (side-band variations, etc.)
7891 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7892 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 7893 fhBackSubtractionMin->SetBinContent(j,-0.07);
62f6d8bf 7894 }
7895
7896 // Background D MESON candidate subtraction (side-band variations, etc.)
7897 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7898 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 7899 fhBackSubtractionMax->SetBinContent(j,0.07);
62f6d8bf 7900 }
7901
7902 // MC CORRECTIONS, -5% 10% for assoc track eff
7903 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7904 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 7905 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 7906 }
7907
7908 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7909 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 7910 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 7911 }
7912
7913
7914 // MC D EFF CORRECTION
7915 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7916 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7917 fhMCDefficiencyMin->SetBinContent(j,-0.05);
7918 }
7919
7920 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7921 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7922 fhMCDefficiencyMax->SetBinContent(j,0.05);
7923 }
7924
7925
7926 // Contamination from secondary tracks
7927 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7928 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 7929 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 7930 }
7931
7932 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7933 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 7934 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 7935 }
7936
7937 // MC CLOSURETEST (D meson efficiency)
7938 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7939 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7940 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 7941 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 7942
7943 if(-0.4<x&&x<-0.2){
7944 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7945 }
7946 else if(-0.2<x&&x<-0.1){
7947 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7948 }
7949 else if(-0.1<x&&x<0.1){
7950 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7951 }
7952 else if(0.1<x&&x<0.2){
7953 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7954 }
7955 if(0.2<x&&x<0.4){
7956 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7957 }
7958 }
7959
7960 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7961 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7962 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 7963 fhMCclosureTestMax->SetBinContent(j,0.7);
62f6d8bf 7964
7965 // if(-0.4<x&&x<-0.2){
7966 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7967 // }
7968 // else if(-0.2<x&&x<-0.1){
7969 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7970 // }
7971 // else if(-0.2<x&&x<-0.1){
7972 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7973 // }
7974 // else if(-0.1<x&&x<0.1){
7975 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7976 // }
7977 // else if(0.1<x&&x<0.2){
7978 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7979 // }
7980 // if(0.2<x&&x<0.4){
7981 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7982 // }
7983
7984 }
7985
7986 // Feed-down
7987
7988 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7989 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7990 x=fhBeautyFDmin->GetBinLowEdge(j);
7991 fhBeautyFDmin->SetBinContent(j,-0.05);
7992
7993 // if(-0.4<x&&x<-0.2){
7994// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7995// }
7996// else if(-0.2<x&&x<-0.1){
7997// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7998// }
7999// else if(-0.2<x&&x<-0.1){
8000// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8001// }
8002// else if(-0.1<x&&x<0.1){
8003// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8004// }
8005// else if(0.1<x&&x<0.2){
8006// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8007// }
8008// if(0.2<x&&x<0.4){
8009// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8010// }
8011 }
8012
8013 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8014 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8015 x=fhBeautyFDmax->GetBinLowEdge(j);
8016 fhBeautyFDmax->SetBinContent(j,0.03);
8017
8018// if(-0.4<x&&x<-0.2){
8019// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8020// }
8021// else if(-0.2<x&&x<-0.1){
8022// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8023// }
8024// else if(-0.2<x&&x<-0.1){
8025// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8026// }
8027// else if(-0.1<x&&x<0.1){
8028// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8029// }
8030// else if(0.1<x&&x<0.2){
8031// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8032// }
8033// if(0.2<x&&x<0.4){
8034// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8035// }
8036
8037 }
8038
8039
8040}
8041
76948b1d 8042void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
8043 Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
62f6d8bf 8044 fmeson=1;
8045 fstrmeson="Dstar";
8046 fstrptAss="ptAsMore05";
8047 fstrptD="Dpt5to8";
8048 if(!fhDeltaPhiTemplate){
8049 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8050 }
8051 Double_t x;
8052 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8053 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8054 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8055 fhYieldExtraction->SetBinContent(j,0.1);
8056 }
8057
8058 // Background D MESON candidate subtraction (side-band variations, etc.)
8059 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8060 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 8061 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 8062 }
8063
8064 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8065 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8066 fhBackSubtractionMax->SetBinContent(j,0.05);
8067 }
8068
8069 // MC CORRECTIONS/ -5% 10% for assoc track eff
8070 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8071 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 8072 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 8073 }
8074
8075 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8076 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 8077 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 8078 }
8079
8080 // MC D EFF CORRECTION
8081 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8082 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8083 fhMCDefficiencyMin->SetBinContent(j,-0.05);
8084 }
8085
8086 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8087 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8088 fhMCDefficiencyMax->SetBinContent(j,0.05);
8089 }
8090
8091
8092 // Contamination from secondary tracks
8093 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8094 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 8095 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 8096 }
8097
8098 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8099 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 8100 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 8101 }
8102
8103 // MC CLOSURETEST (D meson efficiency)
8104 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8105 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8106 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 8107 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 8108
8109 if(-0.4<x&&x<-0.2){
8110 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8111 }
8112 else if(-0.2<x&&x<-0.1){
8113 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8114 }
8115 else if(-0.1<x&&x<0.1){
8116 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8117 }
8118 else if(0.1<x&&x<0.2){
8119 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8120 }
8121 if(0.2<x&&x<0.4){
8122 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8123 }
8124 }
8125
8126 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8127 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8128 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 8129 fhMCclosureTestMax->SetBinContent(j,0.07);
62f6d8bf 8130
8131 // if(-0.4<x&&x<-0.2){
8132 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8133 // }
8134 // else if(-0.2<x&&x<-0.1){
8135 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8136 // }
8137 // else if(-0.2<x&&x<-0.1){
8138 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8139 // }
8140 // else if(-0.1<x&&x<0.1){
8141 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8142 // }
8143 // else if(0.1<x&&x<0.2){
8144 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8145 // }
8146 // if(0.2<x&&x<0.4){
8147 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8148 // }
8149
8150 }
8151
8152 // Feed-down
8153
8154 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8155 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8156 x=fhBeautyFDmin->GetBinLowEdge(j);
8157 fhBeautyFDmin->SetBinContent(j,-0.05);
8158
8159 // if(-0.4<x&&x<-0.2){
8160// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8161// }
8162// else if(-0.2<x&&x<-0.1){
8163// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8164// }
8165// else if(-0.2<x&&x<-0.1){
8166// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8167// }
8168// else if(-0.1<x&&x<0.1){
8169// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8170// }
8171// else if(0.1<x&&x<0.2){
8172// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8173// }
8174// if(0.2<x&&x<0.4){
8175// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8176// }
8177 }
8178
8179 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8180 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8181 x=fhBeautyFDmax->GetBinLowEdge(j);
8182 fhBeautyFDmax->SetBinContent(j,0.03);
8183
8184// if(-0.4<x&&x<-0.2){
8185// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8186// }
8187// else if(-0.2<x&&x<-0.1){
8188// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8189// }
8190// else if(-0.2<x&&x<-0.1){
8191// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8192// }
8193// else if(-0.1<x&&x<0.1){
8194// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8195// }
8196// else if(0.1<x&&x<0.2){
8197// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8198// }
8199// if(0.2<x&&x<0.4){
8200// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8201// }
8202
8203 }
8204
8205}
8206
8207
8208
76948b1d 8209void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05(){
8210 Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
62f6d8bf 8211 fmeson=1;
8212 fstrmeson="Dstar";
8213 fstrptAss="ptAsMore05";
8214 fstrptD="Dpt8to16";
8215 if(!fhDeltaPhiTemplate){
8216 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8217 }
8218 Double_t x;
8219 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8220 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8221 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8222 fhYieldExtraction->SetBinContent(j,0.1);
8223 }
8224
8225 // Background D MESON candidate subtraction (side-band variations, etc.)
8226 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8227 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 8228 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 8229 }
8230
8231 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8232 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8233 fhBackSubtractionMax->SetBinContent(j,0.05);
8234 }
8235
8236 // MC CORRECTIONS -5% +10% for assoc track eff
8237 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8238 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 8239 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 8240 }
8241
8242 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8243 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 8244 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 8245 }
8246 // MC D EFF CORRECTION
8247 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8248 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 8249 fhMCDefficiencyMin->SetBinContent(j,-0.08);
62f6d8bf 8250 }
8251
8252 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8253 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 8254 fhMCDefficiencyMax->SetBinContent(j,0.08);
62f6d8bf 8255 }
8256
8257
8258 // Contamination from secondary tracks
8259 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8260 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 8261 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 8262 }
8263
8264 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8265 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 8266 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 8267 }
8268
8269 // MC CLOSURETEST (D meson efficiency)
8270 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8271 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8272 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 8273 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 8274
8275 if(-0.4<x&&x<-0.2){
8276 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8277 }
8278 else if(-0.2<x&&x<-0.1){
8279 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8280 }
8281 else if(-0.1<x&&x<0.1){
8282 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8283 }
8284 else if(0.1<x&&x<0.2){
8285 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8286 }
8287 if(0.2<x&&x<0.4){
8288 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8289 }
8290 }
8291
8292 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8293 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8294 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 8295 fhMCclosureTestMax->SetBinContent(j,0.07);
62f6d8bf 8296
8297 // if(-0.4<x&&x<-0.2){
8298 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8299 // }
8300 // else if(-0.2<x&&x<-0.1){
8301 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8302 // }
8303 // else if(-0.2<x&&x<-0.1){
8304 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8305 // }
8306 // else if(-0.1<x&&x<0.1){
8307 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8308 // }
8309 // else if(0.1<x&&x<0.2){
8310 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8311 // }
8312 // if(0.2<x&&x<0.4){
8313 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8314 // }
8315
8316 }
8317
8318 // Feed-down
8319
8320 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8321 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8322 x=fhBeautyFDmin->GetBinLowEdge(j);
8323 fhBeautyFDmin->SetBinContent(j,-0.05);
8324
8325 // if(-0.4<x&&x<-0.2){
8326// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8327// }
8328// else if(-0.2<x&&x<-0.1){
8329// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8330// }
8331// else if(-0.2<x&&x<-0.1){
8332// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8333// }
8334// else if(-0.1<x&&x<0.1){
8335// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8336// }
8337// else if(0.1<x&&x<0.2){
8338// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8339// }
8340// if(0.2<x&&x<0.4){
8341// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8342// }
8343 }
8344
8345 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8346 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8347 x=fhBeautyFDmax->GetBinLowEdge(j);
8348 fhBeautyFDmax->SetBinContent(j,0.03);
8349
8350// if(-0.4<x&&x<-0.2){
8351// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8352// }
8353// else if(-0.2<x&&x<-0.1){
8354// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8355// }
8356// else if(-0.2<x&&x<-0.1){
8357// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8358// }
8359// else if(-0.1<x&&x<0.1){
8360// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8361// }
8362// else if(0.1<x&&x<0.2){
8363// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8364// }
8365// if(0.2<x&&x<0.4){
8366// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8367// }
8368
8369 }
8370
8371
8372}
8373
8374
8375
76948b1d 8376void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
8377 Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
8378 fmeson=2;
62f6d8bf 8379 fstrmeson="Dplus";
8380 fstrptAss="ptAsMore05";
8381 fstrptD="Dpt3to5";
8382 if(!fhDeltaPhiTemplate){
8383 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8384 }
8385 Double_t x;
8386 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8387 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8388 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8389 fhYieldExtraction->SetBinContent(j,0.1);
8390 }
8391
8392 // Background D MESON candidate subtraction (side-band variations, etc.)
8393 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8394 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 8395 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 8396 }
8397
8398 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8399 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 8400 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 8401 }
8402
8403
8404 // MC CORRECTIONS ( associatate track efficiency):
8405 // -5% +10% for assoc track eff
8406 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8407 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 8408 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 8409 }
8410
8411 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8412 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 8413 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 8414 }
8415
8416 // MC D EFF CORRECTION
8417 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8418 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 8419 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 8420 }
8421
8422 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8423 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 8424 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 8425 }
8426
8427
8428 // Contamination from secondary tracks
8429 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8430 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 8431 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 8432 }
8433
8434 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8435 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 8436 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 8437 }
8438
8439
8440 // MC CLOSURETEST (D meson efficiency)
8441 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8442 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8443 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 8444 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 8445
8446 if(-0.4<x&&x<-0.2){
8447 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8448 }
8449 else if(-0.2<x&&x<-0.1){
8450 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8451 }
8452 else if(-0.1<x&&x<0.1){
8453 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8454 }
8455 else if(0.1<x&&x<0.2){
8456 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8457 }
8458 if(0.2<x&&x<0.4){
8459 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8460 }
8461 }
8462
8463 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8464 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8465 // x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 8466 fhMCclosureTestMax->SetBinContent(j,0.06);
62f6d8bf 8467
8468 // if(-0.4<x&&x<-0.2){
8469 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8470 // }
8471 // else if(-0.2<x&&x<-0.1){
8472 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8473 // }
8474 // else if(-0.2<x&&x<-0.1){
8475 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8476 // }
8477 // else if(-0.1<x&&x<0.1){
8478 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8479 // }
8480 // else if(0.1<x&&x<0.2){
8481 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8482 // }
8483 // if(0.2<x&&x<0.4){
8484 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8485 // }
8486
8487 }
8488
8489 // Feed-down
8490
8491 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8492 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8493 x=fhBeautyFDmin->GetBinLowEdge(j);
8494 fhBeautyFDmin->SetBinContent(j,-0.05);
8495
8496 // if(-0.4<x&&x<-0.2){
8497// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8498// }
8499// else if(-0.2<x&&x<-0.1){
8500// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8501// }
8502// else if(-0.2<x&&x<-0.1){
8503// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8504// }
8505// else if(-0.1<x&&x<0.1){
8506// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8507// }
8508// else if(0.1<x&&x<0.2){
8509// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8510// }
8511// if(0.2<x&&x<0.4){
8512// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8513// }
8514 }
8515
8516 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8517 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8518 x=fhBeautyFDmax->GetBinLowEdge(j);
8519 fhBeautyFDmax->SetBinContent(j,0.03);
8520
8521// if(-0.4<x&&x<-0.2){
8522// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8523// }
8524// else if(-0.2<x&&x<-0.1){
8525// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8526// }
8527// else if(-0.2<x&&x<-0.1){
8528// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8529// }
8530// else if(-0.1<x&&x<0.1){
8531// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8532// }
8533// else if(0.1<x&&x<0.2){
8534// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8535// }
8536// if(0.2<x&&x<0.4){
8537// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8538// }
8539
8540 }
8541
8542}
8543
76948b1d 8544void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
8545 Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8546 fmeson=2;
62f6d8bf 8547 fstrmeson="Dplus";
8548 fstrptAss="ptAsMore05";
8549 fstrptD="Dpt5to8";
8550 if(!fhDeltaPhiTemplate){
8551 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8552 }
8553 Double_t x;
8554 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8555 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8556 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8557 fhYieldExtraction->SetBinContent(j,0.1);
8558 }
8559
8560 // Background D MESON candidate subtraction (side-band variations, etc.)
8561 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8562 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 8563 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 8564 }
8565
8566 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8567 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 8568 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 8569 }
8570
8571 // MC CORRECTIONS: -5% +10% for assoc track eff
8572 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8573 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 8574 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 8575 }
8576
8577 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8578 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 8579 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 8580 }
8581
8582
8583 // MC D EFF CORRECTION
8584 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8585 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 8586 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 8587 }
8588
8589 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8590 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 8591 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 8592 }
8593
8594
8595 // Contamination from secondary tracks
8596 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8597 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 8598 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 8599 }
8600
8601 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8602 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 8603 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 8604 }
8605
8606 // MC CLOSURETEST (D meson efficiency)
8607 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8608 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8609 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 8610 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 8611
8612 if(-0.4<x&&x<-0.2){
8613 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8614 }
8615 else if(-0.2<x&&x<-0.1){
8616 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8617 }
8618 else if(-0.1<x&&x<0.1){
8619 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8620 }
8621 else if(0.1<x&&x<0.2){
8622 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8623 }
8624 if(0.2<x&&x<0.4){
8625 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8626 }
8627 }
8628
8629 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8630 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8631 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 8632 fhMCclosureTestMax->SetBinContent(j,0.06);
62f6d8bf 8633
8634 // if(-0.4<x&&x<-0.2){
8635 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8636 // }
8637 // else if(-0.2<x&&x<-0.1){
8638 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8639 // }
8640 // else if(-0.2<x&&x<-0.1){
8641 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8642 // }
8643 // else if(-0.1<x&&x<0.1){
8644 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8645 // }
8646 // else if(0.1<x&&x<0.2){
8647 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8648 // }
8649 // if(0.2<x&&x<0.4){
8650 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8651 // }
8652
8653 }
8654
8655 // Feed-down
8656
8657 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8658 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8659 x=fhBeautyFDmin->GetBinLowEdge(j);
8660 fhBeautyFDmin->SetBinContent(j,-0.05);
8661
8662 // if(-0.4<x&&x<-0.2){
8663// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8664// }
8665// else if(-0.2<x&&x<-0.1){
8666// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8667// }
8668// else if(-0.2<x&&x<-0.1){
8669// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8670// }
8671// else if(-0.1<x&&x<0.1){
8672// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8673// }
8674// else if(0.1<x&&x<0.2){
8675// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8676// }
8677// if(0.2<x&&x<0.4){
8678// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8679// }
8680 }
8681
8682 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8683 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8684 x=fhBeautyFDmax->GetBinLowEdge(j);
8685 fhBeautyFDmax->SetBinContent(j,0.03);
8686
8687// if(-0.4<x&&x<-0.2){
8688// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8689// }
8690// else if(-0.2<x&&x<-0.1){
8691// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8692// }
8693// else if(-0.2<x&&x<-0.1){
8694// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8695// }
8696// else if(-0.1<x&&x<0.1){
8697// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8698// }
8699// else if(0.1<x&&x<0.2){
8700// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8701// }
8702// if(0.2<x&&x<0.4){
8703// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8704// }
8705
8706 }
8707
8708}
8709
8710
76948b1d 8711void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05(){
8712 Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8713 fmeson=2;
62f6d8bf 8714 fstrmeson="Dplus";
8715 fstrptAss="ptAsMore05";
8716 fstrptD="Dpt8to16";
8717 if(!fhDeltaPhiTemplate){
8718 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8719 }
8720
8721 Double_t x;
8722 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8723 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8724 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8725 fhYieldExtraction->SetBinContent(j,0.1);
8726 }
8727
8728 // Background D MESON candidate subtraction (side-band variations, etc.)
8729 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8730 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 8731 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 8732 }
8733
8734 // Background D MESON candidate subtraction (side-band variations, etc.)
8735 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8736 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 8737 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 8738 }
8739
8740 // MC CORRECTIONS, -5% 10% for assoc track eff
8741 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8742 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 8743 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 8744 }
8745
8746 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8747 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 8748 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 8749 }
8750
8751
8752 // MC D EFF CORRECTION
8753 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8754 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 8755 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 8756 }
8757
8758 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8759 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 8760 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 8761 }
8762
8763
8764 // Contamination from secondary tracks
8765 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8766 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 8767 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 8768 }
8769
8770 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8771 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 8772 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 8773 }
8774
8775 // MC CLOSURETEST (D meson efficiency)
8776 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8777 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8778 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 8779 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 8780
8781 if(-0.4<x&&x<-0.2){
8782 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8783 }
8784 else if(-0.2<x&&x<-0.1){
8785 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8786 }
8787 else if(-0.1<x&&x<0.1){
8788 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8789 }
8790 else if(0.1<x&&x<0.2){
8791 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8792 }
8793 if(0.2<x&&x<0.4){
8794 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8795 }
8796 }
8797
8798 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8799 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8800 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 8801 fhMCclosureTestMax->SetBinContent(j,0.06);
62f6d8bf 8802
8803 // if(-0.4<x&&x<-0.2){
8804 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8805 // }
8806 // else if(-0.2<x&&x<-0.1){
8807 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8808 // }
8809 // else if(-0.2<x&&x<-0.1){
8810 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8811 // }
8812 // else if(-0.1<x&&x<0.1){
8813 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8814 // }
8815 // else if(0.1<x&&x<0.2){
8816 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8817 // }
8818 // if(0.2<x&&x<0.4){
8819 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8820 // }
8821
8822 }
8823
8824 // Feed-down
8825
8826 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8827 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8828 x=fhBeautyFDmin->GetBinLowEdge(j);
8829 fhBeautyFDmin->SetBinContent(j,-0.05);
8830
8831 // if(-0.4<x&&x<-0.2){
8832// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8833// }
8834// else if(-0.2<x&&x<-0.1){
8835// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8836// }
8837// else if(-0.2<x&&x<-0.1){
8838// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8839// }
8840// else if(-0.1<x&&x<0.1){
8841// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8842// }
8843// else if(0.1<x&&x<0.2){
8844// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8845// }
8846// if(0.2<x&&x<0.4){
8847// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8848// }
8849 }
8850
8851 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8852 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8853 x=fhBeautyFDmax->GetBinLowEdge(j);
8854 fhBeautyFDmax->SetBinContent(j,0.03);
8855
8856// if(-0.4<x&&x<-0.2){
8857// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8858// }
8859// else if(-0.2<x&&x<-0.1){
8860// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8861// }
8862// else if(-0.2<x&&x<-0.1){
8863// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8864// }
8865// else if(-0.1<x&&x<0.1){
8866// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8867// }
8868// else if(0.1<x&&x<0.2){
8869// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8870// }
8871// if(0.2<x&&x<0.4){
8872// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8873// }
8874
8875 }
8876
8877}
8878
8879
8880
8881// pt(assoc)> 1 GeV/c
76948b1d 8882void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
8883 Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
62f6d8bf 8884 fmeson=0;
8885 fstrmeson="Dzero";
8886 fstrptAss="ptAsMore1";
8887 fstrptD="Dpt3to5";
8888 if(!fhDeltaPhiTemplate){
8889 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8890 }
8891 Double_t x;
8892 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8893 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8894 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8895 fhYieldExtraction->SetBinContent(j,0.1);
8896 }
8897
8898 // Background D MESON candidate subtraction (side-band variations, etc.)
8899 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8900 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8901 fhBackSubtractionMin->SetBinContent(j,-0.05);
8902 }
8903
8904 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8905 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8906 fhBackSubtractionMax->SetBinContent(j,0.05);
8907 }
8908
8909
8910 // MC CORRECTIONS ( associatate track efficiency):
8911 // -5% +10% for assoc track eff
8912 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8913 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 8914 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 8915 }
8916
8917 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8918 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 8919 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 8920 }
8921
8922 // MC D EFF CORRECTION
8923 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8924 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8925 fhMCDefficiencyMin->SetBinContent(j,-0.05);
8926 }
8927
8928 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8929 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8930 fhMCDefficiencyMax->SetBinContent(j,0.05);
8931 }
8932
8933
8934 // Contamination from secondary tracks
8935 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8936 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 8937 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 8938 }
8939
8940 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8941 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 8942 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 8943 }
8944
8945
8946 // MC CLOSURETEST (D meson efficiency)
8947 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8948 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8949 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 8950 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 8951
8952 if(-0.4<x&&x<-0.2){
8953 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8954 }
8955 else if(-0.2<x&&x<-0.1){
8956 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8957 }
8958 else if(-0.1<x&&x<0.1){
8959 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8960 }
8961 else if(0.1<x&&x<0.2){
8962 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8963 }
8964 if(0.2<x&&x<0.4){
8965 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8966 }
8967 }
8968
8969 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8970 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8971 // x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 8972 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 8973
8974 // if(-0.4<x&&x<-0.2){
8975 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8976 // }
8977 // else if(-0.2<x&&x<-0.1){
8978 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8979 // }
8980 // else if(-0.2<x&&x<-0.1){
8981 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8982 // }
8983 // else if(-0.1<x&&x<0.1){
8984 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8985 // }
8986 // else if(0.1<x&&x<0.2){
8987 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8988 // }
8989 // if(0.2<x&&x<0.4){
8990 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8991 // }
8992
8993 }
8994
8995 // Feed-down
8996
8997 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8998 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8999 x=fhBeautyFDmin->GetBinLowEdge(j);
9000 fhBeautyFDmin->SetBinContent(j,-0.05);
9001
9002 // if(-0.4<x&&x<-0.2){
9003// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9004// }
9005// else if(-0.2<x&&x<-0.1){
9006// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9007// }
9008// else if(-0.2<x&&x<-0.1){
9009// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9010// }
9011// else if(-0.1<x&&x<0.1){
9012// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9013// }
9014// else if(0.1<x&&x<0.2){
9015// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9016// }
9017// if(0.2<x&&x<0.4){
9018// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9019// }
9020 }
9021
9022 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9023 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9024 x=fhBeautyFDmax->GetBinLowEdge(j);
9025 fhBeautyFDmax->SetBinContent(j,0.03);
9026
9027// if(-0.4<x&&x<-0.2){
9028// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9029// }
9030// else if(-0.2<x&&x<-0.1){
9031// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9032// }
9033// else if(-0.2<x&&x<-0.1){
9034// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9035// }
9036// else if(-0.1<x&&x<0.1){
9037// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9038// }
9039// else if(0.1<x&&x<0.2){
9040// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9041// }
9042// if(0.2<x&&x<0.4){
9043// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9044// }
9045
9046 }
9047
9048}
9049
76948b1d 9050void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
9051 Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
62f6d8bf 9052 fmeson=0;
9053 fstrmeson="Dzero";
9054 fstrptAss="ptAsMore1";
9055 fstrptD="Dpt5to8";
9056 if(!fhDeltaPhiTemplate){
9057 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9058 }
9059 Double_t x;
9060 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9061 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9062 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9063 fhYieldExtraction->SetBinContent(j,0.1);
9064 }
9065
9066 // Background D MESON candidate subtraction (side-band variations, etc.)
9067 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9068 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 9069 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 9070 }
9071
9072 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9073 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9074 fhBackSubtractionMax->SetBinContent(j,0.05);
9075 }
9076
9077 // MC CORRECTIONS: -5% +10% for assoc track eff
9078 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9079 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 9080 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 9081 }
9082
9083 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9084 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 9085 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 9086 }
9087
9088
9089 // MC D EFF CORRECTION
9090 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9091 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9092 fhMCDefficiencyMin->SetBinContent(j,-0.05);
9093 }
9094
9095 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9096 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9097 fhMCDefficiencyMax->SetBinContent(j,0.05);
9098 }
9099
9100
9101 // Contamination from secondary tracks
9102 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9103 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 9104 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 9105 }
9106
9107 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9108 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 9109 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 9110 }
9111
9112 // MC CLOSURETEST (D meson efficiency)
9113 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9114 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9115 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 9116 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 9117
9118 if(-0.4<x&&x<-0.2){
9119 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9120 }
9121 else if(-0.2<x&&x<-0.1){
9122 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9123 }
9124 else if(-0.1<x&&x<0.1){
9125 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9126 }
9127 else if(0.1<x&&x<0.2){
9128 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9129 }
9130 if(0.2<x&&x<0.4){
9131 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9132 }
9133 }
9134
9135 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9136 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9137 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 9138 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 9139
9140 // if(-0.4<x&&x<-0.2){
9141 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9142 // }
9143 // else if(-0.2<x&&x<-0.1){
9144 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9145 // }
9146 // else if(-0.2<x&&x<-0.1){
9147 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9148 // }
9149 // else if(-0.1<x&&x<0.1){
9150 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9151 // }
9152 // else if(0.1<x&&x<0.2){
9153 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9154 // }
9155 // if(0.2<x&&x<0.4){
9156 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9157 // }
9158
9159 }
9160
9161 // Feed-down
9162
9163 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9164 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9165 x=fhBeautyFDmin->GetBinLowEdge(j);
9166 fhBeautyFDmin->SetBinContent(j,-0.05);
9167
9168 // if(-0.4<x&&x<-0.2){
9169// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9170// }
9171// else if(-0.2<x&&x<-0.1){
9172// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9173// }
9174// else if(-0.2<x&&x<-0.1){
9175// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9176// }
9177// else if(-0.1<x&&x<0.1){
9178// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9179// }
9180// else if(0.1<x&&x<0.2){
9181// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9182// }
9183// if(0.2<x&&x<0.4){
9184// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9185// }
9186 }
9187
9188 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9189 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9190 x=fhBeautyFDmax->GetBinLowEdge(j);
9191 fhBeautyFDmax->SetBinContent(j,0.03);
9192
9193// if(-0.4<x&&x<-0.2){
9194// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9195// }
9196// else if(-0.2<x&&x<-0.1){
9197// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9198// }
9199// else if(-0.2<x&&x<-0.1){
9200// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9201// }
9202// else if(-0.1<x&&x<0.1){
9203// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9204// }
9205// else if(0.1<x&&x<0.2){
9206// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9207// }
9208// if(0.2<x&&x<0.4){
9209// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9210// }
9211
9212 }
9213
9214}
9215
9216
76948b1d 9217void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
9218 Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
62f6d8bf 9219 fmeson=0;
9220 fstrmeson="Dzero";
9221 fstrptAss="ptAsMore1";
9222 fstrptD="Dpt8to16";
9223 if(!fhDeltaPhiTemplate){
9224 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9225 }
9226
9227 Double_t x;
9228 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9229 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9230 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9231 fhYieldExtraction->SetBinContent(j,0.1);
9232 }
9233
9234 // Background D MESON candidate subtraction (side-band variations, etc.)
9235 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9236 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 9237 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 9238 }
9239
9240 // Background D MESON candidate subtraction (side-band variations, etc.)
9241 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9242 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9243 fhBackSubtractionMax->SetBinContent(j,0.05);
9244 }
9245
9246 // MC CORRECTIONS, -5% 10% for assoc track eff
9247 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9248 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 9249 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 9250 }
9251
9252 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9253 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 9254 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 9255 }
9256
9257
9258 // MC D EFF CORRECTION
9259 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9260 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9261 fhMCDefficiencyMin->SetBinContent(j,-0.05);
9262 }
9263
9264 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9265 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9266 fhMCDefficiencyMax->SetBinContent(j,0.05);
9267 }
9268
9269
9270 // Contamination from secondary tracks
9271 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9272 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 9273 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 9274 }
9275
9276 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9277 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 9278 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 9279 }
9280
9281 // MC CLOSURETEST (D meson efficiency)
9282 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9283 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9284 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 9285 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 9286
9287 if(-0.4<x&&x<-0.2){
9288 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9289 }
9290 else if(-0.2<x&&x<-0.1){
9291 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9292 }
9293 else if(-0.1<x&&x<0.1){
9294 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9295 }
9296 else if(0.1<x&&x<0.2){
9297 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9298 }
9299 if(0.2<x&&x<0.4){
9300 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9301 }
9302 }
9303
9304 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9305 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9306 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 9307 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 9308
9309 // if(-0.4<x&&x<-0.2){
9310 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9311 // }
9312 // else if(-0.2<x&&x<-0.1){
9313 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9314 // }
9315 // else if(-0.2<x&&x<-0.1){
9316 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9317 // }
9318 // else if(-0.1<x&&x<0.1){
9319 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9320 // }
9321 // else if(0.1<x&&x<0.2){
9322 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9323 // }
9324 // if(0.2<x&&x<0.4){
9325 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9326 // }
9327
9328 }
9329
9330 // Feed-down
9331
9332 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9333 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9334 x=fhBeautyFDmin->GetBinLowEdge(j);
9335 fhBeautyFDmin->SetBinContent(j,-0.05);
9336
9337 // if(-0.4<x&&x<-0.2){
9338// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9339// }
9340// else if(-0.2<x&&x<-0.1){
9341// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9342// }
9343// else if(-0.2<x&&x<-0.1){
9344// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9345// }
9346// else if(-0.1<x&&x<0.1){
9347// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9348// }
9349// else if(0.1<x&&x<0.2){
9350// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9351// }
9352// if(0.2<x&&x<0.4){
9353// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9354// }
9355 }
9356
9357 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9358 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9359 x=fhBeautyFDmax->GetBinLowEdge(j);
9360 fhBeautyFDmax->SetBinContent(j,0.03);
9361
9362// if(-0.4<x&&x<-0.2){
9363// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9364// }
9365// else if(-0.2<x&&x<-0.1){
9366// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9367// }
9368// else if(-0.2<x&&x<-0.1){
9369// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9370// }
9371// else if(-0.1<x&&x<0.1){
9372// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9373// }
9374// else if(0.1<x&&x<0.2){
9375// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9376// }
9377// if(0.2<x&&x<0.4){
9378// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9379// }
9380
9381 }
9382
9383}
9384
9385
9386
9387
9388//--------------------------------------------------
76948b1d 9389void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
9390 Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
62f6d8bf 9391 fmeson=1;
9392 fstrmeson="Dstar";
9393 fstrptAss="ptAsMore1";
9394 fstrptD="Dpt3to5";
9395 if(!fhDeltaPhiTemplate){
9396 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9397 }
9398 Double_t x;
9399 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9400 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9401 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9402 fhYieldExtraction->SetBinContent(j,0.1);
9403 }
9404
9405 // Background D MESON candidate subtraction (side-band variations, etc.)
9406 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9407 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 9408 fhBackSubtractionMin->SetBinContent(j,-0.08);
62f6d8bf 9409 }
9410
9411 // Background D MESON candidate subtraction (side-band variations, etc.)
9412 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9413 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 9414 fhBackSubtractionMax->SetBinContent(j,0.08);
62f6d8bf 9415 }
9416
9417 // MC CORRECTIONS, -5% 10% for assoc track eff
9418 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9419 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 9420 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 9421 }
9422
9423 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9424 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 9425 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 9426 }
9427
9428
9429 // MC D EFF CORRECTION
9430 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9431 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9432 fhMCDefficiencyMin->SetBinContent(j,-0.05);
9433 }
9434
9435 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9436 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9437 fhMCDefficiencyMax->SetBinContent(j,0.05);
9438 }
9439
9440
9441 // Contamination from secondary tracks
9442 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9443 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 9444 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 9445 }
9446
9447 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9448 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 9449 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 9450 }
9451
9452 // MC CLOSURETEST (D meson efficiency)
9453 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9454 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9455 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 9456 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 9457
9458 if(-0.4<x&&x<-0.2){
9459 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9460 }
9461 else if(-0.2<x&&x<-0.1){
9462 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9463 }
9464 else if(-0.1<x&&x<0.1){
9465 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9466 }
9467 else if(0.1<x&&x<0.2){
9468 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9469 }
9470 if(0.2<x&&x<0.4){
9471 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9472 }
9473 }
9474
9475 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9476 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9477 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 9478 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 9479
9480 // if(-0.4<x&&x<-0.2){
9481 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9482 // }
9483 // else if(-0.2<x&&x<-0.1){
9484 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9485 // }
9486 // else if(-0.2<x&&x<-0.1){
9487 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9488 // }
9489 // else if(-0.1<x&&x<0.1){
9490 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9491 // }
9492 // else if(0.1<x&&x<0.2){
9493 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9494 // }
9495 // if(0.2<x&&x<0.4){
9496 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9497 // }
9498
9499 }
9500
9501 // Feed-down
9502
9503 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9504 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9505 x=fhBeautyFDmin->GetBinLowEdge(j);
9506 fhBeautyFDmin->SetBinContent(j,-0.05);
9507
9508 // if(-0.4<x&&x<-0.2){
9509// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9510// }
9511// else if(-0.2<x&&x<-0.1){
9512// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9513// }
9514// else if(-0.2<x&&x<-0.1){
9515// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9516// }
9517// else if(-0.1<x&&x<0.1){
9518// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9519// }
9520// else if(0.1<x&&x<0.2){
9521// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9522// }
9523// if(0.2<x&&x<0.4){
9524// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9525// }
9526 }
9527
9528 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9529 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9530 x=fhBeautyFDmax->GetBinLowEdge(j);
9531 fhBeautyFDmax->SetBinContent(j,0.03);
9532
9533// if(-0.4<x&&x<-0.2){
9534// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9535// }
9536// else if(-0.2<x&&x<-0.1){
9537// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9538// }
9539// else if(-0.2<x&&x<-0.1){
9540// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9541// }
9542// else if(-0.1<x&&x<0.1){
9543// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9544// }
9545// else if(0.1<x&&x<0.2){
9546// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9547// }
9548// if(0.2<x&&x<0.4){
9549// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9550// }
9551
9552 }
9553
9554
9555}
9556
76948b1d 9557void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
9558 Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
62f6d8bf 9559 fmeson=1;
9560 fstrmeson="Dstar";
9561 fstrptAss="ptAsMore1";
9562 fstrptD="Dpt5to8";
9563 if(!fhDeltaPhiTemplate){
9564 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9565 }
9566 Double_t x;
9567 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9568 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9569 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9570 fhYieldExtraction->SetBinContent(j,0.1);
9571 }
9572
9573 // Background D MESON candidate subtraction (side-band variations, etc.)
9574 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9575 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 9576 fhBackSubtractionMin->SetBinContent(j,-0.06);
62f6d8bf 9577 }
9578
9579 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9580 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 9581 fhBackSubtractionMax->SetBinContent(j,0.06);
62f6d8bf 9582 }
9583
9584 // MC CORRECTIONS/ -5% 10% for assoc track eff
9585 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9586 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 9587 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 9588 }
9589
9590 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9591 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 9592 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 9593 }
9594
9595 // MC D EFF CORRECTION
9596 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9597 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9598 fhMCDefficiencyMin->SetBinContent(j,-0.05);
9599 }
9600
9601 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9602 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9603 fhMCDefficiencyMax->SetBinContent(j,0.05);
9604 }
9605
9606
9607 // Contamination from secondary tracks
9608 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9609 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 9610 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 9611 }
9612
9613 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9614 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 9615 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 9616 }
9617
9618 // MC CLOSURETEST (D meson efficiency)
9619 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9620 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9621 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 9622 fhMCclosureTestMin->SetBinContent(j,-0.);
62f6d8bf 9623
9624 if(-0.4<x&&x<-0.2){
9625 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9626 }
9627 else if(-0.2<x&&x<-0.1){
9628 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9629 }
9630 else if(-0.1<x&&x<0.1){
9631 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9632 }
9633 else if(0.1<x&&x<0.2){
9634 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9635 }
9636 if(0.2<x&&x<0.4){
9637 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9638 }
9639 }
9640
9641 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9642 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9643 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 9644 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 9645
9646 // if(-0.4<x&&x<-0.2){
9647 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9648 // }
9649 // else if(-0.2<x&&x<-0.1){
9650 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9651 // }
9652 // else if(-0.2<x&&x<-0.1){
9653 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9654 // }
9655 // else if(-0.1<x&&x<0.1){
9656 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9657 // }
9658 // else if(0.1<x&&x<0.2){
9659 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9660 // }
9661 // if(0.2<x&&x<0.4){
9662 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9663 // }
9664
9665 }
9666
9667 // Feed-down
9668
9669 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9670 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9671 x=fhBeautyFDmin->GetBinLowEdge(j);
9672 fhBeautyFDmin->SetBinContent(j,-0.05);
9673
9674 // if(-0.4<x&&x<-0.2){
9675// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9676// }
9677// else if(-0.2<x&&x<-0.1){
9678// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9679// }
9680// else if(-0.2<x&&x<-0.1){
9681// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9682// }
9683// else if(-0.1<x&&x<0.1){
9684// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9685// }
9686// else if(0.1<x&&x<0.2){
9687// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9688// }
9689// if(0.2<x&&x<0.4){
9690// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9691// }
9692 }
9693
9694 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9695 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9696 x=fhBeautyFDmax->GetBinLowEdge(j);
9697 fhBeautyFDmax->SetBinContent(j,0.03);
9698
9699// if(-0.4<x&&x<-0.2){
9700// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9701// }
9702// else if(-0.2<x&&x<-0.1){
9703// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9704// }
9705// else if(-0.2<x&&x<-0.1){
9706// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9707// }
9708// else if(-0.1<x&&x<0.1){
9709// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9710// }
9711// else if(0.1<x&&x<0.2){
9712// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9713// }
9714// if(0.2<x&&x<0.4){
9715// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9716// }
9717
9718 }
9719
9720}
9721
9722
9723
76948b1d 9724void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
9725 Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
62f6d8bf 9726 fmeson=1;
9727 fstrmeson="Dstar";
9728 fstrptAss="ptAsMore1";
9729 fstrptD="Dpt8to16";
9730 if(!fhDeltaPhiTemplate){
9731 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9732 }
9733 Double_t x;
9734 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9735 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9736 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9737 fhYieldExtraction->SetBinContent(j,0.1);
9738 }
9739
9740 // Background D MESON candidate subtraction (side-band variations, etc.)
9741 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9742 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 9743 fhBackSubtractionMin->SetBinContent(j,-0.05);
62f6d8bf 9744 }
9745
9746 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9747 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9748 fhBackSubtractionMax->SetBinContent(j,0.05);
9749 }
9750
9751 // MC CORRECTIONS -5% +10% for assoc track eff
9752 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9753 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 9754 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 9755 }
9756
9757 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9758 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 9759 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 9760 }
9761 // MC D EFF CORRECTION
9762 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9763 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 9764 fhMCDefficiencyMin->SetBinContent(j,-0.08);
62f6d8bf 9765 }
9766
9767 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9768 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 9769 fhMCDefficiencyMax->SetBinContent(j,0.08);
62f6d8bf 9770 }
9771
9772
9773 // Contamination from secondary tracks
9774 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9775 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 9776 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 9777 }
9778
9779 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9780 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 9781 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 9782 }
9783
9784 // MC CLOSURETEST (D meson efficiency)
9785 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9786 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9787 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 9788 fhMCclosureTestMin->SetBinContent(j,-0);
62f6d8bf 9789
9790 if(-0.4<x&&x<-0.2){
9791 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9792 }
9793 else if(-0.2<x&&x<-0.1){
9794 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9795 }
9796 else if(-0.1<x&&x<0.1){
9797 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9798 }
9799 else if(0.1<x&&x<0.2){
9800 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9801 }
9802 if(0.2<x&&x<0.4){
9803 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9804 }
9805 }
9806
9807 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9808 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9809 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 9810 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 9811
9812 // if(-0.4<x&&x<-0.2){
9813 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9814 // }
9815 // else if(-0.2<x&&x<-0.1){
9816 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9817 // }
9818 // else if(-0.2<x&&x<-0.1){
9819 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9820 // }
9821 // else if(-0.1<x&&x<0.1){
9822 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9823 // }
9824 // else if(0.1<x&&x<0.2){
9825 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9826 // }
9827 // if(0.2<x&&x<0.4){
9828 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9829 // }
9830
9831 }
9832
9833 // Feed-down
9834
9835 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9836 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9837 x=fhBeautyFDmin->GetBinLowEdge(j);
9838 fhBeautyFDmin->SetBinContent(j,-0.05);
9839
9840 // if(-0.4<x&&x<-0.2){
9841// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9842// }
9843// else if(-0.2<x&&x<-0.1){
9844// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9845// }
9846// else if(-0.2<x&&x<-0.1){
9847// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9848// }
9849// else if(-0.1<x&&x<0.1){
9850// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9851// }
9852// else if(0.1<x&&x<0.2){
9853// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9854// }
9855// if(0.2<x&&x<0.4){
9856// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9857// }
9858 }
9859
9860 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9861 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9862 x=fhBeautyFDmax->GetBinLowEdge(j);
9863 fhBeautyFDmax->SetBinContent(j,0.03);
9864
9865// if(-0.4<x&&x<-0.2){
9866// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9867// }
9868// else if(-0.2<x&&x<-0.1){
9869// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9870// }
9871// else if(-0.2<x&&x<-0.1){
9872// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9873// }
9874// else if(-0.1<x&&x<0.1){
9875// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9876// }
9877// else if(0.1<x&&x<0.2){
9878// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9879// }
9880// if(0.2<x&&x<0.4){
9881// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9882// }
9883
9884 }
9885
9886
9887}
9888
9889
9890
76948b1d 9891void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
9892 Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9893 fmeson=2;
62f6d8bf 9894 fstrmeson="Dplus";
9895 fstrptAss="ptAsMore1";
9896 fstrptD="Dpt3to5";
9897 if(!fhDeltaPhiTemplate){
9898 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9899 }
9900 Double_t x;
9901 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9902 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9903 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9904 fhYieldExtraction->SetBinContent(j,0.1);
9905 }
9906
9907 // Background D MESON candidate subtraction (side-band variations, etc.)
9908 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9909 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 9910 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 9911 }
9912
9913 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9914 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 9915 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 9916 }
9917
9918
9919 // MC CORRECTIONS ( associatate track efficiency):
9920 // -5% +10% for assoc track eff
9921 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9922 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 9923 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 9924 }
9925
9926 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9927 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 9928 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 9929 }
9930
9931 // MC D EFF CORRECTION
9932 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9933 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 9934 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 9935 }
9936
9937 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9938 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 9939 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 9940 }
9941
9942
9943 // Contamination from secondary tracks
9944 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9945 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 9946 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 9947 }
9948
9949 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9950 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 9951 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 9952 }
9953
9954
9955 // MC CLOSURETEST (D meson efficiency)
9956 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9957 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9958 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 9959 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 9960
9961 if(-0.4<x&&x<-0.2){
9962 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9963 }
9964 else if(-0.2<x&&x<-0.1){
9965 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9966 }
9967 else if(-0.1<x&&x<0.1){
9968 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9969 }
9970 else if(0.1<x&&x<0.2){
9971 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9972 }
9973 if(0.2<x&&x<0.4){
9974 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9975 }
9976 }
9977
9978 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9979 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9980 // x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 9981 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 9982
9983 // if(-0.4<x&&x<-0.2){
9984 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9985 // }
9986 // else if(-0.2<x&&x<-0.1){
9987 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9988 // }
9989 // else if(-0.2<x&&x<-0.1){
9990 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9991 // }
9992 // else if(-0.1<x&&x<0.1){
9993 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9994 // }
9995 // else if(0.1<x&&x<0.2){
9996 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9997 // }
9998 // if(0.2<x&&x<0.4){
9999 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10000 // }
10001
10002 }
10003
10004 // Feed-down
10005
10006 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10007 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10008 x=fhBeautyFDmin->GetBinLowEdge(j);
10009 fhBeautyFDmin->SetBinContent(j,-0.05);
10010
10011 // if(-0.4<x&&x<-0.2){
10012// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10013// }
10014// else if(-0.2<x&&x<-0.1){
10015// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10016// }
10017// else if(-0.2<x&&x<-0.1){
10018// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10019// }
10020// else if(-0.1<x&&x<0.1){
10021// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10022// }
10023// else if(0.1<x&&x<0.2){
10024// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10025// }
10026// if(0.2<x&&x<0.4){
10027// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10028// }
10029 }
10030
10031 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10032 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10033 x=fhBeautyFDmax->GetBinLowEdge(j);
10034 fhBeautyFDmax->SetBinContent(j,0.03);
10035
10036// if(-0.4<x&&x<-0.2){
10037// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10038// }
10039// else if(-0.2<x&&x<-0.1){
10040// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10041// }
10042// else if(-0.2<x&&x<-0.1){
10043// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10044// }
10045// else if(-0.1<x&&x<0.1){
10046// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10047// }
10048// else if(0.1<x&&x<0.2){
10049// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10050// }
10051// if(0.2<x&&x<0.4){
10052// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10053// }
10054
10055 }
10056
10057}
10058
76948b1d 10059void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
10060 Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
10061 fmeson=2;
62f6d8bf 10062 fstrmeson="Dplus";
10063 fstrptAss="ptAsMore1";
10064 fstrptD="Dpt5to8";
10065 if(!fhDeltaPhiTemplate){
10066 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
10067 }
10068 Double_t x;
10069 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
10070 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
10071 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
10072 fhYieldExtraction->SetBinContent(j,0.1);
10073 }
10074
10075 // Background D MESON candidate subtraction (side-band variations, etc.)
10076 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
10077 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 10078 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 10079 }
10080
10081 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10082 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 10083 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 10084 }
10085
10086 // MC CORRECTIONS: -5% +10% for assoc track eff
10087 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
10088 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 10089 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 10090 }
10091
10092 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10093 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 10094 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 10095 }
10096
10097
10098 // MC D EFF CORRECTION
10099 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10100 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 10101 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 10102 }
10103
10104 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10105 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 10106 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 10107 }
10108
10109
10110 // Contamination from secondary tracks
10111 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10112 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 10113 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 10114 }
10115
10116 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10117 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 10118 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 10119 }
10120
10121 // MC CLOSURETEST (D meson efficiency)
10122 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
10123 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
10124 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 10125 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 10126
10127 if(-0.4<x&&x<-0.2){
10128 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10129 }
10130 else if(-0.2<x&&x<-0.1){
10131 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10132 }
10133 else if(-0.1<x&&x<0.1){
10134 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10135 }
10136 else if(0.1<x&&x<0.2){
10137 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10138 }
10139 if(0.2<x&&x<0.4){
10140 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10141 }
10142 }
10143
10144 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10145 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10146 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 10147 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 10148
10149 // if(-0.4<x&&x<-0.2){
10150 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10151 // }
10152 // else if(-0.2<x&&x<-0.1){
10153 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10154 // }
10155 // else if(-0.2<x&&x<-0.1){
10156 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10157 // }
10158 // else if(-0.1<x&&x<0.1){
10159 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10160 // }
10161 // else if(0.1<x&&x<0.2){
10162 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10163 // }
10164 // if(0.2<x&&x<0.4){
10165 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10166 // }
10167
10168 }
10169
10170 // Feed-down
10171
10172 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10173 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10174 x=fhBeautyFDmin->GetBinLowEdge(j);
10175 fhBeautyFDmin->SetBinContent(j,-0.05);
10176
10177 // if(-0.4<x&&x<-0.2){
10178// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10179// }
10180// else if(-0.2<x&&x<-0.1){
10181// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10182// }
10183// else if(-0.2<x&&x<-0.1){
10184// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10185// }
10186// else if(-0.1<x&&x<0.1){
10187// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10188// }
10189// else if(0.1<x&&x<0.2){
10190// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10191// }
10192// if(0.2<x&&x<0.4){
10193// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10194// }
10195 }
10196
10197 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10198 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10199 x=fhBeautyFDmax->GetBinLowEdge(j);
10200 fhBeautyFDmax->SetBinContent(j,0.03);
10201
10202// if(-0.4<x&&x<-0.2){
10203// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10204// }
10205// else if(-0.2<x&&x<-0.1){
10206// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10207// }
10208// else if(-0.2<x&&x<-0.1){
10209// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10210// }
10211// else if(-0.1<x&&x<0.1){
10212// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10213// }
10214// else if(0.1<x&&x<0.2){
10215// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10216// }
10217// if(0.2<x&&x<0.4){
10218// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10219// }
10220
10221 }
10222
10223}
10224
10225
76948b1d 10226void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){
10227 Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
10228 fmeson=2;
62f6d8bf 10229 fstrmeson="Dplus";
10230 fstrptAss="ptAsMore1";
10231 fstrptD="Dpt8to16";
10232 if(!fhDeltaPhiTemplate){
10233 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
10234 }
10235
10236 Double_t x;
10237 // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
10238 fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
10239 for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
10240 fhYieldExtraction->SetBinContent(j,0.1);
10241 }
10242
10243 // Background D MESON candidate subtraction (side-band variations, etc.)
10244 fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
10245 for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
76948b1d 10246 fhBackSubtractionMin->SetBinContent(j,-0.1);
62f6d8bf 10247 }
10248
10249 // Background D MESON candidate subtraction (side-band variations, etc.)
10250 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10251 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
76948b1d 10252 fhBackSubtractionMax->SetBinContent(j,0.1);
62f6d8bf 10253 }
10254
10255 // MC CORRECTIONS, -5% 10% for assoc track eff
10256 fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
10257 for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
76948b1d 10258 fhMCcorrectionsMin->SetBinContent(j,-0.04);
62f6d8bf 10259 }
10260
10261 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10262 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
76948b1d 10263 fhMCcorrectionsMax->SetBinContent(j,0.04);
62f6d8bf 10264 }
10265
10266
10267 // MC D EFF CORRECTION
10268 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10269 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
76948b1d 10270 fhMCDefficiencyMin->SetBinContent(j,-0.1);
62f6d8bf 10271 }
10272
10273 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10274 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
76948b1d 10275 fhMCDefficiencyMax->SetBinContent(j,0.1);
62f6d8bf 10276 }
10277
10278
10279 // Contamination from secondary tracks
10280 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10281 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
76948b1d 10282 fhSecContaminationMin->SetBinContent(j,-0.035);
62f6d8bf 10283 }
10284
10285 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10286 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
76948b1d 10287 fhSecContaminationMax->SetBinContent(j,0.035);
62f6d8bf 10288 }
10289
10290 // MC CLOSURETEST (D meson efficiency)
10291 fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
10292 for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
10293 x=fhMCclosureTestMin->GetBinLowEdge(j);
76948b1d 10294 fhMCclosureTestMin->SetBinContent(j,-0.0);
62f6d8bf 10295
10296 if(-0.4<x&&x<-0.2){
10297 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10298 }
10299 else if(-0.2<x&&x<-0.1){
10300 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10301 }
10302 else if(-0.1<x&&x<0.1){
10303 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10304 }
10305 else if(0.1<x&&x<0.2){
10306 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10307 }
10308 if(0.2<x&&x<0.4){
10309 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10310 }
10311 }
10312
10313 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10314 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10315 x=fhMCclosureTestMax->GetBinLowEdge(j);
76948b1d 10316 fhMCclosureTestMax->SetBinContent(j,0.05);
62f6d8bf 10317
10318 // if(-0.4<x&&x<-0.2){
10319 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10320 // }
10321 // else if(-0.2<x&&x<-0.1){
10322 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10323 // }
10324 // else if(-0.2<x&&x<-0.1){
10325 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10326 // }
10327 // else if(-0.1<x&&x<0.1){
10328 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10329 // }
10330 // else if(0.1<x&&x<0.2){
10331 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10332 // }
10333 // if(0.2<x&&x<0.4){
10334 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10335 // }
10336
10337 }
10338
10339 // Feed-down
10340
10341 fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10342 for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10343 x=fhBeautyFDmin->GetBinLowEdge(j);
10344 fhBeautyFDmin->SetBinContent(j,-0.05);
10345
10346 // if(-0.4<x&&x<-0.2){
10347// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10348// }
10349// else if(-0.2<x&&x<-0.1){
10350// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10351// }
10352// else if(-0.2<x&&x<-0.1){
10353// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10354// }
10355// else if(-0.1<x&&x<0.1){
10356// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10357// }
10358// else if(0.1<x&&x<0.2){
10359// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10360// }
10361// if(0.2<x&&x<0.4){
10362// fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10363// }
10364 }
10365
10366 fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10367 for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10368 x=fhBeautyFDmax->GetBinLowEdge(j);
10369 fhBeautyFDmax->SetBinContent(j,0.03);
10370
10371// if(-0.4<x&&x<-0.2){
10372// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10373// }
10374// else if(-0.2<x&&x<-0.1){
10375// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10376// }
10377// else if(-0.2<x&&x<-0.1){
10378// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10379// }
10380// else if(-0.1<x&&x<0.1){
10381// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10382// }
10383// else if(0.1<x&&x<0.2){
10384// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10385// }
10386// if(0.2<x&&x<0.4){
10387// fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10388// }
10389
10390 }
10391
10392}
10393
10394
10395