Update of the CA tracker
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 25 Mar 2009 11:13:14 +0000 (11:13 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 25 Mar 2009 11:13:14 +0000 (11:13 +0000)
56 files changed:
HLT/TPCLib/tracking-ca/AliHLT3DTrackParam.cxx
HLT/TPCLib/tracking-ca/AliHLT3DTrackParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBHit.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBHit.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGrid.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGrid.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAHit.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAHitArea.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAHitArea.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCPoint.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCPoint.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMath.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursCleaner.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursCleaner.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAParam.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAPerformance.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAPerformance.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAProcess.h
HLT/TPCLib/tracking-ca/AliHLTTPCCARow.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCARow.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAStartHitsFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAStartHitsFinder.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackConvertor.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackConvertor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.cxx [new file with mode: 0644]
HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAUsedHitsInitialiser.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAUsedHitsInitialiser.h
HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx
HLT/TPCLib/tracking-ca/AliTPCtrackerCA.h

index b6f0bea..b7f275e 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
index 73111b7..b23a66a 100644 (file)
@@ -1,18 +1,17 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project           * 
-//* ALICE Experiment at CERN, All rights reserved.                            *
-//* See cxx source for full Copyright notice                                  *
-
-//*                                                                           *
-//* AliHLT3DTrackParam class is under development and currently not in use    *
-//*                                                                           *
+// ***************************************************************************
+// This file is property of and copyright by the ALICE HLT Project           * 
+// ALICE Experiment at CERN, All rights reserved.                            *
+// See cxx source for full Copyright notice                                  *
+//                                                                           *
+// AliHLT3DTrackParam class is under development and currently not in use    *
+//                                                                           *
+//****************************************************************************
 
 #ifndef ALIHLT3DTRACKPARAM_H
 #define ALIHLT3DTRACKPARAM_H
 
-#include "Rtypes.h"
 #include "TObject.h"
 
 /**
@@ -107,7 +106,7 @@ class AliHLT3DTrackParam :public TObject
       TransportToDS( Bz,GetDStoPoint(Bz, xyz, T0), T0 ) ; 
     }
 
-  void TransportToPoint( Double_t Bz, Double_t x, Double_t y, Double_t z, Double_t *T0=0 )
+  void TransportToPoint( Double_t Bz, Double_t x, Double_t y, Double_t z, const Double_t *T0=0 )
     { 
       Double_t xyz[3] = {x,y,z};
       TransportToPoint( Bz, xyz, T0 );
index 4a82e6e..10591c2 100644 (file)
@@ -14,6 +14,7 @@
  */  
  
 //#define HLTCA_STANDALONE // compilation w/o root
+#define HLTCA_INTERNAL_PERFORMANCE
 
 #ifdef __CUDACC__
 
@@ -23,7 +24,7 @@
 
 #if defined(HLTCA_STANDALONE) || defined(HLTCA_GPUCODE)
 
-class TObject{};
+// class TObject{};
 
 #define ClassDef(name,id)
 #define ClassImp(name)
@@ -81,7 +82,6 @@ typedef float          Size_t;      //Attribute size (float)
 #else 
 
 #include "Rtypes.h"
-#include "TObject.h"
 
 #endif
 
@@ -97,7 +97,7 @@ typedef float          Size_t;      //Attribute size (float)
 #define GPUshared() __shared__ 
 #define GPUsync() __syncthreads()
 
-__constant__ float4 cTracker[30000/sizeof(float4)];
+__constant__ float4 gAliHLTTPCCATracker[30000/sizeof(float4)];
 
 #else
 
@@ -114,11 +114,6 @@ struct ushort2{ unsigned short x; unsigned short y; };
 struct uint1{ unsigned int x; };
 struct uint4{ unsigned int x,y,z,w; };
 
-float2 inline make_float2(float x, float y ){
-  float2 ret = {x,y};
-  return ret;
-}
-
 #endif
 
 
index 2575c4a..5ffa20d 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 
 #include "TMath.h"
 #include "TStyle.h"
 #include "TCanvas.h"
+#include "TApplication.h"
+
+
 
 
 AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
 {
   // reference to static object
   static AliHLTTPCCADisplay gAliHLTTPCCADisplay;
+  static Bool_t firstCall = 1;
+  if( firstCall ){
+    if( !gApplication ) new TApplication("myapp",0,0);
+    gAliHLTTPCCADisplay.Init();
+    firstCall = 0;
+  }
   return gAliHLTTPCCADisplay; 
 }
 
@@ -63,7 +73,7 @@ AliHLTTPCCADisplay::AliHLTTPCCADisplay( const AliHLTTPCCADisplay& )
   // dummy
 }
 
-AliHLTTPCCADisplay& AliHLTTPCCADisplay::operator=( const AliHLTTPCCADisplay& )
+const AliHLTTPCCADisplay& AliHLTTPCCADisplay::operator=( const AliHLTTPCCADisplay& ) const 
 {
   // dummy
   return *this;
@@ -85,7 +95,7 @@ void AliHLTTPCCADisplay::Init()
   fYX = new TCanvas ("YX", "YX window", -1, 0, 600, 600);
   fZX = new TCanvas ("ZX", "ZX window", -610, 0, 590, 600);  
   fMarker = TMarker(0.0, 0.0, 20);//6);
-  fDrawOnlyRef = 1;
+  fDrawOnlyRef = 0;
 }
 
 void AliHLTTPCCADisplay::Update()
@@ -141,7 +151,7 @@ void AliHLTTPCCADisplay::SetTPCView()
 }
 
 
-void AliHLTTPCCADisplay::SetGB( AliHLTTPCCAGBTracker *GBTracker )
+void AliHLTTPCCADisplay::SetGB( AliHLTTPCCAGBTracker * const GBTracker )
 {
   fGB = GBTracker;
 }
@@ -168,8 +178,14 @@ void AliHLTTPCCADisplay::SetCurrentSlice( AliHLTTPCCATracker *slice )
     fYX->Range(cx-dr, cy-dr*1.05, cx+dr, cy+dr);
     fZX->Range(cz-dz, cy-dr*1.05, cz+dz, cy+dr);
     
-    //fYX->Range(cx-dr*0., cy-dr*1., cx+dr*.2, cy-dr*0.2);
-    //fZX->Range(cz-dz   , cy-dr*1., cz+dz, cy-dr*0.2);
+    //fYX->Range(cx-dr*.3, cy-dr*1.05, cx+dr*.3, cy-dr*.35);
+    //fZX->Range(cz-dz, cy-dr*1.05, cz+dz, cy-dr*.3);
+
+    //fYX->Range(cx-dr*.3, cy-dr*.8, cx-dr*.1, cy-dr*.75);
+    //fZX->Range(cz-dz*0, cy-dr*.8, cz+dz, cy-dr*.75);
+
+    //fYX->Range(cx-dr*.08, cy-dr*1., cx-dr*.02, cy-dr*0.7);
+    //fZX->Range(cz-dz*.2, cy-dr*1., cz-dz*.05, cy-dr*0.7);
     
     //Double_t x0 = cx-dr*.1, x1 = cx-dr*.05;
     //Double_t y0 = cy-dr*1.05, y1 = cy-dr*0.7;
@@ -272,7 +288,7 @@ void AliHLTTPCCADisplay::DrawSlice( AliHLTTPCCATracker *slice, Bool_t DrawRows )
 }
 
 
-void AliHLTTPCCADisplay::Set2Slices( AliHLTTPCCATracker *slice )
+void AliHLTTPCCADisplay::Set2Slices( AliHLTTPCCATracker * const slice )
 {
   //* Set view for two neighbouring slices
 
@@ -357,7 +373,7 @@ Int_t AliHLTTPCCADisplay::GetColorK( Double_t k ) const
   return kMyColor[iy];
 }
 
-void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
+void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t * yv ) const
 {
   // convert coordinates global->view
   *xv = x*fCos + y*fSin;
@@ -375,7 +391,7 @@ void AliHLTTPCCADisplay::Slice2View( Double_t x, Double_t y, Double_t *xv, Doubl
 }
 
 
-void AliHLTTPCCADisplay::DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color, Double_t width  )
+void AliHLTTPCCADisplay::DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color, Size_t width  )
 {
   // draw hit
   AliHLTTPCCAGBHit &h = tracker.Hits()[iHit];
@@ -405,7 +421,7 @@ void AliHLTTPCCADisplay::DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, I
   fMarker.DrawMarker(h.Z(), vy); 
 }
 
-void AliHLTTPCCADisplay::DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color, Double_t width )
+void AliHLTTPCCADisplay::DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color, Size_t width )
 {
   // draw hits 
 
@@ -438,7 +454,7 @@ void AliHLTTPCCADisplay::DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color,
   }
 }
 
-void AliHLTTPCCADisplay::DrawSliceHit( Int_t iRow, Int_t iHit, Int_t color, Double_t width )
+void AliHLTTPCCADisplay::DrawSliceHit( Int_t iRow, Int_t iHit, Int_t color, Size_t width )
 {
   // draw hit
   if( !fSlice ) return;
@@ -448,7 +464,7 @@ void AliHLTTPCCADisplay::DrawSliceHit( Int_t iRow, Int_t iHit, Int_t color, Doub
   DrawGBHit(  tracker, id, color, width );
 }
 
-void AliHLTTPCCADisplay::DrawSliceHits( Int_t color, Double_t width )
+void AliHLTTPCCADisplay::DrawSliceHits( Int_t color, Size_t width )
 {
   // draw hits 
 
@@ -495,7 +511,70 @@ void AliHLTTPCCADisplay::DrawSliceHits( Int_t color, Double_t width )
   }
 }
 
-Int_t AliHLTTPCCADisplay::GetTrackMC( AliHLTTPCCADisplayTmpHit *vHits, Int_t NHits )
+
+void AliHLTTPCCADisplay::DrawSliceLink( Int_t iRow, Int_t iHit, Int_t colorUp, Int_t colorDn, Int_t width )
+{
+  // draw link between clusters 
+
+  if( !fPerf || !fGB) return;
+  AliHLTTPCCAGBTracker &tracker = *fGB;
+  if( width<0 ) width = 1.;
+  fLine.SetLineWidth( width );
+  Int_t colUp = colorUp>=0 ? colorUp :kMagenta;
+  Int_t colDn = colorDn>=0 ? colorDn :kBlack;
+  if( iRow<1 || iRow>=fSlice->Param().NRows()-1 ) return;
+
+  const AliHLTTPCCARow& row = fSlice->Row(iRow);
+  const AliHLTTPCCARow& rowUp = fSlice->Row(iRow+1);
+  const AliHLTTPCCARow& rowDn = fSlice->Row(iRow-1);
+    
+  Int_t id = fSlice->HitInputIDs()[row.FirstHit()+iHit];
+  AliHLTTPCCAGBHit &h = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id]; 
+  Short_t iUp = ((Short_t*)(fSlice->RowData() + row.FullOffset()))[row.FullLinkOffset()+iHit];
+  Short_t iDn = ((Short_t*)(fSlice->RowData() + row.FullOffset()))[row.FullLinkOffset()+row.NHits()+iHit];
+
+  if( iUp>=0){
+    Int_t id1 =fSlice->HitInputIDs()[rowUp.FirstHit()+iUp];
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id1]; 
+    Double_t vx, vy, vx1, vy1;
+    Slice2View( h.X(), h.Y(), &vx, &vy );  
+    Slice2View( h1.X(), h1.Y(), &vx1, &vy1 );  
+    fLine.SetLineColor( colUp );
+    fYX->cd();
+    fLine.DrawLine(vx-.1,vy,vx1-.1,vy1);
+    fZX->cd();
+    fLine.DrawLine(h.Z()-1.,vy,h1.Z()-1.,vy1);
+  }
+  if( iDn>=0){
+    Int_t id1 =fSlice->HitInputIDs()[rowDn.FirstHit()+iDn];
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id1]; 
+    Double_t vx, vy, vx1, vy1;
+    Slice2View( h.X(), h.Y(), &vx, &vy );  
+    Slice2View( h1.X(), h1.Y(), &vx1, &vy1 );  
+    fLine.SetLineColor( colDn );
+    fYX->cd();
+    fLine.DrawLine(vx+.1,vy,vx1+.1,vy1);
+    fZX->cd();
+    fLine.DrawLine(h.Z()+1.,vy,h1.Z()+1.,vy1);
+  }
+}
+
+
+void AliHLTTPCCADisplay::DrawSliceLinks( Int_t colorUp, Int_t colorDn, Int_t width )
+{
+  // draw links between clusters 
+
+  for( Int_t iRow=1; iRow<fSlice->Param().NRows()-1; iRow++){
+    const AliHLTTPCCARow& row = fSlice->Row(iRow);
+    for( Int_t ih=0; ih<row.NHits(); ih++ ){
+      DrawSliceLink( iRow, ih, colorUp, colorDn, width );
+    }
+  }
+}
+
+
+
+Int_t AliHLTTPCCADisplay::GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, Int_t NHits )
 {
   // get MC label for the track
   
@@ -562,8 +641,8 @@ Int_t AliHLTTPCCADisplay::GetTrackMC( AliHLTTPCCADisplayTmpHit *vHits, Int_t NHi
   return label;
 }
 
-Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, AliHLTTPCCADisplayTmpHit *vHits, 
-                                   Int_t NHits, Int_t color, Double_t width, Bool_t pPoint )
+Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, const AliHLTTPCCADisplayTmpHit *vHits, 
+                                   Int_t NHits, Int_t color, Int_t width, Bool_t pPoint )
 {
   // draw track
 
@@ -603,7 +682,7 @@ Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, A
   Int_t mHits = 0;
 
   //Int_t oldSlice = -1;
-  Double_t alpha = (Alpha==-1) ?fSlice->Param().Alpha() :Alpha;
+  Double_t alpha = ( TMath::Abs(Alpha+1)<1.e-4 ) ?fSlice->Param().Alpha() :Alpha;
   AliHLTTPCCATrackParam tt = t;
 
   for( Int_t iHit=0; iHit<NHits; iHit++ ){
@@ -666,7 +745,7 @@ Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, A
   }
   if( pPoint ){
     Double_t x1=t.X(), y1=t.Y(), z1=t.Z();
-    Double_t a = (Alpha==-1) ?fSlice->Param().Alpha() :Alpha;
+    Double_t a = ( TMath::Abs(Alpha+1)<1.e-4 ) ?fSlice->Param().Alpha() :Alpha;
     SetSliceTransform( a );
 
     Slice2View(x1, y1, &x1, &y1 );
@@ -703,13 +782,13 @@ Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, A
   fArc.SetFillStyle(0);
   fArc.SetLineColor(color);    
   fArc.SetLineWidth(width);        
-  TPolyLine pl;
-  pl.SetLineColor(color);
+  TPolyLine pl;   
+  pl.SetLineColor(color); 
   pl.SetLineWidth(width);
   TPolyLine plZ;
-  plZ.SetLineColor(color);
+  plZ.SetLineColor(color); 
   plZ.SetLineWidth(width);
-  
+   
   fMarker.SetMarkerSize(width/2.);
   fMarker.SetMarkerColor(color);
 
@@ -729,7 +808,7 @@ Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, A
 }
 
 
-Bool_t AliHLTTPCCADisplay::DrawTracklet( AliHLTTPCCATrackParam &track, Int_t *hitstore, Int_t color,Double_t width, Bool_t pPoint )
+Bool_t AliHLTTPCCADisplay::DrawTracklet( AliHLTTPCCATrackParam &track, const Int_t *hitstore, Int_t color, Int_t width, Bool_t pPoint )
 {
   // draw tracklet
   AliHLTTPCCAGBTracker &tracker = *fGB;
@@ -751,7 +830,7 @@ Bool_t AliHLTTPCCADisplay::DrawTracklet( AliHLTTPCCATrackParam &track, Int_t *hi
 }
 
 
-void AliHLTTPCCADisplay::DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t alpha, Int_t itr, Int_t color, Double_t width )
+void AliHLTTPCCADisplay::DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t alpha, Int_t itr, Int_t color, Int_t width )
 {
   // draw slice track
   
@@ -772,7 +851,7 @@ void AliHLTTPCCADisplay::DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t a
   DrawTrack( t, alpha, vHits, track.NHits(), color, width, 1 );
 }
 
-void AliHLTTPCCADisplay::DrawSliceOutTrack( Int_t itr, Int_t color, Double_t width )
+void AliHLTTPCCADisplay::DrawSliceOutTrack( Int_t itr, Int_t color, Int_t width )
 {
   // draw slice track
   
@@ -820,7 +899,7 @@ void AliHLTTPCCADisplay::DrawSliceTrack( Int_t itr, Int_t color )
 }
 
 
-void AliHLTTPCCADisplay::DrawGBTrack( Int_t itr, Int_t color, Double_t width )
+void AliHLTTPCCADisplay::DrawGBTrack( Int_t itr, Int_t color, Int_t width )
 {
   // draw global track
 
@@ -991,8 +1070,9 @@ void AliHLTTPCCADisplay::DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t i
 
 void AliHLTTPCCADisplay::DrawMergedHit( Int_t iRow, Int_t iHit, Int_t color )
 {
+  // connect two cells on display
+
 #ifdef XXX
-  // connect two cells on display, kind of row is drawing
   
   const AliHLTTPCCARow &row = fSlice->Row(iRow);
   AliHLTTPCCAHit &h = row.Hits()[iHit];
index d69c57b..6adb15d 100644 (file)
@@ -1,14 +1,14 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project         * 
-//* ALICE Experiment at CERN, All rights reserved.                          *
-//* See cxx source for full Copyright notice                                *
-
-//*                                                                         *
-//*  AliHLTTPCCADisplay class is a debug utility.                           *
-//*  It is not used in the normal data processing.                          *
-//*                                                                         *
+//  *************************************************************************
+//  This file is property of and copyright by the ALICE HLT Project         * 
+//  ALICE Experiment at CERN, All rights reserved.                          *
+//  See cxx source for full Copyright notice                                *
+//                                                                          *
+//  AliHLTTPCCADisplay class is a debug utility.                            *
+//  It is not used in the normal data processing.                           *
+//                                                                          *
+//***************************************************************************
 
 #ifndef ALIHLTTPCCADISPLAY_H
 #define ALIHLTTPCCADISPLAY_H
@@ -28,6 +28,7 @@ class TCanvas;
 #include "TMarker.h"
 #include "TLatex.h"
 
+
 /**
  * @class AliHLTTPCCADisplay
  */
@@ -35,7 +36,7 @@ class AliHLTTPCCADisplay
 {
 
  public:
-
+  
   class AliHLTTPCCADisplayTmpHit{  
 
   public:
@@ -43,9 +44,9 @@ class AliHLTTPCCADisplay
     Double_t S() const { return fS; }
     Double_t Z() const { return fZ; }
 
-    void SetID( Int_t v ){ fHitID = v; }
-    void SetS( Double_t v){ fS = v; }
-    void SetZ( Double_t v){ fZ = v; }
+    void SetID( Int_t v ){ this->fHitID = v; }    
+    void SetS( Double_t v){ this->fS = v; }
+    void SetZ( Double_t v){ this->fZ = v; }
 
     static Bool_t CompareHitDS( const AliHLTTPCCADisplayTmpHit &a, 
                                 const AliHLTTPCCADisplayTmpHit  &b )
@@ -57,7 +58,7 @@ class AliHLTTPCCADisplay
     {    
       return (a.fZ < b.fZ);
     }
-  protected:
+  private:
     Int_t fHitID; // hit ID
     Double_t fS;  // hit position on the XY track curve 
     Double_t fZ;  // hit Z position
@@ -67,7 +68,7 @@ class AliHLTTPCCADisplay
   
   AliHLTTPCCADisplay();
   AliHLTTPCCADisplay( const AliHLTTPCCADisplay& );
-  AliHLTTPCCADisplay& operator=(const AliHLTTPCCADisplay&);
+  const AliHLTTPCCADisplay& operator=(const AliHLTTPCCADisplay&) const ;
 
   virtual ~AliHLTTPCCADisplay();
 
@@ -78,8 +79,8 @@ class AliHLTTPCCADisplay
   void SetSliceView();
   void SetTPCView();
   void SetCurrentSlice( AliHLTTPCCATracker *slice ); 
-  void SetGB( AliHLTTPCCAGBTracker *GBTracker );   
-  void Set2Slices( AliHLTTPCCATracker *slice );
+  void SetGB( AliHLTTPCCAGBTracker * const GBTracker );   
+  void Set2Slices( AliHLTTPCCATracker * const slice );
 
   Int_t GetColor( Int_t i ) const;
   Int_t GetColorZ( Double_t z ) const ;
@@ -87,25 +88,27 @@ class AliHLTTPCCADisplay
   Int_t GetColorK( Double_t k ) const ;
   void Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const ;
   void Slice2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const ;
-  Int_t GetTrackMC( AliHLTTPCCADisplayTmpHit *vHits, Int_t NHits );
+  Int_t GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, Int_t NHits );
 
   void DrawTPC();
   void DrawSlice( AliHLTTPCCATracker *slice, Bool_t DrawRows=0 ); 
-  void DrawSliceOutTrack( Int_t itr, Int_t color=-1, Double_t width = -1  );
-  void DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t Alpha, Int_t itr, Int_t color=-1, Double_t width = -1  );
+  void DrawSliceOutTrack( Int_t itr, Int_t color=-1, Int_t width = -1  );
+  void DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t Alpha, Int_t itr, Int_t color=-1, Int_t width = -1  );
   void DrawSliceTrack( Int_t itr, Int_t color=-1);
-  Bool_t DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, AliHLTTPCCADisplayTmpHit *vHits, 
-                 Int_t NHits, Int_t color=-1, Double_t width=-1, Bool_t pPoint=0 );
+  Bool_t DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, const AliHLTTPCCADisplayTmpHit *vHits, 
+                   Int_t NHits, Int_t color=-1, Int_t width=-1, Bool_t pPoint=0 );
 
-  void DrawGBTrack( Int_t itr, Int_t color=-1, Double_t width=-1 );
+  void DrawGBTrack( Int_t itr, Int_t color=-1, Int_t width=-1 );
   void DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color=-1 );
-  Bool_t DrawTracklet( AliHLTTPCCATrackParam &track, Int_t *hitstore, Int_t color=-1, Double_t width=-1, Bool_t pPoint=0 );
+  Bool_t DrawTracklet( AliHLTTPCCATrackParam &track, const Int_t *hitstore, Int_t color=-1, Int_t width=-1, Bool_t pPoint=0 );
  
-  void DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color=-1, Double_t width =-1 );
-  void DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color=-1, Double_t width =-1 );
+  void DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color=-1, Size_t width =-1 );
+  void DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color=-1, Size_t width =-1 );
 
-  void DrawSliceHit( Int_t iRow,Int_t iHit, Int_t color=-1, Double_t width=-1 );
-  void DrawSliceHits(Int_t color=-1, Double_t width=-1 );
+  void DrawSliceHit( Int_t iRow,Int_t iHit, Int_t color=-1, Size_t width=-1 );
+  void DrawSliceHits(Int_t color=-1, Size_t width=-1 );
+  void DrawSliceLinks(Int_t colorUp=-1, Int_t colorDn=-1,Int_t width=-1 );
+  void DrawSliceLink(Int_t iRow, Int_t iHit, Int_t colorUp=-1, Int_t colorDn=-1,Int_t width=-1 );
 
 #ifdef XXXX
 
@@ -119,8 +122,8 @@ class AliHLTTPCCADisplay
 
   void SetSliceTransform( AliHLTTPCCATracker *slice );
 
-  TCanvas *CanvasYX(){ return fYX; }
-  TCanvas *CanvasZX(){ return fZX; }
+  TCanvas *CanvasYX() const { return fYX; }
+  TCanvas *CanvasZX() const { return fZX; }
 
  protected:
 
index 78e2888..9519cf5 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCAGBHit.h"
index 50674b8..495d7da 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAGBHIT_H
 #define ALIHLTTPCCAGBHIT_H
index 5427df0..978475e 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
+
 #include "AliHLTTPCCAGBTrack.h"
 
 ClassImp(AliHLTTPCCAGBTrack)
  
-void AliHLTTPCCAGBTrack::Dummy()
+void AliHLTTPCCAGBTrack::Dummy() const
 { 
   //* do nothing
 }
index 239a471..8ad0d46 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAGBTRACK_H
 #define ALIHLTTPCCAGBTRACK_H
@@ -52,7 +54,7 @@ class AliHLTTPCCAGBTrack
 
  private:
 
-  void Dummy(); // to make rulechecker happy by having something in .cxx file
+  void Dummy() const; // to make rulechecker happy by having something in .cxx file
 
   ClassDef(AliHLTTPCCAGBTrack,1)
 };
index 4954179..d654c46 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCAGBTracker.h"
 #include "AliHLTTPCCAGBHit.h"
 #include "AliHLTTPCCAOutTrack.h"
@@ -31,7 +33,6 @@
 
 #ifdef DRAW
 #include "AliHLTTPCCADisplay.h"
-#include "TApplication.h"
 #endif //DRAW
 
 
@@ -40,6 +41,7 @@ AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker()
     fSlices(0), 
     fNSlices(0), 
     fHits(0),
+    fExt2IntHitID(0),
     fNHits(0),
     fTrackHits(0), 
     fTracks(0), 
@@ -58,6 +60,7 @@ AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker(const AliHLTTPCCAGBTracker&)
     fSlices(0), 
     fNSlices(0), 
     fHits(0),
+    fExt2IntHitID(0),
     fNHits(0),
     fTrackHits(0), 
     fTracks(0), 
