]>
Commit | Line | Data |
---|---|---|
154cba94 | 1 | /************************************************************************** |
2 | * This file is property of and copyright by the ALICE HLT Project * | |
3 | * All rights reserved. * | |
4 | * * | |
5 | * Primary Authors: * | |
6 | * Artur Szostak <artursz@iafrica.com> * | |
7 | * * | |
8 | * Permission to use, copy, modify and distribute this software and its * | |
9 | * documentation strictly for non-commercial purposes is hereby granted * | |
10 | * without fee, provided that the above copyright notice appears in all * | |
11 | * copies and that both the copyright notice and this permission notice * | |
12 | * appear in the supporting documentation. The authors make no claims * | |
13 | * about the suitability of this software for any purpose. It is * | |
14 | * provided "as is" without express or implied warranty. * | |
15 | **************************************************************************/ | |
16 | ||
17 | /* $Id: $ */ | |
18 | ||
19 | /// | |
20 | /// @file AliHLTMUONProcessor.cxx | |
21 | /// @author Artur Szostak <artursz@iafrica.com> | |
dba14d7d | 22 | /// @date 19 May 2008 |
154cba94 | 23 | /// @brief Implementation of the abstract base dHLT processor component. |
24 | /// | |
25 | /// This component is the abstract base class of dHLT specific components. | |
26 | /// It implements some common methods used by all the dHLT components. | |
27 | /// | |
28 | ||
29 | #include "AliHLTMUONProcessor.h" | |
17d68f2a | 30 | #include "AliMUONRecoParam.h" |
dba14d7d | 31 | #include "AliCDBManager.h" |
32 | #include "AliCDBStorage.h" | |
ffc1a6f6 | 33 | #include "AliCDBEntry.h" |
dba14d7d | 34 | #include "AliMpCDB.h" |
35 | #include "AliMpDDLStore.h" | |
36 | #include "AliMpDEStore.h" | |
ffc1a6f6 | 37 | #include "TMap.h" |
38 | #include "TObjString.h" | |
39 | #include "TString.h" | |
ffb64d3e | 40 | #include <string> |
41 | #include <cstdlib> | |
42 | #include <fstream> | |
43 | ||
154cba94 | 44 | |
45 | ClassImp(AliHLTMUONProcessor) | |
46 | ||
dba14d7d | 47 | |
ffb64d3e | 48 | AliHLTMUONProcessor::AliHLTMUONProcessor() : |
49 | AliHLTProcessor(), | |
50 | fWarnForUnexpecedBlock(false), | |
51 | fDelaySetup(false), | |
52 | fDumpDataOnError(false), | |
53 | fDumpPath("./") | |
54 | { | |
55 | /// Default constructor. | |
56 | } | |
57 | ||
58 | ||
59 | int AliHLTMUONProcessor::DoInit(int argc, const char** argv) | |
60 | { | |
61 | /// Parses common dHLT component arguments. | |
62 | ||
63 | // Set the default values for various arguments comming from the command line. | |
64 | fDelaySetup = false; | |
65 | fDumpDataOnError = false; | |
66 | fDumpPath = "./"; | |
67 | const char* cdbPath = NULL; | |
68 | Int_t run = -1; | |
69 | ||
70 | for (int i = 0; i < argc; i++) | |
71 | { | |
72 | // Ignore the argument if the child class indicates to do so. | |
73 | if (IgnoreArgument(argv[i])) continue; | |
74 | ||
75 | if (strcmp(argv[i], "-cdbpath") == 0) | |
76 | { | |
77 | if (cdbPath != NULL) | |
78 | { | |
79 | HLTWarning("CDB path was already specified. Will" | |
80 | " replace previous value given by -cdbpath." | |
81 | ); | |
82 | } | |
83 | if (argc <= i+1) | |
84 | { | |
85 | HLTError("The CDB path was not specified." ); | |
86 | return -EINVAL; | |
87 | } | |
88 | cdbPath = argv[i+1]; | |
89 | i++; | |
90 | continue; | |
91 | } | |
92 | ||
93 | if (strcmp(argv[i], "-run") == 0) | |
94 | { | |
95 | if (run != -1) | |
96 | { | |
97 | HLTWarning("Run number was already specified. Will" | |
98 | " replace previous value given by -run." | |
99 | ); | |
100 | } | |
101 | if (argc <= i+1) | |
102 | { | |
103 | HLTError("The run number was not specified."); | |
104 | return -EINVAL; | |
105 | } | |
106 | ||
107 | char* cpErr = NULL; | |
108 | run = Int_t( strtol(argv[i+1], &cpErr, 0) ); | |
109 | if (cpErr == NULL or *cpErr != '\0' or run < 0) | |
110 | { | |
111 | HLTError("Cannot convert '%s' to a valid run number." | |
112 | " Expected a positive integer value.", argv[i+1] | |
113 | ); | |
114 | return -EINVAL; | |
115 | } | |
116 | ||
117 | i++; | |
118 | continue; | |
119 | } | |
120 | ||
121 | if (strcmp(argv[i], "-delaysetup") == 0) | |
122 | { | |
123 | fDelaySetup = true; | |
124 | continue; | |
125 | } | |
126 | ||
127 | if (strcmp(argv[i], "-dumponerror") == 0) | |
128 | { | |
129 | fDumpDataOnError = true; | |
130 | continue; | |
131 | } | |
132 | ||
133 | if (strcmp(argv[i], "-dumppath") == 0) | |
134 | { | |
135 | if (fDumpPath != NULL) | |
136 | { | |
137 | HLTWarning("The dump path was already specified. Will" | |
138 | " replace previous value given by -dumppath." | |
139 | ); | |
140 | } | |
141 | if (argc <= i+1) | |
142 | { | |
143 | HLTError("The dump path was not specified."); | |
144 | return -EINVAL; | |
145 | } | |
146 | fDumpPath = argv[i+1]; | |
147 | i++; | |
148 | continue; | |
149 | } | |
150 | } | |
151 | ||
152 | if (cdbPath != NULL or run != -1) | |
153 | { | |
154 | int result = SetCDBPathAndRunNo(cdbPath, run); | |
155 | if (result != 0) | |
156 | { | |
157 | // Error messages already generated in SetCDBPathAndRunNo. | |
158 | return result; | |
159 | } | |
160 | } | |
161 | ||
162 | return 0; | |
163 | } | |
164 | ||
165 | ||
166 | bool AliHLTMUONProcessor::ArgumentAlreadyHandled(int& i, const char* argi) const | |
167 | { | |
168 | /// This method can be used by the derivind child class to check if a particular | |
169 | /// argument in argv was already processed. | |
170 | ||
171 | if (strcmp(argi, "-cdbpath") == 0) | |
172 | { | |
173 | if (IgnoreArgument(argi)) return false; | |
a63da6d6 | 174 | i++; // argument takes one parameter |
ffb64d3e | 175 | return true; |
176 | } | |
177 | ||
178 | if (strcmp(argi, "-run") == 0) | |
179 | { | |
180 | if (IgnoreArgument(argi)) return false; | |
a63da6d6 | 181 | i++; // argument takes one parameter |
ffb64d3e | 182 | return true; |
183 | } | |
184 | ||
185 | if (strcmp(argi, "-delaysetup") == 0) | |
186 | { | |
187 | if (IgnoreArgument(argi)) return false; | |
188 | return true; | |
189 | } | |
190 | ||
191 | if (strcmp(argi, "-dumponerror") == 0) | |
192 | { | |
193 | if (IgnoreArgument(argi)) return false; | |
194 | return true; | |
195 | } | |
196 | ||
197 | if (strcmp(argi, "-dumppath") == 0) | |
198 | { | |
199 | if (IgnoreArgument(argi)) return false; | |
a63da6d6 | 200 | i++; // argument takes one parameter |
ffb64d3e | 201 | return true; |
202 | } | |
203 | ||
204 | return false; | |
205 | } | |
206 | ||
207 | ||
ffc1a6f6 | 208 | int AliHLTMUONProcessor::SetCDBPathAndRunNo( |
dba14d7d | 209 | const char* cdbPath, Int_t run, bool useDefault |
210 | ) const | |
211 | { | |
ffc1a6f6 | 212 | /// Sets the CDB path and run number to read from. |
dba14d7d | 213 | /// \param cdbPath The CDB path to use. If set to NULL and the path has |
214 | /// not been set in the CDB manager then the default path | |
162637e4 | 215 | /// "local://$ALICE_ROOT/OCDB" is used if the 'useDefault' flag is also true. |
dba14d7d | 216 | /// \param run The run number to use. If set to -1 and the run number has |
217 | /// not been set in the CDB manager then a value of zero is used if | |
218 | /// the 'useDefault' flag is also true. | |
ffc1a6f6 | 219 | /// \param useDefault If set to true then a default CDB path and/or run number |
dba14d7d | 220 | /// is used if they have not been set and 'cdbPath' == NULL or |
ffc1a6f6 | 221 | /// 'run' == -1. |
222 | /// \return Zero if the object could be loaded. Otherwise an error code, | |
223 | /// compatible with the HLT framework, is returned. | |
dba14d7d | 224 | |
162637e4 | 225 | const char* defaultPath = "local://$ALICE_ROOT/OCDB"; |
dba14d7d | 226 | Int_t defaultRun = 0; |
227 | ||
228 | AliCDBManager* cdbManager = AliCDBManager::Instance(); | |
229 | if (cdbManager == NULL) | |
230 | { | |
231 | HLTError("CDB manager instance does not exist."); | |
232 | return -EIO; | |
233 | } | |
234 | ||
235 | // Setup the CDB path. | |
dba14d7d | 236 | if (cdbPath != NULL) |
237 | { | |
238 | cdbManager->SetDefaultStorage(cdbPath); | |
dba14d7d | 239 | } |
ffc1a6f6 | 240 | else if (not cdbManager->IsDefaultStorageSet() and useDefault) |
dba14d7d | 241 | { |
ffc1a6f6 | 242 | cdbManager->SetDefaultStorage(defaultPath); |
dba14d7d | 243 | } |
244 | ||
245 | // Now setup the run number. | |
246 | if (run != -1) | |
247 | { | |
248 | cdbManager->SetRun(run); | |
249 | } | |
250 | else | |
251 | { | |
252 | if (useDefault) cdbManager->SetRun(defaultRun); | |
253 | } | |
ffc1a6f6 | 254 | |
255 | return 0; | |
256 | } | |
257 | ||
258 | ||
259 | int AliHLTMUONProcessor::FetchMappingStores() const | |
260 | { | |
261 | /// Fetches the DDL and detector element store objects for MUON mapping. | |
262 | /// \return Zero if the objects could be loaded. Otherwise an error code, | |
263 | /// which is compatible with the HLT framework, is returned. | |
264 | /// \note AliMpDDLStore::Instance() and AliMpDEStore::Instance() must be used | |
265 | /// to fetch the objects after this method returns a code equal to zero. | |
266 | ||
267 | Bool_t warn = kFALSE; | |
268 | ||
269 | // Check if the objects are already loaded. If they are then exit early, | |
270 | // otherwise we need to try load the objects. | |
271 | if (AliMpDDLStore::Instance(warn) != NULL and AliMpDEStore::Instance(warn) != NULL) | |
272 | return 0; | |
273 | ||
274 | AliCDBManager* cdbManager = AliCDBManager::Instance(); | |
275 | if (cdbManager == NULL) | |
276 | { | |
277 | HLTError("CDB manager instance does not exist."); | |
278 | return -EIO; | |
279 | } | |
280 | ||
281 | const char* cdbPathUsed = "unknown (not set)"; | |
282 | AliCDBStorage* store = cdbManager->GetDefaultStorage(); | |
283 | if (store != NULL) cdbPathUsed = store->GetURI().Data(); | |
284 | ||
dba14d7d | 285 | Int_t runUsed = cdbManager->GetRun(); |
286 | ||
287 | // Now we can try load the DDL and DE store objects. | |
dba14d7d | 288 | if (not AliMpCDB::LoadDDLStore(warn)) |
289 | { | |
290 | HLTError("Failed to load DDL or detector element store specified" | |
291 | " for CDB path '%s' and run no. %d.", | |
292 | cdbPathUsed, runUsed | |
293 | ); | |
294 | return -ENOENT; | |
295 | } | |
296 | ||
550ea228 | 297 | if (AliMpDDLStore::Instance(warn) == NULL or AliMpDEStore::Instance(warn) == NULL) |
dba14d7d | 298 | { |
299 | HLTError("Could not find or load the DDL or detector element store instance."); | |
300 | return -EIO; | |
301 | } | |
302 | ||
303 | return 0; | |
304 | } | |
305 | ||
ffc1a6f6 | 306 | |
307 | int AliHLTMUONProcessor::FetchTMapFromCDB(const char* pathToEntry, TMap*& map) const | |
308 | { | |
309 | /// Fetches a TMap object from the CDB. | |
310 | /// [in] \param pathToEntry The relative path to the entry in the CDB to fetch. | |
311 | /// [out] \param map This will be filled with the TMap object found if | |
312 | /// a successful status code is returned. Otherwise it will be unchanged. | |
313 | /// \return Zero if the object could be found. Otherwise an error code, | |
314 | /// which is compatible with the HLT framework, is returned. | |
315 | ||
316 | assert(AliCDBManager::Instance() != NULL); | |
317 | ||
21b32623 | 318 | AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage(); |
319 | if (store == NULL) | |
320 | { | |
321 | HLTError("Could not get the the default storage for the CDB."); | |
322 | return -EIO; | |
323 | } | |
324 | ||
325 | Int_t version = store->GetLatestVersion(pathToEntry, GetRunNo()); | |
326 | Int_t subVersion = store->GetLatestSubVersion(pathToEntry, GetRunNo(), version); | |
327 | AliCDBEntry* entry = AliCDBManager::Instance()->Get(pathToEntry, GetRunNo(), version, subVersion); | |
ffc1a6f6 | 328 | if (entry == NULL) |
329 | { | |
330 | HLTError("Could not get the CDB entry for \"%s\".", pathToEntry); | |
331 | return -EIO; | |
332 | } | |
333 | ||
334 | TObject* obj = entry->GetObject(); | |
335 | if (obj == NULL) | |
336 | { | |
337 | HLTError("Configuration object for \"%s\" is missing.", pathToEntry); | |
338 | return -ENOENT; | |
339 | } | |
340 | ||
341 | if (obj->IsA() != TMap::Class()) | |
342 | { | |
343 | HLTError("Wrong type for configuration object in \"%s\". Found a %s but we need a TMap.", | |
344 | pathToEntry, obj->ClassName() | |
345 | ); | |
346 | return -EPROTO; | |
347 | } | |
348 | map = dynamic_cast<TMap*>(obj); | |
349 | ||
350 | return 0; | |
351 | } | |
352 | ||
353 | ||
354 | int AliHLTMUONProcessor::GetValueFromTMap( | |
355 | TMap* map, const char* paramName, TString& value, | |
356 | const char* pathToEntry, const char* prettyName | |
357 | ) const | |
358 | { | |
359 | /// Tries to find the string value associated with a certain parameter in a TMap. | |
360 | /// [in] \param map The TMap object to search in. | |
361 | /// [in] \param paramName The name of the parameter to search for. | |
362 | /// [out] \param value Will be filled with the object found. | |
363 | /// [in] \param pathToEntry The relative path to the entry in the CDB. | |
364 | /// Used when printing error messages. If set to NULL then a string of | |
365 | /// "(unknown)" is used. (default is NULL). | |
366 | /// [in] \param prettyName Should be the name of the parameter which will | |
367 | /// be used when printing error messages. If this is set to NULL then | |
368 | /// the paramName will be used instead (default is NULL). | |
369 | /// \return Zero if the object could be found. Otherwise an error code, | |
370 | /// which is compatible with the HLT framework, is returned. | |
371 | ||
372 | if (pathToEntry == NULL) pathToEntry = "(unknown)"; | |
373 | if (prettyName == NULL) prettyName = paramName; | |
374 | ||
375 | TPair* pair = static_cast<TPair*>(map->FindObject(paramName)); | |
376 | if (pair == NULL) | |
377 | { | |
378 | HLTError("Configuration object for \"%s\" does not contain the %s value.", | |
379 | pathToEntry, prettyName | |
380 | ); | |
381 | return -ENOENT; | |
382 | } | |
383 | TObject* valueObj = pair->Value(); | |
384 | if (valueObj->IsA() != TObjString::Class()) | |
385 | { | |
386 | HLTError("The %s parameter found in configuration object \"%s\"" | |
387 | " is not a TObjString. Found an object of type %s instead.", | |
388 | prettyName, pathToEntry, valueObj->ClassName() | |
389 | ); | |
390 | return -EPROTO; | |
391 | } | |
392 | value = dynamic_cast<TObjString*>(valueObj)->GetString(); | |
393 | ||
394 | return 0; | |
395 | } | |
396 | ||
397 | ||
398 | int AliHLTMUONProcessor::GetIntFromTMap( | |
399 | TMap* map, const char* paramName, Int_t& value, | |
400 | const char* pathToEntry, const char* prettyName | |
401 | ) const | |
402 | { | |
403 | /// Tries to find a certain parameter in the TMap object and convert it to | |
404 | /// an integer value. | |
405 | /// [in] \param map The TMap object to search in. | |
406 | /// [in] \param paramName The name of the parameter to search for. | |
407 | /// [out] \param value Will be filled with the integer value for the parameter, | |
408 | /// if it was found and it was an integer value. | |
409 | /// [in] \param pathToEntry The relative path to the entry in the CDB. | |
410 | /// Used when printing error messages. If set to NULL then a string of | |
411 | /// "(unknown)" is used. (default is NULL). | |
412 | /// [in] \param prettyName Should be the name of the parameter which will | |
413 | /// be used when printing error messages. If this is set to NULL then | |
414 | /// the paramName will be used instead (default is NULL). | |
415 | /// \return Zero if the object could be found and is valid. Otherwise an | |
416 | /// error code, which is compatible with the HLT framework, is returned. | |
417 | ||
418 | if (pathToEntry == NULL) pathToEntry = "(unknown)"; | |
419 | if (prettyName == NULL) prettyName = paramName; | |
420 | ||
421 | TString valueStr; | |
2b7af22a | 422 | int result = GetValueFromTMap(map, paramName, valueStr, pathToEntry, prettyName); |
ffc1a6f6 | 423 | if (result != 0) return result; |
424 | ||
425 | if (not valueStr.IsDigit()) | |
426 | { | |
427 | HLTError("The %s parameter found in configuration object \"%s\"" | |
428 | "is not a valid integer number string; found \"%s\".", | |
429 | prettyName, pathToEntry, valueStr.Data() | |
430 | ); | |
431 | return -EPROTO; | |
432 | } | |
433 | value = valueStr.Atoi(); | |
434 | ||
435 | return 0; | |
436 | } | |
437 | ||
438 | ||
439 | int AliHLTMUONProcessor::GetPositiveIntFromTMap( | |
440 | TMap* map, const char* paramName, Int_t& value, | |
441 | const char* pathToEntry, const char* prettyName | |
442 | ) const | |
443 | { | |
444 | /// Tries to find a certain parameter in the TMap object and convert it to | |
445 | /// a positive integer value. | |
446 | /// [in] \param map The TMap object to search in. | |
447 | /// [in] \param paramName The name of the parameter to search for. | |
448 | /// [out] \param value Will be filled with the integer value for the parameter, | |
449 | /// if it was found and it was a positive integer value. | |
450 | /// [in] \param pathToEntry The relative path to the entry in the CDB. | |
451 | /// Used when printing error messages. If set to NULL then a string of | |
452 | /// "(unknown)" is used. (default is NULL). | |
453 | /// [in] \param prettyName Should be the name of the parameter which will | |
454 | /// be used when printing error messages. If this is set to NULL then | |
455 | /// the paramName will be used instead (default is NULL). | |
456 | /// \return Zero if the object could be found and is valid. Otherwise an | |
457 | /// error code, which is compatible with the HLT framework, is returned. | |
458 | ||
459 | if (pathToEntry == NULL) pathToEntry = "(unknown)"; | |
460 | if (prettyName == NULL) prettyName = paramName; | |
461 | ||
462 | TString valueStr; | |
2b7af22a | 463 | int result = GetValueFromTMap(map, paramName, valueStr, pathToEntry, prettyName); |
ffc1a6f6 | 464 | if (result != 0) return result; |
465 | ||
466 | if (not valueStr.IsDigit()) | |
467 | { | |
468 | HLTError("The %s parameter found in configuration object \"%s\"" | |
469 | "is not a valid integer number string; found \"%s\".", | |
470 | prettyName, pathToEntry, valueStr.Data() | |
471 | ); | |
472 | return -EPROTO; | |
473 | } | |
474 | Int_t val = valueStr.Atoi(); | |
475 | if (val < 0) | |
476 | { | |
477 | HLTError("The %s parameter found in configuration object \"%s\"" | |
478 | "is not a positive integer number; found \"%d\".", | |
479 | prettyName, pathToEntry, val | |
480 | ); | |
481 | return -EPROTO; | |
482 | } | |
483 | value = val; | |
484 | ||
485 | return 0; | |
486 | } | |
487 | ||
488 | ||
489 | int AliHLTMUONProcessor::GetFloatFromTMap( | |
490 | TMap* map, const char* paramName, Double_t& value, | |
491 | const char* pathToEntry, const char* prettyName | |
492 | ) const | |
493 | { | |
494 | /// Tries to find a certain parameter in the TMap object and convert it to | |
495 | /// an floating point value. | |
496 | /// [in] \param map The TMap object to search in. | |
497 | /// [in] \param paramName The name of the parameter to search for. | |
498 | /// [out] \param value Will be filled with the floating point value for the | |
499 | /// parameter, if it was found and it was a floating point value. | |
500 | /// [in] \param pathToEntry The relative path to the entry in the CDB. | |
501 | /// Used when printing error messages. If set to NULL then a string of | |
502 | /// "(unknown)" is used. (default is NULL). | |
503 | /// [in] \param prettyName Should be the name of the parameter which will | |
504 | /// be used when printing error messages. If this is set to NULL then | |
505 | /// the paramName will be used instead (default is NULL). | |
506 | /// \return Zero if the object could be found and is valid. Otherwise an | |
507 | /// error code, which is compatible with the HLT framework, is returned. | |
508 | ||
509 | if (pathToEntry == NULL) pathToEntry = "(unknown)"; | |
510 | if (prettyName == NULL) prettyName = paramName; | |
511 | ||
512 | TString valueStr; | |
2b7af22a | 513 | int result = GetValueFromTMap(map, paramName, valueStr, pathToEntry, prettyName); |
ffc1a6f6 | 514 | if (result != 0) return result; |
515 | ||
516 | if (not valueStr.IsFloat()) | |
517 | { | |
518 | HLTError("The %s parameter found in configuration object \"%s\"" | |
519 | "is not a valid floating point number string; found \"%s\".", | |
520 | prettyName, pathToEntry, valueStr.Data() | |
521 | ); | |
522 | return -EPROTO; | |
523 | } | |
524 | value = valueStr.Atof(); | |
525 | ||
526 | return 0; | |
527 | } | |
528 | ||
529 | ||
530 | int AliHLTMUONProcessor::GetPositiveFloatFromTMap( | |
531 | TMap* map, const char* paramName, Double_t& value, | |
532 | const char* pathToEntry, const char* prettyName | |
533 | ) const | |
534 | { | |
535 | /// Tries to find a certain parameter in the TMap object and convert it to | |
536 | /// an positive floating point value. | |
537 | /// [in] \param map The TMap object to search in. | |
538 | /// [in] \param paramName The name of the parameter to search for. | |
539 | /// [out] \param value Will be filled with the floating point value for the | |
540 | /// parameter, if it was found and it was a positive floating point value. | |
541 | /// [in] \param pathToEntry The relative path to the entry in the CDB. | |
542 | /// Used when printing error messages. If set to NULL then a string of | |
543 | /// "(unknown)" is used. (default is NULL). | |
544 | /// [in] \param prettyName Should be the name of the parameter which will | |
545 | /// be used when printing error messages. If this is set to NULL then | |
546 | /// the paramName will be used instead (default is NULL). | |
547 | /// \return Zero if the object could be found and is valid. Otherwise an | |
548 | /// error code, which is compatible with the HLT framework, is returned. | |
549 | ||
550 | if (pathToEntry == NULL) pathToEntry = "(unknown)"; | |
551 | if (prettyName == NULL) prettyName = paramName; | |
552 | ||
553 | TString valueStr; | |
2b7af22a | 554 | int result = GetValueFromTMap(map, paramName, valueStr, pathToEntry, prettyName); |
ffc1a6f6 | 555 | if (result != 0) return result; |
556 | ||
557 | if (not valueStr.IsFloat()) | |
558 | { | |
559 | HLTError("The %s parameter found in configuration object \"%s\"" | |
560 | "is not a valid floating point number string; found \"%s\".", | |
561 | prettyName, pathToEntry, valueStr.Data() | |
562 | ); | |
563 | return -EPROTO; | |
564 | } | |
565 | Double_t val = valueStr.Atof(); | |
566 | if (val < 0) | |
567 | { | |
568 | HLTError("The %s parameter found in configuration object \"%s\"" | |
569 | "is not a positive floating point number; found \"%d\".", | |
570 | prettyName, pathToEntry, val | |
571 | ); | |
572 | return -EPROTO; | |
573 | } | |
574 | value = val; | |
575 | ||
576 | return 0; | |
577 | } | |
17d68f2a | 578 | |
579 | ||
580 | int AliHLTMUONProcessor::LoadRecoParamsFromCDB(AliMUONRecoParam*& params) const | |
581 | { | |
582 | /// Fetches the reconstruction parameters object from the CDB for MUON. | |
583 | /// [out] \param params This will be filled with the reconstruction | |
584 | /// parameters object found if a successful status code is returned. | |
585 | /// Otherwise it will be unchanged. | |
586 | /// \return Zero if the object could be found. Otherwise an error code, | |
587 | /// which is compatible with the HLT framework, is returned. | |
588 | ||
589 | assert(AliCDBManager::Instance() != NULL); | |
21b32623 | 590 | |
591 | AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage(); | |
592 | if (store == NULL) | |
593 | { | |
594 | HLTError("Could not get the the default storage for the CDB."); | |
595 | return -EIO; | |
596 | } | |
597 | ||
17d68f2a | 598 | const char* pathToEntry = "MUON/Calib/RecoParam"; |
21b32623 | 599 | Int_t version = store->GetLatestVersion(pathToEntry, GetRunNo()); |
600 | Int_t subVersion = store->GetLatestSubVersion(pathToEntry, GetRunNo(), version); | |
601 | AliCDBEntry* entry = AliCDBManager::Instance()->Get(pathToEntry, GetRunNo(), version, subVersion); | |
17d68f2a | 602 | if (entry == NULL) |
603 | { | |
604 | HLTError("Could not get the CDB entry for \"%s\".", pathToEntry); | |
605 | return -EIO; | |
606 | } | |
607 | ||
608 | TObject* obj = entry->GetObject(); | |
609 | if (obj == NULL) | |
610 | { | |
611 | HLTError("Reconstruction parameters object for \"%s\" is missing.", pathToEntry); | |
612 | return -ENOENT; | |
613 | } | |
614 | ||
615 | TObjArray* objarr = dynamic_cast<TObjArray*>(obj); | |
616 | if (objarr != NULL) | |
617 | { | |
618 | obj = objarr->Last(); | |
619 | } | |
620 | ||
621 | AliMUONRecoParam* par = dynamic_cast<AliMUONRecoParam*>(obj); | |
622 | if (par == NULL) | |
623 | { | |
624 | HLTError("No AliMUONRecoParam class found for entry \"%s\". Found a %s class instead.", | |
625 | pathToEntry, obj->ClassName() | |
626 | ); | |
627 | return -EPROTO; | |
628 | } | |
629 | ||
630 | params = par; | |
631 | return 0; | |
632 | } | |
633 | ||
ffb64d3e | 634 | |
635 | void AliHLTMUONProcessor::DumpBuffer( | |
636 | const void* buffer, AliHLTUInt32_t size, const char* filename | |
637 | ) const | |
638 | { | |
639 | /// Dumps the data contained in a buffer to file as is. | |
640 | ||
641 | using std::fstream; | |
642 | ||
643 | fstream file(filename, fstream::out | fstream::trunc | fstream::binary); | |
644 | if (file.good()) | |
645 | { | |
646 | file.write(reinterpret_cast<const char*>(buffer), size); | |
647 | if (file.fail()) | |
648 | { | |
649 | HLTError("Could not write data block to file %s during" | |
650 | " dumping operation!", | |
651 | filename | |
652 | ); | |
653 | } | |
654 | } | |
655 | else | |
656 | { | |
657 | HLTError("Could not open file %s for dumping data block!", filename); | |
658 | } | |
659 | } | |
660 | ||
661 | ||
662 | void AliHLTMUONProcessor::DumpBlock( | |
663 | const AliHLTComponentBlockData* block, const char* fileNamePrefix | |
664 | ) const | |
665 | { | |
666 | /// Dumps the data block and meta information to file. | |
667 | ||
668 | std::string filename = fDumpPath; | |
669 | filename += fileNamePrefix; | |
670 | filename += "-blockmeta.bin"; | |
671 | DumpBuffer(block, sizeof(AliHLTComponentBlockData), filename.c_str()); | |
672 | filename = fDumpPath; | |
673 | filename += fileNamePrefix; | |
674 | filename += "-data.bin"; | |
675 | DumpBuffer(block->fPtr, block->fSize, filename.c_str()); | |
676 | } | |
677 | ||
678 | ||
679 | void AliHLTMUONProcessor::DumpEvent( | |
680 | const AliHLTComponentEventData& evtData, | |
681 | const AliHLTComponentBlockData* blocks, | |
682 | AliHLTComponentTriggerData& trigData, | |
683 | AliHLTUInt8_t* outputPtr, | |
684 | AliHLTUInt32_t& size, | |
685 | AliHLTComponentBlockDataList& outputBlocks | |
686 | ) const | |
687 | { | |
688 | /// Dumps the event information to files in the dump path given by the | |
689 | /// method DumpPath, which can be set by the command line argument -dumppath. | |
690 | ||
691 | using std::fstream; | |
692 | char strbuf[1024]; | |
693 | ||
694 | std::string filename = fDumpPath; | |
695 | sprintf(strbuf, "dump_event-0x%16.16llX.log", evtData.fEventID); | |
696 | filename += strbuf; | |
697 | fstream logfile(filename.c_str(), fstream::out | fstream::trunc); | |
698 | if (logfile.fail()) | |
699 | { | |
700 | HLTError("Could not open log file '%s' for dump information.", filename.c_str()); | |
701 | return; | |
702 | } | |
703 | ||
704 | filename = fDumpPath; | |
705 | sprintf(strbuf, "dump_event-0x%16.16llX-eventdata.bin", evtData.fEventID); | |
706 | filename += strbuf; | |
707 | logfile << "Dumping event data structure to file: " << filename << std::endl; | |
708 | DumpBuffer(&evtData, sizeof(AliHLTComponentEventData), filename.c_str()); | |
709 | ||
710 | filename = fDumpPath; | |
711 | sprintf(strbuf, "dump_event-0x%16.16llX-triggerdata.bin", evtData.fEventID); | |
712 | filename += strbuf; | |
713 | logfile << "Dumping trigger data structure to file: " << filename << std::endl; | |
714 | DumpBuffer(&trigData, sizeof(AliHLTComponentTriggerData), filename.c_str()); | |
715 | ||
716 | for (unsigned int n = 0; n < evtData.fBlockCnt; n++) | |
717 | { | |
718 | sprintf(strbuf, "dump_event-0x%16.16llX-block-0x%8.8X", evtData.fEventID, n); | |
719 | filename = strbuf; | |
720 | sprintf(strbuf, "0x%8.8X", blocks[n].fSpecification); | |
721 | logfile << "Found block with data type = " << DataType2Text(blocks[n].fDataType) | |
722 | << ", specification = " << strbuf << ". Dumping to file: " | |
723 | << filename << "-data.bin" << std::endl; | |
724 | DumpBlock(&blocks[n], filename.c_str()); | |
725 | } | |
726 | ||
727 | filename = fDumpPath; | |
728 | sprintf(strbuf, "dump_event-0x%16.16llX-output-buffer.bin", evtData.fEventID); | |
729 | filename += strbuf; | |
730 | logfile << "Dumping output buffer to file: " << filename << std::endl; | |
731 | DumpBuffer(outputPtr, size, filename.c_str()); | |
732 | ||
733 | for (size_t i = 0; i < outputBlocks.size(); i++) | |
734 | { | |
735 | sprintf(strbuf, "dump_event-0x%16.16llX-output-block-0x%8.8X", evtData.fEventID, int(i)); | |
736 | filename = strbuf; | |
737 | sprintf(strbuf, "0x%8.8X", outputBlocks[i].fSpecification); | |
738 | logfile << "Generated output data block with type = " | |
739 | << DataType2Text(outputBlocks[i].fDataType) | |
740 | << ", specification = " << strbuf << ". Dumping to file: " | |
741 | << filename << "-data.bin" << std::endl; | |
742 | DumpBlock(&outputBlocks[i], filename.c_str()); | |
743 | } | |
744 | } | |
745 | ||
746 | ||
747 | void AliHLTMUONProcessor::DumpEvent( | |
748 | const AliHLTComponentEventData& evtData, | |
749 | AliHLTComponentTriggerData& trigData | |
750 | ) const | |
751 | { | |
752 | /// Dumps the event information to files in the dump path given by the | |
753 | /// method DumpPath, which can be set by the command line argument -dumppath. | |
754 | ||
755 | using std::fstream; | |
756 | char strbuf[1024]; | |
757 | ||
758 | std::string filename = fDumpPath; | |
759 | sprintf(strbuf, "dump_event-0x%16.16llX.log", evtData.fEventID); | |
760 | filename += strbuf; | |
761 | fstream logfile(filename.c_str(), fstream::out | fstream::trunc); | |
762 | if (logfile.fail()) | |
763 | { | |
764 | HLTError("Could not open log file '%s' for dump information.", filename.c_str()); | |
765 | return; | |
766 | } | |
767 | ||
768 | filename = fDumpPath; | |
769 | sprintf(strbuf, "dump_event-0x%16.16llX-eventdata.bin", evtData.fEventID); | |
770 | filename += strbuf; | |
771 | logfile << "Dumping event data structure to file: " << filename << std::endl; | |
772 | DumpBuffer(&evtData, sizeof(AliHLTComponentEventData), filename.c_str()); | |
773 | ||
774 | filename = fDumpPath; | |
775 | sprintf(strbuf, "dump_event-0x%16.16llX-triggerdata.bin", evtData.fEventID); | |
776 | filename += strbuf; | |
777 | logfile << "Dumping trigger data structure to file: " << filename << std::endl; | |
778 | DumpBuffer(&trigData, sizeof(AliHLTComponentTriggerData), filename.c_str()); | |
779 | ||
780 | for (int i = 0; i < GetNumberOfInputBlocks(); i++) | |
781 | { | |
782 | const AliHLTComponentBlockData* block = GetInputBlock(i); | |
783 | sprintf(strbuf, "dump_event-0x%16.16llX-block-0x%8.8X", evtData.fEventID, i); | |
784 | filename = strbuf; | |
785 | sprintf(strbuf, "0x%8.8X", block->fSpecification); | |
786 | logfile << "Found block with data type = " << DataType2Text(block->fDataType) | |
787 | << ", specification = " << strbuf << ". Dumping to file: " | |
788 | << filename << "-data.bin" << std::endl; | |
789 | DumpBlock(block, filename.c_str()); | |
790 | } | |
791 | } | |
792 |