New module TRIGGER (Chiara, Annalisa)
[u/mrichter/AliRoot.git] / HLT / pendolino / AliHLTPendolino.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALI_HLT_PENDOLINO_H
5 #define ALI_HLT_PENDOLINO_H
6 //* This file is property of and copyright by the ALICE HLT Project        * 
7 //* ALICE Experiment at CERN, All rights reserved.                         *
8 //* See cxx source for full Copyright notice                               *
9
10 /** @file   AliHLTPendolino.h
11     @author Sebastian Bablok
12     @date   
13     @brief  
14 */
15
16 //#include <TObject.h>
17 #include <TString.h>
18 #include <TMap.h>
19
20
21 #include <AliShuttleInterface.h>
22
23 //#include "AliHLTPredictionProcessorInterface.h"
24
25 #ifdef SHUTTLE_PRE_REV29388_INTERFACE
26 #define CONST_PROPERTY const
27 #else
28 #define CONST_PROPERTY
29 #endif
30
31 class AliHLTPendolinoLogger;
32
33 /**
34  * Class that implements the AliShuttleInterface and provides the required
35  * features for the contacting the PredictionProcessor and storing the result
36  * to the HCDB
37  * 
38  * @author Sebastian Bablok
39  *
40  * @date 2007-10-22
41  */
42 class AliHLTPendolino : public AliShuttleInterface {
43         public:
44
45                 /**
46                  * Static string that defines the local storage indicator in path
47                  */  
48                 static const TString kLOCAL_STORAGE_DEFINE;  // defines the local storage
49
50                 /**
51                  * Static string defining the name of this inteface module.
52                  */
53                 static const char* kHLTInterfaceModule;  // defines the name of inteface module
54
55                 /**
56                  * Static value defining error value for a Pendolino exception.
57                  */ 
58                 static const Int_t kHLTPendolinoException;  // error value for a Pendolino exception
59
60                 /**
61                  * Static value defining error value for a bad cast
62                  */ 
63                 static const Int_t kHLTPendolinoBadCast;  // error value for a bad cast
64
65                 /**
66                  * Static value defining error value for handed in module is not 
67                  * implementing the PredictionProcessor interface.
68                  */ 
69                 static const Int_t kHLTPendolinoNotPredictProc;  //  error value for "not implementing the PredictionProcessor interface"
70
71                 /**
72                  * Static value defining error value for module not existing.
73                  */ 
74                 static const Int_t kHLTPendolinoModuleNotExisting;  // error value for module not existing
75
76                 /**
77                  * Static value defining error value for PredictionProc does not
78                  * process DCS values.
79                  */     
80                 static const Int_t kHLTPendolinoNoDCS; // error value for PredictionProc does not process DCS
81
82                 /**
83                  * Static string that defines the base folder for the Taxi list files.
84                  */ 
85                 static const TString kTaxiListBaseFolder;  // defines the base folder for the Taxi list files
86
87                 /**
88                  * Static string that defines list folder name for taxi list
89                  */
90                 static const TString kTaxiListFolderName; // defines list folder name for taxi list
91
92                 /**
93                  * Static string that defines the filename for the Taxi list required
94                  * by the Pendolino
95                  */  
96                 static const TString kTaxiListPendolino; // defines the filename for the Taxi list 
97
98                 /**
99                  * Static value that defines the max length of a line that can be read
100                  * when browsing through the list file
101                  */ 
102                 static const Int_t kMAX_LINE_LENGTH; // defines the max length of a line
103                 
104
105                 /**
106                  * Constructor for AliHLTPendolino.
107                  *
108                  * @param run the current run number
109                  * @param HCDBbase path to the HCDB base folder
110                  * @param runType the current run type
111                  * @param logger pointer to the desired logger; default is the command
112                  *                      line logger.
113                  * @param startTime start time of the DCS Archive DB request
114                  * @param endTime end time of the DCS Archive DB request
115                  */
116                 AliHLTPendolino(Int_t run, TString HCDBbase, TString runType = "TEST", 
117                                 AliHLTPendolinoLogger* logger = 0, UInt_t startTime = 0, 
118                                 UInt_t endTime = 0);
119
120                 /**
121                  * Destructor for
122                  */
123                 virtual ~AliHLTPendolino();
124
125                 /**
126                  * Function to store processed data in the HCDB
127                  *
128                  * @param path the storage path consisting of "detector/type/objectname"
129                  *                      where detector should be the detector name used by offline,
130                  *                      type is something like "CALIB" or "ALIGN", while 
131                  *                      objectname the name represents, by which it can be requested
132                  *                      from the HCDB.
133                  * @param object the object to store
134                  * @param metaData metaData to store
135                  * @param validityStart object is valid from current run number minus 
136                  *                      validityStart
137                  * @param validityInfinite if true, validity is set to infinity
138                  *
139                  * @return true on success, else false
140                  */
141                 virtual Bool_t Store(const AliCDBPath& path, TObject* object, 
142                                 AliCDBMetaData* metaData, Int_t validityStart = 0, 
143                                 Bool_t validityInfinite = kFALSE);
144                 /**
145                  * Function is required from interface, but is disbled in its 
146                  * implementation since additional refernce data will not be used by 
147                  * the DAs inside the HLT. Therefore always returns false
148                  *
149                  * @return always false, since function is disabled.
150                  */
151             virtual Bool_t StoreReferenceData(const AliCDBPath& path, 
152                                 TObject* object, AliCDBMetaData* metaData);
153                 /**
154                  * Function is required from interface, but is disbled in its
155          * implementation since additional reference data will not be used by
156          * the DAs inside the HLT. Therefore always returns false
157          *
158          * @return always false, since function is disabled.
159          */
160             virtual Bool_t StoreReferenceFile(const char* detector, 
161                                 const char* localFile, const char* gridFileName);
162
163                 /**
164                  * Function is required from interface, but is disbled in its
165                  * implementation since additional run meta data will only be stored
166                  * by the the GPR - Preprocessor of the Offline Shuttle.
167                  * 
168                  * @return always false, since function is disabled.
169                  */                  
170                 virtual Bool_t StoreRunMetadataFile(const char* localFile, 
171                                 const char* gridFileName);
172
173                 /**
174                  * Function is required from interface, but is disbled in its
175          * implementation since additional refernce data will not be used by
176          * the DAs inside the HLT. Therefore always returns NULL.
177                  * If this feature is lateron required by HLT, inherit from this class
178                  * and overwrite this function with the required functionality.
179          *
180          * @return always NULL, since not used.
181          */
182 //          virtual const char* GetFile(Int_t system, const char* detector, 
183 //                              const char* id, const char* source);  --> is private now
184             
185         /**
186          * Function is required from interface, but is disbled in its
187          * implementation since additional refernce data will not be used by
188          * the DAs inside the HLT. Therefore always returns NULL.
189          * If this feature is lateron required by HLT, inherit from this class
190          * and overwrite this function with the required functionality.
191          *
192          * @return always NULL, since not used.
193          */
194 //          virtual TList* GetFileSources(Int_t system, const char* detector, 
195 //                              const char* id = 0);  -> is priavte now
196                 
197         /**
198          * Function is required from interface, but is disbled in its
199          * implementation since additional refernce data will not be used by
200          * the DAs inside the HLT. Therefore always returns NULL.
201          * If this feature is lateron required by HLT, inherit from this class
202          * and overwrite this function with the required functionality.
203          *
204          * @return always NULL, since not used.
205          */
206 //          virtual TList* GetFileIDs(Int_t system, const char* detector, 
207 //                              const char* source);  -> is private now
208             
209                 /**
210                  * Retrieves current run parameter.
211                  * 
212                  * @param lbEntry name of the run parameter
213                  *
214                  * @return value of the run parameter
215                  */
216             virtual const char* GetRunParameter(const char* lbEntry);
217
218                 /**
219                  * Retrieves the current run type.              
220                  *
221                  * @return the current run type
222                  */
223                 virtual const char* GetRunType();
224                 
225                 /**
226                  * Returns the HLT status.
227                  * Since the Pendolino is part of the HLT, the function will always
228                  * return true
229                  *
230                  * @return always true - see above
231                  */
232             virtual Bool_t GetHLTStatus();
233
234                 /**
235                  * Retrieves a file from the OCDB, but does not uses the OCDB but the 
236                  * HCDB (local copy of the OCDB). - Since the HCDB only contains OCDB
237                  * objects, that are included in the list the Taxi uses for fetching 
238                  * the data from the OCDB, it can happen, that the corresponding 
239                  * AliCDBEntry is missing. 
240                  * TODO: Think of mechanism to automatically include the object in the
241                  * Taxi list.
242                  * 
243                  * @param detector the detectorname, to which the object belongs
244                  * @param path the path of the object
245                  *
246                  * @return pointer to the fetched HCDB entry
247                  */
248             virtual AliCDBEntry* GetFromOCDB(const char* detector, 
249                                 const AliCDBPath& path);
250             
251                 /**
252                  * Function to allow Pendolino and PredictionProcessor to make log 
253                  * entries.
254                  *
255                  * @param detector the detector, that wants to issue this message
256                  * @param message the log message
257                  */
258             virtual void Log(const char* detector, const char* message);
259
260                 /**
261                  * Function is required from interface, but is disbled in the Pendolino
262                  * because at the moment there is no Trigger configuration available 
263                  * for Pendolino. At the moment it just return a NULL pointer and makes
264                  * some log output.
265                  *
266                  * @return NULL pointer, since it should not be used.
267                  */
268 //              virtual const char* GetTriggerConfiguration(); --> is private now
269
270                 /**
271                  * Registers a preprocessor; actually it has to be a PredictionProcessor
272                  * since the Pendolino requires a PredictionProcessor. If the registered
273                  * preprocessor is not implementing a PredictionProcessor, a log entry
274                  * is made and the registration discarded.
275                  *
276                  * @param preprocessor the PredictionProcessor that shall be registered.
277                  *                      For more details please see above !!
278                  */ 
279                 virtual void RegisterPreprocessor(AliPreprocessor* preprocessor);
280 //                                      AliHLTPredictionProcessorInterface* preprocessor);
281
282                 /**
283                  * Function to get the current run number
284                  *
285                  * @return current run number
286                  */
287                 virtual Int_t GetRunNumber();
288
289                 /**
290                  * Function to enable prediction making in all registered 
291                  * PredictionProcessors, if they implement the required interface
292                  *          
293                  * @return number of PredictionProcessor, which has been switched to
294                  *                              prediction making (NOTE: the internal list may conatin 
295                  *                              more PredictionProcessors, but if switching on failed 
296                  *                              for one, this one is not counted.)
297                  */
298                 virtual UInt_t setToPredictMaking(); 
299
300                 /**
301                  * Function to get the number of registered PredictionProcessors
302                  *
303                  * @return number of registered PredictionProcessors
304                  */
305                 Int_t getNumberOfPredictProc();
306
307                 /**
308                  * Function to check if given PredtionProc allows for processing DCS
309                  * and enable prediction making
310                  *
311                  * @param detector the detector in whose PredictionProcessor the 
312                  *                      prediction making shall be enabled.
313                  *
314                  * @return 0 on success, else an error code is returned
315                  */
316                 virtual Int_t setToPredictMaking(TString detector);
317
318                 /**
319                  * Function to initlaize a dedicated Prediction Processor
320                  * 
321                  * @param detector the detector, whose PredictProc shall be initialized
322                  * @param run the current run number
323                  * @param startTime the start time of the fetched data
324                  * @param endTime the end time of the fetched data
325                  *
326                  * @return 0 on success, else an error code is returned
327                  */
328                 virtual Int_t initPredictProc(TString detector, Int_t run, 
329                                         UInt_t startTime, UInt_t endTime);
330
331                 /**
332                  * Function to hand in retrieved DCS values. These values are handed to
333                  * the corresponding PredictionProcessor of the according detector.
334                  * The PredictionProcessor should prepare the data inside and store 
335                  * them to the HCDB.
336                  *
337                  * @param detector the according detector, to whose PredictionProcessor
338                  *                      shall prepare the handed-in data
339                  * @param DCSValues pointer to the map containing the fetched DCS values
340                  *
341                  * @return 0 on success, else an error code is returned.
342                  */
343                 virtual Int_t prepareDCSValues(TString detector, TMap* DCSValues);
344
345                 /**
346                  * Function to retrieve dummy data for testing the Pendolino from a
347                  * given PredictionProcessor. The function called is handed further to
348                  * the corresponding PredictionProcessor.
349                  * NOTE: The returned TMap can be NULL, if no corresponding 
350                  * PredictionProcessor is registered.
351                  *
352                  * @param detector the according detector, from whom the 
353                  *                      PredictionProcessor shall produce the dummy data.
354                  * @param aliasName optional parameter to hand in a alias name for 
355                  *                      producing a DCSMap for the given alias.
356                  *
357                  * @return the DCSMap with the dummy data to test (given by the 
358                  *                      PredictionProcessor). NOTE: can be NULL, if no corresponding
359                  *                      PredictionProcessor is registered.
360                  */
361                 virtual TMap* emulateDCSMap(TString detector, TString aliasName = "");
362    
363                 /**
364                  * Function to add a entry request to the Taxi lists.
365                  *
366                  * @param entryPath the path entry, that shall be included in the 
367                  *                              list file.
368                  *
369                  * @return true, when successful included or entry already existing in 
370                  *                              list; else false.
371                  */
372                 virtual Bool_t includeAliCDBEntryInList(const TString& entryPath); 
373
374                 /**
375                  * Function to get the start time of the DCS Archive DB request; in HLT
376                  * this is the same like the start time given in the Initialize() call 
377                  * to the PredictionProcessors (NOTE: thsi is differnet to the 
378                  * implementation in the Offline Shuttle - there the initial start time
379                  * is set to the start-of-data for the complete run.)
380                  */
381 #ifdef SHUTTLE_PRE_REV29388_INTERFACE
382                 virtual const UInt_t GetStartTimeDCSQuery();
383 #else
384                 virtual UInt_t GetStartTimeDCSQuery();
385 #endif
386
387                 /**
388                  * Function to get the end time of the DCS Archive DB request; in HLT
389                  * this is the same like the end time given in the Initialize() call
390                  * to the PredictionProcessors (NOTE: thsi is differnet to the
391                  * implementation in the Offline Shuttle - there the initial end time
392                  * is set to the end-of-data for the complete run.)
393                  */
394 #ifdef SHUTTLE_PRE_REV29388_INTERFACE
395                 virtual const UInt_t GetEndTimeDCSQuery();
396 #else
397                 virtual UInt_t GetEndTimeDCSQuery();
398 #endif
399                                 
400                 
401         protected:
402
403                 
404         private:
405         /**
406          * Function is required from interface, but is disbled in its
407          * implementation since additional refernce data will not be used by
408          * the DAs inside the HLT. Therefore always returns NULL.
409          * If this feature is lateron required by HLT, inherit from this class
410          * and overwrite this function with the required functionality.
411          *
412          * @return always NULL, since not used.
413          */
414         virtual TList* GetFileIDs(Int_t system, const char* detector,
415                 const char* source);
416
417         /**
418          * Function is required from interface, but is disbled in its
419          * implementation since additional refernce data will not be used by
420          * the DAs inside the HLT. Therefore always returns NULL.
421          * If this feature is lateron required by HLT, inherit from this class
422          * and overwrite this function with the required functionality.
423          *
424          * @return always NULL, since not used.
425          */
426         virtual TList* GetFileSources(Int_t system, const char* detector,
427                 const char* id = 0);
428
429         /**
430          * Function is required from interface, but is disbled in its
431          * implementation since additional refernce data will not be used by
432          * the DAs inside the HLT. Therefore always returns NULL.
433          * If this feature is lateron required by HLT, inherit from this class
434          * and overwrite this function with the required functionality.
435          *
436          * @return always NULL, since not used.
437          */
438         virtual const char* GetFile(Int_t system, const char* detector,
439                 const char* id, const char* source);
440
441         /**
442          * Function is required from interface, but is disbled in the Pendolino
443          * because at the moment there is no Trigger configuration available
444          * for Pendolino. At the moment it just return a NULL pointer and makes
445          * some log output.
446          *
447          * @return NULL pointer, since it should not be used.
448          */
449                 virtual const char* GetTriggerConfiguration();
450                 virtual const char* GetTriggerDetectorMask();
451
452                 /**
453                  * Disable the default constructor.
454                  */
455                 AliHLTPendolino();
456
457                 /** copy constructor prohibited */
458                 AliHLTPendolino(const AliHLTPendolino&);
459                 /** assignment operator prohibited */
460                 AliHLTPendolino& operator=(const AliHLTPendolino&);
461
462                 /**
463                  * Stores the current run type
464                  */
465                 TString fRunType;  // Stores the current run type
466
467                 /**
468                  * Stores the current run number
469                  */
470                 Int_t fRunNumber;  // Stores the current run number
471
472                 /**
473                  * Stores the HCDBpath
474                  */
475                 TString fHCDBPath;       // Stores the HCDBpath
476
477                 /**
478                  * Map that stores the all PredictionProcessors with their name
479                  * (detector)
480                  */
481                 TMap fPredictionProcessorMap;  // stores the all PredictionProcessors
482
483                 /**
484                  * Pointer to the used Pendolino logger
485                  */
486                 AliHLTPendolinoLogger* fpLogger; // Pointer to the used Pendolino logger
487
488                 /**
489                  * Indicates, if Logger is owned by Pendolino
490                  */
491                 Bool_t fOwnLogger;  //  Indicates, if Logger is owned by Pendolino
492
493                 /**
494                  * Stores the start time of the DCS Archive DB request
495                  */
496                 UInt_t fStartTime;
497
498                 /**
499                  * Stores the end time of the DCS Archive DB request
500                  */
501                 UInt_t fEndTime;
502                 
503                 ClassDef(AliHLTPendolino, 6);
504
505 };
506
507
508 inline const char* AliHLTPendolino::GetRunType() {
509         // getter for run type
510         return fRunType.Data();
511 }
512
513 inline Int_t AliHLTPendolino::GetRunNumber() {
514         // getter for run number
515         return fRunNumber;
516 }
517
518 inline Int_t AliHLTPendolino::getNumberOfPredictProc() {
519         // getter for number of registered PredictionProcessors
520         return fPredictionProcessorMap.GetSize();
521 }
522
523
524 #endif
525