I have to recenter the TPC event plane (for LHC11h) and therefore did some modificati...

recentering method can be switched on/off by the user and ideally would make the TPC event plane flat(ter). This requires one more argument
to the AddTaskEventplane.C macro with default: no use of recentering to keep ongoing analysis untouched.
Julian Book

diff --git a/ANALYSIS/AliEPSelectionTask.cxx b/ANALYSIS/AliEPSelectionTask.cxx
index 7d0d235c61d48c8aa98adea8557926064ab37dbd..601035b61be0cf64ddf3a4d00f37c5ee795093ba 100644 (file)
--- a/ANALYSIS/AliEPSelectionTask.cxx
+++ b/ANALYSIS/AliEPSelectionTask.cxx
@@ -72,9 +72,11 @@ AliAnalysisTaskSE(),
   fAnalysisInput("ESD"),
   fTrackType("TPC"),
   fPeriod(""),
+  fCentrality(-1.),
   fUseMCRP(kFALSE),
   fUsePhiWeight(kFALSE),
   fUsePtWeight(kFALSE),
+  fUseRecentering(kFALSE),
   fSaveTrackContribution(kFALSE),
   fUserphidist(kFALSE),
   fUsercuts(kFALSE),
@@ -84,6 +86,8 @@ AliAnalysisTaskSE(),
   fSplitMethod(0),
   fESDtrackCuts(0),
   fEPContainer(0),
+  fQxContainer(0),
+  fQyContainer(0),
   fSparseDist(0),
   fHruns(0),
   fQVector(0),
@@ -108,7 +112,10 @@ AliAnalysisTaskSE(),
   for(Int_t i = 0; i < 4; ++i) {
      fPhiDist[i] = 0;
   }
-}   
+  for(Int_t i = 0; i < 2; ++i) {
+     fQDist[i] = 0;
+  }
+}
 
 //________________________________________________________________________
 AliEPSelectionTask::AliEPSelectionTask(const char *name):
@@ -116,9 +123,11 @@ AliEPSelectionTask::AliEPSelectionTask(const char *name):
   fAnalysisInput("ESD"),
   fTrackType("TPC"),
   fPeriod(""),
+  fCentrality(-1.),
   fUseMCRP(kFALSE),
   fUsePhiWeight(kFALSE),
   fUsePtWeight(kFALSE),  
+  fUseRecentering(kFALSE),
   fSaveTrackContribution(kFALSE),
   fUserphidist(kFALSE),
   fUsercuts(kFALSE),
@@ -128,6 +137,8 @@ AliEPSelectionTask::AliEPSelectionTask(const char *name):
   fSplitMethod(0),
   fESDtrackCuts(0),
   fEPContainer(0),
+  fQxContainer(0),
+  fQyContainer(0),
   fSparseDist(0),
   fHruns(0),
   fQVector(0),
@@ -153,6 +164,9 @@ AliEPSelectionTask::AliEPSelectionTask(const char *name):
   for(Int_t i = 0; i < 4; i++) {
      fPhiDist[i] = 0;
   }
+  for(Int_t i = 0; i < 2; ++i) {
+     fQDist[i] = 0;
+  }
 }
  
 //________________________________________________________________________
@@ -186,6 +200,14 @@ AliEPSelectionTask::~AliEPSelectionTask()
       }
       if(fHruns) delete fHruns;
   }
+  if(fQDist[0] && fQDist[1]) {
+    for(Int_t i = 0; i < 2; i++) {
+      if(fQDist[i]){
+       delete fQDist[i];
+       fQDist[i] = 0;
+      }
+    }
+  }
 }  
 
 //________________________________________________________________________
@@ -243,6 +265,7 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
           AliInfo(Form("Changing Phi-distribution to run %d",fRunNumber));
           SetOADBandPeriod();
          SetPhiDist();      
+         SetQvectorDist(); // recentring objects
       }
       
       
