HLT/TPCLib/AliHLTTPCMemHandler.cxx

   1 // @(#) $Id$
   2 // Original: AliHLTMemHandler.cxx,v 1.52 2005/06/14 10:55:21 cvetan
   3
   4 //**************************************************************************
   5 //* This file is property of and copyright by the ALICE HLT Project        *
   6 //* ALICE Experiment at CERN, All rights reserved.                         *
   7 //*                                                                        *
   8 //* Primary Authors: U. Frankenfeld, A. Vestbo, C. Loizides                *
   9 //*                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
  10 //*                  for The ALICE HLT Project.                            *
  11 //*                                                                        *
  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 //**************************************************************************
  20
  21 //  @file   AliHLTTPCMemHandler.cxx
  22 //  @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by
  23 //          Matthias Richter
  24 //  @date
  25 //  @brief  input interface base class for the TPC tracking code before
  26 //          migration to the HLT component framework
  27
  28 #include <cassert>
  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"
  37 #include "TMath.h"
  38
  39 #if __GNUC__ >= 3
  40 using namespace std;
  41 #endif
  42
  43 ClassImp(AliHLTTPCMemHandler)
  44
  45 AliHLTTPCMemHandler::AliHLTTPCMemHandler()
  46   :
  47   fRowMin(0),
  48   fRowMax(0),
  49   fSlice(0),
  50   fPatch(0),
  51   fInBinary(NULL),
  52   fOutBinary(NULL),
  53   fPt(NULL),
  54   fSize(0),
  55   fIsRandom(kFALSE),
  56   fNRandom(0),
  57   fNGenerate(0),
  58   fNUsed(0),
  59   fNDigits(0),
  60   fDPt(NULL),
  61   fRandomDigits(NULL),
  62   fDummy(0)
  63 {
  64   //Constructor
  65   Init(0,0);
  66   ResetROI();
  67 }
  68
  69 AliHLTTPCMemHandler::~AliHLTTPCMemHandler()
  70 {
  71   //Destructor
  72   if(fPt) delete[] fPt;
  73   if(fRandomDigits) delete [] fRandomDigits;
  74   if(fDPt) delete [] fDPt;
  75 }
  76
  77 void AliHLTTPCMemHandler::Init(Int_t s,Int_t p, Int_t *r)
  78 {
  79   //init handler
  80   assert(s<fgkNSlice);
  81   if (s>fgkNSlice) {
  82     fSlice=0;
  83     fPatch=0;
  84     fRowMin=0;
  85     fRowMax=0;
  86     if (r) *r=0;
  87     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Init","sector coordinates")
  88       <<"Invalid slice no " << s <<ENDLOG;
  89     return;
  90   }
  91   fSlice=s;fPatch=p;
  92   if(r) {
  93     fRowMin=r[0];
  94     fRowMax=r[1];
  95   }else{
  96      fRowMin=AliHLTTPCTransform::GetFirstRow(p);
  97      fRowMax=AliHLTTPCTransform::GetLastRow(p);
  98   }
  99   ResetROI();
 100 }
 101
 102 void AliHLTTPCMemHandler::ResetROI()
 103 {
 104   //Resets the Look-up table for Region of Interest mode.
 105   for(Int_t i=fRowMin; i<=fRowMax; i++)
 106     {
 107       fEtaMinTimeBin[i] = 0;
 108       fEtaMaxTimeBin[i] = AliHLTTPCTransform::GetNTimeBins()-1;
 109     }
 110 }
 111
 112 void AliHLTTPCMemHandler::SetROI(const Float_t *eta,Int_t */*slice*/)
 113 {
 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
 121
 122
 123   if(TMath::Abs(eta[1])<.00001)
 124     {
 125       LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetROI","Eta Values")
 126         <<"Bad ROI parameters."<<ENDLOG;
 127       for(Int_t i=fRowMin; i<=fRowMax; i++)
 128         {
 129           fEtaMinTimeBin[i]=0;
 130           fEtaMaxTimeBin[i]=0;
 131         }
 132       return;
 133     }
 134
 135   for(Int_t i=fRowMin; i<=fRowMax; i++)
 136     {
 137       Int_t sector,row;
 138       Float_t xyz[3];
 139
 140       Float_t thetamax = 2*atan(exp(-1.*eta[1]));
 141
 142       xyz[0] = AliHLTTPCTransform::Row2X(i);
 143       xyz[1]=0;
 144       xyz[2] = xyz[0]/tan(thetamax);
 145       AliHLTTPCTransform::Slice2Sector(fSlice,i,sector,row);
 146       AliHLTTPCTransform::Local2Raw(xyz,sector,row);
 147
 148       fEtaMinTimeBin[i] = (Int_t)xyz[2];
 149
 150       if(TMath::Abs(eta[0])<.00001)
 151         fEtaMaxTimeBin[i] = 445;
 152       else
 153         {
 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];
 161         }
 162     }
 163
 164 }
 165
 166 Bool_t AliHLTTPCMemHandler::SetBinaryInput(char *name)
 167 {
 168   //Set the input binary file.
 169   fInBinary = fopen(name,"r");
 170   if(!fInBinary){
 171     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open")
 172       <<"Error opening file "<<name<<ENDLOG;
 173     return kFALSE;
 174   }
 175   return kTRUE;
 176 }
 177
 178 Bool_t AliHLTTPCMemHandler::SetBinaryInput(FILE *file)
 179 {
 180   //Set the input binary file.
 181   fInBinary = file;
 182   if(!fInBinary){
 183     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open")
 184     <<"Pointer to File = 0x0 "<<ENDLOG;
 185     return kFALSE;
 186   }
 187   return kTRUE;
 188 }
 189
 190 void AliHLTTPCMemHandler::CloseBinaryInput()
 191 {
 192   //Close the input file.
 193   if(!fInBinary){
 194     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryInput","File Close")
 195       <<"Nothing to Close"<<ENDLOG;
 196     return;
 197   }
 198   fclose(fInBinary);
 199   fInBinary =0;
 200 }
 201
 202 Bool_t AliHLTTPCMemHandler::SetBinaryOutput(char *name)
 203 {
 204   //Set the binary output file.
 205     fOutBinary = fopen(name,"w");
 206   if(!fOutBinary){
 207     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open")
 208       <<"Pointer to File = 0x0 "<<ENDLOG;
 209     return kFALSE;
 210   }
 211   return kTRUE;
 212 }
 213
 214 Bool_t AliHLTTPCMemHandler::SetBinaryOutput(FILE *file)
 215 {
 216   //Set the binary output file.
 217     fOutBinary = file;
 218   if(!fOutBinary){
 219     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open")
 220       <<"Pointer to File = 0x0 "<<ENDLOG;
 221     return kFALSE;
 222   }
 223   return kTRUE;
 224 }
 225
 226 void AliHLTTPCMemHandler::CloseBinaryOutput()
 227 {
 228   //close binary
 229   if(!fOutBinary){
 230     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryOutPut","File Close")
 231       <<"Nothing to Close"<<ENDLOG;
 232     return;
 233   }
 234   fclose(fOutBinary);
 235   fOutBinary =0;
 236 }
 237
 238 UInt_t AliHLTTPCMemHandler::GetFileSize()
 239 {
 240   //Returns the file size in bytes of the input file.
 241   if(!fInBinary){
 242     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetFileSize","File")
 243       <<"No Input File"<<ENDLOG;
 244     return 0;
 245   }
 246   fseek(fInBinary,0,SEEK_END);
 247   UInt_t size = (UInt_t) ftell(fInBinary);
 248   rewind(fInBinary);
 249   return size;
 250 }
 251
 252 Byte_t *AliHLTTPCMemHandler::Allocate()
 253 {
 254   //Allocate
 255   return Allocate(GetFileSize());
 256 }
 257
 258 Byte_t *AliHLTTPCMemHandler::Allocate(AliHLTTPCTrackArray *array)
 259 {
 260   //Allocate memory for tracks in memory. Used by TrackArray2Binary()
 261   if(!array){
 262     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory")
 263       <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
 264     return 0;
 265   }
 266   return Allocate(array->GetOutSize());
 267 }
 268
 269 Byte_t *AliHLTTPCMemHandler::Allocate(UInt_t size)
 270 {
 271   //Allocate memory of size in bytes.
 272   if(fPt){
 273     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory")
 274       <<"Delete Memory"<<ENDLOG;
 275     Free();
 276   }
 277   fPt = new Byte_t[size];
 278   fSize = size;
 279   memset(fPt,0,fSize);
 280   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Allocate","Memory")
 281   <<AliHLTTPCLog::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG;
 282   return fPt;
 283 }
 284
 285 void AliHLTTPCMemHandler::Free()
 286 {
 287   //Clear the memory, if allocated.
 288   if(!fPt){
 289     //    LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMemHandler::Free","Memory")
 290     //      <<"No Memory allocated - can't Free"<<ENDLOG;
 291     return;
 292   }
 293   delete[] fPt;
 294   fPt = 0;
 295   fSize =0;
 296 }
 297
 298 ///////////////////////////////////////// Random
 299 void AliHLTTPCMemHandler::SetRandomSeed()
 300 {
 301   //If you are adding random data to the original data.
 302   time_t *tp=0;
 303   SetRandomSeed(time(tp));
 304 }
 305
 306 void AliHLTTPCMemHandler::SetRandomCluster(Int_t maxnumber)
 307 {
 308   //If you are adding random data to the original data.
 309
 310   fIsRandom = kTRUE;
 311   fNRandom = maxnumber;
 312   fNDigits = 0;
 313   if(fRandomDigits) delete [] fRandomDigits;
 314   fRandomDigits = new AliHLTTPCRandomDigitData[fNRandom*9];
 315   if(fDPt) delete [] fDPt;
 316   fDPt = new AliHLTTPCRandomDigitData *[fNRandom*9];
 317 }
 318
 319 void AliHLTTPCMemHandler::QSort(AliHLTTPCRandomDigitData **a, Int_t first, Int_t last)
 320 {
 321
 322    // Sort array of AliHLTTPCRandomDigitData pointers using a quicksort algorithm.
 323    // Uses CompareDigits() to compare objects.
 324    // Thanks to Root!
 325
 326    static AliHLTTPCRandomDigitData *tmp;
 327    static int i;           // "static" to save stack space
 328    int j;
 329
 330    while (last - first > 1) {
 331       i = first;
 332       j = last;
 333       for (;;) {
 334          while (++i < last && CompareDigits(a[i], a[first]) < 0)
 335             ;
 336          while (--j > first && CompareDigits(a[j], a[first]) > 0)
 337             ;
 338          if (i >= j)
 339             break;
 340
 341          tmp  = a[i];
 342          a[i] = a[j];
 343          a[j] = tmp;
 344       }
 345       if (j == first) {
 346          ++first;
 347          continue;
 348       }
 349       tmp = a[first];
 350       a[first] = a[j];
 351       a[j] = tmp;
 352
 353       if (j - first < last - (j + 1)) {
 354         QSort(a, first, j);
 355         first = j + 1;   // QSort(j + 1, last);
 356       } else {
 357         QSort(a, j + 1, last);
 358         last = j;        // QSort(first, j);
 359       }
 360    }
 361 }
 362
 363 UInt_t AliHLTTPCMemHandler::GetRandomSize() const
 364 {
 365   //get random size
 366   Int_t nrandom = 0;
 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.));
 370   }
 371   return 9 * nrandom * sizeof(AliHLTTPCDigitData);
 372 }
 373
 374 void AliHLTTPCMemHandler::Generate(Int_t row)
 375 {
 376   //Generate random data on row, if you didn't
 377   //ask for this, nothing happens here.
 378
 379   if(!fIsRandom) return;
 380   ResetRandom();
 381   fNDigits = 0;
 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() );
 386
 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);
 392   }
 393   QSort(fDPt,0,fNDigits);
 394 }
 395
 396
 397 void AliHLTTPCMemHandler::DigitizePoint(Int_t row, Int_t pad,
 398                                     Int_t time,Int_t charge)
 399 {
 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;
 404       if(j) dcharge /=2;
 405       if(k) dcharge /=2;
 406       if(dcharge<10) continue;
 407       Int_t dpad  = j + pad;
 408       Int_t dtime = k + time;
 409
 410       if(dpad<0||dpad>=AliHLTTPCTransform::GetNPads(row))  continue;
 411       if(dtime<0||dtime>=AliHLTTPCTransform::GetNTimeBins()) continue;
 412
 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];
 418       fNDigits++;
 419     }
 420   }
 421 }
 422
 423 ///////////////////////////////////////// Digit IO
 424 Bool_t AliHLTTPCMemHandler::Memory2BinaryFile(UInt_t nrow,AliHLTTPCDigitRowData *data)
 425 {
 426   //Write data to the outputfile as is. No run-length encoding is done.
 427
 428   if(!fOutBinary){
 429     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
 430       <<"No Output File"<<ENDLOG;
 431     return kFALSE;
 432   }
 433   if(!data){
 434     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
 435       <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
 436     return kFALSE;
 437   }
 438
 439   AliHLTTPCDigitRowData *rowPt = data;
 440   Int_t outsize = 0;
 441   for(UInt_t i=0;i<nrow;i++){
 442     Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit
 443       + sizeof(AliHLTTPCDigitRowData);
 444     outsize += size;
 445     fwrite(rowPt,size,1,fOutBinary);
 446     Byte_t  *bytePt =(Byte_t *) rowPt;
 447     bytePt += size;
 448     rowPt = (AliHLTTPCDigitRowData *) bytePt;
 449   }
 450   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","Memory")
 451     <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
 452     <<nrow<<" Rows)"<<ENDLOG;
 453   return kTRUE;
 454 }
 455
 456 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & nrow,AliHLTTPCDigitRowData *data,UInt_t& sz)
 457 {
 458   //Read inputfile into memory as is, and store it in data.
 459   // No run-length encoding is assumed.
 460
 461   if(!fInBinary){
 462     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
 463       <<"No Input File"<<ENDLOG;
 464     return kFALSE;
 465   }
 466   if(!data){
 467     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
 468       <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
 469     return kFALSE;
 470   }
 471   rewind(fInBinary);
 472   AliHLTTPCDigitRowData *rowPt = data;
 473   UInt_t rowcount = 0;
 474   UInt_t outsize =0;
 475   while(!feof(fInBinary)){
 476     Byte_t  *bytePt =(Byte_t *) rowPt;
 477
 478     if (sz<outsize+sizeof(AliHLTTPCDigitRowData)) {
 479       LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
 480         << "target data buffer too small" <<ENDLOG;
 481       return kFALSE;
 482     }
 483     if(fread(rowPt,sizeof(AliHLTTPCDigitRowData),1,fInBinary)!=1) break;
 484
 485     bytePt += sizeof(AliHLTTPCDigitRowData);
 486     outsize += sizeof(AliHLTTPCDigitRowData);
 487
 488     UInt_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit;
 489
 490     if (sz<outsize+size) {
 491       LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","Memory")
 492         << "target data buffer too small" <<ENDLOG;
 493       return kFALSE;
 494     }
 495     //if(fread(bytePt,size,1,fInBinary)!=1) break;
 496     fread(bytePt,size,1,fInBinary);
 497     bytePt += size;
 498     outsize += size;
 499     rowPt = (AliHLTTPCDigitRowData *) bytePt;
 500     rowcount++;
 501   }
 502   nrow= rowcount;
 503     LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","Memory")
 504     <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory ("
 505     <<rowcount<<" Rows)"<<ENDLOG;
 506   sz = outsize;
 507   return kTRUE;
 508 }
 509
 510 void AliHLTTPCMemHandler::AddData(AliHLTTPCDigitData *data,UInt_t & ndata,
 511                               UInt_t /*row*/,UShort_t pad,UShort_t time,UShort_t charge) const
 512 {
 513   //add some data
 514   data[ndata].fPad = pad;
 515   data[ndata].fTime = time;
 516   data[ndata].fCharge = charge;
 517   ndata++;
 518 }
 519
 520 void AliHLTTPCMemHandler::AddRandom(AliHLTTPCDigitData *data, UInt_t & ndata)
 521 {
 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;
 526   ndata++;
 527   fNUsed++;
 528 }
 529
 530 void AliHLTTPCMemHandler::MergeDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata,
 531                                       UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
 532 {
 533   //merge random data
 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;
 541     fNUsed++;
 542   }
 543   ndata++;
 544 }
 545
 546 void AliHLTTPCMemHandler::AddDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata,
 547                    UInt_t row, UShort_t pad, UShort_t time, UShort_t charge)
 548 {
 549   //add data random
 550   Int_t action;
 551   while((action=ComparePoints(row,pad,time))==1){
 552     AddRandom(data,ndata);
 553   }
 554   if(action==0){
 555     MergeDataRandom(data,ndata,row,pad,time,charge);
 556   }
 557   if(action<0){
 558     AddData(data,ndata,row,pad,time,charge);
 559   }
 560 }
 561
 562 void AliHLTTPCMemHandler::Write(UInt_t *comp, UInt_t & index,
 563                             UInt_t & subindex, UShort_t value) const
 564 {
 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];
 569   if(subindex == 2){
 570     subindex = 0;
 571     index++;
 572   }
 573   else subindex++;
 574 }
 575
 576 UShort_t AliHLTTPCMemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const
 577 {
 578   //read compressed data
 579   UInt_t shift[3] = {0,10,20};
 580   UShort_t value = (comp[index]>>shift[subindex])&0x03ff;
 581   if(subindex == 2){
 582     subindex = 0;
 583     index++;
 584   }
 585   else subindex++;
 586
 587   return value;
 588 }
 589
 590 UShort_t AliHLTTPCMemHandler::Test(const UInt_t *comp,
 591                                UInt_t index, UInt_t  subindex) const
 592 {
 593   //supi dupi test
 594   UInt_t shift[3] = {0,10,20};
 595   return (comp[index]>>shift[subindex])&0x03ff;
 596 }
 597
 598 Int_t AliHLTTPCMemHandler::Memory2CompMemory(UInt_t nrow,
 599                                          AliHLTTPCDigitRowData *data,UInt_t *comp)
 600 {
 601   //Performs run-length encoding on data stored in memory pointed to by data.
 602   //The compressed data is written to comp.
 603   if(!comp){
 604     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory")
 605       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 606     return 0;
 607   }
 608   if(!data){
 609     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory")
 610       <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
 611     return 0;
 612   }
 613   AliHLTTPCDigitRowData *rowPt = data;
 614   UInt_t index=0;
 615   UInt_t subindex=0;
 616
 617   for(UInt_t i=0;i<nrow;i++){
 618     UShort_t value = rowPt->fRow;
 619     Write(comp,index,subindex,value);
 620     UShort_t maxpad=0;
 621     UShort_t npad=0;
 622     Int_t ddd[1000];
 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]++;
 627       }
 628     }
 629     for(Int_t d=0;d<200;d++){
 630       if(ddd[d]){
 631         npad++;
 632         maxpad =d;
 633       }
 634     }
 635     Write(comp,index,subindex,npad);
 636     UInt_t digit=0;
 637     for(UShort_t pad=0;pad <= maxpad;pad++){
 638       if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad !=  pad)
 639         continue;
 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);
 646         }
 647       }
 648       while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
 649         UShort_t charge = rowPt->fDigitData[digit].fCharge;
 650         if(charge>=1023){
 651           charge=1023;
 652         }
 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);
 661           }
 662         }
 663         digit++;
 664       }
 665       Write(comp,index,subindex,0);
 666       Write(comp,index,subindex,0);
 667     }
 668
 669     Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
 670                                             sizeof(AliHLTTPCDigitRowData);
 671     Byte_t  *bytePt =(Byte_t *) rowPt;
 672     bytePt += size;
 673     rowPt = (AliHLTTPCDigitRowData *) bytePt;
 674   }
 675   while(subindex)
 676     Write(comp,index,subindex,0);
 677   return index * sizeof(UInt_t);
 678 }
 679
 680 Int_t AliHLTTPCMemHandler::CompMemory2Memory(UInt_t  nrow,
 681                                              AliHLTTPCDigitRowData *data,UInt_t *comp, UInt_t& sz)
 682 {
 683   //Uncompress the run-length encoded data in memory pointed to by comp, and
 684   //  store it in data.
 685
 686   if(!comp){
 687     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2Memory","Memory")
 688       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 689     return 0;
 690   }
 691   if(!data){
 692     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2Memory","Memory")
 693       <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
 694     return 0;
 695   }
 696   Int_t outsize=0;
 697
 698   AliHLTTPCDigitRowData *rowPt = data;
 699   UInt_t index=0;
 700   UInt_t subindex=0;
 701
 702   for(UInt_t i=0;i<nrow;i++){
 703     UInt_t ndigit=0;
 704     UInt_t row =Read(comp,index,subindex);
 705     rowPt->fRow=row;
 706     Generate(row);
 707     UShort_t npad = Read(comp,index,subindex);
 708     for(UShort_t p=0;p<npad;p++){
 709       UShort_t charge;
 710       UShort_t time =0;
 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 ){
 715           continue;
 716         }
 717       }
 718       for(;;){
 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);
 724           time++;
 725         }
 726         UShort_t tshift = Read(comp,index,subindex);
 727         if(tshift == 0) break;
 728         time += tshift;
 729       }
 730     }
 731     rowPt->fNDigit = ndigit;
 732     Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
 733       sizeof(AliHLTTPCDigitRowData);
 734     Byte_t  *bytePt =(Byte_t *) rowPt;
 735     bytePt += size;
 736     outsize += size;
 737     rowPt = (AliHLTTPCDigitRowData *) bytePt;
 738   }
 739   sz = outsize;
 740   return outsize;
 741 }
 742
 743 UInt_t AliHLTTPCMemHandler::GetCompMemorySize(UInt_t nrow,AliHLTTPCDigitRowData *data) const
 744 {
 745   //Return the size of RLE data, after compressing data.
 746
 747   if(!data){
 748     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetCompMemorySize","Memory")
 749       <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG;
 750     return 0;
 751   }
 752   AliHLTTPCDigitRowData *rowPt = data;
 753   UInt_t index=0;
 754
 755   for(UInt_t i=0;i<nrow;i++){
 756     index++;
 757     UShort_t maxpad=0;
 758     UShort_t npad=0;
 759     Int_t ddd[1000];
 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]++;
 764       }
 765     }
 766     for(Int_t d=0;d<200;d++){
 767       if(ddd[d]){
 768         npad++;
 769         maxpad =d;
 770       }
 771     }
 772     index++;
 773     UInt_t digit=0;
 774     for(UShort_t pad=0;pad <= maxpad;pad++){
 775       if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad !=  pad)
 776         continue;
 777       index++;
 778       //    write zero if time != 0
 779       if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
 780         if(rowPt->fDigitData[digit].fTime>0){
 781           index++;
 782           index++;
 783         }
 784       }
 785       while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){
 786         index++;
 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){
 790             index++;
 791             index++;
 792           }
 793         }
 794         digit++;
 795       }
 796       index++;
 797       index++;
 798     }
 799
 800     Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+
 801                                             sizeof(AliHLTTPCDigitRowData);
 802     Byte_t  *bytePt =(Byte_t *) rowPt;
 803     bytePt += size;
 804     rowPt = (AliHLTTPCDigitRowData *) bytePt;
 805   }
 806   while(index%3)
 807     index++;
 808   return (index/3) * sizeof(UInt_t);
 809 }
 810
 811 UInt_t AliHLTTPCMemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp) const
 812 {
 813   //get memory size
 814   if(!comp){
 815     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetMemorySize","Memory")
 816     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 817     return 0;
 818   }
 819   Int_t outsize=0;
 820
 821   UInt_t index=0;
 822   UInt_t subindex=0;
 823
 824   for(UInt_t i=0;i<nrow;i++){
 825     UInt_t ndigit=0;
 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;
 833       }
 834       for(;;){
 835         while(Read(comp,index,subindex)!=0) ndigit++;
 836         if(Read(comp,index,subindex)==0) break;
 837       }
 838     }
 839     Int_t size = sizeof(AliHLTTPCDigitData) * ndigit+
 840                                         sizeof(AliHLTTPCDigitRowData);
 841     outsize += size;
 842   }
 843
 844   return outsize;
 845 }
 846
 847 UInt_t AliHLTTPCMemHandler::GetNRow(UInt_t *comp,UInt_t size)
 848 {
 849   //get number of rows
 850   if(!comp){
 851     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetNRow","Memory")
 852       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 853     return 0;
 854   }
 855   size = size /4;
 856   UInt_t nrow=0;
 857   UInt_t index=0;
 858   UInt_t subindex=0;
 859   while(index<size-1){ //don't start with last word
 860     nrow++;
 861     UInt_t ndigit=0;
 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;
 869       }
 870       for(;;){
 871         while(Read(comp,index,subindex)!=0) ndigit++;
 872         if(Read(comp,index,subindex)==0) break;
 873       }
 874     }
 875   }
 876   if(index==size-1){  //last word
 877     if(subindex<2){
 878       if(Read(comp,index,subindex)!=0) nrow++;
 879     }
 880   }
 881   return nrow;
 882 }
 883
 884 Bool_t AliHLTTPCMemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp,
 885                                               UInt_t size)
 886 {
 887   //Write the RLE data in comp to the output file.
 888
 889   if(!fOutBinary){
 890     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","File")
 891     <<"No Output File"<<ENDLOG;
 892     return kFALSE;
 893   }
 894   if(!comp){
 895     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory")
 896     <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 897     return kFALSE;
 898   }
 899   if(size==0)
 900     size=GetMemorySize(nrow,comp);
 901   if(!size){
 902     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory")
 903     <<"Memory size = 0 "<<ENDLOG;
 904     return kFALSE;
 905   }
 906   UInt_t length = size/sizeof(UInt_t);
 907   fwrite(&length,sizeof(UInt_t),1,fOutBinary);
 908   fwrite(comp,size,1,fOutBinary);
 909   return kTRUE;
 910 }
 911
 912 Bool_t AliHLTTPCMemHandler::CompBinary2CompMemory(UInt_t & nrow,UInt_t *comp)
 913 {
 914   //Read the RLE data from file, and store it in comp. No unpacking yet.
 915
 916   if(!fInBinary){
 917     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompBinary2CompMemory","File")
 918       <<"No Output File"<<ENDLOG;
 919     return kFALSE;
 920   }
 921   if(!comp){
 922     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompBinary2CompMemory","Memory")
 923       <<"Pointer to compressed data = 0x0 "<<ENDLOG;
 924     return kFALSE;
 925   }
 926   rewind(fInBinary);
 927   UInt_t length;
 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);
 933   return kTRUE;
 934 }
 935
 936 AliHLTTPCDigitRowData *AliHLTTPCMemHandler::CompBinary2Memory(UInt_t & nrow, UInt_t& sz )
 937 {
 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);
 944   sz = size;
 945   AliHLTTPCDigitRowData *data = (AliHLTTPCDigitRowData *)Allocate(size);
 946   CompMemory2Memory(nrow,data,comp);
 947   handler->Free();
 948   delete handler;
 949   return data;
 950 }
 951
 952 Bool_t AliHLTTPCMemHandler::Memory2CompBinary(UInt_t nrow,AliHLTTPCDigitRowData *data)
 953 {
 954   //Perform RLE on the data, and write it to the output file.
 955   Bool_t out = kTRUE;
 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);
 961   handler->Free();
 962   delete handler;
 963   return out;
 964 }
 965
 966
 967 ///////////////////////////////////////// Point IO
 968 Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t npoint,AliHLTTPCSpacePointData *data)
 969 {
 970   //Writing spacepoints stored in data to the outputfile.
 971   if(!fOutBinary){
 972     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
 973       <<"No Output File"<<ENDLOG;
 974     return kFALSE;
 975   }
 976   if(!data){
 977     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
 978       <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
 979     return kFALSE;
 980   }
 981   UInt_t size = npoint*sizeof(AliHLTTPCSpacePointData);
 982   fwrite(data,size,1,fOutBinary);
 983
 984   return kTRUE;
 985 }
 986
 987 Bool_t AliHLTTPCMemHandler::Transform(UInt_t npoint,AliHLTTPCSpacePointData *data,Int_t slice)
 988 {
 989   //Transform the space points in data, to global coordinates in slice.
 990   if(!data){
 991     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Transform","Memory")
 992     <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
 993     return kFALSE;
 994   }
 995
 996   for(UInt_t i=0;i<npoint;i++){
 997     Float_t xyz[3];
 998     xyz[0] = data[i].fX;
 999     xyz[1] = data[i].fY;
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];
1005   }
1006   return kTRUE;
1007 }
1008
1009 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & npoint,AliHLTTPCSpacePointData *data, UInt_t& sz)
1010 {
1011   //Read the space points in inputfile, and store it in data.
1012   if(!fInBinary){
1013     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1014     <<"No Input File"<<ENDLOG;
1015     return kFALSE;
1016   }
1017   if(!data){
1018     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
1019     <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG;
1020     return kFALSE;
1021   }
1022
1023   Int_t size = GetFileSize();
1024   sz = size;
1025   npoint = size/sizeof(AliHLTTPCSpacePointData);
1026   if(size==0) {
1027     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1028     <<"File Size == 0"<<ENDLOG;
1029     return kFALSE;
1030   }
1031
1032   if(fread(data,size,1,fInBinary)!=1){
1033     LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","File")
1034     <<"File Read Error "<<ENDLOG;
1035     return kFALSE;
1036   }
1037   if(size%sizeof(AliHLTTPCSpacePointData)){
1038     LOG(AliHLTTPCLog::kFatal,"AliHLTTPCMemHandler::Binary2Memory","File Size")
1039     <<"File Size wrong "<<ENDLOG;
1040     return kFALSE;
1041   }
1042   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","File")
1043   <<AliHLTTPCLog::kDec<<"Wrote  "<<size<<" Bytes to Memory"<<ENDLOG;
1044   return kTRUE;
1045 }
1046
1047 ///////////////////////////////////////// Track IO
1048 Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t ntrack,AliHLTTPCTrackSegmentData *data)
1049 {
1050   //Write the tracks stored in data, to outputfile.
1051   if(!fOutBinary){
1052     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File")
1053     <<"No Output File"<<ENDLOG;
1054     return kFALSE;
1055   }
1056   if(!data){
1057     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory")
1058     <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1059     return kFALSE;
1060   }
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;
1066     bytePt += size;
1067     trackPt = (AliHLTTPCTrackSegmentData*) bytePt;
1068   }
1069   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","File")
1070   <<AliHLTTPCLog::kDec<<"Wrote  "<<ntrack<<" Tracks to File"<<ENDLOG;
1071
1072   return kTRUE;
1073 }
1074
1075 Bool_t AliHLTTPCMemHandler::Binary2Memory(UInt_t & ntrack,AliHLTTPCTrackSegmentData *data)
1076 {
1077   //Read the tracks in inputfile, and store it in data.
1078   if(!fInBinary){
1079     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","File")
1080     <<"No Input File"<<ENDLOG;
1081     return kFALSE;
1082   }
1083   if(!data){
1084     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2Memory","Memory")
1085     <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1086     return kFALSE;
1087   }
1088
1089   ntrack=0;
1090   AliHLTTPCTrackSegmentData *trackPt = data;
1091   rewind(fInBinary);
1092
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;
1100     ntrack++;
1101   }
1102   LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Binary2Memory","File")
1103   <<AliHLTTPCLog::kDec<<"Wrote  "<<ntrack<<" Tracks to Memory"<<ENDLOG;
1104   return kTRUE;
1105 }
1106
1107 Bool_t AliHLTTPCMemHandler::TrackArray2Binary(AliHLTTPCTrackArray *array)
1108 {
1109   //Write the trackarray to the outputfile.
1110   if(!fOutBinary){
1111     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Binary","File")
1112     <<"No Output File"<<ENDLOG;
1113     return kFALSE;
1114   }
1115   if(!array){
1116     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Binary","Memory")
1117     <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1118     return kFALSE;
1119   }
1120   AliHLTTPCTrackSegmentData *data = (AliHLTTPCTrackSegmentData *)Allocate(array);
1121
1122   UInt_t ntrack;
1123   TrackArray2Memory(ntrack,data,array);
1124   Memory2Binary(ntrack,data);
1125   Free();
1126   return kTRUE;
1127 }
1128
1129 Bool_t AliHLTTPCMemHandler::Binary2TrackArray(AliHLTTPCTrackArray *array)
1130 {
1131   //Read the tracks in inputfile, and fill it in trackarray.
1132   //array should already be constructed.
1133   if(!fInBinary){
1134     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2TrackArray","File")
1135     <<"No Input File"<<ENDLOG;
1136     return kFALSE;
1137   }
1138   if(!array){
1139     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Binary2TrackArray","Memory")
1140     <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1141     return kFALSE;
1142   }
1143   AliHLTTPCTrackSegmentData *data = (AliHLTTPCTrackSegmentData *)Allocate();
1144   UInt_t ntrack;
1145   Binary2Memory(ntrack,data);
1146   Memory2TrackArray(ntrack,data,array);
1147   Free();
1148   return kTRUE;
1149 }
1150
1151 Bool_t AliHLTTPCMemHandler::TrackArray2Memory(UInt_t & ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array) const
1152 {
1153   //Fill the trackarray into the AliTrackSegmentData structures before writing to outputfile.
1154   if(!data){
1155     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Memory","Memory")
1156     <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1157     return kFALSE;
1158   }
1159   if(!array){
1160     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::TrackArray2Memory","Memory")
1161     <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1162     return kFALSE;
1163   }
1164
1165   array->WriteTracks(ntrack,data);
1166   return kTRUE;
1167 }
1168
1169 Bool_t AliHLTTPCMemHandler::Memory2TrackArray(UInt_t ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array) const
1170 {
1171   //Fill the tracks in data into trackarray.
1172
1173   if(!data){
1174     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1175     <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1176     return kFALSE;
1177   }
1178   if(!array){
1179     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1180     <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1181     return kFALSE;
1182   }
1183   array->FillTracks(ntrack,data);
1184   return kTRUE;
1185 }
1186
1187 Bool_t AliHLTTPCMemHandler::Memory2TrackArray(UInt_t ntrack,AliHLTTPCTrackSegmentData *data,AliHLTTPCTrackArray *array,Int_t slice) const
1188 {
1189   //Fill the tracks in data into trackarray, and rotate the tracks to global coordinates.
1190
1191   if(!data){
1192     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1193     <<"Pointer to AliHLTTPCTrackSegmentData = 0x0 "<<ENDLOG;
1194     return kFALSE;
1195   }
1196   if(!array){
1197     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2TrackArray","Memory")
1198     <<"Pointer to AliHLTTPCTrackArray = 0x0 "<<ENDLOG;
1199     return kFALSE;
1200   }
1201   array->FillTracks(ntrack,data,slice);
1202   return kTRUE;
1203 }
1204
1205 void AliHLTTPCMemHandler::UpdateRowPointer(AliHLTTPCDigitRowData *&tempPt)
1206 {
1207   //Update the data pointer to the next padrow in memory.
1208
1209   Byte_t *tmp = (Byte_t*)tempPt;
1210   Int_t size = sizeof(AliHLTTPCDigitRowData) + tempPt->fNDigit*sizeof(AliHLTTPCDigitData);
1211   tmp += size;
1212   tempPt = (AliHLTTPCDigitRowData*)tmp;
1213 }
1214
1215 Int_t  AliHLTTPCMemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const
1216 {
1217   //compare two points
1218   if(fNUsed>=fNDigits) return -2;
1219
1220   if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0;
1221
1222   if(pad<fDPt[fNUsed]->fPad) return -1;
1223   if(pad==fDPt[fNUsed]->fPad&&time<fDPt[fNUsed]->fTime)  return -1;
1224
1225   return 1;
1226 }
1227
1228 Int_t AliHLTTPCMemHandler::CompareDigits(const AliHLTTPCRandomDigitData *a,const AliHLTTPCRandomDigitData *b) const
1229 {
1230   //compare two digits
1231   if(a->fPad==b->fPad && a->fTime == b->fTime) return 0;
1232
1233   if(a->fPad<b->fPad) return -1;
1234   if(a->fPad==b->fPad && a->fTime<b->fTime) return -1;
1235
1236   return 1;
1237 }