]>
Commit | Line | Data |
---|---|---|
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 | ||
46 | using namespace std; | |
47 | ||
48 | ||
49 | ClassImp(AliHLTPendolino) | |
50 | ||
51 | ||
52 | /** Static string to define a local storage for the OCDB contact. */ | |
53 | const TString AliHLTPendolino::kLOCAL_STORAGE_DEFINE = "local://"; | |
54 | ||
55 | const char* AliHLTPendolino::kHLTInterfaceModule = "Pendolino-Core"; | |
56 | ||
57 | const TString AliHLTPendolino::kTaxiListBaseFolder = getenv("ALIHLT_T_HCDBDIR"); | |
58 | //"/opt/T-HCDB/lists/lists-taxi/"; | |
59 | ||
60 | const TString AliHLTPendolino::kTaxiListFolderName = "lists/lists-taxi/"; | |
61 | ||
62 | const TString AliHLTPendolino::kTaxiListPendolino = "Pendolino.list"; | |
63 | ||
64 | const Int_t AliHLTPendolino::kMAX_LINE_LENGTH = 256; | |
65 | ||
66 | const Int_t AliHLTPendolino::kHLTPendolinoException = -10; | |
67 | ||
68 | const Int_t AliHLTPendolino::kHLTPendolinoBadCast = -9; | |
69 | ||
70 | const Int_t AliHLTPendolino::kHLTPendolinoNotPredictProc = -8; | |
71 | ||
72 | const Int_t AliHLTPendolino::kHLTPendolinoModuleNotExisting = -7; | |
73 | ||
74 | const Int_t AliHLTPendolino::kHLTPendolinoNoDCS = -6; | |
75 | ||
76 | //const Int_t AliHLTPendolino:: | |
77 | ||
78 | ||
79 | ||
8d6c34c9 | 80 | AliHLTPendolino::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 | ||
98 | AliHLTPendolino::~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 | |
148 | Bool_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 | ||
202 | Bool_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 | ||
213 | Bool_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 | ||
229 | Bool_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 | ||
244 | const 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 | ||
259 | const 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 | ||
268 | ||
269 | TList* AliHLTPendolino::GetFileSources(Int_t system, const char* detector, | |
270 | const char* id) { | |
271 | // Disabled Function inherited from interface | |
272 | TString msg; | |
273 | TString det(detector); | |
274 | TString filename(id); | |
275 | TString from(GetSystemName(system)); | |
276 | msg = " ~~~ PredictProc (" + det + ") requests file sources for (" + filename | |
277 | + ") from '" + from + ". Discarding call in Pendolino."; | |
278 | Log(kHLTInterfaceModule, msg.Data()); | |
279 | ||
280 | return NULL; | |
281 | } | |
282 | ||
283 | ||
284 | TList* AliHLTPendolino::GetFileIDs(Int_t system, const char* detector, | |
285 | const char* source) { | |
286 | // Disabled Function inherited from interface | |
287 | TString msg; | |
288 | TString det(detector); | |
289 | TString filename(source); | |
290 | TString from(GetSystemName(system)); | |
291 | msg = " ~~~ PredictProc (" + det + ") requests file IDs for (" + filename | |
292 | + ") from '" + from + ". Discarding call in Pendolino."; | |
293 | Log(kHLTInterfaceModule, msg.Data()); | |
294 | ||
295 | return NULL; | |
296 | } | |
297 | ||
298 | ||
bf560255 | 299 | const char* AliHLTPendolino::GetRunParameter(const char* /*lbEntry*/) { |
e58fb035 | 300 | // getter for run parameter |
301 | ||
302 | // TODO | |
303 | // maybe using a parameter file, where these settings are stored at start up by | |
304 | // the starting script and a dedicated class read and stores its content. | |
305 | ||
306 | Log(kHLTInterfaceModule, | |
307 | " ### GetRunParameter are not defined, yet. Feature will be available soon."); | |
308 | return NULL; | |
309 | } | |
310 | ||
311 | ||
312 | Bool_t AliHLTPendolino::GetHLTStatus() { | |
313 | // getter for HLT status | |
314 | // since this is the Pendolino -> always true | |
315 | return kTRUE; | |
316 | } | |
317 | ||
318 | ||
319 | AliCDBEntry* AliHLTPendolino::GetFromOCDB(const char* detector, | |
320 | const AliCDBPath& path) { | |
321 | // fetches entry from HCDB | |
322 | AliCDBManager *man = AliCDBManager::Instance(); | |
323 | AliCDBEntry* entry = 0; | |
324 | ||
325 | if (man == 0) { | |
326 | TString msg(" *** ERROR, cannot obtain a CDB Manager reference for: "); | |
327 | msg += detector; | |
328 | Log(kHLTInterfaceModule, msg.Data()); | |
329 | return NULL; | |
330 | } | |
331 | ||
bf560255 | 332 | AliCDBStorage *hcdb = man->GetStorage(fHCDBPath.Data()); |
e58fb035 | 333 | if (hcdb == 0) { |
334 | TString msg(" *** ERROR, cannot acquire HCDB storage ("); | |
bf560255 | 335 | msg += fHCDBPath + ") for fetching data for Pendolino."; |
e58fb035 | 336 | Log(kHLTInterfaceModule, msg.Data()); |
337 | return NULL; | |
338 | } | |
339 | ||
bf560255 | 340 | entry = hcdb->Get(path, fRunNumber); |
e58fb035 | 341 | |
342 | if (entry == 0) { | |
343 | TString msg(" ~~~ WARNING: no valid entry for '"); | |
344 | msg += path.GetPath() + "' in HCDB for run number "; | |
bf560255 | 345 | msg += fRunNumber; |
e58fb035 | 346 | Log(kHLTInterfaceModule, msg.Data()); |
347 | } | |
348 | ||
349 | return entry; | |
350 | ||
351 | /* | |
352 | AliCDBEntry* entry = 0; | |
353 | try { | |
bf560255 | 354 | entry = dynamic_cast<AliCDBEntry*> (hcdb->Get(path, fRunNumber)); |
e58fb035 | 355 | } catch (std::bad_cast) { |
356 | TString msg(" *** ERROR, bad cast of HCDB entry ("); | |
357 | msg += path.GetPath() + ") after fetching from HCDB."; | |
358 | Log(kHLTInterfaceModule, msg.Data()); | |
359 | return NULL; | |
360 | } | |
361 | return entry; | |
362 | */ | |
363 | ||
364 | } | |
365 | ||
366 | ||
367 | Bool_t AliHLTPendolino::includeAliCDBEntryInList(const TString& entryPath) { | |
368 | // includes entry in Taxi list (objects to be fetched from OCDB) | |
369 | Bool_t bRet = kFALSE; | |
370 | ifstream infile; | |
371 | ofstream outfile; | |
372 | TString filename; | |
373 | TTimeStamp ts; | |
374 | ||
375 | filename = kTaxiListBaseFolder + "/" + kTaxiListFolderName + | |
376 | kTaxiListPendolino; | |
377 | Log(kHLTInterfaceModule, filename + " [DEBUG] filename"); | |
378 | ||
379 | infile.open(filename, ios_base::in); | |
380 | if (infile.is_open()) { | |
381 | char line[kMAX_LINE_LENGTH]; | |
382 | ||
383 | while (!infile.eof()) { | |
384 | infile.getline(line, kMAX_LINE_LENGTH); | |
385 | if (strncmp(line, entryPath.Data(), entryPath.Length()) == 0) { | |
386 | // entry already exists, leave function after proper clean up | |
387 | TString msg(" --- Entry '"); | |
388 | msg += entryPath + "' is already included in Taxi list file."; | |
389 | Log(kHLTInterfaceModule, msg.Data()); | |
390 | infile.close(); | |
391 | return kTRUE; | |
392 | } | |
393 | } | |
394 | infile.close(); | |
395 | ||
396 | // include entry to list | |
397 | outfile.open(filename, ios_base::out | ios_base::app); | |
398 | if (!outfile.is_open()) { | |
399 | TString msg(" *** Unable to create Pendolino list file '"); | |
400 | msg += filename + "' for Taxi. Continueing without list update..."; | |
401 | Log(kHLTInterfaceModule, msg.Data()); | |
402 | return kFALSE; | |
403 | } | |
404 | // outfile.seekp(-1, ios::end); | |
405 | outfile << endl; | |
bf560255 | 406 | outfile << "#HLT (Pendolino) - Run: " << fRunNumber << ", Time: " << |
e58fb035 | 407 | ts.AsString() << endl; |
408 | outfile << entryPath.Data() << endl; | |
409 | outfile.close(); | |
410 | ||
411 | TString msg(" +++ Included missing entry '"); | |
412 | msg += entryPath + "' in Taxi list file."; | |
413 | Log(kHLTInterfaceModule, msg.Data()); | |
414 | bRet = kTRUE; | |
415 | ||
416 | } else { | |
417 | TString msg(" ~~~ Unable to open Pendolino list file '"); | |
418 | msg += filename + "' for Taxi. Creating new one."; | |
419 | Log(kHLTInterfaceModule, msg.Data()); | |
420 | outfile.open(filename, ios_base::out); | |
421 | ||
422 | if (outfile.is_open()) { | |
423 | outfile << "# Automatic generated Taxi list." << endl; | |
424 | outfile << "# It contains the OCDB entries required by the Pendolino." | |
425 | << endl << "#" << endl; | |
426 | outfile << "# !!! DON'T EDIT THIS FILE (if you don't know what you are doing) !!!" | |
427 | << endl << endl; | |
bf560255 | 428 | outfile << "#HLT (Pendolino) - Run: " << fRunNumber << ", Time: " << |
e58fb035 | 429 | ts.AsString() << endl; |
430 | outfile << entryPath.Data() << endl; | |
431 | outfile.close(); | |
432 | bRet = kTRUE; | |
433 | ||
434 | } else { | |
bf560255 | 435 | msg=" *** Unable to create Pendolino list file '"; |
e58fb035 | 436 | msg += filename + "' for Taxi. Continueing without list update..."; |
437 | Log(kHLTInterfaceModule, msg.Data()); | |
438 | } | |
439 | } | |
440 | ||
441 | return bRet; | |
442 | } | |
443 | ||
444 | ||
445 | void AliHLTPendolino::Log(const char* detector, const char* message) { | |
446 | // logging function | |
bf560255 | 447 | fpLogger->log(detector, message); |
e58fb035 | 448 | // refer data to a Pendolino Logger, which can take care of it |
449 | } | |
450 | ||
451 | ||
452 | void AliHLTPendolino::RegisterPreprocessor(AliPreprocessor* preprocessor) { | |
453 | // registers a PredictionProcessor | |
454 | if (preprocessor == 0) { | |
455 | Log(kHLTInterfaceModule, | |
456 | " *** ERROR: Cannot register NULL pointer as PredictionProcessor."); | |
457 | return; | |
458 | } | |
459 | ||
460 | TString detector(preprocessor->GetName()); | |
461 | ||
bf560255 | 462 | if (fPredictionProcessorMap.GetValue(detector.Data())) { |
e58fb035 | 463 | Log(kHLTInterfaceModule, " ~~~ Already registered PredictionProcessor '" + |
464 | detector + "'. Ignoring call."); | |
465 | return; | |
466 | } | |
467 | // store as AliPreprocessor* and make cast to AliHLTPredictionProcessorInterface* | |
468 | // later, when accesing them. | |
bf560255 | 469 | fPredictionProcessorMap.Add(new TObjString(detector), preprocessor); |
e58fb035 | 470 | |
471 | /* | |
472 | TString detector(preprocessor->GetName()); | |
473 | AliHLTPredictionProcessorInterface* predictProc = 0; | |
474 | // UInt_t retVal = 0; | |
475 | ||
476 | // TODO move this in seperated call outside RegisterPreprocessor(..) | |
477 | // safety reason, since preprocessor is not completely generated yet | |
478 | if (!preprocessor->ProcessDCS()) { | |
479 | Log(kHLTInterfaceModule, " *** PredictionProcessor '" + detector + | |
480 | "' not registered, because it will not process DCS values."); | |
481 | return; | |
482 | } | |
483 | Log(kHLTInterfaceModule, "Module Processes DCS values, Registering PredictionProc " | |
484 | + detector); | |
485 | ||
486 | // don't use this check, if there are several PreProcs from one detector | |
487 | // they will have all have different names | |
488 | //if (GetDetPos(detector.Data()) < 0) { | |
489 | // Log(kHLTInterfaceModule, " *** Invalid detector name: " + detector); | |
490 | //} | |
491 | ||
492 | // Check if preprocessor is actually PredictionProcessor | |
493 | try { | |
494 | ||
495 | predictProc = reinterpret_cast<AliHLTPredictionProcessorInterface*> | |
496 | (preprocessor); | |
497 | // Don't use dynamic_cast or C-style cast, they only rename the pointer/object, | |
498 | // but don't import the extended members -> use reinterpret_cast. Maybe perform | |
499 | // dynamic_cast check in other function, which is not called inside a C-tor | |
500 | // of AliHLTPredictionProcessorInterface. | |
501 | ||
502 | // ATTENTION: Don't call any functions of AliHLTPredictionProcessorInterface here | |
503 | // the object has not been completely generated yet, only AliPreprocessor part | |
504 | // is available. Call of these function should be performed in seperate call outside | |
505 | // RegisterPreprocessor(..).) | |
506 | ||
507 | } catch (std::bad_cast) { | |
508 | // failed -> is not a AliHLTPredictionProcessorInterface implementation | |
509 | // -> discarding call | |
510 | Log(kHLTInterfaceModule, " *** Cannot register PredictionProcessor '" + detector + | |
511 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
512 | return; | |
513 | } catch (std::exception& e) { | |
514 | Log(kHLTInterfaceModule, " *** Exception in the registering of the PredictProc."); | |
515 | } | |
516 | ||
bf560255 | 517 | if (fPredictionProcessorMap.GetValue(detector.Data())) { |
e58fb035 | 518 | Log(kHLTInterfaceModule, " ~~~ Already registered PredictionProcessor '" + |
519 | detector + "'. Ignoring call."); | |
520 | return; | |
521 | } | |
522 | ||
bf560255 | 523 | fPredictionProcessorMap.Add(new TObjString(detector), predictProc); |
e58fb035 | 524 | */ |
525 | } | |
526 | ||
527 | ||
528 | UInt_t AliHLTPendolino::setToPredictMaking() { | |
529 | // switches prdiction making on in all registered PredictioProcessors | |
530 | UInt_t retVal = 0; | |
531 | ||
532 | // get an iterator for the map | |
bf560255 | 533 | TMapIter iter(&fPredictionProcessorMap, kIterForward); |
e58fb035 | 534 | AliHLTPredictionProcessorInterface* aPredict; |
535 | TObject* key = 0; | |
536 | ||
537 | // get each key inside the map | |
538 | while ((key = iter.Next())) { | |
539 | TString detector = key->GetName(); | |
540 | ||
541 | try { | |
542 | // get value for the key | |
543 | aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> | |
bf560255 | 544 | (fPredictionProcessorMap.GetValue(key)); |
e58fb035 | 545 | |
546 | if (aPredict == 0) { | |
547 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
548 | + detector + | |
549 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
550 | continue; | |
551 | } | |
552 | // detector = aPredict->GetName(); | |
553 | ||
554 | if ((aPredict->ProcessDCS()) && (aPredict->makePrediction() == 0)) { | |
555 | retVal++; | |
556 | } else { | |
557 | Log(kHLTInterfaceModule, " *** PredictionProcessor '" + detector | |
558 | + "' does not allow DCS processing or failed to init prediction making."); | |
559 | } | |
560 | } catch (std::bad_cast) { | |
561 | // failed -> is not a AliHLTPredictionProcessorInterface implementation | |
562 | // -> discarding call | |
563 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
564 | + detector + | |
565 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
566 | continue; | |
567 | ||
568 | } catch (std::exception& e) { | |
569 | Log(kHLTInterfaceModule, " *** Exception in call for makePrediction of " | |
570 | + detector + "."); | |
571 | continue; | |
572 | } | |
573 | } | |
574 | return retVal; | |
575 | } | |
576 | ||
577 | ||
578 | Int_t AliHLTPendolino::setToPredictMaking(TString detector) { | |
579 | // switches prediction making on in chosen PreditionProcessor | |
580 | Int_t retVal = 0; | |
581 | AliHLTPredictionProcessorInterface* aPredict = 0; | |
582 | ||
583 | try { | |
584 | // get the value for the key | |
bf560255 | 585 | TObject* object = fPredictionProcessorMap.GetValue(detector.Data()); |
e58fb035 | 586 | |
587 | if (object == 0) { | |
588 | Log(kHLTInterfaceModule, " *** No PredictionProcessor for '" + | |
589 | detector + "' registered."); | |
590 | return kHLTPendolinoModuleNotExisting; | |
591 | } | |
592 | ||
593 | aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object); | |
594 | ||
595 | if (aPredict == 0) { | |
596 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
597 | + detector + | |
598 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
599 | return kHLTPendolinoNotPredictProc; | |
600 | } | |
601 | // detector = aPredict->GetName(); | |
602 | ||
603 | if (!((aPredict->ProcessDCS()) && (aPredict->makePrediction() == 0))) { | |
604 | Log(kHLTInterfaceModule, " *** PredictionProcessor '" + detector + | |
605 | "' does not allow DCS processing or failed to init prediction making."); | |
606 | retVal = kHLTPendolinoNoDCS; | |
607 | } | |
608 | ||
609 | } catch (std::bad_cast) { | |
610 | // failed -> is not a AliHLTPredictionProcessorInterface implementation | |
611 | // -> discarding call | |
612 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
613 | + detector + | |
614 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
615 | retVal = kHLTPendolinoBadCast; | |
616 | ||
617 | } catch (std::exception& e) { | |
618 | Log(kHLTInterfaceModule, " *** Exception in call for makePrediction of " | |
619 | + detector + "."); | |
620 | retVal = kHLTPendolinoException; | |
621 | } | |
622 | ||
623 | return retVal; | |
624 | } | |
625 | ||
626 | ||
627 | Int_t AliHLTPendolino::prepareDCSValues(TString detector, TMap* DCSValues) { | |
628 | // function to prepare retrieved DCS values | |
629 | Int_t retVal = 0; | |
630 | AliHLTPredictionProcessorInterface* aPredict = 0; | |
631 | ||
632 | try { | |
633 | // get the value for the key | |
bf560255 | 634 | TObject* object = fPredictionProcessorMap.GetValue(detector.Data()); |
e58fb035 | 635 | |
636 | if (object == 0) { | |
637 | Log(kHLTInterfaceModule, " *** No PredictionProcessor for '" + | |
638 | detector + "' registered."); | |
639 | return kHLTPendolinoModuleNotExisting; | |
640 | } | |
641 | ||
642 | aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object); | |
643 | ||
644 | if (aPredict == 0) { | |
645 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
646 | + detector + | |
647 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
648 | return kHLTPendolinoNotPredictProc; | |
649 | } | |
650 | ||
651 | retVal = aPredict->Process(DCSValues); | |
652 | ||
653 | ||
654 | } catch (std::bad_cast) { | |
655 | // failed -> is not a AliHLTPredictionProcessorInterface implementation | |
656 | // -> discarding call | |
657 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
658 | + detector + | |
659 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
660 | retVal = kHLTPendolinoBadCast; | |
661 | ||
662 | } catch (std::exception& e) { | |
663 | Log(kHLTInterfaceModule, " *** Exception in call prepareDCSValues of " | |
664 | + detector + "."); | |
665 | retVal = kHLTPendolinoException; | |
666 | } | |
667 | ||
668 | return retVal; | |
669 | } | |
670 | ||
671 | TMap* AliHLTPendolino::emulateDCSMap(TString detector, TString aliasName) { | |
672 | // function to generate test data of given PredictionProcessor | |
673 | TMap* result = NULL; | |
674 | AliHLTPredictionProcessorInterface* aPredict = 0; | |
675 | ||
676 | try { | |
677 | // get the value for the key | |
bf560255 | 678 | TObject* object = fPredictionProcessorMap.GetValue(detector.Data()); |
e58fb035 | 679 | |
680 | if (object == 0) { | |
681 | Log(kHLTInterfaceModule, " *** No PredictionProcessor for '" + | |
682 | detector + "' registered."); | |
683 | return result; | |
684 | } | |
685 | ||
686 | aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object); | |
687 | ||
688 | if (aPredict == 0) { | |
689 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
690 | + detector + | |
691 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
692 | return result; | |
693 | } | |
694 | ||
695 | result = aPredict->produceTestData(aliasName); | |
696 | ||
697 | ||
698 | } catch (std::bad_cast) { | |
699 | // failed -> is not a AliHLTPredictionProcessorInterface implementation | |
700 | // -> discarding call | |
701 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
702 | + detector + | |
703 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
704 | ||
705 | } catch (std::exception& e) { | |
706 | Log(kHLTInterfaceModule, " *** Exception in call emulateDCSMap of " | |
707 | + detector + "."); | |
708 | } | |
709 | return result; | |
710 | } | |
711 | ||
712 | ||
713 | Int_t AliHLTPendolino::initPredictProc(TString detector, Int_t run, | |
714 | UInt_t startTime, UInt_t endTime) { | |
715 | // initializes given PredictionProcessor (defined by detector name) | |
716 | Int_t retVal = 0; | |
717 | AliHLTPredictionProcessorInterface* aPredict = 0; | |
718 | ||
719 | try { | |
720 | // get the value for the key | |
bf560255 | 721 | TObject* object = fPredictionProcessorMap.GetValue(detector.Data()); |
e58fb035 | 722 | |
723 | if (object == 0) { | |
724 | Log(kHLTInterfaceModule, " *** No PredictionProcessor for '" + | |
725 | detector + "' registered."); | |
726 | return kHLTPendolinoModuleNotExisting; | |
727 | } | |
728 | ||
729 | aPredict = dynamic_cast<AliHLTPredictionProcessorInterface*> (object); | |
730 | ||
731 | if (aPredict == 0) { | |
732 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
733 | + detector + | |
734 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
735 | return kHLTPendolinoNotPredictProc; | |
736 | } | |
737 | ||
738 | // Initialize Prediction Processor | |
739 | aPredict->Initialize(run, startTime, endTime); | |
740 | ||
741 | } catch (std::bad_cast) { | |
742 | // failed -> is not a AliHLTPredictionProcessorInterface implementation | |
743 | // -> discarding call | |
744 | Log(kHLTInterfaceModule, " *** Cannot use PredictionProcessor '" | |
745 | + detector + | |
746 | "'. Does not implement the AliHLTPredictionProcessorInterface."); | |
747 | retVal = kHLTPendolinoBadCast; | |
748 | ||
749 | } catch (std::exception& e) { | |
750 | Log(kHLTInterfaceModule, " *** Exception in call prepareDCSValues of " | |
751 | + detector + "."); | |
752 | retVal = kHLTPendolinoException; | |
753 | } | |
754 | ||
755 | return retVal; | |
756 | } | |
757 | ||
758 | ||
8aaabc08 | 759 | #ifdef SHUTTLE_PRE_REV29388_INTERFACE |
760 | const UInt_t AliHLTPendolino::GetStartTimeDCSQuery() | |
761 | #else | |
762 | UInt_t AliHLTPendolino::GetStartTimeDCSQuery() | |
763 | #endif | |
764 | { | |
8d6c34c9 | 765 | return fStartTime; |
766 | } | |
767 | ||
8aaabc08 | 768 | #ifdef SHUTTLE_PRE_REV29388_INTERFACE |
769 | const UInt_t AliHLTPendolino::GetEndTimeDCSQuery() | |
770 | #else | |
771 | UInt_t AliHLTPendolino::GetEndTimeDCSQuery() | |
772 | #endif | |
773 | { | |
8d6c34c9 | 774 | return fEndTime; |
775 | } | |
776 | ||
777 |