@@ -271,8 +294,11 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
       const int nt = tracklist->GetEntries();
       
       if (nt>4){
+
+       // qvector full event
        fQVector = new TVector2(GetQ(esdEP,tracklist));
        fEventplaneQ = fQVector->Phi()/2; 
+       // q vector subevents
        GetQsub(qq1, qq2, tracklist, esdEP);
        fQsub1 = new TVector2(qq1);
        fQsub2 = new TVector2(qq2);
@@ -319,11 +345,19 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
     AliAODEvent* aod = dynamic_cast<AliAODEvent*>(event);
 
     if (aod){
+
+      // get centrality of the event
+      AliAODHeader *header=aod->GetHeader();
+      AliCentrality *centrality=header->GetCentralityP();
+      if(!centrality)  AliError(Form("No AliCentrality attached to AOD header"));
+      fCentrality = centrality->GetCentralityPercentile("V0M");
+
       if (!(fRunNumber == aod->GetRunNumber())) {
         fRunNumber = aod->GetRunNumber();
         AliInfo(Form("Changing Phi-distribution to run %d",fRunNumber));
         SetOADBandPeriod();
-        SetPhiDist();      
+        SetPhiDist();
+        SetQvectorDist();
       }
 
       if (fUseMCRP) {
@@ -350,13 +384,16 @@ void AliEPSelectionTask::UserExec(Option_t */*option*/)
       const int NT = tracklist->GetEntries();
       
       if (NT>4){
+
+       // qvector full event
        fQVector = new TVector2(GetQ(esdEP,tracklist));
-       fEventplaneQ = fQVector->Phi()/2.; 
+       fEventplaneQ = fQVector->Phi()/2; 
+       // q vector subevents
        GetQsub(qq1, qq2, tracklist, esdEP);
        fQsub1 = new TVector2(qq1);
        fQsub2 = new TVector2(qq2);
-       fQsubRes = (fQsub1->Phi()/2. - fQsub2->Phi()/2.);
-       
+       fQsubRes = (fQsub1->Phi()/2 - fQsub2->Phi()/2);
+
        esdEP->SetQVector(fQVector);
        esdEP->SetEventplaneQ(fEventplaneQ);
        esdEP->SetQsub(fQsub1,fQsub2);
@@ -411,13 +448,17 @@ void AliEPSelectionTask::Terminate(Option_t */*option*/)
 //__________________________________________________________________________
 TVector2 AliEPSelectionTask::GetQ(AliEventplane* EP, TObjArray* tracklist)
 {
-// Get the Q vector
+  // Get the Q vector
   TVector2 mQ;
   float mQx=0, mQy=0;
   AliVTrack* track;
   Double_t weight;
   Int_t idtemp = -1;
-  
+  // get recentering values
+  Double_t mean[2], rms[2];
+  Recenter(0, mean);
+  Recenter(1, rms);
+
   int nt = tracklist->GetEntries();
 
   for (int i=0; i<nt; i++){
@@ -428,24 +469,28 @@ TVector2 AliEPSelectionTask::GetQ(AliEventplane* EP, TObjArray* tracklist)
     if (fSaveTrackContribution){
       idtemp = track->GetID(); 
       if ((fAnalysisInput.CompareTo("AOD")==0) && (fAODfilterbit == 128)) idtemp = idtemp*(-1) - 1;
-      EP->GetQContributionXArray()->AddAt(weight*cos(2*track->Phi()),idtemp);
-      EP->GetQContributionYArray()->AddAt(weight*sin(2*track->Phi()),idtemp);
+      EP->GetQContributionXArray()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+      EP->GetQContributionYArray()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
      }
-     mQx += (weight*cos(2*track->Phi()));
-     mQy += (weight*sin(2*track->Phi()));
+     mQx += (weight*cos(2*track->Phi())/rms[0]);
+     mQy += (weight*sin(2*track->Phi())/rms[1]);
     }
   }
-  mQ.Set(mQx,mQy);
+  mQ.Set(mQx-(mean[0]/rms[0]), mQy-(mean[1]/rms[1]));
   return mQ;
 }
   
   //________________________________________________________________________
 void AliEPSelectionTask::GetQsub(TVector2 &Q1, TVector2 &Q2, TObjArray* tracklist,AliEventplane* EP)
 {
-// Get Qsub
+  // Get Qsub
   TVector2 mQ[2];
   float mQx1=0, mQy1=0, mQx2=0, mQy2=0;
   Double_t weight;
+  // get recentering values
+  Double_t mean[2], rms[2];
+  Recenter(0, mean);
+  Recenter(1, rms);
 
   AliVTrack* track;
   TRandom2 rn = 0;
@@ -468,39 +513,39 @@ void AliEPSelectionTask::GetQsub(TVector2 &Q1, TVector2 &Q2, TObjArray* tracklis
       if( trackcounter1 < int(nt/2.) && trackcounter2 < int(nt/2.)){
         float random = rn.Rndm();
         if(random < .5){
-          mQx1 += (weight*cos(2*track->Phi()));
-          mQy1 += (weight*sin(2*track->Phi()));
+          mQx1 += (weight*cos(2*track->Phi())/rms[0]);
+          mQy1 += (weight*sin(2*track->Phi())/rms[1]);
           if (fSaveTrackContribution){
-            EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi()),idtemp);
-            EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi()),idtemp);
+            EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+            EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
           }
           trackcounter1++;
         }
         else {
-          mQx2 += (weight*cos(2*track->Phi()));
-          mQy2 += (weight*sin(2*track->Phi()));
+          mQx2 += (weight*cos(2*track->Phi())/rms[0]);
+          mQy2 += (weight*sin(2*track->Phi())/rms[1]);
           if (fSaveTrackContribution){
-            EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi()),idtemp);
-            EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi()),idtemp);
+            EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+            EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
           }
           trackcounter2++;
         }
       }
       else if( trackcounter1 >= int(nt/2.)){
-        mQx2 += (weight*cos(2*track->Phi()));
-        mQy2 += (weight*sin(2*track->Phi()));
+        mQx2 += (weight*cos(2*track->Phi())/rms[0]);
+        mQy2 += (weight*sin(2*track->Phi())/rms[1]);
         if (fSaveTrackContribution){
-          EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi()),idtemp);
-          EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi()),idtemp);
+          EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+          EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
         }
         trackcounter2++;
       }
       else {
-        mQx1 += (weight*cos(2*track->Phi()));
-        mQy1 += (weight*sin(2*track->Phi()));
+        mQx1 += (weight*cos(2*track->Phi())/rms[0]);
+        mQy1 += (weight*sin(2*track->Phi())/rms[1]);
         if (fSaveTrackContribution){
-          EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi()),idtemp);
-          EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi()),idtemp);
+          EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+          EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
         }
         trackcounter1++;
       }
