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