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 // Responsible of the values set for the different mesons/datasets
  25 //      D0:  in pp (2010 min bias) Fabio Colamaria, fabio.colamaria@ba.infn.it ;  p-Pb (2013 min bias): Fabio Colamaria, fabio.colamaria@ba.infn.it,  Somnath Kar, somnath.kar@cern.ch
  26 //      D*+: in pp 2010 min. bias and p-Pb 2013 min. bias  Sandro Bjelogrlic, sandro.bjelogrlic@cern.ch
  27 //      D+:  in pp 2010 min. bias and p-Pb 2013 min. bias  Jitendra Kumar, jitendra.kumar@cern.ch
  28 //
  29 /////////////////////////////////////////////////////////////
  30 #include <Riostream.h>
  31 #include "AliHFDhadronCorrSystUnc.h"
  32 #include <TMath.h>
  33 #include <TH1D.h>
  34 #include <TH2D.h>
  35 #include <TCanvas.h>
  36 #include <TGraphAsymmErrors.h>
  37 #include <TNamed.h>
  38
  39 using std::cout;
  40 using std::endl;
  41
  42 ClassImp(AliHFDhadronCorrSystUnc)
  43
  44 AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc() : TNamed(),
  45   fmeson(),
  46   fstrmeson(),
  47   fstrptAss(),
  48   fstrptD(),
  49   fhDeltaPhiTemplate(),
  50   fhYieldExtraction(),
  51   fhBackSubtractionMin(),
  52   fhBackSubtractionMax(),
  53   fhBeautyFDmin(),
  54   fhBeautyFDmax(),
  55   fhMCclosureTestMin(),
  56   fhMCclosureTestMax(),
  57   fhMCcorrectionsMin(),
  58   fhMCcorrectionsMax(),
  59   fhMCDefficiencyMin(),
  60   fhMCDefficiencyMax(),
  61   fhSecContaminationMin(),
  62   fhSecContaminationMax(),
  63   fhTotalMin(),
  64   fhTotalMax(),
  65   fhTotalNonFDMin(),
  66   fhTotalNonFDMax(),
  67   fhTotalNonFlatDPhiMin(),
  68   fhTotalNonFlatDPhiMax(),
  69   fhtotFlatMin(),
  70   fhtotFlatMax(),
  71   fgrYieldUnc(),
  72   fgrBackSubUnc(),
  73   fgrMCcorrections(),
  74   fgrMCDefficiency(),
  75   fgrSecContamination(),
  76   fgrMCclosureTest(),
  77   fgrBeautyFD(),
  78   fgrYieldUncRel(),
  79   fgrBackSubUncRel(),
  80   fgrMCcorrectionsRel(),
  81   fgrMCDefficiencyRel(),
  82   fgrSecContaminationRel(),
  83   fgrMCclosureTestRel(),
  84   fgrBeautyFDRel(),
  85   fgrTotal(),
  86   fgrTotalRel(),
  87   fgrTotalNonFD(),
  88   fgrTotalNonFlatDPhi(),
  89   fgrTotalNonFlatDPhiRel(),
  90   fgrTotalFlatDPhi(),
  91   fgrTotalFlatDPhiRel()
  92
  93 {
  94   // default constructor
  95 }
  96
  97
  98 AliHFDhadronCorrSystUnc::AliHFDhadronCorrSystUnc(const char* name) :
  99   TNamed(name,name),
 100   fmeson(),
 101   fstrmeson(),
 102   fstrptAss(),
 103   fstrptD(),
 104   fhDeltaPhiTemplate(),
 105   fhYieldExtraction(),
 106   fhBackSubtractionMin(),
 107   fhBackSubtractionMax(),
 108   fhBeautyFDmin(),
 109   fhBeautyFDmax(),
 110   fhMCclosureTestMin(),
 111   fhMCclosureTestMax(),
 112   fhMCcorrectionsMin(),
 113   fhMCcorrectionsMax(),
 114   fhMCDefficiencyMin(),
 115   fhMCDefficiencyMax(),
 116   fhSecContaminationMin(),
 117   fhSecContaminationMax(),
 118   fhTotalMin(),
 119   fhTotalMax(),
 120   fhTotalNonFDMin(),
 121   fhTotalNonFDMax(),
 122   fhTotalNonFlatDPhiMin(),
 123   fhTotalNonFlatDPhiMax(),
 124   fhtotFlatMin(),
 125   fhtotFlatMax(),
 126   fgrYieldUnc(),
 127   fgrBackSubUnc(),
 128   fgrMCcorrections(),
 129   fgrMCDefficiency(),
 130   fgrSecContamination(),
 131   fgrMCclosureTest(),
 132   fgrBeautyFD(),
 133   fgrYieldUncRel(),
 134   fgrBackSubUncRel(),
 135   fgrMCcorrectionsRel(),
 136   fgrMCDefficiencyRel(),
 137   fgrSecContaminationRel(),
 138   fgrMCclosureTestRel(),
 139   fgrBeautyFDRel(),
 140   fgrTotal(),
 141   fgrTotalRel(),
 142   fgrTotalNonFD(),
 143   fgrTotalNonFlatDPhi(),
 144   fgrTotalNonFlatDPhiRel(),
 145   fgrTotalFlatDPhi(),
 146   fgrTotalFlatDPhiRel()
 147 {
 148   // default constructor
 149 }
 150
 151
 152
 153 AliHFDhadronCorrSystUnc::~AliHFDhadronCorrSystUnc(){
 154   // destructor
 155
 156   delete fhDeltaPhiTemplate;
 157   delete fhYieldExtraction;
 158   delete fhBackSubtractionMin;
 159   delete   fhBackSubtractionMax;
 160   delete  fhBeautyFDmin;
 161   delete  fhBeautyFDmax;
 162   delete  fhMCclosureTestMin;
 163   delete  fhMCclosureTestMax;
 164   delete  fhMCcorrectionsMin;
 165   delete  fhMCcorrectionsMax;
 166   delete  fhMCDefficiencyMin;
 167   delete  fhMCDefficiencyMax;
 168   delete  fhSecContaminationMin;
 169   delete  fhSecContaminationMax;
 170   delete  fhTotalMin;
 171   delete fhTotalMax;
 172   delete fhTotalNonFDMin;
 173   delete fhTotalNonFDMax;
 174   delete fhTotalNonFlatDPhiMin;
 175   delete fhTotalNonFlatDPhiMax;
 176   delete fhtotFlatMin;
 177   delete fhtotFlatMax;
 178   delete fgrYieldUnc;
 179   delete fgrBackSubUnc;
 180   delete fgrMCcorrections;
 181   delete fgrMCDefficiency;
 182   delete fgrSecContamination;
 183   delete fgrMCclosureTest;
 184   delete fgrBeautyFD;
 185   delete fgrYieldUncRel;
 186   delete fgrBackSubUncRel;
 187   delete fgrMCcorrectionsRel;
 188   delete fgrMCDefficiencyRel;
 189   delete fgrSecContaminationRel;
 190   delete fgrMCclosureTestRel;
 191   delete fgrBeautyFDRel;
 192   delete fgrTotal;
 193   delete fgrTotalRel;
 194   delete fgrTotalNonFD;
 195   delete fgrTotalNonFlatDPhi;
 196   delete fgrTotalNonFlatDPhiRel;
 197   delete fgrTotalFlatDPhi;
 198   delete fgrTotalFlatDPhiRel;
 199
 200 }
 201
 202
 203 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP(){
 204   Printf("Loading syst unc for D0 pp2010 3-5 0.3 thr");
 205   fmeson=0;
 206   fstrmeson="Dzero";
 207   fstrptAss="ptAsMore03";
 208   fstrptD="Dpt3to5";
 209   if(!fhDeltaPhiTemplate){
 210     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 211   }
 212   Double_t x;
 213   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 214   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 215   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 216     fhYieldExtraction->SetBinContent(j,0.1);
 217   }
 218
 219   // Background D MESON candidate subtraction (side-band variations, etc.)
 220   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 221   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 222     fhBackSubtractionMin->SetBinContent(j,-0.05);
 223   }
 224
 225   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 226   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 227     fhBackSubtractionMax->SetBinContent(j,0.05);
 228   }
 229
 230
 231   // MC CORRECTIONS ( associatate track efficiency):
 232   //  -5%  +10% for assoc track eff
 233   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 234   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 235     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 236   }
 237
 238   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 239   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 240     fhMCcorrectionsMax->SetBinContent(j,0.10);
 241   }
 242
 243   // MC D EFF CORRECTION
 244   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 245   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 246     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 247   }
 248
 249   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 250   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 251     fhMCDefficiencyMax->SetBinContent(j,0.05);
 252   }
 253
 254
 255   // Contamination from secondary tracks
 256   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 257   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 258     fhSecContaminationMin->SetBinContent(j,-0.05);
 259   }
 260
 261   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 262   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 263     fhSecContaminationMax->SetBinContent(j,0.05);
 264   }
 265
 266
 267   // MC CLOSURETEST (D meson efficiency)
 268   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 269   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 270     x=fhMCclosureTestMin->GetBinLowEdge(j);
 271     fhMCclosureTestMin->SetBinContent(j,-0.08);
 272
 273     if(-0.4<x&&x<-0.2){
 274       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 275     }
 276     else if(-0.2<x&&x<-0.1){
 277       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 278     }
 279     else if(-0.1<x&&x<0.1){
 280       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 281     }
 282     else if(0.1<x&&x<0.2){
 283       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 284     }
 285     if(0.2<x&&x<0.4){
 286       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 287     }
 288   }
 289
 290   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 291   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 292     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
 293     fhMCclosureTestMax->SetBinContent(j,0.);
 294
 295     //     if(-0.4<x&&x<-0.2){
 296     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 297     //     }
 298     //     else if(-0.2<x&&x<-0.1){
 299     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 300     //     }
 301     //     else if(-0.2<x&&x<-0.1){
 302     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 303     //     }
 304     //     else if(-0.1<x&&x<0.1){
 305     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 306     //     }
 307     //     else if(0.1<x&&x<0.2){
 308     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 309     //     }
 310     //     if(0.2<x&&x<0.4){
 311     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 312     //     }
 313
 314   }
 315
 316   // Feed-down
 317
 318   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 319   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 320     x=fhBeautyFDmin->GetBinLowEdge(j);
 321     fhBeautyFDmin->SetBinContent(j,-0.05);
 322
 323   //   if(-0.4<x&&x<-0.2){
 324 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 325 //     }
 326 //     else if(-0.2<x&&x<-0.1){
 327 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 328 //     }
 329 //     else if(-0.2<x&&x<-0.1){
 330 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 331 //     }
 332 //     else if(-0.1<x&&x<0.1){
 333 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 334 //     }
 335 //     else if(0.1<x&&x<0.2){
 336 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 337 //     }
 338 //     if(0.2<x&&x<0.4){
 339 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 340 //     }
 341   }
 342
 343   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 344   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 345     x=fhBeautyFDmax->GetBinLowEdge(j);
 346     fhBeautyFDmax->SetBinContent(j,0.03);
 347
 348 //     if(-0.4<x&&x<-0.2){
 349 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 350 //     }
 351 //     else if(-0.2<x&&x<-0.1){
 352 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 353 //     }
 354 //     else if(-0.2<x&&x<-0.1){
 355 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 356 //     }
 357 //     else if(-0.1<x&&x<0.1){
 358 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 359 //     }
 360 //     else if(0.1<x&&x<0.2){
 361 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 362 //     }
 363 //     if(0.2<x&&x<0.4){
 364 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 365 //     }
 366
 367   }
 368
 369 }
 370
 371 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP(){
 372   Printf("Loading syst unc for D0 pp2010 5-8 0.3 thr");
 373
 374   fmeson=0;
 375   fstrmeson="Dzero";
 376   fstrptAss="ptAsMore03";
 377   fstrptD="Dpt5to8";
 378   if(!fhDeltaPhiTemplate){
 379     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 380   }
 381   Double_t x;
 382   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 383   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 384   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 385     fhYieldExtraction->SetBinContent(j,0.1);
 386   }
 387
 388   // Background D MESON candidate subtraction (side-band variations, etc.)
 389   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 390   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 391     fhBackSubtractionMin->SetBinContent(j,-0.05);
 392   }
 393
 394   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 395   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 396     fhBackSubtractionMax->SetBinContent(j,0.05);
 397   }
 398
 399   // MC CORRECTIONS:  -5%  +10% for assoc track eff
 400   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 401   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 402     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 403   }
 404
 405   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 406   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 407     fhMCcorrectionsMax->SetBinContent(j,0.10);
 408   }
 409
 410
 411   // MC D EFF CORRECTION
 412   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 413   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 414     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 415   }
 416
 417   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 418   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 419     fhMCDefficiencyMax->SetBinContent(j,0.05);
 420   }
 421
 422
 423   // Contamination from secondary tracks
 424   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 425   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 426     fhSecContaminationMin->SetBinContent(j,-0.05);
 427   }
 428
 429   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 430   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 431     fhSecContaminationMax->SetBinContent(j,0.05);
 432   }
 433
 434   // MC CLOSURETEST (D meson efficiency)
 435   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 436   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 437     x=fhMCclosureTestMin->GetBinLowEdge(j);
 438     fhMCclosureTestMin->SetBinContent(j,-0.08);
 439
 440     if(-0.4<x&&x<-0.2){
 441       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 442     }
 443     else if(-0.2<x&&x<-0.1){
 444       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 445     }
 446     else if(-0.1<x&&x<0.1){
 447       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 448     }
 449     else if(0.1<x&&x<0.2){
 450       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 451     }
 452     if(0.2<x&&x<0.4){
 453       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 454     }
 455   }
 456
 457   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 458   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 459     x=fhMCclosureTestMax->GetBinLowEdge(j);
 460     fhMCclosureTestMax->SetBinContent(j,0.);
 461
 462     //     if(-0.4<x&&x<-0.2){
 463     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 464     //     }
 465     //     else if(-0.2<x&&x<-0.1){
 466     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 467     //     }
 468     //     else if(-0.2<x&&x<-0.1){
 469     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 470     //     }
 471     //     else if(-0.1<x&&x<0.1){
 472     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 473     //     }
 474     //     else if(0.1<x&&x<0.2){
 475     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 476     //     }
 477     //     if(0.2<x&&x<0.4){
 478     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 479     //     }
 480
 481   }
 482
 483   // Feed-down
 484
 485   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 486   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 487     x=fhBeautyFDmin->GetBinLowEdge(j);
 488     fhBeautyFDmin->SetBinContent(j,-0.05);
 489
 490   //   if(-0.4<x&&x<-0.2){
 491 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 492 //     }
 493 //     else if(-0.2<x&&x<-0.1){
 494 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 495 //     }
 496 //     else if(-0.2<x&&x<-0.1){
 497 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 498 //     }
 499 //     else if(-0.1<x&&x<0.1){
 500 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 501 //     }
 502 //     else if(0.1<x&&x<0.2){
 503 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 504 //     }
 505 //     if(0.2<x&&x<0.4){
 506 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 507 //     }
 508   }
 509
 510   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 511   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 512     x=fhBeautyFDmax->GetBinLowEdge(j);
 513     fhBeautyFDmax->SetBinContent(j,0.03);
 514
 515 //     if(-0.4<x&&x<-0.2){
 516 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 517 //     }
 518 //     else if(-0.2<x&&x<-0.1){
 519 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 520 //     }
 521 //     else if(-0.2<x&&x<-0.1){
 522 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 523 //     }
 524 //     else if(-0.1<x&&x<0.1){
 525 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 526 //     }
 527 //     else if(0.1<x&&x<0.2){
 528 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 529 //     }
 530 //     if(0.2<x&&x<0.4){
 531 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 532 //     }
 533
 534   }
 535
 536 }
 537
 538
 539 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(){
 540
 541   Printf("Loading syst unc for D0 pp2010 8-16 0.3 thr");
 542
 543   fmeson=0;
 544   fstrmeson="Dzero";
 545   fstrptAss="ptAsMore03";
 546   fstrptD="Dpt8to16";
 547   if(!fhDeltaPhiTemplate){
 548     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 549   }
 550
 551   Double_t x;
 552   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 553   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 554   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 555     fhYieldExtraction->SetBinContent(j,0.1);
 556   }
 557
 558   // Background D MESON candidate subtraction (side-band variations, etc.)
 559   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 560   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 561     fhBackSubtractionMin->SetBinContent(j,-0.05);
 562   }
 563
 564   // Background D MESON candidate subtraction (side-band variations, etc.)
 565   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 566   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 567     fhBackSubtractionMax->SetBinContent(j,0.05);
 568   }
 569
 570   // MC CORRECTIONS,  -5% 10% for assoc track eff
 571   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 572   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 573     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 574   }
 575
 576   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 577   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 578     fhMCcorrectionsMax->SetBinContent(j,0.10);
 579   }
 580
 581
 582   // MC D EFF CORRECTION
 583   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 584   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 585     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 586   }
 587
 588   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 589   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 590     fhMCDefficiencyMax->SetBinContent(j,0.05);
 591   }
 592
 593
 594   // Contamination from secondary tracks
 595   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 596   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 597     fhSecContaminationMin->SetBinContent(j,-0.05);
 598   }
 599
 600   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 601   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 602     fhSecContaminationMax->SetBinContent(j,0.05);
 603   }
 604
 605   // MC CLOSURETEST (D meson efficiency)
 606   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 607   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 608     x=fhMCclosureTestMin->GetBinLowEdge(j);
 609     fhMCclosureTestMin->SetBinContent(j,-0.08);
 610
 611     if(-0.4<x&&x<-0.2){
 612       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 613     }
 614     else if(-0.2<x&&x<-0.1){
 615       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 616     }
 617     else if(-0.1<x&&x<0.1){
 618       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 619     }
 620     else if(0.1<x&&x<0.2){
 621       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 622     }
 623     if(0.2<x&&x<0.4){
 624       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 625     }
 626   }
 627
 628   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 629   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 630     x=fhMCclosureTestMax->GetBinLowEdge(j);
 631     fhMCclosureTestMax->SetBinContent(j,0.);
 632
 633     //     if(-0.4<x&&x<-0.2){
 634     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 635     //     }
 636     //     else if(-0.2<x&&x<-0.1){
 637     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 638     //     }
 639     //     else if(-0.2<x&&x<-0.1){
 640     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 641     //     }
 642     //     else if(-0.1<x&&x<0.1){
 643     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 644     //     }
 645     //     else if(0.1<x&&x<0.2){
 646     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 647     //     }
 648     //     if(0.2<x&&x<0.4){
 649     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 650     //     }
 651
 652   }
 653
 654   // Feed-down
 655
 656   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 657   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 658     x=fhBeautyFDmin->GetBinLowEdge(j);
 659     fhBeautyFDmin->SetBinContent(j,-0.05);
 660
 661   //   if(-0.4<x&&x<-0.2){
 662 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 663 //     }
 664 //     else if(-0.2<x&&x<-0.1){
 665 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 666 //     }
 667 //     else if(-0.2<x&&x<-0.1){
 668 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 669 //     }
 670 //     else if(-0.1<x&&x<0.1){
 671 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 672 //     }
 673 //     else if(0.1<x&&x<0.2){
 674 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 675 //     }
 676 //     if(0.2<x&&x<0.4){
 677 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 678 //     }
 679   }
 680
 681   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 682   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 683     x=fhBeautyFDmax->GetBinLowEdge(j);
 684     fhBeautyFDmax->SetBinContent(j,0.03);
 685
 686 //     if(-0.4<x&&x<-0.2){
 687 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 688 //     }
 689 //     else if(-0.2<x&&x<-0.1){
 690 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 691 //     }
 692 //     else if(-0.2<x&&x<-0.1){
 693 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 694 //     }
 695 //     else if(-0.1<x&&x<0.1){
 696 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 697 //     }
 698 //     else if(0.1<x&&x<0.2){
 699 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 700 //     }
 701 //     if(0.2<x&&x<0.4){
 702 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 703 //     }
 704
 705   }
 706
 707 }
 708
 709
 710
 711
 712 //--------------------------------------------------
 713 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP(){
 714   Printf("Loading syst unc for D*+ pp 2010, 3<pt(D)<5 GeV/c, pt(assoc)>0.3");
 715   fmeson=1;
 716   fstrmeson="Dstar";
 717   fstrptAss="ptAsMore03";
 718   fstrptD="Dpt3to5";
 719   if(!fhDeltaPhiTemplate){
 720     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 721   }
 722   Double_t x;
 723   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 724   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 725   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 726     fhYieldExtraction->SetBinContent(j,0.1);
 727   }
 728
 729   // Background D MESON candidate subtraction (side-band variations, etc.)
 730   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 731   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 732     fhBackSubtractionMin->SetBinContent(j,-0.05);
 733   }
 734
 735   // Background D MESON candidate subtraction (side-band variations, etc.)
 736   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 737   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 738     fhBackSubtractionMax->SetBinContent(j,0.05);
 739   }
 740
 741   // MC CORRECTIONS, -5%  10% for assoc track eff
 742   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 743   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 744     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 745   }
 746
 747   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 748   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 749     fhMCcorrectionsMax->SetBinContent(j,0.10);
 750   }
 751
 752
 753   // MC D EFF CORRECTION
 754   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 755   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 756     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 757   }
 758
 759   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 760   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 761     fhMCDefficiencyMax->SetBinContent(j,0.05);
 762   }
 763
 764
 765   // Contamination from secondary tracks
 766   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 767   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 768     fhSecContaminationMin->SetBinContent(j,-0.05);
 769   }
 770
 771   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 772   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 773     fhSecContaminationMax->SetBinContent(j,0.05);
 774   }
 775
 776   // MC CLOSURETEST (D meson efficiency)
 777   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 778   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 779     x=fhMCclosureTestMin->GetBinLowEdge(j);
 780     fhMCclosureTestMin->SetBinContent(j,-0.08);
 781
 782     if(-0.4<x&&x<-0.2){
 783       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 784     }
 785     else if(-0.2<x&&x<-0.1){
 786       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 787     }
 788     else if(-0.1<x&&x<0.1){
 789       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 790     }
 791     else if(0.1<x&&x<0.2){
 792       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 793     }
 794     if(0.2<x&&x<0.4){
 795       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 796     }
 797   }
 798
 799   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 800   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 801     x=fhMCclosureTestMax->GetBinLowEdge(j);
 802     fhMCclosureTestMax->SetBinContent(j,0.);
 803
 804     //     if(-0.4<x&&x<-0.2){
 805     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 806     //     }
 807     //     else if(-0.2<x&&x<-0.1){
 808     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 809     //     }
 810     //     else if(-0.2<x&&x<-0.1){
 811     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 812     //     }
 813     //     else if(-0.1<x&&x<0.1){
 814     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 815     //     }
 816     //     else if(0.1<x&&x<0.2){
 817     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 818     //     }
 819     //     if(0.2<x&&x<0.4){
 820     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 821     //     }
 822
 823   }
 824
 825   // Feed-down
 826
 827   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 828   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 829     x=fhBeautyFDmin->GetBinLowEdge(j);
 830     fhBeautyFDmin->SetBinContent(j,-0.05);
 831
 832   //   if(-0.4<x&&x<-0.2){
 833 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 834 //     }
 835 //     else if(-0.2<x&&x<-0.1){
 836 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 837 //     }
 838 //     else if(-0.2<x&&x<-0.1){
 839 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 840 //     }
 841 //     else if(-0.1<x&&x<0.1){
 842 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
 843 //     }
 844 //     else if(0.1<x&&x<0.2){
 845 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
 846 //     }
 847 //     if(0.2<x&&x<0.4){
 848 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
 849 //     }
 850   }
 851
 852   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
 853   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
 854     x=fhBeautyFDmax->GetBinLowEdge(j);
 855     fhBeautyFDmax->SetBinContent(j,0.03);
 856
 857 //     if(-0.4<x&&x<-0.2){
 858 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 859 //     }
 860 //     else if(-0.2<x&&x<-0.1){
 861 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 862 //     }
 863 //     else if(-0.2<x&&x<-0.1){
 864 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 865 //     }
 866 //     else if(-0.1<x&&x<0.1){
 867 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
 868 //     }
 869 //     else if(0.1<x&&x<0.2){
 870 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
 871 //     }
 872 //     if(0.2<x&&x<0.4){
 873 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
 874 //     }
 875
 876   }
 877
 878
 879 }
 880
 881 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss03HP(){
 882   Printf("Loading syst unc for D*+ pp 2010, 5<pt(D)<8 GeV/c, pt(assoc)>0.3");
 883   fmeson=1;
 884   fstrmeson="Dstar";
 885   fstrptAss="ptAsMore03";
 886   fstrptD="Dpt5to8";
 887   if(!fhDeltaPhiTemplate){
 888     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
 889   }
 890   Double_t x;
 891   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
 892   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
 893   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
 894     fhYieldExtraction->SetBinContent(j,0.1);
 895   }
 896
 897   // Background D MESON candidate subtraction (side-band variations, etc.)
 898   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
 899   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
 900     fhBackSubtractionMin->SetBinContent(j,-0.05);
 901   }
 902
 903   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
 904   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
 905     fhBackSubtractionMax->SetBinContent(j,0.05);
 906   }
 907
 908   // MC CORRECTIONS/ -5%  10% for assoc track eff
 909   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
 910   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
 911     fhMCcorrectionsMin->SetBinContent(j,-0.05);
 912   }
 913
 914   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
 915   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
 916     fhMCcorrectionsMax->SetBinContent(j,0.10);
 917   }
 918
 919   // MC D EFF CORRECTION
 920   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
 921   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
 922     fhMCDefficiencyMin->SetBinContent(j,-0.05);
 923   }
 924
 925   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
 926   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
 927     fhMCDefficiencyMax->SetBinContent(j,0.05);
 928   }
 929
 930
 931   // Contamination from secondary tracks
 932   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
 933   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
 934     fhSecContaminationMin->SetBinContent(j,-0.05);
 935   }
 936
 937   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
 938   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
 939     fhSecContaminationMax->SetBinContent(j,0.05);
 940   }
 941
 942   // MC CLOSURETEST (D meson efficiency)
 943   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
 944   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
 945     x=fhMCclosureTestMin->GetBinLowEdge(j);
 946     fhMCclosureTestMin->SetBinContent(j,-0.08);
 947
 948     if(-0.4<x&&x<-0.2){
 949       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 950     }
 951     else if(-0.2<x&&x<-0.1){
 952       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 953     }
 954     else if(-0.1<x&&x<0.1){
 955       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
 956     }
 957     else if(0.1<x&&x<0.2){
 958       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
 959     }
 960     if(0.2<x&&x<0.4){
 961       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
 962     }
 963   }
 964
 965   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
 966   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
 967     x=fhMCclosureTestMax->GetBinLowEdge(j);
 968     fhMCclosureTestMax->SetBinContent(j,0.);
 969
 970     //     if(-0.4<x&&x<-0.2){
 971     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 972     //     }
 973     //     else if(-0.2<x&&x<-0.1){
 974     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 975     //     }
 976     //     else if(-0.2<x&&x<-0.1){
 977     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 978     //     }
 979     //     else if(-0.1<x&&x<0.1){
 980     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
 981     //     }
 982     //     else if(0.1<x&&x<0.2){
 983     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
 984     //     }
 985     //     if(0.2<x&&x<0.4){
 986     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
 987     //     }
 988
 989   }
 990
 991   // Feed-down
 992
 993   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
 994   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
 995     x=fhBeautyFDmin->GetBinLowEdge(j);
 996     fhBeautyFDmin->SetBinContent(j,-0.05);
 997
 998   //   if(-0.4<x&&x<-0.2){
 999 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1000 //     }
