HLT/MUON/AliHLTMUONProcessor.cxx

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