HLT/rec/AliHLTMiscImplementation.cxx

   1 // $Id$
   2
   3 //**************************************************************************
   4 //* This file is property of and copyright by the ALICE HLT Project        *
   5 //* ALICE Experiment at CERN, All rights reserved.                         *
   6 //*                                                                        *
   7 //* Primary Authors: Matthias Richter <Matthias.Richter@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   AliHLTMisc.cxx
  20 /// @author Matthias Richter
  21 /// @date
  22 /// @brief  Miscellaneous methods for the HLT AliRoot integration
  23
  24 #include "AliHLTMiscImplementation.h"
  25 #include "AliHLTLogging.h"
  26 #include "AliCDBManager.h"
  27 #include "AliCDBStorage.h"
  28 #include "AliCDBEntry.h"
  29 #include "AliGRPManager.h"
  30 #include "AliRawReader.h"
  31 #include "AliTracker.h"
  32 #ifndef HAVE_NOT_ALIESDHLTDECISION
  33 #include "AliESDHLTDecision.h"
  34 #endif //HAVE_NOT_ALIESDHLTDECISION
  35 #include "TGeoGlobalMagField.h"
  36 #include "AliHLTGlobalTriggerDecision.h"
  37
  38 /** ROOT macro for the implementation of ROOT specific class methods */
  39 ClassImp(AliHLTMiscImplementation);
  40
  41 AliHLTMiscImplementation::AliHLTMiscImplementation()
  42 {
  43 }
  44
  45 AliHLTMiscImplementation::~AliHLTMiscImplementation()
  46 {
  47   // see header file for function documentation
  48 }
  49
  50 int AliHLTMiscImplementation::InitCDB(const char* cdbpath)
  51 {
  52   // see header file for function documentation
  53   int iResult=0;
  54   AliCDBManager* pCDB = AliCDBManager::Instance();
  55   AliHLTLogging log;
  56   if (!pCDB) {
  57     log.Logging(kHLTLogError, "InitCDB", "CDB handling", "Could not get CDB instance");
  58   } else {
  59     if (cdbpath && cdbpath[0]!=0) {
  60       TString uri=cdbpath;
  61       if (!uri.BeginsWith("local://") &&
  62           !uri.Contains("://")) {
  63         // assume a local path if no uri specifier is found
  64         uri="local://";
  65         uri+=cdbpath;
  66       }
  67       pCDB->SetDefaultStorage(uri);
  68       log.Logging(kHLTLogDebug, "InitCDB", "CDB handling", "CDB instance 0x%x", pCDB);
  69     } else if (!pCDB->IsDefaultStorageSet()) {
  70       const char* cdbUri="local://$ALICE_ROOT/OCDB";
  71       pCDB->SetDefaultStorage(cdbUri);
  72       pCDB->SetRun(0);
  73       log.Logging(kHLTLogInfo, "InitCDB", "CDB handling", "set default URI: %s", cdbUri);
  74     }
  75   }
  76   return iResult;
  77 }
  78
  79 int AliHLTMiscImplementation::SetCDBRunNo(int runNo)
  80 {
  81   // see header file for function documentation
  82   int iResult=0;
  83   AliCDBManager* pCDB = AliCDBManager::Instance();
  84   AliHLTLogging log;
  85   if (!pCDB) {
  86     log.Logging(kHLTLogError, "SetCDBRunNo", "CDB handling", "Could not get CDB instance");
  87   } else {
  88     pCDB->SetRun(runNo);
  89   }
  90   return iResult;
  91 }
  92
  93 int AliHLTMiscImplementation::GetCDBRunNo()
  94 {
  95   // see header file for function documentation
  96   AliCDBManager* pCDB = AliCDBManager::Instance();
  97   AliHLTLogging log;
  98   if (!pCDB) {
  99     log.Logging(kHLTLogError, "SetCDBRunNo", "CDB handling", "Could not get CDB instance");
 100   } else {
 101     return pCDB->GetRun();
 102   }
 103   return -1;
 104 }
 105
 106 AliCDBEntry* AliHLTMiscImplementation::LoadOCDBEntry(const char* path, int runNo, int version, int subVersion)
 107 {
 108   // see header file for function documentation
 109   AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
 110   if (!store) {
 111     return NULL;
 112   }
 113   if (version<0) version = store->GetLatestVersion(path, runNo);
 114   if (subVersion<0) subVersion = store->GetLatestSubVersion(path, runNo, version);
 115   return AliCDBManager::Instance()->Get(path, runNo, version, subVersion);
 116 }
 117
 118 TObject* AliHLTMiscImplementation::ExtractObject(AliCDBEntry* entry)
 119 {
 120   // see header file for function documentation
 121   if (!entry) return NULL;
 122   return entry->GetObject();
 123 }
 124
 125 int AliHLTMiscImplementation::InitMagneticField() const
 126 {
 127   // see header file for function documentation
 128
 129   // BAD: unit test fails if I call TGeoGlobalMagField::Instance()
 130   // at this point. Something goes wrong in the cleaning of the global
 131   // ROOT onject
 132   /*
 133   if (TGeoGlobalMagField::Instance()->GetField()) {
 134     // everything set, but think about storing the currents for
 135     // a cross-check
 136     return 0;
 137   }
 138   */
 139
 140   // The magnetic field is initialized once at the start
 141   // of run. The fields are supposed to be constant througout the
 142   // data taking of one run. The run is aborted if the changes
 143   // exceed a certain limit.
 144   AliGRPManager grpman;
 145   if (grpman.ReadGRPEntry() && grpman.SetMagField()) {
 146     return 0;
 147   }
 148
 149   return -ENOENT;
 150 }
 151
 152 AliHLTUInt64_t AliHLTMiscImplementation::GetTriggerMask(AliRawReader* rawReader) const
 153 {
 154   // see header file for function documentation
 155   if (!rawReader) return 0;
 156   AliHLTUInt64_t trgMask=0;
 157   if (rawReader) {
 158     const UInt_t* pattern=rawReader->GetTriggerPattern();
 159     trgMask=pattern[1]&0xfffffff; // 28 upper bits of the 50 bit mask
 160     trgMask<<=32;
 161     trgMask|=pattern[0]; // 32 lower bits of the mask
 162   }
 163   return trgMask;
 164 }
 165
 166 Double_t AliHLTMiscImplementation::GetBz()
 167 {
 168   // Returns Bz.
 169   return AliTracker::GetBz();
 170 }
 171
 172 Double_t AliHLTMiscImplementation::GetBz(const Double_t *r)
 173 {
 174   // Returns Bz (kG) at the point "r" .
 175   return AliTracker::GetBz(r);
 176 }
 177
 178 void AliHLTMiscImplementation::GetBxByBz(const Double_t r[3], Double_t b[3])
 179 {
 180   // Returns Bx, By and Bz (kG) at the point "r" .
 181   return AliTracker::GetBxByBz(r, b);
 182 }
 183
 184 const TClass* AliHLTMiscImplementation::IsAliESDHLTDecision() const
 185 {
 186   // Return the IsA of the AliESDHLTDecision class
 187 #ifndef HAVE_NOT_ALIESDHLTDECISION
 188   return AliESDHLTDecision::Class();
 189 #else // HAVE_NOT_ALIESDHLTDECISION
 190   return NULL;
 191 #endif // HAVE_NOT_ALIESDHLTDECISION
 192 }
 193
 194 int AliHLTMiscImplementation::Copy(const AliHLTGlobalTriggerDecision* pDecision, TObject* object) const
 195 {
 196   // Copy HLT global trigger decision to AliESDHLTDecision container
 197   if (!pDecision || !object) return -EINVAL;
 198 #ifndef HAVE_NOT_ALIESDHLTDECISION
 199   AliESDHLTDecision* pESDHLTDecision=NULL;
 200   if (object->IsA()==NULL ||
 201       object->IsA() != AliESDHLTDecision::Class() ||
 202       (pESDHLTDecision=dynamic_cast<AliESDHLTDecision*>(object))==NULL) {
 203 //     HLTError("can not copy HLT global decision to object of class \"%s\"",
 204 //           object->IsA()?object->IsA()->GetName():"NULL");
 205     return -EINVAL;
 206   }
 207
 208   pESDHLTDecision->~AliESDHLTDecision();
 209   new (pESDHLTDecision) AliESDHLTDecision(pDecision->Result(), pDecision->GetTitle());
 210
 211 #endif // HAVE_NOT_ALIESDHLTDECISION
 212   return 0;
 213 }