HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx

   1 // @(#) $Id$
   2 // **************************************************************************
   3 // This file is property of and copyright by the ALICE HLT Project          *
   4 // ALICE Experiment at CERN, All rights reserved.                           *
   5 //                                                                          *
   6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
   7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
   8 //                  for The ALICE HLT Project.                              *
   9 //                                                                          *
  10 // Permission to use, copy, modify and distribute this software and its     *
  11 // documentation strictly for non-commercial purposes is hereby granted     *
  12 // without fee, provided that the above copyright notice appears in all     *
  13 // copies and that both the copyright notice and this permission notice     *
  14 // appear in the supporting documentation. The authors make no claims       *
  15 // about the suitability of this software for any purpose. It is            *
  16 // provided "as is" without express or implied warranty.                    *
  17 //                                                                          *
  18 //***************************************************************************
  19
  20 #include "AliHLTTPCCATracker.h"
  21 #include "AliHLTTPCCAOutTrack.h"
  22 #include "AliHLTTPCCARow.h"
  23 #include "AliHLTTPCCATrack.h"
  24 #include "AliHLTTPCCATracklet.h"
  25 #include "AliHLTTPCCAMath.h"
  26 #include "MemoryAssignmentHelpers.h"
  27
  28 #include "TStopwatch.h"
  29 #include "AliHLTTPCCAHitArea.h"
  30 #include "AliHLTTPCCANeighboursFinder.h"
  31 #include "AliHLTTPCCANeighboursCleaner.h"
  32 #include "AliHLTTPCCAStartHitsFinder.h"
  33 #include "AliHLTTPCCATrackletConstructor.h"
  34 #include "AliHLTTPCCATrackletSelector.h"
  35 #include "AliHLTTPCCAProcess.h"
  36 #include "AliHLTTPCCASliceTrack.h"
  37 #include "AliHLTTPCCASliceOutput.h"
  38 #include "AliHLTTPCCAClusterData.h"
  39 #include "AliHLTTPCCADataCompressor.h"
  40
  41 #include "AliHLTTPCCATrackParam.h"
  42
  43 #include "AliHLTTPCCAGPUConfig.h"
  44
  45 #if !defined(HLTCA_GPUCODE)
  46 #include <iostream>
  47 #include <iomanip>
  48 #include <string.h>
  49 #endif
  50
  51 //#define DRAW1
  52
  53 #ifdef DRAW1
  54 #include "AliHLTTPCCADisplay.h"
  55 #endif //DRAW1
  56
  57 #ifdef HLTCA_INTERNAL_PERFORMANCE
  58 //#include "AliHLTTPCCAPerformance.h"
  59 #endif
  60
  61 #ifdef HLTCA_STANDALONE
  62 #include "AliHLTTPCCAStandaloneFramework.h"
  63 #endif
  64
  65 ClassImp( AliHLTTPCCATracker )
  66
  67
  68 #if !defined(HLTCA_GPUCODE)
  69
  70 AliHLTTPCCATracker::~AliHLTTPCCATracker()
  71 {
  72   // destructor
  73         if (!fIsGPUTracker)
  74         {
  75                 if (fCommonMem) delete fCommonMem;
  76                 if (fHitMemory) delete[] fHitMemory;
  77                 if (fTrackletMemory) delete[] fTrackletMemory;
  78                 if (fTrackMemory) delete[] fTrackMemory;
  79                 fCommonMem = NULL;
  80                 fHitMemory = fTrackMemory = NULL;
  81         }
  82 }
  83
  84 // ----------------------------------------------------------------------------------
  85 void AliHLTTPCCATracker::Initialize( const AliHLTTPCCAParam &param )
  86 {
  87   // initialisation
  88   fParam = param;
  89   fParam.Update();
  90   fData.InitializeRows( fParam );
  91
  92   StartEvent();
  93 }
  94
  95 void AliHLTTPCCATracker::StartEvent()
  96 {
  97   // start new event and fresh the memory
  98
  99   SetupCommonMemory();
 100 }
 101
 102 void AliHLTTPCCATracker::SetGPUTracker()
 103 {
 104         //Make this a GPU Tracker
 105         fIsGPUTracker = true;
 106         fData.SetGpuSliceData();
 107 }
 108
 109 char* AliHLTTPCCATracker::SetGPUTrackerCommonMemory(char* const pGPUMemory)
 110 {
 111         //Set up common Memory Pointer for GPU Tracker
 112   fCommonMem = (commonMemoryStruct*) pGPUMemory;
 113   return(pGPUMemory + sizeof(commonMemoryStruct));
 114 }
 115
 116
 117 char* AliHLTTPCCATracker::SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits)
 118 {
 119         //Set up Hits Memory Pointers for GPU Tracker
 120         fHitMemory = (char*) pGPUMemory;
 121         SetPointersHits(MaxNHits);
 122         pGPUMemory += fHitMemorySize;
 123         AssignMemory(fTrackletTmpStartHits, pGPUMemory, NHitsTotal());
 124         AssignMemory(fRowStartHitCountOffset, pGPUMemory, Param().NRows());
 125
 126         return(pGPUMemory);
 127 }
 128
 129 char* AliHLTTPCCATracker::SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracks)
 130 {
 131         //Set up Tracklet Memory Pointers for GPU Tracker
 132         fTrackletMemory = (char*) pGPUMemory;
 133         SetPointersTracklets(MaxNTracks);
 134         pGPUMemory += fTrackletMemorySize;
 135         AssignMemory(fGPUTrackletTemp, pGPUMemory, MaxNTracks);
 136         AssignMemory(fRowBlockTracklets, pGPUMemory, MaxNTracks * 2 * (Param().NRows() / HLTCA_GPU_SCHED_ROW_STEP + 1));
 137         AssignMemory(fRowBlockPos, pGPUMemory, 2 * (Param().NRows() / HLTCA_GPU_SCHED_ROW_STEP + 1));
 138         AssignMemory(fBlockStartingTracklet, pGPUMemory, HLTCA_GPU_BLOCK_COUNT);
 139
 140         return(pGPUMemory);
 141 }
 142
 143 char* AliHLTTPCCATracker::SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits )
 144 {
 145         //Set up Tracks Memory Pointer for GPU Tracker
 146         fTrackMemory = (char*) pGPUMemory;
 147         SetPointersTracks(MaxNTracks, MaxNHits);
 148         pGPUMemory += fTrackMemorySize;
 149
 150         return(pGPUMemory);
 151 }
 152
 153 void AliHLTTPCCATracker::DumpSliceData(std::ostream &out)
 154 {
 155         //Dump Slice Input Data to File
 156         out << "Slice Data:" << std::endl;
 157         for (int i = 0;i < Param().NRows();i++)
 158         {
 159                 out << "Row: " << i << std::endl;
 160                 for (int j = 0;j < Row(i).NHits();j++)
 161                 {
 162                         if (j && j % 16 == 0) out << std::endl;
 163                         out << j << '-' << Data().HitDataY(Row(i), j) << '-' << Data().HitDataZ(Row(i), j) << ", ";
 164                 }
 165                 out << std::endl;
 166         }
 167 }
 168
 169 void AliHLTTPCCATracker::DumpLinks(std::ostream &out)
 170 {
 171         //Dump Links (after Neighbours Finder / Cleaner) to file
 172         out << "Hit Links:" << std::endl;
 173         for (int i = 0;i < Param().NRows();i++)
 174         {
 175                 out << "Row: " << i << std::endl;
 176                 for (int j = 0;j < Row(i).NHits();j++)
 177                 {
 178                         if (j && j % 32 == 0) out << std::endl;
 179                         out << HitLinkUpData(Row(i), j) << "/" << HitLinkDownData(Row(i), j) << ", ";
 180                 }
 181                 out << std::endl;
 182         }
 183 }
 184
 185 void AliHLTTPCCATracker::DumpHitWeights(std::ostream &out)
 186 {
 187         //dump hit weights to file
 188     out << "Hit Weights:" << std::endl;
 189     for (int i = 0;i < Param().NRows();i++)
 190     {
 191         out << "Row: " << i << ":" << std::endl;
 192         for (int j = 0;j < Row(i).NHits();j++)
 193         {
 194             if (j && j % 32 == 0) out << std::endl;
 195             out << HitWeight(Row(i), j) << ", ";
 196         }
 197         out << std::endl;
 198     }
 199 }
 200
 201 int AliHLTTPCCATracker::StarthitSortComparison(const void*a, const void* b)
 202 {
 203         //qsort helper function to sort start hits
 204         AliHLTTPCCAHitId* aa = (AliHLTTPCCAHitId*) a;
 205         AliHLTTPCCAHitId* bb = (AliHLTTPCCAHitId*) b;
 206
 207         if (aa->RowIndex() != bb->RowIndex()) return(aa->RowIndex() - bb->RowIndex());
 208         return(aa->HitIndex() - bb->HitIndex());
 209 }
 210
 211 void AliHLTTPCCATracker::DumpStartHits(std::ostream &out)
 212 {
 213         //sort start hits and dump to file
 214         out << "Start Hits: (" << *NTracklets() << ")" << std::endl;
 215 #ifdef HLTCA_GPU_SORT_DUMPDATA
 216         qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
 217 #endif
 218         for (int i = 0;i < *NTracklets();i++)
 219         {
 220                 out << TrackletStartHit(i).RowIndex() << "-" << TrackletStartHit(i).HitIndex() << std::endl;
 221         }
 222         out << std::endl;
 223 }
 224
 225 void AliHLTTPCCATracker::DumpTrackHits(std::ostream &out)
 226 {
 227         //dump tracks to file
 228         out << "Tracks: (" << *NTracks() << ")" << std::endl;
 229 #ifdef HLTCA_GPU_SORT_DUMPDATA
 230         for (int k = 0;k < Param().NRows();k++)
 231         {
 232                 for (int l = 0;l < Row(k).NHits();l++)
 233                 {
 234 #endif
 235                         for (int j = 0;j < *NTracks();j++)
 236                         {
 237                                 if (Tracks()[j].NHits() == 0 || !Tracks()[j].Alive()) continue;
 238 #ifdef HLTCA_GPU_SORT_DUMPDATA
 239                                 if (TrackHits()[Tracks()[j].FirstHitID()].RowIndex() == k && TrackHits()[Tracks()[j].FirstHitID()].HitIndex() == l)
 240                                 {
 241 #endif
 242                                         for (int i = 0;i < Tracks()[j].NHits();i++)
 243                                         {
 244                                                 out << TrackHits()[Tracks()[j].FirstHitID() + i].RowIndex() << "-" << TrackHits()[Tracks()[j].FirstHitID() + i].HitIndex() << ", ";
 245                                         }
 246                                         out << "(Track: " << j << ")" << std::endl;
 247 #ifdef HLTCA_GPU_SORT_DUMPDATA
 248                                 }
 249                         }
 250 #endif
 251                 }
 252 #ifdef HLTCA_GPU_SORT_DUMPDATA
 253         }
 254 #endif
 255 }
 256
 257 void AliHLTTPCCATracker::DumpTrackletHits(std::ostream &out)
 258 {
 259         //dump tracklets to file
 260         out << "Tracklets: (" << *NTracklets() << ")" << std::endl;
 261 #ifdef HLTCA_GPU_SORT_DUMPDATA
 262         AliHLTTPCCAHitId* tmpIds = new AliHLTTPCCAHitId[*NTracklets()];
 263         AliHLTTPCCATracklet* tmpTracklets = new AliHLTTPCCATracklet[*NTracklets()];
 264         memcpy(tmpIds, TrackletStartHits(), *NTracklets() * sizeof(AliHLTTPCCAHitId));
 265         memcpy(tmpTracklets, Tracklets(), *NTracklets() * sizeof(AliHLTTPCCATracklet));
 266 #ifdef EXTERN_ROW_HITS
 267         int* tmpHits = new int[*NTracklets() * Param().NRows()];
 268         memcpy(tmpHits, TrackletRowHits(), *NTracklets() * Param().NRows() * sizeof(int));
 269 #endif
 270         qsort(TrackletStartHits(), *NTracklets(), sizeof(AliHLTTPCCAHitId), StarthitSortComparison);
 271         for (int i = 0;i < *NTracklets();i++)
 272         {
 273                 for (int j = 0;j < *NTracklets();j++)
 274                 {
 275                         if (tmpIds[i].RowIndex() == TrackletStartHit(j).RowIndex() && tmpIds[i].HitIndex() == TrackletStartHit(j).HitIndex())
 276                         {
 277                                 memcpy(&Tracklets()[j], &tmpTracklets[i], sizeof(AliHLTTPCCATracklet));
 278 #ifdef EXTERN_ROW_HITS
 279                                 if (tmpTracklets[i].NHits())
 280                                 {
 281                                         for (int k = tmpTracklets[i].FirstRow();k <= tmpTracklets[i].LastRow();k++)
 282                                         {
 283                                                 fTrackletRowHits[k * *NTracklets() + j] = tmpHits[k * *NTracklets() + i];
 284                                         }
 285                                 }
 286 #endif
 287                                 break;
 288                         }
 289                 }
 290         }
 291         delete[] tmpIds;
 292         delete[] tmpTracklets;
 293 #ifdef EXTERN_ROW_HITS
 294         delete[] tmpHits;
 295 #endif
 296 #endif
 297         for (int j = 0;j < *NTracklets();j++)
 298         {
 299                 out << "Tracklet " << j << " (Hits: " << std::setw(3) << Tracklets()[j].NHits() << ", Start: " << std::setw(3) << TrackletStartHit(j).RowIndex() << "-" << std::setw(3) << TrackletStartHit(j).HitIndex() << ") ";
 300                 if (Tracklets()[j].NHits() == 0);
 301                 else if (Tracklets()[j].LastRow() > Tracklets()[j].FirstRow() && (Tracklets()[j].FirstRow() >= Param().NRows() || Tracklets()[j].LastRow() >= Param().NRows()))
 302                 {
 303 #ifdef HLTCA_STANDALONE
 304                         printf("\nError: First %d Last %d Num %d", Tracklets()[j].FirstRow(), Tracklets()[j].LastRow(), Tracklets()[j].NHits());
 305 #endif
 306                 }
 307                 else if (Tracklets()[j].NHits() && Tracklets()[j].LastRow() > Tracklets()[j].FirstRow())
 308                 {
 309                         for (int i = Tracklets()[j].FirstRow();i <= Tracklets()[j].LastRow();i++)
 310                         {
 311                                 //if (Tracklets()[j].RowHit(i) != -1)
 312 #ifdef EXTERN_ROW_HITS
 313                                         out << i << "-" << fTrackletRowHits[i * fCommonMem->fNTracklets + j] << ", ";
 314 #else
 315                                         out << i << "-" << Tracklets()[j].RowHit(i) << ", ";
 316 #endif
 317                         }
 318                 }
 319                 out << std::endl;
 320         }
 321 }
 322
 323
 324 void AliHLTTPCCATracker::SetupCommonMemory()
 325 {
 326   // set up common memory
 327
 328   if (!fIsGPUTracker)
 329   {
 330     if ( !fCommonMem ) {
 331       // the 1600 extra bytes are not used unless fCommonMemorySize increases with a later event
 332       //fCommonMemory = reinterpret_cast<char*> ( new uint4 [ fCommonMemorySize/sizeof( uint4 ) + 100] );
 333           fCommonMem = new commonMemoryStruct;
 334     }
 335
 336         if (fHitMemory) delete[] fHitMemory;
 337         if (fTrackletMemory) delete[] fTrackletMemory;
 338         if (fTrackMemory) delete[] fTrackMemory;
 339   }
 340
 341   fHitMemory = fTrackletMemory = fTrackMemory = 0;
 342
 343   fData.Clear();
 344   fCommonMem->fNTracklets = 0;
 345   fCommonMem->fNTracks = 0 ;
 346   fCommonMem->fNTrackHits = 0;
 347 }
 348
 349 void AliHLTTPCCATracker::ReadEvent( AliHLTTPCCAClusterData *clusterData )
 350 {
 351   // read event
 352
 353   fClusterData = clusterData;
 354
 355   StartEvent();
 356
 357   //* Convert input hits, create grids, etc.
 358   fData.InitFromClusterData( *clusterData );
 359   {
 360     if (!fIsGPUTracker)
 361         {
 362                 SetPointersHits( fData.NumberOfHits() ); // to calculate the size
 363                 fHitMemory = reinterpret_cast<char*> ( new uint4 [ fHitMemorySize/sizeof( uint4 ) + 100] );
 364         }
 365     SetPointersHits( fData.NumberOfHits() ); // set pointers for hits
 366   }
 367 }
 368
 369 GPUhd() void  AliHLTTPCCATracker::SetPointersHits( int MaxNHits )
 370 {
 371   // set all pointers to the event memory
 372
 373   char *mem = fHitMemory;
 374
 375   // extra arrays for tpc clusters
 376
 377 #ifdef HLTCA_GPU_SORT_STARTHITS_2
 378   AssignMemory( fTrackletStartHits, mem, MaxNHits + 32);
 379 #else
 380   AssignMemory( fTrackletStartHits, mem, MaxNHits);
 381 #endif
 382
 383   // calculate the size
 384
 385   fHitMemorySize = mem - fHitMemory;
 386 }
 387
 388 GPUhd() void  AliHLTTPCCATracker::SetPointersTracklets( int MaxNTracklets )
 389 {
 390   // set all pointers to the tracklets memory
 391   char *mem = fTrackletMemory;
 392
 393   // memory for tracklets
 394
 395   AssignMemory( fTracklets, mem, MaxNTracklets );
 396 #ifdef EXTERN_ROW_HITS
 397   AssignMemory( fTrackletRowHits, mem, MaxNTracklets * Param().NRows());
 398 #endif
 399
 400   fTrackletMemorySize = mem - fTrackletMemory;
 401 }
 402
 403
 404 GPUhd() void  AliHLTTPCCATracker::SetPointersTracks( int MaxNTracks, int MaxNHits )
 405 {
 406   // set all pointers to the tracks memory
 407   char *mem = fTrackMemory;
 408
 409   // memory for selected tracks
 410
 411   AssignMemory( fTracks, mem, MaxNTracks );
 412   AssignMemory( fTrackHits, mem, 2 * MaxNHits );
 413
 414   // calculate the size
 415
 416   fTrackMemorySize = mem - fTrackMemory;
 417 }
 418
 419 GPUh() int AliHLTTPCCATracker::CheckEmptySlice() const
 420 {
 421         //Check if the Slice is empty, if so set the output apropriate and tell the reconstuct procesdure to terminate
 422   if ( NHitsTotal() < 1 ) {
 423     {
 424       AliHLTTPCCASliceOutput::Allocate(*fOutput, 0, 0, fOutputControl);
 425       AliHLTTPCCASliceOutput* useOutput = *fOutput;
 426       if (useOutput == NULL) return(1);
 427       useOutput->SetNTracks( 0 );
 428       useOutput->SetNTrackClusters( 0 );
 429       useOutput->SetNOutTracks(0);
 430       useOutput->SetNOutTrackHits(0);
 431     }
 432
 433     return 1;
 434   }
 435   return 0;
 436 }
 437
 438 void AliHLTTPCCATracker::RunNeighboursFinder()
 439 {
 440         //Run the CPU Neighbours Finder
 441         AliHLTTPCCAProcess<AliHLTTPCCANeighboursFinder>( Param().NRows(), 1, *this );
 442 }
 443
 444 void AliHLTTPCCATracker::RunNeighboursCleaner()
 445 {
 446         //Run the CPU Neighbours Cleaner
 447         AliHLTTPCCAProcess<AliHLTTPCCANeighboursCleaner>( Param().NRows() - 2, 1, *this );
 448 }
 449
 450 void AliHLTTPCCATracker::RunStartHitsFinder()
 451 {
 452         //Run the CPU Start Hits Finder
 453         AliHLTTPCCAProcess<AliHLTTPCCAStartHitsFinder>( Param().NRows() - 4, 1, *this );
 454 }
 455
 456 void AliHLTTPCCATracker::RunTrackletConstructor()
 457 {
 458         //Run CPU Tracklet Constructor
 459   AliHLTTPCCATrackletConstructor::AliHLTTPCCATrackletConstructorNewCPU(*this);
 460 }
 461
 462 void AliHLTTPCCATracker::RunTrackletSelector()
 463 {
 464         //Run CPU Tracklet Selector
 465   AliHLTTPCCAProcess<AliHLTTPCCATrackletSelector>( 1, fCommonMem->fNTracklets, *this );
 466 }
 467
 468 #ifdef HLTCA_STANDALONE
 469 void AliHLTTPCCATracker::StandalonePerfTime(int i)
 470 {
 471   //Query Performance Timer for Standalone Version of Tracker
 472   if (fGPUDebugLevel >= 1)
 473   {
 474     AliHLTTPCCAStandaloneFramework::StandaloneQueryTime(&fPerfTimers[i]);
 475   }
 476 }
 477 #else
 478 void AliHLTTPCCATracker::StandalonePerfTime(int /*i*/) {}
 479 #endif
 480
 481 GPUh() void AliHLTTPCCATracker::Reconstruct()
 482 {
 483   //* reconstruction of event
 484   //std::cout<<"Reconstruct slice "<<fParam.ISlice()<<", nHits="<<NHitsTotal()<<std::endl;
 485
 486   fTimers[0] = 0; // find neighbours
 487   fTimers[1] = 0; // construct tracklets
 488   fTimers[2] = 0; // fit tracklets
 489   fTimers[3] = 0; // prolongation of tracklets
 490   fTimers[4] = 0; // selection
 491   fTimers[5] = 0; // write output
 492   fTimers[6] = 0;
 493   fTimers[7] = 0;
 494
 495   //if( fParam.ISlice()<1 ) return; //SG!!!
 496
 497   TStopwatch timer0;
 498
 499   StandalonePerfTime(0);
 500
 501   if (CheckEmptySlice()) return;
 502
 503 #ifdef DRAW1
 504   //if( fParam.ISlice()==2 || fParam.ISlice()==3)
 505     {
 506   AliHLTTPCCADisplay::Instance().ClearView();
 507   AliHLTTPCCADisplay::Instance().SetSliceView();
 508   AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
 509   AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );
 510   if ( NHitsTotal() > 0 ) {
 511     AliHLTTPCCADisplay::Instance().DrawSliceHits( kRed, .5 );
 512     AliHLTTPCCADisplay::Instance().Ask();
 513   }
 514   }
 515 #endif //DRAW1
 516
 517         fCommonMem->fNTracklets = fCommonMem->fNTracks = fCommonMem->fNTrackHits = 0;
 518
 519 #if !defined(HLTCA_GPUCODE)
 520
 521   if (fGPUDebugLevel >= 6)
 522   {
 523           *fGPUDebugOut << std::endl << std::endl << "Slice: " << Param().ISlice() << std::endl;
 524           *fGPUDebugOut << "Slice Data:" << std::endl;
 525           DumpSliceData(*fGPUDebugOut);
 526   }
 527
 528   StandalonePerfTime(1);
 529
 530   RunNeighboursFinder();
 531
 532   StandalonePerfTime(2);
 533
 534   if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut);
 535
 536 #ifdef HLTCA_INTERNAL_PERFORMANCE
 537   //if( Param().ISlice()<=2 )
 538   //AliHLTTPCCAPerformance::Instance().LinkPerformance( Param().ISlice() );
 539 #endif
 540
 541
 542 #ifdef DRAW1
 543   if ( NHitsTotal() > 0 ) {
 544     AliHLTTPCCADisplay::Instance().DrawSliceLinks( -1, -1, 1 );
 545     AliHLTTPCCADisplay::Instance().Ask();
 546   }
 547 #endif //DRAW1
 548
 549   RunNeighboursCleaner();
 550
 551   StandalonePerfTime(3);
 552
 553   if (fGPUDebugLevel >= 6) DumpLinks(*fGPUDebugOut);
 554
 555   RunStartHitsFinder();
 556
 557   StandalonePerfTime(4);
 558   StandalonePerfTime(5);
 559
 560   if (fGPUDebugLevel >= 6) DumpStartHits(*fGPUDebugOut);
 561
 562   fData.ClearHitWeights();
 563
 564   SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // to calculate the size
 565   fTrackletMemory = reinterpret_cast<char*> ( new uint4 [ fTrackletMemorySize/sizeof( uint4 ) + 100] );
 566   SetPointersTracklets( fCommonMem->fNTracklets * 2 ); // set pointers for hits
 567
 568   SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // to calculate the size
 569   fTrackMemory = reinterpret_cast<char*> ( new uint4 [ fTrackMemorySize/sizeof( uint4 ) + 100] );
 570   SetPointersTracks( fCommonMem->fNTracklets * 2, NHitsTotal() ); // set pointers for hits
 571
 572   StandalonePerfTime(6);
 573   StandalonePerfTime(7);
 574
 575   RunTrackletConstructor();
 576
 577   StandalonePerfTime(8);
 578
 579   if (fGPUDebugLevel >= 6) DumpTrackletHits(*fGPUDebugOut);
 580   if (fGPUDebugLevel >= 6) DumpHitWeights(*fGPUDebugOut);
 581
 582   //std::cout<<"Slice "<<Param().ISlice()<<": NHits="<<NHitsTotal()<<", NTracklets="<<*NTracklets()<<std::endl;
 583
 584   RunTrackletSelector();
 585
 586   StandalonePerfTime(9);
 587
 588   //std::cout<<"Slice "<<Param().ISlice()<<": N start hits/tracklets/tracks = "<<nStartHits<<" "<<nStartHits<<" "<<*fNTracks<<std::endl;
 589
 590   if (fGPUDebugLevel >= 6) DumpTrackHits(*fGPUDebugOut);
 591
 592   //std::cout<<"Memory used for slice "<<fParam.ISlice()<<" : "<<fCommonMemorySize/1024./1024.<<" + "<<fHitMemorySize/1024./1024.<<" + "<<fTrackMemorySize/1024./1024.<<" = "<<( fCommonMemorySize+fHitMemorySize+fTrackMemorySize )/1024./1024.<<" Mb "<<std::endl;
 593
 594   WriteOutput();
 595
 596   StandalonePerfTime(10);
 597
 598 #endif
 599
 600 #ifdef DRAW1
 601   {
 602     AliHLTTPCCADisplay &disp = AliHLTTPCCADisplay::Instance();
 603     AliHLTTPCCATracker &slice = *this;
 604     std::cout << "N out tracks = " << slice.NOutTracks() << std::endl;
 605     AliHLTTPCCADisplay::Instance().SetSliceView();
 606     AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
 607     AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );
 608     disp.DrawSliceHits( kRed, .5 );
 609     disp.Ask();
 610     for ( int itr = 0; itr < slice.NOutTracks(); itr++ ) {
 611       std::cout << "track N " << itr << ", nhits=" << slice.OutTracks()[itr].NHits() << std::endl;
 612       disp.DrawSliceOutTrack( itr, kBlue );
 613       //disp.Ask();
 614       //int id = slice.OutTracks()[itr].OrigTrackID();
 615       //AliHLTTPCCATrack &tr = Tracks()[id];
 616       //for( int ih=0; ih<tr.NHits(); ih++ ){
 617       //int ic = (fTrackHits[tr.FirstHitID()+ih]);
 618       //std::cout<<ih<<" "<<ID2IRow(ic)<<" "<<ID2IHit(ic)<<std::endl;
 619       //}
 620       //disp.DrawSliceTrack( id, kBlue );
 621       //disp.Ask();
 622     }
 623     disp.Ask();
 624   }
 625 #endif //DRAW1
 626
 627   timer0.Stop();
 628   fTimers[0] = timer0.CpuTime() / 100.;
 629
 630 }
 631
 632 GPUh() void AliHLTTPCCATracker::WriteOutput()
 633 {
 634   // write output
 635
 636   TStopwatch timer;
 637
 638   //cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl;
 639
 640   if (fOutputControl == NULL) fOutputControl = new AliHLTTPCCASliceOutput::outputControlStruct;
 641   AliHLTTPCCASliceOutput::Allocate(*fOutput, fCommonMem->fNTracks, fCommonMem->fNTrackHits, fOutputControl);
 642   AliHLTTPCCASliceOutput* useOutput = *fOutput;
 643   if (useOutput == NULL) return;
 644
 645   if (fOutputControl->fDefaultOutput)
 646   {
 647           useOutput->SetNTracks( fCommonMem->fNTracks );
 648           useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
 649
 650           int nStoredHits = 0;
 651
 652           for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
 653                 AliHLTTPCCATrack &iTrack = fTracks[iTr];
 654
 655                 AliHLTTPCCASliceTrack out;
 656                 out.SetFirstClusterRef( nStoredHits );
 657                 out.SetNClusters( iTrack.NHits() );
 658                 out.SetParam( iTrack.Param() );
 659
 660                 useOutput->SetTrack( iTr, out );
 661
 662                 int iID = iTrack.FirstHitID();
 663                 for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
 664                   const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
 665                   int iRow = ic.RowIndex();
 666                   int ih = ic.HitIndex();
 667
 668                   const AliHLTTPCCARow &row = fData.Row( iRow );
 669
 670                   //float y0 = row.Grid().YMin();
 671                   //float z0 = row.Grid().ZMin();
 672                   //float stepY = row.HstepY();
 673                   //float stepZ = row.HstepZ();
 674                   //float x = row.X();
 675
 676                   //const uint4 *tmpint4 = RowData() + row.FullOffset();
 677                   //const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
 678                   //ushort2 hh = hits[ih];
 679                   //float y = y0 + hh.x*stepY;
 680                   //float z = z0 + hh.y*stepZ;
 681
 682                   int clusterIndex = fData.ClusterDataIndex( row, ih );
 683                   int clusterRowIndex = clusterIndex - fClusterData->RowOffset( iRow );
 684
 685                   if ( clusterIndex < 0 || clusterIndex >= fClusterData->NumberOfClusters() ) {
 686                         //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
 687                         //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
 688                         //abort();
 689                         continue;
 690                   }
 691                   if ( clusterRowIndex < 0 || clusterRowIndex >= fClusterData->NumberOfClusters( iRow ) ) {
 692                         //std::cout << inpIDtot << ", " << fClusterData->NumberOfClusters()
 693                         //<< "; " << inpID << ", " << fClusterData->NumberOfClusters( iRow ) << std::endl;
 694                         //abort();
 695                         continue;
 696                   }
 697
 698                   float origX = fClusterData->X( clusterIndex );
 699                   float origY = fClusterData->Y( clusterIndex );
 700                   float origZ = fClusterData->Z( clusterIndex );
 701
 702
 703                   int id = fClusterData->Id( clusterIndex );
 704                   AliHLTTPCCACompressedCluster cXYZ = AliHLTTPCCADataCompressor::PackXYZ( iRow, origX, origY, origZ );
 705
 706                   //float2 hUnpackedYZ;
 707                   //hUnpackedYZ.x = origY;
 708                   //hUnpackedYZ.y = origZ;
 709                   //float hUnpackedX = origX;
 710
 711                   useOutput->SetClusterId( nStoredHits, id  );
 712                   useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
 713                   useOutput->SetClusterPackedXYZ( nStoredHits, cXYZ );
 714                   nStoredHits++;
 715                 }
 716           }
 717   }
 718
 719
 720   // old stuff
 721   if (fOutputControl->fObsoleteOutput)
 722   {
 723           useOutput->SetNOutTrackHits(0);
 724           useOutput->SetNOutTracks(0);
 725
 726
 727           for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
 728
 729                 const AliHLTTPCCATrack &iTrack = fTracks[iTr];
 730
 731                 //std::cout<<"iTr = "<<iTr<<", nHits="<<iTrack.NHits()<<std::endl;
 732
 733                 //if( !iTrack.Alive() ) continue;
 734                 if ( iTrack.NHits() < 3 ) continue;
 735                 AliHLTTPCCAOutTrack &out = useOutput->OutTracks()[useOutput->NOutTracks()];
 736                 out.SetFirstHitRef( useOutput->NOutTrackHits() );
 737                 out.SetNHits( 0 );
 738                 out.SetOrigTrackID( iTr );
 739                 AliHLTTPCCATrackParam tmpParam;
 740                 tmpParam.InitParam();
 741                 tmpParam.SetParam(iTrack.Param());
 742                 out.SetStartPoint( tmpParam );
 743                 out.SetEndPoint( tmpParam );
 744
 745                 int iID = iTrack.FirstHitID();
 746                 int nOutTrackHitsOld = useOutput->NOutTrackHits();
 747
 748                 for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
 749                   const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
 750                   const AliHLTTPCCARow &row = Row( ic );
 751                   int ih = ic.HitIndex();
 752                   useOutput->SetOutTrackHit(useOutput->NOutTrackHits(), HitInputID( row, ih ));
 753                   useOutput->SetNOutTrackHits(useOutput->NOutTrackHits() + 1 );
 754                   //std::cout<<"write i,row,hit,id="<<ith<<", "<<ID2IRow(ic)<<", "<<ih<<", "<<HitInputID( row, ih )<<std::endl;
 755                   if ( useOutput->NOutTrackHits() >= 10*NHitsTotal() ) {
 756                         std::cout << "fNOutTrackHits>NHitsTotal()" << std::endl;
 757                         //exit(0);
 758                         return;//SG!!!
 759                   }
 760                   out.SetNHits( out.NHits() + 1 );
 761                 }
 762                 if ( out.NHits() >= 2 ) {
 763                   useOutput->SetNOutTracks(useOutput->NOutTracks() + 1);
 764                 } else {
 765                   useOutput->SetNOutTrackHits(nOutTrackHitsOld);
 766                 }
 767           }
 768   }
 769
 770   timer.Stop();
 771   fTimers[5] += timer.CpuTime();
 772 }
 773
 774 #endif
 775
 776 GPUh() void AliHLTTPCCATracker::FitTrackFull( const AliHLTTPCCATrack &/**/, float * /**/ ) const
 777 {
 778   // fit track with material
 779 #ifdef XXX
 780   //* Fit the track
 781   FitTrack( iTrack, tt0 );
 782   if ( iTrack.NHits() <= 3 ) return;
 783
 784   AliHLTTPCCATrackParam &t = iTrack.Param();
 785   AliHLTTPCCATrackParam t0 = t;
 786
 787   t.Chi2() = 0;
 788   t.NDF() = -5;
 789   bool first = 1;
 790
 791   int iID = iTrack.FirstHitID();
 792   for ( int ih = 0; ih < iTrack.NHits(); ih++, iID++ ) {
 793     const AliHLTTPCCAHitId &ic = fTrackHits[iID];
 794     int iRow = ic.rowIndex();
 795     const AliHLTTPCCARow &row = fData.Row( iRow );
 796     if ( !t0.TransportToX( row.X() ) ) continue;
 797     float dy, dz;
 798     const AliHLTTPCCAHit &h = ic.hitIndex();
 799
 800     // check for wrong hits
 801     if ( 0 ) {
 802       dy = t0.GetY() - h.Y();
 803       dz = t0.GetZ() - h.Z();
 804
 805       //if( dy*dy > 3.5*3.5*(/*t0.GetErr2Y() + */h.ErrY()*h.ErrY() ) ) continue;//SG!!!
 806       //if( dz*dz > 3.5*3.5*(/*t0.GetErr2Z() + */h.ErrZ()*h.ErrZ() ) ) continue;
 807     }
 808
 809     if ( !t.TransportToX( row.X() ) ) continue;
 810
 811     //* Update the track
 812
 813     if ( first ) {
 814       t.Cov()[ 0] = .5 * .5;
 815       t.Cov()[ 1] = 0;
 816       t.Cov()[ 2] = .5 * .5;
 817       t.Cov()[ 3] = 0;
 818       t.Cov()[ 4] = 0;
 819       t.Cov()[ 5] = .2 * .2;
 820       t.Cov()[ 6] = 0;
 821       t.Cov()[ 7] = 0;
 822       t.Cov()[ 8] = 0;
 823       t.Cov()[ 9] = .2 * .2;
 824       t.Cov()[10] = 0;
 825       t.Cov()[11] = 0;
 826       t.Cov()[12] = 0;
 827       t.Cov()[13] = 0;
 828       t.Cov()[14] = .2 * .2;
 829       t.Chi2() = 0;
 830       t.NDF() = -5;
 831     }
 832     float err2Y, err2Z;
 833     GetErrors2( iRow, t, err2Y, err2Z );
 834
 835     if ( !t.Filter2( h.Y(), h.Z(), err2Y, err2Z ) ) continue;
 836
 837     first = 0;
 838   }
 839   /*
 840   float cosPhi = iTrack.Param().GetCosPhi();
 841   p0.Param().TransportToX(ID2Row( iTrack.PointID()[0] ).X());
 842   p2.Param().TransportToX(ID2Row( iTrack.PointID()[1] ).X());
 843   if( p0.Param().GetCosPhi()*cosPhi<0 ){ // change direction
 844   float *par = p0.Param().Par();
 845   float *cov = p0.Param().Cov();
 846   par[2] = -par[2]; // sin phi
 847   par[3] = -par[3]; // DzDs
 848     par[4] = -par[4]; // kappa
 849     cov[3] = -cov[3];
 850     cov[4] = -cov[4];
 851     cov[6] = -cov[6];
 852     cov[7] = -cov[7];
 853     cov[10] = -cov[10];
 854     cov[11] = -cov[11];
 855     p0.Param().CosPhi() = -p0.Param().GetCosPhi();
 856   }
 857   */
 858 #endif
 859 }
 860
 861 GPUh() void AliHLTTPCCATracker::FitTrack( const AliHLTTPCCATrack &/*track*/, float * /*t0[]*/ ) const
 862 {
 863   //* Fit the track
 864 #ifdef XXX
 865   AliHLTTPCCAEndPoint &p2 = ID2Point( track.PointID()[1] );
 866   const AliHLTTPCCAHit &c0 = ID2Hit( fTrackHits[p0.TrackHitID()].HitID() );
 867   const AliHLTTPCCAHit &c1 = ID2Hit( fTrackHits[track.HitID()[1]].HitID() );
 868   const AliHLTTPCCAHit &c2 = ID2Hit( fTrackHits[p2.TrackHitID()].HitID() );
 869   const AliHLTTPCCARow &row0 = ID2Row( fTrackHits[p0.TrackHitID()].HitID() );
 870   const AliHLTTPCCARow &row1 = ID2Row( fTrackHits[track.HitID()[1]].HitID() );
 871   const AliHLTTPCCARow &row2 = ID2Row( fTrackHits[p2.TrackHitID()].HitID() );
 872   float sp0[5] = {row0.X(), c0.Y(), c0.Z(), c0.ErrY(), c0.ErrZ() };
 873   float sp1[5] = {row1.X(), c1.Y(), c1.Z(), c1.ErrY(), c1.ErrZ() };
 874   float sp2[5] = {row2.X(), c2.Y(), c2.Z(), c2.ErrY(), c2.ErrZ() };
 875   //std::cout<<"Fit track, points ="<<sp0[0]<<" "<<sp0[1]<<" / "<<sp1[0]<<" "<<sp1[1]<<" / "<<sp2[0]<<" "<<sp2[1]<<std::endl;
 876   if ( track.NHits() >= 3 ) {
 877     p0.Param().ConstructXYZ3( sp0, sp1, sp2, p0.Param().CosPhi(), t0 );
 878     p2.Param().ConstructXYZ3( sp2, sp1, sp0, p2.Param().CosPhi(), t0 );
 879     //p2.Param() = p0.Param();
 880     //p2.Param().TransportToX(row2.X());
 881     //p2.Param().Par()[1] = -p2.Param().Par()[1];
 882     //p2.Param().Par()[4] = -p2.Param().Par()[4];
 883   } else {
 884     p0.Param().X() = row0.X();
 885     p0.Param().Y() = c0.Y();
 886     p0.Param().Z() = c0.Z();
 887     p0.Param().Err2Y() = c0.ErrY() * c0.ErrY();
 888     p0.Param().Err2Z() = c0.ErrZ() * c0.ErrZ();
 889     p2.Param().X() = row2.X();
 890     p2.Param().Y() = c2.Y();
 891     p2.Param().Z() = c2.Z();
 892     p2.Param().Err2Y() = c2.ErrY() * c2.ErrY();
 893     p2.Param().Err2Z() = c2.ErrZ() * c2.ErrZ();
 894   }
 895 #endif
 896 }
 897
 898
 899 GPUd() void AliHLTTPCCATracker::GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const
 900 {
 901   //
 902   // Use calibrated cluster error from OCDB
 903   //
 904
 905   fParam.GetClusterErrors2( iRow, z, sinPhi, cosPhi, DzDs, Err2Y, Err2Z );
 906   Err2Y*=fParam.ClusterError2CorrectionY();
 907   Err2Z*=fParam.ClusterError2CorrectionZ();
 908 }
 909
 910 GPUd() void AliHLTTPCCATracker::GetErrors2( int iRow, const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const
 911 {
 912   //
 913   // Use calibrated cluster error from OCDB
 914   //
 915
 916   fParam.GetClusterErrors2( iRow, t.GetZ(), t.SinPhi(), t.GetCosPhi(), t.DzDs(), Err2Y, Err2Z );
 917 }
 918
 919
 920 #if !defined(HLTCA_GPUCODE)
 921
 922 GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
 923 {
 924   // write event to the file
 925   for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) {
 926     out << fData.Row( iRow ).HitNumberOffset() << " " << fData.Row( iRow ).NHits() << std::endl;
 927   }
 928   out << NHitsTotal() << std::endl;
 929
 930   AliHLTResizableArray<float> y( NHitsTotal() ), z( NHitsTotal() );
 931
 932   for ( int iRow = 0; iRow < fParam.NRows(); iRow++ ) {
 933     const AliHLTTPCCARow &row = Row( iRow );
 934     float y0 = row.Grid().YMin();
 935     float z0 = row.Grid().ZMin();
 936     float stepY = row.HstepY();
 937     float stepZ = row.HstepZ();
 938     for ( int ih = 0; ih < fData.Row( iRow ).NHits(); ih++ ) {
 939       int id = HitInputID( row, ih );
 940       y[id] = y0 + HitDataY( row, ih ) * stepY;
 941       z[id] = z0 + HitDataZ( row, ih ) * stepZ;
 942     }
 943   }
 944   for ( int ih = 0; ih < NHitsTotal(); ih++ ) {
 945     out << y[ih] << " " << z[ih] << std::endl;
 946   }
 947 }
 948
 949 GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out )
 950 {
 951   //* Write tracks to file
 952   AliHLTTPCCASliceOutput* useOutput = *fOutput;
 953
 954   out << fTimers[0] << std::endl;
 955   out << useOutput->NOutTrackHits() << std::endl;
 956   for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
 957     out << useOutput->OutTrackHit(ih) << " ";
 958   }
 959   out << std::endl;
 960
 961   out << useOutput->NOutTracks() << std::endl;
 962
 963   for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
 964     const AliHLTTPCCAOutTrack &t = useOutput->OutTrack(itr);
 965     AliHLTTPCCATrackParam p1 = t.StartPoint();
 966     AliHLTTPCCATrackParam p2 = t.EndPoint();
 967     out << t.NHits() << " ";
 968     out << t.FirstHitRef() << " ";
 969     out << t.OrigTrackID() << " ";
 970     out << std::endl;
 971     out << p1.X() << " ";
 972     out << p1.SignCosPhi() << " ";
 973     out << p1.Chi2() << " ";
 974     out << p1.NDF() << std::endl;
 975     for ( int i = 0; i < 5; i++ ) out << p1.Par()[i] << " ";
 976     out << std::endl;
 977     for ( int i = 0; i < 15; i++ ) out << p1.Cov()[i] << " ";
 978     out << std::endl;
 979     out << p2.X() << " ";
 980     out << p2.SignCosPhi() << " ";
 981     out << p2.Chi2() << " ";
 982     out << p2.NDF() << std::endl;
 983     for ( int i = 0; i < 5; i++ ) out << p2.Par()[i] << " ";
 984     out << std::endl;
 985     for ( int i = 0; i < 15; i++ ) out << p2.Cov()[i] << " ";
 986     out << std::endl;
 987   }
 988 }
 989
 990 GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in )
 991 {
 992   //* Read tracks  from file
 993   AliHLTTPCCASliceOutput::Allocate(*fOutput, 4096, 16384, fOutputControl);//Just some max values
 994   AliHLTTPCCASliceOutput* useOutput = *fOutput;
 995
 996   int tmpval;
 997   in >> fTimers[0];
 998   in >> tmpval;
 999   useOutput->SetNOutTrackHits(tmpval);
1000
1001   for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
1002     in >> tmpval;
1003         useOutput->SetOutTrackHit(ih, tmpval);
1004   }
1005   in >> tmpval;
1006   useOutput->SetNOutTracks(tmpval);
1007
1008   for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
1009     AliHLTTPCCAOutTrack &t = useOutput->OutTracks()[itr];
1010     AliHLTTPCCATrackParam p1, p2;
1011     int i;
1012     float f;
1013     in >> i; t.SetNHits( i );
1014     in >> i; t.SetFirstHitRef( i );
1015     in >> i; t.SetOrigTrackID( i );
1016     in >> f; p1.SetX( f );
1017     in >> f; p1.SetSignCosPhi( f );
1018     in >> f; p1.SetChi2( f );
1019     in >> i; p1.SetNDF( i );
1020     for ( int j = 0; j < 5; j++ ) { in >> f; p1.SetPar( j, f ); }
1021     for ( int j = 0; j < 15; j++ ) { in >> f; p1.SetCov( j, f ); }
1022     in >> f; p2.SetX( f );
1023     in >> f; p2.SetSignCosPhi( f );
1024     in >> f; p2.SetChi2( f );
1025     in >> i; p2.SetNDF( i );
1026     for ( int j = 0; j < 5; j++ ) { in >> f; p2.SetPar( j, f ); }
1027     for ( int j = 0; j < 15; j++ ) { in >> f; p2.SetCov( j, f ); }
1028     t.SetStartPoint( p1 );
1029     t.SetEndPoint( p2 );
1030   }
1031 }
1032 #endif