PWG2/FLOW/AliFlowAnalyser.h

   1 //////////////////////////////////////////////////////////////////////
   2 //
   3 // $Id$
   4 //
   5 // Author: Emanuele Simili
   6 //
   7 //////////////////////////////////////////////////////////////////////
   8 //
   9 // Description: flow analysis for AliFlowEvent(s), adapted from STAR .
  10 // Original Authors:                 Raimond Snellings & Art Poskanzer
  11 //
  12 //////////////////////////////////////////////////////////////////////
  13
  14 #ifndef ALIFLOWANALYSER_H
  15 #define ALIFLOWANALYSER_H
  16
  17 #include <TVector2.h>
  18 #include <TFile.h>
  19 #include "AliFlowConstants.h"
  20
  21 class TH1F;
  22 class TH1D;
  23 class TH2F;
  24 class TH2D;
  25 class TH3F;
  26 class TProfile;
  27 class TProfile2D;
  28 class TOrdCollection;
  29
  30 class AliFlowTrack;
  31 class AliFlowV0;
  32 class AliFlowEvent;
  33 class AliFlowSelection;
  34 class Flow;
  35
  36 class AliFlowAnalyser {
  37
  38
  39 public:
  40
  41   AliFlowAnalyser(const AliFlowSelection* flowSelect = 0);      // Constructor with selection object (default selection if no one given)
  42   virtual  ~AliFlowAnalyser();                                  // Default destructor (no actions)
  43
  44  // Steps of the flow analysis
  45   Bool_t   Init() ;                                             // Books histograms for flow analysis
  46   Bool_t   Finish() ;                                           // Saves histograms, Closes stuff
  47
  48  // Analysis of 1 event (can be called from outside)
  49   Bool_t   Analyse(AliFlowEvent* flowEvent = 0) ;               // Fills the defaults histograms (init them first!) and performs the calculation for the given event
  50
  51  // Resolution corrections to v_n (call it at the end of the evts loop)
  52   Bool_t   Resolution() ;                                       // Calculates resolution and mean flow values
  53
  54  // Weights calculation and saving (call it at the end of the evts loop)
  55   void     Weightening() ;                                      // Calculates weights and fills PhiWgt histograms
  56
  57  // Options
  58   void     SetEtaSub(Bool_t es = kTRUE)                         { fEtaSub = es ; }              // Set eta subevents
  59   void     SetV1Ep1Ep2(Bool_t v1Ep1Ep2 = kTRUE)                 { fV1Ep1Ep2 = v1Ep1Ep2 ; }      // Switches the v_1{EP1,EP2} calculation on/off
  60   void     SetShuffle(Bool_t sh = kTRUE)                        { fShuffle = sh ; }             // Set to re-shuffle evt tracks
  61   void     SetUsePhiWgt(Bool_t pw = kTRUE)                      { fReadPhiWgt = pw ; }          // Set to use phi weights (true by default...if there)
  62   void     SetUseBayWgt(Bool_t bw = kTRUE)                      { fBayWgt = bw ; }              // Set to use bayesian weights for p.id. (false by default)
  63   void     SetUsePtWgt(Bool_t ptw = kTRUE)                      { fPtWgt = ptw ; }              // uses pT as a weight for RP determination
  64   void     SetUseEtaWgt(Bool_t etw = kTRUE)                     { fEtaWgt = etw ; }             // uses eta as a weight for RP determination
  65   void     SetUseOnePhiWgt(Bool_t opw = kTRUE)                  { fOnePhiWgt = opw ; }          // just one wgt histogram
  66   void     SetUseFirstLastPhiWgt(Bool_t flw = kTRUE)            { fOnePhiWgt = !flw ; }         // uses 3 wgt histograms
  67   void     SetFlowForV0(Bool_t v0 = kTRUE)                      { fV0loop = v0 ; }              // Enables Flow study for v0
  68   void     SetTrackLoop(Bool_t trkl = kTRUE)                    { fTrackLoop = trkl ; }         // Enables Tracks loop (keep it kTRUE)
  69   //void     SetDebugg(Int_t db = 1) ;                          // set the cout's for debug (default is 1)
  70
  71  // Histograms
  72   void     SetPtRangevEta(Float_t lo, Float_t hi)               { fPtRangevEta[0] = lo ; fPtRangevEta[1] = hi ; }  // Sets the pt range for the v(eta) histograms.
  73   void     SetEtaRangevPt(Float_t lo, Float_t hi)               { fEtaRangevPt[0] = lo ; fEtaRangevPt[1] = hi ; }  // Sets the |eta| range for the v(pt) histograms.
  74   //void     SetMaxLabel(Int_t lab = 100)                       { fMaxLabel = lab ; }
  75
  76  // Output
  77   void     SetHistFileName(TString name)                        { fHistFileName = name ; }      // Sets output file name
  78   TString  GetHistFileName() const                              { return fHistFileName ; }
  79
  80  // Phi Weights
  81   TString  GetWgtFileName() const                               { return (TString)fPhiWgtFile->GetName() ; }
  82   void     FillWgtArrays(TFile* wgtFile) ;                      // Loads phi & bayesian weights from file (flowPhiWgt.hist.root) and fills the arrays
  83
  84  // Results
  85   Float_t  GetRunBayesian(Int_t nPid=2, Int_t selN=0) ;         // Normalized Particle abundance (all events up to here)
  86   void     PrintRunBayesian(Int_t selN=0) ;                     // Prints the normalized Particle abundance (up to here)
  87   void     PrintEventQuantities() ;                             // Prints event by event calculated quantities
  88   Float_t  Res(Int_t eventN, Int_t harN) const                  { return fRes[eventN][harN]; }    // Returns the calculated resolution for the RP
  89   Float_t  ResErr(Int_t eventN, Int_t harN) const               { return fResErr[eventN][harN]; } // Returns the estimated error on the resolution
  90
  91
  92  protected:
  93
  94  // Internal methods to fill the histogram
  95   Bool_t   FillFromFlowEvent(AliFlowEvent* fFlowEvent) ;        // Fills internal variables and array from Flow Events
  96   void     FillEventHistograms(AliFlowEvent* fFlowEvent) ;      // Fills Events' histograms (from AliFlowEvent)
  97   void     FillParticleHistograms(TObjArray* fFlowTracks) ;     // Fills Tracks' histograms (from AliFlowTrack)
  98   void     FillV0Histograms(TObjArray* fFlowV0s) ;              // Fills V0s' histograms
  99   Int_t    HarmonicsLoop(AliFlowTrack* fFlowTrack) ;            // Harmonics & Selections histograms (from AliFlowTracks)
 100   //void     FillLabels() ;                                     // fills an histogram of Labels (the ones from ESD)
 101
 102  // Weights plugged to the event
 103   void     FillBayesianWgt(AliFlowEvent* fFlowEvent) ;          // Plugs the bayesian weights (fBayesianWgt[0]*) into the AliFlowEvent
 104   void     FillEvtPhiWgt(AliFlowEvent* fFlowEvent) ;            // Plugs the PhiWeights (fPhiWgt*, etc.) into the AliFlowEvent
 105
 106  // Resolution Calculation
 107   Double_t Chi(Double_t res) ;                                  // Calculates chi from the event plane resolution
 108   Double_t ResEventPlane(Double_t chi) ;                        // Calculates the event plane resolution as a function of chi
 109   Double_t ResEventPlaneK2(Double_t chi) ;                      // Calculates the event plane resolution as a function of chi for the case k=2.
 110   Double_t ResEventPlaneK3(Double_t chi) ;                      // Calculates the event plane resolution as a function of chi for the case k=3.
 111   Double_t ResEventPlaneK4(Double_t chi) ;                      // Calculates the event plane resolution as a function of chi for the case k=4.
 112
 113
 114  private:
 115
 116  // Flags
 117   Bool_t           fTrackLoop ;                                 //! tracks main loop
 118   Bool_t           fV0loop ;                                    //! correlation analysis is done also for neutral secundary vertex
 119   Bool_t           fShuffle ;                                   //! to randomly reshuffle tracks
 120   Bool_t           fV1Ep1Ep2;                                   //! Flag for v_1{EP1,EP2} calculation on/off
 121   Bool_t           fEtaSub;                                     //! eta subevents
 122   Bool_t           fReadPhiWgt ;                                //! Phi Weights are applied to Phi distrib. (default is false)
 123   Bool_t           fBayWgt ;                                    //! Bayesian Weights are applied to P.Id. (default is false)
 124   Bool_t           fRePid ;                                     //! Re-Calculates the P.Id. basing on the bayesian wgts (if plugged in)
 125
 126   Bool_t           fPtWgt ;                                     //! flag to use pT as a weight for RP determination
 127   Bool_t           fEtaWgt ;                                    //! flag to use eta as a weight for RP determination
 128   Bool_t           fOnePhiWgt ;                                 //! if kTRUE: just one phi-wgt histogram, if kFALSE: three phi-wgt histogram (TPC+,TPC-,cross)
 129
 130  // Files
 131   TFile*           fHistFile ;                                  //! histograms file (output)
 132   TFile*           fPhiWgtFile ;                                //! phi weight file
 133   TString          fHistFileName ;                              //! Output File Name (histograms from flow analysis)
 134   //TString        fFlowEvtFileName ;                           //! Input file name (Flow Events)
 135
 136  // enumerators
 137   Int_t            fEventNumber ;                               //! progressive enumeration of AliFlowEvents
 138   Int_t            fTrackNumber ;                               //! progressive enumeration of AliFlowTracks
 139   Int_t            fV0Number ;                                  //! progressive enumeration of AliFlowV0s
 140   //Int_t          fNumberOfEvents ;                            //! total number of AliFlowEvents in file
 141   Int_t            fNumberOfTracks ;                            //! total number of tracks in the current event
 142   Int_t            fNumberOfV0s ;                               //! total number of v0s in the current event
 143   Int_t            fPidId ;                                     //! Particle Id hypothesys of the track (0..4 for e,mu,pi,k,p)
 144
 145  // Internal pointers
 146   AliFlowEvent*     fFlowEvent ;                                //! pointer to AliFlowEvent
 147   AliFlowTrack*     fFlowTrack ;                                //! pointer to AliFlowTrack
 148   AliFlowV0*        fFlowV0 ;                                   //! pointer to AliFlowV0
 149   AliFlowSelection* fFlowSelect ;                               //! selection object
 150   TObjArray*        fFlowTracks ;                               //! pointer to the TrackCollection
 151   TObjArray*        fFlowV0s ;                                  //! pointer to the V0Collection
 152
 153   Float_t           fVertex[3] ;                                //! Event's Vertex position
 154
 155  // For weights
 156   Int_t             fPhiBins ;                                  //! n. of phi bins
 157   Float_t           fPhiMin ;                                   //! wgt histo range (phi)
 158   Float_t           fPhiMax ;                                   //! wgt histo range (phi)
 159
 160   Flow::PhiWgt_t    fPhiWgt ;                                   //! PhiWgt Array (all TPC)
 161   Flow::PhiWgt_t    fPhiWgtPlus ;                               //! PhiWgt Array (TPC+)
 162   Flow::PhiWgt_t    fPhiWgtMinus ;                              //! PhiWgt Array (TPC-)
 163   Flow::PhiWgt_t    fPhiWgtCross ;                              //! PhiWgt Array (TPC/)
 164
 165  // For bayesian weights
 166   Double_t          fBayesianWgt[Flow::nSels][Flow::nPid] ;     //! Bayesian weights (expected particle abundance)
 167
 168 #ifndef __CINT__
 169   TVector2 fQ[Flow::nSels][Flow::nHars];                        //! flow vector
 170   Float_t  fPsi[Flow::nSels][Flow::nHars];                      //! event plane angle
 171   UInt_t   fMult[Flow::nSels][Flow::nHars];                     //! multiplicity
 172   Float_t  fQnorm[Flow::nSels][Flow::nHars];                    //! Q/Sqrt(Mult)
 173   TVector2 fQSub[Flow::nSubs][Flow::nSels][Flow::nHars];        //! flow vector subs
 174   Float_t  fPsiSub[Flow::nSubs][Flow::nSels][Flow::nHars];      //! plane angle of subevents
 175   UInt_t   fMultSub[Flow::nSubs][Flow::nSels][Flow::nHars];     //! multiplicity subs
 176   Float_t  fRes[Flow::nSels][Flow::nHars];                      //! event plane resolution
 177   Float_t  fResErr[Flow::nSels][Flow::nHars];                   //! event plane resolution error
 178 #endif /*__CINT__*/
 179
 180  // for Histograms
 181   TString           fLabel ;                                    //! label axis : rapidity or pseudorapidity
 182   Float_t           fEtaMin ;                                   //! histo range (eta)
 183   Float_t           fEtaMax ;                                   //! histo range (eta)
 184   Float_t           fPtMin ;                                    //! histo range (pt)
 185   Float_t           fPtMax ;                                    //! histo range (pt)
 186   Float_t           fPtMaxPart ;                                //! max pt for _part histo
 187   Int_t             fEtaBins ;                                  //! n. of eta bins
 188   Int_t             fPtBins ;                                   //! n. of pt bins
 189   Int_t             fPtBinsPart ;                               //! n. of pt bins for _part histo
 190   Float_t           fPtRangevEta[2] ;                           //! pt range for the v(eta) histograms.
 191   Float_t           fEtaRangevPt[2] ;                           //! |eta| range for the v(pt) histograms.
 192   Int_t             fMaxLabel ;                                 //! for the MC labels histogram (max bin)
 193
 194   TOrdCollection*   fPhiWgtHistList ;                           //! Weights:  histogram list
 195   TOrdCollection*   fVnResHistList ;                            //! Resolution and Vn:  histogram list
 196
 197 // for Single histograms
 198
 199  // *****************
 200  // EVENTs HISTOGRAMS
 201  // *****************
 202   TH1F*     fHistTrigger;                                  //!
 203   TH1F*     fHistMult;                                     //!
 204   TH1F*     fHistV0Mult;                                   //!
 205   TH1F*     fHistOrigMult;                                 //!
 206   TH1F*     fHistMultOverOrig;                             //!
 207   TH1F*     fHistMultEta;                                  //!
 208   TH1F*     fHistCent;                                     //!
 209   TH1F*     fHistVertexZ;                                  //!
 210   TH2F*     fHistVertexXY2D;                               //!
 211   TH2F*     fHistEnergyZDC;                                //!
 212   TH1F*     fHistPartZDC;                                  //!
 213   TProfile* fHistPidMult;                                  //!
 214   TH1F*     fHistBayPidMult;                               //!
 215   TH1F*     fHistEtaSym;                                   //!          // ...part also
 216   TH1F*     fHistEtaSymPart;                               //!
 217   TH2F*     fHistEtaSymVerZ2D;                             //!          // ...part also
 218   TH2F*     fHistEtaSymVerZ2DPart;                         //!
 219  // selected (TR & V0)
 220   TH1F*     fHistMultPart;                                 //!
 221   TH1F*     fHistV0MultPart;                               //!
 222   TH1F*     fHistBayPidMultPart;                           //!
 223   TH1F*     fHistMultPartUnit;                             //!
 224
 225  // *****************
 226  // TRACKs HISTOGRAMS (all tracks)
 227  // *****************
 228   TH1F*     fHistPtot ;                                    //!
 229   TH1F*     fHistPt ;                                      //!
 230   TH1F*     fHistCharge;                                   //!
 231   TH1F*     fHistDcaGlobal;                                //!
 232   TH1F*     fHistDca;                                      //!
 233   TH1F*     fHistTransDca;                                 //!
 234   TH1F*     fHistChi2;                                     //!
 235   TH1F*     fHistLenght;                                   //!
 236   TH1F*     fHistInvMass ;                                 //!
 237   TH1F*     fHistFitOverMax;                               //!
 238   TH2D*     fHistPhiPtCon ;                                //!
 239   TH2D*     fHistPhiPtUnc ;                                //!
 240   TH2D*     fHistPtPhiPos ;                                //!
 241   TH2D*     fHistPtPhiNeg ;                                //!
 242   TH3F*     fHistAllEtaPtPhi3D;                            //!
 243   TProfile* fHistCosPhi;                                   //!
 244   TH2F*     fHistPidPt;                                    //!
 245   TH1F*     fHistPhi ;                                     //!
 246   TH1F*     fHistPhiCons ;                                 //!
 247   TH2D*     fHistYieldAll2D;                               //!
 248   TH2D*     fHistYieldCon2D;                               //!
 249   TH2D*     fHistYieldUnc2D;                               //!
 250   TH3F*     fHistConsEtaPtPhi3D;                           //!
 251   TH3F*     fHistGlobEtaPtPhi3D;                           //!
 252   TH3F*     fHistUncEtaPtPhi3D ;                           //!
 253   // fit & dE/dX for each detector (all tracks)
 254   TH1F*     fHistChi2ITS;                                  //!
 255   TH1F*     fHistChi2normITS;                              //!
 256   TH1F*     fHistFitPtsITS;                                //!
 257   TH1F*     fHistMaxPtsITS;                                //!
 258   TH2F*     fHistMeanDedxPos2DITS;                         //!
 259   TH2F*     fHistMeanDedxNeg2DITS;                         //!
 260   // -
 261   TH1F*     fHistChi2TPC;                                  //!
 262   TH1F*     fHistChi2normTPC;                              //!
 263   TH1F*     fHistFitPtsTPC;                                //!
 264   TH1F*     fHistMaxPtsTPC;                                //!
 265   TH1F*     fHistFitOverMaxTPC;                            //!
 266   TH2F*     fHistMeanDedxPos2D;                            //!
 267   TH2F*     fHistMeanDedxNeg2D;                            //!
 268   // -
 269   TH1F*     fHistChi2TRD;                                  //!
 270   TH1F*     fHistChi2normTRD;                              //!
 271   TH1F*     fHistFitPtsTRD;                                //!
 272   TH1F*     fHistMaxPtsTRD;                                //!
 273   TH2F*     fHistMeanDedxPos2DTRD;                         //!
 274   TH2F*     fHistMeanDedxNeg2DTRD;                         //!
 275   // -
 276   TH1F*     fHistChi2TOF;                                  //!
 277   TH1F*     fHistChi2normTOF;                              //!
 278   TH1F*     fHistFitPtsTOF;                                //!
 279   TH1F*     fHistMaxPtsTOF;                                //!
 280   TH2F*     fHistMeanDedxPos2DTOF;                         //!
 281   TH2F*     fHistMeanDedxNeg2DTOF;                         //!
 282   // detector response for particle type (all tracks, based on Pid)
 283   TH2F*     fHistMeanTPCPiPlus ;                           //!
 284   TH2F*     fHistMeanTPCPiMinus ;                          //!
 285   TH2F*     fHistMeanTPCProton ;                           //!
 286   TH2F*     fHistMeanTPCPbar ;                             //!
 287   TH2F*     fHistMeanTPCKplus ;                            //!
 288   TH2F*     fHistMeanTPCKminus ;                           //!
 289   TH2F*     fHistMeanTPCDeuteron ;                         //!
 290   TH2F*     fHistMeanTPCAntiDeuteron ;                     //!
 291   TH2F*     fHistMeanTPCPositron ;                         //!
 292   TH2F*     fHistMeanTPCElectron ;                         //!
 293   TH2F*     fHistMeanTPCMuonPlus ;                         //!
 294   TH2F*     fHistMeanTPCMuonMinus ;                        //!
 295   // -
 296   TH2F*     fHistMeanITSPiPlus ;                           //!
 297   TH2F*     fHistMeanITSPiMinus ;                          //!
 298   TH2F*     fHistMeanITSProton ;                           //!
 299   TH2F*     fHistMeanITSPbar ;                             //!
 300   TH2F*     fHistMeanITSKplus ;                            //!
 301   TH2F*     fHistMeanITSKminus ;                           //!
 302   TH2F*     fHistMeanITSDeuteron ;                         //!
 303   TH2F*     fHistMeanITSAntiDeuteron ;                     //!
 304   TH2F*     fHistMeanITSPositron ;                         //!
 305   TH2F*     fHistMeanITSElectron ;                         //!
 306   TH2F*     fHistMeanITSMuonPlus ;                         //!
 307   TH2F*     fHistMeanITSMuonMinus ;                        //!
 308   // -
 309   TH2F*     fHistMeanTOFPiPlus ;                           //!
 310   TH2F*     fHistMeanTOFPiMinus ;                          //!
 311   TH2F*     fHistMeanTOFProton ;                           //!
 312   TH2F*     fHistMeanTOFPbar ;                             //!
 313   TH2F*     fHistMeanTOFKplus ;                            //!
 314   TH2F*     fHistMeanTOFKminus ;                           //!
 315   TH2F*     fHistMeanTOFDeuteron ;                         //!
 316   TH2F*     fHistMeanTOFAntiDeuteron ;                     //!
 317   TH2F*     fHistMeanTOFPositron ;                         //!
 318   TH2F*     fHistMeanTOFElectron ;                         //!
 319   TH2F*     fHistMeanTOFMuonPlus ;                         //!
 320   TH2F*     fHistMeanTOFMuonMinus ;                        //!
 321   // -
 322   TH2F*     fHistMeanTRDPiPlus ;                           //!
 323   TH2F*     fHistMeanTRDPiMinus ;                          //!
 324   TH2F*     fHistMeanTRDProton ;                           //!
 325   TH2F*     fHistMeanTRDPbar ;                             //!
 326   TH2F*     fHistMeanTRDKplus ;                            //!
 327   TH2F*     fHistMeanTRDKminus ;                           //!
 328   TH2F*     fHistMeanTRDDeuteron ;                         //!
 329   TH2F*     fHistMeanTRDAntiDeuteron ;                     //!
 330   TH2F*     fHistMeanTRDPositron ;                         //!
 331   TH2F*     fHistMeanTRDElectron ;                         //!
 332   TH2F*     fHistMeanTRDMuonPlus ;                         //!
 333   TH2F*     fHistMeanTRDMuonMinus ;                        //!
 334   // pid probability for all particle (all tracks)
 335   TH1F*     fHistPidPiPlus;                                //!
 336   TH1F*     fHistPidPiMinus;                               //!
 337   TH1F*     fHistPidProton;                                //!
 338   TH1F*     fHistPidAntiProton;                            //!
 339   TH1F*     fHistPidKplus;                                 //!
 340   TH1F*     fHistPidKminus;                                //!
 341   TH1F*     fHistPidDeuteron;                              //!
 342   TH1F*     fHistPidAntiDeuteron;                          //!
 343   TH1F*     fHistPidElectron;                              //!
 344   TH1F*     fHistPidPositron;                              //!
 345   TH1F*     fHistPidMuonMinus;                             //!
 346   TH1F*     fHistPidMuonPlus;                              //!
 347   // pid probability for particle type (all tracks, based on Pid)
 348   TH1F*     fHistPidPiPlusPart;                            //!
 349   TH1F*     fHistPidPiMinusPart;                           //!
 350   TH1F*     fHistPidProtonPart;                            //!
 351   TH1F*     fHistPidAntiProtonPart;                        //!
 352   TH1F*     fHistPidKplusPart;                             //!
 353   TH1F*     fHistPidKminusPart;                            //!
 354   TH1F*     fHistPidDeuteronPart;                          //!
 355   TH1F*     fHistPidAntiDeuteronPart;                      //!
 356   TH1F*     fHistPidElectronPart;                          //!
 357   TH1F*     fHistPidPositronPart;                          //!
 358   TH1F*     fHistPidMuonMinusPart;                         //!
 359   TH1F*     fHistPidMuonPlusPart;                          //!
 360   // MC labels from the simulation (all tracks)
 361   TH2F*     mLabHist;                                      //!
 362  // *****************
 363  // selected TRACKS
 364  // *****************
 365   TProfile* fHistBinEta;                                   //!
 366   TProfile* fHistBinPt;                                    //!
 367   //
 368   TH3F*     fHistEtaPtPhi3DPart ;                          //!
 369   TH2D*     fHistYieldPart2D;                              //!
 370   TH1F*     fHistDcaGlobalPart ;                           //!
 371   TH1F*     fHistInvMassPart ;                             //!
 372   TH3F*     fHistEtaPtPhi3DOut ;                           //!
 373   TH2D*     fHistYieldOut2D;                               //!
 374   TH1F*     fHistDcaGlobalOut ;                            //!
 375   TH1F*     fHistInvMassOut ;                              //!
 376   TH3F*     fHistMeanDedxPos3DPart ;                       //!
 377   TH3F*     fHistMeanDedxNeg3DPart ;                       //!
 378   TH3F*     fHistMeanDedxPos3DPartITS ;                    //!
 379   TH3F*     fHistMeanDedxNeg3DPartITS ;                    //!
 380 //
 381
 382  // *****************
 383  // V0s HISTOGRAMS (all v0s)
 384  // *****************
 385   TH1F*     fHistV0Mass;                                   //!
 386   TH3F*     fHistV0EtaPtPhi3D;                             //!
 387   TH2D*     fHistV0YieldAll2D;                             //!
 388   TH2D*     fHistV0PYall2D;                                //!
 389   TH1F*     fHistV0Dca;                                    //!
 390   TH1F*     fHistV0Chi2;                                   //!
 391   TH1F*     fHistV0Lenght;                                 //!
 392   TH1F*     fHistV0Sigma;                                  //!
 393   TProfile* fHistV0CosPhi;                                 //!
 394   TH2D*     fHistV0MassPtSlices;                           //!
 395  // *****************
 396  // selected V0s
 397  // *****************
 398   TProfile* fHistV0BinEta;                                 //!
 399   TProfile* fHistV0BinPt;                                  //!
 400   TProfile* fHistV0sbBinEta;                               //!
 401   TProfile* fHistV0sbBinPt;                                //!
 402   //
 403   TH1F*     fHistV0MassWin ;                               //!
 404   TH3F*     fHistV0EtaPtPhi3DPart ;                        //!
 405   TH2D*     fHistV0YieldPart2D;                            //!
 406   TH1F*     fHistV0DcaPart ;                               //!
 407   TH1F*     fHistV0LenghtPart ;                            //!
 408   TH1F*     fHistV0sbMassSide ;                            //!
 409   TH3F*     fHistV0sbEtaPtPhi3DPart ;                      //!
 410   TH2D*     fHistV0sbYieldPart2D;                          //!
 411   TH1F*     fHistV0sbDcaPart ;                             //!
 412   TH1F*     fHistV0sbLenghtPart ;                          //!
 413
 414 // for each harmonic, each selection, and each sub-event
 415
 416  // *****************
 417  // SUB-EVENTs HISTOGRAMS
 418  // *****************
 419   struct histSubHars {
 420    TH1F*     fHistPsiSubs;
 421   };
 422   struct histSubs;
 423   friend struct histSubs;
 424   struct histSubs {
 425    struct histSubHars fHistSubHar[Flow::nHars];
 426   };
 427   struct histSubs fHistSub[Flow::nSels*Flow::nSubs];        //!
 428
 429 // for each harmonic and each selection
 430
 431   struct histFullHars
 432   {
 433    // weights
 434     TH1D*       fHistPhiPlus;
 435     TH1D*       fHistPhiMinus;
 436     TH1D*       fHistPhiAll;
 437     TH1D*       fHistPhiWgtPlus;
 438     TH1D*       fHistPhiWgtMinus;
 439     TH1D*       fHistPhiWgtAll;
 440     TH1D*       fHistPhiFlatPlus;
 441     TH1D*       fHistPhiFlatMinus;
 442     TH1D*       fHistPhiFlatAll;
 443     TH1D*       fHistPhi;
 444     TH1D*       fHistPhiWgt;
 445     TH1D*       fHistPhiFlat;
 446    // flow (events)
 447     TH1F*       fHistPsi;
 448     TH1F*       fHistPsiSubCorr;
 449     TH1F*       fHistPsiSubCorrDiff;
 450     TH1F*       fHistPsiDiff;
 451     TH1F*       fHistMult;
 452     TH1F*       fHistQnorm;
 453    // flow (tracks)
 454     TH1F*       fHistPhiCorr;
 455     TProfile2D* fHistvObs2D;
 456     TProfile*   fHistvObsEta;
 457     TProfile*   fHistvObsPt;
 458     TH2D*       fHistv2D;
 459     TH1D*       fHistvEta;
 460     TH1D*       fHistvPt;
 461    // flow (v0s)
 462     TH1F*       fHistV0PhiCorr;
 463     TProfile2D* fHistV0vObs2D;
 464     TProfile*   fHistV0vObsEta;
 465     TProfile*   fHistV0vObsPt;
 466     TH2D*       fHistV0v2D;
 467     TH1D*       fHistV0vEta;
 468     TH1D*       fHistV0vPt;
 469    // flow (v0s sidebands)
 470     TProfile*   fHistV0sbvObsEtaSx ;
 471     TProfile*   fHistV0sbvObsPtSx ;
 472     TProfile*   fHistV0sbvObsEtaDx ;
 473     TProfile*   fHistV0sbvObsPtDx ;
 474     TH1F*       fHistV0sbPhiCorr ;
 475     TProfile2D* fHistV0sbvObs2D ;
 476     TProfile*   fHistV0sbvObsEta ;
 477     TProfile*   fHistV0sbvObsPt ;
 478     TH2D*       fHistV0sbv2D ;
 479     TH1D*       fHistV0sbvEta ;
 480     TH1D*       fHistV0sbvPt ;
 481    // check (tracks used for R.P.)
 482     TH1F*       fHistYieldPt ;
 483     TH3F*       fHistEtaPtPhi3D ;
 484     TH2D*       fHistYield2D ;
 485     TH1F*       fHistDcaGlob ;
 486    // check (tracks excluded)
 487     TH1F*       fHistYieldPtout;
 488     TH3F*       fHistEtaPtPhi3Dout ;
 489     TH2D*       fHistYield2Dout ;
 490     TH1F*       fHistDcaGlobout ;
 491   };
 492
 493 // for each selection
 494
 495   struct histFulls;
 496   friend struct histFulls;
 497   struct histFulls
 498   {
 499    TH1F*     fHistBayPidMult;
 500   // flow (events)
 501    TProfile* fHistCos;
 502    TH1F*     fHistRes;
 503    TProfile* fHistvObs;
 504    TH1D*     fHistv;
 505    TProfile* fHistV0vObs;
 506    TProfile* fHistV0sbvObsSx;
 507    TProfile* fHistV0sbvObsDx;
 508    TH1D*     fHistV0v;
 509   // wgt, evts, trks, v0s (as defined above)
 510    struct histFullHars  fHistFullHar[Flow::nHars];
 511   };
 512   struct histFulls fHistFull[Flow::nSels];                     //!
 513
 514   ClassDef(AliFlowAnalyser,0)              // macro for rootcint
 515 };
 516
 517 #endif
 518
 519
 520
 521 // lame = not productive; poorly designed; uncool ...