TRD nSigma OADB related new codes and modifications and OADB root file -- Xianguo Lu
[u/mrichter/AliRoot.git] / RAW / AliRawReaderFile.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 /// 
20 /// This is a class for reading raw data files.
21 ///
22 /// The files of one event are expected to be in one directory. The name 
23 /// of the directory is "raw" + the event number. Each file contains
24 /// the raw data (with data header) of one DDL. The convention for the
25 /// file names is "DET_#DDL.ddl". "DET" is the name of the detector and
26 /// "#DDL" is the unique equipment ID.
27 ///
28 /// The constructor of AliRawReaderFile takes the event number or the
29 /// directory name as argument.
30 /// 
31 ///////////////////////////////////////////////////////////////////////////////
32
33 #include <cstdlib>
34 #include "AliRawReaderFile.h"
35 #include "AliDAQ.h"
36 #include <TSystem.h>
37 #include <TArrayC.h>
38
39
40 using std::ios;
41 ClassImp(AliRawReaderFile)
42
43
44 AliRawReaderFile::AliRawReaderFile(Int_t eventNumber) :
45   fEventIndex(eventNumber),
46   fDirName("."),
47   fDirectory(NULL),
48   fStream(NULL),
49   fEquipmentId(-1),
50   fBuffer(NULL),
51   fBufferSize(0),
52   fEquipmentSize(0),
53   fDDLIndex(NULL),
54   fDDLCurrent(-1),
55   fType(7),
56   fRunNb(0),
57   fDetectorPattern(0),
58   fTimestamp(0)
59 {
60 // create an object to read digits from the given event
61 // in the current directory
62
63   fDirectory = OpenDirectory();
64   if (!fDirectory) fIsValid = kFALSE;
65   if (!OpenNextFile()) fIsValid = kFALSE;
66
67   fId[0] = fId[1] = 0;
68   fTriggerPattern[0] = fTriggerPattern[1] = fTriggerPattern[3] = fTriggerPattern[3] = 0;
69 }
70
71 AliRawReaderFile::AliRawReaderFile(const char* dirName, Int_t eventNumber) :
72   fEventIndex(eventNumber),
73   fDirName(dirName),
74   fDirectory(NULL),
75   fStream(NULL),
76   fEquipmentId(-1),
77   fBuffer(NULL),
78   fBufferSize(0),
79   fEquipmentSize(0),
80   fDDLIndex(NULL),
81   fDDLCurrent(-1),
82   fType(7),
83   fRunNb(0),
84   fDetectorPattern(0),
85   fTimestamp(0)
86 {
87 // create an object to read digits from the given directory
88
89   fDirectory = OpenDirectory();
90   if (!fDirectory) fIsValid = kFALSE;
91   if (fEventIndex >= 0 && (!OpenNextFile())) fIsValid = kFALSE;
92
93   fId[0] = fId[1] = 0;
94   fTriggerPattern[0] = fTriggerPattern[1] = fTriggerPattern[3] = fTriggerPattern[3] = 0;
95 }
96
97 AliRawReaderFile::~AliRawReaderFile()
98 {
99 // close the input file
100
101   if (fDirectory) gSystem->FreeDirectory(fDirectory);
102   if (fStream) {
103 #if defined(__HP_aCC) || defined(__DECCXX)
104     if (fStream->rdbuf()->is_open()) fStream->close();
105 #else
106     if (fStream->is_open()) fStream->close();
107 #endif
108     delete fStream;
109   }
110   if (fHeader) delete fHeader;
111   if (fHeaderV3) delete fHeaderV3;
112
113   if (fBuffer) delete[] fBuffer;
114   if (fDDLIndex) delete fDDLIndex; fDDLIndex=NULL;
115 }
116
117 void AliRawReaderFile::RequireHeader(Bool_t required)
118 {
119   // Reading of raw data in case of missing
120   // raw data header is not implemented for
121   // this class
122   if (!required) {
123     Warning("AliRawReaderFile","Reading of raw data without raw data header!");
124     if (fHeader) delete fHeader;
125     if (fHeaderV3) delete fHeaderV3;
126     fHeader = NULL;
127     fHeaderV3 = NULL;
128   }
129
130   AliRawReader::RequireHeader(required);
131 }
132
133 TString AliRawReaderFile::GetDirName() const
134 {
135 // return the current directory name
136
137   TString dirName(fDirName);
138   if (fEventIndex >= 0) {
139     dirName += "/raw";
140     dirName += fEventIndex;
141   }
142   return dirName;
143 }
144
145 void* AliRawReaderFile::OpenDirectory()
146 {
147 // open and return the directory
148
149   TString dirName = GetDirName();
150   void* directory = gSystem->OpenDirectory(dirName);
151   if (!directory) {
152     Error("OpenDirectory", "could not open directory %s", dirName.Data());
153   }
154   return directory;
155 }
156
157 Bool_t AliRawReaderFile::CreateFileIndex()
158 {
159 // scan the files of the directory and create index of all DDL files
160 // returns kFALSE if no DDL files available
161   Bool_t result=kFALSE;
162   fDDLCurrent=-1;
163   if (fDDLIndex) return fDDLIndex->GetSize()>0;
164   if (!fDirectory) return kFALSE;
165   fDDLIndex=new TArrayC(0);
166   if (!fDDLIndex) return kFALSE;
167   TString entry;
168   while ((entry = gSystem->GetDirEntry(fDirectory))) {
169     const char* filename=entry.Data();
170     if (!filename || entry.IsNull()) break;
171     if (entry.BeginsWith("run")) {
172       entry.ReplaceAll("run","");
173       fRunNb = entry.Atoi();
174       continue;
175     }
176     if (!entry.EndsWith(".ddl")) continue;
177     result=kTRUE;
178     entry.Remove(0, entry.Last('_')+1);
179     entry.Remove(entry.Length()-4);
180     Int_t equipmentId = atoi(entry.Data());
181     Int_t ddlIndex = -1;
182     fDetectorPattern |= (1 << AliDAQ::DetectorIDFromDdlID(equipmentId,ddlIndex));
183     if (fDDLIndex->GetSize()<=equipmentId) {
184       fDDLIndex->Set(equipmentId+1);
185     }
186     char* array=(char*)fDDLIndex->GetArray();
187     array[equipmentId]=1;
188   }
189
190   return result;
191 }
192
193 Bool_t AliRawReaderFile::OpenNextFile()
194 {
195 // open the next file
196 // returns kFALSE if the current file is the last one
197
198   if (!fDDLIndex && !CreateFileIndex()) return kFALSE;
199   if (fSelectMinEquipmentId>=0 && fSelectMinEquipmentId>fEquipmentId)
200     fDDLCurrent=fSelectMinEquipmentId-1;
201
202   if (fStream) {
203 #if defined(__HP_aCC) || defined(__DECCXX)
204     if (fStream->rdbuf()->is_open()) fStream->close();
205 #else
206     if (fStream->is_open()) fStream->close();
207 #endif
208     delete fStream;
209     fStream = NULL;
210     fEquipmentId = -1;
211     fEquipmentSize = 0;
212   }
213
214   if (!fDirectory) return kFALSE;
215   while (++fDDLCurrent<(fDDLIndex->GetSize()) && 
216          (fDDLCurrent<=fSelectMaxEquipmentId || fSelectMaxEquipmentId<0)) {
217     if (fDDLIndex->At(fDDLCurrent)==0) continue;
218     Int_t dummy=0;
219     TString entry;
220     entry.Form("%s_%d.ddl", AliDAQ::DetectorNameFromDdlID(fDDLCurrent, dummy), fDDLCurrent);
221     char* fileName = gSystem->ConcatFileName(GetDirName(), entry);
222     if (!fileName) continue;
223     // read the timestamp
224     FileStat_t buf;
225     if (gSystem->GetPathInfo(fileName,buf) == 0) {
226       fTimestamp = buf.fMtime;
227     }
228 #ifndef __DECCXX 
229     fStream = new fstream(fileName, ios::binary|ios::in);
230 #else
231     fStream = new fstream(fileName, ios::in);
232 #endif
233     delete [] fileName;
234     break;
235   }
236
237   if (!fStream) return kFALSE;
238   fEquipmentId = fDDLCurrent;
239 #if defined(__HP_aCC) || defined(__DECCXX)
240   return (fStream->rdbuf()->is_open());
241 #else
242   return (fStream->is_open());
243 #endif
244 }
245
246
247 Bool_t AliRawReaderFile::ReadHeader()
248 {
249 // read a data header at the current stream position
250 // returns kFALSE if the mini header could not be read
251
252   if (!fStream && !OpenNextFile()) return kFALSE;
253   do {
254     UInt_t dataSize=0;
255     UInt_t headerSize=0;
256     if (fCount > 0) fStream->seekg(Int_t(fStream->tellg()) + fCount);
257     UInt_t currentPos = fStream->tellg();
258     if (fRequireHeader) {
259       if(! fHeader) fHeader = new AliRawDataHeader;
260       while (!fStream->read((char*) fHeader, sizeof(AliRawDataHeader))) {
261         if (!OpenNextFile()) return kFALSE;
262         currentPos = fStream->tellg();
263       }
264       dataSize=fHeader->fSize;
265       headerSize=sizeof(AliRawDataHeader);
266       if(fHeader->GetVersion() == 3){
267         delete fHeader;
268         fHeader = NULL;
269         if(! fHeaderV3) fHeaderV3 = new AliRawDataHeaderV3;
270         //rewind
271         fStream->seekg(currentPos);
272         if (!fStream->read((char*) fHeaderV3, sizeof(AliRawDataHeaderV3)))
273           return kFALSE;
274         headerSize=sizeof(AliRawDataHeaderV3);
275       } else if (fHeaderV3) {
276         delete fHeaderV3;
277         fHeaderV3 = NULL;
278       }
279       
280     }
281     else {
282       if (fStream->eof())
283         if (!OpenNextFile()) return kFALSE;
284     }
285     if ( headerSize && dataSize != 0xFFFFFFFF) {
286       fCount = dataSize - headerSize;
287     } else {
288       currentPos = fStream->tellg();
289       fStream->seekg(0, ios::end);
290       fCount = UInt_t(fStream->tellg()) - currentPos;
291       fStream->seekg(currentPos);
292     }
293     fEquipmentSize = fCount + headerSize;
294   } while (!IsSelected());
295   return kTRUE;
296 }
297
298 Bool_t AliRawReaderFile::ReadNextData(UChar_t*& data)
299 {
300 // reads the next payload at the current stream position
301 // returns kFALSE if the data could not be read
302
303   while (fCount == 0) {
304     if (!ReadHeader()) return kFALSE;
305   }
306   if (fBufferSize < fCount) {
307     if (fBuffer) delete[] fBuffer;
308     fBufferSize = Int_t(fCount*1.2);
309     fBuffer = new UChar_t[fBufferSize];
310   }
311   if (!fStream->read((char*) fBuffer, fCount)) {
312     Error("ReadNext", "could not read data!");
313     return kFALSE;
314   }
315   fCount = 0;
316
317   data = fBuffer;
318   return kTRUE;
319 }
320
321 Bool_t AliRawReaderFile::ReadNext(UChar_t* data, Int_t size)
322 {
323 // reads the next block of data at the current stream position
324 // returns kFALSE if the data could not be read
325
326   if (!fStream->read((char*) data, size)) {
327     Error("ReadNext", "could not read data!");
328     return kFALSE;
329   }
330   fCount -= size;
331   return kTRUE;
332 }
333
334
335 Bool_t AliRawReaderFile::Reset()
336 {
337 // reset the current stream position to the first DDL file of the curevent
338
339   void* directory = OpenDirectory();
340   if (!directory) return kFALSE;
341
342   if (fStream) {
343 #if defined(__HP_aCC) || defined(__DECCXX)
344     if (fStream->rdbuf()->is_open()) fStream->close();
345 #else
346     if (fStream->is_open()) fStream->close();
347 #endif
348     delete fStream;
349     fStream = NULL;
350   }
351
352   if (fDirectory) gSystem->FreeDirectory(fDirectory);
353   fDirectory = directory;
354
355   // Matthias 05.06.2008
356   // do not open the next file. That might collide with a subsequent
357   // SelectEquipment call as the 'file pointer' is already set.
358   // This is important for the indexing of the DDL files.
359   // ---------------------------------------------------------
360   // All ReadNext functions first require the fCount member to be
361   // non zero or call ReadHeader. That allows to postpone the call
362   // to OpenNextFile to the next invocation of ReadHeader.
363   // ReadHeader has been mofified according to that.
364   /*
365   OpenNextFile();
366   */
367   fEquipmentId=-1;
368   fDDLCurrent=-1;
369   fCount = 0;
370   return kTRUE;
371 }
372
373 Bool_t AliRawReaderFile::NextEvent()
374 {
375 // go to the next event directory
376
377   if (fDDLIndex) delete fDDLIndex;
378   fDDLIndex=NULL;
379   fDetectorPattern = 0;
380   if (fEventIndex < -1) return kFALSE;
381
382   do {
383     TString dirName = fDirName + "/raw";
384     dirName += (fEventIndex + 1);
385     void* directory = gSystem->OpenDirectory(dirName);
386     if (!directory) return kFALSE;
387     gSystem->FreeDirectory(directory);
388
389     fEventIndex++;
390     Reset();
391   } while (!IsEventSelected());
392
393   // Read the header of the first payload
394   // in order to fill the 'fake' event header
395   if (ReadHeader() && ( fHeader || fHeaderV3) ) {
396     UInt_t eid1=0, eid2=0;
397     ULong64_t trg1=0, trg2=0;
398     if(fHeader){
399       eid1=fHeader->GetEventID1();
400       eid2=fHeader->GetEventID2();
401       trg1=fHeader->GetTriggerClasses();
402     } else {
403       eid1=fHeaderV3->GetEventID1();
404       eid2=fHeaderV3->GetEventID2();
405       trg1=fHeaderV3->GetTriggerClasses();
406       trg2=fHeaderV3->GetTriggerClassesNext50();
407     }
408
409     fId[0] = ((eid2 >> 20) & 0xf);
410     fId[1] = (eid1 & 0xfff) | ((eid2 & 0xfffff) << 12);
411     fTriggerPattern[0] = (trg1 & 0xffffffff);
412     fTriggerPattern[1] = ((trg1 >> 32) & 0x3ffff) | ((trg2 & 0x3fff) << 18);
413     fTriggerPattern[2] = ((trg2 >> 14) & 0xffffffff);
414     fTriggerPattern[3] = ((trg2 >> 46) & 0xf);
415   }
416   else {
417     Warning("AliRawReaderFile","Can not read CDH header! The event header fields will be empty!");
418   }
419   Reset();
420
421   fEventNumber++;
422
423   return kTRUE;
424 }
425
426 Bool_t AliRawReaderFile::RewindEvents()
427 {
428 // reset the event counter
429
430   if (fEventIndex >= 0)  fEventIndex = -1;
431   fEventNumber = -1;
432   return Reset();
433 }