Correcting with mixed events based on different vz bins

diff --git a/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.cxx b/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.cxx
index cbdbe8b76154c50df027a3ff541a6cbf0758ebf8..6c264efcd89b5e618ff1092d98bab56d77227fcf 100644 (file)
--- a/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.cxx
+++ b/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.cxx
@@ -697,6 +697,8 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram(Int_t iVariableSingle,
                                                 Int_t iVariablePair,
                                                 Double_t psiMin, 
                                                 Double_t psiMax,
+                                                Double_t vertexZMin,
+                                                Double_t vertexZMax,
                                                 Double_t ptTriggerMin,
                                                 Double_t ptTriggerMax,
                                                 Double_t ptAssociatedMin,
@@ -711,6 +713,10 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram(Int_t iVariableSingle,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -728,6 +734,16 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram(Int_t iVariableSingle,
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+ if(fVertexBinning){
+   fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+   fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+   fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+   fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+   fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+   fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+ }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistP->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -749,12 +765,12 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram(Int_t iVariableSingle,
   //Printf("P:%lf - N:%lf - PN:%lf - NP:%lf - PP:%lf - NN:%lf",fHistP->GetEntries(0),fHistN->GetEntries(0),fHistPN->GetEntries(0),fHistNP->GetEntries(0),fHistPP->GetEntries(0),fHistNN->GetEntries(0));
 
   // Project into the wanted space (1st: analysis step, 2nd: axis)
-  TH1D* hTemp1 = (TH1D*)fHistPN->Project(0,iVariablePair);
-  TH1D* hTemp2 = (TH1D*)fHistNP->Project(0,iVariablePair);
-  TH1D* hTemp3 = (TH1D*)fHistPP->Project(0,iVariablePair);
-  TH1D* hTemp4 = (TH1D*)fHistNN->Project(0,iVariablePair);
-  TH1D* hTemp5 = (TH1D*)fHistP->Project(0,iVariableSingle);
-  TH1D* hTemp6 = (TH1D*)fHistN->Project(0,iVariableSingle);
+  TH1D* hTemp1 = (TH1D*)fHistPN->Project(0,iVariablePair); //
+  TH1D* hTemp2 = (TH1D*)fHistNP->Project(0,iVariablePair); //
+  TH1D* hTemp3 = (TH1D*)fHistPP->Project(0,iVariablePair); //
+  TH1D* hTemp4 = (TH1D*)fHistNN->Project(0,iVariablePair); //
+  TH1D* hTemp5 = (TH1D*)fHistP->Project(0,iVariableSingle); //
+  TH1D* hTemp6 = (TH1D*)fHistN->Project(0,iVariableSingle); //
 
   TH1D *gHistBalanceFunctionHistogram = 0x0;
   if((hTemp1)&&(hTemp2)&&(hTemp3)&&(hTemp4)&&(hTemp5)&&(hTemp6)) {
@@ -797,6 +813,8 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram2pMethod(Int_t iVariableSingle,
                                                         Int_t iVariablePair,
                                                         Double_t psiMin, 
                                                         Double_t psiMax,
+                                                        Double_t vertexZMin,
+                                                        Double_t vertexZMax,
                                                         Double_t ptTriggerMin,
                                                         Double_t ptTriggerMax,
                                                         Double_t ptAssociatedMin,
@@ -813,6 +831,10 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram2pMethod(Int_t iVariableSingle,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -830,6 +852,16 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram2pMethod(Int_t iVariableSingle,
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistP->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -865,6 +897,16 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram2pMethod(Int_t iVariableSingle,
   fHistPPMix->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNNMix->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    fHistPMix->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNMix->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPNMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNPMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPPMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNNMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+  
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistPMix->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -961,6 +1003,8 @@ TH1D *AliBalancePsi::GetBalanceFunctionHistogram2pMethod(Int_t iVariableSingle,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi(Double_t psiMin, 
                                                        Double_t psiMax,
+                                                       Double_t vertexZMin,
+                                                       Double_t vertexZMax,
                                                        Double_t ptTriggerMin,
                                                        Double_t ptTriggerMax,
                                                        Double_t ptAssociatedMin,
@@ -976,6 +1020,10 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -995,6 +1043,16 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi(Double_t psiMin,
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistP->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1052,6 +1110,8 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi(Double_t psiMin,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi2pMethod(Double_t psiMin, 
                                                                Double_t psiMax,
+                                                               Double_t vertexZMin,
+                                                               Double_t vertexZMax,
                                                                Double_t ptTriggerMin,
                                                                Double_t ptTriggerMax,
                                                                Double_t ptAssociatedMin,
@@ -1075,6 +1135,10 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi2pMethod(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1091,6 +1155,16 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi2pMethod(Double_t psiMin,
   fHistNP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
+  
+  // Vz
+  if(fVertexBinning){
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
 
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
@@ -1128,6 +1202,15 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi2pMethod(Double_t psiMin,
   fHistPPMix->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNNMix->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    fHistPMix->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNMix->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPNMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNPMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPPMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNNMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistPMix->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1216,6 +1299,8 @@ TH2D *AliBalancePsi::GetBalanceFunctionDeltaEtaDeltaPhi2pMethod(Double_t psiMin,
 TH1D *AliBalancePsi::GetBalanceFunction1DFrom2D2pMethod(Bool_t bPhi,
                                                         Double_t psiMin,
                                                         Double_t psiMax,
+                                                       Double_t vertexZMin,
+                                                       Double_t vertexZMax,
                                                         Double_t ptTriggerMin,
                                                         Double_t ptTriggerMax,
                                                         Double_t ptAssociatedMin,
@@ -1240,6 +1325,10 @@ TH1D *AliBalancePsi::GetBalanceFunction1DFrom2D2pMethod(Bool_t bPhi,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1257,6 +1346,16 @@ TH1D *AliBalancePsi::GetBalanceFunction1DFrom2D2pMethod(Bool_t bPhi,
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001);
   fHistNN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001);
 
+  // Vz
+  if(fVertexBinning){
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistP->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1293,6 +1392,16 @@ TH1D *AliBalancePsi::GetBalanceFunction1DFrom2D2pMethod(Bool_t bPhi,
   fHistPPMix->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001);
   fHistNNMix->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001);
 
+  // Vz
+  if(fVertexBinning){
+    fHistPMix->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNMix->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPNMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNPMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPPMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNNMix->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+  
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistPMix->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1403,6 +1512,8 @@ TH1D *AliBalancePsi::GetBalanceFunction1DFrom2D2pMethod(Bool_t bPhi,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetCorrelationFunctionPN(Double_t psiMin, 
                                              Double_t psiMax,
+                                             Double_t vertexZMin,
+                                             Double_t vertexZMax,
                                              Double_t ptTriggerMin,
                                              Double_t ptTriggerMax,
                                              Double_t ptAssociatedMin,
@@ -1414,6 +1525,10 @@ TH2D *AliBalancePsi::GetCorrelationFunctionPN(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1427,6 +1542,13 @@ TH2D *AliBalancePsi::GetCorrelationFunctionPN(Double_t psiMin,
   fHistP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistPN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    //Printf("Cutting on Vz...");
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistP->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1478,6 +1600,8 @@ TH2D *AliBalancePsi::GetCorrelationFunctionPN(Double_t psiMin,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetCorrelationFunctionNP(Double_t psiMin, 
                                              Double_t psiMax,
+                                             Double_t vertexZMin,
+                                             Double_t vertexZMax,
                                              Double_t ptTriggerMin,
                                              Double_t ptTriggerMax,
                                              Double_t ptAssociatedMin,
@@ -1489,6 +1613,10 @@ TH2D *AliBalancePsi::GetCorrelationFunctionNP(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1501,6 +1629,12 @@ TH2D *AliBalancePsi::GetCorrelationFunctionNP(Double_t psiMin,
   // Psi_2: axis 0
   fHistN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
+
+  // Vz
+  if(fVertexBinning){
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
     
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
@@ -1533,6 +1667,8 @@ TH2D *AliBalancePsi::GetCorrelationFunctionNP(Double_t psiMin,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetCorrelationFunctionPP(Double_t psiMin, 
                                              Double_t psiMax,
+                                             Double_t vertexZMin,
+                                             Double_t vertexZMax,
                                              Double_t ptTriggerMin,
                                              Double_t ptTriggerMax,
                                              Double_t ptAssociatedMin,
@@ -1544,6 +1680,10 @@ TH2D *AliBalancePsi::GetCorrelationFunctionPP(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1557,6 +1697,12 @@ TH2D *AliBalancePsi::GetCorrelationFunctionPP(Double_t psiMin,
   fHistP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistP->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1588,6 +1734,8 @@ TH2D *AliBalancePsi::GetCorrelationFunctionPP(Double_t psiMin,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetCorrelationFunctionNN(Double_t psiMin, 
                                              Double_t psiMax,
+                                             Double_t vertexZMin,
+                                             Double_t vertexZMax,
                                              Double_t ptTriggerMin,
                                              Double_t ptTriggerMax,
                                              Double_t ptAssociatedMin,
@@ -1599,6 +1747,10 @@ TH2D *AliBalancePsi::GetCorrelationFunctionNN(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1612,6 +1764,12 @@ TH2D *AliBalancePsi::GetCorrelationFunctionNN(Double_t psiMin,
   fHistN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
 
+  // Vz
+  if(fVertexBinning){
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
+
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {
     fHistN->GetGrid(0)->GetGrid()->GetAxis(1)->SetRangeUser(ptTriggerMin,ptTriggerMax-0.00001);
@@ -1643,6 +1801,8 @@ TH2D *AliBalancePsi::GetCorrelationFunctionNN(Double_t psiMin,
 //____________________________________________________________________//
 TH2D *AliBalancePsi::GetCorrelationFunctionChargeIndependent(Double_t psiMin, 
                                                             Double_t psiMax,
+                                                            Double_t vertexZMin,
+                                                            Double_t vertexZMax,
                                                             Double_t ptTriggerMin,
                                                             Double_t ptTriggerMax,
                                                             Double_t ptAssociatedMin,
@@ -1654,6 +1814,10 @@ TH2D *AliBalancePsi::GetCorrelationFunctionChargeIndependent(Double_t psiMin,
     AliError("psiMax <= psiMin");
     return NULL;
   }
+  if(vertexZMin > vertexZMax-0.00001){
+    AliError("vertexZMax <= vertexZMin");
+    return NULL;
+  }
   if(ptTriggerMin > ptTriggerMax-0.00001){
     AliError("ptTriggerMax <= ptTriggerMin");
     return NULL;
@@ -1670,6 +1834,16 @@ TH2D *AliBalancePsi::GetCorrelationFunctionChargeIndependent(Double_t psiMin,
   fHistPP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistNP->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
   fHistPN->GetGrid(0)->GetGrid()->GetAxis(0)->SetRangeUser(psiMin,psiMax-0.00001); 
+ 
+  // Vz
+  if(fVertexBinning){
+    fHistP->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistN->GetGrid(0)->GetGrid()->GetAxis(2)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistPP->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+    fHistNN->GetGrid(0)->GetGrid()->GetAxis(5)->SetRangeUser(vertexZMin,vertexZMax-0.00001); 
+  }
 
   // pt trigger
   if((ptTriggerMin != -1.)&&(ptTriggerMax != -1.)) {

diff --git a/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.h b/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.h
index fb079e04b32cf359f96979ab61bf44856760cbdb..10afb8f699b5c2781b4afeb32c48a8d7c7db49b1 100644 (file)
--- a/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.h
+++ b/PWGCF/EBYE/BalanceFunctions/AliBalancePsi.h
@@ -73,26 +73,36 @@ class AliBalancePsi : public TObject {
                        Double_t vertexZ = 0);
   
   TH2D   *GetCorrelationFunctionPN(Double_t psiMin, Double_t psiMax,
+                                  Double_t vertexZMin=-1,
+                                  Double_t vertexZMax=-1,
                                   Double_t ptTriggerMin=-1.,
                                   Double_t ptTriggerMax=-1.,
                                   Double_t ptAssociatedMin=-1.,
                                   Double_t ptAssociatedMax=-1);
   TH2D   *GetCorrelationFunctionNP(Double_t psiMin, Double_t psiMax,
+                                  Double_t vertexZMin=-1,
+                                  Double_t vertexZMax=-1,
                                   Double_t ptTriggerMin=-1.,
                                   Double_t ptTriggerMax=-1.,
                                   Double_t ptAssociatedMin=-1.,
                                   Double_t ptAssociatedMax=-1);
   TH2D   *GetCorrelationFunctionPP(Double_t psiMin, Double_t psiMax,
+                                  Double_t vertexZMin=-1,
+                                  Double_t vertexZMax=-1,
                                   Double_t ptTriggerMin=-1.,
                                   Double_t ptTriggerMax=-1.,
                                   Double_t ptAssociatedMin=-1.,
                                   Double_t ptAssociatedMax=-1);
   TH2D   *GetCorrelationFunctionNN(Double_t psiMin, Double_t psiMax,
+                                  Double_t vertexZMin=-1,
+                                  Double_t vertexZMax=-1,
                                   Double_t ptTriggerMin=-1.,
                                   Double_t ptTriggerMax=-1.,
                                   Double_t ptAssociatedMin=-1.,
-                                  Double_t ptAssociatedMax=-1);
+                                  Double_t ptAssociatedMax=-1);  
   TH2D   *GetCorrelationFunctionChargeIndependent(Double_t psiMin, Double_t psiMax,
+                                                 Double_t vertexZMin=-1,
+                                                 Double_t vertexZMax=-1,
                                                  Double_t ptTriggerMin=-1.,
                                                  Double_t ptTriggerMax=-1.,
                                                  Double_t ptAssociatedMin=-1.,
@@ -121,27 +131,35 @@ class AliBalancePsi : public TObject {
   TH1D *GetBalanceFunctionHistogram(Int_t iVariableSingle,
                                    Int_t iVariablePair,
                                    Double_t psiMin, Double_t psiMax,
+                                   Double_t vertexZMin=-1,
+                                   Double_t vertexZMax=-1,
                                    Double_t ptTriggerMin=-1.,
                                    Double_t ptTriggerMax=-1.,
                                    Double_t ptAssociatedMin=-1.,
-                                   Double_t ptAssociatedMax=-1);
+                                   Double_t ptAssociatedMax=-1);   //
 
   TH1D *GetBalanceFunctionHistogram2pMethod(Int_t iVariableSingle,
-                                   Int_t iVariablePair,
-                                   Double_t psiMin, Double_t psiMax,
-                                   Double_t ptTriggerMin=-1.,
-                                   Double_t ptTriggerMax=-1.,
-                                   Double_t ptAssociatedMin=-1.,
-                                   Double_t ptAssociatedMax=-1,
-                                   AliBalancePsi *bfMix=NULL);
+                                           Int_t iVariablePair,
+                                           Double_t psiMin, Double_t psiMax,
+                                           Double_t vertexZMin=-1,
+                                           Double_t vertexZMax=-1,
+                                           Double_t ptTriggerMin=-1.,
+                                           Double_t ptTriggerMax=-1.,
+                                           Double_t ptAssociatedMin=-1.,
+                                           Double_t ptAssociatedMax=-1,
+                                           AliBalancePsi *bfMix=NULL);
 
   TH2D *GetBalanceFunctionDeltaEtaDeltaPhi(Double_t psiMin, Double_t psiMax,
+                                          Double_t vertexZMin=-1,
+                                          Double_t vertexZMax=-1,
                                           Double_t ptTriggerMin=-1.,
                                           Double_t ptTriggerMax=-1.,
                                           Double_t ptAssociatedMin=-1.,
-                                          Double_t ptAssociatedMax=-1);
+                                          Double_t ptAssociatedMax=-1);   
   
   TH2D *GetBalanceFunctionDeltaEtaDeltaPhi2pMethod(Double_t psiMin, Double_t psiMax,
+                                                  Double_t vertexZMin=-1,
+                                                  Double_t vertexZMax=-1,
                                                   Double_t ptTriggerMin=-1.,
                                                   Double_t ptTriggerMax=-1.,
                                                   Double_t ptAssociatedMin=-1.,
@@ -150,6 +168,8 @@ class AliBalancePsi : public TObject {
 
   TH1D *GetBalanceFunction1DFrom2D2pMethod(Bool_t bPhi,
                                           Double_t psiMin, Double_t psiMax,
+                                          Double_t vertexZMin=-1,
+                                          Double_t vertexZMax=-1,
                                           Double_t ptTriggerMin=-1.,
                                           Double_t ptTriggerMax=-1.,
                                           Double_t ptAssociatedMin=-1.,

diff --git a/PWGCF/EBYE/macros/drawBalanceFunctionPsi.C b/PWGCF/EBYE/macros/drawBalanceFunctionPsi.C
index fb55c4b8d880a0707d01541b94eebcd909a22728..9501476daaad770c848bf8cbd346d450d79cf853 100644 (file)
--- a/PWGCF/EBYE/macros/drawBalanceFunctionPsi.C
+++ b/PWGCF/EBYE/macros/drawBalanceFunctionPsi.C
@@ -1,5 +1,5 @@
 const Int_t numberOfCentralityBins = 12;
-TString centralityArray[numberOfCentralityBins] = {"0-10","10-20","20-30","30-40","40-50","50-60","60-70","70-80","0-100","0-1","1-2","2-3"};
+TString centralityArray[numberOfCentralityBins] = {"0-100","10-20","20-30","30-40","40-50","50-60","60-70","70-80","0-100","0-1","1-2","2-3"};
 
 void drawBalanceFunctionPsi(const char* filename = "AnalysisResultsPsi.root", 
                            Int_t gCentrality = 1,
@@ -7,10 +7,13 @@ void drawBalanceFunctionPsi(const char* filename = "AnalysisResultsPsi.root",
                            Int_t gBit = -1,
                            const char* gCentralityEstimator = 0x0,
                            Double_t psiMin = -0.5, Double_t psiMax = 0.5,
+                           Double_t vertexZMin = -10.,
+                           Double_t vertexZMax = 10.,
                            Double_t ptTriggerMin = -1.,
                            Double_t ptTriggerMax = -1.,
                            Double_t ptAssociatedMin = -1.,
                            Double_t ptAssociatedMax = -1.,
+                           Bool_t kUseVzBinning = kTRUE,
                            Bool_t k2pMethod = kFALSE,
                            Bool_t k2pMethod2D = kFALSE,
                            TString eventClass = "EventPlane", //Can be "EventPlane", "Centrality", "Multiplicity"
@@ -45,8 +48,8 @@ void drawBalanceFunctionPsi(const char* filename = "AnalysisResultsPsi.root",
     draw(listBF,listBFShuffled,listBFMixed,
         gCentrality,gDeltaEtaDeltaPhi,
         gCentralityEstimator,
-        psiMin,psiMax,
-        ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,
+        psiMin,psiMax,vertexZMin,vertexZMax,
+        ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,kUseVzBinning,
         k2pMethod,k2pMethod2D,eventClass,bRootMoments);  
 }
 
@@ -205,8 +208,11 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
          Int_t gCentrality, Int_t gDeltaEtaDeltaPhi, 
          const char* gCentralityEstimator,
          Double_t psiMin, Double_t psiMax,
+         Double_t vertexZMin,
+         Double_t vertexZMax,
          Double_t ptTriggerMin, Double_t ptTriggerMax,
          Double_t ptAssociatedMin, Double_t ptAssociatedMax,
+         Bool_t kUseVzBinning,
          Bool_t k2pMethod = kFALSE,Bool_t k2pMethod2D = kFALSE, TString eventClass="EventPlane",Bool_t bRootMoments=kTRUE) {
   gROOT->LoadMacro("~/SetPlotStyle.C");
   SetPlotStyle();
@@ -256,6 +262,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   b->SetHistNnp(hNP);
   b->SetHistNpp(hPP);
   b->SetHistNnn(hNN);
+  if(kUseVzBinning) b->SetVertexZBinning(kTRUE);
 
   //balance function shuffling
   AliTHn *hPShuffled = NULL;
@@ -299,6 +306,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
     bShuffled->SetHistNnp(hNPShuffled);
     bShuffled->SetHistNpp(hPPShuffled);
     bShuffled->SetHistNnn(hNNShuffled);
+    if(kUseVzBinning) bShuffled->SetVertexZBinning(kTRUE);
   }
 
   //balance function mixing
@@ -345,6 +353,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
     bMixed->SetHistNnp(hNPMixed);
     bMixed->SetHistNpp(hPPMixed);
     bMixed->SetHistNnn(hNNMixed);
+    if(kUseVzBinning) bMixed->SetVertexZBinning(kTRUE);
   }
 
   TH1D *gHistBalanceFunction;
@@ -387,7 +396,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   //Raw balance function
   if(k2pMethod && !k2pMethod2D){ 
     if(bMixed){
-      gHistBalanceFunction = b->GetBalanceFunctionHistogram2pMethod(0,gDeltaEtaDeltaPhi,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+      gHistBalanceFunction = b->GetBalanceFunctionHistogram2pMethod(0,gDeltaEtaDeltaPhi,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
     }
     else{
       cerr<<"RAW: NO MIXED BF BUT REQUESTED CORRECTING WITH IT! --> FAIL"<<endl;
@@ -397,9 +406,9 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   else if(k2pMethod && k2pMethod2D){ 
     if(bMixed){
       if(gDeltaEtaDeltaPhi==1) //Delta eta
-       gHistBalanceFunction = b->GetBalanceFunction1DFrom2D2pMethod(0,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+       gHistBalanceFunction = b->GetBalanceFunction1DFrom2D2pMethod(0,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
       else //Delta phi
-       gHistBalanceFunction = b->GetBalanceFunction1DFrom2D2pMethod(1,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+       gHistBalanceFunction = b->GetBalanceFunction1DFrom2D2pMethod(1,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
     }
     else{
       cerr<<"RAW: NO MIXED BF BUT REQUESTED CORRECTING WITH IT! --> FAIL"<<endl;
@@ -407,7 +416,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
     }
   }
   else
-    gHistBalanceFunction = b->GetBalanceFunctionHistogram(0,gDeltaEtaDeltaPhi,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistBalanceFunction = b->GetBalanceFunctionHistogram(0,gDeltaEtaDeltaPhi,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   gHistBalanceFunction->SetMarkerStyle(20);
   gHistBalanceFunction->SetTitle(histoTitle.Data());
   gHistBalanceFunction->GetYaxis()->SetTitleOffset(1.3);
@@ -416,7 +425,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   //Shuffled balance function
   //if(k2pMethod){ 
   //if(bMixed)
-      //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunctionHistogram2pMethod(0,gDeltaEtaDeltaPhi,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+      //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunctionHistogram2pMethod(0,gDeltaEtaDeltaPhi,vertexZMin,vertexZMax,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
   //else{
   //cerr<<"SHUFFLE: NO MIXED BF BUT REQUESTED CORRECTING WITH IT! --> FAIL"<<endl;
   //return;
@@ -425,9 +434,9 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   //else if(k2pMethod2D){ 
   //if(bMixed){
   //  if(gDeltaEtaDeltaPhi==1) //Delta eta
-  //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunction1DFrom2D2pMethod(0,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+  //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunction1DFrom2D2pMethod(0,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
   //  else //Delta phi
-  //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunction1DFrom2D2pMethod(1,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+  //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunction1DFrom2D2pMethod(1,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
   //}
   //else{
   //  cerr<<"SHUFFLE: NO MIXED BF BUT REQUESTED CORRECTING WITH IT! --> FAIL"<<endl;
@@ -435,14 +444,14 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   //}
   //}
   //else
-  //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunctionHistogram(0,gDeltaEtaDeltaPhi,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+  //gHistBalanceFunctionShuffled = bShuffled->GetBalanceFunctionHistogram(0,gDeltaEtaDeltaPhi,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   //gHistBalanceFunctionShuffled->SetMarkerStyle(24);
   //gHistBalanceFunctionShuffled->SetName("gHistBalanceFunctionShuffled");
   
   //Mixed balance function
   if(k2pMethod && !k2pMethod2D){ 
     if(bMixed)
-      gHistBalanceFunctionMixed = bMixed->GetBalanceFunctionHistogram2pMethod(0,gDeltaEtaDeltaPhi,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+      gHistBalanceFunctionMixed = bMixed->GetBalanceFunctionHistogram2pMethod(0,gDeltaEtaDeltaPhi,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
     else{
       cerr<<"MIXED: NO MIXED BF BUT REQUESTED CORRECTING WITH IT! --> FAIL"<<endl;
       return;
@@ -451,9 +460,9 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
   else if(k2pMethod && k2pMethod2D){ 
     if(bMixed){
       if(gDeltaEtaDeltaPhi==1) //Delta eta
-       gHistBalanceFunctionMixed = bMixed->GetBalanceFunction1DFrom2D2pMethod(0,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+       gHistBalanceFunctionMixed = bMixed->GetBalanceFunction1DFrom2D2pMethod(0,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
       else //Delta phi
-       gHistBalanceFunctionMixed = bMixed->GetBalanceFunction1DFrom2D2pMethod(1,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
+       gHistBalanceFunctionMixed = bMixed->GetBalanceFunction1DFrom2D2pMethod(1,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,bMixed);
     }
     else{
       cerr<<"MIXED: NO MIXED BF BUT REQUESTED CORRECTING WITH IT! --> FAIL"<<endl;
@@ -461,7 +470,7 @@ void draw(TList *listBF, TList *listBFShuffled, TList *listBFMixed,
     }
   }
   else
-    gHistBalanceFunctionMixed = bMixed->GetBalanceFunctionHistogram(0,gDeltaEtaDeltaPhi,psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistBalanceFunctionMixed = bMixed->GetBalanceFunctionHistogram(0,gDeltaEtaDeltaPhi,psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   gHistBalanceFunctionMixed->SetMarkerStyle(25);
   gHistBalanceFunctionMixed->SetName("gHistBalanceFunctionMixed");
   

diff --git a/PWGCF/EBYE/macros/drawCorrelationFunctionPsi.C b/PWGCF/EBYE/macros/drawCorrelationFunctionPsi.C
index 506713fde186bacaa3bb629bc2e27791ff723a89..4d84ce1d6e952f0bd75c3c640c3a17ec7de3b521 100644 (file)
--- a/PWGCF/EBYE/macros/drawCorrelationFunctionPsi.C
+++ b/PWGCF/EBYE/macros/drawCorrelationFunctionPsi.C
@@ -12,11 +12,14 @@ void drawCorrelationFunctionPsi(const char* filename = "AnalysisResultsPsi_train
                                Bool_t kShowMixed = kTRUE, 
                                Double_t psiMin = -0.5, 
                                Double_t psiMax = 3.5,
+                               Double_t vertexZMin = -10.,
+                               Double_t vertexZMax = 10.,
                                Double_t ptTriggerMin = -1.,
                                Double_t ptTriggerMax = -1.,
                                Double_t ptAssociatedMin = -1.,
                                Double_t ptAssociatedMax = -1.,
                                Bool_t normToTrig = kTRUE,
+                               Bool_t kUseVzBinning = kTRUE,
                                Int_t rebinEta = 1,
                                Int_t rebinPhi = 1,
                                TString eventClass = "EventPlane") //Can be "EventPlane", "Centrality", "Multiplicity"
@@ -87,8 +90,8 @@ void drawCorrelationFunctionPsi(const char* filename = "AnalysisResultsPsi_train
   }
   else 
     draw(list,listShuffled,listMixed,listQA,
-        gCentralityEstimator,gCentrality,psiMin,psiMax,
-        ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,normToTrig,rebinEta,rebinPhi,eventClass);
+        gCentralityEstimator,gCentrality,psiMin,psiMax,vertexZMin,vertexZMax,
+        ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax,normToTrig,kUseVzBinning,rebinEta,rebinPhi,eventClass);
 }
 
 //______________________________________________________//
@@ -251,12 +254,16 @@ TList *GetListOfObjects(const char* filename,
 }
 
 //______________________________________________________//
-void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
+void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, 
+         TList *listQA,
          const char *gCentralityEstimator,
-         Int_t gCentrality, Double_t psiMin, Double_t psiMax,
+         Int_t gCentrality, Double_t psiMin, Double_t psiMax,  
+         Double_t vertexZMin,Double_t vertexZMax,
          Double_t ptTriggerMin, Double_t ptTriggerMax,
          Double_t ptAssociatedMin, Double_t ptAssociatedMax,
-         Bool_t normToTrig, Int_t rebinEta, Int_t rebinPhi,TString eventClass) {
+         Bool_t normToTrig,                            
+         Bool_t kUseVzBinning,
+         Int_t rebinEta, Int_t rebinPhi,TString eventClass) {
   //Draws the correlation functions for every centrality bin
   //(+-), (-+), (++), (--)  
   AliTHn *hP = NULL;
@@ -297,6 +304,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
   b->SetHistNnp(hNP);
   b->SetHistNpp(hPP);
   b->SetHistNnn(hNN);
+  if(kUseVzBinning) b->SetVertexZBinning(kTRUE);
 
   //balance function shuffling
   AliTHn *hPShuffled = NULL;
@@ -342,6 +350,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     bShuffled->SetHistNnp(hNPShuffled);
     bShuffled->SetHistNpp(hPPShuffled);
     bShuffled->SetHistNnn(hNNShuffled);
+    if(kUseVzBinning) bShuffled->SetVertexZBinning(kTRUE);
   }
 
   //balance function mixing
@@ -388,6 +397,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     bMixed->SetHistNnp(hNPMixed);
     bMixed->SetHistNpp(hPPMixed);
     bMixed->SetHistNnn(hNNMixed);
+    if(kUseVzBinning) bMixed->SetVertexZBinning(kTRUE);
   }
 
 
@@ -463,8 +473,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     else 
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
   }
-
-  gHistPN[0] = b->GetCorrelationFunctionPN(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+  gHistPN[0] = b->GetCorrelationFunctionPN(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   if(rebinEta > 1 || rebinPhi > 1){
     gHistPN[0]->Rebin2D(rebinEta,rebinPhi);
     gHistPN[0]->Scale(1./(Double_t)(rebinEta*rebinPhi));
@@ -498,7 +507,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     else 
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
-    gHistPN[1] = bShuffled->GetCorrelationFunctionPN(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistPN[1] = bShuffled->GetCorrelationFunctionPN(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistPN[1]->Rebin2D(rebinEta,rebinPhi);
       gHistPN[1]->Scale(1./(Double_t)(rebinEta*rebinPhi));
@@ -535,7 +544,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
     // if normalization to trigger then do not divide Event mixing by number of trigger particles
-    gHistPN[2] = bMixed->GetCorrelationFunctionPN(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistPN[2] = bMixed->GetCorrelationFunctionPN(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistPN[2]->Rebin2D(rebinEta,rebinPhi);
       gHistPN[2]->Scale(1./(Double_t)(rebinEta*rebinPhi));
@@ -686,7 +695,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
   }
 
-  gHistNP[0] = b->GetCorrelationFunctionNP(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+  gHistNP[0] = b->GetCorrelationFunctionNP(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   if(rebinEta > 1 || rebinPhi > 1){
     gHistNP[0]->Rebin2D(rebinEta,rebinPhi);
     gHistNP[0]->Scale(1./(Double_t)(rebinEta*rebinPhi));
@@ -721,7 +730,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     else 
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
-    gHistNP[1] = bShuffled->GetCorrelationFunctionNP(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistNP[1] = bShuffled->GetCorrelationFunctionNP(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistNP[1]->Rebin2D(rebinEta,rebinPhi);
       gHistNP[1]->Scale(1./(Double_t)(rebinEta*rebinPhi));
@@ -758,7 +767,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
 
     // if normalization to trigger then do not divide Event mixing by number of trigger particles
-    gHistNP[2] = bMixed->GetCorrelationFunctionNP(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistNP[2] = bMixed->GetCorrelationFunctionNP(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistNP[2]->Rebin2D(rebinEta,rebinPhi);
       gHistNP[2]->Scale(1./(Double_t)(rebinEta*rebinPhi));
@@ -909,7 +918,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
   }
 
-  gHistPP[0] = b->GetCorrelationFunctionPP(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+  gHistPP[0] = b->GetCorrelationFunctionPP(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   if(rebinEta > 1 || rebinPhi > 1){
     gHistPP[0]->Rebin2D(rebinEta,rebinPhi);
     gHistPP[0]->Scale(1./(Double_t)(rebinEta*rebinPhi));  
@@ -944,7 +953,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     else 
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
-    gHistPP[1] = bShuffled->GetCorrelationFunctionPP(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistPP[1] = bShuffled->GetCorrelationFunctionPP(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistPP[1]->Rebin2D(rebinEta,rebinPhi);
       gHistPP[1]->Scale(1./(Double_t)(rebinEta*rebinPhi));  
@@ -981,7 +990,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
     // if normalization to trigger then do not divide Event mixing by number of trigger particles
-    gHistPP[2] = bMixed->GetCorrelationFunctionPP(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistPP[2] = bMixed->GetCorrelationFunctionPP(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistPP[2]->Rebin2D(rebinEta,rebinPhi);
       gHistPP[2]->Scale(1./(Double_t)(rebinEta*rebinPhi));  
@@ -1130,7 +1139,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
   } 
 
-  gHistNN[0] = b->GetCorrelationFunctionNN(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+  gHistNN[0] = b->GetCorrelationFunctionNN(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
   if(rebinEta > 1 || rebinPhi > 1){
     gHistNN[0]->Rebin2D(rebinEta,rebinPhi);
     gHistNN[0]->Scale(1./(Double_t)(rebinEta*rebinPhi));  
@@ -1165,7 +1174,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
     else 
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
-    gHistNN[1] = bShuffled->GetCorrelationFunctionNN(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistNN[1] = bShuffled->GetCorrelationFunctionNN(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistNN[1]->Rebin2D(rebinEta,rebinPhi);
       gHistNN[1]->Scale(1./(Double_t)(rebinEta*rebinPhi));  
@@ -1202,7 +1211,7 @@ void draw(TList *list, TList *listBFShuffled, TList *listBFMixed, TList *listQA,
       histoTitle += " (0^{o} < #varphi^{t} - #Psi_{2} < 180^{o})"; 
     
     // if normalization to trigger then do not divide Event mixing by number of trigger particles
-    gHistNN[2] = bMixed->GetCorrelationFunctionNN(psiMin,psiMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
+    gHistNN[2] = bMixed->GetCorrelationFunctionNN(psiMin,psiMax,vertexZMin,vertexZMax,ptTriggerMin,ptTriggerMax,ptAssociatedMin,ptAssociatedMax);
     if(rebinEta > 1 || rebinPhi > 1){
       gHistNN[2]->Rebin2D(rebinEta,rebinPhi);
       gHistNN[2]->Scale(1./(Double_t)(rebinEta*rebinPhi));  
@@ -1421,6 +1430,8 @@ void drawCorrelationFunctions(const char* lhcPeriod = "LHC10h",
                              const char* gEventPlaneEstimator = "VZERO",
                              Int_t gCentrality = 1,
                              Double_t psiMin = -0.5, Double_t psiMax = 3.5,
+                             Double_t vertexZMin = -10.,
+                             Double_t vertexZMax = 10.,
                              Double_t ptTriggerMin = -1.,
                              Double_t ptTriggerMax = -1.,
                              Double_t ptAssociatedMin = -1.,
@@ -1539,7 +1550,7 @@ void drawCorrelationFunctions(const char* lhcPeriod = "LHC10h",
   pngName += ".PositiveNegative.png";
   cPN->SaveAs(pngName.Data());
   if(kFit)
-    fitCorrelationFunctions(gCentrality, psiMin, psiMax,
+    fitCorrelationFunctions(gCentrality, psiMin, psiMax,vertexZMin, vertexZMax,
                            ptTriggerMin,ptTriggerMax,
                            ptAssociatedMin, ptAssociatedMax,gHistPN);
 
@@ -1584,7 +1595,7 @@ void drawCorrelationFunctions(const char* lhcPeriod = "LHC10h",
   cNP->SaveAs(pngName.Data());
 
   if(kFit)
-    fitCorrelationFunctions(gCentrality, psiMin, psiMax,
+    fitCorrelationFunctions(gCentrality, psiMin, psiMax,vertexZMin, vertexZMax,
                            ptTriggerMin,ptTriggerMax,
                            ptAssociatedMin, ptAssociatedMax,gHistNP);
 
@@ -1629,7 +1640,7 @@ void drawCorrelationFunctions(const char* lhcPeriod = "LHC10h",
   cPP->SaveAs(pngName.Data());
 
   if(kFit)
-    fitCorrelationFunctions(gCentrality, psiMin, psiMax,
+    fitCorrelationFunctions(gCentrality, psiMin, psiMax,vertexZMin, vertexZMax,
                            ptTriggerMin,ptTriggerMax,
                            ptAssociatedMin, ptAssociatedMax,gHistPP);
 
@@ -1674,7 +1685,7 @@ void drawCorrelationFunctions(const char* lhcPeriod = "LHC10h",
   cNN->SaveAs(pngName.Data());
 
   if(kFit)
-    fitCorrelationFunctions(gCentrality, psiMin, psiMax,
+    fitCorrelationFunctions(gCentrality, psiMin, psiMax,vertexZMin, vertexZMax,
                            ptTriggerMin,ptTriggerMax,
                            ptAssociatedMin, ptAssociatedMax,gHistNN);
 }
@@ -1690,6 +1701,8 @@ void drawProjections(const char* lhcPeriod = "LHC10h",
                     Int_t gCentrality = 1,
                     Double_t psiMin = -0.5, 
                     Double_t psiMax = 3.5,
+                    Double_t vertexZMin = -10., 
+                    Double_t vertexZMax = 10.,
                     Double_t ptTriggerMin = -1.,
                     Double_t ptTriggerMax = -1.,
                     Double_t ptAssociatedMin = -1.,
@@ -2223,6 +2236,7 @@ void drawProjections(const char* lhcPeriod = "LHC10h",
 //____________________________________________________________//
 void fitCorrelationFunctions(Int_t gCentrality = 1,
                             Double_t psiMin = -0.5, Double_t psiMax = 3.5,
+                            Double_t vertexZMin = -10.,Double_t vertexZMax = 10.,
                             Double_t ptTriggerMin = -1.,
                             Double_t ptTriggerMax = -1.,
                             Double_t ptAssociatedMin = -1.,