@@ -70,7 +73,7 @@ AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker(const AliHLTTPCCAGBTracker&)
   //* dummy
 }
 
-AliHLTTPCCAGBTracker &AliHLTTPCCAGBTracker::operator=(const AliHLTTPCCAGBTracker&)
+const AliHLTTPCCAGBTracker &AliHLTTPCCAGBTracker::operator=(const AliHLTTPCCAGBTracker&) const
 {
   //* dummy
   return *this;
@@ -129,6 +132,8 @@ void AliHLTTPCCAGBTracker::StartEvent()
   fTracks = 0;
   if( fHits ) delete[] fHits;
   fHits=0;
+  if( fExt2IntHitID ) delete[] fExt2IntHitID;
+  fExt2IntHitID = 0;
   fNHits = 0;
   fNTracks = 0;
   for( Int_t i=0; i<fNSlices; i++) fSlices[i].StartEvent();
@@ -140,7 +145,10 @@ void AliHLTTPCCAGBTracker::SetNHits( Int_t nHits )
   //* set the number of hits
   if( fHits ) delete[] fHits;
   fHits = 0;
+  if( fExt2IntHitID ) delete[] fExt2IntHitID;
+  fExt2IntHitID = 0;
   fHits = new AliHLTTPCCAGBHit[ nHits ];
+  fExt2IntHitID = new Int_t[ nHits ];
   fNHits = 0;
 }  
 
@@ -161,7 +169,7 @@ void AliHLTTPCCAGBTracker::ReadHit( Float_t x, Float_t y, Float_t z,
   hit.SetISlice( iSlice );
   hit.SetIRow( iRow );
   hit.SetIsUsed( 0 );
-  fNHits++;
+  fNHits++;  
 }
 
 void AliHLTTPCCAGBTracker::FindTracks()
@@ -171,22 +179,17 @@ void AliHLTTPCCAGBTracker::FindTracks()
   fStatNEvents++;  
 
 #ifdef DRAW
-  if( fStatNEvents<=1 ){
-    if( !gApplication ){
-      TApplication *myapp = new TApplication("myapp",0,0);
-    }    
-    AliHLTTPCCADisplay::Instance().Init();
-  }
   AliHLTTPCCADisplay::Instance().SetGB(this);
   AliHLTTPCCADisplay::Instance().SetTPCView();
   AliHLTTPCCADisplay::Instance().DrawTPC();
   AliHLTTPCCADisplay::Instance().Ask();
 #endif //DRAW  
 
-  if( fNHits<=0 ) return;
   
   std::sort(fHits,fHits+fNHits, AliHLTTPCCAGBHit::Compare );  
 
+  for( Int_t i=0; i<fNHits; i++ )  fExt2IntHitID[fHits[i].ID()] = i;
+
   // Read hits, row by row
 
   Int_t nHitsTotal = fNHits;
@@ -234,6 +237,8 @@ void AliHLTTPCCAGBTracker::FindTracks()
   hitY=0;
   if( hitZ ) delete[] hitZ;
   hitZ=0;
+  if( fNHits<=0 ) return;
 
   TStopwatch timer1;
   TStopwatch timer2;
@@ -305,12 +310,6 @@ void AliHLTTPCCAGBTracker::FindTracks0()
   fTime = 0;
   fStatNEvents++;  
 #ifdef DRAW
-  if( fStatNEvents<=1 ){
-    if( !gApplication ){
-      TApplication *myapp = new TApplication("myapp",0,0);
-    }    
-    AliHLTTPCCADisplay::Instance().Init();
-  }
   AliHLTTPCCADisplay::Instance().SetTPCView();
   AliHLTTPCCADisplay::Instance().DrawTPC();
 #endif //DRAW  
