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
28 // see below for class documentation
30 // refer to README to build package
32 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
34 /** \class AliHLTTPCMemHandler
36 //_____________________________________________________________
37 // AliHLTTPCMemHandler
39 // The HLT Binary File handler
41 // This class does all the memory I/O handling of HLT binary files.
46 // 1) Reading a binary file:
48 // AliHLTTPCMemHandler file;
49 // file.SetBinaryInput(filename);
50 // file.Init(slice,patch);
53 // AliHLTTPCDigitRowData *data = file.CompBinary2Memory(nrows);
55 // for(int i=0; i<nrows; i++)
58 // AliHLTTPCDigitData *dataPt = (AliHLTTPCDigitData*)data->fDigitData;
59 // for(int j=0; j<data->fNDigit; j++)
61 // pad = dataPt[j].fPad;
62 // time = dataPt[j].fTime;
63 // charge = dataPt[j].fCharge;
66 // file.UpdateRowPointer(data);
69 // file.CloseBinaryInput();
70 // ________________________
72 // 2) Writing a binary file:
74 // //First of all you need to store the data in memory,
75 // //and have a pointer to it of type AliHLTTPCDigitRowData.
76 // //E.g. if you just want to write the data you read in example 1)
77 // //into a new file, you can do the following:
79 // AliHLTTPCMemHandler newfile;
80 // newfile.Init(slice,patch);
81 // newfile.SetBinaryOutput(newfilename);
82 // newfile.Memory2CompBinary((UInt_t)NumberOfRowsInPatch,(AliHLTTPCDigitRowData*)data);
83 // newfile.CloseBinaryOutput();
86 // Compressed file format:
87 // -----------------------
89 // The data is RLE encoded and currently using _10_ bit range for the ADC-values.
93 #include "AliHLTTPCRootTypes.h"
94 #include "AliHLTTPCDigitData.h"
95 #include "AliHLTTPCLogging.h"
96 #include "AliHLTTPCTransform.h"
97 #include "AliHLTTPCTrackSegmentData.h"
98 #include "AliHLTTPCSpacePointData.h"
99 #include "AliHLTTPCTrackArray.h"
100 #include "AliHLTTPCMemHandler.h"
106 ClassImp(AliHLTTPCMemHandler)
108 AliHLTTPCMemHandler::AliHLTTPCMemHandler()
132 AliHLTTPCMemHandler::~AliHLTTPCMemHandler()
135 if(fPt) delete[] fPt;
136 if(fRandomDigits) delete [] fRandomDigits;
137 if(fDPt) delete [] fDPt;
140 void AliHLTTPCMemHandler::Init(Int_t s,Int_t p, Int_t *r)
148 fRowMin=AliHLTTPCTransform::GetFirstRow(p);
149 fRowMax=AliHLTTPCTransform::GetLastRow(p);
154 void AliHLTTPCMemHandler::ResetROI()
156 //Resets the Look-up table for Region of Interest mode.
157 for(Int_t i=fRowMin; i<=fRowMax; i++)
159 fEtaMinTimeBin[i] = 0;
160 fEtaMaxTimeBin[i] = AliHLTTPCTransform::GetNTimeBins()-1;
164 void AliHLTTPCMemHandler::SetROI(Float_t *eta,Int_t */*slice*/)
166 // Init the Look-up table for the Region of Interest mode.
167 // Here you can specify a certain etaregion, - all data
168 // outside this region will be discarded:
169 // eta[0] = mimium eta
170 // eta[1] = maximum eta
171 // slice[0] = mimumum slice
172 // slice[1] = maximum slice
177 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetROI","Eta Values")
178 <<"Bad ROI parameters. IDIOT! "<<ENDLOG;
179 for(Int_t i=fRowMin; i<=fRowMax; i++)
187 for(Int_t i=fRowMin; i<=fRowMax; i++)
192 Float_t thetamax = 2*atan(exp(-1.*eta[1]));
194 xyz[0] = AliHLTTPCTransform::Row2X(i);
196 xyz[2] = xyz[0]/tan(thetamax);
197 AliHLTTPCTransform::Slice2Sector(fSlice,i,sector,row);
198 AliHLTTPCTransform::Local2Raw(xyz,sector,row);
200 fEtaMinTimeBin[i] = (Int_t)xyz[2];
203 fEtaMaxTimeBin[i] = 445;
206 Float_t thetamin = 2*atan(exp(-1.*eta[0]));
207 xyz[0] = AliHLTTPCTransform::Row2X(i);
208 xyz[1] = AliHLTTPCTransform::GetMaxY(i);
209 Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2));
210 xyz[2] = radii/tan(thetamin);
211 AliHLTTPCTransform::Local2Raw(xyz,sector,row);
212 fEtaMaxTimeBin[i] = (Int_t)xyz[2];
218 Bool_t AliHLTTPCMemHandler::SetBinaryInput(char *name)
220 //Set the input binary file.
221 fInBinary = fopen(name,"r");
223 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open")
224 <<"Error opening file "<<name<<ENDLOG;
230 Bool_t AliHLTTPCMemHandler::SetBinaryInput(FILE *file)
232 //Set the input binary file.
235 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open")
236 <<"Pointer to File = 0x0 "<<ENDLOG;
242 void AliHLTTPCMemHandler::CloseBinaryInput()
244 //Close the input file.
246 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryInput","File Close")
247 <<"Nothing to Close"<<ENDLOG;
254 Bool_t AliHLTTPCMemHandler::SetBinaryOutput(char *name)
256 //Set the binary output file.
257 fOutBinary = fopen(name,"w");
259 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open")
260 <<"Pointer to File = 0x0 "<<ENDLOG;
266 Bool_t AliHLTTPCMemHandler::SetBinaryOutput(FILE *file)
268 //Set the binary output file.
271 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open")
272 <<"Pointer to File = 0x0 "<<ENDLOG;
278 void AliHLTTPCMemHandler::CloseBinaryOutput()
282 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryOutPut","File Close")
283 <<"Nothing to Close"<<ENDLOG;
290 UInt_t AliHLTTPCMemHandler::GetFileSize()
292 //Returns the file size in bytes of the input file.
294 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetFileSize","File")
295 <<"No Input File"<<ENDLOG;
298 fseek(fInBinary,0,SEEK_END);
299 UInt_t size = (UInt_t) ftell(fInBinary);
304 Byte_t *AliHLTTPCMemHandler::Allocate()
307 return Allocate(GetFileSize());
310 Byte_t *AliHLTTPCMemHandler::Allocate(AliHLTTPCTrackArray *array)
312 //Allocate memory for tracks in memory. Used by TrackArray2Binary()
314 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory")
315 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
318 return Allocate(array->GetOutSize());
321 Byte_t *AliHLTTPCMemHandler::Allocate(UInt_t size)
323 //Allocate memory of size in bytes.
325 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory")
326 <<"Delete Memory"<<ENDLOG;
329 fPt = new Byte_t[size];
332 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Allocate","Memory")
333 <<AliHLTTPCLog::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
337 void AliHLTTPCMemHandler::Free()
339 //Clear the memory, if allocated.
341 // LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMemHandler::Free","Memory")
342 // <<"No Memory allocated - can't Free"<<ENDLOG;
350 ///////////////////////////////////////// Random
351 void AliHLTTPCMemHandler::SetRandomSeed()
353 //If you are adding random data to the original data.
355 SetRandomSeed(time(tp));
358 void AliHLTTPCMemHandler::SetRandomCluster(Int_t maxnumber)
360 //If you are adding random data to the original data.
363 fNRandom = maxnumber;
365 if(fRandomDigits) delete [] fRandomDigits;
366 fRandomDigits = new AliHLTTPCRandomDigitData[fNRandom*9];
367 if(fDPt) delete [] fDPt;
368 fDPt = new AliHLTTPCRandomDigitData *[fNRandom*9];
371 void AliHLTTPCMemHandler::QSort(AliHLTTPCRandomDigitData **a, Int_t first, Int_t last)
374 // Sort array of AliHLTTPCRandomDigitData pointers using a quicksort algorithm.
375 // Uses CompareDigits() to compare objects.
378 static AliHLTTPCRandomDigitData *tmp;
379 static int i; // "static" to save stack space
382 while (last - first > 1) {
386 while (++i < last && CompareDigits(a[i], a[first]) < 0)
388 while (--j > first && CompareDigits(a[j], a[first]) > 0)
405 if (j - first < last - (j + 1)) {
407 first = j + 1; // QSort(j + 1, last);
409 QSort(a, j + 1, last);
410 last = j; // QSort(first, j);
415 UInt_t AliHLTTPCMemHandler::GetRandomSize() const
419 for(Int_t r=fRowMin;r<=fRowMax;r++){
420 Int_t npad=AliHLTTPCTransform::GetNPads(r);
421 nrandom += Int_t (fNGenerate * ((Double_t) npad/141.));
423 return 9 * nrandom * sizeof(AliHLTTPCDigitData);
426 void AliHLTTPCMemHandler::Generate(Int_t row)
428 //Generate random data on row, if you didn't
429 //ask for this, nothing happens here.
431 if(!fIsRandom) return;
434 Int_t npad=AliHLTTPCTransform::GetNPads(row);
435 Int_t ntime = fEtaMaxTimeBin[row] - fEtaMinTimeBin[row];
436 Int_t nrandom = Int_t (fNGenerate * ((Double_t) npad/141.) *
437 (Double_t) ntime/(Double_t) AliHLTTPCTransform::GetNTimeBins() );
439 for(Int_t n=0;n<nrandom;n++){
440 Int_t pad = (int)((float)rand()/RAND_MAX*npad);
441 Int_t time =(int)((float)rand()/RAND_MAX*ntime+fEtaMinTimeBin[row] );
442 Int_t charge = (int)((float)rand()/RAND_MAX*AliHLTTPCTransform::GetADCSat());
443 DigitizePoint(row,pad,time,charge);
445 QSort(fDPt,0,fNDigits);
449 void AliHLTTPCMemHandler::DigitizePoint(Int_t row, Int_t pad,
450 Int_t time,Int_t charge)
452 //Making one single random cluster.
453 for(Int_t j=-1;j<2;j++){
454 for(Int_t k=-1;k<2;k++){
455 Int_t dcharge = charge;
458 if(dcharge<10) continue;
459 Int_t dpad = j + pad;
460 Int_t dtime = k + time;
462 if(dpad<0||dpad>=AliHLTTPCTransform::GetNPads(row)) continue;
463 if(dtime<0||dtime>=AliHLTTPCTransform::GetNTimeBins()) continue;
465 fRandomDigits[fNDigits].fCharge = dcharge;
466 fRandomDigits[fNDigits].fRow = row;
467 fRandomDigits[fNDigits].fPad = dpad;
468 fRandomDigits[fNDigits].fTime = dtime;
469 fDPt[fNDigits] = &fRandomDigits[fNDigits];
475 ///////////////////////////////////////// Digit IO
476 Bool_t AliHLTTPCMemHandler::Memory2BinaryFile(UInt_t nrow,AliHLTTPCDigitRowData *data)
478 //Write data to the outputfile as is. No run-length encoding is done.
481 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
482 <<"No Output File"<<ENDLOG;
486 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
487 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
491 AliHLTTPCDigitRowData *rowPt = data;
493 for(UInt_t i=0;i<nrow;i++){
494 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit
495 + sizeof(AliHLTTPCDigitRowData);
497 fwrite(rowPt,size,1,fOutBinary);
498 Byte_t *bytePt =(Byte_t *) rowPt;
500 rowPt = (AliHLTTPCDigitRowData *) bytePt;
502 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","Memory")
503 <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
504 <<nrow<<" Rows)"<<ENDLOG;
508 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *data,UInt_t& sz)
510 //Read inputfile into memory as is, and store it in data.
511 // No run-length encoding is assumed.
514 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
515 <<"No Input File"<<ENDLOG;
519 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
520 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
524 AliHLTTPCDigitRowData *rowPt = data;
527 while(!feof(fInBinary)){
528 Byte_t *bytePt =(Byte_t *) rowPt;
530 if (sz<outsize+sizeof(AliHLTTPCDigitRowData)) {
531 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
532 << "target data buffer too small" <<ENDLOG;
535 if(fread(rowPt,sizeof(AliHLTTPCDigitRowData),1,fInBinary)!=1) break;
537 bytePt += sizeof(AliHLTTPCDigitRowData);
538 outsize += sizeof(AliHLTTPCDigitRowData);
540 UInt_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit;
542 if (sz<outsize+size) {
543 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
544 << "target data buffer too small" <<ENDLOG;
547 //if(fread(bytePt,size,1,fInBinary)!=1) break;
548 fread(bytePt,size,1,fInBinary);
551 rowPt = (AliHLTTPCDigitRowData *) bytePt;
555 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","Memory")
556 <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
557 <<rowcount<<" Rows)"<<ENDLOG;
562 void AliHLTTPCMemHandler::AddData(AliHLTTPCDigitData *data,UInt_t & ndata,
563 UInt_t /*row*/,UShort_t pad,UShort_t time,UShort_t charge) const
566 data[ndata].fPad = pad;
567 data[ndata].fTime = time;
568 data[ndata].fCharge = charge;
572 void AliHLTTPCMemHandler::AddRandom(AliHLTTPCDigitData *data, UInt_t & ndata)
574 //add some random data
575 data[ndata].fPad = fDPt[fNUsed]->fPad;
576 data[ndata].fTime = fDPt[fNUsed]->fTime;
577 data[ndata].fCharge = fDPt[fNUsed]->fCharge;
582 void AliHLTTPCMemHandler::MergeDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata,
583 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
586 data[ndata].fPad = pad;
587 data[ndata].fTime = time;
588 data[ndata].fCharge = charge;
589 while(ComparePoints(row,pad,time)==0){
590 Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge;
591 if(charge>=AliHLTTPCTransform::GetADCSat()) ch = AliHLTTPCTransform::GetADCSat();
592 data[ndata].fCharge = ch;
598 void AliHLTTPCMemHandler::AddDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata,
599 UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
603 while((action=ComparePoints(row,pad,time))==1){
604 AddRandom(data,ndata);
607 MergeDataRandom(data,ndata,row,pad,time,charge);
610 AddData(data,ndata,row,pad,time,charge);
614 void AliHLTTPCMemHandler::Write(UInt_t *comp, UInt_t & index,
615 UInt_t & subindex, UShort_t value) const
617 //write compressed data
618 UInt_t shift[3] = {0,10,20};
619 if(subindex==0) comp[index] =0; //clean up memory
620 comp[index] |= (value&0x03ff)<<shift[subindex];
628 UShort_t AliHLTTPCMemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const
630 //read compressed data
631 UInt_t shift[3] = {0,10,20};
632 UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
642 UShort_t AliHLTTPCMemHandler::Test(UInt_t *comp,
643 UInt_t index, UInt_t subindex) const
646 UInt_t shift[3] = {0,10,20};
647 return (comp[index]>>shift[subindex])&0x03ff;
650 Int_t AliHLTTPCMemHandler::Memory2CompMemory(UInt_t nrow,
651 AliHLTTPCDigitRowData *data,UInt_t *comp)
653 //Performs run-length encoding on data stored in memory pointed to by data.
654 //The compressed data is written to comp.
656 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory")
657 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
661 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory")
662 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
665 AliHLTTPCDigitRowData *rowPt = data;
669 for(UInt_t i=0;i<nrow;i++){
670 UShort_t value = rowPt->fRow;
671 Write(comp,index,subindex,value);
675 for(Int_t d=0;d<200;d++) ddd[d]=0;
676 for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){
677 if(rowPt->fDigitData[dig].fPad <200){
678 ddd[rowPt->fDigitData[dig].fPad]++;
681 for(Int_t d=0;d<200;d++){
687 Write(comp,index,subindex,npad);
689 for(UShort_t pad=0;pad <= maxpad;pad++){
690 if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
692 Write(comp,index,subindex,pad);
693 // write zero if time != 0
694 if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
695 if(rowPt->fDigitData[digit].fTime>0){
696 Write(comp,index,subindex,0);
697 Write(comp,index,subindex,rowPt->fDigitData[digit].fTime);
700 while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
701 UShort_t charge = rowPt->fDigitData[digit].fCharge;
705 Write(comp,index,subindex,charge);
706 if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){
707 if(rowPt->fDigitData[digit].fTime +1 !=
708 rowPt->fDigitData[digit+1].fTime){
709 Write(comp,index,subindex,0);
710 UShort_t nzero = rowPt->fDigitData[digit+1].fTime -
711 (rowPt->fDigitData[digit].fTime +1);
712 Write(comp,index,subindex,nzero);
717 Write(comp,index,subindex,0);
718 Write(comp,index,subindex,0);
721 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
722 sizeof(AliHLTTPCDigitRowData);
723 Byte_t *bytePt =(Byte_t *) rowPt;
725 rowPt = (AliHLTTPCDigitRowData *) bytePt;
728 Write(comp,index,subindex,0);
729 return index * sizeof(UInt_t);
732 Int_t AliHLTTPCMemHandler::CompMemory2Memory(UInt_t nrow,
733 AliHLTTPCDigitRowData *data,UInt_t *comp, UInt_t& sz)
735 //Uncompress the run-length encoded data in memory pointed to by comp, and
739 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2Memory","Memory")
740 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
744 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2Memory","Memory")
745 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
750 AliHLTTPCDigitRowData *rowPt = data;
754 for(UInt_t i=0;i<nrow;i++){
756 UInt_t row =Read(comp,index,subindex);
759 UShort_t npad = Read(comp,index,subindex);
760 for(UShort_t p=0;p<npad;p++){
763 UShort_t pad = Read(comp,index,subindex);
764 if(Test(comp,index,subindex)==0){
765 Read(comp,index,subindex);
766 if( (time = Read(comp,index,subindex)) == 0 ){
771 while( (charge=Read(comp,index,subindex)) != 0){
772 if(time>=fEtaMinTimeBin[row]&&time<=fEtaMaxTimeBin[row])
773 //AddData(rowPt->fDigitData,ndigit,row,pad,time,charge);
774 //seems we are using this function... but dont know why
775 AddDataRandom(rowPt->fDigitData,ndigit,row,pad,time,charge);
778 UShort_t tshift = Read(comp,index,subindex);
779 if(tshift == 0) break;
783 rowPt->fNDigit = ndigit;
784 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
785 sizeof(AliHLTTPCDigitRowData);
786 Byte_t *bytePt =(Byte_t *) rowPt;
789 rowPt = (AliHLTTPCDigitRowData *) bytePt;
795 UInt_t AliHLTTPCMemHandler::GetCompMemorySize(UInt_t nrow,AliHLTTPCDigitRowData *data) const
797 //Return the size of RLE data, after compressing data.
800 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetCompMemorySize","Memory")
801 <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
804 AliHLTTPCDigitRowData *rowPt = data;
807 for(UInt_t i=0;i<nrow;i++){
812 for(Int_t d=0;d<200;d++) ddd[d]=0;
813 for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){
814 if(rowPt->fDigitData[dig].fPad <200){
815 ddd[rowPt->fDigitData[dig].fPad]++;
818 for(Int_t d=0;d<200;d++){
826 for(UShort_t pad=0;pad <= maxpad;pad++){
827 if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad)
830 // write zero if time != 0
831 if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
832 if(rowPt->fDigitData[digit].fTime>0){
837 while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
839 if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){
840 if(rowPt->fDigitData[digit].fTime +1 !=
841 rowPt->fDigitData[digit+1].fTime){
852 Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
853 sizeof(AliHLTTPCDigitRowData);
854 Byte_t *bytePt =(Byte_t *) rowPt;
856 rowPt = (AliHLTTPCDigitRowData *) bytePt;
860 return (index/3) * sizeof(UInt_t);
863 UInt_t AliHLTTPCMemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp) const
867 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetMemorySize","Memory")
868 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
876 for(UInt_t i=0;i<nrow;i++){
878 Read(comp,index,subindex);
879 UShort_t npad = Read(comp,index,subindex);
880 for(UShort_t p=0;p<npad;p++){
881 Read(comp,index,subindex);
882 if(Test(comp,index,subindex)==0){
883 Read(comp,index,subindex);
884 if(Read(comp,index,subindex)== 0) continue;
887 while(Read(comp,index,subindex)!=0) ndigit++;
888 if(Read(comp,index,subindex)==0) break;
891 Int_t size = sizeof(AliHLTTPCDigitData) * ndigit+
892 sizeof(AliHLTTPCDigitRowData);
899 UInt_t AliHLTTPCMemHandler::GetNRow(UInt_t *comp,UInt_t size)
903 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetNRow","Memory")
904 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
911 while(index<size-1){ //don't start with last word
914 Read(comp,index,subindex);
915 UShort_t npad = Read(comp,index,subindex);
916 for(UShort_t p=0;p<npad;p++){
917 Read(comp,index,subindex);
918 if(Test(comp,index,subindex)==0){
919 Read(comp,index,subindex);
920 if(Read(comp,index,subindex)==0)continue;
923 while(Read(comp,index,subindex)!=0) ndigit++;
924 if(Read(comp,index,subindex)==0) break;
928 if(index==size-1){ //last word
930 if(Read(comp,index,subindex)!=0) nrow++;
936 Bool_t AliHLTTPCMemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
939 //Write the RLE data in comp to the output file.
942 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","File")
943 <<"No Output File"<<ENDLOG;
947 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory")
948 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
952 size=GetMemorySize(nrow,comp);
954 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory")
955 <<"Memory size = 0 "<<ENDLOG;
958 UInt_t length = size/sizeof(UInt_t);
959 fwrite(&length,sizeof(UInt_t),1,fOutBinary);
960 fwrite(comp,size,1,fOutBinary);
964 Bool_t AliHLTTPCMemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp)
966 //Read the RLE data from file, and store it in comp. No unpacking yet.
969 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompBinary2CompMemory","File")
970 <<"No Output File"<<ENDLOG;
974 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompBinary2CompMemory","Memory")
975 <<"Pointer to compressed data = 0x0 "<<ENDLOG;
980 if(fread(&length,sizeof(UInt_t),1,fInBinary)!=1) return kFALSE;
981 UInt_t size = length*sizeof(UInt_t);
982 if(fread(comp,size,1,fInBinary)!=1) return kFALSE;
983 // now find the number of dig
984 nrow = GetNRow(comp,size);
988 AliHLTTPCDigitRowData *AliHLTTPCMemHandler::CompBinary2Memory(UInt_t & nrow, UInt_t& sz )
990 // Read the RLE inputfile, unpack it and return the pointer to it.
991 AliHLTTPCMemHandler * handler = new AliHLTTPCMemHandler();
992 handler->SetBinaryInput(fInBinary);
993 UInt_t *comp =(UInt_t *)handler->Allocate();
994 handler->CompBinary2CompMemory(nrow,comp);
995 UInt_t size = GetMemorySize(nrow,comp);
997 AliHLTTPCDigitRowData *data = (AliHLTTPCDigitRowData *)Allocate(size);
998 CompMemory2Memory(nrow,data,comp);
1004 Bool_t AliHLTTPCMemHandler::Memory2CompBinary(UInt_t nrow,AliHLTTPCDigitRowData *data)
1006 //Perform RLE on the data, and write it to the output file.
1008 AliHLTTPCMemHandler * handler = new AliHLTTPCMemHandler();
1009 UInt_t size = GetCompMemorySize(nrow,data);
1010 UInt_t *comp =(UInt_t *)handler->Allocate(size);
1011 Memory2CompMemory(nrow,data,comp);
1012 CompMemory2CompBinary(nrow,comp,size);
1019 ///////////////////////////////////////// Point IO
1020 Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t npoint,AliHLTTPCSpacePointData *data)
1022 //Writing spacepoints stored in data to the outputfile.
1024 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
1025 <<"No Output File"<<ENDLOG;
1029 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
1030 <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
1033 UInt_t size = npoint*sizeof(AliHLTTPCSpacePointData);
1034 fwrite(data,size,1,fOutBinary);
1039 Bool_t AliHLTTPCMemHandler::Transform(UInt_t npoint,AliHLTTPCSpacePointData *data,Int_t slice)
1041 //Transform the space points in data, to global coordinates in slice.
1043 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Transform","Memory")
1044 <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
1048 for(UInt_t i=0;i<npoint;i++){
1050 xyz[0] = data[i].fX;
1051 xyz[1] = data[i].fY;
1052 xyz[2] = data[i].fZ;
1053 AliHLTTPCTransform::Local2Global(xyz,slice);
1054 data[i].fX = xyz[0];
1055 data[i].fY = xyz[1];
1056 data[i].fZ = xyz[2];
1061 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & npoint,AliHLTTPCSpacePointData *data, UInt_t& sz)
1063 //Read the space points in inputfile, and store it in data.
1065 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1066 <<"No Input File"<<ENDLOG;
1070 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
1071 <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
1075 Int_t size = GetFileSize();
1077 npoint = size/sizeof(AliHLTTPCSpacePointData);
1079 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1080 <<"File Size == 0"<<ENDLOG;
1084 if(fread(data,size,1,fInBinary)!=1){
1085 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","File")
1086 <<"File Read Error "<<ENDLOG;
1089 if(size%sizeof(AliHLTTPCSpacePointData)){
1090 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","File Size")
1091 <<"File Size wrong "<<ENDLOG;
1094 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","File")
1095 <<AliHLTTPCLog::kDec<<"Wrote "<<size<<" Bytes to Memory"<<ENDLOG;
1099 ///////////////////////////////////////// Track IO
1100 Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t ntrack,AliHLTTPCTrackSegmentData *data)
1102 //Write the tracks stored in data, to outputfile.
1104 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
1105 <<"No Output File"<<ENDLOG;
1109 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
1110 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1113 AliHLTTPCTrackSegmentData *trackPt = data;
1114 for(UInt_t i=0;i<ntrack;i++){
1115 Int_t size=sizeof(AliHLTTPCTrackSegmentData)+trackPt->fNPoints*sizeof(UInt_t);
1116 fwrite(trackPt,size,1,fOutBinary);
1117 Byte_t *bytePt = (Byte_t*) trackPt;
1119 trackPt = (AliHLTTPCTrackSegmentData*) bytePt;
1121 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","File")
1122 <<AliHLTTPCLog::kDec<<"Wrote "<<ntrack<<" Tracks to File"<<ENDLOG;
1127 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & ntrack,AliHLTTPCTrackSegmentData *data)
1129 //Read the tracks in inputfile, and store it in data.
1131 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1132 <<"No Input File"<<ENDLOG;
1136 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
1137 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1142 AliHLTTPCTrackSegmentData *trackPt = data;
1145 while(!feof(fInBinary)){
1146 if(fread(trackPt,sizeof(AliHLTTPCTrackSegmentData),1,fInBinary)!=1) break;
1147 Int_t size=trackPt->fNPoints*sizeof(UInt_t);
1148 if(fread(trackPt->fPointIDs,size,1,fInBinary)!=1) break;
1149 Byte_t *bytePt = (Byte_t*) trackPt;
1150 bytePt += sizeof(AliHLTTPCTrackSegmentData)+size;
1151 trackPt = (AliHLTTPCTrackSegmentData*) bytePt;
1154 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","File")
1155 <<AliHLTTPCLog::kDec<<"Wrote "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1159 Bool_t AliHLTTPCMemHandler::TrackArray2Binary(AliHLTTPCTrackArray *array)
1161 //Write the trackarray to the outputfile.
1163 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Binary","File")
1164 <<"No Output File"<<ENDLOG;
1168 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Binary","Memory")
1169 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1172 AliHLTTPCTrackSegmentData *data = (AliHLTTPCTrackSegmentData *)Allocate(array);
1175 TrackArray2Memory(ntrack,data,array);
1176 Memory2Binary(ntrack,data);
1181 Bool_t AliHLTTPCMemHandler::Binary2TrackArray(AliHLTTPCTrackArray *array)
1183 //Read the tracks in inputfile, and fill it in trackarray.
1184 //array should already be constructed.
1186 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2TrackArray","File")
1187 <<"No Input File"<<ENDLOG;
1191 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2TrackArray","Memory")
1192 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1195 AliHLTTPCTrackSegmentData *data = (AliHLTTPCTrackSegmentData *)Allocate();
1197 Binary2Memory(ntrack,data);
1198 Memory2TrackArray(ntrack,data,array);
1203 Bool_t AliHLTTPCMemHandler::TrackArray2Memory(UInt_t & ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array) const
1205 //Fill the trackarray into the AliTrackSegmentData structures before writing to outputfile.
1207 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Memory","Memory")
1208 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1212 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Memory","Memory")
1213 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1217 array->WriteTracks(ntrack,data);
1221 Bool_t AliHLTTPCMemHandler::Memory2TrackArray(UInt_t ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array) const
1223 //Fill the tracks in data into trackarray.
1226 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1227 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1231 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1232 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1235 array->FillTracks(ntrack,data);
1239 Bool_t AliHLTTPCMemHandler::Memory2TrackArray(UInt_t ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array,Int_t slice) const
1241 //Fill the tracks in data into trackarray, and rotate the tracks to global coordinates.
1244 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1245 <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1249 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1250 <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1253 array->FillTracks(ntrack,data,slice);
1257 void AliHLTTPCMemHandler::UpdateRowPointer(AliHLTTPCDigitRowData *&tempPt)
1259 //Update the data pointer to the next padrow in memory.
1261 Byte_t *tmp = (Byte_t*)tempPt;
1262 Int_t size = sizeof(AliHLTTPCDigitRowData) + tempPt->fNDigit*sizeof(AliHLTTPCDigitData);
1264 tempPt = (AliHLTTPCDigitRowData*)tmp;
1267 Int_t AliHLTTPCMemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const
1269 //compare two points
1270 if(fNUsed>=fNDigits) return -2;
1272 if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0;
1274 if(pad<fDPt[fNUsed]->fPad) return -1;
1275 if(pad==fDPt[fNUsed]->fPad&&time<fDPt[fNUsed]->fTime) return -1;
1280 Int_t AliHLTTPCMemHandler::CompareDigits(AliHLTTPCRandomDigitData *a,AliHLTTPCRandomDigitData *b) const
1282 //compare two digits
1283 if(a->fPad==b->fPad && a->fTime == b->fTime) return 0;
1285 if(a->fPad<b->fPad) return -1;
1286 if(a->fPad==b->fPad && a->fTime<b->fTime) return -1;