doing backward compatibility correctly
[u/mrichter/AliRoot.git] / HLT / rec / AliRawReaderHLT.cxx
1 // $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  for The ALICE HLT Project.                            *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   AliRawReaderHLT.cxx
20     @author Matthias Richter
21     @date   
22     @brief  AliRawReader implementation which replaces original input of
23             detectors with the appropriate HLT output.                    */
24
25 // see header file for class documentation
26 // or
27 // refer to README to build package
28 // or
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31 #include "AliRawReaderHLT.h"
32 #include "AliHLTOUTRawReader.h"
33 #include "AliHLTModuleAgent.h"
34 #include "AliHLTOUTHandler.h"
35 #include "AliHLTOUTHandlerEquId.h"
36 #include "AliHLTSystem.h"
37 #include "AliLog.h"
38 #include "AliDAQ.h"            // RAW, for detector names and equipment ids
39 #include "TObjString.h"
40 #include <cassert>
41
42 /** ROOT macro for the implementation of ROOT specific class methods */
43 ClassImp(AliRawReaderHLT)
44
45 AliRawReaderHLT::AliRawReaderHLT(AliRawReader* pRawreader, const char* options)
46   :
47   AliRawReader(),
48   AliHLTReconstructorBase(),
49   fpParentReader(pRawreader),
50   fOptions(),
51   fSystemOptions(),
52   fpData(NULL),
53   fDataSize(0),
54   fOffset(0),
55   fPosition(0),
56   fEquipmentId(-1),
57   fbHaveHLTData(false),
58   fDetectors(),
59   fpHLTOUT(NULL),
60   fbReadFirst(true),
61   fpDataHandler(NULL)
62 {
63   // see header file for class documentation
64   // or
65   // refer to README to build package
66   // or
67   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
68   fOptions=options;
69   ScanOptions(options);
70 }
71
72 AliRawReaderHLT::~AliRawReaderHLT()
73 {
74   // see header file for class documentation
75   ReleaseHLTData();
76 }
77
78 UInt_t AliRawReaderHLT::GetType() const
79 {
80   // see header file for class documentation
81   return fpParentReader->GetType();
82 }
83
84 UInt_t AliRawReaderHLT::GetRunNumber() const
85 {
86   // see header file for class documentation
87   return fpParentReader->GetRunNumber();
88 }
89
90 const UInt_t* AliRawReaderHLT::GetEventId() const
91 {
92   // see header file for class documentation
93   return fpParentReader->GetEventId();
94 }
95
96 const UInt_t* AliRawReaderHLT::GetTriggerPattern() const
97 {
98   // see header file for class documentation
99   return fpParentReader->GetTriggerPattern();
100 }
101
102 const UInt_t* AliRawReaderHLT::GetDetectorPattern() const
103 {
104   // see header file for class documentation
105   return fpParentReader->GetDetectorPattern();
106 }
107
108 const UInt_t* AliRawReaderHLT::GetAttributes() const
109 {
110   // see header file for class documentation
111   return fpParentReader->GetAttributes();
112 }
113
114 const UInt_t* AliRawReaderHLT::GetSubEventAttributes() const
115 {
116   // see header file for class documentation
117   return fpParentReader->GetSubEventAttributes();
118 }
119
120 UInt_t AliRawReaderHLT::GetLDCId() const
121 {
122   // see header file for class documentation
123   return fpParentReader->GetLDCId();
124 }
125
126 UInt_t AliRawReaderHLT::GetGDCId() const
127 {
128   // see header file for class documentation
129   return fpParentReader->GetGDCId();
130 }
131
132 UInt_t AliRawReaderHLT::GetTimestamp() const
133 {
134   // see header file for class documentation
135   return fpParentReader->GetTimestamp();
136 }
137
138 const UInt_t* AliRawReaderHLT::GetEquipmentAttributes() const
139 {
140   // see header file for class documentation
141   return fpParentReader->GetEquipmentAttributes();
142 }
143
144 Int_t    AliRawReaderHLT::GetEquipmentElementSize() const
145 {
146   // see header file for class documentation
147   // don't know what it really means, bu the AliRawReaderFile
148   // just sets it to 0
149   // do the same if we have a valid equipment data set from
150   // the HLT stream
151   if (fEquipmentId>=0) return 0;
152   return fpParentReader->GetEquipmentElementSize();
153 }
154
155 Int_t    AliRawReaderHLT::GetEquipmentHeaderSize() const
156 {
157   // see header file for class documentation
158
159   // equipment header means the additional data header?
160   // if we have a valid equipment data set from the HLT stream
161   // there is no additional header
162   if (fEquipmentId>=0) return 0;
163   return fpParentReader->GetEquipmentHeaderSize();
164 }
165
166 Int_t    AliRawReaderHLT::GetEquipmentSize() const
167 {
168   // see header file for class documentation
169   if (fEquipmentId>=0) return fDataSize+sizeof(AliRawDataHeader);
170   return fpParentReader->GetEquipmentSize();
171 }
172
173 Int_t    AliRawReaderHLT::GetEquipmentType() const
174 {
175   // see header file for class documentation
176   return fpParentReader->GetEquipmentType();
177 }
178
179 Int_t    AliRawReaderHLT::GetEquipmentId() const
180 {
181   // see header file for class documentation
182   Int_t id=-1;
183   if (fEquipmentId>=0) id=fEquipmentId;
184   else id=fpParentReader->GetEquipmentId();
185   return id;
186 }
187
188 Bool_t   AliRawReaderHLT::ReadHeader()
189 {
190   // see header file for class documentation
191   Bool_t result=kFALSE;
192   Bool_t firstParentCycle=fbHaveHLTData;
193   while (fbHaveHLTData=(fbHaveHLTData && ReadNextHLTData())) {
194     // all internal data variables set
195     assert(fpData!=NULL);
196     fHeader=reinterpret_cast<AliRawDataHeader*>(const_cast<AliHLTUInt8_t*>(fpData));
197     fOffset=sizeof(AliRawDataHeader);
198     fPosition=fOffset;
199     if (result=IsSelected()) break;
200   }
201   firstParentCycle&=!fbHaveHLTData; // true if it just changed from true to false
202   while (!result) {
203     if (firstParentCycle) {
204       firstParentCycle=kFALSE;
205       // reset and set the selection back to the original one
206       fpParentReader->Reset();
207       fpParentReader->SelectEquipment(fSelectEquipmentType, fSelectMinEquipmentId, fSelectMaxEquipmentId);
208     }
209
210     if (!(result=fpParentReader->ReadHeader())) {
211       fHeader=NULL;
212       break;
213     }
214     fHeader=const_cast<AliRawDataHeader*>(fpParentReader->GetDataHeader());
215
216     // filter out all equipment ids which should be taken from the HLT stream
217     int id=fpParentReader->GetEquipmentId();
218     if (result=!IsHLTInput(id)) break;
219   }
220   return result;
221 }
222
223 Bool_t   AliRawReaderHLT::ReadNextData(UChar_t*& data)
224 {
225   // see header file for class documentation
226
227   // this function is the backbone of the ReadNext functions, it gets the
228   // whole data block either from the HLT stream or the parent raw reader.
229   // Each call of ReadNextData directly jumps to the next data set.
230   Bool_t result=kTRUE;
231
232   // read new header if data already read
233   if (fPosition<fDataSize || (result=ReadHeader())) {
234     if (fbHaveHLTData && fpHLTOUT!=NULL) {
235       // all internal data variables set
236       result=kTRUE;
237       data=const_cast<AliHLTUInt8_t*>(fpData+sizeof(AliRawDataHeader));
238     } else {
239       // no data in the HLT stream, read real data
240       //AliInfo(Form("read from parent reader: min=%d max=%d", fSelectMinEquipmentId, fSelectMaxEquipmentId));
241
242       // read data
243       result=fpParentReader->ReadNextData(data);
244       if (result) {
245         fpData=data;
246         fDataSize=fpParentReader->GetDataSize();
247       } else {
248         fpData=NULL;
249         fDataSize=0;
250       }
251
252       fEquipmentId=-1;
253     }
254     fOffset=sizeof(AliRawDataHeader);
255     fPosition=fDataSize;
256   }
257   return result;
258 }
259
260 Bool_t   AliRawReaderHLT::ReadNextInt(UInt_t& data)
261 {
262   // see header file for class documentation
263   int iCopy=sizeof(UInt_t);
264   UChar_t* dummy=NULL;
265   do {
266     if (fpData && (fDataSize-fOffset)>=iCopy) {
267       data=*reinterpret_cast<const UInt_t*>(fpData+fOffset);
268       fOffset+=iCopy;
269       return kTRUE;
270     }
271   } while (ReadNextData(dummy));
272   return kFALSE;
273 }
274
275 Bool_t   AliRawReaderHLT::ReadNextShort(UShort_t& data)
276 {
277   // see header file for class documentation
278   int iCopy=sizeof(UShort_t);
279   UChar_t* dummy=NULL;
280   do {
281     if (fpData && (fDataSize-fOffset)>=iCopy) {
282       data=*reinterpret_cast<const UShort_t*>(fpData+fOffset);
283       fOffset+=iCopy;
284       return kTRUE;
285     }
286   } while (ReadNextData(dummy));
287   return kFALSE;
288 }
289
290 Bool_t   AliRawReaderHLT::ReadNextChar(UChar_t& data)
291 {
292   // see header file for class documentation
293   int iCopy=sizeof(UChar_t);
294   UChar_t* dummy=NULL;
295   do {
296     if (fpData && (fDataSize-fOffset)>=iCopy) {
297       data=*reinterpret_cast<const UChar_t*>(fpData+fOffset);
298       fOffset+=iCopy;
299       return kTRUE;
300     }
301   } while (ReadNextData(dummy));
302   return kFALSE;
303 }
304
305 Bool_t   AliRawReaderHLT::ReadNext(UChar_t* data, Int_t size)
306 {
307   // see header file for class documentation
308   UChar_t* dummy=NULL;
309   do {
310     if (fpData && (fDataSize-fOffset)>=size) {
311       // copy remaining data
312       int iCopy=fDataSize-fOffset;
313       if (iCopy>size) iCopy=size;
314       memcpy(data, fpData+fOffset, iCopy);
315       fOffset+=iCopy;
316       return kTRUE;
317     }
318   } while (ReadNextData(dummy));
319   return kFALSE;
320 }
321
322 Bool_t   AliRawReaderHLT::Reset()
323 {
324   // see header file for class documentation
325   ReleaseHLTData(false/* keep HLTOUT instance */);
326   Bool_t result=fpParentReader->Reset();
327   fEquipmentId=-1;
328
329   // check if redirection is enabled for at least one detector in the selected range
330   fbHaveHLTData=EvaluateSelection();
331
332   // start reading HLTOUT data blocks from the beginning
333   fbReadFirst=true;
334
335   return result;
336 }
337
338 Bool_t   AliRawReaderHLT::NextEvent()
339 {
340   // see header file for class documentation
341
342   ReleaseHLTData();
343
344   Bool_t result=fpParentReader->NextEvent();
345   if (result) {
346     fEventNumber++;
347     Reset();
348   }
349   return result;
350 }
351
352 Bool_t   AliRawReaderHLT::RewindEvents()
353 {
354   // see header file for class documentation
355   fEventNumber=-1;
356   Reset();
357   return fpParentReader->RewindEvents();
358 }
359
360 void AliRawReaderHLT::Select(Int_t detectorID, Int_t minDDLID, Int_t maxDDLID)
361 {
362   // see header file for class documentation
363   AliRawReader::Select(detectorID, minDDLID, maxDDLID);
364   fpParentReader->Select(detectorID, minDDLID, maxDDLID);
365   fbHaveHLTData=EvaluateSelection();
366 }
367
368 // most likely we do not need this method since the base class directly forwards
369 // to this method
370 // void AliRawReaderHLT::Select(const char *detectorName, Int_t minDDLID, Int_t maxDDLID)
371 // {
372 //   AliInfo(Form("detectorName=%s, minDDLID=%d, maxDDLID=%d", detectorName, minDDLID, maxDDLID));
373 //   AliRawReader::Select(detectorName, minDDLID, maxDDLID);
374 //   fpParentReader->Select(detectorName, minDDLID, maxDDLID);
375 // }
376
377 void AliRawReaderHLT::SelectEquipment(Int_t equipmentType, Int_t minEquipmentId, Int_t maxEquipmentId)
378 {
379   // see header file for class documentation
380
381   //AliInfo(Form("equipmentType=%d, minEquipmentId=%d, maxEquipmentId=%d", equipmentType, minEquipmentId, maxEquipmentId));
382   AliRawReader::SelectEquipment(equipmentType, minEquipmentId, maxEquipmentId);
383   fpParentReader->SelectEquipment(equipmentType, minEquipmentId, maxEquipmentId);
384   fbHaveHLTData=EvaluateSelection();
385 }
386
387 void AliRawReaderHLT::SkipInvalid(Bool_t skip)
388 {
389   // see header file for class documentation
390
391   AliRawReader::SkipInvalid(skip);
392   fpParentReader->SkipInvalid(skip);
393 }
394
395 void AliRawReaderHLT::SelectEvents(Int_t type)
396 {
397   // see header file for class documentation
398
399   //AliInfo(Form("type=%d", type));
400   AliRawReader::SelectEvents(type);
401   fpParentReader->SelectEvents(type);
402 }
403
404 int AliRawReaderHLT::ScanOptions(const char* options)
405 {
406   // see header file for class documentation
407   int iResult=0;
408   TString optString(options);
409   TString argument;
410   TString parameter;
411   TObjArray* pTokens=optString.Tokenize(" ");
412   if (pTokens) {
413     int iEntries=pTokens->GetEntries();
414     for (int i =0; i<iEntries; i++) {
415       argument=((TObjString*)pTokens->At(i))->GetString();
416       // first scan all the other options
417       // no other options for the moment
418
419       // it must be a detector name
420       int detId=AliDAQ::DetectorID(argument.Data());
421       if (detId>=0) {
422         fDetectors.push_back(detId);
423       } else {
424         if (!fSystemOptions.IsNull()) fSystemOptions+=" ";
425         fSystemOptions+=argument;
426       }
427     }
428     delete pTokens;
429   }
430
431   return iResult;
432 }
433
434 Bool_t   AliRawReaderHLT::ReadNextHLTData()
435 {
436   // see header file for class documentation
437   bool result=kTRUE;
438   if (fbReadFirst || !fpHLTOUT) {
439     if (!fpHLTOUT) {
440     fpHLTOUT=new AliHLTOUTRawReader(fpParentReader);
441     if (result=(fpHLTOUT!=NULL)) {
442       AliHLTSystem* pSystem=GetInstance();
443       if (pSystem) {
444         pSystem->ScanOptions(fSystemOptions.Data());
445       }
446       if (result=(fpHLTOUT->Init()>=0)) {
447       }
448     }
449     }
450     if (result) {
451       result=fpHLTOUT->SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec,
452                                             AliHLTModuleAgent::kRawReader)>=0;
453     }
454     fbReadFirst=false;
455   } else {
456     // first release the data buffer
457     ReleaseHLTData(false /* keep HLTOUT instance */);
458     result=fpHLTOUT->SelectNextDataBlock()>=0;
459   }
460   if (result) {
461     AliHLTComponentDataType dt=kAliHLTVoidDataType;
462     AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
463     fpHLTOUT->GetDataBlockDescription(dt, spec);
464     AliHLTUInt32_t size=0;
465     AliHLTOUTHandler* pHandler=fpHLTOUT->GetHandler();
466     if (pHandler) {
467       if (dynamic_cast<AliHLTOUTHandlerEquId*>(pHandler)!=NULL) {
468         AliHLTOUT::AliHLTOUTLockGuard g(fpHLTOUT);
469         fEquipmentId=pHandler->ProcessData(fpHLTOUT);
470         fpData=NULL;
471         fDataSize=pHandler->GetProcessedData(fpData);
472         if (!fpData) {
473           result=fpHLTOUT->GetDataBuffer(fpData, size)>=0;
474           fpDataHandler=NULL;
475           AliDebug(AliLog::kDebug, Form("forward data block from HLTOUT stream to equipment %d", fEquipmentId));
476           fDataSize=(int)size;
477         } else {
478           // remember the current handler in order to properly release the data buffer
479           fpDataHandler=pHandler;
480           AliDebug(AliLog::kDebug, Form("forward decoded data block provided by handler to equipment %d", fEquipmentId));
481         }
482         return kTRUE;
483       } else {
484         AliError(Form("handler is not of type AliHLTOUTHandlerEquId for block %x data type %s spec %#x; data block skipped",
485                       fpHLTOUT->GetDataBlockIndex(), AliHLTComponent::DataType2Text(dt).c_str(), spec));
486       }
487     } else {
488       AliWarning(Form("no data handler found for block %x data type %s spec %#x; data block skipped",
489                       fpHLTOUT->GetDataBlockIndex(), AliHLTComponent::DataType2Text(dt).c_str(), spec));
490     }
491   } else {
492     ReleaseHLTData(false /* keep HLTOUT instance */);
493   }
494   return kFALSE;
495 }
496
497 Bool_t AliRawReaderHLT::IsHLTInput(int ddlid)
498 {
499   // see header file for class documentation
500   vector<int>::iterator detector=fDetectors.begin();
501   for (; detector!=fDetectors.end(); detector++) {
502     int ddlOffset=AliDAQ::DdlIDOffset(*detector);
503     int nofDDLs=AliDAQ::NumberOfDdls(*detector);
504     if (ddlid>=ddlOffset && ddlid<ddlOffset+nofDDLs)
505       return kTRUE;
506   }
507   return kFALSE;
508 }
509
510 int AliRawReaderHLT::ReleaseHLTData(bool bReleaseHLTOUT)
511 {
512   // see header file for class documentation
513   if (fpHLTOUT) {
514     if (fpDataHandler) fpDataHandler->ReleaseProcessedData(fpData, fDataSize);
515     else fpHLTOUT->ReleaseDataBuffer(fpData);
516     fpDataHandler=NULL;
517     if (bReleaseHLTOUT) {
518       delete fpHLTOUT;
519       fpHLTOUT=NULL;
520     }
521   }
522
523   fpData=NULL;
524   fDataSize=0;
525   fOffset=0;
526   fPosition=0;
527   fEquipmentId=-1;
528
529   return 0;
530 }
531
532 Bool_t AliRawReaderHLT::EvaluateSelection()
533 {
534   // see header file for class documentation
535   Bool_t bHaveHLTData=kFALSE;
536   if (bHaveHLTData=(fDetectors.size()>0)) {
537     vector<int>::iterator detector=fDetectors.begin();
538     for (; detector!=fDetectors.end(); detector++) {
539       int ddlOffset=AliDAQ::DdlIDOffset(*detector);
540       int nofDDLs=AliDAQ::NumberOfDdls(*detector);
541       if ((fSelectMinEquipmentId<0 || fSelectMinEquipmentId<ddlOffset+nofDDLs) &&
542           (fSelectMaxEquipmentId<0 || fSelectMaxEquipmentId>=ddlOffset))
543         break;
544     }
545     bHaveHLTData=detector!=fDetectors.end();
546   }
547   return bHaveHLTData;
548 }
549
550 AliRawReader* AliRawReaderHLTCreateInstance(AliRawReader* pParentReader, const char* options)
551 {
552   // see header file for class documentation
553   if (!pParentReader) return NULL;
554   return new AliRawReaderHLT(pParentReader, options);
555 }