PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16
  17 /* $Id: $ */
  18
  19 /////////////////////////////////////////////////////////////
  20 // class for systematic uncertainties on D meson -hadron correlation distribution
  21 //
  22 // Author: A. Rossi, andrea.rossi@cern.ch
  23 /////////////////////////////////////////////////////////////
  24 #include <Riostream.h>
  25 #include "AliHFDhadronCorrSystUnc.h"
  26 #include <TMath.h>
  27 #include <TH1D.h>
  28 #include <TH2D.h>
  29 #include <TCanvas.h>
  30 #include <TGraphAsymmErrors.h>
  31 #include <TNamed.h>
  32
  33 using std::cout;
  34 using std::endl;
  35
  36 ClassImp(AliHFDhadronCorrSystUnc)
  37
  38 AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc() : TNamed(),
  39   fmeson(),
  40   fstrmeson(),
  41   fstrptAss(),
  42   fstrptD(),
  43   fhDeltaPhiTemplate(),
  44   fhYieldExtraction(),
  45   fhBackSubtractionMin(),
  46   fhBackSubtractionMax(),
  47   fhBeautyFDmin(),
  48   fhBeautyFDmax(),
  49   fhMCclosureTestMin(),
  50   fhMCclosureTestMax(),
  51   fhMCcorrectionsMin(),
  52   fhMCcorrectionsMax(),
  53   fhMCDefficiencyMin(),
  54   fhMCDefficiencyMax(),
  55   fhSecContaminationMin(),
  56   fhSecContaminationMax(),
  57   fhTotalMin(),
  58   fhTotalMax(),
  59   fhTotalNonFDMin(),
  60   fhTotalNonFDMax(),
  61   fhTotalNonFlatDPhiMin(),
  62   fhTotalNonFlatDPhiMax(),
  63   fhtotFlatMin(),
  64   fhtotFlatMax(),
  65   fgrYieldUnc(),
  66   fgrBackSubUnc(),
  67   fgrMCcorrections(),
  68   fgrMCDefficiency(),
  69   fgrSecContamination(),
  70   fgrMCclosureTest(),
  71   fgrBeautyFD(),
  72   fgrYieldUncRel(),
  73   fgrBackSubUncRel(),
  74   fgrMCcorrectionsRel(),
  75   fgrMCDefficiencyRel(),
  76   fgrSecContaminationRel(),
  77   fgrMCclosureTestRel(),
  78   fgrBeautyFDRel(),
  79   fgrTotal(),
  80   fgrTotalRel(),
  81   fgrTotalNonFD(),
  82   fgrTotalNonFlatDPhi(),
  83   fgrTotalNonFlatDPhiRel(),
  84   fgrTotalFlatDPhi(),
  85   fgrTotalFlatDPhiRel()
  86
  87 {
  88   // default constructor
  89 }
  90
  91
  92 AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc(const char* name) :
  93   TNamed(name,name),
  94   fmeson(),
  95   fstrmeson(),
  96   fstrptAss(),
  97   fstrptD(),
  98   fhDeltaPhiTemplate(),
  99   fhYieldExtraction(),
 100   fhBackSubtractionMin(),
 101   fhBackSubtractionMax(),
 102   fhBeautyFDmin(),
 103   fhBeautyFDmax(),
 104   fhMCclosureTestMin(),
 105   fhMCclosureTestMax(),
 106   fhMCcorrectionsMin(),
 107   fhMCcorrectionsMax(),
 108   fhMCDefficiencyMin(),
 109   fhMCDefficiencyMax(),
 110   fhSecContaminationMin(),
 111   fhSecContaminationMax(),
 112   fhTotalMin(),
 113   fhTotalMax(),
 114   fhTotalNonFDMin(),
 115   fhTotalNonFDMax(),
 116   fhTotalNonFlatDPhiMin(),
 117   fhTotalNonFlatDPhiMax(),
 118   fhtotFlatMin(),
 119   fhtotFlatMax(),
 120   fgrYieldUnc(),
 121   fgrBackSubUnc(),
 122   fgrMCcorrections(),
 123   fgrMCDefficiency(),
 124   fgrSecContamination(),
 125   fgrMCclosureTest(),
 126   fgrBeautyFD(),
 127   fgrYieldUncRel(),
 128   fgrBackSubUncRel(),
 129   fgrMCcorrectionsRel(),
 130   fgrMCDefficiencyRel(),
 131   fgrSecContaminationRel(),
 132   fgrMCclosureTestRel(),
 133   fgrBeautyFDRel(),
 134   fgrTotal(),
 135   fgrTotalRel(),
 136   fgrTotalNonFD(),
 137   fgrTotalNonFlatDPhi(),
 138   fgrTotalNonFlatDPhiRel(),
 139   fgrTotalFlatDPhi(),
 140   fgrTotalFlatDPhiRel()
 141 {
 142   // default constructor
 143 }
 144
 145
 146
 147 AliHFDhadronCorrSystUnc::~AliHFDhadronCorrSystUnc(){
 148   // destructor
 149
 150   delete fhDeltaPhiTemplate;
 151   delete fhYieldExtraction;
 152   delete fhBackSubtractionMin;
 153   delete   fhBackSubtractionMax;
 154   delete  fhBeautyFDmin;
 155   delete  fhBeautyFDmax;
 156   delete  fhMCclosureTestMin;
 157   delete  fhMCclosureTestMax;
 158   delete  fhMCcorrectionsMin;
 159   delete  fhMCcorrectionsMax;
 160   delete  fhMCDefficiencyMin;
 161   delete  fhMCDefficiencyMax;
 162   delete  fhSecContaminationMin;
 163   delete  fhSecContaminationMax;
 164   delete  fhTotalMin;
 165   delete fhTotalMax;
 166   delete fhTotalNonFDMin;
 167   delete fhTotalNonFDMax;
 168   delete fhTotalNonFlatDPhiMin;
 169   delete fhTotalNonFlatDPhiMax;
 170   delete fhtotFlatMin;
 171   delete fhtotFlatMax;
 172   delete fgrYieldUnc;
 173   delete fgrBackSubUnc;
 174   delete fgrMCcorrections;
 175   delete fgrMCDefficiency;
 176   delete fgrSecContamination;
 177   delete fgrMCclosureTest;
 178   delete fgrBeautyFD;
 179   delete fgrYieldUncRel;
 180   delete fgrBackSubUncRel;
 181   delete fgrMCcorrectionsRel;
 182   delete fgrMCDefficiencyRel;
 183   delete fgrSecContaminationRel;
 184   delete fgrMCclosureTestRel;
 185   delete fgrBeautyFDRel;
 186   delete fgrTotal;
 187   delete fgrTotalRel;
 188   delete fgrTotalNonFD;
 189   delete fgrTotalNonFlatDPhi;
 190   delete fgrTotalNonFlatDPhiRel;
 191   delete fgrTotalFlatDPhi;
 192   delete fgrTotalFlatDPhiRel;
 193
 194 }
 195
 196
 197 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP(){
 198   Printf("Loading syst unc for D0 pp2010 3-5 0.3 thr");
 199   fmeson=0;
 200   fstrmeson="Dzero";
 201   fstrptAss="ptAsMore03";
 202   fstrptD="Dpt3to5";
 203   if(!fhDeltaPhiTemplate){
 204     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 205   }
 206   Double_t x;
 207   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 208   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 209   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 210     fhYieldExtraction->SetBinContent(j,0.1);
 211   }
 212
 213   // Background D MESON candidate subtraction (side-band variations, etc.)
 214   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 215   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 216     fhBackSubtractionMin->SetBinContent(j,-0.05);
 217   }
 218
 219   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 220   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 221     fhBackSubtractionMax->SetBinContent(j,0.05);
 222   }
 223
 224
 225   // MC CORRECTIONS ( associatate track efficiency):
 226   //  -5%  +10% for assoc track eff
 227   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 228   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 229     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 230   }
 231
 232   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 233   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 234     fhMCcorrectionsMax->SetBinContent(j,0.10);
 235   }
 236
 237   // MC D EFF CORRECTION
 238   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 239   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 240     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 241   }
 242
 243   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 244   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 245     fhMCDefficiencyMax->SetBinContent(j,0.05);
 246   }
 247
 248
 249   // Contamination from secondary tracks
 250   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 251   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 252     fhSecContaminationMin->SetBinContent(j,-0.05);
 253   }
 254
 255   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 256   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 257     fhSecContaminationMax->SetBinContent(j,0.05);
 258   }
 259
 260
 261   // MC CLOSURETEST (D meson efficiency)
 262   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 263   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 264     x=fhMCclosureTestMin->GetBinLowEdge(j);
 265     fhMCclosureTestMin->SetBinContent(j,-0.08);
 266
 267     if(-0.4<x&&x<-0.2){
 268       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 269     }
 270     else if(-0.2<x&&x<-0.1){
 271       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 272     }
 273     else if(-0.1<x&&x<0.1){
 274       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 275     }
 276     else if(0.1<x&&x<0.2){
 277       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 278     }
 279     if(0.2<x&&x<0.4){
 280       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 281     }
 282   }
 283
 284   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 285   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 286     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
 287     fhMCclosureTestMax->SetBinContent(j,0.);
 288
 289     //     if(-0.4<x&&x<-0.2){
 290     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 291     //     }
 292     //     else if(-0.2<x&&x<-0.1){
 293     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 294     //     }
 295     //     else if(-0.2<x&&x<-0.1){
 296     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 297     //     }
 298     //     else if(-0.1<x&&x<0.1){
 299     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 300     //     }
 301     //     else if(0.1<x&&x<0.2){
 302     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 303     //     }
 304     //     if(0.2<x&&x<0.4){
 305     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 306     //     }
 307
 308   }
 309
 310   // Feed-down
 311
 312   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 313   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 314     x=fhBeautyFDmin->GetBinLowEdge(j);
 315     fhBeautyFDmin->SetBinContent(j,-0.05);
 316
 317   //   if(-0.4<x&&x<-0.2){
 318 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 319 //     }
 320 //     else if(-0.2<x&&x<-0.1){
 321 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 322 //     }
 323 //     else if(-0.2<x&&x<-0.1){
 324 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 325 //     }
 326 //     else if(-0.1<x&&x<0.1){
 327 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 328 //     }
 329 //     else if(0.1<x&&x<0.2){
 330 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 331 //     }
 332 //     if(0.2<x&&x<0.4){
 333 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 334 //     }
 335   }
 336
 337   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 338   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 339     x=fhBeautyFDmax->GetBinLowEdge(j);
 340     fhBeautyFDmax->SetBinContent(j,0.03);
 341
 342 //     if(-0.4<x&&x<-0.2){
 343 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 344 //     }
 345 //     else if(-0.2<x&&x<-0.1){
 346 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 347 //     }
 348 //     else if(-0.2<x&&x<-0.1){
 349 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 350 //     }
 351 //     else if(-0.1<x&&x<0.1){
 352 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 353 //     }
 354 //     else if(0.1<x&&x<0.2){
 355 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 356 //     }
 357 //     if(0.2<x&&x<0.4){
 358 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 359 //     }
 360
 361   }
 362
 363 }
 364
 365 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP(){
 366   Printf("Loading syst unc for D0 pp2010 5-8 0.3 thr");
 367
 368   fmeson=0;
 369   fstrmeson="Dzero";
 370   fstrptAss="ptAsMore03";
 371   fstrptD="Dpt5to8";
 372   if(!fhDeltaPhiTemplate){
 373     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 374   }
 375   Double_t x;
 376   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 377   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 378   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 379     fhYieldExtraction->SetBinContent(j,0.1);
 380   }
 381
 382   // Background D MESON candidate subtraction (side-band variations, etc.)
 383   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 384   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 385     fhBackSubtractionMin->SetBinContent(j,-0.05);
 386   }
 387
 388   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 389   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 390     fhBackSubtractionMax->SetBinContent(j,0.05);
 391   }
 392
 393   // MC CORRECTIONS:  -5%  +10% for assoc track eff
 394   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 395   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 396     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 397   }
 398
 399   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 400   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 401     fhMCcorrectionsMax->SetBinContent(j,0.10);
 402   }
 403
 404
 405   // MC D EFF CORRECTION
 406   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 407   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 408     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 409   }
 410
 411   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 412   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 413     fhMCDefficiencyMax->SetBinContent(j,0.05);
 414   }
 415
 416
 417   // Contamination from secondary tracks
 418   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 419   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 420     fhSecContaminationMin->SetBinContent(j,-0.05);
 421   }
 422
 423   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 424   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 425     fhSecContaminationMax->SetBinContent(j,0.05);
 426   }
 427
 428   // MC CLOSURETEST (D meson efficiency)
 429   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 430   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 431     x=fhMCclosureTestMin->GetBinLowEdge(j);
 432     fhMCclosureTestMin->SetBinContent(j,-0.08);
 433
 434     if(-0.4<x&&x<-0.2){
 435       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 436     }
 437     else if(-0.2<x&&x<-0.1){
 438       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 439     }
 440     else if(-0.1<x&&x<0.1){
 441       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 442     }
 443     else if(0.1<x&&x<0.2){
 444       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 445     }
 446     if(0.2<x&&x<0.4){
 447       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 448     }
 449   }
 450
 451   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 452   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 453     x=fhMCclosureTestMax->GetBinLowEdge(j);
 454     fhMCclosureTestMax->SetBinContent(j,0.);
 455
 456     //     if(-0.4<x&&x<-0.2){
 457     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 458     //     }
 459     //     else if(-0.2<x&&x<-0.1){
 460     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 461     //     }
 462     //     else if(-0.2<x&&x<-0.1){
 463     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 464     //     }
 465     //     else if(-0.1<x&&x<0.1){
 466     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 467     //     }
 468     //     else if(0.1<x&&x<0.2){
 469     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 470     //     }
 471     //     if(0.2<x&&x<0.4){
 472     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 473     //     }
 474
 475   }
 476
 477   // Feed-down
 478
 479   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 480   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 481     x=fhBeautyFDmin->GetBinLowEdge(j);
 482     fhBeautyFDmin->SetBinContent(j,-0.05);
 483
 484   //   if(-0.4<x&&x<-0.2){
 485 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 486 //     }
 487 //     else if(-0.2<x&&x<-0.1){
 488 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 489 //     }
 490 //     else if(-0.2<x&&x<-0.1){
 491 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 492 //     }
 493 //     else if(-0.1<x&&x<0.1){
 494 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 495 //     }
 496 //     else if(0.1<x&&x<0.2){
 497 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 498 //     }
 499 //     if(0.2<x&&x<0.4){
 500 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 501 //     }
 502   }
 503
 504   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 505   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 506     x=fhBeautyFDmax->GetBinLowEdge(j);
 507     fhBeautyFDmax->SetBinContent(j,0.03);
 508
 509 //     if(-0.4<x&&x<-0.2){
 510 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 511 //     }
 512 //     else if(-0.2<x&&x<-0.1){
 513 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 514 //     }
 515 //     else if(-0.2<x&&x<-0.1){
 516 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 517 //     }
 518 //     else if(-0.1<x&&x<0.1){
 519 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 520 //     }
 521 //     else if(0.1<x&&x<0.2){
 522 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 523 //     }
 524 //     if(0.2<x&&x<0.4){
 525 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 526 //     }
 527
 528   }
 529
 530 }
 531
 532
 533 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(){
 534
 535   Printf("Loading syst unc for D0 pp2010 8-16 0.3 thr");
 536
 537   fmeson=0;
 538   fstrmeson="Dzero";
 539   fstrptAss="ptAsMore03";
 540   fstrptD="Dpt8to16";
 541   if(!fhDeltaPhiTemplate){
 542     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 543   }
 544
 545   Double_t x;
 546   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 547   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 548   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 549     fhYieldExtraction->SetBinContent(j,0.1);
 550   }
 551
 552   // Background D MESON candidate subtraction (side-band variations, etc.)
 553   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 554   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 555     fhBackSubtractionMin->SetBinContent(j,-0.05);
 556   }
 557
 558   // Background D MESON candidate subtraction (side-band variations, etc.)
 559   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 560   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 561     fhBackSubtractionMax->SetBinContent(j,0.05);
 562   }
 563
 564   // MC CORRECTIONS,  -5% 10% for assoc track eff
 565   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 566   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 567     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 568   }
 569
 570   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 571   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 572     fhMCcorrectionsMax->SetBinContent(j,0.10);
 573   }
 574
 575
 576   // MC D EFF CORRECTION
 577   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 578   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 579     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 580   }
 581
 582   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 583   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 584     fhMCDefficiencyMax->SetBinContent(j,0.05);
 585   }
 586
 587
 588   // Contamination from secondary tracks
 589   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 590   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 591     fhSecContaminationMin->SetBinContent(j,-0.05);
 592   }
 593
 594   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 595   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 596     fhSecContaminationMax->SetBinContent(j,0.05);
 597   }
 598
 599   // MC CLOSURETEST (D meson efficiency)
 600   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 601   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 602     x=fhMCclosureTestMin->GetBinLowEdge(j);
 603     fhMCclosureTestMin->SetBinContent(j,-0.08);
 604
 605     if(-0.4<x&&x<-0.2){
 606       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 607     }
 608     else if(-0.2<x&&x<-0.1){
 609       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 610     }
 611     else if(-0.1<x&&x<0.1){
 612       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 613     }
 614     else if(0.1<x&&x<0.2){
 615       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 616     }
 617     if(0.2<x&&x<0.4){
 618       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 619     }
 620   }
 621
 622   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 623   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 624     x=fhMCclosureTestMax->GetBinLowEdge(j);
 625     fhMCclosureTestMax->SetBinContent(j,0.);
 626
 627     //     if(-0.4<x&&x<-0.2){
 628     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 629     //     }
 630     //     else if(-0.2<x&&x<-0.1){
 631     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 632     //     }
 633     //     else if(-0.2<x&&x<-0.1){
 634     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 635     //     }
 636     //     else if(-0.1<x&&x<0.1){
 637     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 638     //     }
 639     //     else if(0.1<x&&x<0.2){
 640     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 641     //     }
 642     //     if(0.2<x&&x<0.4){
 643     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 644     //     }
 645
 646   }
 647
 648   // Feed-down
 649
 650   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 651   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 652     x=fhBeautyFDmin->GetBinLowEdge(j);
 653     fhBeautyFDmin->SetBinContent(j,-0.05);
 654
 655   //   if(-0.4<x&&x<-0.2){
 656 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 657 //     }
 658 //     else if(-0.2<x&&x<-0.1){
 659 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 660 //     }
 661 //     else if(-0.2<x&&x<-0.1){
 662 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 663 //     }
 664 //     else if(-0.1<x&&x<0.1){
 665 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 666 //     }
 667 //     else if(0.1<x&&x<0.2){
 668 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 669 //     }
 670 //     if(0.2<x&&x<0.4){
 671 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 672 //     }
 673   }
 674
 675   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 676   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 677     x=fhBeautyFDmax->GetBinLowEdge(j);
 678     fhBeautyFDmax->SetBinContent(j,0.03);
 679
 680 //     if(-0.4<x&&x<-0.2){
 681 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 682 //     }
 683 //     else if(-0.2<x&&x<-0.1){
 684 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 685 //     }
 686 //     else if(-0.2<x&&x<-0.1){
 687 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 688 //     }
 689 //     else if(-0.1<x&&x<0.1){
 690 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 691 //     }
 692 //     else if(0.1<x&&x<0.2){
 693 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 694 //     }
 695 //     if(0.2<x&&x<0.4){
 696 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 697 //     }
 698
 699   }
 700
 701 }
 702
 703
 704
 705
 706 //--------------------------------------------------
 707 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP(){
 708   Printf("Loading syst unc for D*+ pp 2010, 3<pt(D)<5 GeV/c, pt(assoc)>0.3");
 709   fmeson=1;
 710   fstrmeson="Dstar";
 711   fstrptAss="ptAsMore03";
 712   fstrptD="Dpt3to5";
 713   if(!fhDeltaPhiTemplate){
 714     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 715   }
 716   Double_t x;
 717   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 718   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 719   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 720     fhYieldExtraction->SetBinContent(j,0.1);
 721   }
 722
 723   // Background D MESON candidate subtraction (side-band variations, etc.)
 724   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 725   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 726     fhBackSubtractionMin->SetBinContent(j,-0.05);
 727   }
 728
 729   // Background D MESON candidate subtraction (side-band variations, etc.)
 730   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 731   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 732     fhBackSubtractionMax->SetBinContent(j,0.05);
 733   }
 734
 735   // MC CORRECTIONS, -5%  10% for assoc track eff
 736   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 737   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 738     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 739   }
 740
 741   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 742   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 743     fhMCcorrectionsMax->SetBinContent(j,0.10);
 744   }
 745
 746
 747   // MC D EFF CORRECTION
 748   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 749   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 750     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 751   }
 752
 753   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 754   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 755     fhMCDefficiencyMax->SetBinContent(j,0.05);
 756   }
 757
 758
 759   // Contamination from secondary tracks
 760   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 761   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 762     fhSecContaminationMin->SetBinContent(j,-0.05);
 763   }
 764
 765   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 766   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 767     fhSecContaminationMax->SetBinContent(j,0.05);
 768   }
 769
 770   // MC CLOSURETEST (D meson efficiency)
 771   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 772   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 773     x=fhMCclosureTestMin->GetBinLowEdge(j);
 774     fhMCclosureTestMin->SetBinContent(j,-0.08);
 775
 776     if(-0.4<x&&x<-0.2){
 777       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 778     }
 779     else if(-0.2<x&&x<-0.1){
 780       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 781     }
 782     else if(-0.1<x&&x<0.1){
 783       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 784     }
 785     else if(0.1<x&&x<0.2){
 786       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 787     }
 788     if(0.2<x&&x<0.4){
 789       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 790     }
 791   }
 792
 793   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 794   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 795     x=fhMCclosureTestMax->GetBinLowEdge(j);
 796     fhMCclosureTestMax->SetBinContent(j,0.);
 797
 798     //     if(-0.4<x&&x<-0.2){
 799     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 800     //     }
 801     //     else if(-0.2<x&&x<-0.1){
 802     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 803     //     }
 804     //     else if(-0.2<x&&x<-0.1){
 805     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 806     //     }
 807     //     else if(-0.1<x&&x<0.1){
 808     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 809     //     }
 810     //     else if(0.1<x&&x<0.2){
 811     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 812     //     }
 813     //     if(0.2<x&&x<0.4){
 814     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 815     //     }
 816
 817   }
 818
 819   // Feed-down
 820
 821   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 822   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 823     x=fhBeautyFDmin->GetBinLowEdge(j);
 824     fhBeautyFDmin->SetBinContent(j,-0.05);
 825
 826   //   if(-0.4<x&&x<-0.2){
 827 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 828 //     }
 829 //     else if(-0.2<x&&x<-0.1){
 830 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 831 //     }
 832 //     else if(-0.2<x&&x<-0.1){
 833 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 834 //     }
 835 //     else if(-0.1<x&&x<0.1){
 836 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 837 //     }
 838 //     else if(0.1<x&&x<0.2){
 839 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 840 //     }
 841 //     if(0.2<x&&x<0.4){
 842 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 843 //     }
 844   }
 845
 846   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 847   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 848     x=fhBeautyFDmax->GetBinLowEdge(j);
 849     fhBeautyFDmax->SetBinContent(j,0.03);
 850
 851 //     if(-0.4<x&&x<-0.2){
 852 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 853 //     }
 854 //     else if(-0.2<x&&x<-0.1){
 855 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 856 //     }
 857 //     else if(-0.2<x&&x<-0.1){
 858 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 859 //     }
 860 //     else if(-0.1<x&&x<0.1){
 861 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 862 //     }
 863 //     else if(0.1<x&&x<0.2){
 864 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 865 //     }
 866 //     if(0.2<x&&x<0.4){
 867 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 868 //     }
 869
 870   }
 871
 872
 873 }
 874
 875 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss03HP(){
 876   Printf("Loading syst unc for D*+ pp 2010, 5<pt(D)<8 GeV/c, pt(assoc)>0.3");
 877   fmeson=1;
 878   fstrmeson="Dstar";
 879   fstrptAss="ptAsMore03";
 880   fstrptD="Dpt5to8";
 881   if(!fhDeltaPhiTemplate){
 882     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 883   }
 884   Double_t x;
 885   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 886   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 887   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 888     fhYieldExtraction->SetBinContent(j,0.1);
 889   }
 890
 891   // Background D MESON candidate subtraction (side-band variations, etc.)
 892   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 893   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 894     fhBackSubtractionMin->SetBinContent(j,-0.05);
 895   }
 896
 897   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 898   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 899     fhBackSubtractionMax->SetBinContent(j,0.05);
 900   }
 901
 902   // MC CORRECTIONS/ -5%  10% for assoc track eff
 903   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 904   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 905     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 906   }
 907
 908   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 909   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 910     fhMCcorrectionsMax->SetBinContent(j,0.10);
 911   }
 912
 913   // MC D EFF CORRECTION
 914   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 915   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 916     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 917   }
 918
 919   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 920   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 921     fhMCDefficiencyMax->SetBinContent(j,0.05);
 922   }
 923
 924
 925   // Contamination from secondary tracks
 926   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 927   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 928     fhSecContaminationMin->SetBinContent(j,-0.05);
 929   }
 930
 931   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 932   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 933     fhSecContaminationMax->SetBinContent(j,0.05);
 934   }
 935
 936   // MC CLOSURETEST (D meson efficiency)
 937   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 938   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 939     x=fhMCclosureTestMin->GetBinLowEdge(j);
 940     fhMCclosureTestMin->SetBinContent(j,-0.08);
 941
 942     if(-0.4<x&&x<-0.2){
 943       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 944     }
 945     else if(-0.2<x&&x<-0.1){
 946       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 947     }
 948     else if(-0.1<x&&x<0.1){
 949       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 950     }
 951     else if(0.1<x&&x<0.2){
 952       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 953     }
 954     if(0.2<x&&x<0.4){
 955       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 956     }
 957   }
 958
 959   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 960   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 961     x=fhMCclosureTestMax->GetBinLowEdge(j);
 962     fhMCclosureTestMax->SetBinContent(j,0.);
 963
 964     //     if(-0.4<x&&x<-0.2){
 965     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 966     //     }
 967     //     else if(-0.2<x&&x<-0.1){
 968     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 969     //     }
 970     //     else if(-0.2<x&&x<-0.1){
 971     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 972     //     }
 973     //     else if(-0.1<x&&x<0.1){
 974     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 975     //     }
 976     //     else if(0.1<x&&x<0.2){
 977     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 978     //     }
 979     //     if(0.2<x&&x<0.4){
 980     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 981     //     }
 982
 983   }
 984
 985   // Feed-down
 986
 987   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 988   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 989     x=fhBeautyFDmin->GetBinLowEdge(j);
 990     fhBeautyFDmin->SetBinContent(j,-0.05);
 991
 992   //   if(-0.4<x&&x<-0.2){
 993 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 994 //     }
 995 //     else if(-0.2<x&&x<-0.1){
 996 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 997 //     }
 998 //     else if(-0.2<x&&x<-0.1){
 999 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1000 //     }
