adding implementations to extract event type and time stamp from RawReader
[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 "AliLog.h"
27 #include "AliCDBManager.h"
28 #include "AliCDBStorage.h"
29 #include "AliCDBEntry.h"
30 #include "AliGRPManager.h"
31 #include "AliRawReader.h"
32 #include "AliRawEventHeaderBase.h"
33 #include "AliTracker.h"
34 #ifndef HAVE_NOT_ALIESDHLTDECISION
35 #include "AliESDHLTDecision.h"
36 #endif //HAVE_NOT_ALIESDHLTDECISION
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, int version, int subVersion) const
112 {
113   // see header file for function documentation
114   AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
115   if (!store) {
116     return NULL;
117   }
118   if (version<0) version = store->GetLatestVersion(path, runNo);
119   if (subVersion<0) subVersion = store->GetLatestSubVersion(path, runNo, version);
120   return store->Get(path, runNo, version, subVersion);
121 }
122
123 TObject* AliHLTMiscImplementation::ExtractObject(AliCDBEntry* entry) const
124 {
125   // see header file for function documentation
126   if (!entry) return NULL;
127   return entry->GetObject();
128 }
129
130 int AliHLTMiscImplementation::CheckOCDBEntries(const TMap* const pMap) const
131 {
132   // check the availability of the OCDB entry descriptions in the TMap
133   //  key : complete OCDB path of the entry
134   //  value : auxiliary object - short description
135   int iResult=0;
136   if (!pMap) return -EINVAL;
137
138   const TMap* pStorages=AliCDBManager::Instance()->GetStorageMap();
139   Int_t runNo = GetCDBRunNo();
140
141   TIterator* next=pMap->MakeIterator();
142   TObject* pEntry=NULL;
143   while ((pEntry=next->Next())) {
144     // check if the entry has specific storage
145     AliCDBStorage* pStorage=NULL;
146     TObject* pStorageId=pStorages->GetValue(pEntry->GetName());
147     if (pStorageId) {
148       pStorage=AliCDBManager::Instance()->GetStorage(pStorageId->GetName());
149     } else {
150       pStorage=AliCDBManager::Instance()->GetDefaultStorage();
151     }
152
153     if (pStorage->GetLatestVersion(pEntry->GetName(), runNo)<0) {
154       AliHLTLogging log;
155       log.Logging(kHLTLogError, "CheckOCDBEntries", "CDB handling", "can not find required OCDB object %s for run number %d in storage %s", pEntry->GetName(), runNo, pStorage->GetURI().Data());
156       iResult=-ENOENT;
157     } else {
158       AliHLTLogging log;
159       log.Logging(kHLTLogDebug, "CheckOCDBEntries", "CDB handling", "found required OCDB object %s for run number %d in storage %s", pEntry->GetName(), runNo, pStorage->GetURI().Data());
160     }
161   }
162
163   return iResult;
164 }
165
166 int AliHLTMiscImplementation::InitMagneticField() const
167 {
168   // see header file for function documentation
169
170   // BAD: unit test fails if I call TGeoGlobalMagField::Instance()
171   // at this point. Something goes wrong in the cleaning of the global
172   // ROOT onject
173   /*
174   if (TGeoGlobalMagField::Instance()->GetField()) {
175     // everything set, but think about storing the currents for
176     // a cross-check
177     return 0;
178   }
179   */
180
181   // The magnetic field is initialized once at the start
182   // of run. The fields are supposed to be constant througout the
183   // data taking of one run. The run is aborted if the changes
184   // exceed a certain limit.
185   AliGRPManager grpman;
186   if (grpman.ReadGRPEntry() && grpman.SetMagField()) {
187     return 0;
188   }
189
190   return -ENOENT;
191 }
192
193 AliHLTUInt64_t AliHLTMiscImplementation::GetTriggerMask(AliRawReader* rawReader) const
194 {
195   // see header file for function documentation
196   if (!rawReader) return 0;
197   AliHLTUInt64_t trgMask=0;
198   if (rawReader) {
199     const UInt_t* pattern=rawReader->GetTriggerPattern();
200     trgMask=pattern[1]&0xfffffff; // 28 upper bits of the 50 bit mask
201     trgMask<<=32;
202     trgMask|=pattern[0]; // 32 lower bits of the mask
203   }
204   return trgMask;
205 }
206
207 AliHLTUInt32_t AliHLTMiscImplementation::GetTimeStamp(AliRawReader* rawReader) const
208 {
209   // extract time stamp of the event from the event header
210   if (!rawReader) return 0;
211   const AliRawEventHeaderBase* eventHeader = rawReader->GetEventHeader();
212   if (!eventHeader) return 0;
213   return eventHeader->Get("Timestamp");
214 }
215
216 AliHLTUInt32_t AliHLTMiscImplementation::GetEventType(AliRawReader* rawReader) const
217 {
218   // extract event type from the event header
219   if (!rawReader) return 0;
220   const AliRawEventHeaderBase* eventHeader = rawReader->GetEventHeader();
221   if (!eventHeader) return 0;
222   return eventHeader->Get("Type");
223 }
224
225 Double_t AliHLTMiscImplementation::GetBz()
226 {
227   // Returns Bz.
228   return AliTracker::GetBz();
229 }
230
231 Double_t AliHLTMiscImplementation::GetBz(const Double_t *r)
232 {
233   // Returns Bz (kG) at the point "r" .
234   return AliTracker::GetBz(r);
235 }
236
237 void AliHLTMiscImplementation::GetBxByBz(const Double_t r[3], Double_t b[3])
238 {
239   // Returns Bx, By and Bz (kG) at the point "r" .
240   return AliTracker::GetBxByBz(r, b);
241 }
242
243 const TClass* AliHLTMiscImplementation::IsAliESDHLTDecision() const
244 {
245   // Return the IsA of the AliESDHLTDecision class
246 #ifndef HAVE_NOT_ALIESDHLTDECISION
247   return AliESDHLTDecision::Class();
248 #else // HAVE_NOT_ALIESDHLTDECISION
249   return NULL;
250 #endif // HAVE_NOT_ALIESDHLTDECISION
251 }
252
253 int AliHLTMiscImplementation::Copy(const AliHLTGlobalTriggerDecision* pDecision, TObject* object) const
254 {
255   // Copy HLT global trigger decision to AliESDHLTDecision container
256   if (!pDecision || !object) return -EINVAL;
257 #ifndef HAVE_NOT_ALIESDHLTDECISION
258   AliESDHLTDecision* pESDHLTDecision=NULL;
259   if (object->IsA()==NULL ||
260       object->IsA() != AliESDHLTDecision::Class() ||
261       (pESDHLTDecision=dynamic_cast<AliESDHLTDecision*>(object))==NULL) {
262 //     HLTError("can not copy HLT global decision to object of class \"%s\"", 
263 //           object->IsA()?object->IsA()->GetName():"NULL");
264     return -EINVAL;
265   }
266
267   pESDHLTDecision->~AliESDHLTDecision();
268   new (pESDHLTDecision) AliESDHLTDecision(pDecision->Result(), pDecision->GetTitle());
269
270 #endif // HAVE_NOT_ALIESDHLTDECISION
271   return 0;
272 }
273
274 int AliHLTMiscImplementation::InitStreamerInfos(const char* ocdbEntry) const
275 {
276   // init streamer infos for HLT reconstruction
277   // Root schema evolution is not enabled for AliHLTMessage and all streamed objects.
278   // Objects in the raw data payload rely on the availability of the correct stream info.
279   // The relevant streamer info for a specific run is stored in the OCDB.
280   int iResult=0;
281
282   AliCDBEntry* pEntry=LoadOCDBEntry(ocdbEntry);
283   TObject* pObject=NULL;
284   if (pEntry && (pObject=ExtractObject(pEntry))!=NULL)
285     {
286     TObjArray* pSchemas=dynamic_cast<TObjArray*>(pObject);
287     if (pSchemas) {
288       iResult=InitStreamerInfos(pSchemas);
289     } else {
290       AliError(Form("internal mismatch in OCDB entry %s: wrong class type", ocdbEntry));
291     }
292   } else {
293     AliWarning(Form("missing HLT reco data (%s), skipping initialization of streamer info for TObjects in HLT raw data payload", ocdbEntry));
294   }
295   return iResult;
296 }
297
298 int AliHLTMiscImplementation::InitStreamerInfos(TObjArray* pSchemas) const
299 {
300   // init streamer infos for HLT reconstruction from an array of TStreamerInfo objects
301
302   for (int i=0; i<pSchemas->GetEntriesFast(); i++) {
303     if (pSchemas->At(i)) {
304       TStreamerInfo* pSchema=dynamic_cast<TStreamerInfo*>(pSchemas->At(i));
305       if (pSchema) {
306         int version=pSchema->GetClassVersion();
307         TClass* pClass=TClass::GetClass(pSchema->GetName());
308         if (pClass) {
309           if (pClass->GetClassVersion()==version) {
310             AliDebug(0,Form("skipping schema definition %d version %d to class %s as this is the native version", i, version, pSchema->GetName()));
311             continue;
312           }
313           TObjArray* pInfos=pClass->GetStreamerInfos();
314           if (pInfos /*&& version<pInfos->GetEntriesFast()*/) {
315             if (pInfos->At(version)==NULL) {
316               TStreamerInfo* pClone=(TStreamerInfo*)pSchema->Clone();
317               if (pClone) {
318                 pClone->SetClass(pClass);
319                 pClone->BuildOld();
320                 pInfos->AddAtAndExpand(pClone, version);
321                 AliDebug(0,Form("adding schema definition %d version %d to class %s", i, version, pSchema->GetName()));
322               } else {
323                 AliError(Form("skipping schema definition %d (%s), unable to create clone object", i, pSchema->GetName()));
324               }
325             } else {
326               TStreamerInfo* pInfo=dynamic_cast<TStreamerInfo*>(pInfos->At(version));
327               if (pInfo && pInfo->GetClassVersion()==version) {
328                 AliDebug(0,Form("schema definition %d version %d already available in class %s, skipping ...", i, version, pSchema->GetName()));
329               } else {
330                 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));
331               }
332             }
333           } else {
334             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));
335           }
336         } else {
337           AliError(Form("skipping schema definition %d (%s), unable to find class", i, pSchema->GetName()));
338         }
339       } else {
340         AliError(Form("skipping schema definition %d, not of TStreamerInfo", i));
341       }
342     }
343   }
344
345   return 0;
346 }