First look at the global tracking mode: usage of asymmetric bins to reach high pT

diff --git a/PWG2/SPECTRA/AliProtonAnalysis.cxx b/PWG2/SPECTRA/AliProtonAnalysis.cxx
index 568aa1f5ff08cd696695fdcd936b6d9c88b847b9..04da459f8b219524dfd507bc52fb5a80b8fd9bff 100644 (file)
--- a/PWG2/SPECTRA/AliProtonAnalysis.cxx
+++ b/PWG2/SPECTRA/AliProtonAnalysis.cxx
@@ -124,6 +124,58 @@ AliProtonAnalysis::AliProtonAnalysis(Int_t nbinsY,
   fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT
 } 
 
+//____________________________________________________________________//
+AliProtonAnalysis::AliProtonAnalysis(Int_t nbinsY, Double_t *gY,
+                                    Int_t nbinsPt,Double_t *gPt) : 
+  TObject(), fProtonAnalysisBase(0),
+  fNBinsY(nbinsY), fMinY(gY[0]), fMaxY(gY[nbinsY]),
+  fNBinsPt(nbinsPt), fMinPt(gPt[0]), fMaxPt(gPt[nbinsPt]),
+  fProtonContainer(0), fAntiProtonContainer(0),
+  fHistEvents(0), fHistYPtProtons(0), fHistYPtAntiProtons(0),
+  fEffGridListProtons(0), fCorrectionListProtons2D(0), 
+  fEfficiencyListProtons1D(0), fCorrectionListProtons1D(0),
+  fEffGridListAntiProtons(0), fCorrectionListAntiProtons2D(0), 
+  fEfficiencyListAntiProtons1D(0), fCorrectionListAntiProtons1D(0),
+  fCorrectProtons(0), fCorrectAntiProtons(0){
+  //Default constructor
+  fHistEvents = new TH1I("fHistEvents","Analyzed events",1,0,1);
+
+  fHistYPtProtons = new TH2D("fHistYPtProtons","Protons",
+                            fNBinsY,gY,fNBinsPt,gPt);
+  fHistYPtProtons->SetStats(kTRUE);
+  fHistYPtProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+  if(fProtonAnalysisBase->GetEtaMode())
+    fHistYPtProtons->GetXaxis()->SetTitle("#eta");
+  else
+    fHistYPtProtons->GetXaxis()->SetTitle("y");
+  fHistYPtProtons->GetXaxis()->SetTitleColor(1);
+
+  fHistYPtAntiProtons = new TH2D("fHistYPtAntiProtons","Antiprotons",
+                                fNBinsY,gY,fNBinsPt,gPt);
+  fHistYPtAntiProtons->SetStats(kTRUE);
+  fHistYPtAntiProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+  if(fProtonAnalysisBase->GetEtaMode())
+    fHistYPtAntiProtons->GetXaxis()->SetTitle("#eta");
+  else
+    fHistYPtAntiProtons->GetXaxis()->SetTitle("y");
+  fHistYPtAntiProtons->GetXaxis()->SetTitleColor(1);
+
+  //setting up the containers
+  Int_t iBin[2];
+  iBin[0] = nbinsY;
+  iBin[1] = nbinsPt;
+  fProtonContainer = new AliCFContainer("containerProtons",
+                                       "container for protons",
+                                       1,2,iBin);
+  fProtonContainer->SetBinLimits(0,gY); //rapidity or eta
+  fProtonContainer->SetBinLimits(1,gPt); //pT
+  fAntiProtonContainer = new AliCFContainer("containerAntiProtons",
+                                           "container for antiprotons",
+                                           1,2,iBin);
+  fAntiProtonContainer->SetBinLimits(0,gY); //rapidity or eta
+  fAntiProtonContainer->SetBinLimits(1,gPt); //pT
+} 
+
 //____________________________________________________________________//
 AliProtonAnalysis::~AliProtonAnalysis() {
   //Default destructor
@@ -208,6 +260,56 @@ void AliProtonAnalysis::InitAnalysisHistograms(Int_t nbinsY,
   fAntiProtonContainer->SetBinLimits(1,binLimPt); //pT
 }
 
+//____________________________________________________________________//
+void AliProtonAnalysis::InitAnalysisHistograms(Int_t nbinsY, Double_t *gY, 
+                                              Int_t nbinsPt, Double_t *gPt) {
+  //Initializes the histograms using asymmetric values - global tracking
+  fNBinsY = nbinsY;
+  fMinY = gY[0];
+  fMaxY = gY[nbinsY];
+  fNBinsPt = nbinsPt;
+  fMinPt = gPt[0];
+  fMaxPt = gPt[nbinsPt];
+
+  fHistEvents = new TH1I("fHistEvents","Analyzed events",1,0,1);
+
+  fHistYPtProtons = new TH2D("fHistYPtProtons","Protons",
+                            fNBinsY,gY,fNBinsPt,gPt);
+  fHistYPtProtons->SetStats(kTRUE);
+  fHistYPtProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+  if(fProtonAnalysisBase->GetEtaMode())
+    fHistYPtProtons->GetXaxis()->SetTitle("#eta");
+  else
+    fHistYPtProtons->GetXaxis()->SetTitle("y");
+  fHistYPtProtons->GetXaxis()->SetTitleColor(1);
+
+  fHistYPtAntiProtons = new TH2D("fHistYPtAntiProtons","Antiprotons",
+                                fNBinsY,gY,fNBinsPt,gPt);
+  fHistYPtAntiProtons->SetStats(kTRUE);
+  fHistYPtAntiProtons->GetYaxis()->SetTitle("P_{T} [GeV/c]");
+  if(fProtonAnalysisBase->GetEtaMode())
+    fHistYPtAntiProtons->GetXaxis()->SetTitle("#eta");
+  else
+    fHistYPtAntiProtons->GetXaxis()->SetTitle("y");
+  fHistYPtAntiProtons->GetXaxis()->SetTitleColor(1);
+
+  //setting up the containers
+  Int_t iBin[2];
+  iBin[0] = nbinsY;
+  iBin[1] = nbinsPt;
+
+  fProtonContainer = new AliCFContainer("containerProtons",
+                                       "container for protons",
+                                       1,2,iBin);
+  fProtonContainer->SetBinLimits(0,gY); //rapidity
+  fProtonContainer->SetBinLimits(1,gPt); //pT
+  fAntiProtonContainer = new AliCFContainer("containerAntiProtons",
+                                           "container for antiprotons",
+                                           1,2,iBin);
+  fAntiProtonContainer->SetBinLimits(0,gY); //rapidity
+  fAntiProtonContainer->SetBinLimits(1,gPt); //pT
+}
+
 //____________________________________________________________________//
 Bool_t AliProtonAnalysis::ReadFromFile(const char* filename) {
   //Read the containers from the existing file

diff --git a/PWG2/SPECTRA/AliProtonAnalysis.h b/PWG2/SPECTRA/AliProtonAnalysis.h
index f2a6b29a968fd3755346199bcc1825ed0ed108ed..8ca4d72d13d81a55dffa909d44b099bf821021b9 100644 (file)
--- a/PWG2/SPECTRA/AliProtonAnalysis.h
+++ b/PWG2/SPECTRA/AliProtonAnalysis.h
@@ -39,6 +39,8 @@ class AliProtonAnalysis : public TObject {
   AliProtonAnalysis();
   AliProtonAnalysis(Int_t nbinsY, Float_t fLowY, Float_t fHighY,
                    Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
+  AliProtonAnalysis(Int_t nbinsY, Double_t *gY,
+                   Int_t nbinsPt, Double_t *gPt);
   virtual ~AliProtonAnalysis();
 
   void SetBaseAnalysis(AliProtonAnalysisBase * const baseAnalysis) {
@@ -48,6 +50,8 @@ class AliProtonAnalysis : public TObject {
 
   void InitAnalysisHistograms(Int_t nbinsY, Float_t fLowY, Float_t fHighY,
                              Int_t nbinsPt, Float_t fLowPt, Float_t fHighPt);
+  void InitAnalysisHistograms(Int_t nbinsY, Double_t *gY,
+                             Int_t nbinsPt, Double_t *gPt);
   Bool_t ReadFromFile(const char* filename);
   void Analyze(AliESDEvent *fESD, 
               const AliESDVertex *vertex);

diff --git a/PWG2/SPECTRA/AliProtonQAAnalysis.cxx b/PWG2/SPECTRA/AliProtonQAAnalysis.cxx
index ac45b5ef174dcec0fa50d01db46f37b32fd70c86..ef6692dca2ee2377f4b715cfb3bee5d8a22d38c6 100644 (file)
--- a/PWG2/SPECTRA/AliProtonQAAnalysis.cxx
+++ b/PWG2/SPECTRA/AliProtonQAAnalysis.cxx
@@ -44,8 +44,8 @@ ClassImp(AliProtonQAAnalysis)
 //____________________________________________________________________//
 AliProtonQAAnalysis::AliProtonQAAnalysis() : 
   TObject(), fProtonAnalysisBase(0),
-  fNBinsY(0), fMinY(0), fMaxY(0),
-  fNBinsPt(0), fMinPt(0), fMaxPt(0),
+  fNBinsY(0), fMinY(0), fMaxY(0), fY(0),
+  fNBinsPt(0), fMinPt(0), fMaxPt(0), fPt(0), fUseAsymmetricBinning(kFALSE),
   fGlobalQAList(0), fQAVertexList(0), fQA2DList(0),
   fQAPrimaryProtonsAcceptedList(0),
   fQAPrimaryProtonsRejectedList(0),
@@ -1005,6 +1005,24 @@ void AliProtonQAAnalysis::SetQAYPtBins(Int_t nbinsY,
   if(fRunEfficiencyAnalysis) InitEfficiencyAnalysis();
 }
 
+//____________________________________________________________________//
+void AliProtonQAAnalysis::SetQAYPtBins(Int_t nbinsY, Double_t *gY,
+                                      Int_t nbinsPt, Double_t *gPt) {
+  //Initializes the QA binning - asymmetric binning case
+  fUseAsymmetricBinning = kTRUE;
+  fNBinsY = nbinsY;
+  for(Int_t i = 0; i < nbinsY; i++) fY[i] = gY[i];
+  fMinY = gY[0]; fMaxY = gY[nbinsPt];
+  fNBinsPt = nbinsPt;
+  for(Int_t i = 0; i < nbinsPt; i++) fPt[i] = gPt[i];
+  fMinPt = gPt[0]; fMaxPt = gPt[nbinsPt];
+  InitQA();
+  InitCutLists();
+  InitVertexQA();
+  if(fRunMCAnalysis) InitMCAnalysis();
+  if(fRunEfficiencyAnalysis) InitEfficiencyAnalysis();
+}
+
 //____________________________________________________________________//
 void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   //Initialization of the efficiency list - reconstruction & PID efficiency
@@ -1012,10 +1030,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList = new TList();
 
   //MC primary protons and antiprotons for the reconstruction efficiency
-  TH2D *gHistMCYPtProtons = new TH2D("gHistMCYPtProtons",
-                                    ";;P_{T} [GeV/c]",
-                                    fNBinsY,fMinY,fMaxY,
-                                    fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistMCYPtProtons = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistMCYPtProtons = new TH2D("gHistMCYPtProtons",
+                                ";;P_{T} [GeV/c]",
+                                fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistMCYPtProtons = new TH2D("gHistMCYPtProtons",
+                                ";;P_{T} [GeV/c]",
+                                fNBinsY,fMinY,fMaxY,
+                                fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistMCYPtProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1023,10 +1047,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistMCYPtProtons->SetStats(kTRUE);
   gHistMCYPtProtons->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistMCYPtProtons);
-  TH2D *gHistMCYPtAntiProtons = new TH2D("gHistMCYPtAntiProtons",
-                                        ";y;P_{T} [GeV/c]",
-                                        fNBinsY,fMinY,fMaxY,
-                                        fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistMCYPtAntiProtons = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistMCYPtAntiProtons = new TH2D("gHistMCYPtAntiProtons",
+                                    ";;P_{T} [GeV/c]",
+                                    fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistMCYPtAntiProtons = new TH2D("gHistMCYPtAntiProtons",
+                                    ";y;P_{T} [GeV/c]",
+                                    fNBinsY,fMinY,fMaxY,
+                                    fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistMCYPtAntiProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1036,10 +1066,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistMCYPtAntiProtons);
 
   //MC secondary protons and antiprotons that come from weak decay for the reconstruction efficiency
-  TH2D *gHistMCYPtProtonsFromWeak = new TH2D("gHistMCYPtProtonsFromWeak",
-                                            ";;P_{T} [GeV/c]",
-                                            fNBinsY,fMinY,fMaxY,
-                                            fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistMCYPtProtonsFromWeak = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistMCYPtProtonsFromWeak = new TH2D("gHistMCYPtProtonsFromWeak",
+                                        ";;P_{T} [GeV/c]",
+                                        fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistMCYPtProtonsFromWeak = new TH2D("gHistMCYPtProtonsFromWeak",
+                                        ";;P_{T} [GeV/c]",
+                                        fNBinsY,fMinY,fMaxY,
+                                        fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistMCYPtProtonsFromWeak->GetXaxis()->SetTitle("#eta");
   else 
@@ -1047,10 +1083,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistMCYPtProtonsFromWeak->SetStats(kTRUE);
   gHistMCYPtProtonsFromWeak->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistMCYPtProtonsFromWeak);
-  TH2D *gHistMCYPtAntiProtonsFromWeak = new TH2D("gHistMCYPtAntiProtonsFromWeak",
-                                                ";y;P_{T} [GeV/c]",
-                                                fNBinsY,fMinY,fMaxY,
-                                                fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistMCYPtAntiProtonsFromWeak = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistMCYPtAntiProtonsFromWeak = new TH2D("gHistMCYPtAntiProtonsFromWeak",
+                                            ";;P_{T} [GeV/c]",
+                                            fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistMCYPtAntiProtonsFromWeak = new TH2D("gHistMCYPtAntiProtonsFromWeak",
+                                            ";y;P_{T} [GeV/c]",
+                                            fNBinsY,fMinY,fMaxY,
+                                            fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistMCYPtAntiProtonsFromWeak->GetXaxis()->SetTitle("#eta");
   else 
@@ -1060,10 +1102,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistMCYPtAntiProtonsFromWeak);
 
   //MC secondary protons and antiprotons that come from hadronic interactions for the reconstruction efficiency
-  TH2D *gHistMCYPtProtonsFromHadronic = new TH2D("gHistMCYPtProtonsFromHadronic",
-                                                ";;P_{T} [GeV/c]",
-                                                fNBinsY,fMinY,fMaxY,
-                                                fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistMCYPtProtonsFromHadronic = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistMCYPtProtonsFromHadronic = new TH2D("gHistMCYPtProtonsFromHadronic",
+                                            ";;P_{T} [GeV/c]",
+                                            fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistMCYPtProtonsFromHadronic = new TH2D("gHistMCYPtProtonsFromHadronic",
+                                            ";;P_{T} [GeV/c]",
+                                            fNBinsY,fMinY,fMaxY,
+                                            fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistMCYPtProtonsFromHadronic->GetXaxis()->SetTitle("#eta");
   else 
@@ -1071,10 +1119,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistMCYPtProtonsFromHadronic->SetStats(kTRUE);
   gHistMCYPtProtonsFromHadronic->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistMCYPtProtonsFromHadronic);
-  TH2D *gHistMCYPtAntiProtonsFromHadronic = new TH2D("gHistMCYPtAntiProtonsFromHadronic",
-                                                    ";y;P_{T} [GeV/c]",
-                                                    fNBinsY,fMinY,fMaxY,
-                                                    fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistMCYPtAntiProtonsFromHadronic = 0x0;
+  if(fUseAsymmetricBinning)
+  gHistMCYPtAntiProtonsFromHadronic = new TH2D("gHistMCYPtAntiProtonsFromHadronic",
+                                              ";;P_{T} [GeV/c]",
+                                              fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistMCYPtAntiProtonsFromHadronic = new TH2D("gHistMCYPtAntiProtonsFromHadronic",
+                                                ";y;P_{T} [GeV/c]",
+                                                fNBinsY,fMinY,fMaxY,
+                                                fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistMCYPtAntiProtonsFromHadronic->GetXaxis()->SetTitle("#eta");
   else 
@@ -1084,10 +1138,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistMCYPtAntiProtonsFromHadronic);
   
   //ESD primary protons and antiprotons for the reconstruction efficiency
-  TH2D *gHistESDYPtProtons = new TH2D("gHistESDYPtProtons",
-                                     ";;P_{T} [GeV/c]",
-                                     fNBinsY,fMinY,fMaxY,
-                                     fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistESDYPtProtons = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistESDYPtProtons = new TH2D("gHistESDYPtProtons",
+                                 ";;P_{T} [GeV/c]",
+                                 fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistESDYPtProtons = new TH2D("gHistESDYPtProtons",
+                                 ";;P_{T} [GeV/c]",
+                                 fNBinsY,fMinY,fMaxY,
+                                 fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDYPtProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1095,10 +1155,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistESDYPtProtons->SetStats(kTRUE);
   gHistESDYPtProtons->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistESDYPtProtons);
-  TH2D *gHistESDYPtAntiProtons = new TH2D("gHistESDYPtAntiProtons",
-                                         ";;P_{T} [GeV/c]",
-                                         fNBinsY,fMinY,fMaxY,
-                                         fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistESDYPtAntiProtons = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistESDYPtAntiProtons = new TH2D("gHistESDYPtAntiProtons",
+                                     ";;P_{T} [GeV/c]",
+                                     fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistESDYPtAntiProtons = new TH2D("gHistESDYPtAntiProtons",
+                                     ";;P_{T} [GeV/c]",
+                                     fNBinsY,fMinY,fMaxY,
+                                     fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDYPtAntiProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1108,10 +1174,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistESDYPtAntiProtons);
 
   //ESD (anti)protons from weak decays for the reconstruction efficiency
-  TH2D *gHistESDYPtProtonsFromWeak = new TH2D("gHistESDYPtProtonsFromWeak",
-                                             ";;P_{T} [GeV/c]",
-                                             fNBinsY,fMinY,fMaxY,
-                                             fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistESDYPtProtonsFromWeak = 0x0;
+  if(fUseAsymmetricBinning)
+  gHistESDYPtProtonsFromWeak = new TH2D("gHistESDYPtProtonsFromWeak",
+                                       ";;P_{T} [GeV/c]",
+                                       fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistESDYPtProtonsFromWeak = new TH2D("gHistESDYPtProtonsFromWeak",
+                                         ";;P_{T} [GeV/c]",
+                                         fNBinsY,fMinY,fMaxY,
+                                         fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDYPtProtonsFromWeak->GetXaxis()->SetTitle("#eta");
   else 
@@ -1119,10 +1191,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistESDYPtProtonsFromWeak->SetStats(kTRUE);
   gHistESDYPtProtonsFromWeak->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistESDYPtProtonsFromWeak);
-  TH2D *gHistESDYPtAntiProtonsFromWeak = new TH2D("gHistESDYPtAntiProtonsFromWeak",
-                                                 ";;P_{T} [GeV/c]",
-                                                 fNBinsY,fMinY,fMaxY,
-                                                 fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistESDYPtAntiProtonsFromWeak = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistESDYPtAntiProtonsFromWeak = new TH2D("gHistESDYPtAntiProtonsFromWeak",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistESDYPtAntiProtonsFromWeak = new TH2D("gHistESDYPtAntiProtonsFromWeak",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fMinY,fMaxY,
+                                             fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDYPtAntiProtonsFromWeak->GetXaxis()->SetTitle("#eta");
   else 
@@ -1132,10 +1210,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistESDYPtAntiProtonsFromWeak);
 
   //ESD (anti)protons from hadronic interactions for the reconstruction efficiency
-  TH2D *gHistESDYPtProtonsFromHadronic = new TH2D("gHistESDYPtProtonsFromHadronic",
-                                                 ";;P_{T} [GeV/c]",
-                                                 fNBinsY,fMinY,fMaxY,
-                                                 fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistESDYPtProtonsFromHadronic = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistESDYPtProtonsFromHadronic = new TH2D("gHistESDYPtProtonsFromHadronic",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistESDYPtProtonsFromHadronic = new TH2D("gHistESDYPtProtonsFromHadronic",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fMinY,fMaxY,
+                                             fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDYPtProtonsFromHadronic->GetXaxis()->SetTitle("#eta");
   else 
@@ -1143,10 +1227,16 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistESDYPtProtonsFromHadronic->SetStats(kTRUE);
   gHistESDYPtProtonsFromHadronic->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistESDYPtProtonsFromHadronic);
-  TH2D *gHistESDYPtAntiProtonsFromHadronic = new TH2D("gHistESDYPtAntiProtonsFromHadronic",
-                                                     ";;P_{T} [GeV/c]",
-                                                     fNBinsY,fMinY,fMaxY,
-                                                     fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistESDYPtAntiProtonsFromHadronic = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistESDYPtAntiProtonsFromHadronic = new TH2D("gHistESDYPtAntiProtonsFromHadronic",
+                                                 ";;P_{T} [GeV/c]",
+                                                 fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistESDYPtAntiProtonsFromHadronic = new TH2D("gHistESDYPtAntiProtonsFromHadronic",
+                                                 ";;P_{T} [GeV/c]",
+                                                 fNBinsY,fMinY,fMaxY,
+                                                 fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDYPtAntiProtonsFromHadronic->GetXaxis()->SetTitle("#eta");
   else 
@@ -1155,13 +1245,22 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   gHistESDYPtAntiProtonsFromHadronic->GetXaxis()->SetTitleColor(1);
   fEfficiencyList->Add(gHistESDYPtAntiProtonsFromHadronic);
   
-  
   //ESD reconstructed tracks that were initially protons for the PID efficiency
-  TH3D *gHistESDInitYPtProtons = new TH3D("gHistESDInitYPtProtons",
-                                         ";;P_{T} [GeV/c];N_{points}",
-                                         fNBinsY,fMinY,fMaxY,
-                                         fNBinsPt,fMinPt,fMaxPt,
-                                         50,0,200);
+  TH3D *gHistESDInitYPtProtons = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gNPoints[51];
+    for(Int_t i = 0; i < 51; i++)
+      gNPoints[i] = i*4; 
+  gHistESDInitYPtProtons = new TH3D("gHistESDInitYPtProtons",
+                                   ";;P_{T} [GeV/c];N_{points}",
+                                   fNBinsY,fY,fNBinsPt,fPt,50,gNPoints);
+  }
+  else
+    gHistESDInitYPtProtons = new TH3D("gHistESDInitYPtProtons",
+                                     ";;P_{T} [GeV/c];N_{points}",
+                                     fNBinsY,fMinY,fMaxY,
+                                     fNBinsPt,fMinPt,fMaxPt,
+                                     50,0,200);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDInitYPtProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1171,11 +1270,21 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistESDInitYPtProtons);
   
   //ESD reconstructed tracks that were initially protons and were identified as protons for the PID efficiency
-  TH3D *gHistESDIdYPtProtons = new TH3D("gHistESDIdYPtProtons",
-                                       ";;P_{T} [GeV/c];N_{points}",
-                                       fNBinsY,fMinY,fMaxY,
-                                       fNBinsPt,fMinPt,fMaxPt,
-                                       50,0,200);
+  TH3D *gHistESDIdYPtProtons = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gNPoints[51];
+    for(Int_t i = 0; i < 51; i++)
+      gNPoints[i] = i*4; 
+    gHistESDIdYPtProtons = new TH3D("gHistESDIdYPtProtons",
+                                   ";;P_{T} [GeV/c];N_{points}",
+                                   fNBinsY,fY,fNBinsPt,fPt,50,gNPoints);
+  }
+  else
+    gHistESDIdYPtProtons = new TH3D("gHistESDIdYPtProtons",
+                                   ";;P_{T} [GeV/c];N_{points}",
+                                   fNBinsY,fMinY,fMaxY,
+                                   fNBinsPt,fMinPt,fMaxPt,
+                                   50,0,200);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDIdYPtProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1185,11 +1294,21 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistESDIdYPtProtons);
  
   //ESD reconstructed tracks that were identified as protons for the PID contamination
-  TH3D *gHistESDRecIdYPtProtons = new TH3D("gHistESDRecIdYPtProtons",
-                                          ";;P_{T} [GeV/c];N_{points}",
-                                          fNBinsY,fMinY,fMaxY,
-                                          fNBinsPt,fMinPt,fMaxPt,
-                                          50,0,200);
+  TH3D *gHistESDRecIdYPtProtons = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gNPoints[51];
+    for(Int_t i = 0; i < 51; i++)
+      gNPoints[i] = i*4; 
+    gHistESDRecIdYPtProtons = new TH3D("gHistESDRecIdYPtProtons",
+                                      ";;P_{T} [GeV/c];N_{points}",
+                                      fNBinsY,fY,fNBinsPt,fPt,50,gNPoints);
+  }
+  else
+    gHistESDRecIdYPtProtons = new TH3D("gHistESDRecIdYPtProtons",
+                                      ";;P_{T} [GeV/c];N_{points}",
+                                      fNBinsY,fMinY,fMaxY,
+                                      fNBinsPt,fMinPt,fMaxPt,
+                                      50,0,200);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDRecIdYPtProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1199,11 +1318,21 @@ void AliProtonQAAnalysis::InitEfficiencyAnalysis() {
   fEfficiencyList->Add(gHistESDRecIdYPtProtons);
 
   //ESD reconstructed tracks that were identified as protons but were initially not protons for the PID contamination
-  TH3D *gHistESDContamYPtProtons = new TH3D("gHistESDContamYPtProtons",
-                                           ";;P_{T} [GeV/c];N_{points}",
-                                           fNBinsY,fMinY,fMaxY,
-                                           fNBinsPt,fMinPt,fMaxPt,
-                                           50,0,200);
+  TH3D *gHistESDContamYPtProtons = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gNPoints[51];
+    for(Int_t i = 0; i < 51; i++)
+      gNPoints[i] = i*4; 
+    gHistESDContamYPtProtons = new TH3D("gHistESDContamYPtProtons",
+                                       ";;P_{T} [GeV/c];N_{points}",
+                                       fNBinsY,fY,fNBinsPt,fPt,50,gNPoints);
+  }
+  else
+    gHistESDContamYPtProtons = new TH3D("gHistESDContamYPtProtons",
+                                       ";;P_{T} [GeV/c];N_{points}",
+                                       fNBinsY,fMinY,fMaxY,
+                                       fNBinsPt,fMinPt,fMaxPt,
+                                       50,0,200);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistESDContamYPtProtons->GetXaxis()->SetTitle("#eta");
   else 
@@ -1835,10 +1964,16 @@ void AliProtonQAAnalysis::InitQA() {
   //2D histograms
   //TDirectory *dir2D = gDirectory->mkdir("2D");
   //fGlobalQAList->Add(dir2D); dir2D->cd();
-  TH2D *gHistYPtPrimaryProtonsPass = new TH2D("gHistYPtPrimaryProtonsPass",
-                                             ";;P_{T} [GeV/c]",
-                                             fNBinsY,fMinY,fMaxY,
-                                             fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtPrimaryProtonsPass = 0x0;
+  if(fUseAsymmetricBinning)
+  gHistYPtPrimaryProtonsPass = new TH2D("gHistYPtPrimaryProtonsPass",
+                                       ";;P_{T} [GeV/c]",
+                                       fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtPrimaryProtonsPass = new TH2D("gHistYPtPrimaryProtonsPass",
+                                         ";;P_{T} [GeV/c]",
+                                         fNBinsY,fMinY,fMaxY,
+                                         fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPrimaryProtonsPass->GetXaxis()->SetTitle("#eta");
   else 
@@ -1846,10 +1981,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtPrimaryProtonsPass->SetStats(kTRUE);
   gHistYPtPrimaryProtonsPass->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtPrimaryProtonsPass);//y-pT of primary accepted ESD protons
-  TH2D *gHistYPtPrimaryProtonsReject = new TH2D("gHistYPtPrimaryProtonsReject",
-                                               ";;P_{T} [GeV/c]",
-                                               fNBinsY,fMinY,fMaxY,
-                                               fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtPrimaryProtonsReject = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtPrimaryProtonsReject = new TH2D("gHistYPtPrimaryProtonsReject",
+                                           ";;P_{T} [GeV/c]",
+                                           fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtPrimaryProtonsReject = new TH2D("gHistYPtPrimaryProtonsReject",
+                                           ";;P_{T} [GeV/c]",
+                                           fNBinsY,fMinY,fMaxY,
+                                           fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPrimaryProtonsReject->GetXaxis()->SetTitle("#eta");
   else 
@@ -1858,10 +1999,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtPrimaryProtonsReject->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtPrimaryProtonsReject);//y-pT of primary rejected ESD protons
 
-  TH2D *gHistYPtSecondaryProtonsPass = new TH2D("gHistYPtSecondaryProtonsPass",
-                                               ";;P_{T} [GeV/c]",
-                                               fNBinsY,fMinY,fMaxY,
-                                               fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtSecondaryProtonsPass = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtSecondaryProtonsPass = new TH2D("gHistYPtSecondaryProtonsPass",
+                                           ";;P_{T} [GeV/c]",
+                                           fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtSecondaryProtonsPass = new TH2D("gHistYPtSecondaryProtonsPass",
+                                           ";;P_{T} [GeV/c]",
+                                           fNBinsY,fMinY,fMaxY,
+                                           fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtSecondaryProtonsPass->GetXaxis()->SetTitle("#eta");
   else 
@@ -1869,10 +2016,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtSecondaryProtonsPass->SetStats(kTRUE);
   gHistYPtSecondaryProtonsPass->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtSecondaryProtonsPass);//y-pT of secondary accepted ESD protons
-  TH2D *gHistYPtSecondaryProtonsReject = new TH2D("gHistYPtSecondaryProtonsReject",
-                                                 ";;P_{T} [GeV/c]",
-                                                 fNBinsY,fMinY,fMaxY,
-                                                 fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtSecondaryProtonsReject = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtSecondaryProtonsReject = new TH2D("gHistYPtSecondaryProtonsReject",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtSecondaryProtonsReject = new TH2D("gHistYPtSecondaryProtonsReject",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fMinY,fMaxY,
+                                             fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtSecondaryProtonsReject->GetXaxis()->SetTitle("#eta");
   else 
@@ -1881,10 +2034,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtSecondaryProtonsReject->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtSecondaryProtonsReject);//y-pT of secondary rejected ESD protons
 
-  TH2D *gHistYPtPrimaryAntiProtonsPass = new TH2D("gHistYPtPrimaryAntiProtonsPass",
-                                                 ";;P_{T} [GeV/c]",
-                                                 fNBinsY,fMinY,fMaxY,
-                                                 fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtPrimaryAntiProtonsPass = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtPrimaryAntiProtonsPass = new TH2D("gHistYPtPrimaryAntiProtonsPass",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtPrimaryAntiProtonsPass = new TH2D("gHistYPtPrimaryAntiProtonsPass",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fMinY,fMaxY,
+                                             fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPrimaryAntiProtonsPass->GetXaxis()->SetTitle("#eta");
   else 
@@ -1892,10 +2051,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtPrimaryAntiProtonsPass->SetStats(kTRUE);
   gHistYPtPrimaryAntiProtonsPass->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtPrimaryAntiProtonsPass);//y-pT of primary accepted ESD antiprotons
-  TH2D *gHistYPtPrimaryAntiProtonsReject = new TH2D("gHistYPtPrimaryAntiProtonsReject",
-                                                   ";;P_{T} [GeV/c]",
-                                                   fNBinsY,fMinY,fMaxY,
-                                                   fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtPrimaryAntiProtonsReject = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtPrimaryAntiProtonsReject = new TH2D("gHistYPtPrimaryAntiProtonsReject",
+                                               ";;P_{T} [GeV/c]",
+                                               fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtPrimaryAntiProtonsReject = new TH2D("gHistYPtPrimaryAntiProtonsReject",
+                                               ";;P_{T} [GeV/c]",
+                                               fNBinsY,fMinY,fMaxY,
+                                               fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPrimaryAntiProtonsReject->GetXaxis()->SetTitle("#eta");
   else 
@@ -1904,10 +2069,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtPrimaryAntiProtonsReject->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtPrimaryAntiProtonsReject);//y-pT of primary rejected ESD antiprotons
 
-  TH2D *gHistYPtSecondaryAntiProtonsPass = new TH2D("gHistYPtSecondaryAntiProtonsPass",
-                                                   ";;P_{T} [GeV/c]",
-                                                   fNBinsY,fMinY,fMaxY,
-                                                   fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtSecondaryAntiProtonsPass = 0x0;
+  if(fUseAsymmetricBinning)
+  gHistYPtSecondaryAntiProtonsPass = new TH2D("gHistYPtSecondaryAntiProtonsPass",
+                                             ";;P_{T} [GeV/c]",
+                                             fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtSecondaryAntiProtonsPass = new TH2D("gHistYPtSecondaryAntiProtonsPass",
+                                               ";;P_{T} [GeV/c]",
+                                               fNBinsY,fMinY,fMaxY,
+                                               fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtSecondaryAntiProtonsPass->GetXaxis()->SetTitle("#eta");
   else 
@@ -1915,10 +2086,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtSecondaryAntiProtonsPass->SetStats(kTRUE);
   gHistYPtSecondaryAntiProtonsPass->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtSecondaryAntiProtonsPass);//y-pT of secondary accepted ESD antiprotons
-  TH2D *gHistYPtSecondaryAntiProtonsReject = new TH2D("gHistYPtSecondaryAntiProtonsReject",
-                                                     ";;P_{T} [GeV/c]",
-                                                     fNBinsY,fMinY,fMaxY,
-                                                     fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtSecondaryAntiProtonsReject = 0x0;
+  if(fUseAsymmetricBinning)
+  gHistYPtSecondaryAntiProtonsReject = new TH2D("gHistYPtSecondaryAntiProtonsReject",
+                                               ";;P_{T} [GeV/c]",
+                                               fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtSecondaryAntiProtonsReject = new TH2D("gHistYPtSecondaryAntiProtonsReject",
+                                                 ";;P_{T} [GeV/c]",
+                                                 fNBinsY,fMinY,fMaxY,
+                                                 fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtSecondaryAntiProtonsReject->GetXaxis()->SetTitle("#eta");
   else 
@@ -1927,10 +2104,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtSecondaryAntiProtonsReject->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtSecondaryAntiProtonsReject);//y-pT of secondary rejected ESD antiprotons
 
-  TH2D *gHistYPtPrimaryProtonsMC = new TH2D("gHistYPtPrimaryProtonsMC",
-                                           ";;P_{T} [GeV/c]",
-                                           fNBinsY,fMinY,fMaxY,
-                                           fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtPrimaryProtonsMC = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtPrimaryProtonsMC = new TH2D("gHistYPtPrimaryProtonsMC",
+                                       ";;P_{T} [GeV/c]",
+                                       fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtPrimaryProtonsMC = new TH2D("gHistYPtPrimaryProtonsMC",
+                                       ";;P_{T} [GeV/c]",
+                                       fNBinsY,fMinY,fMaxY,
+                                       fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPrimaryProtonsMC->GetXaxis()->SetTitle("#eta");
   else 
@@ -1938,10 +2121,16 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtPrimaryProtonsMC->SetStats(kTRUE);
   gHistYPtPrimaryProtonsMC->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtPrimaryProtonsMC);//y-pT of primary MC protons
-  TH2D *gHistYPtPrimaryAntiProtonsMC = new TH2D("gHistYPtPrimaryAntiProtonsMC",
-                                               ";;P_{T} [GeV/c]",
-                                               fNBinsY,fMinY,fMaxY,
-                                               fNBinsPt,fMinPt,fMaxPt);
+  TH2D *gHistYPtPrimaryAntiProtonsMC = 0x0;
+  if(fUseAsymmetricBinning)
+    gHistYPtPrimaryAntiProtonsMC = new TH2D("gHistYPtPrimaryAntiProtonsMC",
+                                           ";;P_{T} [GeV/c]",
+                                           fNBinsY,fY,fNBinsPt,fPt);
+  else
+    gHistYPtPrimaryAntiProtonsMC = new TH2D("gHistYPtPrimaryAntiProtonsMC",
+                                           ";;P_{T} [GeV/c]",
+                                           fNBinsY,fMinY,fMaxY,
+                                           fNBinsPt,fMinPt,fMaxPt);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPrimaryAntiProtonsMC->GetXaxis()->SetTitle("#eta");
   else 
@@ -1950,21 +2139,37 @@ void AliProtonQAAnalysis::InitQA() {
   gHistYPtPrimaryAntiProtonsMC->GetXaxis()->SetTitleColor(1);
   fQA2DList->Add(gHistYPtPrimaryAntiProtonsMC);//y-pT of primary MC antiprotons
 
-  TH3F *gHistYPtPDGProtonsPass = new TH3F("gHistYPtPDGProtonsPass",
-                                         ";;P_{T} [GeV/c];PDG",
-                                         fNBinsY,fMinY,fMaxY,
-                                         fNBinsPt,fMinPt,fMaxPt,
-                                         14,-0.5,13.5);
+  TH3F *gHistYPtPDGProtonsPass = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gPDG[15] = {-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5,10.5,11.5,12.5,13.5};
+    gHistYPtPDGProtonsPass = new TH3F("gHistYPtPDGProtonsPass",
+                                     ";;P_{T} [GeV/c];PDG",
+                                     fNBinsY,fY,fNBinsPt,fPt,14,gPDG);
+  }
+  else
+    gHistYPtPDGProtonsPass = new TH3F("gHistYPtPDGProtonsPass",
+                                     ";;P_{T} [GeV/c];PDG",
+                                     fNBinsY,fMinY,fMaxY,
+                                     fNBinsPt,fMinPt,fMaxPt,
+                                     14,-0.5,13.5);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPDGProtonsPass->GetXaxis()->SetTitle("#eta");
   else 
     gHistYPtPDGProtonsPass->GetXaxis()->SetTitle("y");
   fQA2DList->Add(gHistYPtPDGProtonsPass);//composition of secondary protons
-  TH3F *gHistYPtPDGAntiProtonsPass = new TH3F("gHistYPtPDGAntiProtonsPass",
-                                             ";;P_{T} [GeV/c];PDG",
-                                             fNBinsY,fMinY,fMaxY,
-                                             fNBinsPt,fMinPt,fMaxPt,
-                                             14,-0.5,13.5);
+  TH3F *gHistYPtPDGAntiProtonsPass = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gPDG[15] = {-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5,10.5,11.5,12.5,13.5};
+    gHistYPtPDGAntiProtonsPass = new TH3F("gHistYPtPDGAntiProtonsPass",
+                                         ";;P_{T} [GeV/c];PDG",
+                                         fNBinsY,fY,fNBinsPt,fPt,14,gPDG);
+  }
+  else
+    gHistYPtPDGAntiProtonsPass = new TH3F("gHistYPtPDGAntiProtonsPass",
+                                         ";;P_{T} [GeV/c];PDG",
+                                         fNBinsY,fMinY,fMaxY,
+                                         fNBinsPt,fMinPt,fMaxPt,
+                                         14,-0.5,13.5);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPDGAntiProtonsPass->GetXaxis()->SetTitle("#eta");
   else 
@@ -4324,21 +4529,37 @@ void AliProtonQAAnalysis::RunQAAnalysis(AliStack *stack,
 void AliProtonQAAnalysis::InitMCAnalysis() {
   //MC analysis - 3D histograms: y-pT-pdg
   fPDGList = new TList();
-  TH3F *gHistYPtPDGProtons = new TH3F("gHistYPtPDGProtons",
-                                     ";;P_{T} [GeV/c];PDG",
-                                     fNBinsY,fMinY,fMaxY,
-                                     fNBinsPt,fMinPt,fMaxPt,
-                                     14,-0.5,13.5);
+  TH3F *gHistYPtPDGProtons = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gPDG[15] = {-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5,10.5,11.5,12.5,13.5};
+  gHistYPtPDGProtons = new TH3F("gHistYPtPDGProtons",
+                               ";;P_{T} [GeV/c];PDG",
+                               fNBinsY,fY,fNBinsPt,fPt,14,gPDG);
+  }
+  else
+    gHistYPtPDGProtons = new TH3F("gHistYPtPDGProtons",
+                                 ";;P_{T} [GeV/c];PDG",
+                                 fNBinsY,fMinY,fMaxY,
+                                 fNBinsPt,fMinPt,fMaxPt,
+                                 14,-0.5,13.5);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPDGProtons->GetXaxis()->SetTitle("#eta");
   else 
     gHistYPtPDGProtons->GetXaxis()->SetTitle("y");
   fPDGList->Add(gHistYPtPDGProtons);
-  TH3F *gHistYPtPDGAntiProtons = new TH3F("gHistYPtPDGAntiProtons",
-                                         ";;P_{T} [GeV/c];PDG",
-                                         fNBinsY,fMinY,fMaxY,
-                                         fNBinsPt,fMinPt,fMaxPt,
-                                         14,-0.5,13.5);
+  TH3F *gHistYPtPDGAntiProtons = 0x0;
+  if(fUseAsymmetricBinning) {
+    Double_t gPDG[15] = {-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5,10.5,11.5,12.5,13.5};
+    gHistYPtPDGAntiProtons = new TH3F("gHistYPtPDGAntiProtons",
+                                     ";;P_{T} [GeV/c];PDG",
+                                     fNBinsY,fY,fNBinsPt,fPt,14,gPDG);
+  }
+  else
+    gHistYPtPDGAntiProtons = new TH3F("gHistYPtPDGAntiProtons",
+                                     ";;P_{T} [GeV/c];PDG",
+                                     fNBinsY,fMinY,fMaxY,
+                                     fNBinsPt,fMinPt,fMaxPt,
+                                     14,-0.5,13.5);
   if(fProtonAnalysisBase->GetEtaMode()) 
     gHistYPtPDGAntiProtons->GetXaxis()->SetTitle("#eta");
   else 

diff --git a/PWG2/SPECTRA/AliProtonQAAnalysis.h b/PWG2/SPECTRA/AliProtonQAAnalysis.h
index 06feb433cd63d8701519a480ae7dda2f81913272..4d5592efcbe8467bd7ad3b62aca686fba6f6d5d6 100644 (file)
--- a/PWG2/SPECTRA/AliProtonQAAnalysis.h
+++ b/PWG2/SPECTRA/AliProtonQAAnalysis.h
@@ -46,6 +46,8 @@ class AliProtonQAAnalysis : public TObject {
   TList *GetVertexQAList() const {return fQAVertexList;}
 
   //QA histograms
+  void SetQAYPtBins(Int_t nbinsY, Double_t *gY,
+                   Int_t nbinsPt, Double_t *gPt);
   void SetQAYPtBins(Int_t nbinsY, Double_t minY, Double_t maxY,
                    Int_t nbinsPt, Double_t minPt, Double_t maxPt);
   void RunQAAnalysis(AliStack *stack, 
@@ -110,9 +112,12 @@ class AliProtonQAAnalysis : public TObject {
 
   Int_t fNBinsY; //number of bins in eta or y
   Float_t fMinY, fMaxY; //min & max value of eta or y
+  Double_t *fY; //table of y or eta values - asymmetric
   Int_t fNBinsPt;  //number of bins in pT
   Float_t fMinPt, fMaxPt; //min & max value of pT
-  
+  Double_t *fPt; //table of pT values - asymmetric
+  Bool_t fUseAsymmetricBinning; //Flag showing if the asymmetric binning is used
+
   //QA histograms
   //Bool_t fQAHistograms; //Boolean to activate the QA histograms
   TList *fGlobalQAList; //TList storing the directories for the QA histograms

diff --git a/PWG2/SPECTRA/macros/configProtonAnalysis.C b/PWG2/SPECTRA/macros/configProtonAnalysis.C
index a86dc465e77046ed2b5f6ca867a777102d11790d..cbdd29fc2750ff5a0601d292bdc857e8c56d2dcb 100644 (file)
--- a/PWG2/SPECTRA/macros/configProtonAnalysis.C
+++ b/PWG2/SPECTRA/macros/configProtonAnalysis.C
@@ -7,14 +7,22 @@ AliProtonAnalysis *GetProtonAnalysisObject(const char* analysisLevel = "ESD",
 
   AliProtonAnalysis *analysis = new AliProtonAnalysis();
   analysis->SetBaseAnalysis(baseAnalysis);
-  //if(analysisBase->GetEtaMode()) analysis->SetEtaMode();
-  analysis->InitAnalysisHistograms(baseAnalysis->GetNBinsX(),
-                                  baseAnalysis->GetMinX(),
-                                  baseAnalysis->GetMaxX(),
-                                  baseAnalysis->GetNBinsY(),
-                                  baseAnalysis->GetMinY(),
-                                  baseAnalysis->GetMaxY());
-    
+  if(analysisBase->GetEtaMode()) analysis->SetEtaMode();
+  if(analysisBase->GetAnalysisMode() == AliProtonAnalysisBase::kGlobal) {
+    Double_t gY[17] = {-0.9,-0.75,-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.75,0.9};
+    Double_t gPt[18] = {0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.1,2.4,2.7,3.1};
+    analysis->InitAnalysisHistograms(16,gY,17,gPt);
+    //Double_t gPt[27] = {0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.7,1.9,2.1,2.4,2.7,3.0,3.4,3.8,4.2,4.7,5.1,6.0,7.0,9.0,12.0};
+    //analysis->InitAnalysisHistograms(16,gY,26,gPt);
+  }
+  else
+    analysis->InitAnalysisHistograms(baseAnalysis->GetNBinsX(),
+                                    baseAnalysis->GetMinX(),
+                                    baseAnalysis->GetMaxX(),
+                                    baseAnalysis->GetNBinsY(),
+                                    baseAnalysis->GetMinY(),
+                                    baseAnalysis->GetMaxY());
+  
   return analysis;
 }
 

diff --git a/PWG2/SPECTRA/macros/runProtonAnalysisQA.C b/PWG2/SPECTRA/macros/runProtonAnalysisQA.C
index 5e88c7f9e2606e3f95345fc88f61e5811c865877..532a17bae7172f37625f8c12f5c81e40641b96c2 100644 (file)
--- a/PWG2/SPECTRA/macros/runProtonAnalysisQA.C
+++ b/PWG2/SPECTRA/macros/runProtonAnalysisQA.C
@@ -23,7 +23,7 @@ void runProtonAnalysisQA(const char* esdAnalysisType = "Hybrid",
   timer.Start();
   
   //runLocal("ESD",esdAnalysisType,pidMode,"/home/pchrist/ALICE/Baryons/QA/Local");
-  runProof("ESD",esdAnalysisType,pidMode,100000,"/COMMON/COMMON/LHC09a4_run8100X#esdTree");
+  runProof("ESD",esdAnalysisType,pidMode,300000,"/COMMON/COMMON/LHC09a4_run8100X#esdTree");
   //runInteractive("ESD",esdAnalysisType,pidMode,"wn.xml");
   //runBatch("ESD",esdAnalysisType,pidMode,"wn.xml");