Compatibility with the Root trunk
[u/mrichter/AliRoot.git] / PWGCF / Correlations / DPhi / FourierDecomposition / AliPool.cxx
1 #include "AliPool.h"
2
3 // ===================================================================
4 //                             AliEvtPool
5 // ===================================================================
6
7 using std::cout;
8 using std::endl;
9
10 ClassImp(AliEvtPool)
11
12 AliEvtPool::~AliEvtPool()
13 {
14   while (!fEvents.empty()) {
15     MiniEvent* fe= fEvents.front();
16     delete fe;
17     fe = 0;
18     fEvents.pop_front();
19   }
20 }
21
22 void 
23 AliEvtPool::PrintInfo() const
24 {
25   cout << Form("%20s: %d events", "Pool capacity", fMixDepth) << endl;
26   cout << Form("%20s: %d events, %d tracks", "Current size", 
27                GetCurrentNEvents(), NTracksInPool()) << endl;
28   cout << Form("%20s: %.1f to %.1f", "Sub-event mult.", fMultMin, fMultMax) << endl;
29   cout << Form("%20s: %.1f to %.1f", "Z-vtx range", fZvtxMin, fZvtxMax) << endl;
30
31   return;
32 }
33
34 Bool_t 
35 AliEvtPool::EventMatchesBin(Int_t mult, Double_t zvtx) const
36 {
37   return EventMatchesBin((Double_t) mult, zvtx);
38 }
39
40 Bool_t 
41 AliEvtPool::EventMatchesBin(Double_t mult, Double_t zvtx) const
42 {
43   // Lower bin limit included; upper limit excluded.
44
45   Bool_t multOK = (mult >= fMultMin && mult < fMultMax);
46   Bool_t zvtxOK = (zvtx >= fZvtxMin && zvtx < fZvtxMax);
47   return (multOK && zvtxOK);
48 }
49
50 Int_t 
51 AliEvtPool::NTracksInPool() const
52 {
53   // Number of tracks for this cent, zvtx bin; possibly includes many events.
54
55   Int_t ntrk=0;
56   for (Int_t i=0; i<(Int_t)fEvents.size(); ++i) {
57     ntrk += fNTracksInEvent.at(i);
58   }
59   return ntrk;
60 }
61
62 Int_t
63 AliEvtPool::SetEventMultRange(Int_t multMin, Int_t multMax)
64 {
65   fMultMin = (Double_t)multMin;
66   fMultMax = (Double_t)multMax;
67   return 0;
68 }
69
70 Int_t
71 AliEvtPool::SetEventMultRange(Double_t multMin, Double_t multMax)
72 {
73   fMultMin = multMin;
74   fMultMax = multMax;
75   return 0;
76 }
77
78 Int_t
79 AliEvtPool::SetEventZvtxRange(Double_t zvtxMin, Double_t zvtxMax)
80 {
81   fZvtxMin = zvtxMin;
82   fZvtxMax = zvtxMax;
83   return 0;
84 }
85
86 Int_t
87 AliEvtPool::GlobalEventIndex(Int_t j) const
88 {
89   // Index returned from passing local pool event index.
90
91   if (j < 0 || j >= (Int_t)fEventIndex.size()) {
92     cout << "ERROR in AliEvtPool::GlobalEventIndex(): "
93          << " Invalid index " << j << endl;
94     return -99;
95   }
96   return fEventIndex.at(j);
97 }
98
99 Int_t
100 AliEvtPool::UpdatePool(MiniEvent* miniEvt)
101 {
102   // A rolling buffer (a double-ended queue) is updated by removing
103   // the oldest event, and appending the newest.
104
105   static Int_t iEvent = -1; 
106   iEvent++;
107
108   Int_t mult = miniEvt->size(); // # tracks in this (mini) event
109   Int_t nTrk = NTracksInPool();
110
111   if (nTrk < fTargetTrackDepth && ((nTrk + mult) >= fTargetTrackDepth)) 
112     fNTimes++;
113
114   // remove 0th element before appending this event
115   Bool_t removeFirstEvent = 0;
116   if (nTrk>fTargetTrackDepth) {
117     Int_t nTrksFirstEvent= fNTracksInEvent.front();
118     Int_t diff = nTrk - nTrksFirstEvent + mult;
119     if (diff>fTargetTrackDepth)
120       removeFirstEvent = 1;
121   }
122   if (removeFirstEvent) {
123     MiniEvent* oldestEvent = fEvents.front();
124     oldestEvent->clear();
125     delete oldestEvent;
126     fEvents.pop_front();         // remove first track array 
127     fNTracksInEvent.pop_front(); // remove first int
128     fEventIndex.pop_front();
129   }
130
131   fNTracksInEvent.push_back(mult);
132   fEvents.push_back(miniEvt);
133   fEventIndex.push_back(iEvent);
134
135   if (fNTimes==1) {
136     fFirstFilled = kTRUE;
137     if (AliEvtPool::fDebug) {
138       cout << "\nPool " << MultBinIndex() << ", " << ZvtxBinIndex() 
139            << " ready at event "<< iEvent;
140       PrintInfo();
141       cout << endl;
142     }
143     fNTimes++; // See this message exactly once/pool
144   } else {
145     fFirstFilled = kFALSE;
146   }
147
148   fWasUpdated = true;
149
150   if (AliEvtPool::fDebug) {
151     cout << " Event " << fEventIndex.back();
152     cout << " PoolDepth = " << GetCurrentNEvents(); 
153     cout << " NTracksInCurrentEvent = " << " " << mult << endl;
154   }
155
156   return fEvents.size();
157 }
158
159 MiniEvent* 
160 AliEvtPool::GetEvent(Int_t i) const
161 {
162   if (i<0 || i>=(Int_t)fEvents.size()) {
163     cout << "AliEvtPool::GetEvent(" 
164          << i << "): Invalid index" << endl;
165     return 0x0;
166   }
167
168   MiniEvent* ev = fEvents.at(i);
169   return ev;
170 }
171
172 Int_t
173 AliEvtPool::NTracksInEvent(Int_t iEvent) const
174 {
175   // Return number of tracks in iEvent, which is the local pool index.
176
177   Int_t n = -1;
178   Int_t curEvent = fEventIndex.back();
179   Int_t offset = curEvent - iEvent;
180   Int_t pos = fEventIndex.size() - offset - 1;
181
182   if (offset==0)
183     n = fNTracksInEvent.back();
184   else if (offset < 0 || iEvent < 0) {
185     n = 0;
186   }
187   else if (offset > 0 && offset <= (int)fEventIndex.size()) {
188     n = fNTracksInEvent.at(pos);
189   }
190   else
191     cout << "Event info no longer in memory" << endl;
192   return n;
193 }
194
195 // ===================================================================
196 //                          AliEvtPoolManager
197 // ===================================================================
198
199
200 ClassImp(AliEvtPoolManager)
201
202 AliEvtPoolManager::AliEvtPoolManager(Int_t depth,     Int_t minNTracks,
203                                      Int_t nMultBins, Double_t *multbins,
204                                      Int_t nZvtxBins, Double_t *zvtxbins) 
205 : fDebug(0), fNMultBins(0), fNZvtxBins(0), fEvPool(0), fTargetTrackDepth(minNTracks) 
206 {
207   // Constructor.
208
209   InitEventPools(depth, nMultBins, multbins, nZvtxBins, zvtxbins);
210   cout << "AliEvtPoolManager initialized." << endl;
211 }
212
213 AliEvtPoolManager::~AliEvtPoolManager()
214 {
215   for (Int_t iM=0; iM<fNMultBins; iM++) {
216     for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
217       AliEvtPool* pool = fEvPool.at(iM).at(iZ);
218       delete pool;
219     }
220   }
221 }
222
223 Int_t AliEvtPoolManager::InitEventPools(Int_t depth, 
224                                        Int_t nMultBins, Double_t *multbin, 
225                                        Int_t nZvtxBins, Double_t *zvtxbin)
226 {
227   // Assign AliEvtPoolManager members.
228
229   fNMultBins = nMultBins;
230   fNZvtxBins = nZvtxBins;
231
232   for (Int_t iM=0; iM<fNMultBins; iM++) {
233     std::vector<AliEvtPool*> evp;
234     for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
235       evp.push_back(new AliEvtPool(depth, 
236                                    multbin[iM], multbin[iM+1], 
237                                    zvtxbin[iZ], zvtxbin[iZ+1] ));
238     }
239     fEvPool.push_back(evp);
240   }
241   
242   for (Int_t iM=0; iM<nMultBins; iM++) {
243     for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
244       fEvPool.at(iM).at(iZ)->SetMultBinIndex(iM);
245       fEvPool.at(iM).at(iZ)->SetZvtxBinIndex(iZ);
246       fEvPool.at(iM).at(iZ)->SetTargetTrackDepth(fTargetTrackDepth);
247       fEvPool.at(iM).at(iZ)->SetDebug(fDebug);
248     }
249   }
250   
251   if (fDebug) {
252     cout << "fEvPool outer size: " << fEvPool.size() << endl;
253     for (Int_t iM=0; iM<nMultBins; iM++) {
254       for (Int_t iZ=0; iZ<nZvtxBins; iZ++) {
255         if(fEvPool.at(iM).at(iZ)) {
256           cout << "multiplicity bin: " << iM;
257           cout << ", z-vertex bin: " << iZ;
258           fEvPool.at(iM).at(iZ)->PrintInfo();
259         }
260       }
261     }
262   }
263   
264   return fEvPool.size();
265 }
266
267 AliEvtPool*
268 AliEvtPoolManager::GetEventPool(Int_t iMult, Int_t iZvtx) const
269 {
270   if (iMult < 0 || iMult >= fNMultBins) 
271     return 0x0;
272   if (iZvtx < 0 || iZvtx >= fNZvtxBins) 
273     return 0x0;
274   return fEvPool.at(iMult).at(iZvtx);
275 }
276
277 AliEvtPool*
278 AliEvtPoolManager::GetEventPool(Int_t centVal, Double_t zVtxVal) const
279 {
280   return GetEventPool((Double_t)centVal, zVtxVal);
281 }
282
283 AliEvtPool*
284 AliEvtPoolManager::GetEventPool(Double_t centVal, Double_t zVtxVal) const
285 {
286   // Return appropriate pool for this centrality and z-vertex value.
287
288   for (Int_t iM=0; iM<fNMultBins; iM++) {
289     for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
290       AliEvtPool* pool = GetEventPool(iM, iZ);
291       if (pool->EventMatchesBin(centVal, zVtxVal))
292         return pool;
293     }
294   }
295   return 0x0;
296 }
297
298 Int_t
299 AliEvtPoolManager::UpdatePools(MiniEvent* miniEvt)
300 {
301   // Call UpdatePool for all bins.
302
303   for (Int_t iM=0; iM<fNMultBins; iM++) {
304     for (Int_t iZ=0; iZ<fNZvtxBins; iZ++) {
305       if (fEvPool.at(iM).at(iZ)->UpdatePool(miniEvt) > -1)
306         break;
307     }
308   }
309   return 0;
310 }