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