]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/src/AliL3MemHandler.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Addons for html documentation
[u/mrichter/AliRoot.git] / HLT / src / AliL3MemHandler.cxx
CommitLineData
b661165c 1// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
2//*-- Copyright &copy Uli
108615fc 3
4#include <math.h>
5#include <time.h>
6#include <iostream.h>
7#include <stdio.h>
d48c6b0b 8#include <string.h>
108615fc 9
10#include "AliL3MemHandler.h"
11#include "AliL3Transform.h"
12#include "AliL3Logging.h"
13
14#include "AliL3DigitData.h"
15#include "AliL3TrackSegmentData.h"
16#include "AliL3SpacePointData.h"
17#include "AliL3TrackArray.h"
b661165c 18
108615fc 19//_____________________________________________________________
b661165c 20// AliL3MemHandler
108615fc 21//
22// The L3 Binary File handler
23//
24
25ClassImp(AliL3MemHandler)
26
27AliL3MemHandler::AliL3MemHandler(){
fc600b9e 28 // Default constructor
108615fc 29 fPt = 0;
30 fSize =0;
31 fInBinary = 0;
32 fOutBinary = 0;
33 fNRandom = 0;
34 Int_t r[2]={0,0};
35 Init(0,0,r);
36 IsRandom = kFALSE;
37 fDigits = 0;
38 fDPt =0;
39 fNGenerate = 0;
40 fNUsed = 0;
41 fNDigits = 0;
42
ae97a0b9 43 Int_t row[2] = {0,175};
108615fc 44 Init(0,0,row);
45 ResetROI();
46}
47
48
49AliL3MemHandler::~AliL3MemHandler(){
50 //Destructor
51 if(fPt) delete[] fPt;
52 if(fDigits) delete [] fDigits;
53 if(fDPt) delete [] fDPt;
54}
55
56void AliL3MemHandler::ResetROI(){
57 for(Int_t i=fRowMin; i<=fRowMax; i++)
58 {
59 fEtaMinTimeBin[i] = 0;
60 fEtaMaxTimeBin[i] = 445;
61 }
62}
63
64
65void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice){
66 if(eta[1]==0)
67 {
68 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetROI","Eta Values")
69 <<"Bad ROI parameters. IDIOT! "<<ENDLOG;
70 for(Int_t i=fRowMin; i<=fRowMax; i++)
71 {
72 fEtaMinTimeBin[i]=0;
73 fEtaMaxTimeBin[i]=0;
74 }
75 return;
76 }
77
78 for(Int_t i=fRowMin; i<=fRowMax; i++)
79 {
80 Int_t sector,row;
81 Float_t xyz[3];
82
83 Float_t thetamax = 2*atan(exp(-1.*eta[1]));
84
85 xyz[0] = fTransformer->Row2X(i);
86 xyz[1]=0;
87 xyz[2] = xyz[0]/tan(thetamax);
88 fTransformer->Slice2Sector(fSlice,i,sector,row);
89 fTransformer->Local2Raw(xyz,sector,row);
90
91 fEtaMinTimeBin[i] = (Int_t)xyz[2];
92
93 if(eta[0]==0)
94 fEtaMaxTimeBin[i] = 445;
95 else
96 {
97 Float_t thetamin = 2*atan(exp(-1.*eta[0]));
98 xyz[0] = fTransformer->Row2X(i);
99 xyz[1] = fTransformer->GetMaxY(i);
100 Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
101 xyz[2] = radii/tan(thetamin);
102 fTransformer->Local2Raw(xyz,sector,row);
103 fEtaMaxTimeBin[i] = (Int_t)xyz[2];
104 }
105 }
106
107}
108
109Bool_t AliL3MemHandler::SetBinaryInput(char *name){
110 fInBinary = fopen(name,"r");
111 if(!fInBinary){
112 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
113 <<"Pointer to File = 0x0 "<<ENDLOG;
114 return kFALSE;
115 }
116 return kTRUE;
117}
118
119Bool_t AliL3MemHandler::SetBinaryInput(FILE *file){
120 fInBinary = file;
121 if(!fInBinary){
122 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
123 <<"Pointer to File = 0x0 "<<ENDLOG;
124 return kFALSE;
125 }
126 return kTRUE;
127}
128
129void AliL3MemHandler::CloseBinaryInput(){
130 if(!fInBinary){
131 LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryInput","File Close")
132 <<"Nothing to Close"<<ENDLOG;
133 return;
134 }
135 fclose(fInBinary);
136 fInBinary =0;
137}
138
139Bool_t AliL3MemHandler::SetBinaryOutput(char *name){
140 fOutBinary = fopen(name,"w");
141 if(!fOutBinary){
142 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
143 <<"Pointer to File = 0x0 "<<ENDLOG;
144 return kFALSE;
145 }
146 return kTRUE;
147}
148
149Bool_t AliL3MemHandler::SetBinaryOutput(FILE *file){
150 fOutBinary = file;
151 if(!fOutBinary){
152 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
153 <<"Pointer to File = 0x0 "<<ENDLOG;
154 return kFALSE;
155 }
156 return kTRUE;
157}
158
159void AliL3MemHandler::CloseBinaryOutput(){
160 if(!fOutBinary){
161 LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryOutPut","File Close")
162 <<"Nothing to Close"<<ENDLOG;
163 return;
164 }
165 fclose(fOutBinary);
166 fOutBinary =0;
167}
168
169
170UInt_t AliL3MemHandler::GetFileSize(){
171 if(!fInBinary){
172 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetFileSize","File")
173 <<"No Input File"<<ENDLOG;
174 return 0;
175 }
176 fseek(fInBinary,0,SEEK_END);
177 UInt_t size = (UInt_t) ftell(fInBinary);
178 rewind(fInBinary);
179 return size;
180}
181
182Byte_t *AliL3MemHandler::Allocate(){
183 return Allocate(GetFileSize());
184}
185
186Byte_t *AliL3MemHandler::Allocate(AliL3TrackArray *array){
187 if(!array){
188 LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
189 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
190 return 0;
191 }
192 return Allocate(array->GetOutSize());
193}
194
195Byte_t *AliL3MemHandler::Allocate(UInt_t size){
196 if(fPt){
197 LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
198 <<"Delete Memory"<<ENDLOG;
199 Free();
200 }
201 fPt = new Byte_t[size];
202 fSize = size;
d48c6b0b 203 memset(fPt,0,fSize);
108615fc 204 LOG(AliL3Log::kDebug,"AliL3MemHandler::Allocate","Memory")
205 <<AliL3Log::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
206 return fPt;
207}
208
209void AliL3MemHandler::Free(){
210 if(!fPt){
211 LOG(AliL3Log::kWarning,"AliL3MemHandler::Free","Memory")
212 <<"No Memory allocated - can't Free"<<ENDLOG;
213 return;
214 }
215 delete[] fPt;
216 fPt = 0;
217 fSize =0;
218}
219
220///////////////////////////////////////// Random
221void AliL3MemHandler::SetRandomSeed(){
222 time_t *tp=0;
223 SetRandomSeed(time(tp));
224}
225
226void AliL3MemHandler::SetRandomCluster(Int_t maxnumber){
227 IsRandom = kTRUE;
228 fNRandom = maxnumber;
229 fNDigits = 0;
230 if(fDigits) delete [] fDigits;
231 fDigits = new AliL3RandomDigitData[fNRandom*9];
232 if(fDPt) delete [] fDPt;
ffaac6c0 233 fDPt = new AliL3RandomDigitData *[fNRandom*9];
108615fc 234}
235
236void AliL3MemHandler::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last){
237
238 // Sort array of AliL3RandomDigitData pointers using a quicksort algorithm.
239 // Uses CompareDigits() to compare objects.
240 // Thanks to Root!
241
242 static AliL3RandomDigitData *tmp;
243 static int i; // "static" to save stack space
244 int j;
245
246 while (last - first > 1) {
247 i = first;
248 j = last;
249 for (;;) {
250 while (++i < last && CompareDigits(a[i], a[first]) < 0)
251 ;
252 while (--j > first && CompareDigits(a[j], a[first]) > 0)
253 ;
254 if (i >= j)
255 break;
256
257 tmp = a[i];
258 a[i] = a[j];
259 a[j] = tmp;
260 }
261 if (j == first) {
262 ++first;
263 continue;
264 }
265 tmp = a[first];
266 a[first] = a[j];
267 a[j] = tmp;
268 if (j - first < last - (j + 1)) {
269 QSort(a, first, j);
270 first = j + 1; // QSort(j + 1, last);
271 } else {
272 QSort(a, j + 1, last);
273 last = j; // QSort(first, j);
274 }
275 }
276}
277
278UInt_t AliL3MemHandler::GetRandomSize(){
279 Int_t nrandom = 0;
280 for(Int_t r=fRowMin;r<=fRowMax;r++){
281 Int_t npad=fTransformer->GetNPads(r);
282 nrandom += Int_t (fNGenerate * ((Double_t) npad/141.));
283 }
284 return 9 * nrandom * sizeof(AliL3DigitData);
285}
286
287void AliL3MemHandler::Generate(Int_t row){
288 if(!IsRandom) return;
289 ResetRandom();
290 fNDigits = 0;
291 Int_t npad=fTransformer->GetNPads(row);
292 Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
293 Int_t nrandom = Int_t (fNGenerate * ((Double_t) npad/141.) *
294 (Double_t) ntime/(Double_t) fTransformer->GetNTimeBins() );
295
296 for(Int_t n=0;n<nrandom;n++){
297 Int_t pad = (int)((float)rand()/RAND_MAX*npad);
298 Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
299 Int_t charge = (int)((float)rand()/RAND_MAX*1023);
300 DigitizePoint(row,pad,time,charge);
301 }
302 QSort(fDPt,0,fNDigits);
303// for(Int_t d=0;d<fNDigits;d++)
304// fprintf(stderr,"%d %d %d %d\n",fDPt[d]->fRow,fDPt[d]->fPad,
305// fDPt[d]->fTime,fDPt[d]->fCharge);
306}
307
308
309void AliL3MemHandler::DigitizePoint(Int_t row, Int_t pad,
310 Int_t time,Int_t charge){
311 for(Int_t j=-1;j<2;j++){
312 for(Int_t k=-1;k<2;k++){
313 Int_t dcharge = charge;
314 if(j) dcharge /=2;
315 if(k) dcharge /=2;
316 if(dcharge<10) continue;
317 Int_t dpad = j + pad;
318 Int_t dtime = k + time;
319
320 if(dpad<0||dpad>=fTransformer->GetNPads(row)) continue;
321 if(dtime<0||dtime>=fTransformer->GetNTimeBins()) continue;
322
323 fDigits[fNDigits].fCharge = dcharge;
324 fDigits[fNDigits].fRow = row;
325 fDigits[fNDigits].fPad = dpad;
326 fDigits[fNDigits].fTime = dtime;
327 fDPt[fNDigits] = &fDigits[fNDigits];
328 fNDigits++;
329 }
330 }
331}
332
333///////////////////////////////////////// Digit IO
334Bool_t AliL3MemHandler::Memory2Binary(UInt_t nrow,AliL3DigitRowData *data){
335 if(!fOutBinary){
336 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
337 <<"No Output File"<<ENDLOG;
338 return kFALSE;
339 }
340 if(!data){
341 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
342 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
343 return kFALSE;
344 }
345
346 AliL3DigitRowData *row_pt = data;
347 Int_t outsize = 0;
348 for(UInt_t i=0;i<nrow;i++){
349 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit
350 + sizeof(AliL3DigitRowData);
351 outsize += size;
352 fwrite(row_pt,size,1,fOutBinary);
353 Byte_t *byte_pt =(Byte_t *) row_pt;
354 byte_pt += size;
355 row_pt = (AliL3DigitRowData *) byte_pt;
356 }
357 LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","Memory")
358 <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
359 <<nrow<<" Rows)"<<ENDLOG;
360 return kTRUE;
361}
362
363Bool_t AliL3MemHandler::Binary2Memory(UInt_t & nrow,AliL3DigitRowData *data){
364 if(!fInBinary){
365 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
366 <<"No Input File"<<ENDLOG;
367 return kFALSE;
368 }
369 if(!data){
370 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
371 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
372 return kFALSE;
373 }
374 rewind(fInBinary);
375 AliL3DigitRowData *row_pt = data;
376 UInt_t rowcount = 0;
377 Int_t outsize =0;
378 while(!feof(fInBinary)){
379 Byte_t *byte_pt =(Byte_t *) row_pt;
380
381 if(fread(row_pt,sizeof(AliL3DigitRowData),1,fInBinary)!=1) break;
382 byte_pt += sizeof(AliL3DigitRowData);
383 outsize += sizeof(AliL3DigitRowData);
384
385 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit;
386
387 if(fread(byte_pt,size,1,fInBinary)!=1) break;
388 byte_pt += size;
389 outsize += size;
390
391 row_pt = (AliL3DigitRowData *) byte_pt;
392 rowcount++;
393 }
394 nrow= rowcount;
395 LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","Memory")
396 <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
397 <<rowcount<<" Rows)"<<ENDLOG;
398 return kTRUE;
399}
400
401void AliL3MemHandler::AddData(AliL3DigitData *data,UInt_t & ndata,
402 UInt_t row,UShort_t pad,UShort_t time,UShort_t charge){
403 data[ndata].fPad = pad;
404 data[ndata].fTime = time;
405 data[ndata].fCharge = charge;
406 ndata++;
407}
408
409void AliL3MemHandler::AddRandom(AliL3DigitData *data, UInt_t & ndata){
410 data[ndata].fPad = fDPt[fNUsed]->fPad;
411 data[ndata].fTime = fDPt[fNUsed]->fTime;
412 data[ndata].fCharge = fDPt[fNUsed]->fCharge;
413 ndata++;
414 fNUsed++;
415}
416
417void AliL3MemHandler::MergeDataRandom(AliL3DigitData *data, UInt_t & ndata,
418 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){
419// AddData(data,ndata,row,pad,time,charge);
420 data[ndata].fPad = pad;
421 data[ndata].fTime = time;
422 data[ndata].fCharge = charge;
423 while(ComparePoints(row,pad,time)==0){
424 Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
425 if(charge>1023) ch = 1023;
426 data[ndata].fCharge = ch;
427 fNUsed++;
428 }
429 ndata++;
430}
431
432void AliL3MemHandler::AddDataRandom(AliL3DigitData *data, UInt_t & ndata,
433 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){
434 Int_t action;
435 while((action=ComparePoints(row,pad,time))==1){
436 AddRandom(data,ndata);
437 }
438 if(action==0){
439 MergeDataRandom(data,ndata,row,pad,time,charge);
440 }
441 if(action<0){
442 AddData(data,ndata,row,pad,time,charge);
443 }
444}
445
446void AliL3MemHandler::Write(UInt_t *comp, UInt_t & index,
447 UInt_t & subindex, UShort_t value){
448 UInt_t shift[3] = {0,10,20};
b00ff616 449 if(subindex==0) comp[index] =0; //clean up memory
108615fc 450 comp[index] |= (value&0x03ff)<<shift[subindex];
451 if(subindex == 2){
452 subindex = 0;
453 index++;
454 }
455 else subindex++;
456}
457
458UShort_t AliL3MemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex){
459 UInt_t shift[3] = {0,10,20};
460 UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
461 if(subindex == 2){
462 subindex = 0;
463 index++;
464 }
465 else subindex++;
466
467 return value;
468}
469
470UShort_t AliL3MemHandler::Test(UInt_t *comp,
471 UInt_t index, UInt_t subindex){
472 UInt_t shift[3] = {0,10,20};
473 return (comp[index]>>shift[subindex])&0x03ff;
474}
475
476Int_t AliL3MemHandler::Memory2CompMemory(UInt_t nrow,
477 AliL3DigitRowData *data,UInt_t *comp){
478 if(!comp){
479 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
480 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
481 return 0;
482 }
483 if(!data){
484 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
485 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
486 return 0;
487 }
488 AliL3DigitRowData *row_pt = data;
489 UInt_t index=0;
490 UInt_t subindex=0;
491
492 for(UInt_t i=0;i<nrow;i++){
493 UShort_t value = row_pt->fRow;
494 Write(comp,index,subindex,value);
495 UShort_t maxpad=0;
496 UShort_t npad=0;
497 Int_t ddd[1000];
498 for(Int_t d=0;d<200;d++) ddd[d]=0;
499 for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
500 if(row_pt->fDigitData[dig].fPad <200){
501 ddd[row_pt->fDigitData[dig].fPad]++;
502 }
503 }
504 for(Int_t d=0;d<200;d++){
505 if(ddd[d]){
506 npad++;
507 maxpad =d;
508 }
509 }
510 Write(comp,index,subindex,npad);
511 UInt_t digit=0;
512 for(UShort_t pad=0;pad <= maxpad;pad++){
513 if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad != pad)
514 continue;
515 Write(comp,index,subindex,pad);
516// write zero if time != 0
517 if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
518 if(row_pt->fDigitData[digit].fTime>0){
519 Write(comp,index,subindex,0);
520 Write(comp,index,subindex,row_pt->fDigitData[digit].fTime);
521 }
522 }
523 while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
524 UShort_t charge = row_pt->fDigitData[digit].fCharge;
525 if(charge>=1024){
526 charge=1023;
527 }
528 Write(comp,index,subindex,charge);
529 if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
530 if(row_pt->fDigitData[digit].fTime +1 !=
531 row_pt->fDigitData[digit+1].fTime){
532 Write(comp,index,subindex,0);
533 UShort_t nzero = row_pt->fDigitData[digit+1].fTime -
534 (row_pt->fDigitData[digit].fTime +1);
535 Write(comp,index,subindex,nzero);
536 }
537 }
538 digit++;
539 }
540 Write(comp,index,subindex,0);
541 Write(comp,index,subindex,0);
542 }
543
544 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
545 sizeof(AliL3DigitRowData);
546 Byte_t *byte_pt =(Byte_t *) row_pt;
547 byte_pt += size;
548 row_pt = (AliL3DigitRowData *) byte_pt;
549 }
550 while(subindex)
551 Write(comp,index,subindex,0);
552 return index * sizeof(UInt_t);
553}
554
555Int_t AliL3MemHandler::CompMemory2Memory(UInt_t nrow,
556 AliL3DigitRowData *data,UInt_t *comp){
557 if(!comp){
558 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
559 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
560 return 0;
561 }
562 if(!data){
563 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
564 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
565 return 0;
566 }
567 Int_t outsize=0;
568
569 AliL3DigitRowData *row_pt = data;
570 UInt_t index=0;
571 UInt_t subindex=0;
572
573 for(UInt_t i=0;i<nrow;i++){
574 UInt_t ndigit=0;
575 UInt_t row =Read(comp,index,subindex);
576 row_pt->fRow=row;
577 Generate(row);
578 UShort_t npad = Read(comp,index,subindex);
579 for(UShort_t p=0;p<npad;p++){
580 UShort_t charge;
581 UShort_t time =0;
582 UShort_t pad = Read(comp,index,subindex);
583 if(Test(comp,index,subindex)==0){
584 Read(comp,index,subindex);
585 if( (time = Read(comp,index,subindex)) == 0 ){
586 continue;
587 }
588 }
589 for(;;){
590 while( (charge=Read(comp,index,subindex)) != 0){
591 if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
592// AddData(row_pt->fDigitData,ndigit,row,pad,time,charge);
593 AddDataRandom(row_pt->fDigitData,ndigit,row,pad,time,charge);
594 time++;
595 }
596 UShort_t tshift = Read(comp,index,subindex);
597 if(tshift ==0) break;
598 time += tshift;
599 }
600 }
601 row_pt->fNDigit = ndigit;
602 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
603 sizeof(AliL3DigitRowData);
604 Byte_t *byte_pt =(Byte_t *) row_pt;
605 byte_pt += size;
606 outsize += size;
607 row_pt = (AliL3DigitRowData *) byte_pt;
608 }
609 return outsize;
610}
611
612UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data){
613 if(!data){
614 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetCompMemorySize","Memory")
615 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
616 return 0;
617 }
618 AliL3DigitRowData *row_pt = data;
619 UInt_t index=0;
620
621 for(UInt_t i=0;i<nrow;i++){
622 index++;
623 UShort_t maxpad=0;
624 UShort_t npad=0;
625 Int_t ddd[1000];
626 for(Int_t d=0;d<200;d++) ddd[d]=0;
627 for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
628 if(row_pt->fDigitData[dig].fPad <200){
629 ddd[row_pt->fDigitData[dig].fPad]++;
630 }
631 }
632 for(Int_t d=0;d<200;d++){
633 if(ddd[d]){
634 npad++;
635 maxpad =d;
636 }
637 }
638 index++;
639 UInt_t digit=0;
640 for(UShort_t pad=0;pad <= maxpad;pad++){
641 if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad != pad)
642 continue;
643 index++;
644// write zero if time != 0
645 if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
646 if(row_pt->fDigitData[digit].fTime>0){
647 index++;
648 index++;
649 }
650 }
651 while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
652 index++;
653 if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
654 if(row_pt->fDigitData[digit].fTime +1 !=
655 row_pt->fDigitData[digit+1].fTime){
656 index++;
657 index++;
658 }
659 }
660 digit++;
661 }
662 index++;
663 index++;
664 }
665
666 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
667 sizeof(AliL3DigitRowData);
668 Byte_t *byte_pt =(Byte_t *) row_pt;
669 byte_pt += size;
670 row_pt = (AliL3DigitRowData *) byte_pt;
671 }
672 while(index%3)
673 index++;
674 return (index/3) * sizeof(UInt_t);
675}
676
677UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp){
678 if(!comp){
679 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetMemorySize","Memory")
680 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
681 return 0;
682 }
683 Int_t outsize=0;
684
685 UInt_t index=0;
686 UInt_t subindex=0;
687
688 for(UInt_t i=0;i<nrow;i++){
689 UInt_t ndigit=0;
690 Read(comp,index,subindex);
691 UShort_t npad = Read(comp,index,subindex);
692 for(UShort_t p=0;p<npad;p++){
693 Read(comp,index,subindex);
694 if(Test(comp,index,subindex)==0){
695 Read(comp,index,subindex);
696 if(Read(comp,index,subindex)== 0) continue;
697 }
698 for(;;){
699 while(Read(comp,index,subindex)!=0) ndigit++;
700 if(Read(comp,index,subindex)==0) break;
701 }
702 }
703 Int_t size = sizeof(AliL3DigitData) * ndigit+
704 sizeof(AliL3DigitRowData);
705 outsize += size;
706 }
707
708 return outsize;
709}
710
711UInt_t AliL3MemHandler::GetNRow(UInt_t *comp,UInt_t size){
712 if(!comp){
713 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetNRow","Memory")
714 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
715 return 0;
716 }
717 size = size /4;
718 UInt_t nrow=0;
719 UInt_t index=0;
720 UInt_t subindex=0;
b00ff616 721 while(index<size-1){ //don't start with last word
108615fc 722 nrow++;
723 UInt_t ndigit=0;
724 Read(comp,index,subindex);
725 UShort_t npad = Read(comp,index,subindex);
726 for(UShort_t p=0;p<npad;p++){
727 Read(comp,index,subindex);
728 if(Test(comp,index,subindex)==0){
729 Read(comp,index,subindex);
730 if(Read(comp,index,subindex)==0)continue;
731 }
732 for(;;){
733 while(Read(comp,index,subindex)!=0) ndigit++;
734 if(Read(comp,index,subindex)==0) break;
735 }
736 }
737 }
b00ff616 738 if(index==size-1){ //last word
739 if(subindex<2){
740 if(Read(comp,index,subindex)!=0) nrow++;
741 }
742 }
108615fc 743 return nrow;
744}
745
746Bool_t AliL3MemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
747 UInt_t size){
748 if(!fOutBinary){
749 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","File")
750 <<"No Output File"<<ENDLOG;
751 return kFALSE;
752 }
753 if(!comp){
754 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
755 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
756 return kFALSE;
757 }
758 if(size==0)
759 size=GetMemorySize(nrow,comp);
760 if(!size){
761 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
762 <<"Memory size = 0 "<<ENDLOG;
763 return kFALSE;
764 }
765 UInt_t length = size/sizeof(UInt_t);
766 fwrite(&length,sizeof(UInt_t),1,fOutBinary);
767 fwrite(comp,size,1,fOutBinary);
768 return kTRUE;
769}
770
771Bool_t AliL3MemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp){
772 if(!fInBinary){
773 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","File")
774 <<"No Output File"<<ENDLOG;
775 return kFALSE;
776 }
777 if(!comp){
778 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","Memory")
779 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
780 return kFALSE;
781 }
782 rewind(fInBinary);
783 UInt_t length;
784 if(fread(&length,sizeof(UInt_t),1,fInBinary)!=1) return kFALSE;
785 UInt_t size = length*sizeof(UInt_t);
786 if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
787 // now find the number of dig
788 nrow = GetNRow(comp,size);
789 return kTRUE;
790}
791
792AliL3DigitRowData *AliL3MemHandler::CompBinary2Memory(UInt_t & nrow){
793 AliL3MemHandler * handler = new AliL3MemHandler();
794 handler->SetBinaryInput(fInBinary);
795 UInt_t *comp =(UInt_t *)handler->Allocate();
796 handler->CompBinary2CompMemory(nrow,comp);
797 UInt_t size = GetMemorySize(nrow,comp);
798 AliL3DigitRowData *data = (AliL3DigitRowData *)Allocate(size);
799 CompMemory2Memory(nrow,data,comp);
800 handler->Free();
801 delete handler;
802 return data;
803}
804
805Bool_t AliL3MemHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data){
806 Bool_t out = kTRUE;
807 AliL3MemHandler * handler = new AliL3MemHandler();
808 UInt_t size = GetCompMemorySize(nrow,data);
809 UInt_t *comp =(UInt_t *)handler->Allocate(size);
810 Memory2CompMemory(nrow,data,comp);
811 CompMemory2CompBinary(nrow,comp,size);
812 handler->Free();
813 delete handler;
814 return out;
815}
816
817
818///////////////////////////////////////// Point IO
819Bool_t AliL3MemHandler::Memory2Binary(UInt_t npoint,AliL3SpacePointData *data){
820 if(!fOutBinary){
821 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
822 <<"No Output File"<<ENDLOG;
823 return kFALSE;
824 }
825 if(!data){
826 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
827 <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
828 return kFALSE;
829 }
830 UInt_t size = npoint*sizeof(AliL3SpacePointData);
831 fwrite(data,size,1,fOutBinary);
832
833 return kTRUE;
834}
835
836Bool_t AliL3MemHandler::Transform(UInt_t npoint,AliL3SpacePointData *data,
837 Int_t slice, AliL3Transform* trans){
838 if(!data){
839 LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Memory")
840 <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
841 return kFALSE;
842 }
843 if(!trans){
844 LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Object")
845 <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
846 return kFALSE;
847 }
848 for(UInt_t i=0;i<npoint;i++){
849 Float_t xyz[3];
850 xyz[0] = data[i].fX;
851 xyz[1] = data[i].fY;
852 xyz[2] = data[i].fZ;
853 trans->Local2Global(xyz,slice);
854 data[i].fX = xyz[0];
855 data[i].fY = xyz[1];
856 data[i].fZ = xyz[2];
857 }
858 return kTRUE;
859}
860
861Bool_t AliL3MemHandler::Binary2Memory(UInt_t & npoint,AliL3SpacePointData *data){
862 if(!fInBinary){
863 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
864 <<"No Input File"<<ENDLOG;
865 return kFALSE;
866 }
867 if(!data){
868 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
869 <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
870 return kFALSE;
871 }
872
873 Int_t size = GetFileSize();
874/*
875 UInt_t size,slice,patch,row[2];
876 AliL3EventDataTypeRoot datatype;
877 UInt_t node;
878 if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
879 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
880 <<"File Read Error "<<ENDLOG;
881 return kFALSE;
882 }
883 if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
884 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
885 <<"File Read Error "<<ENDLOG;
886 return kFALSE;
887 }
888 if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
889 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
890 <<"File Read Error "<<ENDLOG;
891 return kFALSE;
892 }
893 if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
894 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
895 <<"File Read Error "<<ENDLOG;
896 return kFALSE;
897 }
898 if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
899 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
900 <<"File Read Error "<<ENDLOG;
901 return kFALSE;
902 }
903 if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
904 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
905 <<"File Read Error "<<ENDLOG;
906 return kFALSE;
907 }
908*/
909 npoint = size/sizeof(AliL3SpacePointData);
910 if(fread(data,size,1,fInBinary)!=1){
911 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
912 <<"File Read Error "<<ENDLOG;
913 return kFALSE;
914 }
915 if(size%sizeof(AliL3SpacePointData)){
916 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File Size")
917 <<"File Size wrong "<<ENDLOG;
918 return kFALSE;
919 }
920 LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
921 <<AliL3Log::kDec<<"Wrote "<<size<<" Bytes to Memory"<<ENDLOG;
922 return kTRUE;
923}
924
925///////////////////////////////////////// Track IO
926Bool_t AliL3MemHandler::Memory2Binary(UInt_t ntrack,AliL3TrackSegmentData *data){
927 if(!fOutBinary){
928 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
929 <<"No Output File"<<ENDLOG;
930 return kFALSE;
931 }
932 if(!data){
933 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
934 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
935 return kFALSE;
936 }
937 AliL3TrackSegmentData *track_pt = data;
938 for(UInt_t i=0;i<ntrack;i++){
939 Int_t size=sizeof(AliL3TrackSegmentData)+track_pt->fNPoints*sizeof(UInt_t);
940 fwrite(track_pt,size,1,fOutBinary);
941 Byte_t *byte_pt = (Byte_t*) track_pt;
942 byte_pt += size;
943 track_pt = (AliL3TrackSegmentData*) byte_pt;
944 }
945 LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","File")
946 <<AliL3Log::kDec<<"Wrote "<<ntrack<<" Tracks to File"<<ENDLOG;
947
948 return kTRUE;
949}
950
951Bool_t AliL3MemHandler::Binary2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data){
952 if(!fInBinary){
953 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
954 <<"No Input File"<<ENDLOG;
955 return kFALSE;
956 }
957 if(!data){
958 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
959 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
960 return kFALSE;
961 }
962
963 ntrack=0;
964 AliL3TrackSegmentData *track_pt = data;
965 rewind(fInBinary);
966/*
967 UInt_t size,slice,patch,row[2];
968 AliL3EventDataTypeRoot datatype;
969 UInt_t node;
970 if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
971 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
972 <<"File Read Error "<<ENDLOG;
973 return kFALSE;
974 }
975 if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
976 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
977 <<"File Read Error "<<ENDLOG;
978 return kFALSE;
979 }
980 if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
981 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
982 <<"File Read Error "<<ENDLOG;
983 return kFALSE;
984 }
985 if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
986 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
987 <<"File Read Error "<<ENDLOG;
988 return kFALSE;
989 }
990 if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
991 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
992 <<"File Read Error "<<ENDLOG;
993 return kFALSE;
994 }
995 if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
996 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
997 <<"File Read Error "<<ENDLOG;
998 return kFALSE;
999 }
1000*/
1001 while(!feof(fInBinary)){
1002 if(fread(track_pt,sizeof(AliL3TrackSegmentData),1,fInBinary)!=1) break;
1003 Int_t size=track_pt->fNPoints*sizeof(UInt_t);
1004 if(fread(track_pt->fPointIDs,size,1,fInBinary)!=1) break;
1005 Byte_t *byte_pt = (Byte_t*) track_pt;
1006 byte_pt += sizeof(AliL3TrackSegmentData)+size;
1007 track_pt = (AliL3TrackSegmentData*) byte_pt;
1008 ntrack++;
1009 }
1010 LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
1011 <<AliL3Log::kDec<<"Wrote "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1012 return kTRUE;
1013}
1014
1015Bool_t AliL3MemHandler::TrackArray2Binary(AliL3TrackArray *array){
1016 if(!fOutBinary){
1017 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","File")
1018 <<"No Output File"<<ENDLOG;
1019 return kFALSE;
1020 }
1021 if(!array){
1022 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","Memory")
1023 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1024 return kFALSE;
1025 }
1026 AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate(array);
1027 UInt_t ntrack;
1028 TrackArray2Memory(ntrack,data,array);
1029 Memory2Binary(ntrack,data);
1030 Free();
1031 return kTRUE;
1032}
1033
1034Bool_t AliL3MemHandler::Binary2TrackArray(AliL3TrackArray *array){
1035 if(!fInBinary){
1036 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","File")
1037 <<"No Input File"<<ENDLOG;
1038 return kFALSE;
1039 }
1040 if(!array){
1041 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","Memory")
1042 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1043 return kFALSE;
1044 }
1045 AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate();
1046 UInt_t ntrack;
1047 Binary2Memory(ntrack,data);
1048 Memory2TrackArray(ntrack,data,array);
1049 Free();
1050 return kTRUE;
1051}
1052
1053Bool_t AliL3MemHandler::TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){
1054 if(!data){
1055 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1056 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1057 return kFALSE;
1058 }
1059 if(!array){
1060 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1061 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1062 return kFALSE;
1063 }
1064 array->WriteTracks(ntrack,data);
1065 return kTRUE;
1066}
1067
1068Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){
1069 if(!data){
1070 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1071 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1072 return kFALSE;
1073 }
1074 if(!array){
1075 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1076 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1077 return kFALSE;
1078 }
1079 array->FillTracks(ntrack,data);
1080 return kTRUE;
1081}
1082
1083Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice, AliL3Transform* trans){
1084 if(!data){
1085 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1086 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1087 return kFALSE;
1088 }
1089 if(!array){
1090 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1091 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1092 return kFALSE;
1093 }
1094 if(!trans){
1095 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Object")
1096 <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
1097 return kFALSE;
1098 }
1099 array->FillTracks(ntrack,data,slice,trans);
1100 return kTRUE;
1101}
1102
9bd4d591 1103void AliL3MemHandler::UpdateRowPointer(AliL3DigitRowData *&tempPt)
1104{
1105 //Update the data pointer to the next padrow
1106
1107 Byte_t *tmp = (Byte_t*)tempPt;
1108 Int_t size = sizeof(AliL3DigitRowData) + tempPt->fNDigit*sizeof(AliL3DigitData);
1109 tmp += size;
1110 tempPt = (AliL3DigitRowData*)tmp;
1111}