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