HLT/comp/AliL3Compress.cxx

   1 //$Id$
   2
   3 // Author: Anders Vestbo <mailto:vestbo$fi.uib.no>
   4 //*-- Copyright &copy ASV
   5
   6 #include <stdio.h>
   7 #include <stream.h>
   8 #include <stdlib.h>
   9 #include <TH1.h>
  10 #include <TH2.h>
  11 #include <TRandom.h>
  12
  13 #include "AliL3Compress.h"
  14 #include "AliL3TrackArray.h"
  15 #include "AliL3ModelTrack.h"
  16 #include "AliL3Transform.h"
  17 #include "AliL3MemHandler.h"
  18 #ifdef use_aliroot
  19 #include "AliL3FileHandler.h"
  20 #endif
  21 #include "bitio.h"
  22
  23 //_____________________________________________________________
  24 //
  25 //  AliL3Compress
  26 //
  27 // Class for compressing and uncompressing data.
  28
  29 ClassImp(AliL3Compress)
  30
  31 AliL3Compress::AliL3Compress()
  32 {
  33   fTracks=0;
  34   SetBitNumbers(0,0,0,0);
  35   fSlice =0;
  36   fPatch=0;
  37   fDigits=0;
  38   fDPt=0;
  39 }
  40
  41 AliL3Compress::AliL3Compress(Int_t slice,Int_t patch,Char_t *path)
  42 {
  43   fSlice=slice;
  44   fPatch=patch;
  45   SetBitNumbers(0,0,0,0);
  46   fTracks=0;
  47   fDigits=0;
  48   fDPt=0;
  49   sprintf(fPath,"%s",path);
  50 }
  51
  52 AliL3Compress::~AliL3Compress()
  53 {
  54   if(fTracks)
  55     delete fTracks;
  56   if(fDigits)
  57     delete [] fDigits;
  58   if(fDPt)
  59     delete [] fDPt;
  60 }
  61
  62 void AliL3Compress::SetBitNumbers(Int_t pad,Int_t time,Int_t charge,Int_t shape)
  63 {
  64   fNumPadBits=pad;
  65   fNumTimeBits=time;
  66   fNumChargeBits=charge;
  67   fNumShapeBits=shape;
  68 }
  69
  70 void AliL3Compress::WriteFile(AliL3TrackArray *tracks)
  71 {
  72   Char_t fname[100];
  73   sprintf(fname,"%s/tracks_m_%d_%d.raw",fPath,fSlice,fPatch);
  74   FILE *file = fopen(fname,"w");
  75   Short_t ntracks = tracks->GetNTracks();
  76   //cout<<"Writing "<<ntracks<<" tracks to file"<<endl;
  77
  78   Int_t count=0;
  79   AliL3ClusterModel *clusters=0;
  80   AliL3TrackModel *model=0;
  81   for(Int_t i=0; i<ntracks; i++)
  82     {
  83       AliL3ModelTrack *track = (AliL3ModelTrack*)tracks->GetCheckedTrack(i);
  84       if(!track) continue;
  85
  86       //Do not save useless tracks or clusters:
  87       //if(track->CheckClustersQuality(2) == 0)
  88       //continue;
  89
  90       track->FillModel();
  91       model = track->GetModel();
  92       if(model->fNClusters==0) continue;
  93       clusters = track->GetClusters();
  94       //cout<<"Writing "<<(int)model->fNClusters<<" clusters"<<endl;
  95       if(fwrite(model,sizeof(AliL3TrackModel),1,file)!=1) break;
  96       //cout<<"Writing "<<(int)model->fNClusters<<" clusters to file"<<endl;
  97       if(fwrite(clusters,model->fNClusters*sizeof(AliL3ClusterModel),1,file)!=1) break;
  98       //track->Print();
  99       count++;
 100
 101     }
 102   cout<<"Wrote "<<count<<" tracks "<<endl;
 103   fclose(file);
 104 }
 105
 106 void AliL3Compress::ReadFile(Char_t which)
 107 {
 108   //Read the trackfile.
 109
 110   Char_t fname[100];
 111   if(which == 'm')
 112     sprintf(fname,"%s/tracks_m_%d_%d.raw",fPath,fSlice,fPatch);
 113   else if(which == 'u')
 114     sprintf(fname,"%s/tracks_u_%d_%d.raw",fPath,fSlice,fPatch);
 115   else
 116     {
 117       cerr<<"AliL3Compress::ReadFile() : Wrong option"<<endl;
 118       return;
 119     }
 120
 121   FILE *file = fopen(fname,"r");
 122   if(!file)
 123     {
 124       cerr<<"Cannot open file "<<fname<<endl;
 125       return;
 126     }
 127
 128   if(fTracks)
 129     delete fTracks;
 130   fTracks = new AliL3TrackArray("AliL3ModelTrack");
 131
 132   cout<<"Reading file "<<fname<<endl;
 133   while(!feof(file))
 134     {
 135       AliL3ModelTrack *track = (AliL3ModelTrack*)fTracks->NextTrack();
 136       track->Init(fSlice,fPatch);
 137       AliL3TrackModel *model = track->GetModel();
 138       AliL3ClusterModel *clusters = track->GetClusters();
 139       //cout<<"Reading model "<<(int)model<<endl;
 140       if(fread(model,sizeof(AliL3TrackModel),1,file)!=1) break;
 141       //cout<<"Reading clusters "<<(int)clusters<<endl;
 142       if(fread(clusters,(model->fNClusters)*sizeof(AliL3ClusterModel),1,file)!=1) break;
 143       //cout<<"Filling track"<<endl;
 144       track->FillTrack();
 145       //track->Print();
 146     }
 147
 148   fTracks->RemoveLast();
 149   cout<<"Read "<<fTracks->GetNTracks()<<" tracks from file"<<endl;
 150   fclose(file);
 151 }
 152
 153 void AliL3Compress::CompressFile()
 154 {
 155   if(fNumTimeBits==0)
 156     {
 157       cerr<<"AliL3Compress::CompressFile() : Bitnumbers not set"<<endl;
 158       return;
 159     }
 160
 161   Char_t fname[100];
 162   sprintf(fname,"%s/tracks_c_%d_%d.raw",fPath,fSlice,fPatch);
 163   BIT_FILE *output = OpenOutputBitFile(fname);
 164
 165   sprintf(fname,"%s/tracks_m_%d_%d.raw",fPath,fSlice,fPatch);
 166   FILE *input = fopen(fname,"r");
 167   if(!input)
 168     {
 169       cerr<<"AliL3Compress::CompressFile() : Error opening file: "<<fname<<endl;
 170       return;
 171     }
 172
 173   AliL3TrackModel track;
 174   AliL3ClusterModel cluster;
 175   Int_t temp;
 176   Short_t power;
 177
 178   Int_t timeo,pado,chargeo,shapeo;
 179   timeo=pado=chargeo=shapeo=0;
 180   while(!feof(input))
 181     {
 182       if(fread(&track,sizeof(AliL3TrackModel),1,input)!=1) break;
 183
 184       if(output->mask != 0x80) //Write the current byte to file.
 185         {
 186           //cerr<<"\nAliL3Compress::CompressFile() : Writing overhead bits!!!"<<endl;
 187           if(putc(output->rack,output->file )!=output->rack)
 188             cerr<<"AliL3Compress::ComressFile : Error writing to bitfile"<<endl;
 189           output->mask=0x80;
 190           output->rack=0;
 191         }
 192
 193       //Write track parameters:
 194       fwrite(&track,sizeof(AliL3TrackModel),1,output->file);
 195       for(Int_t i=0; i<track.fNClusters; i++)
 196         {
 197           if(fread(&cluster,sizeof(AliL3ClusterModel),1,input)!=1) break;
 198
 199           //Write empty flag:
 200           temp = (Int_t)cluster.fPresent;
 201           OutputBit(output,temp);
 202           if(!temp) continue;
 203
 204           //Write time information:
 205           temp = (Int_t)cluster.fDTime;
 206           if(temp<0)
 207             OutputBit(output,0);
 208           else
 209             OutputBit(output,1);
 210           power = 1<<(fNumTimeBits-1);
 211           if(abs(temp)>=power)
 212             {
 213               timeo++;
 214               temp=power - 1;
 215             }
 216           OutputBits(output,abs(temp),(fNumTimeBits-1));
 217
 218           //Write pad information:
 219           temp = (Int_t)cluster.fDPad;
 220           if(temp<0)
 221             OutputBit(output,0);
 222           else
 223             OutputBit(output,1);
 224           power = 1<<(fNumPadBits-1);
 225           if(abs(temp)>=power)
 226             {
 227               pado++;
 228               temp=power - 1;
 229             }
 230           OutputBits(output,abs(temp),(fNumPadBits-1));
 231
 232           //Write charge information:
 233           temp = (Int_t)cluster.fDCharge;
 234           if(temp<0)
 235             OutputBit(output,0);
 236           else
 237             OutputBit(output,1);
 238           power = 1<<(fNumChargeBits-1);
 239           if(abs(temp)>=power)
 240             {
 241               chargeo++;
 242               temp=power - 1;
 243             }
 244           OutputBits(output,abs(temp),(fNumChargeBits-1));
 245
 246           //Write shape information:
 247           temp = (Int_t)cluster.fDSigmaY2;
 248           if(temp<0)
 249             OutputBit(output,0);
 250           else
 251             OutputBit(output,1);
 252           power = 1<<(fNumShapeBits-1);
 253           if(abs(temp) >= power)
 254             {
 255               shapeo++;
 256               temp = power - 1;
 257             }
 258           OutputBits(output,abs(temp),(fNumShapeBits-1));
 259
 260           temp = (Int_t)cluster.fDSigmaZ2;
 261           if(temp<0)
 262             OutputBit(output,0);
 263           else
 264             OutputBit(output,1);
 265           power = 1<<(fNumShapeBits-1);
 266           if(abs(temp) >= power)
 267             {
 268               shapeo++;
 269               temp=power - 1;
 270             }
 271           OutputBits(output,abs(temp),(fNumShapeBits-1));
 272         }
 273     }
 274
 275   fclose(input);
 276   CloseOutputBitFile(output);
 277
 278   cout<<endl<<"Saturations: "<<endl
 279       <<"Pad "<<pado<<endl
 280       <<"Time "<<timeo<<endl
 281       <<"Charge "<<chargeo<<endl
 282       <<"Shape "<<shapeo<<endl;
 283 }
 284
 285 void AliL3Compress::ExpandFile()
 286 {
 287   if(fNumTimeBits==0)
 288     {
 289       cerr<<"AliL3Compress::ExpandFile() : Bitnumbers not set"<<endl;
 290       return;
 291     }
 292
 293   Char_t fname[100];
 294   sprintf(fname,"%s/tracks_c_%d_%d.raw",fPath,fSlice,fPatch);
 295   BIT_FILE *input = OpenInputBitFile(fname);
 296
 297   sprintf(fname,"%s/tracks_u_%d_%d.raw",fPath,fSlice,fPatch);
 298   FILE *output = fopen(fname,"w");
 299   if(!output)
 300     {
 301       cerr<<"AliL3Compress::ExpandFile() : Error opening file: "<<fname<<endl;
 302       return;
 303     }
 304
 305   AliL3TrackModel trackmodel;
 306   AliL3ClusterModel *clusters=0;
 307   Int_t count=0;
 308
 309   clusters = new AliL3ClusterModel[(AliL3Transform::GetNRows(fPatch))];
 310   while(!feof(input->file))
 311     {
 312       input->mask=0x80;//make sure we read a new byte from file.
 313
 314       //Read and write track:
 315       if(fread(&trackmodel,sizeof(AliL3TrackModel),1,input->file)!=1) break;
 316       fwrite(&trackmodel,sizeof(AliL3TrackModel),1,output);
 317
 318       for(Int_t i=0; i<AliL3Transform::GetNRows(fPatch); i++)
 319         {
 320           Int_t temp,sign;
 321
 322           //Read empty flag:
 323           temp = InputBit(input);
 324           if(!temp)
 325             {
 326               clusters[i].fPresent=kFALSE;
 327               continue;
 328             }
 329           clusters[i].fPresent=kTRUE;
 330
 331           //Read time information:
 332           sign=InputBit(input);
 333           temp = InputBits(input,(fNumTimeBits-1));
 334           if(!sign)
 335             temp*=-1;
 336           clusters[i].fDTime = temp;
 337
 338           //Read pad information:
 339           sign=InputBit(input);
 340           temp = InputBits(input,(fNumPadBits-1));
 341           if(!sign)
 342             temp*=-1;
 343           clusters[i].fDPad = temp;
 344
 345           //Read charge information:
 346           sign = InputBit(input);
 347           temp=InputBits(input,(fNumChargeBits-1));
 348           if(!sign)
 349             temp*=-1;
 350           clusters[i].fDCharge = temp;
 351
 352           //Read shape information:
 353           sign = InputBit(input);
 354           temp = InputBits(input,(fNumShapeBits-1));
 355           if(!sign)
 356             temp*=-1;
 357           clusters[i].fDSigmaY2 = temp;
 358
 359           sign = InputBit(input);
 360           temp = InputBits(input,(fNumShapeBits-1));
 361           if(!sign)
 362             temp*=-1;
 363           clusters[i].fDSigmaZ2 = temp;
 364         }
 365
 366
 367       count++;
 368       fwrite(clusters,(trackmodel.fNClusters)*sizeof(AliL3ClusterModel),1,output);
 369
 370     }
 371
 372   delete [] clusters;
 373   fclose(output);
 374   CloseInputBitFile(input);
 375 }
 376
 377 void AliL3Compress::CreateDigitArray(Int_t maxnumber)
 378 {
 379   fNUsed=0;
 380   fNDigits = 0;
 381   fMaxDigits=maxnumber;
 382   if(fDigits) delete [] fDigits;
 383   fDigits = new AliL3RandomDigitData[maxnumber];
 384   if(fDPt) delete [] fDPt;
 385   fDPt = new AliL3RandomDigitData*[maxnumber];
 386 }
 387
 388 void AliL3Compress::RestoreData(Char_t which='u')
 389 {
 390   //Restore the data.
 391   //which == u : restore compressed data
 392   //which == m : restore uncompressed data
 393
 394
 395   ReadFile(which);
 396
 397   CreateDigitArray(10000000);
 398
 399   Float_t pad,time,sigmaY2,sigmaZ2;
 400   Int_t charge;
 401   for(Int_t j=AliL3Transform::GetFirstRow(fPatch); j<=AliL3Transform::GetLastRow(fPatch); j++)
 402     {
 403       cout<<"Building clusters on row "<<j<<endl;
 404       for(Int_t i=0; i<fTracks->GetNTracks(); i++)
 405         {
 406           AliL3ModelTrack *track = (AliL3ModelTrack*)fTracks->GetCheckedTrack(i);
 407           if(!track) continue;
 408           if(!track->GetPad(j,pad) ||
 409              !track->GetTime(j,time) ||
 410              !track->GetClusterCharge(j,charge) ||
 411              !track->GetXYWidth(j,sigmaY2) ||
 412              !track->GetZWidth(j,sigmaZ2))
 413             continue;
 414
 415           CreateDigits(j,pad,time,charge,sigmaY2,sigmaZ2);
 416         }
 417     }
 418
 419   QSort(fDPt,0,fNDigits);
 420 }
 421
 422 void AliL3Compress::PrintDigits(Int_t padrow=-1)
 423 {
 424   Int_t pad,time,charge,row;
 425   for(Int_t i=0; i<fNDigits; i++)
 426     {
 427       row = fDPt[i]->fRow;
 428       if(padrow > 0)
 429         if(row != padrow) continue;
 430       pad = fDPt[i]->fPad;
 431       time = fDPt[i]->fTime;
 432       charge = fDPt[i]->fCharge;
 433       if(i>0 && row != fDPt[i-1]->fRow)
 434         cout<<"---Padrow "<<row<<"---"<<endl;
 435       cout<<"Padrow "<<row<<" Pad "<<pad<<" time "<<time<<" charge "<<charge<<endl;
 436     }
 437 }
 438
 439 void AliL3Compress::WriteRestoredData()
 440 {
 441   Char_t fname[100];
 442
 443   //Get the remaining raw data array:
 444   AliL3MemHandler *mem = new AliL3MemHandler();
 445   sprintf(fname,"%s/remains_%d_%d.raw",fPath,fSlice,fPatch);
 446   mem->SetBinaryInput(fname);
 447   UInt_t numdigits;
 448   AliL3DigitRowData *origRow = mem->CompBinary2Memory(numdigits);
 449   mem->CloseBinaryInput();
 450
 451   //Allocate memory for the merged data:
 452   UInt_t size = mem->GetAllocatedSize() + fNDigits*sizeof(AliL3DigitData);
 453   cout<<"Allocating "<<size<<" bytes for merged data array "<<endl;
 454   Byte_t *data = new Byte_t[size];
 455   memset(data,0,size);
 456   AliL3DigitRowData *tempRow = (AliL3DigitRowData*)data;
 457
 458   Int_t ndigits,action,charge;
 459   UShort_t pad,time;
 460
 461   UInt_t digit_counter;
 462   Int_t row_counter=0;
 463   for(Int_t i=AliL3Transform::GetFirstRow(fPatch); i<=AliL3Transform::GetLastRow(fPatch); i++)
 464     {
 465       tempRow->fRow = i;
 466       ndigits=0;
 467       AliL3DigitData *origDig = origRow->fDigitData;
 468       AliL3DigitData *tempDig = tempRow->fDigitData;
 469       if((Int_t)origRow->fRow != i)
 470         cerr<<"AliL3Compress::WriteRestoredData() : Mismatching row numbering "<<(Int_t)origRow->fRow<<" "<<i<<endl;
 471
 472       //cout<<"Writing row "<<i<<" with "<<(Int_t)origRow->fNDigit<<" old digits"<<endl;
 473       digit_counter=0;
 474
 475       while(1)
 476         {
 477           while(digit_counter < origRow->fNDigit)
 478             {
 479               pad = origDig[digit_counter].fPad;
 480               time = origDig[digit_counter].fTime;
 481               charge = origDig[digit_counter].fCharge;
 482               digit_counter++;
 483               while( (action=ComparePoints(i,pad,time)) == 1)
 484                 {
 485                   tempDig[ndigits].fPad = fDPt[fNUsed]->fPad;
 486                   tempDig[ndigits].fTime = fDPt[fNUsed]->fTime;
 487                   tempDig[ndigits].fCharge = fDPt[fNUsed]->fCharge;
 488                   ndigits++;
 489                   fNUsed++;
 490
 491                 }
 492               if(action == 0)
 493                 {
 494                   tempDig[ndigits].fPad = pad;
 495                   tempDig[ndigits].fTime = time;
 496                   tempDig[ndigits].fCharge = charge;
 497                   ndigits++;
 498                 }
 499             }
 500
 501           if(fNUsed >= fNDigits)
 502             {
 503               //cerr<<"AliL3Compress::WriteRestoredData() : Array out of range : "<<fNUsed<<" "<<fNDigits<<endl;
 504               break;
 505             }
 506           if(fDPt[fNUsed]->fRow != i) //we are on a new row
 507             break;
 508           tempDig[ndigits].fPad = fDPt[fNUsed]->fPad;
 509           tempDig[ndigits].fTime = fDPt[fNUsed]->fTime;
 510           tempDig[ndigits].fCharge = fDPt[fNUsed]->fCharge;
 511           ndigits++;
 512           fNUsed++;
 513         }
 514       //cout<<"Writing "<<ndigits<<" digits on row "<<i<<endl;
 515       if(ndigits > 4)
 516         {
 517           row_counter++;
 518         }
 519       tempRow->fNDigit = ndigits;
 520       Int_t size = sizeof(AliL3DigitData)*tempRow->fNDigit + sizeof(AliL3DigitRowData);
 521       Byte_t *byte_pt = (Byte_t*)tempRow;
 522       byte_pt += size;
 523       tempRow = (AliL3DigitRowData*)byte_pt;
 524       mem->UpdateRowPointer(origRow);
 525     }
 526
 527   if(row_counter != AliL3Transform::GetNRows(fPatch))
 528     cerr<<"AliL3Compress::WriteRestoredData() : Written rows: "<<row_counter<<" total rows "<<AliL3Transform::GetNRows(fPatch)<<endl;
 529
 530   mem->Free();
 531   sprintf(fname,"%s/restored_%d_%d.raw",fPath,fSlice,fPatch);
 532   mem->SetBinaryOutput(fname);
 533   mem->Memory2CompBinary((UInt_t)AliL3Transform::GetNRows(fPatch),(AliL3DigitRowData*)data);
 534   mem->CloseBinaryOutput();
 535
 536   delete [] data;
 537   delete mem;
 538
 539 }
 540
 541 void AliL3Compress::CreateDigits(Int_t row,Float_t pad,Float_t time,Int_t charge,Float_t sigmaY2,Float_t sigmaZ2)
 542 {
 543   //Create raw data out of the cluster.
 544
 545
 546
 547   //Convert back the sigmas:
 548   /*
 549     Float_t padw,timew;
 550     if(fPatch < 2)
 551     padw = AliL3Transform::GetPadPitchWidthLow();
 552     else
 553     padw = AliL3Transform::GetPadPitchWidthUp();
 554     timew = AliL3Transform::GetZWidth();
 555   */
 556
 557   /*
 558     if(fPatch < 3)
 559     sigmaY2 = sigmaY2/2.07;
 560     sigmaY2 = sigmaY2/0.108;
 561   */
 562
 563   //sigmaY2 = sigmaY2/(padw*padw);
 564
 565   //sigmaY2 = sigmaY2;// - 1./12;
 566
 567   /*
 568     if(fPatch < 3)
 569     sigmaZ2 = sigmaZ2/1.77;
 570     sigmaZ2 = sigmaZ2/0.169;
 571   */
 572
 573   //sigmaZ2 = sigmaZ2/(timew*timew);
 574   //sigmaZ2 = sigmaZ2;// - 1./12;
 575
 576   if(sigmaY2 <= 0 || sigmaZ2 <= 0)
 577     {
 578       cerr<<"AliL3Compress::CreateDigits() : Wrong sigmas : "<<sigmaY2<<" "<<sigmaZ2;
 579       cerr<<" on row "<<row<<" pad "<<pad<<" time "<<time<<endl;
 580       return;
 581     }
 582
 583   TRandom *random = new TRandom();
 584
 585   Int_t entries=1000;
 586   TH1F *hist1 = new TH1F("hist1","",AliL3Transform::GetNPads(row),0,AliL3Transform::GetNPads(row)-1);
 587   TH1F *hist2 = new TH1F("hist2","",AliL3Transform::GetNTimeBins(),0,AliL3Transform::GetNTimeBins()-1);
 588   TH2F *hist3 = new TH2F("hist3","",AliL3Transform::GetNPads(row),0,AliL3Transform::GetNPads(row)-1,AliL3Transform::GetNTimeBins(),0,AliL3Transform::GetNTimeBins()-1);
 589
 590
 591
 592   //Create the distributions in pad and time:
 593   for(Int_t i=0; i<entries; i++)
 594     {
 595       hist1->Fill(random->Gaus(pad,sqrt(sigmaY2)));
 596       hist2->Fill(random->Gaus(time,sqrt(sigmaZ2)));
 597     }
 598
 599   //Create the cluster:
 600   Int_t bin1,bin2;
 601   Double_t content1,content2,dpad,dtime;
 602   for(Int_t i=0; i<hist1->GetEntries(); i++)
 603     {
 604       bin1 = hist1->GetBin(i);
 605       content1 = hist1->GetBinContent(bin1);
 606       if((Int_t)content1==0) continue;
 607       content1 = charge*content1/entries;
 608       dpad = hist1->GetBinCenter(bin1);
 609       for(Int_t j=0; j<hist2->GetEntries(); j++)
 610         {
 611           bin2 = hist2->GetBin(j);
 612           content2 = hist2->GetBinContent(bin2);
 613           if((Int_t)content2==0) continue;
 614           content2 = content1*content2/entries;
 615           dtime = hist2->GetBinCenter(bin2);
 616           hist3->Fill(dpad,dtime,content2);
 617         }
 618     }
 619
 620   Int_t local_dig=0;
 621   //Fill it into the digit array:
 622   for(Int_t i=0; i<hist3->GetNbinsX(); i++)
 623     {
 624       for(Int_t j=0; j<hist3->GetNbinsY(); j++)
 625         {
 626           bin1 = hist3->GetBin(i,j);
 627           content1 = hist3->GetBinContent(bin1);
 628           if((Int_t)content1 < 3) continue;
 629           if(content1 >= 1024)
 630             content1 = 1023;
 631           if(fNDigits >= fMaxDigits)
 632             {
 633               cerr<<"AliL3Compress::CreateDigits() : Array index out of range : "<<fNDigits<<endl;
 634               return;
 635             }
 636           fDigits[fNDigits].fCharge=(Int_t)content1;
 637           fDigits[fNDigits].fRow = row;
 638           fDigits[fNDigits].fPad = (Int_t)hist3->GetXaxis()->GetBinCenter(i);
 639           fDigits[fNDigits].fTime = (Int_t)hist3->GetYaxis()->GetBinCenter(j);
 640           fDPt[fNDigits] = &fDigits[fNDigits];
 641           fNDigits++;
 642           local_dig++;
 643         }
 644     }
 645   //if(local_dig < 5)
 646   //  cout<<"Small cluster "<<local_dig<<" pad "<<(Int_t)fDigits[fNDigits-1].fPad<<" time "<<(Int_t)fDigits[fNDigits-1].fTime<<endl;
 647
 648   delete random;
 649   delete hist1;
 650   delete hist2;
 651   delete hist3;
 652 }
 653
 654 void AliL3Compress::PrintCompRatio()
 655 {
 656   Char_t fname[100];
 657   sprintf(fname,"%s/remains_%d_%d.raw",fPath,fSlice,fPatch);
 658   AliL3MemHandler *mem = new AliL3MemHandler();
 659   if(!mem->SetBinaryInput(fname))
 660     {
 661       cerr<<"AliL3Compress::PrintCompRatio(): Error opening file: "<<fname<<endl;
 662       return;
 663     }
 664   UInt_t ndigits;
 665   AliL3DigitRowData *rowPt = (AliL3DigitRowData*)mem->CompBinary2Memory(ndigits);
 666   mem->CloseBinaryInput();
 667
 668   Int_t digit_counter=0;
 669   for(Int_t i=AliL3Transform::GetFirstRow(fPatch); i<=AliL3Transform::GetLastRow(fPatch); i++)
 670     {
 671       digit_counter += rowPt->fNDigit;
 672       mem->UpdateRowPointer(rowPt);
 673     }
 674   delete mem;
 675
 676   sprintf(fname,"%s/tracks_c_%d_%d.raw",fPath,fSlice,fPatch);
 677   FILE *file1 = fopen(fname,"r");
 678   if(!file1)
 679     {
 680       cerr<<"AliL3Compress::PrintCompRatio(): Error opening file: "<<fname<<endl;
 681       return;
 682     }
 683   fseek(file1,0,SEEK_END);
 684   UInt_t filesize1 = (UInt_t)ftell(file1);
 685   fclose(file1);
 686
 687   sprintf(fname,"%s/digits_%d_%d.raw",fPath,fSlice,fPatch);
 688   FILE *file2 = fopen(fname,"r");
 689   if(!file2)
 690     {
 691       cerr<<"AliL3Compress::PrintCompRatio(): Error opening file: "<<fname<<endl;
 692       return;
 693     }
 694   fseek(file2,0,SEEK_END);
 695   UInt_t filesize2 = (UInt_t)ftell(file2);
 696   fclose(file2);
 697
 698   cout<<"----------------------"<<endl;
 699   cout<<"Original file size   : "<<filesize2<<endl;
 700   cout<<"Compressed file size : "<<filesize1<<endl;
 701   cout<<"Remaining digits     : "<<digit_counter<<endl;
 702   cout<<"Compression ratio    : "<<(Float_t)(filesize1 + (10*digit_counter)/8)/(Float_t)(filesize2)<<endl;
 703
 704 }
 705
 706 void AliL3Compress::QSort(AliL3RandomDigitData **a, Int_t first, Int_t last)
 707 {
 708
 709   // Sort array of AliL3RandomDigitData pointers using a quicksort algorithm.
 710   // Uses CompareDigits() to compare objects.
 711   // Thanks to Root!
 712
 713   static AliL3RandomDigitData *tmp;
 714   static int i;           // "static" to save stack space
 715   int j;
 716
 717   while (last - first > 1) {
 718     i = first;
 719     j = last;
 720     for (;;) {
 721       while (++i < last && CompareDigits(a[i], a[first]) < 0)
 722         ;
 723       while (--j > first && CompareDigits(a[j], a[first]) > 0)
 724         ;
 725       if (i >= j)
 726         break;
 727
 728       tmp  = a[i];
 729       a[i] = a[j];
 730       a[j] = tmp;
 731     }
 732     if (j == first) {
 733       ++first;
 734       continue;
 735     }
 736     tmp = a[first];
 737     a[first] = a[j];
 738     a[j] = tmp;
 739     if (j - first < last - (j + 1)) {
 740       QSort(a, first, j);
 741       first = j + 1;   // QSort(j + 1, last);
 742     } else {
 743       QSort(a, j + 1, last);
 744       last = j;        // QSort(first, j);
 745     }
 746   }
 747 }
 748
 749 void AliL3Compress::WriteRootFile(Char_t *newrootfile)
 750 {
 751 #ifdef use_aliroot
 752   Char_t fname[100];
 753   AliL3MemHandler *mem = new AliL3MemHandler();
 754   sprintf(fname,"%s/restored_%d_%d.raw",fPath,fSlice,fPatch);
 755   mem->SetBinaryInput(fname);
 756   UInt_t ndigits;
 757   AliL3DigitRowData *rowPt = (AliL3DigitRowData*)mem->CompBinary2Memory(ndigits);
 758   mem->CloseBinaryInput();
 759
 760   sprintf(fname,"%s/digitfile",fPath);
 761
 762   AliL3FileHandler *file = new AliL3FileHandler();
 763   if(!file->SetAliInput(fname))
 764     {
 765       cerr<<"AliL3Compress::WriteRootFile() : Error opening file: "<<fname<<endl;
 766       return;
 767     }
 768   const Int_t rows[2] = {AliL3Transform::GetFirstRow(fPatch),AliL3Transform::GetLastRow(fPatch)};
 769   file->Init(fSlice,fPatch,rows);
 770   file->AliDigits2RootFile(rowPt,newrootfile);
 771   file->CloseAliInput();
 772
 773   delete mem;
 774   delete file;
 775 #endif
 776
 777   return;
 778 }