add mixed event bin calculation for different centrality, vertex z, and event plane...

diff --git a/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.cxx b/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.cxx
index b33345cdfbd8b3d6a98d8c24462f8931e135c8f8..a59129c098f026d108db0d5c32dad5c9fa4ab3ef 100755 (executable)
--- a/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.cxx
+++ b/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.cxx
@@ -51,7 +51,9 @@ fCheckCaloPID(0),             fRecalculateCaloPID(0),
 fMinPt(0),                    fMaxPt(0),                   fPairTimeCut(200), 
 fMultiBin(0),                 fNZvertBin(0),
 fNrpBin(0),                   fNCentrBin(0),
-fNmaxMixEv(0),                fMaxMulti(0),                fMinMulti(0),
+fNmaxMixEv(0),                fDoOwnMix(0),                   
+fUseTrackMultBins(0),
+fMaxMulti(0),                 fMinMulti(0),
 fUseSelectEvent(kFALSE),      fMakePlots(kFALSE),
 fInputAODBranch(0x0),         fInputAODName(""),
 fOutputAODBranch(0x0),        fNewAOD(kFALSE),
@@ -402,6 +404,144 @@ AliGenEventHeader *  AliAnaCaloTrackCorrBaseClass::GetMCGenEventHeader() const
   
 }
 