@@ -517,18 +562,18 @@ void AliEPSelectionTask::GetQsub(TVector2 &Q1, TVector2 &Q2, TObjArray* tracklis
       if ((fAnalysisInput.CompareTo("AOD")==0) && (fAODfilterbit == 128)) idtemp = idtemp*(-1) - 1;
 
       if (eta > fEtaGap/2.) {  
-        mQx1 += (weight*cos(2*track->Phi()));
-        mQy1 += (weight*sin(2*track->Phi()));
+        mQx1 += (weight*cos(2*track->Phi())/rms[0]);
+        mQy1 += (weight*sin(2*track->Phi())/rms[1]);
         if (fSaveTrackContribution){
-          EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi()),idtemp);
-          EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi()),idtemp);
+          EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+          EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
         }
       } else if (eta < -1.*fEtaGap/2.) {
-        mQx2 += (weight*cos(2*track->Phi()));
-        mQy2 += (weight*sin(2*track->Phi()));
+        mQx2 += (weight*cos(2*track->Phi())/rms[0]);
+        mQy2 += (weight*sin(2*track->Phi())/rms[1]);
         if (fSaveTrackContribution){
-          EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi()),idtemp);
-          EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi()),idtemp);
+          EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+          EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
         }
       }
     }
@@ -544,18 +589,18 @@ void AliEPSelectionTask::GetQsub(TVector2 &Q1, TVector2 &Q2, TObjArray* tracklis
       if ((fAnalysisInput.CompareTo("AOD")==0) && (fAODfilterbit == 128)) idtemp = idtemp*(-1) - 1;
 
       if (cha > 0) {  
-        mQx1 += (weight*cos(2*track->Phi()));
-        mQy1 += (weight*sin(2*track->Phi()));
+        mQx1 += (weight*cos(2*track->Phi())/rms[0]);
+        mQy1 += (weight*sin(2*track->Phi())/rms[1]);
         if (fSaveTrackContribution){
-          EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi()),idtemp);
-          EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi()),idtemp);
+          EP->GetQContributionXArraysub1()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+          EP->GetQContributionYArraysub1()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
         }
       } else if (cha < 0) {
-        mQx2 += (weight*cos(2*track->Phi()));
-        mQy2 += (weight*sin(2*track->Phi()));
+        mQx2 += (weight*cos(2*track->Phi())/rms[0]);
+        mQy2 += (weight*sin(2*track->Phi())/rms[1]);
         if (fSaveTrackContribution){
-          EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi()),idtemp);
-          EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi()),idtemp);
+          EP->GetQContributionXArraysub2()->AddAt(weight*cos(2*track->Phi())/rms[0],idtemp);
+          EP->GetQContributionYArraysub2()->AddAt(weight*sin(2*track->Phi())/rms[1],idtemp);
         }
       }
     }
