HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayMain.cxx

   1 // $Id$
   2
   3 /** \class AliHLTTPCDisplayMain
   4 <pre>
   5 //_____________________________________________________________
   6 // AliHLTTPCDisplayMain
   7 //
   8 // Display class for the HLT events.
   9 </pre>
  10 */
  11 // Author: Jochen Thaeder <mailto:thaeder@kip.uni-heidelberg.de>
  12 //*-- Copyright &copy ALICE HLT Group
  13
  14 #define DEBUG 0
  15
  16
  17 #if defined(HAVE_HOMERREADER)
  18 #include "HOMERReader.h"
  19 #endif // defined(HAVE_HOMERREADER)
  20 //-----------
  21 #include "AliHLTTPCDisplayMain.h"
  22 #include "AliHLTTPCDisplayCharge.h"
  23 #include "AliHLTTPCDisplayPadRow.h"
  24 #include "AliHLTTPCDisplayPad.h"
  25 #include "AliHLTTPCDisplay3D.h"
  26 #include "AliHLTTPCDisplayResiduals.h"
  27 #include "AliHLTTPCDisplayFront.h"
  28 //-----------
  29 #include "AliHLTStdIncludes.h"
  30 #include "AliHLTTPCDefinitions.h"
  31 #include "AliHLTDataTypes.h"
  32 #include "AliHLTTPCSpacePointData.h"
  33 #include "AliHLTTPCClusterDataFormat.h"
  34 #include "AliHLTTPCTrackletDataFormat.h"
  35 #include "AliHLTTPCDigitReader.h"
  36 #include "AliHLT_C_Component_WrapperInterface.h"
  37 #include "AliHLTTPCLogging.h"
  38
  39 #include "AliHLTTPCTransform.h"
  40 #include "AliHLTTPCTrack.h"
  41 #include "AliHLTTPCTrackArray.h"
  42 #include "AliHLTTPCMemHandler.h"
  43 #include "AliHLTTPCDigitReaderPacked.h"
  44
  45 #ifdef use_aliroot
  46 #include <TClonesArray.h>
  47 #include <AliRun.h>
  48 #include <AliSimDigits.h>
  49 #include <AliTPCParam.h>
  50 #endif
  51
  52 #if __GNUC__ >= 3
  53 using namespace std;
  54 #endif
  55
  56 ClassImp(AliHLTTPCDisplayMain)
  57
  58 //____________________________________________________________________________________________________
  59 AliHLTTPCDisplayMain::AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t)) {
  60     //constructor
  61
  62     // Set B-Field
  63     AliHLTTPCTransform::SetBField( 0.8 );
  64
  65     //callback handler
  66     fPt2Gui = pt2GUI;
  67     fPadCallback = pt2Function;
  68
  69     fReader = NULL;
  70
  71     fDisplayCharge = NULL;
  72     fDisplayPadRow = NULL;
  73     fDisplayPad = NULL;
  74     fDisplay3D = NULL;
  75     fDisplayResiduals = NULL;
  76     fDisplayFront = NULL;
  77
  78     fCanvasCharge = NULL;
  79     fCanvasPadRow = NULL;
  80     fCanvasPad = NULL;
  81     fCanvas3D = NULL;
  82     fCanvasResiduals = NULL;
  83     fCanvasFront = NULL;
  84     fCanvasHits_S = NULL;
  85     fCanvasQ_Track = NULL;
  86     fCanvasQ_S = NULL;
  87
  88     fConnect = kFALSE;
  89
  90     fExistsRawData = kFALSE;
  91     fExistsClusterData = kFALSE;
  92     fExistsTrackData = kFALSE;
  93
  94     AliHLTTPCTransform::SetBField(0.4);
  95
  96     memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
  97     memset(fNcl, 0, 36*6*sizeof(UInt_t));
  98
  99     fTracks = NULL;
 100
 101     fTheta = 90.;
 102     fPhi = 0.;
 103
 104     fSwitch3DCluster = kFALSE;
 105     fSwitch3DTracks = kFALSE;
 106     fSwitch3DPadRow = kFALSE;
 107     fSwitch3DGeometry = kTRUE;
 108
 109
 110     // fMinHits = 0;
 111     // fPtThreshold = 0.;
 112
 113     fCutHits = 0;
 114     fCutPt = 0.;
 115     fCutPsi = 0.;
 116     fCutLambda = 0.;
 117     fCut_S = 0.;
 118     fCutPadrow = 159;
 119
 120     fNPads = AliHLTTPCTransform::GetNPads(0);
 121     fPad = -1;
 122     fPadRow = 0;
 123     fTimebin = 0;
 124
 125     fAllTimebins = kTRUE;
 126     fSplitPadRow = kFALSE;
 127
 128     fSlicePadRow = 0;
 129     fSelectTrack = -1;
 130     fSelectTrackSlice = 0;
 131     fSelectTrackSwitch = kFALSE;
 132     fSelectCluster = 0;
 133
 134     fMinSlice = 0;
 135     fMaxSlice = 35;
 136     fSlicePair = kFALSE;
 137
 138     SetSliceArray();
 139
 140     fBackColor = 1;
 141     fLineColor = 0;
 142     fKeepView = kTRUE;
 143
 144     fTrackParam.kappa = 0.;
 145     fTrackParam.nHits = 0;
 146     fTrackParam.charge = 0;
 147     fTrackParam.radius = 0.;
 148     fTrackParam.slice = 0;
 149     fTrackParam.phi0 = 0.;
 150     fTrackParam.psi = 0.;
 151     fTrackParam.lambda = 0.;
 152     fTrackParam.pt = 0.;
 153     fTrackParam.id = 0;
 154     fTrackParam.bfield = 0.;
 155     fTrackParam.s = 0.;
 156 }
 157
 158 //____________________________________________________________________________________________________
 159 AliHLTTPCDisplayMain::~AliHLTTPCDisplayMain() {
 160     //destructor
 161     if ( fTracks )  delete fTracks;
 162     fTracks = NULL;
 163
 164 #if defined(HAVE_HOMERREADER)
 165     HOMERReader* reader= (HOMERReader*) fReader;
 166
 167     if (reader)
 168       delete reader;
 169     fReader = NULL;
 170 #endif // defined(HAVE_HOMERREADER)
 171
 172     if (fDisplayResiduals)
 173       delete fDisplayResiduals;
 174     fDisplayResiduals = NULL;
 175
 176     if (fDisplay3D)
 177       delete fDisplay3D;
 178     fDisplay3D = NULL;
 179
 180     if (fDisplayPad)
 181       delete fDisplayPad;
 182     fDisplayPad = NULL;
 183
 184     if (fDisplayPadRow)
 185       delete fDisplayPadRow;
 186     fDisplayPadRow = NULL;
 187
 188     if (fDisplayFront)
 189       delete fDisplayFront;
 190     fDisplayFront = NULL;
 191
 192     if (fDisplayCharge)
 193       delete fDisplayCharge;
 194     fDisplayCharge = NULL;
 195 }
 196
 197 //____________________________________________________________________________________________________
 198 Int_t AliHLTTPCDisplayMain::Connect( unsigned int cnt, const char** hostnames, unsigned short* ports, Char_t *gfile){
 199
 200 #if defined(HAVE_HOMERREADER)
 201     // -- input datatypes , reverse
 202     Char_t* spptID="SRETSULC";
 203     Char_t* trkID = "SGESKART";
 204     Char_t* padrowID = "KPWR_LDD";
 205
 206     Int_t ret;
 207     Int_t tries = 0;
 208
 209     while(1) {
 210         HOMERReader* reader = new HOMERReader( cnt, (const char**) hostnames, ports );
 211
 212         ret=reader->GetConnectionStatus();
 213
 214         if ( ret ) {
 215             Int_t ndx = reader->GetErrorConnectionNdx();
 216             if ( ndx < (Int_t) cnt) printf( "Error establishing connection to TCP source %s:%hu: %s (%d)\n", hostnames[ndx], ports[ndx], strerror(ret), ret );
 217             else printf( "Error establishing connection to unknown source with index %d: %s (%d)\n",ndx, strerror(ret), ret );
 218
 219             delete reader;
 220             reader = NULL;
 221             return -1;
 222         }
 223
 224         //cout << "TRY = " << tries << " || " ;
 225         tries++;
 226
 227         Int_t  ret1 = reader->ReadNextEvent();
 228         if ( ret1 ) {
 229             Int_t ndx = reader->GetErrorConnectionNdx();
 230             printf( "Error reading event from source %d: %s (%d)\n", ndx, strerror(ret1), ret1 );
 231             delete reader;
 232             reader = NULL;
 233             continue;
 234         }
 235
 236         unsigned long blockCnt = reader->GetBlockCnt();  // ####
 237 #if DEBUG
 238         printf( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
 239 #endif
 240         if (blockCnt == 0){
 241             delete reader;
 242             reader = NULL;
 243             continue;
 244         }
 245
 246         fReader = (void*) reader;
 247
 248         // Switch on the Display parts according what data types are present
 249         for ( unsigned long i = 0; i < blockCnt; i++ ) {
 250             char tmp1[9];
 251             memset( tmp1, 0, 9 );
 252             void *tmp11 = tmp1;
 253             ULong64_t* tmp12 = (ULong64_t*)tmp11;
 254             *tmp12 = reader->GetBlockDataType( i );
 255             if (!strcmp(tmp1,padrowID)) fExistsRawData = kTRUE;
 256             if (!strcmp(tmp1,spptID)) fExistsClusterData = kTRUE;
 257             if (!strcmp(tmp1,trkID)) fExistsTrackData = kTRUE;
 258         }
 259
 260         break;
 261     }
 262     fConnect = kTRUE;
 263
 264     // Initialize TPC Display Classes  -- IMPORTANT... don't change the order of them
 265     fDisplay3D = new AliHLTTPCDisplay3D(this, gfile);
 266
 267     if (ExistsRawData()){
 268         fDisplayPadRow = new AliHLTTPCDisplayPadRow(this);
 269         fDisplayPad = new AliHLTTPCDisplayPad(this);
 270         fDisplayFront = new AliHLTTPCDisplayFront(this);
 271     }
 272
 273     if (ExistsClusterData()){
 274         fDisplayCharge = new AliHLTTPCDisplayCharge(this);
 275     }
 276
 277     if (ExistsTrackData() && ExistsClusterData() ){
 278         fDisplayResiduals = new AliHLTTPCDisplayResiduals(this);
 279     }
 280
 281     return 0;
 282 #else
 283     HLTFatal("HOMER raeder not available");
 284 #endif // defined(HAVE_HOMERREADER)
 285 }
 286
 287 //____________________________________________________________________________________________________
 288 void AliHLTTPCDisplayMain::ReadData(Bool_t nextSwitch){
 289 #if defined(HAVE_HOMERREADER)
 290     // READ CLUSTER and TRACK data
 291     HOMERReader* reader = (HOMERReader*)fReader;
 292
 293     for(Int_t ii=0;ii<36;ii++) fTracksPerSlice[ii] = 0;
 294
 295     // -- input datatypes , reverse
 296     Char_t* spptID="SRETSULC";
 297     Char_t* trkID = "SGESKART";
 298     Int_t ret;
 299     ULong_t blk;
 300
 301     if (nextSwitch) {
 302         while(1){
 303             ret = reader->ReadNextEvent();
 304
 305             if ( ret ) {
 306                 Int_t ndx = reader->GetErrorConnectionNdx();
 307                 printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
 308                 continue;
 309             }
 310             break;
 311         }
 312     }
 313
 314     ULong_t blockCnt = reader->GetBlockCnt();
 315 #if DEBUG
 316     printf( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
 317 #endif
 318     for ( ULong_t i = 0; i < blockCnt; i++ ) {
 319         Char_t tmp1[9], tmp2[5];
 320         memset( tmp1, 0, 9 );
 321         memset( tmp2, 0, 5 );
 322         void *tmp11 = tmp1;
 323         ULong64_t* tmp12 = (ULong64_t*)tmp11;
 324         *tmp12 = reader->GetBlockDataType( i );
 325         void *tmp21 = tmp2;
 326         ULong_t* tmp22 = (ULong_t*)tmp21;
 327         *tmp22 = reader->GetBlockDataOrigin( i );
 328 #if DEBUG
 329         printf( "Block %lu length: %lu - type: %s - origin: %s\n",i, reader->GetBlockDataLength( i ), tmp1, tmp2 );
 330 #endif
 331     }
 332
 333     //--------------------------------------------------------------------------------------------
 334     // READ CLUSTER DATA
 335     //--------------------------------------------------------------------------------------------
 336     blk = reader->FindBlockNdx( spptID, " CPT",0xFFFFFFFF );
 337
 338     while ( blk != ~(ULong_t)0 ) {
 339 #if DEBUG
 340         printf( "Found clusters block %lu\n", blk );
 341 #endif
 342         const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)reader->GetBlockData( blk );
 343         if ( !clusterData ) {
 344 #if DEBUG
 345             printf( "No track data for block %lu\n", blk );
 346 #endif
 347             continue;
 348         }
 349
 350         ULong_t spec = reader->GetBlockDataSpec( blk );
 351         Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
 352         Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
 353 #if DEBUG
 354         printf( "%lu Clusters found for slice %u - patch %u\n", clusterData->fSpacePointCnt, slice, patch );
 355 #endif
 356         void* tmp30 = (void*)clusterData;
 357         Byte_t* tmp31 = (Byte_t*)tmp30;
 358         ULong_t offset;
 359         offset = sizeof(clusterData->fSpacePointCnt);
 360         if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) ) offset = reader->GetBlockTypeAlignment( blk, 1 );
 361         tmp31 += offset;
 362         tmp30 = tmp31;
 363         AliHLTTPCSpacePointData* tmp32 = (AliHLTTPCSpacePointData*)tmp30;
 364
 365         SetupCluster( slice, patch, clusterData->fSpacePointCnt, tmp32 );
 366
 367         blk = reader->FindBlockNdx( spptID, " CPT", 0xFFFFFFFF, blk+1 );
 368     }
 369
 370     //--------------------------------------------------------------------------------------------
 371     // READ TRACKS
 372     //--------------------------------------------------------------------------------------------
 373     if ( fTracks ) delete fTracks;
 374     fTracks = new AliHLTTPCTrackArray;
 375
 376     blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF );
 377
 378     while ( blk != ~(ULong_t)0 ) {
 379 #if DEBUG
 380         printf( "Found tracks in block %lu\n", blk );
 381 #endif
 382         const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*)reader->GetBlockData( blk );
 383         if ( !trackData ) {
 384 #if DEBUG
 385             printf( "No track data for block %lu\n", blk );
 386 #endif
 387             continue;
 388         }
 389
 390         ULong_t spec = reader->GetBlockDataSpec( blk );
 391         Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
 392 #if DEBUG
 393         Int_t patchmin = AliHLTTPCDefinitions::GetMinPatchNr( spec );
 394         Int_t patchmax = AliHLTTPCDefinitions::GetMaxPatchNr( spec );
 395
 396         printf( "%lu tracks found for slice %u - patch %u-%u\n", trackData->fTrackletCnt, slice, patchmin, patchmax );
 397 #endif
 398         fTracksPerSlice[slice] = trackData->fTrackletCnt; // Fill number if tracks per slice
 399
 400         AliHLTTPCTrackSegmentData* tmp42 = (AliHLTTPCTrackSegmentData*) &(trackData->fTracklets[0]);
 401         fTracks->FillTracks( trackData->fTrackletCnt, tmp42, slice );
 402
 403         blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF, blk+1 );
 404     }
 405
 406     SetupTracks();
 407 #else
 408     HLTFatal("HOMER raeder not available");
 409 #endif // defined(HAVE_HOMERREADER)
 410 }
 411
 412 //____________________________________________________________________________________________________
 413 void AliHLTTPCDisplayMain::DisplayEvent(){
 414 #if defined(HAVE_HOMERREADER)
 415     HOMERReader* reader = (HOMERReader*)fReader;
 416
 417     //--------------------------------------------------------------------------------------------
 418     // READ RAW DATA for PADROW/PAD HISTOGRAM
 419     //--------------------------------------------------------------------------------------------
 420     if ( ExistsRawData() ){
 421         fDisplayPadRow->Reset();
 422         fDisplayPad->Reset();
 423         fDisplayFront->Reset();
 424
 425         char* rawID = "KPWR_LDD";
 426         Int_t padrowpatch =  AliHLTTPCTransform::GetPatch(fPadRow);
 427         Int_t maxpadrowpatch =  padrowpatch;
 428
 429         if (fPadRow == 30 || fPadRow == 90 || fPadRow == 139) maxpadrowpatch++;
 430
 431         for (Int_t patch=0; patch < 6; patch++){
 432             unsigned long blk;
 433             AliHLTUInt32_t rawSpec = AliHLTTPCDefinitions::EncodeDataSpecification( (AliHLTUInt8_t) fSlicePadRow, (AliHLTUInt8_t) fSlicePadRow,
 434                                                                                     (AliHLTUInt8_t) patch,(AliHLTUInt8_t) patch );
 435             // READ RAW DATA BLOCK
 436             blk = reader->FindBlockNdx( rawID, " CPT", rawSpec );
 437
 438             if ( ~(unsigned long)0 != blk ){
 439 #if DEBUG
 440                 printf( "Raw Data found for slice %u/patch %u\n", fSlicePadRow, patch );
 441 #endif
 442                 unsigned long rawDataBlock = (unsigned long) reader->GetBlockData( blk );
 443                 unsigned long rawDataLen = reader->GetBlockDataLength( blk );
 444
 445                 fDisplayFront->Fill(patch, rawDataBlock, rawDataLen);
 446
 447                 if (patch == padrowpatch || patch == maxpadrowpatch ) {
 448                     fDisplayPadRow->Fill(patch, rawDataBlock, rawDataLen);
 449                     fDisplayPad->Fill(patch, rawDataBlock, rawDataLen);
 450                 }
 451             }
 452         }
 453
 454         fDisplayPad->Draw();
 455         fDisplayPadRow->Draw();
 456         fDisplayFront->Draw();
 457     }
 458
 459     //--------------------------------------------------------------------------------------------
 460     // DRAW RESIDUALS
 461     //--------------------------------------------------------------------------------------------
 462     if ( ExistsClusterData() && ExistsTrackData() ){
 463         fDisplayResiduals->Reset();
 464         fDisplayResiduals->Fill();
 465         fDisplayResiduals->Draw();
 466     }
 467
 468     //--------------------------------------------------------------------------------------------
 469     // DRAW CHARGE
 470     //--------------------------------------------------------------------------------------------
 471     if ( ExistsClusterData() ){
 472         fDisplayCharge->Reset();
 473         fDisplayCharge->Fill();
 474         fDisplayCharge->Draw();
 475     }
 476
 477     //--------------------------------------------------------------------------------------------
 478     // DRAW 3D
 479     //--------------------------------------------------------------------------------------------
 480
 481     // TAKE CARE !!! EXISTSxxxData() HANDLING of 3D will be done IN this class !!!
 482     fDisplay3D->Draw();
 483 #else
 484     HLTFatal("HOMER raeder not available");
 485 #endif // defined(HAVE_HOMERREADER)
 486
 487 }
 488
 489 //____________________________________________________________________________________________________
 490 void AliHLTTPCDisplayMain::SaveHistograms(){
 491   // Save histograms as eps
 492   fDisplayCharge->Save();
 493   fDisplayPadRow->Save();
 494   fDisplayPad->Save();
 495   fDisplay3D->Save();
 496   fDisplayResiduals->Save();
 497   fDisplayFront->Save();
 498   fDisplayCharge->Save();
 499 }
 500
 501 //----------------------------------------------------------------------------------------------------
 502 //                 SETUP
 503 //____________________________________________________________________________________________________
 504 void AliHLTTPCDisplayMain::SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data)  {
 505
 506     if (data && slice>=0 && slice<36 && patch>=0 && patch<AliHLTTPCTransform::GetNPatches()) {
 507         if (fClusters[slice][patch]!=NULL) {
 508             delete(fClusters[slice][patch]);
 509             fClusters[slice][patch]=NULL;
 510         }
 511         Int_t arraysize=nofClusters*sizeof(AliHLTTPCSpacePointData);
 512         fClusters[slice][patch] = (AliHLTTPCSpacePointData*)new Byte_t[arraysize];
 513         if (fClusters[slice][patch]) {
 514             memcpy(fClusters[slice][patch], data, arraysize);
 515             fNcl[slice][patch]=nofClusters;
 516         } else {
 517             fNcl[slice][patch]=nofClusters;
 518             LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::SetupCluster","memory allocation") << "memory allocation failed "<<ENDLOG;
 519         }
 520     } else LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::SetupCluster","argument check") << "invalid argument "<<ENDLOG;
 521 }
 522
 523 //____________________________________________________________________________________________________
 524 void AliHLTTPCDisplayMain::SetupTracks() {
 525
 526     // Set USED cluster
 527     Int_t ntracks = fTracks->GetNTracks();
 528
 529     for(Int_t j=0; j<ntracks; j++) {
 530         AliHLTTPCTrack *gtrack = fTracks->GetCheckedTrack(j);
 531         if(!gtrack) continue;
 532
 533         Int_t nHits = gtrack->GetNHits();
 534         UInt_t *hitnum = gtrack->GetHitNumbers();
 535
 536         for(Int_t h=0; h<nHits; h++){
 537
 538             UInt_t id=hitnum[h];
 539             Int_t slice = (id>>25) & 0x7f;
 540             Int_t patch = (id>>22) & 0x7;
 541             UInt_t pos = id&0x3fffff;
 542
 543             AliHLTTPCSpacePointData *points = fClusters[slice][patch];
 544
 545             if(!points) {
 546                 LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayMain::SetupTracks","Clusterarray")
 547                   <<"No points at slice "<<slice<<" patch "<<patch<<" pos "<<pos<<ENDLOG;
 548                 continue;
 549             }
 550
 551             if(pos>=fNcl[slice][patch]) {
 552                 LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplayMain::SetupTracks","Clusterarray")
 553                   <<"Pos is too large: pos "<<pos <<" ncl "<<fNcl[slice][patch]<<ENDLOG;
 554                 continue;
 555             }
 556             points[pos].fUsed = kTRUE;
 557             points[pos].fTrackN = j;
 558         }
 559     }
 560 }
 561
 562 //____________________________________________________________________________________________________
 563 void AliHLTTPCDisplayMain::SetSliceArray() {
 564     Int_t slice=0;
 565     Int_t minSlice = fMinSlice;
 566     Int_t maxSlice = fMaxSlice;
 567     Int_t realslice = 0;
 568
 569     for (slice=0;slice< 36;slice++){
 570         fSliceArray[slice] = kFALSE;
 571     }
 572
 573     // Single Slice, or Range
 574     if (minSlice > maxSlice) maxSlice += 17;
 575
 576     for (slice=minSlice;slice<=maxSlice;slice++){
 577         realslice = slice % 18;
 578         fSliceArray[realslice] = kTRUE;
 579         fSliceArray[realslice+18] = kTRUE;
 580     }
 581
 582     // Pair of Slices
 583     if (fSlicePair) {
 584         minSlice = fMinSlice + 9;
 585         maxSlice = fMaxSlice + 9;
 586
 587         if (minSlice > maxSlice) maxSlice += 17;
 588
 589         for (slice=minSlice;slice<=maxSlice;slice++){
 590             realslice = slice % 18;
 591             fSliceArray[realslice] = kTRUE;
 592             fSliceArray[realslice+18] = kTRUE;
 593         }
 594     }
 595 }
 596
 597 //----------------------------------------------------------------------------------------------------
 598 //                 GETTER
 599 //____________________________________________________________________________________________________
 600 Int_t AliHLTTPCDisplayMain::GetGlobalTrack(Int_t slice){
 601     // get global track out of the "selectTrack" parameters
 602     Int_t currenttrack= -1;
 603     Int_t trackcounter = 0;
 604     Int_t ntracks = fTracks->GetNTracks();
 605
 606     if ( slice == fSelectTrackSlice) {
 607         for(Int_t j=0; j<ntracks; j++) {
 608
 609             AliHLTTPCTrack *gtrack = fTracks->GetCheckedTrack(j);
 610             if(!gtrack) continue;
 611
 612             // --- CHECK if track is should be drawn
 613             // select Single Track
 614             if(gtrack->GetSector() != fSelectTrackSlice) continue;
 615
 616             if (trackcounter != fSelectTrack){
 617                 trackcounter++;
 618                 continue;
 619             }
 620             trackcounter++;
 621             // +++
 622             //if((fPtThreshold > 0) && (gtrack->GetPt()< fPtThreshold)) continue;
 623             //if(gtrack->GetNHits() < fMinHits) continue;
 624
 625             currenttrack = j;
 626             break;
 627         }
 628     }
 629
 630     return currenttrack;
 631 }
 632
 633 //----------------------------------------------------------------------------------------------------
 634 //                 EVENTS
 635 //____________________________________________________________________________________________________
 636 void AliHLTTPCDisplayMain::ExecPadEvent(Int_t event, Int_t px, Int_t py, TObject *selected){
 637    TCanvas *c = (TCanvas *) gTQSender;
 638
 639    if (event == 11 &&selected->InheritsFrom("TH2F")) {
 640         TH2F *hist = (TH2F*) selected;
 641
 642         Int_t binx = hist->GetXaxis()->FindBin(c->AbsPixeltoX(px)) -1 ;
 643 //      Int_t biny = hist->GetYaxis()->FindBin(c->AbsPixeltoY(py)) -1;
 644
 645         fPadCallback(fPt2Gui, binx);
 646   }
 647 }
 648
 649