1001 //     else if(-0.2<x&&x<-0.1){
1002 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1003 //     }
1004 //     else if(-0.2<x&&x<-0.1){
1005 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1006 //     }
1007 //     else if(-0.1<x&&x<0.1){
1008 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1009 //     }
1010 //     else if(0.1<x&&x<0.2){
1011 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1012 //     }
1013 //     if(0.2<x&&x<0.4){
1014 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1015 //     }
1016   }
1017
1018   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1019   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
1020     x=fhBeautyFDmax->GetBinLowEdge(j);
1021     fhBeautyFDmax->SetBinContent(j,0.03);
1022
1023 //     if(-0.4<x&&x<-0.2){
1024 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1025 //     }
1026 //     else if(-0.2<x&&x<-0.1){
1027 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1028 //     }
1029 //     else if(-0.2<x&&x<-0.1){
1030 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1031 //     }
1032 //     else if(-0.1<x&&x<0.1){
1033 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1034 //     }
1035 //     else if(0.1<x&&x<0.2){
1036 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1037 //     }
1038 //     if(0.2<x&&x<0.4){
1039 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1040 //     }
1041
1042   }
1043
1044 }
1045
1046
1047
1048 void AliHFDhadronCorrSystUnc::InitEmptyHistosFromTemplate(){
1049   if(!fhDeltaPhiTemplate){
1050     Printf("Template histo not set, using standard binning");
1051     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
1052   }
1053    fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
1054    fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
1055    fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1056    fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
1057    fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1058    fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
1059    fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1060    fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
1061    fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1062    fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
1063    fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
1064    fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
1065    fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1066 }
1067
1068
1069
1070
1071 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss03HP(){
1072   Printf("Loading syst unc for D*+ pp 2010, 8<pt(D)<16 GeV/c, pt(assoc)>0.3");
1073   fmeson=1;
1074   fstrmeson="Dstar";
1075   fstrptAss="ptAsMore03";
1076   fstrptD="Dpt8to16";
1077   if(!fhDeltaPhiTemplate){
1078     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
1079   }
1080   Double_t x;
1081   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
1082   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
1083   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
1084     fhYieldExtraction->SetBinContent(j,0.1);
1085   }
1086
1087   // Background D MESON candidate subtraction (side-band variations, etc.)
1088   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
1089   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
1090     fhBackSubtractionMin->SetBinContent(j,-0.05);
1091   }
1092
1093   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
1094   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
1095     fhBackSubtractionMax->SetBinContent(j,0.05);
1096   }
1097
1098   // MC CORRECTIONS   -5% +10% for assoc track eff
1099   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
1100   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
1101     fhMCcorrectionsMin->SetBinContent(j,-0.05);
1102   }
1103
1104   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
1105   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
1106     fhMCcorrectionsMax->SetBinContent(j,0.10);
1107   }
1108   // MC D EFF CORRECTION
1109   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
1110   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
1111     fhMCDefficiencyMin->SetBinContent(j,-0.05);
1112   }
1113
1114   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
1115   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
1116     fhMCDefficiencyMax->SetBinContent(j,0.05);
1117   }
1118
1119
1120   // Contamination from secondary tracks
1121   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
1122   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
1123     fhSecContaminationMin->SetBinContent(j,-0.05);
1124   }
1125
1126   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
1127   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
1128     fhSecContaminationMax->SetBinContent(j,0.05);
1129   }
1130
1131   // MC CLOSURETEST (D meson efficiency)
1132   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
1133   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
1134     x=fhMCclosureTestMin->GetBinLowEdge(j);
1135     fhMCclosureTestMin->SetBinContent(j,-0.08);
1136
1137     if(-0.4<x&&x<-0.2){
1138       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1139     }
1140     else if(-0.2<x&&x<-0.1){
1141       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1142     }
1143     else if(-0.1<x&&x<0.1){
1144       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
1145     }
1146     else if(0.1<x&&x<0.2){
1147       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
1148     }
1149     if(0.2<x&&x<0.4){
1150       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
1151     }
1152   }
1153
1154   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
1155   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
1156     x=fhMCclosureTestMax->GetBinLowEdge(j);
1157     fhMCclosureTestMax->SetBinContent(j,0.);
1158
1159     //     if(-0.4<x&&x<-0.2){
1160     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1161     //     }
1162     //     else if(-0.2<x&&x<-0.1){
1163     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1164     //     }
1165     //     else if(-0.2<x&&x<-0.1){
1166     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1167     //     }
1168     //     else if(-0.1<x&&x<0.1){
1169     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
1170     //     }
1171     //     else if(0.1<x&&x<0.2){
1172     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
1173     //     }
1174     //     if(0.2<x&&x<0.4){
1175     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
1176     //     }
1177
1178   }
1179
1180   // Feed-down
1181
1182   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
1183   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
1184     x=fhBeautyFDmin->GetBinLowEdge(j);
1185     fhBeautyFDmin->SetBinContent(j,-0.05);
1186
1187   //   if(-0.4<x&&x<-0.2){
1188 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1189 //     }
1190 //     else if(-0.2<x&&x<-0.1){
1191 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1192 //     }
1193 //     else if(-0.2<x&&x<-0.1){
1194 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1195 //     }
1196 //     else if(-0.1<x&&x<0.1){
1197 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
1198 //     }
1199 //     else if(0.1<x&&x<0.2){
1200 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
1201 //     }
1202 //     if(0.2<x&&x<0.4){
1203 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
1204 //     }
1205   }
1206
1207   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
1208   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
1209     x=fhBeautyFDmax->GetBinLowEdge(j);
1210     fhBeautyFDmax->SetBinContent(j,0.03);
1211
1212 //     if(-0.4<x&&x<-0.2){
1213 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1214 //     }
1215 //     else if(-0.2<x&&x<-0.1){
1216 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1217 //     }
1218 //     else if(-0.2<x&&x<-0.1){
1219 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1220 //     }
1221 //     else if(-0.1<x&&x<0.1){
1222 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
1223 //     }
1224 //     else if(0.1<x&&x<0.2){
1225 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
1226 //     }
1227 //     if(0.2<x&&x<0.4){
1228 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
1229 //     }
1230
1231   }
1232
1233
1234 }
1235
1236
1237 void AliHFDhadronCorrSystUnc::SetHistoTemplate(TH1D *h,TString strname,Bool_t clone){
1238   if(fhDeltaPhiTemplate)delete fhDeltaPhiTemplate;
1239   if(!clone){
1240     fhDeltaPhiTemplate=h;
1241   }
1242   else{
1243     if(strname.IsNull()){fhDeltaPhiTemplate=(TH1D*)h->Clone("fhDeltaPhiTemplate");
1244     }
1245     else fhDeltaPhiTemplate=(TH1D*)h->Clone(strname.Data());
1246   }
1247 }
1248
1249
1250 void AliHFDhadronCorrSystUnc::SetHistoYieldExtraction(TH1D *h,TString strname,Bool_t clone){
1251   if(fhYieldExtraction)delete fhYieldExtraction;
1252   if(!clone){
1253     fhYieldExtraction=h;
1254   }
1255   else{
1256     if(strname.IsNull()){fhYieldExtraction=(TH1D*)h->Clone("fhYieldExtraction");
1257     }
1258     else fhYieldExtraction=(TH1D*)h->Clone(strname.Data());
1259   }
1260 }
1261
1262 void AliHFDhadronCorrSystUnc::SetHistoBackSubtraction(TH1D *hMax,TString strname,Bool_t clone,TH1D *hMin){
1263   if(!hMax){
1264     Printf("No Input Histo for back uncertainty");
1265     return;
1266   }
1267   if(fhBackSubtractionMax)delete fhBackSubtractionMax;
1268   if(!clone){
1269     fhBackSubtractionMax=hMax;
1270   }
1271   else{
1272     if(strname.IsNull()){fhBackSubtractionMax=(TH1D*)hMax->Clone("fhBackSubtractionMax");
1273     }
1274     else fhBackSubtractionMax=(TH1D*)hMax->Clone(strname.Data());
1275   }
1276
1277   if(fhBackSubtractionMin)delete fhBackSubtractionMin;
1278   if(hMin){
1279     if(!clone){
1280       fhBackSubtractionMin=hMin;
1281     }
1282     else{
1283       if(strname.IsNull()){fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1284       }
1285       else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1286     }
1287   }
1288   else{
1289     if(strname.IsNull()){
1290       fhBackSubtractionMin=(TH1D*)hMin->Clone("fhBackSubtractionMin");
1291     }
1292     else fhBackSubtractionMin=(TH1D*)hMin->Clone(strname.Data());
1293     for(Int_t k=0;k<=fhBackSubtractionMin->GetNbinsX();k++){
1294       fhBackSubtractionMin->SetBinContent(k,-1.*fhBackSubtractionMin->GetBinContent(k));
1295     }
1296   }
1297
1298
1299
1300
1301 }
1302
1303
1304 void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMax(TH1D *h,TString strname,Bool_t clone){
1305   if(fhMCclosureTestMax)delete fhMCclosureTestMax;
1306   if(!clone){
1307     fhMCclosureTestMax=h;
1308   }
1309   else{
1310     if(strname.IsNull()){fhMCclosureTestMax=(TH1D*)h->Clone("fhMCclosureTestMax");
1311     }
1312     else fhMCclosureTestMax=(TH1D*)h->Clone(strname.Data());
1313   }
1314 }
1315
1316 void AliHFDhadronCorrSystUnc::SetHistoMCclosureTestMin(TH1D *h,TString strname,Bool_t clone){
1317     if(fhMCclosureTestMin)delete fhMCclosureTestMin;
1318     if(!clone){
1319       fhMCclosureTestMin=h;
1320     }
1321     else{
1322       if(strname.IsNull()){fhMCclosureTestMin=(TH1D*)h->Clone("fhMCclosureTestMin");
1323       }
1324       else fhMCclosureTestMin=(TH1D*)h->Clone(strname.Data());
1325     }
1326 }
1327
1328
1329 void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMin(TH1D *h,TString strname,Bool_t clone){
1330     if(fhMCcorrectionsMin)delete fhMCcorrectionsMin;
1331     if(!clone){
1332       fhMCcorrectionsMin=h;
1333     }
1334     else{
1335       if(strname.IsNull()){fhMCcorrectionsMin=(TH1D*)h->Clone("fhMCcorrectionsMin");
1336       }
1337       else fhMCcorrectionsMin=(TH1D*)h->Clone(strname.Data());
1338     }
1339 }
1340
1341
1342 void AliHFDhadronCorrSystUnc::SetHistoMCcorrectionsMax(TH1D *h,TString strname,Bool_t clone){
1343     if(fhMCcorrectionsMax)delete fhMCcorrectionsMax;
1344     if(!clone){
1345       fhMCcorrectionsMax=h;
1346     }
1347     else{
1348       if(strname.IsNull()){fhMCcorrectionsMax=(TH1D*)h->Clone("fhMCcorrectionsMax");
1349       }
1350       else fhMCcorrectionsMax=(TH1D*)h->Clone(strname.Data());
1351     }
1352 }
1353
1354
1355 void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMin(TH1D *h,TString strname,Bool_t clone){
1356     if(fhMCDefficiencyMin)delete fhMCDefficiencyMin;
1357     if(!clone){
1358       fhMCDefficiencyMin=h;
1359     }
1360     else{
1361       if(strname.IsNull()){fhMCDefficiencyMin=(TH1D*)h->Clone("fhMCDefficiencyMin");
1362       }
1363       else fhMCDefficiencyMin=(TH1D*)h->Clone(strname.Data());
1364     }
1365 }
1366
1367
1368 void AliHFDhadronCorrSystUnc::SetHistoMCDefficiencyMax(TH1D *h,TString strname,Bool_t clone){
1369     if(fhMCDefficiencyMax)delete fhMCDefficiencyMax;
1370     if(!clone){
1371       fhMCDefficiencyMax=h;
1372     }
1373     else{
1374       if(strname.IsNull()){fhMCDefficiencyMax=(TH1D*)h->Clone("fhMCDefficiencyMax");
1375       }
1376       else fhMCDefficiencyMax=(TH1D*)h->Clone(strname.Data());
1377     }
1378 }
1379
1380
1381 void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMin(TH1D *h,TString strname,Bool_t clone){
1382     if(fhSecContaminationMin)delete fhSecContaminationMin;
1383     if(!clone){
1384       fhSecContaminationMin=h;
1385     }
1386     else{
1387       if(strname.IsNull()){fhSecContaminationMin=(TH1D*)h->Clone("fhSecContaminationMin");
1388       }
1389       else fhSecContaminationMin=(TH1D*)h->Clone(strname.Data());
1390     }
1391 }
1392
1393
1394 void AliHFDhadronCorrSystUnc::SetHistoSecContaminationMax(TH1D *h,TString strname,Bool_t clone){
1395     if(fhSecContaminationMax)delete fhSecContaminationMax;
1396     if(!clone){
1397       fhSecContaminationMax=h;
1398     }
1399     else{
1400       if(strname.IsNull()){fhSecContaminationMax=(TH1D*)h->Clone("fhSecContaminationMax");
1401       }
1402       else fhSecContaminationMax=(TH1D*)h->Clone(strname.Data());
1403     }
1404 }
1405
1406
1407 void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmin(TH1D *h,TString strname,Bool_t clone){
1408     if(fhBeautyFDmin)delete fhBeautyFDmin;
1409     if(!clone){
1410       fhBeautyFDmin=h;
1411     }
1412     else{
1413       if(strname.IsNull()){fhBeautyFDmin=(TH1D*)h->Clone("fhBeautyFDmin");
1414       }
1415       else fhBeautyFDmin=(TH1D*)h->Clone(strname.Data());
1416     }
1417 }
1418
1419
1420 void AliHFDhadronCorrSystUnc::SetHistoBeautyFDmax(TH1D *h,TString strname,Bool_t clone){
1421     if(fhBeautyFDmax)delete fhBeautyFDmax;
1422     if(!clone){
1423       fhBeautyFDmax=h;
1424     }
1425     else{
1426       if(strname.IsNull()){fhBeautyFDmax=(TH1D*)h->Clone("fhBeautyFDmax");
1427       }
1428       else fhBeautyFDmax=(TH1D*)h->Clone(strname.Data());
1429     }
1430 }
1431
1432
1433
1434
1435
1436 void AliHFDhadronCorrSystUnc::BuildTotalUncHisto(){
1437   if(fhTotalMin)delete fhTotalMin;
1438   if(fhTotalMax)delete fhTotalMax;
1439
1440   fhTotalMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMin");
1441   fhTotalMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalMax");
1442   Double_t errMin,errMax;
1443
1444   for(Int_t j=1;j<=fhTotalMin->GetNbinsX();j++){
1445     errMin=fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j);
1446     errMin+=fhMCcorrectionsMin->GetBinContent(j)*fhMCcorrectionsMin->GetBinContent(j);
1447     errMin+=fhMCDefficiencyMin->GetBinContent(j)*fhMCDefficiencyMin->GetBinContent(j);
1448     errMin+=fhSecContaminationMin->GetBinContent(j)*fhSecContaminationMin->GetBinContent(j);
1449     errMin+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1450     errMin+=fhBackSubtractionMin->GetBinContent(j)*fhBackSubtractionMin->GetBinContent(j);
1451     errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1452
1453     fhTotalMin->SetBinContent(j,-TMath::Sqrt(errMin));
1454
1455     errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j);
1456     errMax+=fhMCcorrectionsMax->GetBinContent(j)*fhMCcorrectionsMax->GetBinContent(j);
1457     errMax+=fhMCDefficiencyMax->GetBinContent(j)*fhMCDefficiencyMax->GetBinContent(j);
1458     errMax+=fhSecContaminationMax->GetBinContent(j)*fhSecContaminationMax->GetBinContent(j);
1459     errMax+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1460     errMax+=fhBackSubtractionMax->GetBinContent(j)*fhBackSubtractionMax->GetBinContent(j);
1461     errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1462
1463     fhTotalMax->SetBinContent(j,TMath::Sqrt(errMax));
1464
1465
1466   }
1467
1468   fhTotalMin->SetLineColor(kBlack);
1469   fhTotalMin->SetLineWidth(2);
1470   fhTotalMin->SetFillStyle(0);
1471   fhTotalMin->SetFillColor(kBlack);
1472   fhTotalMin->SetMarkerColor(kBlack);
1473   fhTotalMin->SetMarkerStyle(20);
1474
1475   fhTotalMax->SetLineColor(kBlack);
1476   fhTotalMax->SetLineWidth(2);
1477   fhTotalMax->SetFillStyle(0);
1478   fhTotalMax->SetFillColor(kBlack);
1479   fhTotalMax->SetMarkerColor(kBlack);
1480   fhTotalMax->SetMarkerStyle(20);
1481
1482 }
1483
1484 void AliHFDhadronCorrSystUnc::BuildTotalNonFlatUncHisto(){
1485   if(fhTotalNonFlatDPhiMin)delete fhTotalNonFlatDPhiMin;
1486   if(fhTotalNonFlatDPhiMax)delete fhTotalNonFlatDPhiMax;
1487
1488   fhTotalNonFlatDPhiMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMin");
1489   fhTotalNonFlatDPhiMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFlatDPhiMax");
1490   Double_t errMin,errMax,mcClosureMinmax,mcClosureMaxmin;
1491
1492   mcClosureMinmax=fhMCclosureTestMin->GetBinContent(fhMCclosureTestMin->GetMaximumBin());
1493   mcClosureMaxmin=fhMCclosureTestMax->GetBinContent(fhMCclosureTestMax->GetMinimumBin());
1494   Printf("MC closure - The max of min is: %f, the min of max is: %f", mcClosureMinmax, mcClosureMaxmin);
1495
1496   for(Int_t j=1;j<=fhTotalNonFlatDPhiMin->GetNbinsX();j++){
1497     errMin=(fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j)-mcClosureMinmax*mcClosureMinmax);// Forced to this quadrature subtraction, doing: (fhMCclosureTestMin->GetBinContent(j)-mcClosureMinmax)*(fhMCclosureTestMin->GetBinContent(j)-mcClosureMinmax) gives the wrong result.. of course
1498
1499     errMin+=fhBeautyFDmin->GetBinContent(j)*fhBeautyFDmin->GetBinContent(j);
1500
1501     fhTotalNonFlatDPhiMin->SetBinContent(j,-TMath::Sqrt(errMin));
1502
1503     errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j)-mcClosureMaxmin*mcClosureMaxmin; // Forced to this quadrature subtraction, doing:(fhMCclosureTestMax->GetBinContent(j)-mcClosureMaxmin)*(fhMCclosureTestMax->GetBinContent(j)-mcClosureMaxmin) gives the wrong result.. of course
1504
1505     errMax+=fhBeautyFDmax->GetBinContent(j)*fhBeautyFDmax->GetBinContent(j);
1506
1507     fhTotalNonFlatDPhiMax->SetBinContent(j,TMath::Sqrt(errMax));
1508
1509
1510   }
1511
1512   fhtotFlatMin=(TH1D*)fhTotalMin->Clone("hTotFlatDPhiMin");
1513   fhtotFlatMin->SetTitle("#Delta#phi indipendent");
1514
1515   fhtotFlatMax=(TH1D*)fhTotalMax->Clone("hTotFlatDPhiMax");
1516   fhtotFlatMax->SetTitle("#Delta#phi indipendent");
1517
1518   for(Int_t jfl=1;jfl<=fhtotFlatMin->GetNbinsX();jfl++){
1519     fhtotFlatMin->SetBinContent(jfl,-TMath::Sqrt(fhTotalMin->GetBinContent(jfl)*fhTotalMin->GetBinContent(jfl)-fhTotalNonFlatDPhiMin->GetBinContent(jfl)*fhTotalNonFlatDPhiMin->GetBinContent(jfl)));
1520     fhtotFlatMax->SetBinContent(jfl,TMath::Sqrt(fhTotalMax->GetBinContent(jfl)*fhTotalMax->GetBinContent(jfl)-fhTotalNonFlatDPhiMax->GetBinContent(jfl)*fhTotalNonFlatDPhiMax->GetBinContent(jfl)));
1521   }
1522
1523   fhtotFlatMin->SetLineStyle(2);
1524   fhtotFlatMax->SetLineStyle(2);
1525
1526
1527
1528
1529   fhTotalNonFlatDPhiMin->SetLineColor(kBlue);
1530   fhTotalNonFlatDPhiMin->SetLineWidth(2);
1531   fhTotalNonFlatDPhiMin->SetFillStyle(0);
1532   fhTotalNonFlatDPhiMin->SetFillColor(kBlue);
1533   fhTotalNonFlatDPhiMin->SetMarkerColor(kBlue);
1534   fhTotalNonFlatDPhiMin->SetMarkerStyle(20);
1535
1536   fhTotalNonFlatDPhiMax->SetLineColor(kBlue);
1537   fhTotalNonFlatDPhiMax->SetLineWidth(2);
1538   fhTotalNonFlatDPhiMax->SetFillStyle(0);
1539   fhTotalNonFlatDPhiMax->SetFillColor(kBlue);
1540   fhTotalNonFlatDPhiMax->SetMarkerColor(kBlue);
1541   fhTotalNonFlatDPhiMax->SetMarkerStyle(20);
1542
1543 }
1544
1545
1546 void AliHFDhadronCorrSystUnc::BuildTotalNonFDUncHisto(){
1547   if(fhTotalNonFDMin)delete fhTotalNonFDMin;
1548   if(fhTotalNonFDMax)delete fhTotalNonFDMax;
1549
1550   fhTotalNonFDMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMin");
1551   fhTotalNonFDMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhTotalNonFDMax");
1552   Double_t errMin,errMax;
1553
1554   for(Int_t j=1;j<=fhTotalNonFDMin->GetNbinsX();j++){
1555     errMin=fhMCclosureTestMin->GetBinContent(j)*fhMCclosureTestMin->GetBinContent(j);
1556     errMin+=fhMCcorrectionsMin->GetBinContent(j)*fhMCcorrectionsMin->GetBinContent(j);
1557     errMin+=fhMCDefficiencyMin->GetBinContent(j)*fhMCDefficiencyMin->GetBinContent(j);
1558     errMin+=fhSecContaminationMin->GetBinContent(j)*fhSecContaminationMin->GetBinContent(j);
1559     errMin+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1560     errMin+=fhBackSubtractionMin->GetBinContent(j)*fhBackSubtractionMin->GetBinContent(j);
1561
1562     fhTotalNonFDMin->SetBinContent(j,-TMath::Sqrt(errMin));
1563
1564     errMax=fhMCclosureTestMax->GetBinContent(j)*fhMCclosureTestMax->GetBinContent(j);
1565     errMax+=fhMCcorrectionsMax->GetBinContent(j)*fhMCcorrectionsMax->GetBinContent(j);
1566     errMax+=fhMCDefficiencyMax->GetBinContent(j)*fhMCDefficiencyMax->GetBinContent(j);
1567     errMax+=fhSecContaminationMax->GetBinContent(j)*fhSecContaminationMax->GetBinContent(j);
1568     errMax+=fhYieldExtraction->GetBinContent(j)*fhYieldExtraction->GetBinContent(j);
1569     errMax+=fhBackSubtractionMax->GetBinContent(j)*fhBackSubtractionMax->GetBinContent(j);
1570
1571     fhTotalNonFDMax->SetBinContent(j,TMath::Sqrt(errMax));
1572
1573
1574   }
1575
1576 }
1577
1578
1579 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010(Int_t meson,Double_t ptD,Double_t minptAss){
1580
1581   if(meson==0){
1582
1583     // 0.3 GeV/c
1584     if(TMath::Abs(minptAss-0.3)<0.0001){
1585       if(ptD>2&&ptD<5){
1586         InitStandardUncertaintiesPP2010DzeroLowPtAss03HP();
1587       }
1588       else if(ptD>5&&ptD<8){
1589         InitStandardUncertaintiesPP2010DzeroMidPtAss03HP();
1590       }
1591       else if(ptD>8&&ptD<16){
1592         InitStandardUncertaintiesPP2010DzeroHighPtAss03HP();
1593       }
1594       else {
1595         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1596       }
1597     }
1598     // 0.5 GeV/c
1599     else if(TMath::Abs(minptAss-0.5)<0.0001){
1600       if(ptD>3&&ptD<5){
1601         InitStandardUncertaintiesPP2010DzeroLowPtAss05();
1602       }
1603       else if(ptD>5&&ptD<8){
1604         InitStandardUncertaintiesPP2010DzeroMidPtAss05();
1605       }
1606       else if(ptD>8&&ptD<16){
1607         InitStandardUncertaintiesPP2010DzeroHighPtAss05();
1608       }
1609       else {
1610         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1611       }
1612     }
1613     // 1 GeV/c
1614     else if(TMath::Abs(minptAss-1.)<0.0001){
1615       if(ptD>3&&ptD<5){
1616         InitStandardUncertaintiesPP2010DzeroLowPtAss1();
1617       }
1618       else if(ptD>5&&ptD<8){
1619         InitStandardUncertaintiesPP2010DzeroMidPtAss1();
1620
1621       }
1622       else if(ptD>8&&ptD<16){
1623         InitStandardUncertaintiesPP2010DzeroHighPtAss1();
1624       }
1625       else {
1626         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1627       }
1628     }
1629     else {
1630       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1631     }
1632   }
1633   else if(meson==1){
1634     // 0.3 GeV/c
1635     if(TMath::Abs(minptAss-0.3)<0.0001){
1636       if(ptD>3&&ptD<5){
1637         InitStandardUncertaintiesPP2010DstarLowPtAss03HP();
1638       }
1639       else if(ptD>5&&ptD<8){
1640         InitStandardUncertaintiesPP2010DstarMidPtAss03HP();
1641       }
1642       else if(ptD>8&&ptD<16){
1643         InitStandardUncertaintiesPP2010DstarHighPtAss03HP();
1644       }
1645       else {
1646         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1647       }
1648     }
1649     // 0.5 GeV/c
1650     else if(TMath::Abs(minptAss-0.5)<0.0001){
1651       if(ptD>3&&ptD<5){
1652         InitStandardUncertaintiesPP2010DstarLowPtAss05();
1653       }
1654       else if(ptD>5&&ptD<8){
1655         InitStandardUncertaintiesPP2010DstarMidPtAss05();
1656       }
1657       else if(ptD>8&&ptD<16){
1658         InitStandardUncertaintiesPP2010DstarHighPtAss05();
1659       }
1660       else {
1661         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1662       }
1663     }
1664
1665     // 1 GeV/c
1666     else if(TMath::Abs(minptAss-1.)<0.0001){
1667       if(ptD>3&&ptD<5){
1668         InitStandardUncertaintiesPP2010DstarLowPtAss1();
1669       }
1670       else if(ptD>5&&ptD<8){
1671         InitStandardUncertaintiesPP2010DstarMidPtAss1();
1672       }
1673       else if(ptD>8&&ptD<16){
1674         InitStandardUncertaintiesPP2010DstarHighPtAss1();
1675       }
1676       else {
1677         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1678       }
1679     }
1680     else {
1681       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1682     }
1683   }
1684   else if(meson==2){
1685     // 0.3 GeV/c
1686     if(TMath::Abs(minptAss-0.3)<0.0001){
1687       if(ptD>3&&ptD<5){
1688         InitStandardUncertaintiesPP2010DplusLowPtAss03();
1689       }
1690       else if(ptD>5&&ptD<8){
1691         InitStandardUncertaintiesPP2010DplusMidPtAss03();
1692       }
1693       else if(ptD>8&&ptD<16){
1694         InitStandardUncertaintiesPP2010DplusHighPtAss03();
1695       }
1696       else {
1697         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1698       }
1699     }
1700     // 0.5 GeV/c
1701     else if(TMath::Abs(minptAss-0.5)<0.0001){
1702       if(ptD>3&&ptD<5){
1703         InitStandardUncertaintiesPP2010DplusLowPtAss05();
1704       }
1705       else if(ptD>5&&ptD<8){
1706         InitStandardUncertaintiesPP2010DplusMidPtAss05();
1707       }
1708       else if(ptD>8&&ptD<16){
1709         InitStandardUncertaintiesPP2010DplusHighPtAss05();
1710       }
1711       else {
1712         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1713       }
1714     }
1715     // 1 GeV/c
1716     else if(TMath::Abs(minptAss-1.)<0.0001){
1717       if(ptD>3&&ptD<5){
1718         InitStandardUncertaintiesPP2010DplusLowPtAss1();
1719       }
1720       else if(ptD>5&&ptD<8){
1721         InitStandardUncertaintiesPP2010DplusMidPtAss1();
1722       }
1723       else if(ptD>8&&ptD<16){
1724         InitStandardUncertaintiesPP2010DplusHighPtAss1();
1725       }
1726       else {
1727         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1728       }
1729     }
1730     else {
1731       printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1732     }
1733   }
1734   else {
1735     printf("PP:No meson is found  Check your input \n");
1736   }
1737 }
1738
1739 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013(Int_t meson,Double_t ptD,Double_t minptAss){
1740
1741   if(meson==0){
1742     // 0.3 GeV/c
1743     if(TMath::Abs(minptAss-0.3)<0.0001){
1744       if(ptD>3&&ptD<5){
1745         InitStandardUncertaintiesPPb2013DzeroLowPtAss03();
1746       }
1747       else if(ptD>5&&ptD<8){
1748         InitStandardUncertaintiesPPb2013DzeroMidPtAss03();
1749       }
1750       else if(ptD>8&&ptD<16){
1751         InitStandardUncertaintiesPPb2013DzeroHighPtAss03();
1752       }
1753
1754       else {
1755         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1756       }
1757     }
1758     // 0.5 GeV/c
1759     else if(TMath::Abs(minptAss-0.5)<0.0001){
1760       if(ptD>3&&ptD<5){
1761         InitStandardUncertaintiesPPb2013DzeroLowPtAss05();
1762       }
1763       else if(ptD>5&&ptD<8){
1764         InitStandardUncertaintiesPPb2013DzeroMidPtAss05();
1765       }
1766       else if(ptD>8&&ptD<16){
1767         InitStandardUncertaintiesPPb2013DzeroHighPtAss05();
1768       }
1769
1770       else {
1771         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1772       }
1773     }
1774
1775     // 1 GeV/c
1776     else if(TMath::Abs(minptAss-1.)<0.0001){
1777       if(ptD>3&&ptD<5){
1778         InitStandardUncertaintiesPPb2013DzeroLowPtAss1();
1779       }
1780       else if(ptD>5&&ptD<8){
1781         InitStandardUncertaintiesPPb2013DzeroMidPtAss1();
1782       }
1783       else if(ptD>8&&ptD<16){
1784         InitStandardUncertaintiesPPb2013DzeroHighPtAss1();
1785       }
1786       else {
1787         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1788       }
1789     }
1790     else {
1791       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1792     }
1793   }
1794   else if(meson==1){
1795     // 0.3 GeV/c
1796     if(TMath::Abs(minptAss-0.3)<0.0001){
1797       if(ptD>3&&ptD<5){
1798         InitStandardUncertaintiesPPb2013DstarLowPtAss03();
1799       }
1800       else if(ptD>5&&ptD<8){
1801         InitStandardUncertaintiesPPb2013DstarMidPtAss03();
1802       }
1803       else if(ptD>8&&ptD<16){
1804         InitStandardUncertaintiesPPb2013DstarHighPtAss03();
1805       }
1806       else {
1807         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1808       }
1809     }
1810     // 0.5 GeV/c
1811     else if(TMath::Abs(minptAss-0.5)<0.0001){
1812       if(ptD>3&&ptD<5){
1813         InitStandardUncertaintiesPPb2013DstarLowPtAss05();
1814       }
1815       else if(ptD>5&&ptD<8){
1816         InitStandardUncertaintiesPPb2013DstarMidPtAss05();
1817       }
1818       else if(ptD>8&&ptD<16){
1819         InitStandardUncertaintiesPPb2013DstarHighPtAss05();
1820       }
1821       else {
1822         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1823       }
1824     }
1825     // 1 GeV/c
1826     else if(TMath::Abs(minptAss-1.)<0.0001){
1827       if(ptD>3&&ptD<5){
1828         InitStandardUncertaintiesPPb2013DstarLowPtAss1();
1829       }
1830       else if(ptD>5&&ptD<8){
1831         InitStandardUncertaintiesPPb2013DstarMidPtAss1();
1832       }
1833       else if(ptD>8&&ptD<16){
1834         InitStandardUncertaintiesPPb2013DstarHighPtAss1();
1835       }
1836       else {
1837         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1838       }
1839     }
1840     else {
1841       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1842     }
1843   }
1844   else if(meson==2){
1845     // 0.3 GeV/c
1846     if(TMath::Abs(minptAss-0.3)<0.0001){
1847       if(ptD>3&&ptD<5){
1848         InitStandardUncertaintiesPPb2013DplusLowPtAss03();
1849       }
1850       else if(ptD>5&&ptD<8){
1851         InitStandardUncertaintiesPPb2013DplusMidPtAss03();
1852       }
1853       else if(ptD>8&&ptD<16){
1854         InitStandardUncertaintiesPPb2013DplusHighPtAss03();
1855       }
1856       else {
1857         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1858       }
1859     }
1860     // 0.5 GeV/c
1861     else if(TMath::Abs(minptAss-0.5)<0.0001){
1862       if(ptD>3&&ptD<5){
1863         InitStandardUncertaintiesPPb2013DplusLowPtAss05();
1864       }
1865       else if(ptD>5&&ptD<8){
1866         InitStandardUncertaintiesPPb2013DplusMidPtAss05();
1867       }
1868       else if(ptD>8&&ptD<16){
1869         InitStandardUncertaintiesPPb2013DplusHighPtAss05();
1870       }
1871       else {
1872         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1873       }
1874     }
1875     // 1 GeV/c
1876     else if(TMath::Abs(minptAss-1.)<0.0001){
1877       if(ptD>3&&ptD<5){
1878         InitStandardUncertaintiesPPb2013DplusLowPtAss1();
1879       }
1880       else if(ptD>5&&ptD<8){
1881         InitStandardUncertaintiesPPb2013DplusMidPtAss1();
1882       }
1883       else if(ptD>8&&ptD<16){
1884         InitStandardUncertaintiesPPb2013DplusHighPtAss1();
1885       }
1886       else {
1887         printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
1888       }
1889     }
1890     else {
1891       printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
1892     }
1893   }
1894   else {
1895         printf("pPb-No meson is found  Check your input \n");
1896   }
1897 }
1898
1899
1900 TGraphAsymmErrors* AliHFDhadronCorrSystUnc::GetUncGraphFromHistos(TH1D *hRef,TH1D *hMin,TH1D *hMax){
1901
1902   //  Int_t npoints=hMin->GetNbinsX();
1903   Double_t ew=hMin->GetBinWidth(1)/2.;
1904   Double_t value,eyl,eym;
1905
1906   TGraphAsymmErrors *gr=new TGraphAsymmErrors();
1907   for(Int_t j=1;j<=hMin->GetNbinsX();j++){
1908     if(hRef){
1909       value=hRef->GetBinContent(j);
1910       eyl=hMin->GetBinContent(j)*value;
1911       if(eyl<0.)eyl*=-1.;
1912       if(hMax)eym=hMax->GetBinContent(j)*value;
1913       else eym=eyl;
1914     }
1915     else {
1916       value=0.;
1917       eyl=hMin->GetBinContent(j);
1918       if(eyl<0.)eyl*=-1.;
1919       if(hMax)eym=hMax->GetBinContent(j);
1920       else eym=eyl;
1921     }
1922
1923     gr->SetPoint(j-1,hMin->GetBinCenter(j),value);
1924     gr->SetPointError(j-1,ew,ew,eyl,eym);
1925   }
1926
1927   return gr;
1928 }
1929
1930 void AliHFDhadronCorrSystUnc::BuildGraphsRelUnc(){
1931   if(fgrYieldUncRel)delete fgrYieldUncRel;
1932   if(fgrBackSubUncRel)delete fgrBackSubUncRel;
1933   if(fgrMCcorrectionsRel)delete fgrMCcorrectionsRel;
1934   if(fgrMCDefficiencyRel)delete fgrMCDefficiencyRel;
1935   if(fgrSecContaminationRel)delete fgrSecContaminationRel;
1936   if(fgrMCclosureTestRel)delete fgrMCclosureTestRel;
1937   if(fgrBeautyFDRel)delete fgrBeautyFDRel;
1938
1939   fgrYieldUncRel=GetUncGraphFromHistos(0x0,fhYieldExtraction,0x0);
1940   fgrYieldUncRel->SetName("fgrYieldUncRel");
1941   fgrYieldUncRel->SetTitle("D meson yield");
1942
1943
1944   fgrBackSubUncRel=GetUncGraphFromHistos(0x0,fhBackSubtractionMin,fhBackSubtractionMax);
1945   fgrBackSubUncRel->SetName("fgrBackSubUncRel");
1946   fgrBackSubUncRel->SetTitle("Background D correlation subtraction");
1947
1948
1949
1950   fgrMCcorrectionsRel=GetUncGraphFromHistos(0x0,fhMCcorrectionsMin,fhMCcorrectionsMax);
1951   fgrMCcorrectionsRel->SetName("fgrMCcorrectionsRel");
1952   fgrMCcorrectionsRel->SetTitle("Associated track efficiency");
1953
1954   fgrMCDefficiencyRel=GetUncGraphFromHistos(0x0,fhMCDefficiencyMin,fhMCDefficiencyMax);
1955   fgrMCDefficiencyRel->SetName("fgrMCDefficiencyRel");
1956   fgrMCDefficiencyRel->SetTitle("D meson efficiency");
1957
1958   fgrSecContaminationRel=GetUncGraphFromHistos(0x0,fhSecContaminationMin,fhSecContaminationMax);
1959   fgrSecContaminationRel->SetName("fgrSecContaminationRel");
1960   fgrSecContaminationRel->SetTitle("Secondary contamination");
1961
1962   fgrMCclosureTestRel=GetUncGraphFromHistos(0x0,fhMCclosureTestMin,fhMCclosureTestMax);
1963   fgrMCclosureTestRel->SetName("fgrMCclosureTestRel");
1964   fgrMCclosureTestRel->SetTitle("MC closure test");
1965
1966   fgrBeautyFDRel=GetUncGraphFromHistos(0x0,fhBeautyFDmin,fhBeautyFDmax);
1967   fgrBeautyFDRel->SetName("fgrBeautyFDRel");
1968   fgrBeautyFDRel->SetTitle("Feed-down");
1969
1970   fgrYieldUncRel->SetLineColor(kBlue);
1971   fgrYieldUncRel->SetLineWidth(2);
1972   fgrYieldUncRel->SetFillStyle(3002);
1973   fgrYieldUncRel->SetFillColor(kBlue);
1974   fgrYieldUncRel->SetMarkerColor(kBlue);
1975   fgrYieldUncRel->SetMarkerStyle(20);
1976
1977
1978   fgrBackSubUncRel->SetLineColor(kMagenta);
1979   fgrBackSubUncRel->SetLineWidth(2);
1980   fgrBackSubUncRel->SetFillStyle(3008);
1981   fgrBackSubUncRel->SetFillColor(kMagenta);
1982   fgrBackSubUncRel->SetMarkerColor(kBlue);
1983   fgrBackSubUncRel->SetMarkerStyle(20);
1984
1985
1986   fgrMCcorrectionsRel->SetLineColor(kGreen);
1987   fgrMCcorrectionsRel->SetLineWidth(2);
1988   fgrMCcorrectionsRel->SetFillStyle(3006);
1989   fgrMCcorrectionsRel->SetFillColor(kGreen);
1990   fgrMCcorrectionsRel->SetMarkerColor(kGreen);
1991   fgrMCcorrectionsRel->SetMarkerStyle(22);
1992
1993   fgrMCDefficiencyRel->SetLineColor(kCyan);
1994   fgrMCDefficiencyRel->SetLineWidth(2);
1995   fgrMCDefficiencyRel->SetFillStyle(3004);
1996   fgrMCDefficiencyRel->SetFillColor(kCyan);
1997   fgrMCDefficiencyRel->SetMarkerColor(kCyan);
1998   fgrMCDefficiencyRel->SetMarkerStyle(22);
1999
2000   fgrSecContaminationRel->SetLineColor(kOrange);
2001   fgrSecContaminationRel->SetLineWidth(2);
2002   fgrSecContaminationRel->SetFillStyle(3007);
2003   fgrSecContaminationRel->SetFillColor(kOrange);
2004   fgrSecContaminationRel->SetMarkerColor(kOrange);
2005   fgrSecContaminationRel->SetMarkerStyle(22);
2006
2007   fgrMCclosureTestRel->SetLineColor(kRed);
2008   fgrMCclosureTestRel->SetLineWidth(2);
2009   fgrMCclosureTestRel->SetFillStyle(3005);
2010   fgrMCclosureTestRel->SetFillColor(kRed);
2011   fgrMCclosureTestRel->SetMarkerColor(kRed);
2012   fgrMCclosureTestRel->SetMarkerStyle(26);
2013
2014   fgrBeautyFDRel->SetLineColor(kViolet);
2015   fgrBeautyFDRel->SetLineWidth(2);
2016   fgrBeautyFDRel->SetFillStyle(3021);
2017   fgrBeautyFDRel->SetFillColor(kViolet);
2018   fgrBeautyFDRel->SetMarkerColor(kViolet);
2019   fgrBeautyFDRel->SetMarkerStyle(28);
2020
2021
2022
2023
2024 }
2025
2026 void AliHFDhadronCorrSystUnc::BuildGraphsUnc(TH1D *hRef){
2027
2028   if(fgrYieldUnc)delete fgrYieldUnc;
2029   if(fgrBackSubUnc)delete fgrBackSubUnc;
2030   if(fgrMCcorrections)delete fgrMCcorrections;
2031   if(fgrMCDefficiency)delete fgrMCDefficiency;
2032   if(fgrSecContamination)delete fgrSecContamination;
2033   if(fgrMCclosureTest)delete fgrMCclosureTest;
2034   if(fgrBeautyFD)delete fgrBeautyFD;
2035   if(fgrTotalRel)delete fgrTotalRel;
2036   if(fgrTotal)delete fgrTotal;
2037   if(fgrTotalNonFlatDPhi)delete fgrTotalNonFlatDPhi;
2038   if(fgrTotalNonFlatDPhiRel)delete fgrTotalNonFlatDPhiRel;
2039   if(fgrTotalFlatDPhi)delete fgrTotalFlatDPhi;
2040   if(fgrTotalFlatDPhiRel)delete fgrTotalFlatDPhiRel;
2041
2042   fgrYieldUnc=GetUncGraphFromHistos(hRef,fhYieldExtraction,0x0);
2043   fgrYieldUnc->SetName("fgrYieldUnc");
2044   fgrYieldUnc->SetTitle("D meson yield");
2045
2046   fgrBackSubUnc=GetUncGraphFromHistos(hRef,fhBackSubtractionMin,fhBackSubtractionMax);
2047   fgrBackSubUnc->SetName("fgrBackSubUnc");
2048   fgrBackSubUnc->SetTitle("Background D correlation subtraction");
2049
2050
2051   fgrMCcorrections=GetUncGraphFromHistos(hRef,fhMCcorrectionsMin,fhMCcorrectionsMax);
2052   fgrMCcorrections->SetName("fgrMCcorrections");
2053   fgrMCcorrections->SetTitle("Associated track efficiency");
2054
2055   fgrMCDefficiency=GetUncGraphFromHistos(hRef,fhMCDefficiencyMin,fhMCDefficiencyMax);
2056   fgrMCDefficiency->SetName("fgrMCDefficiency");
2057   fgrMCDefficiency->SetTitle("D meson efficiency");
2058
2059   fgrSecContamination=GetUncGraphFromHistos(hRef,fhSecContaminationMin,fhSecContaminationMax);
2060   fgrSecContamination->SetName("fgrSecContamination");
2061   fgrSecContamination->SetTitle("Secondary contamination");
2062
2063   fgrMCclosureTest=GetUncGraphFromHistos(hRef,fhMCclosureTestMin,fhMCclosureTestMax);
2064   fgrMCclosureTest->SetName("fgrMCclosureTest");
2065   fgrMCclosureTest->SetTitle("MC closure test");
2066
2067   fgrBeautyFD=GetUncGraphFromHistos(hRef,fhBeautyFDmin,fhBeautyFDmax);
2068   fgrBeautyFD->SetName("fgrBeautyFD");
2069   fgrBeautyFD->SetTitle("Feed-down");
2070
2071   fgrYieldUnc->SetLineColor(kBlue);
2072   fgrYieldUnc->SetLineWidth(2);
2073   fgrYieldUnc->SetFillStyle(0);
2074   fgrYieldUnc->SetFillColor(kBlue);
2075   fgrYieldUnc->SetMarkerColor(kBlue);
2076   fgrYieldUnc->SetMarkerStyle(20);
2077
2078
2079   fgrBackSubUnc->SetLineColor(kMagenta);
2080   fgrBackSubUnc->SetLineWidth(2);
2081   fgrBackSubUnc->SetFillStyle(0);
2082   fgrBackSubUnc->SetFillColor(kMagenta);
2083   fgrBackSubUnc->SetMarkerColor(kBlue);
2084   fgrBackSubUnc->SetMarkerStyle(20);
2085
2086
2087   fgrMCcorrections->SetLineColor(kGreen);
2088   fgrMCcorrections->SetLineWidth(2);
2089   fgrMCcorrections->SetFillStyle(0);
2090   fgrMCcorrections->SetFillColor(kGreen);
2091   fgrMCcorrections->SetMarkerColor(kGreen);
2092   fgrMCcorrections->SetMarkerStyle(22);
2093
2094   fgrMCDefficiency->SetLineColor(kCyan);
2095   fgrMCDefficiency->SetLineWidth(2);
2096   fgrMCDefficiency->SetFillStyle(0);
2097   fgrMCDefficiency->SetFillColor(kCyan);
2098   fgrMCDefficiency->SetMarkerColor(kCyan);
2099   fgrMCDefficiency->SetMarkerStyle(22);
2100
2101   fgrSecContamination->SetLineColor(kOrange);
2102   fgrSecContamination->SetLineWidth(2);
2103   fgrSecContamination->SetFillStyle(0);
2104   fgrSecContamination->SetFillColor(kOrange);
2105   fgrSecContamination->SetMarkerColor(kOrange);
2106   fgrSecContamination->SetMarkerStyle(22);
2107
2108   fgrMCclosureTest->SetLineColor(kRed);
2109   fgrMCclosureTest->SetLineWidth(2);
2110   fgrMCclosureTest->SetFillStyle(0);
2111   fgrMCclosureTest->SetFillColor(kRed);
2112   fgrMCclosureTest->SetMarkerColor(kRed);
2113   fgrMCclosureTest->SetMarkerStyle(26);
2114
2115   fgrBeautyFD->SetLineColor(kViolet);
2116   fgrBeautyFD->SetLineWidth(2);
2117   fgrBeautyFD->SetFillStyle(0);
2118   fgrBeautyFD->SetFillColor(kViolet);
2119   fgrBeautyFD->SetMarkerColor(kViolet);
2120   fgrBeautyFD->SetMarkerStyle(28);
2121
2122   //  fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
2123   if(fhTotalMin){
2124     fgrTotalRel=GetUncGraphFromHistos(0x0,fhTotalMin,fhTotalMax);
2125     fgrTotalRel->SetLineColor(kBlack);
2126     fgrTotalRel->SetLineWidth(2);
2127     fgrTotalRel->SetFillStyle(0);
2128     //    fgrTotalRel->SetFillColor(kRed);
2129     fgrTotalRel->SetMarkerColor(kBlack);
2130     fgrTotalRel->SetMarkerStyle(26);
2131
2132     fgrTotal=GetUncGraphFromHistos(hRef,fhTotalMin,fhTotalMax);
2133     fgrTotal->SetLineColor(kBlack);
2134     fgrTotal->SetLineWidth(2);
2135     fgrTotal->SetFillStyle(0);
2136     fgrTotal->SetFillColor(kRed);
2137     fgrTotal->SetMarkerColor(kBlack);
2138     fgrTotal->SetMarkerStyle(26);
2139   }
2140
2141   if(fhTotalNonFDMin){
2142     fgrTotalNonFD=GetUncGraphFromHistos(hRef,fhTotalNonFDMin,fhTotalNonFDMax);
2143     fgrTotalNonFD->SetLineColor(kBlue);
2144     fgrTotalNonFD->SetLineWidth(2);
2145     fgrTotalNonFD->SetFillStyle(3005);
2146     fgrTotalNonFD->SetFillColor(kBlue);
2147     fgrTotalNonFD->SetMarkerColor(kBlue);
2148     fgrTotalNonFD->SetMarkerStyle(26);
2149   }
2150
2151   if(fhTotalNonFlatDPhiMin){
2152     fgrTotalNonFlatDPhiRel=GetUncGraphFromHistos(0x0,fhTotalNonFlatDPhiMin,fhTotalNonFlatDPhiMax);
2153     fgrTotalNonFlatDPhiRel->SetLineColor(kBlack);
2154     fgrTotalNonFlatDPhiRel->SetLineWidth(2);
2155     fgrTotalNonFlatDPhiRel->SetFillStyle(0);
2156     //    fgrTotalRel->SetFillColor(kRed);
2157     fgrTotalNonFlatDPhiRel->SetMarkerColor(kBlack);
2158     fgrTotalNonFlatDPhiRel->SetMarkerStyle(26);
2159
2160     fgrTotalNonFlatDPhi=GetUncGraphFromHistos(hRef,fhTotalNonFlatDPhiMin,fhTotalNonFlatDPhiMax);
2161     fgrTotalNonFlatDPhi->SetLineColor(kBlack);
2162     fgrTotalNonFlatDPhi->SetLineWidth(2);
2163     fgrTotalNonFlatDPhi->SetFillStyle(3005);
2164     fgrTotalNonFlatDPhi->SetFillColor(kRed);
2165     fgrTotalNonFlatDPhi->SetMarkerColor(kBlack);
2166     fgrTotalNonFlatDPhi->SetMarkerStyle(26);
2167
2168     fgrTotalFlatDPhiRel=GetUncGraphFromHistos(0x0,fhtotFlatMin,fhtotFlatMax);
2169     fgrTotalFlatDPhiRel->SetLineColor(kBlack);
2170     fgrTotalFlatDPhiRel->SetLineWidth(2);
2171     fgrTotalFlatDPhiRel->SetFillStyle(0);
2172     //    fgrTotalRel->SetFillColor(kRed);
2173     fgrTotalFlatDPhiRel->SetMarkerColor(kBlack);
2174     fgrTotalFlatDPhiRel->SetMarkerStyle(26);
2175
2176     fgrTotalFlatDPhi=GetUncGraphFromHistos(hRef,fhtotFlatMin,fhtotFlatMax);
2177     fgrTotalFlatDPhi->SetLineColor(kBlack);
2178     fgrTotalFlatDPhi->SetLineWidth(2);
2179     fgrTotalFlatDPhi->SetFillStyle(3005);
2180     fgrTotalFlatDPhi->SetFillColor(kBlack);
2181     fgrTotalFlatDPhi->SetMarkerColor(kBlack);
2182     fgrTotalFlatDPhi->SetMarkerStyle(26);
2183   }
2184
2185 }
2186
2187
2188 TCanvas* AliHFDhadronCorrSystUnc::BuildSystUncertaintyPlotVsDeltaPhi(TH1D *hCorrPlot,Int_t doInit){
2189
2190   if(doInit!=0){
2191     BuildTotalUncHisto();
2192     BuildTotalNonFDUncHisto();
2193     BuildTotalNonFlatUncHisto();
2194     BuildGraphsUnc(hCorrPlot);
2195     BuildGraphsRelUnc();
2196
2197   }
2198
2199   // Easy canva with relative uncertainties
2200   TCanvas *cCanvaRelUnc=new TCanvas("cCanvaRelUnc","cCanvaRelUnc",700,700);
2201   cCanvaRelUnc->cd();
2202   TH2D *hDraw=new TH2D("hDraw","hDraw",32,-TMath::Pi()/2.,3./2.*TMath::Pi(),200,-2.,2.);
2203   hDraw->SetXTitle("#Delta#phi (rad)");
2204   hDraw->SetYTitle("Relative uncertainty");
2205   hDraw->Draw();
2206
2207
2208   fgrYieldUncRel->Draw("E2");
2209   fgrBackSubUncRel->Draw("E2");
2210   fgrMCcorrectionsRel->Draw("E2");
2211   fgrMCDefficiencyRel->Draw("E2");
2212   fgrSecContaminationRel->Draw("E2");
2213   fgrMCclosureTestRel->Draw("E2");
2214   fgrBeautyFDRel->Draw("E2");
2215   //  fgrTotalRel->Draw("E2");
2216
2217   fhtotFlatMin->Draw("same");
2218   fhtotFlatMax->Draw("same");
2219
2220   fhTotalMin->Draw("same");
2221   fhTotalMax->Draw("same");
2222
2223   TCanvas *cCanvaFinalPlot=new TCanvas("cCanvaFinalPlot","cCanvaFinalPlot",700,700);
2224   cCanvaFinalPlot->cd();
2225   hCorrPlot->Draw();
2226   //  fgrYieldUnc->Draw("pE2");
2227   //  fgrBackSubUnc->Draw("pE2");
2228   //  fgrMCcorrections->Draw("pE2");
2229   //  fgrMCclosureTest->Draw("pE2");
2230   //  fgrBeautyFD->Draw("pE2");
2231   fgrTotal->Draw("E2");
2232
2233
2234   TCanvas *cCanvaFinalPlotFD=new TCanvas("cCanvaFinalPlotFD","cCanvaFinalPlotFD",700,700);
2235   cCanvaFinalPlotFD->cd();
2236   hCorrPlot->Draw();
2237   //  fgrYieldUnc->Draw("pE2");
2238   //  fgrBackSubUnc->Draw("pE2");
2239   //  fgrMCcorrections->Draw("pE2");
2240   //  fgrMCclosureTest->Draw("pE2");
2241   //  fgrBeautyFD->Draw("pE2");
2242   fgrBeautyFD->Draw("E2");
2243   fgrTotalNonFD->Draw("E2");
2244   fgrTotalNonFlatDPhi->Draw("E2");
2245   fgrTotalFlatDPhi->Draw("E2");
2246
2247   return cCanvaFinalPlot;
2248 }
2249
2250
2251 TH1D* AliHFDhadronCorrSystUnc::GetVariedHisto(const TH1D *hIn,const TGraphAsymmErrors *gr,Int_t minmax){
2252
2253   TH1D *hOut;
2254   if(minmax==0){
2255     hOut=(TH1D*)hIn->Clone(Form("%sVariedMin",hIn->GetName()));
2256   }
2257   else if(minmax==1){
2258     hOut=(TH1D*)hIn->Clone(Form("%sVariedMax",hIn->GetName()));
2259   }
2260   //  Int_t np=gr->GetN();
2261   Double_t *x,*y,*ely,*ehy;//*elx,*ehx,
2262   x=gr->GetX();
2263   y=gr->GetY();
2264   //  elx=gr->GetEXlow();
2265   // ehx=gr->GetEXhigh();
2266    ely=gr->GetEYlow();
2267   ehy=gr->GetEYhigh();
2268
2269   for(Int_t jp=1;jp<=hIn->GetNbinsX();jp++){
2270     if(TMath::Abs(x[jp-1]-hIn->GetBinCenter(jp))>0.0001){
2271       Printf("Bin Mismatch: this method assumes that the graph has the points in the center of the histo bin centers");
2272       return 0x0;
2273     }
2274     if(TMath::Abs(y[jp-1]-hIn->GetBinContent(jp))>0.0001){
2275       Printf("Value Mismatch: this method relies on the fact that the graph central values are the same as those of the histo");
2276       return 0x0;
2277     }
2278     if(minmax==0){
2279       hOut->SetBinContent(jp,y[jp-1]-ely[jp-1]);
2280     }
2281     else if(minmax==1){
2282       hOut->SetBinContent(jp,y[jp-1]+ehy[jp-1]);
2283     }
2284     hOut->SetBinError(jp,hIn->GetBinError(jp));
2285   }
2286
2287   return hOut;
2288 }
2289
2290
2291
2292 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2293 /////
2294 ///// METHODS WITH UNCERTAINTIES: PP 2010, for kinematic cases approved after HP2013
2295 /////
2296 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2297
2298
2299 // START FROM DPLUS FOR PT(ASSOC)>0.3
2300 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2301   fmeson=0;
2302   fstrmeson="Dplus";
2303   fstrptAss="ptAsMore03";
2304   fstrptD="Dpt3to5";
2305   if(!fhDeltaPhiTemplate){
2306     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2307   }
2308   Double_t x;
2309   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2310   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2311   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2312     fhYieldExtraction->SetBinContent(j,0.1);
2313   }
2314
2315   // Background D MESON candidate subtraction (side-band variations, etc.)
2316   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2317   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2318     fhBackSubtractionMin->SetBinContent(j,-0.05);
2319   }
2320
2321   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2322   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2323     fhBackSubtractionMax->SetBinContent(j,0.05);
2324   }
2325
2326
2327   // MC CORRECTIONS ( associatate track efficiency):
2328   //  -5%  +10% for assoc track eff
2329   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2330   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2331     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2332   }
2333
2334   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2335   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2336     fhMCcorrectionsMax->SetBinContent(j,0.10);
2337   }
2338
2339   // MC D EFF CORRECTION
2340   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2341   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2342     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2343   }
2344
2345   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2346   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2347     fhMCDefficiencyMax->SetBinContent(j,0.05);
2348   }
2349
2350
2351   // Contamination from secondary tracks
2352   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2353   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2354     fhSecContaminationMin->SetBinContent(j,-0.05);
2355   }
2356
2357   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2358   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2359     fhSecContaminationMax->SetBinContent(j,0.05);
2360   }
2361
2362
2363   // MC CLOSURETEST (D meson efficiency)
2364   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2365   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2366     x=fhMCclosureTestMin->GetBinLowEdge(j);
2367     fhMCclosureTestMin->SetBinContent(j,-0.0);
2368
2369     if(-0.4<x&&x<-0.2){
2370       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2371     }
2372     else if(-0.2<x&&x<-0.1){
2373       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2374     }
2375     else if(-0.1<x&&x<0.1){
2376       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2377     }
2378     else if(0.1<x&&x<0.2){
2379       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2380     }
2381     if(0.2<x&&x<0.4){
2382       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2383     }
2384   }
2385
2386   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2387   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2388     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
2389     fhMCclosureTestMax->SetBinContent(j,0.);
2390
2391     //     if(-0.4<x&&x<-0.2){
2392     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2393     //     }
2394     //     else if(-0.2<x&&x<-0.1){
2395     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2396     //     }
2397     //     else if(-0.2<x&&x<-0.1){
2398     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2399     //     }
2400     //     else if(-0.1<x&&x<0.1){
2401     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2402     //     }
2403     //     else if(0.1<x&&x<0.2){
2404     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2405     //     }
2406     //     if(0.2<x&&x<0.4){
2407     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2408     //     }
2409
2410   }
2411
2412   // Feed-down
2413
2414   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2415   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2416     x=fhBeautyFDmin->GetBinLowEdge(j);
2417     fhBeautyFDmin->SetBinContent(j,-0.05);
2418
2419   //   if(-0.4<x&&x<-0.2){
2420 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2421 //     }
2422 //     else if(-0.2<x&&x<-0.1){
2423 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2424 //     }
2425 //     else if(-0.2<x&&x<-0.1){
2426 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2427 //     }
2428 //     else if(-0.1<x&&x<0.1){
2429 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2430 //     }
2431 //     else if(0.1<x&&x<0.2){
2432 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2433 //     }
2434 //     if(0.2<x&&x<0.4){
2435 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2436 //     }
2437   }
2438
2439   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2440   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2441     x=fhBeautyFDmax->GetBinLowEdge(j);
2442     fhBeautyFDmax->SetBinContent(j,0.03);
2443
2444 //     if(-0.4<x&&x<-0.2){
2445 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2446 //     }
2447 //     else if(-0.2<x&&x<-0.1){
2448 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2449 //     }
2450 //     else if(-0.2<x&&x<-0.1){
2451 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2452 //     }
2453 //     else if(-0.1<x&&x<0.1){
2454 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2455 //     }
2456 //     else if(0.1<x&&x<0.2){
2457 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2458 //     }
2459 //     if(0.2<x&&x<0.4){
2460 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2461 //     }
2462
2463   }
2464
2465 }
2466
2467 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2468
2469   fmeson=0;
2470   fstrmeson="Dplus";
2471   fstrptAss="ptAsMore03";
2472   fstrptD="Dpt5to8";
2473   if(!fhDeltaPhiTemplate){
2474     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2475   }
2476   Double_t x;
2477   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2478   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2479   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2480     fhYieldExtraction->SetBinContent(j,0.1);
2481   }
2482
2483   // Background D MESON candidate subtraction (side-band variations, etc.)
2484   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2485   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2486     fhBackSubtractionMin->SetBinContent(j,-0.05);
2487   }
2488
2489   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2490   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2491     fhBackSubtractionMax->SetBinContent(j,0.05);
2492   }
2493
2494   // MC CORRECTIONS:  -5%  +10% for assoc track eff
2495   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2496   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2497     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2498   }
2499
2500   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2501   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2502     fhMCcorrectionsMax->SetBinContent(j,0.10);
2503   }
2504
2505
2506   // MC D EFF CORRECTION
2507   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2508   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2509     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2510   }
2511
2512   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2513   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2514     fhMCDefficiencyMax->SetBinContent(j,0.05);
2515   }
2516
2517
2518   // Contamination from secondary tracks
2519   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2520   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2521     fhSecContaminationMin->SetBinContent(j,-0.05);
2522   }
2523
2524   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2525   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2526     fhSecContaminationMax->SetBinContent(j,0.05);
2527   }
2528
2529   // MC CLOSURETEST (D meson efficiency)
2530   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2531   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2532     x=fhMCclosureTestMin->GetBinLowEdge(j);
2533     fhMCclosureTestMin->SetBinContent(j,-0.0);
2534
2535     if(-0.4<x&&x<-0.2){
2536       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2537     }
2538     else if(-0.2<x&&x<-0.1){
2539       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2540     }
2541     else if(-0.1<x&&x<0.1){
2542       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2543     }
2544     else if(0.1<x&&x<0.2){
2545       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2546     }
2547     if(0.2<x&&x<0.4){
2548       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2549     }
2550   }
2551
2552   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2553   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2554     x=fhMCclosureTestMax->GetBinLowEdge(j);
2555     fhMCclosureTestMax->SetBinContent(j,0.);
2556
2557     //     if(-0.4<x&&x<-0.2){
2558     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2559     //     }
2560     //     else if(-0.2<x&&x<-0.1){
2561     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2562     //     }
2563     //     else if(-0.2<x&&x<-0.1){
2564     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2565     //     }
2566     //     else if(-0.1<x&&x<0.1){
2567     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2568     //     }
2569     //     else if(0.1<x&&x<0.2){
2570     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2571     //     }
2572     //     if(0.2<x&&x<0.4){
2573     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2574     //     }
2575
2576   }
2577
2578   // Feed-down
2579
2580   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2581   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2582     x=fhBeautyFDmin->GetBinLowEdge(j);
2583     fhBeautyFDmin->SetBinContent(j,-0.05);
2584
2585   //   if(-0.4<x&&x<-0.2){
2586 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2587 //     }
2588 //     else if(-0.2<x&&x<-0.1){
2589 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2590 //     }
2591 //     else if(-0.2<x&&x<-0.1){
2592 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2593 //     }
2594 //     else if(-0.1<x&&x<0.1){
2595 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2596 //     }
2597 //     else if(0.1<x&&x<0.2){
2598 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2599 //     }
2600 //     if(0.2<x&&x<0.4){
2601 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2602 //     }
2603   }
2604
2605   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2606   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2607     x=fhBeautyFDmax->GetBinLowEdge(j);
2608     fhBeautyFDmax->SetBinContent(j,0.03);
2609
2610 //     if(-0.4<x&&x<-0.2){
2611 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2612 //     }
2613 //     else if(-0.2<x&&x<-0.1){
2614 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2615 //     }
2616 //     else if(-0.2<x&&x<-0.1){
2617 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2618 //     }
2619 //     else if(-0.1<x&&x<0.1){
2620 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2621 //     }
2622 //     else if(0.1<x&&x<0.2){
2623 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2624 //     }
2625 //     if(0.2<x&&x<0.4){
2626 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2627 //     }
2628
2629   }
2630
2631 }
2632
2633
2634 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
2635
2636   fmeson=0;
2637   fstrmeson="Dplus";
2638   fstrptAss="ptAsMore03";
2639   fstrptD="Dpt8to16";
2640   if(!fhDeltaPhiTemplate){
2641     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2642   }
2643
2644   Double_t x;
2645   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2646   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2647   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2648     fhYieldExtraction->SetBinContent(j,0.1);
2649   }
2650
2651   // Background D MESON candidate subtraction (side-band variations, etc.)
2652   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2653   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2654     fhBackSubtractionMin->SetBinContent(j,-0.05);
2655   }
2656
2657   // Background D MESON candidate subtraction (side-band variations, etc.)
2658   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2659   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2660     fhBackSubtractionMax->SetBinContent(j,0.05);
2661   }
2662
2663   // MC CORRECTIONS,  -5% 10% for assoc track eff
2664   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2665   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2666     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2667   }
2668
2669   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2670   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2671     fhMCcorrectionsMax->SetBinContent(j,0.10);
2672   }
2673
2674
2675   // MC D EFF CORRECTION
2676   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2677   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2678     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2679   }
2680
2681   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2682   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2683     fhMCDefficiencyMax->SetBinContent(j,0.05);
2684   }
2685
2686
2687   // Contamination from secondary tracks
2688   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2689   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2690     fhSecContaminationMin->SetBinContent(j,-0.05);
2691   }
2692
2693   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2694   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2695     fhSecContaminationMax->SetBinContent(j,0.05);
2696   }
2697
2698   // MC CLOSURETEST (D meson efficiency)
2699   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2700   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2701     x=fhMCclosureTestMin->GetBinLowEdge(j);
2702     fhMCclosureTestMin->SetBinContent(j,-0.0);
2703
2704     if(-0.4<x&&x<-0.2){
2705       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2706     }
2707     else if(-0.2<x&&x<-0.1){
2708       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2709     }
2710     else if(-0.1<x&&x<0.1){
2711       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2712     }
2713     else if(0.1<x&&x<0.2){
2714       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2715     }
2716     if(0.2<x&&x<0.4){
2717       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2718     }
2719   }
2720
2721   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2722   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2723     x=fhMCclosureTestMax->GetBinLowEdge(j);
2724     fhMCclosureTestMax->SetBinContent(j,0.);
2725
2726     //     if(-0.4<x&&x<-0.2){
2727     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2728     //     }
2729     //     else if(-0.2<x&&x<-0.1){
2730     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2731     //     }
2732     //     else if(-0.2<x&&x<-0.1){
2733     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2734     //     }
2735     //     else if(-0.1<x&&x<0.1){
2736     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2737     //     }
2738     //     else if(0.1<x&&x<0.2){
2739     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2740     //     }
2741     //     if(0.2<x&&x<0.4){
2742     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2743     //     }
2744
2745   }
2746
2747   // Feed-down
2748
2749   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2750   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2751     x=fhBeautyFDmin->GetBinLowEdge(j);
2752     fhBeautyFDmin->SetBinContent(j,-0.05);
2753
2754   //   if(-0.4<x&&x<-0.2){
2755 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2756 //     }
2757 //     else if(-0.2<x&&x<-0.1){
2758 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2759 //     }
2760 //     else if(-0.2<x&&x<-0.1){
2761 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2762 //     }
2763 //     else if(-0.1<x&&x<0.1){
2764 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2765 //     }
2766 //     else if(0.1<x&&x<0.2){
2767 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2768 //     }
2769 //     if(0.2<x&&x<0.4){
2770 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2771 //     }
2772   }
2773
2774   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2775   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2776     x=fhBeautyFDmax->GetBinLowEdge(j);
2777     fhBeautyFDmax->SetBinContent(j,0.03);
2778
2779 //     if(-0.4<x&&x<-0.2){
2780 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2781 //     }
2782 //     else if(-0.2<x&&x<-0.1){
2783 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2784 //     }
2785 //     else if(-0.2<x&&x<-0.1){
2786 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2787 //     }
2788 //     else if(-0.1<x&&x<0.1){
2789 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2790 //     }
2791 //     else if(0.1<x&&x<0.2){
2792 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2793 //     }
2794 //     if(0.2<x&&x<0.4){
2795 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2796 //     }
2797
2798   }
2799
2800 }
2801
2802
2803
2804 //////// HIGHER PT ASS THRESHOLDS
2805
2806 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){
2807   Printf("Setting syst for D0 pp 2010 3-5 0.5 thr");
2808   fmeson=0;
2809   fstrmeson="Dzero";
2810   fstrptAss="ptAsMore05";
2811   fstrptD="Dpt3to5";
2812   if(!fhDeltaPhiTemplate){
2813     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2814   }
2815   Double_t x;
2816   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2817   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2818   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2819     fhYieldExtraction->SetBinContent(j,0.1);
2820   }
2821
2822   // Background D MESON candidate subtraction (side-band variations, etc.)
2823   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2824   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2825     fhBackSubtractionMin->SetBinContent(j,-0.05);
2826   }
2827
2828   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2829   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2830     fhBackSubtractionMax->SetBinContent(j,0.05);
2831   }
2832
2833
2834   // MC CORRECTIONS ( associatate track efficiency):
2835   //  -5%  +10% for assoc track eff
2836   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
2837   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
2838     fhMCcorrectionsMin->SetBinContent(j,-0.05);
2839   }
2840
2841   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
2842   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
2843     fhMCcorrectionsMax->SetBinContent(j,0.10);
2844   }
2845
2846   // MC D EFF CORRECTION
2847   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
2848   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
2849     fhMCDefficiencyMin->SetBinContent(j,-0.05);
2850   }
2851
2852   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
2853   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
2854     fhMCDefficiencyMax->SetBinContent(j,0.05);
2855   }
2856
2857
2858   // Contamination from secondary tracks
2859   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
2860   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
2861     fhSecContaminationMin->SetBinContent(j,-0.05);
2862   }
2863
2864   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
2865   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
2866     fhSecContaminationMax->SetBinContent(j,0.05);
2867   }
2868
2869
2870   // MC CLOSURETEST (D meson efficiency)
2871   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
2872   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
2873     x=fhMCclosureTestMin->GetBinLowEdge(j);
2874     fhMCclosureTestMin->SetBinContent(j,-0.);
2875
2876     if(-0.4<x&&x<-0.2){
2877       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2878     }
2879     else if(-0.2<x&&x<-0.1){
2880       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2881     }
2882     else if(-0.1<x&&x<0.1){
2883       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
2884     }
2885     else if(0.1<x&&x<0.2){
2886       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
2887     }
2888     if(0.2<x&&x<0.4){
2889       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
2890     }
2891   }
2892
2893   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
2894   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
2895     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
2896     fhMCclosureTestMax->SetBinContent(j,0.);
2897
2898     //     if(-0.4<x&&x<-0.2){
2899     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2900     //     }
2901     //     else if(-0.2<x&&x<-0.1){
2902     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2903     //     }
2904     //     else if(-0.2<x&&x<-0.1){
2905     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2906     //     }
2907     //     else if(-0.1<x&&x<0.1){
2908     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
2909     //     }
2910     //     else if(0.1<x&&x<0.2){
2911     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
2912     //     }
2913     //     if(0.2<x&&x<0.4){
2914     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
2915     //     }
2916
2917   }
2918
2919   // Feed-down
2920
2921   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
2922   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
2923     x=fhBeautyFDmin->GetBinLowEdge(j);
2924     fhBeautyFDmin->SetBinContent(j,-0.05);
2925
2926   //   if(-0.4<x&&x<-0.2){
2927 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2928 //     }
2929 //     else if(-0.2<x&&x<-0.1){
2930 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2931 //     }
2932 //     else if(-0.2<x&&x<-0.1){
2933 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2934 //     }
2935 //     else if(-0.1<x&&x<0.1){
2936 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
2937 //     }
2938 //     else if(0.1<x&&x<0.2){
2939 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
2940 //     }
2941 //     if(0.2<x&&x<0.4){
2942 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
2943 //     }
2944   }
2945
2946   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
2947   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
2948     x=fhBeautyFDmax->GetBinLowEdge(j);
2949     fhBeautyFDmax->SetBinContent(j,0.03);
2950
2951 //     if(-0.4<x&&x<-0.2){
2952 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2953 //     }
2954 //     else if(-0.2<x&&x<-0.1){
2955 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2956 //     }
2957 //     else if(-0.2<x&&x<-0.1){
2958 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2959 //     }
2960 //     else if(-0.1<x&&x<0.1){
2961 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
2962 //     }
2963 //     else if(0.1<x&&x<0.2){
2964 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
2965 //     }
2966 //     if(0.2<x&&x<0.4){
2967 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
2968 //     }
2969
2970   }
2971
2972 }
2973
2974 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
2975   Printf("Setting syst for D0 pp 2010 5-8 0.5 thr");
2976
2977   fmeson=0;
2978   fstrmeson="Dzero";
2979   fstrptAss="ptAsMore05";
2980   fstrptD="Dpt5to8";
2981   if(!fhDeltaPhiTemplate){
2982     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
2983   }
2984   Double_t x;
2985   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
2986   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
2987   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
2988     fhYieldExtraction->SetBinContent(j,0.1);
2989   }
2990
2991   // Background D MESON candidate subtraction (side-band variations, etc.)
2992   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
2993   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
2994     fhBackSubtractionMin->SetBinContent(j,-0.05);
2995   }
2996
2997   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
2998   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
2999     fhBackSubtractionMax->SetBinContent(j,0.05);
3000   }
3001
3002   // MC CORRECTIONS:  -5%  +10% for assoc track eff
3003   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3004   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3005     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3006   }
3007
3008   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3009   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3010     fhMCcorrectionsMax->SetBinContent(j,0.10);
3011   }
3012
3013
3014   // MC D EFF CORRECTION
3015   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3016   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3017     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3018   }
3019
3020   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3021   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3022     fhMCDefficiencyMax->SetBinContent(j,0.05);
3023   }
3024
3025
3026   // Contamination from secondary tracks
3027   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3028   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3029     fhSecContaminationMin->SetBinContent(j,-0.05);
3030   }
3031
3032   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3033   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3034     fhSecContaminationMax->SetBinContent(j,0.05);
3035   }
3036
3037   // MC CLOSURETEST (D meson efficiency)
3038   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3039   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3040     x=fhMCclosureTestMin->GetBinLowEdge(j);
3041     fhMCclosureTestMin->SetBinContent(j,-0.);
3042
3043     if(-0.4<x&&x<-0.2){
3044       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3045     }
3046     else if(-0.2<x&&x<-0.1){
3047       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3048     }
3049     else if(-0.1<x&&x<0.1){
3050       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3051     }
3052     else if(0.1<x&&x<0.2){
3053       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3054     }
3055     if(0.2<x&&x<0.4){
3056       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3057     }
3058   }
3059
3060   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3061   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3062     x=fhMCclosureTestMax->GetBinLowEdge(j);
3063     fhMCclosureTestMax->SetBinContent(j,0.);
3064
3065     //     if(-0.4<x&&x<-0.2){
3066     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3067     //     }
3068     //     else if(-0.2<x&&x<-0.1){
3069     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3070     //     }
3071     //     else if(-0.2<x&&x<-0.1){
3072     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3073     //     }
3074     //     else if(-0.1<x&&x<0.1){
3075     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3076     //     }
3077     //     else if(0.1<x&&x<0.2){
3078     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3079     //     }
3080     //     if(0.2<x&&x<0.4){
3081     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3082     //     }
3083
3084   }
3085
3086   // Feed-down
3087
3088   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3089   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3090     x=fhBeautyFDmin->GetBinLowEdge(j);
3091     fhBeautyFDmin->SetBinContent(j,-0.05);
3092
3093   //   if(-0.4<x&&x<-0.2){
3094 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3095 //     }
3096 //     else if(-0.2<x&&x<-0.1){
3097 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3098 //     }
3099 //     else if(-0.2<x&&x<-0.1){
3100 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3101 //     }
3102 //     else if(-0.1<x&&x<0.1){
3103 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3104 //     }
3105 //     else if(0.1<x&&x<0.2){
3106 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3107 //     }
3108 //     if(0.2<x&&x<0.4){
3109 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3110 //     }
3111   }
3112
3113   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3114   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3115     x=fhBeautyFDmax->GetBinLowEdge(j);
3116     fhBeautyFDmax->SetBinContent(j,0.03);
3117
3118 //     if(-0.4<x&&x<-0.2){
3119 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3120 //     }
3121 //     else if(-0.2<x&&x<-0.1){
3122 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3123 //     }
3124 //     else if(-0.2<x&&x<-0.1){
3125 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3126 //     }
3127 //     else if(-0.1<x&&x<0.1){
3128 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3129 //     }
3130 //     else if(0.1<x&&x<0.2){
3131 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3132 //     }
3133 //     if(0.2<x&&x<0.4){
3134 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3135 //     }
3136
3137   }
3138
3139 }
3140
3141
3142 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
3143   Printf("Setting syst for D0 pp 2010 8-16 0.5 thr");
3144
3145   fmeson=0;
3146   fstrmeson="Dzero";
3147   fstrptAss="ptAsMore05";
3148   fstrptD="Dpt8to16";
3149   if(!fhDeltaPhiTemplate){
3150     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3151   }
3152
3153   Double_t x;
3154   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3155   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3156   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3157     fhYieldExtraction->SetBinContent(j,0.1);
3158   }
3159
3160   // Background D MESON candidate subtraction (side-band variations, etc.)
3161   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3162   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3163     fhBackSubtractionMin->SetBinContent(j,-0.05);
3164   }
3165
3166   // Background D MESON candidate subtraction (side-band variations, etc.)
3167   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3168   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3169     fhBackSubtractionMax->SetBinContent(j,0.05);
3170   }
3171
3172   // MC CORRECTIONS,  -5% 10% for assoc track eff
3173   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3174   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3175     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3176   }
3177
3178   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3179   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3180     fhMCcorrectionsMax->SetBinContent(j,0.10);
3181   }
3182
3183
3184   // MC D EFF CORRECTION
3185   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3186   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3187     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3188   }
3189
3190   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3191   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3192     fhMCDefficiencyMax->SetBinContent(j,0.05);
3193   }
3194
3195
3196   // Contamination from secondary tracks
3197   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3198   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3199     fhSecContaminationMin->SetBinContent(j,-0.05);
3200   }
3201
3202   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3203   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3204     fhSecContaminationMax->SetBinContent(j,0.05);
3205   }
3206
3207   // MC CLOSURETEST (D meson efficiency)
3208   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3209   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3210     x=fhMCclosureTestMin->GetBinLowEdge(j);
3211     fhMCclosureTestMin->SetBinContent(j,-0.);
3212
3213     if(-0.4<x&&x<-0.2){
3214       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3215     }
3216     else if(-0.2<x&&x<-0.1){
3217       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3218     }
3219     else if(-0.1<x&&x<0.1){
3220       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3221     }
3222     else if(0.1<x&&x<0.2){
3223       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3224     }
3225     if(0.2<x&&x<0.4){
3226       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3227     }
3228   }
3229
3230   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3231   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3232     x=fhMCclosureTestMax->GetBinLowEdge(j);
3233     fhMCclosureTestMax->SetBinContent(j,0.);
3234
3235     //     if(-0.4<x&&x<-0.2){
3236     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3237     //     }
3238     //     else if(-0.2<x&&x<-0.1){
3239     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3240     //     }
3241     //     else if(-0.2<x&&x<-0.1){
3242     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3243     //     }
3244     //     else if(-0.1<x&&x<0.1){
3245     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3246     //     }
3247     //     else if(0.1<x&&x<0.2){
3248     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3249     //     }
3250     //     if(0.2<x&&x<0.4){
3251     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3252     //     }
3253
3254   }
3255
3256   // Feed-down
3257
3258   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3259   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3260     x=fhBeautyFDmin->GetBinLowEdge(j);
3261     fhBeautyFDmin->SetBinContent(j,-0.05);
3262
3263   //   if(-0.4<x&&x<-0.2){
3264 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3265 //     }
3266 //     else if(-0.2<x&&x<-0.1){
3267 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3268 //     }
3269 //     else if(-0.2<x&&x<-0.1){
3270 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3271 //     }
3272 //     else if(-0.1<x&&x<0.1){
3273 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3274 //     }
3275 //     else if(0.1<x&&x<0.2){
3276 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3277 //     }
3278 //     if(0.2<x&&x<0.4){
3279 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3280 //     }
3281   }
3282
3283   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3284   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3285     x=fhBeautyFDmax->GetBinLowEdge(j);
3286     fhBeautyFDmax->SetBinContent(j,0.03);
3287
3288 //     if(-0.4<x&&x<-0.2){
3289 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3290 //     }
3291 //     else if(-0.2<x&&x<-0.1){
3292 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3293 //     }
3294 //     else if(-0.2<x&&x<-0.1){
3295 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3296 //     }
3297 //     else if(-0.1<x&&x<0.1){
3298 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3299 //     }
3300 //     else if(0.1<x&&x<0.2){
3301 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3302 //     }
3303 //     if(0.2<x&&x<0.4){
3304 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3305 //     }
3306
3307   }
3308
3309 }
3310
3311
3312
3313
3314 //--------------------------------------------------
3315 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){
3316   Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3317   fmeson=1;
3318   fstrmeson="Dstar";
3319   fstrptAss="ptAsMore05";
3320   fstrptD="Dpt3to5";
3321   if(!fhDeltaPhiTemplate){
3322     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3323   }
3324   Double_t x;
3325   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3326   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3327   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3328     fhYieldExtraction->SetBinContent(j,0.1);
3329   }
3330
3331   // Background D MESON candidate subtraction (side-band variations, etc.)
3332   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3333   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3334     fhBackSubtractionMin->SetBinContent(j,-0.05);
3335   }
3336
3337   // Background D MESON candidate subtraction (side-band variations, etc.)
3338   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3339   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3340     fhBackSubtractionMax->SetBinContent(j,0.05);
3341   }
3342
3343   // MC CORRECTIONS, -5%  10% for assoc track eff
3344   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3345   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3346     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3347   }
3348
3349   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3350   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3351     fhMCcorrectionsMax->SetBinContent(j,0.10);
3352   }
3353
3354
3355   // MC D EFF CORRECTION
3356   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3357   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3358     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3359   }
3360
3361   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3362   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3363     fhMCDefficiencyMax->SetBinContent(j,0.05);
3364   }
3365
3366
3367   // Contamination from secondary tracks
3368   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3369   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3370     fhSecContaminationMin->SetBinContent(j,-0.05);
3371   }
3372
3373   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3374   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3375     fhSecContaminationMax->SetBinContent(j,0.05);
3376   }
3377
3378   // MC CLOSURETEST (D meson efficiency)
3379   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3380   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3381     x=fhMCclosureTestMin->GetBinLowEdge(j);
3382     fhMCclosureTestMin->SetBinContent(j,-0.08);
3383
3384     if(-0.4<x&&x<-0.2){
3385       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3386     }
3387     else if(-0.2<x&&x<-0.1){
3388       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3389     }
3390     else if(-0.1<x&&x<0.1){
3391       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3392     }
3393     else if(0.1<x&&x<0.2){
3394       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3395     }
3396     if(0.2<x&&x<0.4){
3397       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3398     }
3399   }
3400
3401   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3402   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3403     x=fhMCclosureTestMax->GetBinLowEdge(j);
3404     fhMCclosureTestMax->SetBinContent(j,0.);
3405
3406     //     if(-0.4<x&&x<-0.2){
3407     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3408     //     }
3409     //     else if(-0.2<x&&x<-0.1){
3410     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3411     //     }
3412     //     else if(-0.2<x&&x<-0.1){
3413     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3414     //     }
3415     //     else if(-0.1<x&&x<0.1){
3416     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3417     //     }
3418     //     else if(0.1<x&&x<0.2){
3419     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3420     //     }
3421     //     if(0.2<x&&x<0.4){
3422     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3423     //     }
3424
3425   }
3426
3427   // Feed-down
3428
3429   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3430   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3431     x=fhBeautyFDmin->GetBinLowEdge(j);
3432     fhBeautyFDmin->SetBinContent(j,-0.05);
3433
3434   //   if(-0.4<x&&x<-0.2){
3435 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3436 //     }
3437 //     else if(-0.2<x&&x<-0.1){
3438 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3439 //     }
3440 //     else if(-0.2<x&&x<-0.1){
3441 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3442 //     }
3443 //     else if(-0.1<x&&x<0.1){
3444 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3445 //     }
3446 //     else if(0.1<x&&x<0.2){
3447 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3448 //     }
3449 //     if(0.2<x&&x<0.4){
3450 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3451 //     }
3452   }
3453
3454   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3455   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3456     x=fhBeautyFDmax->GetBinLowEdge(j);
3457     fhBeautyFDmax->SetBinContent(j,0.03);
3458
3459 //     if(-0.4<x&&x<-0.2){
3460 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3461 //     }
3462 //     else if(-0.2<x&&x<-0.1){
3463 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3464 //     }
3465 //     else if(-0.2<x&&x<-0.1){
3466 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3467 //     }
3468 //     else if(-0.1<x&&x<0.1){
3469 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3470 //     }
3471 //     else if(0.1<x&&x<0.2){
3472 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3473 //     }
3474 //     if(0.2<x&&x<0.4){
3475 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3476 //     }
3477
3478   }
3479
3480
3481 }
3482
3483 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
3484   Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3485   fmeson=1;
3486   fstrmeson="Dstar";
3487   fstrptAss="ptAsMore05";
3488   fstrptD="Dpt5to8";
3489   if(!fhDeltaPhiTemplate){
3490     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3491   }
3492   Double_t x;
3493   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3494   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3495   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3496     fhYieldExtraction->SetBinContent(j,0.1);
3497   }
3498
3499   // Background D MESON candidate subtraction (side-band variations, etc.)
3500   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3501   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3502     fhBackSubtractionMin->SetBinContent(j,-0.05);
3503   }
3504
3505   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3506   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3507     fhBackSubtractionMax->SetBinContent(j,0.05);
3508   }
3509
3510   // MC CORRECTIONS/ -5%  10% for assoc track eff
3511   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3512   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3513     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3514   }
3515
3516   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3517   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3518     fhMCcorrectionsMax->SetBinContent(j,0.10);
3519   }
3520
3521   // MC D EFF CORRECTION
3522   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3523   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3524     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3525   }
3526
3527   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3528   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3529     fhMCDefficiencyMax->SetBinContent(j,0.05);
3530   }
3531
3532
3533   // Contamination from secondary tracks
3534   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3535   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3536     fhSecContaminationMin->SetBinContent(j,-0.05);
3537   }
3538
3539   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3540   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3541     fhSecContaminationMax->SetBinContent(j,0.05);
3542   }
3543
3544   // MC CLOSURETEST (D meson efficiency)
3545   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3546   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3547     x=fhMCclosureTestMin->GetBinLowEdge(j);
3548     fhMCclosureTestMin->SetBinContent(j,-0.0);
3549
3550     if(-0.4<x&&x<-0.2){
3551       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3552     }
3553     else if(-0.2<x&&x<-0.1){
3554       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3555     }
3556     else if(-0.1<x&&x<0.1){
3557       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3558     }
3559     else if(0.1<x&&x<0.2){
3560       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3561     }
3562     if(0.2<x&&x<0.4){
3563       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3564     }
3565   }
3566
3567   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3568   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3569     x=fhMCclosureTestMax->GetBinLowEdge(j);
3570     fhMCclosureTestMax->SetBinContent(j,0.);
3571
3572     //     if(-0.4<x&&x<-0.2){
3573     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3574     //     }
3575     //     else if(-0.2<x&&x<-0.1){
3576     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3577     //     }
3578     //     else if(-0.2<x&&x<-0.1){
3579     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3580     //     }
3581     //     else if(-0.1<x&&x<0.1){
3582     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3583     //     }
3584     //     else if(0.1<x&&x<0.2){
3585     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3586     //     }
3587     //     if(0.2<x&&x<0.4){
3588     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3589     //     }
3590
3591   }
3592
3593   // Feed-down
3594
3595   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3596   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3597     x=fhBeautyFDmin->GetBinLowEdge(j);
3598     fhBeautyFDmin->SetBinContent(j,-0.05);
3599
3600   //   if(-0.4<x&&x<-0.2){
3601 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3602 //     }
3603 //     else if(-0.2<x&&x<-0.1){
3604 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3605 //     }
3606 //     else if(-0.2<x&&x<-0.1){
3607 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3608 //     }
3609 //     else if(-0.1<x&&x<0.1){
3610 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3611 //     }
3612 //     else if(0.1<x&&x<0.2){
3613 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3614 //     }
3615 //     if(0.2<x&&x<0.4){
3616 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3617 //     }
3618   }
3619
3620   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3621   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3622     x=fhBeautyFDmax->GetBinLowEdge(j);
3623     fhBeautyFDmax->SetBinContent(j,0.03);
3624
3625 //     if(-0.4<x&&x<-0.2){
3626 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3627 //     }
3628 //     else if(-0.2<x&&x<-0.1){
3629 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3630 //     }
3631 //     else if(-0.2<x&&x<-0.1){
3632 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3633 //     }
3634 //     else if(-0.1<x&&x<0.1){
3635 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3636 //     }
3637 //     else if(0.1<x&&x<0.2){
3638 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3639 //     }
3640 //     if(0.2<x&&x<0.4){
3641 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3642 //     }
3643
3644   }
3645
3646 }
3647
3648
3649
3650 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
3651   Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
3652   fmeson=1;
3653   fstrmeson="Dstar";
3654   fstrptAss="ptAsMore05";
3655   fstrptD="Dpt8to16";
3656   if(!fhDeltaPhiTemplate){
3657     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3658   }
3659   Double_t x;
3660   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3661   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3662   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3663     fhYieldExtraction->SetBinContent(j,0.1);
3664   }
3665
3666   // Background D MESON candidate subtraction (side-band variations, etc.)
3667   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3668   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3669     fhBackSubtractionMin->SetBinContent(j,-0.12);
3670   }
3671 // check those values
3672   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3673   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3674     fhBackSubtractionMax->SetBinContent(j,0.12); // check this one in particular
3675   }
3676
3677   // MC CORRECTIONS   -5% +10% for assoc track eff
3678   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3679   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3680     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3681   }
3682
3683   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3684   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3685     fhMCcorrectionsMax->SetBinContent(j,0.10);
3686   }
3687   // MC D EFF CORRECTION
3688   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3689   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3690     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3691   }
3692
3693   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3694   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3695     fhMCDefficiencyMax->SetBinContent(j,0.05);
3696   }
3697
3698
3699   // Contamination from secondary tracks
3700   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3701   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3702     fhSecContaminationMin->SetBinContent(j,-0.05);
3703   }
3704
3705   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3706   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3707     fhSecContaminationMax->SetBinContent(j,0.05);
3708   }
3709
3710   // MC CLOSURETEST (D meson efficiency)
3711   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3712   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3713     x=fhMCclosureTestMin->GetBinLowEdge(j);
3714     fhMCclosureTestMin->SetBinContent(j,-0);
3715
3716     if(-0.4<x&&x<-0.2){
3717       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3718     }
3719     else if(-0.2<x&&x<-0.1){
3720       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3721     }
3722     else if(-0.1<x&&x<0.1){
3723       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3724     }
3725     else if(0.1<x&&x<0.2){
3726       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3727     }
3728     if(0.2<x&&x<0.4){
3729       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3730     }
3731   }
3732
3733   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3734   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3735     x=fhMCclosureTestMax->GetBinLowEdge(j);
3736     fhMCclosureTestMax->SetBinContent(j,0.);
3737
3738     //     if(-0.4<x&&x<-0.2){
3739     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3740     //     }
3741     //     else if(-0.2<x&&x<-0.1){
3742     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3743     //     }
3744     //     else if(-0.2<x&&x<-0.1){
3745     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3746     //     }
3747     //     else if(-0.1<x&&x<0.1){
3748     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3749     //     }
3750     //     else if(0.1<x&&x<0.2){
3751     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3752     //     }
3753     //     if(0.2<x&&x<0.4){
3754     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3755     //     }
3756
3757   }
3758
3759   // Feed-down
3760
3761   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3762   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3763     x=fhBeautyFDmin->GetBinLowEdge(j);
3764     fhBeautyFDmin->SetBinContent(j,-0.05);
3765
3766   //   if(-0.4<x&&x<-0.2){
3767 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3768 //     }
3769 //     else if(-0.2<x&&x<-0.1){
3770 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3771 //     }
3772 //     else if(-0.2<x&&x<-0.1){
3773 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3774 //     }
3775 //     else if(-0.1<x&&x<0.1){
3776 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3777 //     }
3778 //     else if(0.1<x&&x<0.2){
3779 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3780 //     }
3781 //     if(0.2<x&&x<0.4){
3782 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3783 //     }
3784   }
3785
3786   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3787   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3788     x=fhBeautyFDmax->GetBinLowEdge(j);
3789     fhBeautyFDmax->SetBinContent(j,0.03);
3790
3791 //     if(-0.4<x&&x<-0.2){
3792 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3793 //     }
3794 //     else if(-0.2<x&&x<-0.1){
3795 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3796 //     }
3797 //     else if(-0.2<x&&x<-0.1){
3798 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3799 //     }
3800 //     else if(-0.1<x&&x<0.1){
3801 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3802 //     }
3803 //     else if(0.1<x&&x<0.2){
3804 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3805 //     }
3806 //     if(0.2<x&&x<0.4){
3807 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3808 //     }
3809
3810   }
3811
3812
3813 }
3814
3815
3816
3817 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){
3818   Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
3819   fmeson=2;
3820   fstrmeson="Dplus";
3821   fstrptAss="ptAsMore05";
3822   fstrptD="Dpt3to5";
3823   if(!fhDeltaPhiTemplate){
3824     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3825   }
3826   Double_t x;
3827   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3828   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3829   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3830     fhYieldExtraction->SetBinContent(j,0.1);
3831   }
3832
3833   // Background D MESON candidate subtraction (side-band variations, etc.)
3834   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
3835   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
3836     fhBackSubtractionMin->SetBinContent(j,-0.05);
3837   }
3838
3839   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
3840   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
3841     fhBackSubtractionMax->SetBinContent(j,0.05);
3842   }
3843
3844
3845   // MC CORRECTIONS ( associatate track efficiency):
3846   //  -5%  +10% for assoc track eff
3847   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
3848   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
3849     fhMCcorrectionsMin->SetBinContent(j,-0.05);
3850   }
3851
3852   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
3853   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
3854     fhMCcorrectionsMax->SetBinContent(j,0.10);
3855   }
3856
3857   // MC D EFF CORRECTION
3858   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
3859   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
3860     fhMCDefficiencyMin->SetBinContent(j,-0.05);
3861   }
3862
3863   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
3864   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
3865     fhMCDefficiencyMax->SetBinContent(j,0.05);
3866   }
3867
3868
3869   // Contamination from secondary tracks
3870   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
3871   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
3872     fhSecContaminationMin->SetBinContent(j,-0.05);
3873   }
3874
3875   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
3876   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
3877     fhSecContaminationMax->SetBinContent(j,0.05);
3878   }
3879
3880
3881   // MC CLOSURETEST (D meson efficiency)
3882   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
3883   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
3884     x=fhMCclosureTestMin->GetBinLowEdge(j);
3885     fhMCclosureTestMin->SetBinContent(j,-0.0);
3886
3887     if(-0.4<x&&x<-0.2){
3888       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3889     }
3890     else if(-0.2<x&&x<-0.1){
3891       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3892     }
3893     else if(-0.1<x&&x<0.1){
3894       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
3895     }
3896     else if(0.1<x&&x<0.2){
3897       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
3898     }
3899     if(0.2<x&&x<0.4){
3900       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
3901     }
3902   }
3903
3904   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
3905   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
3906     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
3907     fhMCclosureTestMax->SetBinContent(j,0.);
3908
3909     //     if(-0.4<x&&x<-0.2){
3910     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3911     //     }
3912     //     else if(-0.2<x&&x<-0.1){
3913     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3914     //     }
3915     //     else if(-0.2<x&&x<-0.1){
3916     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3917     //     }
3918     //     else if(-0.1<x&&x<0.1){
3919     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
3920     //     }
3921     //     else if(0.1<x&&x<0.2){
3922     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
3923     //     }
3924     //     if(0.2<x&&x<0.4){
3925     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
3926     //     }
3927
3928   }
3929
3930   // Feed-down
3931
3932   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
3933   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
3934     x=fhBeautyFDmin->GetBinLowEdge(j);
3935     fhBeautyFDmin->SetBinContent(j,-0.05);
3936
3937   //   if(-0.4<x&&x<-0.2){
3938 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3939 //     }
3940 //     else if(-0.2<x&&x<-0.1){
3941 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3942 //     }
3943 //     else if(-0.2<x&&x<-0.1){
3944 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3945 //     }
3946 //     else if(-0.1<x&&x<0.1){
3947 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
3948 //     }
3949 //     else if(0.1<x&&x<0.2){
3950 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
3951 //     }
3952 //     if(0.2<x&&x<0.4){
3953 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
3954 //     }
3955   }
3956
3957   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
3958   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
3959     x=fhBeautyFDmax->GetBinLowEdge(j);
3960     fhBeautyFDmax->SetBinContent(j,0.03);
3961
3962 //     if(-0.4<x&&x<-0.2){
3963 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3964 //     }
3965 //     else if(-0.2<x&&x<-0.1){
3966 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3967 //     }
3968 //     else if(-0.2<x&&x<-0.1){
3969 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3970 //     }
3971 //     else if(-0.1<x&&x<0.1){
3972 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
3973 //     }
3974 //     else if(0.1<x&&x<0.2){
3975 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
3976 //     }
3977 //     if(0.2<x&&x<0.4){
3978 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
3979 //     }
3980
3981   }
3982
3983 }
3984
3985 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
3986   Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
3987   fmeson=2;
3988   fstrmeson="Dplus";
3989   fstrptAss="ptAsMore05";
3990   fstrptD="Dpt5to8";
3991   if(!fhDeltaPhiTemplate){
3992     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
3993   }
3994   Double_t x;
3995   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
3996   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
3997   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
3998     fhYieldExtraction->SetBinContent(j,0.1);
3999   }
4000
4001   // Background D MESON candidate subtraction (side-band variations, etc.)
4002   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4003   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4004     fhBackSubtractionMin->SetBinContent(j,-0.05);
4005   }
4006
4007   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4008   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4009     fhBackSubtractionMax->SetBinContent(j,0.05);
4010   }
4011
4012   // MC CORRECTIONS:  -5%  +10% for assoc track eff
4013   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4014   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4015     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4016   }
4017
4018   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4019   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4020     fhMCcorrectionsMax->SetBinContent(j,0.10);
4021   }
4022
4023
4024   // MC D EFF CORRECTION
4025   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4026   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4027     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4028   }
4029
4030   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4031   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4032     fhMCDefficiencyMax->SetBinContent(j,0.05);
4033   }
4034
4035
4036   // Contamination from secondary tracks
4037   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4038   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4039     fhSecContaminationMin->SetBinContent(j,-0.05);
4040   }
4041
4042   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4043   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4044     fhSecContaminationMax->SetBinContent(j,0.05);
4045   }
4046
4047   // MC CLOSURETEST (D meson efficiency)
4048   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4049   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4050     x=fhMCclosureTestMin->GetBinLowEdge(j);
4051     fhMCclosureTestMin->SetBinContent(j,-0.0);
4052
4053     if(-0.4<x&&x<-0.2){
4054       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4055     }
4056     else if(-0.2<x&&x<-0.1){
4057       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4058     }
4059     else if(-0.1<x&&x<0.1){
4060       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4061     }
4062     else if(0.1<x&&x<0.2){
4063       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4064     }
4065     if(0.2<x&&x<0.4){
4066       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4067     }
4068   }
4069
4070   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4071   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4072     x=fhMCclosureTestMax->GetBinLowEdge(j);
4073     fhMCclosureTestMax->SetBinContent(j,0.);
4074
4075     //     if(-0.4<x&&x<-0.2){
4076     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4077     //     }
4078     //     else if(-0.2<x&&x<-0.1){
4079     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4080     //     }
4081     //     else if(-0.2<x&&x<-0.1){
4082     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4083     //     }
4084     //     else if(-0.1<x&&x<0.1){
4085     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4086     //     }
4087     //     else if(0.1<x&&x<0.2){
4088     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4089     //     }
4090     //     if(0.2<x&&x<0.4){
4091     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4092     //     }
4093
4094   }
4095
4096   // Feed-down
4097
4098   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4099   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4100     x=fhBeautyFDmin->GetBinLowEdge(j);
4101     fhBeautyFDmin->SetBinContent(j,-0.05);
4102
4103   //   if(-0.4<x&&x<-0.2){
4104 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4105 //     }
4106 //     else if(-0.2<x&&x<-0.1){
4107 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4108 //     }
4109 //     else if(-0.2<x&&x<-0.1){
4110 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4111 //     }
4112 //     else if(-0.1<x&&x<0.1){
4113 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4114 //     }
4115 //     else if(0.1<x&&x<0.2){
4116 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4117 //     }
4118 //     if(0.2<x&&x<0.4){
4119 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4120 //     }
4121   }
4122
4123   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4124   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4125     x=fhBeautyFDmax->GetBinLowEdge(j);
4126     fhBeautyFDmax->SetBinContent(j,0.03);
4127
4128 //     if(-0.4<x&&x<-0.2){
4129 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4130 //     }
4131 //     else if(-0.2<x&&x<-0.1){
4132 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4133 //     }
4134 //     else if(-0.2<x&&x<-0.1){
4135 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4136 //     }
4137 //     else if(-0.1<x&&x<0.1){
4138 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4139 //     }
4140 //     else if(0.1<x&&x<0.2){
4141 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4142 //     }
4143 //     if(0.2<x&&x<0.4){
4144 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4145 //     }
4146
4147   }
4148
4149 }
4150
4151
4152 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
4153   Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
4154   fmeson=2;
4155   fstrmeson="Dplus";
4156   fstrptAss="ptAsMore05";
4157   fstrptD="Dpt8to16";
4158   if(!fhDeltaPhiTemplate){
4159     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4160   }
4161
4162   Double_t x;
4163   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4164   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4165   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4166     fhYieldExtraction->SetBinContent(j,0.1);
4167   }
4168
4169   // Background D MESON candidate subtraction (side-band variations, etc.)
4170   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4171   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4172     fhBackSubtractionMin->SetBinContent(j,-0.05);
4173   }
4174
4175   // Background D MESON candidate subtraction (side-band variations, etc.)
4176   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4177   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4178     fhBackSubtractionMax->SetBinContent(j,0.05);
4179   }
4180
4181   // MC CORRECTIONS,  -5% 10% for assoc track eff
4182   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4183   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4184     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4185   }
4186
4187   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4188   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4189     fhMCcorrectionsMax->SetBinContent(j,0.10);
4190   }
4191
4192
4193   // MC D EFF CORRECTION
4194   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4195   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4196     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4197   }
4198
4199   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4200   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4201     fhMCDefficiencyMax->SetBinContent(j,0.05);
4202   }
4203
4204
4205   // Contamination from secondary tracks
4206   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4207   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4208     fhSecContaminationMin->SetBinContent(j,-0.05);
4209   }
4210
4211   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4212   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4213     fhSecContaminationMax->SetBinContent(j,0.05);
4214   }
4215
4216   // MC CLOSURETEST (D meson efficiency)
4217   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4218   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4219     x=fhMCclosureTestMin->GetBinLowEdge(j);
4220     fhMCclosureTestMin->SetBinContent(j,-0.0);
4221
4222     if(-0.4<x&&x<-0.2){
4223       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4224     }
4225     else if(-0.2<x&&x<-0.1){
4226       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4227     }
4228     else if(-0.1<x&&x<0.1){
4229       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4230     }
4231     else if(0.1<x&&x<0.2){
4232       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4233     }
4234     if(0.2<x&&x<0.4){
4235       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4236     }
4237   }
4238
4239   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4240   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4241     x=fhMCclosureTestMax->GetBinLowEdge(j);
4242     fhMCclosureTestMax->SetBinContent(j,0.);
4243
4244     //     if(-0.4<x&&x<-0.2){
4245     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4246     //     }
4247     //     else if(-0.2<x&&x<-0.1){
4248     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4249     //     }
4250     //     else if(-0.2<x&&x<-0.1){
4251     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4252     //     }
4253     //     else if(-0.1<x&&x<0.1){
4254     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4255     //     }
4256     //     else if(0.1<x&&x<0.2){
4257     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4258     //     }
4259     //     if(0.2<x&&x<0.4){
4260     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4261     //     }
4262
4263   }
4264
4265   // Feed-down
4266
4267   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4268   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4269     x=fhBeautyFDmin->GetBinLowEdge(j);
4270     fhBeautyFDmin->SetBinContent(j,-0.05);
4271
4272   //   if(-0.4<x&&x<-0.2){
4273 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4274 //     }
4275 //     else if(-0.2<x&&x<-0.1){
4276 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4277 //     }
4278 //     else if(-0.2<x&&x<-0.1){
4279 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4280 //     }
4281 //     else if(-0.1<x&&x<0.1){
4282 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4283 //     }
4284 //     else if(0.1<x&&x<0.2){
4285 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4286 //     }
4287 //     if(0.2<x&&x<0.4){
4288 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4289 //     }
4290   }
4291
4292   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4293   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4294     x=fhBeautyFDmax->GetBinLowEdge(j);
4295     fhBeautyFDmax->SetBinContent(j,0.03);
4296
4297 //     if(-0.4<x&&x<-0.2){
4298 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4299 //     }
4300 //     else if(-0.2<x&&x<-0.1){
4301 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4302 //     }
4303 //     else if(-0.2<x&&x<-0.1){
4304 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4305 //     }
4306 //     else if(-0.1<x&&x<0.1){
4307 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4308 //     }
4309 //     else if(0.1<x&&x<0.2){
4310 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4311 //     }
4312 //     if(0.2<x&&x<0.4){
4313 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4314 //     }
4315
4316   }
4317
4318 }
4319
4320
4321
4322 // pt(assoc)> 1 GeV/c
4323 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){
4324   Printf("Setting uncertainties for Dzero pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
4325   fmeson=0;
4326   fstrmeson="Dzero";
4327   fstrptAss="ptAsMore1";
4328   fstrptD="Dpt3to5";
4329   if(!fhDeltaPhiTemplate){
4330     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4331   }
4332   Double_t x;
4333   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4334   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4335   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4336     fhYieldExtraction->SetBinContent(j,0.1);
4337   }
4338
4339   // Background D MESON candidate subtraction (side-band variations, etc.)
4340   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4341   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4342     fhBackSubtractionMin->SetBinContent(j,-0.05);
4343   }
4344
4345   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4346   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4347     fhBackSubtractionMax->SetBinContent(j,0.05);
4348   }
4349
4350
4351   // MC CORRECTIONS ( associatate track efficiency):
4352   //  -5%  +10% for assoc track eff
4353   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4354   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4355     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4356   }
4357
4358   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4359   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4360     fhMCcorrectionsMax->SetBinContent(j,0.10);
4361   }
4362
4363   // MC D EFF CORRECTION
4364   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4365   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4366     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4367   }
4368
4369   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4370   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4371     fhMCDefficiencyMax->SetBinContent(j,0.05);
4372   }
4373
4374
4375   // Contamination from secondary tracks
4376   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4377   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4378     fhSecContaminationMin->SetBinContent(j,-0.05);
4379   }
4380
4381   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4382   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4383     fhSecContaminationMax->SetBinContent(j,0.05);
4384   }
4385
4386
4387   // MC CLOSURETEST (D meson efficiency)
4388   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4389   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4390     x=fhMCclosureTestMin->GetBinLowEdge(j);
4391     fhMCclosureTestMin->SetBinContent(j,-0.);
4392
4393     if(-0.4<x&&x<-0.2){
4394       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4395     }
4396     else if(-0.2<x&&x<-0.1){
4397       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4398     }
4399     else if(-0.1<x&&x<0.1){
4400       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4401     }
4402     else if(0.1<x&&x<0.2){
4403       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4404     }
4405     if(0.2<x&&x<0.4){
4406       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4407     }
4408   }
4409
4410   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4411   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4412     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
4413     fhMCclosureTestMax->SetBinContent(j,0.);
4414
4415     //     if(-0.4<x&&x<-0.2){
4416     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4417     //     }
4418     //     else if(-0.2<x&&x<-0.1){
4419     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4420     //     }
4421     //     else if(-0.2<x&&x<-0.1){
4422     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4423     //     }
4424     //     else if(-0.1<x&&x<0.1){
4425     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4426     //     }
4427     //     else if(0.1<x&&x<0.2){
4428     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4429     //     }
4430     //     if(0.2<x&&x<0.4){
4431     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4432     //     }
4433
4434   }
4435
4436   // Feed-down
4437
4438   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4439   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4440     x=fhBeautyFDmin->GetBinLowEdge(j);
4441     fhBeautyFDmin->SetBinContent(j,-0.05);
4442
4443   //   if(-0.4<x&&x<-0.2){
4444 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4445 //     }
4446 //     else if(-0.2<x&&x<-0.1){
4447 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4448 //     }
4449 //     else if(-0.2<x&&x<-0.1){
4450 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4451 //     }
4452 //     else if(-0.1<x&&x<0.1){
4453 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4454 //     }
4455 //     else if(0.1<x&&x<0.2){
4456 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4457 //     }
4458 //     if(0.2<x&&x<0.4){
4459 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4460 //     }
4461   }
4462
4463   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4464   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4465     x=fhBeautyFDmax->GetBinLowEdge(j);
4466     fhBeautyFDmax->SetBinContent(j,0.03);
4467
4468 //     if(-0.4<x&&x<-0.2){
4469 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4470 //     }
4471 //     else if(-0.2<x&&x<-0.1){
4472 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4473 //     }
4474 //     else if(-0.2<x&&x<-0.1){
4475 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4476 //     }
4477 //     else if(-0.1<x&&x<0.1){
4478 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4479 //     }
4480 //     else if(0.1<x&&x<0.2){
4481 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4482 //     }
4483 //     if(0.2<x&&x<0.4){
4484 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4485 //     }
4486
4487   }
4488
4489 }
4490
4491 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){
4492   Printf("Setting uncertainties for Dzero pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
4493   fmeson=0;
4494   fstrmeson="Dzero";
4495   fstrptAss="ptAsMore1";
4496   fstrptD="Dpt5to8";
4497   if(!fhDeltaPhiTemplate){
4498     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4499   }
4500   Double_t x;
4501   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4502   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4503   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4504     fhYieldExtraction->SetBinContent(j,0.1);
4505   }
4506
4507   // Background D MESON candidate subtraction (side-band variations, etc.)
4508   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4509   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4510     fhBackSubtractionMin->SetBinContent(j,-0.05);
4511   }
4512
4513   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4514   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4515     fhBackSubtractionMax->SetBinContent(j,0.05);
4516   }
4517
4518   // MC CORRECTIONS:  -5%  +10% for assoc track eff
4519   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4520   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4521     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4522   }
4523
4524   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4525   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4526     fhMCcorrectionsMax->SetBinContent(j,0.10);
4527   }
4528
4529
4530   // MC D EFF CORRECTION
4531   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4532   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4533     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4534   }
4535
4536   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4537   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4538     fhMCDefficiencyMax->SetBinContent(j,0.05);
4539   }
4540
4541
4542   // Contamination from secondary tracks
4543   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4544   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4545     fhSecContaminationMin->SetBinContent(j,-0.05);
4546   }
4547
4548   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4549   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4550     fhSecContaminationMax->SetBinContent(j,0.05);
4551   }
4552
4553   // MC CLOSURETEST (D meson efficiency)
4554   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4555   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4556     x=fhMCclosureTestMin->GetBinLowEdge(j);
4557     fhMCclosureTestMin->SetBinContent(j,-0.);
4558
4559     if(-0.4<x&&x<-0.2){
4560       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4561     }
4562     else if(-0.2<x&&x<-0.1){
4563       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4564     }
4565     else if(-0.1<x&&x<0.1){
4566       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4567     }
4568     else if(0.1<x&&x<0.2){
4569       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4570     }
4571     if(0.2<x&&x<0.4){
4572       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4573     }
4574   }
4575
4576   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4577   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4578     x=fhMCclosureTestMax->GetBinLowEdge(j);
4579     fhMCclosureTestMax->SetBinContent(j,0.);
4580
4581     //     if(-0.4<x&&x<-0.2){
4582     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4583     //     }
4584     //     else if(-0.2<x&&x<-0.1){
4585     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4586     //     }
4587     //     else if(-0.2<x&&x<-0.1){
4588     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4589     //     }
4590     //     else if(-0.1<x&&x<0.1){
4591     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4592     //     }
4593     //     else if(0.1<x&&x<0.2){
4594     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4595     //     }
4596     //     if(0.2<x&&x<0.4){
4597     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4598     //     }
4599
4600   }
4601
4602   // Feed-down
4603
4604   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4605   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4606     x=fhBeautyFDmin->GetBinLowEdge(j);
4607     fhBeautyFDmin->SetBinContent(j,-0.05);
4608
4609   //   if(-0.4<x&&x<-0.2){
4610 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4611 //     }
4612 //     else if(-0.2<x&&x<-0.1){
4613 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4614 //     }
4615 //     else if(-0.2<x&&x<-0.1){
4616 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4617 //     }
4618 //     else if(-0.1<x&&x<0.1){
4619 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4620 //     }
4621 //     else if(0.1<x&&x<0.2){
4622 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4623 //     }
4624 //     if(0.2<x&&x<0.4){
4625 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4626 //     }
4627   }
4628
4629   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4630   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4631     x=fhBeautyFDmax->GetBinLowEdge(j);
4632     fhBeautyFDmax->SetBinContent(j,0.03);
4633
4634 //     if(-0.4<x&&x<-0.2){
4635 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4636 //     }
4637 //     else if(-0.2<x&&x<-0.1){
4638 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4639 //     }
4640 //     else if(-0.2<x&&x<-0.1){
4641 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4642 //     }
4643 //     else if(-0.1<x&&x<0.1){
4644 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4645 //     }
4646 //     else if(0.1<x&&x<0.2){
4647 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4648 //     }
4649 //     if(0.2<x&&x<0.4){
4650 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4651 //     }
4652
4653   }
4654
4655 }
4656
4657
4658 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
4659   Printf("Setting uncertainties for Dzero pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
4660   fmeson=0;
4661   fstrmeson="Dzero";
4662   fstrptAss="ptAsMore1";
4663   fstrptD="Dpt8to16";
4664   if(!fhDeltaPhiTemplate){
4665     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4666   }
4667
4668   Double_t x;
4669   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4670   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4671   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4672     fhYieldExtraction->SetBinContent(j,0.1);
4673   }
4674
4675   // Background D MESON candidate subtraction (side-band variations, etc.)
4676   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4677   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4678     fhBackSubtractionMin->SetBinContent(j,-0.05);
4679   }
4680
4681   // Background D MESON candidate subtraction (side-band variations, etc.)
4682   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4683   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4684     fhBackSubtractionMax->SetBinContent(j,0.05);
4685   }
4686
4687   // MC CORRECTIONS,  -5% 10% for assoc track eff
4688   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4689   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4690     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4691   }
4692
4693   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4694   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4695     fhMCcorrectionsMax->SetBinContent(j,0.10);
4696   }
4697
4698
4699   // MC D EFF CORRECTION
4700   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4701   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4702     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4703   }
4704
4705   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4706   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4707     fhMCDefficiencyMax->SetBinContent(j,0.05);
4708   }
4709
4710
4711   // Contamination from secondary tracks
4712   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4713   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4714     fhSecContaminationMin->SetBinContent(j,-0.05);
4715   }
4716
4717   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4718   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4719     fhSecContaminationMax->SetBinContent(j,0.05);
4720   }
4721
4722   // MC CLOSURETEST (D meson efficiency)
4723   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4724   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4725     x=fhMCclosureTestMin->GetBinLowEdge(j);
4726     fhMCclosureTestMin->SetBinContent(j,-0.);
4727
4728     if(-0.4<x&&x<-0.2){
4729       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4730     }
4731     else if(-0.2<x&&x<-0.1){
4732       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4733     }
4734     else if(-0.1<x&&x<0.1){
4735       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4736     }
4737     else if(0.1<x&&x<0.2){
4738       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4739     }
4740     if(0.2<x&&x<0.4){
4741       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4742     }
4743   }
4744
4745   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4746   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4747     x=fhMCclosureTestMax->GetBinLowEdge(j);
4748     fhMCclosureTestMax->SetBinContent(j,0.);
4749
4750     //     if(-0.4<x&&x<-0.2){
4751     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4752     //     }
4753     //     else if(-0.2<x&&x<-0.1){
4754     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4755     //     }
4756     //     else if(-0.2<x&&x<-0.1){
4757     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4758     //     }
4759     //     else if(-0.1<x&&x<0.1){
4760     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4761     //     }
4762     //     else if(0.1<x&&x<0.2){
4763     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4764     //     }
4765     //     if(0.2<x&&x<0.4){
4766     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4767     //     }
4768
4769   }
4770
4771   // Feed-down
4772
4773   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4774   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4775     x=fhBeautyFDmin->GetBinLowEdge(j);
4776     fhBeautyFDmin->SetBinContent(j,-0.05);
4777
4778   //   if(-0.4<x&&x<-0.2){
4779 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4780 //     }
4781 //     else if(-0.2<x&&x<-0.1){
4782 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4783 //     }
4784 //     else if(-0.2<x&&x<-0.1){
4785 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4786 //     }
4787 //     else if(-0.1<x&&x<0.1){
4788 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4789 //     }
4790 //     else if(0.1<x&&x<0.2){
4791 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4792 //     }
4793 //     if(0.2<x&&x<0.4){
4794 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4795 //     }
4796   }
4797
4798   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4799   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4800     x=fhBeautyFDmax->GetBinLowEdge(j);
4801     fhBeautyFDmax->SetBinContent(j,0.03);
4802
4803 //     if(-0.4<x&&x<-0.2){
4804 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4805 //     }
4806 //     else if(-0.2<x&&x<-0.1){
4807 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4808 //     }
4809 //     else if(-0.2<x&&x<-0.1){
4810 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4811 //     }
4812 //     else if(-0.1<x&&x<0.1){
4813 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4814 //     }
4815 //     else if(0.1<x&&x<0.2){
4816 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4817 //     }
4818 //     if(0.2<x&&x<0.4){
4819 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4820 //     }
4821
4822   }
4823
4824 }
4825
4826
4827
4828
4829 //--------------------------------------------------
4830 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
4831   Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
4832   fmeson=1;
4833   fstrmeson="Dstar";
4834   fstrptAss="ptAsMore1";
4835   fstrptD="Dpt3to5";
4836   if(!fhDeltaPhiTemplate){
4837     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
4838   }
4839   Double_t x;
4840   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
4841   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
4842   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
4843     fhYieldExtraction->SetBinContent(j,0.1);
4844   }
4845
4846   // Background D MESON candidate subtraction (side-band variations, etc.)
4847   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
4848   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
4849     fhBackSubtractionMin->SetBinContent(j,-0.05);
4850   }
4851
4852   // Background D MESON candidate subtraction (side-band variations, etc.)
4853   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
4854   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
4855     fhBackSubtractionMax->SetBinContent(j,0.05);
4856   }
4857
4858   // MC CORRECTIONS, -5%  10% for assoc track eff
4859   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
4860   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
4861     fhMCcorrectionsMin->SetBinContent(j,-0.05);
4862   }
4863
4864   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
4865   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
4866     fhMCcorrectionsMax->SetBinContent(j,0.10);
4867   }
4868
4869
4870   // MC D EFF CORRECTION
4871   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
4872   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
4873     fhMCDefficiencyMin->SetBinContent(j,-0.05);
4874   }
4875
4876   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
4877   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
4878     fhMCDefficiencyMax->SetBinContent(j,0.05);
4879   }
4880
4881
4882   // Contamination from secondary tracks
4883   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
4884   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
4885     fhSecContaminationMin->SetBinContent(j,-0.05);
4886   }
4887
4888   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
4889   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
4890     fhSecContaminationMax->SetBinContent(j,0.05);
4891   }
4892
4893   // MC CLOSURETEST (D meson efficiency)
4894   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
4895   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
4896     x=fhMCclosureTestMin->GetBinLowEdge(j);
4897     fhMCclosureTestMin->SetBinContent(j,-0.08);
4898
4899     if(-0.4<x&&x<-0.2){
4900       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4901     }
4902     else if(-0.2<x&&x<-0.1){
4903       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4904     }
4905     else if(-0.1<x&&x<0.1){
4906       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
4907     }
4908     else if(0.1<x&&x<0.2){
4909       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
4910     }
4911     if(0.2<x&&x<0.4){
4912       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
4913     }
4914   }
4915
4916   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
4917   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
4918     x=fhMCclosureTestMax->GetBinLowEdge(j);
4919     fhMCclosureTestMax->SetBinContent(j,0.);
4920
4921     //     if(-0.4<x&&x<-0.2){
4922     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4923     //     }
4924     //     else if(-0.2<x&&x<-0.1){
4925     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4926     //     }
4927     //     else if(-0.2<x&&x<-0.1){
4928     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4929     //     }
4930     //     else if(-0.1<x&&x<0.1){
4931     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
4932     //     }
4933     //     else if(0.1<x&&x<0.2){
4934     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
4935     //     }
4936     //     if(0.2<x&&x<0.4){
4937     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
4938     //     }
4939
4940   }
4941
4942   // Feed-down
4943
4944   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
4945   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
4946     x=fhBeautyFDmin->GetBinLowEdge(j);
4947     fhBeautyFDmin->SetBinContent(j,-0.05);
4948
4949   //   if(-0.4<x&&x<-0.2){
4950 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4951 //     }
4952 //     else if(-0.2<x&&x<-0.1){
4953 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4954 //     }
4955 //     else if(-0.2<x&&x<-0.1){
4956 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4957 //     }
4958 //     else if(-0.1<x&&x<0.1){
4959 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
4960 //     }
4961 //     else if(0.1<x&&x<0.2){
4962 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
4963 //     }
4964 //     if(0.2<x&&x<0.4){
4965 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
4966 //     }
4967   }
4968
4969   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
4970   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
4971     x=fhBeautyFDmax->GetBinLowEdge(j);
4972     fhBeautyFDmax->SetBinContent(j,0.03);
4973
4974 //     if(-0.4<x&&x<-0.2){
4975 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4976 //     }
4977 //     else if(-0.2<x&&x<-0.1){
4978 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4979 //     }
4980 //     else if(-0.2<x&&x<-0.1){
4981 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4982 //     }
4983 //     else if(-0.1<x&&x<0.1){
4984 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
4985 //     }
4986 //     else if(0.1<x&&x<0.2){
4987 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
4988 //     }
4989 //     if(0.2<x&&x<0.4){
4990 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
4991 //     }
4992
4993   }
4994
4995
4996 }
4997
4998 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){
4999   Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
5000   fmeson=1;
5001   fstrmeson="Dstar";
5002   fstrptAss="ptAsMore1";
5003   fstrptD="Dpt5to8";
5004   if(!fhDeltaPhiTemplate){
5005     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5006   }
5007   Double_t x;
5008   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5009   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5010   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5011     fhYieldExtraction->SetBinContent(j,0.1);
5012   }
5013
5014   // Background D MESON candidate subtraction (side-band variations, etc.)
5015   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5016   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5017     fhBackSubtractionMin->SetBinContent(j,-0.05);
5018   }
5019
5020   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5021   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5022     fhBackSubtractionMax->SetBinContent(j,0.05);
5023   }
5024
5025   // MC CORRECTIONS/ -5%  10% for assoc track eff
5026   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5027   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5028     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5029   }
5030
5031   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5032   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5033     fhMCcorrectionsMax->SetBinContent(j,0.10);
5034   }
5035
5036   // MC D EFF CORRECTION
5037   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5038   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5039     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5040   }
5041
5042   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5043   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5044     fhMCDefficiencyMax->SetBinContent(j,0.05);
5045   }
5046
5047
5048   // Contamination from secondary tracks
5049   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5050   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5051     fhSecContaminationMin->SetBinContent(j,-0.05);
5052   }
5053
5054   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5055   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5056     fhSecContaminationMax->SetBinContent(j,0.05);
5057   }
5058
5059   // MC CLOSURETEST (D meson efficiency)
5060   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5061   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5062     x=fhMCclosureTestMin->GetBinLowEdge(j);
5063     fhMCclosureTestMin->SetBinContent(j,-0.08);
5064
5065     if(-0.4<x&&x<-0.2){
5066       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5067     }
5068     else if(-0.2<x&&x<-0.1){
5069       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5070     }
5071     else if(-0.1<x&&x<0.1){
5072       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5073     }
5074     else if(0.1<x&&x<0.2){
5075       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5076     }
5077     if(0.2<x&&x<0.4){
5078       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5079     }
5080   }
5081
5082   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5083   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5084     x=fhMCclosureTestMax->GetBinLowEdge(j);
5085     fhMCclosureTestMax->SetBinContent(j,0.);
5086
5087     //     if(-0.4<x&&x<-0.2){
5088     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5089     //     }
5090     //     else if(-0.2<x&&x<-0.1){
5091     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5092     //     }
5093     //     else if(-0.2<x&&x<-0.1){
5094     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5095     //     }
5096     //     else if(-0.1<x&&x<0.1){
5097     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5098     //     }
5099     //     else if(0.1<x&&x<0.2){
5100     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5101     //     }
5102     //     if(0.2<x&&x<0.4){
5103     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5104     //     }
5105
5106   }
5107
5108   // Feed-down
5109
5110   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5111   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5112     x=fhBeautyFDmin->GetBinLowEdge(j);
5113     fhBeautyFDmin->SetBinContent(j,-0.05);
5114
5115   //   if(-0.4<x&&x<-0.2){
5116 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5117 //     }
5118 //     else if(-0.2<x&&x<-0.1){
5119 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5120 //     }
5121 //     else if(-0.2<x&&x<-0.1){
5122 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5123 //     }
5124 //     else if(-0.1<x&&x<0.1){
5125 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5126 //     }
5127 //     else if(0.1<x&&x<0.2){
5128 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5129 //     }
5130 //     if(0.2<x&&x<0.4){
5131 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5132 //     }
5133   }
5134
5135   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5136   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5137     x=fhBeautyFDmax->GetBinLowEdge(j);
5138     fhBeautyFDmax->SetBinContent(j,0.03);
5139
5140 //     if(-0.4<x&&x<-0.2){
5141 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5142 //     }
5143 //     else if(-0.2<x&&x<-0.1){
5144 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5145 //     }
5146 //     else if(-0.2<x&&x<-0.1){
5147 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5148 //     }
5149 //     else if(-0.1<x&&x<0.1){
5150 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5151 //     }
5152 //     else if(0.1<x&&x<0.2){
5153 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5154 //     }
5155 //     if(0.2<x&&x<0.4){
5156 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5157 //     }
5158
5159   }
5160
5161 }
5162
5163
5164
5165 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){
5166   Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5167   fmeson=1;
5168   fstrmeson="Dstar";
5169   fstrptAss="ptAsMore1";
5170   fstrptD="Dpt8to16";
5171   if(!fhDeltaPhiTemplate){
5172     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5173   }
5174   Double_t x;
5175   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5176   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5177   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5178     fhYieldExtraction->SetBinContent(j,0.1);
5179   }
5180
5181   // Background D MESON candidate subtraction (side-band variations, etc.)
5182   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5183   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5184     fhBackSubtractionMin->SetBinContent(j,-0.12);
5185   }
5186
5187   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5188   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5189
5190       fhBackSubtractionMax->SetBinContent(j,0.12);
5191   }
5192
5193   // MC CORRECTIONS   -5% +10% for assoc track eff
5194   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5195   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5196     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5197   }
5198
5199   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5200   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5201     fhMCcorrectionsMax->SetBinContent(j,0.10);
5202   }
5203   // MC D EFF CORRECTION
5204   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5205   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5206     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5207   }
5208
5209   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5210   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5211     fhMCDefficiencyMax->SetBinContent(j,0.05);
5212   }
5213
5214
5215   // Contamination from secondary tracks
5216   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5217   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5218     fhSecContaminationMin->SetBinContent(j,-0.05);
5219   }
5220
5221   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5222   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5223     fhSecContaminationMax->SetBinContent(j,0.05);
5224   }
5225
5226   // MC CLOSURETEST (D meson efficiency)
5227   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5228   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5229     x=fhMCclosureTestMin->GetBinLowEdge(j);
5230     fhMCclosureTestMin->SetBinContent(j,-0.08);
5231
5232     if(-0.4<x&&x<-0.2){
5233       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5234     }
5235     else if(-0.2<x&&x<-0.1){
5236       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5237     }
5238     else if(-0.1<x&&x<0.1){
5239       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5240     }
5241     else if(0.1<x&&x<0.2){
5242       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5243     }
5244     if(0.2<x&&x<0.4){
5245       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5246     }
5247   }
5248
5249   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5250   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5251     x=fhMCclosureTestMax->GetBinLowEdge(j);
5252     fhMCclosureTestMax->SetBinContent(j,0.);
5253
5254     //     if(-0.4<x&&x<-0.2){
5255     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5256     //     }
5257     //     else if(-0.2<x&&x<-0.1){
5258     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5259     //     }
5260     //     else if(-0.2<x&&x<-0.1){
5261     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5262     //     }
5263     //     else if(-0.1<x&&x<0.1){
5264     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5265     //     }
5266     //     else if(0.1<x&&x<0.2){
5267     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5268     //     }
5269     //     if(0.2<x&&x<0.4){
5270     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5271     //     }
5272
5273   }
5274
5275   // Feed-down
5276
5277   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5278   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5279     x=fhBeautyFDmin->GetBinLowEdge(j);
5280     fhBeautyFDmin->SetBinContent(j,-0.05);
5281
5282   //   if(-0.4<x&&x<-0.2){
5283 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5284 //     }
5285 //     else if(-0.2<x&&x<-0.1){
5286 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5287 //     }
5288 //     else if(-0.2<x&&x<-0.1){
5289 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5290 //     }
5291 //     else if(-0.1<x&&x<0.1){
5292 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5293 //     }
5294 //     else if(0.1<x&&x<0.2){
5295 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5296 //     }
5297 //     if(0.2<x&&x<0.4){
5298 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5299 //     }
5300   }
5301
5302   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5303   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5304     x=fhBeautyFDmax->GetBinLowEdge(j);
5305     fhBeautyFDmax->SetBinContent(j,0.03);
5306
5307 //     if(-0.4<x&&x<-0.2){
5308 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5309 //     }
5310 //     else if(-0.2<x&&x<-0.1){
5311 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5312 //     }
5313 //     else if(-0.2<x&&x<-0.1){
5314 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5315 //     }
5316 //     else if(-0.1<x&&x<0.1){
5317 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5318 //     }
5319 //     else if(0.1<x&&x<0.2){
5320 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5321 //     }
5322 //     if(0.2<x&&x<0.4){
5323 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5324 //     }
5325
5326   }
5327
5328
5329 }
5330
5331
5332
5333 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){
5334   Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
5335   fmeson=2;
5336   fstrmeson="Dplus";
5337   fstrptAss="ptAsMore1";
5338   fstrptD="Dpt3to5";
5339   if(!fhDeltaPhiTemplate){
5340     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5341   }
5342   Double_t x;
5343   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5344   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5345   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5346     fhYieldExtraction->SetBinContent(j,0.1);
5347   }
5348
5349   // Background D MESON candidate subtraction (side-band variations, etc.)
5350   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5351   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5352     fhBackSubtractionMin->SetBinContent(j,-0.05);
5353   }
5354
5355   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5356   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5357     fhBackSubtractionMax->SetBinContent(j,0.05);
5358   }
5359
5360
5361   // MC CORRECTIONS ( associatate track efficiency):
5362   //  -5%  +10% for assoc track eff
5363   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5364   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5365     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5366   }
5367
5368   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5369   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5370     fhMCcorrectionsMax->SetBinContent(j,0.10);
5371   }
5372
5373   // MC D EFF CORRECTION
5374   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5375   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5376     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5377   }
5378
5379   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5380   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5381     fhMCDefficiencyMax->SetBinContent(j,0.05);
5382   }
5383
5384
5385   // Contamination from secondary tracks
5386   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5387   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5388     fhSecContaminationMin->SetBinContent(j,-0.05);
5389   }
5390
5391   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5392   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5393     fhSecContaminationMax->SetBinContent(j,0.05);
5394   }
5395
5396
5397   // MC CLOSURETEST (D meson efficiency)
5398   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5399   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5400     x=fhMCclosureTestMin->GetBinLowEdge(j);
5401     fhMCclosureTestMin->SetBinContent(j,-0.0);
5402
5403     if(-0.4<x&&x<-0.2){
5404       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5405     }
5406     else if(-0.2<x&&x<-0.1){
5407       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5408     }
5409     else if(-0.1<x&&x<0.1){
5410       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5411     }
5412     else if(0.1<x&&x<0.2){
5413       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5414     }
5415     if(0.2<x&&x<0.4){
5416       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5417     }
5418   }
5419
5420   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5421   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5422     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
5423     fhMCclosureTestMax->SetBinContent(j,0.);
5424
5425     //     if(-0.4<x&&x<-0.2){
5426     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5427     //     }
5428     //     else if(-0.2<x&&x<-0.1){
5429     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5430     //     }
5431     //     else if(-0.2<x&&x<-0.1){
5432     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5433     //     }
5434     //     else if(-0.1<x&&x<0.1){
5435     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5436     //     }
5437     //     else if(0.1<x&&x<0.2){
5438     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5439     //     }
5440     //     if(0.2<x&&x<0.4){
5441     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5442     //     }
5443
5444   }
5445
5446   // Feed-down
5447
5448   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5449   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5450     x=fhBeautyFDmin->GetBinLowEdge(j);
5451     fhBeautyFDmin->SetBinContent(j,-0.05);
5452
5453   //   if(-0.4<x&&x<-0.2){
5454 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5455 //     }
5456 //     else if(-0.2<x&&x<-0.1){
5457 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5458 //     }
5459 //     else if(-0.2<x&&x<-0.1){
5460 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5461 //     }
5462 //     else if(-0.1<x&&x<0.1){
5463 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5464 //     }
5465 //     else if(0.1<x&&x<0.2){
5466 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5467 //     }
5468 //     if(0.2<x&&x<0.4){
5469 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5470 //     }
5471   }
5472
5473   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5474   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5475     x=fhBeautyFDmax->GetBinLowEdge(j);
5476     fhBeautyFDmax->SetBinContent(j,0.03);
5477
5478 //     if(-0.4<x&&x<-0.2){
5479 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5480 //     }
5481 //     else if(-0.2<x&&x<-0.1){
5482 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5483 //     }
5484 //     else if(-0.2<x&&x<-0.1){
5485 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5486 //     }
5487 //     else if(-0.1<x&&x<0.1){
5488 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5489 //     }
5490 //     else if(0.1<x&&x<0.2){
5491 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5492 //     }
5493 //     if(0.2<x&&x<0.4){
5494 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5495 //     }
5496
5497   }
5498
5499 }
5500
5501 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){
5502   Printf("Setting uncertainties for Dplus pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
5503   fmeson=2;
5504   fstrmeson="Dplus";
5505   fstrptAss="ptAsMore1";
5506   fstrptD="Dpt5to8";
5507   if(!fhDeltaPhiTemplate){
5508     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5509   }
5510   Double_t x;
5511   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5512   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5513   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5514     fhYieldExtraction->SetBinContent(j,0.1);
5515   }
5516
5517   // Background D MESON candidate subtraction (side-band variations, etc.)
5518   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5519   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5520     fhBackSubtractionMin->SetBinContent(j,-0.05);
5521   }
5522
5523   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5524   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5525     fhBackSubtractionMax->SetBinContent(j,0.05);
5526   }
5527
5528   // MC CORRECTIONS:  -5%  +10% for assoc track eff
5529   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5530   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5531     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5532   }
5533
5534   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5535   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5536     fhMCcorrectionsMax->SetBinContent(j,0.10);
5537   }
5538
5539
5540   // MC D EFF CORRECTION
5541   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5542   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5543     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5544   }
5545
5546   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5547   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5548     fhMCDefficiencyMax->SetBinContent(j,0.05);
5549   }
5550
5551
5552   // Contamination from secondary tracks
5553   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5554   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5555     fhSecContaminationMin->SetBinContent(j,-0.05);
5556   }
5557
5558   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5559   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5560     fhSecContaminationMax->SetBinContent(j,0.05);
5561   }
5562
5563   // MC CLOSURETEST (D meson efficiency)
5564   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5565   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5566     x=fhMCclosureTestMin->GetBinLowEdge(j);
5567     fhMCclosureTestMin->SetBinContent(j,-0.0);
5568
5569     if(-0.4<x&&x<-0.2){
5570       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5571     }
5572     else if(-0.2<x&&x<-0.1){
5573       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5574     }
5575     else if(-0.1<x&&x<0.1){
5576       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5577     }
5578     else if(0.1<x&&x<0.2){
5579       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5580     }
5581     if(0.2<x&&x<0.4){
5582       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5583     }
5584   }
5585
5586   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5587   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5588     x=fhMCclosureTestMax->GetBinLowEdge(j);
5589     fhMCclosureTestMax->SetBinContent(j,0.);
5590
5591     //     if(-0.4<x&&x<-0.2){
5592     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5593     //     }
5594     //     else if(-0.2<x&&x<-0.1){
5595     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5596     //     }
5597     //     else if(-0.2<x&&x<-0.1){
5598     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5599     //     }
5600     //     else if(-0.1<x&&x<0.1){
5601     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5602     //     }
5603     //     else if(0.1<x&&x<0.2){
5604     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5605     //     }
5606     //     if(0.2<x&&x<0.4){
5607     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5608     //     }
5609
5610   }
5611
5612   // Feed-down
5613
5614   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5615   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5616     x=fhBeautyFDmin->GetBinLowEdge(j);
5617     fhBeautyFDmin->SetBinContent(j,-0.05);
5618
5619   //   if(-0.4<x&&x<-0.2){
5620 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5621 //     }
5622 //     else if(-0.2<x&&x<-0.1){
5623 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5624 //     }
5625 //     else if(-0.2<x&&x<-0.1){
5626 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5627 //     }
5628 //     else if(-0.1<x&&x<0.1){
5629 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5630 //     }
5631 //     else if(0.1<x&&x<0.2){
5632 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5633 //     }
5634 //     if(0.2<x&&x<0.4){
5635 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5636 //     }
5637   }
5638
5639   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5640   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5641     x=fhBeautyFDmax->GetBinLowEdge(j);
5642     fhBeautyFDmax->SetBinContent(j,0.03);
5643
5644 //     if(-0.4<x&&x<-0.2){
5645 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5646 //     }
5647 //     else if(-0.2<x&&x<-0.1){
5648 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5649 //     }
5650 //     else if(-0.2<x&&x<-0.1){
5651 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5652 //     }
5653 //     else if(-0.1<x&&x<0.1){
5654 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5655 //     }
5656 //     else if(0.1<x&&x<0.2){
5657 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5658 //     }
5659 //     if(0.2<x&&x<0.4){
5660 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5661 //     }
5662
5663   }
5664
5665 }
5666
5667
5668 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
5669   Printf("Setting uncertainties for Dplus pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
5670   fmeson=2;
5671   fstrmeson="Dplus";
5672   fstrptAss="ptAsMore1";
5673   fstrptD="Dpt8to16";
5674   if(!fhDeltaPhiTemplate){
5675     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5676   }
5677
5678   Double_t x;
5679   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5680   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5681   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5682     fhYieldExtraction->SetBinContent(j,0.1);
5683   }
5684
5685   // Background D MESON candidate subtraction (side-band variations, etc.)
5686   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5687   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5688     fhBackSubtractionMin->SetBinContent(j,-0.05);
5689   }
5690
5691   // Background D MESON candidate subtraction (side-band variations, etc.)
5692   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5693   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5694     fhBackSubtractionMax->SetBinContent(j,0.05);
5695   }
5696
5697   // MC CORRECTIONS,  -5% 10% for assoc track eff
5698   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5699   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5700     fhMCcorrectionsMin->SetBinContent(j,-0.05);
5701   }
5702
5703   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5704   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5705     fhMCcorrectionsMax->SetBinContent(j,0.10);
5706   }
5707
5708
5709   // MC D EFF CORRECTION
5710   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5711   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5712     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5713   }
5714
5715   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5716   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5717     fhMCDefficiencyMax->SetBinContent(j,0.05);
5718   }
5719
5720
5721   // Contamination from secondary tracks
5722   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5723   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5724     fhSecContaminationMin->SetBinContent(j,-0.05);
5725   }
5726
5727   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5728   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5729     fhSecContaminationMax->SetBinContent(j,0.05);
5730   }
5731
5732   // MC CLOSURETEST (D meson efficiency)
5733   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5734   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5735     x=fhMCclosureTestMin->GetBinLowEdge(j);
5736     fhMCclosureTestMin->SetBinContent(j,-0.0);
5737
5738     if(-0.4<x&&x<-0.2){
5739       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5740     }
5741     else if(-0.2<x&&x<-0.1){
5742       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5743     }
5744     else if(-0.1<x&&x<0.1){
5745       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5746     }
5747     else if(0.1<x&&x<0.2){
5748       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5749     }
5750     if(0.2<x&&x<0.4){
5751       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5752     }
5753   }
5754
5755   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5756   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5757     x=fhMCclosureTestMax->GetBinLowEdge(j);
5758     fhMCclosureTestMax->SetBinContent(j,0.);
5759
5760     //     if(-0.4<x&&x<-0.2){
5761     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5762     //     }
5763     //     else if(-0.2<x&&x<-0.1){
5764     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5765     //     }
5766     //     else if(-0.2<x&&x<-0.1){
5767     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5768     //     }
5769     //     else if(-0.1<x&&x<0.1){
5770     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5771     //     }
5772     //     else if(0.1<x&&x<0.2){
5773     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5774     //     }
5775     //     if(0.2<x&&x<0.4){
5776     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5777     //     }
5778
5779   }
5780
5781   // Feed-down
5782
5783   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5784   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5785     x=fhBeautyFDmin->GetBinLowEdge(j);
5786     fhBeautyFDmin->SetBinContent(j,-0.05);
5787
5788   //   if(-0.4<x&&x<-0.2){
5789 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5790 //     }
5791 //     else if(-0.2<x&&x<-0.1){
5792 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5793 //     }
5794 //     else if(-0.2<x&&x<-0.1){
5795 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5796 //     }
5797 //     else if(-0.1<x&&x<0.1){
5798 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5799 //     }
5800 //     else if(0.1<x&&x<0.2){
5801 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5802 //     }
5803 //     if(0.2<x&&x<0.4){
5804 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5805 //     }
5806   }
5807
5808   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5809   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5810     x=fhBeautyFDmax->GetBinLowEdge(j);
5811     fhBeautyFDmax->SetBinContent(j,0.03);
5812
5813 //     if(-0.4<x&&x<-0.2){
5814 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5815 //     }
5816 //     else if(-0.2<x&&x<-0.1){
5817 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5818 //     }
5819 //     else if(-0.2<x&&x<-0.1){
5820 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5821 //     }
5822 //     else if(-0.1<x&&x<0.1){
5823 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
5824 //     }
5825 //     else if(0.1<x&&x<0.2){
5826 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
5827 //     }
5828 //     if(0.2<x&&x<0.4){
5829 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5830 //     }
5831
5832   }
5833
5834 }
5835
5836
5837
5838
5839
5840
5841 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5842 /////
5843 ///// METHODS WITH UNCERTAINTIES: pPb 2013
5844 /////
5845 ////////////////////////////////////////////////////////////////////////////////////////////////////////
5846
5847
5848 // pt assoc > 0.3 GeV/c
5849
5850 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
5851   Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
5852   fmeson=0;
5853   fstrmeson="Dzero";
5854   fstrptAss="ptAsMore03";
5855   fstrptD="Dpt3to5";
5856   if(!fhDeltaPhiTemplate){
5857     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
5858   }
5859   Double_t x;
5860   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
5861   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
5862   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
5863     fhYieldExtraction->SetBinContent(j,0.1);
5864   }
5865
5866   // Background D MESON candidate subtraction (side-band variations, etc.)
5867   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
5868   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
5869     fhBackSubtractionMin->SetBinContent(j,-0.05);
5870   }
5871
5872   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
5873   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
5874     fhBackSubtractionMax->SetBinContent(j,0.05);
5875   }
5876
5877
5878   // MC CORRECTIONS ( associatate track efficiency):
5879   //  -5%  +10% for assoc track eff
5880   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
5881   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
5882     fhMCcorrectionsMin->SetBinContent(j,-0.04);
5883   }
5884
5885   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
5886   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
5887     fhMCcorrectionsMax->SetBinContent(j,0.04);
5888   }
5889
5890   // MC D EFF CORRECTION
5891   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
5892   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
5893     fhMCDefficiencyMin->SetBinContent(j,-0.05);
5894   }
5895
5896   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
5897   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
5898     fhMCDefficiencyMax->SetBinContent(j,0.05);
5899   }
5900
5901
5902   // Contamination from secondary tracks
5903   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
5904   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
5905     fhSecContaminationMin->SetBinContent(j,-0.035);
5906   }
5907
5908   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
5909   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
5910     fhSecContaminationMax->SetBinContent(j,0.035);
5911   }
5912
5913
5914   // MC CLOSURETEST (D meson efficiency)
5915   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
5916   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
5917     x=fhMCclosureTestMin->GetBinLowEdge(j);
5918     fhMCclosureTestMin->SetBinContent(j,-0.);
5919
5920     if(-0.4<x&&x<-0.2){
5921       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5922     }
5923     else if(-0.2<x&&x<-0.1){
5924       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5925     }
5926     else if(-0.1<x&&x<0.1){
5927       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
5928     }
5929     else if(0.1<x&&x<0.2){
5930       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
5931     }
5932     if(0.2<x&&x<0.4){
5933       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
5934     }
5935   }
5936
5937   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
5938   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
5939     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
5940     fhMCclosureTestMax->SetBinContent(j,0.08);
5941
5942     //     if(-0.4<x&&x<-0.2){
5943     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5944     //     }
5945     //     else if(-0.2<x&&x<-0.1){
5946     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5947     //     }
5948     //     else if(-0.2<x&&x<-0.1){
5949     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5950     //     }
5951     //     else if(-0.1<x&&x<0.1){
5952     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
5953     //     }
5954     //     else if(0.1<x&&x<0.2){
5955     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
5956     //     }
5957     //     if(0.2<x&&x<0.4){
5958     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
5959     //     }
5960
5961   }
5962
5963   // Feed-down
5964
5965   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
5966   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
5967     x=fhBeautyFDmin->GetBinLowEdge(j);
5968     fhBeautyFDmin->SetBinContent(j,-0.05);
5969
5970   //   if(-0.4<x&&x<-0.2){
5971 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5972 //     }
5973 //     else if(-0.2<x&&x<-0.1){
5974 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5975 //     }
5976 //     else if(-0.2<x&&x<-0.1){
5977 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5978 //     }
5979 //     else if(-0.1<x&&x<0.1){
5980 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
5981 //     }
5982 //     else if(0.1<x&&x<0.2){
5983 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
5984 //     }
5985 //     if(0.2<x&&x<0.4){
5986 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
5987 //     }
5988   }
5989
5990   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
5991   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
5992     x=fhBeautyFDmax->GetBinLowEdge(j);
5993     fhBeautyFDmax->SetBinContent(j,0.03);
5994
5995 //     if(-0.4<x&&x<-0.2){
5996 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
5997 //     }
5998 //     else if(-0.2<x&&x<-0.1){
5999 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6000 //     }
6001 //     else if(-0.2<x&&x<-0.1){
6002 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6003 //     }
6004 //     else if(-0.1<x&&x<0.1){
6005 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6006 //     }
6007 //     else if(0.1<x&&x<0.2){
6008 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6009 //     }
6010 //     if(0.2<x&&x<0.4){
6011 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6012 //     }
6013
6014   }
6015
6016 }
6017
6018 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
6019   Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
6020   fmeson=0;
6021   fstrmeson="Dzero";
6022   fstrptAss="ptAsMore03";
6023   fstrptD="Dpt5to8";
6024   if(!fhDeltaPhiTemplate){
6025     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6026   }
6027   Double_t x;
6028   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6029   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6030   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6031     fhYieldExtraction->SetBinContent(j,0.1);
6032   }
6033
6034   // Background D MESON candidate subtraction (side-band variations, etc.)
6035   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6036   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6037     fhBackSubtractionMin->SetBinContent(j,-0.05);
6038   }
6039
6040   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6041   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6042     fhBackSubtractionMax->SetBinContent(j,0.05);
6043   }
6044
6045   // MC CORRECTIONS:  -5%  +10% for assoc track eff
6046   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6047   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6048     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6049   }
6050
6051   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6052   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6053     fhMCcorrectionsMax->SetBinContent(j,0.04);
6054   }
6055
6056
6057   // MC D EFF CORRECTION
6058   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6059   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6060     fhMCDefficiencyMin->SetBinContent(j,-0.05);
6061   }
6062
6063   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6064   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6065     fhMCDefficiencyMax->SetBinContent(j,0.05);
6066   }
6067
6068
6069   // Contamination from secondary tracks
6070   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6071   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6072     fhSecContaminationMin->SetBinContent(j,-0.035);
6073   }
6074
6075   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6076   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6077     fhSecContaminationMax->SetBinContent(j,0.035);
6078   }
6079
6080   // MC CLOSURETEST (D meson efficiency)
6081   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6082   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6083     x=fhMCclosureTestMin->GetBinLowEdge(j);
6084     fhMCclosureTestMin->SetBinContent(j,-0.);
6085
6086     if(-0.4<x&&x<-0.2){
6087       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6088     }
6089     else if(-0.2<x&&x<-0.1){
6090       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6091     }
6092     else if(-0.1<x&&x<0.1){
6093       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6094     }
6095     else if(0.1<x&&x<0.2){
6096       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6097     }
6098     if(0.2<x&&x<0.4){
6099       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6100     }
6101   }
6102
6103   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6104   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6105     x=fhMCclosureTestMax->GetBinLowEdge(j);
6106     fhMCclosureTestMax->SetBinContent(j,0.08);
6107
6108     //     if(-0.4<x&&x<-0.2){
6109     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6110     //     }
6111     //     else if(-0.2<x&&x<-0.1){
6112     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6113     //     }
6114     //     else if(-0.2<x&&x<-0.1){
6115     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6116     //     }
6117     //     else if(-0.1<x&&x<0.1){
6118     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6119     //     }
6120     //     else if(0.1<x&&x<0.2){
6121     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6122     //     }
6123     //     if(0.2<x&&x<0.4){
6124     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6125     //     }
6126
6127   }
6128
6129   // Feed-down
6130
6131   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6132   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6133     x=fhBeautyFDmin->GetBinLowEdge(j);
6134     fhBeautyFDmin->SetBinContent(j,-0.05);
6135
6136   //   if(-0.4<x&&x<-0.2){
6137 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6138 //     }
6139 //     else if(-0.2<x&&x<-0.1){
6140 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6141 //     }
6142 //     else if(-0.2<x&&x<-0.1){
6143 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6144 //     }
6145 //     else if(-0.1<x&&x<0.1){
6146 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6147 //     }
6148 //     else if(0.1<x&&x<0.2){
6149 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6150 //     }
6151 //     if(0.2<x&&x<0.4){
6152 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6153 //     }
6154   }
6155
6156   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6157   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6158     x=fhBeautyFDmax->GetBinLowEdge(j);
6159     fhBeautyFDmax->SetBinContent(j,0.03);
6160
6161 //     if(-0.4<x&&x<-0.2){
6162 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6163 //     }
6164 //     else if(-0.2<x&&x<-0.1){
6165 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6166 //     }
6167 //     else if(-0.2<x&&x<-0.1){
6168 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6169 //     }
6170 //     else if(-0.1<x&&x<0.1){
6171 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6172 //     }
6173 //     else if(0.1<x&&x<0.2){
6174 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6175 //     }
6176 //     if(0.2<x&&x<0.4){
6177 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6178 //     }
6179
6180   }
6181
6182 }
6183
6184
6185 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03(){
6186   Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
6187   fmeson=0;
6188   fstrmeson="Dzero";
6189   fstrptAss="ptAsMore03";
6190   fstrptD="Dpt8to16";
6191   if(!fhDeltaPhiTemplate){
6192     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6193   }
6194
6195   Double_t x;
6196   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6197   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6198   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6199     fhYieldExtraction->SetBinContent(j,0.1);
6200   }
6201
6202   // Background D MESON candidate subtraction (side-band variations, etc.)
6203   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6204   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6205     fhBackSubtractionMin->SetBinContent(j,-0.05);
6206   }
6207
6208   // Background D MESON candidate subtraction (side-band variations, etc.)
6209   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6210   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6211     fhBackSubtractionMax->SetBinContent(j,0.05);
6212   }
6213
6214   // MC CORRECTIONS,  -5% 10% for assoc track eff
6215   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6216   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6217     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6218   }
6219
6220   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6221   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6222     fhMCcorrectionsMax->SetBinContent(j,0.04);
6223   }
6224
6225
6226   // MC D EFF CORRECTION
6227   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6228   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6229     fhMCDefficiencyMin->SetBinContent(j,-0.05);
6230   }
6231
6232   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6233   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6234     fhMCDefficiencyMax->SetBinContent(j,0.05);
6235   }
6236
6237
6238   // Contamination from secondary tracks
6239   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6240   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6241     fhSecContaminationMin->SetBinContent(j,-0.035);
6242   }
6243
6244   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6245   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6246     fhSecContaminationMax->SetBinContent(j,0.035);
6247   }
6248
6249   // MC CLOSURETEST (D meson efficiency)
6250   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6251   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6252     x=fhMCclosureTestMin->GetBinLowEdge(j);
6253     fhMCclosureTestMin->SetBinContent(j,-0.);
6254
6255     if(-0.4<x&&x<-0.2){
6256       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6257     }
6258     else if(-0.2<x&&x<-0.1){
6259       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6260     }
6261     else if(-0.1<x&&x<0.1){
6262       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6263     }
6264     else if(0.1<x&&x<0.2){
6265       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6266     }
6267     if(0.2<x&&x<0.4){
6268       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6269     }
6270   }
6271
6272   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6273   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6274     x=fhMCclosureTestMax->GetBinLowEdge(j);
6275     fhMCclosureTestMax->SetBinContent(j,0.08);
6276
6277     //     if(-0.4<x&&x<-0.2){
6278     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6279     //     }
6280     //     else if(-0.2<x&&x<-0.1){
6281     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6282     //     }
6283     //     else if(-0.2<x&&x<-0.1){
6284     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6285     //     }
6286     //     else if(-0.1<x&&x<0.1){
6287     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6288     //     }
6289     //     else if(0.1<x&&x<0.2){
6290     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6291     //     }
6292     //     if(0.2<x&&x<0.4){
6293     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6294     //     }
6295
6296   }
6297
6298   // Feed-down
6299
6300   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6301   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6302     x=fhBeautyFDmin->GetBinLowEdge(j);
6303     fhBeautyFDmin->SetBinContent(j,-0.05);
6304
6305   //   if(-0.4<x&&x<-0.2){
6306 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6307 //     }
6308 //     else if(-0.2<x&&x<-0.1){
6309 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6310 //     }
6311 //     else if(-0.2<x&&x<-0.1){
6312 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6313 //     }
6314 //     else if(-0.1<x&&x<0.1){
6315 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6316 //     }
6317 //     else if(0.1<x&&x<0.2){
6318 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6319 //     }
6320 //     if(0.2<x&&x<0.4){
6321 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6322 //     }
6323   }
6324
6325   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6326   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6327     x=fhBeautyFDmax->GetBinLowEdge(j);
6328     fhBeautyFDmax->SetBinContent(j,0.03);
6329
6330 //     if(-0.4<x&&x<-0.2){
6331 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6332 //     }
6333 //     else if(-0.2<x&&x<-0.1){
6334 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6335 //     }
6336 //     else if(-0.2<x&&x<-0.1){
6337 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6338 //     }
6339 //     else if(-0.1<x&&x<0.1){
6340 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6341 //     }
6342 //     else if(0.1<x&&x<0.2){
6343 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6344 //     }
6345 //     if(0.2<x&&x<0.4){
6346 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6347 //     }
6348
6349   }
6350
6351 }
6352
6353
6354
6355
6356 //--------------------------------------------------
6357 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
6358   Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6359   fmeson=1;
6360   fstrmeson="Dstar";
6361   fstrptAss="ptAsMore03";
6362   fstrptD="Dpt3to5";
6363   if(!fhDeltaPhiTemplate){
6364     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6365   }
6366   Double_t x;
6367   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6368   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6369   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6370     fhYieldExtraction->SetBinContent(j,0.1);
6371   }
6372
6373   // Background D MESON candidate subtraction (side-band variations, etc.)
6374   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6375   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6376     fhBackSubtractionMin->SetBinContent(j,-0.05);
6377   }
6378
6379   // Background D MESON candidate subtraction (side-band variations, etc.)
6380   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6381   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6382     fhBackSubtractionMax->SetBinContent(j,0.05);
6383   }
6384
6385   // MC CORRECTIONS, -5%  10% for assoc track eff
6386   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6387   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6388     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6389   }
6390
6391   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6392   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6393     fhMCcorrectionsMax->SetBinContent(j,0.04);
6394   }
6395
6396
6397   // MC D EFF CORRECTION
6398   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6399   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6400     fhMCDefficiencyMin->SetBinContent(j,-0.05);
6401   }
6402
6403   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6404   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6405     fhMCDefficiencyMax->SetBinContent(j,0.05);
6406   }
6407
6408
6409   // Contamination from secondary tracks
6410   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6411   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6412     fhSecContaminationMin->SetBinContent(j,-0.035);
6413   }
6414
6415   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6416   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6417     fhSecContaminationMax->SetBinContent(j,0.035);
6418   }
6419
6420   // MC CLOSURETEST (D meson efficiency)
6421   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6422   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6423     x=fhMCclosureTestMin->GetBinLowEdge(j);
6424     fhMCclosureTestMin->SetBinContent(j,-0.);
6425
6426     if(-0.4<x&&x<-0.2){
6427       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6428     }
6429     else if(-0.2<x&&x<-0.1){
6430       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6431     }
6432     else if(-0.1<x&&x<0.1){
6433       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6434     }
6435     else if(0.1<x&&x<0.2){
6436       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6437     }
6438     if(0.2<x&&x<0.4){
6439       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6440     }
6441   }
6442
6443   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6444   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6445     x=fhMCclosureTestMax->GetBinLowEdge(j);
6446     fhMCclosureTestMax->SetBinContent(j,0.08);
6447
6448     //     if(-0.4<x&&x<-0.2){
6449     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6450     //     }
6451     //     else if(-0.2<x&&x<-0.1){
6452     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6453     //     }
6454     //     else if(-0.2<x&&x<-0.1){
6455     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6456     //     }
6457     //     else if(-0.1<x&&x<0.1){
6458     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6459     //     }
6460     //     else if(0.1<x&&x<0.2){
6461     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6462     //     }
6463     //     if(0.2<x&&x<0.4){
6464     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6465     //     }
6466
6467   }
6468
6469   // Feed-down
6470
6471   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6472   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6473     x=fhBeautyFDmin->GetBinLowEdge(j);
6474     fhBeautyFDmin->SetBinContent(j,-0.05);
6475
6476   //   if(-0.4<x&&x<-0.2){
6477 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6478 //     }
6479 //     else if(-0.2<x&&x<-0.1){
6480 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6481 //     }
6482 //     else if(-0.2<x&&x<-0.1){
6483 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6484 //     }
6485 //     else if(-0.1<x&&x<0.1){
6486 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6487 //     }
6488 //     else if(0.1<x&&x<0.2){
6489 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6490 //     }
6491 //     if(0.2<x&&x<0.4){
6492 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6493 //     }
6494   }
6495
6496   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6497   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6498     x=fhBeautyFDmax->GetBinLowEdge(j);
6499     fhBeautyFDmax->SetBinContent(j,0.03);
6500
6501 //     if(-0.4<x&&x<-0.2){
6502 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6503 //     }
6504 //     else if(-0.2<x&&x<-0.1){
6505 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6506 //     }
6507 //     else if(-0.2<x&&x<-0.1){
6508 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6509 //     }
6510 //     else if(-0.1<x&&x<0.1){
6511 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6512 //     }
6513 //     else if(0.1<x&&x<0.2){
6514 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6515 //     }
6516 //     if(0.2<x&&x<0.4){
6517 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6518 //     }
6519
6520   }
6521
6522
6523 }
6524
6525 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
6526   Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
6527   fmeson=1;
6528   fstrmeson="Dstar";
6529   fstrptAss="ptAsMore03";
6530   fstrptD="Dpt5to8";
6531   if(!fhDeltaPhiTemplate){
6532     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6533   }
6534   Double_t x;
6535   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6536   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6537   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6538     fhYieldExtraction->SetBinContent(j,0.1);
6539   }
6540
6541   // Background D MESON candidate subtraction (side-band variations, etc.)
6542   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6543   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6544     fhBackSubtractionMin->SetBinContent(j,-0.04);
6545   }
6546
6547   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6548   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6549     fhBackSubtractionMax->SetBinContent(j,0.04);
6550   }
6551
6552   // MC CORRECTIONS/ -5%  10% for assoc track eff
6553   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6554   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6555     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6556   }
6557
6558   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6559   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6560     fhMCcorrectionsMax->SetBinContent(j,0.04);
6561   }
6562
6563   // MC D EFF CORRECTION
6564   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6565   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6566     fhMCDefficiencyMin->SetBinContent(j,-0.04);
6567   }
6568
6569   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6570   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6571     fhMCDefficiencyMax->SetBinContent(j,0.04);
6572   }
6573
6574
6575   // Contamination from secondary tracks
6576   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6577   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6578     fhSecContaminationMin->SetBinContent(j,-0.035);
6579   }
6580
6581   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6582   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6583     fhSecContaminationMax->SetBinContent(j,0.035);
6584   }
6585
6586   // MC CLOSURETEST (D meson efficiency)
6587   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6588   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6589     x=fhMCclosureTestMin->GetBinLowEdge(j);
6590     fhMCclosureTestMin->SetBinContent(j,-0.0);
6591
6592     if(-0.4<x&&x<-0.2){
6593       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6594     }
6595     else if(-0.2<x&&x<-0.1){
6596       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6597     }
6598     else if(-0.1<x&&x<0.1){
6599       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6600     }
6601     else if(0.1<x&&x<0.2){
6602       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6603     }
6604     if(0.2<x&&x<0.4){
6605       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6606     }
6607   }
6608
6609   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6610   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6611     x=fhMCclosureTestMax->GetBinLowEdge(j);
6612     fhMCclosureTestMax->SetBinContent(j,0.08);
6613
6614     //     if(-0.4<x&&x<-0.2){
6615     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6616     //     }
6617     //     else if(-0.2<x&&x<-0.1){
6618     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6619     //     }
6620     //     else if(-0.2<x&&x<-0.1){
6621     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6622     //     }
6623     //     else if(-0.1<x&&x<0.1){
6624     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6625     //     }
6626     //     else if(0.1<x&&x<0.2){
6627     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6628     //     }
6629     //     if(0.2<x&&x<0.4){
6630     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6631     //     }
6632
6633   }
6634
6635   // Feed-down
6636
6637   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6638   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6639     x=fhBeautyFDmin->GetBinLowEdge(j);
6640     fhBeautyFDmin->SetBinContent(j,-0.05);
6641
6642   //   if(-0.4<x&&x<-0.2){
6643 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6644 //     }
6645 //     else if(-0.2<x&&x<-0.1){
6646 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6647 //     }
6648 //     else if(-0.2<x&&x<-0.1){
6649 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6650 //     }
6651 //     else if(-0.1<x&&x<0.1){
6652 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6653 //     }
6654 //     else if(0.1<x&&x<0.2){
6655 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6656 //     }
6657 //     if(0.2<x&&x<0.4){
6658 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6659 //     }
6660   }
6661
6662   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6663   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6664     x=fhBeautyFDmax->GetBinLowEdge(j);
6665     fhBeautyFDmax->SetBinContent(j,0.03);
6666
6667 //     if(-0.4<x&&x<-0.2){
6668 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6669 //     }
6670 //     else if(-0.2<x&&x<-0.1){
6671 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6672 //     }
6673 //     else if(-0.2<x&&x<-0.1){
6674 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6675 //     }
6676 //     else if(-0.1<x&&x<0.1){
6677 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6678 //     }
6679 //     else if(0.1<x&&x<0.2){
6680 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6681 //     }
6682 //     if(0.2<x&&x<0.4){
6683 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6684 //     }
6685
6686   }
6687
6688 }
6689
6690
6691
6692 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03(){
6693   Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
6694   fmeson=1;
6695   fstrmeson="Dstar";
6696   fstrptAss="ptAsMore03";
6697   fstrptD="Dpt8to16";
6698   if(!fhDeltaPhiTemplate){
6699     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6700   }
6701   Double_t x;
6702   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6703   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6704   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6705     fhYieldExtraction->SetBinContent(j,0.1);
6706   }
6707
6708   // Background D MESON candidate subtraction (side-band variations, etc.)
6709   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6710   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6711     fhBackSubtractionMin->SetBinContent(j,-0.05);
6712   }
6713
6714   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6715   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6716     fhBackSubtractionMax->SetBinContent(j,0.05);
6717   }
6718
6719   // MC CORRECTIONS   -5% +10% for assoc track eff
6720   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6721   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6722     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6723   }
6724
6725   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6726   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6727     fhMCcorrectionsMax->SetBinContent(j,0.04);
6728   }
6729   // MC D EFF CORRECTION
6730   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6731   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6732     fhMCDefficiencyMin->SetBinContent(j,-0.08);
6733   }
6734
6735   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6736   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6737     fhMCDefficiencyMax->SetBinContent(j,0.08);
6738   }
6739
6740
6741   // Contamination from secondary tracks
6742   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6743   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6744     fhSecContaminationMin->SetBinContent(j,-0.035);
6745   }
6746
6747   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6748   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6749     fhSecContaminationMax->SetBinContent(j,0.035);
6750   }
6751
6752   // MC CLOSURETEST (D meson efficiency)
6753   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6754   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6755     x=fhMCclosureTestMin->GetBinLowEdge(j);
6756     fhMCclosureTestMin->SetBinContent(j,-0.0);
6757
6758     if(-0.4<x&&x<-0.2){
6759       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6760     }
6761     else if(-0.2<x&&x<-0.1){
6762       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6763     }
6764     else if(-0.1<x&&x<0.1){
6765       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6766     }
6767     else if(0.1<x&&x<0.2){
6768       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6769     }
6770     if(0.2<x&&x<0.4){
6771       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6772     }
6773   }
6774
6775   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6776   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6777     x=fhMCclosureTestMax->GetBinLowEdge(j);
6778     fhMCclosureTestMax->SetBinContent(j,0.08);
6779
6780     //     if(-0.4<x&&x<-0.2){
6781     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6782     //     }
6783     //     else if(-0.2<x&&x<-0.1){
6784     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6785     //     }
6786     //     else if(-0.2<x&&x<-0.1){
6787     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6788     //     }
6789     //     else if(-0.1<x&&x<0.1){
6790     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6791     //     }
6792     //     else if(0.1<x&&x<0.2){
6793     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6794     //     }
6795     //     if(0.2<x&&x<0.4){
6796     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6797     //     }
6798
6799   }
6800
6801   // Feed-down
6802
6803   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6804   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6805     x=fhBeautyFDmin->GetBinLowEdge(j);
6806     fhBeautyFDmin->SetBinContent(j,-0.05);
6807
6808   //   if(-0.4<x&&x<-0.2){
6809 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6810 //     }
6811 //     else if(-0.2<x&&x<-0.1){
6812 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6813 //     }
6814 //     else if(-0.2<x&&x<-0.1){
6815 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6816 //     }
6817 //     else if(-0.1<x&&x<0.1){
6818 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6819 //     }
6820 //     else if(0.1<x&&x<0.2){
6821 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6822 //     }
6823 //     if(0.2<x&&x<0.4){
6824 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6825 //     }
6826   }
6827
6828   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
6829   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
6830     x=fhBeautyFDmax->GetBinLowEdge(j);
6831     fhBeautyFDmax->SetBinContent(j,0.03);
6832
6833 //     if(-0.4<x&&x<-0.2){
6834 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6835 //     }
6836 //     else if(-0.2<x&&x<-0.1){
6837 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6838 //     }
6839 //     else if(-0.2<x&&x<-0.1){
6840 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6841 //     }
6842 //     else if(-0.1<x&&x<0.1){
6843 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
6844 //     }
6845 //     else if(0.1<x&&x<0.2){
6846 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
6847 //     }
6848 //     if(0.2<x&&x<0.4){
6849 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
6850 //     }
6851
6852   }
6853
6854
6855 }
6856
6857
6858
6859
6860 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
6861   Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");
6862   fmeson=2;
6863   fstrmeson="Dplus";
6864   fstrptAss="ptAsMore03";
6865   fstrptD="Dpt3to5";
6866   if(!fhDeltaPhiTemplate){
6867     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
6868   }
6869   Double_t x;
6870   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
6871   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
6872   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
6873     fhYieldExtraction->SetBinContent(j,0.1);
6874   }
6875
6876   // Background D MESON candidate subtraction (side-band variations, etc.)
6877   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
6878   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
6879     fhBackSubtractionMin->SetBinContent(j,-0.1);
6880   }
6881
6882   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
6883   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
6884     fhBackSubtractionMax->SetBinContent(j,0.1);
6885   }
6886
6887
6888   // MC CORRECTIONS ( associatate track efficiency):
6889   //  -5%  +10% for assoc track eff
6890   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
6891   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
6892     fhMCcorrectionsMin->SetBinContent(j,-0.04);
6893   }
6894
6895   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
6896   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
6897     fhMCcorrectionsMax->SetBinContent(j,0.04);
6898   }
6899
6900   // MC D EFF CORRECTION
6901   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
6902   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
6903     fhMCDefficiencyMin->SetBinContent(j,-0.1);
6904   }
6905
6906   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
6907   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
6908     fhMCDefficiencyMax->SetBinContent(j,0.1);
6909   }
6910
6911
6912   // Contamination from secondary tracks
6913   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
6914   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
6915     fhSecContaminationMin->SetBinContent(j,-0.035);
6916   }
6917
6918   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
6919   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
6920     fhSecContaminationMax->SetBinContent(j,0.035);
6921   }
6922
6923
6924   // MC CLOSURETEST (D meson efficiency)
6925   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
6926   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
6927     x=fhMCclosureTestMin->GetBinLowEdge(j);
6928     fhMCclosureTestMin->SetBinContent(j,-0.0);
6929
6930     if(-0.4<x&&x<-0.2){
6931       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6932     }
6933     else if(-0.2<x&&x<-0.1){
6934       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6935     }
6936     else if(-0.1<x&&x<0.1){
6937       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
6938     }
6939     else if(0.1<x&&x<0.2){
6940       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
6941     }
6942     if(0.2<x&&x<0.4){
6943       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
6944     }
6945   }
6946
6947   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
6948   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
6949     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
6950     fhMCclosureTestMax->SetBinContent(j,0.08);
6951
6952     //     if(-0.4<x&&x<-0.2){
6953     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6954     //     }
6955     //     else if(-0.2<x&&x<-0.1){
6956     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6957     //     }
6958     //     else if(-0.2<x&&x<-0.1){
6959     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6960     //     }
6961     //     else if(-0.1<x&&x<0.1){
6962     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
6963     //     }
6964     //     else if(0.1<x&&x<0.2){
6965     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
6966     //     }
6967     //     if(0.2<x&&x<0.4){
6968     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
6969     //     }
6970
6971   }
6972
6973   // Feed-down
6974
6975   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
6976   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
6977     x=fhBeautyFDmin->GetBinLowEdge(j);
6978     fhBeautyFDmin->SetBinContent(j,-0.05);
6979
6980   //   if(-0.4<x&&x<-0.2){
6981 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6982 //     }
6983 //     else if(-0.2<x&&x<-0.1){
6984 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6985 //     }
6986 //     else if(-0.2<x&&x<-0.1){
6987 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6988 //     }
6989 //     else if(-0.1<x&&x<0.1){
6990 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
6991 //     }
6992 //     else if(0.1<x&&x<0.2){
6993 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
6994 //     }
6995 //     if(0.2<x&&x<0.4){
6996 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
6997 //     }
6998   }
6999
7000   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7001   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7002     x=fhBeautyFDmax->GetBinLowEdge(j);
7003     fhBeautyFDmax->SetBinContent(j,0.03);
7004
7005 //     if(-0.4<x&&x<-0.2){
7006 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7007 //     }
7008 //     else if(-0.2<x&&x<-0.1){
7009 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7010 //     }
7011 //     else if(-0.2<x&&x<-0.1){
7012 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7013 //     }
7014 //     else if(-0.1<x&&x<0.1){
7015 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7016 //     }
7017 //     else if(0.1<x&&x<0.2){
7018 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7019 //     }
7020 //     if(0.2<x&&x<0.4){
7021 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7022 //     }
7023
7024   }
7025
7026 }
7027
7028 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
7029   Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");
7030   fmeson=2;
7031   fstrmeson="Dplus";
7032   fstrptAss="ptAsMore03";
7033   fstrptD="Dpt5to8";
7034   if(!fhDeltaPhiTemplate){
7035     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7036   }
7037   Double_t x;
7038   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7039   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7040   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7041     fhYieldExtraction->SetBinContent(j,0.1);
7042   }
7043
7044   // Background D MESON candidate subtraction (side-band variations, etc.)
7045   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7046   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7047     fhBackSubtractionMin->SetBinContent(j,-0.1);
7048   }
7049
7050   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7051   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7052     fhBackSubtractionMax->SetBinContent(j,0.1);
7053   }
7054
7055   // MC CORRECTIONS:  -5%  +10% for assoc track eff
7056   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7057   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7058     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7059   }
7060
7061   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7062   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7063     fhMCcorrectionsMax->SetBinContent(j,0.04);
7064   }
7065
7066
7067   // MC D EFF CORRECTION
7068   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7069   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7070     fhMCDefficiencyMin->SetBinContent(j,-0.1);
7071   }
7072
7073   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7074   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7075     fhMCDefficiencyMax->SetBinContent(j,0.1);
7076   }
7077
7078
7079   // Contamination from secondary tracks
7080   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7081   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7082     fhSecContaminationMin->SetBinContent(j,-0.035);
7083   }
7084
7085   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7086   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7087     fhSecContaminationMax->SetBinContent(j,0.035);
7088   }
7089
7090   // MC CLOSURETEST (D meson efficiency)
7091   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7092   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7093     x=fhMCclosureTestMin->GetBinLowEdge(j);
7094     fhMCclosureTestMin->SetBinContent(j,-0.0);
7095
7096     if(-0.4<x&&x<-0.2){
7097       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7098     }
7099     else if(-0.2<x&&x<-0.1){
7100       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7101     }
7102     else if(-0.1<x&&x<0.1){
7103       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7104     }
7105     else if(0.1<x&&x<0.2){
7106       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7107     }
7108     if(0.2<x&&x<0.4){
7109       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7110     }
7111   }
7112
7113   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7114   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7115     x=fhMCclosureTestMax->GetBinLowEdge(j);
7116     fhMCclosureTestMax->SetBinContent(j,0.08);
7117
7118     //     if(-0.4<x&&x<-0.2){
7119     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7120     //     }
7121     //     else if(-0.2<x&&x<-0.1){
7122     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7123     //     }
7124     //     else if(-0.2<x&&x<-0.1){
7125     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7126     //     }
7127     //     else if(-0.1<x&&x<0.1){
7128     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7129     //     }
7130     //     else if(0.1<x&&x<0.2){
7131     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7132     //     }
7133     //     if(0.2<x&&x<0.4){
7134     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7135     //     }
7136
7137   }
7138
7139   // Feed-down
7140
7141   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7142   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7143     x=fhBeautyFDmin->GetBinLowEdge(j);
7144     fhBeautyFDmin->SetBinContent(j,-0.05);
7145
7146   //   if(-0.4<x&&x<-0.2){
7147 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7148 //     }
7149 //     else if(-0.2<x&&x<-0.1){
7150 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7151 //     }
7152 //     else if(-0.2<x&&x<-0.1){
7153 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7154 //     }
7155 //     else if(-0.1<x&&x<0.1){
7156 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7157 //     }
7158 //     else if(0.1<x&&x<0.2){
7159 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7160 //     }
7161 //     if(0.2<x&&x<0.4){
7162 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7163 //     }
7164   }
7165
7166   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7167   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7168     x=fhBeautyFDmax->GetBinLowEdge(j);
7169     fhBeautyFDmax->SetBinContent(j,0.03);
7170
7171 //     if(-0.4<x&&x<-0.2){
7172 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7173 //     }
7174 //     else if(-0.2<x&&x<-0.1){
7175 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7176 //     }
7177 //     else if(-0.2<x&&x<-0.1){
7178 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7179 //     }
7180 //     else if(-0.1<x&&x<0.1){
7181 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7182 //     }
7183 //     else if(0.1<x&&x<0.2){
7184 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7185 //     }
7186 //     if(0.2<x&&x<0.4){
7187 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7188 //     }
7189
7190   }
7191
7192 }
7193
7194
7195 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03(){
7196   Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");
7197   fmeson=2;
7198   fstrmeson="Dplus";
7199   fstrptAss="ptAsMore03";
7200   fstrptD="Dpt8to16";
7201   if(!fhDeltaPhiTemplate){
7202     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7203   }
7204
7205   Double_t x;
7206   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7207   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7208   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7209     fhYieldExtraction->SetBinContent(j,0.1);
7210   }
7211
7212   // Background D MESON candidate subtraction (side-band variations, etc.)
7213   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7214   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7215     fhBackSubtractionMin->SetBinContent(j,-0.1);
7216   }
7217
7218   // Background D MESON candidate subtraction (side-band variations, etc.)
7219   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7220   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7221     fhBackSubtractionMax->SetBinContent(j,0.1);
7222   }
7223
7224   // MC CORRECTIONS,  -5% 10% for assoc track eff
7225   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7226   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7227     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7228   }
7229
7230   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7231   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7232     fhMCcorrectionsMax->SetBinContent(j,0.04);
7233   }
7234
7235
7236   // MC D EFF CORRECTION
7237   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7238   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7239     fhMCDefficiencyMin->SetBinContent(j,-0.1);
7240   }
7241
7242   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7243   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7244     fhMCDefficiencyMax->SetBinContent(j,0.1);
7245   }
7246
7247
7248   // Contamination from secondary tracks
7249   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7250   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7251     fhSecContaminationMin->SetBinContent(j,-0.035);
7252   }
7253
7254   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7255   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7256     fhSecContaminationMax->SetBinContent(j,0.035);
7257   }
7258
7259   // MC CLOSURETEST (D meson efficiency)
7260   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7261   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7262     x=fhMCclosureTestMin->GetBinLowEdge(j);
7263     fhMCclosureTestMin->SetBinContent(j,-0.0);
7264
7265     if(-0.4<x&&x<-0.2){
7266       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7267     }
7268     else if(-0.2<x&&x<-0.1){
7269       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7270     }
7271     else if(-0.1<x&&x<0.1){
7272       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7273     }
7274     else if(0.1<x&&x<0.2){
7275       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7276     }
7277     if(0.2<x&&x<0.4){
7278       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7279     }
7280   }
7281
7282   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7283   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7284     x=fhMCclosureTestMax->GetBinLowEdge(j);
7285     fhMCclosureTestMax->SetBinContent(j,0.08);
7286
7287     //     if(-0.4<x&&x<-0.2){
7288     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7289     //     }
7290     //     else if(-0.2<x&&x<-0.1){
7291     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7292     //     }
7293     //     else if(-0.2<x&&x<-0.1){
7294     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7295     //     }
7296     //     else if(-0.1<x&&x<0.1){
7297     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7298     //     }
7299     //     else if(0.1<x&&x<0.2){
7300     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7301     //     }
7302     //     if(0.2<x&&x<0.4){
7303     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7304     //     }
7305
7306   }
7307
7308   // Feed-down
7309
7310   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7311   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7312     x=fhBeautyFDmin->GetBinLowEdge(j);
7313     fhBeautyFDmin->SetBinContent(j,-0.05);
7314
7315   //   if(-0.4<x&&x<-0.2){
7316 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7317 //     }
7318 //     else if(-0.2<x&&x<-0.1){
7319 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7320 //     }
7321 //     else if(-0.2<x&&x<-0.1){
7322 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7323 //     }
7324 //     else if(-0.1<x&&x<0.1){
7325 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7326 //     }
7327 //     else if(0.1<x&&x<0.2){
7328 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7329 //     }
7330 //     if(0.2<x&&x<0.4){
7331 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7332 //     }
7333   }
7334
7335   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7336   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7337     x=fhBeautyFDmax->GetBinLowEdge(j);
7338     fhBeautyFDmax->SetBinContent(j,0.03);
7339
7340 //     if(-0.4<x&&x<-0.2){
7341 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7342 //     }
7343 //     else if(-0.2<x&&x<-0.1){
7344 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7345 //     }
7346 //     else if(-0.2<x&&x<-0.1){
7347 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7348 //     }
7349 //     else if(-0.1<x&&x<0.1){
7350 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7351 //     }
7352 //     else if(0.1<x&&x<0.2){
7353 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7354 //     }
7355 //     if(0.2<x&&x<0.4){
7356 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7357 //     }
7358
7359   }
7360
7361 }
7362
7363
7364
7365 //////// HIGHER PT ASS THRESHOLDS
7366
7367 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
7368   Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
7369   fmeson=0;
7370   fstrmeson="Dzero";
7371   fstrptAss="ptAsMore05";
7372   fstrptD="Dpt3to5";
7373   if(!fhDeltaPhiTemplate){
7374     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7375   }
7376   Double_t x;
7377   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7378   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7379   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7380     fhYieldExtraction->SetBinContent(j,0.1);
7381   }
7382
7383   // Background D MESON candidate subtraction (side-band variations, etc.)
7384   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7385   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7386     fhBackSubtractionMin->SetBinContent(j,-0.05);
7387   }
7388
7389   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7390   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7391     fhBackSubtractionMax->SetBinContent(j,0.05);
7392   }
7393
7394
7395   // MC CORRECTIONS ( associatate track efficiency):
7396   //  -5%  +10% for assoc track eff
7397   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7398   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7399     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7400   }
7401
7402   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7403   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7404     fhMCcorrectionsMax->SetBinContent(j,0.04);
7405   }
7406
7407   // MC D EFF CORRECTION
7408   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7409   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7410     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7411   }
7412
7413   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7414   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7415     fhMCDefficiencyMax->SetBinContent(j,0.05);
7416   }
7417
7418
7419   // Contamination from secondary tracks
7420   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7421   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7422     fhSecContaminationMin->SetBinContent(j,-0.035);
7423   }
7424
7425   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7426   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7427     fhSecContaminationMax->SetBinContent(j,0.035);
7428   }
7429
7430
7431   // MC CLOSURETEST (D meson efficiency)
7432   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7433   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7434     x=fhMCclosureTestMin->GetBinLowEdge(j);
7435     fhMCclosureTestMin->SetBinContent(j,-0.);
7436
7437     if(-0.4<x&&x<-0.2){
7438       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7439     }
7440     else if(-0.2<x&&x<-0.1){
7441       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7442     }
7443     else if(-0.1<x&&x<0.1){
7444       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7445     }
7446     else if(0.1<x&&x<0.2){
7447       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7448     }
7449     if(0.2<x&&x<0.4){
7450       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7451     }
7452   }
7453
7454   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7455   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7456     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
7457     fhMCclosureTestMax->SetBinContent(j,0.07);
7458
7459     //     if(-0.4<x&&x<-0.2){
7460     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7461     //     }
7462     //     else if(-0.2<x&&x<-0.1){
7463     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7464     //     }
7465     //     else if(-0.2<x&&x<-0.1){
7466     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7467     //     }
7468     //     else if(-0.1<x&&x<0.1){
7469     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7470     //     }
7471     //     else if(0.1<x&&x<0.2){
7472     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7473     //     }
7474     //     if(0.2<x&&x<0.4){
7475     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7476     //     }
7477
7478   }
7479
7480   // Feed-down
7481
7482   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7483   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7484     x=fhBeautyFDmin->GetBinLowEdge(j);
7485     fhBeautyFDmin->SetBinContent(j,-0.05);
7486
7487   //   if(-0.4<x&&x<-0.2){
7488 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7489 //     }
7490 //     else if(-0.2<x&&x<-0.1){
7491 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7492 //     }
7493 //     else if(-0.2<x&&x<-0.1){
7494 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7495 //     }
7496 //     else if(-0.1<x&&x<0.1){
7497 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7498 //     }
7499 //     else if(0.1<x&&x<0.2){
7500 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7501 //     }
7502 //     if(0.2<x&&x<0.4){
7503 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7504 //     }
7505   }
7506
7507   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7508   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7509     x=fhBeautyFDmax->GetBinLowEdge(j);
7510     fhBeautyFDmax->SetBinContent(j,0.03);
7511
7512 //     if(-0.4<x&&x<-0.2){
7513 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7514 //     }
7515 //     else if(-0.2<x&&x<-0.1){
7516 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7517 //     }
7518 //     else if(-0.2<x&&x<-0.1){
7519 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7520 //     }
7521 //     else if(-0.1<x&&x<0.1){
7522 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7523 //     }
7524 //     else if(0.1<x&&x<0.2){
7525 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7526 //     }
7527 //     if(0.2<x&&x<0.4){
7528 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7529 //     }
7530
7531   }
7532
7533 }
7534
7535 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
7536   Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
7537   fmeson=0;
7538   fstrmeson="Dzero";
7539   fstrptAss="ptAsMore05";
7540   fstrptD="Dpt5to8";
7541   if(!fhDeltaPhiTemplate){
7542     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7543   }
7544   Double_t x;
7545   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7546   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7547   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7548     fhYieldExtraction->SetBinContent(j,0.1);
7549   }
7550
7551   // Background D MESON candidate subtraction (side-band variations, etc.)
7552   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7553   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7554     fhBackSubtractionMin->SetBinContent(j,-0.05);
7555   }
7556
7557   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7558   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7559     fhBackSubtractionMax->SetBinContent(j,0.05);
7560   }
7561
7562   // MC CORRECTIONS:  -5%  +10% for assoc track eff
7563   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7564   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7565     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7566   }
7567
7568   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7569   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7570     fhMCcorrectionsMax->SetBinContent(j,0.04);
7571   }
7572
7573
7574   // MC D EFF CORRECTION
7575   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7576   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7577     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7578   }
7579
7580   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7581   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7582     fhMCDefficiencyMax->SetBinContent(j,0.05);
7583   }
7584
7585
7586   // Contamination from secondary tracks
7587   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7588   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7589     fhSecContaminationMin->SetBinContent(j,-0.035);
7590   }
7591
7592   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7593   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7594     fhSecContaminationMax->SetBinContent(j,0.035);
7595   }
7596
7597   // MC CLOSURETEST (D meson efficiency)
7598   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7599   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7600     x=fhMCclosureTestMin->GetBinLowEdge(j);
7601     fhMCclosureTestMin->SetBinContent(j,-0.);
7602
7603     if(-0.4<x&&x<-0.2){
7604       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7605     }
7606     else if(-0.2<x&&x<-0.1){
7607       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7608     }
7609     else if(-0.1<x&&x<0.1){
7610       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7611     }
7612     else if(0.1<x&&x<0.2){
7613       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7614     }
7615     if(0.2<x&&x<0.4){
7616       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7617     }
7618   }
7619
7620   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7621   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7622     x=fhMCclosureTestMax->GetBinLowEdge(j);
7623     fhMCclosureTestMax->SetBinContent(j,0.07);
7624
7625     //     if(-0.4<x&&x<-0.2){
7626     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7627     //     }
7628     //     else if(-0.2<x&&x<-0.1){
7629     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7630     //     }
7631     //     else if(-0.2<x&&x<-0.1){
7632     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7633     //     }
7634     //     else if(-0.1<x&&x<0.1){
7635     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7636     //     }
7637     //     else if(0.1<x&&x<0.2){
7638     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7639     //     }
7640     //     if(0.2<x&&x<0.4){
7641     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7642     //     }
7643
7644   }
7645
7646   // Feed-down
7647
7648   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7649   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7650     x=fhBeautyFDmin->GetBinLowEdge(j);
7651     fhBeautyFDmin->SetBinContent(j,-0.05);
7652
7653   //   if(-0.4<x&&x<-0.2){
7654 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7655 //     }
7656 //     else if(-0.2<x&&x<-0.1){
7657 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7658 //     }
7659 //     else if(-0.2<x&&x<-0.1){
7660 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7661 //     }
7662 //     else if(-0.1<x&&x<0.1){
7663 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7664 //     }
7665 //     else if(0.1<x&&x<0.2){
7666 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7667 //     }
7668 //     if(0.2<x&&x<0.4){
7669 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7670 //     }
7671   }
7672
7673   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7674   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7675     x=fhBeautyFDmax->GetBinLowEdge(j);
7676     fhBeautyFDmax->SetBinContent(j,0.03);
7677
7678 //     if(-0.4<x&&x<-0.2){
7679 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7680 //     }
7681 //     else if(-0.2<x&&x<-0.1){
7682 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7683 //     }
7684 //     else if(-0.2<x&&x<-0.1){
7685 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7686 //     }
7687 //     else if(-0.1<x&&x<0.1){
7688 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7689 //     }
7690 //     else if(0.1<x&&x<0.2){
7691 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7692 //     }
7693 //     if(0.2<x&&x<0.4){
7694 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7695 //     }
7696
7697   }
7698
7699 }
7700
7701
7702 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05(){
7703   Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
7704   fmeson=0;
7705   fstrmeson="Dzero";
7706   fstrptAss="ptAsMore05";
7707   fstrptD="Dpt8to16";
7708   if(!fhDeltaPhiTemplate){
7709     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7710   }
7711
7712   Double_t x;
7713   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7714   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7715   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7716     fhYieldExtraction->SetBinContent(j,0.1);
7717   }
7718
7719   // Background D MESON candidate subtraction (side-band variations, etc.)
7720   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7721   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7722     fhBackSubtractionMin->SetBinContent(j,-0.05);
7723   }
7724
7725   // Background D MESON candidate subtraction (side-band variations, etc.)
7726   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7727   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7728     fhBackSubtractionMax->SetBinContent(j,0.05);
7729   }
7730
7731   // MC CORRECTIONS,  -5% 10% for assoc track eff
7732   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7733   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7734     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7735   }
7736
7737   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7738   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7739     fhMCcorrectionsMax->SetBinContent(j,0.04);
7740   }
7741
7742
7743   // MC D EFF CORRECTION
7744   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7745   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7746     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7747   }
7748
7749   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7750   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7751     fhMCDefficiencyMax->SetBinContent(j,0.05);
7752   }
7753
7754
7755   // Contamination from secondary tracks
7756   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7757   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7758     fhSecContaminationMin->SetBinContent(j,-0.035);
7759   }
7760
7761   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7762   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7763     fhSecContaminationMax->SetBinContent(j,0.035);
7764   }
7765
7766   // MC CLOSURETEST (D meson efficiency)
7767   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7768   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7769     x=fhMCclosureTestMin->GetBinLowEdge(j);
7770     fhMCclosureTestMin->SetBinContent(j,-0.);
7771
7772     if(-0.4<x&&x<-0.2){
7773       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7774     }
7775     else if(-0.2<x&&x<-0.1){
7776       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7777     }
7778     else if(-0.1<x&&x<0.1){
7779       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7780     }
7781     else if(0.1<x&&x<0.2){
7782       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7783     }
7784     if(0.2<x&&x<0.4){
7785       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7786     }
7787   }
7788
7789   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7790   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7791     x=fhMCclosureTestMax->GetBinLowEdge(j);
7792     fhMCclosureTestMax->SetBinContent(j,0.07);
7793
7794     //     if(-0.4<x&&x<-0.2){
7795     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7796     //     }
7797     //     else if(-0.2<x&&x<-0.1){
7798     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7799     //     }
7800     //     else if(-0.2<x&&x<-0.1){
7801     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7802     //     }
7803     //     else if(-0.1<x&&x<0.1){
7804     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7805     //     }
7806     //     else if(0.1<x&&x<0.2){
7807     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7808     //     }
7809     //     if(0.2<x&&x<0.4){
7810     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7811     //     }
7812
7813   }
7814
7815   // Feed-down
7816
7817   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7818   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7819     x=fhBeautyFDmin->GetBinLowEdge(j);
7820     fhBeautyFDmin->SetBinContent(j,-0.05);
7821
7822   //   if(-0.4<x&&x<-0.2){
7823 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7824 //     }
7825 //     else if(-0.2<x&&x<-0.1){
7826 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7827 //     }
7828 //     else if(-0.2<x&&x<-0.1){
7829 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7830 //     }
7831 //     else if(-0.1<x&&x<0.1){
7832 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
7833 //     }
7834 //     else if(0.1<x&&x<0.2){
7835 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7836 //     }
7837 //     if(0.2<x&&x<0.4){
7838 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7839 //     }
7840   }
7841
7842   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
7843   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
7844     x=fhBeautyFDmax->GetBinLowEdge(j);
7845     fhBeautyFDmax->SetBinContent(j,0.03);
7846
7847 //     if(-0.4<x&&x<-0.2){
7848 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7849 //     }
7850 //     else if(-0.2<x&&x<-0.1){
7851 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7852 //     }
7853 //     else if(-0.2<x&&x<-0.1){
7854 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7855 //     }
7856 //     else if(-0.1<x&&x<0.1){
7857 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
7858 //     }
7859 //     else if(0.1<x&&x<0.2){
7860 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
7861 //     }
7862 //     if(0.2<x&&x<0.4){
7863 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
7864 //     }
7865
7866   }
7867
7868 }
7869
7870
7871
7872
7873 //--------------------------------------------------
7874 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
7875   Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
7876   fmeson=1;
7877   fstrmeson="Dstar";
7878   fstrptAss="ptAsMore05";
7879   fstrptD="Dpt3to5";
7880   if(!fhDeltaPhiTemplate){
7881     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
7882   }
7883   Double_t x;
7884   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
7885   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
7886   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
7887     fhYieldExtraction->SetBinContent(j,0.1);
7888   }
7889
7890   // Background D MESON candidate subtraction (side-band variations, etc.)
7891   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
7892   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
7893     fhBackSubtractionMin->SetBinContent(j,-0.07);
7894   }
7895
7896   // Background D MESON candidate subtraction (side-band variations, etc.)
7897   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
7898   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
7899     fhBackSubtractionMax->SetBinContent(j,0.07);
7900   }
7901
7902   // MC CORRECTIONS, -5%  10% for assoc track eff
7903   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
7904   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
7905     fhMCcorrectionsMin->SetBinContent(j,-0.04);
7906   }
7907
7908   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
7909   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
7910     fhMCcorrectionsMax->SetBinContent(j,0.04);
7911   }
7912
7913
7914   // MC D EFF CORRECTION
7915   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
7916   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
7917     fhMCDefficiencyMin->SetBinContent(j,-0.05);
7918   }
7919
7920   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
7921   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
7922     fhMCDefficiencyMax->SetBinContent(j,0.05);
7923   }
7924
7925
7926   // Contamination from secondary tracks
7927   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
7928   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
7929     fhSecContaminationMin->SetBinContent(j,-0.035);
7930   }
7931
7932   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
7933   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
7934     fhSecContaminationMax->SetBinContent(j,0.035);
7935   }
7936
7937   // MC CLOSURETEST (D meson efficiency)
7938   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
7939   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
7940     x=fhMCclosureTestMin->GetBinLowEdge(j);
7941     fhMCclosureTestMin->SetBinContent(j,-0.0);
7942
7943     if(-0.4<x&&x<-0.2){
7944       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7945     }
7946     else if(-0.2<x&&x<-0.1){
7947       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7948     }
7949     else if(-0.1<x&&x<0.1){
7950       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
7951     }
7952     else if(0.1<x&&x<0.2){
7953       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
7954     }
7955     if(0.2<x&&x<0.4){
7956       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
7957     }
7958   }
7959
7960   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
7961   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
7962     x=fhMCclosureTestMax->GetBinLowEdge(j);
7963     fhMCclosureTestMax->SetBinContent(j,0.7);
7964
7965     //     if(-0.4<x&&x<-0.2){
7966     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7967     //     }
7968     //     else if(-0.2<x&&x<-0.1){
7969     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7970     //     }
7971     //     else if(-0.2<x&&x<-0.1){
7972     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7973     //     }
7974     //     else if(-0.1<x&&x<0.1){
7975     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
7976     //     }
7977     //     else if(0.1<x&&x<0.2){
7978     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
7979     //     }
7980     //     if(0.2<x&&x<0.4){
7981     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
7982     //     }
7983
7984   }
7985
7986   // Feed-down
7987
7988   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
7989   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
7990     x=fhBeautyFDmin->GetBinLowEdge(j);
7991     fhBeautyFDmin->SetBinContent(j,-0.05);
7992
7993   //   if(-0.4<x&&x<-0.2){
7994 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
7995 //     }
7996 //     else if(-0.2<x&&x<-0.1){
7997 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
7998 //     }
7999 //     else if(-0.2<x&&x<-0.1){
8000 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8001 //     }
8002 //     else if(-0.1<x&&x<0.1){
8003 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8004 //     }
8005 //     else if(0.1<x&&x<0.2){
8006 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8007 //     }
8008 //     if(0.2<x&&x<0.4){
8009 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8010 //     }
8011   }
8012
8013   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8014   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8015     x=fhBeautyFDmax->GetBinLowEdge(j);
8016     fhBeautyFDmax->SetBinContent(j,0.03);
8017
8018 //     if(-0.4<x&&x<-0.2){
8019 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8020 //     }
8021 //     else if(-0.2<x&&x<-0.1){
8022 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8023 //     }
8024 //     else if(-0.2<x&&x<-0.1){
8025 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8026 //     }
8027 //     else if(-0.1<x&&x<0.1){
8028 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8029 //     }
8030 //     else if(0.1<x&&x<0.2){
8031 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8032 //     }
8033 //     if(0.2<x&&x<0.4){
8034 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8035 //     }
8036
8037   }
8038
8039
8040 }
8041
8042 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
8043   Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8044   fmeson=1;
8045   fstrmeson="Dstar";
8046   fstrptAss="ptAsMore05";
8047   fstrptD="Dpt5to8";
8048   if(!fhDeltaPhiTemplate){
8049     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8050   }
8051   Double_t x;
8052   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8053   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8054   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8055     fhYieldExtraction->SetBinContent(j,0.1);
8056   }
8057
8058   // Background D MESON candidate subtraction (side-band variations, etc.)
8059   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8060   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8061     fhBackSubtractionMin->SetBinContent(j,-0.05);
8062   }
8063
8064   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8065   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8066     fhBackSubtractionMax->SetBinContent(j,0.05);
8067   }
8068
8069   // MC CORRECTIONS/ -5%  10% for assoc track eff
8070   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8071   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8072     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8073   }
8074
8075   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8076   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8077     fhMCcorrectionsMax->SetBinContent(j,0.04);
8078   }
8079
8080   // MC D EFF CORRECTION
8081   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8082   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8083     fhMCDefficiencyMin->SetBinContent(j,-0.05);
8084   }
8085
8086   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8087   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8088     fhMCDefficiencyMax->SetBinContent(j,0.05);
8089   }
8090
8091
8092   // Contamination from secondary tracks
8093   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8094   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8095     fhSecContaminationMin->SetBinContent(j,-0.035);
8096   }
8097
8098   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8099   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8100     fhSecContaminationMax->SetBinContent(j,0.035);
8101   }
8102
8103   // MC CLOSURETEST (D meson efficiency)
8104   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8105   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8106     x=fhMCclosureTestMin->GetBinLowEdge(j);
8107     fhMCclosureTestMin->SetBinContent(j,-0.0);
8108
8109     if(-0.4<x&&x<-0.2){
8110       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8111     }
8112     else if(-0.2<x&&x<-0.1){
8113       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8114     }
8115     else if(-0.1<x&&x<0.1){
8116       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8117     }
8118     else if(0.1<x&&x<0.2){
8119       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8120     }
8121     if(0.2<x&&x<0.4){
8122       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8123     }
8124   }
8125
8126   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8127   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8128     x=fhMCclosureTestMax->GetBinLowEdge(j);
8129     fhMCclosureTestMax->SetBinContent(j,0.07);
8130
8131     //     if(-0.4<x&&x<-0.2){
8132     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8133     //     }
8134     //     else if(-0.2<x&&x<-0.1){
8135     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8136     //     }
8137     //     else if(-0.2<x&&x<-0.1){
8138     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8139     //     }
8140     //     else if(-0.1<x&&x<0.1){
8141     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8142     //     }
8143     //     else if(0.1<x&&x<0.2){
8144     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8145     //     }
8146     //     if(0.2<x&&x<0.4){
8147     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8148     //     }
8149
8150   }
8151
8152   // Feed-down
8153
8154   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8155   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8156     x=fhBeautyFDmin->GetBinLowEdge(j);
8157     fhBeautyFDmin->SetBinContent(j,-0.05);
8158
8159   //   if(-0.4<x&&x<-0.2){
8160 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8161 //     }
8162 //     else if(-0.2<x&&x<-0.1){
8163 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8164 //     }
8165 //     else if(-0.2<x&&x<-0.1){
8166 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8167 //     }
8168 //     else if(-0.1<x&&x<0.1){
8169 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8170 //     }
8171 //     else if(0.1<x&&x<0.2){
8172 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8173 //     }
8174 //     if(0.2<x&&x<0.4){
8175 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8176 //     }
8177   }
8178
8179   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8180   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8181     x=fhBeautyFDmax->GetBinLowEdge(j);
8182     fhBeautyFDmax->SetBinContent(j,0.03);
8183
8184 //     if(-0.4<x&&x<-0.2){
8185 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8186 //     }
8187 //     else if(-0.2<x&&x<-0.1){
8188 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8189 //     }
8190 //     else if(-0.2<x&&x<-0.1){
8191 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8192 //     }
8193 //     else if(-0.1<x&&x<0.1){
8194 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8195 //     }
8196 //     else if(0.1<x&&x<0.2){
8197 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8198 //     }
8199 //     if(0.2<x&&x<0.4){
8200 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8201 //     }
8202
8203   }
8204
8205 }
8206
8207
8208
8209 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05(){
8210   Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8211   fmeson=1;
8212   fstrmeson="Dstar";
8213   fstrptAss="ptAsMore05";
8214   fstrptD="Dpt8to16";
8215   if(!fhDeltaPhiTemplate){
8216     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8217   }
8218   Double_t x;
8219   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8220   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8221   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8222     fhYieldExtraction->SetBinContent(j,0.1);
8223   }
8224
8225   // Background D MESON candidate subtraction (side-band variations, etc.)
8226   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8227   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8228     fhBackSubtractionMin->SetBinContent(j,-0.05);
8229   }
8230
8231   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8232   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8233     fhBackSubtractionMax->SetBinContent(j,0.05);
8234   }
8235
8236   // MC CORRECTIONS   -5% +10% for assoc track eff
8237   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8238   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8239     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8240   }
8241
8242   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8243   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8244     fhMCcorrectionsMax->SetBinContent(j,0.04);
8245   }
8246   // MC D EFF CORRECTION
8247   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8248   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8249     fhMCDefficiencyMin->SetBinContent(j,-0.08);
8250   }
8251
8252   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8253   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8254     fhMCDefficiencyMax->SetBinContent(j,0.08);
8255   }
8256
8257
8258   // Contamination from secondary tracks
8259   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8260   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8261     fhSecContaminationMin->SetBinContent(j,-0.035);
8262   }
8263
8264   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8265   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8266     fhSecContaminationMax->SetBinContent(j,0.035);
8267   }
8268
8269   // MC CLOSURETEST (D meson efficiency)
8270   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8271   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8272     x=fhMCclosureTestMin->GetBinLowEdge(j);
8273     fhMCclosureTestMin->SetBinContent(j,-0.0);
8274
8275     if(-0.4<x&&x<-0.2){
8276       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8277     }
8278     else if(-0.2<x&&x<-0.1){
8279       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8280     }
8281     else if(-0.1<x&&x<0.1){
8282       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8283     }
8284     else if(0.1<x&&x<0.2){
8285       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8286     }
8287     if(0.2<x&&x<0.4){
8288       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8289     }
8290   }
8291
8292   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8293   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8294     x=fhMCclosureTestMax->GetBinLowEdge(j);
8295     fhMCclosureTestMax->SetBinContent(j,0.07);
8296
8297     //     if(-0.4<x&&x<-0.2){
8298     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8299     //     }
8300     //     else if(-0.2<x&&x<-0.1){
8301     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8302     //     }
8303     //     else if(-0.2<x&&x<-0.1){
8304     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8305     //     }
8306     //     else if(-0.1<x&&x<0.1){
8307     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8308     //     }
8309     //     else if(0.1<x&&x<0.2){
8310     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8311     //     }
8312     //     if(0.2<x&&x<0.4){
8313     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8314     //     }
8315
8316   }
8317
8318   // Feed-down
8319
8320   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8321   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8322     x=fhBeautyFDmin->GetBinLowEdge(j);
8323     fhBeautyFDmin->SetBinContent(j,-0.05);
8324
8325   //   if(-0.4<x&&x<-0.2){
8326 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8327 //     }
8328 //     else if(-0.2<x&&x<-0.1){
8329 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8330 //     }
8331 //     else if(-0.2<x&&x<-0.1){
8332 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8333 //     }
8334 //     else if(-0.1<x&&x<0.1){
8335 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8336 //     }
8337 //     else if(0.1<x&&x<0.2){
8338 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8339 //     }
8340 //     if(0.2<x&&x<0.4){
8341 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8342 //     }
8343   }
8344
8345   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8346   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8347     x=fhBeautyFDmax->GetBinLowEdge(j);
8348     fhBeautyFDmax->SetBinContent(j,0.03);
8349
8350 //     if(-0.4<x&&x<-0.2){
8351 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8352 //     }
8353 //     else if(-0.2<x&&x<-0.1){
8354 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8355 //     }
8356 //     else if(-0.2<x&&x<-0.1){
8357 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8358 //     }
8359 //     else if(-0.1<x&&x<0.1){
8360 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8361 //     }
8362 //     else if(0.1<x&&x<0.2){
8363 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8364 //     }
8365 //     if(0.2<x&&x<0.4){
8366 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8367 //     }
8368
8369   }
8370
8371
8372 }
8373
8374
8375
8376 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
8377   Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
8378   fmeson=2;
8379   fstrmeson="Dplus";
8380   fstrptAss="ptAsMore05";
8381   fstrptD="Dpt3to5";
8382   if(!fhDeltaPhiTemplate){
8383     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8384   }
8385   Double_t x;
8386   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8387   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8388   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8389     fhYieldExtraction->SetBinContent(j,0.1);
8390   }
8391
8392   // Background D MESON candidate subtraction (side-band variations, etc.)
8393   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8394   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8395     fhBackSubtractionMin->SetBinContent(j,-0.1);
8396   }
8397
8398   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8399   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8400     fhBackSubtractionMax->SetBinContent(j,0.1);
8401   }
8402
8403
8404   // MC CORRECTIONS ( associatate track efficiency):
8405   //  -5%  +10% for assoc track eff
8406   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8407   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8408     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8409   }
8410
8411   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8412   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8413     fhMCcorrectionsMax->SetBinContent(j,0.04);
8414   }
8415
8416   // MC D EFF CORRECTION
8417   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8418   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8419     fhMCDefficiencyMin->SetBinContent(j,-0.1);
8420   }
8421
8422   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8423   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8424     fhMCDefficiencyMax->SetBinContent(j,0.1);
8425   }
8426
8427
8428   // Contamination from secondary tracks
8429   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8430   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8431     fhSecContaminationMin->SetBinContent(j,-0.035);
8432   }
8433
8434   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8435   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8436     fhSecContaminationMax->SetBinContent(j,0.035);
8437   }
8438
8439
8440   // MC CLOSURETEST (D meson efficiency)
8441   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8442   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8443     x=fhMCclosureTestMin->GetBinLowEdge(j);
8444     fhMCclosureTestMin->SetBinContent(j,-0.0);
8445
8446     if(-0.4<x&&x<-0.2){
8447       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8448     }
8449     else if(-0.2<x&&x<-0.1){
8450       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8451     }
8452     else if(-0.1<x&&x<0.1){
8453       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8454     }
8455     else if(0.1<x&&x<0.2){
8456       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8457     }
8458     if(0.2<x&&x<0.4){
8459       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8460     }
8461   }
8462
8463   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8464   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8465     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
8466     fhMCclosureTestMax->SetBinContent(j,0.06);
8467
8468     //     if(-0.4<x&&x<-0.2){
8469     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8470     //     }
8471     //     else if(-0.2<x&&x<-0.1){
8472     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8473     //     }
8474     //     else if(-0.2<x&&x<-0.1){
8475     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8476     //     }
8477     //     else if(-0.1<x&&x<0.1){
8478     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8479     //     }
8480     //     else if(0.1<x&&x<0.2){
8481     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8482     //     }
8483     //     if(0.2<x&&x<0.4){
8484     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8485     //     }
8486
8487   }
8488
8489   // Feed-down
8490
8491   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8492   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8493     x=fhBeautyFDmin->GetBinLowEdge(j);
8494     fhBeautyFDmin->SetBinContent(j,-0.05);
8495
8496   //   if(-0.4<x&&x<-0.2){
8497 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8498 //     }
8499 //     else if(-0.2<x&&x<-0.1){
8500 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8501 //     }
8502 //     else if(-0.2<x&&x<-0.1){
8503 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8504 //     }
8505 //     else if(-0.1<x&&x<0.1){
8506 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8507 //     }
8508 //     else if(0.1<x&&x<0.2){
8509 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8510 //     }
8511 //     if(0.2<x&&x<0.4){
8512 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8513 //     }
8514   }
8515
8516   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8517   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8518     x=fhBeautyFDmax->GetBinLowEdge(j);
8519     fhBeautyFDmax->SetBinContent(j,0.03);
8520
8521 //     if(-0.4<x&&x<-0.2){
8522 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8523 //     }
8524 //     else if(-0.2<x&&x<-0.1){
8525 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8526 //     }
8527 //     else if(-0.2<x&&x<-0.1){
8528 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8529 //     }
8530 //     else if(-0.1<x&&x<0.1){
8531 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8532 //     }
8533 //     else if(0.1<x&&x<0.2){
8534 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8535 //     }
8536 //     if(0.2<x&&x<0.4){
8537 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8538 //     }
8539
8540   }
8541
8542 }
8543
8544 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
8545   Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
8546   fmeson=2;
8547   fstrmeson="Dplus";
8548   fstrptAss="ptAsMore05";
8549   fstrptD="Dpt5to8";
8550   if(!fhDeltaPhiTemplate){
8551     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8552   }
8553   Double_t x;
8554   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8555   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8556   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8557     fhYieldExtraction->SetBinContent(j,0.1);
8558   }
8559
8560   // Background D MESON candidate subtraction (side-band variations, etc.)
8561   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8562   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8563     fhBackSubtractionMin->SetBinContent(j,-0.1);
8564   }
8565
8566   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8567   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8568     fhBackSubtractionMax->SetBinContent(j,0.1);
8569   }
8570
8571   // MC CORRECTIONS:  -5%  +10% for assoc track eff
8572   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8573   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8574     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8575   }
8576
8577   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8578   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8579     fhMCcorrectionsMax->SetBinContent(j,0.04);
8580   }
8581
8582
8583   // MC D EFF CORRECTION
8584   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8585   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8586     fhMCDefficiencyMin->SetBinContent(j,-0.1);
8587   }
8588
8589   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8590   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8591     fhMCDefficiencyMax->SetBinContent(j,0.1);
8592   }
8593
8594
8595   // Contamination from secondary tracks
8596   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8597   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8598     fhSecContaminationMin->SetBinContent(j,-0.035);
8599   }
8600
8601   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8602   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8603     fhSecContaminationMax->SetBinContent(j,0.035);
8604   }
8605
8606   // MC CLOSURETEST (D meson efficiency)
8607   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8608   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8609     x=fhMCclosureTestMin->GetBinLowEdge(j);
8610     fhMCclosureTestMin->SetBinContent(j,-0.0);
8611
8612     if(-0.4<x&&x<-0.2){
8613       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8614     }
8615     else if(-0.2<x&&x<-0.1){
8616       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8617     }
8618     else if(-0.1<x&&x<0.1){
8619       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8620     }
8621     else if(0.1<x&&x<0.2){
8622       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8623     }
8624     if(0.2<x&&x<0.4){
8625       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8626     }
8627   }
8628
8629   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8630   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8631     x=fhMCclosureTestMax->GetBinLowEdge(j);
8632     fhMCclosureTestMax->SetBinContent(j,0.06);
8633
8634     //     if(-0.4<x&&x<-0.2){
8635     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8636     //     }
8637     //     else if(-0.2<x&&x<-0.1){
8638     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8639     //     }
8640     //     else if(-0.2<x&&x<-0.1){
8641     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8642     //     }
8643     //     else if(-0.1<x&&x<0.1){
8644     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8645     //     }
8646     //     else if(0.1<x&&x<0.2){
8647     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8648     //     }
8649     //     if(0.2<x&&x<0.4){
8650     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8651     //     }
8652
8653   }
8654
8655   // Feed-down
8656
8657   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8658   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8659     x=fhBeautyFDmin->GetBinLowEdge(j);
8660     fhBeautyFDmin->SetBinContent(j,-0.05);
8661
8662   //   if(-0.4<x&&x<-0.2){
8663 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8664 //     }
8665 //     else if(-0.2<x&&x<-0.1){
8666 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8667 //     }
8668 //     else if(-0.2<x&&x<-0.1){
8669 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8670 //     }
8671 //     else if(-0.1<x&&x<0.1){
8672 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8673 //     }
8674 //     else if(0.1<x&&x<0.2){
8675 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8676 //     }
8677 //     if(0.2<x&&x<0.4){
8678 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8679 //     }
8680   }
8681
8682   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8683   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8684     x=fhBeautyFDmax->GetBinLowEdge(j);
8685     fhBeautyFDmax->SetBinContent(j,0.03);
8686
8687 //     if(-0.4<x&&x<-0.2){
8688 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8689 //     }
8690 //     else if(-0.2<x&&x<-0.1){
8691 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8692 //     }
8693 //     else if(-0.2<x&&x<-0.1){
8694 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8695 //     }
8696 //     else if(-0.1<x&&x<0.1){
8697 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8698 //     }
8699 //     else if(0.1<x&&x<0.2){
8700 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8701 //     }
8702 //     if(0.2<x&&x<0.4){
8703 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8704 //     }
8705
8706   }
8707
8708 }
8709
8710
8711 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05(){
8712   Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");
8713   fmeson=2;
8714   fstrmeson="Dplus";
8715   fstrptAss="ptAsMore05";
8716   fstrptD="Dpt8to16";
8717   if(!fhDeltaPhiTemplate){
8718     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8719   }
8720
8721   Double_t x;
8722   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8723   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8724   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8725     fhYieldExtraction->SetBinContent(j,0.1);
8726   }
8727
8728   // Background D MESON candidate subtraction (side-band variations, etc.)
8729   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8730   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8731     fhBackSubtractionMin->SetBinContent(j,-0.1);
8732   }
8733
8734   // Background D MESON candidate subtraction (side-band variations, etc.)
8735   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8736   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8737     fhBackSubtractionMax->SetBinContent(j,0.1);
8738   }
8739
8740   // MC CORRECTIONS,  -5% 10% for assoc track eff
8741   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8742   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8743     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8744   }
8745
8746   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8747   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8748     fhMCcorrectionsMax->SetBinContent(j,0.04);
8749   }
8750
8751
8752   // MC D EFF CORRECTION
8753   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8754   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8755     fhMCDefficiencyMin->SetBinContent(j,-0.1);
8756   }
8757
8758   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8759   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8760     fhMCDefficiencyMax->SetBinContent(j,0.1);
8761   }
8762
8763
8764   // Contamination from secondary tracks
8765   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8766   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8767     fhSecContaminationMin->SetBinContent(j,-0.035);
8768   }
8769
8770   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8771   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8772     fhSecContaminationMax->SetBinContent(j,0.035);
8773   }
8774
8775   // MC CLOSURETEST (D meson efficiency)
8776   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8777   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8778     x=fhMCclosureTestMin->GetBinLowEdge(j);
8779     fhMCclosureTestMin->SetBinContent(j,-0.0);
8780
8781     if(-0.4<x&&x<-0.2){
8782       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8783     }
8784     else if(-0.2<x&&x<-0.1){
8785       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8786     }
8787     else if(-0.1<x&&x<0.1){
8788       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8789     }
8790     else if(0.1<x&&x<0.2){
8791       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8792     }
8793     if(0.2<x&&x<0.4){
8794       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8795     }
8796   }
8797
8798   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8799   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8800     x=fhMCclosureTestMax->GetBinLowEdge(j);
8801     fhMCclosureTestMax->SetBinContent(j,0.06);
8802
8803     //     if(-0.4<x&&x<-0.2){
8804     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8805     //     }
8806     //     else if(-0.2<x&&x<-0.1){
8807     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8808     //     }
8809     //     else if(-0.2<x&&x<-0.1){
8810     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8811     //     }
8812     //     else if(-0.1<x&&x<0.1){
8813     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8814     //     }
8815     //     else if(0.1<x&&x<0.2){
8816     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8817     //     }
8818     //     if(0.2<x&&x<0.4){
8819     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8820     //     }
8821
8822   }
8823
8824   // Feed-down
8825
8826   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8827   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8828     x=fhBeautyFDmin->GetBinLowEdge(j);
8829     fhBeautyFDmin->SetBinContent(j,-0.05);
8830
8831   //   if(-0.4<x&&x<-0.2){
8832 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8833 //     }
8834 //     else if(-0.2<x&&x<-0.1){
8835 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8836 //     }
8837 //     else if(-0.2<x&&x<-0.1){
8838 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8839 //     }
8840 //     else if(-0.1<x&&x<0.1){
8841 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
8842 //     }
8843 //     else if(0.1<x&&x<0.2){
8844 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
8845 //     }
8846 //     if(0.2<x&&x<0.4){
8847 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
8848 //     }
8849   }
8850
8851   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
8852   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
8853     x=fhBeautyFDmax->GetBinLowEdge(j);
8854     fhBeautyFDmax->SetBinContent(j,0.03);
8855
8856 //     if(-0.4<x&&x<-0.2){
8857 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8858 //     }
8859 //     else if(-0.2<x&&x<-0.1){
8860 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8861 //     }
8862 //     else if(-0.2<x&&x<-0.1){
8863 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8864 //     }
8865 //     else if(-0.1<x&&x<0.1){
8866 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
8867 //     }
8868 //     else if(0.1<x&&x<0.2){
8869 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
8870 //     }
8871 //     if(0.2<x&&x<0.4){
8872 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
8873 //     }
8874
8875   }
8876
8877 }
8878
8879
8880
8881 // pt(assoc)> 1 GeV/c
8882 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
8883   Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
8884   fmeson=0;
8885   fstrmeson="Dzero";
8886   fstrptAss="ptAsMore1";
8887   fstrptD="Dpt3to5";
8888   if(!fhDeltaPhiTemplate){
8889     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
8890   }
8891   Double_t x;
8892   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
8893   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
8894   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
8895     fhYieldExtraction->SetBinContent(j,0.1);
8896   }
8897
8898   // Background D MESON candidate subtraction (side-band variations, etc.)
8899   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
8900   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
8901     fhBackSubtractionMin->SetBinContent(j,-0.05);
8902   }
8903
8904   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
8905   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
8906     fhBackSubtractionMax->SetBinContent(j,0.05);
8907   }
8908
8909
8910   // MC CORRECTIONS ( associatate track efficiency):
8911   //  -5%  +10% for assoc track eff
8912   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
8913   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
8914     fhMCcorrectionsMin->SetBinContent(j,-0.04);
8915   }
8916
8917   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
8918   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
8919     fhMCcorrectionsMax->SetBinContent(j,0.04);
8920   }
8921
8922   // MC D EFF CORRECTION
8923   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
8924   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
8925     fhMCDefficiencyMin->SetBinContent(j,-0.05);
8926   }
8927
8928   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
8929   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
8930     fhMCDefficiencyMax->SetBinContent(j,0.05);
8931   }
8932
8933
8934   // Contamination from secondary tracks
8935   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
8936   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
8937     fhSecContaminationMin->SetBinContent(j,-0.035);
8938   }
8939
8940   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
8941   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
8942     fhSecContaminationMax->SetBinContent(j,0.035);
8943   }
8944
8945
8946   // MC CLOSURETEST (D meson efficiency)
8947   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
8948   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
8949     x=fhMCclosureTestMin->GetBinLowEdge(j);
8950     fhMCclosureTestMin->SetBinContent(j,-0.);
8951
8952     if(-0.4<x&&x<-0.2){
8953       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8954     }
8955     else if(-0.2<x&&x<-0.1){
8956       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8957     }
8958     else if(-0.1<x&&x<0.1){
8959       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
8960     }
8961     else if(0.1<x&&x<0.2){
8962       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
8963     }
8964     if(0.2<x&&x<0.4){
8965       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
8966     }
8967   }
8968
8969   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
8970   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
8971     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
8972     fhMCclosureTestMax->SetBinContent(j,0.05);
8973
8974     //     if(-0.4<x&&x<-0.2){
8975     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8976     //     }
8977     //     else if(-0.2<x&&x<-0.1){
8978     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8979     //     }
8980     //     else if(-0.2<x&&x<-0.1){
8981     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8982     //     }
8983     //     else if(-0.1<x&&x<0.1){
8984     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
8985     //     }
8986     //     else if(0.1<x&&x<0.2){
8987     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
8988     //     }
8989     //     if(0.2<x&&x<0.4){
8990     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
8991     //     }
8992
8993   }
8994
8995   // Feed-down
8996
8997   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
8998   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
8999     x=fhBeautyFDmin->GetBinLowEdge(j);
9000     fhBeautyFDmin->SetBinContent(j,-0.05);
9001
9002   //   if(-0.4<x&&x<-0.2){
9003 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9004 //     }
9005 //     else if(-0.2<x&&x<-0.1){
9006 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9007 //     }
9008 //     else if(-0.2<x&&x<-0.1){
9009 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9010 //     }
9011 //     else if(-0.1<x&&x<0.1){
9012 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9013 //     }
9014 //     else if(0.1<x&&x<0.2){
9015 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9016 //     }
9017 //     if(0.2<x&&x<0.4){
9018 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9019 //     }
9020   }
9021
9022   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9023   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9024     x=fhBeautyFDmax->GetBinLowEdge(j);
9025     fhBeautyFDmax->SetBinContent(j,0.03);
9026
9027 //     if(-0.4<x&&x<-0.2){
9028 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9029 //     }
9030 //     else if(-0.2<x&&x<-0.1){
9031 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9032 //     }
9033 //     else if(-0.2<x&&x<-0.1){
9034 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9035 //     }
9036 //     else if(-0.1<x&&x<0.1){
9037 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9038 //     }
9039 //     else if(0.1<x&&x<0.2){
9040 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9041 //     }
9042 //     if(0.2<x&&x<0.4){
9043 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9044 //     }
9045
9046   }
9047
9048 }
9049
9050 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
9051   Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
9052   fmeson=0;
9053   fstrmeson="Dzero";
9054   fstrptAss="ptAsMore1";
9055   fstrptD="Dpt5to8";
9056   if(!fhDeltaPhiTemplate){
9057     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9058   }
9059   Double_t x;
9060   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9061   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9062   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9063     fhYieldExtraction->SetBinContent(j,0.1);
9064   }
9065
9066   // Background D MESON candidate subtraction (side-band variations, etc.)
9067   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9068   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9069     fhBackSubtractionMin->SetBinContent(j,-0.05);
9070   }
9071
9072   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9073   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9074     fhBackSubtractionMax->SetBinContent(j,0.05);
9075   }
9076
9077   // MC CORRECTIONS:  -5%  +10% for assoc track eff
9078   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9079   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9080     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9081   }
9082
9083   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9084   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9085     fhMCcorrectionsMax->SetBinContent(j,0.04);
9086   }
9087
9088
9089   // MC D EFF CORRECTION
9090   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9091   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9092     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9093   }
9094
9095   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9096   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9097     fhMCDefficiencyMax->SetBinContent(j,0.05);
9098   }
9099
9100
9101   // Contamination from secondary tracks
9102   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9103   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9104     fhSecContaminationMin->SetBinContent(j,-0.035);
9105   }
9106
9107   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9108   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9109     fhSecContaminationMax->SetBinContent(j,0.035);
9110   }
9111
9112   // MC CLOSURETEST (D meson efficiency)
9113   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9114   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9115     x=fhMCclosureTestMin->GetBinLowEdge(j);
9116     fhMCclosureTestMin->SetBinContent(j,-0.);
9117
9118     if(-0.4<x&&x<-0.2){
9119       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9120     }
9121     else if(-0.2<x&&x<-0.1){
9122       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9123     }
9124     else if(-0.1<x&&x<0.1){
9125       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9126     }
9127     else if(0.1<x&&x<0.2){
9128       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9129     }
9130     if(0.2<x&&x<0.4){
9131       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9132     }
9133   }
9134
9135   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9136   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9137     x=fhMCclosureTestMax->GetBinLowEdge(j);
9138     fhMCclosureTestMax->SetBinContent(j,0.05);
9139
9140     //     if(-0.4<x&&x<-0.2){
9141     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9142     //     }
9143     //     else if(-0.2<x&&x<-0.1){
9144     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9145     //     }
9146     //     else if(-0.2<x&&x<-0.1){
9147     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9148     //     }
9149     //     else if(-0.1<x&&x<0.1){
9150     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9151     //     }
9152     //     else if(0.1<x&&x<0.2){
9153     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9154     //     }
9155     //     if(0.2<x&&x<0.4){
9156     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9157     //     }
9158
9159   }
9160
9161   // Feed-down
9162
9163   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9164   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9165     x=fhBeautyFDmin->GetBinLowEdge(j);
9166     fhBeautyFDmin->SetBinContent(j,-0.05);
9167
9168   //   if(-0.4<x&&x<-0.2){
9169 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9170 //     }
9171 //     else if(-0.2<x&&x<-0.1){
9172 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9173 //     }
9174 //     else if(-0.2<x&&x<-0.1){
9175 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9176 //     }
9177 //     else if(-0.1<x&&x<0.1){
9178 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9179 //     }
9180 //     else if(0.1<x&&x<0.2){
9181 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9182 //     }
9183 //     if(0.2<x&&x<0.4){
9184 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9185 //     }
9186   }
9187
9188   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9189   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9190     x=fhBeautyFDmax->GetBinLowEdge(j);
9191     fhBeautyFDmax->SetBinContent(j,0.03);
9192
9193 //     if(-0.4<x&&x<-0.2){
9194 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9195 //     }
9196 //     else if(-0.2<x&&x<-0.1){
9197 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9198 //     }
9199 //     else if(-0.2<x&&x<-0.1){
9200 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9201 //     }
9202 //     else if(-0.1<x&&x<0.1){
9203 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9204 //     }
9205 //     else if(0.1<x&&x<0.2){
9206 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9207 //     }
9208 //     if(0.2<x&&x<0.4){
9209 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9210 //     }
9211
9212   }
9213
9214 }
9215
9216
9217 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
9218   Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
9219   fmeson=0;
9220   fstrmeson="Dzero";
9221   fstrptAss="ptAsMore1";
9222   fstrptD="Dpt8to16";
9223   if(!fhDeltaPhiTemplate){
9224     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9225   }
9226
9227   Double_t x;
9228   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9229   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9230   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9231     fhYieldExtraction->SetBinContent(j,0.1);
9232   }
9233
9234   // Background D MESON candidate subtraction (side-band variations, etc.)
9235   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9236   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9237     fhBackSubtractionMin->SetBinContent(j,-0.05);
9238   }
9239
9240   // Background D MESON candidate subtraction (side-band variations, etc.)
9241   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9242   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9243     fhBackSubtractionMax->SetBinContent(j,0.05);
9244   }
9245
9246   // MC CORRECTIONS,  -5% 10% for assoc track eff
9247   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9248   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9249     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9250   }
9251
9252   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9253   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9254     fhMCcorrectionsMax->SetBinContent(j,0.04);
9255   }
9256
9257
9258   // MC D EFF CORRECTION
9259   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9260   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9261     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9262   }
9263
9264   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9265   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9266     fhMCDefficiencyMax->SetBinContent(j,0.05);
9267   }
9268
9269
9270   // Contamination from secondary tracks
9271   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9272   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9273     fhSecContaminationMin->SetBinContent(j,-0.035);
9274   }
9275
9276   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9277   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9278     fhSecContaminationMax->SetBinContent(j,0.035);
9279   }
9280
9281   // MC CLOSURETEST (D meson efficiency)
9282   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9283   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9284     x=fhMCclosureTestMin->GetBinLowEdge(j);
9285     fhMCclosureTestMin->SetBinContent(j,-0.);
9286
9287     if(-0.4<x&&x<-0.2){
9288       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9289     }
9290     else if(-0.2<x&&x<-0.1){
9291       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9292     }
9293     else if(-0.1<x&&x<0.1){
9294       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9295     }
9296     else if(0.1<x&&x<0.2){
9297       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9298     }
9299     if(0.2<x&&x<0.4){
9300       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9301     }
9302   }
9303
9304   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9305   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9306     x=fhMCclosureTestMax->GetBinLowEdge(j);
9307     fhMCclosureTestMax->SetBinContent(j,0.05);
9308
9309     //     if(-0.4<x&&x<-0.2){
9310     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9311     //     }
9312     //     else if(-0.2<x&&x<-0.1){
9313     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9314     //     }
9315     //     else if(-0.2<x&&x<-0.1){
9316     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9317     //     }
9318     //     else if(-0.1<x&&x<0.1){
9319     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9320     //     }
9321     //     else if(0.1<x&&x<0.2){
9322     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9323     //     }
9324     //     if(0.2<x&&x<0.4){
9325     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9326     //     }
9327
9328   }
9329
9330   // Feed-down
9331
9332   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9333   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9334     x=fhBeautyFDmin->GetBinLowEdge(j);
9335     fhBeautyFDmin->SetBinContent(j,-0.05);
9336
9337   //   if(-0.4<x&&x<-0.2){
9338 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9339 //     }
9340 //     else if(-0.2<x&&x<-0.1){
9341 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9342 //     }
9343 //     else if(-0.2<x&&x<-0.1){
9344 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9345 //     }
9346 //     else if(-0.1<x&&x<0.1){
9347 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9348 //     }
9349 //     else if(0.1<x&&x<0.2){
9350 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9351 //     }
9352 //     if(0.2<x&&x<0.4){
9353 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9354 //     }
9355   }
9356
9357   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9358   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9359     x=fhBeautyFDmax->GetBinLowEdge(j);
9360     fhBeautyFDmax->SetBinContent(j,0.03);
9361
9362 //     if(-0.4<x&&x<-0.2){
9363 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9364 //     }
9365 //     else if(-0.2<x&&x<-0.1){
9366 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9367 //     }
9368 //     else if(-0.2<x&&x<-0.1){
9369 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9370 //     }
9371 //     else if(-0.1<x&&x<0.1){
9372 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9373 //     }
9374 //     else if(0.1<x&&x<0.2){
9375 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9376 //     }
9377 //     if(0.2<x&&x<0.4){
9378 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9379 //     }
9380
9381   }
9382
9383 }
9384
9385
9386
9387
9388 //--------------------------------------------------
9389 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
9390  Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9391   fmeson=1;
9392   fstrmeson="Dstar";
9393   fstrptAss="ptAsMore1";
9394   fstrptD="Dpt3to5";
9395   if(!fhDeltaPhiTemplate){
9396     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9397   }
9398   Double_t x;
9399   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9400   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9401   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9402     fhYieldExtraction->SetBinContent(j,0.1);
9403   }
9404
9405   // Background D MESON candidate subtraction (side-band variations, etc.)
9406   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9407   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9408     fhBackSubtractionMin->SetBinContent(j,-0.08);
9409   }
9410
9411   // Background D MESON candidate subtraction (side-band variations, etc.)
9412   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9413   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9414     fhBackSubtractionMax->SetBinContent(j,0.08);
9415   }
9416
9417   // MC CORRECTIONS, -5%  10% for assoc track eff
9418   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9419   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9420     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9421   }
9422
9423   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9424   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9425     fhMCcorrectionsMax->SetBinContent(j,0.04);
9426   }
9427
9428
9429   // MC D EFF CORRECTION
9430   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9431   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9432     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9433   }
9434
9435   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9436   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9437     fhMCDefficiencyMax->SetBinContent(j,0.05);
9438   }
9439
9440
9441   // Contamination from secondary tracks
9442   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9443   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9444     fhSecContaminationMin->SetBinContent(j,-0.035);
9445   }
9446
9447   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9448   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9449     fhSecContaminationMax->SetBinContent(j,0.035);
9450   }
9451
9452   // MC CLOSURETEST (D meson efficiency)
9453   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9454   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9455     x=fhMCclosureTestMin->GetBinLowEdge(j);
9456     fhMCclosureTestMin->SetBinContent(j,-0.0);
9457
9458     if(-0.4<x&&x<-0.2){
9459       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9460     }
9461     else if(-0.2<x&&x<-0.1){
9462       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9463     }
9464     else if(-0.1<x&&x<0.1){
9465       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9466     }
9467     else if(0.1<x&&x<0.2){
9468       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9469     }
9470     if(0.2<x&&x<0.4){
9471       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9472     }
9473   }
9474
9475   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9476   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9477     x=fhMCclosureTestMax->GetBinLowEdge(j);
9478     fhMCclosureTestMax->SetBinContent(j,0.05);
9479
9480     //     if(-0.4<x&&x<-0.2){
9481     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9482     //     }
9483     //     else if(-0.2<x&&x<-0.1){
9484     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9485     //     }
9486     //     else if(-0.2<x&&x<-0.1){
9487     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9488     //     }
9489     //     else if(-0.1<x&&x<0.1){
9490     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9491     //     }
9492     //     else if(0.1<x&&x<0.2){
9493     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9494     //     }
9495     //     if(0.2<x&&x<0.4){
9496     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9497     //     }
9498
9499   }
9500
9501   // Feed-down
9502
9503   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9504   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9505     x=fhBeautyFDmin->GetBinLowEdge(j);
9506     fhBeautyFDmin->SetBinContent(j,-0.05);
9507
9508   //   if(-0.4<x&&x<-0.2){
9509 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9510 //     }
9511 //     else if(-0.2<x&&x<-0.1){
9512 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9513 //     }
9514 //     else if(-0.2<x&&x<-0.1){
9515 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9516 //     }
9517 //     else if(-0.1<x&&x<0.1){
9518 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9519 //     }
9520 //     else if(0.1<x&&x<0.2){
9521 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9522 //     }
9523 //     if(0.2<x&&x<0.4){
9524 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9525 //     }
9526   }
9527
9528   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9529   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9530     x=fhBeautyFDmax->GetBinLowEdge(j);
9531     fhBeautyFDmax->SetBinContent(j,0.03);
9532
9533 //     if(-0.4<x&&x<-0.2){
9534 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9535 //     }
9536 //     else if(-0.2<x&&x<-0.1){
9537 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9538 //     }
9539 //     else if(-0.2<x&&x<-0.1){
9540 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9541 //     }
9542 //     else if(-0.1<x&&x<0.1){
9543 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9544 //     }
9545 //     else if(0.1<x&&x<0.2){
9546 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9547 //     }
9548 //     if(0.2<x&&x<0.4){
9549 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9550 //     }
9551
9552   }
9553
9554
9555 }
9556
9557 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
9558  Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
9559   fmeson=1;
9560   fstrmeson="Dstar";
9561   fstrptAss="ptAsMore1";
9562   fstrptD="Dpt5to8";
9563   if(!fhDeltaPhiTemplate){
9564     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9565   }
9566   Double_t x;
9567   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9568   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9569   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9570     fhYieldExtraction->SetBinContent(j,0.1);
9571   }
9572
9573   // Background D MESON candidate subtraction (side-band variations, etc.)
9574   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9575   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9576     fhBackSubtractionMin->SetBinContent(j,-0.06);
9577   }
9578
9579   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9580   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9581     fhBackSubtractionMax->SetBinContent(j,0.06);
9582   }
9583
9584   // MC CORRECTIONS/ -5%  10% for assoc track eff
9585   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9586   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9587     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9588   }
9589
9590   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9591   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9592     fhMCcorrectionsMax->SetBinContent(j,0.04);
9593   }
9594
9595   // MC D EFF CORRECTION
9596   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9597   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9598     fhMCDefficiencyMin->SetBinContent(j,-0.05);
9599   }
9600
9601   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9602   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9603     fhMCDefficiencyMax->SetBinContent(j,0.05);
9604   }
9605
9606
9607   // Contamination from secondary tracks
9608   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9609   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9610     fhSecContaminationMin->SetBinContent(j,-0.035);
9611   }
9612
9613   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9614   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9615     fhSecContaminationMax->SetBinContent(j,0.035);
9616   }
9617
9618   // MC CLOSURETEST (D meson efficiency)
9619   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9620   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9621     x=fhMCclosureTestMin->GetBinLowEdge(j);
9622     fhMCclosureTestMin->SetBinContent(j,-0.);
9623
9624     if(-0.4<x&&x<-0.2){
9625       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9626     }
9627     else if(-0.2<x&&x<-0.1){
9628       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9629     }
9630     else if(-0.1<x&&x<0.1){
9631       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9632     }
9633     else if(0.1<x&&x<0.2){
9634       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9635     }
9636     if(0.2<x&&x<0.4){
9637       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9638     }
9639   }
9640
9641   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9642   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9643     x=fhMCclosureTestMax->GetBinLowEdge(j);
9644     fhMCclosureTestMax->SetBinContent(j,0.05);
9645
9646     //     if(-0.4<x&&x<-0.2){
9647     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9648     //     }
9649     //     else if(-0.2<x&&x<-0.1){
9650     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9651     //     }
9652     //     else if(-0.2<x&&x<-0.1){
9653     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9654     //     }
9655     //     else if(-0.1<x&&x<0.1){
9656     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9657     //     }
9658     //     else if(0.1<x&&x<0.2){
9659     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9660     //     }
9661     //     if(0.2<x&&x<0.4){
9662     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9663     //     }
9664
9665   }
9666
9667   // Feed-down
9668
9669   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9670   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9671     x=fhBeautyFDmin->GetBinLowEdge(j);
9672     fhBeautyFDmin->SetBinContent(j,-0.05);
9673
9674   //   if(-0.4<x&&x<-0.2){
9675 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9676 //     }
9677 //     else if(-0.2<x&&x<-0.1){
9678 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9679 //     }
9680 //     else if(-0.2<x&&x<-0.1){
9681 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9682 //     }
9683 //     else if(-0.1<x&&x<0.1){
9684 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9685 //     }
9686 //     else if(0.1<x&&x<0.2){
9687 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9688 //     }
9689 //     if(0.2<x&&x<0.4){
9690 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9691 //     }
9692   }
9693
9694   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9695   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9696     x=fhBeautyFDmax->GetBinLowEdge(j);
9697     fhBeautyFDmax->SetBinContent(j,0.03);
9698
9699 //     if(-0.4<x&&x<-0.2){
9700 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9701 //     }
9702 //     else if(-0.2<x&&x<-0.1){
9703 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9704 //     }
9705 //     else if(-0.2<x&&x<-0.1){
9706 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9707 //     }
9708 //     else if(-0.1<x&&x<0.1){
9709 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9710 //     }
9711 //     else if(0.1<x&&x<0.2){
9712 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9713 //     }
9714 //     if(0.2<x&&x<0.4){
9715 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9716 //     }
9717
9718   }
9719
9720 }
9721
9722
9723
9724 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
9725   Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
9726   fmeson=1;
9727   fstrmeson="Dstar";
9728   fstrptAss="ptAsMore1";
9729   fstrptD="Dpt8to16";
9730   if(!fhDeltaPhiTemplate){
9731     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9732   }
9733   Double_t x;
9734   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9735   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9736   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9737     fhYieldExtraction->SetBinContent(j,0.1);
9738   }
9739
9740   // Background D MESON candidate subtraction (side-band variations, etc.)
9741   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9742   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9743     fhBackSubtractionMin->SetBinContent(j,-0.05);
9744   }
9745
9746   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9747   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9748     fhBackSubtractionMax->SetBinContent(j,0.05);
9749   }
9750
9751   // MC CORRECTIONS   -5% +10% for assoc track eff
9752   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9753   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9754     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9755   }
9756
9757   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9758   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9759     fhMCcorrectionsMax->SetBinContent(j,0.04);
9760   }
9761   // MC D EFF CORRECTION
9762   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9763   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9764     fhMCDefficiencyMin->SetBinContent(j,-0.08);
9765   }
9766
9767   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9768   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9769     fhMCDefficiencyMax->SetBinContent(j,0.08);
9770   }
9771
9772
9773   // Contamination from secondary tracks
9774   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9775   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9776     fhSecContaminationMin->SetBinContent(j,-0.035);
9777   }
9778
9779   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9780   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9781     fhSecContaminationMax->SetBinContent(j,0.035);
9782   }
9783
9784   // MC CLOSURETEST (D meson efficiency)
9785   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9786   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9787     x=fhMCclosureTestMin->GetBinLowEdge(j);
9788     fhMCclosureTestMin->SetBinContent(j,-0);
9789
9790     if(-0.4<x&&x<-0.2){
9791       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9792     }
9793     else if(-0.2<x&&x<-0.1){
9794       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9795     }
9796     else if(-0.1<x&&x<0.1){
9797       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9798     }
9799     else if(0.1<x&&x<0.2){
9800       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9801     }
9802     if(0.2<x&&x<0.4){
9803       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9804     }
9805   }
9806
9807   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9808   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9809     x=fhMCclosureTestMax->GetBinLowEdge(j);
9810     fhMCclosureTestMax->SetBinContent(j,0.05);
9811
9812     //     if(-0.4<x&&x<-0.2){
9813     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9814     //     }
9815     //     else if(-0.2<x&&x<-0.1){
9816     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9817     //     }
9818     //     else if(-0.2<x&&x<-0.1){
9819     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9820     //     }
9821     //     else if(-0.1<x&&x<0.1){
9822     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9823     //     }
9824     //     else if(0.1<x&&x<0.2){
9825     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9826     //     }
9827     //     if(0.2<x&&x<0.4){
9828     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9829     //     }
9830
9831   }
9832
9833   // Feed-down
9834
9835   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
9836   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
9837     x=fhBeautyFDmin->GetBinLowEdge(j);
9838     fhBeautyFDmin->SetBinContent(j,-0.05);
9839
9840   //   if(-0.4<x&&x<-0.2){
9841 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9842 //     }
9843 //     else if(-0.2<x&&x<-0.1){
9844 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9845 //     }
9846 //     else if(-0.2<x&&x<-0.1){
9847 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9848 //     }
9849 //     else if(-0.1<x&&x<0.1){
9850 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
9851 //     }
9852 //     else if(0.1<x&&x<0.2){
9853 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
9854 //     }
9855 //     if(0.2<x&&x<0.4){
9856 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
9857 //     }
9858   }
9859
9860   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
9861   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
9862     x=fhBeautyFDmax->GetBinLowEdge(j);
9863     fhBeautyFDmax->SetBinContent(j,0.03);
9864
9865 //     if(-0.4<x&&x<-0.2){
9866 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9867 //     }
9868 //     else if(-0.2<x&&x<-0.1){
9869 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9870 //     }
9871 //     else if(-0.2<x&&x<-0.1){
9872 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9873 //     }
9874 //     else if(-0.1<x&&x<0.1){
9875 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
9876 //     }
9877 //     else if(0.1<x&&x<0.2){
9878 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
9879 //     }
9880 //     if(0.2<x&&x<0.4){
9881 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
9882 //     }
9883
9884   }
9885
9886
9887 }
9888
9889
9890
9891 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
9892   Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
9893   fmeson=2;
9894   fstrmeson="Dplus";
9895   fstrptAss="ptAsMore1";
9896   fstrptD="Dpt3to5";
9897   if(!fhDeltaPhiTemplate){
9898     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
9899   }
9900   Double_t x;
9901   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
9902   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
9903   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
9904     fhYieldExtraction->SetBinContent(j,0.1);
9905   }
9906
9907   // Background D MESON candidate subtraction (side-band variations, etc.)
9908   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
9909   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
9910     fhBackSubtractionMin->SetBinContent(j,-0.1);
9911   }
9912
9913   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
9914   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
9915     fhBackSubtractionMax->SetBinContent(j,0.1);
9916   }
9917
9918
9919   // MC CORRECTIONS ( associatate track efficiency):
9920   //  -5%  +10% for assoc track eff
9921   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
9922   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
9923     fhMCcorrectionsMin->SetBinContent(j,-0.04);
9924   }
9925
9926   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
9927   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
9928     fhMCcorrectionsMax->SetBinContent(j,0.04);
9929   }
9930
9931   // MC D EFF CORRECTION
9932   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
9933   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
9934     fhMCDefficiencyMin->SetBinContent(j,-0.1);
9935   }
9936
9937   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
9938   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
9939     fhMCDefficiencyMax->SetBinContent(j,0.1);
9940   }
9941
9942
9943   // Contamination from secondary tracks
9944   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
9945   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
9946     fhSecContaminationMin->SetBinContent(j,-0.035);
9947   }
9948
9949   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
9950   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
9951     fhSecContaminationMax->SetBinContent(j,0.035);
9952   }
9953
9954
9955   // MC CLOSURETEST (D meson efficiency)
9956   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
9957   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
9958     x=fhMCclosureTestMin->GetBinLowEdge(j);
9959     fhMCclosureTestMin->SetBinContent(j,-0.0);
9960
9961     if(-0.4<x&&x<-0.2){
9962       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9963     }
9964     else if(-0.2<x&&x<-0.1){
9965       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9966     }
9967     else if(-0.1<x&&x<0.1){
9968       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
9969     }
9970     else if(0.1<x&&x<0.2){
9971       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
9972     }
9973     if(0.2<x&&x<0.4){
9974       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
9975     }
9976   }
9977
9978   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
9979   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
9980     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
9981     fhMCclosureTestMax->SetBinContent(j,0.05);
9982
9983     //     if(-0.4<x&&x<-0.2){
9984     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
9985     //     }
9986     //     else if(-0.2<x&&x<-0.1){
9987     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9988     //     }
9989     //     else if(-0.2<x&&x<-0.1){
9990     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9991     //     }
9992     //     else if(-0.1<x&&x<0.1){
9993     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
9994     //     }
9995     //     else if(0.1<x&&x<0.2){
9996     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
9997     //     }
9998     //     if(0.2<x&&x<0.4){
9999     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10000     //     }
10001
10002   }
10003
10004   // Feed-down
10005
10006   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10007   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10008     x=fhBeautyFDmin->GetBinLowEdge(j);
10009     fhBeautyFDmin->SetBinContent(j,-0.05);
10010
10011   //   if(-0.4<x&&x<-0.2){
10012 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10013 //     }
10014 //     else if(-0.2<x&&x<-0.1){
10015 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10016 //     }
10017 //     else if(-0.2<x&&x<-0.1){
10018 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10019 //     }
10020 //     else if(-0.1<x&&x<0.1){
10021 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10022 //     }
10023 //     else if(0.1<x&&x<0.2){
10024 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10025 //     }
10026 //     if(0.2<x&&x<0.4){
10027 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10028 //     }
10029   }
10030
10031   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10032   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10033     x=fhBeautyFDmax->GetBinLowEdge(j);
10034     fhBeautyFDmax->SetBinContent(j,0.03);
10035
10036 //     if(-0.4<x&&x<-0.2){
10037 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10038 //     }
10039 //     else if(-0.2<x&&x<-0.1){
10040 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10041 //     }
10042 //     else if(-0.2<x&&x<-0.1){
10043 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10044 //     }
10045 //     else if(-0.1<x&&x<0.1){
10046 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10047 //     }
10048 //     else if(0.1<x&&x<0.2){
10049 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10050 //     }
10051 //     if(0.2<x&&x<0.4){
10052 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10053 //     }
10054
10055   }
10056
10057 }
10058
10059 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
10060   Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
10061   fmeson=2;
10062   fstrmeson="Dplus";
10063   fstrptAss="ptAsMore1";
10064   fstrptD="Dpt5to8";
10065   if(!fhDeltaPhiTemplate){
10066     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
10067   }
10068   Double_t x;
10069   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
10070   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
10071   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
10072     fhYieldExtraction->SetBinContent(j,0.1);
10073   }
10074
10075   // Background D MESON candidate subtraction (side-band variations, etc.)
10076   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
10077   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
10078     fhBackSubtractionMin->SetBinContent(j,-0.1);
10079   }
10080
10081   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10082   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
10083     fhBackSubtractionMax->SetBinContent(j,0.1);
10084   }
10085
10086   // MC CORRECTIONS:  -5%  +10% for assoc track eff
10087   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
10088   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
10089     fhMCcorrectionsMin->SetBinContent(j,-0.04);
10090   }
10091
10092   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10093   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
10094     fhMCcorrectionsMax->SetBinContent(j,0.04);
10095   }
10096
10097
10098   // MC D EFF CORRECTION
10099   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10100   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
10101     fhMCDefficiencyMin->SetBinContent(j,-0.1);
10102   }
10103
10104   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10105   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
10106     fhMCDefficiencyMax->SetBinContent(j,0.1);
10107   }
10108
10109
10110   // Contamination from secondary tracks
10111   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10112   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
10113     fhSecContaminationMin->SetBinContent(j,-0.035);
10114   }
10115
10116   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10117   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
10118     fhSecContaminationMax->SetBinContent(j,0.035);
10119   }
10120
10121   // MC CLOSURETEST (D meson efficiency)
10122   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
10123   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
10124     x=fhMCclosureTestMin->GetBinLowEdge(j);
10125     fhMCclosureTestMin->SetBinContent(j,-0.0);
10126
10127     if(-0.4<x&&x<-0.2){
10128       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10129     }
10130     else if(-0.2<x&&x<-0.1){
10131       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10132     }
10133     else if(-0.1<x&&x<0.1){
10134       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10135     }
10136     else if(0.1<x&&x<0.2){
10137       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10138     }
10139     if(0.2<x&&x<0.4){
10140       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10141     }
10142   }
10143
10144   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10145   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10146     x=fhMCclosureTestMax->GetBinLowEdge(j);
10147     fhMCclosureTestMax->SetBinContent(j,0.05);
10148
10149     //     if(-0.4<x&&x<-0.2){
10150     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10151     //     }
10152     //     else if(-0.2<x&&x<-0.1){
10153     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10154     //     }
10155     //     else if(-0.2<x&&x<-0.1){
10156     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10157     //     }
10158     //     else if(-0.1<x&&x<0.1){
10159     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10160     //     }
10161     //     else if(0.1<x&&x<0.2){
10162     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10163     //     }
10164     //     if(0.2<x&&x<0.4){
10165     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10166     //     }
10167
10168   }
10169
10170   // Feed-down
10171
10172   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10173   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10174     x=fhBeautyFDmin->GetBinLowEdge(j);
10175     fhBeautyFDmin->SetBinContent(j,-0.05);
10176
10177   //   if(-0.4<x&&x<-0.2){
10178 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10179 //     }
10180 //     else if(-0.2<x&&x<-0.1){
10181 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10182 //     }
10183 //     else if(-0.2<x&&x<-0.1){
10184 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10185 //     }
10186 //     else if(-0.1<x&&x<0.1){
10187 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10188 //     }
10189 //     else if(0.1<x&&x<0.2){
10190 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10191 //     }
10192 //     if(0.2<x&&x<0.4){
10193 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10194 //     }
10195   }
10196
10197   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10198   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10199     x=fhBeautyFDmax->GetBinLowEdge(j);
10200     fhBeautyFDmax->SetBinContent(j,0.03);
10201
10202 //     if(-0.4<x&&x<-0.2){
10203 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10204 //     }
10205 //     else if(-0.2<x&&x<-0.1){
10206 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10207 //     }
10208 //     else if(-0.2<x&&x<-0.1){
10209 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10210 //     }
10211 //     else if(-0.1<x&&x<0.1){
10212 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10213 //     }
10214 //     else if(0.1<x&&x<0.2){
10215 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10216 //     }
10217 //     if(0.2<x&&x<0.4){
10218 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10219 //     }
10220
10221   }
10222
10223 }
10224
10225
10226 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){
10227   Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");
10228   fmeson=2;
10229   fstrmeson="Dplus";
10230   fstrptAss="ptAsMore1";
10231   fstrptD="Dpt8to16";
10232   if(!fhDeltaPhiTemplate){
10233     fhDeltaPhiTemplate=new TH1D("fhDeltaPhiTemplate","fhDeltaPhiTemplate",32,-TMath::Pi()/2.,3./2.*TMath::Pi());
10234   }
10235
10236   Double_t x;
10237   // D MESON YIELD EXTRACTION (->NORMALIZATION): relative uncertainty is constant
10238   fhYieldExtraction=(TH1D*)fhDeltaPhiTemplate->Clone("fhYieldExtraction");
10239   for(Int_t j=1;j<=fhYieldExtraction->GetNbinsX();j++){
10240     fhYieldExtraction->SetBinContent(j,0.1);
10241   }
10242
10243   // Background D MESON candidate subtraction (side-band variations, etc.)
10244   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
10245   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
10246     fhBackSubtractionMin->SetBinContent(j,-0.1);
10247   }
10248
10249   // Background D MESON candidate subtraction (side-band variations, etc.)
10250   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
10251   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
10252     fhBackSubtractionMax->SetBinContent(j,0.1);
10253   }
10254
10255   // MC CORRECTIONS,  -5% 10% for assoc track eff
10256   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
10257   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
10258     fhMCcorrectionsMin->SetBinContent(j,-0.04);
10259   }
10260
10261   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
10262   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
10263     fhMCcorrectionsMax->SetBinContent(j,0.04);
10264   }
10265
10266
10267   // MC D EFF CORRECTION
10268   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
10269   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
10270     fhMCDefficiencyMin->SetBinContent(j,-0.1);
10271   }
10272
10273   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
10274   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
10275     fhMCDefficiencyMax->SetBinContent(j,0.1);
10276   }
10277
10278
10279   // Contamination from secondary tracks
10280   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
10281   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
10282     fhSecContaminationMin->SetBinContent(j,-0.035);
10283   }
10284
10285   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
10286   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
10287     fhSecContaminationMax->SetBinContent(j,0.035);
10288   }
10289
10290   // MC CLOSURETEST (D meson efficiency)
10291   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
10292   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
10293     x=fhMCclosureTestMin->GetBinLowEdge(j);
10294     fhMCclosureTestMin->SetBinContent(j,-0.0);
10295
10296     if(-0.4<x&&x<-0.2){
10297       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10298     }
10299     else if(-0.2<x&&x<-0.1){
10300       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10301     }
10302     else if(-0.1<x&&x<0.1){
10303       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.02);
10304     }
10305     else if(0.1<x&&x<0.2){
10306       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.015);
10307     }
10308     if(0.2<x&&x<0.4){
10309       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);
10310     }
10311   }
10312
10313   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
10314   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
10315     x=fhMCclosureTestMax->GetBinLowEdge(j);
10316     fhMCclosureTestMax->SetBinContent(j,0.05);
10317
10318     //     if(-0.4<x&&x<-0.2){
10319     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10320     //     }
10321     //     else if(-0.2<x&&x<-0.1){
10322     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10323     //     }
10324     //     else if(-0.2<x&&x<-0.1){
10325     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10326     //     }
10327     //     else if(-0.1<x&&x<0.1){
10328     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.08);
10329     //     }
10330     //     else if(0.1<x&&x<0.2){
10331     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.06);
10332     //     }
10333     //     if(0.2<x&&x<0.4){
10334     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);
10335     //     }
10336
10337   }
10338
10339   // Feed-down
10340
10341   fhBeautyFDmin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmin");
10342   for(Int_t j=1;j<=fhBeautyFDmin->GetNbinsX();j++){
10343     x=fhBeautyFDmin->GetBinLowEdge(j);
10344     fhBeautyFDmin->SetBinContent(j,-0.05);
10345
10346   //   if(-0.4<x&&x<-0.2){
10347 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10348 //     }
10349 //     else if(-0.2<x&&x<-0.1){
10350 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10351 //     }
10352 //     else if(-0.2<x&&x<-0.1){
10353 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10354 //     }
10355 //     else if(-0.1<x&&x<0.1){
10356 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.08);
10357 //     }
10358 //     else if(0.1<x&&x<0.2){
10359 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.06);
10360 //     }
10361 //     if(0.2<x&&x<0.4){
10362 //       fhBeautyFDmin->SetBinContent(j,fhBeautyFDmin->GetBinContent(j)-0.04);
10363 //     }
10364   }
10365
10366   fhBeautyFDmax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBeautyFDmax");
10367   for(Int_t j=1;j<=fhBeautyFDmax->GetNbinsX();j++){
10368     x=fhBeautyFDmax->GetBinLowEdge(j);
10369     fhBeautyFDmax->SetBinContent(j,0.03);
10370
10371 //     if(-0.4<x&&x<-0.2){
10372 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10373 //     }
10374 //     else if(-0.2<x&&x<-0.1){
10375 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10376 //     }
10377 //     else if(-0.2<x&&x<-0.1){
10378 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10379 //     }
10380 //     else if(-0.1<x&&x<0.1){
10381 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.08);
10382 //     }
10383 //     else if(0.1<x&&x<0.2){
10384 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);
10385 //     }
10386 //     if(0.2<x&&x<0.4){
10387 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);
10388 //     }
10389
10390   }
10391
10392 }
10393
10394
10395