Compatibility with the Root trunk
[u/mrichter/AliRoot.git] / PWGCF / Correlations / DPhi / FourierDecomposition / AliPool.h
1 #ifndef AliPool_h
2 #define AliPool_h
3
4 #include <vector>
5 #include <deque>
6 #include <Rtypes.h>
7 #include <Riostream.h>
8 #include <TObject.h>
9 #include <TFile.h>
10 #include <TMath.h>
11 #include <TSystem.h>
12
13 using std::vector;
14 using std::deque;
15
16
17 class AliMiniTrack;
18
19 // Low-memory event mixing classes:
20 // - AliEvtPoolManager: Maintain 2D vector (z,cent) of AliEvtPools.
21 // - AliEvtPool: collections of sub-events in z and mult/cent bins.
22 // - AliMiniTrack: super-lightweight track "struct" class.
23 //
24 // Stores a buffer of tracks that updates continuously. The track type
25 // contained by the pools can be anything (no inheritance from
26 // AliVParticle, or even TObject, required). To use a track type other
27 // than AliMiniTrack, just redefine the MiniEvent typedef (for example,
28 // using AliESDTracks, or TLorenzVectors).
29 // Pools are updated based on maintaining a minimum fixed
30 // number of tracks. Multiplicity/centrality and z-vertex bins must be
31 // passed in at initialization. For example of implementation, see
32 // $ALICE_ROOT/PWGCF/Correlations/DPhi/FourierDecomposition/AliDhcTask.cxx
33 //
34 // Authors: A. Adare and C. Loizides
35
36 typedef std::vector< AliMiniTrack > MiniEvent;
37
38 class AliMiniTrack
39 {
40  public:
41   AliMiniTrack() : fPt(0), fEta(0), fPhi(0), fSign(0) {};
42   AliMiniTrack(Double_t pt, Double_t eta, Double_t phi, Int_t sign) :
43    fPt(pt), fEta(eta), fPhi(phi), fSign(sign>=0?1:0) {};
44  
45   Float_t Eta()  const { return fEta; }
46   Float_t Phi()  const { return fPhi; }
47   Float_t Pt()   const { return fPt;  }
48   Int_t   Sign() const { if (fSign) return 1; return -1; }
49
50  protected: 
51   Float_t fPt;
52   Float_t fEta;
53   Float_t fPhi;
54   Bool_t  fSign;
55 };
56
57 class AliEvtPool : public TObject
58 {
59  public:
60  AliEvtPool(Int_t d) : 
61    fEvents(0),
62    fNTracksInEvent(0),
63    fEventIndex(0),
64    fMixDepth(d), 
65    fMultMin(-999), 
66    fMultMax(+999), 
67    fZvtxMin(-999), 
68    fZvtxMax(+999), 
69    fWasUpdated(0), 
70    fMultBinIndex(0), 
71     fZvtxBinIndex(0), 
72    fDebug(0), 
73    fTargetTrackDepth(0),
74    fFirstFilled(0),
75    fNTimes(0) {;}
76   
77  AliEvtPool(Int_t d, Double_t multMin, Double_t multMax, 
78             Double_t zvtxMin, Double_t zvtxMax) : 
79    fEvents(0),
80    fNTracksInEvent(0),
81    fEventIndex(0),
82    fMixDepth(d), 
83    fMultMin(multMin), 
84    fMultMax(multMax), 
85    fZvtxMin(zvtxMin),
86    fZvtxMax(zvtxMax),
87    fWasUpdated(0),
88     fMultBinIndex(0), 
89    fZvtxBinIndex(0),
90    fDebug(0),
91    fTargetTrackDepth(0),
92    fFirstFilled(0),
93    fNTimes(0) {;}
94   ~AliEvtPool();
95   
96   Bool_t      EventMatchesBin(Int_t mult,    Double_t zvtx) const;
97   Bool_t      EventMatchesBin(Double_t mult, Double_t zvtx) const;
98   Bool_t      IsReady()                    const { return NTracksInPool() >= fTargetTrackDepth; }
99   Bool_t      IsFirstReady()               const { return fFirstFilled;   }
100   Int_t       GetNTimes()                  const { return fNTimes;        }
101   Int_t       GetCurrentNEvents()          const { return fEvents.size(); }
102   Int_t       GlobalEventIndex(Int_t j)    const;
103   MiniEvent*  GetEvent(Int_t i)            const;
104   Int_t       MultBinIndex()               const { return fMultBinIndex; }
105   Int_t       NTracksInEvent(Int_t iEvent) const;
106   Int_t       NTracksInCurrentEvent()      const { if (fNTracksInEvent.empty()) return 0;  
107                                                    return fNTracksInEvent.back(); }
108   void        PrintInfo()                  const;
109   Int_t       NTracksInPool()              const;
110   Bool_t      WasUpdated()                 const { return fWasUpdated; }
111   Int_t       ZvtxBinIndex()               const { return fZvtxBinIndex; }
112   void        SetDebug(Bool_t b)                 { fDebug = b; }
113   void        SetTargetTrackDepth(Int_t d)       { fTargetTrackDepth = d; }
114   Int_t       SetEventMultRange(Int_t    multMin, Int_t multMax);
115   Int_t       SetEventMultRange(Double_t multMin, Double_t multMax);
116   Int_t       SetEventZvtxRange(Double_t zvtxMin, Double_t zvtxMax);
117   void        SetMultBinIndex(Int_t iM)          { fMultBinIndex = iM; }
118   void        SetZvtxBinIndex(Int_t iZ)          { fZvtxBinIndex = iZ; }
119   Int_t       UpdatePool(MiniEvent* miniEvt);
120   
121 protected:
122   deque< MiniEvent* >   fEvents;              //Pool of events storing Minitracks
123   deque<int>            fNTracksInEvent;      //Tracks in event
124   deque<int>            fEventIndex;          //Original event index
125   Int_t                 fMixDepth;            //Number of evts. to mix with
126   Double_t              fMultMin, fMultMax;   //Track multiplicity bin range
127   Double_t              fZvtxMin, fZvtxMax;   //Event z-vertex bin range
128   Bool_t                fWasUpdated;          //Evt. succesfully passed selection?
129   Int_t                 fMultBinIndex;        //Multiplicity bin
130   Int_t                 fZvtxBinIndex;        //Zvertex bin
131   Int_t                 fDebug;               //If 1 then debug on
132   Int_t                 fTargetTrackDepth;    //Number of tracks, once full
133   Bool_t                fFirstFilled;         //Init to false
134   Int_t                 fNTimes;              //Number of times init. condition reached
135
136   ClassDef(AliEvtPool,1) // Event pool class
137 };
138
139 class AliEvtPoolManager : public TObject
140 {
141 public:
142   AliEvtPoolManager() : 
143     fDebug(0),
144     fNMultBins(0), 
145     fNZvtxBins(0),
146     fEvPool(0),
147     fTargetTrackDepth(0) {;}
148   AliEvtPoolManager(Int_t maxEvts, Int_t minNTracks,
149                     Int_t nMultBins, Double_t *multbins,
150                     Int_t nZvtxBins, Double_t *zvtxbins);
151
152   ~AliEvtPoolManager();
153   
154   // First uses bin indices, second uses the variables themselves.
155   AliEvtPool *GetEventPool(Int_t iMult, Int_t iZvtx) const;
156   AliEvtPool *GetEventPool(Int_t    centVal, Double_t zvtxVal) const;
157   AliEvtPool *GetEventPool(Double_t centVal, Double_t zvtxVal) const;
158
159   Int_t       InitEventPools(Int_t depth, 
160                              Int_t nmultbins, Double_t *multbins, 
161                              Int_t nzvtxbins, Double_t *zvtxbins);
162   void        SetTargetTrackDepth(Int_t d) { fTargetTrackDepth = d;}
163   Int_t       UpdatePools(MiniEvent*);
164   void        SetDebug(Bool_t b) { fDebug = b; }
165
166 protected:
167   Int_t      fDebug;                         // If 1 then debug on
168   Int_t      fNMultBins;                     // number mult bins
169   Int_t      fNZvtxBins;                     // number vertex bins
170   vector< vector<AliEvtPool*> > fEvPool;     // pool in bins of [fMultBin][fZvtxBin]
171   Int_t      fTargetTrackDepth;              // Required track size, same for all pools.
172
173   ClassDef(AliEvtPoolManager,1)
174 };
175 #endif