HLT/TPCLib/Ref/AliHLTTPC.cxx

   1 // @(#) $Id$
   2
   3 // Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
   4 //*-- Copyright &copy ALICE HLT Group
   5
   6 #include "AliHLTTPCStandardIncludes.h"
   7
   8 #ifndef no_root
   9 #include <TFile.h>
  10 #include <TDirectory.h>
  11 #include <TClonesArray.h>
  12 #include <TStopwatch.h>
  13 #endif
  14
  15 #include "AliHLTTPCLogging.h"
  16 #include "AliHLTTPC.h"
  17 #include "AliHLTTPCConfMapper.h"
  18 #include "AliHLTTPCVertex.h"
  19 #include "AliHLTTPCVertexFinder.h"
  20 #include "AliHLTTPCTrackMerger.h"
  21 #include "AliHLTTPCGlobalMerger.h"
  22 #include "AliHLTTPCInterMerger.h"
  23 #include "AliHLTTPCConfMapPoint.h"
  24 #include "AliHLTTPCConfMapTrack.h"
  25 #include "AliHLTTPCTransform.h"
  26 #include "AliHLTTPCClustFinderNew.h"
  27 #include "AliHLTTPCDigitData.h"
  28 #include "AliHLTTPCTrackArray.h"
  29 #include "AliHLTTPCMemHandler.h"
  30 #include "AliHLTTPCFitter.h"
  31 #ifdef use_aliroot
  32 #include "AliHLTTPCFileHandler.h"
  33 #endif
  34 #include "AliHLTTPCBenchmark.h"
  35 #include "AliHLTTPCDigitData.h"
  36 #include "AliHLTTPCTrackSegmentData.h"
  37 #include "AliHLTTPCSpacePointData.h"
  38 #include "AliHLTTPCVertexData.h"
  39 #include "AliHLTTPCDDLDataFileHandler.h"
  40
  41 /** \class AliHLTTPC
  42 <pre>
  43 //_____________________________________________________________
  44 //
  45 //  AliHLTTPC
  46 //
  47 //  Interface class for Level3 tracker.
  48 //  For example how to use, see exa/runtracker.C (root)
  49 //  or programs/runtracker.cxx (standalone program).
  50 //Begin_Html
  51 //<img src="tpcsectorsnb.gif">
  52 //End_Html
  53 </pre>
  54 */
  55
  56 ClassImp(AliHLTTPC)
  57
  58 Bool_t AliHLTTPC::fSetTracks2FirstPoint = kTRUE;//Define track parameters at first point
  59
  60 AliHLTTPC::AliHLTTPC()
  61 {
  62   //Default constructor. Should also be used when input is from binary files.
  63   //In that case the path to where the binary files are located has to be
  64   //passed to the AliLevel::Init function.
  65
  66   fInputFile=0;
  67 }
  68
  69 AliHLTTPC::AliHLTTPC(Char_t *infile)
  70 {
  71   //Constructor to use for when input is anything else but binary files,
  72   //meaning rootfiles or raw files.
  73
  74   fInputFile = infile;
  75
  76 }
  77
  78 void AliHLTTPC::Init(Char_t *path,EFileType filetype,Int_t npatches)
  79 {
  80   if((filetype!=kBinary) && (filetype!=kDate) && !fInputFile)
  81     {
  82       LOG(AliHLTTPCLog::kError,"AliHLTTPC::Init","Files")
  83         <<"You have not supplied the input rootfile; use the appropriate ctor!"<<ENDLOG;
  84       return;
  85     }
  86
  87   fWriteOut = kFALSE;
  88   fPileUp = kFALSE;
  89   fNoCF=kFALSE;
  90   fUseBinary = (filetype==kBinary);
  91   SetPath(path);
  92
  93   fDoRoi = kFALSE;
  94   fDoNonVertex = kFALSE;
  95   fFindVertex = kFALSE;
  96   SetClusterFinderParam();
  97
  98   fEta[0] = 0.;
  99   fEta[1] = 1.1;
 100
 101   fEvent=0;
 102
 103   switch(npatches){
 104   case 0:
 105     fNPatch = 1;
 106     fRow[0][0] = AliHLTTPCTransform::GetFirstRow(3);
 107     fRow[0][1] = AliHLTTPCTransform::GetLastRow(5);
 108     break;
 109   case 1:
 110     fNPatch = 1;        //number of patches change row in process
 111     fRow[0][0] = 0;
 112     fRow[0][1] = AliHLTTPCTransform::GetLastRow(-1);
 113     break;
 114   case 2:
 115     fNPatch = 2;        //number of patches change row in process
 116     fRow[0][0] = 0;     // first row
 117     fRow[0][1] = AliHLTTPCTransform::GetLastRow(1);
 118     fRow[1][0] = AliHLTTPCTransform::GetFirstRow(2);
 119     fRow[1][1] = AliHLTTPCTransform::GetLastRow(5);
 120     break;
 121   default:
 122     fNPatch = 6;
 123     fRow[0][0] = AliHLTTPCTransform::GetFirstRow(0);
 124     fRow[0][1] = AliHLTTPCTransform::GetLastRow(0);
 125     fRow[1][0] = AliHLTTPCTransform::GetFirstRow(1);
 126     fRow[1][1] = AliHLTTPCTransform::GetLastRow(1);
 127     fRow[2][0] = AliHLTTPCTransform::GetFirstRow(2);
 128     fRow[2][1] = AliHLTTPCTransform::GetLastRow(2);
 129     fRow[3][0] = AliHLTTPCTransform::GetFirstRow(3);
 130     fRow[3][1] = AliHLTTPCTransform::GetLastRow(3);
 131     fRow[4][0] = AliHLTTPCTransform::GetFirstRow(4);
 132     fRow[4][1] = AliHLTTPCTransform::GetLastRow(4);
 133     fRow[5][0] = AliHLTTPCTransform::GetFirstRow(5);
 134     fRow[5][1] = AliHLTTPCTransform::GetLastRow(5);
 135   }
 136
 137   fVertexFinder = new AliHLTTPCVertexFinder();
 138   fVertex = new AliHLTTPCVertex();
 139   fTracker = new AliHLTTPCConfMapper();
 140   fTrackMerger = new AliHLTTPCTrackMerger(fNPatch);
 141   fInterMerger = new AliHLTTPCInterMerger();
 142   fGlobalMerger = new AliHLTTPCGlobalMerger();
 143   SetMergerParameters();//Set default merger parameters
 144 #ifdef use_aliroot
 145   if(filetype==kRoot){
 146     fFileHandler = new AliHLTTPCFileHandler();
 147     fFileHandler->SetAliInput(fInputFile);
 148   }else if(filetype==kRaw){
 149     fFileHandler = new AliHLTTPCDDLDataFileHandler();
 150     fFileHandler->SetReaderInput(fInputFile);
 151   }else if(filetype==kDate){
 152     fFileHandler = new AliHLTTPCDDLDataFileHandler();
 153     fFileHandler->SetReaderInput(fInputFile,-1);
 154   }else{
 155     fFileHandler = new AliHLTTPCMemHandler();
 156   }
 157 #else
 158   if(filetype==kRaw){
 159     fFileHandler = new AliHLTTPCDDLDataFileHandler();
 160     fFileHandler->SetReaderInput(fInputFile);
 161   }else{
 162     fFileHandler = new AliHLTTPCMemHandler();
 163   }
 164 #endif
 165   fBenchmark = new AliHLTTPCBenchmark();
 166 }
 167
 168 void AliHLTTPC::DoBench(char* name){
 169   fBenchmark->Analyze(name);
 170   delete fBenchmark;
 171   fBenchmark = new AliHLTTPCBenchmark();
 172 }
 173
 174 void AliHLTTPC::DoMc(char* file){
 175 #ifdef use_aliroot
 176   if(!fFileHandler->IsDigit(fEvent))
 177     fFileHandler->SetMCOutput(file);
 178 #endif
 179 }
 180
 181 AliHLTTPC::~AliHLTTPC(){
 182   //Destructor
 183   if(fVertexFinder) delete fVertexFinder;
 184   if(fVertex) delete fVertex;
 185   if(fTracker) delete fTracker;
 186   if(fTrackMerger) delete fTrackMerger;
 187   if(fInterMerger) delete fInterMerger;
 188   if(fFileHandler) delete fFileHandler;
 189   if(fGlobalMerger) delete fGlobalMerger;
 190 }
 191
 192 void AliHLTTPC::SetClusterFinderParam(Float_t fXYError, Float_t fZError, Bool_t deconv)
 193 {
 194   fXYClusterError=fXYError;
 195   fZClusterError=fZError;
 196   fClusterDeconv=deconv;
 197 }
 198
 199 void AliHLTTPC::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
 200                                 Int_t trackletlength, Int_t tracklength,
 201                                 Int_t rowscopetracklet, Int_t rowscopetrack,
 202                                 Double_t min_pt_fit, Double_t maxangle,
 203                                 Double_t goodDist, Double_t hitChi2Cut,
 204                                 Double_t goodHitChi2, Double_t trackChi2Cut,
 205                                 Int_t maxdist,Double_t maxphi,Double_t maxeta,Bool_t vertexconstraint)
 206 {
 207   //Set parameters input to the tracker
 208   //If no arguments are given, default parameters will be used
 209
 210   fTracker->SetNSegments(phi_segments,eta_segments);
 211   fTracker->SetMaxDca(min_pt_fit);
 212   fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexconstraint);
 213   fTracker->SetTrackletCuts(maxangle,goodDist,vertexconstraint);
 214   if(vertexconstraint)
 215     fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack,maxphi,maxeta);
 216   else
 217     fTracker->NonVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
 218   fTracker->InitVolumes();
 219 }
 220
 221 void AliHLTTPC::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
 222 {
 223   fGlobalMerger->SetParameter(maxy,maxz,maxkappa,maxpsi,maxtgl);
 224 }
 225
 226 void AliHLTTPC::ProcessEvent(Int_t first,Int_t last,Int_t event){
 227   //Do tracking on all slices in region [first,last]
 228   //Slices numbering in TPC goes from 0-35, which means that one slice
 229   //corresponds to inner+outer sector.E.g. slice 2 corresponds to
 230   //inner=2 + outer=38.
 231
 232   fGlobalMerger->Setup(first,last);
 233   fEvent=event;
 234   for(Int_t i=first; i<=last; i++){
 235     ProcessSlice(i);
 236     fGlobalMerger->SetVertex(fVertex);
 237     fGlobalMerger->InitSlice(i);
 238     fGlobalMerger->FillTracks(fNTrackData,fTrackData);
 239     fFileHandler->Free();   //free the memory
 240     fNTrackData=0;
 241     fTrackData=0;
 242   }
 243   fBenchmark->Start("Global track merger");
 244   //fGlobalMerger->AddAllTracks();
 245   fGlobalMerger->Merge();
 246   //fGlobalMerger->SlowMerge(fWriteOutPath);
 247   fBenchmark->Stop("Global track merger");
 248
 249   FitGlobalTracks();
 250
 251   if(fWriteOut) WriteResults();
 252   fFileHandler->FreeDigitsTree();
 253 }
 254
 255 void AliHLTTPC::ProcessSlice(Int_t slice){
 256   char name[256];
 257   Bool_t UseCF = kFALSE;
 258 #ifdef use_aliroot
 259   UseCF = fFileHandler->IsDigit(fEvent);
 260 #endif
 261   if(fUseBinary)
 262     UseCF = kTRUE;   //In case you are not using aliroot
 263   if(fNoCF == kTRUE) //In case you don't want to run with cluster finder
 264     UseCF = kFALSE;
 265
 266   const Int_t maxpoints=120000;
 267   const Int_t pointsize = maxpoints * sizeof(AliHLTTPCSpacePointData);
 268   AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
 269
 270   fTrackMerger->Reset();
 271   fTrackMerger->SetRows(fRow[0]);
 272
 273   for(Int_t patch=fNPatch-1;patch>=0;patch--){
 274     fFileHandler->Init(slice,patch,&fRow[patch][0]);
 275     UInt_t npoints=0;
 276     AliHLTTPCSpacePointData *points =0;
 277     UInt_t ndigits=0;
 278     AliHLTTPCDigitRowData *digits =0;
 279     if(UseCF){
 280       if(fUseBinary){
 281         if(!fDoRoi){
 282           if(1){     //Binary to Memory
 283             fFileHandler->Free();
 284             if(fNPatch == 1)
 285               sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
 286             else
 287               sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
 288             if(!fFileHandler->SetBinaryInput(name)) return;
 289             if(fPileUp)
 290               { //Read binary files which are not RLE
 291                 digits = (AliHLTTPCDigitRowData*)fFileHandler->Allocate();
 292                 fFileHandler->Binary2Memory(ndigits,digits);
 293               }
 294             else //Read RLE binary files
 295               digits= (AliHLTTPCDigitRowData *)fFileHandler->CompBinary2Memory(ndigits);
 296
 297             fFileHandler->CloseBinaryInput();
 298           }
 299
 300           if(0){     //Binary to Memory with Benchmark
 301             fFileHandler->Free();
 302             if(fNPatch == 1)
 303               sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
 304             else
 305               sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
 306             if(!memory->SetBinaryInput(name)) return;
 307             UInt_t compsize=memory->GetFileSize();
 308             UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
 309             memory->CompBinary2CompMemory(ndigits,comp);
 310             memory->CloseBinaryInput();
 311             UInt_t datasize=memory->GetMemorySize(ndigits,comp);
 312             digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
 313             fBenchmark->Start("Unpacker");
 314             fFileHandler->CompMemory2Memory(ndigits,digits,comp);
 315             fBenchmark->Stop("Unpacker");
 316             memory->Free();
 317           }
 318
 319           if(0){     //Binary to Memory with Random
 320             fFileHandler->Free();
 321             fFileHandler->ResetRandom();
 322             fFileHandler->SetRandomCluster(100);
 323             fFileHandler->SetNGenerate(100);
 324             if(fNPatch == 1)
 325               sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
 326             else
 327               sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
 328             if(!memory->SetBinaryInput(name)) return;
 329             UInt_t compsize=memory->GetFileSize();
 330             UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
 331             memory->CompBinary2CompMemory(ndigits,comp);
 332             memory->CloseBinaryInput();
 333             UInt_t dsize=memory->GetMemorySize(ndigits,comp);
 334             UInt_t rsize=fFileHandler->GetRandomSize();
 335             digits=(AliHLTTPCDigitRowData*)fFileHandler->Allocate(dsize+rsize);
 336             fBenchmark->Start("Unpacker");
 337             fFileHandler->CompMemory2Memory(ndigits,digits,comp);
 338             fBenchmark->Stop("Unpacker");
 339             memory->Free();
 340           }
 341         }
 342
 343         else{     //Binary to Memory with Roi
 344           fFileHandler->Free();
 345           Int_t sli[2]={0,0};
 346           fFileHandler->SetROI(fEta,sli);
 347           if(fNPatch==1)
 348             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
 349           else
 350             sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
 351           if(!memory->SetBinaryInput(name)) return;
 352           UInt_t compsize=memory->GetFileSize();
 353           UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
 354           memory->CompBinary2CompMemory(ndigits,comp);
 355           memory->CloseBinaryInput();
 356           UInt_t datasize=memory->GetMemorySize(ndigits,comp);
 357           digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
 358           fBenchmark->Start("Unpacker");
 359           datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp);
 360           fBenchmark->Stop("Unpacker");
 361           memory->Free();
 362         }
 363       }//end UseBinary
 364       else{
 365 #ifdef use_aliroot
 366         fBenchmark->Start("Dummy Unpacker");
 367         if(fNPatch==1)
 368           sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,-1);
 369         else
 370           sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,patch);
 371         fBenchmark->Stop("Dummy Unpacker");
 372
 373         if(0){   //Ali to Binary
 374           fFileHandler->SetBinaryOutput(name);
 375           fFileHandler->AliDigits2CompBinary();
 376           fFileHandler->CloseBinaryOutput();
 377         }
 378
 379         if(1){   //Ali to Memory
 380           digits=(AliHLTTPCDigitRowData *)fFileHandler->AliAltroDigits2Memory(ndigits,fEvent);
 381           if(0){ //Memory to Binary
 382             fFileHandler->SetBinaryOutput(name);
 383             fFileHandler->Memory2CompBinary(ndigits,digits);
 384             fFileHandler->CloseBinaryOutput();
 385           }
 386         }
 387 #endif
 388       }//end else UseBinary
 389
 390       points = (AliHLTTPCSpacePointData *) memory->Allocate(pointsize);
 391       fClusterFinder = new AliHLTTPCClustFinderNew();
 392       fClusterFinder->InitSlice(slice,patch,fRow[patch][0],fRow[patch][1],maxpoints);
 393       fClusterFinder->SetDeconv(fClusterDeconv);
 394       fClusterFinder->SetXYError(fXYClusterError);
 395       fClusterFinder->SetZError(fZClusterError);
 396       if((fXYClusterError>0)&&(fZClusterError>0))
 397         fClusterFinder->SetCalcErr(kFALSE);
 398       fClusterFinder->SetOutputArray(points);
 399       fBenchmark->Start("Cluster finder");
 400       fClusterFinder->Read(ndigits,digits);
 401       fClusterFinder->ProcessDigits();
 402       fBenchmark->Stop("Cluster finder");
 403       npoints = fClusterFinder->GetNumberOfClusters();
 404       delete fClusterFinder;
 405       fClusterFinder = 0;
 406       fFileHandler->Free();
 407       LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Cluster Finder")
 408         <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
 409     }//end UseCF
 410     else{// if not use Clusterfinder
 411       if(fUseBinary){//Binary to Memory
 412         memory->Free();
 413         if(fNPatch==1)
 414           sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,-1);
 415         else
 416           sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,patch);
 417         if(!memory->SetBinaryInput(name)) return;
 418         points = (AliHLTTPCSpacePointData *) memory->Allocate();
 419         memory->Binary2Memory(npoints,points);
 420         memory->CloseBinaryInput();
 421         LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Read Cluster")
 422         <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points in File"<<ENDLOG;
 423       }
 424 #ifdef use_aliroot
 425       else{
 426         points = fFileHandler->AliPoints2Memory(npoints);
 427       }
 428 #endif
 429       fBenchmark->Start("Dummy Unpacker");
 430       fBenchmark->Stop("Dummy Unpacker");
 431       fBenchmark->Start("Dummy CF");
 432       fBenchmark->Stop("Dummy CF");
 433     }
 434
 435     if(patch == fNPatch-1){
 436       // Vertex
 437       if(fFindVertex){
 438       // Vertex Finder
 439
 440         fBenchmark->Start("Vertex Finder Read");
 441         fVertexFinder->Reset();
 442         fVertexFinder->Read(npoints,points);
 443         fBenchmark->Stop("Vertex Finder Read");
 444         fBenchmark->Start("Vertex Finder");
 445         fVertexFinder->Analyze();
 446         AliHLTTPCVertexData vertex[1];
 447         fVertexFinder->Write(vertex);
 448         fVertex->Read(vertex);
 449         fBenchmark->Stop("Vertex Finder");
 450       }
 451       else{
 452         //use 0,0,0 for vertex
 453         fVertex->SetZero();
 454       }
 455       fTrackMerger->SetVertex(fVertex);
 456     }
 457
 458     fTracker->InitSector(slice,fRow[patch],fEta);
 459     fTracker->SetVertex(fVertex);
 460     fBenchmark->Start("Tracker setup");
 461     fTracker->ReadHits(npoints,points);
 462     fTracker->MainVertexTracking_a();
 463     fBenchmark->Stop("Tracker setup");
 464     fBenchmark->Start("Track follower");
 465     fTracker->MainVertexTracking_b();
 466     fBenchmark->Stop("Track follower");
 467     if(fDoNonVertex)
 468       fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
 469     fBenchmark->Start("Sector track fitting");
 470     fTracker->FillTracks();
 471     fBenchmark->Stop("Sector track fitting");
 472
 473     if(fWriteOut)
 474        WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
 475
 476     //free memory
 477     if(UseCF)
 478       memory->Free();
 479     else
 480       fFileHandler->Free();
 481
 482     UInt_t ntracks0 =0;
 483     AliHLTTPCTrackSegmentData *trackdata0  =
 484          (AliHLTTPCTrackSegmentData *) memory->Allocate(fTracker->GetTracks());
 485     memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
 486
 487     //write tracks
 488     if(fWriteOut){
 489       if(fNPatch==1)
 490         sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
 491       else
 492         sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
 493       memory->SetBinaryOutput(name);
 494       memory->Memory2Binary(ntracks0,trackdata0);
 495       memory->CloseBinaryOutput();
 496     }
 497
 498     fInterMerger->Reset();
 499     fInterMerger->Init(fRow[patch],patch);
 500
 501     fInterMerger->FillTracks(ntracks0,trackdata0);
 502
 503     //fBenchmark->Start("Inter Merger");
 504     // fInterMerger->Merge();
 505     //    fInterMerger->SlowMerge();
 506
 507     //fBenchmark->Stop("Inter Merger");
 508     /*
 509     //write inter merged tracks
 510     if(fWriteOut){
 511       sprintf(name,"%stracks_im_%d_%d.raw",fWriteOutPath,slice,patch);
 512       WriteTracks(name,fInterMerger,'i'); //write output of intermerger
 513       }
 514     */
 515     memory->Free();
 516
 517     UInt_t ntracks1 =0;
 518     AliHLTTPCTrackSegmentData *trackdata1 =
 519       (AliHLTTPCTrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
 520     memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
 521
 522     fTrackMerger->InitSector(slice,patch);
 523     fTrackMerger->FillTracks(ntracks1,trackdata1);
 524
 525     memory->Free();
 526   }
 527   //fBenchmark->Start("Patch Merger");
 528   //fTrackMerger->SlowMerge();
 529   fTrackMerger->AddAllTracks();
 530   //fTrackMerger->Merge();
 531   //fBenchmark->Stop("Patch Merger");
 532   /*
 533   //write merged tracks
 534   if(fWriteOut){
 535     sprintf(name,"%stracks_tm_%d.raw",fWriteOutPath,slice);
 536     WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
 537   }
 538   */
 539   fTrackData = (AliHLTTPCTrackSegmentData *)
 540                          fFileHandler->Allocate(fTrackMerger->GetOutTracks());
 541
 542   fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
 543                                                 fTrackMerger->GetOutTracks());
 544
 545   delete memory;
 546 }
 547
 548 void AliHLTTPC::FitGlobalTracks()
 549 {
 550   AliHLTTPCFitter *fitter = new AliHLTTPCFitter(fVertex);
 551   if(fNPatch==1)
 552     fitter->LoadClusters(fWriteOutPath,fEvent,kTRUE);
 553   else
 554     fitter->LoadClusters(fWriteOutPath,fEvent,kFALSE);
 555
 556   fBenchmark->Start("Global track fitter");
 557   AliHLTTPCTrackArray *tracks = fGlobalMerger->GetOutTracks();
 558   for(Int_t i=0; i<tracks->GetNTracks(); i++)
 559     {
 560       AliHLTTPCTrack *tr = tracks->GetCheckedTrack(i);
 561       if(!tr) continue;
 562       fitter->FitHelix(tr);
 563       fitter->UpdateTrack(tr);
 564     }
 565   fBenchmark->Stop("Global track fitter");
 566   delete fitter;
 567 }
 568
 569 void AliHLTTPC::WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
 570                                  Int_t slice,Int_t patch)
 571 {
 572   char name[256];
 573   if(fNPatch==1)
 574     sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
 575   else
 576     sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
 577   AliHLTTPCMemHandler * memory = new AliHLTTPCMemHandler();
 578   memory->SetBinaryOutput(name);
 579   memory->Transform(npoints,points,slice);
 580   memory->Memory2Binary(npoints,points);
 581   memory->CloseBinaryOutput();
 582   delete  memory;
 583 }
 584
 585 Int_t AliHLTTPC::WriteTracks(char *filename,AliHLTTPCMerger *merger,char opt)
 586 {
 587   AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
 588   memory->SetBinaryOutput(filename);
 589   if(opt=='a'||opt=='i'){  //add intracks
 590     for(Int_t i=0;i<merger->GetNIn();i++){
 591       AliHLTTPCTrackArray *tr=merger->GetInTracks(i);
 592       memory->TrackArray2Binary(tr);
 593     }
 594   }
 595
 596   if(opt=='o'||opt=='a'){
 597     AliHLTTPCTrackArray *tr=merger->GetOutTracks();
 598     memory->TrackArray2Binary(tr);
 599   }
 600
 601   memory->CloseBinaryOutput();
 602
 603   return 1;
 604 }
 605
 606 void AliHLTTPC::WriteResults()
 607 {
 608   //Write the resulting tracks to outputfile
 609   Char_t fname[256];
 610   sprintf(fname,"%s/tracks_%d.raw",fWriteOutPath,fEvent);
 611   WriteTracks(fname,fGlobalMerger,'a');
 612   //WriteTracks("tracks.raw",fGlobalMerger,'a');
 613   sprintf(fname,"%s/tracks_gl_%d.raw",fWriteOutPath,fEvent);
 614   WriteTracks(fname,fGlobalMerger,'o');
 615   //WriteTracks("tracks_gl.raw",fGlobalMerger,'o');
 616 }