1 //Author: Uli Frankenfeld
2 //Last Modified: 17.12.2000
9 #include "AliL3MemHandler.h"
10 #include "AliL3Transform.h"
11 #include "AliL3Logging.h"
13 #include "AliL3DigitData.h"
14 #include "AliL3TrackSegmentData.h"
15 #include "AliL3SpacePointData.h"
16 #include "AliL3TrackArray.h"
17 //_____________________________________________________________
19 // The L3 Binary File handler
22 ClassImp(AliL3MemHandler)
24 AliL3MemHandler::AliL3MemHandler(){
40 Int_t row[2] = {0,173};
46 AliL3MemHandler::~AliL3MemHandler(){
49 if(fDigits) delete [] fDigits;
50 if(fDPt) delete [] fDPt;
53 void AliL3MemHandler::ResetROI(){
54 for(Int_t i=fRowMin; i<=fRowMax; i++)
56 fEtaMinTimeBin[i] = 0;
57 fEtaMaxTimeBin[i] = 445;
62 void AliL3MemHandler::SetROI(Float_t *eta,Int_t *slice){
65 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetROI","Eta Values")
66 <<"Bad ROI parameters. IDIOT! "<<ENDLOG;
67 for(Int_t i=fRowMin; i<=fRowMax; i++)
75 for(Int_t i=fRowMin; i<=fRowMax; i++)
80 Float_t thetamax = 2*atan(exp(-1.*eta[1]));
82 xyz[0] = fTransformer->Row2X(i);
84 xyz[2] = xyz[0]/tan(thetamax);
85 fTransformer->Slice2Sector(fSlice,i,sector,row);
86 fTransformer->Local2Raw(xyz,sector,row);
88 fEtaMinTimeBin[i] = (Int_t)xyz[2];
91 fEtaMaxTimeBin[i] = 445;
94 Float_t thetamin = 2*atan(exp(-1.*eta[0]));
95 xyz[0] = fTransformer->Row2X(i);
96 xyz[1] = fTransformer->GetMaxY(i);
97 Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
98 xyz[2] = radii/tan(thetamin);
99 fTransformer->Local2Raw(xyz,sector,row);
100 fEtaMaxTimeBin[i] = (Int_t)xyz[2];
106 Bool_t AliL3MemHandler::SetBinaryInput(char *name){
107 fInBinary = fopen(name,"r");
109 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
110 <<"Pointer to File = 0x0 "<<ENDLOG;
116 Bool_t AliL3MemHandler::SetBinaryInput(FILE *file){
119 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryInput","File Open")
120 <<"Pointer to File = 0x0 "<<ENDLOG;
126 void AliL3MemHandler::CloseBinaryInput(){
128 LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryInput","File Close")
129 <<"Nothing to Close"<<ENDLOG;
136 Bool_t AliL3MemHandler::SetBinaryOutput(char *name){
137 fOutBinary = fopen(name,"w");
139 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
140 <<"Pointer to File = 0x0 "<<ENDLOG;
146 Bool_t AliL3MemHandler::SetBinaryOutput(FILE *file){
149 LOG(AliL3Log::kWarning,"AliL3MemHandler::SetBinaryOutput","File Open")
150 <<"Pointer to File = 0x0 "<<ENDLOG;
156 void AliL3MemHandler::CloseBinaryOutput(){
158 LOG(AliL3Log::kWarning,"AliL3MemHandler::CloseBinaryOutPut","File Close")
159 <<"Nothing to Close"<<ENDLOG;
167 UInt_t AliL3MemHandler::GetFileSize(){
169 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetFileSize","File")
170 <<"No Input File"<<ENDLOG;
173 fseek(fInBinary,0,SEEK_END);
174 UInt_t size = (UInt_t) ftell(fInBinary);
179 Byte_t *AliL3MemHandler::Allocate(){
180 return Allocate(GetFileSize());
183 Byte_t *AliL3MemHandler::Allocate(AliL3TrackArray *array){
185 LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
186 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
189 return Allocate(array->GetOutSize());
192 Byte_t *AliL3MemHandler::Allocate(UInt_t size){
194 LOG(AliL3Log::kWarning,"AliL3MemHandler::Allocate","Memory")
195 <<"Delete Memory"<<ENDLOG;
198 fPt = new Byte_t[size];
200 LOG(AliL3Log::kDebug,"AliL3MemHandler::Allocate","Memory")
201 <<AliL3Log::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
205 void AliL3MemHandler::Free(){
207 LOG(AliL3Log::kWarning,"AliL3MemHandler::Free","Memory")
208 <<"No Memory allocated - can't Free"<<ENDLOG;
216 ///////////////////////////////////////// Random
217 void AliL3MemHandler::SetRandomSeed(){
219 SetRandomSeed(time(tp));
222 void AliL3MemHandler::SetRandomCluster(Int_t maxnumber){
224 fNRandom = maxnumber;
226 if(fDigits) delete [] fDigits;
227 fDigits = new AliL3RandomDigitData[fNRandom*9];
228 if(fDPt) delete [] fDPt;
229 fDPt = (AliL3RandomDigitData **)new Int_t[fNRandom*9];
232 void AliL3MemHandler::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last){
234 // Sort array of AliL3RandomDigitData pointers using a quicksort algorithm.
235 // Uses CompareDigits() to compare objects.
238 static AliL3RandomDigitData *tmp;
239 static int i; // "static" to save stack space
242 while (last - first > 1) {
246 while (++i < last && CompareDigits(a[i], a[first]) < 0)
248 while (--j > first && CompareDigits(a[j], a[first]) > 0)
264 if (j - first < last - (j + 1)) {
266 first = j + 1; // QSort(j + 1, last);
268 QSort(a, j + 1, last);
269 last = j; // QSort(first, j);
274 UInt_t AliL3MemHandler::GetRandomSize(){
276 for(Int_t r=fRowMin;r<=fRowMax;r++){
277 Int_t npad=fTransformer->GetNPads(r);
278 nrandom += Int_t (fNGenerate * ((Double_t) npad/141.));
280 return 9 * nrandom * sizeof(AliL3DigitData);
283 void AliL3MemHandler::Generate(Int_t row){
284 if(!IsRandom) return;
287 Int_t npad=fTransformer->GetNPads(row);
288 Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
289 Int_t nrandom = Int_t (fNGenerate * ((Double_t) npad/141.) *
290 (Double_t) ntime/(Double_t) fTransformer->GetNTimeBins() );
292 for(Int_t n=0;n<nrandom;n++){
293 Int_t pad = (int)((float)rand()/RAND_MAX*npad);
294 Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
295 Int_t charge = (int)((float)rand()/RAND_MAX*1023);
296 DigitizePoint(row,pad,time,charge);
298 QSort(fDPt,0,fNDigits);
299 // for(Int_t d=0;d<fNDigits;d++)
300 // fprintf(stderr,"%d %d %d %d\n",fDPt[d]->fRow,fDPt[d]->fPad,
301 // fDPt[d]->fTime,fDPt[d]->fCharge);
305 void AliL3MemHandler::DigitizePoint(Int_t row, Int_t pad,
306 Int_t time,Int_t charge){
307 for(Int_t j=-1;j<2;j++){
308 for(Int_t k=-1;k<2;k++){
309 Int_t dcharge = charge;
312 if(dcharge<10) continue;
313 Int_t dpad = j + pad;
314 Int_t dtime = k + time;
316 if(dpad<0||dpad>=fTransformer->GetNPads(row)) continue;
317 if(dtime<0||dtime>=fTransformer->GetNTimeBins()) continue;
319 fDigits[fNDigits].fCharge = dcharge;
320 fDigits[fNDigits].fRow = row;
321 fDigits[fNDigits].fPad = dpad;
322 fDigits[fNDigits].fTime = dtime;
323 fDPt[fNDigits] = &fDigits[fNDigits];
329 ///////////////////////////////////////// Digit IO
330 Bool_t AliL3MemHandler::Memory2Binary(UInt_t nrow,AliL3DigitRowData *data){
332 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
333 <<"No Output File"<<ENDLOG;
337 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
338 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
342 AliL3DigitRowData *row_pt = data;
344 for(UInt_t i=0;i<nrow;i++){
345 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit
346 + sizeof(AliL3DigitRowData);
348 fwrite(row_pt,size,1,fOutBinary);
349 Byte_t *byte_pt =(Byte_t *) row_pt;
351 row_pt = (AliL3DigitRowData *) byte_pt;
353 LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","Memory")
354 <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
355 <<nrow<<" Rows)"<<ENDLOG;
359 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & nrow,AliL3DigitRowData *data){
361 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
362 <<"No Input File"<<ENDLOG;
366 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
367 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
371 AliL3DigitRowData *row_pt = data;
374 while(!feof(fInBinary)){
375 Byte_t *byte_pt =(Byte_t *) row_pt;
377 if(fread(row_pt,sizeof(AliL3DigitRowData),1,fInBinary)!=1) break;
378 byte_pt += sizeof(AliL3DigitRowData);
379 outsize += sizeof(AliL3DigitRowData);
381 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit;
383 if(fread(byte_pt,size,1,fInBinary)!=1) break;
387 row_pt = (AliL3DigitRowData *) byte_pt;
391 LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","Memory")
392 <<AliL3Log::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
393 <<rowcount<<" Rows)"<<ENDLOG;
397 void AliL3MemHandler::AddData(AliL3DigitData *data,UInt_t & ndata,
398 UInt_t row,UShort_t pad,UShort_t time,UShort_t charge){
399 data[ndata].fPad = pad;
400 data[ndata].fTime = time;
401 data[ndata].fCharge = charge;
405 void AliL3MemHandler::AddRandom(AliL3DigitData *data, UInt_t & ndata){
406 data[ndata].fPad = fDPt[fNUsed]->fPad;
407 data[ndata].fTime = fDPt[fNUsed]->fTime;
408 data[ndata].fCharge = fDPt[fNUsed]->fCharge;
413 void AliL3MemHandler::MergeDataRandom(AliL3DigitData *data, UInt_t & ndata,
414 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){
415 // AddData(data,ndata,row,pad,time,charge);
416 data[ndata].fPad = pad;
417 data[ndata].fTime = time;
418 data[ndata].fCharge = charge;
419 while(ComparePoints(row,pad,time)==0){
420 Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
421 if(charge>1023) ch = 1023;
422 data[ndata].fCharge = ch;
428 void AliL3MemHandler::AddDataRandom(AliL3DigitData *data, UInt_t & ndata,
429 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge){
431 while((action=ComparePoints(row,pad,time))==1){
432 AddRandom(data,ndata);
435 MergeDataRandom(data,ndata,row,pad,time,charge);
438 AddData(data,ndata,row,pad,time,charge);
442 void AliL3MemHandler::Write(UInt_t *comp, UInt_t & index,
443 UInt_t & subindex, UShort_t value){
444 UInt_t shift[3] = {0,10,20};
445 comp[index] |= (value&0x03ff)<<shift[subindex];
453 UShort_t AliL3MemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex){
454 UInt_t shift[3] = {0,10,20};
455 UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
465 UShort_t AliL3MemHandler::Test(UInt_t *comp,
466 UInt_t index, UInt_t subindex){
467 UInt_t shift[3] = {0,10,20};
468 return (comp[index]>>shift[subindex])&0x03ff;
471 Int_t AliL3MemHandler::Memory2CompMemory(UInt_t nrow,
472 AliL3DigitRowData *data,UInt_t *comp){
474 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
475 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
479 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2CompMemory","Memory")
480 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
483 AliL3DigitRowData *row_pt = data;
487 for(UInt_t i=0;i<nrow;i++){
488 UShort_t value = row_pt->fRow;
489 Write(comp,index,subindex,value);
493 for(Int_t d=0;d<200;d++) ddd[d]=0;
494 for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
495 if(row_pt->fDigitData[dig].fPad <200){
496 ddd[row_pt->fDigitData[dig].fPad]++;
499 for(Int_t d=0;d<200;d++){
505 Write(comp,index,subindex,npad);
507 for(UShort_t pad=0;pad <= maxpad;pad++){
508 if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad != pad)
510 Write(comp,index,subindex,pad);
511 // write zero if time != 0
512 if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
513 if(row_pt->fDigitData[digit].fTime>0){
514 Write(comp,index,subindex,0);
515 Write(comp,index,subindex,row_pt->fDigitData[digit].fTime);
518 while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
519 UShort_t charge = row_pt->fDigitData[digit].fCharge;
523 Write(comp,index,subindex,charge);
524 if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
525 if(row_pt->fDigitData[digit].fTime +1 !=
526 row_pt->fDigitData[digit+1].fTime){
527 Write(comp,index,subindex,0);
528 UShort_t nzero = row_pt->fDigitData[digit+1].fTime -
529 (row_pt->fDigitData[digit].fTime +1);
530 Write(comp,index,subindex,nzero);
535 Write(comp,index,subindex,0);
536 Write(comp,index,subindex,0);
539 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
540 sizeof(AliL3DigitRowData);
541 Byte_t *byte_pt =(Byte_t *) row_pt;
543 row_pt = (AliL3DigitRowData *) byte_pt;
546 Write(comp,index,subindex,0);
547 return index * sizeof(UInt_t);
550 Int_t AliL3MemHandler::CompMemory2Memory(UInt_t nrow,
551 AliL3DigitRowData *data,UInt_t *comp){
553 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
554 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
558 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2Memory","Memory")
559 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
564 AliL3DigitRowData *row_pt = data;
568 for(UInt_t i=0;i<nrow;i++){
570 UInt_t row =Read(comp,index,subindex);
573 UShort_t npad = Read(comp,index,subindex);
574 for(UShort_t p=0;p<npad;p++){
577 UShort_t pad = Read(comp,index,subindex);
578 if(Test(comp,index,subindex)==0){
579 Read(comp,index,subindex);
580 if( (time = Read(comp,index,subindex)) == 0 ){
585 while( (charge=Read(comp,index,subindex)) != 0){
586 if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
587 // AddData(row_pt->fDigitData,ndigit,row,pad,time,charge);
588 AddDataRandom(row_pt->fDigitData,ndigit,row,pad,time,charge);
591 UShort_t tshift = Read(comp,index,subindex);
592 if(tshift ==0) break;
596 row_pt->fNDigit = ndigit;
597 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
598 sizeof(AliL3DigitRowData);
599 Byte_t *byte_pt =(Byte_t *) row_pt;
602 row_pt = (AliL3DigitRowData *) byte_pt;
607 UInt_t AliL3MemHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data){
609 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetCompMemorySize","Memory")
610 <<"Pointer to AliL3DigitRowData = 0x0 "<<ENDLOG;
613 AliL3DigitRowData *row_pt = data;
616 for(UInt_t i=0;i<nrow;i++){
621 for(Int_t d=0;d<200;d++) ddd[d]=0;
622 for(UInt_t dig=0;dig<row_pt->fNDigit;dig++){
623 if(row_pt->fDigitData[dig].fPad <200){
624 ddd[row_pt->fDigitData[dig].fPad]++;
627 for(Int_t d=0;d<200;d++){
635 for(UShort_t pad=0;pad <= maxpad;pad++){
636 if(digit>=row_pt->fNDigit || row_pt->fDigitData[digit].fPad != pad)
639 // write zero if time != 0
640 if(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
641 if(row_pt->fDigitData[digit].fTime>0){
646 while(digit<row_pt->fNDigit && row_pt->fDigitData[digit].fPad == pad){
648 if(digit+1<row_pt->fNDigit&&row_pt->fDigitData[digit+1].fPad == pad){
649 if(row_pt->fDigitData[digit].fTime +1 !=
650 row_pt->fDigitData[digit+1].fTime){
661 Int_t size = sizeof(AliL3DigitData) * row_pt->fNDigit+
662 sizeof(AliL3DigitRowData);
663 Byte_t *byte_pt =(Byte_t *) row_pt;
665 row_pt = (AliL3DigitRowData *) byte_pt;
669 return (index/3) * sizeof(UInt_t);
672 UInt_t AliL3MemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp){
674 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetMemorySize","Memory")
675 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
683 for(UInt_t i=0;i<nrow;i++){
685 Read(comp,index,subindex);
686 UShort_t npad = Read(comp,index,subindex);
687 for(UShort_t p=0;p<npad;p++){
688 Read(comp,index,subindex);
689 if(Test(comp,index,subindex)==0){
690 Read(comp,index,subindex);
691 if(Read(comp,index,subindex)== 0) continue;
694 while(Read(comp,index,subindex)!=0) ndigit++;
695 if(Read(comp,index,subindex)==0) break;
698 Int_t size = sizeof(AliL3DigitData) * ndigit+
699 sizeof(AliL3DigitRowData);
706 UInt_t AliL3MemHandler::GetNRow(UInt_t *comp,UInt_t size){
708 LOG(AliL3Log::kWarning,"AliL3MemHandler::GetNRow","Memory")
709 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
719 Read(comp,index,subindex);
720 UShort_t npad = Read(comp,index,subindex);
721 for(UShort_t p=0;p<npad;p++){
722 Read(comp,index,subindex);
723 if(Test(comp,index,subindex)==0){
724 Read(comp,index,subindex);
725 if(Read(comp,index,subindex)==0)continue;
728 while(Read(comp,index,subindex)!=0) ndigit++;
729 if(Read(comp,index,subindex)==0) break;
735 if(Read(comp,index,subindex)!=0) nrow++;
740 Bool_t AliL3MemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
743 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","File")
744 <<"No Output File"<<ENDLOG;
748 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
749 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
753 size=GetMemorySize(nrow,comp);
755 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompMemory2CompBinary","Memory")
756 <<"Memory size = 0 "<<ENDLOG;
759 UInt_t length = size/sizeof(UInt_t);
760 fwrite(&length,sizeof(UInt_t),1,fOutBinary);
761 fwrite(comp,size,1,fOutBinary);
765 Bool_t AliL3MemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp){
767 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","File")
768 <<"No Output File"<<ENDLOG;
772 LOG(AliL3Log::kWarning,"AliL3MemHandler::CompBinary2CompMemory","Memory")
773 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
778 if(fread(&length,sizeof(UInt_t),1,fInBinary)!=1) return kFALSE;
779 UInt_t size = length*sizeof(UInt_t);
780 if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
781 // now find the number of dig
782 nrow = GetNRow(comp,size);
786 AliL3DigitRowData *AliL3MemHandler::CompBinary2Memory(UInt_t & nrow){
787 AliL3MemHandler * handler = new AliL3MemHandler();
788 handler->SetBinaryInput(fInBinary);
789 UInt_t *comp =(UInt_t *)handler->Allocate();
790 handler->CompBinary2CompMemory(nrow,comp);
791 UInt_t size = GetMemorySize(nrow,comp);
792 AliL3DigitRowData *data = (AliL3DigitRowData *)Allocate(size);
793 CompMemory2Memory(nrow,data,comp);
799 Bool_t AliL3MemHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data){
801 AliL3MemHandler * handler = new AliL3MemHandler();
802 UInt_t size = GetCompMemorySize(nrow,data);
803 UInt_t *comp =(UInt_t *)handler->Allocate(size);
804 Memory2CompMemory(nrow,data,comp);
805 CompMemory2CompBinary(nrow,comp,size);
812 ///////////////////////////////////////// Point IO
813 Bool_t AliL3MemHandler::Memory2Binary(UInt_t npoint,AliL3SpacePointData *data){
815 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
816 <<"No Output File"<<ENDLOG;
820 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
821 <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
824 UInt_t size = npoint*sizeof(AliL3SpacePointData);
825 fwrite(data,size,1,fOutBinary);
830 Bool_t AliL3MemHandler::Transform(UInt_t npoint,AliL3SpacePointData *data,
831 Int_t slice, AliL3Transform* trans){
833 LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Memory")
834 <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
838 LOG(AliL3Log::kWarning,"AliL3MemHandler::Transform","Object")
839 <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
842 for(UInt_t i=0;i<npoint;i++){
847 trans->Local2Global(xyz,slice);
855 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & npoint,AliL3SpacePointData *data){
857 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
858 <<"No Input File"<<ENDLOG;
862 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
863 <<"Pointer to AliL3SpacePointData = 0x0 "<<ENDLOG;
867 Int_t size = GetFileSize();
869 UInt_t size,slice,patch,row[2];
870 AliL3EventDataTypeRoot datatype;
872 if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
873 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
874 <<"File Read Error "<<ENDLOG;
877 if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
878 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
879 <<"File Read Error "<<ENDLOG;
882 if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
883 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
884 <<"File Read Error "<<ENDLOG;
887 if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
888 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
889 <<"File Read Error "<<ENDLOG;
892 if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
893 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
894 <<"File Read Error "<<ENDLOG;
897 if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
898 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
899 <<"File Read Error "<<ENDLOG;
903 npoint = size/sizeof(AliL3SpacePointData);
904 if(fread(data,size,1,fInBinary)!=1){
905 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
906 <<"File Read Error "<<ENDLOG;
909 if(size%sizeof(AliL3SpacePointData)){
910 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File Size")
911 <<"File Size wrong "<<ENDLOG;
914 LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
915 <<AliL3Log::kDec<<"Wrote "<<size<<" Bytes to Memory"<<ENDLOG;
919 ///////////////////////////////////////// Track IO
920 Bool_t AliL3MemHandler::Memory2Binary(UInt_t ntrack,AliL3TrackSegmentData *data){
922 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","File")
923 <<"No Output File"<<ENDLOG;
927 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2Binary","Memory")
928 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
931 AliL3TrackSegmentData *track_pt = data;
932 for(UInt_t i=0;i<ntrack;i++){
933 Int_t size=sizeof(AliL3TrackSegmentData)+track_pt->fNPoints*sizeof(UInt_t);
934 fwrite(track_pt,size,1,fOutBinary);
935 Byte_t *byte_pt = (Byte_t*) track_pt;
937 track_pt = (AliL3TrackSegmentData*) byte_pt;
939 LOG(AliL3Log::kDebug,"AliL3MemHandler::Memory2Binary","File")
940 <<AliL3Log::kDec<<"Wrote "<<ntrack<<" Tracks to File"<<ENDLOG;
945 Bool_t AliL3MemHandler::Binary2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data){
947 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","File")
948 <<"No Input File"<<ENDLOG;
952 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2Memory","Memory")
953 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
958 AliL3TrackSegmentData *track_pt = data;
961 UInt_t size,slice,patch,row[2];
962 AliL3EventDataTypeRoot datatype;
964 if(fread(&datatype,sizeof(AliL3EventDataTypeRoot),1,fInBinary)!=1){
965 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
966 <<"File Read Error "<<ENDLOG;
969 if(fread(&node,sizeof(UInt_t),1,fInBinary)!=1){
970 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
971 <<"File Read Error "<<ENDLOG;
974 if(fread(&size,sizeof(UInt_t),1,fInBinary)!=1){
975 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
976 <<"File Read Error "<<ENDLOG;
979 if(fread(&slice,sizeof(UInt_t),1,fInBinary)!=1){
980 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
981 <<"File Read Error "<<ENDLOG;
984 if(fread(&patch,sizeof(UInt_t),1,fInBinary)!=1){
985 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
986 <<"File Read Error "<<ENDLOG;
989 if(fread(row,2*sizeof(UInt_t),1,fInBinary)!=1){
990 LOG(AliL3Log::kFatal,"AliL3MemHandler::Binary2Memory","File")
991 <<"File Read Error "<<ENDLOG;
995 while(!feof(fInBinary)){
996 if(fread(track_pt,sizeof(AliL3TrackSegmentData),1,fInBinary)!=1) break;
997 Int_t size=track_pt->fNPoints*sizeof(UInt_t);
998 if(fread(track_pt->fPointIDs,size,1,fInBinary)!=1) break;
999 Byte_t *byte_pt = (Byte_t*) track_pt;
1000 byte_pt += sizeof(AliL3TrackSegmentData)+size;
1001 track_pt = (AliL3TrackSegmentData*) byte_pt;
1004 LOG(AliL3Log::kDebug,"AliL3MemHandler::Binary2Memory","File")
1005 <<AliL3Log::kDec<<"Wrote "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1009 Bool_t AliL3MemHandler::TrackArray2Binary(AliL3TrackArray *array){
1011 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","File")
1012 <<"No Output File"<<ENDLOG;
1016 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Binary","Memory")
1017 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1020 AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate(array);
1022 TrackArray2Memory(ntrack,data,array);
1023 Memory2Binary(ntrack,data);
1028 Bool_t AliL3MemHandler::Binary2TrackArray(AliL3TrackArray *array){
1030 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","File")
1031 <<"No Input File"<<ENDLOG;
1035 LOG(AliL3Log::kWarning,"AliL3MemHandler::Binary2TrackArray","Memory")
1036 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1039 AliL3TrackSegmentData *data = (AliL3TrackSegmentData *)Allocate();
1041 Binary2Memory(ntrack,data);
1042 Memory2TrackArray(ntrack,data,array);
1047 Bool_t AliL3MemHandler::TrackArray2Memory(UInt_t & ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){
1049 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1050 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1054 LOG(AliL3Log::kWarning,"AliL3MemHandler::TrackArray2Memory","Memory")
1055 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1058 array->WriteTracks(ntrack,data);
1062 Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array){
1064 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1065 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1069 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1070 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1073 array->FillTracks(ntrack,data);
1077 Bool_t AliL3MemHandler::Memory2TrackArray(UInt_t ntrack,AliL3TrackSegmentData *data,AliL3TrackArray *array,Int_t slice, AliL3Transform* trans){
1079 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1080 <<"Pointer to AliL3TrackSegmentData = 0x0 "<<ENDLOG;
1084 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Memory")
1085 <<"Pointer to AliL3TrackArray = 0x0 "<<ENDLOG;
1089 LOG(AliL3Log::kWarning,"AliL3MemHandler::Memory2TrackArray","Object")
1090 <<"Pointer to AliL3Transform = 0x0 "<<ENDLOG;
1093 array->FillTracks(ntrack,data,slice,trans);