PWG4/UserTasks/EmcalTasks/AliAnalysisTaskEMCALPi0PbPb.h

   1 #ifndef AliAnalysisTaskEMCALPi0PbPb_h
   2 #define AliAnalysisTaskEMCALPi0PbPb_h
   3
   4 // $Id$
   5
   6 class TAxis;
   7 class TClonesArray;
   8 class TH1;
   9 class TH2;
  10 class TNtuple;
  11 class TObjArray;
  12 class AliAODCaloCells;
  13 class AliAODCaloCluster;
  14 class AliAODEvent;
  15 class AliAODTrack;
  16 class AliAODVertex;
  17 class AliEMCALGeometry;
  18 class AliEMCALRecoUtils;
  19 class AliESDCaloCells;
  20 class AliESDCaloCluster;
  21 class AliESDEvent;
  22 class AliESDTrack;
  23 class AliESDVertex;
  24 class AliESDtrackCuts;
  25 class AliMCEvent;
  26 class AliMCParticle;
  27 class AliStaHeader;
  28 class AliStaVertex;
  29
  30 #include "AliAnalysisTaskSE.h"
  31
  32 class AliAnalysisTaskEMCALPi0PbPb : public AliAnalysisTaskSE {
  33  public:
  34   AliAnalysisTaskEMCALPi0PbPb();
  35   AliAnalysisTaskEMCALPi0PbPb(const char *name);
  36   virtual ~AliAnalysisTaskEMCALPi0PbPb();
  37
  38   void         UserCreateOutputObjects();
  39   void         UserExec(Option_t *option);
  40   void         Terminate(Option_t *);
  41
  42   void         SetAsymMax(Double_t asymMax)                   { fAsymMax       = asymMax;   }
  43   void         SetCentrality(const char *n)                   { fCentVar       = n;         }
  44   void         SetCentralityRange(Double_t from, Double_t to) { fCentFrom=from; fCentTo=to; }
  45   void         SetClusName(const char *n)                     { fClusName      = n;         }
  46   void         SetDoAfterburner(Bool_t b)                     { fDoAfterburner = b;         }
  47   void         SetDoTrackMatWithGeom(Bool_t b)                { fDoTrMatGeom   = b;         }
  48   void         SetFillNtuple(Bool_t b)                        { fDoNtuple      = b;         }
  49   void         SetGeoName(const char *n)                      { fGeoName       = n;         }
  50   void         SetGeoUtils(AliEMCALGeometry *geo)             { fGeom          = geo;       }
  51   void         SetIsoDist(Double_t d)                         { fIsoDist       = d;         }
  52   void         SetL0TimeRange(Int_t l, Int_t h)               { fMinL0Time=l; fMaxL0Time=h; }
  53   void         SetMarkCells(const char *n)                    { fMarkCells     = n;         }
  54   void         SetMcMode(Bool_t b)                            { fMcMode        = b;         }
  55   void         SetEmbedMode(Bool_t b)                         { fEmbedMode     = b;         }
  56   void         SetMinClusEnergy(Double_t e)                   { fMinE          = e;         }
  57   void         SetMinEcc(Double_t ecc)                        { fMinEcc        = ecc;       }
  58   void         SetMinErat(Double_t erat)                      { fMinErat       = erat;      }
  59   void         SetMinNClustersPerTrack(Double_t m)            { fMinNClusPerTr = m;         }
  60   void         SetNminCells(Int_t n)                          { fNminCells     = n;         }
  61   void         SetPrimTrackCuts(AliESDtrackCuts *c)           { fPrimTrCuts    = c;         }
  62   void         SetRecoUtils(AliEMCALRecoUtils *reco)          { fReco          = reco;      }
  63   void         SetTrClassNames(const char *n)                 { fTrClassNames  = n;         }
  64   void         SetTrackCuts(AliESDtrackCuts *c)               { fTrCuts        = c;         }
  65   void         SetTrainMode(Bool_t b)                         { fTrainMode     = b;         }
  66   void         SetUseQualFlag(Bool_t b)                       { fUseQualFlag   = b;         }
  67   void         SetVertexRange(Double_t z1, Double_t z2)       { fVtxZMin=z1; fVtxZMax=z2;   }
  68   void         SetDoPhysicsSelection(Bool_t b)                { fDoPSel        = b;         }
  69
  70  protected:
  71   virtual void CalcCaloTriggers();
  72   virtual void CalcClusterProps();
  73   virtual void CalcPrimTracks();
  74   virtual void CalcMcInfo();
  75   virtual void CalcTracks();
  76   virtual void ClusterAfterburner();
  77   virtual void FillCellHists();
  78   virtual void FillClusHists();
  79   virtual void FillNtuple();
  80   virtual void FillOtherHists();
  81   virtual void FillPionHists();
  82   virtual void FillMcHists();
  83   virtual void FillTrackHists();
  84   void         FillVertex(AliStaVertex *v, const AliESDVertex *esdv);
  85   void         FillVertex(AliStaVertex *v, const AliAODVertex *aodv);
  86   Double_t     GetCellIsolation(Double_t cEta, Double_t cPhi, Double_t radius=0.2)                        const;
  87   Double_t     GetCellIsoNxM(Double_t cEta, Double_t cPhi, Int_t N, Int_t M)                              const;
  88   Double_t     GetCellEnergy(const AliVCluster *c)    const;
  89   Double_t     GetMaxCellEnergy(const AliVCluster *c) const { Short_t id=-1; return GetMaxCellEnergy(c,id); }
  90   Double_t     GetMaxCellEnergy(const AliVCluster *c, Short_t &id)                                        const;
  91   Int_t        GetNCells(const AliVCluster *c, Double_t emin=0.)                                          const;
  92   Int_t        GetNCells(Int_t sm, Double_t emin=0.)                                                      const;
  93   void         GetSigma(const AliVCluster *c, Double_t &sigmaMax, Double_t &sigmaMin)                     const;
  94   void         GetSigmaEtaEta(const AliVCluster *c, Double_t &sigmaEtaEta, Double_t &sigmaPhiPhi)         const;
  95   Double_t     GetTrackIsolation(Double_t cEta, Double_t cPhi, Double_t radius=0.2, Double_t pt=0.)       const;
  96   Double_t     GetTrackIsoStrip(Double_t cEta, Double_t cPhi, Double_t dEta=0.015, Double_t dPhi=0.3, Double_t pt=0.)       const;
  97   Double_t     GetTrigEnergy(const AliVCluster *c)                                                        const;
  98   Bool_t       IsShared(const AliVCluster *c)                                                             const;
  99   Bool_t       IsIdPartOfCluster(const AliVCluster *c, Short_t id)                                        const;
 100   void         PrintDaughters(const AliVParticle *p, const TObjArray *arr, Int_t level=0)                 const;
 101   void         PrintDaughters(const AliMCParticle *p, const AliMCEvent *arr, Int_t level=0)               const;
 102   void         PrintTrackRefs(AliMCParticle *p)                                                           const;
 103   void         ProcessDaughters(AliVParticle *p, Int_t index, const TObjArray *arr);
 104   void         ProcessDaughters(AliMCParticle *p, Int_t index, const AliMCEvent *arr);
 105   Double_t     GetSecondMaxCell(AliVCluster *clus);
 106
 107     // input members
 108   TString                fCentVar;                // variable for centrality determination
 109   Double_t               fCentFrom;               // min centrality (def=0)
 110   Double_t               fCentTo;                 // max centrality (def=100)
 111   Double_t               fVtxZMin;                // min primary vertex z (def=-10cm)
 112   Double_t               fVtxZMax;                // max primary vertex z (def=+10cm)
 113   Bool_t                 fUseQualFlag;            // if true use quality flag for centrality
 114   TString                fClusName;               // cluster branch name (def="")
 115   Bool_t                 fDoNtuple;               // if true write out ntuple
 116   Bool_t                 fDoAfterburner;          // if true run after burner
 117   Double_t               fAsymMax;                // maximum energy asymmetry (def=1)
 118   Int_t                  fNminCells;              // minimum number of cells attached to cluster (def=1)
 119   Double_t               fMinE;                   // minimum cluster energy (def=0.1 GeV/c)
 120   Double_t               fMinErat;                // minimum emax/ec ratio (def=0)
 121   Double_t               fMinEcc;                 // minimum eccentricity (def=0)
 122   TString                fGeoName;                // geometry name (def = EMCAL_FIRSTYEARV1)
 123   Double_t               fMinNClusPerTr;          // minimum number of cluster per track (def=50)
 124   Double_t               fIsoDist;                // isolation distance (def=0.2)
 125   TString                fTrClassNames;           // trigger class names
 126   AliESDtrackCuts       *fTrCuts;                 // track cuts
 127   AliESDtrackCuts       *fPrimTrCuts;             // track cuts
 128   Bool_t                 fDoTrMatGeom;            // track matching including geometry
 129   Bool_t                 fTrainMode;              // train mode with minimal number of resources
 130   TString                fMarkCells;              // list of mark cells to monitor
 131   Int_t                  fMinL0Time;              // minimum accepted time for trigger
 132   Int_t                  fMaxL0Time;              // maximum accepted time for trigger
 133   Bool_t                 fMcMode;                 // monte carlo mode
 134   Bool_t                 fEmbedMode;              // embedding mode
 135   AliEMCALGeometry      *fGeom;                   // geometry utils
 136   AliEMCALRecoUtils     *fReco;                   // reco utils
 137   TString                fTrigName;               // trigger name
 138   Bool_t                 fDoPSel;                 // if false then accept all events
 139     // derived members (ie with ! after //)
 140   Bool_t                 fIsGeoMatsSet;           //!indicate that geo matrices are set
 141   ULong64_t              fNEvs;                   //!accepted events
 142   TList                 *fOutput;                 //!container of output histograms
 143   TObjArray             *fTrClassNamesArr;        //!array of trig class names
 144   AliESDEvent           *fEsdEv;                  //!pointer to input esd event
 145   AliAODEvent           *fAodEv;                  //!pointer to input aod event
 146   const TObjArray       *fRecPoints;              //!pointer to rec points (AliAnalysisTaskEMCALClusterizeFast)
 147   const TClonesArray    *fDigits;                 //!pointer to digits     (AliAnalysisTaskEMCALClusterizeFast)
 148   TObjArray             *fEsdClusters;            //!pointer to esd clusters
 149   AliESDCaloCells       *fEsdCells;               //!pointer to esd cells
 150   TObjArray             *fAodClusters;            //!pointer to aod clusters
 151   AliAODCaloCells       *fAodCells;               //!pointer to aod cells
 152   TAxis                 *fPtRanges;               //!pointer to pt ranges
 153   TObjArray             *fSelTracks;              //!pointer to selected tracks
 154   TObjArray             *fSelPrimTracks;          //!pointer to selected primary tracks
 155     // ntuple
 156   TTree                 *fNtuple;                 //!pointer to ntuple
 157   AliStaHeader          *fHeader;                 //!pointer to header
 158   AliStaVertex          *fPrimVert;               //!pointer to primary vertex
 159   AliStaVertex          *fSpdVert;                //!pointer to SPD vertex
 160   AliStaVertex          *fTpcVert;                //!pointer to TPC vertex
 161   TClonesArray          *fClusters;               //!pointer to clusters
 162   TClonesArray          *fTriggers;               //!pointer to triggers
 163   TClonesArray          *fMcParts;                //!pointer to mc particles
 164     // histograms
 165   TH1                   *fHCuts;                  //!histo for cuts
 166   TH1                   *fHVertexZ;               //!histo for vtxz
 167   TH1                   *fHVertexZ2;              //!histo for vtxz after vtx cuts
 168   TH1                   *fHCent;                  //!histo for cent
 169   TH1                   *fHCentQual;              //!histo for cent after quality flag cut
 170   TH1                   *fHTclsBeforeCuts;        //!histo for trigger classes before cuts
 171   TH1                   *fHTclsAfterCuts;         //!histo for trigger classes after cuts
 172
 173     // histograms for cells
 174   TH2                  **fHColuRow;               //!histo for cell column and row
 175   TH2                  **fHColuRowE;              //!histo for cell column and row weight energy
 176   TH1                  **fHCellMult;              //!histo for cell multiplicity in module
 177   TH1                   *fHCellE;                 //!histo for cell energy
 178   TH1                   *fHCellH;                 //!histo for highest cell energy
 179   TH1                   *fHCellM;                 //!histo for mean cell energy (normalized to hit cells)
 180   TH1                   *fHCellM2;                //!histo for mean cell energy (normalized to all cells)
 181   TH1                  **fHCellFreqNoCut;         //!histo for cell frequency without cut
 182   TH1                  **fHCellFreqCut100M;       //!histo for cell frequency with cut 100MeV
 183   TH1                  **fHCellFreqCut300M;       //!histo for cell frequency with cut 300MeV
 184   TH1                  **fHCellFreqE;             //!histo for cell frequency weighted with energy
 185   TH1                  **fHCellCheckE;            //!histo for cell E distribution for given channels
 186     // histograms for clusters
 187   TH1                   *fHClustEccentricity;     //!histo for cluster eccentricity
 188   TH2                   *fHClustEtaPhi;           //!histo for cluster eta vs. phi
 189   TH2                   *fHClustEnergyPt;         //!histo for cluster energy vs. pT
 190   TH2                   *fHClustEnergySigma;      //!histo for cluster energy vs. variance over long axis
 191   TH2                   *fHClustSigmaSigma;       //!histo for sigma vs. lambda_0 comparison
 192   TH2                   *fHClustNCellEnergyRatio; //!histo for cluster n cells vs. energy ratio
 193   TH2                   *fHClustEnergyNCell;      //!histo for cluster energy vs. cluster n cells
 194     // histograms for primary tracks
 195   TH1                   *fHPrimTrackPt;           //!histo for primary track pt
 196   TH1                   *fHPrimTrackEta;          //!histo for primary track eta
 197   TH1                   *fHPrimTrackPhi;           //!histo for primary track phi
 198     // histograms for track matching
 199   TH1                   *fHMatchDr;               //!histo for dR track cluster matching
 200   TH1                   *fHMatchDz;               //!histo for dZ track cluster matching
 201   TH1                   *fHMatchEp;               //!histo for E/p track cluster matching
 202     // histograms for pion candidates
 203   TH2                   *fHPionEtaPhi;            //!histo for pion eta vs. phi
 204   TH2                   *fHPionMggPt;             //!histo for pion mass vs. pT
 205   TH2                   *fHPionMggAsym;           //!histo for pion mass vs. asym
 206   TH2                   *fHPionMggDgg;            //!histo for pion mass vs. opening angle
 207   TH1                   *fHPionInvMasses[21];     //!histos for invariant mass plots
 208     // histograms for MC
 209
 210  private:
 211   AliAnalysisTaskEMCALPi0PbPb(const AliAnalysisTaskEMCALPi0PbPb&);            // not implemented
 212   AliAnalysisTaskEMCALPi0PbPb &operator=(const AliAnalysisTaskEMCALPi0PbPb&); // not implemented
 213
 214   ClassDef(AliAnalysisTaskEMCALPi0PbPb, 12) // Analysis task for neutral pions in Pb+Pb
 215 };
 216 #endif
 217
 218 #ifndef AliStaObjs_h
 219 #define AliStaObjs_h
 220 class AliStaHeader
 221 {
 222  public:
 223   AliStaHeader() : fRun(0), fOrbit(0), fPeriod(0), fBx(0), fL0(0), fL1(0), fL2(0),
 224                    fTrClassMask(0), fTrCluster(0), fOffTriggers(0), fFiredTriggers(),
 225                    fTcls(0), fV0And(0), fIsHT(0), fV0Cent(0), fV0(0), fCl1Cent(0), fCl1(0), fTrCent(0),
 226                    fTr(0), fCqual(-1), fPsi(0), fPsiRes(0), fNSelTr(0), fNSelPrimTr(0), fNSelPrimTr1(0),
 227                    fNSelPrimTr2(0), fNCells(0), fNCells0(0), fNCells01(0), fNCells03(0),
 228                    fNCells1(0), fNCells2(0), fNCells5(0), fNClus(0), fNClus1(0), fNClus2(0), fNClus5(0),
 229                    fMaxCellE(0), fMaxClusE(0), fMaxTrE(0), fNcSM0(0), fNcSM1(0), fNcSM2(0), fNcSM3(0),
 230                    fNcSM4(0), fNcSM5(0), fNcSM6(0),fNcSM7(0),fNcSM8(0),fNcSM9(0) {;}
 231   virtual ~AliStaHeader() {;}
 232
 233   ULong64_t     GetEventId() const {
 234                   return (((ULong64_t)fPeriod << 36) |
 235                           ((ULong64_t)fOrbit  << 12) |
 236                           (ULong64_t)fBx);
 237                 }
 238
 239  public:
 240   Int_t         fRun;            //         run number
 241   UInt_t        fOrbit;          //         orbit number
 242   UInt_t        fPeriod;         //         period number
 243   UShort_t      fBx;             //         bunch crossing id
 244   UInt_t        fL0;             //         l0 trigger bits
 245   UInt_t        fL1;             //         l1 trigger bits
 246   UShort_t      fL2;             //         l2 trigger bits
 247   ULong64_t     fTrClassMask;    //         trigger class mask
 248   UChar_t       fTrCluster;      //         trigger cluster mask
 249   UInt_t        fOffTriggers;    //         fired offline triggers for this event
 250   TString       fFiredTriggers;  //         string with fired triggers
 251   UInt_t        fTcls;           //         custom trigger definition
 252   Bool_t        fV0And;          //         if V0AND (from AliTriggerAnalysis)
 253   Bool_t        fIsHT;           //         if EMCAL L0 (from AliTriggerAnalysis)
 254   Double32_t    fV0Cent;         //[0,0,16] v0 cent
 255   Double32_t    fV0;             //[0,0,16] v0 result used for cent
 256   Double32_t    fCl1Cent;        //[0,0,16] cl1 cent
 257   Double32_t    fCl1;            //[0,0,16] cl1 result used for cent
 258   Double32_t    fTrCent;         //[0,0,16] tr cent
 259   Double32_t    fTr;             //[0,0,16] tr result used for cent
 260   Int_t         fCqual;          //         centrality quality
 261   Double32_t    fPsi;            //[0,0,16] event-plane angle
 262   Double32_t    fPsiRes;         //[0,0,16] event-plane ange resolution
 263   UShort_t      fNSelTr;         //         # selected tracks
 264   UShort_t      fNSelPrimTr;     //         # selected tracks (primary)
 265   UShort_t      fNSelPrimTr1;    //         # selected tracks (primary) pt > 1 GeV/c
 266   UShort_t      fNSelPrimTr2;    //         # selected tracks (primary) pt > 2 GeV/c
 267   UShort_t      fNCells;         //         # cells
 268   UShort_t      fNCells0;        //         # cells > 0.45 GeV
 269   UShort_t      fNCells01;       //         # cells > 0.1  GeV
 270   UShort_t      fNCells03;       //         # cells > 0.3  GeV
 271   UShort_t      fNCells1;        //         # cells > 1    GeV
 272   UShort_t      fNCells2;        //         # cells > 2    GeV
 273   UShort_t      fNCells5;        //         # cells > 5    GeV
 274   UShort_t      fNClus;          //         # clus
 275   UShort_t      fNClus1;         //         # clus > 1 GeV
 276   UShort_t      fNClus2;         //         # clus > 2 GeV
 277   UShort_t      fNClus5;         //         # clus > 5 GeV
 278   Double32_t    fMaxCellE;       //[0,0,16] maximum cell energy
 279   Double32_t    fMaxClusE;       //[0,0,16] maximum clus energy
 280   Double32_t    fMaxTrE;         //[0,0,16] maximum trigger energy
 281   UShort_t      fNcSM0;          //         # cells > 0.1  GeV in SM 0
 282   UShort_t      fNcSM1;          //         # cells > 0.1  GeV in SM 1
 283   UShort_t      fNcSM2;          //         # cells > 0.1  GeV in SM 2
 284   UShort_t      fNcSM3;          //         # cells > 0.1  GeV in SM 3
 285   UShort_t      fNcSM4;          //         # cells > 0.1  GeV in SM 4
 286   UShort_t      fNcSM5;          //         # cells > 0.1  GeV in SM 5
 287   UShort_t      fNcSM6;          //         # cells > 0.1  GeV in SM 6
 288   UShort_t      fNcSM7;          //         # cells > 0.1  GeV in SM 7
 289   UShort_t      fNcSM8;          //         # cells > 0.1  GeV in SM 8
 290   UShort_t      fNcSM9;          //         # cells > 0.1  GeV in SM 9
 291
 292   ClassDef(AliStaHeader,5) // Header class
 293 };
 294
 295 class AliStaVertex
 296 {
 297  public:
 298   AliStaVertex(Double_t x=0, Double_t y=0, Double_t z=0) : fVx(x), fVy(y), fVz(z), fVc(-1), fDisp(0), fZres(0),
 299                                                            fChi2(0), fSt(0), fIs3D(0), fIsZ(0) {;}
 300   virtual ~AliStaVertex() {;}
 301
 302  public:
 303   Double_t      fVx;          //[0,0,16] vertex x
 304   Double_t      fVy;          //[0,0,16] vertex y
 305   Double_t      fVz;          //[0,0,16] vertex z
 306   Double_t      fVc;          //[0,0,16] number of contributors to vertex
 307   Double_t      fDisp;        //[0,0,16] dispersion
 308   Double_t      fZres;        //[0,0,16] z-resolution
 309   Double_t      fChi2;        //[0,0,16] chi2 of fit
 310   Bool_t        fSt;          //         status bit
 311   Bool_t        fIs3D;        //         is vertex from 3D
 312   Bool_t        fIsZ;         //         is vertex from Z only
 313
 314   ClassDef(AliStaVertex,1) // Vertex class
 315 };
 316
 317 class AliStaCluster : public TObject
 318 {
 319  public:
 320     AliStaCluster() : TObject(),
 321                       fE(0), fR(0), fEta(0), fPhi(0), fN(0), fN1(0), fN3(0), fIdMax(-1), fSM(-1), fEmax(0), fE2max(0),
 322                       fTmax(0), fDbc(-1), fDisp(-1), fM20(-1), fM02(-1), fEcc(-1), fSig(-1), fSigEtaEta(-1), fSigPhiPhi(-1),
 323                       fIsTrackM(0), fTrDz(0), fTrDr(-1), fTrEp(0), fTrDedx(0), fTrIso(0), fTrIso1(0), fTrIso2(0),
 324                       fTrIsoD1(0), fTrIso1D1(0), fTrIso2D1(0), fTrIsoD3(0), fTrIso1D3(0), fTrIso2D3(0),fTrIsoStrip(0),
 325                       fCeIso(0), fCeIso1(0), fCeIso3(0), fCeIso4x4(0), fCeIso5x5(0), fCeCore(0), fCeIso3x22(0),
 326                       fIsShared(0), fTrigId(-1), fTrigE(0), fMcLabel(-1), fEmbE(0) {;}
 327
 328  public:
 329   Double32_t    fE;                //[0,0,16] energy
 330   Double32_t    fR;                //[0,0,16] radius (cylinder)
 331   Double32_t    fEta;              //[0,0,16] eta
 332   Double32_t    fPhi;              //[0,0,16] phi
 333   UChar_t       fN;                //         number of cells
 334   UChar_t       fN1;               //         number of cells > 100 MeV
 335   UChar_t       fN3;               //         number of cells > 300 MeV
 336   Short_t       fIdMax;            //         id maximum cell
 337   Char_t        fSM;               //         super module number (from maximum cell)
 338   Double32_t    fEmax;             //[0,0,16] energy of maximum cell
 339   Double32_t    fE2max;            //[0,0,16] energy of second maximum cell
 340   Double32_t    fTmax;             //[0,0,16] time of maximum cell
 341   Double32_t    fDbc;              //[0,0,16] distance to nearest bad channel
 342   Double32_t    fDisp;             //[0,0,16] cluster dispersion, for shape analysis
 343   Double32_t    fM20;              //[0,0,16] 2-nd moment along the main eigen axis
 344   Double32_t    fM02;              //[0,0,16] 2-nd moment along the second eigen axis
 345   Double32_t    fEcc;              //[0,0,16] eccentricity
 346   Double32_t    fSig;              //[0,0,16] sigma
 347   Double32_t    fSigEtaEta;        //[0,0,16] sigma eta-eta
 348   Double32_t    fSigPhiPhi;        //[0,0,16] sigma phi-phi
 349   Bool_t        fIsTrackM;         //         if true then track values are set
 350   Double32_t    fTrDz;             //[0,0,16] dZ to nearest track
 351   Double32_t    fTrDr;             //[0,0,16] dR to nearest track (in x,y)
 352   Double32_t    fTrEp;             //[0,0,16] E/P to nearest track
 353   Double32_t    fTrDedx;           //[0,0,16] dE/dx (TPC signal) to nearest track
 354   Double32_t    fTrIso;            //[0,0,16] track isolation
 355   Double32_t    fTrIso1;           //[0,0,16] track isolation (pt>1GeV/c)
 356   Double32_t    fTrIso2;           //[0,0,16] track isolation (pt>2GeV/c)
 357   Double32_t    fTrIsoD1;          //[0,0,16] track isolation, iso dist 0.25
 358   Double32_t    fTrIso1D1;         //[0,0,16] track isolation (pt>1GeV/c), iso dist 0.1
 359   Double32_t    fTrIso2D1;         //[0,0,16] track isolation (pt>2GeV/c), iso dist 0.1
 360   Double32_t    fTrIsoD3;          //[0,0,16] track isolation, iso dist 0.3
 361   Double32_t    fTrIso1D3;         //[0,0,16] track isolation (pt>1GeV/c), iso dist 0.3
 362   Double32_t    fTrIso2D3;         //[0,0,16] track isolation (pt>2GeV/c), iso dist 0.3
 363   Double32_t    fTrIsoStrip;       //[0,0,16] track isolation strip, dEtaXdPhi=0.015x0.3
 364   Double32_t    fCeIso;            //[0,0,16] cell isolation in R=0.20
 365   Double32_t    fCeIso1;           //[0,0,16] cell isolation in R=0.10
 366   Double32_t    fCeIso3;           //[0,0,16] cell isolation in R=0.30
 367   Double32_t    fCeIso4x4;         //[0,0,16] cell isolation in 4x4 cells
 368   Double32_t    fCeIso5x5;         //[0,0,16] cell isolation in 5x5 cells
 369   Double32_t    fCeCore;           //[0,0,16] cell content in R=0.05
 370   Double32_t    fCeIso3x22;        //[0,0,16] cell isolation in rectangular strip of dEtaXdPhi=0.042x0.308
 371   Bool_t        fIsShared;         //         =true then extends across more than one super module
 372   Short_t       fTrigId;           //         index of matched trigger tower
 373   Double32_t    fTrigE;            //[0,0,16] energy (FEE) of matched trigger tower
 374   Short_t       fMcLabel;          //         index of closest MC particle
 375   Double32_t    fEmbE;             //[0,0,16] sum of energy of embedded (MC) cells in cluster
 376
 377   ClassDef(AliStaCluster,7) // Cluster class
 378 };
 379
 380 class AliStaTrigger : public TObject
 381 {
 382  public:
 383   AliStaTrigger() : TObject(), fE(0), fEta(0), fPhi(0), fIdMax(-1) {}
 384
 385  public:
 386   Double32_t    fE;                //[0,0,16] energy
 387   Double32_t    fEta;              //[0,0,16] eta
 388   Double32_t    fPhi;              //[0,0,16] phi
 389   Short_t       fIdMax;            //         id maximum cell
 390
 391   ClassDef(AliStaTrigger,2) // Trigger class
 392 };
 393
 394 class AliStaPart : public TObject
 395 {
 396  public:
 397   AliStaPart() : TObject(), fPt(0), fEta(0), fPhi(0), fVR(0), fVEta(0), fVPhi(0), fPid(0), fMo(-1), fDet(-2),
 398                  fLab(-1), fNs(0) { memset(fDs,-1,sizeof(Short_t)*99); }
 399
 400   Int_t         OnEmcal() const { return (fDet==8);  }
 401   Int_t         IsSim()   const { return (fDet!=-2); }
 402
 403  public:
 404   Double32_t    fPt;               //[0,0,16] pt
 405   Double32_t    fEta;              //[0,0,16] eta
 406   Double32_t    fPhi;              //[0,0,16] phi
 407   Double32_t    fVR;               //[0,0,16] prod r (cylinder)
 408   Double32_t    fVEta;             //[0,0,16] prod eta
 409   Double32_t    fVPhi;             //[0,0,16] prod phi
 410   Short_t       fPid;              //         pid
 411   Short_t       fMo;               //         index of mother
 412   Short_t       fDet;              //         detector in which particle left trace (8 for EMCAL, see AliTrackReference.h)
 413     // the following must be filled before first usage
 414   Short_t       fLab;              //!        label (index in array)
 415   Short_t       fNs;               //!        number of daughters
 416   Short_t       fDs[99];           //!        daughters
 417
 418   ClassDef(AliStaPart,1) // Particle class
 419 };
 420 #endif