b385c3fe66ac283ade2905df8d917ad59ad67033
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTCalibrationProcessor.cxx
1 /**************************************************************************
2  * This file is property of and copyright by the ALICE HLT Project        * 
3  * ALICE Experiment at CERN, All rights reserved.                         *
4  *                                                                        *
5  * Primary Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
6  *                  Sebastian Bablok                                      *
7  *                  for The ALICE HLT Project.                            *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          *
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17
18 /** 
19  * @file   AliHLTCalibrationProcessor.cxx
20  * @author Jochen Thaeder, Sebastian Bablok
21  * @date 
22  * @brief  Base class of HLT calibration components.  */
23
24 // see header file for class documentation
25 // or
26 // refer to README to build package
27 // or
28 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
29
30 #if __GNUC__ >= 3
31 using namespace std;
32 #endif
33
34 #include "AliHLTCalibrationProcessor.h"
35 #include "AliHLTMemoryFile.h"
36
37 #include <cstdlib>
38 #include <cerrno>
39 #include <string.h>
40 #include <TObjString.h>
41 #include <TFile.h>
42
43 ClassImp(AliHLTCalibrationProcessor);
44
45
46 const AliHLTUInt32_t AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize = 204;
47 const AliHLTUInt32_t AliHLTCalibrationProcessor::fgkFXSProtocolHeaderVersion = 1;
48
49 /*
50  * ################ Constructor / Destructor ####################
51  */
52
53 AliHLTCalibrationProcessor::AliHLTCalibrationProcessor() : 
54   fEventModulo(0),
55   fUseCorruptEvents(kFALSE),
56   fEventCounter(0),
57   fDDLNumber(),
58   fDummy(0) {
59
60   // see header file for class documentation
61   // or
62   // refer to README to build package
63   // or
64   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
65 }
66
67 AliHLTCalibrationProcessor::~AliHLTCalibrationProcessor() {
68   // see header file for class documentation
69 }
70
71 /*
72  * ######################## InitCalibration #####################
73  */
74
75 Int_t AliHLTCalibrationProcessor::DoInit( int argc, const char** argv ) {
76   // see header file for class documentation
77
78   Int_t iResult = 0;
79   TString argument = "";
80   TString parameter = "";
81   Int_t bMissingParam=0;
82   
83   for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {
84     argument = argv[ii];
85
86     if ( argument.IsNull() ) continue;
87
88     // -eventmodulo
89     if ( argument.CompareTo("-eventmodulo") == 0 ) {
90       if ( ( bMissingParam=( ++ii >= argc ) ) ) break;
91       parameter = argv[ii];  
92       parameter.Remove(TString::kLeading, ' '); // remove all blanks
93       if (parameter.IsDigit()) {
94         fEventModulo = parameter.Atoi();
95         HLTInfo("EventModulo is set to %d.", fEventModulo);
96       } 
97       else {
98         HLTError("Cannot convert EventModulo specifier '%s'.", argv[ii]);
99         iResult = -EINVAL;
100         break;
101       }
102     } 
103     // -usecorruptevents
104     else if ( argument.CompareTo( "-usecorruptevents" ) == 0 ) {
105       HLTInfo( "Passing through of corrupted events enabled." );
106       fUseCorruptEvents = kTRUE;
107     } 
108     // not known by calibration processor
109     else {
110       if ( ( iResult = ScanArgument( argc-ii, &argv[ii] ) ) == -EINVAL ) {
111         HLTError( "unknown argument %s", argument.Data() );
112         break;
113       } 
114       else if ( iResult == -EPROTO ) {
115         bMissingParam = 1;
116         break;
117       } 
118       else if ( iResult >= 0 ) {
119         ii += iResult;
120         iResult = 0;
121       }
122     }
123   }
124   
125   if ( bMissingParam ) {
126     HLTError( "missing parameter for argument %s", argument.Data() );
127     iResult = -EPROTO;
128   }
129
130   if ( iResult >= 0 ) {
131     iResult = InitCalibration();
132   }
133
134   // Reset the DDLNumberList
135   memset( fDDLNumber, 0, gkAliHLTFXSHeaderfDDLNumberSize);
136
137   return iResult;
138 }
139
140 Int_t AliHLTCalibrationProcessor::InitCalibration() {
141   // see header file for class documentation
142   
143   // fDummy is just touched here to avoid coding convention violation RC11. 
144   // The function can not be declared  const since it is just the default implementation, 
145   // overloaded virtual function might not be const.
146   fDummy = 0;
147
148   return 0;
149 }
150
151
152 Int_t AliHLTCalibrationProcessor::ScanArgument(int argc, const char** argv) {
153   // see header file for class documentation
154   
155   // there are no other arguments than the standard ones
156   if ( argc == 0 && argv == NULL) {
157     // this is just to get rid of the warning "unused parameter"
158   }
159   
160   // fDummy is just touched here to avoid coding convention violation RC11. 
161   // The function can not be declared  const since it is just the default implementation, 
162   // overloaded virtual function might not be const.
163   fDummy = 0;
164
165   return -EINVAL;
166 }
167
168 /*
169  * ######################## DeinitCalibration #####################
170  */
171
172 Int_t AliHLTCalibrationProcessor::DoDeinit() {
173   // see header file for class documentation
174  
175   int iResult = DeinitCalibration();
176  
177   return iResult;
178 }
179
180 Int_t AliHLTCalibrationProcessor::DeinitCalibration() {
181   // see header file for class documentation
182
183   // fDummy is just touched here to avoid coding convention violation RC11. 
184   // The function can not be declared  const since it is just the default implementation, 
185   // overloaded virtual function might not be const.
186   fDummy = 0;
187
188   return 0;
189 }
190
191 /*
192  * ######################## DoEvent #####################
193  */
194
195 Int_t AliHLTCalibrationProcessor::DoEvent( const AliHLTComponentEventData& evtData,
196                const AliHLTComponentBlockData* blocks, 
197                AliHLTComponentTriggerData& trigData,
198                AliHLTUInt8_t* outputPtr, 
199                AliHLTUInt32_t& size,
200                vector<AliHLTComponentBlockData>& outputBlocks )
201 {
202   // see header file for class documentation
203
204   Int_t iResult = 0;
205
206   const AliHLTComponentBlockData* blkSOR = NULL;
207   blkSOR = GetFirstInputBlock( kAliHLTDataTypeSOR );
208   const AliHLTComponentBlockData* blkEOR = NULL;
209   blkEOR = GetFirstInputBlock( kAliHLTDataTypeEOR );
210
211   // ** if event Type is not SOR or EOR -> fill DDLNumber list and process data
212   if ( ! blkEOR  && !blkSOR ) {
213
214 #if 0    
215     // ** Set DDLNumber List
216     if ( trigData.fData != NULL) {
217       AliHLTEventTriggerData* trg = ( AliHLTEventTriggerData* ) trigData.fData;
218       if ( trg != NULL) {
219         AliHLTEventDDL list = (AliHLTEventDDL) trg->fReadoutList;        
220           
221         Int_t wordNdx = GetFirstUsedDDLWord(list);
222         if ( wordNdx >=0 ) {
223           
224           Int_t wordCount = 1;
225           // Handle special TPC and TOF case
226           if ( wordNdx == 3 )
227             wordCount = 8;
228           else if ( wordNdx == 12 )
229             wordCount = 3;
230           
231           // check word for word and binary OR it with existing DDLNumberList
232           for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
233             AliHLTUInt32_t word = list.fList[wordNdx+ndx];
234         
235             // set only 4 bit into one Char_t
236             for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
237               fDDLNumber[(8*ndx)+charNdx] |= (Char_t) word & 0x0000000F;
238               word = word >> 4;
239             }
240           }
241         } // if ( wordNdx > 0 ) {
242       } // if ( trg != NULL) {
243     } // if ( trigData.fData != NULL) {
244 #endif
245     
246     // ** ProcessData
247     iResult = ProcessCalibration( evtData, blocks, trigData, outputPtr, size, outputBlocks );
248     fEventCounter++; 
249   }  
250
251   // - if event Type is EOR or event modulo is set -> ship data to FXS
252   // - use event modulo ship data also during the run 
253   if ( ( fEventModulo > 0 && fEventCounter == fEventModulo ) || blkEOR ){
254     HLTDebug ( "Ship Data to FXS!" );
255     iResult = ShipDataToFXS( evtData, blocks, trigData, outputPtr, size, outputBlocks );
256     fEventCounter = 0;
257   }
258
259   return iResult;
260 }
261
262 /*
263  * ######################## ProcessCalibration #####################
264  */
265
266 Int_t AliHLTCalibrationProcessor::ProcessCalibration( const AliHLTComponentEventData& evtData,
267                                                       const AliHLTComponentBlockData* /*blocks*/, 
268                                                       AliHLTComponentTriggerData& trigData,
269                                                       AliHLTUInt8_t* /*outputPtr*/, 
270                                                       AliHLTUInt32_t& /*size*/,
271                                                       vector<AliHLTComponentBlockData>& /*outputBlocks*/ ) {
272   // see header file for class documentation
273
274   // we just forward to the high level method, all other parameters already
275   // have been stored internally
276   return ProcessCalibration( evtData, trigData );
277 }
278
279 Int_t AliHLTCalibrationProcessor::ProcessCalibration( const AliHLTComponentEventData& /*evtData*/, 
280                                                       AliHLTComponentTriggerData& /*trigData*/) {
281   // see header file for class documentation
282
283   HLTFatal( "no processing method implemented" );
284   return -ENOSYS;
285 }
286
287 /*
288  * ######################## ShipDataToFXS #####################
289  */
290
291 Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData& evtData,
292                                                  const AliHLTComponentBlockData* /*blocks*/, 
293                                                  AliHLTComponentTriggerData& trigData,
294                                                  AliHLTUInt8_t* /*outputPtr*/, 
295                                                  AliHLTUInt32_t& /*size*/,
296                                                  vector<AliHLTComponentBlockData>& /*outputBlocks*/ ) {
297   // see header file for class documentation
298
299   // we just forward to the high level method, all other parameters already
300   // have been stored internally
301   return ShipDataToFXS( evtData, trigData );
302 }
303
304
305 Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, 
306                                                  AliHLTComponentTriggerData& /*trigData*/) {
307   // see header file for class documentation
308
309   HLTFatal( "no processing method implemented" );
310   return -ENOSYS;
311 }
312
313 /*
314  * ######################## CreateFXSHeader #####################
315  */
316
317 Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
318   // see header file for class documentation
319
320   Int_t iResult = 0;
321
322   // ** Fill header version
323   pHeader.fHeaderVersion = AliHLTCalibrationProcessor::fgkFXSProtocolHeaderVersion;
324
325   // ** Fill run number
326   pHeader.fRunNumber = GetRunNo(); 
327   
328   // ** Fill origin
329   HLTDebug( "FXS Header Detector  size max %i - actual %i .",gkAliHLTFXSHeaderfOriginSize, strlen( pDetector ) );
330   strncpy ( pHeader.fOrigin, pDetector, gkAliHLTFXSHeaderfOriginSize ) ; 
331
332   // To take care if fileIDs which are longer than gkAliHLTFXSHeaderfOriginSize, write one 0 is cheaper than an if.
333   pHeader.fOrigin[gkAliHLTFXSHeaderfOriginSize-1] = 0;
334
335   // ** Fill file ID
336   HLTDebug( "FXS Header FileID size max %i - actual %i .",gkAliHLTFXSHeaderfFileIDSize, strlen( pFileID ) );
337   strncpy ( pHeader.fFileID, pFileID, gkAliHLTFXSHeaderfFileIDSize ) ; 
338
339   // To take care if fileIDs which are longer than gkAliHLTFXSHeaderfFileIDSize, write one 0 is cheaper than an if.
340   pHeader.fFileID[gkAliHLTFXSHeaderfFileIDSize-1] = 0;
341
342   // ** Fill DDL number
343
344   // -- if component provides list, convert to fDDLNumber
345   if ( pDDLList ) {
346     // use user list
347     
348     Int_t wordNdx = GetFirstUsedDDLWord( *(pDDLList) );
349     if ( wordNdx >=0 ) {
350           
351       Int_t wordCount = 1;
352       // Handle special TPC and TOF case
353       if ( wordNdx == 3 )
354         wordCount = 8;
355       else if ( wordNdx == 12 )
356         wordCount = 3;
357           
358       // check word for word 
359       for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
360         AliHLTUInt32_t word = pDDLList->fList[wordNdx+ndx];
361         
362         // set only 4 bit into one Char_t
363         for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
364           fDDLNumber[(8*ndx)+charNdx] = (Char_t) word & 0x0000000F;
365           word = word >> 4;
366         }
367       }
368     } // if ( wordNdx > 0 ) {
369     else
370       iResult = wordNdx;
371   } //   if ( pDDLList ) {
372
373   // -- fill header with ascii chars
374   for (Int_t ndx = 0; ndx < gkAliHLTFXSHeaderfDDLNumberSize; ndx++ ){
375     Int_t numberToChar = (Int_t) fDDLNumber[ndx];
376     // Get ASCII
377     if ( numberToChar > 9 ) numberToChar += 55;
378     else numberToChar += 48;
379     
380     pHeader.fDDLNumber[ndx] = (Char_t) numberToChar;
381   }
382   
383   return iResult;
384 }  // Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
385
386 /*
387  * ######################## PushToFXS #####################
388  */
389
390 Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
391   // see header file for class documentation
392
393   Int_t iResult = 0;
394   
395   AliHLTFXSHeader pHeader;
396
397   CreateFXSHeader( pHeader, pDetector, pFileID, pDDLList );
398   
399   if ( pObject ) {
400     
401     AliHLTMemoryFile* pMemFile = CreateMemoryFile( kAliHLTDataTypeFXSCalib, kAliHLTVoidDataSpec );
402     if ( pMemFile ) {
403       
404       iResult = pMemFile->WriteHeaderBuffer( (const char*) &pHeader, AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize );
405
406       if ( iResult ) {
407         HLTError( "Buffer size to small - for header!" ); 
408       }
409       else {
410         iResult = Write( pMemFile, pObject );
411         if ( !iResult ) {
412           HLTError( "Buffer size to small - for data!" ); 
413         }
414         else {
415           iResult = CloseMemoryFile( pMemFile );  
416         }
417       }
418     } 
419     else {
420       iResult = -ENOMEM;
421     }
422   } 
423   else {
424     iResult=-EINVAL;
425   }
426
427   return iResult;
428
429 } // Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* detector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
430
431 Int_t AliHLTCalibrationProcessor::PushToFXS( void* pBuffer, int iSize, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
432   // see header file for class documentation
433
434   Int_t iResult = 0;
435   
436   AliHLTFXSHeader pHeader;
437
438   CreateFXSHeader( pHeader, pDetector, pFileID, pDDLList );
439   
440   iResult = PushBack( pBuffer, iSize, kAliHLTDataTypeFXSCalib, kAliHLTVoidDataSpec, (void*) (&pHeader), AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize );
441
442   return iResult;
443
444 } // Int_t AliHLTCalibrationProcessor::PushToFXS(void* pBuffer, int iSize, const char* pDdetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
445