2 // Original: AliHLTMemHandler.cxx,v 1.52 2005/06/14 10:55:21 cvetan
4 //**************************************************************************
5 //* This file is property of and copyright by the ALICE HLT Project *
6 //* ALICE Experiment at CERN, All rights reserved. *
8 //* Primary Authors: U. Frankenfeld, A. Vestbo, C. Loizides *
9 //* Matthias Richter <Matthias.Richter@ift.uib.no> *
10 //* for The ALICE HLT Project. *
12 //* Permission to use, copy, modify and distribute this software and its *
13 //* documentation strictly for non-commercial purposes is hereby granted *
14 //* without fee, provided that the above copyright notice appears in all *
15 //* copies and that both the copyright notice and this permission notice *
16 //* appear in the supporting documentation. The authors make no claims *
17 //* about the suitability of this software for any purpose. It is *
18 //* provided "as is" without express or implied warranty. *
19 //**************************************************************************
21 // @file AliHLTTPCMemHandler.cxx
22 // @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by
25 // @brief input interface base class for the TPC tracking code before
26 // migration to the HLT component framework
29 #include "AliHLTTPCRootTypes.h"
30 #include "AliHLTTPCDigitData.h"
31 #include "AliHLTTPCLogging.h"
32 #include "AliHLTTPCTransform.h"
33 #include "AliHLTTPCTrackSegmentData.h"
34 #include "AliHLTTPCSpacePointData.h"
35 #include "AliHLTTPCTrackArray.h"
36 #include "AliHLTTPCMemHandler.h"
43 ClassImp(AliHLTTPCMemHandler)
45 AliHLTTPCMemHandler::AliHLTTPCMemHandler()
69 AliHLTTPCMemHandler::~AliHLTTPCMemHandler()
73 if(fRandomDigits) delete [] fRandomDigits;
74 if(fDPt) delete [] fDPt;
77 void AliHLTTPCMemHandler::Init(Int_t s,Int_t p, Int_t *r)
87 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Init","sector coordinates")
88 <<"Invalid slice no " << s <<ENDLOG;
96 fRowMin=AliHLTTPCTransform::GetFirstRow(p);
97 fRowMax=AliHLTTPCTransform::GetLastRow(p);
102 void AliHLTTPCMemHandler::ResetROI()
104 //Resets the Look-up table for Region of Interest mode.
105 for(Int_t i=fRowMin; i<=fRowMax; i++)
107 fEtaMinTimeBin[i] = 0;
108 fEtaMaxTimeBin[i] = AliHLTTPCTransform::GetNTimeBins()-1;
112 void AliHLTTPCMemHandler::SetROI(const Float_t *eta,Int_t */*slice*/)
114 // Init the Look-up table for the Region of Interest mode.
115 // Here you can specify a certain etaregion, - all data
116 // outside this region will be discarded:
117 // eta[0] = mimium eta
118 // eta[1] = maximum eta
119 // slice[0] = mimumum slice
120 // slice[1] = maximum slice
123 if(TMath::Abs(eta[1])<.00001)
125 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetROI","Eta Values")
126 <<"Bad ROI parameters."<<ENDLOG;
127 for(Int_t i=fRowMin; i<=fRowMax; i++)
135 for(Int_t i=fRowMin; i<=fRowMax; i++)
140 Float_t thetamax = 2*atan(exp(-1.*eta[1]));
142 xyz[0] = AliHLTTPCTransform::Row2X(i);
144 xyz[2] = xyz[0]/tan(thetamax);
145 AliHLTTPCTransform::Slice2Sector(fSlice,i,sector,row);
146 AliHLTTPCTransform::Local2Raw(xyz,sector,row);
148 fEtaMinTimeBin[i] = (Int_t)xyz[2];
150 if(TMath::Abs(eta[0])<.00001)
151 fEtaMaxTimeBin[i] = 445;
154 Float_t thetamin = 2*atan(exp(-1.*eta[0]));
155 xyz[0] = AliHLTTPCTransform::Row2X(i);
156 xyz[1] = AliHLTTPCTransform::GetMaxY(i);
157 Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
158 xyz[2] = radii/tan(thetamin);
159 AliHLTTPCTransform::Local2Raw(xyz,sector,row);
160 fEtaMaxTimeBin[i] = (Int_t)xyz[2];
166 Bool_t AliHLTTPCMemHandler::SetBinaryInput(char *name)
168 //Set the input binary file.
169 fInBinary = fopen(name,"r");
171 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open")
172 <<"Error opening file "<<name<<ENDLOG;
178 Bool_t AliHLTTPCMemHandler::SetBinaryInput(FILE *file)
180 //Set the input binary file.
183 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open")
184 <<"Pointer to File = 0x0 "<<ENDLOG;
190 void AliHLTTPCMemHandler::CloseBinaryInput()
192 //Close the input file.
194 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryInput","File Close")
195 <<"Nothing to Close"<<ENDLOG;
202 Bool_t AliHLTTPCMemHandler::SetBinaryOutput(char *name)
204 //Set the binary output file.
205 fOutBinary = fopen(name,"w");
207 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open")
208 <<"Pointer to File = 0x0 "<<ENDLOG;
214 Bool_t AliHLTTPCMemHandler::SetBinaryOutput(FILE *file)
216 //Set the binary output file.
219 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open")
220 <<"Pointer to File = 0x0 "<<ENDLOG;
226 void AliHLTTPCMemHandler::CloseBinaryOutput()
230 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryOutPut","File Close")
231 <<"Nothing to Close"<<ENDLOG;
238 UInt_t AliHLTTPCMemHandler::GetFileSize()
240 //Returns the file size in bytes of the input file.
242 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetFileSize","File")
243 <<"No Input File"<<ENDLOG;
246 fseek(fInBinary,0,SEEK_END);
247 UInt_t size = (UInt_t) ftell(fInBinary);
252 Byte_t *AliHLTTPCMemHandler::Allocate()
255 return Allocate(GetFileSize());
258 Byte_t *AliHLTTPCMemHandler::Allocate(AliHLTTPCTrackArray *array)
260 //Allocate memory for tracks in memory. Used by TrackArray2Binary()
262 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory")
263 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
266 return Allocate(array->GetOutSize());
269 Byte_t *AliHLTTPCMemHandler::Allocate(UInt_t size)
271 //Allocate memory of size in bytes.
273 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory")
274 <<"Delete Memory"<<ENDLOG;
277 fPt = new Byte_t[size];
280 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Allocate","Memory")
281 <<AliHLTTPCLog::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
285 void AliHLTTPCMemHandler::Free()
287 //Clear the memory, if allocated.
289 // LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMemHandler::Free","Memory")
290 // <<"No Memory allocated - can't Free"<<ENDLOG;
298 ///////////////////////////////////////// Random
299 void AliHLTTPCMemHandler::SetRandomSeed()
301 //If you are adding random data to the original data.
303 SetRandomSeed(time(tp));
306 void AliHLTTPCMemHandler::SetRandomCluster(Int_t maxnumber)
308 //If you are adding random data to the original data.
311 fNRandom = maxnumber;
313 if(fRandomDigits) delete [] fRandomDigits;
314 fRandomDigits = new AliHLTTPCRandomDigitData[fNRandom*9];
315 if(fDPt) delete [] fDPt;
316 fDPt = new AliHLTTPCRandomDigitData *[fNRandom*9];
319 void AliHLTTPCMemHandler::QSort(AliHLTTPCRandomDigitData **a, Int_t first, Int_t last)
322 // Sort array of AliHLTTPCRandomDigitData pointers using a quicksort algorithm.
323 // Uses CompareDigits() to compare objects.
326 static AliHLTTPCRandomDigitData *tmp;
327 static int i; // "static" to save stack space
330 while (last - first > 1) {
334 while (++i < last && CompareDigits(a[i], a[first]) < 0)
336 while (--j > first && CompareDigits(a[j], a[first]) > 0)
353 if (j - first < last - (j + 1)) {
355 first = j + 1; // QSort(j + 1, last);
357 QSort(a, j + 1, last);
358 last = j; // QSort(first, j);
363 UInt_t AliHLTTPCMemHandler::GetRandomSize() const
367 for(Int_t r=fRowMin;r<=fRowMax;r++){
368 Int_t npad=AliHLTTPCTransform::GetNPads(r);
369 nrandom += Int_t (fNGenerate * ((Double_t) npad/141.));
371 return 9 * nrandom * sizeof(AliHLTTPCDigitData);
374 void AliHLTTPCMemHandler::Generate(Int_t row)
376 //Generate random data on row, if you didn't
377 //ask for this, nothing happens here.
379 if(!fIsRandom) return;
382 Int_t npad=AliHLTTPCTransform::GetNPads(row);
383 Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
384 Int_t nrandom = Int_t (fNGenerate * ((Double_t) npad/141.) *
385 (Double_t) ntime/(Double_t) AliHLTTPCTransform::GetNTimeBins() );
387 for(Int_t n=0;n<nrandom;n++){
388 Int_t pad = (int)((float)rand()/RAND_MAX*npad);
389 Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
390 Int_t charge = (int)((float)rand()/RAND_MAX*AliHLTTPCTransform::GetADCSat());
391 DigitizePoint(row,pad,time,charge);
393 QSort(fDPt,0,fNDigits);
397 void AliHLTTPCMemHandler::DigitizePoint(Int_t row, Int_t pad,
398 Int_t time,Int_t charge)
400 //Making one single random cluster.
401 for(Int_t j=-1;j<2;j++){
402 for(Int_t k=-1;k<2;k++){
403 Int_t dcharge = charge;
406 if(dcharge<10) continue;
407 Int_t dpad = j + pad;
408 Int_t dtime = k + time;
410 if(dpad<0||dpad>=AliHLTTPCTransform::GetNPads(row)) continue;
411 if(dtime<0||dtime>=AliHLTTPCTransform::GetNTimeBins()) continue;
413 fRandomDigits[fNDigits].fCharge = dcharge;
414 fRandomDigits[fNDigits].fRow = row;
415 fRandomDigits[fNDigits].fPad = dpad;
416 fRandomDigits[fNDigits].fTime = dtime;
417 fDPt[fNDigits] = &fRandomDigits[fNDigits];
423 ///////////////////////////////////////// Digit IO
424 Bool_t AliHLTTPCMemHandler::Memory2BinaryFile(UInt_t nrow,AliHLTTPCDigitRowData *data)
426 //Write data to the outputfile as is. No run-length encoding is done.
429 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
430 <<"No Output File"<<ENDLOG;
434 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
435 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
439 AliHLTTPCDigitRowData *rowPt = data;
441 for(UInt_t i=0;i<nrow;i++){
442 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit
443 + sizeof(AliHLTTPCDigitRowData);
445 fwrite(rowPt,size,1,fOutBinary);
446 Byte_t *bytePt =(Byte_t *) rowPt;
448 rowPt = (AliHLTTPCDigitRowData *) bytePt;
450 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","Memory")
451 <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
452 <<nrow<<" Rows)"<<ENDLOG;
456 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *data,UInt_t& sz)
458 //Read inputfile into memory as is, and store it in data.
459 // No run-length encoding is assumed.
462 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
463 <<"No Input File"<<ENDLOG;
467 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
468 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
472 AliHLTTPCDigitRowData *rowPt = data;
475 while(!feof(fInBinary)){
476 Byte_t *bytePt =(Byte_t *) rowPt;
478 if (sz<outsize+sizeof(AliHLTTPCDigitRowData)) {
479 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
480 << "target data buffer too small" <<ENDLOG;
483 if(fread(rowPt,sizeof(AliHLTTPCDigitRowData),1,fInBinary)!=1) break;
485 bytePt += sizeof(AliHLTTPCDigitRowData);
486 outsize += sizeof(AliHLTTPCDigitRowData);
488 UInt_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit;
490 if (sz<outsize+size) {
491 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
492 << "target data buffer too small" <<ENDLOG;
495 //if(fread(bytePt,size,1,fInBinary)!=1) break;
496 fread(bytePt,size,1,fInBinary);
499 rowPt = (AliHLTTPCDigitRowData *) bytePt;
503 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","Memory")
504 <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
505 <<rowcount<<" Rows)"<<ENDLOG;
510 void AliHLTTPCMemHandler::AddData(AliHLTTPCDigitData *data,UInt_t & ndata,
511 UInt_t /*row*/,UShort_t pad,UShort_t time,UShort_t charge) const
514 data[ndata].fPad = pad;
515 data[ndata].fTime = time;
516 data[ndata].fCharge = charge;
520 void AliHLTTPCMemHandler::AddRandom(AliHLTTPCDigitData *data, UInt_t & ndata)
522 //add some random data
523 data[ndata].fPad = fDPt[fNUsed]->fPad;
524 data[ndata].fTime = fDPt[fNUsed]->fTime;
525 data[ndata].fCharge = fDPt[fNUsed]->fCharge;
530 void AliHLTTPCMemHandler::MergeDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata,
531 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
534 data[ndata].fPad = pad;
535 data[ndata].fTime = time;
536 data[ndata].fCharge = charge;
537 while(ComparePoints(row,pad,time)==0){
538 Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
539 if(charge>=AliHLTTPCTransform::GetADCSat()) ch = AliHLTTPCTransform::GetADCSat();
540 data[ndata].fCharge = ch;
546 void AliHLTTPCMemHandler::AddDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata,
547 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
551 while((action=ComparePoints(row,pad,time))==1){
552 AddRandom(data,ndata);
555 MergeDataRandom(data,ndata,row,pad,time,charge);
558 AddData(data,ndata,row,pad,time,charge);
562 void AliHLTTPCMemHandler::Write(UInt_t *comp, UInt_t & index,
563 UInt_t & subindex, UShort_t value) const
565 //write compressed data
566 UInt_t shift[3] = {0,10,20};
567 if(subindex==0) comp[index] =0; //clean up memory
568 comp[index] |= (value&0x03ff)<<shift[subindex];
576 UShort_t AliHLTTPCMemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const
578 //read compressed data
579 UInt_t shift[3] = {0,10,20};
580 UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
590 UShort_t AliHLTTPCMemHandler::Test(const UInt_t *comp,
591 UInt_t index, UInt_t subindex) const
594 UInt_t shift[3] = {0,10,20};
595 return (comp[index]>>shift[subindex])&0x03ff;
598 Int_t AliHLTTPCMemHandler::Memory2CompMemory(UInt_t nrow,
599 AliHLTTPCDigitRowData *data,UInt_t *comp)
601 //Performs run-length encoding on data stored in memory pointed to by data.
602 //The compressed data is written to comp.
604 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory")
605 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
609 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory")
610 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
613 AliHLTTPCDigitRowData *rowPt = data;
617 for(UInt_t i=0;i<nrow;i++){
618 UShort_t value = rowPt->fRow;
619 Write(comp,index,subindex,value);
623 for(Int_t d=0;d<200;d++) ddd[d]=0;
624 for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){
625 if(rowPt->fDigitData[dig].fPad <200){
626 ddd[rowPt->fDigitData[dig].fPad]++;
629 for(Int_t d=0;d<200;d++){
635 Write(comp,index,subindex,npad);
637 for(UShort_t pad=0;pad <= maxpad;pad++){
638 if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
640 Write(comp,index,subindex,pad);
641 // write zero if time != 0
642 if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
643 if(rowPt->fDigitData[digit].fTime>0){
644 Write(comp,index,subindex,0);
645 Write(comp,index,subindex,rowPt->fDigitData[digit].fTime);
648 while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
649 UShort_t charge = rowPt->fDigitData[digit].fCharge;
653 Write(comp,index,subindex,charge);
654 if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){
655 if(rowPt->fDigitData[digit].fTime +1 !=
656 rowPt->fDigitData[digit+1].fTime){
657 Write(comp,index,subindex,0);
658 UShort_t nzero = rowPt->fDigitData[digit+1].fTime -
659 (rowPt->fDigitData[digit].fTime +1);
660 Write(comp,index,subindex,nzero);
665 Write(comp,index,subindex,0);
666 Write(comp,index,subindex,0);
669 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
670 sizeof(AliHLTTPCDigitRowData);
671 Byte_t *bytePt =(Byte_t *) rowPt;
673 rowPt = (AliHLTTPCDigitRowData *) bytePt;
676 Write(comp,index,subindex,0);
677 return index * sizeof(UInt_t);
680 Int_t AliHLTTPCMemHandler::CompMemory2Memory(UInt_t nrow,
681 AliHLTTPCDigitRowData *data,UInt_t *comp, UInt_t& sz)
683 //Uncompress the run-length encoded data in memory pointed to by comp, and
687 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2Memory","Memory")
688 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
692 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2Memory","Memory")
693 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
698 AliHLTTPCDigitRowData *rowPt = data;
702 for(UInt_t i=0;i<nrow;i++){
704 UInt_t row =Read(comp,index,subindex);
707 UShort_t npad = Read(comp,index,subindex);
708 for(UShort_t p=0;p<npad;p++){
711 UShort_t pad = Read(comp,index,subindex);
712 if(Test(comp,index,subindex)==0){
713 Read(comp,index,subindex);
714 if( (time = Read(comp,index,subindex)) == 0 ){
719 while( (charge=Read(comp,index,subindex)) != 0){
720 if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
721 //AddData(rowPt->fDigitData,ndigit,row,pad,time,charge);
722 //seems we are using this function... but dont know why
723 AddDataRandom(rowPt->fDigitData,ndigit,row,pad,time,charge);
726 UShort_t tshift = Read(comp,index,subindex);
727 if(tshift == 0) break;
731 rowPt->fNDigit = ndigit;
732 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
733 sizeof(AliHLTTPCDigitRowData);
734 Byte_t *bytePt =(Byte_t *) rowPt;
737 rowPt = (AliHLTTPCDigitRowData *) bytePt;
743 UInt_t AliHLTTPCMemHandler::GetCompMemorySize(UInt_t nrow,AliHLTTPCDigitRowData *data) const
745 //Return the size of RLE data, after compressing data.
748 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetCompMemorySize","Memory")
749 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
752 AliHLTTPCDigitRowData *rowPt = data;
755 for(UInt_t i=0;i<nrow;i++){
760 for(Int_t d=0;d<200;d++) ddd[d]=0;
761 for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){
762 if(rowPt->fDigitData[dig].fPad <200){
763 ddd[rowPt->fDigitData[dig].fPad]++;
766 for(Int_t d=0;d<200;d++){
774 for(UShort_t pad=0;pad <= maxpad;pad++){
775 if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
778 // write zero if time != 0
779 if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
780 if(rowPt->fDigitData[digit].fTime>0){
785 while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
787 if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){
788 if(rowPt->fDigitData[digit].fTime +1 !=
789 rowPt->fDigitData[digit+1].fTime){
800 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
801 sizeof(AliHLTTPCDigitRowData);
802 Byte_t *bytePt =(Byte_t *) rowPt;
804 rowPt = (AliHLTTPCDigitRowData *) bytePt;
808 return (index/3) * sizeof(UInt_t);
811 UInt_t AliHLTTPCMemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp) const
815 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetMemorySize","Memory")
816 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
824 for(UInt_t i=0;i<nrow;i++){
826 Read(comp,index,subindex);
827 UShort_t npad = Read(comp,index,subindex);
828 for(UShort_t p=0;p<npad;p++){
829 Read(comp,index,subindex);
830 if(Test(comp,index,subindex)==0){
831 Read(comp,index,subindex);
832 if(Read(comp,index,subindex)== 0) continue;
835 while(Read(comp,index,subindex)!=0) ndigit++;
836 if(Read(comp,index,subindex)==0) break;
839 Int_t size = sizeof(AliHLTTPCDigitData) * ndigit+
840 sizeof(AliHLTTPCDigitRowData);
847 UInt_t AliHLTTPCMemHandler::GetNRow(UInt_t *comp,UInt_t size)
851 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetNRow","Memory")
852 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
859 while(index<size-1){ //don't start with last word
862 Read(comp,index,subindex);
863 UShort_t npad = Read(comp,index,subindex);
864 for(UShort_t p=0;p<npad;p++){
865 Read(comp,index,subindex);
866 if(Test(comp,index,subindex)==0){
867 Read(comp,index,subindex);
868 if(Read(comp,index,subindex)==0)continue;
871 while(Read(comp,index,subindex)!=0) ndigit++;
872 if(Read(comp,index,subindex)==0) break;
876 if(index==size-1){ //last word
878 if(Read(comp,index,subindex)!=0) nrow++;
884 Bool_t AliHLTTPCMemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
887 //Write the RLE data in comp to the output file.
890 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","File")
891 <<"No Output File"<<ENDLOG;
895 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory")
896 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
900 size=GetMemorySize(nrow,comp);
902 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory")
903 <<"Memory size = 0 "<<ENDLOG;
906 UInt_t length = size/sizeof(UInt_t);
907 fwrite(&length,sizeof(UInt_t),1,fOutBinary);
908 fwrite(comp,size,1,fOutBinary);
912 Bool_t AliHLTTPCMemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp)
914 //Read the RLE data from file, and store it in comp. No unpacking yet.
917 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompBinary2CompMemory","File")
918 <<"No Output File"<<ENDLOG;
922 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompBinary2CompMemory","Memory")
923 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
928 if(fread(&length,sizeof(UInt_t),1,fInBinary)!=1) return kFALSE;
929 UInt_t size = length*sizeof(UInt_t);
930 if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
931 // now find the number of dig
932 nrow = GetNRow(comp,size);
936 AliHLTTPCDigitRowData *AliHLTTPCMemHandler::CompBinary2Memory(UInt_t & nrow, UInt_t& sz )
938 // Read the RLE inputfile, unpack it and return the pointer to it.
939 AliHLTTPCMemHandler * handler = new AliHLTTPCMemHandler();
940 handler->SetBinaryInput(fInBinary);
941 UInt_t *comp =(UInt_t *)handler->Allocate();
942 handler->CompBinary2CompMemory(nrow,comp);
943 UInt_t size = GetMemorySize(nrow,comp);
945 AliHLTTPCDigitRowData *data = (AliHLTTPCDigitRowData *)Allocate(size);
946 CompMemory2Memory(nrow,data,comp);
952 Bool_t AliHLTTPCMemHandler::Memory2CompBinary(UInt_t nrow,AliHLTTPCDigitRowData *data)
954 //Perform RLE on the data, and write it to the output file.
956 AliHLTTPCMemHandler * handler = new AliHLTTPCMemHandler();
957 UInt_t size = GetCompMemorySize(nrow,data);
958 UInt_t *comp =(UInt_t *)handler->Allocate(size);
959 Memory2CompMemory(nrow,data,comp);
960 CompMemory2CompBinary(nrow,comp,size);
967 ///////////////////////////////////////// Point IO
968 Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t npoint,AliHLTTPCSpacePointData *data)
970 //Writing spacepoints stored in data to the outputfile.
972 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
973 <<"No Output File"<<ENDLOG;
977 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
978 <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
981 UInt_t size = npoint*sizeof(AliHLTTPCSpacePointData);
982 fwrite(data,size,1,fOutBinary);
987 Bool_t AliHLTTPCMemHandler::Transform(UInt_t npoint,AliHLTTPCSpacePointData *data,Int_t slice)
989 //Transform the space points in data, to global coordinates in slice.
991 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Transform","Memory")
992 <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
996 for(UInt_t i=0;i<npoint;i++){
1000 xyz[2] = data[i].fZ;
1001 AliHLTTPCTransform::Local2Global(xyz,slice);
1002 data[i].fX = xyz[0];
1003 data[i].fY = xyz[1];
1004 data[i].fZ = xyz[2];
1009 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & npoint,AliHLTTPCSpacePointData *data, UInt_t& sz)
1011 //Read the space points in inputfile, and store it in data.
1013 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1014 <<"No Input File"<<ENDLOG;
1018 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
1019 <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
1023 Int_t size = GetFileSize();
1025 npoint = size/sizeof(AliHLTTPCSpacePointData);
1027 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1028 <<"File Size == 0"<<ENDLOG;
1032 if(fread(data,size,1,fInBinary)!=1){
1033 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","File")
1034 <<"File Read Error "<<ENDLOG;
1037 if(size%sizeof(AliHLTTPCSpacePointData)){
1038 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","File Size")
1039 <<"File Size wrong "<<ENDLOG;
1042 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","File")
1043 <<AliHLTTPCLog::kDec<<"Wrote "<<size<<" Bytes to Memory"<<ENDLOG;
1047 ///////////////////////////////////////// Track IO
1048 Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t ntrack,AliHLTTPCTrackSegmentData *data)
1050 //Write the tracks stored in data, to outputfile.
1052 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
1053 <<"No Output File"<<ENDLOG;
1057 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
1058 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1061 AliHLTTPCTrackSegmentData *trackPt = data;
1062 for(UInt_t i=0;i<ntrack;i++){
1063 Int_t size=sizeof(AliHLTTPCTrackSegmentData)+trackPt->fNPoints*sizeof(UInt_t);
1064 fwrite(trackPt,size,1,fOutBinary);
1065 Byte_t *bytePt = (Byte_t*) trackPt;
1067 trackPt = (AliHLTTPCTrackSegmentData*) bytePt;
1069 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","File")
1070 <<AliHLTTPCLog::kDec<<"Wrote "<<ntrack<<" Tracks to File"<<ENDLOG;
1075 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & ntrack,AliHLTTPCTrackSegmentData *data)
1077 //Read the tracks in inputfile, and store it in data.
1079 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1080 <<"No Input File"<<ENDLOG;
1084 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
1085 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1090 AliHLTTPCTrackSegmentData *trackPt = data;
1093 while(!feof(fInBinary)){
1094 if(fread(trackPt,sizeof(AliHLTTPCTrackSegmentData),1,fInBinary)!=1) break;
1095 Int_t size=trackPt->fNPoints*sizeof(UInt_t);
1096 if(fread(trackPt->fPointIDs,size,1,fInBinary)!=1) break;
1097 Byte_t *bytePt = (Byte_t*) trackPt;
1098 bytePt += sizeof(AliHLTTPCTrackSegmentData)+size;
1099 trackPt = (AliHLTTPCTrackSegmentData*) bytePt;
1102 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","File")
1103 <<AliHLTTPCLog::kDec<<"Wrote "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1107 Bool_t AliHLTTPCMemHandler::TrackArray2Binary(AliHLTTPCTrackArray *array)
1109 //Write the trackarray to the outputfile.
1111 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Binary","File")
1112 <<"No Output File"<<ENDLOG;
1116 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Binary","Memory")
1117 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1120 AliHLTTPCTrackSegmentData *data = (AliHLTTPCTrackSegmentData *)Allocate(array);
1123 TrackArray2Memory(ntrack,data,array);
1124 Memory2Binary(ntrack,data);
1129 Bool_t AliHLTTPCMemHandler::Binary2TrackArray(AliHLTTPCTrackArray *array)
1131 //Read the tracks in inputfile, and fill it in trackarray.
1132 //array should already be constructed.
1134 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2TrackArray","File")
1135 <<"No Input File"<<ENDLOG;
1139 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2TrackArray","Memory")
1140 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1143 AliHLTTPCTrackSegmentData *data = (AliHLTTPCTrackSegmentData *)Allocate();
1145 Binary2Memory(ntrack,data);
1146 Memory2TrackArray(ntrack,data,array);
1151 Bool_t AliHLTTPCMemHandler::TrackArray2Memory(UInt_t & ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array) const
1153 //Fill the trackarray into the AliTrackSegmentData structures before writing to outputfile.
1155 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Memory","Memory")
1156 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1160 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Memory","Memory")
1161 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1165 array->WriteTracks(ntrack,data);
1169 Bool_t AliHLTTPCMemHandler::Memory2TrackArray(UInt_t ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array) const
1171 //Fill the tracks in data into trackarray.
1174 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1175 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1179 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1180 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1183 array->FillTracks(ntrack,data);
1187 Bool_t AliHLTTPCMemHandler::Memory2TrackArray(UInt_t ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array,Int_t slice) const
1189 //Fill the tracks in data into trackarray, and rotate the tracks to global coordinates.
1192 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1193 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1197 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1198 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1201 array->FillTracks(ntrack,data,slice);
1205 void AliHLTTPCMemHandler::UpdateRowPointer(AliHLTTPCDigitRowData *&tempPt)
1207 //Update the data pointer to the next padrow in memory.
1209 Byte_t *tmp = (Byte_t*)tempPt;
1210 Int_t size = sizeof(AliHLTTPCDigitRowData) + tempPt->fNDigit*sizeof(AliHLTTPCDigitData);
1212 tempPt = (AliHLTTPCDigitRowData*)tmp;
1215 Int_t AliHLTTPCMemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const
1217 //compare two points
1218 if(fNUsed>=fNDigits) return -2;
1220 if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0;
1222 if(pad<fDPt[fNUsed]->fPad) return -1;
1223 if(pad==fDPt[fNUsed]->fPad&&time<fDPt[fNUsed]->fTime) return -1;
1228 Int_t AliHLTTPCMemHandler::CompareDigits(const AliHLTTPCRandomDigitData *a,const AliHLTTPCRandomDigitData *b) const
1230 //compare two digits
1231 if(a->fPad==b->fPad && a->fTime == b->fTime) return 0;
1233 if(a->fPad<b->fPad) return -1;
1234 if(a->fPad==b->fPad && a->fTime<b->fTime) return -1;