- moved AliHLTDisplay files from TPCLib to TPCLib/OnlineDisplay
[u/mrichter/AliRoot.git] / 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