@@ -563,9 +608,9 @@ void AliEPSelectionTask::GetQsub(TVector2 &Q1, TVector2 &Q2, TObjArray* tracklis
     printf("plane resolution determination method not available!\n\n ");
     return;
   }
-     
-  mQ[0].Set(mQx1,mQy1);
-  mQ[1].Set(mQx2,mQy2);
+  // apply recenetering
+  mQ[0].Set(mQx1-(mean[0]/rms[0]), mQy1-(mean[1]/rms[1]));
+  mQ[1].Set(mQx2-(mean[0]/rms[0]), mQy2-(mean[1]/rms[1]));
   Q1 = mQ[0];
   Q2 = mQ[1];
 }
@@ -663,6 +708,32 @@ Double_t AliEPSelectionTask::GetPhiWeight(TObject* track1)
   return phiweight;
 }
 
+//________________________________________________________________________
+void AliEPSelectionTask::Recenter(Int_t var, Double_t * values)
+{
+  
+  if (fUseRecentering && fQDist[0] && fQDist[1] && fCentrality!=-1.) {
+    Int_t centbin = fQDist[0]->FindBin(fCentrality);
+
+    if(var==0) { // fill mean
+      values[0] = fQDist[0]->GetBinContent(centbin);
+      values[1] = fQDist[1]->GetBinContent(centbin);
+    }
+    else if(var==1) { // fill rms
+      values[0] = fQDist[0]->GetBinError(centbin);
+      values[1] = fQDist[1]->GetBinError(centbin);
+      // protection against division by zero
+      if(values[0]==0.0) values[0]=1.0;
+      if(values[1]==0.0) values[1]=1.0;
+    }
+  }
+  else { //default (no recentering)
+    values[0] = var;
+    values[1] = var;
+  }
+  return;
+}
+
 //__________________________________________________________________________
 void AliEPSelectionTask::SetPhiDist() 
 {
@@ -741,6 +812,44 @@ void AliEPSelectionTask::SetPhiDist()
   }
 }
 
