Bugfix; Need Init(slice,patch)
[u/mrichter/AliRoot.git] / HLT / misc / AliL3DataHandler.cxx
CommitLineData
b328544b 1//$Id$
2
3// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
4//*-- Copyright &copy ASV
5
6#include "AliL3DataHandler.h"
7#include "AliL3Logging.h"
8#include "AliTransBit.h"
9
10#include <stdio.h>
11
12//_____________________________________________________________
13// AliL3DataHandler
14//
15// HLT Binary file handler.
16//
17// This class have more or less the same functionality as AliL3MemHandler,
18// except that it handles 8 bit ADC-values. Reading and writing is done in the same way
19// as illustrated in example 1) and 2) in AliL3MemHandler.
20//
21// For converting 10 bit data files to 8 bit data files, do:
22//
23// AliL3MemHandler *file = new AliL3DataHandler();
494015ab 24// file->Init(slice,patch);
b328544b 25// file->SetBinaryInput(inputfile); //10 bit data file
26// file->SetBinaryOutput(outputfile); //8 bit data file
27// file->Convert10to8Bit();
28// file->CloseBinaryInput();
29// file->CloseBinaryOutput();
30// delete file;
31//
32// Compress data format
33// --------------------
34//
35// The data is RLE encoded, using _8_bit representation of the ADC-values.
36// Conversion is done in the class AliTransBit.
37//
38// In the beginning of every row, the row number if written and the number of pads
39// containing data on that row. For every pad with data the pad number is written,
40// and then comes the ADC-values on that pad. When a serie of zeros occure, a zero
41// is written followed by the number of zeros. If the number of zeros is more than
42// 255 (8 bit), another 8 bit word is written for the remaining. At the end of one
ffe3a919 43// pad, 2 zeros are written. Example:
b328544b 44//
45// ROW PAD 0 NZEROS ADC ADC ADC ADC 0 NZEROS ADC ADC 0 0
46//
47// Everything is written using 8 bit;
48// (ROW < 176, PAD < 200, ADC < 255, if(NZEROS > 255) write 2 words;)
49
50ClassImp(AliL3DataHandler)
51
52
53AliL3DataHandler::AliL3DataHandler()
54{
55 fBitTransformer = 0;
56}
57
58AliL3DataHandler::~AliL3DataHandler()
59{
60 if(fBitTransformer)
61 delete fBitTransformer;
62
63}
64
65void AliL3DataHandler::Convert10to8Bit()
66{
67 //Convert from 10 bit data in inputfile, to 8 bit data written to outputfile.
68
69 if(!fInBinary)
70 {
71 LOG(AliL3Log::kError,"AliL3DataHandler::Convert10to8Bit","File")
72 <<AliL3Log::kHex<<"Pointer to input file : "<<(Int_t)fInBinary<<ENDLOG;
73 return;
74 }
75 if(!fOutBinary)
76 {
77 LOG(AliL3Log::kError,"AliL3DataHandler::Convert10to8Bit","File")
78 <<AliL3Log::kHex<<"Pointer to output file : "<<(Int_t)fOutBinary<<ENDLOG;
79 return;
80 }
81
82
83 //Initialize the bit transformation class:
84 fBitTransformer = new AliTransBit_v1();
85 Int_t b0=10; // original number of bits
86 Int_t b1=8; // compressed
87 fBitTransformer->SetBits(b0,b1);
88 fBitTransformer->FindOptimumX0();
89 fBitTransformer->Update();
90
91 AliL3MemHandler *memory = new AliL3MemHandler();
494015ab 92 memory->Init(fSlice,fPatch);
b328544b 93 memory->SetBinaryInput(fInBinary);
94 UInt_t nrow;
95 AliL3DigitRowData *data = (AliL3DigitRowData*)memory->CompBinary2Memory(nrow);
96
97 Memory2CompBinary(nrow,data);
98
99 delete memory;
100}
101
102Bool_t AliL3DataHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data)
103{
104 //Compress data by RLE, and write to a binary file.
105
106 UInt_t size = GetCompMemorySize(nrow,data);
107 Byte_t *comp = Allocate(size);
108 Memory2CompMemory(nrow,data,comp);
109 if(!CompMemory2CompBinary(nrow,comp,size))
110 {
111 LOG(AliL3Log::kError,"AliL3DataHandler::Memory2CompBinary","File")
112 <<"Error writing to file "<<ENDLOG;
113 return 0;
114 }
115 Free();
116 return kTRUE;
117}
118
119AliL3DigitRowData *AliL3DataHandler::CompBinary2Memory(UInt_t &nrow)
120{
121 //Read RLE compressed binary file, unpack it and return pointer to it.
122
123 AliL3MemHandler *memory = new AliL3MemHandler();
124 memory->SetBinaryInput(fInBinary);
125 Byte_t *comp = memory->Allocate();
126
127 if(!CompBinary2CompMemory(nrow,comp))
128 {
129 LOG(AliL3Log::kError,"AliL3DataHandler::CompBinary2Memory","File")
130 <<"Error reading from file "<<ENDLOG;
131 return 0;
132 }
133 UInt_t size = GetMemorySize(nrow,comp);
134 AliL3DigitRowData *data = (AliL3DigitRowData*)Allocate(size);
135 CompMemory2Memory(nrow,data,comp);
136 delete memory;
137 return data;
138}
139
140void AliL3DataHandler::Write(Byte_t *comp,UInt_t &index,UShort_t value)
141{
142 //Write one value (=1 byte) to array comp.
143
144 if(value > 255)
145 {
146 LOG(AliL3Log::kFatal,"AliL3DataHandler::Write","Bitnumbers")
147 <<"Value too big for storing in 1 byte, something is wrong: "<<value<<" "<<index<<ENDLOG;
148 }
149 comp[index] = (Byte_t)value;
150 index++;
151}
152
153Short_t AliL3DataHandler::Read(Byte_t *comp,UInt_t &index)
154{
155 //Read one value (=1 byte) from array comp
156
157 Short_t value = (Short_t)comp[index];
158 index++;
159 return value;
160}
161
162Short_t AliL3DataHandler::Test(Byte_t *comp,UInt_t index)
163{
164 //Check the value (=1 byte) in array comp, but not read.
165
166 Short_t value = (Short_t)comp[index];
167 return value;
168}
169
170Bool_t AliL3DataHandler::Memory2CompMemory(UInt_t nrow,AliL3DigitRowData *data,Byte_t *comp)
171{
172 //Perform RLE.
173
174 if(!data)
175 {
176 LOG(AliL3Log::kError,"AliL3DataHandler::Memory2CompMemory","Data")
177 <<AliL3Log::kHex<<" Pointer to data = "<<(Int_t)data<<ENDLOG;
178 return 0;
179 }
180 if(!comp)
181 {
182 LOG(AliL3Log::kError,"AliL3DataHandler::Memory2CompMemory","Data")
183 <<AliL3Log::kHex<<" Pointer to compressed data = "<<(Int_t)comp<<ENDLOG;
184 return 0;
185 }
186
187 AliL3DigitRowData *rowPt = data;
188
189 UInt_t index = 0;
190 Int_t npads[200];
191
192 for(UInt_t i=0; i<nrow; i++)
193 {
194 //Write the row number:
195 UShort_t value = rowPt->fRow;
196 Write(comp,index,value);
197
198 UShort_t number_of_pads=0;
199 UShort_t max_pad = 0;
200
201 for(Int_t j=0; j<200; j++)
202 npads[j]=0;
203 for(UInt_t dig=0; dig<rowPt->fNDigit; dig++)
204 {
205 if(rowPt->fDigitData[dig].fPad < 200)
206 npads[rowPt->fDigitData[dig].fPad]++;
207 }
208 for(Int_t j=0; j<200; j++)
209 {
210 if(npads[j])
211 {
212 number_of_pads++;
213 max_pad = j;
214 }
215 }
216
217 //Write the number of pads on this row:
218 Write(comp,index,number_of_pads);
219 UInt_t digit=0;
220
221 for(UShort_t pad=0; pad <= max_pad; pad++)
222 {
223
224 if(digit >= rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
225 continue;
226
227 //Write the current pad:
228 Write(comp,index,pad);
229
230 if(digit < rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad)
231 {
232 if(rowPt->fDigitData[digit].fTime > 0)
233 {
234 //If first time!=0, write the number of following zeros,
235 //and then the first timebin:
236 Write(comp,index,0);
237
238 //Check if we have to use more than 1 byte to write the zeros:
239 Int_t number_of_zero_intervals=0;
240 if(rowPt->fDigitData[digit].fTime > 255)
241 {
242 number_of_zero_intervals++;
243 Write(comp,index,255);
244 if(rowPt->fDigitData[digit].fTime > 2*255)
245 {
246 Write(comp,index,255);
247 number_of_zero_intervals++;
248 }
249 }
250 Write(comp,index,(rowPt->fDigitData[digit].fTime - number_of_zero_intervals*255));
251 }
252 }
253
254 while(digit < rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad)
255 {
256 UShort_t charge = rowPt->fDigitData[digit].fCharge;
257
258 if(fBitTransformer)
259 charge = fBitTransformer->Get0to1(charge); //Transform 10 to 8 bit.
260
261 //Check for saturation:
ffe3a919 262 if(charge>255)
b328544b 263 {
264 LOG(AliL3Log::kWarning,"AliL3DataHandler::Memory2CompMemory","Digit")
265 <<"ADC-value saturated : "<<charge<<ENDLOG;
266 charge=255;
267 }
268
269 //Write the charge:
270 Write(comp,index,charge);
271
272 //Check if the next digit is zero:
273 if(digit+1 < rowPt->fNDigit && rowPt->fDigitData[digit+1].fPad == pad)
274 {
275 if(rowPt->fDigitData[digit].fTime + 1 != rowPt->fDigitData[digit+1].fTime)
276 {
277 Write(comp,index,0);
278 UShort_t nzero = rowPt->fDigitData[digit+1].fTime - (rowPt->fDigitData[digit].fTime + 1);
279
280 //Check if we have to use more than one byte to write the zeros:
281 Int_t number_of_zero_intervals=0;
282 if(nzero > 255)
283 {
284 number_of_zero_intervals++;
285 Write(comp,index,255);
286 if(nzero > 2*255)
287 {
288 Write(comp,index,255);
289 number_of_zero_intervals++;
290 }
291 }
292 Write(comp,index,(nzero - number_of_zero_intervals*255));
293 }
294 }
295 digit++;
296 }
297
298 //This is the end of the pad, state it with 2 zeros:
299 Write(comp,index,0);
300 Write(comp,index,0);
301 }
302
303 UpdateRowPointer(rowPt);
304
305 }
306
307 return index * sizeof(Byte_t);
308
309}
310
311UInt_t AliL3DataHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data)
312{
313 //Calculate the size (in bytes) of RLE data.
314
315 if(!data)
316 {
317 LOG(AliL3Log::kError,"AliL3DataHandler::GetCompMemorySize","Data")
318 <<AliL3Log::kHex<<" Data pointer = "<<(Int_t)data<<ENDLOG;
319 return 0;
320 }
321
322 AliL3DigitRowData *rowPt = data;
323
324 UInt_t index = 0;
325 Int_t npads[200];
326
327 for(UInt_t i=0;i<nrow;i++)
328 {
329 //Write the row number:
330 index++;
331
332 UShort_t max_pad=0;
333 UShort_t number_of_pads = 0;
334
335 for(Int_t j=0; j<200; j++)
336 npads[j]=0;
337
338 for(UInt_t dig=0; dig<rowPt->fNDigit; dig++)
339 {
340 if(rowPt->fDigitData[dig].fPad <200)
341 npads[rowPt->fDigitData[dig].fPad]++;
342 }
343 for(Int_t j=0; j<200; j++)
344 {
345 if(npads[j])
346 {
347 number_of_pads++;
348 max_pad = j;
349 }
350 }
351
352 //Write the number of pads on this row:
353 index++;
354
355 UInt_t digit=0;
356 for(UShort_t pad=0; pad <= max_pad; pad++)
357 {
358 if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
359 continue;
360
361 //Write the current pad:
362 index++;
363
364
365 if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad)
366 {
367 if(rowPt->fDigitData[digit].fTime > 0)
368 {
369 //If first time!=0, write the number of following zeros,
370 //and then the first timebin:
371
372 index++;
373 index++;
374
375 //Check if we have to use more than 1 byte to write the zeros:
376 if(rowPt->fDigitData[digit].fTime > 255)
377 index++;
378 if(rowPt->fDigitData[digit].fTime > 2*255)
379 index++;
380 }
381 }
382
383 while(digit < rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad)
384 {
385 //Write the charge:
386 index++;
387
388 //Check if the next digit is zero:
389 if(digit+1 < rowPt->fNDigit && rowPt->fDigitData[digit+1].fPad == pad)
390 {
391 if(rowPt->fDigitData[digit].fTime +1 != rowPt->fDigitData[digit+1].fTime)
392 {
393 index++;
394 index++;
395
396 //Check if we have to use more than 1 byte to write the zeros:
397 UInt_t nzeros = rowPt->fDigitData[digit+1].fTime - rowPt->fDigitData[digit].fTime + 1;
398 if(nzeros > 255)
399 index++;
400 if(nzeros > 2*255)
401 index++;
402 }
403 }
404 digit++;
405 }
406
407 //Mark the end of the pad with 2 zeros:
408 index++;
409 index++;
410 }
411
412 UpdateRowPointer(rowPt);
413 }
414
415 return index * sizeof(Byte_t);
416
417}
418
419UInt_t AliL3DataHandler::CompMemory2Memory(UInt_t nrow,AliL3DigitRowData *data,Byte_t *comp)
420{
421 //Uncompress RLE data.
422
423 if(!data)
424 {
425 LOG(AliL3Log::kError,"AliL3DataHandler::CompMemory2Memory","Array")
426 <<AliL3Log::kHex<<"Pointer to data: "<<(Int_t)data<<ENDLOG;
427 return 0;
428 }
429 if(!comp)
430 {
431 LOG(AliL3Log::kError,"AliL3DataHandler::CompMemory2Memory","Array")
432 <<AliL3Log::kHex<<"Pointer to compressed data: "<<(Int_t)data<<ENDLOG;
433 return 0;
434 }
435
436 Int_t outsize=0;
437
438 AliL3DigitRowData *rowPt = data;
439 UInt_t index=0;
ffe3a919 440
b328544b 441 UShort_t pad,time,charge;
442 for(UInt_t i=0; i<nrow; i++)
443 {
444 UInt_t ndigit=0;
445
446 //Read the row:
447 rowPt->fRow = Read(comp,index);
ffe3a919 448
b328544b 449 //Read the number of pads:
450 UShort_t npads = Read(comp,index);
ffe3a919 451
b328544b 452 for(UShort_t p=0; p<npads; p++)
453 {
454 //Read the current pad:
455 pad = Read(comp,index);
456
457 time = 0;
ffe3a919 458
459 //Check for zeros:
b328544b 460 if(Test(comp,index) == 0) //Zeros
461 {
462 //Read the first zero
463 Read(comp,index);
464 if(Test(comp,index) == 0)//end of pad.
465 {
466 time = Read(comp,index);
467 continue;
468 }
469 if( (time = Read(comp,index)) == 255 )
470 if( (time += Read(comp,index)) == 2*255)
471 time += Read(comp,index);
472 }
473 while(1)
474 {
475 while( (charge = Read(comp,index)) != 0)
476 {
477 rowPt->fDigitData[ndigit].fPad = pad;
478 rowPt->fDigitData[ndigit].fTime = time;
479 rowPt->fDigitData[ndigit].fCharge = charge;
480 time++;
481 ndigit++;
482 }
483 if(Test(comp,index) == 0)
484 {
485 Read(comp,index); //end of pad
486 break;
487 }
488 UShort_t time_shift;
489 if( (time_shift = Read(comp,index)) == 255)
490 if( (time_shift += Read(comp,index)) == 2*255)
491 time_shift += Read(comp,index);
492 time += time_shift;
493 }
494 }
495 rowPt->fNDigit = ndigit;
496 UpdateRowPointer(rowPt);
497 outsize += sizeof(AliL3DigitData)*ndigit + sizeof(AliL3DigitRowData);
498 }
499
500 return outsize;
501}
502
503UInt_t AliL3DataHandler::GetMemorySize(UInt_t nrow,Byte_t *comp)
504{
505 //Calculate size (in bytes) of unpacked data.
506
507 UInt_t index=0;
508 Int_t outsize=0;
ffe3a919 509
b328544b 510 for(UInt_t i=0; i<nrow; i++)
511 {
512 UInt_t ndigit=0;//Digits on this row.
513
514 //Row number:
515 Read(comp,index);
516
517 UShort_t npad = Read(comp,index);
ffe3a919 518
b328544b 519 for(UShort_t pad=0; pad<npad; pad++)
520 {
521 //Read the pad number:
522 Read(comp,index);
523
524 //Check for zeros:
525 if(Test(comp,index)==0) //Zeros are coming
526 {
527 Read(comp,index);
528 if(Test(comp,index) == 0)
529 {
530 Read(comp,index); //This was the end of pad.
531 continue;
532 }
ffe3a919 533 if(Read(comp,index) == 255) //There can be up to 3 bytes with zero coding.
534 if(Read(comp,index) == 255)
b328544b 535 Read(comp,index);
ffe3a919 536 }
537
538 while(1)
539 {
540 while(Read(comp,index) != 0) ndigit++;
b328544b 541
ffe3a919 542 if(Test(comp,index) == 0)
b328544b 543 {
ffe3a919 544 Read(comp,index); //2 zeros = end of pad.
545 break;
b328544b 546 }
ffe3a919 547 if(Read(comp,index) == 255) //There can be up to 3 bytes with zero coding.
548 if(Read(comp,index) == 255)
549 Read(comp,index);
550
b328544b 551 }
ffe3a919 552
b328544b 553 }
554 Int_t size = sizeof(AliL3DigitData)*ndigit + sizeof(AliL3DigitRowData);
555 outsize += size;
556 }
557 return outsize;
558}
559
560Bool_t AliL3DataHandler::CompBinary2CompMemory(UInt_t &nrow,Byte_t *comp)
561{
562 //Read RLE data from binary file into array comp.
563
564 rewind(fInBinary);
565 UInt_t size = GetFileSize() - 2;
566 Byte_t type;
567 if(fread(&type,1,1,fInBinary)!=1) return kFALSE;
568 if(type > 0)
569 {
570 LOG(AliL3Log::kError,"AliL3DataHandler::CompBinary2CompMemory","Filetype")
571 <<"Inputfile does not seem to contain 8 bit data : "<<type<<ENDLOG;
572 return kFALSE;
573 }
574 if(fread(&nrow,1,1,fInBinary)!=1) return kFALSE;
575 if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
576
577 return kTRUE;
578}
579
580Bool_t AliL3DataHandler::CompMemory2CompBinary(UInt_t nrow,Byte_t *comp,UInt_t size)
581{
582 //Write RLE data in comp to binary file.
494015ab 583 //In order to distinguish these files from 10 bit data,
b328544b 584 //a zero is written to the beginning of the file.
585
586 Byte_t length = (Byte_t)nrow;
587 Byte_t type = 0;
588 if(fwrite(&type,1,1,fOutBinary)!=1) return kFALSE; //Write a zero, to mark that this file contains 8 bit data.
589 if(fwrite(&length,1,1,fOutBinary)!=1) return kFALSE;
590 if(fwrite(comp,size,1,fOutBinary)!=1) return kFALSE;
591 return kTRUE;
592}