+
+//___________________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventCentralityBin()
+{
+  // Define the centrality bin for mixing
+  // In pp collisions analysis hardcoded track multiplicities
+  
+  Int_t curCentrBin = 0;
+  
+  if(fUseTrackMultBins) // pp collisions
+  { // Track multiplicity bins
+    //curCentrBin = (GetTrackMultiplicity()-1)/5; 
+    //if(curCentrBin > GetNCentrBin()-1) curCentrBin=GetNCentrBin()-1;
+    Int_t trackMult = GetReader()->GetTrackMultiplicity();
+    if(trackMult<=5)
+      curCentrBin=8;
+    else if(trackMult<=10)
+      curCentrBin=7;
+    else if(trackMult<=15)
+      curCentrBin=6;
+    else if(trackMult<=20)
+      curCentrBin=5;
+    else if(trackMult<=30)
+      curCentrBin=4;
+    else if(trackMult<=40)
+      curCentrBin=3;
+    else if(trackMult<=55)
+      curCentrBin=2;
+    else if(trackMult<=70)
+      curCentrBin=1 ;
+    else curCentrBin=0 ;        
+  }
+  else // Set centrality based on centrality task, PbPb collisions
+  {
+    Float_t minCent = GetReader()->GetCentralityBin(0);
+    Float_t maxCent = GetReader()->GetCentralityBin(1);
+    
+    if((minCent< 0 && maxCent< 0) || minCent>=maxCent)
+    {
+      curCentrBin = GetEventCentrality() * GetNCentrBin() / GetReader()->GetCentralityOpt(); 
+    }
+    else
+    {
+      curCentrBin = (Int_t)(GetEventCentrality()-minCent) * GetNCentrBin() / (maxCent-minCent); 
+      if(curCentrBin==GetNCentrBin()) curCentrBin = GetNCentrBin()-1;
+    }  
+    
+    if(GetDebug() > 0 )
+      printf("AliAnaCaloTrackCorrBaseClass::GetEventCentralityBin() - %d, centrality %d, n bins %d, max bin from centrality %d\n",
+             curCentrBin, GetEventCentrality(), GetNCentrBin(), GetReader()->GetCentralityOpt());        
+  }  
+  
+  return curCentrBin;
+  
+}
+
+//_________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventRPBin()
+{
+  //Reaction plane bin
+  
+  Int_t curRPBin  = 0 ;
+  
+  if(GetNRPBin() > 1 && GetEventPlane())
+  {
+    Float_t epAngle = GetEventPlaneAngle();//->GetEventplane(GetEventPlaneMethod(),fReader->GetInputEvent());
+    
+    if(epAngle < 0 || epAngle >TMath::Pi())
+    { 
+      printf("AliAnaCaloTrackCorrBaseClass::GetEventRPBin() - Wrong event plane angle : %f \n",epAngle);
+      return -1;
+    }
+    
+    curRPBin = TMath::Nint(epAngle*(GetNRPBin()-1)/TMath::Pi());
+    if(curRPBin >= GetNRPBin()) printf("RP Bin %d out of range %d\n",curRPBin,GetNRPBin());
+    
+    if(GetDebug() > 0 )
+      printf("AliAnaCaloTrackCorrBaseClass::GetEventRPBin() - %d, bin float %f, angle %f, n bins %d\n", 
+             curRPBin,epAngle*(GetNRPBin()-1)/TMath::Pi(),epAngle,GetNRPBin());
+  }  
+  
+  return curRPBin ;
+  
+}
+
+//_________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventVzBin()
+{
+  // Return Vz bin, divide vertex in GetNZvertBin() bins, 
+  // depending on the vertex cut
+  
+  Double_t v[3] = {0,0,0}; //vertex 
+  GetReader()->GetVertex(v);
+  
+  Int_t curZvertBin = (Int_t)(0.5*GetNZvertBin()*(v[2]+GetZvertexCut())/GetZvertexCut());
+  
+  if(GetDebug() > 0 )
+    printf("AliAnaCaloTrackCorrBaseClass::GetEventVzBin() - %d, vz %2.2f, n bins %d \n",
+           curZvertBin, v[2], GetNZvertBin()); 
+  
+  return curZvertBin;
+}
+
+//____________________________________________________________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin(const Int_t iCen, const Int_t iVz, const Int_t iRP)
+{
+  // Event mixing bin, combination of vz, centrality and reaction plane bins
+  
+  if(iCen<0 || iVz < 0 || iRP < 0)
+    return -1;
+  else
+    return iCen*GetNZvertBin()*GetNRPBin()+iVz*GetNRPBin()+iRP;
+}
+
+//__________________________________________________
+Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin()
+{
+  // Event mixing bin, combination of vz, centrality and reaction plane bins
+  
+  //Get vertex z bin
+  Int_t iVz =  GetEventVzBin();
+  
+  // centrality (PbPb) or tracks multiplicity (pp) bin
+  Int_t iCen = GetEventCentralityBin();
+  
+  // reaction plane bin (PbPb)
+  Int_t iRP = GetEventRPBin();  
+  
+  Int_t eventBin = GetEventMixBin(iCen, iVz, iRP);
+  
+  if(GetDebug() > 0)
+    printf("AliAnaCaloTrackCorrBaseClass::GetEventMixBin() - Bins : cent %d, vz %d, RP %d, event %d/%d\n",
+           iCen,iVz, iRP, eventBin, GetNZvertBin()*GetNRPBin()*GetNCentrBin());
+  
+  return eventBin;
+  
+}
+
 //_________________________________________________
 void AliAnaCaloTrackCorrBaseClass::InitParameters()
 { 

diff --git a/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h b/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h
index 2368790a960c3691f817edc310904366a8a85d96..d38a911e3e418175aff47dccd48ca1e02adb1b2c 100755 (executable)
--- a/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h
+++ b/PWG/CaloTrackCorrBase/AliAnaCaloTrackCorrBaseClass.h
@@ -81,6 +81,7 @@ public:
        
   //Event plane
   virtual AliEventplane* GetEventPlane()                   const { return fReader->GetEventPlane()       ; }           
+  virtual Double_t       GetEventPlaneAngle()              const { return fReader->GetEventPlaneAngle()  ; }           
   virtual TString        GetEventPlaneMethod()             const { return fReader->GetEventPlaneMethod() ; }
   
   //AOD branch
@@ -169,6 +170,12 @@ public:
   virtual Float_t        GetZvertexCut()                   const { return GetReader()->GetZvertexCut();} //cut on vertex position  
   virtual Int_t          GetMaxMulti()                     const { return fMaxMulti  ; }  
   virtual Int_t          GetMinMulti()                     const { return fMinMulti  ; }  
+    
+  virtual Int_t          GetEventCentralityBin();
+  virtual Int_t          GetEventRPBin();
+  virtual Int_t          GetEventVzBin();
+  virtual Int_t          GetEventMixBin();
+  virtual Int_t          GetEventMixBin(const Int_t iCen, const Int_t iVz, const Int_t iRP);
   
   virtual void           SetMultiBin(Int_t n=1)                  { fMultiBin  = n ;} //number of bins in Multiplicity  
   virtual void           SetNZvertBin(Int_t n=1)                 { fNZvertBin = n ;} //number of bins for vertex position
@@ -177,6 +184,15 @@ public:
   virtual void           SetNMaxEvMix(Int_t n=20)                { fNmaxMixEv = n ;} //maximal number of events for mixing
   virtual void           SetMultiplicity(Int_t multimin, Int_t multimax) {fMinMulti = multimin ; fMaxMulti = multimax ; }
   
+  virtual void           SwitchOnTrackMultBins()                 { fUseTrackMultBins = kTRUE  ; }
+  virtual void           SwitchOffTrackMultBins()                { fUseTrackMultBins = kFALSE ; }
+  
+  virtual void           SwitchOnOwnMix()                        { fDoOwnMix         = kTRUE  ; }
+  virtual void           SwitchOffOwnMix()                       { fDoOwnMix         = kFALSE ; }
+  
+  virtual Bool_t         DoOwnMix()                              { return fDoOwnMix           ; }
+  virtual Bool_t         UseTrackMultBins()                      { return fUseTrackMultBins   ; }
+
   //Mixed event  
   virtual Int_t           CheckMixedEventVertex(const Int_t caloLabel, const Int_t trackLabel) ;
   virtual AliMixedEvent * GetMixedEvent()                        { return GetReader()->GetMixedEvent()  ; } 
@@ -275,6 +291,8 @@ private:
   Int_t                      fNrpBin ;            // Number of bins in event container for reaction plain
   Int_t                      fNCentrBin ;               // Number of bins in event container for centrality
   Int_t                      fNmaxMixEv ;               // Maximal number of events stored in buffer for mixing
+  Bool_t                     fDoOwnMix;            // Do combinatorial background not the one provided by the frame
+  Bool_t                     fUseTrackMultBins;    // Use track multiplicity and not centrality bins in mixing
   Int_t                      fMaxMulti ;           // Maximum multiplicity of particles in the analysis
   Int_t                      fMinMulti ;           // Maximum multiplicity of particles in the analysis
   Bool_t                     fUseSelectEvent ;     // Select events based on multiplicity and vertex cuts
@@ -302,7 +320,7 @@ private:
   AliAnaCaloTrackCorrBaseClass(              const AliAnaCaloTrackCorrBaseClass & bc) ; // cpy ctor
   AliAnaCaloTrackCorrBaseClass & operator = (const AliAnaCaloTrackCorrBaseClass & bc) ; // cpy assignment
   
-  ClassDef(AliAnaCaloTrackCorrBaseClass,20)
+  ClassDef(AliAnaCaloTrackCorrBaseClass,21)
 } ;