removing deprecated option to query specific (sub)version of OCDB entry
[u/mrichter/AliRoot.git] / 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 "AliHLTErrorGuard.h"
27 #include "AliLog.h"
28 #include "AliCDBManager.h"
29 #include "AliCDBStorage.h"
30 #include "AliCDBEntry.h"
31 #include "AliGRPManager.h"
32 #include "AliRawReader.h"
33 #include "AliRawEventHeaderBase.h"
34 #include "AliTracker.h"
35 #include "AliESDtrack.h"
36 #include "AliESDHLTDecision.h"
37 #include "TGeoGlobalMagField.h"
38 #include "AliHLTGlobalTriggerDecision.h"
39 #include "TClass.h"
40 #include "TStreamerInfo.h"
41 #include "TObjArray.h"
42
43 /** ROOT macro for the implementation of ROOT specific class methods */
44 ClassImp(AliHLTMiscImplementation);
45
46 AliHLTMiscImplementation::AliHLTMiscImplementation()
47 {
48 }
49
50 AliHLTMiscImplementation::~AliHLTMiscImplementation()
51 {
52   // see header file for function documentation
53 }
54
55 int AliHLTMiscImplementation::InitCDB(const char* cdbpath)
56 {
57   // see header file for function documentation
58   int iResult=0;
59   AliCDBManager* pCDB = AliCDBManager::Instance();
60   AliHLTLogging log;
61   if (!pCDB) {
62     log.Logging(kHLTLogError, "InitCDB", "CDB handling", "Could not get CDB instance");
63   } else {
64     if (cdbpath && cdbpath[0]!=0) {
65       TString uri=cdbpath;
66       if (!uri.BeginsWith("local://") &&
67           !uri.Contains("://")) {
68         // assume a local path if no uri specifier is found
69         uri="local://";
70         uri+=cdbpath;
71       }
72       pCDB->SetDefaultStorage(uri);
73       log.Logging(kHLTLogDebug, "InitCDB", "CDB handling", "CDB instance 0x%x", pCDB);
74     } else if (!pCDB->IsDefaultStorageSet()) {
75       const char* cdbUri="local://$ALICE_ROOT/OCDB";
76       pCDB->SetDefaultStorage(cdbUri);
77       pCDB->SetRun(0);
78       log.Logging(kHLTLogInfo, "InitCDB", "CDB handling", "set default URI: %s", cdbUri);
79     }
80   }
81   return iResult;
82 }
83
84 int AliHLTMiscImplementation::SetCDBRunNo(int runNo)
85 {
86   // see header file for function documentation
87   int iResult=0;
88   AliCDBManager* pCDB = AliCDBManager::Instance();
89   AliHLTLogging log;
90   if (!pCDB) {
91     log.Logging(kHLTLogError, "SetCDBRunNo", "CDB handling", "Could not get CDB instance");
92   } else {
93     pCDB->SetRun(runNo);
94   }
95   return iResult;
96 }
97
98 int AliHLTMiscImplementation::GetCDBRunNo() const
99 {
100   // see header file for function documentation
101   AliCDBManager* pCDB = AliCDBManager::Instance();
102   AliHLTLogging log;
103   if (!pCDB) {
104     log.Logging(kHLTLogError, "SetCDBRunNo", "CDB handling", "Could not get CDB instance");
105   } else {
106     return pCDB->GetRun();
107   }
108   return -1;
109 }
110
111 AliCDBEntry* AliHLTMiscImplementation::LoadOCDBEntry(const char* path, int runNo) const
112 {
113   // see header file for function documentation
114   if (!path) return NULL;
115   AliHLTLogging log;
116
117   AliCDBManager* man = AliCDBManager::Instance();
118   if (!man) {
119     ALIHLTERRORGUARD(1, "failed to access CDB manager");
120     return NULL;
121   }
122   if (runNo<0) runNo=man->GetRun();
123
124   // check the cache first if no specific version required
125   { //condition was deprecated, but keep for formatting
126     const TMap* pCache=man->GetEntryCache();
127     TObject* pEntryObj=NULL;
128     if (pCache && (pEntryObj=pCache->GetValue(path))!=NULL) {
129       AliCDBEntry* pEntry=dynamic_cast<AliCDBEntry*>(pEntryObj);
130       if (pEntry) {
131         log.Logging(kHLTLogDebug, "AliHLTMiscImplementation::LoadOCDBEntry", "CDB handling", "using OCDB object %s from cache", path);
132         return pEntry;
133       } else {
134         log.Logging(kHLTLogError, "AliHLTMiscImplementation::LoadOCDBEntry", "CDB handling", "invalid OCDB object %s found in cache, not of type AliCDBEntry", path);
135       }
136     }
137   }
138
139   const char* uri=man->GetURI(path);
140   if (!uri) {
141     log.Logging(kHLTLogError, "AliHLTMiscImplementation::LoadOCDBEntry", "CDB handling", "can not find URI for CDB object \"%s\"", path);
142     return NULL;
143   }
144
145   AliCDBStorage* store = AliCDBManager::Instance()->GetStorage(uri);
146   if (!store) {
147     log.Logging(kHLTLogError, "AliHLTMiscImplementation::LoadOCDBEntry", "CDB handling", "can not find storage for URI \"%s\"", uri);
148     return NULL;
149   }
150
151   TString strUri=store->GetURI();
152   bool bIsGrid=strUri.BeginsWith("alien://");
153
154   int latest = store->GetLatestVersion(path, runNo);
155   if (latest<0) {
156     log.Logging(kHLTLogError, "AliHLTMiscImplementation::LoadOCDBEntry", "CDB handling", "Could not find an entry in the CDB for \"%s\".", path);
157     return NULL;
158   }
159
160   AliCDBEntry* entry=man->Get(path, runNo);
161   return entry;
162 }
163
164 TObject* AliHLTMiscImplementation::ExtractObject(AliCDBEntry* entry) const
165 {
166   // see header file for function documentation
167   if (!entry) return NULL;
168   return entry->GetObject();
169 }
170
171 int AliHLTMiscImplementation::CheckOCDBEntries(const TMap* const pMap) const
172 {
173   // check the availability of the OCDB entry descriptions in the TMap
174   //  key : complete OCDB path of the entry
175   //  value : auxiliary object - short description
176   // check uses AliCDBStorage::GetLatestVersion, which is the only method
177   // to check the existence without risking AliFatal
178
179   int iResult=0;
180   if (!pMap) return -EINVAL;
181   AliHLTLogging log;
182
183   AliCDBManager* man = AliCDBManager::Instance();
184   if (!man) {
185     ALIHLTERRORGUARD(1, "failed to access CDB manager");
186     return -ENOSYS;
187   }
188   const TMap* pCache=man->GetEntryCache();
189
190   Int_t runNo = GetCDBRunNo();
191
192   TIterator* next=pMap->MakeIterator();
193   if (!next) return -EFAULT;
194
195   TObject* pEntry=NULL;
196   while ((pEntry=next->Next())) {
197     // check if already on cache
198     if (pCache && pCache->GetValue(pEntry->GetName())!=NULL) {
199       log.Logging(kHLTLogDebug, "AliHLTMiscImplementation::CheckOCDBEntries", "CDB handling", "found OCDB object %s on cache", pEntry->GetName());      
200       continue;
201     }
202
203     // check if the entry has specific storage
204     const char* uri=man->GetURI(pEntry->GetName());
205     if (!uri) {
206       log.Logging(kHLTLogError, "AliHLTMiscImplementation::CheckOCDBEntries", "CDB handling", "can not find URI for CDB object \"%s\"", pEntry->GetName());
207       return -ENODEV;
208     }
209
210     AliCDBStorage* pStorage = AliCDBManager::Instance()->GetStorage(uri);
211     if (!pStorage) {
212       log.Logging(kHLTLogError, "AliHLTMiscImplementation::CheckOCDBEntries", "CDB handling", "can not find storage for URI \"%s\"", uri);
213       return -EBADF;
214     }
215
216     // GetLatestVersion is the only method to check the existence without potential AliFatal
217     if (pStorage->GetLatestVersion(pEntry->GetName(), runNo)<0) {
218       log.Logging(kHLTLogError, "AliHLTMiscImplementation::CheckOCDBEntries", "CDB handling", "can not find required OCDB object %s for run number %d in storage %s", pEntry->GetName(), runNo, pStorage->GetURI().Data());
219       iResult=-ENOENT;
220     } else {
221       log.Logging(kHLTLogDebug, "AliHLTMiscImplementation::CheckOCDBEntries", "CDB handling", "found required OCDB object %s for run number %d in storage %s", pEntry->GetName(), runNo, pStorage->GetURI().Data());
222     }
223   }
224   delete next;
225   next=NULL;
226
227   return iResult;
228 }
229
230 int AliHLTMiscImplementation::InitMagneticField() const
231 {
232   // see header file for function documentation
233
234   // BAD: unit test fails if I call TGeoGlobalMagField::Instance()
235   // at this point. Something goes wrong in the cleaning of the global
236   // ROOT onject
237   /*
238   if (TGeoGlobalMagField::Instance()->GetField()) {
239     // everything set, but think about storing the currents for
240     // a cross-check
241     return 0;
242   }
243   */
244
245   // The magnetic field is initialized once at the start
246   // of run. The fields are supposed to be constant througout the
247   // data taking of one run. The run is aborted if the changes
248   // exceed a certain limit.
249   AliGRPManager grpman;
250   if (grpman.ReadGRPEntry() && grpman.SetMagField()) {
251     return 0;
252   }
253
254   return -ENOENT;
255 }
256
257 AliHLTUInt64_t AliHLTMiscImplementation::GetTriggerMask(AliRawReader* rawReader) const
258 {
259   // see header file for function documentation
260   if (!rawReader) return 0;
261   AliHLTUInt64_t trgMask=0;
262   if (rawReader) {
263     const UInt_t* pattern=rawReader->GetTriggerPattern();
264     trgMask=pattern[1]&0xfffffff; // 28 upper bits of the 50 bit mask
265     trgMask<<=32;
266     trgMask|=pattern[0]; // 32 lower bits of the mask
267   }
268   return trgMask;
269 }
270
271 AliHLTUInt32_t AliHLTMiscImplementation::GetTimeStamp(AliRawReader* rawReader) const
272 {
273   // extract time stamp of the event from the event header
274   if (!rawReader) return 0;
275   const AliRawEventHeaderBase* eventHeader = rawReader->GetEventHeader();
276   if (!eventHeader) return 0;
277   return eventHeader->Get("Timestamp");
278 }
279
280 AliHLTUInt32_t AliHLTMiscImplementation::GetEventType(AliRawReader* rawReader) const
281 {
282   // extract event type from the event header
283   if (!rawReader) return 0;
284   const AliRawEventHeaderBase* eventHeader = rawReader->GetEventHeader();
285   if (!eventHeader) return 0;
286   return eventHeader->Get("Type");
287 }
288
289 const char* AliHLTMiscImplementation::GetBeamTypeFromGRP() const
290 {
291   // get beam type from GRP
292   return NULL;
293 }
294
295 Double_t AliHLTMiscImplementation::GetBz()
296 {
297   // Returns Bz.
298   return AliTracker::GetBz();
299 }
300
301 Double_t AliHLTMiscImplementation::GetBz(const Double_t *r)
302 {
303   // Returns Bz (kG) at the point "r" .
304   return AliTracker::GetBz(r);
305 }
306
307 void AliHLTMiscImplementation::GetBxByBz(const Double_t r[3], Double_t b[3])
308 {
309   // Returns Bx, By and Bz (kG) at the point "r" .
310   return AliTracker::GetBxByBz(r, b);
311 }
312
313 const TClass* AliHLTMiscImplementation::IsAliESDHLTDecision() const
314 {
315   // Return the IsA of the AliESDHLTDecision class
316   return AliESDHLTDecision::Class();
317 }
318
319 int AliHLTMiscImplementation::Copy(const AliHLTGlobalTriggerDecision* pDecision, TObject* object) const
320 {
321   // Copy HLT global trigger decision to AliESDHLTDecision container
322   if (!pDecision || !object) return -EINVAL;
323   AliESDHLTDecision* pESDHLTDecision=NULL;
324   if (object->IsA()==NULL ||
325       object->IsA() != AliESDHLTDecision::Class() ||
326       (pESDHLTDecision=dynamic_cast<AliESDHLTDecision*>(object))==NULL) {
327 //     HLTError("can not copy HLT global decision to object of class \"%s\"", 
328 //           object->IsA()?object->IsA()->GetName():"NULL");
329     return -EINVAL;
330   }
331
332   pESDHLTDecision->~AliESDHLTDecision();
333   new (pESDHLTDecision) AliESDHLTDecision(pDecision->Result(), pDecision->GetTitle());
334
335   return 0;
336 }
337
338 int AliHLTMiscImplementation::InitStreamerInfos(const char* ocdbEntry) const
339 {
340   // init streamer infos for HLT reconstruction
341   // Root schema evolution is not enabled for AliHLTMessage and all streamed objects.
342   // Objects in the raw data payload rely on the availability of the correct stream info.
343   // The relevant streamer info for a specific run is stored in the OCDB.
344   int iResult=0;
345
346   AliCDBEntry* pEntry=LoadOCDBEntry(ocdbEntry);
347   TObject* pObject=NULL;
348   if (pEntry && (pObject=ExtractObject(pEntry))!=NULL)
349     {
350     TObjArray* pSchemas=dynamic_cast<TObjArray*>(pObject);
351     if (pSchemas) {
352       iResult=InitStreamerInfos(pSchemas);
353     } else {
354       AliError(Form("internal mismatch in OCDB entry %s: wrong class type", ocdbEntry));
355     }
356   } else {
357     AliWarning(Form("missing HLT reco data (%s), skipping initialization of streamer info for TObjects in HLT raw data payload", ocdbEntry));
358   }
359   return iResult;
360 }
361
362 int AliHLTMiscImplementation::InitStreamerInfos(TObjArray* pSchemas) const
363 {
364   // init streamer infos for HLT reconstruction from an array of TStreamerInfo objects
365
366   for (int i=0; i<pSchemas->GetEntriesFast(); i++) {
367     if (pSchemas->At(i)) {
368       TStreamerInfo* pSchema=dynamic_cast<TStreamerInfo*>(pSchemas->At(i));
369       if (pSchema) {
370         int version=pSchema->GetClassVersion();
371         TClass* pClass=TClass::GetClass(pSchema->GetName());
372         if (pClass) {
373           if (pClass->GetClassVersion()==version) {
374             AliDebug(0,Form("skipping schema definition %d version %d to class %s as this is the native version", i, version, pSchema->GetName()));
375             continue;
376           }
377           TObjArray* pInfos=pClass->GetStreamerInfos();
378           if (pInfos /*&& version<pInfos->GetEntriesFast()*/) {
379             if (pInfos->At(version)==NULL) {
380               TStreamerInfo* pClone=(TStreamerInfo*)pSchema->Clone();
381               if (pClone) {
382                 pClone->SetClass(pClass);
383                 pClone->BuildOld();
384                 pInfos->AddAtAndExpand(pClone, version);
385                 AliDebug(0,Form("adding schema definition %d version %d to class %s", i, version, pSchema->GetName()));
386               } else {
387                 AliError(Form("skipping schema definition %d (%s), unable to create clone object", i, pSchema->GetName()));
388               }
389             } else {
390               TStreamerInfo* pInfo=dynamic_cast<TStreamerInfo*>(pInfos->At(version));
391               if (pInfo && pInfo->GetClassVersion()==version) {
392                 AliDebug(0,Form("schema definition %d version %d already available in class %s, skipping ...", i, version, pSchema->GetName()));
393               } else {
394                 AliError(Form("can not verify version for already existing schema definition %d (%s) version %d: version of existing definition is %d", i, pSchema->GetName(), version, pInfo?pInfo->GetClassVersion():-1));
395               }
396             }
397           } else {
398             AliError(Form("skipping schema definition %d (%s), unable to set version %d in info array of size %d", i, pSchema->GetName(), version, pInfos?pInfos->GetEntriesFast():-1));
399           }
400         } else {
401           AliError(Form("skipping schema definition %d (%s), unable to find class", i, pSchema->GetName()));
402         }
403       } else {
404         AliError(Form("skipping schema definition %d, not of TStreamerInfo", i));
405       }
406     }
407   }
408
409   return 0;
410 }
411
412 void AliHLTMiscImplementation::SetAliESDtrackOnlineModeFlag(bool mode) const
413 {
414   /// set the online mode flag of AliESDtrack
415   AliESDtrack::OnlineMode(mode);
416 }
417
418 bool AliHLTMiscImplementation::GetAliESDtrackOnlineModeFlag() const
419 {
420   /// get status of the online mode flag of AliESDtrack
421   return AliESDtrack::OnlineMode();
422 }