HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
   7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
   8  *          for The ALICE Off-line 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 //                                                                           //
  21 // a TPC sector tracker processing component for the HLT                     //
  22 //                                                                           //
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #if __GNUC__>= 3
  26 using namespace std;
  27 #endif
  28
  29 #include "AliHLTTPCSliceTrackerComponent.h"
  30 #include "AliHLTTPCTransform.h"
  31 #include "AliHLTTPCConfMapper.h"
  32 #include "AliHLTTPCVertex.h"
  33 #include "AliHLTTPCSpacePointData.h"
  34 #include "AliHLTTPCVertexData.h"
  35 #include "AliHLTTPCClusterDataFormat.h"
  36 #include "AliHLTTPCTransform.h"
  37 #include "AliHLTTPCTrackSegmentData.h"
  38 #include "AliHLTTPCTrackArray.h"
  39 #include "AliHLTTPCTrackletDataFormat.h"
  40 //#include "AliHLTTPC.h"
  41 #include <stdlib.h>
  42 #include <errno.h>
  43
  44 // this is a global object used for automatic component registration, do not use this
  45 AliHLTTPCSliceTrackerComponent gAliHLTTPCSliceTrackerComponent;
  46
  47 ClassImp(AliHLTTPCSliceTrackerComponent)
  48
  49 AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
  50     {
  51     fTracker = NULL;
  52     fVertex = NULL;
  53     fEta[0] = 0.;
  54     fEta[1] = 1.1;
  55     fDoNonVertex = false;
  56     fMultiplicity = 4000;
  57     fBField = 0.4;
  58     fDoPP = false;
  59 // BEGINN ############################################## MODIFIY JMT
  60     fnonvertextracking = kFALSE;   // enable NONVERTEX Tracking
  61     fmainvertextracking = kTRUE;   // enable MAINVERTEX Tracking
  62 // END ################################################# MODIFIY JMT
  63     }
  64
  65 AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
  66     {
  67     }
  68
  69 // Public functions to implement AliHLTComponent's interface.
  70 // These functions are required for the registration process
  71
  72 const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
  73     {
  74     return "TPCSliceTracker";
  75     }
  76
  77 void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
  78     {
  79     list.clear();
  80     list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
  81     list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
  82     }
  83
  84 AliHLTComponent_DataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
  85     {
  86     return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
  87     }
  88
  89 void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  90     {
  91     // XXX TODO: Find more realistic values.
  92     constBase = 0;
  93     inputMultiplier = 0.2;
  94     }
  95
  96 AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
  97     {
  98     return new AliHLTTPCSliceTrackerComponent;
  99     }
 100
 101 void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
 102                                    Int_t trackletlength, Int_t tracklength,
 103                                    Int_t rowscopetracklet, Int_t rowscopetrack,
 104                                    Double_t min_pt_fit, Double_t maxangle,
 105                                    Double_t goodDist, Double_t hitChi2Cut,
 106                                    Double_t goodHitChi2, Double_t trackChi2Cut,
 107                                    Int_t maxdist, Double_t maxphi,Double_t maxeta, bool vertexConstraints )
 108     {
 109     //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ??
 110     //Set parameters input to the tracker
 111     //If no arguments are given, default parameters will be used
 112
 113     fTracker->SetNSegments(phi_segments,eta_segments);
 114     fTracker->SetMaxDca(min_pt_fit);
 115     //   fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
 116
 117 // BEGINN ############################################## MODIFIY JMT
 118 #if 1
 119     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
 120
 121     if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
 122         fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
 123         fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
 124
 125         fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
 126         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
 127     }
 128     else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
 129         fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
 130         fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
 131         fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
 132         fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
 133
 134         fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
 135         fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
 136         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
 137     }
 138     else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
 139         fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
 140         fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
 141
 142         fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
 143         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
 144     }
 145 #else
 146     fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints);
 147     fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints);
 148
 149     if( vertexConstraints )
 150         fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
 151     else
 152         fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
 153 #endif
 154 // END ################################################# MODIFIY JMT
 155
 156     //fTracker->SetParamDone(true);
 157     /* Matthias 13.12.2006
 158      * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
 159      * and has always been kTRUE.
 160      * In order to remove the AliHLTTPC class (which is the old steering class for
 161      * HLT (TPC) tracking) from the compilation, this function can not be activated
 162      * again. We have to think about a more elegant way to specify the parameters
 163      * anyway. The following line was surely for some testing, but was never active
 164      * in a tested release.
 165      */
 166     //AliHLTTPC::SetVertexFit( kFALSE );
 167
 168     fTracker->InitVolumes();
 169     }
 170
 171 void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField )
 172     {
 173     AliHLTTPCTransform::SetBField( bField );
 174     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
 175
 176     if ( doPP )
 177         {
 178         //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
 179         SetTrackerParam( 50, 100, 3, 10,
 180                          2, 2,
 181                          0, 0.1745, 5, 100,
 182                          5, 50, 50, 0.1, 0.1, kTRUE);
 183         }
 184     else
 185         {
 186         int mults[] = { 1000, 2000, 4000, 8000 };
 187         int multCount = 4;
 188         int closestMult = 0;
 189         int i;
 190         int multDist, tmpMultDist;
 191         if ( multiplicity>mults[closestMult] )
 192             multDist = multiplicity-mults[closestMult];
 193         else
 194             multDist = mults[closestMult]-multiplicity;
 195         for ( i = 1; i < multCount; i++ )
 196             {
 197             if ( multiplicity>mults[i] )
 198                 tmpMultDist = multiplicity-mults[i];
 199             else
 200                 tmpMultDist = mults[i]-multiplicity;
 201             if ( tmpMultDist < multDist )
 202                 {
 203                 closestMult = i;
 204                 multDist = tmpMultDist;
 205                 }
 206             }
 207
 208         double bfs[] = { 0.2, 0.4 };
 209         int bfCount = 2;
 210         int closestBf = 0;
 211         double bfDist, tmpBFDist;
 212         if ( bField>bfs[closestBf] )
 213             bfDist = bField-bfs[closestBf];
 214         else
 215             bfDist = bfs[closestBf]-bField;
 216         for ( i = 1; i < bfCount; i++ )
 217             {
 218             if ( bField>bfs[i] )
 219                 tmpBFDist = bField-bfs[i];
 220             else
 221                 tmpBFDist = bfs[i]-bField;
 222             if ( tmpBFDist < bfDist )
 223                 {
 224                 closestBf = i;
 225                 bfDist = tmpBFDist;
 226                 }
 227             }
 228
 229         switch ( closestMult )
 230             {
 231             case 0: // 1000
 232                 switch ( closestBf )
 233                     {
 234                     case 0: // 0.2
 235                         SetTrackerParam( 50, 100, 3, 10,
 236                                         2, 4,
 237                                         0, 0.1745, 5, 100,
 238                                         5, 50, 50, 0.1, 0.1, kTRUE );
 239                         break;
 240                     case 1: // 0.4
 241                         SetTrackerParam( 50, 100, 3, 10,
 242                                          2, 4,
 243                                          0, 0.1745, 5, 100,
 244                                          5, 50, 50, 0.1, 0.1, kTRUE );
 245                         break;
 246                     }
 247                 break;
 248             case 1: // 2000
 249                 switch ( closestBf )
 250                     {
 251                     case 0: // 0.2
 252                         SetTrackerParam( 50, 100, 3, 10,
 253                                          2, 4,
 254                                          0, 0.1745, 5, 30,
 255                                          5, 20, 50, 0.1, 0.1, kTRUE );
 256                         break;
 257                     case 1: // 0.4
 258                         SetTrackerParam( 50, 100, 3, 10,
 259                                          2, 5,
 260                                          0, 0.1745, 5, 30,
 261                                          5, 20, 50, 0.1, 0.1, kTRUE );
 262                         break;
 263                     }
 264                 break;
 265             case 2: // 4000
 266                 switch ( closestBf )
 267                     {
 268                     case 0: // 0.2
 269                         SetTrackerParam( 50, 100, 3, 10,
 270                                          2 , 10,
 271                                          0, 0.1745, 5, 20,
 272                                          5, 10 , 50, 0.1, 0.1, kTRUE );
 273                         break;
 274                     case 1: // 0.4
 275                         SetTrackerParam( 50, 100, 3, 10,
 276                                          2, 10,
 277                                          0, 0.1745, 5, 20,
 278                                          5, 10, 50, 0.1, 0.1, kTRUE );
 279                         break;
 280                     }
 281                 break;
 282             case 3: // 8000
 283                 switch ( closestBf )
 284                     {
 285                     case 0: // 0.2
 286                         SetTrackerParam( 50, 100, 3, 10,
 287                                          3, 15,
 288                                          0, 0.1745, 5, 10,
 289                                          5, 5, 50, 0.1, 0.1, kTRUE );
 290                         break;
 291                     case 1: // 0.4
 292                         SetTrackerParam( 50, 100, 3, 10,
 293                                          2, 15,
 294                                          0, 0.1745, 5, 15,
 295                                          5, 5, 50, 0.1, 0.1, kTRUE );
 296                         break;
 297                     }
 298                 break;
 299             }
 300 //      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
 301 //      AliHLTTPCTransform::SetBField( bfs[closestBf] );
 302 //      AliHLTTPCTransform::SetBField( bField );
 303 //      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
 304         }
 305     }
 306
 307
 308
 309 int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
 310     {
 311     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
 312
 313     if ( fTracker || fVertex )
 314         return EINPROGRESS;
 315     fTracker = new AliHLTTPCConfMapper();
 316     fVertex = new AliHLTTPCVertex();
 317     fEta[0] = 0.;
 318     fEta[1] = 1.1;
 319     fDoNonVertex = false;
 320     fMultiplicity = 4000;
 321     fBField = 0.4;
 322     fDoPP = false;
 323
 324     int i = 0;
 325     char* cpErr;
 326     while ( i < argc )
 327         {
 328         if ( !strcmp( argv[i], "pp-run" ) )
 329             {
 330             fDoPP = true;
 331             i++;
 332             continue;
 333             }
 334         if ( !strcmp( argv[i], "multiplicity" ) )
 335             {
 336             if ( argc <= i+1 )
 337                 {
 338                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Missing event multiplicity specifier." );
 339                 return ENOTSUP;
 340                 }
 341             fMultiplicity = strtoul( argv[i+1], &cpErr, 0 );
 342             if ( *cpErr )
 343                 {
 344                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert event multiplicity specifier '%s'.", argv[i+1] );
 345                 return EINVAL;
 346                 }
 347             i += 2;
 348             continue;
 349             }
 350         if ( !strcmp( argv[i], "bfield" ) )
 351             {
 352             if ( argc <= i+1 )
 353                 {
 354                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Missing B-field specifier." );
 355                 return ENOTSUP;
 356                 }
 357             fBField = strtod( argv[i+1], &cpErr );
 358             if ( *cpErr )
 359                 {
 360                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
 361                 return EINVAL;
 362                 }
 363             i += 2;
 364             continue;
 365             }
 366
 367 // BEGINN ############################################## MODIFIY JMT
 368         if ( !strcmp( argv[i], "nonvertextracking" ) ){
 369             fnonvertextracking = kTRUE;
 370             i++;
 371             continue;
 372         }
 373
 374         if ( !strcmp( argv[i], "mainvertextrackingoff" ) ){
 375             fmainvertextracking = kFALSE;
 376             i++;
 377             continue;
 378         }
 379
 380         if ( !strcmp( argv[i], "etarange" ) ){
 381             if ( argc <= i+1 ){
 382                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." );
 383                 return ENOTSUP;
 384             }
 385             fEta[1] = strtod( argv[i+1], &cpErr );
 386             if ( *cpErr ){
 387                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] );
 388                 return EINVAL;
 389             }
 390
 391             i += 2;
 392             continue;
 393         }
 394 // END ################################################# MODIFIY JMT
 395         Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 396         return EINVAL;
 397         }
 398 // #### -B0-CHANGE-START == JMT
 399     if (fBField == 0.){
 400         // parameter for B=0 T
 401         fDoPP = kTRUE;
 402         fnonvertextracking = kTRUE;
 403         fmainvertextracking = kFALSE;
 404     }
 405 // #### -B0-CHANGE-END == JMT
 406
 407     SetTrackerParam( fDoPP, fMultiplicity, fBField );
 408     return 0;
 409     }
 410
 411 int AliHLTTPCSliceTrackerComponent::DoDeinit()
 412     {
 413     if ( fTracker )
 414         delete fTracker;
 415     fTracker = NULL;
 416     if ( fVertex )
 417         delete fVertex;
 418     fVertex = NULL;
 419     return 0;
 420     }
 421
 422 int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
 423                                               AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
 424                                               AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
 425     {
 426     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
 427     if ( evtData.fBlockCnt<=0 )
 428       {
 429         Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
 430         return 0;
 431       }
 432     const AliHLTComponent_BlockData* iter = NULL;
 433     unsigned long ndx;
 434     AliHLTTPCClusterData* inPtrSP;
 435     AliHLTTPCVertexData* inPtrV = NULL;
 436     const AliHLTComponent_BlockData* vertexIter=NULL;
 437     AliHLTTPCTrackletData* outPtr;
 438     AliHLTUInt8_t* outBPtr;
 439     AliHLTUInt32_t vSize = 0;
 440     UInt_t offset=0, mysize, tSize = 0;
 441     outBPtr = outputPtr;
 442     Int_t slice=-1, patch=-1, row[2];
 443     Int_t minPatch=INT_MAX, maxPatch = 0;
 444     offset = 0;
 445     std::vector<Int_t> slices;
 446     std::vector<Int_t>::iterator slIter, slEnd;
 447     std::vector<unsigned> sliceCnts;
 448     std::vector<unsigned>::iterator slCntIter;
 449     Int_t vertexSlice=-1;
 450
 451     // Find min/max rows used in total and find and read out vertex if it is present
 452     // also determine correct slice number, if multiple slice numbers are present in event
 453     // (which should not happen in the first place) we use the one that occurs the most times
 454     row[0] = 0;
 455     row[1] = 0;
 456     bool found;
 457     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 458         {
 459         iter = blocks+ndx;
 460
 461         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 462         found = false;
 463         slIter = slices.begin();
 464         slEnd = slices.end();
 465         slCntIter = sliceCnts.begin();
 466         while ( slIter != slEnd )
 467             {
 468             if ( *slIter == slice )
 469                 {
 470                 found = true;
 471                 break;
 472                 }
 473             slIter++;
 474             slCntIter++;
 475             }
 476         if ( !found )
 477             {
 478             slices.insert( slices.end(), slice );
 479             sliceCnts.insert( sliceCnts.end(), 1 );
 480             }
 481         else
 482             *slCntIter++;
 483
 484         if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
 485             {
 486             inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
 487             vertexIter = iter;
 488             vSize = iter->fSize;
 489             fVertex->Read( inPtrV );
 490             vertexSlice = slice;
 491             }
 492         if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
 493             {
 494             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 495             if ( minPatch>patch )
 496                 {
 497                 minPatch = patch;
 498                 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
 499                 }
 500             if ( maxPatch<patch )
 501                 {
 502                 maxPatch = patch;
 503                 row[1] = AliHLTTPCTransform::GetLastRow( patch );
 504                 }
 505             }
 506         }
 507
 508     // Determine slice number to really use.
 509     if ( slices.size()>1 )
 510         {
 511         Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
 512                  "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
 513                  evtData.fEventID, evtData.fEventID );
 514         unsigned maxCntSlice=0;
 515         slIter = slices.begin();
 516         slEnd = slices.end();
 517         slCntIter = sliceCnts.begin();
 518         while ( slIter != slEnd )
 519             {
 520             Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
 521                      "Slice %lu found %lu times.", *slIter, *slCntIter );
 522             if ( maxCntSlice<*slCntIter )
 523                 {
 524                 maxCntSlice = *slCntIter;
 525                 slice = *slIter;
 526                 }
 527             slIter++;
 528             slCntIter++;
 529             }
 530         Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
 531                  "Using slice %lu.", slice );
 532         }
 533     else if ( slices.size()>0 )
 534       {
 535         slice = *(slices.begin());
 536       }
 537     else
 538       {
 539         slice = -1;
 540       }
 541
 542     if ( vertexSlice != slice )
 543         {
 544         // multiple vertex blocks in event and we used the wrong one...
 545         found = false;
 546         for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 547             {
 548             iter = blocks+ndx;
 549             if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
 550                 {
 551                 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
 552                 vertexIter = iter;
 553                 vSize = iter->fSize;
 554                 fVertex->Read( inPtrV );
 555                 break;
 556                 }
 557             }
 558         }
 559
 560     fTracker->InitSector( slice, row, fEta );
 561     fTracker->SetVertex(fVertex);
 562     mysize = 0;
 563     // read in all hits
 564     std::vector<unsigned long> patchIndices;
 565     std::vector<unsigned long>::iterator pIter, pEnd;
 566     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 567         {
 568         iter = blocks+ndx;
 569
 570         if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
 571             {
 572             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 573             pIter = patchIndices.begin();
 574             pEnd = patchIndices.end();
 575             while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
 576                 pIter++;
 577             patchIndices.insert( pIter, ndx );
 578             }
 579         }
 580     pIter = patchIndices.begin();
 581     pEnd = patchIndices.end();
 582     while ( pIter!=pEnd )
 583         {
 584         ndx = *pIter;
 585         iter = blocks+ndx;
 586
 587         patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 588         inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
 589
 590         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
 591                  "Reading hits for slice %d - patch %d", slice, patch );
 592         fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
 593         pIter++;
 594         }
 595
 596     outPtr = (AliHLTTPCTrackletData*)(outBPtr);
 597 // BEGINN ############################################## MODIFIY JMT
 598 #if 1
 599     fTracker->SetPointers();
 600     if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
 601         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
 602         fTracker->MainVertexTracking_a();
 603         fTracker->MainVertexTracking_b();
 604         fTracker->FillTracks();
 605     }
 606     else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
 607         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
 608         fTracker->MainVertexTracking_a();
 609         fTracker->MainVertexTracking_b();
 610         fTracker->FillTracks();
 611         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
 612         fTracker->NonVertexTracking();
 613     }
 614     else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
 615         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
 616         fTracker->NonVertexTracking();
 617         fTracker->FillTracks();
 618     }
 619 #else
 620     fTracker->MainVertexTracking_a();
 621     fTracker->MainVertexTracking_b();
 622     fTracker->FillTracks();
 623
 624     if ( fDoNonVertex )
 625         fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
 626 #endif
 627 // END ################################################# MODIFIY JMT
 628     // XXX Do track merging??
 629
 630     UInt_t ntracks0=0;
 631     mysize = fTracker->GetTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
 632     outPtr->fTrackletCnt = ntracks0;
 633
 634     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
 635              "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.",
 636              ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
 637
 638     tSize += mysize+sizeof(AliHLTTPCTrackletData);
 639     outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
 640
 641     AliHLTComponent_BlockData bd;
 642     FillBlockData( bd );
 643     bd.fOffset = offset;
 644     bd.fSize = tSize;
 645     bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
 646     outputBlocks.push_back( bd );
 647
 648 #ifdef FORWARD_VERTEX_BLOCK
 649     if ( vertexIter )
 650         {
 651         // Copy the descriptor block for the vertex information.
 652         bd = *vertexIter;
 653         outputBlocks.push_back( bd );
 654         }
 655 #endif // FORWARD_VERTEX_BLOCK
 656
 657     size = tSize;
 658     return 0;
 659     }
 660
 661