Merge branch 'feature-movesplit'

[u/mrichter/AliRoot.git] / PWGHF / correlationHF / AliHFDhadronCorrSystUnc.cxx

diff --git a/PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx b/PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx
index 6fef0047af1e141fefa5fde2ddf38994d9b70da2..0563f8d15e6c5da8b930c101597ad7bc500198a0 100644 (file)
--- a/PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx
+++ b/PWGHF/correlationHF/AliHFDhadronCorrSystUnc.cxx
@@ -20,6 +20,12 @@
 // class for systematic uncertainties on D meson -hadron correlation distribution
 //
 // Author: A. Rossi, andrea.rossi@cern.ch
+//
+// Responsible of the values set for the different mesons/datasets
+//      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
+//      D*+: in pp 2010 min. bias and p-Pb 2013 min. bias  Sandro Bjelogrlic, sandro.bjelogrlic@cern.ch
+//      D+:  in pp 2010 min. bias and p-Pb 2013 min. bias  Jitendra Kumar, jitendra.kumar@cern.ch
+//
 /////////////////////////////////////////////////////////////
 #include <Riostream.h>
 #include "AliHFDhadronCorrSystUnc.h"
@@ -194,7 +200,8 @@ AliHFDhadronCorrSystUnc::~AliHFDhadronCorrSystUnc(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP(){
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP(){ 
+  Printf("Loading syst unc for D0 pp2010 3-5 0.3 thr");
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore03";
@@ -361,7 +368,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss03HP()
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP(){
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP(){ 
+  Printf("Loading syst unc for D0 pp2010 5-8 0.3 thr");
 
   fmeson=0;
   fstrmeson="Dzero";
@@ -380,7 +388,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -528,7 +536,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss03HP()
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(){
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(){ 
+
+  Printf("Loading syst unc for D0 pp2010 8-16 0.3 thr");
   
   fmeson=0;
   fstrmeson="Dzero";
@@ -548,7 +558,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -701,6 +711,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss03HP(
 
 //--------------------------------------------------
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP(){
+  Printf("Loading syst unc for D*+ pp 2010, 3<pt(D)<5 GeV/c, pt(assoc)>0.3");
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore03";
@@ -718,7 +729,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -868,7 +879,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss03HP()
 }
 
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss03HP(){
-
+  Printf("Loading syst unc for D*+ pp 2010, 5<pt(D)<8 GeV/c, pt(assoc)>0.3");
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore03";
@@ -886,7 +897,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss03HP()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -1058,7 +1069,7 @@ void AliHFDhadronCorrSystUnc::InitEmptyHistosFromTemplate(){
 
 
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss03HP(){
-  
+  Printf("Loading syst unc for D*+ pp 2010, 8<pt(D)<16 GeV/c, pt(assoc)>0.3");  
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore03";
@@ -1076,7 +1087,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss03HP(
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -1479,8 +1490,8 @@ void AliHFDhadronCorrSystUnc::BuildTotalNonFlatUncHisto(){
   Double_t errMin,errMax,mcClosureMinmax,mcClosureMaxmin;
 
   mcClosureMinmax=fhMCclosureTestMin->GetBinContent(fhMCclosureTestMin->GetMaximumBin());
-  Printf("The maximum is :%f", mcClosureMinmax);
   mcClosureMaxmin=fhMCclosureTestMax->GetBinContent(fhMCclosureTestMax->GetMinimumBin());
+  Printf("MC closure - The max of min is: %f, the min of max is: %f", mcClosureMinmax, mcClosureMaxmin);
 
   for(Int_t j=1;j<=fhTotalNonFlatDPhiMin->GetNbinsX();j++){
     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  
@@ -1564,49 +1575,325 @@ void AliHFDhadronCorrSystUnc::BuildTotalNonFDUncHisto(){
 
 }
 
+
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010(Int_t meson,Double_t ptD,Double_t minptAss){
+  
   if(meson==0){
+    
+    // 0.3 GeV/c
     if(TMath::Abs(minptAss-0.3)<0.0001){
       if(ptD>2&&ptD<5){
-       InitStandardUncertaintiesPP2010DzeroLowPtAss03HP();    
+       InitStandardUncertaintiesPP2010DzeroLowPtAss03HP();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DzeroMidPtAss03HP();        
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DzeroHighPtAss03HP();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }     
+    // 0.5 GeV/c
+    else if(TMath::Abs(minptAss-0.5)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DzeroLowPtAss05();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DzeroMidPtAss05();               
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DzeroHighPtAss05();
+      }      
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }       
+    // 1 GeV/c
+    else if(TMath::Abs(minptAss-1.)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DzeroLowPtAss1();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DzeroMidPtAss1();
+       
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DzeroHighPtAss1();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    else {
+      printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+    }
+  }    
+  else if(meson==1){
+    // 0.3 GeV/c
+    if(TMath::Abs(minptAss-0.3)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DstarLowPtAss03HP();     
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DstarMidPtAss03HP();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DstarHighPtAss03HP();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 0.5 GeV/c
+    else if(TMath::Abs(minptAss-0.5)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DstarLowPtAss05();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DstarMidPtAss05();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DstarHighPtAss05();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    
+    // 1 GeV/c
+    else if(TMath::Abs(minptAss-1.)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DstarLowPtAss1();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DstarMidPtAss1();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DstarHighPtAss1();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    else {
+      printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+    }
+  }
+  else if(meson==2){
+    // 0.3 GeV/c
+    if(TMath::Abs(minptAss-0.3)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DplusLowPtAss03();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DplusMidPtAss03();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DplusHighPtAss03();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 0.5 GeV/c
+    else if(TMath::Abs(minptAss-0.5)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DplusLowPtAss05();
       }
       else if(ptD>5&&ptD<8){
-       InitStandardUncertaintiesPP2010DzeroMidPtAss03HP();    
+       InitStandardUncertaintiesPP2010DplusMidPtAss05();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DplusHighPtAss05();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 1 GeV/c
+    else if(TMath::Abs(minptAss-1.)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPP2010DplusLowPtAss1();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPP2010DplusMidPtAss1();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPP2010DplusHighPtAss1();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
       }
-      else InitStandardUncertaintiesPP2010DzeroHighPtAss03HP();    
     }
     else {
       printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
     }
   }
+  else {
+    printf("PP:No meson is found  Check your input \n");
+  }
+}
+
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013(Int_t meson,Double_t ptD,Double_t minptAss){
+  
+  if(meson==0){
+    // 0.3 GeV/c
+    if(TMath::Abs(minptAss-0.3)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DzeroLowPtAss03();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DzeroMidPtAss03();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DzeroHighPtAss03();
+      }
+      
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 0.5 GeV/c
+    else if(TMath::Abs(minptAss-0.5)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DzeroLowPtAss05();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DzeroMidPtAss05();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DzeroHighPtAss05();
+      }
+      
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    
+    // 1 GeV/c
+    else if(TMath::Abs(minptAss-1.)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DzeroLowPtAss1();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DzeroMidPtAss1();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DzeroHighPtAss1();
+      } 
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    else {
+      printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+    }
+  }
   else if(meson==1){
+    // 0.3 GeV/c
     if(TMath::Abs(minptAss-0.3)<0.0001){
-      if(ptD>2&&ptD<5){
-       InitStandardUncertaintiesPP2010DstarLowPtAss03HP();    
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DstarLowPtAss03();
       }
       else if(ptD>5&&ptD<8){
-       InitStandardUncertaintiesPP2010DstarMidPtAss03HP();    
+       InitStandardUncertaintiesPPb2013DstarMidPtAss03();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DstarHighPtAss03();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 0.5 GeV/c
+    else if(TMath::Abs(minptAss-0.5)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DstarLowPtAss05();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DstarMidPtAss05();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DstarHighPtAss05();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 1 GeV/c
+    else if(TMath::Abs(minptAss-1.)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DstarLowPtAss1();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DstarMidPtAss1();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DstarHighPtAss1();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
       }
-      else InitStandardUncertaintiesPP2010DstarHighPtAss03HP();    
     }
     else {
-      printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
+      printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
     }
   }
   else if(meson==2){
+    // 0.3 GeV/c
     if(TMath::Abs(minptAss-0.3)<0.0001){
-      if(ptD>2&&ptD<5){
-       InitStandardUncertaintiesPP2010DplusLowPtAss03();    
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DplusLowPtAss03();
       }
       else if(ptD>5&&ptD<8){
-       InitStandardUncertaintiesPP2010DplusMidPtAss03();    
+       InitStandardUncertaintiesPPb2013DplusMidPtAss03();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DplusHighPtAss03();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 0.5 GeV/c
+    else if(TMath::Abs(minptAss-0.5)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DplusLowPtAss05();
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DplusMidPtAss05();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DplusHighPtAss05();
+      }      
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
+      }
+    }
+    // 1 GeV/c
+    else if(TMath::Abs(minptAss-1.)<0.0001){
+      if(ptD>3&&ptD<5){
+       InitStandardUncertaintiesPPb2013DplusLowPtAss1();      
+      }
+      else if(ptD>5&&ptD<8){
+       InitStandardUncertaintiesPPb2013DplusMidPtAss1();
+      }
+      else if(ptD>8&&ptD<16){
+       InitStandardUncertaintiesPPb2013DplusHighPtAss1();
+      }
+      else {
+       printf("Methods for syst unc not ready yet for this pt(ass) bin  \n");
       }
-      else InitStandardUncertaintiesPP2010DplusHighPtAss03();    
     }
     else {
       printf("Methods for syst unc not ready yet for this pt(ass) bin \n");
     }
   }
+  else {
+        printf("pPb-No meson is found  Check your input \n");
+  }
 }
 
 
@@ -2077,7 +2364,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss03(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -2169,7 +2456,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss03(){
 //     else if(0.1<x&&x<0.2){    
 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.06);      
 //     }
-//     if(0.2<x&&x<0.4){    
+//     if(0.2<x&&x<0.4){
 //       fhBeautyFDmax->SetBinContent(j,fhBeautyFDmax->GetBinContent(j)+0.04);      
 //     } 
     
@@ -2196,7 +2483,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -2243,7 +2530,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss03(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -2364,7 +2651,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -2412,7 +2699,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -2516,7 +2803,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss03(){
 
 //////// HIGHER PT ASS THRESHOLDS
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){ 
+  Printf("Setting syst for D0 pp 2010 3-5 0.5 thr");
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore05";
@@ -2583,7 +2871,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -2683,7 +2971,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss05(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){ 
+  Printf("Setting syst for D0 pp 2010 5-8 0.5 thr");
 
   fmeson=0;
   fstrmeson="Dzero";
@@ -2702,7 +2991,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -2749,7 +3038,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -2850,7 +3139,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss05(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){ 
+  Printf("Setting syst for D0 pp 2010 8-16 0.5 thr");
   
   fmeson=0;
   fstrmeson="Dzero";
@@ -2870,7 +3160,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -2918,7 +3208,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -3022,7 +3312,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss05(){
 
 
 //--------------------------------------------------
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){ 
+  Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore05";
@@ -3040,7 +3331,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -3189,8 +3480,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss05(){
 
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){ 
+  Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore05";
@@ -3208,7 +3499,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -3254,7 +3545,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -3356,8 +3647,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss05(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
+  Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");  
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore05";
@@ -3375,12 +3666,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.12);
   }
-
+// check those values
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.12); // check this one in particular
   }
   
   // MC CORRECTIONS   -5% +10% for assoc track eff
@@ -3420,7 +3711,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -3523,8 +3814,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss05(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){ 
+  Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore05";
   fstrptD="Dpt3to5";
@@ -3590,7 +3882,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -3691,8 +3983,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss05(){
 }
 
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
-  fmeson=0;
+  Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore05";
   fstrptD="Dpt5to8";
@@ -3709,7 +4001,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -3756,7 +4048,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -3858,8 +4150,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss05(){
 
 
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
-  fmeson=0;
+  Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");  
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore05";
   fstrptD="Dpt8to16";
@@ -3877,7 +4169,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -3925,7 +4217,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -4028,7 +4320,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss05(){
 
 
 // pt(assoc)> 1 GeV/c
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){
+  Printf("Setting uncertainties for Dzero pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore1";
@@ -4095,7 +4388,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){ P
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -4195,8 +4488,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroLowPtAss1(){ P
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){
+  Printf("Setting uncertainties for Dzero pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore1";
@@ -4214,7 +4507,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){ P
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -4261,7 +4554,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){ P
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -4362,8 +4655,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroMidPtAss1(){ P
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
+  Printf("Setting uncertainties for Dzero pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");  
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore1";
@@ -4382,7 +4675,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -4430,7 +4723,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -4535,6 +4828,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DzeroHighPtAss1(){
 
 //--------------------------------------------------
 void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+  Printf("Setting uncertainties for Dstar pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore1";
@@ -4552,7 +4846,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ P
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -4701,8 +4995,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarLowPtAss1(){ P
 
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){
+  Printf("Setting uncertainties for Dstar pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore1";
@@ -4720,7 +5014,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){ P
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -4868,8 +5162,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarMidPtAss1(){ P
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){ 
+  Printf("Setting uncertainties for Dstar pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");  
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore1";
@@ -4887,12 +5181,13 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.12);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+  
+      fhBackSubtractionMax->SetBinContent(j,0.12);
   }
   
   // MC CORRECTIONS   -5% +10% for assoc track eff
@@ -5035,8 +5330,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DstarHighPtAss1(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){
+  Printf("Setting uncertainties for Dplus pp 2010, 3<pt(D)<5, pt(assoc)>1 GeV/c ");
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore1";
   fstrptD="Dpt3to5";
@@ -5102,7 +5398,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){ P
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -5202,9 +5498,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusLowPtAss1(){ P
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){ 
+  Printf("Setting uncertainties for Dplus pp 2010, 5<pt(D)<8, pt(assoc)>1 GeV/c ");
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore1";
   fstrptD="Dpt5to8";
@@ -5221,7 +5517,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){ P
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -5268,7 +5564,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){ P
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -5369,9 +5665,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusMidPtAss1(){ P
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
+  Printf("Setting uncertainties for Dplus pp 2010, 8<pt(D)<16, pt(assoc)>1 GeV/c ");  
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore1";
   fstrptD="Dpt8to16";
@@ -5389,7 +5685,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -5437,7 +5733,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -5551,7 +5847,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPP2010DplusHighPtAss1(){
 
 // pt assoc > 0.3 GeV/c
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");  
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore03";
@@ -5582,12 +5879,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
   //  -5%  +10% for assoc track eff 
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
@@ -5605,12 +5902,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
 
@@ -5618,7 +5915,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -5640,7 +5937,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -5718,8 +6015,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss03(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");  
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore03";
@@ -5737,7 +6034,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -5748,12 +6045,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
   // MC CORRECTIONS:  -5%  +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -5772,19 +6069,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -5806,7 +6103,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -5885,8 +6182,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss03(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");    
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore03";
@@ -5905,7 +6202,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -5917,12 +6214,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03()
   // MC CORRECTIONS,  -5% 10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -5941,19 +6238,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03()
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -5975,7 +6272,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03()
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -6057,7 +6354,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss03()
 
 
 //--------------------------------------------------
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");  
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore03";
@@ -6075,7 +6373,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -6087,12 +6385,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
   // MC CORRECTIONS, -5%  10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -6111,19 +6409,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -6145,7 +6443,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -6224,8 +6522,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss03(){
 
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");  
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore03";
@@ -6243,53 +6541,53 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.04);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.04);
   }
   
   // MC CORRECTIONS/ -5%  10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.04);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.04);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -6311,7 +6609,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -6391,8 +6689,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss03(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");    
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore03";
@@ -6410,7 +6708,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -6421,41 +6719,41 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03()
   // MC CORRECTIONS   -5% +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.08);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.08);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -6477,7 +6775,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03()
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -6559,8 +6857,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss03()
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
+  Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.3 GeV/c ");    
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore03";
   fstrptD="Dpt3to5";
@@ -6577,12 +6876,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,-0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
 
   
@@ -6590,35 +6889,35 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
   //  -5%  +10% for assoc track eff 
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
 
@@ -6626,7 +6925,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -6648,7 +6947,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -6726,9 +7025,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss03(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
+  Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.3 GeV/c ");    
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore03";
   fstrptD="Dpt5to8";
@@ -6745,54 +7044,54 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
   
   // MC CORRECTIONS:  -5%  +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -6814,7 +7113,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -6893,9 +7192,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss03(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.3 GeV/c ");    
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore03";
   fstrptD="Dpt8to16";
@@ -6913,55 +7212,55 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
   
   // MC CORRECTIONS,  -5% 10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -6983,7 +7282,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03()
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.08);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -7065,7 +7364,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss03()
 
 //////// HIGHER PT ASS THRESHOLDS
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");    
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore05";
@@ -7096,12 +7396,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
   //  -5%  +10% for assoc track eff 
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
@@ -7119,12 +7419,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
 
@@ -7132,7 +7432,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -7154,7 +7454,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.07);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -7232,8 +7532,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss05(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");    
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore05";
@@ -7251,7 +7551,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -7262,12 +7562,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
   // MC CORRECTIONS:  -5%  +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -7286,19 +7586,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -7320,7 +7620,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.07);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -7399,8 +7699,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss05(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");      
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore05";
@@ -7419,7 +7719,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -7431,12 +7731,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05()
   // MC CORRECTIONS,  -5% 10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -7455,19 +7755,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05()
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -7489,7 +7789,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05()
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.07);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -7571,7 +7871,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss05()
 
 
 //--------------------------------------------------
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");      
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore05";
@@ -7589,24 +7890,24 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.07);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.07);
   }
   
   // MC CORRECTIONS, -5%  10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -7625,19 +7926,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -7659,7 +7960,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.7);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -7738,8 +8039,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss05(){
 
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");      
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore05";
@@ -7757,7 +8058,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -7768,12 +8069,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
   // MC CORRECTIONS/ -5%  10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
@@ -7791,19 +8092,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -7825,7 +8126,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.07);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -7905,8 +8206,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss05(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");        
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore05";
@@ -7924,7 +8225,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -7935,41 +8236,41 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05()
   // MC CORRECTIONS   -5% +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.08);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.08);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -7991,7 +8292,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05()
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.07);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -8072,8 +8373,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss05()
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>0.5 GeV/c ");        
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore05";
   fstrptD="Dpt3to5";
@@ -8090,12 +8392,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,-0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
 
   
@@ -8103,35 +8405,35 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
   //  -5%  +10% for assoc track eff 
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
 
@@ -8139,7 +8441,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -8161,7 +8463,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.06);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -8239,9 +8541,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss05(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>0.5 GeV/c ");        
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore05";
   fstrptD="Dpt5to8";
@@ -8258,54 +8560,54 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
   
   // MC CORRECTIONS:  -5%  +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -8327,7 +8629,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.06);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -8406,9 +8708,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss05(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>0.5 GeV/c ");          
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore05";
   fstrptD="Dpt8to16";
@@ -8426,55 +8728,55 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05()
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
   
   // MC CORRECTIONS,  -5% 10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -8496,7 +8798,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05()
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.06);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -8577,7 +8879,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss05()
 
 
 // pt(assoc)> 1 GeV/c
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
+  Printf("Setting uncertainties for Dzero pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");          
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore1";
@@ -8608,12 +8911,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
   //  -5%  +10% for assoc track eff 
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
@@ -8631,12 +8934,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
 
@@ -8644,7 +8947,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -8666,7 +8969,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -8744,8 +9047,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroLowPtAss1(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
+  Printf("Setting uncertainties for Dzero pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");          
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore1";
@@ -8763,7 +9066,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -8774,12 +9077,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
   // MC CORRECTIONS:  -5%  +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -8798,19 +9101,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -8832,7 +9135,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -8911,8 +9214,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroMidPtAss1(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){ 
+  Printf("Setting uncertainties for Dzero pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");            
   fmeson=0;
   fstrmeson="Dzero";
   fstrptAss="ptAsMore1";
@@ -8931,7 +9234,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
@@ -8943,12 +9246,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
   // MC CORRECTIONS,  -5% 10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -8967,19 +9270,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -9001,7 +9304,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -9083,7 +9386,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DzeroHighPtAss1(){
 
 
 //--------------------------------------------------
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){ 
+ Printf("Setting uncertainties for Dstar pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");            
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore1";
@@ -9101,24 +9405,24 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.08);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.08);
   }
   
   // MC CORRECTIONS, -5%  10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
@@ -9137,19 +9441,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -9171,7 +9475,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -9250,8 +9554,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarLowPtAss1(){
 
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){ 
+ Printf("Setting uncertainties for Dstar pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");            
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore1";
@@ -9269,23 +9573,23 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.06);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.06);
   }
   
   // MC CORRECTIONS/ -5%  10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
@@ -9303,19 +9607,19 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -9337,7 +9641,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -9417,8 +9721,8 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarMidPtAss1(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){ 
+  Printf("Setting uncertainties for Dstar pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");            
   fmeson=1;
   fstrmeson="Dstar";
   fstrptAss="ptAsMore1";
@@ -9436,7 +9740,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.05);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
@@ -9447,41 +9751,41 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
   // MC CORRECTIONS   -5% +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.08);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.08);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -9503,7 +9807,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -9584,8 +9888,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DstarHighPtAss1(){
 
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 3<pt(D)<5, pt(assoc)>1 GeV/c ");            
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore1";
   fstrptD="Dpt3to5";
@@ -9602,12 +9907,12 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,-0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
 
   
@@ -9615,35 +9920,35 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
   //  -5%  +10% for assoc track eff 
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
 
@@ -9651,7 +9956,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -9673,7 +9978,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     //    x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -9751,9 +10056,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusLowPtAss1(){
   
 }
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 5<pt(D)<8, pt(assoc)>1 GeV/c ");            
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore1";
   fstrptD="Dpt5to8";
@@ -9770,54 +10075,54 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
   
   // MC CORRECTIONS:  -5%  +10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -9839,7 +10144,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);      
@@ -9918,9 +10223,9 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusMidPtAss1(){
 }
 
 
-void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){ Printf("TEMPORARY VALUES (PP 2010 ass 03)");
-  
-  fmeson=0;
+void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){ 
+  Printf("Setting uncertainties for Dplus pPb 2013, 8<pt(D)<16, pt(assoc)>1 GeV/c ");            
+  fmeson=2;
   fstrmeson="Dplus";
   fstrptAss="ptAsMore1";
   fstrptD="Dpt8to16";
@@ -9938,55 +10243,55 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMin");
   for(Int_t j=1;j<=fhBackSubtractionMin->GetNbinsX();j++){
-    fhBackSubtractionMin->SetBinContent(j,0.05);
+    fhBackSubtractionMin->SetBinContent(j,-0.1);
   }
 
   // Background D MESON candidate subtraction (side-band variations, etc.)
   fhBackSubtractionMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhBackSubtractionMax");
   for(Int_t j=1;j<=fhBackSubtractionMax->GetNbinsX();j++){
-    fhBackSubtractionMax->SetBinContent(j,0.05);
+    fhBackSubtractionMax->SetBinContent(j,0.1);
   }
   
   // MC CORRECTIONS,  -5% 10% for assoc track eff
   fhMCcorrectionsMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMin");
   for(Int_t j=1;j<=fhMCcorrectionsMin->GetNbinsX();j++){
-    fhMCcorrectionsMin->SetBinContent(j,-0.05);
+    fhMCcorrectionsMin->SetBinContent(j,-0.04);
   }
 
   fhMCcorrectionsMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCcorrectionsMax");
   for(Int_t j=1;j<=fhMCcorrectionsMax->GetNbinsX();j++){
-    fhMCcorrectionsMax->SetBinContent(j,0.10);
+    fhMCcorrectionsMax->SetBinContent(j,0.04);
   }
 
 
   // MC D EFF CORRECTION
   fhMCDefficiencyMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMin");
   for(Int_t j=1;j<=fhMCDefficiencyMin->GetNbinsX();j++){
-    fhMCDefficiencyMin->SetBinContent(j,-0.05);
+    fhMCDefficiencyMin->SetBinContent(j,-0.1);
   }
 
   fhMCDefficiencyMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCDefficiencyMax");
   for(Int_t j=1;j<=fhMCDefficiencyMax->GetNbinsX();j++){
-    fhMCDefficiencyMax->SetBinContent(j,0.05);
+    fhMCDefficiencyMax->SetBinContent(j,0.1);
   }
 
 
   // Contamination from secondary tracks
   fhSecContaminationMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMin");
   for(Int_t j=1;j<=fhSecContaminationMin->GetNbinsX();j++){
-    fhSecContaminationMin->SetBinContent(j,-0.05);
+    fhSecContaminationMin->SetBinContent(j,-0.035);
   }
 
   fhSecContaminationMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhSecContaminationMax");
   for(Int_t j=1;j<=fhSecContaminationMax->GetNbinsX();j++){
-    fhSecContaminationMax->SetBinContent(j,0.05);
+    fhSecContaminationMax->SetBinContent(j,0.035);
   }
 
   // MC CLOSURETEST (D meson efficiency)
   fhMCclosureTestMin=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMin");
   for(Int_t j=1;j<=fhMCclosureTestMin->GetNbinsX();j++){
     x=fhMCclosureTestMin->GetBinLowEdge(j);
-    fhMCclosureTestMin->SetBinContent(j,-0.08);
+    fhMCclosureTestMin->SetBinContent(j,-0.0);
     
     if(-0.4<x&&x<-0.2){    
       fhMCclosureTestMin->SetBinContent(j,fhMCclosureTestMin->GetBinContent(j)-0.01);      
@@ -10008,7 +10313,7 @@ void AliHFDhadronCorrSystUnc::InitStandardUncertaintiesPPb2013DplusHighPtAss1(){
   fhMCclosureTestMax=(TH1D*)fhDeltaPhiTemplate->Clone("fhMCclosureTestMax");
   for(Int_t j=1;j<=fhMCclosureTestMax->GetNbinsX();j++){
     x=fhMCclosureTestMax->GetBinLowEdge(j);
-    fhMCclosureTestMax->SetBinContent(j,0.);
+    fhMCclosureTestMax->SetBinContent(j,0.05);
     
     //     if(-0.4<x&&x<-0.2){    
     //       fhMCclosureTestMax->SetBinContent(j,fhMCclosureTestMax->GetBinContent(j)-0.04);