Additional forward declaration
[u/mrichter/AliRoot.git] / EVE / EveHLT / AliEveEventBuffer.cxx
1 #include <iostream>
2
3 #include "TObjArray.h"
4 #include "TTimer.h"
5 #include "TThread.h"
6 #include "TMutex.h"
7 #include "AliEveEventBuffer.h"
8
9
10 //Not needed, only for debug
11 #include "AliESDEvent.h"
12
13 using namespace std;
14
15 ClassImp(AliEveEventBuffer)
16
17 ///_______________________________________________________________________
18 AliEveEventBuffer::AliEveEventBuffer() :
19   fBufferSize(10),
20   fPreBuffer(4),
21   fBusy(kFALSE),
22   fEventBuffer(NULL),
23   fCurrentEvent(NULL),
24   fBIndex(),
25   fTimer(NULL),
26   fEventId(),
27   fBufferMonStarted(kFALSE),
28   fThread(NULL),
29   fMutex(NULL)
30  {
31   // see header file for class documentation
32   fEventBuffer = new TObjArray(fBufferSize, 0);
33   fEventBuffer->SetOwner(kFALSE);
34   
35   for(int id = 0; id < kSize; id++) {
36     fBIndex[id] = -1;
37   }
38   
39   fTimer = new TTimer();
40   fTimer->Connect("Timeout()", "AliEveEventBuffer", this, "CreateBufferThread()");
41
42   fEventId = new ULong64_t[fBufferSize];
43   for(Int_t id = 0; id < fBufferSize; id++ ) {
44     fEventId[id] = -2;
45   }
46
47   fThread = new TThread(AliEveEventBuffer::BufferThread, (void*) this);
48   fMutex = new TMutex();
49   
50
51 }
52
53
54
55 ///_______________________________________________________________________
56 AliEveEventBuffer::~AliEveEventBuffer() {
57   // see header file for class documentation
58   
59   if ( fEventBuffer ) {
60     fEventBuffer->Clear();
61     delete fEventBuffer;
62   }
63   fEventBuffer = NULL;
64
65   if(fCurrentEvent)
66     delete fCurrentEvent;
67   fCurrentEvent = NULL;
68
69 }
70
71 ///___________________________________________________________________________
72 void AliEveEventBuffer::CreateBufferThread() {
73   
74   
75   cout << "Threadexists: " << fThread->Exists() << endl;
76   if( fMutex->TryLock() ) {
77     cout << "Buffer is busy, no thread created"<< endl;
78     return;
79   } else {
80     if ( (CalculateDifference(fBIndex[kTop],fBIndex[kLast]) < fPreBuffer) ) {
81       SetBusy(kTRUE);
82       cout << "StartBufferThread()"<<endl;
83       fThread->Run();
84       cout << "Started BufferThread"<<endl;
85     } else { 
86       cout << "Buffer is full already"<<endl;
87     }
88   }
89 }
90
91 ///___________________________________________________________________________
92 void * AliEveEventBuffer::BufferThread(void * buffer) {
93   cout <<"BufferThread : " <<endl;
94   if(buffer) {
95       reinterpret_cast<AliEveEventBuffer*>(buffer)->MonitorBuffer();
96   } else {
97     cout << "no buffer"<<endl;
98   }
99   return (void*)0;
100 }
101
102 ///_____________________________________________________________________________
103 void AliEveEventBuffer::MonitorBuffer() {
104   cout << "Monitorbuffer() ";
105   FetchEvent();
106   fMutex->UnLock();
107
108   cout << "done " << endl;
109 }
110
111
112 ///_______________________________________________________________________________
113 TObject * AliEveEventBuffer::NextEvent() {
114   //See header file for documentation
115   cout << "NextEvent()"<<endl;
116   TObject * nextEvent = GetNextUnSeen();
117   return nextEvent;
118 }
119
120 ///______________________________________________________________________________
121 TObject * AliEveEventBuffer::Back() {
122   cout << "go back"<<endl;
123   PrintIndeces();
124   Int_t prevId = CalculatePrevious(fBIndex[kCurrent]);
125   if(prevId == fBIndex[kTop]) {
126     cout << "returning NULL" << endl;
127     return NULL;
128   } else {
129     fBIndex[kCurrent] = prevId;
130     PrintIndeces();
131     cout <<"returning: "<< fBIndex[kCurrent] << " " << fEventBuffer->At(fBIndex[kCurrent]);
132     return fEventBuffer->At(fBIndex[kCurrent]);
133   }
134 }
135
136
137
138 ///______________________________________________________________________________
139 TObject * AliEveEventBuffer::Fwd() {
140   PrintIndeces();
141   if (fBIndex[kCurrent] == fBIndex[kLast]) {
142     cout<<  "returning NULL"<<endl;
143     return NULL;
144   }
145   
146   fBIndex[kCurrent] = CalculateNext(fBIndex[kCurrent]);
147   TObject * event = fEventBuffer->At(fBIndex[kCurrent]);
148   return event;
149 }
150
151
152
153 ///________________________________________________________________________________
154 TObject * AliEveEventBuffer::GetNextUnSeen() {
155   //See header file for documentation
156   cout << "GetNextUnSeen"<<endl;
157   PrintIndeces();
158   if(CalculateDifference(fBIndex[kTop], fBIndex[kLast])) {
159     fBIndex[kLast] = CalculateNext(fBIndex[kLast]);
160     fBIndex[kCurrent] = fBIndex[kLast];
161     PrintIndeces();
162     return fEventBuffer->At(fBIndex[kCurrent]);      
163   } else {
164     cout << "No new event available, only events in buffer available!"<<endl;
165     return NULL;
166   } 
167 }
168 ///_________________________________________________________________________________
169 void AliEveEventBuffer::PrintIndeces() {
170   for(Int_t i = 0; i < kSize; i++) {
171     cout << i << ": " << fBIndex[i] << endl;
172   }
173 }
174 ///_________________________________________________________________________________
175 void AliEveEventBuffer::PrintBuffer() {
176   for(Int_t i = 0; i < 10; i++) {
177     AliESDEvent * event = dynamic_cast<AliESDEvent*>(fEventBuffer->At(i));
178     if(event) {
179       cout << i << ": " <<event << " " << event->GetEventNumberInFile() << endl;;
180     }
181   }
182 }
183
184 ///____________________________________________________________________________________
185 void AliEveEventBuffer::FetchEvent() {
186   cout << "FetchEvent " << endl;
187   TObject * event = GetEventFromSource();
188   ULong64_t eventId = GetEventIdFromSource();
189   if(event) {
190     AddToBuffer(event);
191     fEventId[fBIndex[kTop]] = eventId;  
192   }
193   
194   PrintIndeces();
195   cout << "FetchedEvent " << endl;
196   
197 }
198
199 ///_________________________________________________________________________________
200 void AliEveEventBuffer::AddToBuffer(TObject * event) {
201   cout << "Add to buffer"<<endl;
202   if(!event) return;
203
204   fBIndex[kTop] = CalculateNext(fBIndex[kTop]);
205   //Delete the event already there (ok to delete as object, not aliesdevent, TList?)
206   //TObject * object = fEventBuffer->At(fBIndex[kTop]);
207   fEventBuffer->RemoveAt(fBIndex[kTop]);
208   //if (object) delete object;
209   fEventBuffer->AddAt(event, fBIndex[kTop]);
210
211 }
212
213 ///_____________________________________________________________________________________
214 Int_t AliEveEventBuffer::CalculateNext(Int_t current) {
215   //See header file for documentation
216   current++;
217   if(current == fBufferSize) current = 0;
218   return current;
219 }
220
221
222 ///_____________________________________________________________________________________
223 Int_t AliEveEventBuffer::CalculatePrevious(Int_t current) {
224   //See header file for documentation
225   cout << "CalculatePrev:  " << current; 
226   current--;
227   if(current == -1) current += fBufferSize;
228   cout << "... " << current << endl;
229   return current;
230 }
231
232 ///__________________________________________________________________________________
233 Int_t AliEveEventBuffer::CalculateDifference(Int_t top, Int_t low) {
234   //See header file for documentation
235   if (top > low) {
236     //    cout << "top > low"<<endl;
237     return (top - low);
238   } else if (top < low) {
239     // cout << "low < top"<<endl;
240     return (fBufferSize - low + top);
241   } else {
242     //cout << "calculated to 0"<<endl;
243     return 0;
244   }
245 }
246
247 ///___________________________________________________________________________________
248 void AliEveEventBuffer::StartBufferMonitor() {
249   //cout << "NOT !!! starting buffer mon"<<endl;
250   cout << "starting buffer mon"<<endl;
251   if(!GetBufferMonStarted()) {
252     CreateBufferThread();
253     SetBufferMonStarted(kTRUE);
254     fTimer->Start(15000);
255   } else {
256     cout << "Stopping buffer monitor"<<endl;
257     fTimer->Stop();
258     SetBufferMonStarted(kFALSE);
259   }
260 }
261 ///___________________________________________________________________________________
262 void AliEveEventBuffer::StopBufferMonitor() {
263   cout << "Stopping buffer mon"<<endl;
264   SetBufferMonStarted(kFALSE);
265   fTimer->Stop();
266 }
267
268
269 // //_________________________________________________________________________________
270 // Int_t AliEveEventBuffer::NavigateEventBufferBack() { 
271 //   // see header file for class documentation
272
273 //   // -- reached the end of the buffer
274 //   if ( fNavigateBufferIdx == fBufferLowIdx )
275 //     return -1;
276
277 //   Int_t newIdx = fNavigateBufferIdx - 1;
278 //   if ( newIdx == -1 )
279 //     newIdx = BUFFERSIZE-1;
280
281 //   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;
282
283 //   return newIdx;
284 // }
285
286 // //_______________________________________________________________
287 // Int_t AliEveEventBuffer::NavigateEventBufferFwd() {
288 //   // see header file for class documentation
289
290 //   // -- reached the top of the buffer
291 //   if ( fNavigateBufferIdx == fBufferTopIdx )
292 //     return -1;
293
294 //   Int_t newIdx = fNavigateBufferIdx + 1;
295 //   if ( newIdx == BUFFERSIZE )
296 //     newIdx = 0;
297   
298 //   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;
299
300 //   return newIdx;
301 // }
302
303 // void AliEveEventBuffer::MonitorBuffer() {
304 //   //See header file for documentation
305 //   if( GetNAvailableEvents() < 10) {
306 //     StopBufferChecker();
307 //     StartLoop();
308 //   }
309 // }
310
311 // void AliEveEventBuffer::StartLoop() {
312 //   //See header file for documentation
313 //   fTimer->Start(2000);
314 // }
315 // void AliEveEventBuffer::StopLoop() {
316 //   //See header file for documentation
317 //   fTimer->Stop();
318 // }
319
320 // void AliEveEventBuffer::StartBufferChecker() {
321 //   //See header file for documentation
322 //   fBufferTimer->Start(2000);
323 // }
324 // void AliEveEventBuffer::StopBufferChecker() {
325 //   //See header file for documentation
326 //   fBufferTimer->Stop();
327 // }
328
329 // AliESDEvent * GetNextEvent() {
330   
331 //   tree->GetEntry(fEvent++);
332
333 //   AliESDEvent * event = new AliESDEvent();
334 //   event->ReadFromTree(fTree);
335 //   if (event) {
336 //     return event;
337 //   } else {
338 //     cout << "error getting event" << endl;
339 //     return NULL;
340 //   }
341 // }