1 /**************************************************************************
2 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
19 /////////////////////////////////////////////////////////////
20 // class for systematic uncertainties on D meson -hadron correlation distribution
22 // Author: A. Rossi, andrea.rossi@cern.ch
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
29 /////////////////////////////////////////////////////////////
30 #include <Riostream.h>
31 #include "AliHFDhadronCorrSystUnc.h"
36 #include <TGraphAsymmErrors.h>
42 ClassImp(AliHFDhadronCorrSystUnc)
44 AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc() : TNamed(),
51 fhBackSubtractionMin(),
52 fhBackSubtractionMax(),
61 fhSecContaminationMin(),
62 fhSecContaminationMax(),
67 fhTotalNonFlatDPhiMin(),
68 fhTotalNonFlatDPhiMax(),
75 fgrSecContamination(),
80 fgrMCcorrectionsRel(),
81 fgrMCDefficiencyRel(),
82 fgrSecContaminationRel(),
83 fgrMCclosureTestRel(),
88 fgrTotalNonFlatDPhi(),
89 fgrTotalNonFlatDPhiRel(),
94 // default constructor
98 AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc(const char* name) :
104 fhDeltaPhiTemplate(),
106 fhBackSubtractionMin(),
107 fhBackSubtractionMax(),
110 fhMCclosureTestMin(),
111 fhMCclosureTestMax(),
112 fhMCcorrectionsMin(),
113 fhMCcorrectionsMax(),
114 fhMCDefficiencyMin(),
115 fhMCDefficiencyMax(),
116 fhSecContaminationMin(),
117 fhSecContaminationMax(),
122 fhTotalNonFlatDPhiMin(),
123 fhTotalNonFlatDPhiMax(),
130 fgrSecContamination(),
135 fgrMCcorrectionsRel(),
136 fgrMCDefficiencyRel(),
137 fgrSecContaminationRel(),
138 fgrMCclosureTestRel(),
143 fgrTotalNonFlatDPhi(),
144 fgrTotalNonFlatDPhiRel(),
146 fgrTotalFlatDPhiRel()
148 // default constructor
153 AliHFDhadronCorrSystUnc::~AliHFDhadronCorrSystUnc(){
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;
172 delete fhTotalNonFDMin;
173 delete fhTotalNonFDMax;
174 delete fhTotalNonFlatDPhiMin;
175 delete fhTotalNonFlatDPhiMax;
179 delete fgrBackSubUnc;
180 delete fgrMCcorrections;
181 delete fgrMCDefficiency;
182 delete fgrSecContamination;
183 delete fgrMCclosureTest;
185 delete fgrYieldUncRel;
186 delete fgrBackSubUncRel;
187 delete fgrMCcorrectionsRel;
188 delete fgrMCDefficiencyRel;
189 delete fgrSecContaminationRel;
190 delete fgrMCclosureTestRel;
191 delete fgrBeautyFDRel;
194 delete fgrTotalNonFD;
195 delete fgrTotalNonFlatDPhi;
196 delete fgrTotalNonFlatDPhiRel;
197 delete fgrTotalFlatDPhi;
198 delete fgrTotalFlatDPhiRel;
203 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP(){
204 Printf("Loading syst unc for D0 pp2010 3-5 0.3 thr");
207 fstrptAss="ptAsMore03";
209 if(!fhDeltaPhiTemplate){
210 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
225 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
226 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
227 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
238 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
239 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
240 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
249 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
250 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
251 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
261 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
262 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
263 fhSecContaminationMax->SetBinContent(j,0.05);
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);
274 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
276 else if(-0.2<x&&x<-0.1){
277 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
279 else if(-0.1<x&&x<0.1){
280 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
282 else if(0.1<x&&x<0.2){
283 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
286 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
295 // if(-0.4<x&&x<-0.2){
296 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
298 // else if(-0.2<x&&x<-0.1){
299 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
301 // else if(-0.2<x&&x<-0.1){
302 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
304 // else if(-0.1<x&&x<0.1){
305 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
307 // else if(0.1<x&&x<0.2){
308 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
311 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
323 // if(-0.4<x&&x<-0.2){
324 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
326 // else if(-0.2<x&&x<-0.1){
327 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
329 // else if(-0.2<x&&x<-0.1){
330 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
332 // else if(-0.1<x&&x<0.1){
333 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
335 // else if(0.1<x&&x<0.2){
336 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
339 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
348 // if(-0.4<x&&x<-0.2){
349 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
351 // else if(-0.2<x&&x<-0.1){
352 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
354 // else if(-0.2<x&&x<-0.1){
355 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
357 // else if(-0.1<x&&x<0.1){
358 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
360 // else if(0.1<x&&x<0.2){
361 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
364 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
371 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP(){
372 Printf("Loading syst unc for D0 pp2010 5-8 0.3 thr");
376 fstrptAss="ptAsMore03";
378 if(!fhDeltaPhiTemplate){
379 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
391 fhBackSubtractionMin->SetBinContent(j,-0.05);
394 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
395 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
396 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
405 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
406 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
407 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
417 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
418 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
419 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
429 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
430 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
431 fhSecContaminationMax->SetBinContent(j,0.05);
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);
441 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
443 else if(-0.2<x&&x<-0.1){
444 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
446 else if(-0.1<x&&x<0.1){
447 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
449 else if(0.1<x&&x<0.2){
450 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
453 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
462 // if(-0.4<x&&x<-0.2){
463 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
465 // else if(-0.2<x&&x<-0.1){
466 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
468 // else if(-0.2<x&&x<-0.1){
469 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
471 // else if(-0.1<x&&x<0.1){
472 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
474 // else if(0.1<x&&x<0.2){
475 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
478 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
490 // if(-0.4<x&&x<-0.2){
491 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
493 // else if(-0.2<x&&x<-0.1){
494 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
496 // else if(-0.2<x&&x<-0.1){
497 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
499 // else if(-0.1<x&&x<0.1){
500 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
502 // else if(0.1<x&&x<0.2){
503 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
506 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
515 // if(-0.4<x&&x<-0.2){
516 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
518 // else if(-0.2<x&&x<-0.1){
519 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
521 // else if(-0.2<x&&x<-0.1){
522 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
524 // else if(-0.1<x&&x<0.1){
525 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
527 // else if(0.1<x&&x<0.2){
528 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
531 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
539 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(){
541 Printf("Loading syst unc for D0 pp2010 8-16 0.3 thr");
545 fstrptAss="ptAsMore03";
547 if(!fhDeltaPhiTemplate){
548 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
561 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
576 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
577 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
578 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
588 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
589 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
590 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
600 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
601 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
602 fhSecContaminationMax->SetBinContent(j,0.05);
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);
612 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
614 else if(-0.2<x&&x<-0.1){
615 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
617 else if(-0.1<x&&x<0.1){
618 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
620 else if(0.1<x&&x<0.2){
621 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
624 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
633 // if(-0.4<x&&x<-0.2){
634 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
636 // else if(-0.2<x&&x<-0.1){
637 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
639 // else if(-0.2<x&&x<-0.1){
640 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
642 // else if(-0.1<x&&x<0.1){
643 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
645 // else if(0.1<x&&x<0.2){
646 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
649 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
661 // if(-0.4<x&&x<-0.2){
662 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
664 // else if(-0.2<x&&x<-0.1){
665 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
667 // else if(-0.2<x&&x<-0.1){
668 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
670 // else if(-0.1<x&&x<0.1){
671 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
673 // else if(0.1<x&&x<0.2){
674 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
677 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
686 // if(-0.4<x&&x<-0.2){
687 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
689 // else if(-0.2<x&&x<-0.1){
690 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
692 // else if(-0.2<x&&x<-0.1){
693 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
695 // else if(-0.1<x&&x<0.1){
696 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
698 // else if(0.1<x&&x<0.2){
699 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
702 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
712 //--------------------------------------------------
713 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP(){
714 Printf("Loading syst unc for D*+ pp 2010, 3<pt(D)<5 GeV/c, pt(assoc)>0.3");
717 fstrptAss="ptAsMore03";
719 if(!fhDeltaPhiTemplate){
720 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
732 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
747 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
748 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
749 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
759 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
760 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
761 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
771 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
772 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
773 fhSecContaminationMax->SetBinContent(j,0.05);
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);
783 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
785 else if(-0.2<x&&x<-0.1){
786 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
788 else if(-0.1<x&&x<0.1){
789 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
791 else if(0.1<x&&x<0.2){
792 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
795 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
804 // if(-0.4<x&&x<-0.2){
805 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
807 // else if(-0.2<x&&x<-0.1){
808 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
810 // else if(-0.2<x&&x<-0.1){
811 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
813 // else if(-0.1<x&&x<0.1){
814 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
816 // else if(0.1<x&&x<0.2){
817 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
820 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
832 // if(-0.4<x&&x<-0.2){
833 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
835 // else if(-0.2<x&&x<-0.1){
836 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
838 // else if(-0.2<x&&x<-0.1){
839 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
841 // else if(-0.1<x&&x<0.1){
842 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
844 // else if(0.1<x&&x<0.2){
845 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
848 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
857 // if(-0.4<x&&x<-0.2){
858 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
860 // else if(-0.2<x&&x<-0.1){
861 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
863 // else if(-0.2<x&&x<-0.1){
864 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
866 // else if(-0.1<x&&x<0.1){
867 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
869 // else if(0.1<x&&x<0.2){
870 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
873 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
881 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss03HP(){
882 Printf("Loading syst unc for D*+ pp 2010, 5<pt(D)<8 GeV/c, pt(assoc)>0.3");
885 fstrptAss="ptAsMore03";
887 if(!fhDeltaPhiTemplate){
888 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
900 fhBackSubtractionMin->SetBinContent(j,-0.05);
903 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
904 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
905 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
914 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
915 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
916 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
925 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
926 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
927 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
937 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
938 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
939 fhSecContaminationMax->SetBinContent(j,0.05);
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);
949 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
951 else if(-0.2<x&&x<-0.1){
952 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
954 else if(-0.1<x&&x<0.1){
955 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
957 else if(0.1<x&&x<0.2){
958 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
961 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
970 // if(-0.4<x&&x<-0.2){
971 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
973 // else if(-0.2<x&&x<-0.1){
974 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
976 // else if(-0.2<x&&x<-0.1){
977 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
979 // else if(-0.1<x&&x<0.1){
980 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
982 // else if(0.1<x&&x<0.2){
983 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
986 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
998 // if(-0.4<x&&x<-0.2){
999 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1001 // else if(-0.2<x&&x<-0.1){
1002 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1004 // else if(-0.2<x&&x<-0.1){
1005 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1007 // else if(-0.1<x&&x<0.1){
1008 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1010 // else if(0.1<x&&x<0.2){
1011 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1013 // if(0.2<x&&x<0.4){
1014 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
1023 // if(-0.4<x&&x<-0.2){
1024 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1026 // else if(-0.2<x&&x<-0.1){
1027 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1029 // else if(-0.2<x&&x<-0.1){
1030 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1032 // else if(-0.1<x&&x<0.1){
1033 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1035 // else if(0.1<x&&x<0.2){
1036 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1038 // if(0.2<x&&x<0.4){
1039 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1048 void 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());
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");
1071 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss03HP(){
1072 Printf("Loading syst unc for D*+ pp 2010, 8<pt(D)<16 GeV/c, pt(assoc)>0.3");
1075 fstrptAss="ptAsMore03";
1077 if(!fhDeltaPhiTemplate){
1078 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
1090 fhBackSubtractionMin->SetBinContent(j,-0.05);
1093 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1094 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
1095 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
1104 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1105 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
1106 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
1114 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1115 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
1116 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
1126 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1127 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
1128 fhSecContaminationMax->SetBinContent(j,0.05);
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);
1138 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1140 else if(-0.2<x&&x<-0.1){
1141 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1143 else if(-0.1<x&&x<0.1){
1144 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
1146 else if(0.1<x&&x<0.2){
1147 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1150 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
1159 // if(-0.4<x&&x<-0.2){
1160 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1162 // else if(-0.2<x&&x<-0.1){
1163 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1165 // else if(-0.2<x&&x<-0.1){
1166 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1168 // else if(-0.1<x&&x<0.1){
1169 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
1171 // else if(0.1<x&&x<0.2){
1172 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1174 // if(0.2<x&&x<0.4){
1175 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
1187 // if(-0.4<x&&x<-0.2){
1188 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1190 // else if(-0.2<x&&x<-0.1){
1191 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1193 // else if(-0.2<x&&x<-0.1){
1194 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1196 // else if(-0.1<x&&x<0.1){
1197 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1199 // else if(0.1<x&&x<0.2){
1200 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1202 // if(0.2<x&&x<0.4){
1203 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
1212 // if(-0.4<x&&x<-0.2){
1213 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1215 // else if(-0.2<x&&x<-0.1){
1216 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1218 // else if(-0.2<x&&x<-0.1){
1219 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1221 // else if(-0.1<x&&x<0.1){
1222 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1224 // else if(0.1<x&&x<0.2){
1225 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1227 // if(0.2<x&&x<0.4){
1228 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1237 void AliHFDhadronCorrSystUnc::SetHistoTemplate(TH1D *h,TString strname,Bool_t clone){
1238 if(fhDeltaPhiTemplate)delete fhDeltaPhiTemplate;
1240 fhDeltaPhiTemplate=h;
1243 if(strname.IsNull()){fhDeltaPhiTemplate=(TH1D*)h->Clone("fhDeltaPhiTemplate");
1245 else fhDeltaPhiTemplate=(TH1D*)h->Clone(strname.Data());
1250 void AliHFDhadronCorrSystUnc::SetHistoYieldExtraction(TH1D *h,TString strname,Bool_t clone){
1251 if(fhYieldExtraction)delete fhYieldExtraction;
1253 fhYieldExtraction=h;
1256 if(strname.IsNull()){fhYieldExtraction=(TH1D*)h->Clone("fhYieldExtraction");
1258 else fhYieldExtraction=(TH1D*)h->Clone(strname.Data());
1262 void AliHFDhadronCorrSystUnc::SetHistoBackSubtraction(TH1D *hMax,TString strname,Bool_t clone,TH1D *hMin){
1264 Printf("No Input Histo for back uncertainty");
1267 if(fhBackSubtractionMax)delete fhBackSubtractionMax;
1269 fhBackSubtractionMax=hMax;
1272 if(strname.IsNull()){fhBackSubtractionMax=(TH1D*)hMax->Clone("fhBackSubtractionMax");
1274 else fhBackSubtractionMax=(TH1D*)hMax->Clone(strname.Data());
1277 if(fhBackSubtractionMin)delete fhBackSubtractionMin;
1280 fhBackSubtractionMin=hMin;
1283 if(strname.IsNull()){fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1285 else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1289 if(strname.IsNull()){
1290 fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
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));
1304 void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMax(TH1D *h,TString strname,Bool_t clone){
1305 if(fhMCclosureTestMax)delete fhMCclosureTestMax;
1307 fhMCclosureTestMax=h;
1310 if(strname.IsNull()){fhMCclosureTestMax=(TH1D*)h->Clone("fhMCclosureTestMax");
1312 else fhMCclosureTestMax=(TH1D*)h->Clone(strname.Data());
1316 void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMin(TH1D *h,TString strname,Bool_t clone){
1317 if(fhMCclosureTestMin)delete fhMCclosureTestMin;
1319 fhMCclosureTestMin=h;
1322 if(strname.IsNull()){fhMCclosureTestMin=(TH1D*)h->Clone("fhMCclosureTestMin");
1324 else fhMCclosureTestMin=(TH1D*)h->Clone(strname.Data());
1329 void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMin(TH1D *h,TString strname,Bool_t clone){
1330 if(fhMCcorrectionsMin)delete fhMCcorrectionsMin;
1332 fhMCcorrectionsMin=h;
1335 if(strname.IsNull()){fhMCcorrectionsMin=(TH1D*)h->Clone("fhMCcorrectionsMin");
1337 else fhMCcorrectionsMin=(TH1D*)h->Clone(strname.Data());
1342 void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMax(TH1D *h,TString strname,Bool_t clone){
1343 if(fhMCcorrectionsMax)delete fhMCcorrectionsMax;
1345 fhMCcorrectionsMax=h;
1348 if(strname.IsNull()){fhMCcorrectionsMax=(TH1D*)h->Clone("fhMCcorrectionsMax");
1350 else fhMCcorrectionsMax=(TH1D*)h->Clone(strname.Data());
1355 void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMin(TH1D *h,TString strname,Bool_t clone){
1356 if(fhMCDefficiencyMin)delete fhMCDefficiencyMin;
1358 fhMCDefficiencyMin=h;
1361 if(strname.IsNull()){fhMCDefficiencyMin=(TH1D*)h->Clone("fhMCDefficiencyMin");
1363 else fhMCDefficiencyMin=(TH1D*)h->Clone(strname.Data());
1368 void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMax(TH1D *h,TString strname,Bool_t clone){
1369 if(fhMCDefficiencyMax)delete fhMCDefficiencyMax;
1371 fhMCDefficiencyMax=h;
1374 if(strname.IsNull()){fhMCDefficiencyMax=(TH1D*)h->Clone("fhMCDefficiencyMax");
1376 else fhMCDefficiencyMax=(TH1D*)h->Clone(strname.Data());
1381 void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMin(TH1D *h,TString strname,Bool_t clone){
1382 if(fhSecContaminationMin)delete fhSecContaminationMin;
1384 fhSecContaminationMin=h;
1387 if(strname.IsNull()){fhSecContaminationMin=(TH1D*)h->Clone("fhSecContaminationMin");
1389 else fhSecContaminationMin=(TH1D*)h->Clone(strname.Data());
1394 void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMax(TH1D *h,TString strname,Bool_t clone){
1395 if(fhSecContaminationMax)delete fhSecContaminationMax;
1397 fhSecContaminationMax=h;
1400 if(strname.IsNull()){fhSecContaminationMax=(TH1D*)h->Clone("fhSecContaminationMax");
1402 else fhSecContaminationMax=(TH1D*)h->Clone(strname.Data());
1407 void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmin(TH1D *h,TString strname,Bool_t clone){
1408 if(fhBeautyFDmin)delete fhBeautyFDmin;
1413 if(strname.IsNull()){fhBeautyFDmin=(TH1D*)h->Clone("fhBeautyFDmin");
1415 else fhBeautyFDmin=(TH1D*)h->Clone(strname.Data());
1420 void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmax(TH1D *h,TString strname,Bool_t clone){
1421 if(fhBeautyFDmax)delete fhBeautyFDmax;
1426 if(strname.IsNull()){fhBeautyFDmax=(TH1D*)h->Clone("fhBeautyFDmax");
1428 else fhBeautyFDmax=(TH1D*)h->Clone(strname.Data());
1436 void AliHFDhadronCorrSystUnc::BuildTotalUncHisto(){
1437 if(fhTotalMin)delete fhTotalMin;
1438 if(fhTotalMax)delete fhTotalMax;
1440 fhTotalMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMin");
1441 fhTotalMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMax");
1442 Double_t errMin,errMax;
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);
1453 fhTotalMin->SetBinContent(j,-TMath::Sqrt(errMin));
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);
1463 fhTotalMax->SetBinContent(j,TMath::Sqrt(errMax));
1468 fhTotalMin->SetLineColor(kBlack);
1469 fhTotalMin->SetLineWidth(2);
1470 fhTotalMin->SetFillStyle(0);
1471 fhTotalMin->SetFillColor(kBlack);
1472 fhTotalMin->SetMarkerColor(kBlack);
1473 fhTotalMin->SetMarkerStyle(20);
1475 fhTotalMax->SetLineColor(kBlack);
1476 fhTotalMax->SetLineWidth(2);
1477 fhTotalMax->SetFillStyle(0);
1478 fhTotalMax->SetFillColor(kBlack);
1479 fhTotalMax->SetMarkerColor(kBlack);
1480 fhTotalMax->SetMarkerStyle(20);
1484 void AliHFDhadronCorrSystUnc::BuildTotalNonFlatUncHisto(){
1485 if(fhTotalNonFlatDPhiMin)delete fhTotalNonFlatDPhiMin;
1486 if(fhTotalNonFlatDPhiMax)delete fhTotalNonFlatDPhiMax;
1488 fhTotalNonFlatDPhiMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMin");
1489 fhTotalNonFlatDPhiMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMax");
1490 Double_t errMin,errMax,mcClosureMinmax,mcClosureMaxmin;
1492 mcClosureMinmax=fhMCclosureTestMin->GetBinContent(fhMCclosureTestMin->GetMaximumBin());
1493 mcClosureMaxmin=fhMCclosureTestMax->GetBinContent(fhMCclosureTestMax->GetMinimumBin());
1494 Printf("MC closure - The max of min is: %f, the min of max is: %f", mcClosureMinmax, mcClosureMaxmin);
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
1499 errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1501 fhTotalNonFlatDPhiMin->SetBinContent(j,-TMath::Sqrt(errMin));
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
1505 errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1507 fhTotalNonFlatDPhiMax->SetBinContent(j,TMath::Sqrt(errMax));
1512 fhtotFlatMin=(TH1D*)fhTotalMin->Clone("hTotFlatDPhiMin");
1513 fhtotFlatMin->SetTitle("#Delta#phi indipendent");
1515 fhtotFlatMax=(TH1D*)fhTotalMax->Clone("hTotFlatDPhiMax");
1516 fhtotFlatMax->SetTitle("#Delta#phi indipendent");
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)));
1523 fhtotFlatMin->SetLineStyle(2);
1524 fhtotFlatMax->SetLineStyle(2);
1529 fhTotalNonFlatDPhiMin->SetLineColor(kBlue);
1530 fhTotalNonFlatDPhiMin->SetLineWidth(2);
1531 fhTotalNonFlatDPhiMin->SetFillStyle(0);
1532 fhTotalNonFlatDPhiMin->SetFillColor(kBlue);
1533 fhTotalNonFlatDPhiMin->SetMarkerColor(kBlue);
1534 fhTotalNonFlatDPhiMin->SetMarkerStyle(20);
1536 fhTotalNonFlatDPhiMax->SetLineColor(kBlue);
1537 fhTotalNonFlatDPhiMax->SetLineWidth(2);
1538 fhTotalNonFlatDPhiMax->SetFillStyle(0);
1539 fhTotalNonFlatDPhiMax->SetFillColor(kBlue);
1540 fhTotalNonFlatDPhiMax->SetMarkerColor(kBlue);
1541 fhTotalNonFlatDPhiMax->SetMarkerStyle(20);
1546 void AliHFDhadronCorrSystUnc::BuildTotalNonFDUncHisto(){
1547 if(fhTotalNonFDMin)delete fhTotalNonFDMin;
1548 if(fhTotalNonFDMax)delete fhTotalNonFDMax;
1550 fhTotalNonFDMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMin");
1551 fhTotalNonFDMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMax");
1552 Double_t errMin,errMax;
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);
1562 fhTotalNonFDMin->SetBinContent(j,-TMath::Sqrt(errMin));
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);
1571 fhTotalNonFDMax->SetBinContent(j,TMath::Sqrt(errMax));
1579 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010(Int_t meson,Double_t ptD,Double_t minptAss){
1584 if(TMath::Abs(minptAss-0.3)<0.0001){
1586 InitStandardUncertaintiesPP2010DzeroLowPtAss03HP();
1588 else if(ptD>5&&ptD<8){
1589 InitStandardUncertaintiesPP2010DzeroMidPtAss03HP();
1591 else if(ptD>8&&ptD<16){
1592 InitStandardUncertaintiesPP2010DzeroHighPtAss03HP();
1595 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1599 else if(TMath::Abs(minptAss-0.5)<0.0001){
1601 InitStandardUncertaintiesPP2010DzeroLowPtAss05();
1603 else if(ptD>5&&ptD<8){
1604 InitStandardUncertaintiesPP2010DzeroMidPtAss05();
1606 else if(ptD>8&&ptD<16){
1607 InitStandardUncertaintiesPP2010DzeroHighPtAss05();
1610 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1614 else if(TMath::Abs(minptAss-1.)<0.0001){
1616 InitStandardUncertaintiesPP2010DzeroLowPtAss1();
1618 else if(ptD>5&&ptD<8){
1619 InitStandardUncertaintiesPP2010DzeroMidPtAss1();
1622 else if(ptD>8&&ptD<16){
1623 InitStandardUncertaintiesPP2010DzeroHighPtAss1();
1626 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1630 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1635 if(TMath::Abs(minptAss-0.3)<0.0001){
1637 InitStandardUncertaintiesPP2010DstarLowPtAss03HP();
1639 else if(ptD>5&&ptD<8){
1640 InitStandardUncertaintiesPP2010DstarMidPtAss03HP();
1642 else if(ptD>8&&ptD<16){
1643 InitStandardUncertaintiesPP2010DstarHighPtAss03HP();
1646 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1650 else if(TMath::Abs(minptAss-0.5)<0.0001){
1652 InitStandardUncertaintiesPP2010DstarLowPtAss05();
1654 else if(ptD>5&&ptD<8){
1655 InitStandardUncertaintiesPP2010DstarMidPtAss05();
1657 else if(ptD>8&&ptD<16){
1658 InitStandardUncertaintiesPP2010DstarHighPtAss05();
1661 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1666 else if(TMath::Abs(minptAss-1.)<0.0001){
1668 InitStandardUncertaintiesPP2010DstarLowPtAss1();
1670 else if(ptD>5&&ptD<8){
1671 InitStandardUncertaintiesPP2010DstarMidPtAss1();
1673 else if(ptD>8&&ptD<16){
1674 InitStandardUncertaintiesPP2010DstarHighPtAss1();
1677 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1681 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1686 if(TMath::Abs(minptAss-0.3)<0.0001){
1688 InitStandardUncertaintiesPP2010DplusLowPtAss03();
1690 else if(ptD>5&&ptD<8){
1691 InitStandardUncertaintiesPP2010DplusMidPtAss03();
1693 else if(ptD>8&&ptD<16){
1694 InitStandardUncertaintiesPP2010DplusHighPtAss03();
1697 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1701 else if(TMath::Abs(minptAss-0.5)<0.0001){
1703 InitStandardUncertaintiesPP2010DplusLowPtAss05();
1705 else if(ptD>5&&ptD<8){
1706 InitStandardUncertaintiesPP2010DplusMidPtAss05();
1708 else if(ptD>8&&ptD<16){
1709 InitStandardUncertaintiesPP2010DplusHighPtAss05();
1712 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1716 else if(TMath::Abs(minptAss-1.)<0.0001){
1718 InitStandardUncertaintiesPP2010DplusLowPtAss1();
1720 else if(ptD>5&&ptD<8){
1721 InitStandardUncertaintiesPP2010DplusMidPtAss1();
1723 else if(ptD>8&&ptD<16){
1724 InitStandardUncertaintiesPP2010DplusHighPtAss1();
1727 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1731 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1735 printf("PP:No meson is found Check your input \n");
1739 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013(Int_t meson,Double_t ptD,Double_t minptAss){
1743 if(TMath::Abs(minptAss-0.3)<0.0001){
1745 InitStandardUncertaintiesPPb2013DzeroLowPtAss03();
1747 else if(ptD>5&&ptD<8){
1748 InitStandardUncertaintiesPPb2013DzeroMidPtAss03();
1750 else if(ptD>8&&ptD<16){
1751 InitStandardUncertaintiesPPb2013DzeroHighPtAss03();
1755 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1759 else if(TMath::Abs(minptAss-0.5)<0.0001){
1761 InitStandardUncertaintiesPPb2013DzeroLowPtAss05();
1763 else if(ptD>5&&ptD<8){
1764 InitStandardUncertaintiesPPb2013DzeroMidPtAss05();
1766 else if(ptD>8&&ptD<16){
1767 InitStandardUncertaintiesPPb2013DzeroHighPtAss05();
1771 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1776 else if(TMath::Abs(minptAss-1.)<0.0001){
1778 InitStandardUncertaintiesPPb2013DzeroLowPtAss1();
1780 else if(ptD>5&&ptD<8){
1781 InitStandardUncertaintiesPPb2013DzeroMidPtAss1();
1783 else if(ptD>8&&ptD<16){
1784 InitStandardUncertaintiesPPb2013DzeroHighPtAss1();
1787 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1791 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1796 if(TMath::Abs(minptAss-0.3)<0.0001){
1798 InitStandardUncertaintiesPPb2013DstarLowPtAss03();
1800 else if(ptD>5&&ptD<8){
1801 InitStandardUncertaintiesPPb2013DstarMidPtAss03();
1803 else if(ptD>8&&ptD<16){
1804 InitStandardUncertaintiesPPb2013DstarHighPtAss03();
1807 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1811 else if(TMath::Abs(minptAss-0.5)<0.0001){
1813 InitStandardUncertaintiesPPb2013DstarLowPtAss05();
1815 else if(ptD>5&&ptD<8){
1816 InitStandardUncertaintiesPPb2013DstarMidPtAss05();
1818 else if(ptD>8&&ptD<16){
1819 InitStandardUncertaintiesPPb2013DstarHighPtAss05();
1822 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1826 else if(TMath::Abs(minptAss-1.)<0.0001){
1828 InitStandardUncertaintiesPPb2013DstarLowPtAss1();
1830 else if(ptD>5&&ptD<8){
1831 InitStandardUncertaintiesPPb2013DstarMidPtAss1();
1833 else if(ptD>8&&ptD<16){
1834 InitStandardUncertaintiesPPb2013DstarHighPtAss1();
1837 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1841 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1846 if(TMath::Abs(minptAss-0.3)<0.0001){
1848 InitStandardUncertaintiesPPb2013DplusLowPtAss03();
1850 else if(ptD>5&&ptD<8){
1851 InitStandardUncertaintiesPPb2013DplusMidPtAss03();
1853 else if(ptD>8&&ptD<16){
1854 InitStandardUncertaintiesPPb2013DplusHighPtAss03();
1857 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1861 else if(TMath::Abs(minptAss-0.5)<0.0001){
1863 InitStandardUncertaintiesPPb2013DplusLowPtAss05();
1865 else if(ptD>5&&ptD<8){
1866 InitStandardUncertaintiesPPb2013DplusMidPtAss05();
1868 else if(ptD>8&&ptD<16){
1869 InitStandardUncertaintiesPPb2013DplusHighPtAss05();
1872 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1876 else if(TMath::Abs(minptAss-1.)<0.0001){
1878 InitStandardUncertaintiesPPb2013DplusLowPtAss1();
1880 else if(ptD>5&&ptD<8){
1881 InitStandardUncertaintiesPPb2013DplusMidPtAss1();
1883 else if(ptD>8&&ptD<16){
1884 InitStandardUncertaintiesPPb2013DplusHighPtAss1();
1887 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1891 printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1895 printf("pPb-No meson is found Check your input \n");
1900 TGraphAsymmErrors* AliHFDhadronCorrSystUnc::GetUncGraphFromHistos(TH1D *hRef,TH1D *hMin,TH1D *hMax){
1902 // Int_t npoints=hMin->GetNbinsX();
1903 Double_t ew=hMin->GetBinWidth(1)/2.;
1904 Double_t value,eyl,eym;
1906 TGraphAsymmErrors *gr=new TGraphAsymmErrors();
1907 for(Int_t j=1;j<=hMin->GetNbinsX();j++){
1909 value=hRef->GetBinContent(j);
1910 eyl=hMin->GetBinContent(j)*value;
1912 if(hMax)eym=hMax->GetBinContent(j)*value;
1917 eyl=hMin->GetBinContent(j);
1919 if(hMax)eym=hMax->GetBinContent(j);
1923 gr->SetPoint(j-1,hMin->GetBinCenter(j),value);
1924 gr->SetPointError(j-1,ew,ew,eyl,eym);
1930 void 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;
1939 fgrYieldUncRel=GetUncGraphFromHistos(0x0,fhYieldExtraction,0x0);
1940 fgrYieldUncRel->SetName("fgrYieldUncRel");
1941 fgrYieldUncRel->SetTitle("D meson yield");
1944 fgrBackSubUncRel=GetUncGraphFromHistos(0x0,fhBackSubtractionMin,fhBackSubtractionMax);
1945 fgrBackSubUncRel->SetName("fgrBackSubUncRel");
1946 fgrBackSubUncRel->SetTitle("Background D correlation subtraction");
1950 fgrMCcorrectionsRel=GetUncGraphFromHistos(0x0,fhMCcorrectionsMin,fhMCcorrectionsMax);
1951 fgrMCcorrectionsRel->SetName("fgrMCcorrectionsRel");
1952 fgrMCcorrectionsRel->SetTitle("Associated track efficiency");
1954 fgrMCDefficiencyRel=GetUncGraphFromHistos(0x0,fhMCDefficiencyMin,fhMCDefficiencyMax);
1955 fgrMCDefficiencyRel->SetName("fgrMCDefficiencyRel");
1956 fgrMCDefficiencyRel->SetTitle("D meson efficiency");
1958 fgrSecContaminationRel=GetUncGraphFromHistos(0x0,fhSecContaminationMin,fhSecContaminationMax);
1959 fgrSecContaminationRel->SetName("fgrSecContaminationRel");
1960 fgrSecContaminationRel->SetTitle("Secondary contamination");
1962 fgrMCclosureTestRel=GetUncGraphFromHistos(0x0,fhMCclosureTestMin,fhMCclosureTestMax);
1963 fgrMCclosureTestRel->SetName("fgrMCclosureTestRel");
1964 fgrMCclosureTestRel->SetTitle("MC closure test");
1966 fgrBeautyFDRel=GetUncGraphFromHistos(0x0,fhBeautyFDmin,fhBeautyFDmax);
1967 fgrBeautyFDRel->SetName("fgrBeautyFDRel");
1968 fgrBeautyFDRel->SetTitle("Feed-down");
1970 fgrYieldUncRel->SetLineColor(kBlue);
1971 fgrYieldUncRel->SetLineWidth(2);
1972 fgrYieldUncRel->SetFillStyle(3002);
1973 fgrYieldUncRel->SetFillColor(kBlue);
1974 fgrYieldUncRel->SetMarkerColor(kBlue);
1975 fgrYieldUncRel->SetMarkerStyle(20);
1978 fgrBackSubUncRel->SetLineColor(kMagenta);
1979 fgrBackSubUncRel->SetLineWidth(2);
1980 fgrBackSubUncRel->SetFillStyle(3008);
1981 fgrBackSubUncRel->SetFillColor(kMagenta);
1982 fgrBackSubUncRel->SetMarkerColor(kBlue);
1983 fgrBackSubUncRel->SetMarkerStyle(20);
1986 fgrMCcorrectionsRel->SetLineColor(kGreen);
1987 fgrMCcorrectionsRel->SetLineWidth(2);
1988 fgrMCcorrectionsRel->SetFillStyle(3006);
1989 fgrMCcorrectionsRel->SetFillColor(kGreen);
1990 fgrMCcorrectionsRel->SetMarkerColor(kGreen);
1991 fgrMCcorrectionsRel->SetMarkerStyle(22);
1993 fgrMCDefficiencyRel->SetLineColor(kCyan);
1994 fgrMCDefficiencyRel->SetLineWidth(2);
1995 fgrMCDefficiencyRel->SetFillStyle(3004);
1996 fgrMCDefficiencyRel->SetFillColor(kCyan);
1997 fgrMCDefficiencyRel->SetMarkerColor(kCyan);
1998 fgrMCDefficiencyRel->SetMarkerStyle(22);
2000 fgrSecContaminationRel->SetLineColor(kOrange);
2001 fgrSecContaminationRel->SetLineWidth(2);
2002 fgrSecContaminationRel->SetFillStyle(3007);
2003 fgrSecContaminationRel->SetFillColor(kOrange);
2004 fgrSecContaminationRel->SetMarkerColor(kOrange);
2005 fgrSecContaminationRel->SetMarkerStyle(22);
2007 fgrMCclosureTestRel->SetLineColor(kRed);
2008 fgrMCclosureTestRel->SetLineWidth(2);
2009 fgrMCclosureTestRel->SetFillStyle(3005);
2010 fgrMCclosureTestRel->SetFillColor(kRed);
2011 fgrMCclosureTestRel->SetMarkerColor(kRed);
2012 fgrMCclosureTestRel->SetMarkerStyle(26);
2014 fgrBeautyFDRel->SetLineColor(kViolet);
2015 fgrBeautyFDRel->SetLineWidth(2);
2016 fgrBeautyFDRel->SetFillStyle(3021);
2017 fgrBeautyFDRel->SetFillColor(kViolet);
2018 fgrBeautyFDRel->SetMarkerColor(kViolet);
2019 fgrBeautyFDRel->SetMarkerStyle(28);
2026 void AliHFDhadronCorrSystUnc::BuildGraphsUnc(TH1D *hRef){
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;
2042 fgrYieldUnc=GetUncGraphFromHistos(hRef,fhYieldExtraction,0x0);
2043 fgrYieldUnc->SetName("fgrYieldUnc");
2044 fgrYieldUnc->SetTitle("D meson yield");
2046 fgrBackSubUnc=GetUncGraphFromHistos(hRef,fhBackSubtractionMin,fhBackSubtractionMax);
2047 fgrBackSubUnc->SetName("fgrBackSubUnc");
2048 fgrBackSubUnc->SetTitle("Background D correlation subtraction");
2051 fgrMCcorrections=GetUncGraphFromHistos(hRef,fhMCcorrectionsMin,fhMCcorrectionsMax);
2052 fgrMCcorrections->SetName("fgrMCcorrections");
2053 fgrMCcorrections->SetTitle("Associated track efficiency");
2055 fgrMCDefficiency=GetUncGraphFromHistos(hRef,fhMCDefficiencyMin,fhMCDefficiencyMax);
2056 fgrMCDefficiency->SetName("fgrMCDefficiency");
2057 fgrMCDefficiency->SetTitle("D meson efficiency");
2059 fgrSecContamination=GetUncGraphFromHistos(hRef,fhSecContaminationMin,fhSecContaminationMax);
2060 fgrSecContamination->SetName("fgrSecContamination");
2061 fgrSecContamination->SetTitle("Secondary contamination");
2063 fgrMCclosureTest=GetUncGraphFromHistos(hRef,fhMCclosureTestMin,fhMCclosureTestMax);
2064 fgrMCclosureTest->SetName("fgrMCclosureTest");
2065 fgrMCclosureTest->SetTitle("MC closure test");
2067 fgrBeautyFD=GetUncGraphFromHistos(hRef,fhBeautyFDmin,fhBeautyFDmax);
2068 fgrBeautyFD->SetName("fgrBeautyFD");
2069 fgrBeautyFD->SetTitle("Feed-down");
2071 fgrYieldUnc->SetLineColor(kBlue);
2072 fgrYieldUnc->SetLineWidth(2);
2073 fgrYieldUnc->SetFillStyle(0);
2074 fgrYieldUnc->SetFillColor(kBlue);
2075 fgrYieldUnc->SetMarkerColor(kBlue);
2076 fgrYieldUnc->SetMarkerStyle(20);
2079 fgrBackSubUnc->SetLineColor(kMagenta);
2080 fgrBackSubUnc->SetLineWidth(2);
2081 fgrBackSubUnc->SetFillStyle(0);
2082 fgrBackSubUnc->SetFillColor(kMagenta);
2083 fgrBackSubUnc->SetMarkerColor(kBlue);
2084 fgrBackSubUnc->SetMarkerStyle(20);
2087 fgrMCcorrections->SetLineColor(kGreen);
2088 fgrMCcorrections->SetLineWidth(2);
2089 fgrMCcorrections->SetFillStyle(0);
2090 fgrMCcorrections->SetFillColor(kGreen);
2091 fgrMCcorrections->SetMarkerColor(kGreen);
2092 fgrMCcorrections->SetMarkerStyle(22);
2094 fgrMCDefficiency->SetLineColor(kCyan);
2095 fgrMCDefficiency->SetLineWidth(2);
2096 fgrMCDefficiency->SetFillStyle(0);
2097 fgrMCDefficiency->SetFillColor(kCyan);
2098 fgrMCDefficiency->SetMarkerColor(kCyan);
2099 fgrMCDefficiency->SetMarkerStyle(22);
2101 fgrSecContamination->SetLineColor(kOrange);
2102 fgrSecContamination->SetLineWidth(2);
2103 fgrSecContamination->SetFillStyle(0);
2104 fgrSecContamination->SetFillColor(kOrange);
2105 fgrSecContamination->SetMarkerColor(kOrange);
2106 fgrSecContamination->SetMarkerStyle(22);
2108 fgrMCclosureTest->SetLineColor(kRed);
2109 fgrMCclosureTest->SetLineWidth(2);
2110 fgrMCclosureTest->SetFillStyle(0);
2111 fgrMCclosureTest->SetFillColor(kRed);
2112 fgrMCclosureTest->SetMarkerColor(kRed);
2113 fgrMCclosureTest->SetMarkerStyle(26);
2115 fgrBeautyFD->SetLineColor(kViolet);
2116 fgrBeautyFD->SetLineWidth(2);
2117 fgrBeautyFD->SetFillStyle(0);
2118 fgrBeautyFD->SetFillColor(kViolet);
2119 fgrBeautyFD->SetMarkerColor(kViolet);
2120 fgrBeautyFD->SetMarkerStyle(28);
2122 // fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
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);
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);
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);
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);
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);
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);
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);
2188 TCanvas* AliHFDhadronCorrSystUnc::BuildSystUncertaintyPlotVsDeltaPhi(TH1D *hCorrPlot,Int_t doInit){
2191 BuildTotalUncHisto();
2192 BuildTotalNonFDUncHisto();
2193 BuildTotalNonFlatUncHisto();
2194 BuildGraphsUnc(hCorrPlot);
2195 BuildGraphsRelUnc();
2199 // Easy canva with relative uncertainties
2200 TCanvas *cCanvaRelUnc=new TCanvas("cCanvaRelUnc","cCanvaRelUnc",700,700);
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");
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");
2217 fhtotFlatMin->Draw("same");
2218 fhtotFlatMax->Draw("same");
2220 fhTotalMin->Draw("same");
2221 fhTotalMax->Draw("same");
2223 TCanvas *cCanvaFinalPlot=new TCanvas("cCanvaFinalPlot","cCanvaFinalPlot",700,700);
2224 cCanvaFinalPlot->cd();
2226 // fgrYieldUnc->Draw("pE2");
2227 // fgrBackSubUnc->Draw("pE2");
2228 // fgrMCcorrections->Draw("pE2");
2229 // fgrMCclosureTest->Draw("pE2");
2230 // fgrBeautyFD->Draw("pE2");
2231 fgrTotal->Draw("E2");
2234 TCanvas *cCanvaFinalPlotFD=new TCanvas("cCanvaFinalPlotFD","cCanvaFinalPlotFD",700,700);
2235 cCanvaFinalPlotFD->cd();
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");
2247 return cCanvaFinalPlot;
2251 TH1D* AliHFDhadronCorrSystUnc::GetVariedHisto(const TH1D *hIn,const TGraphAsymmErrors *gr,Int_t minmax){
2255 hOut=(TH1D*)hIn->Clone(Form("%sVariedMin",hIn->GetName()));
2258 hOut=(TH1D*)hIn->Clone(Form("%sVariedMax",hIn->GetName()));
2260 // Int_t np=gr->GetN();
2261 Double_t *x,*y,*ely,*ehy;//*elx,*ehx,
2264 // elx=gr->GetEXlow();
2265 // ehx=gr->GetEXhigh();
2267 ehy=gr->GetEYhigh();
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");
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");
2279 hOut->SetBinContent(jp,y[jp-1]-ely[jp-1]);
2282 hOut->SetBinContent(jp,y[jp-1]+ehy[jp-1]);
2284 hOut->SetBinError(jp,hIn->GetBinError(jp));
2292 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2294 ///// METHODS WITH UNCERTAINTIES: PP 2010, for kinematic cases approved after HP2013
2296 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2299 // START FROM DPLUS FOR PT(ASSOC)>0.3
2300 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2303 fstrptAss="ptAsMore03";
2305 if(!fhDeltaPhiTemplate){
2306 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
2321 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2322 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2323 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
2334 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2335 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2336 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
2345 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2346 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2347 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
2357 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2358 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2359 fhSecContaminationMax->SetBinContent(j,0.05);
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);
2367 fhMCclosureTestMin->SetBinContent(j,-0.0);
2370 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2372 else if(-0.2<x&&x<-0.1){
2373 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2375 else if(-0.1<x&&x<0.1){
2376 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2378 else if(0.1<x&&x<0.2){
2379 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2382 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
2391 // if(-0.4<x&&x<-0.2){
2392 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2394 // else if(-0.2<x&&x<-0.1){
2395 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2397 // else if(-0.2<x&&x<-0.1){
2398 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2400 // else if(-0.1<x&&x<0.1){
2401 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2403 // else if(0.1<x&&x<0.2){
2404 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2406 // if(0.2<x&&x<0.4){
2407 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
2419 // if(-0.4<x&&x<-0.2){
2420 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2422 // else if(-0.2<x&&x<-0.1){
2423 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2425 // else if(-0.2<x&&x<-0.1){
2426 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2428 // else if(-0.1<x&&x<0.1){
2429 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2431 // else if(0.1<x&&x<0.2){
2432 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2434 // if(0.2<x&&x<0.4){
2435 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
2444 // if(-0.4<x&&x<-0.2){
2445 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2447 // else if(-0.2<x&&x<-0.1){
2448 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2450 // else if(-0.2<x&&x<-0.1){
2451 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2453 // else if(-0.1<x&&x<0.1){
2454 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2456 // else if(0.1<x&&x<0.2){
2457 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2459 // if(0.2<x&&x<0.4){
2460 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2467 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2471 fstrptAss="ptAsMore03";
2473 if(!fhDeltaPhiTemplate){
2474 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
2486 fhBackSubtractionMin->SetBinContent(j,-0.05);
2489 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2490 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2491 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
2500 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2501 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2502 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
2512 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2513 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2514 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
2524 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2525 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2526 fhSecContaminationMax->SetBinContent(j,0.05);
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);
2533 fhMCclosureTestMin->SetBinContent(j,-0.0);
2536 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2538 else if(-0.2<x&&x<-0.1){
2539 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2541 else if(-0.1<x&&x<0.1){
2542 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2544 else if(0.1<x&&x<0.2){
2545 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2548 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
2557 // if(-0.4<x&&x<-0.2){
2558 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2560 // else if(-0.2<x&&x<-0.1){
2561 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2563 // else if(-0.2<x&&x<-0.1){
2564 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2566 // else if(-0.1<x&&x<0.1){
2567 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2569 // else if(0.1<x&&x<0.2){
2570 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2572 // if(0.2<x&&x<0.4){
2573 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
2585 // if(-0.4<x&&x<-0.2){
2586 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2588 // else if(-0.2<x&&x<-0.1){
2589 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2591 // else if(-0.2<x&&x<-0.1){
2592 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2594 // else if(-0.1<x&&x<0.1){
2595 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2597 // else if(0.1<x&&x<0.2){
2598 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2600 // if(0.2<x&&x<0.4){
2601 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
2610 // if(-0.4<x&&x<-0.2){
2611 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2613 // else if(-0.2<x&&x<-0.1){
2614 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2616 // else if(-0.2<x&&x<-0.1){
2617 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2619 // else if(-0.1<x&&x<0.1){
2620 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2622 // else if(0.1<x&&x<0.2){
2623 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2625 // if(0.2<x&&x<0.4){
2626 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2634 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2638 fstrptAss="ptAsMore03";
2640 if(!fhDeltaPhiTemplate){
2641 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
2654 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
2669 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2670 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2671 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
2681 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2682 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2683 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
2693 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2694 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2695 fhSecContaminationMax->SetBinContent(j,0.05);
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);
2702 fhMCclosureTestMin->SetBinContent(j,-0.0);
2705 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2707 else if(-0.2<x&&x<-0.1){
2708 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2710 else if(-0.1<x&&x<0.1){
2711 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2713 else if(0.1<x&&x<0.2){
2714 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2717 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
2726 // if(-0.4<x&&x<-0.2){
2727 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2729 // else if(-0.2<x&&x<-0.1){
2730 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2732 // else if(-0.2<x&&x<-0.1){
2733 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2735 // else if(-0.1<x&&x<0.1){
2736 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2738 // else if(0.1<x&&x<0.2){
2739 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2741 // if(0.2<x&&x<0.4){
2742 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
2754 // if(-0.4<x&&x<-0.2){
2755 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2757 // else if(-0.2<x&&x<-0.1){
2758 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2760 // else if(-0.2<x&&x<-0.1){
2761 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2763 // else if(-0.1<x&&x<0.1){
2764 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2766 // else if(0.1<x&&x<0.2){
2767 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2769 // if(0.2<x&&x<0.4){
2770 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
2779 // if(-0.4<x&&x<-0.2){
2780 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2782 // else if(-0.2<x&&x<-0.1){
2783 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2785 // else if(-0.2<x&&x<-0.1){
2786 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2788 // else if(-0.1<x&&x<0.1){
2789 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2791 // else if(0.1<x&&x<0.2){
2792 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2794 // if(0.2<x&&x<0.4){
2795 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2804 //////// HIGHER PT ASS THRESHOLDS
2806 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){
2807 Printf("Setting syst for D0 pp 2010 3-5 0.5 thr");
2810 fstrptAss="ptAsMore05";
2812 if(!fhDeltaPhiTemplate){
2813 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
2828 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2829 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2830 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
2841 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2842 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2843 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
2852 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2853 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2854 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
2864 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2865 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2866 fhSecContaminationMax->SetBinContent(j,0.05);
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);
2874 fhMCclosureTestMin->SetBinContent(j,-0.);
2877 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2879 else if(-0.2<x&&x<-0.1){
2880 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2882 else if(-0.1<x&&x<0.1){
2883 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2885 else if(0.1<x&&x<0.2){
2886 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2889 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
2898 // if(-0.4<x&&x<-0.2){
2899 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2901 // else if(-0.2<x&&x<-0.1){
2902 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2904 // else if(-0.2<x&&x<-0.1){
2905 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2907 // else if(-0.1<x&&x<0.1){
2908 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2910 // else if(0.1<x&&x<0.2){
2911 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2913 // if(0.2<x&&x<0.4){
2914 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
2926 // if(-0.4<x&&x<-0.2){
2927 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2929 // else if(-0.2<x&&x<-0.1){
2930 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2932 // else if(-0.2<x&&x<-0.1){
2933 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2935 // else if(-0.1<x&&x<0.1){
2936 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2938 // else if(0.1<x&&x<0.2){
2939 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2941 // if(0.2<x&&x<0.4){
2942 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
2951 // if(-0.4<x&&x<-0.2){
2952 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2954 // else if(-0.2<x&&x<-0.1){
2955 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2957 // else if(-0.2<x&&x<-0.1){
2958 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2960 // else if(-0.1<x&&x<0.1){
2961 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2963 // else if(0.1<x&&x<0.2){
2964 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2966 // if(0.2<x&&x<0.4){
2967 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2974 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
2975 Printf("Setting syst for D0 pp 2010 5-8 0.5 thr");
2979 fstrptAss="ptAsMore05";
2981 if(!fhDeltaPhiTemplate){
2982 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
2994 fhBackSubtractionMin->SetBinContent(j,-0.05);
2997 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2998 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2999 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
3008 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3009 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3010 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
3020 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3021 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3022 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
3032 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3033 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3034 fhSecContaminationMax->SetBinContent(j,0.05);
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);
3041 fhMCclosureTestMin->SetBinContent(j,-0.);
3044 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3046 else if(-0.2<x&&x<-0.1){
3047 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3049 else if(-0.1<x&&x<0.1){
3050 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3052 else if(0.1<x&&x<0.2){
3053 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3056 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
3065 // if(-0.4<x&&x<-0.2){
3066 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3068 // else if(-0.2<x&&x<-0.1){
3069 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3071 // else if(-0.2<x&&x<-0.1){
3072 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3074 // else if(-0.1<x&&x<0.1){
3075 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3077 // else if(0.1<x&&x<0.2){
3078 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3080 // if(0.2<x&&x<0.4){
3081 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
3093 // if(-0.4<x&&x<-0.2){
3094 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3096 // else if(-0.2<x&&x<-0.1){
3097 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3099 // else if(-0.2<x&&x<-0.1){
3100 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3102 // else if(-0.1<x&&x<0.1){
3103 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3105 // else if(0.1<x&&x<0.2){
3106 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3108 // if(0.2<x&&x<0.4){
3109 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
3118 // if(-0.4<x&&x<-0.2){
3119 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3121 // else if(-0.2<x&&x<-0.1){
3122 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3124 // else if(-0.2<x&&x<-0.1){
3125 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3127 // else if(-0.1<x&&x<0.1){
3128 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3130 // else if(0.1<x&&x<0.2){
3131 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3133 // if(0.2<x&&x<0.4){
3134 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3142 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
3143 Printf("Setting syst for D0 pp 2010 8-16 0.5 thr");
3147 fstrptAss="ptAsMore05";
3149 if(!fhDeltaPhiTemplate){
3150 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
3163 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
3178 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3179 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3180 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
3190 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3191 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3192 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
3202 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3203 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3204 fhSecContaminationMax->SetBinContent(j,0.05);
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);
3211 fhMCclosureTestMin->SetBinContent(j,-0.);
3214 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3216 else if(-0.2<x&&x<-0.1){
3217 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3219 else if(-0.1<x&&x<0.1){
3220 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3222 else if(0.1<x&&x<0.2){
3223 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3226 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
3235 // if(-0.4<x&&x<-0.2){
3236 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3238 // else if(-0.2<x&&x<-0.1){
3239 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3241 // else if(-0.2<x&&x<-0.1){
3242 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3244 // else if(-0.1<x&&x<0.1){
3245 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3247 // else if(0.1<x&&x<0.2){
3248 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3250 // if(0.2<x&&x<0.4){
3251 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
3263 // if(-0.4<x&&x<-0.2){
3264 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3266 // else if(-0.2<x&&x<-0.1){
3267 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3269 // else if(-0.2<x&&x<-0.1){
3270 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3272 // else if(-0.1<x&&x<0.1){
3273 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3275 // else if(0.1<x&&x<0.2){
3276 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3278 // if(0.2<x&&x<0.4){
3279 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
3288 // if(-0.4<x&&x<-0.2){
3289 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3291 // else if(-0.2<x&&x<-0.1){
3292 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3294 // else if(-0.2<x&&x<-0.1){
3295 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3297 // else if(-0.1<x&&x<0.1){
3298 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3300 // else if(0.1<x&&x<0.2){
3301 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3303 // if(0.2<x&&x<0.4){
3304 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3314 //--------------------------------------------------
3315 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){
3316 Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3319 fstrptAss="ptAsMore05";
3321 if(!fhDeltaPhiTemplate){
3322 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
3334 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
3349 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3350 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3351 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
3361 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3362 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3363 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
3373 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3374 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3375 fhSecContaminationMax->SetBinContent(j,0.05);
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);
3385 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3387 else if(-0.2<x&&x<-0.1){
3388 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3390 else if(-0.1<x&&x<0.1){
3391 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3393 else if(0.1<x&&x<0.2){
3394 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3397 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
3406 // if(-0.4<x&&x<-0.2){
3407 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3409 // else if(-0.2<x&&x<-0.1){
3410 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3412 // else if(-0.2<x&&x<-0.1){
3413 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3415 // else if(-0.1<x&&x<0.1){
3416 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3418 // else if(0.1<x&&x<0.2){
3419 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3421 // if(0.2<x&&x<0.4){
3422 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
3434 // if(-0.4<x&&x<-0.2){
3435 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3437 // else if(-0.2<x&&x<-0.1){
3438 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3440 // else if(-0.2<x&&x<-0.1){
3441 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3443 // else if(-0.1<x&&x<0.1){
3444 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3446 // else if(0.1<x&&x<0.2){
3447 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3449 // if(0.2<x&&x<0.4){
3450 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
3459 // if(-0.4<x&&x<-0.2){
3460 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3462 // else if(-0.2<x&&x<-0.1){
3463 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3465 // else if(-0.2<x&&x<-0.1){
3466 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3468 // else if(-0.1<x&&x<0.1){
3469 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3471 // else if(0.1<x&&x<0.2){
3472 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3474 // if(0.2<x&&x<0.4){
3475 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3483 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
3484 Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3487 fstrptAss="ptAsMore05";
3489 if(!fhDeltaPhiTemplate){
3490 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
3502 fhBackSubtractionMin->SetBinContent(j,-0.05);
3505 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3506 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3507 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
3516 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3517 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3518 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
3527 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3528 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3529 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
3539 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3540 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3541 fhSecContaminationMax->SetBinContent(j,0.05);
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);
3548 fhMCclosureTestMin->SetBinContent(j,-0.0);
3551 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3553 else if(-0.2<x&&x<-0.1){
3554 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3556 else if(-0.1<x&&x<0.1){
3557 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3559 else if(0.1<x&&x<0.2){
3560 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3563 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
3572 // if(-0.4<x&&x<-0.2){
3573 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3575 // else if(-0.2<x&&x<-0.1){
3576 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3578 // else if(-0.2<x&&x<-0.1){
3579 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3581 // else if(-0.1<x&&x<0.1){
3582 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3584 // else if(0.1<x&&x<0.2){
3585 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3587 // if(0.2<x&&x<0.4){
3588 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
3600 // if(-0.4<x&&x<-0.2){
3601 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3603 // else if(-0.2<x&&x<-0.1){
3604 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3606 // else if(-0.2<x&&x<-0.1){
3607 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3609 // else if(-0.1<x&&x<0.1){
3610 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3612 // else if(0.1<x&&x<0.2){
3613 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3615 // if(0.2<x&&x<0.4){
3616 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
3625 // if(-0.4<x&&x<-0.2){
3626 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3628 // else if(-0.2<x&&x<-0.1){
3629 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3631 // else if(-0.2<x&&x<-0.1){
3632 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3634 // else if(-0.1<x&&x<0.1){
3635 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3637 // else if(0.1<x&&x<0.2){
3638 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3640 // if(0.2<x&&x<0.4){
3641 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3650 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
3651 Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
3654 fstrptAss="ptAsMore05";
3656 if(!fhDeltaPhiTemplate){
3657 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
3669 fhBackSubtractionMin->SetBinContent(j,-0.12);
3671 // check those values
3672 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3673 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3674 fhBackSubtractionMax->SetBinContent(j,0.12); // check this one in particular
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);
3683 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3684 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3685 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
3693 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3694 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3695 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
3705 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3706 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3707 fhSecContaminationMax->SetBinContent(j,0.05);
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);
3714 fhMCclosureTestMin->SetBinContent(j,-0);
3717 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3719 else if(-0.2<x&&x<-0.1){
3720 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3722 else if(-0.1<x&&x<0.1){
3723 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3725 else if(0.1<x&&x<0.2){
3726 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3729 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
3738 // if(-0.4<x&&x<-0.2){
3739 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3741 // else if(-0.2<x&&x<-0.1){
3742 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3744 // else if(-0.2<x&&x<-0.1){
3745 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3747 // else if(-0.1<x&&x<0.1){
3748 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3750 // else if(0.1<x&&x<0.2){
3751 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3753 // if(0.2<x&&x<0.4){
3754 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
3766 // if(-0.4<x&&x<-0.2){
3767 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3769 // else if(-0.2<x&&x<-0.1){
3770 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3772 // else if(-0.2<x&&x<-0.1){
3773 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3775 // else if(-0.1<x&&x<0.1){
3776 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3778 // else if(0.1<x&&x<0.2){
3779 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3781 // if(0.2<x&&x<0.4){
3782 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
3791 // if(-0.4<x&&x<-0.2){
3792 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3794 // else if(-0.2<x&&x<-0.1){
3795 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3797 // else if(-0.2<x&&x<-0.1){
3798 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3800 // else if(-0.1<x&&x<0.1){
3801 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3803 // else if(0.1<x&&x<0.2){
3804 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3806 // if(0.2<x&&x<0.4){
3807 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3817 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){
3818 Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3821 fstrptAss="ptAsMore05";
3823 if(!fhDeltaPhiTemplate){
3824 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
3839 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3840 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3841 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
3852 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3853 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3854 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
3863 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3864 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3865 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
3875 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3876 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3877 fhSecContaminationMax->SetBinContent(j,0.05);
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);
3885 fhMCclosureTestMin->SetBinContent(j,-0.0);
3888 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3890 else if(-0.2<x&&x<-0.1){
3891 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3893 else if(-0.1<x&&x<0.1){
3894 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3896 else if(0.1<x&&x<0.2){
3897 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3900 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
3909 // if(-0.4<x&&x<-0.2){
3910 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3912 // else if(-0.2<x&&x<-0.1){
3913 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3915 // else if(-0.2<x&&x<-0.1){
3916 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3918 // else if(-0.1<x&&x<0.1){
3919 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3921 // else if(0.1<x&&x<0.2){
3922 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3924 // if(0.2<x&&x<0.4){
3925 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
3937 // if(-0.4<x&&x<-0.2){
3938 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3940 // else if(-0.2<x&&x<-0.1){
3941 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3943 // else if(-0.2<x&&x<-0.1){
3944 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3946 // else if(-0.1<x&&x<0.1){
3947 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3949 // else if(0.1<x&&x<0.2){
3950 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3952 // if(0.2<x&&x<0.4){
3953 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
3962 // if(-0.4<x&&x<-0.2){
3963 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3965 // else if(-0.2<x&&x<-0.1){
3966 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3968 // else if(-0.2<x&&x<-0.1){
3969 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3971 // else if(-0.1<x&&x<0.1){
3972 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3974 // else if(0.1<x&&x<0.2){
3975 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3977 // if(0.2<x&&x<0.4){
3978 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3985 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
3986 Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3989 fstrptAss="ptAsMore05";
3991 if(!fhDeltaPhiTemplate){
3992 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
4004 fhBackSubtractionMin->SetBinContent(j,-0.05);
4007 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4008 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4009 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
4018 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4019 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4020 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
4030 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4031 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4032 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
4042 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4043 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4044 fhSecContaminationMax->SetBinContent(j,0.05);
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);
4051 fhMCclosureTestMin->SetBinContent(j,-0.0);
4054 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4056 else if(-0.2<x&&x<-0.1){
4057 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4059 else if(-0.1<x&&x<0.1){
4060 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4062 else if(0.1<x&&x<0.2){
4063 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4066 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
4075 // if(-0.4<x&&x<-0.2){
4076 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4078 // else if(-0.2<x&&x<-0.1){
4079 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4081 // else if(-0.2<x&&x<-0.1){
4082 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4084 // else if(-0.1<x&&x<0.1){
4085 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4087 // else if(0.1<x&&x<0.2){
4088 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4090 // if(0.2<x&&x<0.4){
4091 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
4103 // if(-0.4<x&&x<-0.2){
4104 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4106 // else if(-0.2<x&&x<-0.1){
4107 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4109 // else if(-0.2<x&&x<-0.1){
4110 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4112 // else if(-0.1<x&&x<0.1){
4113 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4115 // else if(0.1<x&&x<0.2){
4116 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4118 // if(0.2<x&&x<0.4){
4119 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
4128 // if(-0.4<x&&x<-0.2){
4129 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4131 // else if(-0.2<x&&x<-0.1){
4132 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4134 // else if(-0.2<x&&x<-0.1){
4135 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4137 // else if(-0.1<x&&x<0.1){
4138 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4140 // else if(0.1<x&&x<0.2){
4141 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4143 // if(0.2<x&&x<0.4){
4144 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4152 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
4153 Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
4156 fstrptAss="ptAsMore05";
4158 if(!fhDeltaPhiTemplate){
4159 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
4172 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
4187 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4188 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4189 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
4199 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4200 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4201 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
4211 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4212 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4213 fhSecContaminationMax->SetBinContent(j,0.05);
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);
4220 fhMCclosureTestMin->SetBinContent(j,-0.0);
4223 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4225 else if(-0.2<x&&x<-0.1){
4226 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4228 else if(-0.1<x&&x<0.1){
4229 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4231 else if(0.1<x&&x<0.2){
4232 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4235 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
4244 // if(-0.4<x&&x<-0.2){
4245 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4247 // else if(-0.2<x&&x<-0.1){
4248 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4250 // else if(-0.2<x&&x<-0.1){
4251 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4253 // else if(-0.1<x&&x<0.1){
4254 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4256 // else if(0.1<x&&x<0.2){
4257 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4259 // if(0.2<x&&x<0.4){
4260 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
4272 // if(-0.4<x&&x<-0.2){
4273 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4275 // else if(-0.2<x&&x<-0.1){
4276 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4278 // else if(-0.2<x&&x<-0.1){
4279 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4281 // else if(-0.1<x&&x<0.1){
4282 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4284 // else if(0.1<x&&x<0.2){
4285 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4287 // if(0.2<x&&x<0.4){
4288 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
4297 // if(-0.4<x&&x<-0.2){
4298 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4300 // else if(-0.2<x&&x<-0.1){
4301 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4303 // else if(-0.2<x&&x<-0.1){
4304 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4306 // else if(-0.1<x&&x<0.1){
4307 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4309 // else if(0.1<x&&x<0.2){
4310 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4312 // if(0.2<x&&x<0.4){
4313 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4322 // pt(assoc)> 1 GeV/c
4323 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){
4324 Printf("Setting uncertainties for Dzero pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
4327 fstrptAss="ptAsMore1";
4329 if(!fhDeltaPhiTemplate){
4330 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
4345 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4346 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4347 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
4358 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4359 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4360 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
4369 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4370 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4371 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
4381 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4382 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4383 fhSecContaminationMax->SetBinContent(j,0.05);
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);
4391 fhMCclosureTestMin->SetBinContent(j,-0.);
4394 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4396 else if(-0.2<x&&x<-0.1){
4397 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4399 else if(-0.1<x&&x<0.1){
4400 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4402 else if(0.1<x&&x<0.2){
4403 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4406 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
4415 // if(-0.4<x&&x<-0.2){
4416 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4418 // else if(-0.2<x&&x<-0.1){
4419 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4421 // else if(-0.2<x&&x<-0.1){
4422 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4424 // else if(-0.1<x&&x<0.1){
4425 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4427 // else if(0.1<x&&x<0.2){
4428 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4430 // if(0.2<x&&x<0.4){
4431 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
4443 // if(-0.4<x&&x<-0.2){
4444 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4446 // else if(-0.2<x&&x<-0.1){
4447 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4449 // else if(-0.2<x&&x<-0.1){
4450 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4452 // else if(-0.1<x&&x<0.1){
4453 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4455 // else if(0.1<x&&x<0.2){
4456 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4458 // if(0.2<x&&x<0.4){
4459 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
4468 // if(-0.4<x&&x<-0.2){
4469 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4471 // else if(-0.2<x&&x<-0.1){
4472 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4474 // else if(-0.2<x&&x<-0.1){
4475 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4477 // else if(-0.1<x&&x<0.1){
4478 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4480 // else if(0.1<x&&x<0.2){
4481 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4483 // if(0.2<x&&x<0.4){
4484 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4491 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){
4492 Printf("Setting uncertainties for Dzero pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
4495 fstrptAss="ptAsMore1";
4497 if(!fhDeltaPhiTemplate){
4498 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
4510 fhBackSubtractionMin->SetBinContent(j,-0.05);
4513 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4514 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4515 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
4524 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4525 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4526 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
4536 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4537 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4538 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
4548 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4549 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4550 fhSecContaminationMax->SetBinContent(j,0.05);
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);
4557 fhMCclosureTestMin->SetBinContent(j,-0.);
4560 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4562 else if(-0.2<x&&x<-0.1){
4563 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4565 else if(-0.1<x&&x<0.1){
4566 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4568 else if(0.1<x&&x<0.2){
4569 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4572 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
4581 // if(-0.4<x&&x<-0.2){
4582 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4584 // else if(-0.2<x&&x<-0.1){
4585 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4587 // else if(-0.2<x&&x<-0.1){
4588 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4590 // else if(-0.1<x&&x<0.1){
4591 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4593 // else if(0.1<x&&x<0.2){
4594 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4596 // if(0.2<x&&x<0.4){
4597 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
4609 // if(-0.4<x&&x<-0.2){
4610 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4612 // else if(-0.2<x&&x<-0.1){
4613 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4615 // else if(-0.2<x&&x<-0.1){
4616 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4618 // else if(-0.1<x&&x<0.1){
4619 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4621 // else if(0.1<x&&x<0.2){
4622 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4624 // if(0.2<x&&x<0.4){
4625 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
4634 // if(-0.4<x&&x<-0.2){
4635 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4637 // else if(-0.2<x&&x<-0.1){
4638 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4640 // else if(-0.2<x&&x<-0.1){
4641 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4643 // else if(-0.1<x&&x<0.1){
4644 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4646 // else if(0.1<x&&x<0.2){
4647 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4649 // if(0.2<x&&x<0.4){
4650 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4658 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
4659 Printf("Setting uncertainties for Dzero pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
4662 fstrptAss="ptAsMore1";
4664 if(!fhDeltaPhiTemplate){
4665 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
4678 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
4693 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4694 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4695 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
4705 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4706 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4707 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
4717 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4718 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4719 fhSecContaminationMax->SetBinContent(j,0.05);
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);
4726 fhMCclosureTestMin->SetBinContent(j,-0.);
4729 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4731 else if(-0.2<x&&x<-0.1){
4732 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4734 else if(-0.1<x&&x<0.1){
4735 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4737 else if(0.1<x&&x<0.2){
4738 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4741 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
4750 // if(-0.4<x&&x<-0.2){
4751 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4753 // else if(-0.2<x&&x<-0.1){
4754 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4756 // else if(-0.2<x&&x<-0.1){
4757 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4759 // else if(-0.1<x&&x<0.1){
4760 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4762 // else if(0.1<x&&x<0.2){
4763 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4765 // if(0.2<x&&x<0.4){
4766 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
4778 // if(-0.4<x&&x<-0.2){
4779 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4781 // else if(-0.2<x&&x<-0.1){
4782 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4784 // else if(-0.2<x&&x<-0.1){
4785 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4787 // else if(-0.1<x&&x<0.1){
4788 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4790 // else if(0.1<x&&x<0.2){
4791 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4793 // if(0.2<x&&x<0.4){
4794 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
4803 // if(-0.4<x&&x<-0.2){
4804 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4806 // else if(-0.2<x&&x<-0.1){
4807 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4809 // else if(-0.2<x&&x<-0.1){
4810 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4812 // else if(-0.1<x&&x<0.1){
4813 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4815 // else if(0.1<x&&x<0.2){
4816 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4818 // if(0.2<x&&x<0.4){
4819 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4829 //--------------------------------------------------
4830 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
4831 Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
4834 fstrptAss="ptAsMore1";
4836 if(!fhDeltaPhiTemplate){
4837 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
4849 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
4864 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4865 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4866 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
4876 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4877 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4878 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
4888 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4889 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4890 fhSecContaminationMax->SetBinContent(j,0.05);
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);
4900 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4902 else if(-0.2<x&&x<-0.1){
4903 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4905 else if(-0.1<x&&x<0.1){
4906 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4908 else if(0.1<x&&x<0.2){
4909 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4912 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
4921 // if(-0.4<x&&x<-0.2){
4922 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4924 // else if(-0.2<x&&x<-0.1){
4925 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4927 // else if(-0.2<x&&x<-0.1){
4928 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4930 // else if(-0.1<x&&x<0.1){
4931 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4933 // else if(0.1<x&&x<0.2){
4934 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4936 // if(0.2<x&&x<0.4){
4937 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
4949 // if(-0.4<x&&x<-0.2){
4950 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4952 // else if(-0.2<x&&x<-0.1){
4953 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4955 // else if(-0.2<x&&x<-0.1){
4956 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4958 // else if(-0.1<x&&x<0.1){
4959 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4961 // else if(0.1<x&&x<0.2){
4962 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4964 // if(0.2<x&&x<0.4){
4965 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
4974 // if(-0.4<x&&x<-0.2){
4975 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4977 // else if(-0.2<x&&x<-0.1){
4978 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4980 // else if(-0.2<x&&x<-0.1){
4981 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4983 // else if(-0.1<x&&x<0.1){
4984 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4986 // else if(0.1<x&&x<0.2){
4987 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4989 // if(0.2<x&&x<0.4){
4990 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4998 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){
4999 Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
5002 fstrptAss="ptAsMore1";
5004 if(!fhDeltaPhiTemplate){
5005 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
5017 fhBackSubtractionMin->SetBinContent(j,-0.05);
5020 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5021 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5022 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
5031 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5032 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5033 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
5042 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5043 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5044 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
5054 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5055 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5056 fhSecContaminationMax->SetBinContent(j,0.05);
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);
5066 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5068 else if(-0.2<x&&x<-0.1){
5069 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5071 else if(-0.1<x&&x<0.1){
5072 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5074 else if(0.1<x&&x<0.2){
5075 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5078 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
5087 // if(-0.4<x&&x<-0.2){
5088 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5090 // else if(-0.2<x&&x<-0.1){
5091 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5093 // else if(-0.2<x&&x<-0.1){
5094 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5096 // else if(-0.1<x&&x<0.1){
5097 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5099 // else if(0.1<x&&x<0.2){
5100 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5102 // if(0.2<x&&x<0.4){
5103 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
5115 // if(-0.4<x&&x<-0.2){
5116 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5118 // else if(-0.2<x&&x<-0.1){
5119 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5121 // else if(-0.2<x&&x<-0.1){
5122 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5124 // else if(-0.1<x&&x<0.1){
5125 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5127 // else if(0.1<x&&x<0.2){
5128 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5130 // if(0.2<x&&x<0.4){
5131 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
5140 // if(-0.4<x&&x<-0.2){
5141 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5143 // else if(-0.2<x&&x<-0.1){
5144 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5146 // else if(-0.2<x&&x<-0.1){
5147 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5149 // else if(-0.1<x&&x<0.1){
5150 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5152 // else if(0.1<x&&x<0.2){
5153 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5155 // if(0.2<x&&x<0.4){
5156 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5165 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){
5166 Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5169 fstrptAss="ptAsMore1";
5171 if(!fhDeltaPhiTemplate){
5172 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
5184 fhBackSubtractionMin->SetBinContent(j,-0.12);
5187 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5188 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5190 fhBackSubtractionMax->SetBinContent(j,0.12);
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);
5199 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5200 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5201 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
5209 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5210 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5211 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
5221 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5222 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5223 fhSecContaminationMax->SetBinContent(j,0.05);
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);
5233 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5235 else if(-0.2<x&&x<-0.1){
5236 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5238 else if(-0.1<x&&x<0.1){
5239 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5241 else if(0.1<x&&x<0.2){
5242 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5245 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
5254 // if(-0.4<x&&x<-0.2){
5255 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5257 // else if(-0.2<x&&x<-0.1){
5258 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5260 // else if(-0.2<x&&x<-0.1){
5261 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5263 // else if(-0.1<x&&x<0.1){
5264 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5266 // else if(0.1<x&&x<0.2){
5267 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5269 // if(0.2<x&&x<0.4){
5270 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
5282 // if(-0.4<x&&x<-0.2){
5283 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5285 // else if(-0.2<x&&x<-0.1){
5286 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5288 // else if(-0.2<x&&x<-0.1){
5289 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5291 // else if(-0.1<x&&x<0.1){
5292 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5294 // else if(0.1<x&&x<0.2){
5295 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5297 // if(0.2<x&&x<0.4){
5298 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
5307 // if(-0.4<x&&x<-0.2){
5308 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5310 // else if(-0.2<x&&x<-0.1){
5311 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5313 // else if(-0.2<x&&x<-0.1){
5314 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5316 // else if(-0.1<x&&x<0.1){
5317 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5319 // else if(0.1<x&&x<0.2){
5320 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5322 // if(0.2<x&&x<0.4){
5323 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5333 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){
5334 Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
5337 fstrptAss="ptAsMore1";
5339 if(!fhDeltaPhiTemplate){
5340 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
5355 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5356 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5357 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
5368 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5369 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5370 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
5379 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5380 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5381 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
5391 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5392 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5393 fhSecContaminationMax->SetBinContent(j,0.05);
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);
5401 fhMCclosureTestMin->SetBinContent(j,-0.0);
5404 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5406 else if(-0.2<x&&x<-0.1){
5407 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5409 else if(-0.1<x&&x<0.1){
5410 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5412 else if(0.1<x&&x<0.2){
5413 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5416 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
5425 // if(-0.4<x&&x<-0.2){
5426 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5428 // else if(-0.2<x&&x<-0.1){
5429 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5431 // else if(-0.2<x&&x<-0.1){
5432 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5434 // else if(-0.1<x&&x<0.1){
5435 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5437 // else if(0.1<x&&x<0.2){
5438 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5440 // if(0.2<x&&x<0.4){
5441 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
5453 // if(-0.4<x&&x<-0.2){
5454 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5456 // else if(-0.2<x&&x<-0.1){
5457 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5459 // else if(-0.2<x&&x<-0.1){
5460 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5462 // else if(-0.1<x&&x<0.1){
5463 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5465 // else if(0.1<x&&x<0.2){
5466 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5468 // if(0.2<x&&x<0.4){
5469 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
5478 // if(-0.4<x&&x<-0.2){
5479 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5481 // else if(-0.2<x&&x<-0.1){
5482 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5484 // else if(-0.2<x&&x<-0.1){
5485 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5487 // else if(-0.1<x&&x<0.1){
5488 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5490 // else if(0.1<x&&x<0.2){
5491 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5493 // if(0.2<x&&x<0.4){
5494 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5501 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){
5502 Printf("Setting uncertainties for Dplus pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
5505 fstrptAss="ptAsMore1";
5507 if(!fhDeltaPhiTemplate){
5508 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
5520 fhBackSubtractionMin->SetBinContent(j,-0.05);
5523 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5524 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5525 fhBackSubtractionMax->SetBinContent(j,0.05);
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);
5534 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5535 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5536 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
5546 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5547 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5548 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
5558 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5559 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5560 fhSecContaminationMax->SetBinContent(j,0.05);
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);
5567 fhMCclosureTestMin->SetBinContent(j,-0.0);
5570 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5572 else if(-0.2<x&&x<-0.1){
5573 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5575 else if(-0.1<x&&x<0.1){
5576 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5578 else if(0.1<x&&x<0.2){
5579 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5582 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
5591 // if(-0.4<x&&x<-0.2){
5592 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5594 // else if(-0.2<x&&x<-0.1){
5595 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5597 // else if(-0.2<x&&x<-0.1){
5598 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5600 // else if(-0.1<x&&x<0.1){
5601 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5603 // else if(0.1<x&&x<0.2){
5604 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5606 // if(0.2<x&&x<0.4){
5607 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
5619 // if(-0.4<x&&x<-0.2){
5620 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5622 // else if(-0.2<x&&x<-0.1){
5623 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5625 // else if(-0.2<x&&x<-0.1){
5626 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5628 // else if(-0.1<x&&x<0.1){
5629 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5631 // else if(0.1<x&&x<0.2){
5632 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5634 // if(0.2<x&&x<0.4){
5635 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
5644 // if(-0.4<x&&x<-0.2){
5645 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5647 // else if(-0.2<x&&x<-0.1){
5648 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5650 // else if(-0.2<x&&x<-0.1){
5651 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5653 // else if(-0.1<x&&x<0.1){
5654 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5656 // else if(0.1<x&&x<0.2){
5657 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5659 // if(0.2<x&&x<0.4){
5660 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5668 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
5669 Printf("Setting uncertainties for Dplus pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5672 fstrptAss="ptAsMore1";
5674 if(!fhDeltaPhiTemplate){
5675 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
5688 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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);
5703 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5704 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5705 fhMCcorrectionsMax->SetBinContent(j,0.10);
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);
5715 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5716 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5717 fhMCDefficiencyMax->SetBinContent(j,0.05);
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);
5727 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5728 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5729 fhSecContaminationMax->SetBinContent(j,0.05);
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);
5736 fhMCclosureTestMin->SetBinContent(j,-0.0);
5739 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5741 else if(-0.2<x&&x<-0.1){
5742 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5744 else if(-0.1<x&&x<0.1){
5745 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5747 else if(0.1<x&&x<0.2){
5748 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5751 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
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.);
5760 // if(-0.4<x&&x<-0.2){
5761 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5763 // else if(-0.2<x&&x<-0.1){
5764 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5766 // else if(-0.2<x&&x<-0.1){
5767 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5769 // else if(-0.1<x&&x<0.1){
5770 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5772 // else if(0.1<x&&x<0.2){
5773 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5775 // if(0.2<x&&x<0.4){
5776 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
5788 // if(-0.4<x&&x<-0.2){
5789 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5791 // else if(-0.2<x&&x<-0.1){
5792 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5794 // else if(-0.2<x&&x<-0.1){
5795 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5797 // else if(-0.1<x&&x<0.1){
5798 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5800 // else if(0.1<x&&x<0.2){
5801 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5803 // if(0.2<x&&x<0.4){
5804 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
5813 // if(-0.4<x&&x<-0.2){
5814 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5816 // else if(-0.2<x&&x<-0.1){
5817 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5819 // else if(-0.2<x&&x<-0.1){
5820 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5822 // else if(-0.1<x&&x<0.1){
5823 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5825 // else if(0.1<x&&x<0.2){
5826 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5828 // if(0.2<x&&x<0.4){
5829 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5841 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5843 ///// METHODS WITH UNCERTAINTIES: pPb 2013
5845 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5848 // pt assoc > 0.3 GeV/c
5850 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
5851 Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
5854 fstrptAss="ptAsMore03";
5856 if(!fhDeltaPhiTemplate){
5857 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
5872 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5873 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5874 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
5882 fhMCcorrectionsMin->SetBinContent(j,-0.04);
5885 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5886 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5887 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
5896 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5897 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5898 fhMCDefficiencyMax->SetBinContent(j,0.05);
5902 // Contamination from secondary tracks
5903 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5904 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5905 fhSecContaminationMin->SetBinContent(j,-0.035);
5908 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5909 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5910 fhSecContaminationMax->SetBinContent(j,0.035);
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);
5918 fhMCclosureTestMin->SetBinContent(j,-0.);
5921 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5923 else if(-0.2<x&&x<-0.1){
5924 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5926 else if(-0.1<x&&x<0.1){
5927 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5929 else if(0.1<x&&x<0.2){
5930 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5933 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5937 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5938 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5939 // x=fhMCclosureTestMax->GetBinLowEdge(j);
5940 fhMCclosureTestMax->SetBinContent(j,0.08);
5942 // if(-0.4<x&&x<-0.2){
5943 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5945 // else if(-0.2<x&&x<-0.1){
5946 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5948 // else if(-0.2<x&&x<-0.1){
5949 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5951 // else if(-0.1<x&&x<0.1){
5952 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5954 // else if(0.1<x&&x<0.2){
5955 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5957 // if(0.2<x&&x<0.4){
5958 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
5970 // if(-0.4<x&&x<-0.2){
5971 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5973 // else if(-0.2<x&&x<-0.1){
5974 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5976 // else if(-0.2<x&&x<-0.1){
5977 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5979 // else if(-0.1<x&&x<0.1){
5980 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5982 // else if(0.1<x&&x<0.2){
5983 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5985 // if(0.2<x&&x<0.4){
5986 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
5995 // if(-0.4<x&&x<-0.2){
5996 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5998 // else if(-0.2<x&&x<-0.1){
5999 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6001 // else if(-0.2<x&&x<-0.1){
6002 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6004 // else if(-0.1<x&&x<0.1){
6005 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6007 // else if(0.1<x&&x<0.2){
6008 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6010 // if(0.2<x&&x<0.4){
6011 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6018 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
6019 Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
6022 fstrptAss="ptAsMore03";
6024 if(!fhDeltaPhiTemplate){
6025 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
6037 fhBackSubtractionMin->SetBinContent(j,-0.05);
6040 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6041 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6042 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
6048 fhMCcorrectionsMin->SetBinContent(j,-0.04);
6051 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6052 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6053 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
6063 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6064 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6065 fhMCDefficiencyMax->SetBinContent(j,0.05);
6069 // Contamination from secondary tracks
6070 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6071 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6072 fhSecContaminationMin->SetBinContent(j,-0.035);
6075 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6076 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6077 fhSecContaminationMax->SetBinContent(j,0.035);
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);
6084 fhMCclosureTestMin->SetBinContent(j,-0.);
6087 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6089 else if(-0.2<x&&x<-0.1){
6090 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6092 else if(-0.1<x&&x<0.1){
6093 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6095 else if(0.1<x&&x<0.2){
6096 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6099 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6103 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6104 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6105 x=fhMCclosureTestMax->GetBinLowEdge(j);
6106 fhMCclosureTestMax->SetBinContent(j,0.08);
6108 // if(-0.4<x&&x<-0.2){
6109 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6111 // else if(-0.2<x&&x<-0.1){
6112 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6114 // else if(-0.2<x&&x<-0.1){
6115 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6117 // else if(-0.1<x&&x<0.1){
6118 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6120 // else if(0.1<x&&x<0.2){
6121 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6123 // if(0.2<x&&x<0.4){
6124 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
6136 // if(-0.4<x&&x<-0.2){
6137 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6139 // else if(-0.2<x&&x<-0.1){
6140 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6142 // else if(-0.2<x&&x<-0.1){
6143 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6145 // else if(-0.1<x&&x<0.1){
6146 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6148 // else if(0.1<x&&x<0.2){
6149 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6151 // if(0.2<x&&x<0.4){
6152 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
6161 // if(-0.4<x&&x<-0.2){
6162 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6164 // else if(-0.2<x&&x<-0.1){
6165 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6167 // else if(-0.2<x&&x<-0.1){
6168 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6170 // else if(-0.1<x&&x<0.1){
6171 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6173 // else if(0.1<x&&x<0.2){
6174 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6176 // if(0.2<x&&x<0.4){
6177 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6185 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03(){
6186 Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
6189 fstrptAss="ptAsMore03";
6191 if(!fhDeltaPhiTemplate){
6192 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
6205 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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++){
6217 fhMCcorrectionsMin->SetBinContent(j,-0.04);
6220 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6221 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6222 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
6232 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6233 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6234 fhMCDefficiencyMax->SetBinContent(j,0.05);
6238 // Contamination from secondary tracks
6239 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6240 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6241 fhSecContaminationMin->SetBinContent(j,-0.035);
6244 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6245 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6246 fhSecContaminationMax->SetBinContent(j,0.035);
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);
6253 fhMCclosureTestMin->SetBinContent(j,-0.);
6256 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6258 else if(-0.2<x&&x<-0.1){
6259 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6261 else if(-0.1<x&&x<0.1){
6262 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6264 else if(0.1<x&&x<0.2){
6265 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6268 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6272 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6273 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6274 x=fhMCclosureTestMax->GetBinLowEdge(j);
6275 fhMCclosureTestMax->SetBinContent(j,0.08);
6277 // if(-0.4<x&&x<-0.2){
6278 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6280 // else if(-0.2<x&&x<-0.1){
6281 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6283 // else if(-0.2<x&&x<-0.1){
6284 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6286 // else if(-0.1<x&&x<0.1){
6287 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6289 // else if(0.1<x&&x<0.2){
6290 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6292 // if(0.2<x&&x<0.4){
6293 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
6305 // if(-0.4<x&&x<-0.2){
6306 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6308 // else if(-0.2<x&&x<-0.1){
6309 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6311 // else if(-0.2<x&&x<-0.1){
6312 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6314 // else if(-0.1<x&&x<0.1){
6315 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6317 // else if(0.1<x&&x<0.2){
6318 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6320 // if(0.2<x&&x<0.4){
6321 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
6330 // if(-0.4<x&&x<-0.2){
6331 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6333 // else if(-0.2<x&&x<-0.1){
6334 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6336 // else if(-0.2<x&&x<-0.1){
6337 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6339 // else if(-0.1<x&&x<0.1){
6340 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6342 // else if(0.1<x&&x<0.2){
6343 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6345 // if(0.2<x&&x<0.4){
6346 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6356 //--------------------------------------------------
6357 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
6358 Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6361 fstrptAss="ptAsMore03";
6363 if(!fhDeltaPhiTemplate){
6364 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
6376 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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++){
6388 fhMCcorrectionsMin->SetBinContent(j,-0.04);
6391 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6392 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6393 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
6403 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6404 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6405 fhMCDefficiencyMax->SetBinContent(j,0.05);
6409 // Contamination from secondary tracks
6410 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6411 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6412 fhSecContaminationMin->SetBinContent(j,-0.035);
6415 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6416 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6417 fhSecContaminationMax->SetBinContent(j,0.035);
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);
6424 fhMCclosureTestMin->SetBinContent(j,-0.);
6427 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6429 else if(-0.2<x&&x<-0.1){
6430 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6432 else if(-0.1<x&&x<0.1){
6433 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6435 else if(0.1<x&&x<0.2){
6436 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6439 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6443 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6444 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6445 x=fhMCclosureTestMax->GetBinLowEdge(j);
6446 fhMCclosureTestMax->SetBinContent(j,0.08);
6448 // if(-0.4<x&&x<-0.2){
6449 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6451 // else if(-0.2<x&&x<-0.1){
6452 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6454 // else if(-0.2<x&&x<-0.1){
6455 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6457 // else if(-0.1<x&&x<0.1){
6458 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6460 // else if(0.1<x&&x<0.2){
6461 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6463 // if(0.2<x&&x<0.4){
6464 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
6476 // if(-0.4<x&&x<-0.2){
6477 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6479 // else if(-0.2<x&&x<-0.1){
6480 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6482 // else if(-0.2<x&&x<-0.1){
6483 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6485 // else if(-0.1<x&&x<0.1){
6486 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6488 // else if(0.1<x&&x<0.2){
6489 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6491 // if(0.2<x&&x<0.4){
6492 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
6501 // if(-0.4<x&&x<-0.2){
6502 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6504 // else if(-0.2<x&&x<-0.1){
6505 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6507 // else if(-0.2<x&&x<-0.1){
6508 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6510 // else if(-0.1<x&&x<0.1){
6511 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6513 // else if(0.1<x&&x<0.2){
6514 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6516 // if(0.2<x&&x<0.4){
6517 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6525 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
6526 Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
6529 fstrptAss="ptAsMore03";
6531 if(!fhDeltaPhiTemplate){
6532 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
6544 fhBackSubtractionMin->SetBinContent(j,-0.04);
6547 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6548 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6549 fhBackSubtractionMax->SetBinContent(j,0.04);
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++){
6555 fhMCcorrectionsMin->SetBinContent(j,-0.04);
6558 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6559 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6560 fhMCcorrectionsMax->SetBinContent(j,0.04);
6563 // MC D EFF CORRECTION
6564 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6565 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6566 fhMCDefficiencyMin->SetBinContent(j,-0.04);
6569 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6570 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6571 fhMCDefficiencyMax->SetBinContent(j,0.04);
6575 // Contamination from secondary tracks
6576 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6577 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6578 fhSecContaminationMin->SetBinContent(j,-0.035);
6581 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6582 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6583 fhSecContaminationMax->SetBinContent(j,0.035);
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);
6590 fhMCclosureTestMin->SetBinContent(j,-0.0);
6593 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6595 else if(-0.2<x&&x<-0.1){
6596 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6598 else if(-0.1<x&&x<0.1){
6599 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6601 else if(0.1<x&&x<0.2){
6602 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6605 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6609 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6610 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6611 x=fhMCclosureTestMax->GetBinLowEdge(j);
6612 fhMCclosureTestMax->SetBinContent(j,0.08);
6614 // if(-0.4<x&&x<-0.2){
6615 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6617 // else if(-0.2<x&&x<-0.1){
6618 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6620 // else if(-0.2<x&&x<-0.1){
6621 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6623 // else if(-0.1<x&&x<0.1){
6624 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6626 // else if(0.1<x&&x<0.2){
6627 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6629 // if(0.2<x&&x<0.4){
6630 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
6642 // if(-0.4<x&&x<-0.2){
6643 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6645 // else if(-0.2<x&&x<-0.1){
6646 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6648 // else if(-0.2<x&&x<-0.1){
6649 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6651 // else if(-0.1<x&&x<0.1){
6652 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6654 // else if(0.1<x&&x<0.2){
6655 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6657 // if(0.2<x&&x<0.4){
6658 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
6667 // if(-0.4<x&&x<-0.2){
6668 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6670 // else if(-0.2<x&&x<-0.1){
6671 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6673 // else if(-0.2<x&&x<-0.1){
6674 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6676 // else if(-0.1<x&&x<0.1){
6677 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6679 // else if(0.1<x&&x<0.2){
6680 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6682 // if(0.2<x&&x<0.4){
6683 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6692 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03(){
6693 Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
6696 fstrptAss="ptAsMore03";
6698 if(!fhDeltaPhiTemplate){
6699 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
6711 fhBackSubtractionMin->SetBinContent(j,-0.05);
6714 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6715 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6716 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
6722 fhMCcorrectionsMin->SetBinContent(j,-0.04);
6725 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6726 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6727 fhMCcorrectionsMax->SetBinContent(j,0.04);
6729 // MC D EFF CORRECTION
6730 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6731 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6732 fhMCDefficiencyMin->SetBinContent(j,-0.08);
6735 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6736 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6737 fhMCDefficiencyMax->SetBinContent(j,0.08);
6741 // Contamination from secondary tracks
6742 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6743 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6744 fhSecContaminationMin->SetBinContent(j,-0.035);
6747 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6748 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6749 fhSecContaminationMax->SetBinContent(j,0.035);
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);
6756 fhMCclosureTestMin->SetBinContent(j,-0.0);
6759 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6761 else if(-0.2<x&&x<-0.1){
6762 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6764 else if(-0.1<x&&x<0.1){
6765 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6767 else if(0.1<x&&x<0.2){
6768 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6771 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6775 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6776 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6777 x=fhMCclosureTestMax->GetBinLowEdge(j);
6778 fhMCclosureTestMax->SetBinContent(j,0.08);
6780 // if(-0.4<x&&x<-0.2){
6781 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6783 // else if(-0.2<x&&x<-0.1){
6784 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6786 // else if(-0.2<x&&x<-0.1){
6787 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6789 // else if(-0.1<x&&x<0.1){
6790 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6792 // else if(0.1<x&&x<0.2){
6793 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6795 // if(0.2<x&&x<0.4){
6796 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
6808 // if(-0.4<x&&x<-0.2){
6809 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6811 // else if(-0.2<x&&x<-0.1){
6812 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6814 // else if(-0.2<x&&x<-0.1){
6815 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6817 // else if(-0.1<x&&x<0.1){
6818 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6820 // else if(0.1<x&&x<0.2){
6821 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6823 // if(0.2<x&&x<0.4){
6824 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
6833 // if(-0.4<x&&x<-0.2){
6834 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6836 // else if(-0.2<x&&x<-0.1){
6837 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6839 // else if(-0.2<x&&x<-0.1){
6840 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6842 // else if(-0.1<x&&x<0.1){
6843 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6845 // else if(0.1<x&&x<0.2){
6846 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6848 // if(0.2<x&&x<0.4){
6849 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6860 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
6861 Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6864 fstrptAss="ptAsMore03";
6866 if(!fhDeltaPhiTemplate){
6867 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
6879 fhBackSubtractionMin->SetBinContent(j,-0.1);
6882 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6883 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6884 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
6892 fhMCcorrectionsMin->SetBinContent(j,-0.04);
6895 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6896 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6897 fhMCcorrectionsMax->SetBinContent(j,0.04);
6900 // MC D EFF CORRECTION
6901 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6902 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6903 fhMCDefficiencyMin->SetBinContent(j,-0.1);
6906 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6907 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6908 fhMCDefficiencyMax->SetBinContent(j,0.1);
6912 // Contamination from secondary tracks
6913 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6914 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6915 fhSecContaminationMin->SetBinContent(j,-0.035);
6918 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6919 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6920 fhSecContaminationMax->SetBinContent(j,0.035);
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);
6928 fhMCclosureTestMin->SetBinContent(j,-0.0);
6931 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6933 else if(-0.2<x&&x<-0.1){
6934 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6936 else if(-0.1<x&&x<0.1){
6937 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6939 else if(0.1<x&&x<0.2){
6940 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6943 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6947 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6948 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6949 // x=fhMCclosureTestMax->GetBinLowEdge(j);
6950 fhMCclosureTestMax->SetBinContent(j,0.08);
6952 // if(-0.4<x&&x<-0.2){
6953 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6955 // else if(-0.2<x&&x<-0.1){
6956 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6958 // else if(-0.2<x&&x<-0.1){
6959 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6961 // else if(-0.1<x&&x<0.1){
6962 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6964 // else if(0.1<x&&x<0.2){
6965 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6967 // if(0.2<x&&x<0.4){
6968 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
6980 // if(-0.4<x&&x<-0.2){
6981 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6983 // else if(-0.2<x&&x<-0.1){
6984 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6986 // else if(-0.2<x&&x<-0.1){
6987 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6989 // else if(-0.1<x&&x<0.1){
6990 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6992 // else if(0.1<x&&x<0.2){
6993 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6995 // if(0.2<x&&x<0.4){
6996 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
7005 // if(-0.4<x&&x<-0.2){
7006 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7008 // else if(-0.2<x&&x<-0.1){
7009 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7011 // else if(-0.2<x&&x<-0.1){
7012 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7014 // else if(-0.1<x&&x<0.1){
7015 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7017 // else if(0.1<x&&x<0.2){
7018 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7020 // if(0.2<x&&x<0.4){
7021 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7028 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
7029 Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
7032 fstrptAss="ptAsMore03";
7034 if(!fhDeltaPhiTemplate){
7035 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
7047 fhBackSubtractionMin->SetBinContent(j,-0.1);
7050 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7051 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7052 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
7058 fhMCcorrectionsMin->SetBinContent(j,-0.04);
7061 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7062 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7063 fhMCcorrectionsMax->SetBinContent(j,0.04);
7067 // MC D EFF CORRECTION
7068 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7069 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7070 fhMCDefficiencyMin->SetBinContent(j,-0.1);
7073 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7074 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7075 fhMCDefficiencyMax->SetBinContent(j,0.1);
7079 // Contamination from secondary tracks
7080 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7081 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7082 fhSecContaminationMin->SetBinContent(j,-0.035);
7085 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7086 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7087 fhSecContaminationMax->SetBinContent(j,0.035);
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);
7094 fhMCclosureTestMin->SetBinContent(j,-0.0);
7097 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7099 else if(-0.2<x&&x<-0.1){
7100 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7102 else if(-0.1<x&&x<0.1){
7103 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7105 else if(0.1<x&&x<0.2){
7106 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7109 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7113 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7114 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7115 x=fhMCclosureTestMax->GetBinLowEdge(j);
7116 fhMCclosureTestMax->SetBinContent(j,0.08);
7118 // if(-0.4<x&&x<-0.2){
7119 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7121 // else if(-0.2<x&&x<-0.1){
7122 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7124 // else if(-0.2<x&&x<-0.1){
7125 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7127 // else if(-0.1<x&&x<0.1){
7128 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7130 // else if(0.1<x&&x<0.2){
7131 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7133 // if(0.2<x&&x<0.4){
7134 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
7146 // if(-0.4<x&&x<-0.2){
7147 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7149 // else if(-0.2<x&&x<-0.1){
7150 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7152 // else if(-0.2<x&&x<-0.1){
7153 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7155 // else if(-0.1<x&&x<0.1){
7156 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7158 // else if(0.1<x&&x<0.2){
7159 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7161 // if(0.2<x&&x<0.4){
7162 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
7171 // if(-0.4<x&&x<-0.2){
7172 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7174 // else if(-0.2<x&&x<-0.1){
7175 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7177 // else if(-0.2<x&&x<-0.1){
7178 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7180 // else if(-0.1<x&&x<0.1){
7181 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7183 // else if(0.1<x&&x<0.2){
7184 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7186 // if(0.2<x&&x<0.4){
7187 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7195 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03(){
7196 Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
7199 fstrptAss="ptAsMore03";
7201 if(!fhDeltaPhiTemplate){
7202 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
7215 fhBackSubtractionMin->SetBinContent(j,-0.1);
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++){
7221 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
7227 fhMCcorrectionsMin->SetBinContent(j,-0.04);
7230 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7231 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7232 fhMCcorrectionsMax->SetBinContent(j,0.04);
7236 // MC D EFF CORRECTION
7237 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7238 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7239 fhMCDefficiencyMin->SetBinContent(j,-0.1);
7242 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7243 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7244 fhMCDefficiencyMax->SetBinContent(j,0.1);
7248 // Contamination from secondary tracks
7249 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7250 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7251 fhSecContaminationMin->SetBinContent(j,-0.035);
7254 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7255 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7256 fhSecContaminationMax->SetBinContent(j,0.035);
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);
7263 fhMCclosureTestMin->SetBinContent(j,-0.0);
7266 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7268 else if(-0.2<x&&x<-0.1){
7269 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7271 else if(-0.1<x&&x<0.1){
7272 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7274 else if(0.1<x&&x<0.2){
7275 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7278 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7282 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7283 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7284 x=fhMCclosureTestMax->GetBinLowEdge(j);
7285 fhMCclosureTestMax->SetBinContent(j,0.08);
7287 // if(-0.4<x&&x<-0.2){
7288 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7290 // else if(-0.2<x&&x<-0.1){
7291 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7293 // else if(-0.2<x&&x<-0.1){
7294 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7296 // else if(-0.1<x&&x<0.1){
7297 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7299 // else if(0.1<x&&x<0.2){
7300 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7302 // if(0.2<x&&x<0.4){
7303 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
7315 // if(-0.4<x&&x<-0.2){
7316 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7318 // else if(-0.2<x&&x<-0.1){
7319 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7321 // else if(-0.2<x&&x<-0.1){
7322 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7324 // else if(-0.1<x&&x<0.1){
7325 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7327 // else if(0.1<x&&x<0.2){
7328 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7330 // if(0.2<x&&x<0.4){
7331 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
7340 // if(-0.4<x&&x<-0.2){
7341 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7343 // else if(-0.2<x&&x<-0.1){
7344 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7346 // else if(-0.2<x&&x<-0.1){
7347 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7349 // else if(-0.1<x&&x<0.1){
7350 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7352 // else if(0.1<x&&x<0.2){
7353 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7355 // if(0.2<x&&x<0.4){
7356 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7365 //////// HIGHER PT ASS THRESHOLDS
7367 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
7368 Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
7371 fstrptAss="ptAsMore05";
7373 if(!fhDeltaPhiTemplate){
7374 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
7389 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7390 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7391 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
7399 fhMCcorrectionsMin->SetBinContent(j,-0.04);
7402 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7403 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7404 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
7413 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7414 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7415 fhMCDefficiencyMax->SetBinContent(j,0.05);
7419 // Contamination from secondary tracks
7420 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7421 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7422 fhSecContaminationMin->SetBinContent(j,-0.035);
7425 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7426 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7427 fhSecContaminationMax->SetBinContent(j,0.035);
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);
7435 fhMCclosureTestMin->SetBinContent(j,-0.);
7438 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7440 else if(-0.2<x&&x<-0.1){
7441 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7443 else if(-0.1<x&&x<0.1){
7444 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7446 else if(0.1<x&&x<0.2){
7447 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7450 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7454 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7455 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7456 // x=fhMCclosureTestMax->GetBinLowEdge(j);
7457 fhMCclosureTestMax->SetBinContent(j,0.07);
7459 // if(-0.4<x&&x<-0.2){
7460 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7462 // else if(-0.2<x&&x<-0.1){
7463 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7465 // else if(-0.2<x&&x<-0.1){
7466 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7468 // else if(-0.1<x&&x<0.1){
7469 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7471 // else if(0.1<x&&x<0.2){
7472 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7474 // if(0.2<x&&x<0.4){
7475 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
7487 // if(-0.4<x&&x<-0.2){
7488 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7490 // else if(-0.2<x&&x<-0.1){
7491 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7493 // else if(-0.2<x&&x<-0.1){
7494 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7496 // else if(-0.1<x&&x<0.1){
7497 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7499 // else if(0.1<x&&x<0.2){
7500 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7502 // if(0.2<x&&x<0.4){
7503 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
7512 // if(-0.4<x&&x<-0.2){
7513 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7515 // else if(-0.2<x&&x<-0.1){
7516 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7518 // else if(-0.2<x&&x<-0.1){
7519 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7521 // else if(-0.1<x&&x<0.1){
7522 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7524 // else if(0.1<x&&x<0.2){
7525 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7527 // if(0.2<x&&x<0.4){
7528 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7535 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
7536 Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
7539 fstrptAss="ptAsMore05";
7541 if(!fhDeltaPhiTemplate){
7542 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
7554 fhBackSubtractionMin->SetBinContent(j,-0.05);
7557 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7558 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7559 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
7565 fhMCcorrectionsMin->SetBinContent(j,-0.04);
7568 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7569 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7570 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
7580 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7581 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7582 fhMCDefficiencyMax->SetBinContent(j,0.05);
7586 // Contamination from secondary tracks
7587 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7588 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7589 fhSecContaminationMin->SetBinContent(j,-0.035);
7592 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7593 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7594 fhSecContaminationMax->SetBinContent(j,0.035);
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);
7601 fhMCclosureTestMin->SetBinContent(j,-0.);
7604 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7606 else if(-0.2<x&&x<-0.1){
7607 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7609 else if(-0.1<x&&x<0.1){
7610 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7612 else if(0.1<x&&x<0.2){
7613 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7616 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7620 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7621 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7622 x=fhMCclosureTestMax->GetBinLowEdge(j);
7623 fhMCclosureTestMax->SetBinContent(j,0.07);
7625 // if(-0.4<x&&x<-0.2){
7626 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7628 // else if(-0.2<x&&x<-0.1){
7629 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7631 // else if(-0.2<x&&x<-0.1){
7632 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7634 // else if(-0.1<x&&x<0.1){
7635 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7637 // else if(0.1<x&&x<0.2){
7638 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7640 // if(0.2<x&&x<0.4){
7641 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
7653 // if(-0.4<x&&x<-0.2){
7654 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7656 // else if(-0.2<x&&x<-0.1){
7657 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7659 // else if(-0.2<x&&x<-0.1){
7660 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7662 // else if(-0.1<x&&x<0.1){
7663 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7665 // else if(0.1<x&&x<0.2){
7666 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7668 // if(0.2<x&&x<0.4){
7669 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
7678 // if(-0.4<x&&x<-0.2){
7679 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7681 // else if(-0.2<x&&x<-0.1){
7682 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7684 // else if(-0.2<x&&x<-0.1){
7685 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7687 // else if(-0.1<x&&x<0.1){
7688 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7690 // else if(0.1<x&&x<0.2){
7691 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7693 // if(0.2<x&&x<0.4){
7694 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7702 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05(){
7703 Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
7706 fstrptAss="ptAsMore05";
7708 if(!fhDeltaPhiTemplate){
7709 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
7722 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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++){
7734 fhMCcorrectionsMin->SetBinContent(j,-0.04);
7737 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7738 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7739 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
7749 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7750 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7751 fhMCDefficiencyMax->SetBinContent(j,0.05);
7755 // Contamination from secondary tracks
7756 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7757 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7758 fhSecContaminationMin->SetBinContent(j,-0.035);
7761 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7762 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7763 fhSecContaminationMax->SetBinContent(j,0.035);
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);
7770 fhMCclosureTestMin->SetBinContent(j,-0.);
7773 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7775 else if(-0.2<x&&x<-0.1){
7776 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7778 else if(-0.1<x&&x<0.1){
7779 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7781 else if(0.1<x&&x<0.2){
7782 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7785 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7789 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7790 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7791 x=fhMCclosureTestMax->GetBinLowEdge(j);
7792 fhMCclosureTestMax->SetBinContent(j,0.07);
7794 // if(-0.4<x&&x<-0.2){
7795 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7797 // else if(-0.2<x&&x<-0.1){
7798 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7800 // else if(-0.2<x&&x<-0.1){
7801 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7803 // else if(-0.1<x&&x<0.1){
7804 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7806 // else if(0.1<x&&x<0.2){
7807 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7809 // if(0.2<x&&x<0.4){
7810 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
7822 // if(-0.4<x&&x<-0.2){
7823 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7825 // else if(-0.2<x&&x<-0.1){
7826 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7828 // else if(-0.2<x&&x<-0.1){
7829 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7831 // else if(-0.1<x&&x<0.1){
7832 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7834 // else if(0.1<x&&x<0.2){
7835 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7837 // if(0.2<x&&x<0.4){
7838 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
7847 // if(-0.4<x&&x<-0.2){
7848 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7850 // else if(-0.2<x&&x<-0.1){
7851 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7853 // else if(-0.2<x&&x<-0.1){
7854 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7856 // else if(-0.1<x&&x<0.1){
7857 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7859 // else if(0.1<x&&x<0.2){
7860 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7862 // if(0.2<x&&x<0.4){
7863 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7873 //--------------------------------------------------
7874 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
7875 Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
7878 fstrptAss="ptAsMore05";
7880 if(!fhDeltaPhiTemplate){
7881 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
7893 fhBackSubtractionMin->SetBinContent(j,-0.07);
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++){
7899 fhBackSubtractionMax->SetBinContent(j,0.07);
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++){
7905 fhMCcorrectionsMin->SetBinContent(j,-0.04);
7908 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7909 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7910 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
7920 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7921 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7922 fhMCDefficiencyMax->SetBinContent(j,0.05);
7926 // Contamination from secondary tracks
7927 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7928 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7929 fhSecContaminationMin->SetBinContent(j,-0.035);
7932 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7933 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7934 fhSecContaminationMax->SetBinContent(j,0.035);
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);
7941 fhMCclosureTestMin->SetBinContent(j,-0.0);
7944 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7946 else if(-0.2<x&&x<-0.1){
7947 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7949 else if(-0.1<x&&x<0.1){
7950 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7952 else if(0.1<x&&x<0.2){
7953 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7956 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7960 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7961 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7962 x=fhMCclosureTestMax->GetBinLowEdge(j);
7963 fhMCclosureTestMax->SetBinContent(j,0.7);
7965 // if(-0.4<x&&x<-0.2){
7966 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7968 // else if(-0.2<x&&x<-0.1){
7969 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7971 // else if(-0.2<x&&x<-0.1){
7972 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7974 // else if(-0.1<x&&x<0.1){
7975 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7977 // else if(0.1<x&&x<0.2){
7978 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7980 // if(0.2<x&&x<0.4){
7981 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
7993 // if(-0.4<x&&x<-0.2){
7994 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7996 // else if(-0.2<x&&x<-0.1){
7997 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7999 // else if(-0.2<x&&x<-0.1){
8000 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8002 // else if(-0.1<x&&x<0.1){
8003 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8005 // else if(0.1<x&&x<0.2){
8006 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8008 // if(0.2<x&&x<0.4){
8009 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
8018 // if(-0.4<x&&x<-0.2){
8019 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8021 // else if(-0.2<x&&x<-0.1){
8022 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8024 // else if(-0.2<x&&x<-0.1){
8025 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8027 // else if(-0.1<x&&x<0.1){
8028 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8030 // else if(0.1<x&&x<0.2){
8031 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8033 // if(0.2<x&&x<0.4){
8034 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8042 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
8043 Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8046 fstrptAss="ptAsMore05";
8048 if(!fhDeltaPhiTemplate){
8049 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
8061 fhBackSubtractionMin->SetBinContent(j,-0.05);
8064 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8065 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8066 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
8072 fhMCcorrectionsMin->SetBinContent(j,-0.04);
8075 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8076 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8077 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
8086 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8087 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8088 fhMCDefficiencyMax->SetBinContent(j,0.05);
8092 // Contamination from secondary tracks
8093 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8094 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8095 fhSecContaminationMin->SetBinContent(j,-0.035);
8098 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8099 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8100 fhSecContaminationMax->SetBinContent(j,0.035);
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);
8107 fhMCclosureTestMin->SetBinContent(j,-0.0);
8110 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8112 else if(-0.2<x&&x<-0.1){
8113 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8115 else if(-0.1<x&&x<0.1){
8116 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8118 else if(0.1<x&&x<0.2){
8119 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8122 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8126 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8127 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8128 x=fhMCclosureTestMax->GetBinLowEdge(j);
8129 fhMCclosureTestMax->SetBinContent(j,0.07);
8131 // if(-0.4<x&&x<-0.2){
8132 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8134 // else if(-0.2<x&&x<-0.1){
8135 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8137 // else if(-0.2<x&&x<-0.1){
8138 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8140 // else if(-0.1<x&&x<0.1){
8141 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8143 // else if(0.1<x&&x<0.2){
8144 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8146 // if(0.2<x&&x<0.4){
8147 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
8159 // if(-0.4<x&&x<-0.2){
8160 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8162 // else if(-0.2<x&&x<-0.1){
8163 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8165 // else if(-0.2<x&&x<-0.1){
8166 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8168 // else if(-0.1<x&&x<0.1){
8169 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8171 // else if(0.1<x&&x<0.2){
8172 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8174 // if(0.2<x&&x<0.4){
8175 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
8184 // if(-0.4<x&&x<-0.2){
8185 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8187 // else if(-0.2<x&&x<-0.1){
8188 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8190 // else if(-0.2<x&&x<-0.1){
8191 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8193 // else if(-0.1<x&&x<0.1){
8194 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8196 // else if(0.1<x&&x<0.2){
8197 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8199 // if(0.2<x&&x<0.4){
8200 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8209 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05(){
8210 Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8213 fstrptAss="ptAsMore05";
8215 if(!fhDeltaPhiTemplate){
8216 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
8228 fhBackSubtractionMin->SetBinContent(j,-0.05);
8231 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8232 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8233 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
8239 fhMCcorrectionsMin->SetBinContent(j,-0.04);
8242 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8243 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8244 fhMCcorrectionsMax->SetBinContent(j,0.04);
8246 // MC D EFF CORRECTION
8247 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8248 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8249 fhMCDefficiencyMin->SetBinContent(j,-0.08);
8252 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8253 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8254 fhMCDefficiencyMax->SetBinContent(j,0.08);
8258 // Contamination from secondary tracks
8259 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8260 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8261 fhSecContaminationMin->SetBinContent(j,-0.035);
8264 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8265 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8266 fhSecContaminationMax->SetBinContent(j,0.035);
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);
8273 fhMCclosureTestMin->SetBinContent(j,-0.0);
8276 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8278 else if(-0.2<x&&x<-0.1){
8279 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8281 else if(-0.1<x&&x<0.1){
8282 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8284 else if(0.1<x&&x<0.2){
8285 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8288 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8292 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8293 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8294 x=fhMCclosureTestMax->GetBinLowEdge(j);
8295 fhMCclosureTestMax->SetBinContent(j,0.07);
8297 // if(-0.4<x&&x<-0.2){
8298 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8300 // else if(-0.2<x&&x<-0.1){
8301 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8303 // else if(-0.2<x&&x<-0.1){
8304 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8306 // else if(-0.1<x&&x<0.1){
8307 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8309 // else if(0.1<x&&x<0.2){
8310 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8312 // if(0.2<x&&x<0.4){
8313 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
8325 // if(-0.4<x&&x<-0.2){
8326 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8328 // else if(-0.2<x&&x<-0.1){
8329 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8331 // else if(-0.2<x&&x<-0.1){
8332 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8334 // else if(-0.1<x&&x<0.1){
8335 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8337 // else if(0.1<x&&x<0.2){
8338 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8340 // if(0.2<x&&x<0.4){
8341 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
8350 // if(-0.4<x&&x<-0.2){
8351 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8353 // else if(-0.2<x&&x<-0.1){
8354 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8356 // else if(-0.2<x&&x<-0.1){
8357 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8359 // else if(-0.1<x&&x<0.1){
8360 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8362 // else if(0.1<x&&x<0.2){
8363 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8365 // if(0.2<x&&x<0.4){
8366 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8376 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
8377 Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
8380 fstrptAss="ptAsMore05";
8382 if(!fhDeltaPhiTemplate){
8383 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
8395 fhBackSubtractionMin->SetBinContent(j,-0.1);
8398 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8399 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8400 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
8408 fhMCcorrectionsMin->SetBinContent(j,-0.04);
8411 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8412 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8413 fhMCcorrectionsMax->SetBinContent(j,0.04);
8416 // MC D EFF CORRECTION
8417 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8418 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8419 fhMCDefficiencyMin->SetBinContent(j,-0.1);
8422 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8423 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8424 fhMCDefficiencyMax->SetBinContent(j,0.1);
8428 // Contamination from secondary tracks
8429 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8430 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8431 fhSecContaminationMin->SetBinContent(j,-0.035);
8434 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8435 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8436 fhSecContaminationMax->SetBinContent(j,0.035);
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);
8444 fhMCclosureTestMin->SetBinContent(j,-0.0);
8447 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8449 else if(-0.2<x&&x<-0.1){
8450 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8452 else if(-0.1<x&&x<0.1){
8453 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8455 else if(0.1<x&&x<0.2){
8456 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8459 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8463 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8464 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8465 // x=fhMCclosureTestMax->GetBinLowEdge(j);
8466 fhMCclosureTestMax->SetBinContent(j,0.06);
8468 // if(-0.4<x&&x<-0.2){
8469 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8471 // else if(-0.2<x&&x<-0.1){
8472 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8474 // else if(-0.2<x&&x<-0.1){
8475 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8477 // else if(-0.1<x&&x<0.1){
8478 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8480 // else if(0.1<x&&x<0.2){
8481 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8483 // if(0.2<x&&x<0.4){
8484 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
8496 // if(-0.4<x&&x<-0.2){
8497 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8499 // else if(-0.2<x&&x<-0.1){
8500 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8502 // else if(-0.2<x&&x<-0.1){
8503 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8505 // else if(-0.1<x&&x<0.1){
8506 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8508 // else if(0.1<x&&x<0.2){
8509 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8511 // if(0.2<x&&x<0.4){
8512 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
8521 // if(-0.4<x&&x<-0.2){
8522 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8524 // else if(-0.2<x&&x<-0.1){
8525 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8527 // else if(-0.2<x&&x<-0.1){
8528 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8530 // else if(-0.1<x&&x<0.1){
8531 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8533 // else if(0.1<x&&x<0.2){
8534 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8536 // if(0.2<x&&x<0.4){
8537 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8544 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
8545 Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8548 fstrptAss="ptAsMore05";
8550 if(!fhDeltaPhiTemplate){
8551 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
8563 fhBackSubtractionMin->SetBinContent(j,-0.1);
8566 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8567 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8568 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
8574 fhMCcorrectionsMin->SetBinContent(j,-0.04);
8577 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8578 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8579 fhMCcorrectionsMax->SetBinContent(j,0.04);
8583 // MC D EFF CORRECTION
8584 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8585 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8586 fhMCDefficiencyMin->SetBinContent(j,-0.1);
8589 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8590 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8591 fhMCDefficiencyMax->SetBinContent(j,0.1);
8595 // Contamination from secondary tracks
8596 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8597 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8598 fhSecContaminationMin->SetBinContent(j,-0.035);
8601 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8602 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8603 fhSecContaminationMax->SetBinContent(j,0.035);
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);
8610 fhMCclosureTestMin->SetBinContent(j,-0.0);
8613 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8615 else if(-0.2<x&&x<-0.1){
8616 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8618 else if(-0.1<x&&x<0.1){
8619 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8621 else if(0.1<x&&x<0.2){
8622 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8625 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8629 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8630 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8631 x=fhMCclosureTestMax->GetBinLowEdge(j);
8632 fhMCclosureTestMax->SetBinContent(j,0.06);
8634 // if(-0.4<x&&x<-0.2){
8635 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8637 // else if(-0.2<x&&x<-0.1){
8638 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8640 // else if(-0.2<x&&x<-0.1){
8641 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8643 // else if(-0.1<x&&x<0.1){
8644 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8646 // else if(0.1<x&&x<0.2){
8647 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8649 // if(0.2<x&&x<0.4){
8650 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
8662 // if(-0.4<x&&x<-0.2){
8663 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8665 // else if(-0.2<x&&x<-0.1){
8666 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8668 // else if(-0.2<x&&x<-0.1){
8669 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8671 // else if(-0.1<x&&x<0.1){
8672 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8674 // else if(0.1<x&&x<0.2){
8675 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8677 // if(0.2<x&&x<0.4){
8678 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
8687 // if(-0.4<x&&x<-0.2){
8688 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8690 // else if(-0.2<x&&x<-0.1){
8691 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8693 // else if(-0.2<x&&x<-0.1){
8694 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8696 // else if(-0.1<x&&x<0.1){
8697 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8699 // else if(0.1<x&&x<0.2){
8700 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8702 // if(0.2<x&&x<0.4){
8703 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8711 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05(){
8712 Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8715 fstrptAss="ptAsMore05";
8717 if(!fhDeltaPhiTemplate){
8718 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
8731 fhBackSubtractionMin->SetBinContent(j,-0.1);
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++){
8737 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
8743 fhMCcorrectionsMin->SetBinContent(j,-0.04);
8746 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8747 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8748 fhMCcorrectionsMax->SetBinContent(j,0.04);
8752 // MC D EFF CORRECTION
8753 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8754 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8755 fhMCDefficiencyMin->SetBinContent(j,-0.1);
8758 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8759 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8760 fhMCDefficiencyMax->SetBinContent(j,0.1);
8764 // Contamination from secondary tracks
8765 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8766 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8767 fhSecContaminationMin->SetBinContent(j,-0.035);
8770 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8771 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8772 fhSecContaminationMax->SetBinContent(j,0.035);
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);
8779 fhMCclosureTestMin->SetBinContent(j,-0.0);
8782 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8784 else if(-0.2<x&&x<-0.1){
8785 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8787 else if(-0.1<x&&x<0.1){
8788 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8790 else if(0.1<x&&x<0.2){
8791 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8794 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8798 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8799 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8800 x=fhMCclosureTestMax->GetBinLowEdge(j);
8801 fhMCclosureTestMax->SetBinContent(j,0.06);
8803 // if(-0.4<x&&x<-0.2){
8804 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8806 // else if(-0.2<x&&x<-0.1){
8807 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8809 // else if(-0.2<x&&x<-0.1){
8810 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8812 // else if(-0.1<x&&x<0.1){
8813 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8815 // else if(0.1<x&&x<0.2){
8816 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8818 // if(0.2<x&&x<0.4){
8819 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
8831 // if(-0.4<x&&x<-0.2){
8832 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8834 // else if(-0.2<x&&x<-0.1){
8835 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8837 // else if(-0.2<x&&x<-0.1){
8838 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8840 // else if(-0.1<x&&x<0.1){
8841 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8843 // else if(0.1<x&&x<0.2){
8844 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8846 // if(0.2<x&&x<0.4){
8847 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
8856 // if(-0.4<x&&x<-0.2){
8857 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8859 // else if(-0.2<x&&x<-0.1){
8860 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8862 // else if(-0.2<x&&x<-0.1){
8863 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8865 // else if(-0.1<x&&x<0.1){
8866 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8868 // else if(0.1<x&&x<0.2){
8869 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8871 // if(0.2<x&&x<0.4){
8872 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8881 // pt(assoc)> 1 GeV/c
8882 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
8883 Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
8886 fstrptAss="ptAsMore1";
8888 if(!fhDeltaPhiTemplate){
8889 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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);
8904 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8905 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8906 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
8914 fhMCcorrectionsMin->SetBinContent(j,-0.04);
8917 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8918 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8919 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
8928 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8929 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8930 fhMCDefficiencyMax->SetBinContent(j,0.05);
8934 // Contamination from secondary tracks
8935 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8936 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8937 fhSecContaminationMin->SetBinContent(j,-0.035);
8940 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8941 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8942 fhSecContaminationMax->SetBinContent(j,0.035);
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);
8950 fhMCclosureTestMin->SetBinContent(j,-0.);
8953 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8955 else if(-0.2<x&&x<-0.1){
8956 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8958 else if(-0.1<x&&x<0.1){
8959 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8961 else if(0.1<x&&x<0.2){
8962 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8965 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8969 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8970 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8971 // x=fhMCclosureTestMax->GetBinLowEdge(j);
8972 fhMCclosureTestMax->SetBinContent(j,0.05);
8974 // if(-0.4<x&&x<-0.2){
8975 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8977 // else if(-0.2<x&&x<-0.1){
8978 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8980 // else if(-0.2<x&&x<-0.1){
8981 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8983 // else if(-0.1<x&&x<0.1){
8984 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8986 // else if(0.1<x&&x<0.2){
8987 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8989 // if(0.2<x&&x<0.4){
8990 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
9002 // if(-0.4<x&&x<-0.2){
9003 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9005 // else if(-0.2<x&&x<-0.1){
9006 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9008 // else if(-0.2<x&&x<-0.1){
9009 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9011 // else if(-0.1<x&&x<0.1){
9012 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9014 // else if(0.1<x&&x<0.2){
9015 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9017 // if(0.2<x&&x<0.4){
9018 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
9027 // if(-0.4<x&&x<-0.2){
9028 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9030 // else if(-0.2<x&&x<-0.1){
9031 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9033 // else if(-0.2<x&&x<-0.1){
9034 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9036 // else if(-0.1<x&&x<0.1){
9037 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9039 // else if(0.1<x&&x<0.2){
9040 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9042 // if(0.2<x&&x<0.4){
9043 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9050 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
9051 Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
9054 fstrptAss="ptAsMore1";
9056 if(!fhDeltaPhiTemplate){
9057 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
9069 fhBackSubtractionMin->SetBinContent(j,-0.05);
9072 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9073 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9074 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
9080 fhMCcorrectionsMin->SetBinContent(j,-0.04);
9083 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9084 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9085 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
9095 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9096 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9097 fhMCDefficiencyMax->SetBinContent(j,0.05);
9101 // Contamination from secondary tracks
9102 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9103 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9104 fhSecContaminationMin->SetBinContent(j,-0.035);
9107 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9108 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9109 fhSecContaminationMax->SetBinContent(j,0.035);
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);
9116 fhMCclosureTestMin->SetBinContent(j,-0.);
9119 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9121 else if(-0.2<x&&x<-0.1){
9122 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9124 else if(-0.1<x&&x<0.1){
9125 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9127 else if(0.1<x&&x<0.2){
9128 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9131 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9135 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9136 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9137 x=fhMCclosureTestMax->GetBinLowEdge(j);
9138 fhMCclosureTestMax->SetBinContent(j,0.05);
9140 // if(-0.4<x&&x<-0.2){
9141 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9143 // else if(-0.2<x&&x<-0.1){
9144 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9146 // else if(-0.2<x&&x<-0.1){
9147 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9149 // else if(-0.1<x&&x<0.1){
9150 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9152 // else if(0.1<x&&x<0.2){
9153 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9155 // if(0.2<x&&x<0.4){
9156 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
9168 // if(-0.4<x&&x<-0.2){
9169 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9171 // else if(-0.2<x&&x<-0.1){
9172 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9174 // else if(-0.2<x&&x<-0.1){
9175 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9177 // else if(-0.1<x&&x<0.1){
9178 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9180 // else if(0.1<x&&x<0.2){
9181 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9183 // if(0.2<x&&x<0.4){
9184 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
9193 // if(-0.4<x&&x<-0.2){
9194 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9196 // else if(-0.2<x&&x<-0.1){
9197 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9199 // else if(-0.2<x&&x<-0.1){
9200 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9202 // else if(-0.1<x&&x<0.1){
9203 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9205 // else if(0.1<x&&x<0.2){
9206 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9208 // if(0.2<x&&x<0.4){
9209 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9217 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
9218 Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
9221 fstrptAss="ptAsMore1";
9223 if(!fhDeltaPhiTemplate){
9224 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
9237 fhBackSubtractionMin->SetBinContent(j,-0.05);
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);
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++){
9249 fhMCcorrectionsMin->SetBinContent(j,-0.04);
9252 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9253 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9254 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
9264 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9265 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9266 fhMCDefficiencyMax->SetBinContent(j,0.05);
9270 // Contamination from secondary tracks
9271 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9272 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9273 fhSecContaminationMin->SetBinContent(j,-0.035);
9276 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9277 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9278 fhSecContaminationMax->SetBinContent(j,0.035);
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);
9285 fhMCclosureTestMin->SetBinContent(j,-0.);
9288 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9290 else if(-0.2<x&&x<-0.1){
9291 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9293 else if(-0.1<x&&x<0.1){
9294 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9296 else if(0.1<x&&x<0.2){
9297 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9300 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9304 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9305 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9306 x=fhMCclosureTestMax->GetBinLowEdge(j);
9307 fhMCclosureTestMax->SetBinContent(j,0.05);
9309 // if(-0.4<x&&x<-0.2){
9310 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9312 // else if(-0.2<x&&x<-0.1){
9313 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9315 // else if(-0.2<x&&x<-0.1){
9316 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9318 // else if(-0.1<x&&x<0.1){
9319 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9321 // else if(0.1<x&&x<0.2){
9322 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9324 // if(0.2<x&&x<0.4){
9325 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
9337 // if(-0.4<x&&x<-0.2){
9338 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9340 // else if(-0.2<x&&x<-0.1){
9341 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9343 // else if(-0.2<x&&x<-0.1){
9344 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9346 // else if(-0.1<x&&x<0.1){
9347 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9349 // else if(0.1<x&&x<0.2){
9350 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9352 // if(0.2<x&&x<0.4){
9353 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
9362 // if(-0.4<x&&x<-0.2){
9363 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9365 // else if(-0.2<x&&x<-0.1){
9366 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9368 // else if(-0.2<x&&x<-0.1){
9369 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9371 // else if(-0.1<x&&x<0.1){
9372 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9374 // else if(0.1<x&&x<0.2){
9375 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9377 // if(0.2<x&&x<0.4){
9378 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9388 //--------------------------------------------------
9389 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
9390 Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9393 fstrptAss="ptAsMore1";
9395 if(!fhDeltaPhiTemplate){
9396 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
9408 fhBackSubtractionMin->SetBinContent(j,-0.08);
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++){
9414 fhBackSubtractionMax->SetBinContent(j,0.08);
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++){
9420 fhMCcorrectionsMin->SetBinContent(j,-0.04);
9423 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9424 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9425 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
9435 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9436 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9437 fhMCDefficiencyMax->SetBinContent(j,0.05);
9441 // Contamination from secondary tracks
9442 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9443 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9444 fhSecContaminationMin->SetBinContent(j,-0.035);
9447 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9448 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9449 fhSecContaminationMax->SetBinContent(j,0.035);
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);
9456 fhMCclosureTestMin->SetBinContent(j,-0.0);
9459 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9461 else if(-0.2<x&&x<-0.1){
9462 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9464 else if(-0.1<x&&x<0.1){
9465 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9467 else if(0.1<x&&x<0.2){
9468 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9471 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9475 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9476 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9477 x=fhMCclosureTestMax->GetBinLowEdge(j);
9478 fhMCclosureTestMax->SetBinContent(j,0.05);
9480 // if(-0.4<x&&x<-0.2){
9481 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9483 // else if(-0.2<x&&x<-0.1){
9484 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9486 // else if(-0.2<x&&x<-0.1){
9487 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9489 // else if(-0.1<x&&x<0.1){
9490 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9492 // else if(0.1<x&&x<0.2){
9493 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9495 // if(0.2<x&&x<0.4){
9496 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
9508 // if(-0.4<x&&x<-0.2){
9509 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9511 // else if(-0.2<x&&x<-0.1){
9512 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9514 // else if(-0.2<x&&x<-0.1){
9515 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9517 // else if(-0.1<x&&x<0.1){
9518 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9520 // else if(0.1<x&&x<0.2){
9521 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9523 // if(0.2<x&&x<0.4){
9524 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
9533 // if(-0.4<x&&x<-0.2){
9534 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9536 // else if(-0.2<x&&x<-0.1){
9537 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9539 // else if(-0.2<x&&x<-0.1){
9540 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9542 // else if(-0.1<x&&x<0.1){
9543 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9545 // else if(0.1<x&&x<0.2){
9546 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9548 // if(0.2<x&&x<0.4){
9549 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9557 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
9558 Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
9561 fstrptAss="ptAsMore1";
9563 if(!fhDeltaPhiTemplate){
9564 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
9576 fhBackSubtractionMin->SetBinContent(j,-0.06);
9579 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9580 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9581 fhBackSubtractionMax->SetBinContent(j,0.06);
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++){
9587 fhMCcorrectionsMin->SetBinContent(j,-0.04);
9590 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9591 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9592 fhMCcorrectionsMax->SetBinContent(j,0.04);
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);
9601 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9602 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9603 fhMCDefficiencyMax->SetBinContent(j,0.05);
9607 // Contamination from secondary tracks
9608 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9609 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9610 fhSecContaminationMin->SetBinContent(j,-0.035);
9613 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9614 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9615 fhSecContaminationMax->SetBinContent(j,0.035);
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);
9622 fhMCclosureTestMin->SetBinContent(j,-0.);
9625 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9627 else if(-0.2<x&&x<-0.1){
9628 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9630 else if(-0.1<x&&x<0.1){
9631 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9633 else if(0.1<x&&x<0.2){
9634 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9637 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9641 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9642 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9643 x=fhMCclosureTestMax->GetBinLowEdge(j);
9644 fhMCclosureTestMax->SetBinContent(j,0.05);
9646 // if(-0.4<x&&x<-0.2){
9647 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9649 // else if(-0.2<x&&x<-0.1){
9650 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9652 // else if(-0.2<x&&x<-0.1){
9653 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9655 // else if(-0.1<x&&x<0.1){
9656 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9658 // else if(0.1<x&&x<0.2){
9659 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9661 // if(0.2<x&&x<0.4){
9662 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
9674 // if(-0.4<x&&x<-0.2){
9675 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9677 // else if(-0.2<x&&x<-0.1){
9678 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9680 // else if(-0.2<x&&x<-0.1){
9681 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9683 // else if(-0.1<x&&x<0.1){
9684 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9686 // else if(0.1<x&&x<0.2){
9687 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9689 // if(0.2<x&&x<0.4){
9690 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
9699 // if(-0.4<x&&x<-0.2){
9700 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9702 // else if(-0.2<x&&x<-0.1){
9703 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9705 // else if(-0.2<x&&x<-0.1){
9706 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9708 // else if(-0.1<x&&x<0.1){
9709 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9711 // else if(0.1<x&&x<0.2){
9712 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9714 // if(0.2<x&&x<0.4){
9715 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9724 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
9725 Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
9728 fstrptAss="ptAsMore1";
9730 if(!fhDeltaPhiTemplate){
9731 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
9743 fhBackSubtractionMin->SetBinContent(j,-0.05);
9746 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9747 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9748 fhBackSubtractionMax->SetBinContent(j,0.05);
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++){
9754 fhMCcorrectionsMin->SetBinContent(j,-0.04);
9757 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9758 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9759 fhMCcorrectionsMax->SetBinContent(j,0.04);
9761 // MC D EFF CORRECTION
9762 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9763 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9764 fhMCDefficiencyMin->SetBinContent(j,-0.08);
9767 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9768 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9769 fhMCDefficiencyMax->SetBinContent(j,0.08);
9773 // Contamination from secondary tracks
9774 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9775 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9776 fhSecContaminationMin->SetBinContent(j,-0.035);
9779 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9780 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9781 fhSecContaminationMax->SetBinContent(j,0.035);
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);
9788 fhMCclosureTestMin->SetBinContent(j,-0);
9791 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9793 else if(-0.2<x&&x<-0.1){
9794 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9796 else if(-0.1<x&&x<0.1){
9797 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9799 else if(0.1<x&&x<0.2){
9800 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9803 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9807 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9808 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9809 x=fhMCclosureTestMax->GetBinLowEdge(j);
9810 fhMCclosureTestMax->SetBinContent(j,0.05);
9812 // if(-0.4<x&&x<-0.2){
9813 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9815 // else if(-0.2<x&&x<-0.1){
9816 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9818 // else if(-0.2<x&&x<-0.1){
9819 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9821 // else if(-0.1<x&&x<0.1){
9822 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9824 // else if(0.1<x&&x<0.2){
9825 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9827 // if(0.2<x&&x<0.4){
9828 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
9840 // if(-0.4<x&&x<-0.2){
9841 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9843 // else if(-0.2<x&&x<-0.1){
9844 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9846 // else if(-0.2<x&&x<-0.1){
9847 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9849 // else if(-0.1<x&&x<0.1){
9850 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9852 // else if(0.1<x&&x<0.2){
9853 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9855 // if(0.2<x&&x<0.4){
9856 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
9865 // if(-0.4<x&&x<-0.2){
9866 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9868 // else if(-0.2<x&&x<-0.1){
9869 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9871 // else if(-0.2<x&&x<-0.1){
9872 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9874 // else if(-0.1<x&&x<0.1){
9875 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9877 // else if(0.1<x&&x<0.2){
9878 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9880 // if(0.2<x&&x<0.4){
9881 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9891 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
9892 Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9895 fstrptAss="ptAsMore1";
9897 if(!fhDeltaPhiTemplate){
9898 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
9910 fhBackSubtractionMin->SetBinContent(j,-0.1);
9913 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9914 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9915 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
9923 fhMCcorrectionsMin->SetBinContent(j,-0.04);
9926 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9927 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9928 fhMCcorrectionsMax->SetBinContent(j,0.04);
9931 // MC D EFF CORRECTION
9932 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9933 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9934 fhMCDefficiencyMin->SetBinContent(j,-0.1);
9937 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9938 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9939 fhMCDefficiencyMax->SetBinContent(j,0.1);
9943 // Contamination from secondary tracks
9944 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9945 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9946 fhSecContaminationMin->SetBinContent(j,-0.035);
9949 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9950 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9951 fhSecContaminationMax->SetBinContent(j,0.035);
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);
9959 fhMCclosureTestMin->SetBinContent(j,-0.0);
9962 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9964 else if(-0.2<x&&x<-0.1){
9965 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9967 else if(-0.1<x&&x<0.1){
9968 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9970 else if(0.1<x&&x<0.2){
9971 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9974 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9978 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9979 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9980 // x=fhMCclosureTestMax->GetBinLowEdge(j);
9981 fhMCclosureTestMax->SetBinContent(j,0.05);
9983 // if(-0.4<x&&x<-0.2){
9984 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9986 // else if(-0.2<x&&x<-0.1){
9987 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9989 // else if(-0.2<x&&x<-0.1){
9990 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9992 // else if(-0.1<x&&x<0.1){
9993 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9995 // else if(0.1<x&&x<0.2){
9996 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9998 // if(0.2<x&&x<0.4){
9999 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
10011 // if(-0.4<x&&x<-0.2){
10012 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10014 // else if(-0.2<x&&x<-0.1){
10015 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10017 // else if(-0.2<x&&x<-0.1){
10018 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10020 // else if(-0.1<x&&x<0.1){
10021 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10023 // else if(0.1<x&&x<0.2){
10024 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10026 // if(0.2<x&&x<0.4){
10027 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
10036 // if(-0.4<x&&x<-0.2){
10037 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10039 // else if(-0.2<x&&x<-0.1){
10040 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10042 // else if(-0.2<x&&x<-0.1){
10043 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10045 // else if(-0.1<x&&x<0.1){
10046 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10048 // else if(0.1<x&&x<0.2){
10049 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10051 // if(0.2<x&&x<0.4){
10052 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10059 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
10060 Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
10063 fstrptAss="ptAsMore1";
10065 if(!fhDeltaPhiTemplate){
10066 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
10078 fhBackSubtractionMin->SetBinContent(j,-0.1);
10081 fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10082 for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
10083 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
10089 fhMCcorrectionsMin->SetBinContent(j,-0.04);
10092 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10093 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
10094 fhMCcorrectionsMax->SetBinContent(j,0.04);
10098 // MC D EFF CORRECTION
10099 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10100 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
10101 fhMCDefficiencyMin->SetBinContent(j,-0.1);
10104 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10105 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
10106 fhMCDefficiencyMax->SetBinContent(j,0.1);
10110 // Contamination from secondary tracks
10111 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10112 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
10113 fhSecContaminationMin->SetBinContent(j,-0.035);
10116 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10117 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
10118 fhSecContaminationMax->SetBinContent(j,0.035);
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);
10125 fhMCclosureTestMin->SetBinContent(j,-0.0);
10127 if(-0.4<x&&x<-0.2){
10128 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10130 else if(-0.2<x&&x<-0.1){
10131 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10133 else if(-0.1<x&&x<0.1){
10134 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10136 else if(0.1<x&&x<0.2){
10137 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10140 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10144 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10145 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10146 x=fhMCclosureTestMax->GetBinLowEdge(j);
10147 fhMCclosureTestMax->SetBinContent(j,0.05);
10149 // if(-0.4<x&&x<-0.2){
10150 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10152 // else if(-0.2<x&&x<-0.1){
10153 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10155 // else if(-0.2<x&&x<-0.1){
10156 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10158 // else if(-0.1<x&&x<0.1){
10159 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10161 // else if(0.1<x&&x<0.2){
10162 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10164 // if(0.2<x&&x<0.4){
10165 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
10177 // if(-0.4<x&&x<-0.2){
10178 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10180 // else if(-0.2<x&&x<-0.1){
10181 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10183 // else if(-0.2<x&&x<-0.1){
10184 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10186 // else if(-0.1<x&&x<0.1){
10187 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10189 // else if(0.1<x&&x<0.2){
10190 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10192 // if(0.2<x&&x<0.4){
10193 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
10202 // if(-0.4<x&&x<-0.2){
10203 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10205 // else if(-0.2<x&&x<-0.1){
10206 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10208 // else if(-0.2<x&&x<-0.1){
10209 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10211 // else if(-0.1<x&&x<0.1){
10212 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10214 // else if(0.1<x&&x<0.2){
10215 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10217 // if(0.2<x&&x<0.4){
10218 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10226 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){
10227 Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
10230 fstrptAss="ptAsMore1";
10231 fstrptD="Dpt8to16";
10232 if(!fhDeltaPhiTemplate){
10233 fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
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);
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++){
10246 fhBackSubtractionMin->SetBinContent(j,-0.1);
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++){
10252 fhBackSubtractionMax->SetBinContent(j,0.1);
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++){
10258 fhMCcorrectionsMin->SetBinContent(j,-0.04);
10261 fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10262 for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
10263 fhMCcorrectionsMax->SetBinContent(j,0.04);
10267 // MC D EFF CORRECTION
10268 fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10269 for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
10270 fhMCDefficiencyMin->SetBinContent(j,-0.1);
10273 fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10274 for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
10275 fhMCDefficiencyMax->SetBinContent(j,0.1);
10279 // Contamination from secondary tracks
10280 fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10281 for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
10282 fhSecContaminationMin->SetBinContent(j,-0.035);
10285 fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10286 for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
10287 fhSecContaminationMax->SetBinContent(j,0.035);
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);
10294 fhMCclosureTestMin->SetBinContent(j,-0.0);
10296 if(-0.4<x&&x<-0.2){
10297 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10299 else if(-0.2<x&&x<-0.1){
10300 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10302 else if(-0.1<x&&x<0.1){
10303 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10305 else if(0.1<x&&x<0.2){
10306 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10309 fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10313 fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10314 for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10315 x=fhMCclosureTestMax->GetBinLowEdge(j);
10316 fhMCclosureTestMax->SetBinContent(j,0.05);
10318 // if(-0.4<x&&x<-0.2){
10319 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10321 // else if(-0.2<x&&x<-0.1){
10322 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10324 // else if(-0.2<x&&x<-0.1){
10325 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10327 // else if(-0.1<x&&x<0.1){
10328 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10330 // else if(0.1<x&&x<0.2){
10331 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10333 // if(0.2<x&&x<0.4){
10334 // fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
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);
10346 // if(-0.4<x&&x<-0.2){
10347 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10349 // else if(-0.2<x&&x<-0.1){
10350 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10352 // else if(-0.2<x&&x<-0.1){
10353 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10355 // else if(-0.1<x&&x<0.1){
10356 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10358 // else if(0.1<x&&x<0.2){
10359 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10361 // if(0.2<x&&x<0.4){
10362 // fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
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);
10371 // if(-0.4<x&&x<-0.2){
10372 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10374 // else if(-0.2<x&&x<-0.1){
10375 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10377 // else if(-0.2<x&&x<-0.1){
10378 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10380 // else if(-0.1<x&&x<0.1){
10381 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10383 // else if(0.1<x&&x<0.2){
10384 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10386 // if(0.2<x&&x<0.4){
10387 // fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);