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