+//__________________________________________________________________________
+void AliEPSelectionTask::SetQvectorDist() 
+{
+  if(!fUseRecentering) return;
+  AliInfo(Form("Setting q vector distributions"));
+  fQDist[0] = (TProfile*) fQxContainer->GetObject(fRunNumber, "Default");
+  fQDist[1] = (TProfile*) fQyContainer->GetObject(fRunNumber, "Default");
+
+  if (!fQDist[0] || !fQDist[1]) {
+    AliError(Form("Cannot find OADB q-vector distributions for run %d. Using default values (mean=0,rms=1).", fRunNumber));
+    return;
+  }
+
+  Bool_t emptybins;
+
+  int iter = 0;  
+  while (iter<3){
+    emptybins = kFALSE;
+    
+    for (int i=1; i<=fQDist[0]->GetNbinsX()-2; i++){
+      if (!((fQDist[0]->GetBinEntries(i))>0)) {
+       emptybins = kTRUE;
+      }
+    }
+    if (emptybins) {
+      cout << "empty bins - rebinning!" << endl;
+      fQDist[0]->Rebin();
+      fQDist[1]->Rebin();
+      iter++;
+    }
+    else iter = 3;
+  }
+  
+  if (emptybins) {
+    AliError("After Maximum of rebinning still empty Qxy-bins!!!");
+  }
+}
+
 //__________________________________________________________________________
 void AliEPSelectionTask::SetPersonalPhiDistribution(const char* infilename, char* listname)
 {
@@ -755,7 +864,6 @@ void AliEPSelectionTask::SetPersonalPhiDistribution(const char* infilename, char
   f.Close();
 } 
 
-
 //_________________________________________________________________________
 TObjArray* AliEPSelectionTask::GetAODTracksAndMaxID(AliAODEvent* aod, Int_t& maxid)
 {
@@ -832,7 +940,20 @@ void AliEPSelectionTask::SetOADBandPeriod()
            fHruns = (TH1F*)fSparseDist->Projection(0); //projection on run axis;
            fHruns->SetName("runsHisto");
       }
-      }        
+      }
+
+      if(fUseRecentering) {
+       oadbfilename = (Form("%s/COMMON/EVENTPLANE/data/eprecentering.root", AliAnalysisManager::GetOADBPath()));
+       TFile *foadb = TFile::Open(oadbfilename);
+       if(!foadb->IsOpen()) AliFatal(Form("Cannot open OADB file %s", oadbfilename.Data()));
+
+       AliInfo("Using Standard OADB");
+       fQxContainer = (AliOADBContainer*) foadb->Get("eprecentering.Qx");    
+       fQyContainer = (AliOADBContainer*) foadb->Get("eprecentering.Qy");    
+       if (!fQxContainer || !fQyContainer) AliFatal("Cannot fetch OADB container for EP recentering");
+       foadb->Close();
+      }
+
      } 
 }
 

diff --git a/ANALYSIS/AliEPSelectionTask.h b/ANALYSIS/AliEPSelectionTask.h
index ba2882f32797a1431d5401d820d5f1fc0607428c..3d3b2e56da5b5b08a4ed290c09f2ecd8127d5a78 100644 (file)
--- a/ANALYSIS/AliEPSelectionTask.h
+++ b/ANALYSIS/AliEPSelectionTask.h
@@ -25,6 +25,7 @@ class AliEventplane;
 class AliOADBContainer;
 class AliVTrack;
 class THnSparse;
