coding conventions
[u/mrichter/AliRoot.git] / HLT / pendolino / AliHLTPendolino.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: Sebastian Bablok <Sebastian.Bablok@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   AliHLTPendolino.cxx
20 //  @author Sebastian Bablok
21 //  @date   
22 //  @brief  
23 //  @note   maintained by Matthias.Richter@ift.uib.no
24
25 #include "AliHLTPendolino.h"
26
27 #include "AliHLTPredictionProcessorInterface.h"
28 #include "AliHLTPendolinoLogger.h"
29 #include "AliHLTPendolinoLoggerOStream.h"
30 #include "AliHLTLogging.h"
31
32 #include <AliCDBPath.h>
33 #include <AliCDBEntry.h>
34 #include <AliCDBManager.h>
35 #include <AliCDBStorage.h>
36 #include <AliPreprocessor.h>
37 #include <AliCDBId.h>
38
39 #include <TObjString.h>
40 #include <TTimeStamp.h>
41
42 #include <fstream>
43 #include <stdexcept>
44 #include <cstdlib>
45
46
47 using namespace std;
48
49
50 ClassImp(AliHLTPendolino)
51
52
53 /** Static string to define a local storage for the OCDB contact. */
54 const TString AliHLTPendolino::fgkLocalStorageDefine = "local://";
55
56 const char* AliHLTPendolino::fgkHLTInterfaceModule = "Pendolino-Core";
57
58 const TString AliHLTPendolino::fgkTaxiListBaseFolder = getenv("ALIHLT_T_HCDBDIR"); 
59 //"/opt/T-HCDB/lists/lists-taxi/";
60
61 const TString AliHLTPendolino::fgkTaxiListFolderName = "lists/lists-taxi/";
62
63 const TString AliHLTPendolino::fgkTaxiListPendolino = "Pendolino.list";
64
65 const Int_t AliHLTPendolino::fgkMaxLineLength = 256;
66
67 const Int_t AliHLTPendolino::fgkHLTPendolinoException = -10;
68
69 const Int_t AliHLTPendolino::fgkHLTPendolinoBadCast = -9;
70
71 const Int_t AliHLTPendolino::fgkHLTPendolinoNotPredictProc = -8;
72
73 const Int_t AliHLTPendolino::fgkHLTPendolinoModuleNotExisting = -7;
74
75 const Int_t AliHLTPendolino::fgkHLTPendolinoNoDCS = -6;
76
77 //const Int_t AliHLTPendolino::
78
79
80
81 AliHLTPendolino::AliHLTPendolino(Int_t run, TString HCDBbase, TString runType,
82                            AliHLTPendolinoLogger* logger, UInt_t startTime, UInt_t endTime) :
83                         fRunType(runType), fRunNumber(run),
84                         fHCDBPath(""), fPredictionProcessorMap(),
85                         fpLogger(0), fOwnLogger(kFALSE),
86                         fStartTime(startTime), fEndTime(endTime) 
87 {
88   // see header file for class documentation
89   // or
90   // refer to README to build package
91   // or
92   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
93
94         // C-tor of AliHLTPendolino
95         fHCDBPath = fgkLocalStorageDefine + HCDBbase;
96         if (logger == 0) {
97                 fpLogger = new AliHLTPendolinoLoggerOStream();
98                 fOwnLogger = kTRUE;
99         } else {
100                 fpLogger = logger;
101                 fOwnLogger = kFALSE;
102         }
103 }
104
105
106 AliHLTPendolino::~AliHLTPendolino() {
107         // D-tor of AliHLTPendolino
108         // clean up registered PredicitonProcs
109     TMapIter iter(&fPredictionProcessorMap, kIterForward);
110     AliHLTPredictionProcessorInterface* aPredict;
111     TObject* key = 0;
112
113     // get each key inside the map
114     while ((key = iter.Next())) {
115         TString detector = key->GetName();
116
117         try {
118             // get value for the key
119             aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*>
120                     (fPredictionProcessorMap.GetValue(key));
121
122             if (aPredict == 0) {
123                 Log(fgkHLTInterfaceModule, 
124                                                 " *** ERROR, cannot delete registered processor '"
125                                                 + detector + "'; does not seem to be a PredictionProcessor.");
126                 continue;
127             }
128                         Log(fgkHLTInterfaceModule, " ### [DEBUG] deleting PredictProc '" + 
129                                         detector + "'.");
130                         delete aPredict;
131         } catch (std::bad_cast) {
132             // failed -> is not a AliHLTPredictionProcessorInterface implementation
133             // -> discarding call
134             Log(fgkHLTInterfaceModule, " *** ERROR, cannot delete registered processor '"
135                     + detector + "'; does not seem to be a PredictionProcessor..");
136             continue;
137
138         } catch (std::exception& e) {
139             Log(fgkHLTInterfaceModule, 
140                                         " *** Exception in call for deleting PrecitionProcessor '"
141                     + detector + "'.");
142             continue;
143         }
144     }
145         Log(fgkHLTInterfaceModule, " ### [DEBUG] Deleting of PredictionProcessors finished.");
146
147         // clean up logger
148         if ((fOwnLogger) && (fpLogger != 0)) {
149                 delete fpLogger;
150         }
151         
152 }
153
154
155 // inherited virtual functions, maybe use them from base class
156 Bool_t AliHLTPendolino::Store(const AliCDBPath& path, TObject* object,
157                         AliCDBMetaData* metaData, Int_t validityStart, 
158                         Bool_t validityInfinite) {
159         // stores a entry in HCDB
160         Bool_t retVal = kFALSE;
161         Int_t startNumber = 0;
162         Int_t endNumber = 0;
163         AliCDBManager* man = 0; 
164         AliCDBStorage* localHCDB = 0;   
165
166         startNumber = ((fRunNumber - validityStart) <= 0) ? 0 : (fRunNumber - validityStart);
167         endNumber = (validityInfinite) ? AliCDBRunRange::Infinity() : fRunNumber;
168
169         man = AliCDBManager::Instance();
170     if (man == 0) {
171                 Log(fgkHLTInterfaceModule, " *** ERROR cannot obtain a CDB Manager reference.");
172                 return kFALSE;
173         }
174
175     // contact local storage (HCDB)
176     localHCDB = man->GetStorage(fHCDBPath.Data());
177     if (localHCDB == 0) {
178                 TString msg(" *** ERROR in initiating HCDB: ");
179                 msg += fHCDBPath;
180         Log(fgkHLTInterfaceModule, msg.Data());
181         man->DestroyActiveStorages();
182         return kFALSE;
183     }
184
185         // taken from AliShuttle
186         if (! dynamic_cast<TObjString*> (metaData->GetProperty("RunUsed(TObjString)"))) {
187         TObjString runUsed = Form("%d", fRunNumber);
188         metaData->SetProperty("RunUsed(TObjString)", runUsed.Clone());
189     }
190
191
192     // Version is set to current run, it will be used later to transfer data to Grid
193     // Why using current run number as version number ???
194         AliCDBId entryID(path, startNumber, endNumber, fRunNumber, -1);
195         
196         if (localHCDB->Put(object, entryID, metaData)) {
197                 retVal = kTRUE;
198         } else {
199                 TString msg(" *** Unable to store DCS data to HCDB: ");
200                 msg += entryID.ToString();
201         Log(fgkHLTInterfaceModule, msg.Data());
202     }
203
204         man->DestroyActiveStorages();
205
206         return retVal;
207 }
208
209
210 Bool_t AliHLTPendolino::StoreReferenceData(const AliCDBPath& path,
211                                            TObject* /*object*/, AliCDBMetaData* /*metaData*/) {
212         // Disabled Function inherited from interface
213         TString msg(" ~~~ PredictProc tries to store reference data to '" 
214                         + path.GetPath() + "'. Discarding call in Pendolino.");
215         Log(fgkHLTInterfaceModule, msg.Data());
216
217         return kFALSE;
218 }
219
220
221 Bool_t AliHLTPendolino::StoreReferenceFile(const char* detector,
222                         const char* localFile, const char* gridFileName) {
223     // Disabled Function inherited from interface
224     TString msg;
225         TString det(detector);
226         TString filename(localFile);
227         TString gridname(gridFileName);
228         msg = " ~~~ PredictProc (" + det + ") tries to store reference file (" +
229                         filename + ") to '" + gridname + 
230                         "'. Discarding call in Pendolino.";
231     Log(fgkHLTInterfaceModule, msg.Data());
232
233     return kFALSE;
234 }
235
236
237 Bool_t AliHLTPendolino::StoreRunMetadataFile(const char* localFile,
238                         const char* gridFileName) {
239     // Disabled Function inherited from interface
240     TString msg;
241
242     TString filename(localFile);
243     TString gridname(gridFileName);
244     msg = " ~~~ PredictProc tries to store 'run meta data' file (" +
245             filename + ") to '" + gridname + "'. Discarding call in Pendolino.";
246     Log(fgkHLTInterfaceModule, msg.Data());
247
248     return kFALSE;
249 }
250
251
252 const char* AliHLTPendolino::GetFile(Int_t system, const char* detector,
253                         const char* id, const char* source) {
254     // Disabled Function inherited from interface
255     TString msg;
256         TString det(detector);
257         TString filename(id);
258         TString src(source);
259         TString from(GetSystemName(system));
260         msg = " ~~~ PredictProc (" + det + ") requests file (" + filename + ") from '" 
261                         + src + "' at " + from + ". Discarding call in Pendolino.";
262         Log(fgkHLTInterfaceModule, msg.Data());
263
264         return NULL;
265 }
266
267 const char* AliHLTPendolino::GetTriggerConfiguration() {
268     // Disabled Function inherited from interface
269     TString msg;
270     msg = " ~~~ PredictProc tries to request Trigger configuration, this is disabled. Discarding call in Pendolino.";
271         Log(fgkHLTInterfaceModule, msg.Data());
272
273         return NULL;
274 }
275
276 const char* AliHLTPendolino::GetTriggerDetectorMask() {
277     // Disabled Function inherited from interface
278     TString msg;
279     msg = " ~~~ PredictProc tries to request Trigger configuration, this is disabled. Discarding call in Pendolino.";
280         Log(fgkHLTInterfaceModule, msg.Data());
281
282         return NULL;
283 }
284
285
286 TList* AliHLTPendolino::GetFileSources(Int_t system, const char* detector,
287                         const char* id) {
288         // Disabled Function inherited from interface
289     TString msg;
290     TString det(detector);
291     TString filename(id);
292     TString from(GetSystemName(system));
293     msg = " ~~~ PredictProc (" + det + ") requests file sources for (" + filename 
294                         + ") from '" + from + ". Discarding call in Pendolino.";
295     Log(fgkHLTInterfaceModule, msg.Data());
296
297     return NULL;
298 }
299
300
301 TList* AliHLTPendolino::GetFileIDs(Int_t system, const char* detector,
302                         const char* source) {
303     // Disabled Function inherited from interface
304     TString msg;
305     TString det(detector);
306     TString filename(source);
307     TString from(GetSystemName(system));
308     msg = " ~~~ PredictProc (" + det + ") requests file IDs for (" + filename
309             + ") from '" + from + ". Discarding call in Pendolino.";
310     Log(fgkHLTInterfaceModule, msg.Data());
311
312     return NULL;
313 }
314
315
316 const char* AliHLTPendolino::GetRunParameter(const char* /*lbEntry*/) {
317         // getter for run parameter
318                 
319 // TODO
320 // maybe using a parameter file, where these settings are stored at start up by
321 // the starting script and a dedicated class read and stores its content.
322
323         Log(fgkHLTInterfaceModule, 
324                         " ### GetRunParameter are not defined, yet. Feature will be available soon.");
325         return NULL;
326 }
327
328
329 Bool_t AliHLTPendolino::GetHLTStatus() {
330         // getter for HLT status
331         // since this is the Pendolino -> always true
332         return kTRUE;
333 }
334
335
336 AliCDBEntry* AliHLTPendolino::GetFromOCDB(const char* detector,
337                         const AliCDBPath& path) {
338         // fetches entry from HCDB
339         AliCDBManager *man = AliCDBManager::Instance();
340         AliCDBEntry* entry = 0;
341         
342         if (man == 0) {
343                 TString msg(" *** ERROR, cannot obtain a CDB Manager reference for: ");
344                 msg += detector;
345                 Log(fgkHLTInterfaceModule, msg.Data());
346                 return NULL;
347         }
348
349         AliCDBStorage *hcdb = man->GetStorage(fHCDBPath.Data());
350         if (hcdb == 0) {
351                 TString msg(" *** ERROR, cannot acquire HCDB storage (");
352                 msg += fHCDBPath + ") for fetching data for Pendolino.";
353                 Log(fgkHLTInterfaceModule, msg.Data());
354                 return NULL;
355         }
356         
357         entry = hcdb->Get(path, fRunNumber);
358
359         if (entry == 0) {
360                 TString msg(" ~~~ WARNING: no valid entry for '");
361                 msg += path.GetPath() + "' in HCDB for run number ";
362                 msg += fRunNumber;
363                 Log(fgkHLTInterfaceModule, msg.Data());
364         }
365
366         return entry;
367         
368 /*
369         AliCDBEntry* entry = 0;
370         try {
371                 entry = dynamic_cast<AliCDBEntry*> (hcdb->Get(path, fRunNumber));
372         } catch (std::bad_cast) {
373                 TString msg(" *** ERROR, bad cast of HCDB entry (");
374                 msg += path.GetPath() + ") after fetching from HCDB.";
375                 Log(fgkHLTInterfaceModule, msg.Data());
376                 return NULL;
377         }
378         return entry;
379 */
380
381 }
382
383
384 Bool_t AliHLTPendolino::IncludeAliCDBEntryInList(const TString& entryPath) {
385         // includes entry in Taxi list (objects to be fetched from OCDB)
386         Bool_t bRet = kFALSE;
387         ifstream infile;
388         ofstream outfile;
389         TString filename;
390         TTimeStamp ts;
391
392         filename = fgkTaxiListBaseFolder + "/" + fgkTaxiListFolderName + 
393                         fgkTaxiListPendolino;
394         Log(fgkHLTInterfaceModule, filename + " [DEBUG] filename");
395
396         infile.open(filename, ios_base::in);
397         if (infile.is_open()) {
398                 char line[fgkMaxLineLength];
399
400                 while (!infile.eof()) {
401                         infile.getline(line, fgkMaxLineLength);
402                         if (strncmp(line, entryPath.Data(), entryPath.Length()) == 0) {
403                                         // entry already exists, leave function after proper clean up
404                                 TString msg(" --- Entry '");
405                                 msg += entryPath + "' is already included in Taxi list file.";
406                                 Log(fgkHLTInterfaceModule, msg.Data()); 
407                                 infile.close();
408                                 return kTRUE;
409                         }
410                 }
411                 infile.close();
412                 
413                 // include entry to list
414                 outfile.open(filename, ios_base::out | ios_base::app);
415                 if (!outfile.is_open()) {
416                         TString msg(" *** Unable to create Pendolino list file '");
417                         msg += filename + "' for Taxi. Continueing without list update...";
418                         Log(fgkHLTInterfaceModule, msg.Data());
419                         return kFALSE;
420                 }
421 //              outfile.seekp(-1, ios::end);
422                 outfile << endl;
423                 outfile << "#HLT (Pendolino) - Run: " << fRunNumber << ", Time: " <<
424                                 ts.AsString() << endl;
425                 outfile << entryPath.Data() << endl;
426                 outfile.close();
427
428                 TString msg(" +++ Included missing entry '");
429                 msg += entryPath + "' in Taxi list file.";
430                 Log(fgkHLTInterfaceModule, msg.Data());
431                 bRet = kTRUE;
432                 
433         } else {
434                 TString msg(" ~~~ Unable to open Pendolino list file '");
435                 msg += filename + "' for Taxi. Creating new one.";
436                 Log(fgkHLTInterfaceModule, msg.Data());
437                 outfile.open(filename, ios_base::out);
438                 
439                 if (outfile.is_open()) {
440                         outfile << "# Automatic generated Taxi list." << endl;
441                         outfile << "# It contains the OCDB entries required by the Pendolino." 
442                                         << endl << "#" << endl;
443                         outfile << "#    !!! DON'T EDIT THIS FILE (if you don't know what you are doing) !!!"
444                                         << endl << endl;
445                         outfile << "#HLT (Pendolino) - Run: " << fRunNumber << ", Time: " << 
446                                         ts.AsString() << endl;
447                         outfile << entryPath.Data() << endl;
448                         outfile.close();
449                         bRet = kTRUE;
450                 
451                 } else {
452                         msg=" *** Unable to create Pendolino list file '";
453                         msg += filename + "' for Taxi. Continueing without list update...";
454                         Log(fgkHLTInterfaceModule, msg.Data());
455                 }       
456         }
457         
458         return bRet;
459 }
460
461
462 void AliHLTPendolino::Log(const char* detector, const char* message) {
463         // logging function
464         fpLogger->log(detector, message);
465         // refer data to a Pendolino Logger, which can take care of it
466 }
467
468
469 void AliHLTPendolino::RegisterPreprocessor(AliPreprocessor* preprocessor) {
470         // registers a PredictionProcessor
471         if (preprocessor == 0) {
472                 Log(fgkHLTInterfaceModule, 
473                                 " *** ERROR: Cannot register NULL pointer as PredictionProcessor.");
474                 return; 
475         }
476
477     TString detector(preprocessor->GetName());
478
479     if (fPredictionProcessorMap.GetValue(detector.Data())) {
480         Log(fgkHLTInterfaceModule, " ~~~ Already registered PredictionProcessor '" +
481                 detector + "'. Ignoring call.");
482         return;
483     }
484         // store as AliPreprocessor* and make cast to AliHLTPredictionProcessorInterface*
485         // later, when accesing them.
486     fPredictionProcessorMap.Add(new TObjString(detector), preprocessor);
487
488 /*      
489         TString detector(preprocessor->GetName());
490         AliHLTPredictionProcessorInterface* predictProc = 0;
491 //      UInt_t retVal = 0;
492
493         // TODO move this in seperated call outside RegisterPreprocessor(..)
494         // safety reason, since preprocessor is not completely generated yet
495         if (!preprocessor->ProcessDCS()) {
496                 Log(fgkHLTInterfaceModule, " *** PredictionProcessor '" + detector +
497                                 "' not registered, because it will not process DCS values.");
498                 return;
499         }
500         Log(fgkHLTInterfaceModule, "Module Processes DCS values, Registering PredictionProc " 
501                         + detector);
502         
503         // don't use this check, if there are several PreProcs from one detector
504         // they will have all have different names
505         //if (GetDetPos(detector.Data()) < 0) {
506         //      Log(fgkHLTInterfaceModule, "   *** Invalid detector name: " + detector);
507         //}
508
509         // Check if preprocessor is actually PredictionProcessor
510         try {
511
512                 predictProc = reinterpret_cast<AliHLTPredictionProcessorInterface*> 
513                                 (preprocessor);
514 // Don't use dynamic_cast or C-style cast, they only rename the pointer/object, 
515 // but don't import the extended members -> use reinterpret_cast. Maybe perform 
516 // dynamic_cast check in  other function, which is not called inside a C-tor 
517 // of AliHLTPredictionProcessorInterface.
518                 
519 // ATTENTION: Don't call any functions of AliHLTPredictionProcessorInterface here
520 // the object has not been completely generated yet, only AliPreprocessor part
521 // is available. Call of these function should be performed in seperate call outside
522 // RegisterPreprocessor(..).)
523
524         } catch (std::bad_cast) { 
525                 // failed -> is not a AliHLTPredictionProcessorInterface implementation
526                 // -> discarding call
527                 Log(fgkHLTInterfaceModule, " *** Cannot register PredictionProcessor '" + detector +
528                                 "'. Does not implement the AliHLTPredictionProcessorInterface.");
529                 return;
530         } catch (std::exception& e) {
531                 Log(fgkHLTInterfaceModule, " *** Exception in the registering of the PredictProc.");            
532         }
533
534         if (fPredictionProcessorMap.GetValue(detector.Data())) {
535                 Log(fgkHLTInterfaceModule, " ~~~ Already registered PredictionProcessor '" +
536                                 detector + "'. Ignoring call.");
537                 return;
538         }
539
540         fPredictionProcessorMap.Add(new TObjString(detector), predictProc);
541 */
542 }
543
544
545 UInt_t AliHLTPendolino::SetToPredictMaking() {
546         // switches prdiction making on in all registered PredictioProcessors
547         UInt_t retVal = 0;
548
549         // get an iterator for the map
550         TMapIter iter(&fPredictionProcessorMap, kIterForward);
551         AliHLTPredictionProcessorInterface* aPredict;
552         TObject* key = 0;       
553         
554         // get each key inside the map
555         while ((key = iter.Next())) {
556                 TString detector = key->GetName();
557                 
558                 try {
559                         // get value for the key
560                         aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*>
561                                         (fPredictionProcessorMap.GetValue(key));
562                 
563                         if (aPredict == 0) {
564                                 Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
565                                                 + detector +
566                                                 "'. Does not implement the AliHLTPredictionProcessorInterface.");
567                                 continue;
568                         }
569 //                      detector = aPredict->GetName();
570                         
571                         if ((aPredict->ProcessDCS()) && (aPredict->makePrediction() == 0)) {
572                                 retVal++;
573                         } else {
574                                 Log(fgkHLTInterfaceModule, " *** PredictionProcessor '" + detector
575                                                 + "' does not allow DCS processing or failed to init prediction making.");
576                         }
577                 } catch (std::bad_cast) {
578                 // failed -> is not a AliHLTPredictionProcessorInterface implementation
579             // -> discarding call
580                 Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '" 
581                                         + detector +
582                     "'. Does not implement the AliHLTPredictionProcessorInterface.");
583                 continue;
584
585                 } catch (std::exception& e) {
586                         Log(fgkHLTInterfaceModule, " *** Exception in call for makePrediction of " 
587                                         + detector + ".");
588                         continue;
589                 }
590         }
591         return retVal;
592 }
593
594
595 Int_t AliHLTPendolino::setToPredictMaking(TString detector) {
596         // switches prediction making on in chosen PreditionProcessor
597         Int_t retVal = 0;
598         AliHLTPredictionProcessorInterface* aPredict = 0;
599         
600         try {
601                 // get the value for the key
602                 TObject* object = fPredictionProcessorMap.GetValue(detector.Data());
603
604                 if (object == 0) {
605                         Log(fgkHLTInterfaceModule, " *** No PredictionProcessor for '" +
606                                         detector + "' registered.");
607                         return fgkHLTPendolinoModuleNotExisting;
608                 }
609                                 
610                 aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object);
611
612                 if (aPredict == 0) {
613                         Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
614                                         + detector +
615                                         "'. Does not implement the AliHLTPredictionProcessorInterface.");
616                         return fgkHLTPendolinoNotPredictProc;
617                 }
618 //            detector = aPredict->GetName();
619
620                 if (!((aPredict->ProcessDCS()) && (aPredict->makePrediction() == 0))) {
621                         Log(fgkHLTInterfaceModule, " *** PredictionProcessor '" + detector +
622                                         "' does not allow DCS processing or failed to init prediction making.");
623                         retVal = fgkHLTPendolinoNoDCS;
624                 }
625                 
626         } catch (std::bad_cast) {
627                 // failed -> is not a AliHLTPredictionProcessorInterface implementation
628                 // -> discarding call
629                 Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
630                                 + detector +
631                                 "'. Does not implement the AliHLTPredictionProcessorInterface.");
632                 retVal = fgkHLTPendolinoBadCast;
633
634         } catch (std::exception& e) {
635                 Log(fgkHLTInterfaceModule, " *** Exception in call for makePrediction of "
636                                 + detector + ".");
637                 retVal = fgkHLTPendolinoException;
638     }
639         
640     return retVal;
641 }
642
643
644 Int_t AliHLTPendolino::PrepareDCSValues(TString detector, TMap* DCSValues) {
645         // function to prepare retrieved DCS values
646         Int_t retVal = 0;
647         AliHLTPredictionProcessorInterface* aPredict = 0;
648
649         try {
650                 // get the value for the key
651                 TObject* object = fPredictionProcessorMap.GetValue(detector.Data());
652                 
653                 if (object == 0) {
654                         Log(fgkHLTInterfaceModule, " *** No PredictionProcessor for '" +
655                                         detector + "' registered.");
656                         return fgkHLTPendolinoModuleNotExisting;
657                 }
658                                 
659                 aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object);
660
661                 if (aPredict == 0) {
662                         Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
663                                         + detector +
664                                         "'. Does not implement the AliHLTPredictionProcessorInterface.");
665                         return fgkHLTPendolinoNotPredictProc;
666                 }
667
668                 retVal = aPredict->Process(DCSValues);
669
670
671         } catch (std::bad_cast) {
672                 // failed -> is not a AliHLTPredictionProcessorInterface implementation
673                 // -> discarding call
674                 Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
675                                 + detector +
676                                 "'. Does not implement the AliHLTPredictionProcessorInterface.");
677                 retVal = fgkHLTPendolinoBadCast;
678
679         } catch (std::exception& e) {
680                 Log(fgkHLTInterfaceModule, " *** Exception in call prepareDCSValues of "
681                                 + detector + ".");
682                 retVal = fgkHLTPendolinoException;
683         }
684         
685         return retVal;  
686 }
687
688 TMap* AliHLTPendolino::EmulateDCSMap(TString detector, TString aliasName) {
689         // function to generate test data of given PredictionProcessor
690         TMap* result = NULL;
691         AliHLTPredictionProcessorInterface* aPredict = 0;
692
693     try {
694         // get the value for the key
695         TObject* object = fPredictionProcessorMap.GetValue(detector.Data());
696
697         if (object == 0) {
698             Log(fgkHLTInterfaceModule, " *** No PredictionProcessor for '" +
699                     detector + "' registered.");
700             return result;
701         }
702
703         aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object);
704
705         if (aPredict == 0) {
706             Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
707                     + detector +
708                     "'. Does not implement the AliHLTPredictionProcessorInterface.");
709             return result;
710         }
711
712         result = aPredict->produceTestData(aliasName);
713
714
715     } catch (std::bad_cast) {
716         // failed -> is not a AliHLTPredictionProcessorInterface implementation
717         // -> discarding call
718         Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
719                 + detector +
720                 "'. Does not implement the AliHLTPredictionProcessorInterface.");
721
722     } catch (std::exception& e) {
723         Log(fgkHLTInterfaceModule, " *** Exception in call emulateDCSMap of "
724                 + detector + ".");
725     }
726         return result;
727 }
728
729
730 Int_t AliHLTPendolino::initPredictProc(TString detector, Int_t run, 
731                         UInt_t startTime, UInt_t endTime) {
732         // initializes given PredictionProcessor (defined by detector name)
733     Int_t retVal = 0;
734     AliHLTPredictionProcessorInterface* aPredict = 0;
735
736     try {
737         // get the value for the key
738         TObject* object = fPredictionProcessorMap.GetValue(detector.Data());
739
740         if (object == 0) {
741             Log(fgkHLTInterfaceModule, " *** No PredictionProcessor for '" +
742                     detector + "' registered.");
743             return fgkHLTPendolinoModuleNotExisting;
744         }
745
746         aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object);
747
748         if (aPredict == 0) {
749             Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
750                     + detector +
751                     "'. Does not implement the AliHLTPredictionProcessorInterface.");
752             return fgkHLTPendolinoNotPredictProc;
753         }
754                 
755                 // Initialize Prediction Processor
756                 aPredict->Initialize(run, startTime, endTime);
757
758     } catch (std::bad_cast) {
759         // failed -> is not a AliHLTPredictionProcessorInterface implementation
760         // -> discarding call
761         Log(fgkHLTInterfaceModule, " *** Cannot use PredictionProcessor '"
762                 + detector +
763                 "'. Does not implement the AliHLTPredictionProcessorInterface.");
764         retVal = fgkHLTPendolinoBadCast;
765
766     } catch (std::exception& e) {
767         Log(fgkHLTInterfaceModule, " *** Exception in call prepareDCSValues of "
768                 + detector + ".");
769         retVal = fgkHLTPendolinoException;
770     }
771
772     return retVal;
773 }
774
775
776 #ifdef SHUTTLE_PRE_REV29388_INTERFACE
777 const UInt_t AliHLTPendolino::GetStartTimeDCSQuery()
778 #else
779 UInt_t AliHLTPendolino::GetStartTimeDCSQuery()
780 #endif
781 {
782         return fStartTime;
783 }
784
785 #ifdef SHUTTLE_PRE_REV29388_INTERFACE
786 const UInt_t AliHLTPendolino::GetEndTimeDCSQuery()
787 #else
788 UInt_t AliHLTPendolino::GetEndTimeDCSQuery()
789 #endif
790 {
791         return fEndTime;
792 }
793
794 void AliHLTPendolino::Log(const char* name , const char* message, UInt_t level)
795 {
796   // overloaded function of the shuttle interface
797   // translate into HLT log message
798   AliHLTLogging log;
799   AliHLTComponentLogSeverity severity=kHLTLogInfo;
800   switch (level) {
801   case 1: severity=kHLTLogBenchmark; break;
802   case 2: severity=kHLTLogDebug; break;
803   case 3: severity=kHLTLogInfo; break;
804   case 4: severity=kHLTLogWarning; break;
805   default: severity=kHLTLogError;
806   }
807   log.LoggingVarargs(severity, "AliHLTPendolino", name , __FILE__ , __LINE__ , message);
808 }
809