Significantly faster code using file acces with index (Matthias)
[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 ClassImp(AliRawReaderFile)
41
42
43 AliRawReaderFile::AliRawReaderFile(Int_t eventNumber) :
44   fEventIndex(eventNumber),
45   fDirName("."),
46   fDirectory(NULL),
47   fStream(NULL),
48   fEquipmentId(-1),
49   fBuffer(NULL),
50   fBufferSize(0),
51   fEquipmentSize(0),
52   fDDLIndex(NULL),
53   fDDLCurrent(-1)
54 {
55 // create an object to read digits from the given event
56 // in the current directory
57
58   fDirectory = OpenDirectory();
59   OpenNextFile();
60   fHeader = new AliRawDataHeader;
61 }
62
63 AliRawReaderFile::AliRawReaderFile(const char* dirName, Int_t eventNumber) :
64   fEventIndex(eventNumber),
65   fDirName(dirName),
66   fDirectory(NULL),
67   fStream(NULL),
68   fEquipmentId(-1),
69   fBuffer(NULL),
70   fBufferSize(0),
71   fEquipmentSize(0),
72   fDDLIndex(NULL),
73   fDDLCurrent(-1)
74 {
75 // create an object to read digits from the given directory
76
77   fDirectory = OpenDirectory();
78   OpenNextFile();
79   fHeader = new AliRawDataHeader;
80 }
81
82 AliRawReaderFile::~AliRawReaderFile()
83 {
84 // close the input file
85
86   if (fDirectory) gSystem->FreeDirectory(fDirectory);
87   if (fStream) {
88 #if defined(__HP_aCC) || defined(__DECCXX)
89     if (fStream->rdbuf()->is_open()) fStream->close();
90 #else
91     if (fStream->is_open()) fStream->close();
92 #endif
93     delete fStream;
94   }
95   if (fHeader) delete fHeader;
96   if (fBuffer) delete[] fBuffer;
97   if (fDDLIndex) delete fDDLIndex; fDDLIndex=NULL;
98 }
99
100 void AliRawReaderFile::RequireHeader(Bool_t required)
101 {
102   // Reading of raw data in case of missing
103   // raw data header is not implemented for
104   // this class
105   if (!required) {
106     Warning("AliRawReaderFile","Reading of raw data without raw data header is not implemented !");
107     if (fHeader) delete fHeader;
108     fHeader = NULL;
109   }
110   else {
111     if (!fHeader) fHeader = new AliRawDataHeader;
112   }
113
114   AliRawReader::RequireHeader(required);
115 }
116
117 TString AliRawReaderFile::GetDirName() const
118 {
119 // return the current directory name
120
121   TString dirName(fDirName);
122   if (fEventIndex >= 0) {
123     dirName += "/raw";
124     dirName += fEventIndex;
125   }
126   return dirName;
127 }
128
129 void* AliRawReaderFile::OpenDirectory()
130 {
131 // open and return the directory
132
133   TString dirName = GetDirName();
134   void* directory = gSystem->OpenDirectory(dirName);
135   if (!directory) {
136     Error("OpenDirectory", "could not open directory %s", dirName.Data());
137   }
138   return directory;
139 }
140
141 Bool_t AliRawReaderFile::CreateFileIndex()
142 {
143 // scan the files of the directory and create index of all DDL files
144 // returns kFALSE if no DDL files available
145   Bool_t result=kFALSE;
146   fDDLCurrent=-1;
147   if (fDDLIndex) return fDDLIndex->GetSize()>0;
148   if (!fDirectory) return kFALSE;
149   fDDLIndex=new TArrayC(0);
150   if (!fDDLIndex) return kFALSE;
151   TString entry;
152   while (entry = gSystem->GetDirEntry(fDirectory)) {
153     const char* filename=entry.Data();
154     if (!filename || entry.IsNull()) break;
155     if (!entry.EndsWith(".ddl")) continue;
156     result=kTRUE;
157     entry.Remove(0, entry.Last('_')+1);
158     entry.Remove(entry.Length()-4);
159     Int_t equipmentId = atoi(entry.Data());
160     if (fDDLIndex->GetSize()<=equipmentId) {
161       fDDLIndex->Set(equipmentId+1);
162     }
163     char* array=(char*)fDDLIndex->GetArray();
164     array[equipmentId]=1;
165   }
166
167   return result;
168 }
169
170 Bool_t AliRawReaderFile::OpenNextFile()
171 {
172 // open the next file
173 // returns kFALSE if the current file is the last one
174
175   if (!fDDLIndex && !CreateFileIndex()) return kFALSE;
176   if (fSelectMinEquipmentId>=0 && fSelectMinEquipmentId>fEquipmentId)
177     fDDLCurrent=fSelectMinEquipmentId-1;
178
179   if (fStream) {
180 #if defined(__HP_aCC) || defined(__DECCXX)
181     if (fStream->rdbuf()->is_open()) fStream->close();
182 #else
183     if (fStream->is_open()) fStream->close();
184 #endif
185     delete fStream;
186     fStream = NULL;
187     fEquipmentId = -1;
188     fEquipmentSize = 0;
189   }
190
191   if (!fDirectory) return kFALSE;
192   while (++fDDLCurrent<(fDDLIndex->GetSize()) && 
193          (fDDLCurrent<=fSelectMaxEquipmentId || fSelectMaxEquipmentId<0)) {
194     if (fDDLIndex->At(fDDLCurrent)==0) continue;
195     Int_t dummy=0;
196     TString entry;
197     entry.Form("%s_%d.ddl", AliDAQ::DetectorNameFromDdlID(fDDLCurrent, dummy), fDDLCurrent);
198     char* fileName = gSystem->ConcatFileName(GetDirName(), entry);
199     if (!fileName) continue;
200 #ifndef __DECCXX 
201     fStream = new fstream(fileName, ios::binary|ios::in);
202 #else
203     fStream = new fstream(fileName, ios::in);
204 #endif
205     delete [] fileName;
206     break;
207   }
208
209   if (!fStream) return kFALSE;
210   fEquipmentId = fDDLCurrent;
211 #if defined(__HP_aCC) || defined(__DECCXX)
212   return (fStream->rdbuf()->is_open());
213 #else
214   return (fStream->is_open());
215 #endif
216 }
217
218
219 Bool_t AliRawReaderFile::ReadHeader()
220 {
221 // read a data header at the current stream position
222 // returns kFALSE if the mini header could not be read
223
224   if (!fStream && !OpenNextFile()) return kFALSE;
225   do {
226     if (fCount > 0) fStream->seekg(Int_t(fStream->tellg()) + fCount);
227     if (fHeader) {
228       while (!fStream->read((char*) fHeader, sizeof(AliRawDataHeader))) {
229         if (!OpenNextFile()) return kFALSE;
230       }
231     }
232     if (fHeader && fHeader->fSize != 0xFFFFFFFF) {
233       fCount = fHeader->fSize - sizeof(AliRawDataHeader);
234     } else {
235       UInt_t currentPos = fStream->tellg();
236       fStream->seekg(0, ios::end);
237       fCount = UInt_t(fStream->tellg()) - currentPos;
238       fStream->seekg(currentPos);
239     }
240     fEquipmentSize = fCount;
241     if (fHeader) fEquipmentSize += sizeof(AliRawDataHeader);
242   } while (!IsSelected());
243   return kTRUE;
244 }
245
246 Bool_t AliRawReaderFile::ReadNextData(UChar_t*& data)
247 {
248 // reads the next payload at the current stream position
249 // returns kFALSE if the data could not be read
250
251   while (fCount == 0) {
252     if (!ReadHeader()) return kFALSE;
253   }
254   if (fBufferSize < fCount) {
255     if (fBuffer) delete[] fBuffer;
256     fBufferSize = Int_t(fCount*1.2);
257     fBuffer = new UChar_t[fBufferSize];
258   }
259   if (!fStream->read((char*) fBuffer, fCount)) {
260     Error("ReadNext", "could not read data!");
261     return kFALSE;
262   }
263   fCount = 0;
264
265   data = fBuffer;
266   return kTRUE;
267 }
268
269 Bool_t AliRawReaderFile::ReadNext(UChar_t* data, Int_t size)
270 {
271 // reads the next block of data at the current stream position
272 // returns kFALSE if the data could not be read
273
274   if (!fStream->read((char*) data, size)) {
275     Error("ReadNext", "could not read data!");
276     return kFALSE;
277   }
278   fCount -= size;
279   return kTRUE;
280 }
281
282
283 Bool_t AliRawReaderFile::Reset()
284 {
285 // reset the current stream position to the first DDL file of the curevent
286
287   void* directory = OpenDirectory();
288   if (!directory) return kFALSE;
289
290   if (fStream) {
291 #if defined(__HP_aCC) || defined(__DECCXX)
292     if (fStream->rdbuf()->is_open()) fStream->close();
293 #else
294     if (fStream->is_open()) fStream->close();
295 #endif
296     delete fStream;
297     fStream = NULL;
298   }
299
300   if (fDirectory) gSystem->FreeDirectory(fDirectory);
301   fDirectory = directory;
302
303   // Matthias 05.06.2008
304   // do not open the next file. That might collide with a subsequent
305   // SelectEquipment call as the 'file pointer' is already set.
306   // This is important for the indexing of the DDL files.
307   // ---------------------------------------------------------
308   // All ReadNext functions first require the fCount member to be
309   // non zero or call ReadHeader. That allows to postpone the call
310   // to OpenNextFile to the next invocation of ReadHeader.
311   // ReadHeader has been mofified according to that.
312   /*
313   OpenNextFile();
314   */
315   fEquipmentId=-1;
316   fDDLCurrent=-1;
317   fCount = 0;
318   return kTRUE;
319 }
320
321 Bool_t AliRawReaderFile::NextEvent()
322 {
323 // go to the next event directory
324
325   if (fDDLIndex) delete fDDLIndex;
326   fDDLIndex=NULL;
327   if (fEventIndex < -1) return kFALSE;
328
329   do {
330     TString dirName = fDirName + "/raw";
331     dirName += (fEventIndex + 1);
332     void* directory = gSystem->OpenDirectory(dirName);
333     if (!directory) return kFALSE;
334     gSystem->FreeDirectory(directory);
335
336     fEventIndex++;
337     Reset();
338   } while (!IsEventSelected());
339
340   fEventNumber++;
341
342   return kTRUE;
343 }
344
345 Bool_t AliRawReaderFile::RewindEvents()
346 {
347 // reset the event counter
348
349   if (fEventIndex >= 0)  fEventIndex = -1;
350   fEventNumber = -1;
351   return Reset();
352 }