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