PWGCF/FEMTOSCOPY/K0Analysis/PLamAnalysis/AliAnalysisTaskProtonLambda.h

   1 #ifndef ALIANALYSISTASKPROTONLAMBDA_H
   2 #define ALIANALYSISTASKPROTONLAMBDA_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 // Task to study femtoscopic proton-lambda correlations
   8 // Author: Hans Beck, Hans.Beck@cern.ch
   9
  10 // Includes. All classes used in the .h file need to be included.
  11 // Your task compiles with forward declaration and including in the .cxx
  12 // file, but forward declaration will fail when loading this task from
  13 // a library and just including this .h file.
  14 /* #include <TH1F.h> */
  15 /* #include <TH2F.h> */
  16 /* #include <TH3F.h> */
  17 /* #include <TList.h> */
  18 /* #include <TAxis.h> */
  19 class TH1F;
  20 class TH2F;
  21 class TH3F;
  22 #include <THnSparse.h>
  23 class TList;
  24 class TAxis;
  25
  26 #include <AliAnalysisTaskSE.h>
  27 /* #include <AliTPCPIDResponse.h> */
  28 /* #include <AliPIDResponse.h> */
  29 class AliTPCPIDResponse;
  30 class AliPIDResponse;
  31
  32 #include <AliAODEvent.h>
  33 #include <AliAODVertex.h>
  34 #include <AliAODv0.h>
  35 #include <AliAODTrack.h>
  36
  37 class AliAnalysisTaskProtonLambda : public AliAnalysisTaskSE {
  38   // Forward declaration for nested classes
  39  private:
  40   class FemtoBufferTrack;
  41   class FemtoBufferV0;
  42   class FemtoBufferEvent;
  43   class FemtoBuffer;
  44  public:
  45   AliAnalysisTaskProtonLambda();                 // Dummy constructor
  46   AliAnalysisTaskProtonLambda(const char *name); // Constructor
  47   virtual ~AliAnalysisTaskProtonLambda();                // Destructor
  48   AliAnalysisTaskProtonLambda(const AliAnalysisTaskProtonLambda& atpl); // Not implemented
  49   AliAnalysisTaskProtonLambda& operator=(const AliAnalysisTaskProtonLambda& atpl); //Not implemented
  50
  51   void   UserCreateOutputObjects();  // Called once at the beginning
  52   void   UserExec(Option_t *option); // Main loop
  53   void   Terminate(Option_t *);      // Called once at the end
  54
  55  private:
  56   void   ProcessOffline(AliAODv0 *v0, AliAODTrack *pTrack, AliAODTrack *nTrack);    //! Use offline V0 finder
  57   void   ProcessOnTheFly(AliAODv0 *v0, AliAODTrack *pTrack, AliAODTrack *nTrack);   //! Use on-the-fly V0 finder
  58   void   ProcessTOF(AliAODTrack *track);         // Use Tof for 1.0 GeV/c < p < 3.25 GeV/c
  59   void   ProcessTPC(AliAODTrack *track);         // Use TPC for p < 0.75 GeV/c
  60   void   ProcessHybrid(AliAODTrack *track);      // Preselection via TPC, identification w/ Tof 0.75 GeV/c < p < 1.0 GeV/c
  61   void   CleaningProcedure();         // Assure uniqueness of all daughters and primaries
  62   void   ProcessReal();               // TTR cut & qinv calc for real events
  63   void   ProcessMixed();              // TTR cut & qinv calc for mixed events
  64   void   ProcessRealBackground();     // Check procedure with lambda background from sideband, real events
  65   void   ProcessMixedBackground();    // Check procedure with lambda background from sideband, real events
  66
  67   Float_t Qinv(FemtoBufferV0 v01, FemtoBufferV0 v02);           // Calcs Qinv for (anti-)Lam(anti-)Lam
  68   Float_t Qinv(FemtoBufferV0 v0, FemtoBufferTrack track);       // Calcs Qinv for (anti-)Lam(anti-)Pro
  69   Float_t Qinv(FemtoBufferTrack track, FemtoBufferV0 v0);       // Calls Qinv(v0, track)
  70   Float_t QinvProPro(FemtoBufferTrack proTrack1,
  71                      FemtoBufferTrack proTrack2);               // Calcs Qinv for proton proton
  72   Float_t QinvPioPro(FemtoBufferTrack pioTrack,
  73                      FemtoBufferTrack proTrack);                // Calcs Qinv for pion proton
  74   Float_t QinvConstr(FemtoBufferV0 v0, FemtoBufferTrack track); // w/ vtx constraint for pri pro
  75   Float_t QinvConstr(FemtoBufferTrack track, FemtoBufferV0 v0); // Calls QinvConstr(v0, track)
  76   Float_t Minv(FemtoBufferV0 v01, FemtoBufferV0 v02);           // Calcs Minv for (anti-)Lam(anti-)Lam
  77   Float_t Minv(FemtoBufferV0 v0, FemtoBufferTrack track);       // Calcs Minv for (anti-)Lam(anti-)Pro
  78   Float_t Minv(FemtoBufferTrack track, FemtoBufferV0 v0);       // Calls Minv(v0, track)
  79   Float_t mt(FemtoBufferTrack track, FemtoBufferV0 v0);         // mt of pair
  80   Float_t mt(FemtoBufferV0 v0, FemtoBufferTrack track);         //    ""
  81   Float_t mt(FemtoBufferV0 v01, FemtoBufferV0 v02);             //    ""
  82   static Float_t ktSquared(FemtoBufferV0 v01, FemtoBufferV0 v02);      // kt squared
  83   static Float_t ktSquared(FemtoBufferTrack track, FemtoBufferV0 v0);  //    ""
  84   static Float_t ktSquared(FemtoBufferV0 v0, FemtoBufferTrack track);  //    ""
  85   static Float_t calcDist(const Float_t r1[3], const Float_t r2[3]);   // Calcs the distance between vector r1 and r2
  86   //  static Float_t calcDistSft(const Float_t r1[3], const Float_t r2[3],
  87   //                         const FemtoBufferEvent *evt1,
  88   //                         const FemtoBufferEvent *evt2);            // Calcs the distance between vector r1 and r2 shifting them first to originate both in (0,0,0)
  89   Bool_t  goodDCA(AliAODTrack *track);                  //! Does a cut on the DCAxy value and fills a histogram
  90   Float_t RapidityProton(AliAODTrack *track);           //! Rapidity assuming proton mass
  91   //  void    getTPConlyV0Info(const AliAODTrack *posDaughter,const AliAODTrack *negDaughter, Double_t tpcV0Mom[3], Double_t TPConlyV0MinvLam, Double_t TPConlyV0MinvALam);   //! Get V0 momentum and invariant mass using TPC only tracks
  92
  93   // For AOD tracks, need a function to get the dca
  94   static Float_t DCAxy(const AliAODTrack *track, const AliVEvent *evt);
  95   void StoreGlobalTrackReference(AliAODTrack *track);      // Store pointer to global track
  96   void ResetGlobalTrackReference();                        // Reset all pointers to global tracks
  97   Bool_t acceptTrack(const AliAODTrack *track);            // Famous crossed rows / findable clusters
  98   Bool_t GoodTPCFitMapSharedMap(const AliAODTrack *track); // Rejects shared clusters, primaries
  99   Bool_t GoodTPCFitMapSharedMap(const AliAODTrack *pTrack,
 100                                 const AliAODTrack *nTrack);// Rejects shared clusters, two V0 daughters
 101   Float_t GetCorrectedTOFSignal(const AliVTrack *track);   // Return correct TOF signal for old and new AODs
 102   void FillDedxHist(const AliVTrack *track);               // Fill dE/dx histograms
 103
 104   const Bool_t   fkUseOnTheFly;            //! Use on-the-fly or offline V0 finder
 105   const Float_t  fkAbsZvertexCut;          //! Values of Zvertex and centrality cut
 106   const Float_t  fkCentCut;                //! are needed for event mixing
 107   const Float_t  fkLamMass;                //! PDG-Mass of the lambda particle
 108   const Float_t  fkProMass;                //! PDG-Mass of the lambda particle
 109   const Float_t  fkPioMass;                //! PDG-Mass of the lambda particle
 110
 111   Double_t       fPrimaryVtxPosition[3];   //! Position of prim. vertex
 112
 113   AliPIDResponse  *fPIDResponse;           //! PID response object
 114   AliTPCPIDResponse *fTpcResponse;         //! Bethe-Bloch parametrisation
 115
 116
 117   FemtoBuffer     *fFemtoBuffer;           //! Event mixing: event collection
 118
 119   AliAODEvent     *fAOD;                   //! AOD event
 120   AliAODVertex    *fPrimaryVtx;            //! AOD vertex
 121
 122   TList           *fOutputList;            //! V0 output list
 123   TList           *fOutputPrimaries;       //! Primaries output list
 124   TList           *fOutput2Part;           //! Two-particle output list
 125
 126   // Store pointers to global tracks for pid and dca
 127   AliAODTrack     **fGTI;                  //! Array of pointers, just nicely sorted according to the id
 128   const UShort_t  fTrackBuffSize;          //! Size fo the above array, ~12000 for PbPb
 129   //
 130   //! ---------        Histograms        ---------
 131   //
 132   TH1F        *fHistGoodEvent;                  //! Control hist for event cuts
 133
 134   // Low memory version: just get rid of a lot of histograms
 135   /* TH2F        *fHistPrimaryVertexPosXY;         //! Primary vertex position in XY */
 136   /* TH1F        *fHistPrimaryVertexPosZ;          //! Primary vertex position in Z */
 137   /* TH1F        *fHistTrackMultiplicity;          //! Track multiplicity distribution */
 138
 139   /* TH1F        *fHistShareV0pos;                 //! Number of shared clusters, V0 pos daughter */
 140   /* TH1F        *fHistShareV0neg;                 //! Number of shared clusters, V0 neg daughter */
 141
 142   /* TH2F        *fHistPosTofBeforeCut;            //! Tof signal for pos. daughter w/o cut */
 143   /* TH2F        *fHistPosTofAfterCut;             //! Tof signal for pos. daughter with cut */
 144   /* TH2F        *fHistNegTofBeforeCut;            //! Tof signal for pos. daughter w/o cut */
 145   /* TH2F        *fHistNegTofAfterCut;             //! Tof signal for pos. daughter with cut */
 146   /* TH2F        *fHistPosTpcBeforeCut;            //! Tpc signal for pos. daughter w/o cut */
 147   /* TH2F        *fHistPosTpcAfterCut;             //! Tpc signal for pos. daughter with cut */
 148   /* TH2F        *fHistNegTpcBeforeCut;            //! Tpc signal for pos. daughter w/o cut */
 149   /* TH2F        *fHistNegTpcAfterCut;             //! Tpc signal for pos. daughter with cut */
 150
 151   /* TH2F        *fHistGoodV0;                     //! Control histogram for cuts */
 152   /* TH2F        *fHistCorrectSigns;               //! Check of sign of tracks */
 153   /* TH2F        *fHistDcaPosToPrimVertex;         //! DCA of pos daughter to primary vertex */
 154   /* TH2F        *fHistDcaNegToPrimVertex;         //! DCA of neg daughter to primary vertex */
 155   /* TH2F        *fHistDcaPosToPrimVertexZoom;     //! Zoom */
 156   /* TH2F        *fHistDcaNegToPrimVertexZoom;     //! Zoom */
 157   /* TH2F        *fHistRadiusV0;                   //! Radial position of V0 vertex */
 158   /* TH2F        *fHistDecayLengthV0;              //! Dist prim. vertex - V0 vertex */
 159   /* TH2F        *fHistDcaV0Daughters;             //! DCA of daughters */
 160   /* TH2F        *fHistChi2;                       //! Chi2 for V0 vertex */
 161   /* TH2F        *fHistCosPointAngle;              //! Cosine of pointing angle */
 162   /* TH2F        *fHistCosPointAngleZoom;          //! Zoom */
 163
 164   TH1F        *fHistSideBandOffLam;             //! Off: side band background lambda
 165   TH1F        *fHistSideBandOffALam;            //! Off: side band background anti-lambda
 166
 167   TH2F        *fHistTPCNclsPosOffLam;           //! Off: lam-mass vs TPCNcls(pos daughter)
 168   TH2F        *fHistTPCNclsNegOffLam;           //! Off: lam-mass vs TPCNcls(neg daughter)
 169   TH2F        *fHistTPCNclsPosOffALam;          //! Off: alam-mass vs TPCNcls(pos daughter)
 170   TH2F        *fHistTPCNclsNegOffALam;          //! Off: alam-mass vs TPCNcls(neg daughter)
 171   /* TH2F        *fHistPosNsigmaTpcOffLam;         //! */
 172   /* TH2F        *fHistPosNsigmaTpcOffALam;        //! */
 173   /* TH2F        *fHistNegNsigmaTpcOffLam;         //! */
 174   /* TH2F        *fHistNegNsigmaTpcOffALam;        //! */
 175   /* TH2F        *fHistUseTofOffLam;               //! */
 176   /* TH2F        *fHistUseTofOffALam;              //! */
 177   /* TH2F        *fHistDcaPosOffLam;               //! Off: lam-mass vs DCA(pos - prim. vertex) */
 178   /* TH2F        *fHistDcaPosOffALam;              //! Off: alam-mass vs DCA(pos - prim. vertex) */
 179   /* TH2F        *fHistDcaNegOffLam;               //! Off: lam-mass vs DCA(neg - prim. vertex) */
 180   /* TH2F        *fHistDcaNegOffALam;              //! Off: alam-mass vs DCA(neg - prim. vertex) */
 181   /* TH2F        *fHistDcaV0DaughtersOffLam;       //! Off: lam-mass vs DCA(V0-daughters) */
 182   /* TH2F        *fHistDcaV0DaughtersOffALam;      //! Off: alam-mass vs DCA(V0-daughters) */
 183   /* TH2F        *fHistCosPointLamOff;             //! Off: lam-mass vs cosine(pointing angle) */
 184   /* TH2F        *fHistCosPointALamOff;            //! Off: Alam-mass vs cosine(pointing angle) */
 185   /* TH2F        *fHistCosPointLamZoomOff;         //! Zoom */
 186   /* TH2F        *fHistCosPointALamZoomOff;        //! Zoom */
 187   /* TH2F        *fHistV0RadiusLamOff;             //! Off: lam-mass vs radial position(V0) */
 188   /* TH2F        *fHistV0RadiusALamOff;            //! Off: alam-mass vs radial position(V0) */
 189   /* TH2F        *fHistV0DecayLengthLamOff;        //! Off: lam-mass vs decay length(V0) */
 190   /* TH2F        *fHistV0DecayLengthALamOff;       //! Off: alam-mass vs decay length(V0) */
 191   /* TH2F        *fHistDcaV0PriVertexLamOff;       //! Off: lam-mass vs dca (prim. vertex - V0) */
 192   /* TH2F        *fHistDcaV0PriVertexALamOff;      //! Off: alam-mass vs dca (prim. vertex - V0) */
 193   TH1F        *fHistMassLambdaOff;              //! Off: invariant mass assuming lambda
 194   TH1F        *fHistMassAntiLambdaOff;          //! Off: invariant mass assuming anti-lambda
 195   /* TH2F        *fHistPtVsMassLambdaOff;          //! Off: lam-mass vs pt(V0) */
 196   /* TH2F        *fHistPtVsMassAntiLambdaOff;      //! Off: alam-mass vs pt(V0) */
 197   TH3F        *fHistYPtMassLamOff;              //! Off: lam-mass vs y-pt
 198   TH3F        *fHistYPtMassALamOff;             //! Off: alam-mass vs y-pt
 199   /* TH2F        *fHistPtVsYLambdaOff;             //! Off: y-pt (lambda) */
 200   /* TH2F        *fHistPtVsYAntiLambdaOff;         //! Off: y-pt (anti-lambda) */
 201
 202   TH1F        *fHistSideBandOnLam;              //! On-the-fly: side band background lambda
 203   TH1F        *fHistSideBandOnALam;             //! On-the-fly: side band background anti-lambda
 204
 205   /* TH2F        *fHistLikeSignOnLam;              //! On-the-fly: lambda mass vs signs of pairs */
 206   /* TH2F        *fHistLikeSignOnALam;             //! On-the-fly: antilambda mass vs signs of pairs */
 207   TH2F        *fHistTPCNclsPosOnLam;            //! On: lam-mass vs TPCNcls(pos daughter)
 208   TH2F        *fHistTPCNclsNegOnLam;            //! On: lam-mass vs TPCNcls(neg daughter)
 209   TH2F        *fHistTPCNclsPosOnALam;           //! On: alam-mass vs TPCNcls(pos daughter)
 210   TH2F        *fHistTPCNclsNegOnALam;           //! On: alam-mass vs TPCNcls(neg daughter)
 211   /* TH2F        *fHistPosNsigmaTpcOnLam;          //! */
 212   /* TH2F        *fHistPosNsigmaTpcOnALam;         //! */
 213   /* TH2F        *fHistNegNsigmaTpcOnLam;          //! */
 214   /* TH2F        *fHistNegNsigmaTpcOnALam;         //!  */
 215   /* TH2F        *fHistUseTofOnLam;                //! */
 216   /* TH2F        *fHistUseTofOnALam;               //! */
 217   /* TH2F        *fHistDcaPosOnLam;                //! On: lam-mass vs DCA(pos - prim. vertex) */
 218   /* TH2F        *fHistDcaPosOnALam;               //! On: alam-mass vs DCA(pos - prim. vertex) */
 219   /* TH2F        *fHistDcaNegOnLam;                //! On: lam-mass vs DCA(neg - prim. vertex) */
 220   /* TH2F        *fHistDcaNegOnALam;               //! On: alam-mass vs DCA(neg - prim. vertex) */
 221   /* TH2F        *fHistDcaV0DaughtersOnLam;        //! On: lam-mass vs DCA(V0-daughters) */
 222   /* TH2F        *fHistDcaV0DaughtersOnALam;       //! On: alam-mass vs DCA(V0-daughters) */
 223   /* TH2F        *fHistCosPointLamOn;              //! On: lam-mass vs cosine(pointing angle) */
 224   /* TH2F        *fHistCosPointALamOn;             //! On: Alam-mass vs cosine(pointing angle) */
 225   /* TH2F        *fHistCosPointLamZoomOn;          //! Zoom */
 226   /* TH2F        *fHistCosPointALamZoomOn;         //! Zoom */
 227   /* TH2F        *fHistV0RadiusLamOn;              //! On: lam-mass vs radial position(V0) */
 228   /* TH2F        *fHistV0RadiusALamOn;             //! On: alam-mass vs radial position(V0) */
 229   /* TH2F        *fHistV0DecayLengthLamOn;         //! On: lam-mass vs decay length(V0) */
 230   /* TH2F        *fHistV0DecayLengthALamOn;        //! On: alam-mass vs decay length(V0) */
 231   /* TH2F        *fHistDcaV0PriVertexLamOn;        //! On: lam-mass vs dca (prim. vertex - V0) */
 232   /* TH2F        *fHistDcaV0PriVertexALamOn;       //! On: alam-mass vs dca (prim. vertex - V0) */
 233   /* TH2F        *fHistChi2TPCPosLamOn;            //! On: Chi2 TPC clusters */
 234   /* TH2F        *fHistChi2TPCPosALamOn;           //! */
 235   /* TH2F        *fHistChi2TPCNegLamOn;            //! */
 236   /* TH2F        *fHistChi2TPCNegALamOn;           //! */
 237   /* TH1F        *fHistMinvTPConlyLamOn;           //! On: minv w/ TPC only daughters, lambda */
 238   /* TH1F        *fHistMinvTPConlyALamOn;          //! On:        --""--             , anti-lambda */
 239   TH1F        *fHistMassLambdaOn;               //! On: invariant mass assuming lambda
 240   TH1F        *fHistMassAntiLambdaOn;           //! On: invariant mass assuming anti-lambda
 241   /* TH2F        *fHistPtVsMassLambdaOn;           //! On: lam-mass vs pt(V0) */
 242   /* TH2F        *fHistPtVsMassAntiLambdaOn;       //! On: alam-mass vs pt(V0) */
 243   TH3F        *fHistYPtMassLamOn;               //! On: lam-mass vs y-pt
 244   TH3F        *fHistYPtMassALamOn;              //! On: alam-mass vs y-pt
 245   /* TH2F        *fHistPtVsYLambdaOn;              //! On: y-pt (lambda) */
 246   /* TH2F        *fHistPtVsYAntiLambdaOn;          //! On: y-pt (anti-lambda) */
 247
 248   /* TH3F        *fHistMomDiffLam;                 //! Momentum difference standard V0 / */
 249   /* TH3F        *fHistMomDiffALam;                //! TPC only V0 */
 250   /* TH3F        *fHistMomDiffBgLam;               //! */
 251   /* TH3F        *fHistMomDiffBgALam;              //! */
 252   /* TH3F        *fHistMomDiffWoSPDLam;            //! Momentum difference standard V0 / */
 253   /* TH3F        *fHistMomDiffWoSPDALam;           //! TPC only V0, only tracks without  */
 254   /* TH3F        *fHistMomDiffWoSPDBgLam;          //! SPD hits */
 255   /* TH3F        *fHistMomDiffWoSPDBgALam;         //! */
 256
 257   // Primary particles
 258   TH1F        *fPriHistShare;                   //! Primaries: number of shared clusters
 259   // ToF histograms
 260   /* TH1F        *fPriHistPosNsigmaTof;            //! Primaries: Nsigma TOF distribution (pos) */
 261   TH2F        *fPriHistPosNsigmaTofVsP;         //! Pri: Nsigma TOF vs total momentum (pos)
 262   TH2F        *fPriHistPosNsigmaTofVsPt;        //! Pri: Nsigma TOF vs transverse momentum (pos)
 263   /* TH1F        *fPriHistNegNsigmaTof;            //! Primaries: Nsigma TOF distribution (neg) */
 264   TH2F        *fPriHistNegNsigmaTofVsP;         //! Pri: Nsigma TOF vs total momentum (neg)
 265   TH2F        *fPriHistNegNsigmaTofVsPt;        //! Pri: Nsigma TOF vs transverse momentum (neg)
 266   TH2F        *fPriHistTOFsignalPosVsP;         //! Pri: TOF signal vs p (pos)
 267   TH2F        *fPriHistTOFsignalPosVsPt;        //! Pri: TOF signal vs pt (pos)
 268   TH2F        *fPriHistTOFsignalNegVsP;         //! Pri: TOF signal vs p (neg)
 269   TH2F        *fPriHistTOFsignalNegVsPt;        //! Pri: TOF signal vs pt (neg)
 270   // Hybrid analysis: dEdx & ToF histograms
 271   TH1F        *fPriHistHybridTOFsigPosWoTPC;    //! Pri: TOF signal without dEdx selection (pos)
 272   TH1F        *fPriHistHybridTOFsigPosTPCok;    //! Pri: TOF signal with dEdx selection (pos)
 273   TH1F        *fPriHistHybridTOFsigNegWoTPC;    //! Pri: TOF signal without dEdx selection (neg)
 274   TH1F        *fPriHistHybridTOFsigNegTPCok;    //! Pri: TOF signal with dEdx selection (neg)
 275
 276   /* TH1F        *fPriHistHasTofPos;               //! Pri: 1 = TOFpid bit is there, 0 else */
 277   TH2F        *fPriHistTPCsignalPos;            //! Pri: TPC dE/dx signal vs p
 278   /* TH2F        *fPriHistNsigmaTPCPos;            //! Pri: Nsigma TPC distribution vs p */
 279   /* TH2F        *fPriHistTPCsignalTOFcutPos;      //! Pri: dE/dx vs p + TOF sigma(proton) > -10 */
 280   /* TH2F        *fPriHistNsigmaTPCTOFcutPos;      //! Pri: Nsigma TPC vs p + TOF sigma(proton) > -10 */
 281   TH2F        *fPriHistTPCsignalLowPPos;        //! Pri: dEdx for 0.1 < p < 0.3
 282   TH2F        *fPriHistTPCsignalMedPPos;        //! Pri: dEdx for 0.3 < p < 0.9
 283   TH2F        *fPriHistTPCsignalHigPPos;        //! Pri: dEdx for 0.9 < p < 1.9
 284
 285   /* TH1F        *fPriHistHasTofNeg;               //! Pri: 1 = TOFpid bit is there, 0 else */
 286   TH2F        *fPriHistTPCsignalNeg;            //! Pri: TPC dE/dx signal vs p
 287   /* TH2F        *fPriHistNsigmaTPCNeg;            //! Pri: Nsigma TPC distribution vs p */
 288   /* TH2F        *fPriHistTPCsignalTOFcutNeg;      //! Pri:   " + TOF sigma(proton) > -10 */
 289   /* TH2F        *fPriHistNsigmaTPCTOFcutNeg;      //! Pri: Nsigma TPC vs p + TOF sigma(proton) > -10 */
 290   TH2F        *fPriHistTPCsignalLowPNeg;        //! Pri: dEdx for 0.1 < p < 0.3
 291   TH2F        *fPriHistTPCsignalMedPNeg;        //! Pri: dEdx for 0.3 < p < 0.9
 292   TH2F        *fPriHistTPCsignalHigPNeg;        //! Pri: dEdx for 0.9 < p < 1.9
 293
 294   TH3F        *fPriHistDCAxyYPtPro;             //! Pri: DCAxy vs (y,pt) for protons
 295   TH3F        *fPriHistDCAxyYPtAPro;            //! Pri: DCAxy vs (y,pt) for anti-protons
 296
 297   /*        // Histograms for two particle observables */
 298   /* TH2F        *f2HistLamLamMeanMinDistProReal;     //! TTR: Real events */
 299   /* TH2F        *f2HistLamLamMeanMinDistPioReal;     //!  */
 300   /* TH2F        *f2HistLamProMeanMinDistProReal;     //!  */
 301   /* TH2F        *f2HistALamALamMeanMinDistAProReal;  //!  */
 302   /* TH2F        *f2HistALamALamMeanMinDistPioReal;   //!  */
 303   /* TH2F        *f2HistALamAProMeanMinDistAProReal;  //!  */
 304   /* TH2F        *f2HistSftLamLamMeanMinDistProReal;     //! TTR: Shifted pri vtx */
 305   /* TH2F        *f2HistSftLamLamMeanMinDistPioReal;     //!  */
 306   /* TH2F        *f2HistSftLamProMeanMinDistProReal;     //!  */
 307   /* TH2F        *f2HistSftALamALamMeanMinDistAProReal;  //!  */
 308   /* TH2F        *f2HistSftALamALamMeanMinDistPioReal;   //!  */
 309   /* TH2F        *f2HistSftALamAProMeanMinDistAProReal;  //!  */
 310   /* TH2F        *f2HistSftIrocLamLamMeanMinDistProReal;     //! TTR: Shifted pri vtx: IROCs */
 311   /* TH2F        *f2HistSftIrocLamLamMeanMinDistPioReal;     //!  */
 312   /* TH2F        *f2HistSftIrocLamProMeanMinDistProReal;     //!  */
 313   /* TH2F        *f2HistSftIrocALamALamMeanMinDistAProReal;  //!  */
 314   /* TH2F        *f2HistSftIrocALamALamMeanMinDistPioReal;   //!  */
 315   /* TH2F        *f2HistSftIrocALamAProMeanMinDistAProReal;  //!  */
 316   /* TH2F        *f2HistSftOrocLamLamMeanMinDistProReal;     //! TTR: Shifted pri vtx: OROCs */
 317   /* TH2F        *f2HistSftOrocLamLamMeanMinDistPioReal;     //!  */
 318   /* TH2F        *f2HistSftOrocLamProMeanMinDistProReal;     //!  */
 319   /* TH2F        *f2HistSftOrocALamALamMeanMinDistAProReal;  //!  */
 320   /* TH2F        *f2HistSftOrocALamALamMeanMinDistPioReal;   //!  */
 321   /* TH2F        *f2HistSftOrocALamAProMeanMinDistAProReal;  //!  */
 322
 323   // transverse mass mt of the pair
 324   /* TH1F        *f2HistMtLamLamReal;     //! */
 325   TH1F        *f2HistMtLamProReal;     //!
 326   /* TH1F        *f2HistMtALamALamReal;   //! */
 327   TH1F        *f2HistMtALamAProReal;   //!
 328   // .. for low q pairs only
 329   /* TH1F        *f2HistMtLowQLamLamReal;     //! */
 330   TH1F        *f2HistMtLowQLamProReal;     //!
 331   /* TH1F        *f2HistMtLowQALamALamReal;   //! */
 332   TH1F        *f2HistMtLowQALamAProReal;   //!
 333
 334   // September '12: use a THnSparseF with 4 dimensions
 335   // for pro lam: qinv propro, mean d propro
 336   // min d propro, qinv lampro
 337   THnSparseF       *LamProReal;  //!
 338   THnSparseF       *ALamAProReal;//!
 339
 340   // Changed on march 4th: all correlation functions vs
 341   // distances to try out diff. cuts
 342   /* TH3F        *f3HistLamLamQinvReal;                //! Qinv distribution real events */
 343   /* TH3F        *f3HistALamALamQinvReal;              //!                 */
 344   /* TH3F        *f3HistLamLamMinvReal;                //! Minv distribution real events */
 345   /* TH3F        *f3HistLamProMinvReal;                //! */
 346   /* TH3F        *f3HistALamALamMinvReal;              //!                 */
 347   /* TH3F        *f3HistALamAProMinvReal;              //! */
 348
 349  // Background lambdas: real events
 350   /* TH2F        *f2HistBgLamBgLamMeanMinDistProReal;   //! TTR: Real events */
 351   /* TH2F        *f2HistBgLamBgLamMeanMinDistPioReal;   //!  */
 352   /* TH2F        *f2HistBgLamProMeanMinDistProReal;     //!  */
 353   /* TH2F        *f2HistBgALamBgALamMeanMinDistAProReal;//!  */
 354   /* TH2F        *f2HistBgALamBgALamMeanMinDistPioReal; //!  */
 355   /* TH2F        *f2HistBgALamAProMeanMinDistAProReal;  //!  */
 356   /* TH2F        *f2HistSftBgLamBgLamMeanMinDistProReal;   //! TTR: Shifted pri vtx */
 357   /* TH2F        *f2HistSftBgLamBgLamMeanMinDistPioReal;   //!  */
 358   /* TH2F        *f2HistSftBgLamProMeanMinDistProReal;     //!  */
 359   /* TH2F        *f2HistSftBgALamBgALamMeanMinDistAProReal;//!  */
 360   /* TH2F        *f2HistSftBgALamBgALamMeanMinDistPioReal; //!  */
 361   /* TH2F        *f2HistSftBgALamAProMeanMinDistAProReal;  //!  */
 362   /* TH2F        *f2HistSftIrocBgLamBgLamMeanMinDistProReal;   //! TTR: Shifted pri vtx: IROCs */
 363   /* TH2F        *f2HistSftIrocBgLamBgLamMeanMinDistPioReal;   //!  */
 364   /* TH2F        *f2HistSftIrocBgLamProMeanMinDistProReal;     //!  */
 365   /* TH2F        *f2HistSftIrocBgALamBgALamMeanMinDistAProReal;//!  */
 366   /* TH2F        *f2HistSftIrocBgALamBgALamMeanMinDistPioReal; //!  */
 367   /* TH2F        *f2HistSftIrocBgALamAProMeanMinDistAProReal;  //!  */
 368   /* TH2F        *f2HistSftOrocBgLamBgLamMeanMinDistProReal;   //! TTR: Shifted pri vtx: OROCs */
 369   /* TH2F        *f2HistSftOrocBgLamBgLamMeanMinDistPioReal;   //!  */
 370   /* TH2F        *f2HistSftOrocBgLamProMeanMinDistProReal;     //!  */
 371   /* TH2F        *f2HistSftOrocBgALamBgALamMeanMinDistAProReal;//!  */
 372   /* TH2F        *f2HistSftOrocBgALamBgALamMeanMinDistPioReal; //!  */
 373   /* TH2F        *f2HistSftOrocBgALamAProMeanMinDistAProReal;  //!  */
 374
 375   // September '12: use a THnSparseF with 4 dimensions
 376   // for pro lam: qinv propro, mean d propro
 377   // min d propro, qinv lampro
 378   THnSparseF       *BgLamProReal;  //!
 379   THnSparseF       *BgALamAProReal;//!
 380
 381   /* TH3F        *f3HistBgLamBgLamQinvReal;             //! Qinv distribution real events */
 382   /* TH3F        *f3HistBgALamBgALamQinvReal;           //!                 */
 383
 384   // Mixed events
 385   /* TH2F        *f2HistLamLamMeanMinDistProMixed;      //! TTR: Mixed events */
 386   /* TH2F        *f2HistLamLamMeanMinDistPioMixed;      //!  */
 387   /* TH2F        *f2HistLamProMeanMinDistProMixed;      //!  */
 388   /* TH2F        *f2HistALamALamMeanMinDistAProMixed;   //!  */
 389   /* TH2F        *f2HistALamALamMeanMinDistPioMixed;    //!  */
 390   /* TH2F        *f2HistALamAProMeanMinDistAProMixed;   //!  */
 391   /* TH2F        *f2HistSftLamLamMeanMinDistProMixed;      //! TTR: Mixed events, shifted pri vtx */
 392   /* TH2F        *f2HistSftLamLamMeanMinDistPioMixed;      //!  */
 393   /* TH2F        *f2HistSftLamProMeanMinDistProMixed;      //!  */
 394   /* TH2F        *f2HistSftALamALamMeanMinDistAProMixed;   //!  */
 395   /* TH2F        *f2HistSftALamALamMeanMinDistPioMixed;    //!  */
 396   /* TH2F        *f2HistSftALamAProMeanMinDistAProMixed;   //!  */
 397   /* TH2F        *f2HistSftIrocLamLamMeanMinDistProMixed;      //! TTR: Mixed events, shifted pri vtx, IROCs */
 398   /* TH2F        *f2HistSftIrocLamLamMeanMinDistPioMixed;      //!  */
 399   /* TH2F        *f2HistSftIrocLamProMeanMinDistProMixed;      //!  */
 400   /* TH2F        *f2HistSftIrocALamALamMeanMinDistAProMixed;   //!  */
 401   /* TH2F        *f2HistSftIrocALamALamMeanMinDistPioMixed;    //!  */
 402   /* TH2F        *f2HistSftIrocALamAProMeanMinDistAProMixed;   //!  */
 403   /* TH2F        *f2HistSftOrocLamLamMeanMinDistProMixed;      //! TTR: Mixed events, shifted pri vtx, OROCs */
 404   /* TH2F        *f2HistSftOrocLamLamMeanMinDistPioMixed;      //!  */
 405   /* TH2F        *f2HistSftOrocLamProMeanMinDistProMixed;      //!  */
 406   /* TH2F        *f2HistSftOrocALamALamMeanMinDistAProMixed;   //!  */
 407   /* TH2F        *f2HistSftOrocALamALamMeanMinDistPioMixed;    //!  */
 408   /* TH2F        *f2HistSftOrocALamAProMeanMinDistAProMixed;   //!  */
 409
 410   // September '12: use a THnSparseF with 4 dimensions
 411   // for pro lam: qinv propro, mean d propro
 412   // min d propro, qinv lampro
 413   THnSparseF       *LamProMixed; //!
 414   THnSparseF       *ALamAProMixed;//!
 415
 416   /* TH3F        *f3HistLamLamQinvMixed;                //! Qinv distribution mixed events */
 417   /* TH3F        *f3HistALamALamQinvMixed;              //!                 */
 418   /* TH3F        *f3HistLamLamMinvMixed;                //! Minv distribution mixed events */
 419   /* TH3F        *f3HistLamProMinvMixed;                //! */
 420   /* TH3F        *f3HistALamALamMinvMixed;              //!                 */
 421   /* TH3F        *f3HistALamAProMinvMixed;              //! */
 422    // Background lambdas: mixed events
 423   /* TH2F        *f2HistBgLamBgLamMeanMinDistProMixed;   //! TTR: Mixed events */
 424   /* TH2F        *f2HistBgLamBgLamMeanMinDistPioMixed;   //!  */
 425   /* TH2F        *f2HistBgLamProMeanMinDistProMixed;     //!  */
 426   /* TH2F        *f2HistBgALamBgALamMeanMinDistAProMixed;//!  */
 427   /* TH2F        *f2HistBgALamBgALamMeanMinDistPioMixed; //!  */
 428   /* TH2F        *f2HistBgALamAProMeanMinDistAProMixed;  //!  */
 429   /* TH2F        *f2HistSftBgLamBgLamMeanMinDistProMixed;   //! TTR: Mixed events, shifted pri vtx */
 430   /* TH2F        *f2HistSftBgLamBgLamMeanMinDistPioMixed;   //!  */
 431   /* TH2F        *f2HistSftBgLamProMeanMinDistProMixed;     //!  */
 432   /* TH2F        *f2HistSftBgALamBgALamMeanMinDistAProMixed;//!  */
 433   /* TH2F        *f2HistSftBgALamBgALamMeanMinDistPioMixed; //!  */
 434   /* TH2F        *f2HistSftBgALamAProMeanMinDistAProMixed;  //!  */
 435   /* TH2F        *f2HistSftIrocBgLamBgLamMeanMinDistProMixed;   //! TTR: Mixed events, shifted pri vtx, IROCs */
 436   /* TH2F        *f2HistSftIrocBgLamBgLamMeanMinDistPioMixed;   //!  */
 437   /* TH2F        *f2HistSftIrocBgLamProMeanMinDistProMixed;     //!  */
 438   /* TH2F        *f2HistSftIrocBgALamBgALamMeanMinDistAProMixed;//!  */
 439   /* TH2F        *f2HistSftIrocBgALamBgALamMeanMinDistPioMixed; //!  */
 440   /* TH2F        *f2HistSftIrocBgALamAProMeanMinDistAProMixed;  //!  */
 441   /* TH2F        *f2HistSftOrocBgLamBgLamMeanMinDistProMixed;   //! TTR: Mixed events, shifted pri vtx, OROCs */
 442   /* TH2F        *f2HistSftOrocBgLamBgLamMeanMinDistPioMixed;   //!  */
 443   /* TH2F        *f2HistSftOrocBgLamProMeanMinDistProMixed;     //!  */
 444   /* TH2F        *f2HistSftOrocBgALamBgALamMeanMinDistAProMixed;//!  */
 445   /* TH2F        *f2HistSftOrocBgALamBgALamMeanMinDistPioMixed; //!  */
 446   /* TH2F        *f2HistSftOrocBgALamAProMeanMinDistAProMixed;  //!  */
 447
 448   // September '12: use a THnSparseF with 4 dimensions
 449   // for pro lam: qinv propro, mean d propro
 450   // min d propro, qinv lampro
 451   THnSparseF       *BgLamProMixed;   //!
 452   THnSparseF       *BgALamAProMixed; //!
 453
 454   /* TH3F        *f3HistBgLamBgLamQinvMixed;             //! Qinv distribution mixed events */
 455   /* TH3F        *f3HistBgALamBgALamQinvMixed;           //!                 */
 456
 457  private:
 458   //  ------------------------------------
 459   //
 460   //    Nested classes for event mixing
 461   //    Features are
 462   //    * low memory usage as only needed variables
 463   //      are stored and not, e.g., the full AliAODTrack
 464   //    * it's fast, as memory allocation occours
 465   //      only once and no deep copying is done
 466   //      when doing the fifo shift and reseting
 467   //      the event. Resetting and shifting could
 468   //      be reduced to only a few integer assignments.
 469   //
 470   //  ------------------------------------
 471
 472
 473   class FemtoBufferTrack{// Charged tracks
 474   public:
 475     FemtoBufferTrack();                               // Constructor
 476     FemtoBufferTrack(const AliAODTrack *track,
 477                      const Float_t bfield,
 478                      const Float_t priVtx[3]);           // Constructor
 479     ~FemtoBufferTrack(){;}                            // Destructor, nothing to do.
 480     FemtoBufferTrack(const FemtoBufferTrack& fbt);    // Copy constructor
 481     FemtoBufferTrack& operator=(const FemtoBufferTrack& fbt); // Assignment operator
 482     void Set(const AliAODTrack *track,                // Set parameters of the FemtoBufferTrack
 483              const Float_t bfield,                    // to these of the given AliAODtrack
 484              const Float_t priVtx[3]);
 485     void Set(const AliAODTrack *track,                // Overloaded fct that just
 486              const Float_t bfield,                    // calls Set(..,Float)
 487              const Double_t priVtx[3]);
 488     // Two functions to get the global and shifted positions. Both is not trivial as
 489     // tracks in ALICE get propagated in the local system
 490     // Shifted for studying all events shifted to (0,0,0)
 491     void GetShiftedPositionAtShiftedRadii(const AliAODTrack *track,
 492                                           const Float_t bfield, const Float_t priVtx[3]);
 493     // Global if not shifted
 494     void GetGlobalPositionAtGlobalRadii(const AliAODTrack *track,
 495                                         const Float_t bfield);
 496     Bool_t UseIt() const {return fID!=65535;}          // Use entry? eg. set to false by cleaning procedure
 497     void   SetBadFlag(){fID=65535;}                   // Can only set 'bad track' flag
 498     // Interpretation of ALICE coding rule RC14 is that FemtoBufferTrack is a private member
 499     // of AliAnalysisTaskProtonLambda, so the following data member are private
 500     UShort_t fID;               //! Unique track id (->AliAODTrack.h), UShort_t goes to 65000
 501     Double_t fP[3];             //! Momentum of track
 502     /* Float_t  fXglobal[9][3];    //! Global positions at different global radii */
 503     Float_t  fXshifted[9][3];   //! Shifted positions at different shifted radii
 504   };
 505
 506   class FemtoBufferV0{// V0 vertices
 507   public:
 508     // Constructors n stuff
 509     FemtoBufferV0();                          // Constructor
 510     FemtoBufferV0(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter,
 511                   const Double_t bfield, Double_t priVtxPos[3]);   // Constructor
 512     ~FemtoBufferV0(){;}                       // Destructor, nothing to do.
 513     FemtoBufferV0(const FemtoBufferV0 &fbv);  // Copy constructor
 514     FemtoBufferV0& operator=(const FemtoBufferV0 &fbv);// Assignment operator
 515     // Functions
 516     void Set(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter
 517              ,const Double_t bfield, Double_t priVtxPos[3]); // Set properties of this to these of v0
 518     Bool_t UseIt() const {return fCosPoint>0;} // Use entry? eg. set to false by cleaning procedure
 519     void SetBadFlag(){fCosPoint=-9999.;fPosDaughter.SetBadFlag();
 520       fNegDaughter.SetBadFlag();}               // Can only set 'bad track' flag
 521     // Data member
 522     Double_t fP[3];                 //! Momentum (x,y,z)
 523     Float_t fCosPoint;              //! Cosine of pointing angle
 524     FemtoBufferTrack fPosDaughter;  //! Positive daughter of the V0
 525     FemtoBufferTrack fNegDaughter;  //! Negative daughter fo the V0
 526   };
 527
 528   class FemtoBufferEvent{// Event
 529   public:
 530     FemtoBufferEvent();                       // Constructor
 531     FemtoBufferEvent(const UShort_t priTrackBuff,const UShort_t V0Buff,
 532                      const Double_t bfield,const Double_t priVtxPos[3]); // Constructor
 533     FemtoBufferEvent(const UShort_t priTrackBuff,const UShort_t V0Buff); // Constructor
 534     FemtoBufferEvent(const FemtoBufferEvent &fbe);           // Copy constructor
 535     // Assignment operator won't change the size of the arrays!
 536     FemtoBufferEvent& operator=(const FemtoBufferEvent &fbe); // Assignment operator
 537     ~FemtoBufferEvent();                       // Destructor
 538     void Reset(const Double_t bfield, const Double_t priVtxPos[3]);// Resets the event with new variables given
 539
 540     // Functions to add particles to the event
 541     void AddPro(const AliAODTrack *track);      // Add a proton to this event
 542     void AddAPro(const AliAODTrack *track);     // Add a anti-proton this actual event
 543     void AddLam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
 544     // Add a lamba to this event
 545     void AddALam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
 546     // Add a anti-lambda to this event
 547     void AddBgLam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
 548     // Add lambda background to this event
 549     void AddBgALam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
 550     // Add anti-lambda background to this event
 551
 552     // Getters for the event properties, no setters as you're not supposed to change them :)
 553     // The fBfield and fPriVtxPos get set on each 'reset' for a new event and the limits get set
 554     // on creation of the event
 555     Double_t GetBfield()const{return fBfield;}            // Getter for magnetic field of event
 556     void GetVtxPos(Double_t xyz[3])const{for(Int_t i=0;i<3;i++)xyz[i]=fPriVtxPos[i];} // Get the xyz of the vertex.
 557     UShort_t GetPriTrackLim()const{return fPriTrackLim;}  // Get the size of the array for primary tracks
 558     UShort_t GetV0Lim()const{return fV0Lim;}              // Get the size of the array for V0s
 559     // The number of tracks stored in the event
 560     UShort_t GetNPro()const{return fNProTracks;}       // Number of stored protons
 561     UShort_t GetNAPro()const{return fNAProTracks;}     // .. anti-protons
 562     UShort_t GetNLam()const{return fNLamTracks;}       // .. lambda
 563     UShort_t GetNALam()const{return fNALamTracks;}     // .. anti-lambda
 564     UShort_t GetNBgLam()const{return fNBgLamTracks;}   // .. background lambda
 565     UShort_t GetNBgALam()const{return fNBgALamTracks;} // .. background anti-lambda
 566
 567     // Data member, sorry for this private public private mixture,
 568     // but what's this reorder warning? sometimes it's there, st not..
 569   private:
 570     // Size of the arrays for tracks. Constant and private to reflect the idea that
 571     // the arrays get allocated only once to avoid excessive memory allocation
 572     const UShort_t fPriTrackLim;   // Limit for primary tracks
 573     const UShort_t fV0Lim;         // Limit for V0s
 574   public:
 575     // Pointer to array of ...
 576     FemtoBufferTrack *fProTracks;          //! Proton tracks
 577     FemtoBufferTrack *fAProTracks;         //! Anti-proton tracks
 578
 579     FemtoBufferV0    *fLamTracks;          //! Lambda tracks
 580     FemtoBufferV0    *fALamTracks;         //! Anti-lambda tracks
 581
 582     FemtoBufferV0    *fBgLamTracks;        //! Background lambda tracks
 583     FemtoBufferV0    *fBgALamTracks;       //! Background anti-lambda tracks
 584   private:
 585     // Number of stored tracks in the event
 586     UShort_t fNProTracks;    // Number of stored protons
 587     UShort_t fNAProTracks;   // Number of stored anti-protons
 588     UShort_t fNLamTracks;    // Number of stored lambdas
 589     UShort_t fNALamTracks;   // Number of stored anti-lambdas
 590     UShort_t fNBgLamTracks;  // Number of stored lambdas
 591     UShort_t fNBgALamTracks; // Number of stored anti-lambdas
 592
 593     // Double_t needed??? magnetic field probably is like 5.0 and not 5.0000120047
 594     Double_t fBfield;               // Magnetic field in ALICE unit [kG]
 595     Double_t fPriVtxPos[3];         // Primary vtx position
 596   };
 597
 598   class FemtoBuffer { // Holds the events
 599   public:
 600     FemtoBuffer();           // Dummy constructor
 601     FemtoBuffer(const UChar_t ZvertexBins,const UChar_t CentBins,const UChar_t MixBuff,
 602                 const UShort_t PriTrackLim,const UShort_t V0Lim,const Float_t AbsZvertexCut,const Float_t CentCut); // Constructor
 603     FemtoBuffer(const FemtoBuffer &fb); //Ctor
 604     FemtoBuffer& operator=(const AliAnalysisTaskProtonLambda::FemtoBuffer&); // Assignment
 605     ~FemtoBuffer();          // Destructor
 606     void ShiftAndAdd(AliAODEvent *evt); // Discard last event, shift all, set first one
 607     void ShiftAndAdd(const Double_t bfield,const Double_t priVtxPos[3],const Float_t centrality); // Discard last event, shift all, set first one
 608     FemtoBufferEvent *GetEvt(const UChar_t i)const{return fCurEvt[i];}; // Returns a pointer to the i'th event of the current event mixing class
 609     UChar_t GetMixBuffSize()const{return fkMixBuffSize;}// Returns the number of events held in every mixing bin
 610
 611   private:
 612     const UChar_t fkZvertexBins;           // Number of bins in Zvertex
 613     const UChar_t fkCentBins;              // Number of bins in centrality
 614     const UChar_t fkMixBuffSize;           // Number of stored events
 615     const UShort_t fkPriTrackLim;          // Buffer size protons per event
 616     const UShort_t fkV0Lim;                // Buffer size lambdas per event
 617
 618     const TAxis *fZvertexAxis;          //! To find Zvertex bin
 619     const TAxis *fCentAxis;             //! To find centrality bin
 620
 621     FemtoBufferEvent **fCurEvt;//! Array of pointer to the set of the current events
 622                                      //  Note that the pointer won't be constant
 623     FemtoBufferEvent ****fEC;  //! The internal thing where the events
 624                                      //  are stored.
 625                                      //  fEC stands for event collection.
 626   };
 627
 628   ClassDef(AliAnalysisTaskProtonLambda, 1);
 629 };
 630
 631 #endif