@@ -446,7 +445,7 @@ void AliHLTTPCCAGBTracker::Refit()
     for( Int_t itr=0; itr<*slice.NOutTracks(); itr++ ){
 
       AliHLTTPCCAOutTrack &iTr = slice.OutTracks()[itr];
-      
+
       struct FitPoint{    
        Int_t fISlice;
        Int_t fHitID;
@@ -469,7 +468,7 @@ void AliHLTTPCCAGBTracker::Refit()
        p.fAmp = h.Amp();
        nHits++;            
       }
-      
+     
       //if( nHits < 10 ) continue; SG!!!
 
       Int_t firstRow = 0, lastRow = maxNRows-1;
@@ -494,7 +493,8 @@ void AliHLTTPCCAGBTracker::Refit()
       for( Int_t i=firstRow; i<=lastRow; i++ ) searchRows[nSearchRows++] = i;
       
       //std::cout<<"\nRefit slice "<<iSlice<<" track "<<itr<<": "<<std::endl;
-      // refit down 
+
+     // refit down 
       {
        AliHLTTPCCATrackParam t0 = iTr.StartPoint();
        /*
@@ -722,6 +722,7 @@ void AliHLTTPCCAGBTracker::Refit()
        if( CAMath::Abs(t0.Kappa())<1.e-8 ) t0.SetKappa( 1.e-8 );       
        t0.TransportToX( slice.Row(lastRow).X(), .99 );
        iTr.SetEndPoint( t0 );          
+
       }
     }
   }
@@ -751,7 +752,7 @@ Bool_t AliHLTTPCCAGBTracker::FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrac
     Int_t iSlice = h.ISlice();
     AliHLTTPCCATracker &slice = fSlices[iSlice];
 
-    if( slice.Param().Alpha()!=Alpha ){
+    if( CAMath::Abs( slice.Param().Alpha()-Alpha)>1.e-4 ){
       if( ! t.RotateNoCos(  slice.Param().Alpha() - Alpha, t0, .999 ) ) continue;
       Alpha = slice.Param().Alpha();
     }
@@ -808,7 +809,7 @@ Bool_t AliHLTTPCCAGBTracker::FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrac
   ok = ok && (t.GetX()>50);
   
   if( c[0]<=0 || c[2]<=0 || c[5]<=0 || c[9]<=0 || c[14]<=0 ) ok = 0;
-  //if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2 ) ok = 0;
+  if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2 ) ok = 0;
   
   if( CAMath::Abs(t.SinPhi())>.99 ) ok = 0;
   else if( t0.CosPhi()>=0 ) t.SetCosPhi( CAMath::Sqrt(1.-t.SinPhi()*t.SinPhi()) );
@@ -858,7 +859,7 @@ void AliHLTTPCCAGBTracker::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLT
   if( iBorder==0 ){
     dAlpha = dAlpha - CAMath::Pi()/2 ;
   } else if( iBorder==1 ){
-    dAlpha = -dAlpha - CAMath::Pi()/2 ;    
+    dAlpha = -dAlpha - CAMath::Pi()/2 ;  
   } else if( iBorder==2 ){
     dAlpha = dAlpha;
     x0 = slice.Row(63).X();
@@ -870,13 +871,17 @@ void AliHLTTPCCAGBTracker::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLT
     x0 = slice.Row(63).X();
   }
 
-  for (Int_t itr=0; itr<*slice.NOutTracks(); itr++) {      
+  for (Int_t itr=0; itr<*slice.NOutTracks(); itr++) {
     AliHLTTPCCAOutTrack &t = slice.OutTracks()[itr];
-    
+
     AliHLTTPCCATrackParam t0 = t.StartPoint();
     AliHLTTPCCATrackParam t1 = t.EndPoint();
-    Bool_t ok0 = t0.Rotate( dAlpha,.9 );    
-    Bool_t ok1 = t1.Rotate( dAlpha,.9 );
+    //const Float_t maxSin = .9;
+
+    const Float_t maxSin = CAMath::Sin(60./180.*CAMath::Pi());
+
+    Bool_t ok0 = t0.Rotate( dAlpha, maxSin );
+    Bool_t ok1 = t1.Rotate( dAlpha, maxSin );
 
     Bool_t do0 = ok0;
     Bool_t do1 = ok1 && ( !ok0 || t1.CosPhi()*t0.CosPhi()<0 );
@@ -894,7 +899,7 @@ void AliHLTTPCCAGBTracker::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLT
       b.fIRow = fHits[ fFirstSliceHit[iSlice] + slice.OutTrackHits()[t.FirstHitRef()+0]].IRow();
       b.fParam = t0;
       b.fX = t0.GetX();
-      if( b.fParam.TransportToX( x0, .9 ) ) nB++;
+      if( b.fParam.TransportToX( x0, maxSin ) ) nB++;
       //else std::cout<<"0: can not transport to x="<<x0<<std::endl;
 
     }
@@ -906,7 +911,7 @@ void AliHLTTPCCAGBTracker::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLT
       b.fIRow = fHits[ fFirstSliceHit[iSlice] + slice.OutTrackHits()[t.FirstHitRef()+t.NHits()-1]].IRow();
       b.fParam = t1;    
       b.fX = t0.GetX();
-      if( b.fParam.TransportToX( x0, .9 ) ) nB++;
+      if( b.fParam.TransportToX( x0, maxSin ) ) nB++;
       //else std::cout<<"1: can not transport to x="<<x0<<std::endl;
     }
     if( do0 || do1 ) statOK++;
@@ -923,13 +928,14 @@ void AliHLTTPCCAGBTracker::SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTr
 {
   //* split two sets of tracks
 
-  Float_t factor2y = 2.6;
-  Float_t factor2z = 4.0;
-  Float_t factor2s = 2.6;
-  Float_t factor2t = 2.0;
-  Float_t factor2k = 2.2;
-  Float_t factor2ys = 1.5;
-  Float_t factor2zt = 1.5;
+  Float_t factor2y = 10;//2.6;
+  Float_t factor2z = 10;//4.0;
+  Float_t factor2s = 10;//2.6;
+  Float_t factor2t = 10;//2.0;
+  Float_t factor2k = 2.0;//2.2;
+
+  Float_t factor2ys = 1.;//1.5;//SG!!!
+  Float_t factor2zt = 1.;//1.5;//SG!!!
 
   AliHLTTPCCATracker &slice1 = fSlices[iSlice1];
   AliHLTTPCCATracker &slice2 = fSlices[iSlice2];
@@ -1216,6 +1222,7 @@ void AliHLTTPCCAGBTracker::Merging()
       *iS.NOutTrackHits() = nH;
       for( Int_t itr=0; itr<nTr; itr++ ) iS.OutTracks()[itr] = tmpT[itr];
       for( Int_t ih=0; ih<nH; ih++ ) iS.OutTrackHits()[ih] = tmpH[ih];
+      //std::cout<<"\nMerge tracks withing slice "<<iSlice<<" ok\n"<<std::endl;
 
 #ifdef DRAW
   if(0){
@@ -1263,10 +1270,14 @@ void AliHLTTPCCAGBTracker::Merging()
       
   //* arrays for the rotated track parameters
 
-  AliHLTTPCCABorderTrack bCurr0[maxNSliceTracks*10], bNext0[maxNSliceTracks*10];
-  AliHLTTPCCABorderTrack bCurr[maxNSliceTracks*10], bNext[maxNSliceTracks*10];
 
-  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
+    AliHLTTPCCABorderTrack 
+      *bCurr0 = new AliHLTTPCCABorderTrack[maxNSliceTracks*10], 
+      *bNext0 = new AliHLTTPCCABorderTrack[maxNSliceTracks*10],
+      *bCurr = new AliHLTTPCCABorderTrack[maxNSliceTracks*10], 
+      *bNext = new AliHLTTPCCABorderTrack[maxNSliceTracks*10];
+
+    for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
     
     Int_t jSlice = nextSlice[iSlice];
 
@@ -1289,13 +1300,18 @@ void AliHLTTPCCAGBTracker::Merging()
 #endif
     Float_t alph = -1;//iS.Param().Alpha() + ( fSlices[1].Param().Alpha() - fSlices[0].Param().Alpha() )/2;
     Float_t alph1 = -1;//alph - CAMath::Pi()/2;
-    SplitBorderTracks( iSlice, bCurr0, nCurr0, jSlice, bNext0, nNext0, alph );   
+    SplitBorderTracks( iSlice, bCurr0, nCurr0, jSlice, bNext0, nNext0, alph );   //SG!!!
 #ifdef DRAW
     std::cout<<"\nMerge1 tracks :\n"<<std::endl;
 #endif
-    SplitBorderTracks( iSlice, bCurr, nCurr, jSlice, bNext, nNext, alph1 );    
-  }
-  
+    SplitBorderTracks( iSlice, bCurr, nCurr, jSlice, bNext, nNext, alph1 );    //SG!!!
+    }
+
+    if( bCurr0 ) delete[] bCurr0;
+    if( bNext0 ) delete[] bNext0;
+    if( bCurr  ) delete[] bCurr;
+    if( bNext  ) delete[] bNext;
+
   TStopwatch timerMerge2;
 
   Int_t nTracksTot = 0;
@@ -1308,7 +1324,7 @@ void AliHLTTPCCAGBTracker::Merging()
   fTrackHits = 0;
   if(fTracks ) delete[] fTracks;
   fTracks = 0;
-  fTrackHits = new Int_t [fNHits*10];
+  fTrackHits = new Int_t [fNHits*100];//SG!!!
   fTracks = new AliHLTTPCCAGBTrack[nTracksTot];
   fNTracks = 0;
 
@@ -1401,7 +1417,7 @@ void AliHLTTPCCAGBTracker::Merging()
       if( nHits < 30 ) continue;     //SG!!!
 
       // refit 
-      Float_t dEdX;
+      Float_t dEdX=0;
       if( !FitTrack( endPoint, startPoint, startAlpha, hits+firstHit, nHits, dEdX, 0 ) ) continue;
       endAlpha = startAlpha;
       if( !FitTrack( startPoint, endPoint, startAlpha, hits+firstHit, nHits, dEdX, 1 ) ) continue;
@@ -1447,7 +1463,7 @@ void AliHLTTPCCAGBTracker::Merging()
        ok = ok && (p.GetX()>50);
        
        if( c[0]<=0 || c[2]<=0 || c[5]<=0 || c[9]<=0 || c[14]<=0 ) ok = 0;
-       //if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2 ) ok = 0;
+       if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2 ) ok = 0;
        if(!ok) continue;       
       }
       t.SetParam( p );
index 1896c32..22b9d94 100644 (file)
@@ -1,9 +1,10 @@
 //-*- Mode: C++ -*-
-// $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAGBTRACKER_H
 #define ALIHLTTPCCAGBTRACKER_H
@@ -43,7 +44,7 @@ public:
 
   AliHLTTPCCAGBTracker();
   AliHLTTPCCAGBTracker(const AliHLTTPCCAGBTracker&);
-  AliHLTTPCCAGBTracker &operator=(const AliHLTTPCCAGBTracker&);
+  const AliHLTTPCCAGBTracker &operator=(const AliHLTTPCCAGBTracker&) const;
 
   ~AliHLTTPCCAGBTracker();
 
@@ -78,21 +79,24 @@ public:
   void SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTrack B1[], Int_t N1,
                          Int_t iSlice2, AliHLTTPCCABorderTrack B2[], Int_t N2, 
                          Float_t Alpha =-1 );
-  Float_t GetChi2( Float_t x1, Float_t y1, Float_t a00, Float_t a10, Float_t a11, 
-                  Float_t x2, Float_t y2, Float_t b00, Float_t b10, Float_t b11  );
+
+  static Float_t GetChi2( Float_t x1, Float_t y1, Float_t a00, Float_t a10, Float_t a11, 
+                         Float_t x2, Float_t y2, Float_t b00, Float_t b10, Float_t b11  );
 
   void Merging();
 
-  AliHLTTPCCATracker *Slices(){ return fSlices; }
-  AliHLTTPCCAGBHit *Hits(){ return fHits; }
+  AliHLTTPCCATracker *Slices() const { return fSlices; }
+  AliHLTTPCCAGBHit *Hits() const { return fHits; }
+  Int_t Ext2IntHitID( Int_t i ) const { return fExt2IntHitID[i]; }
+
   Int_t NHits() const { return fNHits; }
   Int_t NSlices() const { return fNSlices; }
   Double_t Time() const { return fTime; }
   Double_t StatTime( Int_t iTimer ) const { return fStatTime[iTimer]; }
   Int_t StatNEvents() const { return fStatNEvents; }
   Int_t NTracks() const { return fNTracks; }
-  AliHLTTPCCAGBTrack *Tracks(){ return fTracks; }
-  Int_t *TrackHits() {return fTrackHits; }
+  AliHLTTPCCAGBTrack *Tracks() const { return fTracks; }
+  Int_t *TrackHits() const { return fTrackHits; }
   void GetErrors2( AliHLTTPCCAGBHit &h, AliHLTTPCCATrackParam &t, Float_t &Err2Y, Float_t &Err2Z );
   void GetErrors2( Int_t iSlice, Int_t iRow, AliHLTTPCCATrackParam &t, Float_t &Err2Y, Float_t &Err2Z );
 
@@ -106,6 +110,7 @@ public:
   Double_t SliceTrackerTime() const { return fSliceTrackerTime; }
   void SetSliceTrackerTime( Double_t v ){ fSliceTrackerTime = v; }
   const Int_t *FirstSliceHit() const { return fFirstSliceHit; }
+
   Bool_t FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrackParam t0, 
                   Float_t &Alpha, Int_t hits[], Int_t &NHits, 
                   Float_t &DeDx, Bool_t dir=0 );
@@ -115,6 +120,7 @@ protected:
   AliHLTTPCCATracker *fSlices; //* array of slice trackers
   Int_t fNSlices;              //* N slices
   AliHLTTPCCAGBHit *fHits;     //* hit array
+  Int_t *fExt2IntHitID;        //* array of internal hit indices
   Int_t fNHits;                //* N hits in event
   Int_t *fTrackHits;           //* track->hits reference array
   AliHLTTPCCAGBTrack *fTracks; //* array of tracks
index 86fd0b5..4780cab 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
+
 #include "AliHLTTPCCAGrid.h"
 #include "AliHLTTPCCAMath.h"
 
@@ -61,11 +64,13 @@ GPUd() UInt_t AliHLTTPCCAGrid::GetBin( Float_t Y, Float_t Z ) const
 {
   //* get the bin pointer
   
-  Int_t yBin = (Int_t) CAMath::fmul_rz( Y-fYMin, fStepYInv );
-  Int_t zBin = (Int_t) CAMath::fmul_rz( Z-fZMin, fStepZInv );
-  Int_t bin = CAMath::mul24(zBin,fNy) + yBin;    
-  if( bin<0 ) return 0;
-  if( bin>=(Int_t) fN ) return fN - 1;  
+  Int_t bbY = (Int_t) CAMath::FMulRZ( Y-fYMin, fStepYInv );
+  Int_t bbZ = (Int_t) CAMath::FMulRZ( Z-fZMin, fStepZInv );
+  if( bbY<0 ) bbY = 0;
+  else if( bbY>=(Int_t)fNy ) bbY = fNy - 1;  
+  if( bbZ<0 ) bbZ = 0;
+  else if( bbZ>=(Int_t)fNz ) bbZ = fNz - 1;
+  Int_t bin = CAMath::Mul24(bbZ,fNy) + bbY;    
   return (UInt_t) bin;
 }
 
index 0eca6a8..eb61e76 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAGRID_H
 #define ALIHLTTPCCAGRID_H
index 1cf4afc..9ea624f 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAHIT_H
 #define ALIHLTTPCCAHIT_H
index 0835948..5dde989 100644 (file)
@@ -1,4 +1,4 @@
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCAHitArea.h"
 #include "AliHLTTPCCATracker.h"
-#include "AliHLTTPCCAGrid.h"
 #include "AliHLTTPCCAHit.h"
-#include "AliHLTTPCCARow.h"
 
 /*
-GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a,  AliHLTTPCCAGrid &grid, UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
+GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a,  AliHLTTPCCAGrid &grid, const UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
 { 
   // initialisation
 
@@ -47,7 +46,7 @@ GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a,  AliHLTTPCCAGrid &gri
 */
 
 
-GPUd() void AliHLTTPCCAHitArea::Init( const AliHLTTPCCAGrid &grid, UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
+GPUd() void AliHLTTPCCAHitArea::Init( const AliHLTTPCCAGrid &grid, const UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
 { 
   //initialisation
 
@@ -71,7 +70,7 @@ GPUd() void AliHLTTPCCAHitArea::Init( const AliHLTTPCCAGrid &grid, UShort_t *con
 }
 
 
-GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, UShort_t *content, AliHLTTPCCAHit &h)
+GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content, AliHLTTPCCAHit &h)
 {    
   // get next hit index
   Float_t y0 = row.Grid().YMin();
@@ -99,7 +98,7 @@ GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, const AliH
     }
     //h = tracker.Hits()[ fHitOffset + fIh ];    
     
-    if( 0 && (h.Z()>fMaxZ || h.Z()<fMinZ || h.Y()<fMinY || h.Y()>fMaxY )){ //SG!!!
+    if( 1 && (h.Z()>fMaxZ || h.Z()<fMinZ || h.Y()<fMinY || h.Y()>fMaxY )){ //SG!!!
       fIh++;
       continue;
     }
@@ -112,7 +111,7 @@ GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, const AliH
 
 
 
-GPUd() Int_t AliHLTTPCCAHitArea::GetBest(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, UShort_t *content, AliHLTTPCCAHit &h)
+GPUd() Int_t AliHLTTPCCAHitArea::GetBest(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content, AliHLTTPCCAHit &h)
 {
   // get closest hit in the area
   Int_t best = -1;
index 792268c..18c4cc3 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id: AliHLTTPCCARow.h 27042 2008-07-02 12:06:02Z richterm $
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAHITAREA_H
 #define ALIHLTTPCCAHITAREA_H
@@ -24,11 +26,11 @@ class AliHLTTPCCAHitArea
 {
 public:
   
-  GPUd() void Init( const AliHLTTPCCAGrid &grid, UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz );
+  GPUd() void Init( const AliHLTTPCCAGrid &grid, const UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz );
 
-  GPUd() Int_t GetNext(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, UShort_t *content,AliHLTTPCCAHit &h);
+  GPUd() Int_t GetNext(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content,AliHLTTPCCAHit &h);
 
-  GPUd() Int_t GetBest(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, UShort_t *content,AliHLTTPCCAHit &h );
+  GPUd() Int_t GetBest(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content,AliHLTTPCCAHit &h );
 
   GPUhd() Float_t Y() const { return fY;}
   GPUhd() Float_t Z() const { return fZ;}
index 3f05f1f..e96acfb 100644 (file)
@@ -1,5 +1,5 @@
 // $Id: AliHLTTPCCAMCPoint.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCAMCPoint.h"
index 6c691f9..9eea00f 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAMCPOINT_H
 #define ALIHLTTPCCAMCPOINT_H
index 8700d62..3064cdb 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCAMCTrack.h"
 #include "AliHLTTPCCAMath.h"
 #include "TParticle.h"
index a2d97d5..d2c9d07 100644 (file)
@@ -1,9 +1,10 @@
 //-*- Mode: C++ -*-
-// $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAMCTRACK_H
 #define ALIHLTTPCCAMCTRACK_H
@@ -23,21 +24,34 @@ class AliHLTTPCCAMCTrack
 
   AliHLTTPCCAMCTrack();
   AliHLTTPCCAMCTrack( const TParticle *part );
+
   void SetTPCPar( Float_t X, Float_t Y, Float_t Z, Float_t Px, Float_t Py, Float_t Pz );
 
-  Int_t    &PDG()           { return fPDG;}
-  Double_t *Par()           { return fPar; }
-  Double_t *TPCPar()        { return fTPCPar; }
-  Double_t &P()             { return fP; }
-  Double_t &Pt()            { return fPt; }
+  Int_t     PDG()            const { return fPDG;}
+  const Double_t *Par()            const { return fPar; }
+  const Double_t *TPCPar()         const { return fTPCPar; }
+  Double_t  P()              const { return fP; }
+  Double_t  Pt()             const { return fPt; }
   
-  Int_t    &NHits()         { return fNHits;}
-  Int_t    &NMCPoints()     { return fNMCPoints;}
-  Int_t    &FirstMCPointID(){ return fFirstMCPointID;}
-  Int_t    &NReconstructed(){ return fNReconstructed; }
-  Int_t    &Set()           { return fSet; }
-  Int_t    &NTurns()        { return fNTurns; }
+  Int_t     NHits()          const { return fNHits;}
+  Int_t     NMCPoints()      const { return fNMCPoints;}
+  Int_t     FirstMCPointID() const { return fFirstMCPointID;}
+  Int_t     NReconstructed() const { return fNReconstructed; }
+  Int_t     Set()            const { return fSet; }
+  Int_t     NTurns()         const { return fNTurns; }
 
+  void SetP ( Float_t v )          { fP = v; }
+  void SetPt( Float_t v )          { fPt = v; }
+  void SetPDG( Int_t v )         { fPDG = v; }
+  void SetPar( Int_t i, Double_t v)             { fPar[i] = v; }
+  void SetTPCPar( Int_t i, Double_t v)          { fTPCPar[i] = v; }
+  void SetNHits( Int_t v )         { fNHits = v; }
+  void SetNMCPoints( Int_t v)      { fNMCPoints = v; }
+  void SetFirstMCPointID( Int_t v ){ fFirstMCPointID = v;}
+  void SetNReconstructed( Int_t v ){ fNReconstructed = v; }
+  void SetSet( Int_t v )           { fSet = v; }
+  void SetNTurns( Int_t v )        { fNTurns = v; }
+  
  protected:
 
   Int_t    fPDG;            //* particle pdg code
index a6b7231..c52364b 100644 (file)
@@ -1,9 +1,10 @@
 //-*- Mode: C++ -*-
-// @(#) $Id: AliHLTTPCCARow.h 27042 2008-07-02 12:06:02Z richterm $
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAMATH_H
 #define ALIHLTTPCCAMATH_H
@@ -24,6 +25,8 @@
 class AliHLTTPCCAMath
 {
 public:
+  GPUd() static float2 MakeFloat2(float x, float y );
+
   GPUd() static Float_t Min(Float_t x, Float_t y);
   GPUd() static Float_t Max(Float_t x, Float_t y);
   GPUd() static Int_t Min(Int_t x, Int_t y);
@@ -43,12 +46,12 @@ public:
   GPUd() static Int_t Nint(Float_t x );
   GPUd() static Bool_t Finite(Float_t x );
 
-  GPUd()  static Int_t atomicExch( Int_t *addr, Int_t val);
-  GPUd()  static Int_t atomicAdd ( Int_t *addr, Int_t val);
-  GPUd()  static Int_t atomicMax ( Int_t *addr, Int_t val);
-  GPUd()  static Int_t atomicMin ( Int_t *addr, Int_t val);
-  GPUd()  static Int_t mul24( Int_t a, Int_t b );
-  GPUd()  static Float_t fmul_rz( Float_t a, Float_t b );
+  GPUd()  static Int_t AtomicExch( Int_t *addr, Int_t val);
+  GPUd()  static Int_t AtomicAdd ( Int_t *addr, Int_t val);
+  GPUd()  static Int_t AtomicMax ( Int_t *addr, Int_t val);
+  GPUd()  static Int_t AtomicMin ( Int_t *addr, Int_t val);
+  GPUd()  static Int_t Mul24( Int_t a, Int_t b );
+  GPUd()  static Float_t FMulRZ( Float_t a, Float_t b );
 };
 
 typedef AliHLTTPCCAMath CAMath;
@@ -62,6 +65,16 @@ typedef AliHLTTPCCAMath CAMath;
 #define choice(c1,c2,c3) c3
 #endif
 
+GPUd() inline float2 AliHLTTPCCAMath::MakeFloat2(float x, float y )
+{
+#if !defined( HLTCA_GPUCODE )
+  float2 ret = {x,y};
+  return ret;
+#else
+  return make_float2(x,y);
+#endif
+}
+
 
 GPUd() inline Int_t AliHLTTPCCAMath::Nint(Float_t x)
 {  
@@ -163,18 +176,18 @@ GPUd() inline Float_t AliHLTTPCCAMath::ASin(Float_t x )
 }
 
 
-GPUd() inline Int_t AliHLTTPCCAMath::mul24( Int_t a, Int_t b )
+GPUd() inline Int_t AliHLTTPCCAMath::Mul24( Int_t a, Int_t b )
 {
   return choice( __mul24(a,b), a*b, a*b );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::fmul_rz( Float_t a, Float_t b )
+GPUd() inline Float_t AliHLTTPCCAMath::FMulRZ( Float_t a, Float_t b )
 {
   return choice( __fmul_rz(a,b), a*b, a*b );
 }
 
 
-GPUd()  inline Int_t AliHLTTPCCAMath::atomicExch( Int_t *addr, Int_t val)
+GPUd()  inline Int_t AliHLTTPCCAMath::AtomicExch( Int_t *addr, Int_t val)
 {
 #if defined( HLTCA_GPUCODE )
   return ::atomicExch(addr, val );
@@ -185,7 +198,7 @@ GPUd()  inline Int_t AliHLTTPCCAMath::atomicExch( Int_t *addr, Int_t val)
 #endif
 }
 
-GPUd()  inline Int_t AliHLTTPCCAMath::atomicAdd ( Int_t *addr, Int_t val)
+GPUd()  inline Int_t AliHLTTPCCAMath::AtomicAdd ( Int_t *addr, Int_t val)
 {
 #if defined( HLTCA_GPUCODE )
   return ::atomicAdd(addr, val );
@@ -196,7 +209,7 @@ GPUd()  inline Int_t AliHLTTPCCAMath::atomicAdd ( Int_t *addr, Int_t val)
 #endif
 }
 
-GPUd()  inline Int_t AliHLTTPCCAMath::atomicMax ( Int_t *addr, Int_t val)
+GPUd()  inline Int_t AliHLTTPCCAMath::AtomicMax ( Int_t *addr, Int_t val)
 {
 #if defined( HLTCA_GPUCODE )
   return ::atomicMax(addr, val );
@@ -207,7 +220,7 @@ GPUd()  inline Int_t AliHLTTPCCAMath::atomicMax ( Int_t *addr, Int_t val)
 #endif
 }
 
-GPUd()  inline Int_t AliHLTTPCCAMath::atomicMin ( Int_t *addr, Int_t val)
+GPUd()  inline Int_t AliHLTTPCCAMath::AtomicMin ( Int_t *addr, Int_t val)
 {
 #if defined( HLTCA_GPUCODE )
   return ::atomicMin(addr, val );
index 55d18f0..febd747 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id: AliHLTTPCCANeighboursCleaner.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCANeighboursCleaner.h"
 #include "AliHLTTPCCAMath.h"
 #include "AliHLTTPCCATracker.h"
@@ -25,25 +27,25 @@ GPUd() void AliHLTTPCCANeighboursCleaner::Thread
   AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
 {
   // *
-  // * kill link to the neighbour if the neighbour is not pointed to the hit
+  // * kill link to the neighbour if the neighbour is not pointed to the cluster
   // *
 
   if( iSync==0 )
     {
       if( iThread==0 ){
        s.fNRows = tracker.Param().NRows();
-       s.fIRow = iBlock+1;
-       if( s.fIRow <= s.fNRows-2 ){
-         Int_t iRowUp = s.fIRow+1;
-         Int_t iRowDn = s.fIRow-1;       
+       s.fIRow = iBlock+2;
+       if( s.fIRow <= s.fNRows-3 ){
+         s.fIRowUp = s.fIRow+2;
+         s.fIRowDn = s.fIRow-2;          
          s.fFirstHit = tracker.Row(s.fIRow).FirstHit(); 
          const AliHLTTPCCARow &row = tracker.Row(s.fIRow);
-         const AliHLTTPCCARow &rowUp = tracker.Row(iRowUp);
-         const AliHLTTPCCARow &rowDn = tracker.Row(iRowDn);
+         const AliHLTTPCCARow &rowUp = tracker.Row(s.fIRowUp);
+         const AliHLTTPCCARow &rowDn = tracker.Row(s.fIRowDn);
          s.fHitLinkUp = ((Short_t*)(tracker.RowData() + row.FullOffset())) + row.FullLinkOffset();
-         s.fHitLinkDown = s.fHitLinkUp + row.NHits();
+         s.fHitLinkDn = s.fHitLinkUp + row.NHits();
          s.fDnHitLinkUp = ((Short_t*)(tracker.RowData() + rowDn.FullOffset())) + rowDn.FullLinkOffset();
-         s.fUpHitLinkDown = ((Short_t*)(tracker.RowData() + rowUp.FullOffset())) + rowUp.FullLinkOffset() + rowUp.NHits();
+         s.fUpHitLinkDn = ((Short_t*)(tracker.RowData() + rowUp.FullOffset())) + rowUp.FullLinkOffset() + rowUp.NHits();
 
          s.fNHits = tracker.Row(s.fIRow).NHits();
        }
@@ -51,17 +53,18 @@ GPUd() void AliHLTTPCCANeighboursCleaner::Thread
     } 
   else if( iSync==1 )
     {
-      if( s.fIRow <= s.fNRows-2 ){
+      if( s.fIRow <= s.fNRows-3 ){
+
        for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){
          Int_t up = s.fHitLinkUp[ih];
-         Int_t dn = s.fHitLinkDown[ih];
-         if( (up>=0) && ( s.fUpHitLinkDown[up] != ih) ){
-           s.fHitLinkUp[ih]= -1;      
-           //HLTCA_GPU_SUFFIX(CAMath::atomicExch)( tracker.HitLinkUp() + s.fFirstHit+ih, -1 );      
-         }
-         if( (dn>=0) && ( s.fDnHitLinkUp  [dn] != ih) ){
-           s.fHitLinkDown[ih]=-1;
-           //HLTCA_GPU_SUFFIX(CAMath::atomicExch)( tracker.HitLinkDown() + s.fFirstHit+ih,-1);
+         if( up>=0 ){
+           Short_t upDn = s.fUpHitLinkDn[up];
+           if( (upDn!=ih) ) s.fHitLinkUp[ih]= -1;
+         }       
+         Int_t dn = s.fHitLinkDn[ih];
+         if( dn>=0 ){
+           Short_t dnUp = s.fDnHitLinkUp[dn];
+           if( dnUp!=ih ) s.fHitLinkDn[ih]= -1;
          }
        }
       }
index e6f953f..80e30af 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCANEIGHBOURSCLEANER_H
 #define ALIHLTTPCCANEIGHBOURSCLEANER_H
@@ -25,18 +27,20 @@ class AliHLTTPCCANeighboursCleaner
     public:
 #if !defined(HLTCA_GPUCODE)
       AliHLTTPCCASharedMemory()
-       :fIRow(0),fNRows(0),fNHits(0),fHitLinkDown(0),fHitLinkUp(0),fUpHitLinkDown(0),fDnHitLinkUp(0),fFirstHit(0){}
+       :fIRow(0),fIRowUp(0),fIRowDn(0),fNRows(0),fNHits(0),fHitLinkDn(0),fHitLinkUp(0),fUpHitLinkDn(0),fDnHitLinkUp(0),fFirstHit(0){}
       AliHLTTPCCASharedMemory( const AliHLTTPCCASharedMemory& /*dummy*/) 
-       :fIRow(0),fNRows(0),fNHits(0),fHitLinkDown(0),fHitLinkUp(0),fUpHitLinkDown(0),fDnHitLinkUp(0),fFirstHit(0) {}
+       :fIRow(0),fIRowUp(0),fIRowDn(0),fNRows(0),fNHits(0),fHitLinkDn(0),fHitLinkUp(0),fUpHitLinkDn(0),fDnHitLinkUp(0),fFirstHit(0) {}
       AliHLTTPCCASharedMemory& operator=(const AliHLTTPCCASharedMemory& /*dummy*/){ return *this; }
 #endif
     protected:
       Int_t fIRow; // current row index
+      Int_t fIRowUp; // current row index
+      Int_t fIRowDn; // current row index
       Int_t fNRows; // number of rows
       Int_t fNHits; // number of hits
-      Short_t *fHitLinkDown; // links to the previous row
+      Short_t *fHitLinkDn; // links to the previous row
       Short_t *fHitLinkUp; // links to the next row
-      Short_t *fUpHitLinkDown; // links from next row
+      Short_t *fUpHitLinkDn; // links from next row
       Short_t *fDnHitLinkUp; // links from previous row
       Int_t fFirstHit; // index of the first row hit in global arrays 
     };
index 42288fb..0176ad7 100644 (file)
@@ -1,5 +1,5 @@
-// @(#) $Id: AliHLTTPCCANeighboursFinder.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// @(#) $Id: AliHLTTPCCANeighboursFinder1.cxx 27042 2008-07-02 12:06:02Z richterm $
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCANeighboursFinder.h"
 #include "AliHLTTPCCAHitArea.h"
 #include "AliHLTTPCCATracker.h"
 
+//#define DRAW
+
+#ifdef DRAW
+#include "AliHLTTPCCADisplay.h"
+#endif
+
 GPUd() void AliHLTTPCCANeighboursFinder::Thread
 ( Int_t /*nBlocks*/, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
   AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
@@ -40,14 +47,14 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
          s.fHitLinkUp = ((Short_t*)(tracker.RowData() + row.FullOffset())) + row.FullLinkOffset();
          s.fHitLinkDn = s.fHitLinkUp + row.NHits();
 
-         if( (s.fIRow>0) && (s.fIRow<s.fNRows-1) ){
-           s.fIRowUp = s.fIRow+1;
-           s.fIRowDn = s.fIRow-1; 
+         if( (s.fIRow>=2) && (s.fIRow<=s.fNRows-3) ){
+           s.fIRowUp = s.fIRow+2;
+           s.fIRowDn = s.fIRow-2; 
            s.fFirstDn = tracker.Row(s.fIRowDn).FirstHit();
            s.fFirstUp = tracker.Row(s.fIRowUp).FirstHit();
-           Float_t xDn = tracker.Row(s.fIRowDn).X();
-           Float_t x = tracker.Row(s.fIRow).X();
-           Float_t xUp = tracker.Row(s.fIRowUp).X();
+           float xDn = tracker.Row(s.fIRowDn).X();
+           float x = tracker.Row(s.fIRow).X();
+           float xUp = tracker.Row(s.fIRowUp).X();
            s.fUpNHits = tracker.Row(s.fIRowUp).NHits();
            s.fDnNHits = s.fFirst - s.fFirstDn;
            s.fUpDx = xUp - x;
@@ -63,7 +70,7 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
   else if( iSync==1 )
     {
       if( s.fIRow < s.fNRows ){
-       if( (s.fIRow==0) || (s.fIRow==s.fNRows-1) ){
+       if( (s.fIRow==0) || (s.fIRow==s.fNRows-1) || (s.fIRow==1) || (s.fIRow==s.fNRows-2) ){
          for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){
            s.fHitLinkUp[ih] = -1;
            s.fHitLinkDn[ih] = -1;
@@ -85,21 +92,21 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
     }
   else if( iSync==2 )
     {
-      if( (s.fIRow<=0) || (s.fIRow >= s.fNRows-1) ) return;
+      if( (s.fIRow<=1) || (s.fIRow >= s.fNRows-2) ) return;
  
-      const Float_t kAreaSize = 3;     
-      Float_t chi2Cut = 3.*3.*4*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx );
-      //const Float_t kAreaSize = 3;     
-      //Float_t chi2Cut = 3.*3.*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx ); //SG
-     const Int_t kMaxN = 5;
+      //const float kAreaSize = 3;     
+      float chi2Cut = 3.*3.*4*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx );
+      const float kAreaSize = 3;     
+      //float chi2Cut = 3.*3.*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx ); //SG
+      const Int_t kMaxN = 20;
       
       const AliHLTTPCCARow &row = tracker.Row(s.fIRow);
       const AliHLTTPCCARow &rowUp = tracker.Row(s.fIRowUp);
       const AliHLTTPCCARow &rowDn = tracker.Row(s.fIRowDn);
-      Float_t y0 = row.Grid().YMin();
-      Float_t z0 = row.Grid().ZMin();
-      Float_t stepY = row.HstepY();
-      Float_t stepZ = row.HstepZ();
+      float y0 = row.Grid().YMin();
+      float z0 = row.Grid().ZMin();
+      float stepY = row.HstepY();
+      float stepZ = row.HstepZ();
       const uint4* tmpint4 = tracker.RowData() + row.FullOffset();
       const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
 
@@ -109,11 +116,11 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
        float2 *yzUp = s.fA[iThread];
        //UShort_t neighUp[5];
        //float2 yzUp[5];
-       
+
        Int_t linkUp = -1;
        Int_t linkDn = -1;
        
-       if( s.fDnNHits>=1 && s.fUpNHits>=1 ){
+       if( s.fDnNHits>0 && s.fUpNHits>0 ){
          
          Int_t nNeighUp = 0;
          AliHLTTPCCAHit h0;
@@ -124,56 +131,117 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
          }
          //h0 = tracker.Hits()[ s.fFirst + ih ];         
 
-         Float_t y = h0.Y(); 
-         Float_t z = h0.Z(); 
+         float y = h0.Y(); 
+         float z = h0.Z(); 
 
          AliHLTTPCCAHitArea areaDn, areaUp;
          areaUp.Init( s.fGridUp,  s.fGridContentUp,s.fFirstUp, y*s.fUpTx, z*s.fUpTx, kAreaSize, kAreaSize );
-         areaDn.Init( s.fGridDn,  s.fGridContentDn,s.fFirstDn, y*s.fDnTx, z*s.fDnTx, kAreaSize, kAreaSize );      
-         do{
+         areaDn.Init( s.fGridDn,  s.fGridContentDn,s.fFirstDn, y*s.fDnTx, z*s.fDnTx, kAreaSize, kAreaSize );
+        
+         if( linkUp>=0 ){
            AliHLTTPCCAHit h;
-           Int_t i = areaUp.GetNext( tracker, rowUp,s.fGridContentUp, h );
-           if( i<0 ) break;
-           neighUp[nNeighUp] = (UShort_t) i;       
-           yzUp[nNeighUp] = make_float2( s.fDnDx*(h.Y()-y), s.fDnDx*(h.Z()-z) );
-           if( ++nNeighUp>=kMaxN ) break;
-         }while(1);
-
+           float y0Up = rowUp.Grid().YMin();
+           float z0Up = rowUp.Grid().ZMin();
+           float stepYUp  = rowUp.HstepY();
+           float stepZUp  = rowUp.HstepZ();
+           const uint4* tmpint4Up  = tracker.RowData() + rowUp.FullOffset();
+           const ushort2 *hitsUp  = reinterpret_cast<const ushort2*>(tmpint4Up );
+           ushort2 hh = hitsUp[linkUp];
+           h.SetY( y0Up  + hh.x*stepYUp  );
+           h.SetZ( z0Up  + hh.y*stepZUp  );    
+           neighUp[0] = linkUp;    
+           yzUp[0] = CAMath::MakeFloat2( s.fDnDx*(h.Y()-y), s.fDnDx*(h.Z()-z) );           
+           nNeighUp = 1;
+         } else {
+           do{
+             AliHLTTPCCAHit h;
+             Int_t i = areaUp.GetNext( tracker, rowUp,s.fGridContentUp, h );
+             if( i<0 ) break;        
+             neighUp[nNeighUp] = (UShort_t) i;
+             yzUp[nNeighUp] = CAMath::MakeFloat2( s.fDnDx*(h.Y()-y), s.fDnDx*(h.Z()-z) );
+             if( ++nNeighUp>=kMaxN ) break;
+           }while(1);
+         }
+         
          Int_t nNeighDn=0;
+         
          if( nNeighUp>0 ){
 
            Int_t bestDn=-1, bestUp=-1;
-           Float_t bestD=1.e10;
+           float bestD=1.e10;
 
-           do{
+           if( linkDn>=0 ){
              AliHLTTPCCAHit h;
-             Int_t i = areaDn.GetNext( tracker, rowDn,s.fGridContentDn,h );
-             if( i<0 ) break;
-             nNeighDn++;
-             float2 yzdn = make_float2( s.fUpDx*(h.Y()-y), s.fUpDx*(h.Z()-z) );
+             float y0Dn = rowDn.Grid().YMin();
+             float z0Dn  = rowDn.Grid().ZMin();
+             float stepYDn  = rowDn.HstepY();
+             float stepZDn  = rowDn.HstepZ();
+             const uint4* tmpint4Dn  = tracker.RowData() + rowDn.FullOffset();
+             const ushort2 *hitsDn  = reinterpret_cast<const ushort2*>(tmpint4Dn );
+             ushort2 hh = hitsDn [linkDn];
+             h.SetY( y0Dn  + hh.x*stepYDn  );
+             h.SetZ( z0Dn  + hh.y*stepZDn  );
+             
+             nNeighDn = 1;
+             
+             float2 yzdn = CAMath::MakeFloat2( s.fUpDx*(h.Y()-y), s.fUpDx*(h.Z()-z) );
 
              for( Int_t iUp=0; iUp<nNeighUp; iUp++ ){
                float2 yzup = yzUp[iUp];
-               Float_t dy = yzdn.x - yzup.x;
-               Float_t dz = yzdn.y - yzup.y;
-               Float_t d = dy*dy + dz*dz;
+               float dy = yzdn.x - yzup.x;
+               float dz = yzdn.y - yzup.y;
+               float d = dy*dy + dz*dz;
                if( d<bestD ){
                  bestD = d;
-                 bestDn = i;
+                 bestDn = linkDn;
                  bestUp = iUp;
-               }               
+               }
              }
-           }while(1);   
-         
+           } else {
+             do{
+               AliHLTTPCCAHit h;
+               Int_t i = areaDn.GetNext( tracker, rowDn,s.fGridContentDn,h );
+               if( i<0 ) break;
+
+               nNeighDn++;
+               float2 yzdn = CAMath::MakeFloat2( s.fUpDx*(h.Y()-y), s.fUpDx*(h.Z()-z) );
+
+               for( Int_t iUp=0; iUp<nNeighUp; iUp++ ){
+                 float2 yzup = yzUp[iUp];
+                 float dy = yzdn.x - yzup.x;
+                 float dz = yzdn.y - yzup.y;
+                 float d = dy*dy + dz*dz;
+                 if( d<bestD ){
+                   bestD = d;
+                   bestDn = i;
+                   bestUp = iUp;
+                 }             
+               }
+             }while(1);         
+           }
+
            if( bestD <= chi2Cut ){      
              linkUp = neighUp[bestUp];
              linkDn = bestDn;      
            }
          }
+#ifdef DRAW
+         std::cout<<"n NeighUp = "<<nNeighUp<<", n NeighDn = "<<nNeighDn<<std::endl;
+#endif   
+
        }
        
        s.fHitLinkUp[ih] = linkUp;
        s.fHitLinkDn[ih] = linkDn;
+#ifdef DRAW
+       std::cout<<"Links for row "<<s.fIRow<<", hit "<<ih<<": "<<linkUp<<" "<<linkDn<<std::endl;
+       if( s.fIRow==22 && ih==5 )
+         {
+         AliHLTTPCCADisplay::Instance().DrawSliceLink(s.fIRow, ih, -1, -1, 1);  
+         AliHLTTPCCADisplay::Instance().DrawSliceHit(s.fIRow, ih, kBlue, 1.);
+         AliHLTTPCCADisplay::Instance().Ask();
+       }
+#endif
       }
     }
 }
index df2713c..fed7cc0 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCANEIGHBOURSFINDER_H
 #define ALIHLTTPCCANEIGHBOURSFINDER_H
@@ -52,17 +54,17 @@ class AliHLTTPCCANeighboursFinder
       Int_t fNRows; // number of rows
       Short_t *fHitLinkUp; // links to the next row
       Short_t *fHitLinkDn; // links to the previous  row
-      float2 fA[256][5]; // temp memory
-      UShort_t fB[256][5]; // temp memory
-      UShort_t fGridContentUp[700]; // grid content for the next row
-      UShort_t fGridContentDn[700];// grid content for the previous row
+      float2 fA[256][20]; // temp memory
+      UShort_t fB[256][20]; // temp memory
+      UShort_t fGridContentUp[7000]; // grid content for the next row
+      UShort_t fGridContentDn[7000];// grid content for the previous row
     };
   
   GPUd() static Int_t NThreadSyncPoints(){ return 2; }  
 
   GPUd() static void Thread( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
                             AliHLTTPCCASharedMemory &smem, AliHLTTPCCATracker &tracker );
-  
+
 };
 
 
index 9390557..44bd430 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCAOutTrack.h"
 
 
 ClassImp(AliHLTTPCCAOutTrack)
 
-GPUh() void AliHLTTPCCAOutTrack::Dummy()
+GPUh() void AliHLTTPCCAOutTrack::Dummy() const 
 {
   //* do nothing
 }
index e8e5aab..b3a2136 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAOUTTRACK_H
 #define ALIHLTTPCCAOUTTRACK_H
@@ -50,7 +52,7 @@ class AliHLTTPCCAOutTrack
 
  private:
 
-  void Dummy(); // to make rulechecker happy by having something in .cxx file
+  void Dummy() const; // to make rulechecker happy by having something in .cxx file
 
   ClassDef(AliHLTTPCCAOutTrack,1)
 };
index 9800150..a661fbd 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCAParam.h"
 #include "AliHLTTPCCAMath.h"
 
@@ -26,7 +28,7 @@ GPUd() AliHLTTPCCAParam::AliHLTTPCCAParam()
   : fISlice(0),fNRows(63),fAlpha(0.174533), fDAlpha(0.349066),
     fCosAlpha(0), fSinAlpha(0), fAngleMin(0), fAngleMax(0), fRMin(83.65), fRMax(133.3),
     fZMin(0.0529937), fZMax(249.778), fErrX(0), fErrY(0), fErrZ(0.228808),fPadPitch(0.4),fBz(-5.), 
-    fHitPickUpFactor(2.),
+    fHitPickUpFactor(1.),
     fMaxTrackMatchDRow(4), fTrackConnectionFactor(3.5), fTrackChiCut(3.5), fTrackChi2Cut(10)
 {
   // constructor
index d146acb..e5783d5 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAPARAM_H
 #define ALIHLTTPCCAPARAM_H
@@ -32,15 +34,16 @@ class AliHLTTPCCAParam
   ~AliHLTTPCCAParam(){;}
 
   GPUd() void Initialize( Int_t iSlice, Int_t nRows, Float_t rowX[],
-                  Float_t alpha, Float_t dAlpha,
-                  Float_t rMin, Float_t rMax, Float_t zMin, Float_t zMax,
-                  Float_t padPitch, Float_t zSigma, Float_t bz );
+                         Float_t alpha, Float_t dAlpha,
+                         Float_t rMin, Float_t rMax, Float_t zMin, Float_t zMax,
+                         Float_t padPitch, Float_t zSigma, Float_t bz );
   GPUd() void Update();
   
   GPUd() void Slice2Global( Float_t x, Float_t y,  Float_t z, 
-                    Float_t *X, Float_t *Y,  Float_t *Z ) const;
-  GPUd() GPUd() void Global2Slice( Float_t x, Float_t y,  Float_t z, 
-                    Float_t *X, Float_t *Y,  Float_t *Z ) const;
+                           Float_t *X, Float_t *Y,  Float_t *Z ) const;
+
+  GPUd() void Global2Slice( Float_t x, Float_t y,  Float_t z, 
+                           Float_t *X, Float_t *Y,  Float_t *Z ) const;
 
 
   GPUhd() Int_t ISlice() const { return fISlice;}
index fbd1573..f06d70c 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCAPerformance.h"
 #include "AliHLTTPCCAGBHit.h"
 #include "AliHLTTPCCAMCTrack.h"
@@ -24,6 +26,7 @@
 #include "AliHLTTPCCAGBTrack.h"
 #include "AliHLTTPCCAGBTracker.h"
 #include "AliHLTTPCCATracker.h"
+#include "AliHLTTPCCATracklet.h"
 
 
 #include "TMath.h"
@@ -53,6 +56,24 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance()
   fDoClusterPulls(0),         
   fStatNEvents(0),
   fStatTime(0),
+  fStatSeedNRecTot(0),
+  fStatSeedNRecOut(0),
+  fStatSeedNGhost(0),
+  fStatSeedNMCAll(0),
+  fStatSeedNRecAll(0),
+  fStatSeedNClonesAll(0),
+  fStatSeedNMCRef(0), 
+  fStatSeedNRecRef(0), 
+  fStatSeedNClonesRef(0),  
+  fStatCandNRecTot(0),
+  fStatCandNRecOut(0),
+  fStatCandNGhost(0),
+  fStatCandNMCAll(0),
+  fStatCandNRecAll(0),
+  fStatCandNClonesAll(0),
+  fStatCandNMCRef(0), 
+  fStatCandNRecRef(0), 
+  fStatCandNClonesRef(0),  
   fStatNRecTot(0),
   fStatNRecOut(0),
   fStatNGhost(0),
@@ -89,7 +110,8 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance()
   fhHitResY(0),
   fhHitResZ(0),
   fhHitPullY(0),
-  fhHitPullZ(0),  
+  fhHitPullZ(0), 
+  fhHitShared(0),
   fhHitResY1(0),
   fhHitResZ1(0),
   fhHitPullY1(0),
@@ -99,6 +121,8 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance()
   fhCellPurityVsN(0), 
   fhCellPurityVsPt(0),
   fhEffVsP(0), 
+  fhSeedEffVsP(0),
+  fhCandEffVsP(0),
   fhGBEffVsP(0),
   fhGBEffVsPt(0),
   fhNeighQuality(0),
@@ -148,6 +172,24 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&)
   fDoClusterPulls(0),         
   fStatNEvents(0),
   fStatTime(0),
+  fStatSeedNRecTot(0),
+  fStatSeedNRecOut(0),
+  fStatSeedNGhost(0),
+  fStatSeedNMCAll(0),
+  fStatSeedNRecAll(0),
+  fStatSeedNClonesAll(0),
+  fStatSeedNMCRef(0), 
+  fStatSeedNRecRef(0), 
+  fStatSeedNClonesRef(0),  
+  fStatCandNRecTot(0),
+  fStatCandNRecOut(0),
+  fStatCandNGhost(0),
+  fStatCandNMCAll(0),
+  fStatCandNRecAll(0),
+  fStatCandNClonesAll(0),
+  fStatCandNMCRef(0), 
+  fStatCandNRecRef(0), 
+  fStatCandNClonesRef(0),  
   fStatNRecTot(0),
   fStatNRecOut(0),
   fStatNGhost(0),
@@ -185,6 +227,7 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&)
   fhHitResZ(0),
   fhHitPullY(0),
   fhHitPullZ(0),  
+  fhHitShared(0),
   fhHitResY1(0),
   fhHitResZ1(0),
   fhHitPullY1(0),
@@ -194,6 +237,8 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&)
   fhCellPurityVsN(0), 
   fhCellPurityVsPt(0),
   fhEffVsP(0), 
+  fhSeedEffVsP(0),
+  fhCandEffVsP(0),
   fhGBEffVsP(0),
   fhGBEffVsPt(0),
   fhNeighQuality(0),
@@ -230,7 +275,7 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&)
   //* dummy
 }
 
-AliHLTTPCCAPerformance &AliHLTTPCCAPerformance::operator=(const AliHLTTPCCAPerformance&)
+const AliHLTTPCCAPerformance &AliHLTTPCCAPerformance::operator=(const AliHLTTPCCAPerformance&) const
 {
   //* dummy
   return *this;
@@ -242,7 +287,7 @@ AliHLTTPCCAPerformance::~AliHLTTPCCAPerformance()
   StartEvent();
 }
 
-void AliHLTTPCCAPerformance::SetTracker( AliHLTTPCCAGBTracker *Tracker )
+void AliHLTTPCCAPerformance::SetTracker( AliHLTTPCCAGBTracker * const Tracker )
 {
   //* set pointer to HLT CA Global tracker
   fTracker = Tracker;
@@ -339,6 +384,32 @@ void AliHLTTPCCAPerformance::CreateHistos()
   fHistoDir = gROOT->mkdir("HLTTPCCATrackerPerformance");
   fHistoDir->cd();
 
+  gDirectory->mkdir("Links");
+  gDirectory->cd("Links");  
+
+  fhLinkEff[0] = new TProfile("fhLinkEffPrimRef", "fhLinkEffPrimRef vs row", 156, 2., 158.);
+  fhLinkEff[1] = new TProfile("fhLinkEffPrimExt", "fhLinkEffPrimExt vs row", 156, 2., 158.);
+  fhLinkEff[2] = new TProfile("fhLinkEffSecRef", "fhLinkEffSecRef vs row", 156, 2., 158.);
+  fhLinkEff[3] = new TProfile("fhLinkEffSecExt", "fhLinkEffSecExt vs row", 156, 2., 158.);
+  fhLinkAreaY[0] = new TH1D("fhLinkAreaYPrimRef","fhLinkAreaYPrimRef",100,0,10);
+  fhLinkAreaZ[0] = new TH1D("fhLinkAreaZPrimRef","fhLinkAreaZPrimRef",100,0,10);
+  fhLinkAreaY[1] = new TH1D("fhLinkAreaYPrimExt","fhLinkAreaYPrimExt",100,0,10);
+  fhLinkAreaZ[1] = new TH1D("fhLinkAreaZPrimExt","fhLinkAreaZPrimExt",100,0,10);
+  fhLinkAreaY[2] = new TH1D("fhLinkAreaYSecRef","fhLinkAreaYSecRef",100,0,10);
+  fhLinkAreaZ[2] = new TH1D("fhLinkAreaZSecRef","fhLinkAreaZSecRef",100,0,10);
+  fhLinkAreaY[3] = new TH1D("fhLinkAreaYSecExt","fhLinkAreaYSecExt",100,0,10);
+  fhLinkAreaZ[3] = new TH1D("fhLinkAreaZSecExt","fhLinkAreaZSecExt",100,0,10);
+  fhLinkChiRight[0] = new TH1D("fhLinkChiRightPrimRef","fhLinkChiRightPrimRef",100,0,10);
+  fhLinkChiRight[1] = new TH1D("fhLinkChiRightPrimExt","fhLinkChiRightPrimExt",100,0,10);
+  fhLinkChiRight[2] = new TH1D("fhLinkChiRightSecRef","fhLinkChiRightSecRef",100,0,10);
+  fhLinkChiRight[3] = new TH1D("fhLinkChiRightSecExt","fhLinkChiRightSecExt",100,0,10);
+  fhLinkChiWrong[0] = new TH1D("fhLinkChiWrongPrimRef","fhLinkChiWrongPrimRef",100,0,10);
+  fhLinkChiWrong[1] = new TH1D("fhLinkChiWrongPrimExt","fhLinkChiWrongPrimExt",100,0,10);
+  fhLinkChiWrong[2] = new TH1D("fhLinkChiWrongSecRef","fhLinkChiWrongSecRef",100,0,10);
+  fhLinkChiWrong[3] = new TH1D("fhLinkChiWrongSecExt","fhLinkChiWrongSecExt",100,0,10);
+
+  gDirectory->cd(".."); 
+
   gDirectory->mkdir("Neighbours");
   gDirectory->cd("Neighbours");  
   
@@ -361,7 +432,16 @@ void AliHLTTPCCAPerformance::CreateHistos()
   gDirectory->cd("Tracklets");
 
   fhNHitsPerSeed = new TH1D("NHitsPerSeed","NHitsPerSeed", 160,0,160);
+  fhSeedEffVsP = new TProfile("fhSeedEffVsP", "Track Seed Eff vs P", 100, 0., 5.);
+
+  gDirectory->cd(".."); 
+
+  gDirectory->mkdir("TrackCandidates");
+  gDirectory->cd("TrackCandidates");
+
   fhNHitsPerTrackCand = new TH1D("NHitsPerTrackCand","NHitsPerTrackCand", 160,0,160);
+  fhCandEffVsP = new TProfile("fhCandEffVsP", "Track Candidate Eff vs P", 100, 0., 5.);
+
   gDirectory->cd(".."); 
   
   gDirectory->mkdir("Tracks");
@@ -417,6 +497,9 @@ void AliHLTTPCCAPerformance::CreateHistos()
 
   gDirectory->mkdir("Clusters");
   gDirectory->cd("Clusters");  
+
+  fhHitShared = new TProfile("fhHitSharedf", "fhHitShared vs row", 160, 0., 160.);
+
   fhHitResY = new TH1D("resHitY", "Y cluster resoltion [cm]", 100, -2., 2.);
   fhHitResZ = new TH1D("resHitZ", "Z cluster resoltion [cm]", 100, -2., 2.);
   fhHitPullY = new TH1D("pullHitY", "Y cluster pull", 50, -10., 10.);
@@ -471,7 +554,181 @@ void AliHLTTPCCAPerformance::WriteHistos()
 }
 
 
-void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
+void AliHLTTPCCAPerformance::LinkPerformance( Int_t iSlice )
+{ 
+  // Efficiency and quality of the found neighbours
+  std::cout<<"Link performance..."<<std::endl;
+  if( !fTracker ) return;  
+  AliHLTTPCCATracker &slice = fTracker->Slices()[iSlice];
+
+  const Int_t *id = slice.HitInputIDs();
+
+  Int_t mcType[fNMCTracks];
+
+  for (Int_t imc=0; imc<fNMCTracks; imc++){   
+    if( fMCTracks[imc].P()<.2 ){  mcType[imc] = -1; continue; }
+    Float_t x = fMCTracks[imc].Par()[0];
+    Float_t y = fMCTracks[imc].Par()[1];
+    //Float_t z = fMCTracks[imc].Par()[2];
+    if( x*x + y*y < 100. ){
+      if( fMCTracks[imc].P()>=1 ) mcType[imc] = 0;
+      else mcType[imc] = 1;
+    } else {
+      if( fMCTracks[imc].P()>=1 ) mcType[imc] = 2;
+      else mcType[imc] = 3;
+    }
+  }
+
+  struct AliHLTTPCCAMCHits{
+    Int_t fNHits;
+    Int_t fID[30];
+  }; 
+  AliHLTTPCCAMCHits *mcGbHitsUp = new AliHLTTPCCAMCHits[fNMCTracks];
+  AliHLTTPCCAMCHits *mcGbHitsDn = new AliHLTTPCCAMCHits[fNMCTracks];
+
+  for( Int_t iRow=2; iRow<slice.Param().NRows()-2; iRow++ ){
+    
+    const AliHLTTPCCARow &row = slice.Row(iRow);
+    const AliHLTTPCCARow &rowUp = slice.Row(iRow+2);
+    const AliHLTTPCCARow &rowDn = slice.Row(iRow-2);    
+    
+    Int_t gbHits  [row.NHits()];
+    Int_t gbHitsUp[rowUp.NHits()];
+    Int_t gbHitsDn[rowDn.NHits()];
+
+    for (Int_t ih = 0; ih<row.NHits()  ; ih++) gbHits  [ih] = fTracker->FirstSliceHit()[iSlice]+id[row  .FirstHit()+ih];    
+    for (Int_t ih = 0; ih<rowUp.NHits(); ih++) gbHitsUp[ih] = fTracker->FirstSliceHit()[iSlice]+id[rowUp.FirstHit()+ih];
+    for (Int_t ih = 0; ih<rowDn.NHits(); ih++) gbHitsDn[ih] = fTracker->FirstSliceHit()[iSlice]+id[rowDn.FirstHit()+ih];
+
+    for (Int_t imc=0; imc<fNMCTracks; imc++){ 
+      mcGbHitsUp[imc].fNHits = 0;
+      mcGbHitsDn[imc].fNHits = 0;
+    }
+  
+    for (Int_t ih = 0; ih<rowUp.NHits(); ih++){      
+      AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[gbHitsUp[ih]].ID()];
+      for( Int_t il=0; il<3; il++ ){
+       Int_t imc = l.fLab[il];
+       if( imc <0 ) break;
+       Int_t &nmc = mcGbHitsUp[imc].fNHits;
+       if( nmc>=30 ) continue;
+       mcGbHitsUp[imc].fID[nmc] = gbHitsUp[ih];
+       nmc++;
+      }
+    }
+
+    for (Int_t ih = 0; ih<rowDn.NHits(); ih++){
+      AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[gbHitsDn[ih]].ID()];    
+      for( Int_t il=0; il<3; il++ ){
+       Int_t imc = l.fLab[il];
+       if( imc <0 ) break;
+       Int_t &nmc = mcGbHitsDn[imc].fNHits;
+       if( nmc>=30 ) continue;
+       mcGbHitsDn[imc].fID[nmc] = gbHitsDn[ih];
+       nmc++;
+      }
+    }
+
+    Short_t *linkUp = ((Short_t*)(slice.RowData() + row.FullOffset())) + row.FullLinkOffset();
+    Short_t *linkDn = linkUp + row.NHits();
+
+    //Float_t dxUp = rowUp.X() - row.X();
+    //Float_t dxDn = row.X() - rowDn.X();
+    Float_t tUp = rowUp.X()/row.X();
+    Float_t tDn = rowDn.X()/row.X();
+
+    for( Int_t ih=0; ih<row.NHits(); ih++ ){      
+      
+      Int_t up = linkUp[ih];
+      Int_t dn = linkDn[ih];
+      
+      AliHLTTPCCAGBHit &h = fTracker->Hits()[gbHits[ih]];
+      AliHLTTPCCAHitLabel &l = fHitLabels[h.ID()];    
+
+      Int_t isMC = -1;
+      Int_t mcFound=-1;
+
+      Float_t yUp = h.Y()*tUp, zUp = h.Z()*tUp;
+      Float_t yDn = h.Y()*tDn, zDn = h.Z()*tDn;
+
+      for( Int_t il=0; il<3; il++ ){
+       Int_t imc = l.fLab[il];
+       if( imc<0 ) break;
+
+       Bool_t isMcUp=0, isMcDn=0;
+
+       Float_t dyMin=1.e8, dzMin=1.e8;
+       for( Int_t i=0; i<mcGbHitsUp[imc].fNHits; i++ ){
+         AliHLTTPCCAGBHit &h1 = fTracker->Hits()[mcGbHitsUp[imc].fID[i]];
+         Float_t dy = TMath::Abs(h1.Y()-yUp);
+         Float_t dz = TMath::Abs(h1.Z()-zUp);
+         if( dy*dy+dz*dz < dyMin*dyMin + dzMin*dzMin ){
+           dyMin = dy;
+           dzMin = dz;     
+         }
+       }
+
+       if( mcType[imc]>=0 && mcGbHitsUp[imc].fNHits>=0 ){
+         fhLinkAreaY[mcType[imc]]->Fill(dyMin);
+         fhLinkAreaZ[mcType[imc]]->Fill(dzMin);
+       }
+       if( dyMin*dyMin+dzMin*dzMin<100. ) isMcUp = 1;
+       dyMin=1.e8; 
+       dzMin=1.e8;
+       for( Int_t i=0; i<mcGbHitsDn[imc].fNHits; i++ ){
+         AliHLTTPCCAGBHit &h1 = fTracker->Hits()[mcGbHitsDn[imc].fID[i]];
+         Float_t dy = TMath::Abs(h1.Y()-yDn);
+         Float_t dz = TMath::Abs(h1.Z()-zDn);
+         if( dy*dy+dz*dz < dyMin*dyMin + dzMin*dzMin ){
+           dyMin = dy;
+           dzMin = dz;     
+         }
+       }
+
+       if( mcType[imc]>=0 && mcGbHitsDn[imc].fNHits>=0 ){
+         fhLinkAreaY[mcType[imc]]->Fill(dyMin);
+         fhLinkAreaZ[mcType[imc]]->Fill(dzMin);
+       }
+       if( dyMin*dyMin+dzMin*dzMin<100. ) isMcDn = 1;
+       if( !isMcUp || !isMcDn ) continue;
+       isMC = imc;
+
+       Bool_t found=0;
+       if( up>=0 && dn>=0 ){
+         //std::cout<<"row, ih, mc, up, dn = "<<iRow<<" "<<ih<<" "<<imc<<" "<<up<<" "<<dn<<std::endl;
+         AliHLTTPCCAGBHit &hUp = fTracker->Hits()[gbHitsUp[up]];
+         AliHLTTPCCAGBHit &hDn = fTracker->Hits()[gbHitsDn[dn]];
+         AliHLTTPCCAHitLabel &lUp = fHitLabels[hUp.ID()];
+         AliHLTTPCCAHitLabel &lDn = fHitLabels[hDn.ID()];
+         Bool_t foundUp=0, foundDn=0;
+         for( Int_t jl=0; jl<3; jl++ ){
+           if( lUp.fLab[jl] == imc ) foundUp=1;
+           if( lDn.fLab[jl] == imc ) foundDn=1;
+           //std::cout<<"mc up, dn = "<<lUp.fLab[jl]<<" "<<lDn.fLab[jl]<<std::endl;
+         }
+         if( foundUp && foundDn ) found = 1;
+       }
+       if( found ){ mcFound = imc; break;}     
+      }
+  
+      if( mcFound>=0 ){
+       //std::cout<<" mc "<<mcFound<<" found"<<std::endl;
+       if( mcType[mcFound]>=0 ) fhLinkEff[mcType[mcFound]]->Fill(iRow, 1 );    
+      }else if( isMC>=0 ){
+       //std::cout<<" mc "<<isMC<<" not found"<<std::endl;
+       if( mcType[isMC]>=0 ) fhLinkEff[mcType[isMC]]->Fill(iRow, 0 );                  
+      }
+
+    } // ih    
+  } // iRow
+  delete[] mcGbHitsUp;
+  delete[] mcGbHitsDn;
+}
+
+
+void AliHLTTPCCAPerformance::SliceTrackletPerformance( Int_t iSlice, Bool_t PrintFlag )
 { 
   //* calculate slice tracker performance
   if( !fTracker ) return;
@@ -481,312 +738,446 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
   Int_t nMCRef = 0, nRecRef=0, nClonesRef=0;
   AliHLTTPCCATracker &slice = fTracker->Slices()[iSlice];
 
-  Int_t firstSliceHit = 0;
-  for( ; firstSliceHit<fTracker->NHits(); firstSliceHit++){
-    if( fTracker->Hits()[firstSliceHit].ISlice()==iSlice ) break;
-  }
-  Int_t endSliceHit = firstSliceHit;  
+  Int_t firstSliceHit = fTracker->FirstSliceHit()[iSlice];
+  Int_t endSliceHit = fTracker->NHits();
+  if( iSlice<fTracker->NSlices()-1 ) endSliceHit = fTracker->FirstSliceHit()[iSlice+1];    
 
-  for( ; endSliceHit<fTracker->NHits(); endSliceHit++){
-    if( fTracker->Hits()[endSliceHit].ISlice()!=iSlice ) break;
-  }
-  
-  { // Efficiency and quality of found neighbours
-#ifdef XXX
-    for( Int_t iRow=1; iRow<slice.Param().NRows()-1; iRow++ ){      
-      AliHLTTPCCARow &row = slice.Rows()[iRow];
-      AliHLTTPCCARow &rowP = slice.Rows()[iRow-1];
-      AliHLTTPCCARow &rowN = slice.Rows()[iRow+1];      
-
-      Int_t nHitsRow[fNMCTracks][3];
-      Bool_t foundRow[fNMCTracks];
-      Bool_t isPrim[fNMCTracks];
-      for (Int_t imc=0; imc<fNMCTracks; imc++){ 
-       for( Int_t i=0; i<3; i++ )nHitsRow[imc][i]=0;
-       foundRow[imc]=0;
-       Float_t y = fMCTracks[imc].Par()[1];
-       Float_t z = fMCTracks[imc].Par()[2];
-       isPrim[imc] = (y*y + z*z < 100. );
-      }
+  // Select reconstructable MC tracks
+
+  {
+    for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].SetNHits( 0 );
     
-      for( Int_t i=0; i<3; i++ ){
-       AliHLTTPCCARow &r = slice.Rows()[iRow-1+i];      
-       for (Int_t ih = 0; ih<r.NHits(); ih++){
-         AliHLTTPCCAHit &h = r.Hits()[ih];
-         AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[h.ID()].ID()];
-         if( l.fLab[0] <0 || l.fLab[1]>=0 ) continue;
-         nHitsRow[l.fLab[0]][i]++;
+    for( Int_t ih=firstSliceHit; ih<endSliceHit; ih++){
+      Int_t id = fTracker->Hits()[ih].ID();
+      if( id<0 || id>=fNHits ) break;
+      AliHLTTPCCAHitLabel &l = fHitLabels[id];
+      if( l.fLab[0]>=0 ) fMCTracks[l.fLab[0]].SetNHits(fMCTracks[l.fLab[0]].NHits()+1);
+      if( l.fLab[1]>=0 ) fMCTracks[l.fLab[1]].SetNHits(fMCTracks[l.fLab[1]].NHits()+1);
+      if( l.fLab[2]>=0 ) fMCTracks[l.fLab[2]].SetNHits(fMCTracks[l.fLab[2]].NHits()+1);
+    }
+    
+    for (Int_t imc=0; imc<fNMCTracks; imc++) {         
+      AliHLTTPCCAMCTrack &mc = fMCTracks[imc];
+      mc.SetSet( 0 );
+      mc.SetNReconstructed( 0 );
+      mc.SetNTurns( 1 );
+      if( mc.NHits() >=  30 && mc.P()>=.05 ){
+       mc.SetSet( 1 );
+       nMCAll++;
+       if( mc.NHits() >=  30 && mc.P()>=1. ){
+         mc.SetSet( 2 );
+         nMCRef++;
        }
       }
+    }
+  }
 
-      for( Int_t it=0; it<row.NTriplets(); it++ ){
-       AliHLTTPCCATriplet &t = row.Triplets()[it];
-       if( !t.Alive() ) continue;
-       AliHLTTPCCAHit &h = row.Hits()[t.HitMid()];
-       AliHLTTPCCAHit &hP = rowP.Hits()[t.HitDown()];
-       AliHLTTPCCAHit &hN = rowN.Hits()[t.HitUp()];
-       AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[h.ID()].ID()];
-       AliHLTTPCCAHitLabel &lP = fHitLabels[fTracker->Hits()[hP.ID()].ID()];
-       AliHLTTPCCAHitLabel &lN = fHitLabels[fTracker->Hits()[hN.ID()].ID()];   
-       Bool_t found = ( l.fLab[0]>=0 && lP.fLab[0]==l.fLab[0] && lN.fLab[0]==l.fLab[0] );
-       if( found ) foundRow[l.fLab[0]] = 1;
-       Bool_t isGhost = 1;
-       for( Int_t il=0; il<3; il++ ){
-         if( l.fLab[il]<0 ) continue;
-         Bool_t okP=0, okN=0;
-         for( Int_t jl=0; jl<3; jl++ ){
-           if( lP.fLab[jl]==l.fLab[il] ) okP = 1;
-           if( lN.fLab[jl]==l.fLab[il] ) okN = 1;
+
+  Int_t traN = *slice.NTracklets();
+  Int_t *traLabels = 0; 
+  Double_t *traPurity = 0;
+
+  traLabels = new Int_t[traN];
+  traPurity = new Double_t[traN];
+  {
+    for (Int_t itr=0; itr<traN; itr++) {
+      traLabels[itr]=-1;
+      traPurity[itr]= 0;
+      
+      Int_t hits[1600];
+      Int_t nHits=0;
+
+      {      
+       Int_t id = slice.TrackletStartHits()[itr];
+       Int_t iRow = AliHLTTPCCATracker::ID2IRow(id);
+       Int_t ih =  AliHLTTPCCATracker::ID2IHit(id);
+      
+       while( ih>=0 ){
+         const AliHLTTPCCARow &row = slice.Row(iRow);
+         hits[nHits] = firstSliceHit + slice.HitInputIDs()[row.FirstHit()+ih];
+         nHits++;      
+         Short_t *linkUp = ((Short_t*)(slice.RowData() + row.FullOffset())) + row.FullLinkOffset();
+         ih = linkUp[ih];
+         iRow++;
+       }
+      }
+
+      if( nHits<5 ) continue;
+       
+      Int_t lb[1600*3];
+      Int_t nla=0;
+
+      for( Int_t ih=0; ih<nHits; ih++ ){
+       AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[hits[ih]].ID()];   
+       if(l.fLab[0]>=0 ) lb[nla++]= l.fLab[0];
+       if(l.fLab[1]>=0 ) lb[nla++]= l.fLab[1];
+       if(l.fLab[2]>=0 ) lb[nla++]= l.fLab[2];
+      }
+      
+      sort( lb, lb+nla );
+      Int_t labmax = -1, labcur=-1, lmax = 0, lcurr=0;
+      for( Int_t i=0; i<nla; i++ ){
+       if( lb[i]!=labcur ){
+         if( labcur>=0 && lmax<lcurr ){
+           lmax = lcurr;
+           labmax = labcur;
          }
-         if( okP && okN ) isGhost = 0; 
+         labcur = lb[i];
+         lcurr = 0;
        }
-       fhNeighQuality->Fill(iRow, !isGhost );
-       if( l.fLab[0]>=0 ) fhNeighQualityVsPt->Fill(fMCTracks[l.fLab[0]].Pt(), !isGhost );
+       lcurr++;
       }
-    
-      for (Int_t imc=0; imc<fNMCTracks; imc++){ 
-       if( nHitsRow[imc][0]<=0 || nHitsRow[imc][1]<=0 ||nHitsRow[imc][2]<=0 ) continue;
-       if( !isPrim[imc] ) continue;
-       if( fMCTracks[imc].Pt()>0.2 ) fhNeighEff->Fill(iRow, foundRow[imc] );   
-       fhNeighEffVsPt->Fill( fMCTracks[imc].Pt(), foundRow[imc] );     
+      if( labcur>=0 && lmax<lcurr ){
+       lmax = lcurr;
+       labmax = labcur;
       }
+      lmax = 0;
+      for( Int_t ih=0; ih<nHits; ih++ ){
+       AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[hits[ih]].ID()];   
+       if( l.fLab[0] == labmax || l.fLab[1] == labmax || l.fLab[2] == labmax 
+           ) lmax++;
+      }
+      traLabels[itr] = labmax;
+      traPurity[itr] = ( (nHits>0) ?double(lmax)/double(nHits) :0 );
     }
-#endif    
-  } // efficiency and quality of found neighbours
-
-
-
-
-  if(0){ // Local efficiency of found neighbours
-#ifdef XXX    
-    for( Int_t iRow=1; iRow<slice.Param().NRows()-1; iRow++ ){
-      //cout<<"iRow="<<iRow<<endl;
-      AliHLTTPCCARow &row = slice.Rows()[iRow];      
-      AliHLTTPCCARow &rowP = slice.Rows()[iRow-1];      
-      AliHLTTPCCARow &rowN = slice.Rows()[iRow+1];      
-      Float_t xP = rowP.X() - row.X();
-      Float_t xN = rowN.X() - row.X();
-      Float_t tN = rowN.X()/row.X();
-      Float_t tP = rowP.X()/row.X();
-      Float_t chi2Cut = 2*3.*3.*(xN*xN+xP*xP);
-      for (Int_t ih = 0; ih<row.NHits(); ih++){
-       AliHLTTPCCAHit &h = row.Hits()[ih];
-       AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[h.ID()].ID()];
-       if( l.fLab[0] <0 || l.fLab[1]>=0 ) continue;
-       Float_t yyP = h.Y()*tP;
-       Float_t zzP = h.Z()*tP;
-       Float_t yyN = h.Y()*tN;
-       Float_t zzN = h.Z()*tN;
-       Float_t mcPt = fMCTracks[l.fLab[0]].Pt();
-       if(0){
-         Int_t jhP=-1;
-         Float_t bestDP = 1.e10;
-         for (Int_t ihP = 0; ihP<rowP.NHits(); ihP++){
-           AliHLTTPCCAHit &hP = rowP.Hits()[ihP];
-           AliHLTTPCCAHitLabel &lP = fHitLabels[fTracker->Hits()[hP.ID()].ID()];
-           Bool_t ok = 0;
-           for( Int_t il=0; il<3; il++ ){
-             if( lP.fLab[il]==l.fLab[0] ) ok = 1;
-           }
-           if( !ok ) continue;
-           Float_t dy = hP.Y()-yyP;
-           Float_t dz = hP.Z()-zzP;
-           Float_t d = dy*dy + dz*dz;
-           if( d<bestDP ){
-             bestDP = d;
-             jhP = ihP;
-           }
-         }
+  }
 
-         Int_t jhN=-1;
-         Float_t bestDN = 1.e10;
-         for (Int_t ihN = 0; ihN<rowN.NHits(); ihN++){
-           AliHLTTPCCAHit &hN = rowN.Hits()[ihN];
-           AliHLTTPCCAHitLabel &lN = fHitLabels[fTracker->Hits()[hN.ID()].ID()];
-           Bool_t ok = 0;
-           for( Int_t il=0; il<3; il++ ){
-             if( lN.fLab[il]==l.fLab[0] ) ok = 1;
-           }
-           if( !ok ) continue;
-           Float_t dy = hN.Y()-yyN;
-           Float_t dz = hN.Z()-zzN;
-           Float_t d = dy*dy + dz*dz;
-           if( d<bestDN ){
-             bestDN = d;
-             jhN = ihN;
-           }
-         }
-         if( jhP>=0 && jhN>=0 ){
-           AliHLTTPCCAHit &hP = rowP.Hits()[jhP];
-           AliHLTTPCCAHit &hN = rowN.Hits()[jhN];
-           fhNeighDyVsPt->Fill(mcPt, hP.Y()-yyP);
-           fhNeighDyVsPt->Fill(mcPt, hN.Y()-yyN);
-           fhNeighDzVsPt->Fill(mcPt, hP.Z()-zzP);
-           fhNeighDzVsPt->Fill(mcPt, hN.Z()-zzN);
-           Float_t dy = xP*(hN.Y()-h.Y()) - xN*(hP.Y()-h.Y());
-           Float_t dz = xP*(hN.Z()-h.Z()) - xN*(hP.Z()-h.Z());
-           Float_t chi2 = (dy*dy + dz*dz)/(xN*xN+xP*xP);
-           fhNeighChiVsPt->Fill(mcPt, TMath::Sqrt(chi2/2));        
-         }
-         {
-           Float_t darea = .2;
-           Int_t nAreas = 15;
-           Int_t nComb[nAreas];
-           for( Int_t i=0; i<nAreas; i++ ) nComb[i]=0;
-           for (Int_t ihP = 0; ihP<rowP.NHits(); ihP++){
-             AliHLTTPCCAHit &hP = rowP.Hits()[ihP];
-             Float_t yyy = -xP*h.Y() - xN*(hP.Y()-h.Y());
-             Float_t zzz = -xP*h.Z() - xN*(hP.Z()-h.Z());
-             for (Int_t ihN = 0; ihN<rowN.NHits(); ihN++){
-               AliHLTTPCCAHit &hN = rowN.Hits()[ihN];
-               Float_t dy = xP*hN.Y()+yyy;
-               Float_t dz = xP*hN.Z()+zzz;
-               Float_t chi2 = (dy*dy + dz*dz);
-               if( chi2 >chi2Cut ) continue;
-               Float_t D = TMath::Abs( hP.Y()-yyP );
-               Float_t d = TMath::Abs( hP.Z()-zzP );
-               if( d>D ) D = d;
-               d = TMath::Abs( hN.Y()-yyN );
-               if( d>D ) D = d;
-               d = TMath::Abs( hN.Z()-zzN );
-               if( d>D ) D = d;                
-               Int_t ic = (int) (D/darea);
-               if( ic<nAreas ) nComb[ic]++;
-             }
-           }
-           Int_t j=0;
-           for( Int_t i=0; i<nAreas; i++ ){
-             j+=nComb[i];
-             if(j>0 ) fhNeighNCombVsArea->Fill(i*darea,j);
-           }     
-         }
-       }
+  nRecTot+= traN;
+  
+  for(Int_t itr=0; itr<traN; itr++){      
+    if( traPurity[itr]<.9 || traLabels[itr]<0 || traLabels[itr]>=fNMCTracks){
+      nGhost++;
+      continue;
+    }
+    
+    AliHLTTPCCAMCTrack &mc = fMCTracks[traLabels[itr]];        
+    mc.SetNReconstructed( mc.NReconstructed()+1 );
+    if( mc.Set()== 0 ) nRecOut++;
+    else{
+      if( mc.NReconstructed()==1 ) nRecAll++;
+      else if(mc.NReconstructed() > mc.NTurns() ) nClonesAll++;
+      if( mc.Set()==2 ){
+       if( mc.NReconstructed()==1 ) nRecRef++;
+       else if(mc.NReconstructed() > mc.NTurns() ) nClonesRef++;
+      }
+    }      
+  }
 
-       Float_t area = 5;
-       const Int_t maxN = 1000;
-       Int_t neighP[maxN];
-       Int_t neighN[maxN];
-       Float_t zP[maxN];
-       Float_t yP[maxN];
-       Float_t zN[maxN];
-       Float_t yN[maxN];
-       Int_t nNeighP = 0;
-       Int_t nNeighN = 0;     
-       
-       for (Int_t ihP = 0; ihP<rowP.NHits(); ihP++){
-         AliHLTTPCCAHit &hP = rowP.Hits()[ihP];
-         if( TMath::Abs(hP.Y()-yyP)>area || TMath::Abs(hP.Z()-zzP)>area ) continue;
-         AliHLTTPCCAHitLabel &lP = fHitLabels[fTracker->Hits()[hP.ID()].ID()];
-         Bool_t ok = 0;
-         for( Int_t il=0; il<3; il++ ){
-           if( lP.fLab[il]==l.fLab[0] ) ok = 1;
-         }
-         if( !ok ) continue;
-         neighP[nNeighP] = ihP;
-         zP[nNeighP] = xN*(hP.Z()-h.Z());
-         yP[nNeighP] = xN*(hP.Y()-h.Y());
-         nNeighP++;
-         if( nNeighP>=maxN ) break;
-       }
-       for (Int_t ihN = 0; ihN<rowN.NHits(); ihN++){
-         AliHLTTPCCAHit &hN = rowN.Hits()[ihN];
-         if( TMath::Abs(hN.Y()-yyN)>area || TMath::Abs(hN.Z()-zzN)>area ) continue;
-         AliHLTTPCCAHitLabel &lN = fHitLabels[fTracker->Hits()[hN.ID()].ID()];
-         Bool_t ok = 0;
-         for( Int_t il=0; il<3; il++ ){
-           if( lN.fLab[il]==l.fLab[0] ) ok = 1;
-         }
-         if( !ok ) continue;
-         neighN[nNeighN] = ihN;
-         zN[nNeighN] = xP*(hN.Z()-h.Z());
-         yN[nNeighN] = xP*(hN.Y()-h.Y());
-         nNeighN++;
-         if( nNeighN>=maxN ) break;
-       }
+  for (Int_t ipart=0; ipart<fNMCTracks; ipart++) {             
+    AliHLTTPCCAMCTrack &mc = fMCTracks[ipart];
+    if( mc.Set()>0 ) fhSeedEffVsP->Fill(mc.P(), ( mc.NReconstructed()>0 ?1 :0));
+  }  
 
-       if( nNeighN<=0 || nNeighP<=0 ) continue;
+  if( traLabels ) delete[] traLabels;
+  if( traPurity ) delete[] traPurity;
 
-       {
-         // neighbours found, look for the straight line connection
-         Int_t bestP=-1, bestN=-1;
-         Float_t bestD=1.e10;
-         for( Int_t iP=0; iP<nNeighP; iP++ ){
-           for( Int_t iN=0; iN<nNeighN; iN++ ){
-             Float_t dy = yP[iP]-yN[iN];
-             Float_t dz = zP[iP]-zN[iN];
-             Float_t d = dy*dy + dz*dz;
-             if( d<bestD){
-               bestD = d;
-               bestP = iP;
-               bestN = iN;
-             }
-           }   
-         }
-         if( bestP>=0 ){
-           AliHLTTPCCAHit &hP = rowP.Hits()[neighP[bestP]];
-           AliHLTTPCCAHit &hN = rowN.Hits()[neighN[bestN]];
-           Float_t yP = hP.Y() - h.Y();
-           Float_t zP = hP.Z() - h.Z();
-           Float_t yN = hN.Y() - h.Y();
-           Float_t zN = hN.Z() - h.Z();
-           Float_t dy = yP+yN;//(xN*yP - xP*yN)/TMath::Sqrt(xN*xN+xP*xP);
-           Float_t dz = zP+zN;//(xN*zP - xP*zN)/TMath::Sqrt(xN*xN+xP*xP);
-           //if( fMCTracks[l.fLab[0]].Pt()>1 ){
-           fhNeighChi->Fill(TMath::Sqrt(bestD/(xN*xN+xP*xP)/4.));
-           fhNeighDy->Fill(dy);
-           fhNeighDz->Fill(dz);          
-           //}
-         }
+  fStatSeedNRecTot += nRecTot;
+  fStatSeedNRecOut += nRecOut;
+  fStatSeedNGhost  += nGhost;
+  fStatSeedNMCAll  += nMCAll;
+  fStatSeedNRecAll  += nRecAll;
+  fStatSeedNClonesAll  += nClonesAll;
+  fStatSeedNMCRef  += nMCRef;
+  fStatSeedNRecRef  += nRecRef;
+  fStatSeedNClonesRef  += nClonesRef;
+
+  if( nMCAll ==0 ) return;
+
+  if( PrintFlag ){
+    cout<<"Track seed performance for slice "<<iSlice<<" : "<<endl;
+    cout<<" N tracks : "
+       <<nMCAll<<" mc all, "
+       <<nMCRef<<" mc ref, "
+       <<nRecTot<<" rec total, "
+       <<nRecAll<<" rec all, "
+       <<nClonesAll<<" clones all, "
+       <<nRecRef<<" rec ref, "
+       <<nClonesRef<<" clones ref, "
+       <<nRecOut<<" out, "
+       <<nGhost<<" ghost"<<endl;
+  
+    Int_t nRecExtr = nRecAll - nRecRef;
+    Int_t nMCExtr = nMCAll - nMCRef;
+    Int_t nClonesExtr = nClonesAll - nClonesRef;
+  
+    Double_t dRecTot = (nRecTot>0 ) ? nRecTot :1;
+    Double_t dMCAll = (nMCAll>0 ) ? nMCAll :1;
+    Double_t dMCRef = (nMCRef>0 ) ? nMCRef :1;
+    Double_t dMCExtr = (nMCExtr>0 ) ? nMCExtr :1;
+    Double_t dRecAll = (nRecAll+nClonesAll>0 ) ? nRecAll+nClonesAll :1;
+    Double_t dRecRef = (nRecRef+nClonesRef>0 ) ? nRecRef+nClonesRef :1;
+    Double_t dRecExtr = (nRecExtr+nClonesExtr>0 ) ? nRecExtr+nClonesExtr :1;
+    
+    cout<<" EffRef = ";
+    if( nMCRef>0 ) cout<<nRecRef/dMCRef; else cout<<"_";
+    cout<<", CloneRef = ";
+    if( nRecRef >0 ) cout << nClonesRef/dRecRef; else cout<<"_";
+    cout<<endl;
+    cout<<" EffExtra = ";
+    if( nMCExtr>0 ) cout << nRecExtr/dMCExtr; else cout<<"_";
+    cout <<", CloneExtra = ";
+    if( nRecExtr>0 ) cout << nClonesExtr/dRecExtr; else cout<<"_";
+    cout<<endl;
+    cout<<" EffAll = ";
+    if( nMCAll>0 ) cout<<nRecAll/dMCAll; else cout<<"_";
+    cout <<", CloneAll = ";
+    if( nRecAll>0 ) cout << nClonesAll/dRecAll; else cout<<"_";
+    cout <<endl;
+    cout<<" Out = ";
+    if( nRecTot>0 ) cout <<nRecOut/dRecTot; else cout<<"_";
+    cout <<", Ghost = ";
+    if( nRecTot>0 ) cout<<nGhost/dRecTot; else cout<<"_";
+    cout<<endl;
+  }
+}
+
+
+
+
+void AliHLTTPCCAPerformance::SliceTrackCandPerformance( Int_t iSlice, Bool_t PrintFlag )
+{ 
+  //* calculate slice tracker performance
+  if( !fTracker ) return;
+  
+  Int_t nRecTot = 0, nGhost=0, nRecOut=0;
+  Int_t nMCAll = 0, nRecAll=0, nClonesAll=0;
+  Int_t nMCRef = 0, nRecRef=0, nClonesRef=0;
+  AliHLTTPCCATracker &slice = fTracker->Slices()[iSlice];
+
+  Int_t firstSliceHit = fTracker->FirstSliceHit()[iSlice];
+  Int_t endSliceHit = fTracker->NHits();
+  if( iSlice<fTracker->NSlices()-1 ) endSliceHit = fTracker->FirstSliceHit()[iSlice+1];    
+
+  // Select reconstructable MC tracks
+
+  {
+    for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].SetNHits( 0 );
+    
+    for( Int_t ih=firstSliceHit; ih<endSliceHit; ih++){
+      Int_t id = fTracker->Hits()[ih].ID();
+      if( id<0 || id>=fNHits ) break;
+      AliHLTTPCCAHitLabel &l = fHitLabels[id];
+      if( l.fLab[0]>=0 ) fMCTracks[l.fLab[0]].SetNHits(fMCTracks[l.fLab[0]].NHits()+1);
+      if( l.fLab[1]>=0 ) fMCTracks[l.fLab[1]].SetNHits(fMCTracks[l.fLab[1]].NHits()+1);
+      if( l.fLab[2]>=0 ) fMCTracks[l.fLab[2]].SetNHits(fMCTracks[l.fLab[2]].NHits()+1);
+    }
+    
+    for (Int_t imc=0; imc<fNMCTracks; imc++) {         
+      AliHLTTPCCAMCTrack &mc = fMCTracks[imc];
+      mc.SetSet( 0 );
+      mc.SetNReconstructed( 0 );
+      mc.SetNTurns( 1 );
+      if( mc.NHits() >=  30 && mc.P()>=.05 ){
+       mc.SetSet( 1 );
+       nMCAll++;
+       if( mc.NHits() >=  30 && mc.P()>=1. ){
+         mc.SetSet( 2 );
+         nMCRef++;
        }
+      }
+    }
+  }
 
-       Bool_t okP=0, okN=0;
-       if( h.FirstTriplet()>=0 ){
-         for( Int_t it=h.FirstTriplet(); it<row.NTriplets(); it++ ){
-           AliHLTTPCCATriplet &t = row.Triplets()[it];
-           if( t.HitMid()!=ih ) break;
-           //if( !t.Alive() ) continue;
-           AliHLTTPCCAHit &hP = rowP.Hits()[t.HitDown()];
-           AliHLTTPCCAHit &hN = rowN.Hits()[t.HitUp()];
-           AliHLTTPCCAHitLabel &lP = fHitLabels[fTracker->Hits()[hP.ID()].ID()];
-           AliHLTTPCCAHitLabel &lN = fHitLabels[fTracker->Hits()[hN.ID()].ID()];
-           for( Int_t jl=0; jl<3; jl++ ){
-             if( lP.fLab[jl]==l.fLab[0] ) okP = 1;
-             if( lN.fLab[jl]==l.fLab[0] ) okN = 1;
-           }
-         }     
+  Int_t traN = *slice.NTracklets();
+  Int_t *traLabels = 0; 
+  Double_t *traPurity = 0;
+  traLabels = new Int_t[traN];
+  traPurity = new Double_t[traN];
+  {
+    for (Int_t itr=0; itr<traN; itr++) {
+      traLabels[itr]=-1;
+      traPurity[itr]= 0;
+
+      AliHLTTPCCATracklet &t = slice.Tracklets()[itr];
+       
+      Int_t nHits = t.NHits();
+      if( nHits<10 ) continue;
+      Int_t firstRow = t.FirstRow();
+      Int_t lastRow = t.LastRow();
+      nHits=0;
+
+      Int_t lb[1600*3];
+      Int_t nla=0;
+
+      for( Int_t irow=firstRow; irow<=lastRow; irow++ ){
+       Int_t ih = t.RowHit(irow);
+       if( ih<0 ) continue;
+       Int_t index = firstSliceHit + slice.HitInputIDs()[slice.Row(irow).FirstHit()+ih];
+       AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[index].ID()];      
+       if(l.fLab[0]>=0 ) lb[nla++]= l.fLab[0];
+       if(l.fLab[1]>=0 ) lb[nla++]= l.fLab[1];
+       if(l.fLab[2]>=0 ) lb[nla++]= l.fLab[2];
+       nHits++;     
+      }
+      if( nHits<10 ) continue;      
+      
+      sort( lb, lb+nla );
+      Int_t labmax = -1, labcur=-1, lmax = 0, lcurr=0;
+      for( Int_t i=0; i<nla; i++ ){
+       if( lb[i]!=labcur ){
+         if( labcur>=0 && lmax<lcurr ){
+           lmax = lcurr;
+           labmax = labcur;
+         }
+         labcur = lb[i];
+         lcurr = 0;
        }
-       //fhNeighEff->Fill(iRow, okP&&okN );    
-       //fhNeighEffVsPt->Fill( fMCTracks[l.fLab[0]].Pt(), okP&&okN );  
+       lcurr++;
+      }
+      if( labcur>=0 && lmax<lcurr ){
+       lmax = lcurr;
+       labmax = labcur;
+      }
+      lmax = 0;
+      for( Int_t irow=firstRow; irow<=lastRow; irow++ ){
+       Int_t ih = t.RowHit(irow);
+       if( ih<0 ) continue;
+       Int_t index = firstSliceHit + slice.HitInputIDs()[slice.Row(irow).FirstHit()+ih];
+       AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[index].ID()];      
+       if( l.fLab[0] == labmax || l.fLab[1] == labmax || l.fLab[2] == labmax 
+           ) lmax++;
       }
+      traLabels[itr] = labmax;
+      traPurity[itr] = ( (nHits>0) ?double(lmax)/double(nHits) :0 );
     }
-#endif
   }
   
+  nRecTot+= traN;
+  
+  for(Int_t itr=0; itr<traN; itr++){      
+    if( traPurity[itr]<.9 || traLabels[itr]<0 || traLabels[itr]>=fNMCTracks){
+      nGhost++;
+      continue;
+    }
+    
+    AliHLTTPCCAMCTrack &mc = fMCTracks[traLabels[itr]];        
+    mc.SetNReconstructed( mc.NReconstructed()+1);
+    if( mc.Set()== 0 ) nRecOut++;
+    else{
+      if( mc.NReconstructed()==1 ) nRecAll++;
+      else if(mc.NReconstructed() > mc.NTurns() ) nClonesAll++;
+      if( mc.Set()==2 ){
+       if( mc.NReconstructed()==1 ) nRecRef++;
+       else if(mc.NReconstructed() > mc.NTurns() ) nClonesRef++;
+      }
+    }      
+  }
+
+  for (Int_t ipart=0; ipart<fNMCTracks; ipart++) {             
+    AliHLTTPCCAMCTrack &mc = fMCTracks[ipart];
+    if( mc.Set()>0 ) fhCandEffVsP->Fill(mc.P(), ( mc.NReconstructed()>0 ?1 :0));
+  }  
+
+  if( traLabels ) delete[] traLabels;
+  if( traPurity ) delete[] traPurity;
+
+  fStatCandNRecTot += nRecTot;
+  fStatCandNRecOut += nRecOut;
+  fStatCandNGhost  += nGhost;
+  fStatCandNMCAll  += nMCAll;
+  fStatCandNRecAll  += nRecAll;
+  fStatCandNClonesAll  += nClonesAll;
+  fStatCandNMCRef  += nMCRef;
+  fStatCandNRecRef  += nRecRef;
+  fStatCandNClonesRef  += nClonesRef;
+
+  if( nMCAll ==0 ) return;
+
+  if( PrintFlag ){
+    cout<<"Track candidate performance for slice "<<iSlice<<" : "<<endl;
+    cout<<" N tracks : "
+       <<nMCAll<<" mc all, "
+       <<nMCRef<<" mc ref, "
+       <<nRecTot<<" rec total, "
+       <<nRecAll<<" rec all, "
+       <<nClonesAll<<" clones all, "
+       <<nRecRef<<" rec ref, "
+       <<nClonesRef<<" clones ref, "
+       <<nRecOut<<" out, "
+       <<nGhost<<" ghost"<<endl;
+  
+    Int_t nRecExtr = nRecAll - nRecRef;
+    Int_t nMCExtr = nMCAll - nMCRef;
+    Int_t nClonesExtr = nClonesAll - nClonesRef;
+  
+    Double_t dRecTot = (nRecTot>0 ) ? nRecTot :1;
+    Double_t dMCAll = (nMCAll>0 ) ? nMCAll :1;
+    Double_t dMCRef = (nMCRef>0 ) ? nMCRef :1;
+    Double_t dMCExtr = (nMCExtr>0 ) ? nMCExtr :1;
+    Double_t dRecAll = (nRecAll+nClonesAll>0 ) ? nRecAll+nClonesAll :1;
+    Double_t dRecRef = (nRecRef+nClonesRef>0 ) ? nRecRef+nClonesRef :1;
+    Double_t dRecExtr = (nRecExtr+nClonesExtr>0 ) ? nRecExtr+nClonesExtr :1;
+    
+    cout<<" EffRef = ";
+    if( nMCRef>0 ) cout<<nRecRef/dMCRef; else cout<<"_";
+    cout<<", CloneRef = ";
+    if( nRecRef >0 ) cout << nClonesRef/dRecRef; else cout<<"_";
+    cout<<endl;
+    cout<<" EffExtra = ";
+    if( nMCExtr>0 ) cout << nRecExtr/dMCExtr; else cout<<"_";
+    cout <<", CloneExtra = ";
+    if( nRecExtr>0 ) cout << nClonesExtr/dRecExtr; else cout<<"_";
+    cout<<endl;
+    cout<<" EffAll = ";
+    if( nMCAll>0 ) cout<<nRecAll/dMCAll; else cout<<"_";
+    cout <<", CloneAll = ";
+    if( nRecAll>0 ) cout << nClonesAll/dRecAll; else cout<<"_";
+    cout <<endl;
+    cout<<" Out = ";
+    if( nRecTot>0 ) cout <<nRecOut/dRecTot; else cout<<"_";
+    cout <<", Ghost = ";
+    if( nRecTot>0 ) cout<<nGhost/dRecTot; else cout<<"_";
+    cout<<endl;
+  }
+}
+
+
+
+void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
+{ 
+  //* calculate slice tracker performance
+  if( !fTracker ) return;
+  
+  Int_t nRecTot = 0, nGhost=0, nRecOut=0;
+  Int_t nMCAll = 0, nRecAll=0, nClonesAll=0;
+  Int_t nMCRef = 0, nRecRef=0, nClonesRef=0;
+  AliHLTTPCCATracker &slice = fTracker->Slices()[iSlice];
+
+  Int_t firstSliceHit = 0;
+  for( ; firstSliceHit<fTracker->NHits(); firstSliceHit++){
+    if( fTracker->Hits()[firstSliceHit].ISlice()==iSlice ) break;
+  }
+  Int_t endSliceHit = firstSliceHit;  
+
+  for( ; endSliceHit<fTracker->NHits(); endSliceHit++){
+    if( fTracker->Hits()[endSliceHit].ISlice()!=iSlice ) break;
+  }
+    
 
   // Select reconstructable MC tracks
 
   {
-    for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].NHits() = 0;
+    for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].SetNHits( 0 );
         
     for( Int_t ih=firstSliceHit; ih<endSliceHit; ih++){
       Int_t id = fTracker->Hits()[ih].ID();
       if( id<0 || id>fNHits ) break;
       AliHLTTPCCAHitLabel &l = fHitLabels[id];
-      if( l.fLab[0]>=0 ) fMCTracks[l.fLab[0]].NHits()++;
-      if( l.fLab[1]>=0 ) fMCTracks[l.fLab[1]].NHits()++;
-      if( l.fLab[2]>=0 ) fMCTracks[l.fLab[2]].NHits()++;
+      if( l.fLab[0]>=0 ) fMCTracks[l.fLab[0]].SetNHits(fMCTracks[l.fLab[0]].NHits()+1);
+      if( l.fLab[1]>=0 ) fMCTracks[l.fLab[1]].SetNHits(fMCTracks[l.fLab[1]].NHits()+1);
+      if( l.fLab[2]>=0 ) fMCTracks[l.fLab[2]].SetNHits(fMCTracks[l.fLab[2]].NHits()+1);
     }
     
     for (Int_t imc=0; imc<fNMCTracks; imc++) {         
       AliHLTTPCCAMCTrack &mc = fMCTracks[imc];
-      mc.Set() = 0;
-      mc.NReconstructed() = 0;
-      mc.NTurns() = 1;
+      mc.SetSet( 0 );
+      mc.SetNReconstructed( 0 );
+      mc.SetNTurns( 1 );
       if( mc.NHits() >=  30 && mc.P()>=.05 ){
-       mc.Set() = 1;
+       mc.SetSet(1);
        nMCAll++;
        if( mc.NHits() >=  30 && mc.P()>=1. ){
-         mc.Set() = 2;
+         mc.SetSet( 2 );
          nMCRef++;
        }
       }
@@ -855,7 +1246,7 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
     }
 
     AliHLTTPCCAMCTrack &mc = fMCTracks[traLabels[itr]];        
-    mc.NReconstructed()++;
+    mc.SetNReconstructed(mc.NReconstructed()+1);
     if( mc.Set()== 0 ) nRecOut++;
     else{
       if( mc.NReconstructed()==1 ) nRecAll++;
@@ -954,6 +1345,8 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
   */
   fStatNEvents++;  
   for( Int_t islice=0; islice<fTracker->NSlices(); islice++){ 
+    //SliceTrackletPerformance( islice,0 );
+    SliceTrackCandPerformance( islice, 0 );
     SlicePerformance(islice,0);
   }
 
@@ -969,25 +1362,25 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
       // Select reconstructable MC tracks
    
       {
-       for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].NHits() = 0;
+       for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].SetNHits( 0 );
           
        for( Int_t ih=0; ih<fNHits; ih++){
          AliHLTTPCCAHitLabel &l = fHitLabels[ih];
-         if( l.fLab[0]>=0 ) fMCTracks[l.fLab[0]].NHits()++;
-         if( l.fLab[1]>=0 ) fMCTracks[l.fLab[1]].NHits()++;
-         if( l.fLab[2]>=0 ) fMCTracks[l.fLab[2]].NHits()++;
+         if( l.fLab[0]>=0 ) fMCTracks[l.fLab[0]].SetNHits(fMCTracks[l.fLab[0]].NHits()+1);
+         if( l.fLab[1]>=0 ) fMCTracks[l.fLab[1]].SetNHits(fMCTracks[l.fLab[1]].NHits()+1);
+         if( l.fLab[2]>=0 ) fMCTracks[l.fLab[2]].SetNHits(fMCTracks[l.fLab[2]].NHits()+1);
        }
     
        for (Int_t imc=0; imc<fNMCTracks; imc++) {              
          AliHLTTPCCAMCTrack &mc = fMCTracks[imc];
-         mc.Set() = 0;
-         mc.NReconstructed() = 0;
-         mc.NTurns() = 1;
+         mc.SetSet( 0 );
+         mc.SetNReconstructed( 0 );
+         mc.SetNTurns( 1 );
          if( mc.NHits() >=  50 && mc.P()>=.05 ){
-           mc.Set() = 1;
+           mc.SetSet(1);
            nMCAll++;
            if( mc.P()>=1. ){
-             mc.Set() = 2;
+             mc.SetSet(2);
              nMCRef++;
            }
          }
@@ -1053,7 +1446,7 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
        AliHLTTPCCAGBTrack &tCA = fTracker->Tracks()[itr];
        AliHLTTPCCAMCTrack &mc = fMCTracks[traLabels[itr]];     
        
-       mc.NReconstructed()++;
+       mc.SetNReconstructed(mc.NReconstructed()+1);
        if( mc.Set()== 0 ) nRecOut++;
        else{
          if( mc.NReconstructed()==1 ) nRecAll++;
@@ -1191,8 +1584,13 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
     Int_t nHits = fTracker->NHits();
     for( Int_t ih=0; ih<nHits; ih++ ){
       AliHLTTPCCAGBHit &hit = fTracker->Hits()[ih];
+      AliHLTTPCCAHitLabel &l = fHitLabels[hit.ID()];
       fhHitErrY->Fill(hit.ErrY());
       fhHitErrZ->Fill(hit.ErrZ());
+      Int_t nmc=0;
+      for( Int_t il=0; il<3; il++ ) if( l.fLab[il]>=0 ) nmc++;
+      if( nmc==1 ) fhHitShared->Fill(hit.IRow(),0);
+      else if( nmc>1 ) fhHitShared->Fill(hit.IRow(),1);
     }
   }
 
@@ -1203,15 +1601,15 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
     {
       for (Int_t ipart=0; ipart<fNMCTracks; ipart++) {         
        AliHLTTPCCAMCTrack &mc = fMCTracks[ipart];
-       mc.NMCPoints() = 0;
+       mc.SetNMCPoints(0);
       }
       sort(fMCPoints, fMCPoints+fNMCPoints, AliHLTTPCCAMCPoint::Compare );
       
       for( Int_t ip=0; ip<fNMCPoints; ip++ ){
        AliHLTTPCCAMCPoint &p = fMCPoints[ip];
        AliHLTTPCCAMCTrack &t = fMCTracks[p.TrackID()];
-       if( t.NMCPoints()==0 ) t.FirstMCPointID() = ip;
-       t.NMCPoints()++;
+       if( t.NMCPoints()==0 ) t.SetFirstMCPointID( ip );
+       t.SetNMCPoints(t.NMCPoints()+1);
       }
     }
 
@@ -1288,6 +1686,76 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
   }
 
   {
+    cout<<"\nSlice Track Seed performance: \n"<<endl;
+    cout<<" N tracks : "
+       <<fStatNMCAll/fStatNEvents<<" mc all, "
+       <<fStatSeedNMCRef/fStatNEvents<<" mc ref, "
+       <<fStatSeedNRecTot/fStatNEvents<<" rec total, "
+       <<fStatSeedNRecAll/fStatNEvents<<" rec all, "
+       <<fStatSeedNClonesAll/fStatNEvents<<" clones all, "
+       <<fStatSeedNRecRef/fStatNEvents<<" rec ref, "
+       <<fStatSeedNClonesRef/fStatNEvents<<" clones ref, "
+       <<fStatSeedNRecOut/fStatNEvents<<" out, "
+       <<fStatSeedNGhost/fStatNEvents<<" ghost"<<endl;
+  
+    Int_t nRecExtr = fStatSeedNRecAll - fStatSeedNRecRef;
+    Int_t nMCExtr = fStatNMCAll - fStatNMCRef;
+    Int_t nClonesExtr = fStatSeedNClonesAll - fStatSeedNClonesRef;
+    
+    Double_t dRecTot = (fStatSeedNRecTot>0 ) ? fStatSeedNRecTot :1;
+    Double_t dMCAll = (fStatNMCAll>0 ) ? fStatNMCAll :1;
+    Double_t dMCRef = (fStatNMCRef>0 ) ? fStatNMCRef :1;
+    Double_t dMCExtr = (nMCExtr>0 ) ? nMCExtr :1;
+    Double_t dRecAll = (fStatSeedNRecAll+fStatSeedNClonesAll>0 ) ? fStatSeedNRecAll+fStatSeedNClonesAll :1;
+    Double_t dRecRef = (fStatSeedNRecRef+fStatSeedNClonesRef>0 ) ? fStatSeedNRecRef+fStatSeedNClonesRef :1;
+    Double_t dRecExtr = (nRecExtr+nClonesExtr>0 ) ? nRecExtr+nClonesExtr :1;
+    
+    cout<<" EffRef = "<< fStatSeedNRecRef/dMCRef
+       <<", CloneRef = " << fStatSeedNClonesRef/dRecRef <<endl;
+    cout<<" EffExtra = "<<nRecExtr/dMCExtr
+       <<", CloneExtra = " << nClonesExtr/dRecExtr<<endl;
+    cout<<" EffAll = "<<fStatSeedNRecAll/dMCAll
+       <<", CloneAll = " << fStatSeedNClonesAll/dRecAll<<endl;
+    cout<<" Out = "<<fStatSeedNRecOut/dRecTot
+       <<", Ghost = "<<fStatSeedNGhost/dRecTot<<endl;
+  }
+
+  {
+    cout<<"\nSlice Track candidate performance: \n"<<endl;
+    cout<<" N tracks : "
+       <<fStatNMCAll/fStatNEvents<<" mc all, "
+       <<fStatCandNMCRef/fStatNEvents<<" mc ref, "
+       <<fStatCandNRecTot/fStatNEvents<<" rec total, "
+       <<fStatCandNRecAll/fStatNEvents<<" rec all, "
+       <<fStatCandNClonesAll/fStatNEvents<<" clones all, "
+       <<fStatCandNRecRef/fStatNEvents<<" rec ref, "
+       <<fStatCandNClonesRef/fStatNEvents<<" clones ref, "
+       <<fStatCandNRecOut/fStatNEvents<<" out, "
+       <<fStatCandNGhost/fStatNEvents<<" ghost"<<endl;
+  
+    Int_t nRecExtr = fStatCandNRecAll - fStatCandNRecRef;
+    Int_t nMCExtr = fStatNMCAll - fStatNMCRef;
+    Int_t nClonesExtr = fStatCandNClonesAll - fStatCandNClonesRef;
+    
+    Double_t dRecTot = (fStatCandNRecTot>0 ) ? fStatCandNRecTot :1;
+    Double_t dMCAll = (fStatNMCAll>0 ) ? fStatNMCAll :1;
+    Double_t dMCRef = (fStatNMCRef>0 ) ? fStatNMCRef :1;
+    Double_t dMCExtr = (nMCExtr>0 ) ? nMCExtr :1;
+    Double_t dRecAll = (fStatCandNRecAll+fStatCandNClonesAll>0 ) ? fStatCandNRecAll+fStatCandNClonesAll :1;
+    Double_t dRecRef = (fStatCandNRecRef+fStatCandNClonesRef>0 ) ? fStatCandNRecRef+fStatCandNClonesRef :1;
+    Double_t dRecExtr = (nRecExtr+nClonesExtr>0 ) ? nRecExtr+nClonesExtr :1;
+    
+    cout<<" EffRef = "<< fStatCandNRecRef/dMCRef
+       <<", CloneRef = " << fStatCandNClonesRef/dRecRef <<endl;
+    cout<<" EffExtra = "<<nRecExtr/dMCExtr
+       <<", CloneExtra = " << nClonesExtr/dRecExtr<<endl;
+    cout<<" EffAll = "<<fStatCandNRecAll/dMCAll
+       <<", CloneAll = " << fStatCandNClonesAll/dRecAll<<endl;
+    cout<<" Out = "<<fStatCandNRecOut/dRecTot
+       <<", Ghost = "<<fStatCandNGhost/dRecTot<<endl;
+  }
+
+  {
     cout<<"\nSlice tracker performance: \n"<<endl;
     cout<<" N tracks : "
        <<fStatNMCAll/fStatNEvents<<" mc all, "
@@ -1333,6 +1801,7 @@ void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
        <<" msec/event "<<endl;
   }
 
+
   {
     cout<<"\nGlobal tracker performance for "<<fStatNEvents<<" events: \n"<<endl;
     cout<<" N tracks : "
@@ -1516,18 +1985,19 @@ void AliHLTTPCCAPerformance::ReadMCEvent( istream &in )
   for( Int_t it=0; it<fNMCTracks; it++ ){
     AliHLTTPCCAMCTrack &t = fMCTracks[it];
     Int_t j;
+    Float_t f;
     in>>j;
-    in>> t.PDG();
-    for( Int_t i=0; i<7; i++ ) in>>t.Par()[i];
-    for( Int_t i=0; i<7; i++ ) in>>t.TPCPar()[i];
-    in>> t.P();
-    in>> t.Pt();
-    in>> t.NHits();
-    in>> t.NMCPoints();
-    in>> t.FirstMCPointID();
-    in>> t.NReconstructed();
-    in>> t.Set();
-    in>> t.NTurns();
+    in>> j; t.SetPDG(j);
+    for( Int_t i=0; i<7; i++ ){ in>>f; t.SetPar(i,f);}
+    for( Int_t i=0; i<7; i++ ){ in>>f; t.SetTPCPar(i,f);}
+    in>> f; t.SetP(f);
+    in>> f; t.SetPt(f);
+    in>> j; t.SetNHits(j);
+    in>> j; t.SetNMCPoints(j);
+    in>> j; t.SetFirstMCPointID(j);
+    in>> j; t.SetNReconstructed(j);
+    in>> j; t.SetSet(j);
+    in>> j; t.SetNTurns(j);
   }
   
   in>>fNHits;
index 324baba..7e1ebca 100644 (file)
@@ -1,14 +1,17 @@
 //-*- Mode: C++ -*-
 // $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAPERFORMANCE_H
 #define ALIHLTTPCCAPERFORMANCE_H
 
 #include "AliHLTTPCCADef.h"
+#include "Riostream.h"
 
 class TObject;
 class TParticle;
@@ -39,13 +42,13 @@ class AliHLTTPCCAPerformance
 
   AliHLTTPCCAPerformance();
   AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&);
-  AliHLTTPCCAPerformance &operator=(const AliHLTTPCCAPerformance&);
+  const AliHLTTPCCAPerformance &operator=(const AliHLTTPCCAPerformance&) const;
 
   virtual ~AliHLTTPCCAPerformance();
 
   static AliHLTTPCCAPerformance &Instance();
 
-  void SetTracker( AliHLTTPCCAGBTracker *Tracker );
+  void SetTracker( AliHLTTPCCAGBTracker * const Tracker );
   void StartEvent();
   void SetNHits( Int_t NHits );
   void SetNMCTracks( Int_t NMCTracks );
@@ -62,6 +65,9 @@ class AliHLTTPCCAPerformance
   void CreateHistos();
   void WriteHistos();
   void SlicePerformance( Int_t iSlice, Bool_t PrintFlag  );
+  void SliceTrackletPerformance( Int_t iSlice, Bool_t PrintFlag );
+  void SliceTrackCandPerformance( Int_t iSlice, Bool_t PrintFlag );
+
   void Performance( fstream *StatFile = 0);
 
   void WriteMCEvent( ostream &out ) const;
@@ -70,13 +76,18 @@ class AliHLTTPCCAPerformance
   void ReadMCPoints( istream &in );
   Bool_t DoClusterPulls() const { return fDoClusterPulls; }
   void SetDoClusterPulls( Bool_t v ) { fDoClusterPulls = v; }
-  AliHLTTPCCAHitLabel *HitLabels(){ return fHitLabels;}
-  AliHLTTPCCAMCTrack *MCTracks(){ return fMCTracks; }
+  AliHLTTPCCAHitLabel *HitLabels() const { return fHitLabels;}
+  AliHLTTPCCAMCTrack *MCTracks() const { return fMCTracks; }
   Int_t NMCTracks() const { return fNMCTracks; }
 
   TH1D *HNHitsPerSeed() const { return fhNHitsPerSeed;}
   TH1D *HNHitsPerTrackCand() const { return fhNHitsPerTrackCand; }
 
+  TH1D *LinkChiRight( int i ) const { return fhLinkChiRight[i]; }
+  TH1D *LinkChiWrong( int i ) const { return fhLinkChiWrong[i]; }
+
+  void LinkPerformance( Int_t iSlice );
+
 protected:
 
   AliHLTTPCCAGBTracker *fTracker; //* pointer to the tracker
@@ -91,6 +102,27 @@ protected:
   Bool_t fDoClusterPulls;          //* do cluster pulls (very slow)
   Int_t fStatNEvents; //* n of events proceed
   Double_t fStatTime; //* reco time;
+
+  Int_t fStatSeedNRecTot; //* total n of reconstructed tracks 
+  Int_t fStatSeedNRecOut; //* n of reconstructed tracks in Out set
+  Int_t fStatSeedNGhost;//* n of reconstructed tracks in Ghost set
+  Int_t fStatSeedNMCAll;//* n of MC tracks 
+  Int_t fStatSeedNRecAll; //* n of reconstructed tracks in All set
+  Int_t fStatSeedNClonesAll;//* total n of reconstructed tracks in Clone set
+  Int_t fStatSeedNMCRef; //* n of MC reference tracks 
+  Int_t fStatSeedNRecRef; //* n of reconstructed tracks in Ref set
+  Int_t fStatSeedNClonesRef; //* n of reconstructed clones in Ref set
+
+  Int_t fStatCandNRecTot; //* total n of reconstructed tracks 
+  Int_t fStatCandNRecOut; //* n of reconstructed tracks in Out set
+  Int_t fStatCandNGhost;//* n of reconstructed tracks in Ghost set
+  Int_t fStatCandNMCAll;//* n of MC tracks 
+  Int_t fStatCandNRecAll; //* n of reconstructed tracks in All set
+  Int_t fStatCandNClonesAll;//* total n of reconstructed tracks in Clone set
+  Int_t fStatCandNMCRef; //* n of MC reference tracks 
+  Int_t fStatCandNRecRef; //* n of reconstructed tracks in Ref set
+  Int_t fStatCandNClonesRef; //* n of reconstructed clones in Ref set
+
   Int_t fStatNRecTot; //* total n of reconstructed tracks 
   Int_t fStatNRecOut; //* n of reconstructed tracks in Out set
   Int_t fStatNGhost;//* n of reconstructed tracks in Ghost set
@@ -134,6 +166,7 @@ protected:
     *fhHitResZ,//* hit resolution Z
     *fhHitPullY,//* hit  pull Y
     *fhHitPullZ;//* hit  pull Z
+  TProfile *fhHitShared; //* ratio of the shared clusters
 
   TH1D 
     *fhHitResY1,//* hit resolution Y, pt>1GeV
@@ -150,6 +183,8 @@ protected:
     *fhCellPurityVsN, //* cell purity vs N hits
     *fhCellPurityVsPt,//* cell purity vs MC Pt
     *fhEffVsP, //* reconstruction efficiency vs P plot
+    *fhSeedEffVsP, //* reconstruction efficiency vs P plot
+    *fhCandEffVsP, //* reconstruction efficiency vs P plot
     *fhGBEffVsP, //* global reconstruction efficiency vs P plot
     *fhGBEffVsPt, //* global reconstruction efficiency vs P plot
     *fhNeighQuality, // quality for neighbours finder 
@@ -189,6 +224,12 @@ protected:
     *fhRefNotRecoAngleZ,// parameters of non-reconstructed ref. mc track
     *fhRefNotRecoNHits;// parameters of non-reconstructed ref. mc track
 
+  TProfile * fhLinkEff[4]; // link efficiency
+  TH1D *fhLinkAreaY[4]; // area in Y for the link finder
+  TH1D *fhLinkAreaZ[4]; // area in Z for the link finder
+  TH1D *fhLinkChiRight[4]; // sqrt(chi^2) for right neighbours
+  TH1D *fhLinkChiWrong[4]; // sqrt(chi^2) for wrong neighbours
+
   static void WriteDir2Current( TObject *obj );
   
 };
index f7007a4..67556fc 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAPROCESS_H
 #define ALIHLTTPCCAPROCESS_H
index 479ff00..f4626b7 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCARow.h"
index e512aa4..97dac3a 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAROW_H
 #define ALIHLTTPCCAROW_H
@@ -43,7 +45,6 @@ class AliHLTTPCCARow
   GPUhd() Int_t   FullGridOffset()  const { return fFullGridOffset;}
   GPUhd() Int_t   FullLinkOffset()  const { return fFullLinkOffset;}
 
-
   GPUhd() void SetFirstHit( Int_t v ){ fFirstHit = v; }
   GPUhd() void SetNHits( Int_t v )   { fNHits = v; }
   GPUhd() void SetX( Float_t v )       { fX = v; }
index ebec79f..443ceab 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id: AliHLTTPCCAStartHitsFinder.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCAStartHitsFinder.h"
@@ -30,14 +31,14 @@ GPUd() void AliHLTTPCCAStartHitsFinder::Thread
     {
       if( iThread==0 ){
        if( iBlock==0 ){
-         CAMath::atomicExch( tracker.NTracklets(),0); 
+         CAMath::AtomicExch( tracker.NTracklets(),0); 
        }
        s.fNRows = tracker.Param().NRows();
        s.fIRow = iBlock+1;
        s.fNRowStartHits = 0;
        if( s.fIRow <= s.fNRows-4 ){      
          s.fNHits = tracker.Row(s.fIRow).NHits(); 
-         if( s.fNHits>=1024 ) s.fNHits = 1023;
+         if( s.fNHits>=10240 ) s.fNHits = 10230;
 
          const AliHLTTPCCARow &row = tracker.Row(s.fIRow);
          s.fHitLinkUp = ((Short_t*)(tracker.RowData() + row.FullOffset())) + row.FullLinkOffset();
@@ -50,7 +51,7 @@ GPUd() void AliHLTTPCCAStartHitsFinder::Thread
     {
       for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){      
        if( ( s.fHitLinkDown[ih]<0 ) && ( s.fHitLinkUp[ih]>=0 ) ){
-         Int_t oldNRowStartHits = CAMath::atomicAdd(&s.fNRowStartHits,1);
+         Int_t oldNRowStartHits = CAMath::AtomicAdd(&s.fNRowStartHits,1);
          s.fRowStartHits[oldNRowStartHits] = AliHLTTPCCATracker::IRowIHit2ID(s.fIRow, ih);
        }
       }
@@ -58,7 +59,7 @@ GPUd() void AliHLTTPCCAStartHitsFinder::Thread
   else if( iSync==2 )
     {
       if( iThread == 0 ){
-       s.fNOldStartHits = CAMath::atomicAdd(tracker.NTracklets(),s.fNRowStartHits);  
+       s.fNOldStartHits = CAMath::AtomicAdd(tracker.NTracklets(),s.fNRowStartHits);  
       }
     }
   else if( iSync==3 )
index f33f00b..99246ae 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCASTARTHITSFINDER_H
 #define ALIHLTTPCCASTARTHITSFINDER_H
@@ -38,7 +40,7 @@ class AliHLTTPCCAStartHitsFinder
       Int_t fNHits; // n hits in the row
       Short_t *fHitLinkDown; // pointer to down link array
       Short_t *fHitLinkUp; // pointer to the up link array
-      Int_t fRowStartHits[1024]; // temp. array for the start hits
+      Int_t fRowStartHits[10240]; // temp. array for the start hits
       Int_t fNOldStartHits; // n start hits from other jobs
       Int_t fNRowStartHits; // n start hits for this row
    };
index a6b534d..a986ee3 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCATrack.h"
 
 //ClassImp(AliHLTTPCCATrack)
index 925c42a..cae970a 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACK_H
 #define ALIHLTTPCCATRACK_H
index cbb6d63..db110c0 100644 (file)
@@ -1,5 +1,5 @@
 // $Id: AliHLTTPCCATrackConvertor.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCATrackConvertor.h"
 #include "AliExternalTrackParam.h"
 #include "AliHLTTPCCATrackParam.h"
index 5930a24..6b3d645 100644 (file)
@@ -1,9 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project           * 
-//* ALICE Experiment at CERN, All rights reserved.                            *
-//* See cxx source for full Copyright notice                                  *
-
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACKCONVERTOR_H
 #define ALIHLTTPCCATRACKCONVERTOR_H
index 8620b6a..640f9bc 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCATrackParam.h"
 #include "AliHLTTPCCAMath.h"
 #include <iostream>
@@ -934,7 +936,7 @@ GPUd() void AliHLTTPCCATrackParam::CalculateFitParameters( AliHLTTPCCATrackFitPa
 }
 
 
-GPUd() Bool_t AliHLTTPCCATrackParam::CorrectForMeanMaterial( Float_t xOverX0,  Float_t xTimesRho, AliHLTTPCCATrackFitParam &par )
+GPUd() Bool_t AliHLTTPCCATrackParam::CorrectForMeanMaterial( Float_t xOverX0,  Float_t xTimesRho, const AliHLTTPCCATrackFitParam &par )
 {
   //------------------------------------------------------------------
   // This function corrects the track parameters for the crossed material.
@@ -1170,8 +1172,9 @@ GPUd() Bool_t AliHLTTPCCATrackParam::Filter2NoCos( Float_t y, Float_t z, Float_t
 
   Float_t mSi[3];
   Float_t det = (mS[0]*mS[2] - mS[1]*mS[1]);
-
-  if( det < 1.e-8 ) return 0;
+  
+  if( !finite(det) || det > 1.e15 ) return 0;
+  if( det < 1.e-8  ) return 0;
   det = 1./det;
   mSi[0] = mS[2]*det;
   mSi[1] = -mS[1]*det;
index 33bd5bc..7c25fcd 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project           * 
-//* ALICE Experiment at CERN, All rights reserved.                            *
-//* See cxx source for full Copyright notice                                  *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 
 #ifndef ALIHLTTPCCATRACKPARAM_H
@@ -23,11 +25,9 @@ class AliHLTTPCCATrackParam
 {
  public:
 
-  class AliHLTTPCCATrackFitParam
+  struct AliHLTTPCCATrackFitParam
   {
-  public:
-    Float_t 
-    fBethe, fE,fTheta2, fEP2, fSigmadE2, fK22,fK33,fK43,fK44;// parameters
+    Float_t fBethe, fE,fTheta2, fEP2, fSigmadE2, fK22,fK33,fK43,fK44;// parameters
   };
 
 #if !defined(HLTCA_GPUCODE)
@@ -121,9 +121,9 @@ class AliHLTTPCCATrackParam
   GPUd() void FilterY( Float_t y, Float_t erry );
   GPUd() void FilterZ( Float_t z, Float_t errz );
 
-  GPUd() GPUd() static Float_t ApproximateBetheBloch( Float_t beta2 );
+  GPUd() static Float_t ApproximateBetheBloch( Float_t beta2 );
   GPUd() void CalculateFitParameters( AliHLTTPCCATrackFitParam &par, Float_t Bz, Float_t mass = 0.13957 );
-  GPUd() GPUd() Bool_t CorrectForMeanMaterial( Float_t xOverX0,  Float_t xTimesRho, AliHLTTPCCATrackFitParam &par );
+  GPUd() Bool_t CorrectForMeanMaterial( Float_t xOverX0,  Float_t xTimesRho, const AliHLTTPCCATrackFitParam &par );
   GPUd() void Print() const;
 
 private:
index 88c2690..175d52a 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCATracker.h"
 
 #ifdef DRAW
   #include "AliHLTTPCCADisplay.h"
-  #include "TApplication.h"
 #endif //DRAW
 
+#ifdef HLTCA_INTERNAL_PERFORMANCE
+ #include "AliHLTTPCCAPerformance.h"
+#endif
+
+
 ClassImp(AliHLTTPCCATracker)
 
 #if !defined(HLTCA_GPUCODE)  
@@ -126,7 +131,7 @@ GPUd() AliHLTTPCCATracker::~AliHLTTPCCATracker()
 
 
 // ----------------------------------------------------------------------------------
-GPUd() void AliHLTTPCCATracker::Initialize( AliHLTTPCCAParam &param )
+GPUd() void AliHLTTPCCATracker::Initialize( const AliHLTTPCCAParam &param )
 {
   // initialisation
   fParam = param;
@@ -167,7 +172,7 @@ GPUhd() void  AliHLTTPCCATracker::SetPointers()
   // set all pointers to the event memory
 
   Int_t gridSizeTotal = 2*(2*fNHitsTotal + 10*Param().NRows());
-
+  gridSizeTotal *=100;//SG!!!
   ULong_t mem = (ULong_t) fCommonMemory;  
   UInt_t sI = sizeof(Int_t);
   UInt_t sF = sizeof(Float_t);
@@ -221,7 +226,7 @@ GPUhd() void  AliHLTTPCCATracker::SetPointers()
   mem+= sI;
 
   fTrackHits = (Int_t*) mem;
-  mem+= fNHitsTotal*sI;
+  mem+= 100*fNHitsTotal*sI;//SG!!!
 
   fNOutTracks = (Int_t*) mem;
   mem+= sI;
@@ -235,13 +240,13 @@ GPUhd() void  AliHLTTPCCATracker::SetPointers()
   fNOutTrackHits = (Int_t*) mem;
   mem+= sI;
   fOutTrackHits = (Int_t*) mem;
-  mem+= fNHitsTotal*sI;
+  mem+= 100*fNHitsTotal*sI; //SG!!!
 
   fCommonMemorySize = mem - (ULong_t) fCommonMemory;
 }
 
 
-GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits, Float_t *Y, Float_t *Z, Int_t NHits )
+GPUd() void AliHLTTPCCATracker::ReadEvent( const Int_t *RowFirstHit, const Int_t *RowNHits, const Float_t *Y, const Float_t *Z, Int_t NHits )
 {
   //* Read event
 
@@ -264,6 +269,8 @@ GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits,
     *fNOutTrackHits = 0;
   }
 
+  //std::cout<<"Memory used for slice "<<fParam.ISlice()<<" : "<<fCommonMemorySize/1024./1024.<<" Mb "<<std::endl;
+
   reinterpret_cast<Int_t*>( fInputEvent )[0] = fParam.NRows();
   reinterpret_cast<Int_t*>( fInputEvent )[1+fParam.NRows()*2] = NHits;
   Int_t *rowHeaders = reinterpret_cast<Int_t*>( fInputEvent ) +1;
@@ -282,7 +289,7 @@ GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits,
   if( fTmpHitInputIDs ) delete[] fTmpHitInputIDs;
   fTmpHitInputIDs = new Int_t [NHits];
   const Float_t areaY = .5;
-  const Float_t areaZ = 1.;
+  const Float_t areaZ = .5;
   Int_t newRowNHitsTotal = 0;
   Bool_t *usedHits = new Bool_t [NHits];
   for( Int_t iHit=0; iHit<NHits; iHit++ ) usedHits[iHit] = 0;
@@ -368,9 +375,12 @@ GPUd() void AliHLTTPCCATracker::SetupRowData()
     Bool_t recreate=0;
     if( sy < 2. ) { recreate = 1; sy = 2; }
     if( sz < 2. ) { recreate = 1; sz = 2; }
+    recreate = 1;//SG!!!
+    sy=2;
+    sz=2;
     if( recreate ) grid.Create( yMin, yMax, zMin, zMax, sy, sz );
     row.SetGrid( grid );
-  }    
+  }
 
   AliHLTTPCCAHit ffHits[fNHitsTotal];
 
@@ -405,7 +415,8 @@ GPUd() void AliHLTTPCCATracker::SetupRowData()
     for( Int_t i=0; i<row.NHits(); i++ ){ 
       Int_t bin = bins[i];
       Int_t ind = c[bin] + filled[bin]-1;
-      AliHLTTPCCAHit &h = ffHits[row.FirstHit()+ind];
+
+     AliHLTTPCCAHit &h = ffHits[row.FirstHit()+ind];
       fHitInputIDs[row.FirstHit()+ind] = fTmpHitInputIDs[row.FirstHit()+i];
       h.SetY( hitsYZ[2*(row.FirstHit()+i)] );
       h.SetZ( hitsYZ[2*(row.FirstHit()+i)+1] );
@@ -458,6 +469,7 @@ GPUd() void AliHLTTPCCATracker::SetupRowData()
       size+= (nn)*sizeof(UShort_t);
       row.SetFullLinkOffset( row.NHits()*2 + nn );
       size+= row.NHits()*2*sizeof(Short_t);
+
       if( size%16 ) size = size/sizeof(uint4)+1;
       else size = size/sizeof(uint4);
       row.SetFullSize( size );
@@ -491,17 +503,13 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
   if( fNHitsTotal < 1 ) return;
 
 #ifdef DRAW
-  if( !gApplication ){
-    TApplication *myapp = new TApplication("myapp",0,0);
-  }
-  //AliHLTTPCCADisplay::Instance().Init();  
 
   AliHLTTPCCADisplay::Instance().ClearView();  
   AliHLTTPCCADisplay::Instance().SetSliceView();
   AliHLTTPCCADisplay::Instance().SetCurrentSlice( this );
   AliHLTTPCCADisplay::Instance().DrawSlice( this, 1 );  
   if( fNHitsTotal>0 ){
-    AliHLTTPCCADisplay::Instance().DrawSliceHits( -1, .5);  
+    AliHLTTPCCADisplay::Instance().DrawSliceHits( kRed, 1.);  
     AliHLTTPCCADisplay::Instance().Ask();
   }
 #endif
@@ -510,9 +518,23 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
   *fNTracklets = 0;
 
 #if !defined(HLTCA_GPUCODE)  
-
   AliHLTTPCCAProcess<AliHLTTPCCANeighboursFinder>( Param().NRows(), 1, *this );
 
+#ifdef HLTCA_INTERNAL_PERFORMANCE 
+  //if( Param().ISlice()<=2 ) 
+  //AliHLTTPCCAPerformance::Instance().LinkPerformance( Param().ISlice() );
+#endif
+
+
+#ifdef DRAW
+  if( fNHitsTotal>0 ){
+    AliHLTTPCCADisplay::Instance().DrawSliceLinks( -1, -1, 1);  
+    AliHLTTPCCADisplay::Instance().Ask();
+  }
+#endif
+
+
   AliHLTTPCCAProcess<AliHLTTPCCANeighboursCleaner>( Param().NRows()-2, 1, *this );
   AliHLTTPCCAProcess<AliHLTTPCCAStartHitsFinder>( Param().NRows()-4, 1, *this );
 
@@ -545,6 +567,8 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
 
   AliHLTTPCCAProcess1<AliHLTTPCCATrackletConstructor>(nBlocks, nMemThreads+nThreads,*this);
 
+  //std::cout<<"Slice "<<Param().ISlice()<<": NHits="<<fNHitsTotal<<", NTracklets="<<*NTracklets()<<std::endl;
+
   { 
     nThreads = 128;
     nBlocks = nStartHits/nThreads + 1;
@@ -640,10 +664,10 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
       fOutTrackHits[*fNOutTrackHits] = fHitInputIDs[row.FirstHit()+ih];      
       (*fNOutTrackHits)++;
       //cout<<"write i,row,hit,id="<<ith<<", "<<ID2IRow(ic)<<", "<<ih<<", "<<fHitInputIDs[row.FirstHit()+ih]<<std::endl;     
-      if( *fNOutTrackHits>fNHitsTotal ){
+      if( *fNOutTrackHits>=100*fNHitsTotal ){
        std::cout<<"fNOutTrackHits>fNHitsTotal"<<std::endl;
        //exit(0);
-       return;
+       return;//SG!!!
       }
       out.SetNHits( out.NHits() + 1 );      
     }    
index 833a399..4acfe8f 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACKER_H
 #define ALIHLTTPCCATRACKER_H
@@ -45,11 +47,11 @@ class AliHLTTPCCATracker
   GPUd() ~AliHLTTPCCATracker();
 #endif
 
-  GPUd() void Initialize( AliHLTTPCCAParam &param );
+  GPUd() void Initialize( const AliHLTTPCCAParam &param );
 
   GPUd() void StartEvent();
 
-  GPUd() void ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits, Float_t *Y, Float_t *Z, Int_t NHits );
+  GPUd() void ReadEvent( const Int_t *RowFirstHit, const Int_t *RowNHits, const Float_t *Y, const Float_t *Z, Int_t NHits );
 
   GPUd() void SetupRowData();
 
@@ -90,7 +92,7 @@ class AliHLTTPCCATracker
   GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
   GPUhd() void SetParam( const AliHLTTPCCAParam &v ){ fParam = v; }
 
-  GPUhd() const AliHLTTPCCARow &Row(Int_t i){ return fRows[i]; }
+  GPUhd() const AliHLTTPCCARow &Row(Int_t i) const { return fRows[i]; }
   GPUhd() Double_t Timer(Int_t i) const { return fTimers[i]; }
   GPUhd() void SetTimer(Int_t i, Double_t v ){ fTimers[i] = v; }
 
@@ -119,7 +121,7 @@ class AliHLTTPCCATracker
   GPUhd()  Int_t *NOutTrackHits() const { return  fNOutTrackHits; }
   GPUhd()  Int_t *OutTrackHits() const { return  fOutTrackHits; }
  
-  GPUh() void SetCommonMemory( Char_t *mem ){ fCommonMemory = mem; }
+  GPUh() void SetCommonMemory( Char_t * const mem ){ fCommonMemory = mem; }
 
   private:  
 
index 98ad86c..c374d47 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,7 +14,9 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
+
  
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
index 423328c..416fc73 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACKERCOMPONENT_H
 #define ALIHLTTPCCATRACKERCOMPONENT_H
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.cxx
new file mode 100644 (file)
index 0000000..adf2a7a
--- /dev/null
@@ -0,0 +1,26 @@
+// **************************************************************************
+// This file is property of and copyright by the ALICE HLT Project          * 
+// ALICE Experiment at CERN, All rights reserved.                           *
+//                                                                          *
+// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
+//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
+//                  for The ALICE HLT Project.                              *
+//                                                                          *
+// Permission to use, copy, modify and distribute this software and its     *
+// documentation strictly for non-commercial purposes is hereby granted     *
+// without fee, provided that the above copyright notice appears in all     *
+// copies and that both the copyright notice and this permission notice     *
+// appear in the supporting documentation. The authors make no claims       *
+// about the suitability of this software for any purpose. It is            *
+// provided "as is" without express or implied warranty.                    *
+//                                                                          *
+//***************************************************************************
+
+
+#include "AliHLTTPCCATracklet.h"
+
+#if !defined(HLTCA_GPUCODE)  
+void AliHLTTPCCATracklet::Dummy() const 
+{
+}
+#endif
index 1b6baed..7aeb994 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACKLET_H
 #define ALIHLTTPCCATRACKLET_H
@@ -22,6 +24,7 @@ class AliHLTTPCCATracklet
 
 #if !defined(HLTCA_GPUCODE)
   AliHLTTPCCATracklet() : fStartHitID(0), fNHits(0), fFirstRow(0), fLastRow(0), fParam(){};
+  void Dummy() const ;
   ~AliHLTTPCCATracklet(){}
 #endif
 
@@ -30,7 +33,7 @@ class AliHLTTPCCATracklet
   GPUhd() Int_t  FirstRow()             const { return fFirstRow;   }
   GPUhd() Int_t  LastRow()              const { return fLastRow;    }
   GPUhd() const AliHLTTPCCATrackParam &Param() const { return fParam;      }
-  GPUhd() Int_t  RowHits(Int_t i)   const { return fRowHits[i];    }
+  GPUhd() Int_t  RowHit(Int_t i)   const { return fRowHits[i];    }
 
   GPUhd() void SetStartHitID( Int_t v )           { fStartHitID = v; }
   GPUhd() void SetNHits( Int_t v )               {  fNHits = v;      }
index fc6ff78..b7ccb9c 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id: AliHLTTPCCATrackletConstructor.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCATrackParam.h"
 #include "AliHLTTPCCATrackParam.h"
@@ -23,6 +25,7 @@
 #include "AliHLTTPCCAHitArea.h"
 #include "AliHLTTPCCAMath.h"
 #include "AliHLTTPCCADef.h"
+#include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCATrackletConstructor.h"
 //#include "AliHLTTPCCAPerformance.h"
 //#include "TH1D.h"
@@ -73,21 +76,21 @@ GPUd() void AliHLTTPCCATrackletConstructor::Step1
   if( !r.fGo ) return;
   
   r.fStage = 0;
-  Int_t header = 5+ sizeof(AliHLTTPCCATrackParam)/sizeof(int);
-  r.fTrackStoreOffset = ( header + 160 )*r.fItr;  
-  r.fHitStoreOffset = r.fTrackStoreOffset + header;
-  
-  Int_t *hitstore = ((Int_t*) tracker.Tracklets()) +r.fHitStoreOffset;
   
+  AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
+
   UInt_t kThread = iThread %32;//& 00000020;
-  if( SAVE() ) for( Int_t i=0; i<160; i++ ) hitstore[i] = -1;
+  if( SAVE() ) for( Int_t i=0; i<160; i++ ) tracklet.SetRowHit(i,-1);
     
   Int_t id = tracker.TrackletStartHits()[r.fItr];
-  r.fFirstRow = AliHLTTPCCATracker::ID2IRow(id);
+  r.fStartRow = AliHLTTPCCATracker::ID2IRow(id);
+  r.fEndRow = r.fStartRow;
+  r.fFirstRow = r.fStartRow;
+  r.fLastRow = r.fFirstRow;  
   r.fCurrIH =  AliHLTTPCCATracker::ID2IHit(id);
   
-  CAMath::atomicMin( &s.fMinStartRow32[kThread], r.fFirstRow);    
-  CAMath::atomicMax( &s.fMaxStartRow32[kThread], r.fFirstRow);    
+  CAMath::AtomicMin( &s.fMinStartRow32[kThread], r.fStartRow);    
+  CAMath::AtomicMax( &s.fMaxStartRow32[kThread], r.fStartRow);    
   tParam.SetSinPhi(0);
   tParam.SetDzDs(0);
   tParam.SetKappa(0);
@@ -110,7 +113,6 @@ GPUd() void AliHLTTPCCATrackletConstructor::Step1
   tParam.SetCov(13,0); 
   tParam.SetCov(14,1);     
 
-  r.fLastRow = r.fFirstRow;  
 }
 
 GPUd() void AliHLTTPCCATrackletConstructor::Step2 
@@ -120,7 +122,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::Step2
   // reconstruction of tracklets, step 2
   
   if( iThread==0 ){
-    //CAMath::atomicMinGPU(&s.fMinRow, s.fMinRow32[iThread]);
+    //CAMath::AtomicMinGPU(&s.fMinRow, s.fMinRow32[iThread]);
     Int_t minStartRow = 158;
     Int_t maxStartRow = 0;
     Int_t n = (nThreads>32 ) ?32 :nThreads;
@@ -168,6 +170,18 @@ GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
       r.fNHits = 0;
       break;
     }
+
+    if(0){ // kappa => 1/pt
+      const Double_t kCLight = 0.000299792458;  
+      Double_t bz = tracker.Param().Bz();
+      Double_t c = 1.e4;
+      if( CAMath::Abs(bz)>1.e-4 ) c = 1./(bz*kCLight);
+      Double_t pti = tParam.Kappa()*c;
+      if( 1./.5 < CAMath::Abs(pti) ){ //SG!!!
+       r.fNHits = 0;
+       break;
+      }
+    }
     
     {  
       Bool_t ok=1;
@@ -187,9 +201,9 @@ GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
  
   if( !SAVE() ) return;
     
-  Int_t *store = ((Int_t*)tracker.Tracklets()) + r.fTrackStoreOffset;
-  Int_t *hitstore = ((Int_t*)tracker.Tracklets()) +r.fHitStoreOffset;
-  store[0] = r.fNHits;
+  AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
+
+  tracklet.SetNHits(r.fNHits);
   
   if( r.fNHits>0 ){
 #ifdef DRAW
@@ -200,16 +214,16 @@ GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
       }
     }
 #endif
-    store[3] = r.fFirstRow;
-    store[4] = r.fLastRow;
     if( CAMath::Abs(tParam.Par()[4])<1.e-8 ) tParam.SetPar( 4, 1.e-8);
-    *((AliHLTTPCCATrackParam*)(store+5)) = tParam;
+    tracklet.SetFirstRow( r.fFirstRow );
+    tracklet.SetLastRow( r.fLastRow );
+    tracklet.SetParam( tParam );
     Int_t w = (r.fNHits<<16)+r.fItr;
     for( Int_t iRow=0; iRow<160; iRow++ ){
-      Int_t ih = hitstore[iRow];
+      Int_t ih = tracklet.RowHit( iRow );
       if( ih>=0 ){
        Int_t ihTot = tracker.Row(iRow).FirstHit() + ih;
-       CAMath::atomicMax( tracker.HitWeights() + ihTot, w );
+       CAMath::AtomicMax( tracker.HitWeights() + ihTot, w );
       }
     }
   }  
@@ -224,14 +238,14 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
   //std::cout<<"Update tracklet: "<<r.fItr<<" "<<r.fGo<<" "<<r.fStage<<" "<<iRow<<std::endl;
   Bool_t drawSearch = 0;//r.fItr==356;
   Bool_t drawFit = 0;//r.fItr==356;
-  Bool_t drawFitted = drawFit ;//|| 1;//r.fItr==16;
+  Bool_t drawFitted = 0;//drawFit ;//|| 1;//r.fItr==16;
 
   if( !r.fGo ) return;
 
   const Int_t kMaxRowGap = 4;  
   
-  Int_t *hitstore = ((Int_t*) tracker.Tracklets()) +r.fHitStoreOffset;
-  
+  AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[r.fItr];
+
   const AliHLTTPCCARow &row = tracker.Row(iRow);
   
   Float_t y0 = row.Grid().YMin();
@@ -244,8 +258,10 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
   if( r.fStage == 0 ){ // fitting part     
     do{
       
-      if( iRow<r.fFirstRow || r.fCurrIH<0  ) break;
-
+      if( iRow<r.fStartRow || r.fCurrIH<0  ) break;
+      
+      if( (iRow-r.fStartRow)%2!=0 ) break; // SG!!! - jump over the row
       uint4 *tmpint4 = s.fData[r.fCurrentData];   
       ushort2 hh = reinterpret_cast<ushort2*>(tmpint4)[r.fCurrIH];
       
@@ -257,7 +273,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
       Float_t z = z0 + hh.y*stepZ;
       if( drawFit ) std::cout<<" fit tracklet: new hit "<<oldIH<<", xyz="<<x<<" "<<y<<" "<<z<<std::endl;
     
-      if( iRow==r.fFirstRow ){
+      if( iRow==r.fStartRow ){
        tParam.SetX( x );
        tParam.SetY( y );
        tParam.SetZ( z );
@@ -276,7 +292,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
        r.fLastZ = z;
 
        Float_t ri = 1./CAMath::Sqrt(dx*dx+dy*dy);
-       if( iRow==r.fFirstRow+1 ){
+       if( iRow==r.fStartRow+1 ){
          tParam.SetSinPhi( dy*ri );
          tParam.SetCosPhi( dx*ri );
          tParam.SetDzDs( dz*ri );
@@ -306,7 +322,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
          //#ifdef DRAW
          if( drawFit ) std::cout<<" tracklet "<<r.fItr<<", row "<<iRow<<": can not transport!!"<<std::endl;
 //#endif
-         if( SAVE() ) hitstore[iRow] = -1; 
+         if( SAVE() ) tracklet.SetRowHit( iRow, -1 );
          break; 
        }
                
@@ -327,11 +343,11 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
          //#ifdef DRAW
          if( drawFit ) std::cout<<" tracklet "<<r.fItr<<", row "<<iRow<<": can not filter!!"<<std::endl;
          //#endif
-         if( SAVE() ) hitstore[iRow] = -1; 
+         if( SAVE() ) tracklet.SetRowHit( iRow, -1 );
          break; 
        }          
       }
-      if( SAVE() ) hitstore[iRow] = oldIH; 
+      if( SAVE() ) tracklet.SetRowHit( iRow, oldIH );
       if( drawFit ){
        //#ifdef DRAW
        std::cout<<"fit tracklet after filter "<<r.fItr<<", row "<<iRow<<std::endl;
@@ -344,6 +360,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
       }
       r.fNHits++;
       r.fLastRow = iRow;
+      r.fEndRow = iRow;
       break;
     } while(0);
     
@@ -353,7 +370,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
       //#endif
       r.fStage = 1;
       //AliHLTTPCCAPerformance::Instance().HNHitsPerSeed()->Fill(r.fNHits);
-      if( r.fNHits<5 ){ r.fNHits=0; r.fGo = 0;}//SG!!!
+      if( r.fNHits<3 ){ r.fNHits=0; r.fGo = 0;}//SG!!!
       if( CAMath::Abs(tParam.SinPhi())>.999 ){
        //#ifdef DRAW
        if( drawFitted ) std::cout<<" fitted tracklet  error: sinPhi="<<tParam.SinPhi()<<std::endl;
@@ -381,7 +398,10 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
          std::cout<<"search tracklet "<<r.fItr<<" row "<<iRow<<" miss="<<r.fNMissed<<" go="<<r.fGo<<" stage="<<r.fStage<<std::endl;
          //#endif
        }
-       if( r.fStage == 2 && iRow>=r.fFirstRow ) break; 
+
+       if( r.fStage == 2 && ( (iRow>=r.fEndRow) || 
+                              (iRow>=r.fStartRow && (iRow-r.fStartRow)%2==0 ) 
+                              ) ) break; 
        if( r.fNMissed>kMaxRowGap  ){     
          break;
        }
@@ -529,23 +549,19 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
        Float_t dy = y - fY;
        Float_t dz = z - fZ;      
        
-       //const Float_t kFactor = tracker.Param().HitPickUpFactor()*tracker.Param().HitPickUpFactor()*3.5*3.5;
-       const Float_t kFactor = 3.5*3.5;//SG!!!
+       const Float_t kFactor = tracker.Param().HitPickUpFactor()*tracker.Param().HitPickUpFactor()*3.5*3.5;    
        Float_t sy2 = kFactor*( tParam.GetErr2Y() +  err2Y );
        Float_t sz2 = kFactor*( tParam.GetErr2Z() +  err2Z );
-       if( sy2 > 2. ) sy2 = 2.;//SG
+       if( sy2 > 2. ) sy2 = 2.;
        if( sz2 > 2. ) sz2 = 2.;
-       if( iRow==63 || iRow==64 || iRow==65 ){
-         //if( sy2 < 4. ) sy2 = 4.; //SG!!!
-         //if( sz2 < 4. ) sz2 = 4.;
-       }
+
        if( drawSearch ){
          //#ifdef DRAW
          std::cout<<"dy,sy= "<< dy <<" "<<CAMath::Sqrt(sy2)<<", dz,sz= "<< dz<<" "<<CAMath::Sqrt(sz2)<<std::endl;
          std::cout<<"dy,dz= "<< dy <<" "<<dz<<", sy,sz= "<<CAMath::Sqrt(sy2)<<" "<<CAMath::Sqrt(sz2)<<", sy,sz= "<<CAMath::Sqrt(kFactor*( tParam.GetErr2Y() +  err2Y ))<<" "<<CAMath::Sqrt(kFactor*( tParam.GetErr2Z() +  err2Z ))<<std::endl;
          //#endif
        }
-       if( CAMath::fmul_rz(dy,dy)>sy2 || CAMath::fmul_rz(dz,dz)>sz2  ){
+       if( CAMath::FMulRZ(dy,dy)>sy2 || CAMath::FMulRZ(dz,dz)>sz2  ){
          if( drawSearch ){
            //#ifdef DRAW
 
@@ -568,7 +584,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
          }
          break;
        }
-       if( SAVE() ) hitstore[ iRow ] = best;
+       if( SAVE() ) tracklet.SetRowHit( iRow, best );
        if( drawSearch ){
          //#ifdef DRAW
          std::cout<<"tracklet "<<r.fItr<<" after filter at row "<<iRow<<" : "<<std::endl;
@@ -625,7 +641,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::Thread
       r.fNMissed = 0;           
       r.fStage = 2;
       if( r.fGo ){
-       const AliHLTTPCCARow &row = tracker.Row(r.fFirstRow);           
+       const AliHLTTPCCARow &row = tracker.Row(r.fEndRow);     
        Float_t x = row.X();
        if( !tParam.TransportToX( x, .999 ) ) r.fGo = 0;
       }
index fd39941..29a7a89 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACKLETCONSTRUCTOR_H
 #define ALIHLTTPCCATRACKLETCONSTRUCTOR_H
@@ -33,7 +35,7 @@ class AliHLTTPCCATrackletConstructor
       AliHLTTPCCASharedMemory& operator=(const AliHLTTPCCASharedMemory& /*dummy*/){ return *this; }
 #endif
     protected:
-      uint4 fData[2][(500+500+500)/4]; // temp memory
+      uint4 fData[2][(5000+5000+5000)/4]; // temp memory
       Int_t fItr0; // start track index
       Int_t fItr1; // end track index
       Int_t fNRows; // n rows
@@ -50,11 +52,11 @@ class AliHLTTPCCATrackletConstructor
      public:
 #if !defined(HLTCA_GPUCODE)
       AliHLTTPCCAThreadMemory()
-       : fItr(0), fFirstRow(0), fLastRow(0), fCurrIH(0), fIsMemThread(0), fGo(0), fSave(0), fCurrentData(0), fStage(0), fNHits(0), fNMissed(0), fTrackStoreOffset(0), fHitStoreOffset(0), fLastY(0), fLastZ(0) 
+       : fItr(0), fFirstRow(0), fLastRow(0), fStartRow(0), fEndRow(0), fCurrIH(0), fIsMemThread(0), fGo(0), fSave(0), fCurrentData(0), fStage(0), fNHits(0), fNMissed(0), fLastY(0), fLastZ(0) 
       {}
 
       AliHLTTPCCAThreadMemory( const AliHLTTPCCAThreadMemory& /*dummy*/) 
-       : fItr(0), fFirstRow(0), fLastRow(0), fCurrIH(0), fIsMemThread(0), fGo(0), fSave(0), fCurrentData(0), fStage(0), fNHits(0), fNMissed(0), fTrackStoreOffset(0), fHitStoreOffset(0), fLastY(0), fLastZ(0)
+       : fItr(0), fFirstRow(0), fLastRow(0), fStartRow(0), fEndRow(0), fCurrIH(0), fIsMemThread(0), fGo(0), fSave(0), fCurrentData(0), fStage(0), fNHits(0), fNMissed(0), fLastY(0), fLastZ(0)
       {}
       AliHLTTPCCAThreadMemory& operator=(const AliHLTTPCCAThreadMemory& /*dummy*/){ return *this; }
 #endif
@@ -62,6 +64,8 @@ class AliHLTTPCCATrackletConstructor
       Int_t fItr; // track index
       Int_t fFirstRow;  // first row index
       Int_t fLastRow; // last row index
+      Int_t fStartRow;  // first row index
+      Int_t fEndRow;  // first row index
       Int_t fCurrIH; // indef of the current hit
       Bool_t fIsMemThread; // is the thread used for memory taken
       Bool_t fGo; // do fit/searching flag
@@ -70,8 +74,6 @@ class AliHLTTPCCATrackletConstructor
       Int_t fStage; // reco stage
       Int_t fNHits; // n track hits
       Int_t fNMissed; // n missed hits during search
-      Int_t fTrackStoreOffset; // offset in the global array
-      Int_t fHitStoreOffset;   // offset in the global array
       Float_t fLastY; // Y of the last fitted cluster
       Float_t fLastZ; // Z of the last fitted cluster
     };
index 38876bb..d002f10 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id: AliHLTTPCCATrackletSelector.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
+
 #include "AliHLTTPCCATrackletSelector.h"
 #include "AliHLTTPCCATrack.h"
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCATrackParam.h"
+#include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAMath.h"
 
 GPUd() void AliHLTTPCCATrackletSelector::Thread
@@ -32,8 +35,8 @@ GPUd() void AliHLTTPCCATrackletSelector::Thread
     {
       if( iThread==0 ){
        if(iBlock==0){
-         CAMath::atomicExch(tracker.NTracks(),0);
-         CAMath::atomicExch(tracker.NTrackHits(),0);
+         CAMath::AtomicExch(tracker.NTracks(),0);
+         CAMath::AtomicExch(tracker.NTrackHits(),0);
        }
        s.fNTracklets = *tracker.NTracklets();
        s.fNThreadsTotal = nThreads*nBlocks;
@@ -46,38 +49,60 @@ GPUd() void AliHLTTPCCATrackletSelector::Thread
       Int_t trackHits[160];
        
       for( Int_t itr= s.fItr0 + iThread; itr<s.fNTracklets; itr+=s.fNThreadsTotal ){                   
-       Int_t *t = ((Int_t*)tracker.Tracklets()) + itr*(5+ sizeof(AliHLTTPCCATrackParam)/4 + 160 );     
-       Int_t tNHits = *t;
+
+       AliHLTTPCCATracklet &tracklet = tracker.Tracklets()[itr];
+
+       Int_t tNHits = tracklet.NHits();
        if( tNHits<=0 ) continue;
 
        const Int_t kMaxRowGap = 4;
-       Int_t firstRow = t[3];
-       Int_t lastRow = t[4];
+       const Float_t kMaxShared = .1;
+
+       Int_t firstRow = tracklet.FirstRow();
+       Int_t lastRow = tracklet.LastRow();
 
        tout.SetNHits( 0 );
-       Int_t *hitstore = t + 5+ sizeof(AliHLTTPCCATrackParam)/4 ;    
-       Int_t w = (tNHits<<16)+itr;     
+       Int_t kind = 0;
+       if(0){ // kappa => 1/pt
+         const AliHLTTPCCATrackParam &tParam = tracklet.Param();
+         const Double_t kCLight = 0.000299792458;  
+         Double_t bz = tracker.Param().Bz();
+         Double_t c = 1.e4;
+         if( CAMath::Abs(bz)>1.e-4 ) c = 1./(bz*kCLight);
+         Double_t pti = tParam.Kappa()*c;
+         if( tNHits>=10 && 1./.5 >= CAMath::Abs(pti) ){ //SG!!!
+           kind = 1;
+         }    
+       }
+
+       Int_t w = (kind<<29) + (tNHits<<16)+itr;
+
+       //Int_t w = (tNHits<<16)+itr;   
        //Int_t nRows = tracker.Param().NRows();
        Int_t gap = 0;
-
+       Int_t nShared = 0;
        //std::cout<<" store tracklet: "<<firstRow<<" "<<lastRow<<std::endl;
        for( Int_t irow=firstRow; irow<=lastRow; irow++ ){
          gap++;
-         Int_t ih = hitstore[irow];
+         Int_t ih = tracklet.RowHit(irow);
          if( ih>=0 ){
            Int_t ihTot = tracker.Row(irow).FirstHit()+ih;
-           if( tracker.HitWeights()[ihTot] <= w ){
+           Bool_t own = ( tracker.HitWeights()[ihTot] <= w );
+           Bool_t sharedOK = ( (tout.NHits()<0) || (nShared<tout.NHits()*kMaxShared) );
+           if( own || sharedOK ){//SG!!!
              gap = 0;
              Int_t th = AliHLTTPCCATracker::IRowIHit2ID(irow,ih);
              trackHits[tout.NHits()] = th;
              tout.SetNHits( tout.NHits() + 1 );
+             if( !own ) nShared++;
            }
          }
+         
          if( gap>kMaxRowGap || irow==lastRow ){ // store 
            if( tout.NHits()>=10 ){ //SG!!!
-             Int_t itrout = CAMath::atomicAdd(tracker.NTracks(),1);
-             tout.SetFirstHitID( CAMath::atomicAdd( tracker.NTrackHits(), tout.NHits() ));
-             tout.SetParam( *( (AliHLTTPCCATrackParam*)( t+5) ));
+             Int_t itrout = CAMath::AtomicAdd(tracker.NTracks(),1);
+             tout.SetFirstHitID( CAMath::AtomicAdd( tracker.NTrackHits(), tout.NHits() ));
+             tout.SetParam( tracklet.Param() );
              tout.SetAlive( 1 );
              tracker.Tracks()[itrout] = tout;
              for( Int_t jh=0; jh<tout.NHits(); jh++ ){
@@ -86,6 +111,7 @@ GPUd() void AliHLTTPCCATrackletSelector::Thread
            }
            tout.SetNHits( 0 ); 
            gap = 0;
+           nShared = 0;
          }
        }
       }
index 7444162..833e3e2 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCATRACKLETSELECTOR_H
 #define ALIHLTTPCCATRACKLETSELECTOR_H
index 87bc190..7301253 100644 (file)
@@ -1,5 +1,5 @@
 // @(#) $Id: AliHLTTPCCAUsedHitsInitialiser.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliHLTTPCCAUsedHitsInitialiser.h"
index 6de3721..1b213ec 100644 (file)
@@ -1,8 +1,10 @@
 //-*- Mode: C++ -*-
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALIHLTTPCCAUSEDHITSINITIALISER_H
 #define ALIHLTTPCCAUSEDHITSINITIALISER_H
index 7ffdd8b..9118004 100644 (file)
@@ -1,5 +1,5 @@
 // $Id$
-//***************************************************************************
+// **************************************************************************
 // This file is property of and copyright by the ALICE HLT Project          * 
 // ALICE Experiment at CERN, All rights reserved.                           *
 //                                                                          *
@@ -14,6 +14,7 @@
 // appear in the supporting documentation. The authors make no claims       *
 // about the suitability of this software for any purpose. It is            *
 // provided "as is" without express or implied warranty.                    *
+//                                                                          *
 //***************************************************************************
 
 #include "AliTPCtrackerCA.h"
 ClassImp(AliTPCtrackerCA)
 
 AliTPCtrackerCA::AliTPCtrackerCA()
-  :AliTracker(),fParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+  :AliTracker(),fkParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
 {
   //* default constructor
 }
 
 AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCtrackerCA &):
-  AliTracker(),fParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+  AliTracker(),fkParam(0), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
 {
   //* dummy
 }
 
-AliTPCtrackerCA & AliTPCtrackerCA::operator=(const AliTPCtrackerCA& )
+const AliTPCtrackerCA & AliTPCtrackerCA::operator=(const AliTPCtrackerCA& ) const
 {
   //* dummy 
   return *this;
@@ -83,7 +84,7 @@ AliTPCtrackerCA::~AliTPCtrackerCA()
 //#include "AliHLTTPCCADisplay.h"
 
 AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par): 
-  AliTracker(),fParam(par), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
+  AliTracker(),fkParam(par), fClusters(0), fNClusters(0), fHLTTracker(0),fDoHLTPerformance(0),fDoHLTPerformanceClusters(0),fStatNEvents(0)
 {
   //* constructor
  
@@ -91,7 +92,7 @@ AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par):
   fDoHLTPerformanceClusters = 0;
 
   fHLTTracker = new AliHLTTPCCAGBTracker;
-  fHLTTracker->SetNSlices( fParam->GetNSector()/2 );
+  fHLTTracker->SetNSlices( fkParam->GetNSector()/2 );
 
   if( fDoHLTPerformance ){
     AliHLTTPCCAPerformance::Instance().SetTracker( fHLTTracker );
@@ -101,10 +102,10 @@ AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par):
   
     Float_t bz = AliTracker::GetBz();
 
-    Float_t inRmin = fParam->GetInnerRadiusLow();
-    //Float_t inRmax = fParam->GetInnerRadiusUp();
-    //Float_t outRmin = fParam->GetOuterRadiusLow(); 
-    Float_t outRmax = fParam->GetOuterRadiusUp();
+    Float_t inRmin = fkParam->GetInnerRadiusLow();
+    //Float_t inRmax = fkParam->GetInnerRadiusUp();
+    //Float_t outRmin = fkParam->GetOuterRadiusLow(); 
+    Float_t outRmax = fkParam->GetOuterRadiusUp();
     Float_t plusZmin = 0.0529937; 
     Float_t plusZmax = 249.778; 
     Float_t minusZmin = -249.645; 
@@ -122,18 +123,18 @@ AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par):
     Float_t padPitch = 0.4;
     Float_t sigmaZ = 0.228808;
 
-    Int_t nRows = fParam->GetNRowLow()+fParam->GetNRowUp();
+    Int_t nRows = fkParam->GetNRowLow()+fkParam->GetNRowUp();
     Float_t rowX[200];
-    for( Int_t irow=0; irow<fParam->GetNRowLow(); irow++){
-      rowX[irow] = fParam->GetPadRowRadiiLow(irow);
+    for( Int_t irow=0; irow<fkParam->GetNRowLow(); irow++){
+      rowX[irow] = fkParam->GetPadRowRadiiLow(irow);
     }     
-    for( Int_t irow=0; irow<fParam->GetNRowUp(); irow++){
-      rowX[fParam->GetNRowLow()+irow] = fParam->GetPadRowRadiiUp(irow);
+    for( Int_t irow=0; irow<fkParam->GetNRowUp(); irow++){
+      rowX[fkParam->GetNRowLow()+irow] = fkParam->GetPadRowRadiiUp(irow);
     }
     AliHLTTPCCAParam param;
     param.Initialize( iSlice, nRows, rowX, alpha, dalpha,
                      inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, bz );
-    param.SetHitPickUpFactor( 3. );
+    param.SetHitPickUpFactor( 1. );
     param.SetMaxTrackMatchDRow( 5 );
     param.SetTrackConnectionFactor( 3.5 );
 
@@ -162,7 +163,7 @@ Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
   fHLTTracker->StartEvent();
   if( fDoHLTPerformance ) AliHLTTPCCAPerformance::Instance().StartEvent();
 
-  if( !fParam ) return 1;
+  if( !fkParam ) return 1;
 
   // load mc tracks
   while( fDoHLTPerformance ){
@@ -265,7 +266,7 @@ Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
   for (Int_t i=0; i<nEnt; i++) {
     br->GetEntry(i);
     Int_t sec,row;
-    fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+    fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
     fNClusters += clrow->GetArray()->GetEntriesFast();
   }
 
@@ -276,9 +277,9 @@ Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
   for (Int_t i=0; i<nEnt; i++) {
     br->GetEntry(i);
     Int_t sec,row;
-    fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+    fkParam->AdjustSectorRow(clrow->GetID(),sec,row);
     Int_t nClu = clrow->GetArray()->GetEntriesFast();
-    Float_t x = fParam->GetPadRowRadii(sec,row);
+    Float_t x = fkParam->GetPadRowRadii(sec,row);
     for (Int_t icl=0; icl<nClu; icl++){
       Int_t lab0 = -1;
       Int_t lab1 = -1;
@@ -306,7 +307,7 @@ Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
       cluster->SetY(xx[1]);
       cluster->SetZ(xx[2]);
 
-      TGeoHMatrix  *mat = fParam->GetClusterMatrix(cluster->GetDetector());
+      TGeoHMatrix  *mat = fkParam->GetClusterMatrix(cluster->GetDetector());
       Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
       Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
       if (mat) mat->LocalToMaster(pos,posC);
@@ -322,7 +323,7 @@ Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
 
       if( sec>=36 ){
        sec = sec - 36;
-       row = row + fParam->GetNRowLow(); 
+       row = row + fkParam->GetNRowLow(); 
       }
       
       Int_t index = ind++;
@@ -409,13 +410,18 @@ Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
       tTPC.SetdEdx( tCA.DeDx() );
       if( TMath::Abs(tTPC.GetSigned1Pt())>1./0.02 ) continue;
       Int_t nhits = tCA.NHits();
-      if( nhits>199 ) nhits=199;// kMaxRow ) nhits = kMaxRow;
+      Int_t firstHit=0;
+      if( nhits>160 ){
+       firstHit = nhits-160;
+       nhits=160;
+      }
+
       tTPC.SetNumberOfClusters(nhits);
  
       Float_t alpha = tCA.Alpha();      
       AliHLTTPCCATrackParam t0 = par;
       for( Int_t ih=0; ih<nhits; ih++ ){
-       Int_t index = fHLTTracker->TrackHits()[tCA.FirstHitRef()+ih];
+       Int_t index = fHLTTracker->TrackHits()[tCA.FirstHitRef()+firstHit+ih];
        AliHLTTPCCAGBHit &h = fHLTTracker->Hits()[index];
        Int_t extIndex = h.ID();
        tTPC.SetClusterIndex(ih, extIndex);
@@ -473,44 +479,87 @@ Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
 
 Int_t AliTPCtrackerCA::RefitInward (AliESDEvent *event)
 { 
-  //* back propagation of ESD tracks (not fully functional)
+  //* forward propagation of ESD tracks 
 
   Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
-  Float_t xTPC = fParam->GetInnerRadiusLow();
-  Float_t dAlpha = fParam->GetInnerAngle()/180.*TMath::Pi();
+  Float_t xTPC = fkParam->GetInnerRadiusLow();
+  Float_t dAlpha = fkParam->GetInnerAngle()/180.*TMath::Pi();
   Float_t yMax = xTPC*TMath::Tan(dAlpha/2.); 
 
   Int_t nentr=event->GetNumberOfTracks();
      
-  for (Int_t i=0; i<nentr; i++) {
-    AliESDtrack *esd=event->GetTrack(i);
+  for (Int_t itr=0; itr<nentr; itr++) {
+    AliESDtrack *esd=event->GetTrack(itr);
     ULong_t status=esd->GetStatus(); 
     if (!(status&AliESDtrack::kTPCin)) continue;
     AliHLTTPCCATrackParam t0;
     AliHLTTPCCATrackConvertor::SetExtParam(t0,*esd, bz );
+    AliHLTTPCCATrackParam t = t0;
     Float_t alpha = esd->GetAlpha();
-    if( t0.TransportToXWithMaterial( xTPC, bz) ){
-      if (t0.GetY() > yMax) {
-       if (t0.Rotate(dAlpha)){ 
-         alpha+=dAlpha;  
-         t0.TransportToXWithMaterial( xTPC, bz);
-       }
-      } else if (t0.GetY() <-yMax) {
-       if (t0.Rotate(-dAlpha)){
-         alpha+=-dAlpha;
-         t0.TransportToXWithMaterial( xTPC, bz);
-       }
-      }    
+    Float_t dEdX=0;    
+    Int_t hits[1000];
+    Int_t nHits = esd->GetTPCclusters(hits);
+    
+    // convert clluster indices to AliHLTTPCCAGBHit indices
+
+    for( Int_t i=0; i<nHits; i++ ) hits[i] = fHLTTracker->Ext2IntHitID(hits[i]);
+   
+    Bool_t ok = fHLTTracker->FitTrack( t, t0, alpha, hits, nHits, dEdX, 0 );
+    if( ok &&  nHits>15){
+      if( t.TransportToXWithMaterial( xTPC, bz) ){
+       if (t.GetY() > yMax) {
+         if (t.Rotate(dAlpha)){ 
+           alpha+=dAlpha;  
+           t.TransportToXWithMaterial( xTPC, bz);
+         }
+       } else if (t.GetY() <-yMax) {
+         if (t.Rotate(-dAlpha)){
+           alpha+=-dAlpha;
+           t.TransportToXWithMaterial( xTPC, bz);
+         }
+       }    
+      }
+    
+      AliTPCtrack tt(*esd);
+      AliHLTTPCCATrackConvertor::GetExtParam(t,tt,alpha,bz);
+      esd->UpdateTrackParams( &tt,AliESDtrack::kTPCrefit); 
     }
-    AliTPCtrack tt(*esd);
-    AliHLTTPCCATrackConvertor::GetExtParam(t0,tt,alpha,bz);
-    esd->UpdateTrackParams( &tt,AliESDtrack::kTPCrefit); 
   }
   return 0;
 }
 
-Int_t AliTPCtrackerCA::PropagateBack(AliESDEvent *)
+Int_t AliTPCtrackerCA::PropagateBack(AliESDEvent *event)
 { 
-  //* not implemented yet
-  return 0; 
+
+  //* backward propagation of ESD tracks 
+
+  Float_t bz = fHLTTracker->Slices()[0].Param().Bz();
+  Int_t nentr=event->GetNumberOfTracks();
+     
+  for (Int_t itr=0; itr<nentr; itr++) {
+
+    AliESDtrack *esd=event->GetTrack(itr);
+    ULong_t status=esd->GetStatus(); 
+    if (!(status&AliESDtrack::kTPCin)) continue;
+
+    AliHLTTPCCATrackParam t0;
+    AliHLTTPCCATrackConvertor::SetExtParam(t0,*esd, bz );
+    AliHLTTPCCATrackParam t = t0;
+    Float_t alpha = esd->GetAlpha();
+    Float_t dEdX=0;    
+    Int_t hits[1000];
+    Int_t nHits = esd->GetTPCclusters(hits);
+    
+    // convert clluster indices to AliHLTTPCCAGBHit indices
+
+    for( Int_t i=0; i<nHits; i++ ) hits[i] = fHLTTracker->Ext2IntHitID(hits[i]);
+   
+    Bool_t ok = fHLTTracker->FitTrack( t, t0, alpha, hits, nHits, dEdX, 1 );
+    if( ok &&  nHits>15){
+      AliTPCtrack tt(*esd);
+      AliHLTTPCCATrackConvertor::GetExtParam(t,tt,alpha,bz);
+      esd->UpdateTrackParams( &tt,AliESDtrack::kTPCout); 
+    }
+  }
+  return 0;
 }
index 871bb4e..85b6aef 100644 (file)
@@ -1,9 +1,11 @@
 //-*- Mode: C++ -*-
 // $Id$
-
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//* See cxx source for full Copyright notice                               *
+// ************************************************************************
+// This file is property of and copyright by the ALICE HLT Project        * 
+// ALICE Experiment at CERN, All rights reserved.                         *
+// See cxx source for full Copyright notice                               *
+//                                                                        *
+//*************************************************************************
 
 #ifndef ALITPCTRACKERCA_H
 #define ALITPCTRACKERCA_H
@@ -30,7 +32,7 @@ public:
   AliTPCtrackerCA();
   AliTPCtrackerCA(const AliTPCParam *par); 
   AliTPCtrackerCA(const AliTPCtrackerCA &);
-  AliTPCtrackerCA & operator=(const AliTPCtrackerCA& );
+  const AliTPCtrackerCA & operator=(const AliTPCtrackerCA& ) const;
   virtual ~AliTPCtrackerCA();
   //
   Int_t RefitInward (AliESDEvent *event);
@@ -46,7 +48,7 @@ public:
   //
  protected:
 
-  const AliTPCParam *fParam;  //* TPC parameters
+  const AliTPCParam *fkParam;  //* TPC parameters
   AliTPCclusterMI *fClusters; //* array of clusters
   Int_t fNClusters;           //* N clusters
   AliHLTTPCCAGBTracker *fHLTTracker; //* pointer to the HLT tracker