1001 //     else if(-0.1<x&&x<0.1){
1002 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1003 //     }
1004 //     else if(0.1<x&&x<0.2){
1005 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1006 //     }
1007 //     if(0.2<x&&x<0.4){
1008 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1009 //     }
1010   }
1011
1012   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1013   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
1014     x=fhBeautyFDmax->GetBinLowEdge(j);
1015     fhBeautyFDmax->SetBinContent(j,0.03);
1016
1017 //     if(-0.4<x&&x<-0.2){
1018 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1019 //     }
1020 //     else if(-0.2<x&&x<-0.1){
1021 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1022 //     }
1023 //     else if(-0.2<x&&x<-0.1){
1024 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1025 //     }
1026 //     else if(-0.1<x&&x<0.1){
1027 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1028 //     }
1029 //     else if(0.1<x&&x<0.2){
1030 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1031 //     }
1032 //     if(0.2<x&&x<0.4){
1033 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1034 //     }
1035
1036   }
1037
1038 }
1039
1040
1041
1042 void AliHFDhadronCorrSystUnc::InitEmptyHistosFromTemplate(){
1043   if(!fhDeltaPhiTemplate){
1044     Printf("Template histo not set, using standard binning");
1045     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
1046   }
1047    fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
1048    fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
1049    fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1050    fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
1051    fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1052    fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
1053    fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1054    fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
1055    fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1056    fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
1057    fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
1058    fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
1059    fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1060 }
1061
1062
1063
1064
1065 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss03HP(){
1066   Printf("Loading syst unc for D*+ pp 2010, 8<pt(D)<16 GeV/c, pt(assoc)>0.3");
1067   fmeson=1;
1068   fstrmeson="Dstar";
1069   fstrptAss="ptAsMore03";
1070   fstrptD="Dpt8to16";
1071   if(!fhDeltaPhiTemplate){
1072     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
1073   }
1074   Double_t x;
1075   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
1076   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
1077   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
1078     fhYieldExtraction->SetBinContent(j,0.1);
1079   }
1080
1081   // Background D MESON candidate subtraction (side-band variations, etc.)
1082   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
1083   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
1084     fhBackSubtractionMin->SetBinContent(j,-0.05);
1085   }
1086
1087   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1088   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
1089     fhBackSubtractionMax->SetBinContent(j,0.05);
1090   }
1091
1092   // MC CORRECTIONS   -5% +10% for assoc track eff
1093   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
1094   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
1095     fhMCcorrectionsMin->SetBinContent(j,-0.05);
1096   }
1097
1098   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1099   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
1100     fhMCcorrectionsMax->SetBinContent(j,0.10);
1101   }
1102   // MC D EFF CORRECTION
1103   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
1104   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
1105     fhMCDefficiencyMin->SetBinContent(j,-0.05);
1106   }
1107
1108   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1109   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
1110     fhMCDefficiencyMax->SetBinContent(j,0.05);
1111   }
1112
1113
1114   // Contamination from secondary tracks
1115   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
1116   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
1117     fhSecContaminationMin->SetBinContent(j,-0.05);
1118   }
1119
1120   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1121   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
1122     fhSecContaminationMax->SetBinContent(j,0.05);
1123   }
1124
1125   // MC CLOSURETEST (D meson efficiency)
1126   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
1127   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
1128     x=fhMCclosureTestMin->GetBinLowEdge(j);
1129     fhMCclosureTestMin->SetBinContent(j,-0.08);
1130
1131     if(-0.4<x&&x<-0.2){
1132       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1133     }
1134     else if(-0.2<x&&x<-0.1){
1135       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1136     }
1137     else if(-0.1<x&&x<0.1){
1138       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
1139     }
1140     else if(0.1<x&&x<0.2){
1141       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1142     }
1143     if(0.2<x&&x<0.4){
1144       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1145     }
1146   }
1147
1148   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
1149   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
1150     x=fhMCclosureTestMax->GetBinLowEdge(j);
1151     fhMCclosureTestMax->SetBinContent(j,0.);
1152
1153     //     if(-0.4<x&&x<-0.2){
1154     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1155     //     }
1156     //     else if(-0.2<x&&x<-0.1){
1157     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1158     //     }
1159     //     else if(-0.2<x&&x<-0.1){
1160     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1161     //     }
1162     //     else if(-0.1<x&&x<0.1){
1163     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
1164     //     }
1165     //     else if(0.1<x&&x<0.2){
1166     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1167     //     }
1168     //     if(0.2<x&&x<0.4){
1169     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1170     //     }
1171
1172   }
1173
1174   // Feed-down
1175
1176   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
1177   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
1178     x=fhBeautyFDmin->GetBinLowEdge(j);
1179     fhBeautyFDmin->SetBinContent(j,-0.05);
1180
1181   //   if(-0.4<x&&x<-0.2){
1182 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1183 //     }
1184 //     else if(-0.2<x&&x<-0.1){
1185 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1186 //     }
1187 //     else if(-0.2<x&&x<-0.1){
1188 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1189 //     }
1190 //     else if(-0.1<x&&x<0.1){
1191 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1192 //     }
1193 //     else if(0.1<x&&x<0.2){
1194 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1195 //     }
1196 //     if(0.2<x&&x<0.4){
1197 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1198 //     }
1199   }
1200
1201   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1202   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
1203     x=fhBeautyFDmax->GetBinLowEdge(j);
1204     fhBeautyFDmax->SetBinContent(j,0.03);
1205
1206 //     if(-0.4<x&&x<-0.2){
1207 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1208 //     }
1209 //     else if(-0.2<x&&x<-0.1){
1210 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1211 //     }
1212 //     else if(-0.2<x&&x<-0.1){
1213 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1214 //     }
1215 //     else if(-0.1<x&&x<0.1){
1216 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1217 //     }
1218 //     else if(0.1<x&&x<0.2){
1219 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1220 //     }
1221 //     if(0.2<x&&x<0.4){
1222 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1223 //     }
1224
1225   }
1226
1227
1228 }
1229
1230
1231 void AliHFDhadronCorrSystUnc::SetHistoTemplate(TH1D *h,TString strname,Bool_t clone){
1232   if(fhDeltaPhiTemplate)delete fhDeltaPhiTemplate;
1233   if(!clone){
1234     fhDeltaPhiTemplate=h;
1235   }
1236   else{
1237     if(strname.IsNull()){fhDeltaPhiTemplate=(TH1D*)h->Clone("fhDeltaPhiTemplate");
1238     }
1239     else fhDeltaPhiTemplate=(TH1D*)h->Clone(strname.Data());
1240   }
1241 }
1242
1243
1244 void AliHFDhadronCorrSystUnc::SetHistoYieldExtraction(TH1D *h,TString strname,Bool_t clone){
1245   if(fhYieldExtraction)delete fhYieldExtraction;
1246   if(!clone){
1247     fhYieldExtraction=h;
1248   }
1249   else{
1250     if(strname.IsNull()){fhYieldExtraction=(TH1D*)h->Clone("fhYieldExtraction");
1251     }
1252     else fhYieldExtraction=(TH1D*)h->Clone(strname.Data());
1253   }
1254 }
1255
1256 void AliHFDhadronCorrSystUnc::SetHistoBackSubtraction(TH1D *hMax,TString strname,Bool_t clone,TH1D *hMin){
1257   if(!hMax){
1258     Printf("No Input Histo for back uncertainty");
1259     return;
1260   }
1261   if(fhBackSubtractionMax)delete fhBackSubtractionMax;
1262   if(!clone){
1263     fhBackSubtractionMax=hMax;
1264   }
1265   else{
1266     if(strname.IsNull()){fhBackSubtractionMax=(TH1D*)hMax->Clone("fhBackSubtractionMax");
1267     }
1268     else fhBackSubtractionMax=(TH1D*)hMax->Clone(strname.Data());
1269   }
1270
1271   if(fhBackSubtractionMin)delete fhBackSubtractionMin;
1272   if(hMin){
1273     if(!clone){
1274       fhBackSubtractionMin=hMin;
1275     }
1276     else{
1277       if(strname.IsNull()){fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1278       }
1279       else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1280     }
1281   }
1282   else{
1283     if(strname.IsNull()){
1284       fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1285     }
1286     else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1287     for(Int_t k=0;k<=fhBackSubtractionMin->GetNbinsX();k++){
1288       fhBackSubtractionMin->SetBinContent(k,-1.*fhBackSubtractionMin->GetBinContent(k));
1289     }
1290   }
1291
1292
1293
1294
1295 }
1296
1297
1298 void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMax(TH1D *h,TString strname,Bool_t clone){
1299   if(fhMCclosureTestMax)delete fhMCclosureTestMax;
1300   if(!clone){
1301     fhMCclosureTestMax=h;
1302   }
1303   else{
1304     if(strname.IsNull()){fhMCclosureTestMax=(TH1D*)h->Clone("fhMCclosureTestMax");
1305     }
1306     else fhMCclosureTestMax=(TH1D*)h->Clone(strname.Data());
1307   }
1308 }
1309
1310 void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMin(TH1D *h,TString strname,Bool_t clone){
1311     if(fhMCclosureTestMin)delete fhMCclosureTestMin;
1312     if(!clone){
1313       fhMCclosureTestMin=h;
1314     }
1315     else{
1316       if(strname.IsNull()){fhMCclosureTestMin=(TH1D*)h->Clone("fhMCclosureTestMin");
1317       }
1318       else fhMCclosureTestMin=(TH1D*)h->Clone(strname.Data());
1319     }
1320 }
1321
1322
1323 void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMin(TH1D *h,TString strname,Bool_t clone){
1324     if(fhMCcorrectionsMin)delete fhMCcorrectionsMin;
1325     if(!clone){
1326       fhMCcorrectionsMin=h;
1327     }
1328     else{
1329       if(strname.IsNull()){fhMCcorrectionsMin=(TH1D*)h->Clone("fhMCcorrectionsMin");
1330       }
1331       else fhMCcorrectionsMin=(TH1D*)h->Clone(strname.Data());
1332     }
1333 }
1334
1335
1336 void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMax(TH1D *h,TString strname,Bool_t clone){
1337     if(fhMCcorrectionsMax)delete fhMCcorrectionsMax;
1338     if(!clone){
1339       fhMCcorrectionsMax=h;
1340     }
1341     else{
1342       if(strname.IsNull()){fhMCcorrectionsMax=(TH1D*)h->Clone("fhMCcorrectionsMax");
1343       }
1344       else fhMCcorrectionsMax=(TH1D*)h->Clone(strname.Data());
1345     }
1346 }
1347
1348
1349 void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMin(TH1D *h,TString strname,Bool_t clone){
1350     if(fhMCDefficiencyMin)delete fhMCDefficiencyMin;
1351     if(!clone){
1352       fhMCDefficiencyMin=h;
1353     }
1354     else{
1355       if(strname.IsNull()){fhMCDefficiencyMin=(TH1D*)h->Clone("fhMCDefficiencyMin");
1356       }
1357       else fhMCDefficiencyMin=(TH1D*)h->Clone(strname.Data());
1358     }
1359 }
1360
1361
1362 void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMax(TH1D *h,TString strname,Bool_t clone){
1363     if(fhMCDefficiencyMax)delete fhMCDefficiencyMax;
1364     if(!clone){
1365       fhMCDefficiencyMax=h;
1366     }
1367     else{
1368       if(strname.IsNull()){fhMCDefficiencyMax=(TH1D*)h->Clone("fhMCDefficiencyMax");
1369       }
1370       else fhMCDefficiencyMax=(TH1D*)h->Clone(strname.Data());
1371     }
1372 }
1373
1374
1375 void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMin(TH1D *h,TString strname,Bool_t clone){
1376     if(fhSecContaminationMin)delete fhSecContaminationMin;
1377     if(!clone){
1378       fhSecContaminationMin=h;
1379     }
1380     else{
1381       if(strname.IsNull()){fhSecContaminationMin=(TH1D*)h->Clone("fhSecContaminationMin");
1382       }
1383       else fhSecContaminationMin=(TH1D*)h->Clone(strname.Data());
1384     }
1385 }
1386
1387
1388 void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMax(TH1D *h,TString strname,Bool_t clone){
1389     if(fhSecContaminationMax)delete fhSecContaminationMax;
1390     if(!clone){
1391       fhSecContaminationMax=h;
1392     }
1393     else{
1394       if(strname.IsNull()){fhSecContaminationMax=(TH1D*)h->Clone("fhSecContaminationMax");
1395       }
1396       else fhSecContaminationMax=(TH1D*)h->Clone(strname.Data());
1397     }
1398 }
1399
1400
1401 void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmin(TH1D *h,TString strname,Bool_t clone){
1402     if(fhBeautyFDmin)delete fhBeautyFDmin;
1403     if(!clone){
1404       fhBeautyFDmin=h;
1405     }
1406     else{
1407       if(strname.IsNull()){fhBeautyFDmin=(TH1D*)h->Clone("fhBeautyFDmin");
1408       }
1409       else fhBeautyFDmin=(TH1D*)h->Clone(strname.Data());
1410     }
1411 }
1412
1413
1414 void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmax(TH1D *h,TString strname,Bool_t clone){
1415     if(fhBeautyFDmax)delete fhBeautyFDmax;
1416     if(!clone){
1417       fhBeautyFDmax=h;
1418     }
1419     else{
1420       if(strname.IsNull()){fhBeautyFDmax=(TH1D*)h->Clone("fhBeautyFDmax");
1421       }
1422       else fhBeautyFDmax=(TH1D*)h->Clone(strname.Data());
1423     }
1424 }
1425
1426
1427
1428
1429
1430 void AliHFDhadronCorrSystUnc::BuildTotalUncHisto(){
1431   if(fhTotalMin)delete fhTotalMin;
1432   if(fhTotalMax)delete fhTotalMax;
1433
1434   fhTotalMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMin");
1435   fhTotalMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMax");
1436   Double_t errMin,errMax;
1437
1438   for(Int_t j=1;j<=fhTotalMin->GetNbinsX();j++){
1439     errMin=fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j);
1440     errMin+=fhMCcorrectionsMin->GetBinContent(j)*fhMCcorrectionsMin->GetBinContent(j);
1441     errMin+=fhMCDefficiencyMin->GetBinContent(j)*fhMCDefficiencyMin->GetBinContent(j);
1442     errMin+=fhSecContaminationMin->GetBinContent(j)*fhSecContaminationMin->GetBinContent(j);
1443     errMin+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1444     errMin+=fhBackSubtractionMin->GetBinContent(j)*fhBackSubtractionMin->GetBinContent(j);
1445     errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1446
1447     fhTotalMin->SetBinContent(j,-TMath::Sqrt(errMin));
1448
1449     errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j);
1450     errMax+=fhMCcorrectionsMax->GetBinContent(j)*fhMCcorrectionsMax->GetBinContent(j);
1451     errMax+=fhMCDefficiencyMax->GetBinContent(j)*fhMCDefficiencyMax->GetBinContent(j);
1452     errMax+=fhSecContaminationMax->GetBinContent(j)*fhSecContaminationMax->GetBinContent(j);
1453     errMax+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1454     errMax+=fhBackSubtractionMax->GetBinContent(j)*fhBackSubtractionMax->GetBinContent(j);
1455     errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1456
1457     fhTotalMax->SetBinContent(j,TMath::Sqrt(errMax));
1458
1459
1460   }
1461
1462   fhTotalMin->SetLineColor(kBlack);
1463   fhTotalMin->SetLineWidth(2);
1464   fhTotalMin->SetFillStyle(0);
1465   fhTotalMin->SetFillColor(kBlack);
1466   fhTotalMin->SetMarkerColor(kBlack);
1467   fhTotalMin->SetMarkerStyle(20);
1468
1469   fhTotalMax->SetLineColor(kBlack);
1470   fhTotalMax->SetLineWidth(2);
1471   fhTotalMax->SetFillStyle(0);
1472   fhTotalMax->SetFillColor(kBlack);
1473   fhTotalMax->SetMarkerColor(kBlack);
1474   fhTotalMax->SetMarkerStyle(20);
1475
1476 }
1477
1478 void AliHFDhadronCorrSystUnc::BuildTotalNonFlatUncHisto(){
1479   if(fhTotalNonFlatDPhiMin)delete fhTotalNonFlatDPhiMin;
1480   if(fhTotalNonFlatDPhiMax)delete fhTotalNonFlatDPhiMax;
1481
1482   fhTotalNonFlatDPhiMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMin");
1483   fhTotalNonFlatDPhiMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMax");
1484   Double_t errMin,errMax,mcClosureMinmax,mcClosureMaxmin;
1485
1486   mcClosureMinmax=fhMCclosureTestMin->GetBinContent(fhMCclosureTestMin->GetMaximumBin());
1487   mcClosureMaxmin=fhMCclosureTestMax->GetBinContent(fhMCclosureTestMax->GetMinimumBin());
1488   Printf("MC closure - The max of min is: %f, the min of max is: %f", mcClosureMinmax, mcClosureMaxmin);
1489
1490   for(Int_t j=1;j<=fhTotalNonFlatDPhiMin->GetNbinsX();j++){
1491     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
1492
1493     errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1494
1495     fhTotalNonFlatDPhiMin->SetBinContent(j,-TMath::Sqrt(errMin));
1496
1497     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
1498
1499     errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1500
1501     fhTotalNonFlatDPhiMax->SetBinContent(j,TMath::Sqrt(errMax));
1502
1503
1504   }
1505
1506   fhtotFlatMin=(TH1D*)fhTotalMin->Clone("hTotFlatDPhiMin");
1507   fhtotFlatMin->SetTitle("#Delta#phi indipendent");
1508
1509   fhtotFlatMax=(TH1D*)fhTotalMax->Clone("hTotFlatDPhiMax");
1510   fhtotFlatMax->SetTitle("#Delta#phi indipendent");
1511
1512   for(Int_t jfl=1;jfl<=fhtotFlatMin->GetNbinsX();jfl++){
1513     fhtotFlatMin->SetBinContent(jfl,-TMath::Sqrt(fhTotalMin->GetBinContent(jfl)*fhTotalMin->GetBinContent(jfl)-fhTotalNonFlatDPhiMin->GetBinContent(jfl)*fhTotalNonFlatDPhiMin->GetBinContent(jfl)));
1514     fhtotFlatMax->SetBinContent(jfl,TMath::Sqrt(fhTotalMax->GetBinContent(jfl)*fhTotalMax->GetBinContent(jfl)-fhTotalNonFlatDPhiMax->GetBinContent(jfl)*fhTotalNonFlatDPhiMax->GetBinContent(jfl)));
1515   }
1516
1517   fhtotFlatMin->SetLineStyle(2);
1518   fhtotFlatMax->SetLineStyle(2);
1519
1520
1521
1522
1523   fhTotalNonFlatDPhiMin->SetLineColor(kBlue);
1524   fhTotalNonFlatDPhiMin->SetLineWidth(2);
1525   fhTotalNonFlatDPhiMin->SetFillStyle(0);
1526   fhTotalNonFlatDPhiMin->SetFillColor(kBlue);
1527   fhTotalNonFlatDPhiMin->SetMarkerColor(kBlue);
1528   fhTotalNonFlatDPhiMin->SetMarkerStyle(20);
1529
1530   fhTotalNonFlatDPhiMax->SetLineColor(kBlue);
1531   fhTotalNonFlatDPhiMax->SetLineWidth(2);
1532   fhTotalNonFlatDPhiMax->SetFillStyle(0);
1533   fhTotalNonFlatDPhiMax->SetFillColor(kBlue);
1534   fhTotalNonFlatDPhiMax->SetMarkerColor(kBlue);
1535   fhTotalNonFlatDPhiMax->SetMarkerStyle(20);
1536
1537 }
1538
1539
1540 void AliHFDhadronCorrSystUnc::BuildTotalNonFDUncHisto(){
1541   if(fhTotalNonFDMin)delete fhTotalNonFDMin;
1542   if(fhTotalNonFDMax)delete fhTotalNonFDMax;
1543
1544   fhTotalNonFDMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMin");
1545   fhTotalNonFDMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMax");
1546   Double_t errMin,errMax;
1547
1548   for(Int_t j=1;j<=fhTotalNonFDMin->GetNbinsX();j++){
1549     errMin=fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j);
1550     errMin+=fhMCcorrectionsMin->GetBinContent(j)*fhMCcorrectionsMin->GetBinContent(j);
1551     errMin+=fhMCDefficiencyMin->GetBinContent(j)*fhMCDefficiencyMin->GetBinContent(j);
1552     errMin+=fhSecContaminationMin->GetBinContent(j)*fhSecContaminationMin->GetBinContent(j);
1553     errMin+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1554     errMin+=fhBackSubtractionMin->GetBinContent(j)*fhBackSubtractionMin->GetBinContent(j);
1555
1556     fhTotalNonFDMin->SetBinContent(j,-TMath::Sqrt(errMin));
1557
1558     errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j);
1559     errMax+=fhMCcorrectionsMax->GetBinContent(j)*fhMCcorrectionsMax->GetBinContent(j);
1560     errMax+=fhMCDefficiencyMax->GetBinContent(j)*fhMCDefficiencyMax->GetBinContent(j);
1561     errMax+=fhSecContaminationMax->GetBinContent(j)*fhSecContaminationMax->GetBinContent(j);
1562     errMax+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1563     errMax+=fhBackSubtractionMax->GetBinContent(j)*fhBackSubtractionMax->GetBinContent(j);
1564
1565     fhTotalNonFDMax->SetBinContent(j,TMath::Sqrt(errMax));
1566
1567
1568   }
1569
1570 }
1571
1572
1573 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010(Int_t meson,Double_t ptD,Double_t minptAss){
1574
1575   if(meson==0){
1576
1577     // 0.3 GeV/c
1578     if(TMath::Abs(minptAss-0.3)<0.0001){
1579       if(ptD>2&&ptD<5){
1580         InitStandardUncertaintiesPP2010DzeroLowPtAss03HP();
1581       }
1582       else if(ptD>5&&ptD<8){
1583         InitStandardUncertaintiesPP2010DzeroMidPtAss03HP();
1584       }
1585       else if(ptD>8&&ptD<16){
1586         InitStandardUncertaintiesPP2010DzeroHighPtAss03HP();
1587       }
1588       else {
1589         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1590       }
1591     }
1592     // 0.5 GeV/c
1593     else if(TMath::Abs(minptAss-0.5)<0.0001){
1594       if(ptD>3&&ptD<5){
1595         InitStandardUncertaintiesPP2010DzeroLowPtAss05();
1596       }
1597       else if(ptD>5&&ptD<8){
1598         InitStandardUncertaintiesPP2010DzeroMidPtAss05();
1599       }
1600       else if(ptD>8&&ptD<16){
1601         InitStandardUncertaintiesPP2010DzeroHighPtAss05();
1602       }
1603       else {
1604         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1605       }
1606     }
1607     // 1 GeV/c
1608     else if(TMath::Abs(minptAss-1.)<0.0001){
1609       if(ptD>3&&ptD<5){
1610         InitStandardUncertaintiesPP2010DzeroLowPtAss1();
1611       }
1612       else if(ptD>5&&ptD<8){
1613         InitStandardUncertaintiesPP2010DzeroMidPtAss1();
1614
1615       }
1616       else if(ptD>8&&ptD<16){
1617         InitStandardUncertaintiesPP2010DzeroHighPtAss1();
1618       }
1619       else {
1620         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1621       }
1622     }
1623     else {
1624       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1625     }
1626   }
1627   else if(meson==1){
1628     // 0.3 GeV/c
1629     if(TMath::Abs(minptAss-0.3)<0.0001){
1630       if(ptD>3&&ptD<5){
1631         InitStandardUncertaintiesPP2010DstarLowPtAss03HP();
1632       }
1633       else if(ptD>5&&ptD<8){
1634         InitStandardUncertaintiesPP2010DstarMidPtAss03HP();
1635       }
1636       else if(ptD>8&&ptD<16){
1637         InitStandardUncertaintiesPP2010DstarHighPtAss03HP();
1638       }
1639       else {
1640         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1641       }
1642     }
1643     // 0.5 GeV/c
1644     else if(TMath::Abs(minptAss-0.5)<0.0001){
1645       if(ptD>3&&ptD<5){
1646         InitStandardUncertaintiesPP2010DstarLowPtAss05();
1647       }
1648       else if(ptD>5&&ptD<8){
1649         InitStandardUncertaintiesPP2010DstarMidPtAss05();
1650       }
1651       else if(ptD>8&&ptD<16){
1652         InitStandardUncertaintiesPP2010DstarHighPtAss05();
1653       }
1654       else {
1655         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1656       }
1657     }
1658
1659     // 1 GeV/c
1660     else if(TMath::Abs(minptAss-1.)<0.0001){
1661       if(ptD>3&&ptD<5){
1662         InitStandardUncertaintiesPP2010DstarLowPtAss1();
1663       }
1664       else if(ptD>5&&ptD<8){
1665         InitStandardUncertaintiesPP2010DstarMidPtAss1();
1666       }
1667       else if(ptD>8&&ptD<16){
1668         InitStandardUncertaintiesPP2010DstarHighPtAss1();
1669       }
1670       else {
1671         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1672       }
1673     }
1674     else {
1675       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1676     }
1677   }
1678   else if(meson==2){
1679     // 0.3 GeV/c
1680     if(TMath::Abs(minptAss-0.3)<0.0001){
1681       if(ptD>3&&ptD<5){
1682         InitStandardUncertaintiesPP2010DplusLowPtAss03();
1683       }
1684       else if(ptD>5&&ptD<8){
1685         InitStandardUncertaintiesPP2010DplusMidPtAss03();
1686       }
1687       else if(ptD>8&&ptD<16){
1688         InitStandardUncertaintiesPP2010DplusHighPtAss03();
1689       }
1690       else {
1691         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1692       }
1693     }
1694     // 0.5 GeV/c
1695     else if(TMath::Abs(minptAss-0.5)<0.0001){
1696       if(ptD>3&&ptD<5){
1697         InitStandardUncertaintiesPP2010DplusLowPtAss05();
1698       }
1699       else if(ptD>5&&ptD<8){
1700         InitStandardUncertaintiesPP2010DplusMidPtAss05();
1701       }
1702       else if(ptD>8&&ptD<16){
1703         InitStandardUncertaintiesPP2010DplusHighPtAss05();
1704       }
1705       else {
1706         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1707       }
1708     }
1709     // 1 GeV/c
1710     else if(TMath::Abs(minptAss-1.)<0.0001){
1711       if(ptD>3&&ptD<5){
1712         InitStandardUncertaintiesPPb2013DplusLowPtAss1();
1713       }
1714       else if(ptD>5&&ptD<8){
1715         InitStandardUncertaintiesPPb2013DplusMidPtAss1();
1716       }
1717       else if(ptD>8&&ptD<16){
1718         InitStandardUncertaintiesPPb2013DplusHighPtAss1();
1719       }
1720       else {
1721         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1722       }
1723     }
1724     else {
1725       printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1726     }
1727   }
1728   else {
1729     printf("PP:No meson is found  Check your input \n");
1730   }
1731 }
1732
1733 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013(Int_t meson,Double_t ptD,Double_t minptAss){
1734
1735   if(meson==0){
1736     // 0.3 GeV/c
1737     if(TMath::Abs(minptAss-0.3)<0.0001){
1738       if(ptD>3&&ptD<5){
1739         InitStandardUncertaintiesPPb2013DzeroLowPtAss03();
1740       }
1741       else if(ptD>5&&ptD<8){
1742         InitStandardUncertaintiesPPb2013DzeroMidPtAss03();
1743       }
1744       else if(ptD>8&&ptD<16){
1745         InitStandardUncertaintiesPPb2013DzeroHighPtAss03();
1746       }
1747
1748       else {
1749         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1750       }
1751     }
1752     // 0.5 GeV/c
1753     else if(TMath::Abs(minptAss-0.5)<0.0001){
1754       if(ptD>3&&ptD<5){
1755         InitStandardUncertaintiesPPb2013DzeroLowPtAss05();
1756       }
1757       else if(ptD>5&&ptD<8){
1758         InitStandardUncertaintiesPPb2013DzeroMidPtAss05();
1759       }
1760       else if(ptD>8&&ptD<16){
1761         InitStandardUncertaintiesPPb2013DzeroHighPtAss05();
1762       }
1763
1764       else {
1765         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1766       }
1767     }
1768
1769     // 1 GeV/c
1770     else if(TMath::Abs(minptAss-1.)<0.0001){
1771       if(ptD>3&&ptD<5){
1772         InitStandardUncertaintiesPPb2013DzeroLowPtAss1();
1773       }
1774       else if(ptD>5&&ptD<8){
1775         InitStandardUncertaintiesPPb2013DzeroMidPtAss1();
1776       }
1777       else if(ptD>8&&ptD<16){
1778         InitStandardUncertaintiesPPb2013DzeroHighPtAss1();
1779       }
1780       else {
1781         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1782       }
1783     }
1784     else {
1785       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1786     }
1787   }
1788   else if(meson==1){
1789     // 0.3 GeV/c
1790     if(TMath::Abs(minptAss-0.3)<0.0001){
1791       if(ptD>3&&ptD<5){
1792         InitStandardUncertaintiesPPb2013DstarLowPtAss03();
1793       }
1794       else if(ptD>5&&ptD<8){
1795         InitStandardUncertaintiesPPb2013DstarMidPtAss03();
1796       }
1797       else if(ptD>8&&ptD<16){
1798         InitStandardUncertaintiesPPb2013DstarHighPtAss03();
1799       }
1800       else {
1801         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1802       }
1803     }
1804     // 0.5 GeV/c
1805     else if(TMath::Abs(minptAss-0.5)<0.0001){
1806       if(ptD>3&&ptD<5){
1807         InitStandardUncertaintiesPPb2013DstarLowPtAss05();
1808       }
1809       else if(ptD>5&&ptD<8){
1810         InitStandardUncertaintiesPPb2013DstarMidPtAss05();
1811       }
1812       else if(ptD>8&&ptD<16){
1813         InitStandardUncertaintiesPPb2013DstarHighPtAss05();
1814       }
1815       else {
1816         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1817       }
1818     }
1819     // 1 GeV/c
1820     else if(TMath::Abs(minptAss-1.)<0.0001){
1821       if(ptD>3&&ptD<5){
1822         InitStandardUncertaintiesPPb2013DstarLowPtAss1();
1823       }
1824       else if(ptD>5&&ptD<8){
1825         InitStandardUncertaintiesPPb2013DstarMidPtAss1();
1826       }
1827       else if(ptD>8&&ptD<16){
1828         InitStandardUncertaintiesPPb2013DstarHighPtAss1();
1829       }
1830       else {
1831         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1832       }
1833     }
1834     else {
1835       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1836     }
1837   }
1838   else if(meson==2){
1839     // 0.3 GeV/c
1840     if(TMath::Abs(minptAss-0.3)<0.0001){
1841       if(ptD>3&&ptD<5){
1842         InitStandardUncertaintiesPPb2013DplusLowPtAss03();
1843       }
1844       else if(ptD>5&&ptD<8){
1845         InitStandardUncertaintiesPPb2013DplusMidPtAss03();
1846       }
1847       else if(ptD>8&&ptD<16){
1848         InitStandardUncertaintiesPPb2013DplusHighPtAss03();
1849       }
1850       else {
1851         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1852       }
1853     }
1854     // 0.5 GeV/c
1855     else if(TMath::Abs(minptAss-0.5)<0.0001){
1856       if(ptD>3&&ptD<5){
1857         InitStandardUncertaintiesPPb2013DplusLowPtAss05();
1858       }
1859       else if(ptD>5&&ptD<8){
1860         InitStandardUncertaintiesPPb2013DplusMidPtAss05();
1861       }
1862       else if(ptD>8&&ptD<16){
1863         InitStandardUncertaintiesPPb2013DplusHighPtAss05();
1864       }
1865       else {
1866         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1867       }
1868     }
1869     // 1 GeV/c
1870     else if(TMath::Abs(minptAss-1.)<0.0001){
1871       if(ptD>3&&ptD<5){
1872         InitStandardUncertaintiesPPb2013DplusLowPtAss1();
1873       }
1874       else if(ptD>5&&ptD<8){
1875         InitStandardUncertaintiesPPb2013DplusMidPtAss1();
1876       }
1877       else if(ptD>8&&ptD<16){
1878         InitStandardUncertaintiesPPb2013DplusHighPtAss1();
1879       }
1880       else {
1881         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1882       }
1883     }
1884     else {
1885       printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1886     }
1887   }
1888   else {
1889         printf("pPb-No meson is found  Check your input \n");
1890   }
1891 }
1892
1893
1894 TGraphAsymmErrors* AliHFDhadronCorrSystUnc::GetUncGraphFromHistos(TH1D *hRef,TH1D *hMin,TH1D *hMax){
1895
1896   //  Int_t npoints=hMin->GetNbinsX();
1897   Double_t ew=hMin->GetBinWidth(1)/2.;
1898   Double_t value,eyl,eym;
1899
1900   TGraphAsymmErrors *gr=new TGraphAsymmErrors();
1901   for(Int_t j=1;j<=hMin->GetNbinsX();j++){
1902     if(hRef){
1903       value=hRef->GetBinContent(j);
1904       eyl=hMin->GetBinContent(j)*value;
1905       if(eyl<0.)eyl*=-1.;
1906       if(hMax)eym=hMax->GetBinContent(j)*value;
1907       else eym=eyl;
1908     }
1909     else {
1910       value=0.;
1911       eyl=hMin->GetBinContent(j);
1912       if(eyl<0.)eyl*=-1.;
1913       if(hMax)eym=hMax->GetBinContent(j);
1914       else eym=eyl;
1915     }
1916
1917     gr->SetPoint(j-1,hMin->GetBinCenter(j),value);
1918     gr->SetPointError(j-1,ew,ew,eyl,eym);
1919   }
1920
1921   return gr;
1922 }
1923
1924 void AliHFDhadronCorrSystUnc::BuildGraphsRelUnc(){
1925   if(fgrYieldUncRel)delete fgrYieldUncRel;
1926   if(fgrBackSubUncRel)delete fgrBackSubUncRel;
1927   if(fgrMCcorrectionsRel)delete fgrMCcorrectionsRel;
1928   if(fgrMCDefficiencyRel)delete fgrMCDefficiencyRel;
1929   if(fgrSecContaminationRel)delete fgrSecContaminationRel;
1930   if(fgrMCclosureTestRel)delete fgrMCclosureTestRel;
1931   if(fgrBeautyFDRel)delete fgrBeautyFDRel;
1932
1933   fgrYieldUncRel=GetUncGraphFromHistos(0x0,fhYieldExtraction,0x0);
1934   fgrYieldUncRel->SetName("fgrYieldUncRel");
1935   fgrYieldUncRel->SetTitle("D meson yield");
1936
1937
1938   fgrBackSubUncRel=GetUncGraphFromHistos(0x0,fhBackSubtractionMin,fhBackSubtractionMax);
1939   fgrBackSubUncRel->SetName("fgrBackSubUncRel");
1940   fgrBackSubUncRel->SetTitle("Background D correlation subtraction");
1941
1942
1943
1944   fgrMCcorrectionsRel=GetUncGraphFromHistos(0x0,fhMCcorrectionsMin,fhMCcorrectionsMax);
1945   fgrMCcorrectionsRel->SetName("fgrMCcorrectionsRel");
1946   fgrMCcorrectionsRel->SetTitle("Associated track efficiency");
1947
1948   fgrMCDefficiencyRel=GetUncGraphFromHistos(0x0,fhMCDefficiencyMin,fhMCDefficiencyMax);
1949   fgrMCDefficiencyRel->SetName("fgrMCDefficiencyRel");
1950   fgrMCDefficiencyRel->SetTitle("D meson efficiency");
1951
1952   fgrSecContaminationRel=GetUncGraphFromHistos(0x0,fhSecContaminationMin,fhSecContaminationMax);
1953   fgrSecContaminationRel->SetName("fgrSecContaminationRel");
1954   fgrSecContaminationRel->SetTitle("Secondary contamination");
1955
1956   fgrMCclosureTestRel=GetUncGraphFromHistos(0x0,fhMCclosureTestMin,fhMCclosureTestMax);
1957   fgrMCclosureTestRel->SetName("fgrMCclosureTestRel");
1958   fgrMCclosureTestRel->SetTitle("MC closure test");
1959
1960   fgrBeautyFDRel=GetUncGraphFromHistos(0x0,fhBeautyFDmin,fhBeautyFDmax);
1961   fgrBeautyFDRel->SetName("fgrBeautyFDRel");
1962   fgrBeautyFDRel->SetTitle("Feed-down");
1963
1964   fgrYieldUncRel->SetLineColor(kBlue);
1965   fgrYieldUncRel->SetLineWidth(2);
1966   fgrYieldUncRel->SetFillStyle(3002);
1967   fgrYieldUncRel->SetFillColor(kBlue);
1968   fgrYieldUncRel->SetMarkerColor(kBlue);
1969   fgrYieldUncRel->SetMarkerStyle(20);
1970
1971
1972   fgrBackSubUncRel->SetLineColor(kMagenta);
1973   fgrBackSubUncRel->SetLineWidth(2);
1974   fgrBackSubUncRel->SetFillStyle(3008);
1975   fgrBackSubUncRel->SetFillColor(kMagenta);
1976   fgrBackSubUncRel->SetMarkerColor(kBlue);
1977   fgrBackSubUncRel->SetMarkerStyle(20);
1978
1979
1980   fgrMCcorrectionsRel->SetLineColor(kGreen);
1981   fgrMCcorrectionsRel->SetLineWidth(2);
1982   fgrMCcorrectionsRel->SetFillStyle(3006);
1983   fgrMCcorrectionsRel->SetFillColor(kGreen);
1984   fgrMCcorrectionsRel->SetMarkerColor(kGreen);
1985   fgrMCcorrectionsRel->SetMarkerStyle(22);
1986
1987   fgrMCDefficiencyRel->SetLineColor(kCyan);
1988   fgrMCDefficiencyRel->SetLineWidth(2);
1989   fgrMCDefficiencyRel->SetFillStyle(3004);
1990   fgrMCDefficiencyRel->SetFillColor(kCyan);
1991   fgrMCDefficiencyRel->SetMarkerColor(kCyan);
1992   fgrMCDefficiencyRel->SetMarkerStyle(22);
1993
1994   fgrSecContaminationRel->SetLineColor(kOrange);
1995   fgrSecContaminationRel->SetLineWidth(2);
1996   fgrSecContaminationRel->SetFillStyle(3007);
1997   fgrSecContaminationRel->SetFillColor(kOrange);
1998   fgrSecContaminationRel->SetMarkerColor(kOrange);
1999   fgrSecContaminationRel->SetMarkerStyle(22);
2000
2001   fgrMCclosureTestRel->SetLineColor(kRed);
2002   fgrMCclosureTestRel->SetLineWidth(2);
2003   fgrMCclosureTestRel->SetFillStyle(3005);
2004   fgrMCclosureTestRel->SetFillColor(kRed);
2005   fgrMCclosureTestRel->SetMarkerColor(kRed);
2006   fgrMCclosureTestRel->SetMarkerStyle(26);
2007
2008   fgrBeautyFDRel->SetLineColor(kViolet);
2009   fgrBeautyFDRel->SetLineWidth(2);
2010   fgrBeautyFDRel->SetFillStyle(3021);
2011   fgrBeautyFDRel->SetFillColor(kViolet);
2012   fgrBeautyFDRel->SetMarkerColor(kViolet);
2013   fgrBeautyFDRel->SetMarkerStyle(28);
2014
2015
2016
2017
2018 }
2019
2020 void AliHFDhadronCorrSystUnc::BuildGraphsUnc(TH1D *hRef){
2021
2022   if(fgrYieldUnc)delete fgrYieldUnc;
2023   if(fgrBackSubUnc)delete fgrBackSubUnc;
2024   if(fgrMCcorrections)delete fgrMCcorrections;
2025   if(fgrMCDefficiency)delete fgrMCDefficiency;
2026   if(fgrSecContamination)delete fgrSecContamination;
2027   if(fgrMCclosureTest)delete fgrMCclosureTest;
2028   if(fgrBeautyFD)delete fgrBeautyFD;
2029   if(fgrTotalRel)delete fgrTotalRel;
2030   if(fgrTotal)delete fgrTotal;
2031   if(fgrTotalNonFlatDPhi)delete fgrTotalNonFlatDPhi;
2032   if(fgrTotalNonFlatDPhiRel)delete fgrTotalNonFlatDPhiRel;
2033   if(fgrTotalFlatDPhi)delete fgrTotalFlatDPhi;
2034   if(fgrTotalFlatDPhiRel)delete fgrTotalFlatDPhiRel;
2035
2036   fgrYieldUnc=GetUncGraphFromHistos(hRef,fhYieldExtraction,0x0);
2037   fgrYieldUnc->SetName("fgrYieldUnc");
2038   fgrYieldUnc->SetTitle("D meson yield");
2039
2040   fgrBackSubUnc=GetUncGraphFromHistos(hRef,fhBackSubtractionMin,fhBackSubtractionMax);
2041   fgrBackSubUnc->SetName("fgrBackSubUnc");
2042   fgrBackSubUnc->SetTitle("Background D correlation subtraction");
2043
2044
2045   fgrMCcorrections=GetUncGraphFromHistos(hRef,fhMCcorrectionsMin,fhMCcorrectionsMax);
2046   fgrMCcorrections->SetName("fgrMCcorrections");
2047   fgrMCcorrections->SetTitle("Associated track efficiency");
2048
2049   fgrMCDefficiency=GetUncGraphFromHistos(hRef,fhMCDefficiencyMin,fhMCDefficiencyMax);
2050   fgrMCDefficiency->SetName("fgrMCDefficiency");
2051   fgrMCDefficiency->SetTitle("D meson efficiency");
2052
2053   fgrSecContamination=GetUncGraphFromHistos(hRef,fhSecContaminationMin,fhSecContaminationMax);
2054   fgrSecContamination->SetName("fgrSecContamination");
2055   fgrSecContamination->SetTitle("Secondary contamination");
2056
2057   fgrMCclosureTest=GetUncGraphFromHistos(hRef,fhMCclosureTestMin,fhMCclosureTestMax);
2058   fgrMCclosureTest->SetName("fgrMCclosureTest");
2059   fgrMCclosureTest->SetTitle("MC closure test");
2060
2061   fgrBeautyFD=GetUncGraphFromHistos(hRef,fhBeautyFDmin,fhBeautyFDmax);
2062   fgrBeautyFD->SetName("fgrBeautyFD");
2063   fgrBeautyFD->SetTitle("Feed-down");
2064
2065   fgrYieldUnc->SetLineColor(kBlue);
2066   fgrYieldUnc->SetLineWidth(2);
2067   fgrYieldUnc->SetFillStyle(0);
2068   fgrYieldUnc->SetFillColor(kBlue);
2069   fgrYieldUnc->SetMarkerColor(kBlue);
2070   fgrYieldUnc->SetMarkerStyle(20);
2071
2072
2073   fgrBackSubUnc->SetLineColor(kMagenta);
2074   fgrBackSubUnc->SetLineWidth(2);
2075   fgrBackSubUnc->SetFillStyle(0);
2076   fgrBackSubUnc->SetFillColor(kMagenta);
2077   fgrBackSubUnc->SetMarkerColor(kBlue);
2078   fgrBackSubUnc->SetMarkerStyle(20);
2079
2080
2081   fgrMCcorrections->SetLineColor(kGreen);
2082   fgrMCcorrections->SetLineWidth(2);
2083   fgrMCcorrections->SetFillStyle(0);
2084   fgrMCcorrections->SetFillColor(kGreen);
2085   fgrMCcorrections->SetMarkerColor(kGreen);
2086   fgrMCcorrections->SetMarkerStyle(22);
2087
2088   fgrMCDefficiency->SetLineColor(kCyan);
2089   fgrMCDefficiency->SetLineWidth(2);
2090   fgrMCDefficiency->SetFillStyle(0);
2091   fgrMCDefficiency->SetFillColor(kCyan);
2092   fgrMCDefficiency->SetMarkerColor(kCyan);
2093   fgrMCDefficiency->SetMarkerStyle(22);
2094
2095   fgrSecContamination->SetLineColor(kOrange);
2096   fgrSecContamination->SetLineWidth(2);
2097   fgrSecContamination->SetFillStyle(0);
2098   fgrSecContamination->SetFillColor(kOrange);
2099   fgrSecContamination->SetMarkerColor(kOrange);
2100   fgrSecContamination->SetMarkerStyle(22);
2101
2102   fgrMCclosureTest->SetLineColor(kRed);
2103   fgrMCclosureTest->SetLineWidth(2);
2104   fgrMCclosureTest->SetFillStyle(0);
2105   fgrMCclosureTest->SetFillColor(kRed);
2106   fgrMCclosureTest->SetMarkerColor(kRed);
2107   fgrMCclosureTest->SetMarkerStyle(26);
2108
2109   fgrBeautyFD->SetLineColor(kViolet);
2110   fgrBeautyFD->SetLineWidth(2);
2111   fgrBeautyFD->SetFillStyle(0);
2112   fgrBeautyFD->SetFillColor(kViolet);
2113   fgrBeautyFD->SetMarkerColor(kViolet);
2114   fgrBeautyFD->SetMarkerStyle(28);
2115
2116   //  fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
2117   if(fhTotalMin){
2118     fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
2119     fgrTotalRel->SetLineColor(kBlack);
2120     fgrTotalRel->SetLineWidth(2);
2121     fgrTotalRel->SetFillStyle(0);
2122     //    fgrTotalRel->SetFillColor(kRed);
2123     fgrTotalRel->SetMarkerColor(kBlack);
2124     fgrTotalRel->SetMarkerStyle(26);
2125
2126     fgrTotal=GetUncGraphFromHistos(hRef,fhTotalMin,fhTotalMax);
2127     fgrTotal->SetLineColor(kBlack);
2128     fgrTotal->SetLineWidth(2);
2129     fgrTotal->SetFillStyle(0);
2130     fgrTotal->SetFillColor(kRed);
2131     fgrTotal->SetMarkerColor(kBlack);
2132     fgrTotal->SetMarkerStyle(26);
2133   }
2134
2135   if(fhTotalNonFDMin){
2136     fgrTotalNonFD=GetUncGraphFromHistos(hRef,fhTotalNonFDMin,fhTotalNonFDMax);
2137     fgrTotalNonFD->SetLineColor(kBlue);
2138     fgrTotalNonFD->SetLineWidth(2);
2139     fgrTotalNonFD->SetFillStyle(3005);
2140     fgrTotalNonFD->SetFillColor(kBlue);
2141     fgrTotalNonFD->SetMarkerColor(kBlue);
2142     fgrTotalNonFD->SetMarkerStyle(26);
2143   }
2144
2145   if(fhTotalNonFlatDPhiMin){
2146     fgrTotalNonFlatDPhiRel=GetUncGraphFromHistos(0x0,fhTotalNonFlatDPhiMin,fhTotalNonFlatDPhiMax);
2147     fgrTotalNonFlatDPhiRel->SetLineColor(kBlack);
2148     fgrTotalNonFlatDPhiRel->SetLineWidth(2);
2149     fgrTotalNonFlatDPhiRel->SetFillStyle(0);
2150     //    fgrTotalRel->SetFillColor(kRed);
2151     fgrTotalNonFlatDPhiRel->SetMarkerColor(kBlack);
2152     fgrTotalNonFlatDPhiRel->SetMarkerStyle(26);
2153
2154     fgrTotalNonFlatDPhi=GetUncGraphFromHistos(hRef,fhTotalNonFlatDPhiMin,fhTotalNonFlatDPhiMax);
2155     fgrTotalNonFlatDPhi->SetLineColor(kBlack);
2156     fgrTotalNonFlatDPhi->SetLineWidth(2);
2157     fgrTotalNonFlatDPhi->SetFillStyle(3005);
2158     fgrTotalNonFlatDPhi->SetFillColor(kRed);
2159     fgrTotalNonFlatDPhi->SetMarkerColor(kBlack);
2160     fgrTotalNonFlatDPhi->SetMarkerStyle(26);
2161
2162     fgrTotalFlatDPhiRel=GetUncGraphFromHistos(0x0,fhtotFlatMin,fhtotFlatMax);
2163     fgrTotalFlatDPhiRel->SetLineColor(kBlack);
2164     fgrTotalFlatDPhiRel->SetLineWidth(2);
2165     fgrTotalFlatDPhiRel->SetFillStyle(0);
2166     //    fgrTotalRel->SetFillColor(kRed);
2167     fgrTotalFlatDPhiRel->SetMarkerColor(kBlack);
2168     fgrTotalFlatDPhiRel->SetMarkerStyle(26);
2169
2170     fgrTotalFlatDPhi=GetUncGraphFromHistos(hRef,fhtotFlatMin,fhtotFlatMax);
2171     fgrTotalFlatDPhi->SetLineColor(kBlack);
2172     fgrTotalFlatDPhi->SetLineWidth(2);
2173     fgrTotalFlatDPhi->SetFillStyle(3005);
2174     fgrTotalFlatDPhi->SetFillColor(kBlack);
2175     fgrTotalFlatDPhi->SetMarkerColor(kBlack);
2176     fgrTotalFlatDPhi->SetMarkerStyle(26);
2177   }
2178
2179 }
2180
2181
2182 TCanvas* AliHFDhadronCorrSystUnc::BuildSystUncertaintyPlotVsDeltaPhi(TH1D *hCorrPlot,Int_t doInit){
2183
2184   if(doInit!=0){
2185     BuildTotalUncHisto();
2186     BuildTotalNonFDUncHisto();
2187     BuildTotalNonFlatUncHisto();
2188     BuildGraphsUnc(hCorrPlot);
2189     BuildGraphsRelUnc();
2190
2191   }
2192
2193   // Easy canva with relative uncertainties
2194   TCanvas *cCanvaRelUnc=new TCanvas("cCanvaRelUnc","cCanvaRelUnc",700,700);
2195   cCanvaRelUnc->cd();
2196   TH2D *hDraw=new TH2D("hDraw","hDraw",32,-TMath::Pi()/2.,3./2.*TMath::Pi(),200,-2.,2.);
2197   hDraw->SetXTitle("#Delta#phi (rad)");
2198   hDraw->SetYTitle("Relative uncertainty");
2199   hDraw->Draw();
2200
2201
2202   fgrYieldUncRel->Draw("E2");
2203   fgrBackSubUncRel->Draw("E2");
2204   fgrMCcorrectionsRel->Draw("E2");
2205   fgrMCDefficiencyRel->Draw("E2");
2206   fgrSecContaminationRel->Draw("E2");
2207   fgrMCclosureTestRel->Draw("E2");
2208   fgrBeautyFDRel->Draw("E2");
2209   //  fgrTotalRel->Draw("E2");
2210
2211   fhtotFlatMin->Draw("same");
2212   fhtotFlatMax->Draw("same");
2213
2214   fhTotalMin->Draw("same");
2215   fhTotalMax->Draw("same");
2216
2217   TCanvas *cCanvaFinalPlot=new TCanvas("cCanvaFinalPlot","cCanvaFinalPlot",700,700);
2218   cCanvaFinalPlot->cd();
2219   hCorrPlot->Draw();
2220   //  fgrYieldUnc->Draw("pE2");
2221   //  fgrBackSubUnc->Draw("pE2");
2222   //  fgrMCcorrections->Draw("pE2");
2223   //  fgrMCclosureTest->Draw("pE2");
2224   //  fgrBeautyFD->Draw("pE2");
2225   fgrTotal->Draw("E2");
2226
2227
2228   TCanvas *cCanvaFinalPlotFD=new TCanvas("cCanvaFinalPlotFD","cCanvaFinalPlotFD",700,700);
2229   cCanvaFinalPlotFD->cd();
2230   hCorrPlot->Draw();
2231   //  fgrYieldUnc->Draw("pE2");
2232   //  fgrBackSubUnc->Draw("pE2");
2233   //  fgrMCcorrections->Draw("pE2");
2234   //  fgrMCclosureTest->Draw("pE2");
2235   //  fgrBeautyFD->Draw("pE2");
2236   fgrBeautyFD->Draw("E2");
2237   fgrTotalNonFD->Draw("E2");
2238   fgrTotalNonFlatDPhi->Draw("E2");
2239   fgrTotalFlatDPhi->Draw("E2");
2240
2241   return cCanvaFinalPlot;
2242 }
2243
2244
2245 TH1D* AliHFDhadronCorrSystUnc::GetVariedHisto(const TH1D *hIn,const TGraphAsymmErrors *gr,Int_t minmax){
2246
2247   TH1D *hOut;
2248   if(minmax==0){
2249     hOut=(TH1D*)hIn->Clone(Form("%sVariedMin",hIn->GetName()));
2250   }
2251   else if(minmax==1){
2252     hOut=(TH1D*)hIn->Clone(Form("%sVariedMax",hIn->GetName()));
2253   }
2254   //  Int_t np=gr->GetN();
2255   Double_t *x,*y,*ely,*ehy;//*elx,*ehx,
2256   x=gr->GetX();
2257   y=gr->GetY();
2258   //  elx=gr->GetEXlow();
2259   // ehx=gr->GetEXhigh();
2260    ely=gr->GetEYlow();
2261   ehy=gr->GetEYhigh();
2262
2263   for(Int_t jp=1;jp<=hIn->GetNbinsX();jp++){
2264     if(TMath::Abs(x[jp-1]-hIn->GetBinCenter(jp))>0.0001){
2265       Printf("Bin Mismatch: this method assumes that the graph has the points in the center of the histo bin centers");
2266       return 0x0;
2267     }
2268     if(TMath::Abs(y[jp-1]-hIn->GetBinContent(jp))>0.0001){
2269       Printf("Value Mismatch: this method relies on the fact that the graph central values are the same as those of the histo");
2270       return 0x0;
2271     }
2272     if(minmax==0){
2273       hOut->SetBinContent(jp,y[jp-1]-ely[jp-1]);
2274     }
2275     else if(minmax==1){
2276       hOut->SetBinContent(jp,y[jp-1]+ehy[jp-1]);
2277     }
2278     hOut->SetBinError(jp,hIn->GetBinError(jp));
2279   }
2280
2281   return hOut;
2282 }
2283
2284
2285
2286 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2287 /////
2288 ///// METHODS WITH UNCERTAINTIES: PP 2010, for kinematic cases approved after HP2013
2289 /////
2290 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2291
2292
2293 // START FROM DPLUS FOR PT(ASSOC)>0.3
2294 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2295   fmeson=0;
2296   fstrmeson="Dplus";
2297   fstrptAss="ptAsMore03";
2298   fstrptD="Dpt3to5";
2299   if(!fhDeltaPhiTemplate){
2300     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2301   }
2302   Double_t x;
2303   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2304   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2305   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2306     fhYieldExtraction->SetBinContent(j,0.1);
2307   }
2308
2309   // Background D MESON candidate subtraction (side-band variations, etc.)
2310   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2311   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2312     fhBackSubtractionMin->SetBinContent(j,-0.05);
2313   }
2314
2315   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2316   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2317     fhBackSubtractionMax->SetBinContent(j,0.05);
2318   }
2319
2320
2321   // MC CORRECTIONS ( associatate track efficiency):
2322   //  -5%  +10% for assoc track eff
2323   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2324   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2325     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2326   }
2327
2328   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2329   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2330     fhMCcorrectionsMax->SetBinContent(j,0.10);
2331   }
2332
2333   // MC D EFF CORRECTION
2334   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2335   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2336     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2337   }
2338
2339   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2340   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2341     fhMCDefficiencyMax->SetBinContent(j,0.05);
2342   }
2343
2344
2345   // Contamination from secondary tracks
2346   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2347   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2348     fhSecContaminationMin->SetBinContent(j,-0.05);
2349   }
2350
2351   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2352   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2353     fhSecContaminationMax->SetBinContent(j,0.05);
2354   }
2355
2356
2357   // MC CLOSURETEST (D meson efficiency)
2358   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2359   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2360     x=fhMCclosureTestMin->GetBinLowEdge(j);
2361     fhMCclosureTestMin->SetBinContent(j,-0.0);
2362
2363     if(-0.4<x&&x<-0.2){
2364       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2365     }
2366     else if(-0.2<x&&x<-0.1){
2367       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2368     }
2369     else if(-0.1<x&&x<0.1){
2370       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2371     }
2372     else if(0.1<x&&x<0.2){
2373       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2374     }
2375     if(0.2<x&&x<0.4){
2376       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2377     }
2378   }
2379
2380   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2381   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2382     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
2383     fhMCclosureTestMax->SetBinContent(j,0.);
2384
2385     //     if(-0.4<x&&x<-0.2){
2386     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2387     //     }
2388     //     else if(-0.2<x&&x<-0.1){
2389     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2390     //     }
2391     //     else if(-0.2<x&&x<-0.1){
2392     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2393     //     }
2394     //     else if(-0.1<x&&x<0.1){
2395     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2396     //     }
2397     //     else if(0.1<x&&x<0.2){
2398     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2399     //     }
2400     //     if(0.2<x&&x<0.4){
2401     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2402     //     }
2403
2404   }
2405
2406   // Feed-down
2407
2408   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2409   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2410     x=fhBeautyFDmin->GetBinLowEdge(j);
2411     fhBeautyFDmin->SetBinContent(j,-0.05);
2412
2413   //   if(-0.4<x&&x<-0.2){
2414 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2415 //     }
2416 //     else if(-0.2<x&&x<-0.1){
2417 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2418 //     }
2419 //     else if(-0.2<x&&x<-0.1){
2420 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2421 //     }
2422 //     else if(-0.1<x&&x<0.1){
2423 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2424 //     }
2425 //     else if(0.1<x&&x<0.2){
2426 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2427 //     }
2428 //     if(0.2<x&&x<0.4){
2429 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2430 //     }
2431   }
2432
2433   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2434   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2435     x=fhBeautyFDmax->GetBinLowEdge(j);
2436     fhBeautyFDmax->SetBinContent(j,0.03);
2437
2438 //     if(-0.4<x&&x<-0.2){
2439 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2440 //     }
2441 //     else if(-0.2<x&&x<-0.1){
2442 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2443 //     }
2444 //     else if(-0.2<x&&x<-0.1){
2445 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2446 //     }
2447 //     else if(-0.1<x&&x<0.1){
2448 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2449 //     }
2450 //     else if(0.1<x&&x<0.2){
2451 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2452 //     }
2453 //     if(0.2<x&&x<0.4){
2454 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2455 //     }
2456
2457   }
2458
2459 }
2460
2461 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2462
2463   fmeson=0;
2464   fstrmeson="Dplus";
2465   fstrptAss="ptAsMore03";
2466   fstrptD="Dpt5to8";
2467   if(!fhDeltaPhiTemplate){
2468     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2469   }
2470   Double_t x;
2471   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2472   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2473   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2474     fhYieldExtraction->SetBinContent(j,0.1);
2475   }
2476
2477   // Background D MESON candidate subtraction (side-band variations, etc.)
2478   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2479   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2480     fhBackSubtractionMin->SetBinContent(j,-0.05);
2481   }
2482
2483   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2484   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2485     fhBackSubtractionMax->SetBinContent(j,0.05);
2486   }
2487
2488   // MC CORRECTIONS:  -5%  +10% for assoc track eff
2489   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2490   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2491     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2492   }
2493
2494   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2495   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2496     fhMCcorrectionsMax->SetBinContent(j,0.10);
2497   }
2498
2499
2500   // MC D EFF CORRECTION
2501   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2502   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2503     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2504   }
2505
2506   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2507   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2508     fhMCDefficiencyMax->SetBinContent(j,0.05);
2509   }
2510
2511
2512   // Contamination from secondary tracks
2513   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2514   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2515     fhSecContaminationMin->SetBinContent(j,-0.05);
2516   }
2517
2518   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2519   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2520     fhSecContaminationMax->SetBinContent(j,0.05);
2521   }
2522
2523   // MC CLOSURETEST (D meson efficiency)
2524   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2525   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2526     x=fhMCclosureTestMin->GetBinLowEdge(j);
2527     fhMCclosureTestMin->SetBinContent(j,-0.0);
2528
2529     if(-0.4<x&&x<-0.2){
2530       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2531     }
2532     else if(-0.2<x&&x<-0.1){
2533       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2534     }
2535     else if(-0.1<x&&x<0.1){
2536       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2537     }
2538     else if(0.1<x&&x<0.2){
2539       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2540     }
2541     if(0.2<x&&x<0.4){
2542       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2543     }
2544   }
2545
2546   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2547   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2548     x=fhMCclosureTestMax->GetBinLowEdge(j);
2549     fhMCclosureTestMax->SetBinContent(j,0.);
2550
2551     //     if(-0.4<x&&x<-0.2){
2552     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2553     //     }
2554     //     else if(-0.2<x&&x<-0.1){
2555     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2556     //     }
2557     //     else if(-0.2<x&&x<-0.1){
2558     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2559     //     }
2560     //     else if(-0.1<x&&x<0.1){
2561     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2562     //     }
2563     //     else if(0.1<x&&x<0.2){
2564     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2565     //     }
2566     //     if(0.2<x&&x<0.4){
2567     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2568     //     }
2569
2570   }
2571
2572   // Feed-down
2573
2574   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2575   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2576     x=fhBeautyFDmin->GetBinLowEdge(j);
2577     fhBeautyFDmin->SetBinContent(j,-0.05);
2578
2579   //   if(-0.4<x&&x<-0.2){
2580 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2581 //     }
2582 //     else if(-0.2<x&&x<-0.1){
2583 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2584 //     }
2585 //     else if(-0.2<x&&x<-0.1){
2586 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2587 //     }
2588 //     else if(-0.1<x&&x<0.1){
2589 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2590 //     }
2591 //     else if(0.1<x&&x<0.2){
2592 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2593 //     }
2594 //     if(0.2<x&&x<0.4){
2595 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2596 //     }
2597   }
2598
2599   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2600   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2601     x=fhBeautyFDmax->GetBinLowEdge(j);
2602     fhBeautyFDmax->SetBinContent(j,0.03);
2603
2604 //     if(-0.4<x&&x<-0.2){
2605 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2606 //     }
2607 //     else if(-0.2<x&&x<-0.1){
2608 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2609 //     }
2610 //     else if(-0.2<x&&x<-0.1){
2611 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2612 //     }
2613 //     else if(-0.1<x&&x<0.1){
2614 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2615 //     }
2616 //     else if(0.1<x&&x<0.2){
2617 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2618 //     }
2619 //     if(0.2<x&&x<0.4){
2620 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2621 //     }
2622
2623   }
2624
2625 }
2626
2627
2628 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2629
2630   fmeson=0;
2631   fstrmeson="Dplus";
2632   fstrptAss="ptAsMore03";
2633   fstrptD="Dpt8to16";
2634   if(!fhDeltaPhiTemplate){
2635     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2636   }
2637
2638   Double_t x;
2639   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2640   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2641   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2642     fhYieldExtraction->SetBinContent(j,0.1);
2643   }
2644
2645   // Background D MESON candidate subtraction (side-band variations, etc.)
2646   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2647   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2648     fhBackSubtractionMin->SetBinContent(j,-0.05);
2649   }
2650
2651   // Background D MESON candidate subtraction (side-band variations, etc.)
2652   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2653   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2654     fhBackSubtractionMax->SetBinContent(j,0.05);
2655   }
2656
2657   // MC CORRECTIONS,  -5% 10% for assoc track eff
2658   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2659   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2660     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2661   }
2662
2663   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2664   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2665     fhMCcorrectionsMax->SetBinContent(j,0.10);
2666   }
2667
2668
2669   // MC D EFF CORRECTION
2670   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2671   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2672     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2673   }
2674
2675   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2676   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2677     fhMCDefficiencyMax->SetBinContent(j,0.05);
2678   }
2679
2680
2681   // Contamination from secondary tracks
2682   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2683   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2684     fhSecContaminationMin->SetBinContent(j,-0.05);
2685   }
2686
2687   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2688   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2689     fhSecContaminationMax->SetBinContent(j,0.05);
2690   }
2691
2692   // MC CLOSURETEST (D meson efficiency)
2693   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2694   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2695     x=fhMCclosureTestMin->GetBinLowEdge(j);
2696     fhMCclosureTestMin->SetBinContent(j,-0.0);
2697
2698     if(-0.4<x&&x<-0.2){
2699       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2700     }
2701     else if(-0.2<x&&x<-0.1){
2702       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2703     }
2704     else if(-0.1<x&&x<0.1){
2705       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2706     }
2707     else if(0.1<x&&x<0.2){
2708       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2709     }
2710     if(0.2<x&&x<0.4){
2711       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2712     }
2713   }
2714
2715   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2716   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2717     x=fhMCclosureTestMax->GetBinLowEdge(j);
2718     fhMCclosureTestMax->SetBinContent(j,0.);
2719
2720     //     if(-0.4<x&&x<-0.2){
2721     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2722     //     }
2723     //     else if(-0.2<x&&x<-0.1){
2724     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2725     //     }
2726     //     else if(-0.2<x&&x<-0.1){
2727     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2728     //     }
2729     //     else if(-0.1<x&&x<0.1){
2730     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2731     //     }
2732     //     else if(0.1<x&&x<0.2){
2733     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2734     //     }
2735     //     if(0.2<x&&x<0.4){
2736     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2737     //     }
2738
2739   }
2740
2741   // Feed-down
2742
2743   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2744   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2745     x=fhBeautyFDmin->GetBinLowEdge(j);
2746     fhBeautyFDmin->SetBinContent(j,-0.05);
2747
2748   //   if(-0.4<x&&x<-0.2){
2749 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2750 //     }
2751 //     else if(-0.2<x&&x<-0.1){
2752 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2753 //     }
2754 //     else if(-0.2<x&&x<-0.1){
2755 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2756 //     }
2757 //     else if(-0.1<x&&x<0.1){
2758 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2759 //     }
2760 //     else if(0.1<x&&x<0.2){
2761 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2762 //     }
2763 //     if(0.2<x&&x<0.4){
2764 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2765 //     }
2766   }
2767
2768   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2769   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2770     x=fhBeautyFDmax->GetBinLowEdge(j);
2771     fhBeautyFDmax->SetBinContent(j,0.03);
2772
2773 //     if(-0.4<x&&x<-0.2){
2774 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2775 //     }
2776 //     else if(-0.2<x&&x<-0.1){
2777 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2778 //     }
2779 //     else if(-0.2<x&&x<-0.1){
2780 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2781 //     }
2782 //     else if(-0.1<x&&x<0.1){
2783 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2784 //     }
2785 //     else if(0.1<x&&x<0.2){
2786 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2787 //     }
2788 //     if(0.2<x&&x<0.4){
2789 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2790 //     }
2791
2792   }
2793
2794 }
2795
2796
2797
2798 //////// HIGHER PT ASS THRESHOLDS
2799
2800 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){
2801   Printf("Setting syst for D0 pp 2010 3-5 0.5 thr");
2802   fmeson=0;
2803   fstrmeson="Dzero";
2804   fstrptAss="ptAsMore05";
2805   fstrptD="Dpt3to5";
2806   if(!fhDeltaPhiTemplate){
2807     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2808   }
2809   Double_t x;
2810   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2811   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2812   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2813     fhYieldExtraction->SetBinContent(j,0.1);
2814   }
2815
2816   // Background D MESON candidate subtraction (side-band variations, etc.)
2817   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2818   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2819     fhBackSubtractionMin->SetBinContent(j,-0.05);
2820   }
2821
2822   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2823   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2824     fhBackSubtractionMax->SetBinContent(j,0.05);
2825   }
2826
2827
2828   // MC CORRECTIONS ( associatate track efficiency):
2829   //  -5%  +10% for assoc track eff
2830   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2831   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2832     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2833   }
2834
2835   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2836   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2837     fhMCcorrectionsMax->SetBinContent(j,0.10);
2838   }
2839
2840   // MC D EFF CORRECTION
2841   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2842   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2843     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2844   }
2845
2846   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2847   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2848     fhMCDefficiencyMax->SetBinContent(j,0.05);
2849   }
2850
2851
2852   // Contamination from secondary tracks
2853   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2854   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2855     fhSecContaminationMin->SetBinContent(j,-0.05);
2856   }
2857
2858   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2859   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2860     fhSecContaminationMax->SetBinContent(j,0.05);
2861   }
2862
2863
2864   // MC CLOSURETEST (D meson efficiency)
2865   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2866   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2867     x=fhMCclosureTestMin->GetBinLowEdge(j);
2868     fhMCclosureTestMin->SetBinContent(j,-0.);
2869
2870     if(-0.4<x&&x<-0.2){
2871       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2872     }
2873     else if(-0.2<x&&x<-0.1){
2874       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2875     }
2876     else if(-0.1<x&&x<0.1){
2877       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2878     }
2879     else if(0.1<x&&x<0.2){
2880       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2881     }
2882     if(0.2<x&&x<0.4){
2883       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2884     }
2885   }
2886
2887   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2888   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2889     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
2890     fhMCclosureTestMax->SetBinContent(j,0.);
2891
2892     //     if(-0.4<x&&x<-0.2){
2893     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2894     //     }
2895     //     else if(-0.2<x&&x<-0.1){
2896     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2897     //     }
2898     //     else if(-0.2<x&&x<-0.1){
2899     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2900     //     }
2901     //     else if(-0.1<x&&x<0.1){
2902     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2903     //     }
2904     //     else if(0.1<x&&x<0.2){
2905     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2906     //     }
2907     //     if(0.2<x&&x<0.4){
2908     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2909     //     }
2910
2911   }
2912
2913   // Feed-down
2914
2915   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2916   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2917     x=fhBeautyFDmin->GetBinLowEdge(j);
2918     fhBeautyFDmin->SetBinContent(j,-0.05);
2919
2920   //   if(-0.4<x&&x<-0.2){
2921 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2922 //     }
2923 //     else if(-0.2<x&&x<-0.1){
2924 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2925 //     }
2926 //     else if(-0.2<x&&x<-0.1){
2927 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2928 //     }
2929 //     else if(-0.1<x&&x<0.1){
2930 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2931 //     }
2932 //     else if(0.1<x&&x<0.2){
2933 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2934 //     }
2935 //     if(0.2<x&&x<0.4){
2936 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2937 //     }
2938   }
2939
2940   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2941   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2942     x=fhBeautyFDmax->GetBinLowEdge(j);
2943     fhBeautyFDmax->SetBinContent(j,0.03);
2944
2945 //     if(-0.4<x&&x<-0.2){
2946 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2947 //     }
2948 //     else if(-0.2<x&&x<-0.1){
2949 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2950 //     }
2951 //     else if(-0.2<x&&x<-0.1){
2952 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2953 //     }
2954 //     else if(-0.1<x&&x<0.1){
2955 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2956 //     }
2957 //     else if(0.1<x&&x<0.2){
2958 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2959 //     }
2960 //     if(0.2<x&&x<0.4){
2961 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2962 //     }
2963
2964   }
2965
2966 }
2967
2968 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
2969   Printf("Setting syst for D0 pp 2010 5-8 0.5 thr");
2970
2971   fmeson=0;
2972   fstrmeson="Dzero";
2973   fstrptAss="ptAsMore05";
2974   fstrptD="Dpt5to8";
2975   if(!fhDeltaPhiTemplate){
2976     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2977   }
2978   Double_t x;
2979   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2980   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2981   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2982     fhYieldExtraction->SetBinContent(j,0.1);
2983   }
2984
2985   // Background D MESON candidate subtraction (side-band variations, etc.)
2986   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2987   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2988     fhBackSubtractionMin->SetBinContent(j,-0.05);
2989   }
2990
2991   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2992   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2993     fhBackSubtractionMax->SetBinContent(j,0.05);
2994   }
2995
2996   // MC CORRECTIONS:  -5%  +10% for assoc track eff
2997   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2998   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2999     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3000   }
3001
3002   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3003   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3004     fhMCcorrectionsMax->SetBinContent(j,0.10);
3005   }
3006
3007
3008   // MC D EFF CORRECTION
3009   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3010   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3011     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3012   }
3013
3014   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3015   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3016     fhMCDefficiencyMax->SetBinContent(j,0.05);
3017   }
3018
3019
3020   // Contamination from secondary tracks
3021   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3022   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3023     fhSecContaminationMin->SetBinContent(j,-0.05);
3024   }
3025
3026   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3027   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3028     fhSecContaminationMax->SetBinContent(j,0.05);
3029   }
3030
3031   // MC CLOSURETEST (D meson efficiency)
3032   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3033   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3034     x=fhMCclosureTestMin->GetBinLowEdge(j);
3035     fhMCclosureTestMin->SetBinContent(j,-0.);
3036
3037     if(-0.4<x&&x<-0.2){
3038       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3039     }
3040     else if(-0.2<x&&x<-0.1){
3041       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3042     }
3043     else if(-0.1<x&&x<0.1){
3044       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3045     }
3046     else if(0.1<x&&x<0.2){
3047       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3048     }
3049     if(0.2<x&&x<0.4){
3050       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3051     }
3052   }
3053
3054   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3055   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3056     x=fhMCclosureTestMax->GetBinLowEdge(j);
3057     fhMCclosureTestMax->SetBinContent(j,0.);
3058
3059     //     if(-0.4<x&&x<-0.2){
3060     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3061     //     }
3062     //     else if(-0.2<x&&x<-0.1){
3063     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3064     //     }
3065     //     else if(-0.2<x&&x<-0.1){
3066     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3067     //     }
3068     //     else if(-0.1<x&&x<0.1){
3069     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3070     //     }
3071     //     else if(0.1<x&&x<0.2){
3072     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3073     //     }
3074     //     if(0.2<x&&x<0.4){
3075     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3076     //     }
3077
3078   }
3079
3080   // Feed-down
3081
3082   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3083   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3084     x=fhBeautyFDmin->GetBinLowEdge(j);
3085     fhBeautyFDmin->SetBinContent(j,-0.05);
3086
3087   //   if(-0.4<x&&x<-0.2){
3088 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3089 //     }
3090 //     else if(-0.2<x&&x<-0.1){
3091 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3092 //     }
3093 //     else if(-0.2<x&&x<-0.1){
3094 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3095 //     }
3096 //     else if(-0.1<x&&x<0.1){
3097 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3098 //     }
3099 //     else if(0.1<x&&x<0.2){
3100 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3101 //     }
3102 //     if(0.2<x&&x<0.4){
3103 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3104 //     }
3105   }
3106
3107   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3108   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3109     x=fhBeautyFDmax->GetBinLowEdge(j);
3110     fhBeautyFDmax->SetBinContent(j,0.03);
3111
3112 //     if(-0.4<x&&x<-0.2){
3113 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3114 //     }
3115 //     else if(-0.2<x&&x<-0.1){
3116 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3117 //     }
3118 //     else if(-0.2<x&&x<-0.1){
3119 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3120 //     }
3121 //     else if(-0.1<x&&x<0.1){
3122 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3123 //     }
3124 //     else if(0.1<x&&x<0.2){
3125 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3126 //     }
3127 //     if(0.2<x&&x<0.4){
3128 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3129 //     }
3130
3131   }
3132
3133 }
3134
3135
3136 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
3137   Printf("Setting syst for D0 pp 2010 8-16 0.5 thr");
3138
3139   fmeson=0;
3140   fstrmeson="Dzero";
3141   fstrptAss="ptAsMore05";
3142   fstrptD="Dpt8to16";
3143   if(!fhDeltaPhiTemplate){
3144     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3145   }
3146
3147   Double_t x;
3148   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3149   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3150   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3151     fhYieldExtraction->SetBinContent(j,0.1);
3152   }
3153
3154   // Background D MESON candidate subtraction (side-band variations, etc.)
3155   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3156   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3157     fhBackSubtractionMin->SetBinContent(j,-0.05);
3158   }
3159
3160   // Background D MESON candidate subtraction (side-band variations, etc.)
3161   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3162   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3163     fhBackSubtractionMax->SetBinContent(j,0.05);
3164   }
3165
3166   // MC CORRECTIONS,  -5% 10% for assoc track eff
3167   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3168   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3169     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3170   }
3171
3172   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3173   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3174     fhMCcorrectionsMax->SetBinContent(j,0.10);
3175   }
3176
3177
3178   // MC D EFF CORRECTION
3179   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3180   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3181     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3182   }
3183
3184   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3185   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3186     fhMCDefficiencyMax->SetBinContent(j,0.05);
3187   }
3188
3189
3190   // Contamination from secondary tracks
3191   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3192   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3193     fhSecContaminationMin->SetBinContent(j,-0.05);
3194   }
3195
3196   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3197   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3198     fhSecContaminationMax->SetBinContent(j,0.05);
3199   }
3200
3201   // MC CLOSURETEST (D meson efficiency)
3202   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3203   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3204     x=fhMCclosureTestMin->GetBinLowEdge(j);
3205     fhMCclosureTestMin->SetBinContent(j,-0.);
3206
3207     if(-0.4<x&&x<-0.2){
3208       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3209     }
3210     else if(-0.2<x&&x<-0.1){
3211       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3212     }
3213     else if(-0.1<x&&x<0.1){
3214       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3215     }
3216     else if(0.1<x&&x<0.2){
3217       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3218     }
3219     if(0.2<x&&x<0.4){
3220       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3221     }
3222   }
3223
3224   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3225   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3226     x=fhMCclosureTestMax->GetBinLowEdge(j);
3227     fhMCclosureTestMax->SetBinContent(j,0.);
3228
3229     //     if(-0.4<x&&x<-0.2){
3230     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3231     //     }
3232     //     else if(-0.2<x&&x<-0.1){
3233     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3234     //     }
3235     //     else if(-0.2<x&&x<-0.1){
3236     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3237     //     }
3238     //     else if(-0.1<x&&x<0.1){
3239     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3240     //     }
3241     //     else if(0.1<x&&x<0.2){
3242     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3243     //     }
3244     //     if(0.2<x&&x<0.4){
3245     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3246     //     }
3247
3248   }
3249
3250   // Feed-down
3251
3252   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3253   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3254     x=fhBeautyFDmin->GetBinLowEdge(j);
3255     fhBeautyFDmin->SetBinContent(j,-0.05);
3256
3257   //   if(-0.4<x&&x<-0.2){
3258 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3259 //     }
3260 //     else if(-0.2<x&&x<-0.1){
3261 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3262 //     }
3263 //     else if(-0.2<x&&x<-0.1){
3264 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3265 //     }
3266 //     else if(-0.1<x&&x<0.1){
3267 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3268 //     }
3269 //     else if(0.1<x&&x<0.2){
3270 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3271 //     }
3272 //     if(0.2<x&&x<0.4){
3273 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3274 //     }
3275   }
3276
3277   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3278   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3279     x=fhBeautyFDmax->GetBinLowEdge(j);
3280     fhBeautyFDmax->SetBinContent(j,0.03);
3281
3282 //     if(-0.4<x&&x<-0.2){
3283 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3284 //     }
3285 //     else if(-0.2<x&&x<-0.1){
3286 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3287 //     }
3288 //     else if(-0.2<x&&x<-0.1){
3289 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3290 //     }
3291 //     else if(-0.1<x&&x<0.1){
3292 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3293 //     }
3294 //     else if(0.1<x&&x<0.2){
3295 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3296 //     }
3297 //     if(0.2<x&&x<0.4){
3298 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3299 //     }
3300
3301   }
3302
3303 }
3304
3305
3306
3307
3308 //--------------------------------------------------
3309 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){
3310   Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3311   fmeson=1;
3312   fstrmeson="Dstar";
3313   fstrptAss="ptAsMore05";
3314   fstrptD="Dpt3to5";
3315   if(!fhDeltaPhiTemplate){
3316     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3317   }
3318   Double_t x;
3319   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3320   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3321   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3322     fhYieldExtraction->SetBinContent(j,0.1);
3323   }
3324
3325   // Background D MESON candidate subtraction (side-band variations, etc.)
3326   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3327   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3328     fhBackSubtractionMin->SetBinContent(j,-0.05);
3329   }
3330
3331   // Background D MESON candidate subtraction (side-band variations, etc.)
3332   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3333   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3334     fhBackSubtractionMax->SetBinContent(j,0.05);
3335   }
3336
3337   // MC CORRECTIONS, -5%  10% for assoc track eff
3338   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3339   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3340     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3341   }
3342
3343   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3344   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3345     fhMCcorrectionsMax->SetBinContent(j,0.10);
3346   }
3347
3348
3349   // MC D EFF CORRECTION
3350   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3351   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3352     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3353   }
3354
3355   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3356   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3357     fhMCDefficiencyMax->SetBinContent(j,0.05);
3358   }
3359
3360
3361   // Contamination from secondary tracks
3362   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3363   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3364     fhSecContaminationMin->SetBinContent(j,-0.05);
3365   }
3366
3367   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3368   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3369     fhSecContaminationMax->SetBinContent(j,0.05);
3370   }
3371
3372   // MC CLOSURETEST (D meson efficiency)
3373   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3374   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3375     x=fhMCclosureTestMin->GetBinLowEdge(j);
3376     fhMCclosureTestMin->SetBinContent(j,-0.08);
3377
3378     if(-0.4<x&&x<-0.2){
3379       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3380     }
3381     else if(-0.2<x&&x<-0.1){
3382       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3383     }
3384     else if(-0.1<x&&x<0.1){
3385       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3386     }
3387     else if(0.1<x&&x<0.2){
3388       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3389     }
3390     if(0.2<x&&x<0.4){
3391       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3392     }
3393   }
3394
3395   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3396   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3397     x=fhMCclosureTestMax->GetBinLowEdge(j);
3398     fhMCclosureTestMax->SetBinContent(j,0.);
3399
3400     //     if(-0.4<x&&x<-0.2){
3401     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3402     //     }
3403     //     else if(-0.2<x&&x<-0.1){
3404     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3405     //     }
3406     //     else if(-0.2<x&&x<-0.1){
3407     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3408     //     }
3409     //     else if(-0.1<x&&x<0.1){
3410     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3411     //     }
3412     //     else if(0.1<x&&x<0.2){
3413     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3414     //     }
3415     //     if(0.2<x&&x<0.4){
3416     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3417     //     }
3418
3419   }
3420
3421   // Feed-down
3422
3423   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3424   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3425     x=fhBeautyFDmin->GetBinLowEdge(j);
3426     fhBeautyFDmin->SetBinContent(j,-0.05);
3427
3428   //   if(-0.4<x&&x<-0.2){
3429 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3430 //     }
3431 //     else if(-0.2<x&&x<-0.1){
3432 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3433 //     }
3434 //     else if(-0.2<x&&x<-0.1){
3435 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3436 //     }
3437 //     else if(-0.1<x&&x<0.1){
3438 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3439 //     }
3440 //     else if(0.1<x&&x<0.2){
3441 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3442 //     }
3443 //     if(0.2<x&&x<0.4){
3444 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3445 //     }
3446   }
3447
3448   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3449   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3450     x=fhBeautyFDmax->GetBinLowEdge(j);
3451     fhBeautyFDmax->SetBinContent(j,0.03);
3452
3453 //     if(-0.4<x&&x<-0.2){
3454 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3455 //     }
3456 //     else if(-0.2<x&&x<-0.1){
3457 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3458 //     }
3459 //     else if(-0.2<x&&x<-0.1){
3460 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3461 //     }
3462 //     else if(-0.1<x&&x<0.1){
3463 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3464 //     }
3465 //     else if(0.1<x&&x<0.2){
3466 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3467 //     }
3468 //     if(0.2<x&&x<0.4){
3469 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3470 //     }
3471
3472   }
3473
3474
3475 }
3476
3477 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
3478   Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3479   fmeson=1;
3480   fstrmeson="Dstar";
3481   fstrptAss="ptAsMore05";
3482   fstrptD="Dpt5to8";
3483   if(!fhDeltaPhiTemplate){
3484     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3485   }
3486   Double_t x;
3487   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3488   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3489   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3490     fhYieldExtraction->SetBinContent(j,0.1);
3491   }
3492
3493   // Background D MESON candidate subtraction (side-band variations, etc.)
3494   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3495   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3496     fhBackSubtractionMin->SetBinContent(j,-0.05);
3497   }
3498
3499   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3500   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3501     fhBackSubtractionMax->SetBinContent(j,0.05);
3502   }
3503
3504   // MC CORRECTIONS/ -5%  10% for assoc track eff
3505   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3506   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3507     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3508   }
3509
3510   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3511   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3512     fhMCcorrectionsMax->SetBinContent(j,0.10);
3513   }
3514
3515   // MC D EFF CORRECTION
3516   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3517   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3518     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3519   }
3520
3521   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3522   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3523     fhMCDefficiencyMax->SetBinContent(j,0.05);
3524   }
3525
3526
3527   // Contamination from secondary tracks
3528   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3529   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3530     fhSecContaminationMin->SetBinContent(j,-0.05);
3531   }
3532
3533   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3534   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3535     fhSecContaminationMax->SetBinContent(j,0.05);
3536   }
3537
3538   // MC CLOSURETEST (D meson efficiency)
3539   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3540   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3541     x=fhMCclosureTestMin->GetBinLowEdge(j);
3542     fhMCclosureTestMin->SetBinContent(j,-0.0);
3543
3544     if(-0.4<x&&x<-0.2){
3545       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3546     }
3547     else if(-0.2<x&&x<-0.1){
3548       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3549     }
3550     else if(-0.1<x&&x<0.1){
3551       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3552     }
3553     else if(0.1<x&&x<0.2){
3554       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3555     }
3556     if(0.2<x&&x<0.4){
3557       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3558     }
3559   }
3560
3561   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3562   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3563     x=fhMCclosureTestMax->GetBinLowEdge(j);
3564     fhMCclosureTestMax->SetBinContent(j,0.);
3565
3566     //     if(-0.4<x&&x<-0.2){
3567     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3568     //     }
3569     //     else if(-0.2<x&&x<-0.1){
3570     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3571     //     }
3572     //     else if(-0.2<x&&x<-0.1){
3573     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3574     //     }
3575     //     else if(-0.1<x&&x<0.1){
3576     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3577     //     }
3578     //     else if(0.1<x&&x<0.2){
3579     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3580     //     }
3581     //     if(0.2<x&&x<0.4){
3582     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3583     //     }
3584
3585   }
3586
3587   // Feed-down
3588
3589   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3590   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3591     x=fhBeautyFDmin->GetBinLowEdge(j);
3592     fhBeautyFDmin->SetBinContent(j,-0.05);
3593
3594   //   if(-0.4<x&&x<-0.2){
3595 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3596 //     }
3597 //     else if(-0.2<x&&x<-0.1){
3598 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3599 //     }
3600 //     else if(-0.2<x&&x<-0.1){
3601 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3602 //     }
3603 //     else if(-0.1<x&&x<0.1){
3604 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3605 //     }
3606 //     else if(0.1<x&&x<0.2){
3607 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3608 //     }
3609 //     if(0.2<x&&x<0.4){
3610 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3611 //     }
3612   }
3613
3614   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3615   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3616     x=fhBeautyFDmax->GetBinLowEdge(j);
3617     fhBeautyFDmax->SetBinContent(j,0.03);
3618
3619 //     if(-0.4<x&&x<-0.2){
3620 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3621 //     }
3622 //     else if(-0.2<x&&x<-0.1){
3623 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3624 //     }
3625 //     else if(-0.2<x&&x<-0.1){
3626 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3627 //     }
3628 //     else if(-0.1<x&&x<0.1){
3629 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3630 //     }
3631 //     else if(0.1<x&&x<0.2){
3632 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3633 //     }
3634 //     if(0.2<x&&x<0.4){
3635 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3636 //     }
3637
3638   }
3639
3640 }
3641
3642
3643
3644 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
3645   Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
3646   fmeson=1;
3647   fstrmeson="Dstar";
3648   fstrptAss="ptAsMore05";
3649   fstrptD="Dpt8to16";
3650   if(!fhDeltaPhiTemplate){
3651     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3652   }
3653   Double_t x;
3654   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3655   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3656   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3657     fhYieldExtraction->SetBinContent(j,0.1);
3658   }
3659
3660   // Background D MESON candidate subtraction (side-band variations, etc.)
3661   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3662   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3663     fhBackSubtractionMin->SetBinContent(j,-0.05);
3664   }
3665 // check those values
3666   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3667   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3668     fhBackSubtractionMax->SetBinContent(j,0.2); // check this one in particular
3669   }
3670
3671   // MC CORRECTIONS   -5% +10% for assoc track eff
3672   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3673   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3674     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3675   }
3676
3677   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3678   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3679     fhMCcorrectionsMax->SetBinContent(j,0.10);
3680   }
3681   // MC D EFF CORRECTION
3682   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3683   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3684     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3685   }
3686
3687   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3688   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3689     fhMCDefficiencyMax->SetBinContent(j,0.05);
3690   }
3691
3692
3693   // Contamination from secondary tracks
3694   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3695   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3696     fhSecContaminationMin->SetBinContent(j,-0.05);
3697   }
3698
3699   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3700   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3701     fhSecContaminationMax->SetBinContent(j,0.05);
3702   }
3703
3704   // MC CLOSURETEST (D meson efficiency)
3705   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3706   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3707     x=fhMCclosureTestMin->GetBinLowEdge(j);
3708     fhMCclosureTestMin->SetBinContent(j,-0);
3709
3710     if(-0.4<x&&x<-0.2){
3711       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3712     }
3713     else if(-0.2<x&&x<-0.1){
3714       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3715     }
3716     else if(-0.1<x&&x<0.1){
3717       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3718     }
3719     else if(0.1<x&&x<0.2){
3720       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3721     }
3722     if(0.2<x&&x<0.4){
3723       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3724     }
3725   }
3726
3727   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3728   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3729     x=fhMCclosureTestMax->GetBinLowEdge(j);
3730     fhMCclosureTestMax->SetBinContent(j,0.);
3731
3732     //     if(-0.4<x&&x<-0.2){
3733     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3734     //     }
3735     //     else if(-0.2<x&&x<-0.1){
3736     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3737     //     }
3738     //     else if(-0.2<x&&x<-0.1){
3739     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3740     //     }
3741     //     else if(-0.1<x&&x<0.1){
3742     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3743     //     }
3744     //     else if(0.1<x&&x<0.2){
3745     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3746     //     }
3747     //     if(0.2<x&&x<0.4){
3748     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3749     //     }
3750
3751   }
3752
3753   // Feed-down
3754
3755   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3756   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3757     x=fhBeautyFDmin->GetBinLowEdge(j);
3758     fhBeautyFDmin->SetBinContent(j,-0.05);
3759
3760   //   if(-0.4<x&&x<-0.2){
3761 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3762 //     }
3763 //     else if(-0.2<x&&x<-0.1){
3764 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3765 //     }
3766 //     else if(-0.2<x&&x<-0.1){
3767 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3768 //     }
3769 //     else if(-0.1<x&&x<0.1){
3770 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3771 //     }
3772 //     else if(0.1<x&&x<0.2){
3773 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3774 //     }
3775 //     if(0.2<x&&x<0.4){
3776 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3777 //     }
3778   }
3779
3780   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3781   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3782     x=fhBeautyFDmax->GetBinLowEdge(j);
3783     fhBeautyFDmax->SetBinContent(j,0.03);
3784
3785 //     if(-0.4<x&&x<-0.2){
3786 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3787 //     }
3788 //     else if(-0.2<x&&x<-0.1){
3789 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3790 //     }
3791 //     else if(-0.2<x&&x<-0.1){
3792 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3793 //     }
3794 //     else if(-0.1<x&&x<0.1){
3795 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3796 //     }
3797 //     else if(0.1<x&&x<0.2){
3798 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3799 //     }
3800 //     if(0.2<x&&x<0.4){
3801 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3802 //     }
3803
3804   }
3805
3806
3807 }
3808
3809
3810
3811 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){
3812   Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3813   fmeson=2;
3814   fstrmeson="Dplus";
3815   fstrptAss="ptAsMore05";
3816   fstrptD="Dpt3to5";
3817   if(!fhDeltaPhiTemplate){
3818     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3819   }
3820   Double_t x;
3821   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3822   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3823   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3824     fhYieldExtraction->SetBinContent(j,0.1);
3825   }
3826
3827   // Background D MESON candidate subtraction (side-band variations, etc.)
3828   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3829   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3830     fhBackSubtractionMin->SetBinContent(j,-0.05);
3831   }
3832
3833   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3834   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3835     fhBackSubtractionMax->SetBinContent(j,0.05);
3836   }
3837
3838
3839   // MC CORRECTIONS ( associatate track efficiency):
3840   //  -5%  +10% for assoc track eff
3841   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3842   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3843     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3844   }
3845
3846   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3847   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3848     fhMCcorrectionsMax->SetBinContent(j,0.10);
3849   }
3850
3851   // MC D EFF CORRECTION
3852   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3853   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3854     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3855   }
3856
3857   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3858   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3859     fhMCDefficiencyMax->SetBinContent(j,0.05);
3860   }
3861
3862
3863   // Contamination from secondary tracks
3864   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3865   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3866     fhSecContaminationMin->SetBinContent(j,-0.05);
3867   }
3868
3869   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3870   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3871     fhSecContaminationMax->SetBinContent(j,0.05);
3872   }
3873
3874
3875   // MC CLOSURETEST (D meson efficiency)
3876   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3877   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3878     x=fhMCclosureTestMin->GetBinLowEdge(j);
3879     fhMCclosureTestMin->SetBinContent(j,-0.0);
3880
3881     if(-0.4<x&&x<-0.2){
3882       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3883     }
3884     else if(-0.2<x&&x<-0.1){
3885       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3886     }
3887     else if(-0.1<x&&x<0.1){
3888       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3889     }
3890     else if(0.1<x&&x<0.2){
3891       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3892     }
3893     if(0.2<x&&x<0.4){
3894       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3895     }
3896   }
3897
3898   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3899   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3900     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
3901     fhMCclosureTestMax->SetBinContent(j,0.);
3902
3903     //     if(-0.4<x&&x<-0.2){
3904     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3905     //     }
3906     //     else if(-0.2<x&&x<-0.1){
3907     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3908     //     }
3909     //     else if(-0.2<x&&x<-0.1){
3910     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3911     //     }
3912     //     else if(-0.1<x&&x<0.1){
3913     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3914     //     }
3915     //     else if(0.1<x&&x<0.2){
3916     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3917     //     }
3918     //     if(0.2<x&&x<0.4){
3919     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3920     //     }
3921
3922   }
3923
3924   // Feed-down
3925
3926   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3927   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3928     x=fhBeautyFDmin->GetBinLowEdge(j);
3929     fhBeautyFDmin->SetBinContent(j,-0.05);
3930
3931   //   if(-0.4<x&&x<-0.2){
3932 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3933 //     }
3934 //     else if(-0.2<x&&x<-0.1){
3935 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3936 //     }
3937 //     else if(-0.2<x&&x<-0.1){
3938 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3939 //     }
3940 //     else if(-0.1<x&&x<0.1){
3941 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3942 //     }
3943 //     else if(0.1<x&&x<0.2){
3944 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3945 //     }
3946 //     if(0.2<x&&x<0.4){
3947 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3948 //     }
3949   }
3950
3951   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3952   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3953     x=fhBeautyFDmax->GetBinLowEdge(j);
3954     fhBeautyFDmax->SetBinContent(j,0.03);
3955
3956 //     if(-0.4<x&&x<-0.2){
3957 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3958 //     }
3959 //     else if(-0.2<x&&x<-0.1){
3960 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3961 //     }
3962 //     else if(-0.2<x&&x<-0.1){
3963 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3964 //     }
3965 //     else if(-0.1<x&&x<0.1){
3966 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3967 //     }
3968 //     else if(0.1<x&&x<0.2){
3969 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3970 //     }
3971 //     if(0.2<x&&x<0.4){
3972 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3973 //     }
3974
3975   }
3976
3977 }
3978
3979 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
3980   Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3981   fmeson=2;
3982   fstrmeson="Dplus";
3983   fstrptAss="ptAsMore05";
3984   fstrptD="Dpt5to8";
3985   if(!fhDeltaPhiTemplate){
3986     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3987   }
3988   Double_t x;
3989   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3990   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3991   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3992     fhYieldExtraction->SetBinContent(j,0.1);
3993   }
3994
3995   // Background D MESON candidate subtraction (side-band variations, etc.)
3996   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3997   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3998     fhBackSubtractionMin->SetBinContent(j,-0.05);
3999   }
4000
4001   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4002   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4003     fhBackSubtractionMax->SetBinContent(j,0.05);
4004   }
4005
4006   // MC CORRECTIONS:  -5%  +10% for assoc track eff
4007   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4008   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4009     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4010   }
4011
4012   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4013   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4014     fhMCcorrectionsMax->SetBinContent(j,0.10);
4015   }
4016
4017
4018   // MC D EFF CORRECTION
4019   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4020   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4021     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4022   }
4023
4024   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4025   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4026     fhMCDefficiencyMax->SetBinContent(j,0.05);
4027   }
4028
4029
4030   // Contamination from secondary tracks
4031   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4032   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4033     fhSecContaminationMin->SetBinContent(j,-0.05);
4034   }
4035
4036   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4037   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4038     fhSecContaminationMax->SetBinContent(j,0.05);
4039   }
4040
4041   // MC CLOSURETEST (D meson efficiency)
4042   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4043   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4044     x=fhMCclosureTestMin->GetBinLowEdge(j);
4045     fhMCclosureTestMin->SetBinContent(j,-0.0);
4046
4047     if(-0.4<x&&x<-0.2){
4048       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4049     }
4050     else if(-0.2<x&&x<-0.1){
4051       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4052     }
4053     else if(-0.1<x&&x<0.1){
4054       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4055     }
4056     else if(0.1<x&&x<0.2){
4057       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4058     }
4059     if(0.2<x&&x<0.4){
4060       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4061     }
4062   }
4063
4064   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4065   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4066     x=fhMCclosureTestMax->GetBinLowEdge(j);
4067     fhMCclosureTestMax->SetBinContent(j,0.);
4068
4069     //     if(-0.4<x&&x<-0.2){
4070     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4071     //     }
4072     //     else if(-0.2<x&&x<-0.1){
4073     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4074     //     }
4075     //     else if(-0.2<x&&x<-0.1){
4076     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4077     //     }
4078     //     else if(-0.1<x&&x<0.1){
4079     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4080     //     }
4081     //     else if(0.1<x&&x<0.2){
4082     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4083     //     }
4084     //     if(0.2<x&&x<0.4){
4085     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4086     //     }
4087
4088   }
4089
4090   // Feed-down
4091
4092   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4093   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4094     x=fhBeautyFDmin->GetBinLowEdge(j);
4095     fhBeautyFDmin->SetBinContent(j,-0.05);
4096
4097   //   if(-0.4<x&&x<-0.2){
4098 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4099 //     }
4100 //     else if(-0.2<x&&x<-0.1){
4101 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4102 //     }
4103 //     else if(-0.2<x&&x<-0.1){
4104 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4105 //     }
4106 //     else if(-0.1<x&&x<0.1){
4107 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4108 //     }
4109 //     else if(0.1<x&&x<0.2){
4110 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4111 //     }
4112 //     if(0.2<x&&x<0.4){
4113 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4114 //     }
4115   }
4116
4117   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4118   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4119     x=fhBeautyFDmax->GetBinLowEdge(j);
4120     fhBeautyFDmax->SetBinContent(j,0.03);
4121
4122 //     if(-0.4<x&&x<-0.2){
4123 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4124 //     }
4125 //     else if(-0.2<x&&x<-0.1){
4126 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4127 //     }
4128 //     else if(-0.2<x&&x<-0.1){
4129 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4130 //     }
4131 //     else if(-0.1<x&&x<0.1){
4132 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4133 //     }
4134 //     else if(0.1<x&&x<0.2){
4135 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4136 //     }
4137 //     if(0.2<x&&x<0.4){
4138 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4139 //     }
4140
4141   }
4142
4143 }
4144
4145
4146 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
4147   Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
4148   fmeson=2;
4149   fstrmeson="Dplus";
4150   fstrptAss="ptAsMore05";
4151   fstrptD="Dpt8to16";
4152   if(!fhDeltaPhiTemplate){
4153     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4154   }
4155
4156   Double_t x;
4157   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4158   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4159   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4160     fhYieldExtraction->SetBinContent(j,0.1);
4161   }
4162
4163   // Background D MESON candidate subtraction (side-band variations, etc.)
4164   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4165   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4166     fhBackSubtractionMin->SetBinContent(j,-0.05);
4167   }
4168
4169   // Background D MESON candidate subtraction (side-band variations, etc.)
4170   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4171   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4172     fhBackSubtractionMax->SetBinContent(j,0.05);
4173   }
4174
4175   // MC CORRECTIONS,  -5% 10% for assoc track eff
4176   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4177   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4178     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4179   }
4180
4181   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4182   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4183     fhMCcorrectionsMax->SetBinContent(j,0.10);
4184   }
4185
4186
4187   // MC D EFF CORRECTION
4188   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4189   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4190     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4191   }
4192
4193   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4194   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4195     fhMCDefficiencyMax->SetBinContent(j,0.05);
4196   }
4197
4198
4199   // Contamination from secondary tracks
4200   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4201   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4202     fhSecContaminationMin->SetBinContent(j,-0.05);
4203   }
4204
4205   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4206   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4207     fhSecContaminationMax->SetBinContent(j,0.05);
4208   }
4209
4210   // MC CLOSURETEST (D meson efficiency)
4211   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4212   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4213     x=fhMCclosureTestMin->GetBinLowEdge(j);
4214     fhMCclosureTestMin->SetBinContent(j,-0.0);
4215
4216     if(-0.4<x&&x<-0.2){
4217       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4218     }
4219     else if(-0.2<x&&x<-0.1){
4220       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4221     }
4222     else if(-0.1<x&&x<0.1){
4223       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4224     }
4225     else if(0.1<x&&x<0.2){
4226       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4227     }
4228     if(0.2<x&&x<0.4){
4229       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4230     }
4231   }
4232
4233   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4234   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4235     x=fhMCclosureTestMax->GetBinLowEdge(j);
4236     fhMCclosureTestMax->SetBinContent(j,0.);
4237
4238     //     if(-0.4<x&&x<-0.2){
4239     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4240     //     }
4241     //     else if(-0.2<x&&x<-0.1){
4242     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4243     //     }
4244     //     else if(-0.2<x&&x<-0.1){
4245     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4246     //     }
4247     //     else if(-0.1<x&&x<0.1){
4248     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4249     //     }
4250     //     else if(0.1<x&&x<0.2){
4251     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4252     //     }
4253     //     if(0.2<x&&x<0.4){
4254     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4255     //     }
4256
4257   }
4258
4259   // Feed-down
4260
4261   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4262   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4263     x=fhBeautyFDmin->GetBinLowEdge(j);
4264     fhBeautyFDmin->SetBinContent(j,-0.05);
4265
4266   //   if(-0.4<x&&x<-0.2){
4267 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4268 //     }
4269 //     else if(-0.2<x&&x<-0.1){
4270 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4271 //     }
4272 //     else if(-0.2<x&&x<-0.1){
4273 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4274 //     }
4275 //     else if(-0.1<x&&x<0.1){
4276 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4277 //     }
4278 //     else if(0.1<x&&x<0.2){
4279 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4280 //     }
4281 //     if(0.2<x&&x<0.4){
4282 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4283 //     }
4284   }
4285
4286   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4287   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4288     x=fhBeautyFDmax->GetBinLowEdge(j);
4289     fhBeautyFDmax->SetBinContent(j,0.03);
4290
4291 //     if(-0.4<x&&x<-0.2){
4292 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4293 //     }
4294 //     else if(-0.2<x&&x<-0.1){
4295 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4296 //     }
4297 //     else if(-0.2<x&&x<-0.1){
4298 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4299 //     }
4300 //     else if(-0.1<x&&x<0.1){
4301 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4302 //     }
4303 //     else if(0.1<x&&x<0.2){
4304 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4305 //     }
4306 //     if(0.2<x&&x<0.4){
4307 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4308 //     }
4309
4310   }
4311
4312 }
4313
4314
4315
4316 // pt(assoc)> 1 GeV/c
4317 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){
4318   Printf("Setting uncertainties for Dzero pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
4319   fmeson=0;
4320   fstrmeson="Dzero";
4321   fstrptAss="ptAsMore1";
4322   fstrptD="Dpt3to5";
4323   if(!fhDeltaPhiTemplate){
4324     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4325   }
4326   Double_t x;
4327   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4328   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4329   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4330     fhYieldExtraction->SetBinContent(j,0.1);
4331   }
4332
4333   // Background D MESON candidate subtraction (side-band variations, etc.)
4334   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4335   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4336     fhBackSubtractionMin->SetBinContent(j,-0.05);
4337   }
4338
4339   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4340   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4341     fhBackSubtractionMax->SetBinContent(j,0.05);
4342   }
4343
4344
4345   // MC CORRECTIONS ( associatate track efficiency):
4346   //  -5%  +10% for assoc track eff
4347   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4348   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4349     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4350   }
4351
4352   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4353   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4354     fhMCcorrectionsMax->SetBinContent(j,0.10);
4355   }
4356
4357   // MC D EFF CORRECTION
4358   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4359   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4360     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4361   }
4362
4363   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4364   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4365     fhMCDefficiencyMax->SetBinContent(j,0.05);
4366   }
4367
4368
4369   // Contamination from secondary tracks
4370   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4371   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4372     fhSecContaminationMin->SetBinContent(j,-0.05);
4373   }
4374
4375   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4376   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4377     fhSecContaminationMax->SetBinContent(j,0.05);
4378   }
4379
4380
4381   // MC CLOSURETEST (D meson efficiency)
4382   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4383   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4384     x=fhMCclosureTestMin->GetBinLowEdge(j);
4385     fhMCclosureTestMin->SetBinContent(j,-0.);
4386
4387     if(-0.4<x&&x<-0.2){
4388       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4389     }
4390     else if(-0.2<x&&x<-0.1){
4391       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4392     }
4393     else if(-0.1<x&&x<0.1){
4394       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4395     }
4396     else if(0.1<x&&x<0.2){
4397       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4398     }
4399     if(0.2<x&&x<0.4){
4400       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4401     }
4402   }
4403
4404   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4405   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4406     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
4407     fhMCclosureTestMax->SetBinContent(j,0.);
4408
4409     //     if(-0.4<x&&x<-0.2){
4410     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4411     //     }
4412     //     else if(-0.2<x&&x<-0.1){
4413     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4414     //     }
4415     //     else if(-0.2<x&&x<-0.1){
4416     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4417     //     }
4418     //     else if(-0.1<x&&x<0.1){
4419     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4420     //     }
4421     //     else if(0.1<x&&x<0.2){
4422     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4423     //     }
4424     //     if(0.2<x&&x<0.4){
4425     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4426     //     }
4427
4428   }
4429
4430   // Feed-down
4431
4432   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4433   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4434     x=fhBeautyFDmin->GetBinLowEdge(j);
4435     fhBeautyFDmin->SetBinContent(j,-0.05);
4436
4437   //   if(-0.4<x&&x<-0.2){
4438 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4439 //     }
4440 //     else if(-0.2<x&&x<-0.1){
4441 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4442 //     }
4443 //     else if(-0.2<x&&x<-0.1){
4444 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4445 //     }
4446 //     else if(-0.1<x&&x<0.1){
4447 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4448 //     }
4449 //     else if(0.1<x&&x<0.2){
4450 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4451 //     }
4452 //     if(0.2<x&&x<0.4){
4453 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4454 //     }
4455   }
4456
4457   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4458   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4459     x=fhBeautyFDmax->GetBinLowEdge(j);
4460     fhBeautyFDmax->SetBinContent(j,0.03);
4461
4462 //     if(-0.4<x&&x<-0.2){
4463 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4464 //     }
4465 //     else if(-0.2<x&&x<-0.1){
4466 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4467 //     }
4468 //     else if(-0.2<x&&x<-0.1){
4469 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4470 //     }
4471 //     else if(-0.1<x&&x<0.1){
4472 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4473 //     }
4474 //     else if(0.1<x&&x<0.2){
4475 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4476 //     }
4477 //     if(0.2<x&&x<0.4){
4478 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4479 //     }
4480
4481   }
4482
4483 }
4484
4485 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){
4486   Printf("Setting uncertainties for Dzero pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
4487   fmeson=0;
4488   fstrmeson="Dzero";
4489   fstrptAss="ptAsMore1";
4490   fstrptD="Dpt5to8";
4491   if(!fhDeltaPhiTemplate){
4492     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4493   }
4494   Double_t x;
4495   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4496   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4497   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4498     fhYieldExtraction->SetBinContent(j,0.1);
4499   }
4500
4501   // Background D MESON candidate subtraction (side-band variations, etc.)
4502   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4503   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4504     fhBackSubtractionMin->SetBinContent(j,-0.05);
4505   }
4506
4507   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4508   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4509     fhBackSubtractionMax->SetBinContent(j,0.05);
4510   }
4511
4512   // MC CORRECTIONS:  -5%  +10% for assoc track eff
4513   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4514   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4515     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4516   }
4517
4518   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4519   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4520     fhMCcorrectionsMax->SetBinContent(j,0.10);
4521   }
4522
4523
4524   // MC D EFF CORRECTION
4525   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4526   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4527     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4528   }
4529
4530   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4531   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4532     fhMCDefficiencyMax->SetBinContent(j,0.05);
4533   }
4534
4535
4536   // Contamination from secondary tracks
4537   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4538   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4539     fhSecContaminationMin->SetBinContent(j,-0.05);
4540   }
4541
4542   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4543   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4544     fhSecContaminationMax->SetBinContent(j,0.05);
4545   }
4546
4547   // MC CLOSURETEST (D meson efficiency)
4548   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4549   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4550     x=fhMCclosureTestMin->GetBinLowEdge(j);
4551     fhMCclosureTestMin->SetBinContent(j,-0.);
4552
4553     if(-0.4<x&&x<-0.2){
4554       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4555     }
4556     else if(-0.2<x&&x<-0.1){
4557       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4558     }
4559     else if(-0.1<x&&x<0.1){
4560       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4561     }
4562     else if(0.1<x&&x<0.2){
4563       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4564     }
4565     if(0.2<x&&x<0.4){
4566       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4567     }
4568   }
4569
4570   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4571   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4572     x=fhMCclosureTestMax->GetBinLowEdge(j);
4573     fhMCclosureTestMax->SetBinContent(j,0.);
4574
4575     //     if(-0.4<x&&x<-0.2){
4576     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4577     //     }
4578     //     else if(-0.2<x&&x<-0.1){
4579     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4580     //     }
4581     //     else if(-0.2<x&&x<-0.1){
4582     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4583     //     }
4584     //     else if(-0.1<x&&x<0.1){
4585     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4586     //     }
4587     //     else if(0.1<x&&x<0.2){
4588     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4589     //     }
4590     //     if(0.2<x&&x<0.4){
4591     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4592     //     }
4593
4594   }
4595
4596   // Feed-down
4597
4598   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4599   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4600     x=fhBeautyFDmin->GetBinLowEdge(j);
4601     fhBeautyFDmin->SetBinContent(j,-0.05);
4602
4603   //   if(-0.4<x&&x<-0.2){
4604 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4605 //     }
4606 //     else if(-0.2<x&&x<-0.1){
4607 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4608 //     }
4609 //     else if(-0.2<x&&x<-0.1){
4610 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4611 //     }
4612 //     else if(-0.1<x&&x<0.1){
4613 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4614 //     }
4615 //     else if(0.1<x&&x<0.2){
4616 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4617 //     }
4618 //     if(0.2<x&&x<0.4){
4619 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4620 //     }
4621   }
4622
4623   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4624   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4625     x=fhBeautyFDmax->GetBinLowEdge(j);
4626     fhBeautyFDmax->SetBinContent(j,0.03);
4627
4628 //     if(-0.4<x&&x<-0.2){
4629 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4630 //     }
4631 //     else if(-0.2<x&&x<-0.1){
4632 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4633 //     }
4634 //     else if(-0.2<x&&x<-0.1){
4635 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4636 //     }
4637 //     else if(-0.1<x&&x<0.1){
4638 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4639 //     }
4640 //     else if(0.1<x&&x<0.2){
4641 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4642 //     }
4643 //     if(0.2<x&&x<0.4){
4644 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4645 //     }
4646
4647   }
4648
4649 }
4650
4651
4652 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
4653   Printf("Setting uncertainties for Dzero pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
4654   fmeson=0;
4655   fstrmeson="Dzero";
4656   fstrptAss="ptAsMore1";
4657   fstrptD="Dpt8to16";
4658   if(!fhDeltaPhiTemplate){
4659     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4660   }
4661
4662   Double_t x;
4663   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4664   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4665   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4666     fhYieldExtraction->SetBinContent(j,0.1);
4667   }
4668
4669   // Background D MESON candidate subtraction (side-band variations, etc.)
4670   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4671   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4672     fhBackSubtractionMin->SetBinContent(j,-0.05);
4673   }
4674
4675   // Background D MESON candidate subtraction (side-band variations, etc.)
4676   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4677   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4678     fhBackSubtractionMax->SetBinContent(j,0.05);
4679   }
4680
4681   // MC CORRECTIONS,  -5% 10% for assoc track eff
4682   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4683   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4684     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4685   }
4686
4687   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4688   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4689     fhMCcorrectionsMax->SetBinContent(j,0.10);
4690   }
4691
4692
4693   // MC D EFF CORRECTION
4694   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4695   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4696     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4697   }
4698
4699   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4700   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4701     fhMCDefficiencyMax->SetBinContent(j,0.05);
4702   }
4703
4704
4705   // Contamination from secondary tracks
4706   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4707   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4708     fhSecContaminationMin->SetBinContent(j,-0.05);
4709   }
4710
4711   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4712   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4713     fhSecContaminationMax->SetBinContent(j,0.05);
4714   }
4715
4716   // MC CLOSURETEST (D meson efficiency)
4717   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4718   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4719     x=fhMCclosureTestMin->GetBinLowEdge(j);
4720     fhMCclosureTestMin->SetBinContent(j,-0.);
4721
4722     if(-0.4<x&&x<-0.2){
4723       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4724     }
4725     else if(-0.2<x&&x<-0.1){
4726       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4727     }
4728     else if(-0.1<x&&x<0.1){
4729       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4730     }
4731     else if(0.1<x&&x<0.2){
4732       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4733     }
4734     if(0.2<x&&x<0.4){
4735       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4736     }
4737   }
4738
4739   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4740   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4741     x=fhMCclosureTestMax->GetBinLowEdge(j);
4742     fhMCclosureTestMax->SetBinContent(j,0.);
4743
4744     //     if(-0.4<x&&x<-0.2){
4745     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4746     //     }
4747     //     else if(-0.2<x&&x<-0.1){
4748     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4749     //     }
4750     //     else if(-0.2<x&&x<-0.1){
4751     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4752     //     }
4753     //     else if(-0.1<x&&x<0.1){
4754     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4755     //     }
4756     //     else if(0.1<x&&x<0.2){
4757     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4758     //     }
4759     //     if(0.2<x&&x<0.4){
4760     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4761     //     }
4762
4763   }
4764
4765   // Feed-down
4766
4767   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4768   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4769     x=fhBeautyFDmin->GetBinLowEdge(j);
4770     fhBeautyFDmin->SetBinContent(j,-0.05);
4771
4772   //   if(-0.4<x&&x<-0.2){
4773 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4774 //     }
4775 //     else if(-0.2<x&&x<-0.1){
4776 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4777 //     }
4778 //     else if(-0.2<x&&x<-0.1){
4779 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4780 //     }
4781 //     else if(-0.1<x&&x<0.1){
4782 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4783 //     }
4784 //     else if(0.1<x&&x<0.2){
4785 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4786 //     }
4787 //     if(0.2<x&&x<0.4){
4788 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4789 //     }
4790   }
4791
4792   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4793   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4794     x=fhBeautyFDmax->GetBinLowEdge(j);
4795     fhBeautyFDmax->SetBinContent(j,0.03);
4796
4797 //     if(-0.4<x&&x<-0.2){
4798 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4799 //     }
4800 //     else if(-0.2<x&&x<-0.1){
4801 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4802 //     }
4803 //     else if(-0.2<x&&x<-0.1){
4804 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4805 //     }
4806 //     else if(-0.1<x&&x<0.1){
4807 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4808 //     }
4809 //     else if(0.1<x&&x<0.2){
4810 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4811 //     }
4812 //     if(0.2<x&&x<0.4){
4813 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4814 //     }
4815
4816   }
4817
4818 }
4819
4820
4821
4822
4823 //--------------------------------------------------
4824 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
4825   Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
4826   fmeson=1;
4827   fstrmeson="Dstar";
4828   fstrptAss="ptAsMore1";
4829   fstrptD="Dpt3to5";
4830   if(!fhDeltaPhiTemplate){
4831     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4832   }
4833   Double_t x;
4834   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4835   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4836   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4837     fhYieldExtraction->SetBinContent(j,0.1);
4838   }
4839
4840   // Background D MESON candidate subtraction (side-band variations, etc.)
4841   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4842   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4843     fhBackSubtractionMin->SetBinContent(j,-0.05);
4844   }
4845
4846   // Background D MESON candidate subtraction (side-band variations, etc.)
4847   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4848   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4849     fhBackSubtractionMax->SetBinContent(j,0.05);
4850   }
4851
4852   // MC CORRECTIONS, -5%  10% for assoc track eff
4853   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4854   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4855     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4856   }
4857
4858   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4859   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4860     fhMCcorrectionsMax->SetBinContent(j,0.10);
4861   }
4862
4863
4864   // MC D EFF CORRECTION
4865   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4866   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4867     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4868   }
4869
4870   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4871   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4872     fhMCDefficiencyMax->SetBinContent(j,0.05);
4873   }
4874
4875
4876   // Contamination from secondary tracks
4877   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4878   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4879     fhSecContaminationMin->SetBinContent(j,-0.05);
4880   }
4881
4882   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4883   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4884     fhSecContaminationMax->SetBinContent(j,0.05);
4885   }
4886
4887   // MC CLOSURETEST (D meson efficiency)
4888   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4889   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4890     x=fhMCclosureTestMin->GetBinLowEdge(j);
4891     fhMCclosureTestMin->SetBinContent(j,-0.08);
4892
4893     if(-0.4<x&&x<-0.2){
4894       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4895     }
4896     else if(-0.2<x&&x<-0.1){
4897       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4898     }
4899     else if(-0.1<x&&x<0.1){
4900       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4901     }
4902     else if(0.1<x&&x<0.2){
4903       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4904     }
4905     if(0.2<x&&x<0.4){
4906       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4907     }
4908   }
4909
4910   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4911   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4912     x=fhMCclosureTestMax->GetBinLowEdge(j);
4913     fhMCclosureTestMax->SetBinContent(j,0.);
4914
4915     //     if(-0.4<x&&x<-0.2){
4916     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4917     //     }
4918     //     else if(-0.2<x&&x<-0.1){
4919     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4920     //     }
4921     //     else if(-0.2<x&&x<-0.1){
4922     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4923     //     }
4924     //     else if(-0.1<x&&x<0.1){
4925     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4926     //     }
4927     //     else if(0.1<x&&x<0.2){
4928     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4929     //     }
4930     //     if(0.2<x&&x<0.4){
4931     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4932     //     }
4933
4934   }
4935
4936   // Feed-down
4937
4938   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4939   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4940     x=fhBeautyFDmin->GetBinLowEdge(j);
4941     fhBeautyFDmin->SetBinContent(j,-0.05);
4942
4943   //   if(-0.4<x&&x<-0.2){
4944 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4945 //     }
4946 //     else if(-0.2<x&&x<-0.1){
4947 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4948 //     }
4949 //     else if(-0.2<x&&x<-0.1){
4950 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4951 //     }
4952 //     else if(-0.1<x&&x<0.1){
4953 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4954 //     }
4955 //     else if(0.1<x&&x<0.2){
4956 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4957 //     }
4958 //     if(0.2<x&&x<0.4){
4959 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4960 //     }
4961   }
4962
4963   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4964   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4965     x=fhBeautyFDmax->GetBinLowEdge(j);
4966     fhBeautyFDmax->SetBinContent(j,0.03);
4967
4968 //     if(-0.4<x&&x<-0.2){
4969 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4970 //     }
4971 //     else if(-0.2<x&&x<-0.1){
4972 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4973 //     }
4974 //     else if(-0.2<x&&x<-0.1){
4975 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4976 //     }
4977 //     else if(-0.1<x&&x<0.1){
4978 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4979 //     }
4980 //     else if(0.1<x&&x<0.2){
4981 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4982 //     }
4983 //     if(0.2<x&&x<0.4){
4984 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4985 //     }
4986
4987   }
4988
4989
4990 }
4991
4992 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){
4993   Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
4994   fmeson=1;
4995   fstrmeson="Dstar";
4996   fstrptAss="ptAsMore1";
4997   fstrptD="Dpt5to8";
4998   if(!fhDeltaPhiTemplate){
4999     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5000   }
5001   Double_t x;
5002   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5003   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5004   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5005     fhYieldExtraction->SetBinContent(j,0.1);
5006   }
5007
5008   // Background D MESON candidate subtraction (side-band variations, etc.)
5009   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5010   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5011     fhBackSubtractionMin->SetBinContent(j,-0.05);
5012   }
5013
5014   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5015   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5016     fhBackSubtractionMax->SetBinContent(j,0.05);
5017   }
5018
5019   // MC CORRECTIONS/ -5%  10% for assoc track eff
5020   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5021   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5022     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5023   }
5024
5025   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5026   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5027     fhMCcorrectionsMax->SetBinContent(j,0.10);
5028   }
5029
5030   // MC D EFF CORRECTION
5031   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5032   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5033     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5034   }
5035
5036   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5037   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5038     fhMCDefficiencyMax->SetBinContent(j,0.05);
5039   }
5040
5041
5042   // Contamination from secondary tracks
5043   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5044   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5045     fhSecContaminationMin->SetBinContent(j,-0.05);
5046   }
5047
5048   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5049   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5050     fhSecContaminationMax->SetBinContent(j,0.05);
5051   }
5052
5053   // MC CLOSURETEST (D meson efficiency)
5054   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5055   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5056     x=fhMCclosureTestMin->GetBinLowEdge(j);
5057     fhMCclosureTestMin->SetBinContent(j,-0.08);
5058
5059     if(-0.4<x&&x<-0.2){
5060       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5061     }
5062     else if(-0.2<x&&x<-0.1){
5063       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5064     }
5065     else if(-0.1<x&&x<0.1){
5066       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5067     }
5068     else if(0.1<x&&x<0.2){
5069       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5070     }
5071     if(0.2<x&&x<0.4){
5072       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5073     }
5074   }
5075
5076   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5077   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5078     x=fhMCclosureTestMax->GetBinLowEdge(j);
5079     fhMCclosureTestMax->SetBinContent(j,0.);
5080
5081     //     if(-0.4<x&&x<-0.2){
5082     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5083     //     }
5084     //     else if(-0.2<x&&x<-0.1){
5085     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5086     //     }
5087     //     else if(-0.2<x&&x<-0.1){
5088     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5089     //     }
5090     //     else if(-0.1<x&&x<0.1){
5091     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5092     //     }
5093     //     else if(0.1<x&&x<0.2){
5094     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5095     //     }
5096     //     if(0.2<x&&x<0.4){
5097     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5098     //     }
5099
5100   }
5101
5102   // Feed-down
5103
5104   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5105   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5106     x=fhBeautyFDmin->GetBinLowEdge(j);
5107     fhBeautyFDmin->SetBinContent(j,-0.05);
5108
5109   //   if(-0.4<x&&x<-0.2){
5110 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5111 //     }
5112 //     else if(-0.2<x&&x<-0.1){
5113 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5114 //     }
5115 //     else if(-0.2<x&&x<-0.1){
5116 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5117 //     }
5118 //     else if(-0.1<x&&x<0.1){
5119 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5120 //     }
5121 //     else if(0.1<x&&x<0.2){
5122 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5123 //     }
5124 //     if(0.2<x&&x<0.4){
5125 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5126 //     }
5127   }
5128
5129   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5130   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5131     x=fhBeautyFDmax->GetBinLowEdge(j);
5132     fhBeautyFDmax->SetBinContent(j,0.03);
5133
5134 //     if(-0.4<x&&x<-0.2){
5135 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5136 //     }
5137 //     else if(-0.2<x&&x<-0.1){
5138 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5139 //     }
5140 //     else if(-0.2<x&&x<-0.1){
5141 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5142 //     }
5143 //     else if(-0.1<x&&x<0.1){
5144 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5145 //     }
5146 //     else if(0.1<x&&x<0.2){
5147 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5148 //     }
5149 //     if(0.2<x&&x<0.4){
5150 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5151 //     }
5152
5153   }
5154
5155 }
5156
5157
5158
5159 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){
5160   Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5161   fmeson=1;
5162   fstrmeson="Dstar";
5163   fstrptAss="ptAsMore1";
5164   fstrptD="Dpt8to16";
5165   if(!fhDeltaPhiTemplate){
5166     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5167   }
5168   Double_t x;
5169   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5170   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5171   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5172     fhYieldExtraction->SetBinContent(j,0.1);
5173   }
5174
5175   // Background D MESON candidate subtraction (side-band variations, etc.)
5176   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5177   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5178     fhBackSubtractionMin->SetBinContent(j,-0.05);
5179   }
5180
5181   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5182   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5183
5184       fhBackSubtractionMax->SetBinContent(j,0.2);
5185   }
5186
5187   // MC CORRECTIONS   -5% +10% for assoc track eff
5188   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5189   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5190     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5191   }
5192
5193   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5194   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5195     fhMCcorrectionsMax->SetBinContent(j,0.10);
5196   }
5197   // MC D EFF CORRECTION
5198   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5199   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5200     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5201   }
5202
5203   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5204   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5205     fhMCDefficiencyMax->SetBinContent(j,0.05);
5206   }
5207
5208
5209   // Contamination from secondary tracks
5210   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5211   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5212     fhSecContaminationMin->SetBinContent(j,-0.05);
5213   }
5214
5215   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5216   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5217     fhSecContaminationMax->SetBinContent(j,0.05);
5218   }
5219
5220   // MC CLOSURETEST (D meson efficiency)
5221   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5222   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5223     x=fhMCclosureTestMin->GetBinLowEdge(j);
5224     fhMCclosureTestMin->SetBinContent(j,-0.08);
5225
5226     if(-0.4<x&&x<-0.2){
5227       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5228     }
5229     else if(-0.2<x&&x<-0.1){
5230       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5231     }
5232     else if(-0.1<x&&x<0.1){
5233       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5234     }
5235     else if(0.1<x&&x<0.2){
5236       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5237     }
5238     if(0.2<x&&x<0.4){
5239       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5240     }
5241   }
5242
5243   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5244   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5245     x=fhMCclosureTestMax->GetBinLowEdge(j);
5246     fhMCclosureTestMax->SetBinContent(j,0.);
5247
5248     //     if(-0.4<x&&x<-0.2){
5249     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5250     //     }
5251     //     else if(-0.2<x&&x<-0.1){
5252     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5253     //     }
5254     //     else if(-0.2<x&&x<-0.1){
5255     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5256     //     }
5257     //     else if(-0.1<x&&x<0.1){
5258     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5259     //     }
5260     //     else if(0.1<x&&x<0.2){
5261     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5262     //     }
5263     //     if(0.2<x&&x<0.4){
5264     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5265     //     }
5266
5267   }
5268
5269   // Feed-down
5270
5271   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5272   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5273     x=fhBeautyFDmin->GetBinLowEdge(j);
5274     fhBeautyFDmin->SetBinContent(j,-0.05);
5275
5276   //   if(-0.4<x&&x<-0.2){
5277 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5278 //     }
5279 //     else if(-0.2<x&&x<-0.1){
5280 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5281 //     }
5282 //     else if(-0.2<x&&x<-0.1){
5283 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5284 //     }
5285 //     else if(-0.1<x&&x<0.1){
5286 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5287 //     }
5288 //     else if(0.1<x&&x<0.2){
5289 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5290 //     }
5291 //     if(0.2<x&&x<0.4){
5292 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5293 //     }
5294   }
5295
5296   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5297   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5298     x=fhBeautyFDmax->GetBinLowEdge(j);
5299     fhBeautyFDmax->SetBinContent(j,0.03);
5300
5301 //     if(-0.4<x&&x<-0.2){
5302 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5303 //     }
5304 //     else if(-0.2<x&&x<-0.1){
5305 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5306 //     }
5307 //     else if(-0.2<x&&x<-0.1){
5308 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5309 //     }
5310 //     else if(-0.1<x&&x<0.1){
5311 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5312 //     }
5313 //     else if(0.1<x&&x<0.2){
5314 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5315 //     }
5316 //     if(0.2<x&&x<0.4){
5317 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5318 //     }
5319
5320   }
5321
5322
5323 }
5324
5325
5326
5327 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){
5328   Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
5329   fmeson=2;
5330   fstrmeson="Dplus";
5331   fstrptAss="ptAsMore1";
5332   fstrptD="Dpt3to5";
5333   if(!fhDeltaPhiTemplate){
5334     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5335   }
5336   Double_t x;
5337   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5338   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5339   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5340     fhYieldExtraction->SetBinContent(j,0.1);
5341   }
5342
5343   // Background D MESON candidate subtraction (side-band variations, etc.)
5344   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5345   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5346     fhBackSubtractionMin->SetBinContent(j,-0.05);
5347   }
5348
5349   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5350   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5351     fhBackSubtractionMax->SetBinContent(j,0.05);
5352   }
5353
5354
5355   // MC CORRECTIONS ( associatate track efficiency):
5356   //  -5%  +10% for assoc track eff
5357   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5358   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5359     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5360   }
5361
5362   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5363   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5364     fhMCcorrectionsMax->SetBinContent(j,0.10);
5365   }
5366
5367   // MC D EFF CORRECTION
5368   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5369   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5370     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5371   }
5372
5373   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5374   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5375     fhMCDefficiencyMax->SetBinContent(j,0.05);
5376   }
5377
5378
5379   // Contamination from secondary tracks
5380   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5381   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5382     fhSecContaminationMin->SetBinContent(j,-0.05);
5383   }
5384
5385   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5386   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5387     fhSecContaminationMax->SetBinContent(j,0.05);
5388   }
5389
5390
5391   // MC CLOSURETEST (D meson efficiency)
5392   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5393   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5394     x=fhMCclosureTestMin->GetBinLowEdge(j);
5395     fhMCclosureTestMin->SetBinContent(j,-0.0);
5396
5397     if(-0.4<x&&x<-0.2){
5398       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5399     }
5400     else if(-0.2<x&&x<-0.1){
5401       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5402     }
5403     else if(-0.1<x&&x<0.1){
5404       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5405     }
5406     else if(0.1<x&&x<0.2){
5407       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5408     }
5409     if(0.2<x&&x<0.4){
5410       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5411     }
5412   }
5413
5414   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5415   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5416     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
5417     fhMCclosureTestMax->SetBinContent(j,0.);
5418
5419     //     if(-0.4<x&&x<-0.2){
5420     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5421     //     }
5422     //     else if(-0.2<x&&x<-0.1){
5423     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5424     //     }
5425     //     else if(-0.2<x&&x<-0.1){
5426     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5427     //     }
5428     //     else if(-0.1<x&&x<0.1){
5429     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5430     //     }
5431     //     else if(0.1<x&&x<0.2){
5432     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5433     //     }
5434     //     if(0.2<x&&x<0.4){
5435     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5436     //     }
5437
5438   }
5439
5440   // Feed-down
5441
5442   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5443   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5444     x=fhBeautyFDmin->GetBinLowEdge(j);
5445     fhBeautyFDmin->SetBinContent(j,-0.05);
5446
5447   //   if(-0.4<x&&x<-0.2){
5448 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5449 //     }
5450 //     else if(-0.2<x&&x<-0.1){
5451 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5452 //     }
5453 //     else if(-0.2<x&&x<-0.1){
5454 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5455 //     }
5456 //     else if(-0.1<x&&x<0.1){
5457 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5458 //     }
5459 //     else if(0.1<x&&x<0.2){
5460 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5461 //     }
5462 //     if(0.2<x&&x<0.4){
5463 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5464 //     }
5465   }
5466
5467   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5468   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5469     x=fhBeautyFDmax->GetBinLowEdge(j);
5470     fhBeautyFDmax->SetBinContent(j,0.03);
5471
5472 //     if(-0.4<x&&x<-0.2){
5473 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5474 //     }
5475 //     else if(-0.2<x&&x<-0.1){
5476 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5477 //     }
5478 //     else if(-0.2<x&&x<-0.1){
5479 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5480 //     }
5481 //     else if(-0.1<x&&x<0.1){
5482 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5483 //     }
5484 //     else if(0.1<x&&x<0.2){
5485 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5486 //     }
5487 //     if(0.2<x&&x<0.4){
5488 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5489 //     }
5490
5491   }
5492
5493 }
5494
5495 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){
5496   Printf("Setting uncertainties for Dplus pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
5497   fmeson=2;
5498   fstrmeson="Dplus";
5499   fstrptAss="ptAsMore1";
5500   fstrptD="Dpt5to8";
5501   if(!fhDeltaPhiTemplate){
5502     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5503   }
5504   Double_t x;
5505   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5506   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5507   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5508     fhYieldExtraction->SetBinContent(j,0.1);
5509   }
5510
5511   // Background D MESON candidate subtraction (side-band variations, etc.)
5512   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5513   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5514     fhBackSubtractionMin->SetBinContent(j,-0.05);
5515   }
5516
5517   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5518   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5519     fhBackSubtractionMax->SetBinContent(j,0.05);
5520   }
5521
5522   // MC CORRECTIONS:  -5%  +10% for assoc track eff
5523   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5524   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5525     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5526   }
5527
5528   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5529   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5530     fhMCcorrectionsMax->SetBinContent(j,0.10);
5531   }
5532
5533
5534   // MC D EFF CORRECTION
5535   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5536   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5537     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5538   }
5539
5540   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5541   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5542     fhMCDefficiencyMax->SetBinContent(j,0.05);
5543   }
5544
5545
5546   // Contamination from secondary tracks
5547   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5548   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5549     fhSecContaminationMin->SetBinContent(j,-0.05);
5550   }
5551
5552   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5553   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5554     fhSecContaminationMax->SetBinContent(j,0.05);
5555   }
5556
5557   // MC CLOSURETEST (D meson efficiency)
5558   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5559   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5560     x=fhMCclosureTestMin->GetBinLowEdge(j);
5561     fhMCclosureTestMin->SetBinContent(j,-0.0);
5562
5563     if(-0.4<x&&x<-0.2){
5564       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5565     }
5566     else if(-0.2<x&&x<-0.1){
5567       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5568     }
5569     else if(-0.1<x&&x<0.1){
5570       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5571     }
5572     else if(0.1<x&&x<0.2){
5573       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5574     }
5575     if(0.2<x&&x<0.4){
5576       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5577     }
5578   }
5579
5580   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5581   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5582     x=fhMCclosureTestMax->GetBinLowEdge(j);
5583     fhMCclosureTestMax->SetBinContent(j,0.);
5584
5585     //     if(-0.4<x&&x<-0.2){
5586     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5587     //     }
5588     //     else if(-0.2<x&&x<-0.1){
5589     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5590     //     }
5591     //     else if(-0.2<x&&x<-0.1){
5592     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5593     //     }
5594     //     else if(-0.1<x&&x<0.1){
5595     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5596     //     }
5597     //     else if(0.1<x&&x<0.2){
5598     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5599     //     }
5600     //     if(0.2<x&&x<0.4){
5601     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5602     //     }
5603
5604   }
5605
5606   // Feed-down
5607
5608   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5609   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5610     x=fhBeautyFDmin->GetBinLowEdge(j);
5611     fhBeautyFDmin->SetBinContent(j,-0.05);
5612
5613   //   if(-0.4<x&&x<-0.2){
5614 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5615 //     }
5616 //     else if(-0.2<x&&x<-0.1){
5617 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5618 //     }
5619 //     else if(-0.2<x&&x<-0.1){
5620 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5621 //     }
5622 //     else if(-0.1<x&&x<0.1){
5623 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5624 //     }
5625 //     else if(0.1<x&&x<0.2){
5626 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5627 //     }
5628 //     if(0.2<x&&x<0.4){
5629 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5630 //     }
5631   }
5632
5633   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5634   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5635     x=fhBeautyFDmax->GetBinLowEdge(j);
5636     fhBeautyFDmax->SetBinContent(j,0.03);
5637
5638 //     if(-0.4<x&&x<-0.2){
5639 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5640 //     }
5641 //     else if(-0.2<x&&x<-0.1){
5642 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5643 //     }
5644 //     else if(-0.2<x&&x<-0.1){
5645 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5646 //     }
5647 //     else if(-0.1<x&&x<0.1){
5648 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5649 //     }
5650 //     else if(0.1<x&&x<0.2){
5651 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5652 //     }
5653 //     if(0.2<x&&x<0.4){
5654 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5655 //     }
5656
5657   }
5658
5659 }
5660
5661
5662 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
5663   Printf("Setting uncertainties for Dplus pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5664   fmeson=2;
5665   fstrmeson="Dplus";
5666   fstrptAss="ptAsMore1";
5667   fstrptD="Dpt8to16";
5668   if(!fhDeltaPhiTemplate){
5669     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5670   }
5671
5672   Double_t x;
5673   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5674   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5675   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5676     fhYieldExtraction->SetBinContent(j,0.1);
5677   }
5678
5679   // Background D MESON candidate subtraction (side-band variations, etc.)
5680   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5681   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5682     fhBackSubtractionMin->SetBinContent(j,-0.05);
5683   }
5684
5685   // Background D MESON candidate subtraction (side-band variations, etc.)
5686   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5687   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5688     fhBackSubtractionMax->SetBinContent(j,0.05);
5689   }
5690
5691   // MC CORRECTIONS,  -5% 10% for assoc track eff
5692   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5693   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5694     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5695   }
5696
5697   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5698   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5699     fhMCcorrectionsMax->SetBinContent(j,0.10);
5700   }
5701
5702
5703   // MC D EFF CORRECTION
5704   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5705   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5706     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5707   }
5708
5709   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5710   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5711     fhMCDefficiencyMax->SetBinContent(j,0.05);
5712   }
5713
5714
5715   // Contamination from secondary tracks
5716   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5717   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5718     fhSecContaminationMin->SetBinContent(j,-0.05);
5719   }
5720
5721   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5722   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5723     fhSecContaminationMax->SetBinContent(j,0.05);
5724   }
5725
5726   // MC CLOSURETEST (D meson efficiency)
5727   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5728   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5729     x=fhMCclosureTestMin->GetBinLowEdge(j);
5730     fhMCclosureTestMin->SetBinContent(j,-0.0);
5731
5732     if(-0.4<x&&x<-0.2){
5733       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5734     }
5735     else if(-0.2<x&&x<-0.1){
5736       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5737     }
5738     else if(-0.1<x&&x<0.1){
5739       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5740     }
5741     else if(0.1<x&&x<0.2){
5742       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5743     }
5744     if(0.2<x&&x<0.4){
5745       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5746     }
5747   }
5748
5749   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5750   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5751     x=fhMCclosureTestMax->GetBinLowEdge(j);
5752     fhMCclosureTestMax->SetBinContent(j,0.);
5753
5754     //     if(-0.4<x&&x<-0.2){
5755     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5756     //     }
5757     //     else if(-0.2<x&&x<-0.1){
5758     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5759     //     }
5760     //     else if(-0.2<x&&x<-0.1){
5761     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5762     //     }
5763     //     else if(-0.1<x&&x<0.1){
5764     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5765     //     }
5766     //     else if(0.1<x&&x<0.2){
5767     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5768     //     }
5769     //     if(0.2<x&&x<0.4){
5770     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5771     //     }
5772
5773   }
5774
5775   // Feed-down
5776
5777   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5778   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5779     x=fhBeautyFDmin->GetBinLowEdge(j);
5780     fhBeautyFDmin->SetBinContent(j,-0.05);
5781
5782   //   if(-0.4<x&&x<-0.2){
5783 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5784 //     }
5785 //     else if(-0.2<x&&x<-0.1){
5786 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5787 //     }
5788 //     else if(-0.2<x&&x<-0.1){
5789 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5790 //     }
5791 //     else if(-0.1<x&&x<0.1){
5792 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5793 //     }
5794 //     else if(0.1<x&&x<0.2){
5795 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5796 //     }
5797 //     if(0.2<x&&x<0.4){
5798 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5799 //     }
5800   }
5801
5802   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5803   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5804     x=fhBeautyFDmax->GetBinLowEdge(j);
5805     fhBeautyFDmax->SetBinContent(j,0.03);
5806
5807 //     if(-0.4<x&&x<-0.2){
5808 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5809 //     }
5810 //     else if(-0.2<x&&x<-0.1){
5811 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5812 //     }
5813 //     else if(-0.2<x&&x<-0.1){
5814 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5815 //     }
5816 //     else if(-0.1<x&&x<0.1){
5817 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5818 //     }
5819 //     else if(0.1<x&&x<0.2){
5820 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5821 //     }
5822 //     if(0.2<x&&x<0.4){
5823 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5824 //     }
5825
5826   }
5827
5828 }
5829
5830
5831
5832
5833
5834
5835 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5836 /////
5837 ///// METHODS WITH UNCERTAINTIES: pPb 2013
5838 /////
5839 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5840
5841
5842 // pt assoc > 0.3 GeV/c
5843
5844 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
5845   Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
5846   fmeson=0;
5847   fstrmeson="Dzero";
5848   fstrptAss="ptAsMore03";
5849   fstrptD="Dpt3to5";
5850   if(!fhDeltaPhiTemplate){
5851     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5852   }
5853   Double_t x;
5854   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5855   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5856   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5857     fhYieldExtraction->SetBinContent(j,0.1);
5858   }
5859
5860   // Background D MESON candidate subtraction (side-band variations, etc.)
5861   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5862   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5863     fhBackSubtractionMin->SetBinContent(j,-0.05);
5864   }
5865
5866   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5867   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5868     fhBackSubtractionMax->SetBinContent(j,0.05);
5869   }
5870
5871
5872   // MC CORRECTIONS ( associatate track efficiency):
5873   //  -5%  +10% for assoc track eff
5874   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5875   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5876     fhMCcorrectionsMin->SetBinContent(j,-0.04);
5877   }
5878
5879   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5880   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5881     fhMCcorrectionsMax->SetBinContent(j,0.04);
5882   }
5883
5884   // MC D EFF CORRECTION
5885   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5886   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5887     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5888   }
5889
5890   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5891   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5892     fhMCDefficiencyMax->SetBinContent(j,0.05);
5893   }
5894
5895
5896   // Contamination from secondary tracks
5897   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5898   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5899     fhSecContaminationMin->SetBinContent(j,-0.035);
5900   }
5901
5902   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5903   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5904     fhSecContaminationMax->SetBinContent(j,0.035);
5905   }
5906
5907
5908   // MC CLOSURETEST (D meson efficiency)
5909   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5910   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5911     x=fhMCclosureTestMin->GetBinLowEdge(j);
5912     fhMCclosureTestMin->SetBinContent(j,-0.);
5913
5914     if(-0.4<x&&x<-0.2){
5915       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5916     }
5917     else if(-0.2<x&&x<-0.1){
5918       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5919     }
5920     else if(-0.1<x&&x<0.1){
5921       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5922     }
5923     else if(0.1<x&&x<0.2){
5924       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5925     }
5926     if(0.2<x&&x<0.4){
5927       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5928     }
5929   }
5930
5931   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5932   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5933     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
5934     fhMCclosureTestMax->SetBinContent(j,0.08);
5935
5936     //     if(-0.4<x&&x<-0.2){
5937     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5938     //     }
5939     //     else if(-0.2<x&&x<-0.1){
5940     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5941     //     }
5942     //     else if(-0.2<x&&x<-0.1){
5943     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5944     //     }
5945     //     else if(-0.1<x&&x<0.1){
5946     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5947     //     }
5948     //     else if(0.1<x&&x<0.2){
5949     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5950     //     }
5951     //     if(0.2<x&&x<0.4){
5952     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5953     //     }
5954
5955   }
5956
5957   // Feed-down
5958
5959   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5960   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5961     x=fhBeautyFDmin->GetBinLowEdge(j);
5962     fhBeautyFDmin->SetBinContent(j,-0.05);
5963
5964   //   if(-0.4<x&&x<-0.2){
5965 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5966 //     }
5967 //     else if(-0.2<x&&x<-0.1){
5968 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5969 //     }
5970 //     else if(-0.2<x&&x<-0.1){
5971 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5972 //     }
5973 //     else if(-0.1<x&&x<0.1){
5974 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5975 //     }
5976 //     else if(0.1<x&&x<0.2){
5977 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5978 //     }
5979 //     if(0.2<x&&x<0.4){
5980 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5981 //     }
5982   }
5983
5984   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5985   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5986     x=fhBeautyFDmax->GetBinLowEdge(j);
5987     fhBeautyFDmax->SetBinContent(j,0.03);
5988
5989 //     if(-0.4<x&&x<-0.2){
5990 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5991 //     }
5992 //     else if(-0.2<x&&x<-0.1){
5993 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5994 //     }
5995 //     else if(-0.2<x&&x<-0.1){
5996 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5997 //     }
5998 //     else if(-0.1<x&&x<0.1){
5999 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6000 //     }
6001 //     else if(0.1<x&&x<0.2){
6002 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6003 //     }
6004 //     if(0.2<x&&x<0.4){
6005 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6006 //     }
6007
6008   }
6009
6010 }
6011
6012 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
6013   Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
6014   fmeson=0;
6015   fstrmeson="Dzero";
6016   fstrptAss="ptAsMore03";
6017   fstrptD="Dpt5to8";
6018   if(!fhDeltaPhiTemplate){
6019     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6020   }
6021   Double_t x;
6022   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6023   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6024   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6025     fhYieldExtraction->SetBinContent(j,0.1);
6026   }
6027
6028   // Background D MESON candidate subtraction (side-band variations, etc.)
6029   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6030   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6031     fhBackSubtractionMin->SetBinContent(j,-0.05);
6032   }
6033
6034   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6035   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6036     fhBackSubtractionMax->SetBinContent(j,0.05);
6037   }
6038
6039   // MC CORRECTIONS:  -5%  +10% for assoc track eff
6040   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6041   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6042     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6043   }
6044
6045   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6046   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6047     fhMCcorrectionsMax->SetBinContent(j,0.04);
6048   }
6049
6050
6051   // MC D EFF CORRECTION
6052   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6053   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6054     fhMCDefficiencyMin->SetBinContent(j,-0.05);
6055   }
6056
6057   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6058   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6059     fhMCDefficiencyMax->SetBinContent(j,0.05);
6060   }
6061
6062
6063   // Contamination from secondary tracks
6064   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6065   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6066     fhSecContaminationMin->SetBinContent(j,-0.035);
6067   }
6068
6069   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6070   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6071     fhSecContaminationMax->SetBinContent(j,0.035);
6072   }
6073
6074   // MC CLOSURETEST (D meson efficiency)
6075   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6076   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6077     x=fhMCclosureTestMin->GetBinLowEdge(j);
6078     fhMCclosureTestMin->SetBinContent(j,-0.);
6079
6080     if(-0.4<x&&x<-0.2){
6081       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6082     }
6083     else if(-0.2<x&&x<-0.1){
6084       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6085     }
6086     else if(-0.1<x&&x<0.1){
6087       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6088     }
6089     else if(0.1<x&&x<0.2){
6090       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6091     }
6092     if(0.2<x&&x<0.4){
6093       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6094     }
6095   }
6096
6097   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6098   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6099     x=fhMCclosureTestMax->GetBinLowEdge(j);
6100     fhMCclosureTestMax->SetBinContent(j,0.08);
6101
6102     //     if(-0.4<x&&x<-0.2){
6103     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6104     //     }
6105     //     else if(-0.2<x&&x<-0.1){
6106     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6107     //     }
6108     //     else if(-0.2<x&&x<-0.1){
6109     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6110     //     }
6111     //     else if(-0.1<x&&x<0.1){
6112     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6113     //     }
6114     //     else if(0.1<x&&x<0.2){
6115     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6116     //     }
6117     //     if(0.2<x&&x<0.4){
6118     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6119     //     }
6120
6121   }
6122
6123   // Feed-down
6124
6125   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6126   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6127     x=fhBeautyFDmin->GetBinLowEdge(j);
6128     fhBeautyFDmin->SetBinContent(j,-0.05);
6129
6130   //   if(-0.4<x&&x<-0.2){
6131 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6132 //     }
6133 //     else if(-0.2<x&&x<-0.1){
6134 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6135 //     }
6136 //     else if(-0.2<x&&x<-0.1){
6137 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6138 //     }
6139 //     else if(-0.1<x&&x<0.1){
6140 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6141 //     }
6142 //     else if(0.1<x&&x<0.2){
6143 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6144 //     }
6145 //     if(0.2<x&&x<0.4){
6146 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6147 //     }
6148   }
6149
6150   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6151   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6152     x=fhBeautyFDmax->GetBinLowEdge(j);
6153     fhBeautyFDmax->SetBinContent(j,0.03);
6154
6155 //     if(-0.4<x&&x<-0.2){
6156 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6157 //     }
6158 //     else if(-0.2<x&&x<-0.1){
6159 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6160 //     }
6161 //     else if(-0.2<x&&x<-0.1){
6162 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6163 //     }
6164 //     else if(-0.1<x&&x<0.1){
6165 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6166 //     }
6167 //     else if(0.1<x&&x<0.2){
6168 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6169 //     }
6170 //     if(0.2<x&&x<0.4){
6171 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6172 //     }
6173
6174   }
6175
6176 }
6177
6178
6179 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03(){
6180   Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
6181   fmeson=0;
6182   fstrmeson="Dzero";
6183   fstrptAss="ptAsMore03";
6184   fstrptD="Dpt8to16";
6185   if(!fhDeltaPhiTemplate){
6186     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6187   }
6188
6189   Double_t x;
6190   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6191   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6192   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6193     fhYieldExtraction->SetBinContent(j,0.1);
6194   }
6195
6196   // Background D MESON candidate subtraction (side-band variations, etc.)
6197   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6198   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6199     fhBackSubtractionMin->SetBinContent(j,-0.05);
6200   }
6201
6202   // Background D MESON candidate subtraction (side-band variations, etc.)
6203   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6204   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6205     fhBackSubtractionMax->SetBinContent(j,0.05);
6206   }
6207
6208   // MC CORRECTIONS,  -5% 10% for assoc track eff
6209   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6210   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6211     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6212   }
6213
6214   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6215   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6216     fhMCcorrectionsMax->SetBinContent(j,0.04);
6217   }
6218
6219
6220   // MC D EFF CORRECTION
6221   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6222   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6223     fhMCDefficiencyMin->SetBinContent(j,-0.05);
6224   }
6225
6226   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6227   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6228     fhMCDefficiencyMax->SetBinContent(j,0.05);
6229   }
6230
6231
6232   // Contamination from secondary tracks
6233   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6234   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6235     fhSecContaminationMin->SetBinContent(j,-0.035);
6236   }
6237
6238   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6239   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6240     fhSecContaminationMax->SetBinContent(j,0.035);
6241   }
6242
6243   // MC CLOSURETEST (D meson efficiency)
6244   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6245   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6246     x=fhMCclosureTestMin->GetBinLowEdge(j);
6247     fhMCclosureTestMin->SetBinContent(j,-0.);
6248
6249     if(-0.4<x&&x<-0.2){
6250       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6251     }
6252     else if(-0.2<x&&x<-0.1){
6253       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6254     }
6255     else if(-0.1<x&&x<0.1){
6256       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6257     }
6258     else if(0.1<x&&x<0.2){
6259       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6260     }
6261     if(0.2<x&&x<0.4){
6262       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6263     }
6264   }
6265
6266   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6267   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6268     x=fhMCclosureTestMax->GetBinLowEdge(j);
6269     fhMCclosureTestMax->SetBinContent(j,0.08);
6270
6271     //     if(-0.4<x&&x<-0.2){
6272     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6273     //     }
6274     //     else if(-0.2<x&&x<-0.1){
6275     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6276     //     }
6277     //     else if(-0.2<x&&x<-0.1){
6278     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6279     //     }
6280     //     else if(-0.1<x&&x<0.1){
6281     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6282     //     }
6283     //     else if(0.1<x&&x<0.2){
6284     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6285     //     }
6286     //     if(0.2<x&&x<0.4){
6287     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6288     //     }
6289
6290   }
6291
6292   // Feed-down
6293
6294   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6295   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6296     x=fhBeautyFDmin->GetBinLowEdge(j);
6297     fhBeautyFDmin->SetBinContent(j,-0.05);
6298
6299   //   if(-0.4<x&&x<-0.2){
6300 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6301 //     }
6302 //     else if(-0.2<x&&x<-0.1){
6303 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6304 //     }
6305 //     else if(-0.2<x&&x<-0.1){
6306 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6307 //     }
6308 //     else if(-0.1<x&&x<0.1){
6309 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6310 //     }
6311 //     else if(0.1<x&&x<0.2){
6312 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6313 //     }
6314 //     if(0.2<x&&x<0.4){
6315 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6316 //     }
6317   }
6318
6319   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6320   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6321     x=fhBeautyFDmax->GetBinLowEdge(j);
6322     fhBeautyFDmax->SetBinContent(j,0.03);
6323
6324 //     if(-0.4<x&&x<-0.2){
6325 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6326 //     }
6327 //     else if(-0.2<x&&x<-0.1){
6328 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6329 //     }
6330 //     else if(-0.2<x&&x<-0.1){
6331 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6332 //     }
6333 //     else if(-0.1<x&&x<0.1){
6334 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6335 //     }
6336 //     else if(0.1<x&&x<0.2){
6337 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6338 //     }
6339 //     if(0.2<x&&x<0.4){
6340 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6341 //     }
6342
6343   }
6344
6345 }
6346
6347
6348
6349
6350 //--------------------------------------------------
6351 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
6352   Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6353   fmeson=1;
6354   fstrmeson="Dstar";
6355   fstrptAss="ptAsMore03";
6356   fstrptD="Dpt3to5";
6357   if(!fhDeltaPhiTemplate){
6358     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6359   }
6360   Double_t x;
6361   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6362   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6363   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6364     fhYieldExtraction->SetBinContent(j,0.1);
6365   }
6366
6367   // Background D MESON candidate subtraction (side-band variations, etc.)
6368   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6369   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6370     fhBackSubtractionMin->SetBinContent(j,-0.05);
6371   }
6372
6373   // Background D MESON candidate subtraction (side-band variations, etc.)
6374   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6375   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6376     fhBackSubtractionMax->SetBinContent(j,0.05);
6377   }
6378
6379   // MC CORRECTIONS, -5%  10% for assoc track eff
6380   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6381   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6382     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6383   }
6384
6385   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6386   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6387     fhMCcorrectionsMax->SetBinContent(j,0.04);
6388   }
6389
6390
6391   // MC D EFF CORRECTION
6392   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6393   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6394     fhMCDefficiencyMin->SetBinContent(j,-0.05);
6395   }
6396
6397   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6398   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6399     fhMCDefficiencyMax->SetBinContent(j,0.05);
6400   }
6401
6402
6403   // Contamination from secondary tracks
6404   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6405   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6406     fhSecContaminationMin->SetBinContent(j,-0.035);
6407   }
6408
6409   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6410   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6411     fhSecContaminationMax->SetBinContent(j,0.035);
6412   }
6413
6414   // MC CLOSURETEST (D meson efficiency)
6415   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6416   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6417     x=fhMCclosureTestMin->GetBinLowEdge(j);
6418     fhMCclosureTestMin->SetBinContent(j,-0.);
6419
6420     if(-0.4<x&&x<-0.2){
6421       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6422     }
6423     else if(-0.2<x&&x<-0.1){
6424       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6425     }
6426     else if(-0.1<x&&x<0.1){
6427       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6428     }
6429     else if(0.1<x&&x<0.2){
6430       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6431     }
6432     if(0.2<x&&x<0.4){
6433       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6434     }
6435   }
6436
6437   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6438   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6439     x=fhMCclosureTestMax->GetBinLowEdge(j);
6440     fhMCclosureTestMax->SetBinContent(j,0.08);
6441
6442     //     if(-0.4<x&&x<-0.2){
6443     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6444     //     }
6445     //     else if(-0.2<x&&x<-0.1){
6446     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6447     //     }
6448     //     else if(-0.2<x&&x<-0.1){
6449     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6450     //     }
6451     //     else if(-0.1<x&&x<0.1){
6452     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6453     //     }
6454     //     else if(0.1<x&&x<0.2){
6455     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6456     //     }
6457     //     if(0.2<x&&x<0.4){
6458     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6459     //     }
6460
6461   }
6462
6463   // Feed-down
6464
6465   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6466   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6467     x=fhBeautyFDmin->GetBinLowEdge(j);
6468     fhBeautyFDmin->SetBinContent(j,-0.05);
6469
6470   //   if(-0.4<x&&x<-0.2){
6471 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6472 //     }
6473 //     else if(-0.2<x&&x<-0.1){
6474 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6475 //     }
6476 //     else if(-0.2<x&&x<-0.1){
6477 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6478 //     }
6479 //     else if(-0.1<x&&x<0.1){
6480 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6481 //     }
6482 //     else if(0.1<x&&x<0.2){
6483 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6484 //     }
6485 //     if(0.2<x&&x<0.4){
6486 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6487 //     }
6488   }
6489
6490   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6491   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6492     x=fhBeautyFDmax->GetBinLowEdge(j);
6493     fhBeautyFDmax->SetBinContent(j,0.03);
6494
6495 //     if(-0.4<x&&x<-0.2){
6496 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6497 //     }
6498 //     else if(-0.2<x&&x<-0.1){
6499 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6500 //     }
6501 //     else if(-0.2<x&&x<-0.1){
6502 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6503 //     }
6504 //     else if(-0.1<x&&x<0.1){
6505 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6506 //     }
6507 //     else if(0.1<x&&x<0.2){
6508 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6509 //     }
6510 //     if(0.2<x&&x<0.4){
6511 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6512 //     }
6513
6514   }
6515
6516
6517 }
6518
6519 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
6520   Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
6521   fmeson=1;
6522   fstrmeson="Dstar";
6523   fstrptAss="ptAsMore03";
6524   fstrptD="Dpt5to8";
6525   if(!fhDeltaPhiTemplate){
6526     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6527   }
6528   Double_t x;
6529   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6530   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6531   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6532     fhYieldExtraction->SetBinContent(j,0.1);
6533   }
6534
6535   // Background D MESON candidate subtraction (side-band variations, etc.)
6536   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6537   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6538     fhBackSubtractionMin->SetBinContent(j,-0.04);
6539   }
6540
6541   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6542   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6543     fhBackSubtractionMax->SetBinContent(j,0.04);
6544   }
6545
6546   // MC CORRECTIONS/ -5%  10% for assoc track eff
6547   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6548   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6549     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6550   }
6551
6552   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6553   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6554     fhMCcorrectionsMax->SetBinContent(j,0.04);
6555   }
6556
6557   // MC D EFF CORRECTION
6558   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6559   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6560     fhMCDefficiencyMin->SetBinContent(j,-0.04);
6561   }
6562
6563   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6564   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6565     fhMCDefficiencyMax->SetBinContent(j,0.04);
6566   }
6567
6568
6569   // Contamination from secondary tracks
6570   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6571   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6572     fhSecContaminationMin->SetBinContent(j,-0.035);
6573   }
6574
6575   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6576   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6577     fhSecContaminationMax->SetBinContent(j,0.035);
6578   }
6579
6580   // MC CLOSURETEST (D meson efficiency)
6581   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6582   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6583     x=fhMCclosureTestMin->GetBinLowEdge(j);
6584     fhMCclosureTestMin->SetBinContent(j,-0.0);
6585
6586     if(-0.4<x&&x<-0.2){
6587       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6588     }
6589     else if(-0.2<x&&x<-0.1){
6590       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6591     }
6592     else if(-0.1<x&&x<0.1){
6593       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6594     }
6595     else if(0.1<x&&x<0.2){
6596       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6597     }
6598     if(0.2<x&&x<0.4){
6599       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6600     }
6601   }
6602
6603   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6604   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6605     x=fhMCclosureTestMax->GetBinLowEdge(j);
6606     fhMCclosureTestMax->SetBinContent(j,0.08);
6607
6608     //     if(-0.4<x&&x<-0.2){
6609     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6610     //     }
6611     //     else if(-0.2<x&&x<-0.1){
6612     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6613     //     }
6614     //     else if(-0.2<x&&x<-0.1){
6615     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6616     //     }
6617     //     else if(-0.1<x&&x<0.1){
6618     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6619     //     }
6620     //     else if(0.1<x&&x<0.2){
6621     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6622     //     }
6623     //     if(0.2<x&&x<0.4){
6624     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6625     //     }
6626
6627   }
6628
6629   // Feed-down
6630
6631   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6632   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6633     x=fhBeautyFDmin->GetBinLowEdge(j);
6634     fhBeautyFDmin->SetBinContent(j,-0.05);
6635
6636   //   if(-0.4<x&&x<-0.2){
6637 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6638 //     }
6639 //     else if(-0.2<x&&x<-0.1){
6640 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6641 //     }
6642 //     else if(-0.2<x&&x<-0.1){
6643 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6644 //     }
6645 //     else if(-0.1<x&&x<0.1){
6646 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6647 //     }
6648 //     else if(0.1<x&&x<0.2){
6649 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6650 //     }
6651 //     if(0.2<x&&x<0.4){
6652 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6653 //     }
6654   }
6655
6656   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6657   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6658     x=fhBeautyFDmax->GetBinLowEdge(j);
6659     fhBeautyFDmax->SetBinContent(j,0.03);
6660
6661 //     if(-0.4<x&&x<-0.2){
6662 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6663 //     }
6664 //     else if(-0.2<x&&x<-0.1){
6665 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6666 //     }
6667 //     else if(-0.2<x&&x<-0.1){
6668 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6669 //     }
6670 //     else if(-0.1<x&&x<0.1){
6671 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6672 //     }
6673 //     else if(0.1<x&&x<0.2){
6674 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6675 //     }
6676 //     if(0.2<x&&x<0.4){
6677 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6678 //     }
6679
6680   }
6681
6682 }
6683
6684
6685
6686 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03(){
6687   Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
6688   fmeson=1;
6689   fstrmeson="Dstar";
6690   fstrptAss="ptAsMore03";
6691   fstrptD="Dpt8to16";
6692   if(!fhDeltaPhiTemplate){
6693     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6694   }
6695   Double_t x;
6696   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6697   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6698   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6699     fhYieldExtraction->SetBinContent(j,0.1);
6700   }
6701
6702   // Background D MESON candidate subtraction (side-band variations, etc.)
6703   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6704   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6705     fhBackSubtractionMin->SetBinContent(j,-0.05);
6706   }
6707
6708   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6709   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6710     fhBackSubtractionMax->SetBinContent(j,0.05);
6711   }
6712
6713   // MC CORRECTIONS   -5% +10% for assoc track eff
6714   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6715   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6716     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6717   }
6718
6719   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6720   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6721     fhMCcorrectionsMax->SetBinContent(j,0.04);
6722   }
6723   // MC D EFF CORRECTION
6724   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6725   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6726     fhMCDefficiencyMin->SetBinContent(j,-0.08);
6727   }
6728
6729   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6730   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6731     fhMCDefficiencyMax->SetBinContent(j,0.08);
6732   }
6733
6734
6735   // Contamination from secondary tracks
6736   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6737   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6738     fhSecContaminationMin->SetBinContent(j,-0.035);
6739   }
6740
6741   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6742   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6743     fhSecContaminationMax->SetBinContent(j,0.035);
6744   }
6745
6746   // MC CLOSURETEST (D meson efficiency)
6747   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6748   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6749     x=fhMCclosureTestMin->GetBinLowEdge(j);
6750     fhMCclosureTestMin->SetBinContent(j,-0.0);
6751
6752     if(-0.4<x&&x<-0.2){
6753       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6754     }
6755     else if(-0.2<x&&x<-0.1){
6756       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6757     }
6758     else if(-0.1<x&&x<0.1){
6759       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6760     }
6761     else if(0.1<x&&x<0.2){
6762       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6763     }
6764     if(0.2<x&&x<0.4){
6765       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6766     }
6767   }
6768
6769   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6770   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6771     x=fhMCclosureTestMax->GetBinLowEdge(j);
6772     fhMCclosureTestMax->SetBinContent(j,0.08);
6773
6774     //     if(-0.4<x&&x<-0.2){
6775     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6776     //     }
6777     //     else if(-0.2<x&&x<-0.1){
6778     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6779     //     }
6780     //     else if(-0.2<x&&x<-0.1){
6781     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6782     //     }
6783     //     else if(-0.1<x&&x<0.1){
6784     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6785     //     }
6786     //     else if(0.1<x&&x<0.2){
6787     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6788     //     }
6789     //     if(0.2<x&&x<0.4){
6790     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6791     //     }
6792
6793   }
6794
6795   // Feed-down
6796
6797   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6798   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6799     x=fhBeautyFDmin->GetBinLowEdge(j);
6800     fhBeautyFDmin->SetBinContent(j,-0.05);
6801
6802   //   if(-0.4<x&&x<-0.2){
6803 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6804 //     }
6805 //     else if(-0.2<x&&x<-0.1){
6806 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6807 //     }
6808 //     else if(-0.2<x&&x<-0.1){
6809 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6810 //     }
6811 //     else if(-0.1<x&&x<0.1){
6812 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6813 //     }
6814 //     else if(0.1<x&&x<0.2){
6815 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6816 //     }
6817 //     if(0.2<x&&x<0.4){
6818 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6819 //     }
6820   }
6821
6822   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6823   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6824     x=fhBeautyFDmax->GetBinLowEdge(j);
6825     fhBeautyFDmax->SetBinContent(j,0.03);
6826
6827 //     if(-0.4<x&&x<-0.2){
6828 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6829 //     }
6830 //     else if(-0.2<x&&x<-0.1){
6831 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6832 //     }
6833 //     else if(-0.2<x&&x<-0.1){
6834 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6835 //     }
6836 //     else if(-0.1<x&&x<0.1){
6837 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6838 //     }
6839 //     else if(0.1<x&&x<0.2){
6840 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6841 //     }
6842 //     if(0.2<x&&x<0.4){
6843 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6844 //     }
6845
6846   }
6847
6848
6849 }
6850
6851
6852
6853
6854 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
6855   Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6856   fmeson=2;
6857   fstrmeson="Dplus";
6858   fstrptAss="ptAsMore03";
6859   fstrptD="Dpt3to5";
6860   if(!fhDeltaPhiTemplate){
6861     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6862   }
6863   Double_t x;
6864   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6865   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6866   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6867     fhYieldExtraction->SetBinContent(j,0.1);
6868   }
6869
6870   // Background D MESON candidate subtraction (side-band variations, etc.)
6871   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6872   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6873     fhBackSubtractionMin->SetBinContent(j,-0.1);
6874   }
6875
6876   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6877   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6878     fhBackSubtractionMax->SetBinContent(j,0.1);
6879   }
6880
6881
6882   // MC CORRECTIONS ( associatate track efficiency):
6883   //  -5%  +10% for assoc track eff
6884   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6885   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6886     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6887   }
6888
6889   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6890   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6891     fhMCcorrectionsMax->SetBinContent(j,0.04);
6892   }
6893
6894   // MC D EFF CORRECTION
6895   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6896   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6897     fhMCDefficiencyMin->SetBinContent(j,-0.1);
6898   }
6899
6900   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6901   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6902     fhMCDefficiencyMax->SetBinContent(j,0.1);
6903   }
6904
6905
6906   // Contamination from secondary tracks
6907   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6908   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6909     fhSecContaminationMin->SetBinContent(j,-0.035);
6910   }
6911
6912   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6913   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6914     fhSecContaminationMax->SetBinContent(j,0.035);
6915   }
6916
6917
6918   // MC CLOSURETEST (D meson efficiency)
6919   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6920   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6921     x=fhMCclosureTestMin->GetBinLowEdge(j);
6922     fhMCclosureTestMin->SetBinContent(j,-0.0);
6923
6924     if(-0.4<x&&x<-0.2){
6925       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6926     }
6927     else if(-0.2<x&&x<-0.1){
6928       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6929     }
6930     else if(-0.1<x&&x<0.1){
6931       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6932     }
6933     else if(0.1<x&&x<0.2){
6934       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6935     }
6936     if(0.2<x&&x<0.4){
6937       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6938     }
6939   }
6940
6941   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6942   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6943     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
6944     fhMCclosureTestMax->SetBinContent(j,0.08);
6945
6946     //     if(-0.4<x&&x<-0.2){
6947     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6948     //     }
6949     //     else if(-0.2<x&&x<-0.1){
6950     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6951     //     }
6952     //     else if(-0.2<x&&x<-0.1){
6953     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6954     //     }
6955     //     else if(-0.1<x&&x<0.1){
6956     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6957     //     }
6958     //     else if(0.1<x&&x<0.2){
6959     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6960     //     }
6961     //     if(0.2<x&&x<0.4){
6962     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6963     //     }
6964
6965   }
6966
6967   // Feed-down
6968
6969   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6970   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6971     x=fhBeautyFDmin->GetBinLowEdge(j);
6972     fhBeautyFDmin->SetBinContent(j,-0.05);
6973
6974   //   if(-0.4<x&&x<-0.2){
6975 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6976 //     }
6977 //     else if(-0.2<x&&x<-0.1){
6978 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6979 //     }
6980 //     else if(-0.2<x&&x<-0.1){
6981 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6982 //     }
6983 //     else if(-0.1<x&&x<0.1){
6984 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6985 //     }
6986 //     else if(0.1<x&&x<0.2){
6987 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6988 //     }
6989 //     if(0.2<x&&x<0.4){
6990 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6991 //     }
6992   }
6993
6994   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6995   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6996     x=fhBeautyFDmax->GetBinLowEdge(j);
6997     fhBeautyFDmax->SetBinContent(j,0.03);
6998
6999 //     if(-0.4<x&&x<-0.2){
7000 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7001 //     }
7002 //     else if(-0.2<x&&x<-0.1){
7003 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7004 //     }
7005 //     else if(-0.2<x&&x<-0.1){
7006 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7007 //     }
7008 //     else if(-0.1<x&&x<0.1){
7009 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7010 //     }
7011 //     else if(0.1<x&&x<0.2){
7012 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7013 //     }
7014 //     if(0.2<x&&x<0.4){
7015 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7016 //     }
7017
7018   }
7019
7020 }
7021
7022 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
7023   Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
7024   fmeson=2;
7025   fstrmeson="Dplus";
7026   fstrptAss="ptAsMore03";
7027   fstrptD="Dpt5to8";
7028   if(!fhDeltaPhiTemplate){
7029     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7030   }
7031   Double_t x;
7032   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7033   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7034   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7035     fhYieldExtraction->SetBinContent(j,0.1);
7036   }
7037
7038   // Background D MESON candidate subtraction (side-band variations, etc.)
7039   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7040   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7041     fhBackSubtractionMin->SetBinContent(j,-0.1);
7042   }
7043
7044   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7045   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7046     fhBackSubtractionMax->SetBinContent(j,0.1);
7047   }
7048
7049   // MC CORRECTIONS:  -5%  +10% for assoc track eff
7050   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7051   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7052     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7053   }
7054
7055   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7056   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7057     fhMCcorrectionsMax->SetBinContent(j,0.04);
7058   }
7059
7060
7061   // MC D EFF CORRECTION
7062   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7063   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7064     fhMCDefficiencyMin->SetBinContent(j,-0.1);
7065   }
7066
7067   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7068   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7069     fhMCDefficiencyMax->SetBinContent(j,0.1);
7070   }
7071
7072
7073   // Contamination from secondary tracks
7074   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7075   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7076     fhSecContaminationMin->SetBinContent(j,-0.035);
7077   }
7078
7079   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7080   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7081     fhSecContaminationMax->SetBinContent(j,0.035);
7082   }
7083
7084   // MC CLOSURETEST (D meson efficiency)
7085   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7086   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7087     x=fhMCclosureTestMin->GetBinLowEdge(j);
7088     fhMCclosureTestMin->SetBinContent(j,-0.0);
7089
7090     if(-0.4<x&&x<-0.2){
7091       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7092     }
7093     else if(-0.2<x&&x<-0.1){
7094       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7095     }
7096     else if(-0.1<x&&x<0.1){
7097       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7098     }
7099     else if(0.1<x&&x<0.2){
7100       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7101     }
7102     if(0.2<x&&x<0.4){
7103       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7104     }
7105   }
7106
7107   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7108   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7109     x=fhMCclosureTestMax->GetBinLowEdge(j);
7110     fhMCclosureTestMax->SetBinContent(j,0.08);
7111
7112     //     if(-0.4<x&&x<-0.2){
7113     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7114     //     }
7115     //     else if(-0.2<x&&x<-0.1){
7116     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7117     //     }
7118     //     else if(-0.2<x&&x<-0.1){
7119     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7120     //     }
7121     //     else if(-0.1<x&&x<0.1){
7122     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7123     //     }
7124     //     else if(0.1<x&&x<0.2){
7125     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7126     //     }
7127     //     if(0.2<x&&x<0.4){
7128     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7129     //     }
7130
7131   }
7132
7133   // Feed-down
7134
7135   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7136   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7137     x=fhBeautyFDmin->GetBinLowEdge(j);
7138     fhBeautyFDmin->SetBinContent(j,-0.05);
7139
7140   //   if(-0.4<x&&x<-0.2){
7141 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7142 //     }
7143 //     else if(-0.2<x&&x<-0.1){
7144 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7145 //     }
7146 //     else if(-0.2<x&&x<-0.1){
7147 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7148 //     }
7149 //     else if(-0.1<x&&x<0.1){
7150 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7151 //     }
7152 //     else if(0.1<x&&x<0.2){
7153 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7154 //     }
7155 //     if(0.2<x&&x<0.4){
7156 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7157 //     }
7158   }
7159
7160   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7161   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7162     x=fhBeautyFDmax->GetBinLowEdge(j);
7163     fhBeautyFDmax->SetBinContent(j,0.03);
7164
7165 //     if(-0.4<x&&x<-0.2){
7166 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7167 //     }
7168 //     else if(-0.2<x&&x<-0.1){
7169 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7170 //     }
7171 //     else if(-0.2<x&&x<-0.1){
7172 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7173 //     }
7174 //     else if(-0.1<x&&x<0.1){
7175 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7176 //     }
7177 //     else if(0.1<x&&x<0.2){
7178 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7179 //     }
7180 //     if(0.2<x&&x<0.4){
7181 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7182 //     }
7183
7184   }
7185
7186 }
7187
7188
7189 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03(){
7190   Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
7191   fmeson=2;
7192   fstrmeson="Dplus";
7193   fstrptAss="ptAsMore03";
7194   fstrptD="Dpt8to16";
7195   if(!fhDeltaPhiTemplate){
7196     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7197   }
7198
7199   Double_t x;
7200   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7201   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7202   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7203     fhYieldExtraction->SetBinContent(j,0.1);
7204   }
7205
7206   // Background D MESON candidate subtraction (side-band variations, etc.)
7207   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7208   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7209     fhBackSubtractionMin->SetBinContent(j,-0.1);
7210   }
7211
7212   // Background D MESON candidate subtraction (side-band variations, etc.)
7213   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7214   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7215     fhBackSubtractionMax->SetBinContent(j,0.1);
7216   }
7217
7218   // MC CORRECTIONS,  -5% 10% for assoc track eff
7219   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7220   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7221     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7222   }
7223
7224   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7225   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7226     fhMCcorrectionsMax->SetBinContent(j,0.04);
7227   }
7228
7229
7230   // MC D EFF CORRECTION
7231   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7232   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7233     fhMCDefficiencyMin->SetBinContent(j,-0.1);
7234   }
7235
7236   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7237   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7238     fhMCDefficiencyMax->SetBinContent(j,0.1);
7239   }
7240
7241
7242   // Contamination from secondary tracks
7243   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7244   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7245     fhSecContaminationMin->SetBinContent(j,-0.035);
7246   }
7247
7248   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7249   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7250     fhSecContaminationMax->SetBinContent(j,0.035);
7251   }
7252
7253   // MC CLOSURETEST (D meson efficiency)
7254   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7255   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7256     x=fhMCclosureTestMin->GetBinLowEdge(j);
7257     fhMCclosureTestMin->SetBinContent(j,-0.0);
7258
7259     if(-0.4<x&&x<-0.2){
7260       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7261     }
7262     else if(-0.2<x&&x<-0.1){
7263       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7264     }
7265     else if(-0.1<x&&x<0.1){
7266       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7267     }
7268     else if(0.1<x&&x<0.2){
7269       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7270     }
7271     if(0.2<x&&x<0.4){
7272       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7273     }
7274   }
7275
7276   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7277   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7278     x=fhMCclosureTestMax->GetBinLowEdge(j);
7279     fhMCclosureTestMax->SetBinContent(j,0.08);
7280
7281     //     if(-0.4<x&&x<-0.2){
7282     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7283     //     }
7284     //     else if(-0.2<x&&x<-0.1){
7285     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7286     //     }
7287     //     else if(-0.2<x&&x<-0.1){
7288     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7289     //     }
7290     //     else if(-0.1<x&&x<0.1){
7291     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7292     //     }
7293     //     else if(0.1<x&&x<0.2){
7294     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7295     //     }
7296     //     if(0.2<x&&x<0.4){
7297     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7298     //     }
7299
7300   }
7301
7302   // Feed-down
7303
7304   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7305   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7306     x=fhBeautyFDmin->GetBinLowEdge(j);
7307     fhBeautyFDmin->SetBinContent(j,-0.05);
7308
7309   //   if(-0.4<x&&x<-0.2){
7310 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7311 //     }
7312 //     else if(-0.2<x&&x<-0.1){
7313 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7314 //     }
7315 //     else if(-0.2<x&&x<-0.1){
7316 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7317 //     }
7318 //     else if(-0.1<x&&x<0.1){
7319 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7320 //     }
7321 //     else if(0.1<x&&x<0.2){
7322 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7323 //     }
7324 //     if(0.2<x&&x<0.4){
7325 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7326 //     }
7327   }
7328
7329   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7330   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7331     x=fhBeautyFDmax->GetBinLowEdge(j);
7332     fhBeautyFDmax->SetBinContent(j,0.03);
7333
7334 //     if(-0.4<x&&x<-0.2){
7335 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7336 //     }
7337 //     else if(-0.2<x&&x<-0.1){
7338 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7339 //     }
7340 //     else if(-0.2<x&&x<-0.1){
7341 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7342 //     }
7343 //     else if(-0.1<x&&x<0.1){
7344 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7345 //     }
7346 //     else if(0.1<x&&x<0.2){
7347 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7348 //     }
7349 //     if(0.2<x&&x<0.4){
7350 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7351 //     }
7352
7353   }
7354
7355 }
7356
7357
7358
7359 //////// HIGHER PT ASS THRESHOLDS
7360
7361 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
7362   Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
7363   fmeson=0;
7364   fstrmeson="Dzero";
7365   fstrptAss="ptAsMore05";
7366   fstrptD="Dpt3to5";
7367   if(!fhDeltaPhiTemplate){
7368     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7369   }
7370   Double_t x;
7371   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7372   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7373   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7374     fhYieldExtraction->SetBinContent(j,0.1);
7375   }
7376
7377   // Background D MESON candidate subtraction (side-band variations, etc.)
7378   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7379   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7380     fhBackSubtractionMin->SetBinContent(j,-0.05);
7381   }
7382
7383   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7384   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7385     fhBackSubtractionMax->SetBinContent(j,0.05);
7386   }
7387
7388
7389   // MC CORRECTIONS ( associatate track efficiency):
7390   //  -5%  +10% for assoc track eff
7391   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7392   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7393     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7394   }
7395
7396   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7397   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7398     fhMCcorrectionsMax->SetBinContent(j,0.04);
7399   }
7400
7401   // MC D EFF CORRECTION
7402   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7403   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7404     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7405   }
7406
7407   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7408   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7409     fhMCDefficiencyMax->SetBinContent(j,0.05);
7410   }
7411
7412
7413   // Contamination from secondary tracks
7414   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7415   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7416     fhSecContaminationMin->SetBinContent(j,-0.035);
7417   }
7418
7419   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7420   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7421     fhSecContaminationMax->SetBinContent(j,0.035);
7422   }
7423
7424
7425   // MC CLOSURETEST (D meson efficiency)
7426   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7427   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7428     x=fhMCclosureTestMin->GetBinLowEdge(j);
7429     fhMCclosureTestMin->SetBinContent(j,-0.);
7430
7431     if(-0.4<x&&x<-0.2){
7432       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7433     }
7434     else if(-0.2<x&&x<-0.1){
7435       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7436     }
7437     else if(-0.1<x&&x<0.1){
7438       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7439     }
7440     else if(0.1<x&&x<0.2){
7441       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7442     }
7443     if(0.2<x&&x<0.4){
7444       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7445     }
7446   }
7447
7448   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7449   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7450     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
7451     fhMCclosureTestMax->SetBinContent(j,0.07);
7452
7453     //     if(-0.4<x&&x<-0.2){
7454     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7455     //     }
7456     //     else if(-0.2<x&&x<-0.1){
7457     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7458     //     }
7459     //     else if(-0.2<x&&x<-0.1){
7460     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7461     //     }
7462     //     else if(-0.1<x&&x<0.1){
7463     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7464     //     }
7465     //     else if(0.1<x&&x<0.2){
7466     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7467     //     }
7468     //     if(0.2<x&&x<0.4){
7469     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7470     //     }
7471
7472   }
7473
7474   // Feed-down
7475
7476   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7477   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7478     x=fhBeautyFDmin->GetBinLowEdge(j);
7479     fhBeautyFDmin->SetBinContent(j,-0.05);
7480
7481   //   if(-0.4<x&&x<-0.2){
7482 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7483 //     }
7484 //     else if(-0.2<x&&x<-0.1){
7485 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7486 //     }
7487 //     else if(-0.2<x&&x<-0.1){
7488 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7489 //     }
7490 //     else if(-0.1<x&&x<0.1){
7491 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7492 //     }
7493 //     else if(0.1<x&&x<0.2){
7494 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7495 //     }
7496 //     if(0.2<x&&x<0.4){
7497 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7498 //     }
7499   }
7500
7501   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7502   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7503     x=fhBeautyFDmax->GetBinLowEdge(j);
7504     fhBeautyFDmax->SetBinContent(j,0.03);
7505
7506 //     if(-0.4<x&&x<-0.2){
7507 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7508 //     }
7509 //     else if(-0.2<x&&x<-0.1){
7510 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7511 //     }
7512 //     else if(-0.2<x&&x<-0.1){
7513 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7514 //     }
7515 //     else if(-0.1<x&&x<0.1){
7516 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7517 //     }
7518 //     else if(0.1<x&&x<0.2){
7519 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7520 //     }
7521 //     if(0.2<x&&x<0.4){
7522 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7523 //     }
7524
7525   }
7526
7527 }
7528
7529 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
7530   Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
7531   fmeson=0;
7532   fstrmeson="Dzero";
7533   fstrptAss="ptAsMore05";
7534   fstrptD="Dpt5to8";
7535   if(!fhDeltaPhiTemplate){
7536     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7537   }
7538   Double_t x;
7539   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7540   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7541   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7542     fhYieldExtraction->SetBinContent(j,0.1);
7543   }
7544
7545   // Background D MESON candidate subtraction (side-band variations, etc.)
7546   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7547   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7548     fhBackSubtractionMin->SetBinContent(j,-0.05);
7549   }
7550
7551   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7552   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7553     fhBackSubtractionMax->SetBinContent(j,0.05);
7554   }
7555
7556   // MC CORRECTIONS:  -5%  +10% for assoc track eff
7557   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7558   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7559     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7560   }
7561
7562   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7563   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7564     fhMCcorrectionsMax->SetBinContent(j,0.04);
7565   }
7566
7567
7568   // MC D EFF CORRECTION
7569   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7570   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7571     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7572   }
7573
7574   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7575   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7576     fhMCDefficiencyMax->SetBinContent(j,0.05);
7577   }
7578
7579
7580   // Contamination from secondary tracks
7581   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7582   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7583     fhSecContaminationMin->SetBinContent(j,-0.035);
7584   }
7585
7586   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7587   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7588     fhSecContaminationMax->SetBinContent(j,0.035);
7589   }
7590
7591   // MC CLOSURETEST (D meson efficiency)
7592   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7593   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7594     x=fhMCclosureTestMin->GetBinLowEdge(j);
7595     fhMCclosureTestMin->SetBinContent(j,-0.);
7596
7597     if(-0.4<x&&x<-0.2){
7598       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7599     }
7600     else if(-0.2<x&&x<-0.1){
7601       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7602     }
7603     else if(-0.1<x&&x<0.1){
7604       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7605     }
7606     else if(0.1<x&&x<0.2){
7607       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7608     }
7609     if(0.2<x&&x<0.4){
7610       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7611     }
7612   }
7613
7614   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7615   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7616     x=fhMCclosureTestMax->GetBinLowEdge(j);
7617     fhMCclosureTestMax->SetBinContent(j,0.07);
7618
7619     //     if(-0.4<x&&x<-0.2){
7620     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7621     //     }
7622     //     else if(-0.2<x&&x<-0.1){
7623     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7624     //     }
7625     //     else if(-0.2<x&&x<-0.1){
7626     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7627     //     }
7628     //     else if(-0.1<x&&x<0.1){
7629     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7630     //     }
7631     //     else if(0.1<x&&x<0.2){
7632     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7633     //     }
7634     //     if(0.2<x&&x<0.4){
7635     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7636     //     }
7637
7638   }
7639
7640   // Feed-down
7641
7642   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7643   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7644     x=fhBeautyFDmin->GetBinLowEdge(j);
7645     fhBeautyFDmin->SetBinContent(j,-0.05);
7646
7647   //   if(-0.4<x&&x<-0.2){
7648 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7649 //     }
7650 //     else if(-0.2<x&&x<-0.1){
7651 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7652 //     }
7653 //     else if(-0.2<x&&x<-0.1){
7654 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7655 //     }
7656 //     else if(-0.1<x&&x<0.1){
7657 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7658 //     }
7659 //     else if(0.1<x&&x<0.2){
7660 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7661 //     }
7662 //     if(0.2<x&&x<0.4){
7663 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7664 //     }
7665   }
7666
7667   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7668   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7669     x=fhBeautyFDmax->GetBinLowEdge(j);
7670     fhBeautyFDmax->SetBinContent(j,0.03);
7671
7672 //     if(-0.4<x&&x<-0.2){
7673 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7674 //     }
7675 //     else if(-0.2<x&&x<-0.1){
7676 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7677 //     }
7678 //     else if(-0.2<x&&x<-0.1){
7679 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7680 //     }
7681 //     else if(-0.1<x&&x<0.1){
7682 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7683 //     }
7684 //     else if(0.1<x&&x<0.2){
7685 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7686 //     }
7687 //     if(0.2<x&&x<0.4){
7688 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7689 //     }
7690
7691   }
7692
7693 }
7694
7695
7696 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05(){
7697   Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
7698   fmeson=0;
7699   fstrmeson="Dzero";
7700   fstrptAss="ptAsMore05";
7701   fstrptD="Dpt8to16";
7702   if(!fhDeltaPhiTemplate){
7703     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7704   }
7705
7706   Double_t x;
7707   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7708   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7709   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7710     fhYieldExtraction->SetBinContent(j,0.1);
7711   }
7712
7713   // Background D MESON candidate subtraction (side-band variations, etc.)
7714   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7715   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7716     fhBackSubtractionMin->SetBinContent(j,-0.05);
7717   }
7718
7719   // Background D MESON candidate subtraction (side-band variations, etc.)
7720   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7721   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7722     fhBackSubtractionMax->SetBinContent(j,0.05);
7723   }
7724
7725   // MC CORRECTIONS,  -5% 10% for assoc track eff
7726   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7727   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7728     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7729   }
7730
7731   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7732   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7733     fhMCcorrectionsMax->SetBinContent(j,0.04);
7734   }
7735
7736
7737   // MC D EFF CORRECTION
7738   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7739   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7740     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7741   }
7742
7743   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7744   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7745     fhMCDefficiencyMax->SetBinContent(j,0.05);
7746   }
7747
7748
7749   // Contamination from secondary tracks
7750   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7751   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7752     fhSecContaminationMin->SetBinContent(j,-0.035);
7753   }
7754
7755   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7756   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7757     fhSecContaminationMax->SetBinContent(j,0.035);
7758   }
7759
7760   // MC CLOSURETEST (D meson efficiency)
7761   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7762   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7763     x=fhMCclosureTestMin->GetBinLowEdge(j);
7764     fhMCclosureTestMin->SetBinContent(j,-0.);
7765
7766     if(-0.4<x&&x<-0.2){
7767       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7768     }
7769     else if(-0.2<x&&x<-0.1){
7770       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7771     }
7772     else if(-0.1<x&&x<0.1){
7773       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7774     }
7775     else if(0.1<x&&x<0.2){
7776       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7777     }
7778     if(0.2<x&&x<0.4){
7779       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7780     }
7781   }
7782
7783   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7784   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7785     x=fhMCclosureTestMax->GetBinLowEdge(j);
7786     fhMCclosureTestMax->SetBinContent(j,0.07);
7787
7788     //     if(-0.4<x&&x<-0.2){
7789     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7790     //     }
7791     //     else if(-0.2<x&&x<-0.1){
7792     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7793     //     }
7794     //     else if(-0.2<x&&x<-0.1){
7795     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7796     //     }
7797     //     else if(-0.1<x&&x<0.1){
7798     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7799     //     }
7800     //     else if(0.1<x&&x<0.2){
7801     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7802     //     }
7803     //     if(0.2<x&&x<0.4){
7804     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7805     //     }
7806
7807   }
7808
7809   // Feed-down
7810
7811   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7812   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7813     x=fhBeautyFDmin->GetBinLowEdge(j);
7814     fhBeautyFDmin->SetBinContent(j,-0.05);
7815
7816   //   if(-0.4<x&&x<-0.2){
7817 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7818 //     }
7819 //     else if(-0.2<x&&x<-0.1){
7820 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7821 //     }
7822 //     else if(-0.2<x&&x<-0.1){
7823 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7824 //     }
7825 //     else if(-0.1<x&&x<0.1){
7826 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7827 //     }
7828 //     else if(0.1<x&&x<0.2){
7829 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7830 //     }
7831 //     if(0.2<x&&x<0.4){
7832 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7833 //     }
7834   }
7835
7836   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7837   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7838     x=fhBeautyFDmax->GetBinLowEdge(j);
7839     fhBeautyFDmax->SetBinContent(j,0.03);
7840
7841 //     if(-0.4<x&&x<-0.2){
7842 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7843 //     }
7844 //     else if(-0.2<x&&x<-0.1){
7845 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7846 //     }
7847 //     else if(-0.2<x&&x<-0.1){
7848 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7849 //     }
7850 //     else if(-0.1<x&&x<0.1){
7851 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7852 //     }
7853 //     else if(0.1<x&&x<0.2){
7854 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7855 //     }
7856 //     if(0.2<x&&x<0.4){
7857 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7858 //     }
7859
7860   }
7861
7862 }
7863
7864
7865
7866
7867 //--------------------------------------------------
7868 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
7869   Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
7870   fmeson=1;
7871   fstrmeson="Dstar";
7872   fstrptAss="ptAsMore05";
7873   fstrptD="Dpt3to5";
7874   if(!fhDeltaPhiTemplate){
7875     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7876   }
7877   Double_t x;
7878   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7879   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7880   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7881     fhYieldExtraction->SetBinContent(j,0.1);
7882   }
7883
7884   // Background D MESON candidate subtraction (side-band variations, etc.)
7885   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7886   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7887     fhBackSubtractionMin->SetBinContent(j,-0.07);
7888   }
7889
7890   // Background D MESON candidate subtraction (side-band variations, etc.)
7891   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7892   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7893     fhBackSubtractionMax->SetBinContent(j,0.07);
7894   }
7895
7896   // MC CORRECTIONS, -5%  10% for assoc track eff
7897   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7898   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7899     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7900   }
7901
7902   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7903   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7904     fhMCcorrectionsMax->SetBinContent(j,0.04);
7905   }
7906
7907
7908   // MC D EFF CORRECTION
7909   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7910   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7911     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7912   }
7913
7914   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7915   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7916     fhMCDefficiencyMax->SetBinContent(j,0.05);
7917   }
7918
7919
7920   // Contamination from secondary tracks
7921   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7922   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7923     fhSecContaminationMin->SetBinContent(j,-0.035);
7924   }
7925
7926   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7927   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7928     fhSecContaminationMax->SetBinContent(j,0.035);
7929   }
7930
7931   // MC CLOSURETEST (D meson efficiency)
7932   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7933   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7934     x=fhMCclosureTestMin->GetBinLowEdge(j);
7935     fhMCclosureTestMin->SetBinContent(j,-0.0);
7936
7937     if(-0.4<x&&x<-0.2){
7938       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7939     }
7940     else if(-0.2<x&&x<-0.1){
7941       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7942     }
7943     else if(-0.1<x&&x<0.1){
7944       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7945     }
7946     else if(0.1<x&&x<0.2){
7947       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7948     }
7949     if(0.2<x&&x<0.4){
7950       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7951     }
7952   }
7953
7954   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7955   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7956     x=fhMCclosureTestMax->GetBinLowEdge(j);
7957     fhMCclosureTestMax->SetBinContent(j,0.7);
7958
7959     //     if(-0.4<x&&x<-0.2){
7960     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7961     //     }
7962     //     else if(-0.2<x&&x<-0.1){
7963     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7964     //     }
7965     //     else if(-0.2<x&&x<-0.1){
7966     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7967     //     }
7968     //     else if(-0.1<x&&x<0.1){
7969     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7970     //     }
7971     //     else if(0.1<x&&x<0.2){
7972     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7973     //     }
7974     //     if(0.2<x&&x<0.4){
7975     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7976     //     }
7977
7978   }
7979
7980   // Feed-down
7981
7982   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7983   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7984     x=fhBeautyFDmin->GetBinLowEdge(j);
7985     fhBeautyFDmin->SetBinContent(j,-0.05);
7986
7987   //   if(-0.4<x&&x<-0.2){
7988 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7989 //     }
7990 //     else if(-0.2<x&&x<-0.1){
7991 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7992 //     }
7993 //     else if(-0.2<x&&x<-0.1){
7994 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7995 //     }
7996 //     else if(-0.1<x&&x<0.1){
7997 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7998 //     }
7999 //     else if(0.1<x&&x<0.2){
8000 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8001 //     }
8002 //     if(0.2<x&&x<0.4){
8003 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8004 //     }
8005   }
8006
8007   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8008   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8009     x=fhBeautyFDmax->GetBinLowEdge(j);
8010     fhBeautyFDmax->SetBinContent(j,0.03);
8011
8012 //     if(-0.4<x&&x<-0.2){
8013 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8014 //     }
8015 //     else if(-0.2<x&&x<-0.1){
8016 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8017 //     }
8018 //     else if(-0.2<x&&x<-0.1){
8019 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8020 //     }
8021 //     else if(-0.1<x&&x<0.1){
8022 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8023 //     }
8024 //     else if(0.1<x&&x<0.2){
8025 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8026 //     }
8027 //     if(0.2<x&&x<0.4){
8028 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8029 //     }
8030
8031   }
8032
8033
8034 }
8035
8036 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
8037   Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8038   fmeson=1;
8039   fstrmeson="Dstar";
8040   fstrptAss="ptAsMore05";
8041   fstrptD="Dpt5to8";
8042   if(!fhDeltaPhiTemplate){
8043     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8044   }
8045   Double_t x;
8046   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8047   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8048   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8049     fhYieldExtraction->SetBinContent(j,0.1);
8050   }
8051
8052   // Background D MESON candidate subtraction (side-band variations, etc.)
8053   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8054   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8055     fhBackSubtractionMin->SetBinContent(j,-0.05);
8056   }
8057
8058   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8059   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8060     fhBackSubtractionMax->SetBinContent(j,0.05);
8061   }
8062
8063   // MC CORRECTIONS/ -5%  10% for assoc track eff
8064   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8065   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8066     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8067   }
8068
8069   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8070   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8071     fhMCcorrectionsMax->SetBinContent(j,0.04);
8072   }
8073
8074   // MC D EFF CORRECTION
8075   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8076   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8077     fhMCDefficiencyMin->SetBinContent(j,-0.05);
8078   }
8079
8080   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8081   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8082     fhMCDefficiencyMax->SetBinContent(j,0.05);
8083   }
8084
8085
8086   // Contamination from secondary tracks
8087   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8088   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8089     fhSecContaminationMin->SetBinContent(j,-0.035);
8090   }
8091
8092   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8093   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8094     fhSecContaminationMax->SetBinContent(j,0.035);
8095   }
8096
8097   // MC CLOSURETEST (D meson efficiency)
8098   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8099   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8100     x=fhMCclosureTestMin->GetBinLowEdge(j);
8101     fhMCclosureTestMin->SetBinContent(j,-0.0);
8102
8103     if(-0.4<x&&x<-0.2){
8104       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8105     }
8106     else if(-0.2<x&&x<-0.1){
8107       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8108     }
8109     else if(-0.1<x&&x<0.1){
8110       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8111     }
8112     else if(0.1<x&&x<0.2){
8113       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8114     }
8115     if(0.2<x&&x<0.4){
8116       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8117     }
8118   }
8119
8120   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8121   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8122     x=fhMCclosureTestMax->GetBinLowEdge(j);
8123     fhMCclosureTestMax->SetBinContent(j,0.07);
8124
8125     //     if(-0.4<x&&x<-0.2){
8126     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8127     //     }
8128     //     else if(-0.2<x&&x<-0.1){
8129     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8130     //     }
8131     //     else if(-0.2<x&&x<-0.1){
8132     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8133     //     }
8134     //     else if(-0.1<x&&x<0.1){
8135     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8136     //     }
8137     //     else if(0.1<x&&x<0.2){
8138     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8139     //     }
8140     //     if(0.2<x&&x<0.4){
8141     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8142     //     }
8143
8144   }
8145
8146   // Feed-down
8147
8148   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8149   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8150     x=fhBeautyFDmin->GetBinLowEdge(j);
8151     fhBeautyFDmin->SetBinContent(j,-0.05);
8152
8153   //   if(-0.4<x&&x<-0.2){
8154 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8155 //     }
8156 //     else if(-0.2<x&&x<-0.1){
8157 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8158 //     }
8159 //     else if(-0.2<x&&x<-0.1){
8160 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8161 //     }
8162 //     else if(-0.1<x&&x<0.1){
8163 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8164 //     }
8165 //     else if(0.1<x&&x<0.2){
8166 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8167 //     }
8168 //     if(0.2<x&&x<0.4){
8169 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8170 //     }
8171   }
8172
8173   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8174   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8175     x=fhBeautyFDmax->GetBinLowEdge(j);
8176     fhBeautyFDmax->SetBinContent(j,0.03);
8177
8178 //     if(-0.4<x&&x<-0.2){
8179 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8180 //     }
8181 //     else if(-0.2<x&&x<-0.1){
8182 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8183 //     }
8184 //     else if(-0.2<x&&x<-0.1){
8185 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8186 //     }
8187 //     else if(-0.1<x&&x<0.1){
8188 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8189 //     }
8190 //     else if(0.1<x&&x<0.2){
8191 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8192 //     }
8193 //     if(0.2<x&&x<0.4){
8194 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8195 //     }
8196
8197   }
8198
8199 }
8200
8201
8202
8203 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05(){
8204   Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8205   fmeson=1;
8206   fstrmeson="Dstar";
8207   fstrptAss="ptAsMore05";
8208   fstrptD="Dpt8to16";
8209   if(!fhDeltaPhiTemplate){
8210     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8211   }
8212   Double_t x;
8213   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8214   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8215   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8216     fhYieldExtraction->SetBinContent(j,0.1);
8217   }
8218
8219   // Background D MESON candidate subtraction (side-band variations, etc.)
8220   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8221   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8222     fhBackSubtractionMin->SetBinContent(j,-0.05);
8223   }
8224
8225   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8226   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8227     fhBackSubtractionMax->SetBinContent(j,0.05);
8228   }
8229
8230   // MC CORRECTIONS   -5% +10% for assoc track eff
8231   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8232   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8233     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8234   }
8235
8236   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8237   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8238     fhMCcorrectionsMax->SetBinContent(j,0.04);
8239   }
8240   // MC D EFF CORRECTION
8241   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8242   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8243     fhMCDefficiencyMin->SetBinContent(j,-0.08);
8244   }
8245
8246   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8247   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8248     fhMCDefficiencyMax->SetBinContent(j,0.08);
8249   }
8250
8251
8252   // Contamination from secondary tracks
8253   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8254   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8255     fhSecContaminationMin->SetBinContent(j,-0.035);
8256   }
8257
8258   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8259   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8260     fhSecContaminationMax->SetBinContent(j,0.035);
8261   }
8262
8263   // MC CLOSURETEST (D meson efficiency)
8264   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8265   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8266     x=fhMCclosureTestMin->GetBinLowEdge(j);
8267     fhMCclosureTestMin->SetBinContent(j,-0.0);
8268
8269     if(-0.4<x&&x<-0.2){
8270       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8271     }
8272     else if(-0.2<x&&x<-0.1){
8273       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8274     }
8275     else if(-0.1<x&&x<0.1){
8276       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8277     }
8278     else if(0.1<x&&x<0.2){
8279       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8280     }
8281     if(0.2<x&&x<0.4){
8282       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8283     }
8284   }
8285
8286   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8287   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8288     x=fhMCclosureTestMax->GetBinLowEdge(j);
8289     fhMCclosureTestMax->SetBinContent(j,0.07);
8290
8291     //     if(-0.4<x&&x<-0.2){
8292     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8293     //     }
8294     //     else if(-0.2<x&&x<-0.1){
8295     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8296     //     }
8297     //     else if(-0.2<x&&x<-0.1){
8298     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8299     //     }
8300     //     else if(-0.1<x&&x<0.1){
8301     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8302     //     }
8303     //     else if(0.1<x&&x<0.2){
8304     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8305     //     }
8306     //     if(0.2<x&&x<0.4){
8307     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8308     //     }
8309
8310   }
8311
8312   // Feed-down
8313
8314   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8315   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8316     x=fhBeautyFDmin->GetBinLowEdge(j);
8317     fhBeautyFDmin->SetBinContent(j,-0.05);
8318
8319   //   if(-0.4<x&&x<-0.2){
8320 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8321 //     }
8322 //     else if(-0.2<x&&x<-0.1){
8323 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8324 //     }
8325 //     else if(-0.2<x&&x<-0.1){
8326 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8327 //     }
8328 //     else if(-0.1<x&&x<0.1){
8329 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8330 //     }
8331 //     else if(0.1<x&&x<0.2){
8332 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8333 //     }
8334 //     if(0.2<x&&x<0.4){
8335 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8336 //     }
8337   }
8338
8339   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8340   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8341     x=fhBeautyFDmax->GetBinLowEdge(j);
8342     fhBeautyFDmax->SetBinContent(j,0.03);
8343
8344 //     if(-0.4<x&&x<-0.2){
8345 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8346 //     }
8347 //     else if(-0.2<x&&x<-0.1){
8348 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8349 //     }
8350 //     else if(-0.2<x&&x<-0.1){
8351 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8352 //     }
8353 //     else if(-0.1<x&&x<0.1){
8354 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8355 //     }
8356 //     else if(0.1<x&&x<0.2){
8357 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8358 //     }
8359 //     if(0.2<x&&x<0.4){
8360 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8361 //     }
8362
8363   }
8364
8365
8366 }
8367
8368
8369
8370 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
8371   Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
8372   fmeson=2;
8373   fstrmeson="Dplus";
8374   fstrptAss="ptAsMore05";
8375   fstrptD="Dpt3to5";
8376   if(!fhDeltaPhiTemplate){
8377     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8378   }
8379   Double_t x;
8380   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8381   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8382   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8383     fhYieldExtraction->SetBinContent(j,0.1);
8384   }
8385
8386   // Background D MESON candidate subtraction (side-band variations, etc.)
8387   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8388   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8389     fhBackSubtractionMin->SetBinContent(j,-0.1);
8390   }
8391
8392   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8393   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8394     fhBackSubtractionMax->SetBinContent(j,0.1);
8395   }
8396
8397
8398   // MC CORRECTIONS ( associatate track efficiency):
8399   //  -5%  +10% for assoc track eff
8400   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8401   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8402     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8403   }
8404
8405   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8406   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8407     fhMCcorrectionsMax->SetBinContent(j,0.04);
8408   }
8409
8410   // MC D EFF CORRECTION
8411   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8412   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8413     fhMCDefficiencyMin->SetBinContent(j,-0.1);
8414   }
8415
8416   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8417   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8418     fhMCDefficiencyMax->SetBinContent(j,0.1);
8419   }
8420
8421
8422   // Contamination from secondary tracks
8423   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8424   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8425     fhSecContaminationMin->SetBinContent(j,-0.035);
8426   }
8427
8428   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8429   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8430     fhSecContaminationMax->SetBinContent(j,0.035);
8431   }
8432
8433
8434   // MC CLOSURETEST (D meson efficiency)
8435   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8436   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8437     x=fhMCclosureTestMin->GetBinLowEdge(j);
8438     fhMCclosureTestMin->SetBinContent(j,-0.0);
8439
8440     if(-0.4<x&&x<-0.2){
8441       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8442     }
8443     else if(-0.2<x&&x<-0.1){
8444       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8445     }
8446     else if(-0.1<x&&x<0.1){
8447       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8448     }
8449     else if(0.1<x&&x<0.2){
8450       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8451     }
8452     if(0.2<x&&x<0.4){
8453       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8454     }
8455   }
8456
8457   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8458   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8459     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
8460     fhMCclosureTestMax->SetBinContent(j,0.06);
8461
8462     //     if(-0.4<x&&x<-0.2){
8463     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8464     //     }
8465     //     else if(-0.2<x&&x<-0.1){
8466     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8467     //     }
8468     //     else if(-0.2<x&&x<-0.1){
8469     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8470     //     }
8471     //     else if(-0.1<x&&x<0.1){
8472     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8473     //     }
8474     //     else if(0.1<x&&x<0.2){
8475     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8476     //     }
8477     //     if(0.2<x&&x<0.4){
8478     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8479     //     }
8480
8481   }
8482
8483   // Feed-down
8484
8485   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8486   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8487     x=fhBeautyFDmin->GetBinLowEdge(j);
8488     fhBeautyFDmin->SetBinContent(j,-0.05);
8489
8490   //   if(-0.4<x&&x<-0.2){
8491 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8492 //     }
8493 //     else if(-0.2<x&&x<-0.1){
8494 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8495 //     }
8496 //     else if(-0.2<x&&x<-0.1){
8497 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8498 //     }
8499 //     else if(-0.1<x&&x<0.1){
8500 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8501 //     }
8502 //     else if(0.1<x&&x<0.2){
8503 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8504 //     }
8505 //     if(0.2<x&&x<0.4){
8506 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8507 //     }
8508   }
8509
8510   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8511   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8512     x=fhBeautyFDmax->GetBinLowEdge(j);
8513     fhBeautyFDmax->SetBinContent(j,0.03);
8514
8515 //     if(-0.4<x&&x<-0.2){
8516 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8517 //     }
8518 //     else if(-0.2<x&&x<-0.1){
8519 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8520 //     }
8521 //     else if(-0.2<x&&x<-0.1){
8522 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8523 //     }
8524 //     else if(-0.1<x&&x<0.1){
8525 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8526 //     }
8527 //     else if(0.1<x&&x<0.2){
8528 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8529 //     }
8530 //     if(0.2<x&&x<0.4){
8531 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8532 //     }
8533
8534   }
8535
8536 }
8537
8538 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
8539   Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8540   fmeson=2;
8541   fstrmeson="Dplus";
8542   fstrptAss="ptAsMore05";
8543   fstrptD="Dpt5to8";
8544   if(!fhDeltaPhiTemplate){
8545     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8546   }
8547   Double_t x;
8548   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8549   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8550   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8551     fhYieldExtraction->SetBinContent(j,0.1);
8552   }
8553
8554   // Background D MESON candidate subtraction (side-band variations, etc.)
8555   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8556   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8557     fhBackSubtractionMin->SetBinContent(j,-0.1);
8558   }
8559
8560   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8561   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8562     fhBackSubtractionMax->SetBinContent(j,0.1);
8563   }
8564
8565   // MC CORRECTIONS:  -5%  +10% for assoc track eff
8566   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8567   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8568     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8569   }
8570
8571   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8572   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8573     fhMCcorrectionsMax->SetBinContent(j,0.04);
8574   }
8575
8576
8577   // MC D EFF CORRECTION
8578   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8579   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8580     fhMCDefficiencyMin->SetBinContent(j,-0.1);
8581   }
8582
8583   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8584   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8585     fhMCDefficiencyMax->SetBinContent(j,0.1);
8586   }
8587
8588
8589   // Contamination from secondary tracks
8590   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8591   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8592     fhSecContaminationMin->SetBinContent(j,-0.035);
8593   }
8594
8595   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8596   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8597     fhSecContaminationMax->SetBinContent(j,0.035);
8598   }
8599
8600   // MC CLOSURETEST (D meson efficiency)
8601   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8602   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8603     x=fhMCclosureTestMin->GetBinLowEdge(j);
8604     fhMCclosureTestMin->SetBinContent(j,-0.0);
8605
8606     if(-0.4<x&&x<-0.2){
8607       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8608     }
8609     else if(-0.2<x&&x<-0.1){
8610       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8611     }
8612     else if(-0.1<x&&x<0.1){
8613       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8614     }
8615     else if(0.1<x&&x<0.2){
8616       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8617     }
8618     if(0.2<x&&x<0.4){
8619       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8620     }
8621   }
8622
8623   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8624   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8625     x=fhMCclosureTestMax->GetBinLowEdge(j);
8626     fhMCclosureTestMax->SetBinContent(j,0.06);
8627
8628     //     if(-0.4<x&&x<-0.2){
8629     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8630     //     }
8631     //     else if(-0.2<x&&x<-0.1){
8632     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8633     //     }
8634     //     else if(-0.2<x&&x<-0.1){
8635     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8636     //     }
8637     //     else if(-0.1<x&&x<0.1){
8638     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8639     //     }
8640     //     else if(0.1<x&&x<0.2){
8641     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8642     //     }
8643     //     if(0.2<x&&x<0.4){
8644     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8645     //     }
8646
8647   }
8648
8649   // Feed-down
8650
8651   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8652   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8653     x=fhBeautyFDmin->GetBinLowEdge(j);
8654     fhBeautyFDmin->SetBinContent(j,-0.05);
8655
8656   //   if(-0.4<x&&x<-0.2){
8657 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8658 //     }
8659 //     else if(-0.2<x&&x<-0.1){
8660 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8661 //     }
8662 //     else if(-0.2<x&&x<-0.1){
8663 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8664 //     }
8665 //     else if(-0.1<x&&x<0.1){
8666 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8667 //     }
8668 //     else if(0.1<x&&x<0.2){
8669 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8670 //     }
8671 //     if(0.2<x&&x<0.4){
8672 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8673 //     }
8674   }
8675
8676   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8677   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8678     x=fhBeautyFDmax->GetBinLowEdge(j);
8679     fhBeautyFDmax->SetBinContent(j,0.03);
8680
8681 //     if(-0.4<x&&x<-0.2){
8682 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8683 //     }
8684 //     else if(-0.2<x&&x<-0.1){
8685 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8686 //     }
8687 //     else if(-0.2<x&&x<-0.1){
8688 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8689 //     }
8690 //     else if(-0.1<x&&x<0.1){
8691 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8692 //     }
8693 //     else if(0.1<x&&x<0.2){
8694 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8695 //     }
8696 //     if(0.2<x&&x<0.4){
8697 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8698 //     }
8699
8700   }
8701
8702 }
8703
8704
8705 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05(){
8706   Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8707   fmeson=2;
8708   fstrmeson="Dplus";
8709   fstrptAss="ptAsMore05";
8710   fstrptD="Dpt8to16";
8711   if(!fhDeltaPhiTemplate){
8712     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8713   }
8714
8715   Double_t x;
8716   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8717   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8718   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8719     fhYieldExtraction->SetBinContent(j,0.1);
8720   }
8721
8722   // Background D MESON candidate subtraction (side-band variations, etc.)
8723   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8724   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8725     fhBackSubtractionMin->SetBinContent(j,-0.1);
8726   }
8727
8728   // Background D MESON candidate subtraction (side-band variations, etc.)
8729   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8730   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8731     fhBackSubtractionMax->SetBinContent(j,0.1);
8732   }
8733
8734   // MC CORRECTIONS,  -5% 10% for assoc track eff
8735   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8736   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8737     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8738   }
8739
8740   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8741   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8742     fhMCcorrectionsMax->SetBinContent(j,0.04);
8743   }
8744
8745
8746   // MC D EFF CORRECTION
8747   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8748   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8749     fhMCDefficiencyMin->SetBinContent(j,-0.1);
8750   }
8751
8752   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8753   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8754     fhMCDefficiencyMax->SetBinContent(j,0.1);
8755   }
8756
8757
8758   // Contamination from secondary tracks
8759   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8760   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8761     fhSecContaminationMin->SetBinContent(j,-0.035);
8762   }
8763
8764   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8765   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8766     fhSecContaminationMax->SetBinContent(j,0.035);
8767   }
8768
8769   // MC CLOSURETEST (D meson efficiency)
8770   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8771   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8772     x=fhMCclosureTestMin->GetBinLowEdge(j);
8773     fhMCclosureTestMin->SetBinContent(j,-0.0);
8774
8775     if(-0.4<x&&x<-0.2){
8776       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8777     }
8778     else if(-0.2<x&&x<-0.1){
8779       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8780     }
8781     else if(-0.1<x&&x<0.1){
8782       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8783     }
8784     else if(0.1<x&&x<0.2){
8785       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8786     }
8787     if(0.2<x&&x<0.4){
8788       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8789     }
8790   }
8791
8792   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8793   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8794     x=fhMCclosureTestMax->GetBinLowEdge(j);
8795     fhMCclosureTestMax->SetBinContent(j,0.06);
8796
8797     //     if(-0.4<x&&x<-0.2){
8798     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8799     //     }
8800     //     else if(-0.2<x&&x<-0.1){
8801     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8802     //     }
8803     //     else if(-0.2<x&&x<-0.1){
8804     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8805     //     }
8806     //     else if(-0.1<x&&x<0.1){
8807     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8808     //     }
8809     //     else if(0.1<x&&x<0.2){
8810     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8811     //     }
8812     //     if(0.2<x&&x<0.4){
8813     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8814     //     }
8815
8816   }
8817
8818   // Feed-down
8819
8820   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8821   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8822     x=fhBeautyFDmin->GetBinLowEdge(j);
8823     fhBeautyFDmin->SetBinContent(j,-0.05);
8824
8825   //   if(-0.4<x&&x<-0.2){
8826 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8827 //     }
8828 //     else if(-0.2<x&&x<-0.1){
8829 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8830 //     }
8831 //     else if(-0.2<x&&x<-0.1){
8832 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8833 //     }
8834 //     else if(-0.1<x&&x<0.1){
8835 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8836 //     }
8837 //     else if(0.1<x&&x<0.2){
8838 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8839 //     }
8840 //     if(0.2<x&&x<0.4){
8841 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8842 //     }
8843   }
8844
8845   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8846   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8847     x=fhBeautyFDmax->GetBinLowEdge(j);
8848     fhBeautyFDmax->SetBinContent(j,0.03);
8849
8850 //     if(-0.4<x&&x<-0.2){
8851 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8852 //     }
8853 //     else if(-0.2<x&&x<-0.1){
8854 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8855 //     }
8856 //     else if(-0.2<x&&x<-0.1){
8857 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8858 //     }
8859 //     else if(-0.1<x&&x<0.1){
8860 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8861 //     }
8862 //     else if(0.1<x&&x<0.2){
8863 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8864 //     }
8865 //     if(0.2<x&&x<0.4){
8866 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8867 //     }
8868
8869   }
8870
8871 }
8872
8873
8874
8875 // pt(assoc)> 1 GeV/c
8876 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
8877   Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
8878   fmeson=0;
8879   fstrmeson="Dzero";
8880   fstrptAss="ptAsMore1";
8881   fstrptD="Dpt3to5";
8882   if(!fhDeltaPhiTemplate){
8883     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8884   }
8885   Double_t x;
8886   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8887   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8888   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8889     fhYieldExtraction->SetBinContent(j,0.1);
8890   }
8891
8892   // Background D MESON candidate subtraction (side-band variations, etc.)
8893   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8894   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8895     fhBackSubtractionMin->SetBinContent(j,-0.05);
8896   }
8897
8898   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8899   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8900     fhBackSubtractionMax->SetBinContent(j,0.05);
8901   }
8902
8903
8904   // MC CORRECTIONS ( associatate track efficiency):
8905   //  -5%  +10% for assoc track eff
8906   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8907   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8908     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8909   }
8910
8911   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8912   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8913     fhMCcorrectionsMax->SetBinContent(j,0.04);
8914   }
8915
8916   // MC D EFF CORRECTION
8917   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8918   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8919     fhMCDefficiencyMin->SetBinContent(j,-0.05);
8920   }
8921
8922   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8923   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8924     fhMCDefficiencyMax->SetBinContent(j,0.05);
8925   }
8926
8927
8928   // Contamination from secondary tracks
8929   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8930   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8931     fhSecContaminationMin->SetBinContent(j,-0.035);
8932   }
8933
8934   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8935   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8936     fhSecContaminationMax->SetBinContent(j,0.035);
8937   }
8938
8939
8940   // MC CLOSURETEST (D meson efficiency)
8941   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8942   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8943     x=fhMCclosureTestMin->GetBinLowEdge(j);
8944     fhMCclosureTestMin->SetBinContent(j,-0.);
8945
8946     if(-0.4<x&&x<-0.2){
8947       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8948     }
8949     else if(-0.2<x&&x<-0.1){
8950       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8951     }
8952     else if(-0.1<x&&x<0.1){
8953       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8954     }
8955     else if(0.1<x&&x<0.2){
8956       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8957     }
8958     if(0.2<x&&x<0.4){
8959       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8960     }
8961   }
8962
8963   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8964   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8965     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
8966     fhMCclosureTestMax->SetBinContent(j,0.05);
8967
8968     //     if(-0.4<x&&x<-0.2){
8969     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8970     //     }
8971     //     else if(-0.2<x&&x<-0.1){
8972     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8973     //     }
8974     //     else if(-0.2<x&&x<-0.1){
8975     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8976     //     }
8977     //     else if(-0.1<x&&x<0.1){
8978     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8979     //     }
8980     //     else if(0.1<x&&x<0.2){
8981     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8982     //     }
8983     //     if(0.2<x&&x<0.4){
8984     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8985     //     }
8986
8987   }
8988
8989   // Feed-down
8990
8991   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8992   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8993     x=fhBeautyFDmin->GetBinLowEdge(j);
8994     fhBeautyFDmin->SetBinContent(j,-0.05);
8995
8996   //   if(-0.4<x&&x<-0.2){
8997 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8998 //     }
8999 //     else if(-0.2<x&&x<-0.1){
9000 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9001 //     }
9002 //     else if(-0.2<x&&x<-0.1){
9003 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9004 //     }
9005 //     else if(-0.1<x&&x<0.1){
9006 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9007 //     }
9008 //     else if(0.1<x&&x<0.2){
9009 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9010 //     }
9011 //     if(0.2<x&&x<0.4){
9012 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9013 //     }
9014   }
9015
9016   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9017   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9018     x=fhBeautyFDmax->GetBinLowEdge(j);
9019     fhBeautyFDmax->SetBinContent(j,0.03);
9020
9021 //     if(-0.4<x&&x<-0.2){
9022 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9023 //     }
9024 //     else if(-0.2<x&&x<-0.1){
9025 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9026 //     }
9027 //     else if(-0.2<x&&x<-0.1){
9028 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9029 //     }
9030 //     else if(-0.1<x&&x<0.1){
9031 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9032 //     }
9033 //     else if(0.1<x&&x<0.2){
9034 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9035 //     }
9036 //     if(0.2<x&&x<0.4){
9037 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9038 //     }
9039
9040   }
9041
9042 }
9043
9044 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
9045   Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
9046   fmeson=0;
9047   fstrmeson="Dzero";
9048   fstrptAss="ptAsMore1";
9049   fstrptD="Dpt5to8";
9050   if(!fhDeltaPhiTemplate){
9051     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9052   }
9053   Double_t x;
9054   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9055   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9056   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9057     fhYieldExtraction->SetBinContent(j,0.1);
9058   }
9059
9060   // Background D MESON candidate subtraction (side-band variations, etc.)
9061   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9062   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9063     fhBackSubtractionMin->SetBinContent(j,-0.05);
9064   }
9065
9066   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9067   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9068     fhBackSubtractionMax->SetBinContent(j,0.05);
9069   }
9070
9071   // MC CORRECTIONS:  -5%  +10% for assoc track eff
9072   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9073   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9074     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9075   }
9076
9077   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9078   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9079     fhMCcorrectionsMax->SetBinContent(j,0.04);
9080   }
9081
9082
9083   // MC D EFF CORRECTION
9084   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9085   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9086     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9087   }
9088
9089   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9090   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9091     fhMCDefficiencyMax->SetBinContent(j,0.05);
9092   }
9093
9094
9095   // Contamination from secondary tracks
9096   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9097   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9098     fhSecContaminationMin->SetBinContent(j,-0.035);
9099   }
9100
9101   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9102   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9103     fhSecContaminationMax->SetBinContent(j,0.035);
9104   }
9105
9106   // MC CLOSURETEST (D meson efficiency)
9107   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9108   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9109     x=fhMCclosureTestMin->GetBinLowEdge(j);
9110     fhMCclosureTestMin->SetBinContent(j,-0.);
9111
9112     if(-0.4<x&&x<-0.2){
9113       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9114     }
9115     else if(-0.2<x&&x<-0.1){
9116       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9117     }
9118     else if(-0.1<x&&x<0.1){
9119       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9120     }
9121     else if(0.1<x&&x<0.2){
9122       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9123     }
9124     if(0.2<x&&x<0.4){
9125       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9126     }
9127   }
9128
9129   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9130   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9131     x=fhMCclosureTestMax->GetBinLowEdge(j);
9132     fhMCclosureTestMax->SetBinContent(j,0.05);
9133
9134     //     if(-0.4<x&&x<-0.2){
9135     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9136     //     }
9137     //     else if(-0.2<x&&x<-0.1){
9138     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9139     //     }
9140     //     else if(-0.2<x&&x<-0.1){
9141     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9142     //     }
9143     //     else if(-0.1<x&&x<0.1){
9144     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9145     //     }
9146     //     else if(0.1<x&&x<0.2){
9147     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9148     //     }
9149     //     if(0.2<x&&x<0.4){
9150     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9151     //     }
9152
9153   }
9154
9155   // Feed-down
9156
9157   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9158   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9159     x=fhBeautyFDmin->GetBinLowEdge(j);
9160     fhBeautyFDmin->SetBinContent(j,-0.05);
9161
9162   //   if(-0.4<x&&x<-0.2){
9163 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9164 //     }
9165 //     else if(-0.2<x&&x<-0.1){
9166 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9167 //     }
9168 //     else if(-0.2<x&&x<-0.1){
9169 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9170 //     }
9171 //     else if(-0.1<x&&x<0.1){
9172 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9173 //     }
9174 //     else if(0.1<x&&x<0.2){
9175 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9176 //     }
9177 //     if(0.2<x&&x<0.4){
9178 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9179 //     }
9180   }
9181
9182   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9183   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9184     x=fhBeautyFDmax->GetBinLowEdge(j);
9185     fhBeautyFDmax->SetBinContent(j,0.03);
9186
9187 //     if(-0.4<x&&x<-0.2){
9188 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9189 //     }
9190 //     else if(-0.2<x&&x<-0.1){
9191 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9192 //     }
9193 //     else if(-0.2<x&&x<-0.1){
9194 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9195 //     }
9196 //     else if(-0.1<x&&x<0.1){
9197 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9198 //     }
9199 //     else if(0.1<x&&x<0.2){
9200 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9201 //     }
9202 //     if(0.2<x&&x<0.4){
9203 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9204 //     }
9205
9206   }
9207
9208 }
9209
9210
9211 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
9212   Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
9213   fmeson=0;
9214   fstrmeson="Dzero";
9215   fstrptAss="ptAsMore1";
9216   fstrptD="Dpt8to16";
9217   if(!fhDeltaPhiTemplate){
9218     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9219   }
9220
9221   Double_t x;
9222   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9223   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9224   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9225     fhYieldExtraction->SetBinContent(j,0.1);
9226   }
9227
9228   // Background D MESON candidate subtraction (side-band variations, etc.)
9229   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9230   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9231     fhBackSubtractionMin->SetBinContent(j,-0.05);
9232   }
9233
9234   // Background D MESON candidate subtraction (side-band variations, etc.)
9235   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9236   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9237     fhBackSubtractionMax->SetBinContent(j,0.05);
9238   }
9239
9240   // MC CORRECTIONS,  -5% 10% for assoc track eff
9241   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9242   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9243     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9244   }
9245
9246   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9247   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9248     fhMCcorrectionsMax->SetBinContent(j,0.04);
9249   }
9250
9251
9252   // MC D EFF CORRECTION
9253   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9254   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9255     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9256   }
9257
9258   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9259   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9260     fhMCDefficiencyMax->SetBinContent(j,0.05);
9261   }
9262
9263
9264   // Contamination from secondary tracks
9265   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9266   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9267     fhSecContaminationMin->SetBinContent(j,-0.035);
9268   }
9269
9270   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9271   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9272     fhSecContaminationMax->SetBinContent(j,0.035);
9273   }
9274
9275   // MC CLOSURETEST (D meson efficiency)
9276   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9277   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9278     x=fhMCclosureTestMin->GetBinLowEdge(j);
9279     fhMCclosureTestMin->SetBinContent(j,-0.);
9280
9281     if(-0.4<x&&x<-0.2){
9282       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9283     }
9284     else if(-0.2<x&&x<-0.1){
9285       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9286     }
9287     else if(-0.1<x&&x<0.1){
9288       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9289     }
9290     else if(0.1<x&&x<0.2){
9291       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9292     }
9293     if(0.2<x&&x<0.4){
9294       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9295     }
9296   }
9297
9298   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9299   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9300     x=fhMCclosureTestMax->GetBinLowEdge(j);
9301     fhMCclosureTestMax->SetBinContent(j,0.05);
9302
9303     //     if(-0.4<x&&x<-0.2){
9304     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9305     //     }
9306     //     else if(-0.2<x&&x<-0.1){
9307     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9308     //     }
9309     //     else if(-0.2<x&&x<-0.1){
9310     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9311     //     }
9312     //     else if(-0.1<x&&x<0.1){
9313     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9314     //     }
9315     //     else if(0.1<x&&x<0.2){
9316     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9317     //     }
9318     //     if(0.2<x&&x<0.4){
9319     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9320     //     }
9321
9322   }
9323
9324   // Feed-down
9325
9326   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9327   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9328     x=fhBeautyFDmin->GetBinLowEdge(j);
9329     fhBeautyFDmin->SetBinContent(j,-0.05);
9330
9331   //   if(-0.4<x&&x<-0.2){
9332 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9333 //     }
9334 //     else if(-0.2<x&&x<-0.1){
9335 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9336 //     }
9337 //     else if(-0.2<x&&x<-0.1){
9338 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9339 //     }
9340 //     else if(-0.1<x&&x<0.1){
9341 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9342 //     }
9343 //     else if(0.1<x&&x<0.2){
9344 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9345 //     }
9346 //     if(0.2<x&&x<0.4){
9347 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9348 //     }
9349   }
9350
9351   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9352   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9353     x=fhBeautyFDmax->GetBinLowEdge(j);
9354     fhBeautyFDmax->SetBinContent(j,0.03);
9355
9356 //     if(-0.4<x&&x<-0.2){
9357 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9358 //     }
9359 //     else if(-0.2<x&&x<-0.1){
9360 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9361 //     }
9362 //     else if(-0.2<x&&x<-0.1){
9363 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9364 //     }
9365 //     else if(-0.1<x&&x<0.1){
9366 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9367 //     }
9368 //     else if(0.1<x&&x<0.2){
9369 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9370 //     }
9371 //     if(0.2<x&&x<0.4){
9372 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9373 //     }
9374
9375   }
9376
9377 }
9378
9379
9380
9381
9382 //--------------------------------------------------
9383 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
9384  Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9385   fmeson=1;
9386   fstrmeson="Dstar";
9387   fstrptAss="ptAsMore1";
9388   fstrptD="Dpt3to5";
9389   if(!fhDeltaPhiTemplate){
9390     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9391   }
9392   Double_t x;
9393   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9394   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9395   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9396     fhYieldExtraction->SetBinContent(j,0.1);
9397   }
9398
9399   // Background D MESON candidate subtraction (side-band variations, etc.)
9400   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9401   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9402     fhBackSubtractionMin->SetBinContent(j,-0.08);
9403   }
9404
9405   // Background D MESON candidate subtraction (side-band variations, etc.)
9406   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9407   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9408     fhBackSubtractionMax->SetBinContent(j,0.08);
9409   }
9410
9411   // MC CORRECTIONS, -5%  10% for assoc track eff
9412   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9413   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9414     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9415   }
9416
9417   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9418   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9419     fhMCcorrectionsMax->SetBinContent(j,0.04);
9420   }
9421
9422
9423   // MC D EFF CORRECTION
9424   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9425   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9426     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9427   }
9428
9429   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9430   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9431     fhMCDefficiencyMax->SetBinContent(j,0.05);
9432   }
9433
9434
9435   // Contamination from secondary tracks
9436   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9437   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9438     fhSecContaminationMin->SetBinContent(j,-0.035);
9439   }
9440
9441   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9442   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9443     fhSecContaminationMax->SetBinContent(j,0.035);
9444   }
9445
9446   // MC CLOSURETEST (D meson efficiency)
9447   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9448   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9449     x=fhMCclosureTestMin->GetBinLowEdge(j);
9450     fhMCclosureTestMin->SetBinContent(j,-0.0);
9451
9452     if(-0.4<x&&x<-0.2){
9453       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9454     }
9455     else if(-0.2<x&&x<-0.1){
9456       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9457     }
9458     else if(-0.1<x&&x<0.1){
9459       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9460     }
9461     else if(0.1<x&&x<0.2){
9462       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9463     }
9464     if(0.2<x&&x<0.4){
9465       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9466     }
9467   }
9468
9469   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9470   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9471     x=fhMCclosureTestMax->GetBinLowEdge(j);
9472     fhMCclosureTestMax->SetBinContent(j,0.05);
9473
9474     //     if(-0.4<x&&x<-0.2){
9475     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9476     //     }
9477     //     else if(-0.2<x&&x<-0.1){
9478     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9479     //     }
9480     //     else if(-0.2<x&&x<-0.1){
9481     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9482     //     }
9483     //     else if(-0.1<x&&x<0.1){
9484     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9485     //     }
9486     //     else if(0.1<x&&x<0.2){
9487     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9488     //     }
9489     //     if(0.2<x&&x<0.4){
9490     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9491     //     }
9492
9493   }
9494
9495   // Feed-down
9496
9497   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9498   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9499     x=fhBeautyFDmin->GetBinLowEdge(j);
9500     fhBeautyFDmin->SetBinContent(j,-0.05);
9501
9502   //   if(-0.4<x&&x<-0.2){
9503 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9504 //     }
9505 //     else if(-0.2<x&&x<-0.1){
9506 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9507 //     }
9508 //     else if(-0.2<x&&x<-0.1){
9509 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9510 //     }
9511 //     else if(-0.1<x&&x<0.1){
9512 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9513 //     }
9514 //     else if(0.1<x&&x<0.2){
9515 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9516 //     }
9517 //     if(0.2<x&&x<0.4){
9518 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9519 //     }
9520   }
9521
9522   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9523   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9524     x=fhBeautyFDmax->GetBinLowEdge(j);
9525     fhBeautyFDmax->SetBinContent(j,0.03);
9526
9527 //     if(-0.4<x&&x<-0.2){
9528 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9529 //     }
9530 //     else if(-0.2<x&&x<-0.1){
9531 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9532 //     }
9533 //     else if(-0.2<x&&x<-0.1){
9534 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9535 //     }
9536 //     else if(-0.1<x&&x<0.1){
9537 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9538 //     }
9539 //     else if(0.1<x&&x<0.2){
9540 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9541 //     }
9542 //     if(0.2<x&&x<0.4){
9543 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9544 //     }
9545
9546   }
9547
9548
9549 }
9550
9551 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
9552  Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
9553   fmeson=1;
9554   fstrmeson="Dstar";
9555   fstrptAss="ptAsMore1";
9556   fstrptD="Dpt5to8";
9557   if(!fhDeltaPhiTemplate){
9558     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9559   }
9560   Double_t x;
9561   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9562   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9563   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9564     fhYieldExtraction->SetBinContent(j,0.1);
9565   }
9566
9567   // Background D MESON candidate subtraction (side-band variations, etc.)
9568   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9569   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9570     fhBackSubtractionMin->SetBinContent(j,-0.06);
9571   }
9572
9573   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9574   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9575     fhBackSubtractionMax->SetBinContent(j,0.06);
9576   }
9577
9578   // MC CORRECTIONS/ -5%  10% for assoc track eff
9579   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9580   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9581     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9582   }
9583
9584   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9585   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9586     fhMCcorrectionsMax->SetBinContent(j,0.04);
9587   }
9588
9589   // MC D EFF CORRECTION
9590   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9591   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9592     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9593   }
9594
9595   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9596   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9597     fhMCDefficiencyMax->SetBinContent(j,0.05);
9598   }
9599
9600
9601   // Contamination from secondary tracks
9602   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9603   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9604     fhSecContaminationMin->SetBinContent(j,-0.035);
9605   }
9606
9607   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9608   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9609     fhSecContaminationMax->SetBinContent(j,0.035);
9610   }
9611
9612   // MC CLOSURETEST (D meson efficiency)
9613   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9614   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9615     x=fhMCclosureTestMin->GetBinLowEdge(j);
9616     fhMCclosureTestMin->SetBinContent(j,-0.);
9617
9618     if(-0.4<x&&x<-0.2){
9619       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9620     }
9621     else if(-0.2<x&&x<-0.1){
9622       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9623     }
9624     else if(-0.1<x&&x<0.1){
9625       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9626     }
9627     else if(0.1<x&&x<0.2){
9628       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9629     }
9630     if(0.2<x&&x<0.4){
9631       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9632     }
9633   }
9634
9635   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9636   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9637     x=fhMCclosureTestMax->GetBinLowEdge(j);
9638     fhMCclosureTestMax->SetBinContent(j,0.05);
9639
9640     //     if(-0.4<x&&x<-0.2){
9641     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9642     //     }
9643     //     else if(-0.2<x&&x<-0.1){
9644     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9645     //     }
9646     //     else if(-0.2<x&&x<-0.1){
9647     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9648     //     }
9649     //     else if(-0.1<x&&x<0.1){
9650     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9651     //     }
9652     //     else if(0.1<x&&x<0.2){
9653     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9654     //     }
9655     //     if(0.2<x&&x<0.4){
9656     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9657     //     }
9658
9659   }
9660
9661   // Feed-down
9662
9663   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9664   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9665     x=fhBeautyFDmin->GetBinLowEdge(j);
9666     fhBeautyFDmin->SetBinContent(j,-0.05);
9667
9668   //   if(-0.4<x&&x<-0.2){
9669 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9670 //     }
9671 //     else if(-0.2<x&&x<-0.1){
9672 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9673 //     }
9674 //     else if(-0.2<x&&x<-0.1){
9675 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9676 //     }
9677 //     else if(-0.1<x&&x<0.1){
9678 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9679 //     }
9680 //     else if(0.1<x&&x<0.2){
9681 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9682 //     }
9683 //     if(0.2<x&&x<0.4){
9684 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9685 //     }
9686   }
9687
9688   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9689   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9690     x=fhBeautyFDmax->GetBinLowEdge(j);
9691     fhBeautyFDmax->SetBinContent(j,0.03);
9692
9693 //     if(-0.4<x&&x<-0.2){
9694 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9695 //     }
9696 //     else if(-0.2<x&&x<-0.1){
9697 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9698 //     }
9699 //     else if(-0.2<x&&x<-0.1){
9700 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9701 //     }
9702 //     else if(-0.1<x&&x<0.1){
9703 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9704 //     }
9705 //     else if(0.1<x&&x<0.2){
9706 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9707 //     }
9708 //     if(0.2<x&&x<0.4){
9709 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9710 //     }
9711
9712   }
9713
9714 }
9715
9716
9717
9718 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
9719   Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
9720   fmeson=1;
9721   fstrmeson="Dstar";
9722   fstrptAss="ptAsMore1";
9723   fstrptD="Dpt8to16";
9724   if(!fhDeltaPhiTemplate){
9725     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9726   }
9727   Double_t x;
9728   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9729   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9730   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9731     fhYieldExtraction->SetBinContent(j,0.1);
9732   }
9733
9734   // Background D MESON candidate subtraction (side-band variations, etc.)
9735   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9736   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9737     fhBackSubtractionMin->SetBinContent(j,-0.05);
9738   }
9739
9740   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9741   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9742     fhBackSubtractionMax->SetBinContent(j,0.05);
9743   }
9744
9745   // MC CORRECTIONS   -5% +10% for assoc track eff
9746   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9747   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9748     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9749   }
9750
9751   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9752   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9753     fhMCcorrectionsMax->SetBinContent(j,0.04);
9754   }
9755   // MC D EFF CORRECTION
9756   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9757   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9758     fhMCDefficiencyMin->SetBinContent(j,-0.08);
9759   }
9760
9761   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9762   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9763     fhMCDefficiencyMax->SetBinContent(j,0.08);
9764   }
9765
9766
9767   // Contamination from secondary tracks
9768   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9769   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9770     fhSecContaminationMin->SetBinContent(j,-0.035);
9771   }
9772
9773   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9774   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9775     fhSecContaminationMax->SetBinContent(j,0.035);
9776   }
9777
9778   // MC CLOSURETEST (D meson efficiency)
9779   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9780   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9781     x=fhMCclosureTestMin->GetBinLowEdge(j);
9782     fhMCclosureTestMin->SetBinContent(j,-0);
9783
9784     if(-0.4<x&&x<-0.2){
9785       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9786     }
9787     else if(-0.2<x&&x<-0.1){
9788       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9789     }
9790     else if(-0.1<x&&x<0.1){
9791       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9792     }
9793     else if(0.1<x&&x<0.2){
9794       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9795     }
9796     if(0.2<x&&x<0.4){
9797       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9798     }
9799   }
9800
9801   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9802   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9803     x=fhMCclosureTestMax->GetBinLowEdge(j);
9804     fhMCclosureTestMax->SetBinContent(j,0.05);
9805
9806     //     if(-0.4<x&&x<-0.2){
9807     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9808     //     }
9809     //     else if(-0.2<x&&x<-0.1){
9810     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9811     //     }
9812     //     else if(-0.2<x&&x<-0.1){
9813     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9814     //     }
9815     //     else if(-0.1<x&&x<0.1){
9816     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9817     //     }
9818     //     else if(0.1<x&&x<0.2){
9819     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9820     //     }
9821     //     if(0.2<x&&x<0.4){
9822     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9823     //     }
9824
9825   }
9826
9827   // Feed-down
9828
9829   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9830   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9831     x=fhBeautyFDmin->GetBinLowEdge(j);
9832     fhBeautyFDmin->SetBinContent(j,-0.05);
9833
9834   //   if(-0.4<x&&x<-0.2){
9835 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9836 //     }
9837 //     else if(-0.2<x&&x<-0.1){
9838 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9839 //     }
9840 //     else if(-0.2<x&&x<-0.1){
9841 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9842 //     }
9843 //     else if(-0.1<x&&x<0.1){
9844 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9845 //     }
9846 //     else if(0.1<x&&x<0.2){
9847 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9848 //     }
9849 //     if(0.2<x&&x<0.4){
9850 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9851 //     }
9852   }
9853
9854   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9855   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9856     x=fhBeautyFDmax->GetBinLowEdge(j);
9857     fhBeautyFDmax->SetBinContent(j,0.03);
9858
9859 //     if(-0.4<x&&x<-0.2){
9860 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9861 //     }
9862 //     else if(-0.2<x&&x<-0.1){
9863 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9864 //     }
9865 //     else if(-0.2<x&&x<-0.1){
9866 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9867 //     }
9868 //     else if(-0.1<x&&x<0.1){
9869 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9870 //     }
9871 //     else if(0.1<x&&x<0.2){
9872 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9873 //     }
9874 //     if(0.2<x&&x<0.4){
9875 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9876 //     }
9877
9878   }
9879
9880
9881 }
9882
9883
9884
9885 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
9886   Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9887   fmeson=2;
9888   fstrmeson="Dplus";
9889   fstrptAss="ptAsMore1";
9890   fstrptD="Dpt3to5";
9891   if(!fhDeltaPhiTemplate){
9892     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9893   }
9894   Double_t x;
9895   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9896   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9897   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9898     fhYieldExtraction->SetBinContent(j,0.1);
9899   }
9900
9901   // Background D MESON candidate subtraction (side-band variations, etc.)
9902   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9903   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9904     fhBackSubtractionMin->SetBinContent(j,-0.1);
9905   }
9906
9907   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9908   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9909     fhBackSubtractionMax->SetBinContent(j,0.1);
9910   }
9911
9912
9913   // MC CORRECTIONS ( associatate track efficiency):
9914   //  -5%  +10% for assoc track eff
9915   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9916   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9917     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9918   }
9919
9920   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9921   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9922     fhMCcorrectionsMax->SetBinContent(j,0.04);
9923   }
9924
9925   // MC D EFF CORRECTION
9926   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9927   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9928     fhMCDefficiencyMin->SetBinContent(j,-0.1);
9929   }
9930
9931   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9932   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9933     fhMCDefficiencyMax->SetBinContent(j,0.1);
9934   }
9935
9936
9937   // Contamination from secondary tracks
9938   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9939   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9940     fhSecContaminationMin->SetBinContent(j,-0.035);
9941   }
9942
9943   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9944   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9945     fhSecContaminationMax->SetBinContent(j,0.035);
9946   }
9947
9948
9949   // MC CLOSURETEST (D meson efficiency)
9950   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9951   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9952     x=fhMCclosureTestMin->GetBinLowEdge(j);
9953     fhMCclosureTestMin->SetBinContent(j,-0.0);
9954
9955     if(-0.4<x&&x<-0.2){
9956       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9957     }
9958     else if(-0.2<x&&x<-0.1){
9959       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9960     }
9961     else if(-0.1<x&&x<0.1){
9962       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9963     }
9964     else if(0.1<x&&x<0.2){
9965       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9966     }
9967     if(0.2<x&&x<0.4){
9968       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9969     }
9970   }
9971
9972   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9973   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9974     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
9975     fhMCclosureTestMax->SetBinContent(j,0.05);
9976
9977     //     if(-0.4<x&&x<-0.2){
9978     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9979     //     }
9980     //     else if(-0.2<x&&x<-0.1){
9981     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9982     //     }
9983     //     else if(-0.2<x&&x<-0.1){
9984     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9985     //     }
9986     //     else if(-0.1<x&&x<0.1){
9987     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9988     //     }
9989     //     else if(0.1<x&&x<0.2){
9990     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9991     //     }
9992     //     if(0.2<x&&x<0.4){
9993     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9994     //     }
9995
9996   }
9997
9998   // Feed-down
9999
10000   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10001   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10002     x=fhBeautyFDmin->GetBinLowEdge(j);
10003     fhBeautyFDmin->SetBinContent(j,-0.05);
10004
10005   //   if(-0.4<x&&x<-0.2){
10006 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10007 //     }
10008 //     else if(-0.2<x&&x<-0.1){
10009 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10010 //     }
10011 //     else if(-0.2<x&&x<-0.1){
10012 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10013 //     }
10014 //     else if(-0.1<x&&x<0.1){
10015 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10016 //     }
10017 //     else if(0.1<x&&x<0.2){
10018 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10019 //     }
10020 //     if(0.2<x&&x<0.4){
10021 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10022 //     }
10023   }
10024
10025   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10026   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10027     x=fhBeautyFDmax->GetBinLowEdge(j);
10028     fhBeautyFDmax->SetBinContent(j,0.03);
10029
10030 //     if(-0.4<x&&x<-0.2){
10031 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10032 //     }
10033 //     else if(-0.2<x&&x<-0.1){
10034 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10035 //     }
10036 //     else if(-0.2<x&&x<-0.1){
10037 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10038 //     }
10039 //     else if(-0.1<x&&x<0.1){
10040 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10041 //     }
10042 //     else if(0.1<x&&x<0.2){
10043 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10044 //     }
10045 //     if(0.2<x&&x<0.4){
10046 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10047 //     }
10048
10049   }
10050
10051 }
10052
10053 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
10054   Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
10055   fmeson=2;
10056   fstrmeson="Dplus";
10057   fstrptAss="ptAsMore1";
10058   fstrptD="Dpt5to8";
10059   if(!fhDeltaPhiTemplate){
10060     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
10061   }
10062   Double_t x;
10063   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
10064   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
10065   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
10066     fhYieldExtraction->SetBinContent(j,0.1);
10067   }
10068
10069   // Background D MESON candidate subtraction (side-band variations, etc.)
10070   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
10071   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
10072     fhBackSubtractionMin->SetBinContent(j,-0.1);
10073   }
10074
10075   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10076   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
10077     fhBackSubtractionMax->SetBinContent(j,0.1);
10078   }
10079
10080   // MC CORRECTIONS:  -5%  +10% for assoc track eff
10081   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
10082   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
10083     fhMCcorrectionsMin->SetBinContent(j,-0.04);
10084   }
10085
10086   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10087   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
10088     fhMCcorrectionsMax->SetBinContent(j,0.04);
10089   }
10090
10091
10092   // MC D EFF CORRECTION
10093   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10094   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
10095     fhMCDefficiencyMin->SetBinContent(j,-0.1);
10096   }
10097
10098   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10099   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
10100     fhMCDefficiencyMax->SetBinContent(j,0.1);
10101   }
10102
10103
10104   // Contamination from secondary tracks
10105   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10106   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
10107     fhSecContaminationMin->SetBinContent(j,-0.035);
10108   }
10109
10110   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10111   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
10112     fhSecContaminationMax->SetBinContent(j,0.035);
10113   }
10114
10115   // MC CLOSURETEST (D meson efficiency)
10116   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
10117   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
10118     x=fhMCclosureTestMin->GetBinLowEdge(j);
10119     fhMCclosureTestMin->SetBinContent(j,-0.0);
10120
10121     if(-0.4<x&&x<-0.2){
10122       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10123     }
10124     else if(-0.2<x&&x<-0.1){
10125       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10126     }
10127     else if(-0.1<x&&x<0.1){
10128       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10129     }
10130     else if(0.1<x&&x<0.2){
10131       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10132     }
10133     if(0.2<x&&x<0.4){
10134       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10135     }
10136   }
10137
10138   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10139   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10140     x=fhMCclosureTestMax->GetBinLowEdge(j);
10141     fhMCclosureTestMax->SetBinContent(j,0.05);
10142
10143     //     if(-0.4<x&&x<-0.2){
10144     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10145     //     }
10146     //     else if(-0.2<x&&x<-0.1){
10147     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10148     //     }
10149     //     else if(-0.2<x&&x<-0.1){
10150     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10151     //     }
10152     //     else if(-0.1<x&&x<0.1){
10153     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10154     //     }
10155     //     else if(0.1<x&&x<0.2){
10156     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10157     //     }
10158     //     if(0.2<x&&x<0.4){
10159     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10160     //     }
10161
10162   }
10163
10164   // Feed-down
10165
10166   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10167   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10168     x=fhBeautyFDmin->GetBinLowEdge(j);
10169     fhBeautyFDmin->SetBinContent(j,-0.05);
10170
10171   //   if(-0.4<x&&x<-0.2){
10172 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10173 //     }
10174 //     else if(-0.2<x&&x<-0.1){
10175 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10176 //     }
10177 //     else if(-0.2<x&&x<-0.1){
10178 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10179 //     }
10180 //     else if(-0.1<x&&x<0.1){
10181 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10182 //     }
10183 //     else if(0.1<x&&x<0.2){
10184 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10185 //     }
10186 //     if(0.2<x&&x<0.4){
10187 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10188 //     }
10189   }
10190
10191   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10192   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10193     x=fhBeautyFDmax->GetBinLowEdge(j);
10194     fhBeautyFDmax->SetBinContent(j,0.03);
10195
10196 //     if(-0.4<x&&x<-0.2){
10197 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10198 //     }
10199 //     else if(-0.2<x&&x<-0.1){
10200 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10201 //     }
10202 //     else if(-0.2<x&&x<-0.1){
10203 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10204 //     }
10205 //     else if(-0.1<x&&x<0.1){
10206 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10207 //     }
10208 //     else if(0.1<x&&x<0.2){
10209 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10210 //     }
10211 //     if(0.2<x&&x<0.4){
10212 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10213 //     }
10214
10215   }
10216
10217 }
10218
10219
10220 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){
10221   Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
10222   fmeson=2;
10223   fstrmeson="Dplus";
10224   fstrptAss="ptAsMore1";
10225   fstrptD="Dpt8to16";
10226   if(!fhDeltaPhiTemplate){
10227     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
10228   }
10229
10230   Double_t x;
10231   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
10232   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
10233   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
10234     fhYieldExtraction->SetBinContent(j,0.1);
10235   }
10236
10237   // Background D MESON candidate subtraction (side-band variations, etc.)
10238   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
10239   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
10240     fhBackSubtractionMin->SetBinContent(j,-0.1);
10241   }
10242
10243   // Background D MESON candidate subtraction (side-band variations, etc.)
10244   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10245   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
10246     fhBackSubtractionMax->SetBinContent(j,0.1);
10247   }
10248
10249   // MC CORRECTIONS,  -5% 10% for assoc track eff
10250   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
10251   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
10252     fhMCcorrectionsMin->SetBinContent(j,-0.04);
10253   }
10254
10255   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10256   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
10257     fhMCcorrectionsMax->SetBinContent(j,0.04);
10258   }
10259
10260
10261   // MC D EFF CORRECTION
10262   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10263   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
10264     fhMCDefficiencyMin->SetBinContent(j,-0.1);
10265   }
10266
10267   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10268   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
10269     fhMCDefficiencyMax->SetBinContent(j,0.1);
10270   }
10271
10272
10273   // Contamination from secondary tracks
10274   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10275   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
10276     fhSecContaminationMin->SetBinContent(j,-0.035);
10277   }
10278
10279   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10280   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
10281     fhSecContaminationMax->SetBinContent(j,0.035);
10282   }
10283
10284   // MC CLOSURETEST (D meson efficiency)
10285   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
10286   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
10287     x=fhMCclosureTestMin->GetBinLowEdge(j);
10288     fhMCclosureTestMin->SetBinContent(j,-0.0);
10289
10290     if(-0.4<x&&x<-0.2){
10291       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10292     }
10293     else if(-0.2<x&&x<-0.1){
10294       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10295     }
10296     else if(-0.1<x&&x<0.1){
10297       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10298     }
10299     else if(0.1<x&&x<0.2){
10300       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10301     }
10302     if(0.2<x&&x<0.4){
10303       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10304     }
10305   }
10306
10307   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10308   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10309     x=fhMCclosureTestMax->GetBinLowEdge(j);
10310     fhMCclosureTestMax->SetBinContent(j,0.05);
10311
10312     //     if(-0.4<x&&x<-0.2){
10313     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10314     //     }
10315     //     else if(-0.2<x&&x<-0.1){
10316     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10317     //     }
10318     //     else if(-0.2<x&&x<-0.1){
10319     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10320     //     }
10321     //     else if(-0.1<x&&x<0.1){
10322     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10323     //     }
10324     //     else if(0.1<x&&x<0.2){
10325     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10326     //     }
10327     //     if(0.2<x&&x<0.4){
10328     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10329     //     }
10330
10331   }
10332
10333   // Feed-down
10334
10335   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10336   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10337     x=fhBeautyFDmin->GetBinLowEdge(j);
10338     fhBeautyFDmin->SetBinContent(j,-0.05);
10339
10340   //   if(-0.4<x&&x<-0.2){
10341 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10342 //     }
10343 //     else if(-0.2<x&&x<-0.1){
10344 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10345 //     }
10346 //     else if(-0.2<x&&x<-0.1){
10347 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10348 //     }
10349 //     else if(-0.1<x&&x<0.1){
10350 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10351 //     }
10352 //     else if(0.1<x&&x<0.2){
10353 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10354 //     }
10355 //     if(0.2<x&&x<0.4){
10356 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10357 //     }
10358   }
10359
10360   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10361   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10362     x=fhBeautyFDmax->GetBinLowEdge(j);
10363     fhBeautyFDmax->SetBinContent(j,0.03);
10364
10365 //     if(-0.4<x&&x<-0.2){
10366 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10367 //     }
10368 //     else if(-0.2<x&&x<-0.1){
10369 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10370 //     }
10371 //     else if(-0.2<x&&x<-0.1){
10372 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10373 //     }
10374 //     else if(-0.1<x&&x<0.1){
10375 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10376 //     }
10377 //     else if(0.1<x&&x<0.2){
10378 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10379 //     }
10380 //     if(0.2<x&&x<0.4){
10381 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10382 //     }
10383
10384   }
10385
10386 }
10387
10388
10389