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