b46e2db1334a4f4cae81a546cca9e44ab8dde0b9
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCDDLDataFileHandler.cxx
1 // @(#) $Id$
2
3 // Author: C. Loizides <loizides@ikf.uni-frankfurt.de>
4 //*-- Copyright &copy ALICE HLT Group
5
6 #include "AliHLTTPCRootTypes.h"
7 #include "AliHLTTPCLogging.h"
8 #include "AliHLTTPCTransform.h"
9 #include "AliHLTTPCMemHandler.h"
10 #include "AliHLTTPCDigitData.h"
11 #ifdef use_newio
12 #include "AliRawReaderRoot.h"
13 #include "AliRawReaderDate.h"
14 #else
15 #include "AliHLTTPCDDLTPCRawStream.h"
16 #include "AliHLTTPCDDLRawReaderFile.h"
17 #endif
18 #include "AliHLTTPCDDLDataFileHandler.h"
19
20 #if __GNUC__ >= 3
21 using namespace std;
22 #endif
23
24 /** \class AliHLTTPCDDLDataFileHandler 
25 <pre>
26 //_____________________________________________________________
27 // AliHLTTPCDDLDataFileHandler
28 //
29 //  This class does converts from the DDL format of offline
30 //  into the memory I/O handling of the HLT binary files.
31 //  
32 //  Examples: see ddl2binary in exa and the general 
33 //            AliHLTTPCMemHandler class description
34 //
35 </pre>
36 */
37
38 ClassImp(AliHLTTPCDDLDataFileHandler)
39
40 AliHLTTPCDDLDataFileHandler::AliHLTTPCDDLDataFileHandler()
41 {
42   // default constructor
43   fReader=0;
44   fTPCStream=0;
45 }
46
47 AliHLTTPCDDLDataFileHandler::~AliHLTTPCDDLDataFileHandler()
48 {
49   // destructor
50   FreeAll();
51 }
52
53 void AliHLTTPCDDLDataFileHandler::FreeAll()
54 {
55   // frees all heap memory
56   if(fReader) delete fReader;
57   fReader = 0;
58   if(fTPCStream) delete fTPCStream;
59   fTPCStream = 0;
60 }
61
62
63 #ifdef use_newio
64 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(AliRawEvent *rawevent)
65 {
66   // sets the input of the reader
67   fEvent=-1;
68   fFilename="";
69   if(fReader) delete fReader;
70   fReader=new AliRawReaderRoot(rawevent);
71   if(fTPCStream) delete fTPCStream;
72   fTPCStream=new AliTPCRawStream(fReader);
73
74   return kTRUE;
75 }
76
77 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(Char_t *name,Int_t event)
78 {
79   // sets the input of the reader
80   fEvent=event;
81   if(fReader) delete fReader;
82   if(fTPCStream) delete fTPCStream;
83   if(event>=0){
84     fFilename=name;
85     fReader=new AliRawReaderRoot(name,event);
86   } else {
87     fFilename="";
88     fReader=new AliRawReaderDate((void *)name);
89   }
90   fTPCStream=new AliTPCRawStream(fReader);
91
92   return kTRUE;
93 }
94 #else
95 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(Char_t *name, Bool_t add)
96 {
97   // sets the input of the reader
98   if(fReader){
99     LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::SetReaderInput","File Open")
100       <<"Reader ptr is already in use"<<ENDLOG;
101     return kFALSE;
102   }
103  
104   fReader=new AliHLTTPCDDLRawReaderFile(name,add);
105   fTPCStream=new AliHLTTPCDDLTPCRawStream(fReader);
106   
107   return kTRUE;
108 }
109 Bool_t AliHLTTPCDDLDataFileHandler::SetReaderInput(AliHLTTPCDDLRawReaderFile *rf)
110 {
111   // sets the input of the reader
112   if(fReader){
113     LOG(AliHLTTPCLog::kError,"AliHLTTPCRawDataFileHandler::SetReaderInput","File Open")
114       <<"Reader ptr is already in use, delete it first"<<ENDLOG;
115     return kFALSE;
116   }
117
118   //Open the raw data file with given file.
119   fReader = rf;
120   fTPCStream=new AliHLTTPCDDLTPCRawStream(fReader);
121
122   return kTRUE;
123 }
124 #endif
125
126 void AliHLTTPCDDLDataFileHandler::CloseReaderInput()
127 {
128   // closes the input of the reader
129   if(!fReader){
130     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCRawDataFileHandler::CloseReaderInput","File Close")
131       <<"Nothing to Close"<<ENDLOG;
132     return;
133   }
134
135   delete fReader;
136   delete fTPCStream;
137   fReader = 0;
138   fTPCStream = 0;
139 }
140
141 #ifdef use_newio
142 Bool_t AliHLTTPCDDLDataFileHandler::IsDigit(Int_t /*i*/) const
143 {
144   // dummy
145   return kTRUE;
146 }
147 #endif
148
149 #ifndef fast_raw
150 AliHLTTPCDigitRowData * AliHLTTPCDDLDataFileHandler::DDLData2Memory(UInt_t &nrow,Int_t event)
151 {
152   // transfers the DDL data to the memory
153 #ifdef use_newio
154   if((fEvent>=0)&&(event!=fEvent)){
155     fEvent=event;
156     if(fReader) delete fReader;
157     if(fTPCStream) delete fTPCStream;
158     fReader=new AliRawReaderRoot(fFilename,event);
159     fTPCStream=new AliTPCRawStream(fReader);
160   }
161 #endif
162   AliHLTTPCDigitRowData *data = 0;
163   nrow=0;
164
165   if(!fReader){
166     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCDDLDataFileHandler::DDLData2Memory","File")
167     <<"No Input avalible: no object AliHLTTPCDDLRawReaderFile"<<ENDLOG;
168     return 0; 
169   }
170   
171   Int_t nrows=fRowMax-fRowMin+1;
172   Int_t ndigitcount=0;
173   Int_t * ndigits = new Int_t[nrows];
174   UShort_t ***charges=new UShort_t**[nrows];
175   for(Int_t r=fRowMin;r<=fRowMax;r++){
176     Int_t lrow=r-fRowMin;
177     charges[lrow]=new UShort_t*[AliHLTTPCTransform::GetNPads(r)];
178     for(Int_t k=0;k<AliHLTTPCTransform::GetNPads(r);k++){
179       charges[lrow][k]=new UShort_t[AliHLTTPCTransform::GetNTimeBins()];
180       for(Int_t j=0;j<AliHLTTPCTransform::GetNTimeBins();j++) charges[lrow][k][j]=0;
181     }
182   }
183
184   Int_t ddlsToSearch=0;
185   Int_t ddls[9]={-1,-1,-1,-1,-1,-1,-1,-1,-1};
186   Int_t ddlid=-1,lddlid=-1;
187   for(Int_t r=fRowMin;r<=fRowMax;r++){
188     ndigits[r-fRowMin] = 0; //now digits on row
189
190     Int_t patch=AliHLTTPCTransform::GetPatch(r);
191     Int_t sector,row;
192     AliHLTTPCTransform::Slice2Sector(fSlice,r,sector,row);
193
194     if(sector<36) //taken from AliTPCBuffer160.cxx
195       ddlid=sector*2+patch;
196     else
197       ddlid=70+(sector-36)*4+patch;
198
199     if((lddlid!=ddlid-1)&&(r==30)){ //dont forget the split row on the last ddl
200       ddls[ddlsToSearch++]=ddlid-1;     
201       lddlid=ddlid-1;
202     }
203
204     if((lddlid==-1)||(ddlid!=lddlid)){
205       ddls[ddlsToSearch++]=ddlid;
206       lddlid=ddlid;
207     }
208     if((r==90)||(r==139)){ //dont forget the split row on the next ddl
209       ddls[ddlsToSearch++]=ddlid+1;     
210       lddlid=ddlid+1;
211     }
212   }
213
214   //  for(Int_t i=0;i<ddlsToSearch;i++) cout << ddls[i] <<endl;
215
216   if(ddls[0]>ddls[ddlsToSearch-1]) {
217     Int_t tempddl = ddls[0];
218     ddls[0] = ddls[ddlsToSearch-1];
219     ddls[ddlsToSearch-1] = tempddl;
220   }
221 #ifdef use_newio
222     fReader->Reset();
223     fReader->Select(0,ddls[0],ddls[ddlsToSearch-1]);
224     fTPCStream->Reset();
225 #else
226     fTPCStream->SetDDLID(ddls[i]); //ddl to read out
227 #endif
228     Int_t zerosup = AliHLTTPCTransform::GetZeroSup();
229     Int_t adcsat = AliHLTTPCTransform::GetADCSat();
230     Int_t slice,srow;
231     Int_t lrow=-1;
232
233     while (fTPCStream->Next()){
234
235       if(fTPCStream->IsNewSector() || fTPCStream->IsNewRow()) {
236         Int_t sector=fTPCStream->GetSector();
237         Int_t row=fTPCStream->GetRow();
238         AliHLTTPCTransform::Sector2Slice(slice,srow,sector,row);
239         if(slice!=fSlice){
240           LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Slice")
241             <<AliHLTTPCLog::kDec<<"Found slice "<<slice<<", expected "<<fSlice<<ENDLOG;
242           continue;
243         }
244         lrow=srow-fRowMin;
245       }
246
247       //test row criteria (patch boundaries)
248       if((srow<fRowMin)||(srow>fRowMax))continue;
249
250       Int_t pad=fTPCStream->GetPad();
251       if(fTPCStream->IsNewPad()) {
252         if((pad<0)||(pad>=AliHLTTPCTransform::GetNPads(srow))){
253           LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Pad")
254             <<AliHLTTPCLog::kDec<<"Pad value out of bounds "<<pad<<" "
255             <<AliHLTTPCTransform::GetNPads(srow)<<ENDLOG;
256           continue;
257         }
258       }
259
260       Int_t time=fTPCStream->GetTime();
261       if((time<0)||(time>=AliHLTTPCTransform::GetNTimeBins())){
262         LOG(AliHLTTPCLog::kError,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Time")
263           <<AliHLTTPCLog::kDec<<"Time out of bounds "<<time<<" "
264           <<AliHLTTPCTransform::GetNTimeBins()<<ENDLOG;
265         continue;
266       }
267
268       //store digit
269       UShort_t dig=fTPCStream->GetSignal();
270       if(dig <= zerosup) continue;
271       if(dig >= adcsat) dig = adcsat;
272
273       ndigits[lrow]++; //for this row only
274       ndigitcount++;   //total number of digits to be published
275
276       charges[lrow][pad][time]=dig;
277     }
278
279   Int_t size = sizeof(AliHLTTPCDigitData)*ndigitcount
280     + nrows*sizeof(AliHLTTPCDigitRowData);
281
282   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCDDLDataFileHandler::DDLDigits2Memory","Digits")
283     <<AliHLTTPCLog::kDec<<"Found "<<ndigitcount<<" Digits"<<ENDLOG;
284   
285   data=(AliHLTTPCDigitRowData*) Allocate(size);
286   nrow = (UInt_t)nrows;
287   AliHLTTPCDigitRowData *tempPt = data;
288
289   for(Int_t r=fRowMin;r<=fRowMax;r++){
290     Int_t lrow=r-fRowMin;
291     tempPt->fRow = r;
292     tempPt->fNDigit = ndigits[lrow];
293   
294     Int_t localcount=0;
295     for(Int_t pad=0;pad<AliHLTTPCTransform::GetNPads(r);pad++){
296       for(Int_t time=0;time<AliHLTTPCTransform::GetNTimeBins();time++){
297         UShort_t dig=charges[lrow][pad][time];
298         if(!dig) continue;
299
300         if(localcount >= ndigits[lrow])
301           LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDDLDataFileHandler::DDLDigits2Binary","Memory")
302             <<AliHLTTPCLog::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
303             <<ndigits[lrow]<<ENDLOG;
304         
305
306         tempPt->fDigitData[localcount].fCharge=dig;
307         tempPt->fDigitData[localcount].fPad=pad;
308         tempPt->fDigitData[localcount].fTime=time;
309 #ifdef do_mc
310         tempPt->fDigitData[localcount].fTrackID[0] = 0;
311         tempPt->fDigitData[localcount].fTrackID[1] = 0;
312         tempPt->fDigitData[localcount].fTrackID[2] = 0;
313 #endif
314         localcount++;
315       }
316     }
317
318     if(localcount != ndigits[lrow])
319       LOG(AliHLTTPCLog::kFatal,"AliHLTTPCDDLDataFileHandler::DDLDigits2Binary","Memory")
320         <<AliHLTTPCLog::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
321         <<ndigits[lrow]<<ENDLOG;
322
323
324     Byte_t *tmp = (Byte_t*)tempPt;
325     Int_t size = sizeof(AliHLTTPCDigitRowData)
326                                       + ndigits[lrow]*sizeof(AliHLTTPCDigitData);
327     tmp += size;
328     tempPt = (AliHLTTPCDigitRowData*)tmp;
329   }
330
331   //delete charge array
332   for(Int_t r=fRowMin;r<=fRowMax;r++){
333     Int_t lrow=r-fRowMin;
334     for(Int_t k=0;k<AliHLTTPCTransform::GetNPads(r);k++)
335         delete charges[lrow][k];
336     delete charges[lrow];
337   }
338   delete charges;
339   delete [] ndigits;
340
341   return data;
342 }
343 #else
344 AliHLTTPCDigitRowData * AliHLTTPCDDLDataFileHandler::DDLData2Memory(UInt_t &nrow,Int_t event)
345 {
346   // transfers the DDL data to the memory
347 #ifdef use_newio
348   if((fEvent>=0)&&(event!=fEvent)){
349     fEvent=event;
350     if(fReader) delete fReader;
351     if(fTPCStream) delete fTPCStream;
352     fReader=new AliRawReaderRoot(fFilename,event);
353     fTPCStream=new AliTPCRawStream(fReader);
354   }
355 #endif
356   AliHLTTPCDigitRowData *data = 0;
357   nrow=0;
358
359   if(!fReader){
360     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCDDLDataFileHandler::DDLData2Memory","File")
361     <<"No Input avalible: no object AliHLTTPCDDLRawReaderFile"<<ENDLOG;
362     return 0; 
363   }
364   
365   Int_t nrows=fRowMax-fRowMin+1;
366
367   Int_t ddlsToSearch=0;
368   Int_t ddls[9]={-1,-1,-1,-1,-1,-1,-1,-1,-1};
369   Int_t ddlid=-1,lddlid=-1;
370   for(Int_t r=fRowMin;r<=fRowMax;r++){
371
372     Int_t patch=AliHLTTPCTransform::GetPatch(r);
373     Int_t sector,row;
374     AliHLTTPCTransform::Slice2Sector(fSlice,r,sector,row);
375
376     if(sector<36) //taken from AliTPCBuffer160.cxx
377       ddlid=sector*2+patch;
378     else
379       ddlid=70+(sector-36)*4+patch;
380
381     if((lddlid==-1)||(ddlid!=lddlid)){
382       ddls[ddlsToSearch++]=ddlid;
383       lddlid=ddlid;
384     }
385   }
386
387   //  for(Int_t i=0;i<ddlsToSearch;i++) cout << ddls[i] <<endl;
388
389 #ifdef use_newio
390   fReader->Reset();
391   fReader->Select(0,ddls[0],ddls[ddlsToSearch-1]);
392   fTPCStream->Reset();
393 #else
394   fTPCStream->SetDDLID(ddls[i]); //ddl to read out
395 #endif
396
397   nrow = (UInt_t)nrows;
398
399   return data;
400 }
401 #endif
402
403 Bool_t AliHLTTPCDDLDataFileHandler::DDLData2CompBinary(Int_t event)
404 {
405   // transfers the DDL data to the memory and converts it 
406   // to comp binary 
407   Bool_t out = kTRUE;
408   UInt_t ndigits=0;
409   AliHLTTPCDigitRowData *digits=0;
410   digits = DDLData2Memory(ndigits,event);
411   out = Memory2CompBinary(ndigits,digits);
412   Free();
413   return out;
414 }