+class TProfile;
 
 class AliEPSelectionTask : public AliAnalysisTaskSE {
 
@@ -45,15 +46,18 @@ class AliEPSelectionTask : public AliAnalysisTaskSE {
   void GetQsub(TVector2& Qsub1, TVector2& Qsub2, TObjArray* event,AliEventplane* EP);
   Double_t GetWeight(TObject* track1);
   Double_t GetPhiWeight(TObject* track1);
+  void Recenter(Int_t var, Double_t * values);
 
   virtual void  SetDebugLevel(Int_t level)   {fDebug = level;}
   void SetInput(const char* input)           {fAnalysisInput = input;}
   void SetUseMCRP()                         {fUseMCRP = kTRUE;}
   void SetUsePhiWeight(Bool_t usephi = kTRUE){fUsePhiWeight = usephi;}
   void SetUsePtWeight()                             {fUsePtWeight = kTRUE;}
+  void SetUseRecentering()                  {fUseRecentering = kTRUE;}
   void SetSaveTrackContribution()           {fSaveTrackContribution = kTRUE;}
   void SetTrackType(TString tracktype);
   void SetPhiDist();
+  void SetQvectorDist();
   void SetPersonalESDtrackCuts(AliESDtrackCuts* trackcuts);
   void SetPersonalAODtrackCuts(UInt_t filterbit = 1, Float_t etalow = -0.8, Float_t etaup = 0.8, Float_t ptlow = 0.15, Float_t ptup = 20., Int_t ntpc = 50);
   void SetPersonalPhiDistribution(const char* filename, char* listname);
@@ -73,9 +77,11 @@ class AliEPSelectionTask : public AliAnalysisTaskSE {
   TString  fAnalysisInput;             // "ESD", "AOD"
   TString  fTrackType;                 // "GLOBAL", "TPC"
   TString  fPeriod;                    // "LHC11h","LHC10h"
+  Double_t fCentrality;                 // centrality percentile from "V0M"
   Bool_t   fUseMCRP;                   // i.e. usable for Therminator, when MC RP is provided
   Bool_t   fUsePhiWeight;              // use of phi weights
   Bool_t   fUsePtWeight;               // use of pT weights
+  Bool_t   fUseRecentering;            // use of mean & rms of q vector components for recentering
   Bool_t   fSaveTrackContribution;     // storage of contribution of each track to Q-Vector
   Bool_t   fUserphidist;               // bool, if personal phi distribution should be used
   Bool_t   fUsercuts;                  // bool, if personal cuts should be used
@@ -88,8 +94,11 @@ class AliEPSelectionTask : public AliAnalysisTaskSE {
   AliESDtrackCuts* fESDtrackCuts;       // track cuts
   
   AliOADBContainer* fEPContainer;      //! OADB Container
+  AliOADBContainer* fQxContainer;      //! OADB Container for Q_x vector
+  AliOADBContainer* fQyContainer;      //! OADB Container for Q_y vector
   TH1F*         fPhiDist[4];                   // array of Phi distributions used to calculate phi weights
   THnSparse *fSparseDist;               //! THn for eta-charge phi-weighting
+  TProfile* fQDist[2];                 // array of TProfiles with mean+rms for recentering
   TH1F *fHruns;                         // information about runwise statistics of phi-weights
 
   TVector2* fQVector;                  //! Q-Vector of the event  

diff --git a/ANALYSIS/macros/AddTaskEventplane.C b/ANALYSIS/macros/AddTaskEventplane.C
index 69b9fd5ba56dec934dca22b2808ba8865e645114..78ece6460fbf825af9f23b1028093b7727decc4b 100644 (file)
--- a/ANALYSIS/macros/AddTaskEventplane.C
+++ b/ANALYSIS/macros/AddTaskEventplane.C
@@ -1,4 +1,4 @@
-AliEPSelectionTask *AddTaskEventplane(Bool_t useEtaGap=kFALSE,Float_t etaGap=0.,Bool_t posTPCAOD=kFALSE,TString containername = "EPStat")
+AliEPSelectionTask *AddTaskEventplane(Bool_t useEtaGap=kFALSE,Float_t etaGap=0.,Bool_t posTPCAOD=kFALSE,TString containername = "EPStat",Bool_t doRecenter=kFALSE)
 {
   // Macro to connect an event plane selection task to an existing analysis manager.
 
@@ -29,6 +29,7 @@ AliEPSelectionTask *AddTaskEventplane(Bool_t useEtaGap=kFALSE,Float_t etaGap=0.,
   eventplaneTask->SetTrackType("TPC");
   eventplaneTask->SetUsePtWeight();
   eventplaneTask->SetUsePhiWeight();
+  if(doRecenter) eventplaneTask->SetUseRecentering();
   eventplaneTask->SetSaveTrackContribution();
   if(useEtaGap){
     eventplaneTask->SetSubeventsSplitMethod(AliEPSelectionTask::kEta); 

diff --git a/OADB/COMMON/EVENTPLANE/data/eprecentering.root b/OADB/COMMON/EVENTPLANE/data/eprecentering.root
new file mode 100644 (file)
index 0000000..ab7941d
Binary files /dev/null and b/OADB/COMMON/EVENTPLANE/data/eprecentering.root differ