A tracker update: significant clean up, reorganise of the data structures, p-p track...
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Jan 2009 23:02:02 +0000 (23:02 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Jan 2009 23:02:02 +0000 (23:02 +0000)
42 files changed:
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/AliHLTTPCCAGBTracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGrid.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAHitArea.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAHitArea.h
HLT/TPCLib/tracking-ca/AliHLTTPCCALinksWriter.cxx [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCALinksWriter.h [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMath.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursCleaner.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder1.cxx [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder1.h [deleted file]
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.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAStartHitsFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackPar.cxx [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackPar.h [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam1.cxx [deleted file]
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam1.h [deleted file]
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/AliHLTTPCCATrackletConstructor.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAUsedHitsInitialiser.cxx
HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx

index 4af2626..2c8ea70 100644 (file)
@@ -51,9 +51,9 @@ class AliHLT3DTrackParam :public TObject
   Int_t    GetNDF()    const { return fNDF;   }
   Int_t    GetCharge() const { return fSignQ; }
   
-  Double_t GetParameter ( int i ) const { return fParam[i]; }
-  Double_t GetCovariance( int i ) const { return fCov[i]; }
-  Double_t GetCovariance( int i, int j ) const { return fCov[( j<=i ) ? i*(i+1)/2+j :j*(j+1)/2+i]; }
+  Double_t GetParameter ( Int_t i ) const { return fParam[i]; }
+  Double_t GetCovariance( Int_t i ) const { return fCov[i]; }
+  Double_t GetCovariance( Int_t i, Int_t j ) const { return fCov[( j<=i ) ? i*(i+1)/2+j :j*(j+1)/2+i]; }
 
   //* Accessors with calculations( &value, &estimated sigma )
   //* error flag returned (0 means no error during calculations) 
index 23010b9..4a82e6e 100644 (file)
@@ -98,8 +98,6 @@ typedef float          Size_t;      //Attribute size (float)
 #define GPUsync() __syncthreads()
 
 __constant__ float4 cTracker[30000/sizeof(float4)];
-texture<uchar1> texGrid;               
-texture<float2> texHits;       
 
 #else
 
index f12d509..f3e47da 100644 (file)
 //***************************************************************************
 
 
-//#include "AliHLTTPCCADisplay.h"
+#include "AliHLTTPCCADisplay.h"
 
-#ifdef XXXX
 
-//#include "AliHLTTPCCATracker.h"
-//#include "AliHLTTPCCARow.h"
-//#include "AliHLTTPCCATrack.h"
+#include "AliHLTTPCCATracker.h"
+#include "AliHLTTPCCAGBTracker.h"
+#include "AliHLTTPCCARow.h"
+#include "AliHLTTPCCATrack.h"
+#include "AliHLTTPCCAGBTrack.h"
+#include "AliHLTTPCCAGBHit.h"
 
-//#include "TString.h"
-//#include "Riostream.h"
-//#include "TMath.h"
-//#include "TStyle.h"
-//#include "TCanvas.h"
+#include "TString.h"
+#include "Riostream.h"
+#include "TMath.h"
+#include "TStyle.h"
+#include "TCanvas.h"
 
 
 AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
@@ -39,8 +41,8 @@ AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
   return gAliHLTTPCCADisplay; 
 }
 
-AliHLTTPCCADisplay::AliHLTTPCCADisplay() : TObject(), fYX(0), fZX(0), fAsk(1), fSliceView(1), fSlice(0), 
-                                          fCos(1), fSin(0), fZMin(-250), fZMax(250),fSliceCos(1), fSliceSin(0),
+AliHLTTPCCADisplay::AliHLTTPCCADisplay() : fYX(0), fZX(0), fAsk(1), fSliceView(1), fSlice(0), 
+                                          fCos(1), fSin(0), fZMin(-250), fZMax(250),fYMin(-250), fYMax(250),fSliceCos(1), fSliceSin(0),
                                           fRInnerMin(83.65), fRInnerMax(133.3), fROuterMin(133.5), fROuterMax(247.7),
                                           fTPCZMin(-250.), fTPCZMax(250), fArc(), fLine(), fPLine(), fMarker(), fBox(), fCrown(), fLatex()
 {
@@ -49,8 +51,8 @@ AliHLTTPCCADisplay::AliHLTTPCCADisplay() : TObject(), fYX(0), fZX(0), fAsk(1), f
 
 
 AliHLTTPCCADisplay::AliHLTTPCCADisplay( const AliHLTTPCCADisplay& ) 
-  : TObject(), fYX(0), fZX(0), fAsk(1), fSliceView(1), fSlice(0), 
-    fCos(1), fSin(0), fZMin(-250), fZMax(250),fSliceCos(1), fSliceSin(0),
+  : fYX(0), fZX(0), fAsk(1), fSliceView(1), fSlice(0), 
+    fCos(1), fSin(0), fZMin(-250), fZMax(250), fYMin(-250), fYMax(250), fSliceCos(1), fSliceSin(0),
     fRInnerMin(83.65), fRInnerMax(133.3), fROuterMin(133.5), fROuterMax(247.7),
     fTPCZMin(-250.), fTPCZMax(250), fArc(), fLine(), fPLine(), fMarker(), fBox(), fCrown(), fLatex()
 {
@@ -126,6 +128,8 @@ void AliHLTTPCCADisplay::SetTPCView()
   fSin = 0;
   fZMin = fTPCZMin;
   fZMax = fTPCZMax;
+  fYMin = -fROuterMax;
+  fYMax = fROuterMax;
 }
 
 void AliHLTTPCCADisplay::SetCurrentSlice( AliHLTTPCCATracker *slice )
@@ -141,6 +145,8 @@ void AliHLTTPCCADisplay::SetCurrentSlice( AliHLTTPCCATracker *slice )
     ClearView();
     Double_t r0 = .5*(slice->Param().RMax()+slice->Param().RMin());
     Double_t dr = .5*(slice->Param().RMax()-slice->Param().RMin());
+    fYMin = -dr;
+    fYMax = dr;
     Double_t cx = 0;
     Double_t cy = r0;    
     Double_t cz = .5*(slice->Param().ZMax()+slice->Param().ZMin());
@@ -160,6 +166,75 @@ void AliHLTTPCCADisplay::SetCurrentSlice( AliHLTTPCCATracker *slice )
    }
 }
 
+void AliHLTTPCCADisplay::SetSliceTransform( Double_t alpha )
+{
+  fSliceCos = TMath::Cos( alpha );
+  fSliceSin = TMath::Sin( alpha );
+} 
+
+void AliHLTTPCCADisplay::SetSliceTransform( AliHLTTPCCATracker *slice )
+{
+  SetSliceTransform(slice->Param().Alpha());
+}
+
+
+void AliHLTTPCCADisplay::DrawTPC()
+{
+  // schematically draw TPC detector
+  fYX->Range(-fROuterMax, -fROuterMax, fROuterMax, fROuterMax);
+  fYX->Clear();
+  {
+    fArc.SetLineColor(kBlack);
+    fArc.SetFillStyle(0);
+    fYX->cd();    
+    for( Int_t iSlice=0; iSlice<18; iSlice++){
+      fCrown.SetLineColor(kBlack);
+      fCrown.SetFillStyle(0);
+      fCrown.DrawCrown(0,0,fRInnerMin, fRInnerMax, 360./18.*iSlice, 360./18.*(iSlice+1) );
+      fCrown.DrawCrown(0,0,fROuterMin, fROuterMax, 360./18.*iSlice, 360./18.*(iSlice+1) );
+    }
+  }
+  fZX->cd();
+  fZX->Range( fTPCZMin, -fROuterMax, fTPCZMax, fROuterMax );
+  fZX->Clear();
+}
+
+void AliHLTTPCCADisplay::DrawSlice( AliHLTTPCCATracker *slice )
+{     
+  // draw current the TPC slice
+  fYX->cd();
+  Double_t r0 = .5*(slice->Param().RMax()+slice->Param().RMin());
+  Double_t dr = .5*(slice->Param().RMax()-slice->Param().RMin());
+  Double_t cx = r0*slice->Param().CosAlpha();
+  Double_t cy = r0*slice->Param().SinAlpha();
+  Double_t raddeg = 180./3.1415;
+  Double_t a0 = raddeg*.5*(slice->Param().AngleMax() + slice->Param().AngleMin());
+  Double_t da = raddeg*.5*(slice->Param().AngleMax() - slice->Param().AngleMin());
+  if( fSliceView ){
+    cx = 0; cy = r0;
+    a0 = 90.;
+    fLatex.DrawLatex(cx-dr+dr*.05,cy-dr+dr*.05, Form("YX, Slice %2i",slice->Param().ISlice()));
+  } else {
+    a0+= raddeg*TMath::ATan2(fSin, fCos );
+  }
+  fArc.SetLineColor(kBlack);
+  fArc.SetFillStyle(0);     
+  fCrown.SetLineColor(kBlack);
+  fCrown.SetFillStyle(0);
+    
+  fCrown.DrawCrown(0,0, slice->Param().RMin(),slice->Param().RMax(), a0-da, a0+da );
+
+  fLine.SetLineColor(kBlack);
+  fZX->cd();
+
+  Double_t cz = .5*(slice->Param().ZMax()+slice->Param().ZMin());
+  Double_t dz = .5*(slice->Param().ZMax()-slice->Param().ZMin())*1.2;
+  //fLine.DrawLine(cz+dz, cy-dr, cz+dz, cy+dr ); 
+  if( fSliceView ) fLatex.DrawLatex(cz-dz+dz*.05,cy-dr+dr*.05, Form("ZX, Slice %2i",slice->Param().ISlice()));
+}
+
+
 void AliHLTTPCCADisplay::Set2Slices( AliHLTTPCCATracker *slice )
 {
   //* Set view for two neighbouring slices
@@ -203,24 +278,47 @@ Int_t AliHLTTPCCADisplay::GetColor( Double_t z ) const
   return kMyColor[iz];
 }
 
-void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
+Int_t AliHLTTPCCADisplay::GetColorY( Double_t y ) const 
 {
-  // convert coordinates global->view
-  *xv = x*fCos + y*fSin;
-  *yv = y*fCos - x*fSin;
+  // Get color with respect to Z coordinate
+  const Color_t kMyColor[11] = { kGreen, kBlue, kYellow, kMagenta, kCyan, 
+                                kOrange, kSpring, kTeal, kAzure, kViolet, kPink };
+
+  Double_t yy = (y-fYMin)/(fYMax-fYMin);    
+  Int_t iy = (int) (yy*11);
+  if( iy<0 ) iy = 0;
+  if( iy>10 ) iy = 10;
+  return kMyColor[iy];
 }
 
-void AliHLTTPCCADisplay::SetSliceTransform( Double_t alpha )
+Int_t AliHLTTPCCADisplay::GetColorK( Double_t k ) const 
 {
-  fSliceCos = TMath::Cos( alpha );
-  fSliceSin = TMath::Sin( alpha );
-} 
+  // Get color with respect to Z coordinate
+  const Color_t kMyColor[11] = { kRed, kBlue, kYellow, kMagenta, kCyan, 
+                                kOrange, kSpring, kTeal, kAzure, kViolet, kPink };
+  const Double_t kCLight = 0.000299792458;  
+  const Double_t kBz = 5;
+  Double_t k2QPt = 100;
+  if( TMath::Abs(kBz)>1.e-4 ) k2QPt= 1./(kBz*kCLight);
+  Double_t qPt = k*k2QPt;
+  Double_t pt = 100;
+  if( TMath::Abs(qPt) >1.e-4 ) pt = 1./TMath::Abs(qPt);
+  
+  Double_t yy = (pt-0.1)/(1.-0.1);
+  Int_t iy = (int) (yy*11);
+  if( iy<0 ) iy = 0;
+  if( iy>10 ) iy = 10;
+  return kMyColor[iy];
+}
 
-void AliHLTTPCCADisplay::SetSliceTransform( AliHLTTPCCATracker *slice )
+void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
 {
-  SetSliceTransform(slice->Param().Alpha());
+  // convert coordinates global->view
+  *xv = x*fCos + y*fSin;
+  *yv = y*fCos - x*fSin;
 }
 
+
 void AliHLTTPCCADisplay::Slice2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
 {
   // convert coordinates slice->view
@@ -231,71 +329,310 @@ void AliHLTTPCCADisplay::Slice2View( Double_t x, Double_t y, Double_t *xv, Doubl
 }
 
 
-void AliHLTTPCCADisplay::DrawTPC()
+void AliHLTTPCCADisplay::DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color )
 {
-  // schematically draw TPC detector
-  fYX->Range(-fROuterMax, -fROuterMax, fROuterMax, fROuterMax);
-  fYX->Clear();
+  // draw hit
+  AliHLTTPCCAGBHit &h = tracker.Hits()[iHit];
+  AliHLTTPCCATracker &slice = tracker.Slices()[h.ISlice()];
+  SetSliceTransform(&slice);
+
+  if( color<0 ) color = GetColor( h.Z() );
+  
+  fMarker.SetMarkerSize(.3);
+  fMarker.SetMarkerColor(color);
+  Double_t vx, vy;
+  Slice2View( h.X(), h.Y(), &vx, &vy );  
+  
+  fYX->cd();
+  fMarker.DrawMarker(vx, vy);
+  fZX->cd();  
+  fMarker.DrawMarker(h.Z(), vy); 
+}
+
+void AliHLTTPCCADisplay::DrawGBTrack( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color )
+{
+  // draw global track
+  
+  AliHLTTPCCAGBTrack &track = tracker.Tracks()[itr];
+  if( track.NHits()<2 ) return;
+  Int_t width = 1;
+
+  AliHLTTPCCADisplayTmpHit vHits[track.NHits()];
+  AliHLTTPCCATrackParam t = track.Param();
+  
+  for( Int_t ih=0; ih<track.NHits(); ih++ ){
+    Int_t i = tracker.TrackHits()[ track.FirstHitRef() + ih];
+    AliHLTTPCCAGBHit *h = &(tracker.Hits()[i]);
+    vHits[ih].ID() = i;
+    vHits[ih].S() = 0;
+    vHits[ih].Z() = h->Z();
+  }  
+  
+  //sort(vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
+  Int_t colorY = color;
+
   {
-    fArc.SetLineColor(kBlack);
-    fArc.SetFillStyle(0);
-    fYX->cd();    
-    for( Int_t iSlice=0; iSlice<18; iSlice++){
-      fCrown.SetLineColor(kBlack);
-      fCrown.SetFillStyle(0);
-      fCrown.DrawCrown(0,0,fRInnerMin, fRInnerMax, 360./18.*iSlice, 360./18.*(iSlice+1) );
-      fCrown.DrawCrown(0,0,fROuterMin, fROuterMax, 360./18.*iSlice, 360./18.*(iSlice+1) );
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[ vHits[0].ID()];
+    AliHLTTPCCAGBHit &h2 = tracker.Hits()[ vHits[track.NHits()-1].ID()];
+    if( color<0 ) color = GetColor( (h1.Z()+h2.Z())/2. );
+    Double_t gx1, gy1, gx2, gy2;
+    Slice2View(h1.X(), h1.Y(), &gx1, &gy1 );
+    Slice2View(h2.X(), h2.Y(), &gx2, &gy2 );
+    if( colorY<0 ) colorY = GetColorY( (gy1+gy2)/2. );
+    color = colorY = GetColorK(t.GetKappa());
+  }
+
+  //fMarker.SetMarkerColor(color);//kBlue);
+  //fMarker.SetMarkerSize(1.);
+  fLine.SetLineColor(color);
+  fLine.SetLineWidth(width);    
+  fArc.SetFillStyle(0);
+  fArc.SetLineColor(color);    
+  fArc.SetLineWidth(width);        
+  TPolyLine pl;
+  pl.SetLineColor(color);
+  pl.SetLineWidth(width);
+  TPolyLine plZ;
+  plZ.SetLineColor(colorY);
+  plZ.SetLineWidth(width);
+
+  Int_t oldSlice = -1;
+  //Double_t alpha = track.Alpha();
+  Double_t px[track.NHits()], py[track.NHits()], pz[track.NHits()];
+
+  // YX
+  for( Int_t iHit=0; iHit<track.NHits()-1; iHit++ ){
+
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[vHits[iHit].ID()];
+    AliHLTTPCCAGBHit &h2 = tracker.Hits()[vHits[iHit+1].ID()];
+    Double_t vx1, vy1, vx2, vy2;
+    
+    if( h1.ISlice() != oldSlice ){
+      //t.Rotate( tracker.Slices()[h1.ISlice()].Param().Alpha() - alpha);
+      oldSlice = h1.ISlice();
+      //alpha = tracker.Slices()[h1.ISlice()].Param().Alpha();
+      SetSliceTransform( &(tracker.Slices()[oldSlice]) );
     }
+    Float_t x1=h1.X(), y1=h1.Y(), z1=h1.Z();
+    //t.GetDCAPoint( x1, y1, z1, x1, y1, z1 );  
+    Slice2View(x1, y1, &vx1, &vy1 );
+    px[iHit] = vx1;
+    py[iHit] = vy1;
+    pz[iHit] = z1;
+
+    if( h2.ISlice() != oldSlice ){
+      //t.Rotate( tracker.Slices()[h2.ISlice()].Param().Alpha() - alpha);
+      oldSlice = h2.ISlice();
+      //alpha = tracker.Slices()[h2.ISlice()].Param().Alpha();
+      SetSliceTransform( &(tracker.Slices()[oldSlice]) );
+    }
+    Float_t x2=h2.X(), y2=h2.Y(), z2=h2.Z();
+    //t.GetDCAPoint( h2.X(), h2.Y(), h2.Z(), x2, y2, z2 );
+    Slice2View(x2, y2, &vx2, &vy2 );
+    px[iHit+1] = vx2;
+    py[iHit+1] = vy2;
+    pz[iHit+1] = z2;
+
+    continue;
+
+    Double_t x0 = t.GetX();
+    Double_t y0 = t.GetY();
+    Double_t sinPhi = t.GetSinPhi();
+    Double_t k = t.GetKappa();
+    Double_t ex = t.GetCosPhi();
+    Double_t ey = sinPhi;
+    if( TMath::Abs(k)>1.e-4 ){
+      
+      fYX->cd();
+
+      Double_t r = 1/TMath::Abs(k);
+      Double_t xc = x0 -ey*(1/k);
+      Double_t yc = y0 +ex*(1/k);
+     
+      Double_t vx, vy;
+      Slice2View( xc, yc, &vx, &vy );
+      
+      Double_t a1 = TMath::ATan2(vy1-vy, vx1-vx)/TMath::Pi()*180.;
+      Double_t a2 = TMath::ATan2(vy2-vy, vx2-vx)/TMath::Pi()*180.;
+      if( a1<0 ) a1+=360;
+      if( a2<0 ) a2+=360;
+      if( a2<a1 ) a2+=360;
+      Double_t da = TMath::Abs(a2-a1);
+      if( da>360 ) da-= 360;
+      if( da>180 ){
+       da = a1;
+       a1 = a2;
+       a2 = da;
+       if( a2<a1 ) a2+=360;    
+      }
+      fArc.DrawArc(vx,vy,r, a1,a2,"only");
+      //fArc.DrawArc(vx,vy,r, 0,360,"only");
+   } else {
+      fYX->cd();
+      fLine.DrawLine(vx1,vy1, vx2, vy2 );
+   }
   }
+  
+  fYX->cd();
+  pl.DrawPolyLine(track.NHits(),px,py);    
   fZX->cd();
-  fZX->Range( fTPCZMin, -fROuterMax, fTPCZMax, fROuterMax );
-  fZX->Clear();
+  plZ.DrawPolyLine(track.NHits(),pz,py);
+  
+  fLine.SetLineWidth(1);     
 }
 
-void AliHLTTPCCADisplay::DrawSlice( AliHLTTPCCATracker *slice )
-{     
-  // draw current the TPC slice
-  fYX->cd();
-  Double_t r0 = .5*(slice->Param().RMax()+slice->Param().RMin());
-  Double_t dr = .5*(slice->Param().RMax()-slice->Param().RMin());
-  Double_t cx = r0*slice->Param().CosAlpha();
-  Double_t cy = r0*slice->Param().SinAlpha();
-  Double_t raddeg = 180./3.1415;
-  Double_t a0 = raddeg*.5*(slice->Param().AngleMax() + slice->Param().AngleMin());
-  Double_t da = raddeg*.5*(slice->Param().AngleMax() - slice->Param().AngleMin());
-  if( fSliceView ){
-    cx = 0; cy = r0;
-    a0 = 90.;
-    fLatex.DrawLatex(cx-dr+dr*.05,cy-dr+dr*.05, Form("YX, Slice %2i",slice->Param().ISlice()));
-  } else {
-    a0+= raddeg*TMath::ATan2(fSin, fCos );
+void AliHLTTPCCADisplay::DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color )
+{
+  // draw global track
+  
+  AliHLTTPCCAGBTrack &track = tracker.Tracks()[itr];
+  if( track.NHits()<2 ) return;
+  Int_t width = 1;
+
+  AliHLTTPCCADisplayTmpHit *vHits = new AliHLTTPCCADisplayTmpHit[track.NHits()];
+  AliHLTTPCCATrackParam &t = track.Param();
+  
+  for( Int_t ih=0; ih<track.NHits(); ih++ ){
+    Int_t i = tracker.TrackHits()[ track.FirstHitRef() + ih];
+    AliHLTTPCCAGBHit *h = &(tracker.Hits()[i]);
+    vHits[ih].ID() = i;
+    vHits[ih].S() = 0;
+    vHits[ih].Z() = h->Z();
+  }  
+
+  sort(vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
+  Int_t colorY = color;
+  {
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[ vHits[0].ID()];
+    AliHLTTPCCAGBHit &h2 = tracker.Hits()[ vHits[track.NHits()-1].ID()];
+    if( color<0 ) color = GetColor( (h1.Z()+h2.Z())/2. );
+    Double_t gx1, gy1, gx2, gy2;
+    Slice2View(h1.X(), h1.Y(), &gx1, &gy1 );
+    Slice2View(h2.X(), h2.Y(), &gx2, &gy2 );
+    if( colorY<0 ) colorY = GetColorY( (gy1+gy2)/2. );
+    color = colorY = GetColorK(t.GetKappa());
   }
-  fArc.SetLineColor(kBlack);
-  fArc.SetFillStyle(0);     
-  fCrown.SetLineColor(kBlack);
-  fCrown.SetFillStyle(0);
+
+  fMarker.SetMarkerColor(color);//kBlue);
+  fMarker.SetMarkerSize(1.);
+  fLine.SetLineColor(color);
+  fLine.SetLineWidth(width);    
+  fArc.SetFillStyle(0);
+  fArc.SetLineColor(color);    
+  fArc.SetLineWidth(width);        
+  TPolyLine pl;
+  pl.SetLineColor(colorY);
+  pl.SetLineWidth(width);
+
+  Int_t oldSlice = -1;
+  Double_t alpha = track.Alpha();
+  // YX
+  {
+
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[vHits[0].ID()];
+    AliHLTTPCCAGBHit &h2 = tracker.Hits()[vHits[track.NHits()-1].ID()];
+    Float_t x1, y1, z1, x2, y2, z2;
+    Double_t vx1, vy1, vx2, vy2;
     
-  fCrown.DrawCrown(0,0, slice->Param().RMin(),slice->Param().RMax(), a0-da, a0+da );
+    if( h1.ISlice() != oldSlice ){
+      t.Rotate( tracker.Slices()[h1.ISlice()].Param().Alpha() - alpha);
+      oldSlice = h1.ISlice();
+      alpha = tracker.Slices()[h1.ISlice()].Param().Alpha();
+      SetSliceTransform( &(tracker.Slices()[oldSlice]) );
+    }
+    t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1 );  
+    Slice2View(x1, y1, &vx1, &vy1 );
 
-  fLine.SetLineColor(kBlack);
+    if( h2.ISlice() != oldSlice ){
+      t.Rotate( tracker.Slices()[h2.ISlice()].Param().Alpha() - alpha);
+      oldSlice = h2.ISlice();
+      alpha = tracker.Slices()[h2.ISlice()].Param().Alpha();
+      SetSliceTransform( &(tracker.Slices()[oldSlice]) );
+    }
+    t.GetDCAPoint( h2.X(), h2.Y(), h2.Z(), x2, y2, z2 );
+    Slice2View(x2, y2, &vx2, &vy2 );
+    
+    Double_t x0 = t.GetX();
+    Double_t y0 = t.GetY();
+    Double_t sinPhi = t.GetSinPhi();
+    Double_t k = t.GetKappa();
+    Double_t ex = t.GetCosPhi();
+    Double_t ey = sinPhi;
  
-  fZX->cd();
+    if( TMath::Abs(k)>1.e-4 ){
+      
+      fYX->cd();
 
-  Double_t cz = .5*(slice->Param().ZMax()+slice->Param().ZMin());
-  Double_t dz = .5*(slice->Param().ZMax()-slice->Param().ZMin())*1.2;
-  //fLine.DrawLine(cz+dz, cy-dr, cz+dz, cy+dr ); 
-  if( fSliceView ) fLatex.DrawLatex(cz-dz+dz*.05,cy-dr+dr*.05, Form("ZX, Slice %2i",slice->Param().ISlice()));
+      Double_t r = 1/TMath::Abs(k);
+      Double_t xc = x0 -ey*(1/k);
+      Double_t yc = y0 +ex*(1/k);
+     
+      Double_t vx, vy;
+      Slice2View( xc, yc, &vx, &vy );
+      
+      Double_t a1 = TMath::ATan2(vy1-vy, vx1-vx)/TMath::Pi()*180.;
+      Double_t a2 = TMath::ATan2(vy2-vy, vx2-vx)/TMath::Pi()*180.;
+      if( a1<0 ) a1+=360;
+      if( a2<0 ) a2+=360;
+      if( a2<a1 ) a2+=360;
+      Double_t da = TMath::Abs(a2-a1);
+      if( da>360 ) da-= 360;
+      if( da>180 ){
+       da = a1;
+       a1 = a2;
+       a2 = da;
+       if( a2<a1 ) a2+=360;    
+      }
+      fArc.DrawArc(vx,vy,r, a1,a2,"only");
+      //fArc.DrawArc(vx,vy,r, 0,360,"only");
+   } else {
+      fYX->cd();
+      fLine.DrawLine(vx1,vy1, vx2, vy2 );
+    }
+  }
+
+  // ZX
+  Double_t py[track.NHits()], pz[track.NHits()];
+
+  for( Int_t iHit=0; iHit<track.NHits(); iHit++ ){
+
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[vHits[iHit].ID()];
+    Float_t x1, y1, z1;
+    Double_t vx1, vy1;    
+    if( h1.ISlice() != oldSlice ){
+      t.Rotate( tracker.Slices()[h1.ISlice()].Param().Alpha() - alpha);
+      oldSlice = h1.ISlice();
+      alpha = tracker.Slices()[h1.ISlice()].Param().Alpha();
+      SetSliceTransform( &(tracker.Slices()[oldSlice]) );
+    }
+    t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1 );  
+    Slice2View(x1, y1, &vx1, &vy1 );
+    py[iHit] = vy1;
+    pz[iHit] = z1;
+  }
+
+
+  fZX->cd();
+  pl.DrawPolyLine(track.NHits(),pz,py);    
+  
+  fLine.SetLineWidth(1);     
+  delete[] vHits;  
 }
 
 
+
+#ifdef XXXX
+
+
 void AliHLTTPCCADisplay::DrawHit( Int_t iRow, Int_t iHit, Int_t color )
 {
   // draw hit
   if( !fSlice ) return;
   AliHLTTPCCARow &row = fSlice->Rows()[iRow];
-  AliHLTTPCCAHit *h = &(row.Hits()[iHit]);
+  AliHLTTPCCAHit *h = &(fSlice->Hits()[row.FirstHit()+iHit]);
   if( color<0 ) color = GetColor( h->Z() );
-
+  
   //Double_t dgy = 3.5*TMath::Abs(h->ErrY()*fSlice->Param().CosAlpha() - fSlice->Param().ErrX()*fSlice->Param().SinAlpha() );
   Double_t dx = 0.1;//fSlice->Param().ErrX()*TMath::Sqrt(12.)/2.;
   Double_t dy = 0.35;//h->ErrY()*3.5;
@@ -312,11 +649,11 @@ void AliHLTTPCCADisplay::DrawHit( Int_t iRow, Int_t iHit, Int_t color )
   fYX->cd();
   //if( fSliceView ) fArc.DrawEllipse( vx, vy, dvx, dvy, 0,360, 0);
   //else  fArc.DrawEllipse( vx, vy, dx, dy, 0,360, fSlice->Param().Alpha()*180./3.1415);
-  fMarker.DrawMarker(vx, vy);
+  fMarker.DrawMarker(vy, vx);
   fZX->cd();
   //if( fSliceView ) fArc.DrawEllipse( h->Z(), vy, dz, dvy, 0,360, 0 );
   //else fArc.DrawEllipse( h->Z(), vy, dz, dgy, 0,360, fSlice->Param().Alpha()*180./3.1415);
-  fMarker.DrawMarker(h->Z(), vy); 
+  fMarker.DrawMarker(h->Z(), vx); 
 }
 
 
@@ -395,16 +732,16 @@ void AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrack &track, Int_t color, Bool_t
   // draw track
   
   if( track.NHits()<2 ) return;
-  int width = 2;
+  Int_t width = 2;
 
   AliHLTTPCCADisplayTmpHit *vHits = new AliHLTTPCCADisplayTmpHit[track.NHits()];
   AliHLTTPCCATrackParam &t = track.Param();
 
   Int_t iID = track.FirstHitID();
-  int nhits = 0;
+  Int_t nhits = 0;
   { 
     Int_t iHit = 0;
-    for( int ih=0; ih<track.NHits(); ih++ ){
+    for( Int_t ih=0; ih<track.NHits(); ih++ ){
       Int_t i = fSlice->TrackHits()[iID];
       AliHLTTPCCAHit *h = &(fSlice->ID2Hit( i )); 
       AliHLTTPCCARow &row = fSlice->ID2Row(i);
@@ -542,7 +879,7 @@ void AliHLTTPCCADisplay::DrawTrackletPoint( AliHLTTPCCATrackParam &t, Int_t colo
   Double_t ex = t.GetCosPhi();
   Double_t ey = sinPhi;
 
-  int width = 1;
+  Int_t width = 1;
 
   if( color<0 ) color = GetColor( t.GetZ() );
     
index ac1df77..cfaaf07 100644 (file)
@@ -14,8 +14,8 @@
 #define ALIHLTTPCCADISPLAY_H
 
 
-#ifdef XXXX
 class AliHLTTPCCATracker;
+class AliHLTTPCCAGBTracker;
 class AliHLTTPCCATrack;
 class AliHLTTPCCATrackParam;
 class TCanvas;
@@ -26,7 +26,6 @@ class TCanvas;
 #include "TCrown.h"
 #include "TMarker.h"
 #include "TLatex.h"
-#endif
 
 /**
  * @class AliHLTTPCCADisplay
@@ -34,7 +33,6 @@ class TCanvas;
 class AliHLTTPCCADisplay
 {
  public:
-#ifdef XXXX
   static AliHLTTPCCADisplay &Instance();
   
   AliHLTTPCCADisplay();
@@ -53,23 +51,33 @@ class AliHLTTPCCADisplay
   void Set2Slices( AliHLTTPCCATracker *slice );
 
   Int_t GetColor( Double_t z ) const ;
+  Int_t GetColorY( Double_t y ) const ;
+  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 ;
 
   void DrawTPC();
   void DrawSlice( AliHLTTPCCATracker *slice ); 
+  void DrawGBTrack( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color=-1 );
+  void DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color=-1 );
 
-  void DrawHit( Int_t iRow,Int_t iHit, Int_t color=-1 );
+  void DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color=-1 );
 
+#ifdef XXXX
+
+  void DrawHit( Int_t iRow,Int_t iHit, Int_t color=-1 );
   void DrawMergedHit( Int_t iRow, Int_t iHit, Int_t color=-1 );
 
   void DrawTrack( AliHLTTPCCATrack &track, Int_t color=-1, Bool_t DrawCells=1 );
   void DrawTrackletPoint( AliHLTTPCCATrackParam &t, Int_t color=-1 );
+#endif // XXXX
 
   void SetSliceTransform( Double_t alpha );
 
   void SetSliceTransform( AliHLTTPCCATracker *slice );
 
+  TCanvas *CanvasYX(){ return fYX; }
+  TCanvas *CanvasZX(){ return fZX; }
 
  protected:
 
@@ -77,7 +85,7 @@ class AliHLTTPCCADisplay
   Bool_t fAsk;                      // flag to ask for the pressing key
   Bool_t fSliceView;               // switch between slice/TPC zoom
   AliHLTTPCCATracker *fSlice;      // current CA tracker, includes slice geometry
-  Double_t fCos, fSin, fZMin, fZMax;// view parameters
+  Double_t fCos, fSin, fZMin, fZMax, fYMin, fYMax;// view parameters
   Double_t fSliceCos, fSliceSin;        // current slice angle
   Double_t fRInnerMin, fRInnerMax, fROuterMin, fROuterMax,fTPCZMin, fTPCZMax; // view parameters
 
@@ -112,7 +120,6 @@ class AliHLTTPCCADisplay
     Double_t fZ;  // cell Z position
   };
 
-#endif // XXXX
 
 };
 
index 65d80ca..78e2888 100644 (file)
@@ -20,7 +20,7 @@
 
 //ClassImp(AliHLTTPCCAGBHit)
 
-bool AliHLTTPCCAGBHit::Compare(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b)
+Bool_t AliHLTTPCCAGBHit::Compare(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b)
 {
   //* Comparison function for sorting hits
   if( a.fISlice<b.fISlice ) return 1;
index 864b03f..d46cd56 100644 (file)
@@ -41,12 +41,12 @@ class AliHLTTPCCAGBHit
   Bool_t &IsUsed(){ return fIsUsed; };
 
 
-  static bool Compare(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b);
+  static Bool_t Compare(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b);
 
-  static bool CompareRowDown(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b){
+  static Bool_t CompareRowDown(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b){
     return ( a.fIRow>b.fIRow );
   }
-  static bool ComparePRowDown(const AliHLTTPCCAGBHit *a, const AliHLTTPCCAGBHit *b){
+  static Bool_t ComparePRowDown(const AliHLTTPCCAGBHit *a, const AliHLTTPCCAGBHit *b){
     return ( a->fIRow>b->fIRow );
   }
 
index 5b4e414..36cf1a5 100644 (file)
@@ -22,6 +22,7 @@
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCAGBTrack.h"
 #include "AliHLTTPCCATrackParam.h"
+//#include "AliHLTTPCCAEventHeader.h"
 
 #include "AliHLTTPCCAMath.h"
 #include "TStopwatch.h"
@@ -45,7 +46,8 @@ AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker()
     fNTracks(0),
     fSliceTrackInfos(0),
     fTime(0),
-    fStatNEvents(0)
+    fStatNEvents(0),
+    fSliceTrackerTime(0)
 {
   //* constructor
   for( Int_t i=0; i<20; i++ ) fStatTime[i] = 0;
@@ -62,7 +64,8 @@ AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker(const AliHLTTPCCAGBTracker&)
     fNTracks(0),
     fSliceTrackInfos(0),
     fTime(0),
-    fStatNEvents(0)
+    fStatNEvents(0),
+    fSliceTrackerTime(0)
 {
   //* dummy
 }
@@ -117,7 +120,7 @@ void AliHLTTPCCAGBTracker::StartEvent()
   fHits=0;
   fNHits = 0;
   fNTracks = 0;
-  for( int i=0; i<fNSlices; i++) fSlices[i].StartEvent();
+  for( Int_t i=0; i<fNSlices; i++) fSlices[i].StartEvent();
 }
 
 
@@ -162,9 +165,8 @@ void AliHLTTPCCAGBTracker::FindTracks()
     }    
     AliHLTTPCCADisplay::Instance().Init();
   }
-  AliHLTTPCCADisplay::Instance().SetSliceView();
-  //AliHLTTPCCADisplay::Instance().SetTPCView();
-  //AliHLTTPCCADisplay::Instance().DrawTPC();
+  AliHLTTPCCADisplay::Instance().SetTPCView();
+  AliHLTTPCCADisplay::Instance().DrawTPC();
 #endif //DRAW  
 
   if( fNHits<=0 ) return;
@@ -173,7 +175,7 @@ void AliHLTTPCCAGBTracker::FindTracks()
 
   // Read hits, row by row
 
-  int nHitsTotal = fNHits;
+  Int_t nHitsTotal = fNHits;
   Float_t *hitY = new Float_t [nHitsTotal];
   Float_t *hitZ = new Float_t [nHitsTotal];
 
@@ -185,7 +187,7 @@ void AliHLTTPCCAGBTracker::FindTracks()
     for( Int_t ir=0; ir<200; ir++ ) rowNHits[is][ir] = 0;    
   }
 
-  for( int ih=0; ih<nHitsTotal; ih++){
+  for( Int_t ih=0; ih<nHitsTotal; ih++){
     AliHLTTPCCAGBHit &h = fHits[ih];    
     sliceNHits[h.ISlice()]++;
     rowNHits[h.ISlice()][h.IRow()]++;
@@ -205,9 +207,11 @@ void AliHLTTPCCAGBTracker::FindTracks()
       }
       firstRowHit+=rowNHits[is][ir];
     }
-    //if( is==24 ){//SG!!!
     fSlices[is].ReadEvent( rowFirstHits, rowNHits[is], hitY, hitZ, sliceNHits[is] );
-    //}
+    
+    //Int_t data[ rowNHits[is]]
+    //AliHLTTPCCAEventHeader event;
+
     firstSliceHit+=sliceNHits[is];
   }
 
@@ -217,8 +221,8 @@ void AliHLTTPCCAGBTracker::FindTracks()
 
   TStopwatch timer1;
   TStopwatch timer2;
-  //cout<<"Start CA reconstruction"<<endl;
-  for( int iSlice=0; iSlice<fNSlices; iSlice++ ){
+  //std::cout<<"Start CA reconstruction"<<std::endl;
+  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
     TStopwatch timer;
     AliHLTTPCCATracker &slice = fSlices[iSlice];
     slice.Reconstruct();
@@ -237,13 +241,14 @@ void AliHLTTPCCAGBTracker::FindTracks()
   }
 
   timer2.Stop();
-  //cout<<"blaTime = "<<timer2.CpuTime()*1.e3<<endl;
+  //std::cout<<"blaTime = "<<timer2.CpuTime()*1.e3<<std::endl;
+  fSliceTrackerTime = timer2.CpuTime();
 
   for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
     AliHLTTPCCATracker &iS = fSlices[iSlice];
     if( fSliceTrackInfos[iSlice] ) delete[] fSliceTrackInfos[iSlice];
     fSliceTrackInfos[iSlice]=0;
-    int iNTracks = iS.NOutTracks();
+    Int_t iNTracks = *iS.NOutTracks();
     fSliceTrackInfos[iSlice] = new AliHLTTPCCAGBSliceTrackInfo[iNTracks];
     for( Int_t itr=0; itr<iNTracks; itr++ ){
       fSliceTrackInfos[iSlice][itr].fPrevNeighbour = -1;
@@ -252,13 +257,13 @@ void AliHLTTPCCAGBTracker::FindTracks()
     }
   }
   
-  //cout<<"Start CA merging"<<endl;
+  //std::cout<<"Start CA merging"<<std::endl;
   TStopwatch timerMerge;
   Merging();
   timerMerge.Stop();
   fStatTime[9]+=timerMerge.CpuTime();  
   //fTime+=timerMerge.CpuTime();
-  //cout<<"End CA merging"<<endl;
+  //std::cout<<"End CA merging"<<std::endl;
   timer1.Stop();
   fTime+= timer1.CpuTime();
 
@@ -267,6 +272,140 @@ void AliHLTTPCCAGBTracker::FindTracks()
 #endif //DRAW
 }
 
+
+void AliHLTTPCCAGBTracker::FindTracks0()
+{
+  //* main tracking routine
+  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  
+
+  if( fNHits<=0 ) return;
+  
+  std::sort(fHits,fHits+fNHits, AliHLTTPCCAGBHit::Compare );  
+
+  // Read hits, row by row
+
+  Int_t nHitsTotal = fNHits;
+  Float_t *hitY = new Float_t [nHitsTotal];
+  Float_t *hitZ = new Float_t [nHitsTotal];
+
+  Int_t sliceNHits[fNSlices];  
+  Int_t rowNHits[fNSlices][200];
+  
+  for( Int_t is=0; is<fNSlices; is++ ){
+    sliceNHits[is] = 0;
+    for( Int_t ir=0; ir<200; ir++ ) rowNHits[is][ir] = 0;    
+  }
+
+  for( Int_t ih=0; ih<nHitsTotal; ih++){
+    AliHLTTPCCAGBHit &h = fHits[ih];    
+    sliceNHits[h.ISlice()]++;
+    rowNHits[h.ISlice()][h.IRow()]++;
+  }
+  
+  Int_t firstSliceHit = 0;
+  for( Int_t is=0; is<fNSlices; is++ ){
+    fFirstSliceHit[is] = firstSliceHit;
+    Int_t rowFirstHits[200];
+    Int_t firstRowHit = 0;
+    for( Int_t ir=0; ir<200; ir++ ){
+      rowFirstHits[ir] = firstRowHit;
+      for( Int_t ih=0; ih<rowNHits[is][ir]; ih++){
+       AliHLTTPCCAGBHit &h = fHits[firstSliceHit + firstRowHit + ih];    
+       hitY[firstRowHit + ih] = h.Y();
+       hitZ[firstRowHit + ih] = h.Z(); 
+      }
+      firstRowHit+=rowNHits[is][ir];
+    }
+    //if( is==24 ){//SG!!!
+    fSlices[is].ReadEvent( rowFirstHits, rowNHits[is], hitY, hitZ, sliceNHits[is] );
+    //}
+    
+    //Int_t data[ rowNHits[is]]
+    //AliHLTTPCCAEventHeader event;
+
+    firstSliceHit+=sliceNHits[is];
+  }
+
+  delete[] hitY;
+  delete[] hitZ;
+}
+
+
+void AliHLTTPCCAGBTracker::FindTracks1()
+{
+  //* main tracking routine
+
+  TStopwatch timer2;
+  //std::cout<<"Start CA reconstruction"<<std::endl;
+  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
+    TStopwatch timer;
+    AliHLTTPCCATracker &slice = fSlices[iSlice];
+    slice.Reconstruct();
+    timer.Stop();
+    //fTime+= timer.CpuTime();
+    //blaTime+= timer.CpuTime();
+    fStatTime[0] += timer.CpuTime();
+    fStatTime[1]+=slice.Timers()[0];
+    fStatTime[2]+=slice.Timers()[1];
+    fStatTime[3]+=slice.Timers()[2];
+    fStatTime[4]+=slice.Timers()[3];
+    fStatTime[5]+=slice.Timers()[4];
+    fStatTime[6]+=slice.Timers()[5];
+    fStatTime[7]+=slice.Timers()[6];
+    fStatTime[8]+=slice.Timers()[7];
+  }
+
+  timer2.Stop();
+  //std::cout<<"blaTime = "<<timer2.CpuTime()*1.e3<<std::endl;
+  fSliceTrackerTime = timer2.CpuTime();
+}
+
+
+void AliHLTTPCCAGBTracker::FindTracks2()
+{
+  //* main tracking routine
+
+  TStopwatch timer1;
+
+  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
+    AliHLTTPCCATracker &iS = fSlices[iSlice];
+    if( fSliceTrackInfos[iSlice] ) delete[] fSliceTrackInfos[iSlice];
+    fSliceTrackInfos[iSlice]=0;
+    Int_t iNTracks = *iS.NOutTracks();    
+    fSliceTrackInfos[iSlice] = new AliHLTTPCCAGBSliceTrackInfo[iNTracks];
+    for( Int_t itr=0; itr<iNTracks; itr++ ){
+      fSliceTrackInfos[iSlice][itr].fPrevNeighbour = -1;
+      fSliceTrackInfos[iSlice][itr].fNextNeighbour = -1; 
+      fSliceTrackInfos[iSlice][itr].fUsed = 0;
+    }
+  }
+  
+  //std::cout<<"Start CA merging"<<std::endl;
+  TStopwatch timerMerge;
+  Merging();
+  timerMerge.Stop();
+  fStatTime[9]+=timerMerge.CpuTime();  
+  //fTime+=timerMerge.CpuTime();
+  //std::cout<<"End CA merging"<<std::endl;
+  timer1.Stop();
+  fTime+= fSliceTrackerTime + timer1.CpuTime();
+
+#ifdef DRAW
+  AliHLTTPCCADisplay::Instance().Ask();
+#endif //DRAW
+}
+
 void AliHLTTPCCAGBTracker::Merging()
 {
   //* track merging between slices
@@ -287,14 +426,14 @@ void AliHLTTPCCAGBTracker::Merging()
   Int_t maxNSliceTracks = 0;
   for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
     AliHLTTPCCATracker &iS = fSlices[iSlice];
-    if( maxNSliceTracks < iS.NOutTracks() ) maxNSliceTracks = iS.NOutTracks();
+    if( maxNSliceTracks < *iS.NOutTracks() ) maxNSliceTracks = *iS.NOutTracks();
   }
 
   //* arrays for rotated track parameters
 
   AliHLTTPCCATrackParam *iTrParams[2], *jTrParams[2];
   Bool_t *iOK[2], *jOK[2];
-  for( int i=0; i<2; i++ ){
+  for( Int_t i=0; i<2; i++ ){
     iTrParams[i] = new AliHLTTPCCATrackParam[maxNSliceTracks];
     jTrParams[i] = new AliHLTTPCCATrackParam[maxNSliceTracks];
     iOK[i] = new Bool_t [maxNSliceTracks];
@@ -302,12 +441,12 @@ void AliHLTTPCCAGBTracker::Merging()
   }
   
   for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
-    //cout<<"\nMerge slice "<<iSlice<<endl<<endl;
+    //std::cout<<"\nMerge slice "<<iSlice<<std::endl<<std::endl;
     AliHLTTPCCATracker &iS = fSlices[iSlice];
     Int_t jSlice = nextSlice[iSlice];
     AliHLTTPCCATracker &jS = fSlices[jSlice];    
-    int iNTracks = iS.NOutTracks();
-    int jNTracks = jS.NOutTracks();
+    Int_t iNTracks = *iS.NOutTracks();
+    Int_t jNTracks = *jS.NOutTracks();
     if( iNTracks<=0 || jNTracks<=0 ) continue;
     
     //* prepare slice tracks for merging
@@ -354,7 +493,7 @@ void AliHLTTPCCAGBTracker::Merging()
     }
 
     //* start merging
-    //cout<<"Start slice merging.."<<endl;
+    //std::cout<<"Start slice merging.."<<std::endl;
     for (Int_t itr=0; itr<iNTracks; itr++) {      
       if( !iOK[0][itr] && !iOK[1][itr] ) continue;
       Int_t jBest = -1;
@@ -371,8 +510,8 @@ void AliHLTTPCCAGBTracker::Merging()
            // check for neighbouring   
            {
              Float_t factor2 = 3.5*3.5;
-             float d = jT.GetY() - iT.GetY();
-             float s2 = jT.GetErr2Y() + iT.GetErr2Y();
+             Float_t d = jT.GetY() - iT.GetY();
+             Float_t s2 = jT.GetErr2Y() + iT.GetErr2Y();
              if( d*d>factor2*s2 ){
                continue;
              }
@@ -442,7 +581,7 @@ void AliHLTTPCCAGBTracker::Merging()
   Int_t nTracksTot = 0;
   for( Int_t iSlice = 0; iSlice<fNSlices; iSlice++ ){    
     AliHLTTPCCATracker &slice = fSlices[iSlice];
-    nTracksTot+= slice.NOutTracks();
+    nTracksTot+= *slice.NOutTracks();
   }
   
   if( fTrackHits ) delete[] fTrackHits;
@@ -455,18 +594,18 @@ void AliHLTTPCCAGBTracker::Merging()
 
   Int_t nTrackHits = 0;
 
-  //cout<<"\nStart global track creation...\n"<<endl;  
+  //std::cout<<"\nStart global track creation...\n"<<std::endl;  
 
-         static int nRejected = 0;
+  static Int_t nRejected = 0;
 
   Int_t maxNRows = fSlices[0].Param().NRows();
   
   for( Int_t iSlice = 0; iSlice<fNSlices; iSlice++ ){
     
     AliHLTTPCCATracker &slice = fSlices[iSlice];
-    for( Int_t itr=0; itr<slice.NOutTracks(); itr++ ){
+    for( Int_t itr=0; itr<*slice.NOutTracks(); itr++ ){
       if( fSliceTrackInfos[iSlice][itr].fUsed ) continue;
-      //cout<<"\n slice "<<iSlice<<", track "<<itr<<"\n"<<endl;
+      //std::cout<<"\n slice "<<iSlice<<", track "<<itr<<"\n"<<std::endl;
       //AliHLTTPCCAOutTrack &tCA = slice.OutTracks()[itr];
       AliHLTTPCCAGBTrack &t = fTracks[fNTracks];
       //t.Param() = tCA.StartPoint();
@@ -489,8 +628,8 @@ void AliHLTTPCCAGBTracker::Merging()
        fSliceTrackInfos[jSlice][jtr].fUsed = 1;
        AliHLTTPCCATracker &jslice = fSlices[jSlice];
        AliHLTTPCCAOutTrack &jTr = jslice.OutTracks()[jtr];
-       for( int jhit=0; jhit<jTr.NHits(); jhit++){
-         int id = fFirstSliceHit[jSlice] + jslice.OutTrackHits()[jTr.FirstHitRef()+jhit];        
+       for( Int_t jhit=0; jhit<jTr.NHits(); jhit++){
+         Int_t id = fFirstSliceHit[jSlice] + jslice.OutTrackHits()[jTr.FirstHitRef()+jhit];      
          AliHLTTPCCAGBHit &h = fHits[id];
          FitPoint &p =  fitPoints[h.IRow()];
          if( p.fISlice >=0 ) continue;
@@ -507,7 +646,7 @@ void AliHLTTPCCAGBTracker::Merging()
        jtr = fSliceTrackInfos[jSlice][jtr].fNextNeighbour;
        jSlice = nextSlice[jSlice];     
       } while( jtr >=0 ); 
-
       if( nHits < 10 ) continue;     //SG!!!
 
       Int_t firstRow = 0, lastRow = maxNRows-1;
@@ -534,7 +673,7 @@ void AliHLTTPCCAGBTracker::Merging()
       for( Int_t i=firstRow-1; i>=0; i-- ) searchRows[nSearchRows++] = i;
       
       // refit 
-
+      
       AliHLTTPCCATrackParam t0;
 
       {        
@@ -627,8 +766,21 @@ void AliHLTTPCCAGBTracker::Merging()
            
            Int_t bestsh = -1;
            Float_t ds = 1.e10;
+           Float_t y0 = row->Grid().YMin();
+           Float_t z0 = row->Grid().ZMin();
+           Float_t stepY = row->HstepY();
+           Float_t stepZ = row->HstepZ();
+           uint4* tmpint4 = cslice->RowData() + row->FullOffset();
+           ushort2 *hits = reinterpret_cast<ushort2*>(tmpint4);
+
            for( Int_t ish=0; ish<row->NHits(); ish++ ){
-             AliHLTTPCCAHit &sh = cslice->Hits()[row->FirstHit()+ish];
+             AliHLTTPCCAHit sh;// = cslice->Hits()[row->FirstHit()+ish];
+             {
+               ushort2 hh = hits[ish];
+               sh.Y() = y0 + hh.x*stepY;
+               sh.Z() = z0 + hh.y*stepZ;
+             }
+
              Float_t dy = sh.Y() - t0.GetY();
              Float_t dz = sh.Z() - t0.GetZ();
              Float_t dds = dy*dy+dz*dz;
@@ -643,7 +795,13 @@ void AliHLTTPCCAGBTracker::Merging()
            
            GetErrors2( currslice, iRow, t0, p.fErr2Y, p.fErr2Z );
 
-           AliHLTTPCCAHit &sh = cslice->Hits()[row->FirstHit()+bestsh];
+           AliHLTTPCCAHit sh;// = cslice->Hits()[row->FirstHit()+bestsh];
+           {
+             ushort2 hh = hits[bestsh];
+             sh.Y() = y0 + hh.x*stepY;
+             sh.Z() = z0 + hh.y*stepZ;
+           }
+
            Float_t dy = sh.Y() - t0.GetY();
            Float_t dz = sh.Z() - t0.GetZ();
            Float_t s2z = /*t0.GetErr2Z() + */ p.fErr2Z;
@@ -652,7 +810,7 @@ void AliHLTTPCCAGBTracker::Merging()
            if( dy*dy>factor2*s2y ) continue;
 
            p.fISlice = currslice;
-           p.fHitID = fFirstSliceHit[p.fISlice] + cslice->HitsID()[row->FirstHit() + bestsh];
+           p.fHitID = fFirstSliceHit[p.fISlice] + cslice->HitInputIDs()[row->FirstHit() + bestsh];
            p.fX = row->X();
            p.fY = sh.Y();
            p.fZ = sh.Z();
@@ -665,7 +823,7 @@ void AliHLTTPCCAGBTracker::Merging()
        }
 
        //* final refit, dE/dx calculation
-       //cout<<"\n\nstart refit..\n"<<endl;
+       //std::cout<<"\n\nstart refit..\n"<<std::endl;
 
        AliHLTTPCCATrackParam::AliHLTTPCCATrackFitParam fitPar;
        {
@@ -692,7 +850,7 @@ void AliHLTTPCCAGBTracker::Merging()
          t0.Cov()[14] = .1;
          t0.Chi2() = 0;
          t0.NDF() = -5;        
-         bool first = 1;
+         Bool_t first = 1;
          for( Int_t iRow = maxNRows-1; iRow>=0; iRow-- ){
            FitPoint &p =  fitPoints[iRow];
            if( p.fISlice<0 ) continue;
@@ -702,23 +860,23 @@ void AliHLTTPCCAGBTracker::Merging()
            //* Rotate to the new slice
 
            if( p.fISlice!=currslice ){ 
-             //cout<<"rotate..."<<endl;
-             //cout<<" before rotation:"<<endl;
+             //std::cout<<"rotate..."<<std::endl;
+             //std::cout<<" before rotation:"<<std::endl;
              //t0.Print();
              if( !t0.Rotate( fSlices[p.fISlice].Param().Alpha() - fSlices[currslice].Param().Alpha() ) ) continue;     
-             //cout<<" after rotation:"<<endl;
+             //std::cout<<" after rotation:"<<std::endl;
              //t0.Print();
              currslice = p.fISlice;
            }
            //* Transport to the new row
            
-           //cout<<" before transport:"<<endl;
+           //std::cout<<" before transport:"<<std::endl;
            //t0.Print();
            
            //if( !t0.TransportToX( p.fX, .99 ) ) continue;         
            if( !t0.TransportToXWithMaterial( p.fX, fitPar ) ) continue;            
            //if( !t0.TransportToX( p.fX, .99 ) ) continue;         
-           //cout<<" after transport:"<<endl;
+           //std::cout<<" after transport:"<<std::endl;
            //t0.Print();
 
            //* Update the track
@@ -743,11 +901,11 @@ void AliHLTTPCCAGBTracker::Merging()
              t0.NDF() = -5;
            }
 
-           //cout<<" before filtration:"<<endl;
+           //std::cout<<" before filtration:"<<std::endl;
            //t0.Print();
 
            if( !t0.Filter2( p.fY, p.fZ, p.fErr2Y, p.fErr2Z, .99 ) ) continue;    
-           //cout<<" after filtration:"<<endl;
+           //std::cout<<" after filtration:"<<std::endl;
            //t0.Print();
              first = 0;
            
@@ -760,8 +918,8 @@ void AliHLTTPCCAGBTracker::Merging()
          t.DeDx() = 0;
          if( nDeDx >0 ) t.DeDx() = sumDeDx/nDeDx;
          if( t0.GetErr2Y()<=0 ){
-           cout<<"nhits = "<<t.NHits()<<", t0.GetErr2Y() = "<<t0.GetErr2Y()<<endl;
-           t0.Print();
+           //std::cout<<"nhits = "<<t.NHits()<<", t0.GetErr2Y() = "<<t0.GetErr2Y()<<std::endl;
+           //t0.Print();
            //exit(1);
          }
        }
@@ -787,15 +945,15 @@ void AliHLTTPCCAGBTracker::Merging()
          Bool_t ok=1;
          
          Float_t *c = t0.Cov();
-         for( int i=0; i<15; i++ ) ok = ok && finite(c[i]);
-         for( int i=0; i<5; i++ ) ok = ok && finite(t0.Par()[i]);
+         for( Int_t i=0; i<15; i++ ) ok = ok && finite(c[i]);
+         for( Int_t i=0; i<5; i++ ) ok = ok && finite(t0.Par()[i]);
          ok = ok && (t0.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(!ok){
            nRejected++;
-           //cout<<"\n\nRejected: "<<nRejected<<"\n"<<endl;
+           //std::cout<<"\n\nRejected: "<<nRejected<<"\n"<<std::endl;
            continue;
          }
        }
@@ -808,14 +966,14 @@ void AliHLTTPCCAGBTracker::Merging()
       }
     }
   }
-  //cout<<"\n\nRejected: "<<nRejected<<"\n"<<endl;
+  //std::cout<<"\n\nRejected: "<<nRejected<<"\n"<<std::endl;
   timerMerge2.Stop();
   fStatTime[11]+=timerMerge2.CpuTime();
 
   TStopwatch timerMerge3;
 
   //* selection  
-  //cout<<"Selection..."<<endl;
+  //std::cout<<"Selection..."<<std::endl;
   {
     AliHLTTPCCAGBTrack *vtracks = new AliHLTTPCCAGBTrack [fNTracks];
     Int_t *vhits = new Int_t [fNHits];
@@ -844,7 +1002,7 @@ void AliHLTTPCCAGBTracker::Merging()
       if( to.NHits()<10 ) continue;//SG!!!
       nHits+=to.NHits();
       nTracks++;
-      //cout<<to.Param().GetErr2Y()<<" "<<to.Param().GetErr2Z()<<endl;
+      //std::cout<<to.Param().GetErr2Y()<<" "<<to.Param().GetErr2Z()<<std::endl;
     }
     fNTracks = nTracks;
     if( fTrackHits ) delete[] fTrackHits;
@@ -885,33 +1043,33 @@ void AliHLTTPCCAGBTracker::GetErrors2( AliHLTTPCCAGBHit &h, AliHLTTPCCATrackPara
   GetErrors2( h.ISlice(), h.IRow(), t, Err2Y, Err2Z );
 }
 
-void AliHLTTPCCAGBTracker::WriteSettings( ostream &out ) const
+void AliHLTTPCCAGBTracker::WriteSettings( std::ostream &out ) const
 {
   //* write settings to the file
-  out<< NSlices()<<endl;  
-  for( int iSlice=0; iSlice<NSlices(); iSlice++ ){    
+  out<< NSlices()<<std::endl;  
+  for( Int_t iSlice=0; iSlice<NSlices(); iSlice++ ){    
     fSlices[iSlice].Param().WriteSettings( out );
   }
 }
 
-void AliHLTTPCCAGBTracker::ReadSettings( istream &in )
+void AliHLTTPCCAGBTracker::ReadSettings( std::istream &in )
 {
   //* Read settings from the file
   Int_t nSlices=0;
   in >> nSlices;
   SetNSlices( nSlices );
-  for( int iSlice=0; iSlice<NSlices(); iSlice++ ){    
+  for( Int_t iSlice=0; iSlice<NSlices(); iSlice++ ){    
     AliHLTTPCCAParam param;
     param.ReadSettings ( in );
     fSlices[iSlice].Initialize( param ); 
   }
 }
 
-void AliHLTTPCCAGBTracker::WriteEvent( ostream &out ) const
+void AliHLTTPCCAGBTracker::WriteEvent( std::ostream &out ) const
 {
   // write event to the file
 
-  out<<NHits()<<endl;
+  out<<NHits()<<std::endl;
   for (Int_t ih=0; ih<NHits(); ih++) {
     AliHLTTPCCAGBHit &h = fHits[ih];
     out<<h.X()<<" ";
@@ -922,11 +1080,11 @@ void AliHLTTPCCAGBTracker::WriteEvent( ostream &out ) const
     out<<h.Amp()<<" ";
     out<<h.ID()<<" ";
     out<<h.ISlice()<<" ";
-    out<<h.IRow()<<endl;
+    out<<h.IRow()<<std::endl;
   }
 }
 
-void AliHLTTPCCAGBTracker::ReadEvent( istream &in ) 
+void AliHLTTPCCAGBTracker::ReadEvent( std::istream &in ) 
 {
   //* Read event from file 
 
@@ -943,45 +1101,46 @@ void AliHLTTPCCAGBTracker::ReadEvent( istream &in )
   }
 }
 
-void AliHLTTPCCAGBTracker::WriteTracks( ostream &out ) const 
+void AliHLTTPCCAGBTracker::WriteTracks( std::ostream &out ) const 
 {
   //* Write tracks to file 
 
-  out<<fTime<<endl;
+  out<<fSliceTrackerTime<<std::endl;
   Int_t nTrackHits = 0;
   for( Int_t itr=0; itr<fNTracks; itr++ ){
     nTrackHits+=fTracks[itr].NHits();
   }
-  out<<nTrackHits<<endl;
+  out<<nTrackHits<<std::endl;
   for( Int_t ih=0; ih<nTrackHits; ih++ ){
     out<< fTrackHits[ih]<<" ";
   }
-  out<<endl;
+  out<<std::endl;
   
-  out<<NTracks()<<endl;
+  out<<NTracks()<<std::endl;
   for( Int_t itr=0; itr<fNTracks; itr++ ){
     AliHLTTPCCAGBTrack &t = fTracks[itr];    
     AliHLTTPCCATrackParam &p = t.Param();      
     out<< t.NHits()<<" ";
     out<< t.FirstHitRef()<<" ";
     out<< t.Alpha()<<" ";
-    out<< t.DeDx()<<endl;
+    out<< t.DeDx()<<std::endl;
     out<< p.X()<<" ";
     out<< p.CosPhi()<<" ";
     out<< p.Chi2()<<" ";
-    out<< p.NDF()<<endl;
+    out<< p.NDF()<<std::endl;
     for( Int_t i=0; i<5; i++ ) out<<p.Par()[i]<<" ";
-    out<<endl;
+    out<<std::endl;
     for( Int_t i=0; i<15; i++ ) out<<p.Cov()[i]<<" ";
-    out<<endl;
+    out<<std::endl;
   }
 }
 
-void AliHLTTPCCAGBTracker::ReadTracks( istream &in )
+void AliHLTTPCCAGBTracker::ReadTracks( std::istream &in )
 {
   //* Read tracks  from file 
 
   in>>fTime;
+  fSliceTrackerTime = fTime;
   fStatTime[0]+=fTime;
   fStatNEvents++;
   if( fTrackHits ) delete[] fTrackHits;
index b3d3725..0f1b060 100644 (file)
 
 #include "AliHLTTPCCADef.h"
 
-#if defined( HLTCA_STANDALONE )
-#include <iostream.h>
-#else
-#include "Riostream.h"
+#if !defined(HLTCA_GPUCODE)
+#include <iostream>
 #endif
 
 class AliHLTTPCCATracker;
@@ -57,6 +55,12 @@ public:
                Int_t ID, Int_t iSlice, Int_t iRow );
 
   void FindTracks();
+
+  void FindTracks0();
+  void FindTracks1();
+  void FindTracks2();
+
+
   void Merging();
   AliHLTTPCCATracker *Slices(){ return fSlices; }
   AliHLTTPCCAGBHit *Hits(){ return fHits; }
@@ -71,12 +75,14 @@ public:
   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 );
 
-  void WriteSettings( ostream &out ) const;
-  void ReadSettings( istream &in );
-  void WriteEvent( ostream &out ) const;
-  void ReadEvent( istream &in );
-  void WriteTracks( ostream &out ) const;
-  void ReadTracks( istream &in );
+  void WriteSettings( std::ostream &out ) const;
+  void ReadSettings( std::istream &in );
+  void WriteEvent( std::ostream &out ) const;
+  void ReadEvent( std::istream &in );
+  void WriteTracks( std::ostream &out ) const;
+  void ReadTracks( std::istream &in );
+
+  Double_t &SliceTrackerTime(){ return fSliceTrackerTime; }
 
 protected:
 
@@ -100,6 +106,8 @@ protected:
   Int_t fStatNEvents;    //* n events proceed
   Int_t fFirstSliceHit[100]; // hit array
 
+  Double_t fSliceTrackerTime; // reco time of the slice tracker;
+
 };
 
 #endif
index 86e2eb1..52ea6b9 100644 (file)
@@ -49,8 +49,6 @@ class AliHLTTPCCAGrid
   GPUd() Float_t ZMax() const { return fZMax; }
   GPUd() Float_t StepYInv() const { return fStepYInv; }
   GPUd() Float_t StepZInv() const { return fStepZInv; }
-  GPUhd() UInt_t &Content2() { return fContent2;}
-  GPUhd() UInt_t &Offset() { return fOffset;}    
 
   private:
 
@@ -64,8 +62,6 @@ class AliHLTTPCCAGrid
   Float_t fStepYInv; //* inverse bin size in Y
   Float_t fStepZInv; //* inverse bin size in Z
 
-  UInt_t fContent2;  //* content of the fN/2 bin [4 bytes ]
-  UInt_t fOffset;    //* offset of this Grid content in the common content array
 };
 
 #endif
index 21a499f..e6b7fab 100644 (file)
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCAGrid.h"
 #include "AliHLTTPCCAHit.h"
+#include "AliHLTTPCCARow.h"
 
 
-GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a, AliHLTTPCCATracker &tracker, AliHLTTPCCAGrid &grid, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
+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 )
 { 
   // initialisation
 
-  UInt_t gridOffset = grid.Offset();
   a.HitOffset() = hitoffset;
   a.Y() = y;
   a.Z() = z;
@@ -38,41 +38,47 @@ GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a, AliHLTTPCCATracker &t
   grid.GetBin(a.MaxY(), a.MaxZ(), bYmax, a.BZmax());  
   a.BDY() = bYmax - bYmin + 1;
   a.Ny() = grid.Ny();
-  a.N2() = gridOffset + (grid.N()>>1);
-  a.C2() = grid.Content2();
-  a.IndYmin() = gridOffset + bZmin*a.Ny() + bYmin;
-  a.Iz() = bZmin; 
-  a.HitYfst() = tracker.GetGridContent((UInt_t)( a.IndYmin()));
-  a.HitYlst() = tracker.GetGridContent((UInt_t)( a.IndYmin() + a.BDY()));    
-  if( a.IndYmin()>=a.N2() ) a.HitYfst()+=a.C2();
-  if( a.IndYmin()+ a.BDY() >=a.N2() ) a.HitYlst()+=a.C2();
+  a.IndYmin() = bZmin*a.Ny() + bYmin;
+  a.Iz() = bZmin;
+  a.HitYfst() = content[a.IndYmin()];
+  a.HitYlst() = content[a.IndYmin() + a.BDY()];    
   a.Ih() = a.HitYfst(); 
 }
 
 
-GPUd() void AliHLTTPCCAHitArea::Init( AliHLTTPCCATracker &tracker,AliHLTTPCCAGrid &grid, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
+GPUd() void AliHLTTPCCAHitArea::Init( AliHLTTPCCAGrid &grid, UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
 { 
   //initialisation
-  AliHLTTPCCAHitAreaInit(*this, tracker, grid, hitoffset, y, z, dy, dz);
+  AliHLTTPCCAHitAreaInit(*this, grid, content, hitoffset, y, z, dy, dz);
 }
 
-GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, AliHLTTPCCAHit &h)
+GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, AliHLTTPCCARow &row, UShort_t *content, AliHLTTPCCAHit &h)
 {    
   // get next hit index
+  Float_t y0 = row.Grid().YMin();
+  Float_t z0 = row.Grid().ZMin();
+  Float_t stepY = row.HstepY();
+  Float_t stepZ = row.HstepZ();
+  uint4* tmpint4 = tracker.RowData() + row.FullOffset();
+  ushort2 *hits = reinterpret_cast<ushort2*>(tmpint4);
+
   Int_t ret = -1;
   do{
     while( fIh>=fHitYlst ){
       if( fIz>=fBZmax ) return -1;
       fIz++;
       fIndYmin += fNy;
-      fHitYfst = tracker.GetGridContent((UInt_t)( fIndYmin));
-      fHitYlst = tracker.GetGridContent((UInt_t)( fIndYmin + fBDY));      
-      if( fIndYmin>=fn2 ) fHitYfst+=fc2;
-      if( fIndYmin+ fBDY>=fn2 ) fHitYlst+=fc2;
+      fHitYfst = content[fIndYmin];
+      fHitYlst = content[fIndYmin + fBDY];
       fIh = fHitYfst;
     }
-    
-    h = tracker.GetHit( fHitOffset + fIh );    
+
+    {
+      ushort2 hh = hits[fIh];
+      h.Y() = y0 + hh.x*stepY;
+      h.Z() = z0 + hh.y*stepZ;
+    }
+    //h = tracker.Hits()[ fHitOffset + fIh ];    
     
     if( h.fZ>fMaxZ || h.fZ<fMinZ || h.fY<fMinY || h.fY>fMaxY ){
       fIh++;
@@ -87,14 +93,14 @@ GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, AliHLTTPCC
 
 
 
-GPUd() Int_t AliHLTTPCCAHitArea::GetBest(AliHLTTPCCATracker &tracker, AliHLTTPCCAHit &h)
+GPUd() Int_t AliHLTTPCCAHitArea::GetBest(AliHLTTPCCATracker &tracker, AliHLTTPCCARow &row, UShort_t *content, AliHLTTPCCAHit &h)
 {
   // get closest hit in the area
   Int_t best = -1;
   Float_t ds = 1.e10;
   do{
     AliHLTTPCCAHit hh;
-    Int_t ih=GetNext( tracker, hh ); 
+    Int_t ih=GetNext( tracker, row, content, hh ); 
     if( ih<0 ) break;
     Float_t dy = hh.fY - fY;
     Float_t dz = hh.fZ - fZ;
index c08a699..fa970b8 100644 (file)
@@ -14,6 +14,7 @@
 class AliHLTTPCCAHit;
 class AliHLTTPCCAGrid;
 class AliHLTTPCCATracker;
+class AliHLTTPCCARow;
 
 /**
  * @class ALIHLTTPCCAHitArea
@@ -23,9 +24,9 @@ class AliHLTTPCCAHitArea
 {
 public:
   
-  GPUd() void Init( AliHLTTPCCATracker &tracker, AliHLTTPCCAGrid &grid, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz );
-  GPUd() Int_t GetNext(AliHLTTPCCATracker &tracker, AliHLTTPCCAHit &h);
-  GPUd() Int_t GetBest(AliHLTTPCCATracker &tracker, AliHLTTPCCAHit &h );
+  GPUd() void Init( AliHLTTPCCAGrid &grid, UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz );
+  GPUd() Int_t GetNext(AliHLTTPCCATracker &tracker, AliHLTTPCCARow &row, UShort_t *content,AliHLTTPCCAHit &h);
+  GPUd() Int_t GetBest(AliHLTTPCCATracker &tracker, AliHLTTPCCARow &row, UShort_t *content,AliHLTTPCCAHit &h );
 
   GPUhd() Float_t& Y(){ return fY;}
   GPUhd() Float_t& Z(){ return fZ;}
@@ -41,14 +42,12 @@ public:
   GPUhd() UInt_t&  HitYlst(){ return fHitYlst;}
   GPUhd() UInt_t&  Ih(){ return fIh;}
   GPUhd() UInt_t&  Ny(){ return fNy;}
-  GPUhd() UInt_t&  N2(){ return fn2;}
-  GPUhd() UInt_t&  C2(){ return fc2;}
   GPUhd() UInt_t&  HitOffset(){ return fHitOffset;}
 
   protected:
 
   Float_t fY, fZ, fMinZ, fMaxZ, fMinY, fMaxY;    // search coordinates
-  UInt_t fBZmax, fBDY, fIndYmin, fIz, fHitYfst, fHitYlst, fIh, fNy, fn2, fc2; // !
+  UInt_t fBZmax, fBDY, fIndYmin, fIz, fHitYfst, fHitYlst, fIh, fNy; // !
   UInt_t fHitOffset; // global hit offset
 };
 
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCALinksWriter.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCALinksWriter.cxx
deleted file mode 100644 (file)
index e1a4545..0000000
+++ /dev/null
@@ -1,43 +0,0 @@
-// @(#) $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.                           *
-//                                                                          *
-// 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 "AliHLTTPCCALinksWriter.h"
-#include "AliHLTTPCCATracker.h"
-
-GPUd() void AliHLTTPCCALinksWriter::Thread
-( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-  AliHLTTPCCASharedMemory &/*s*/, AliHLTTPCCATracker &tracker )
-{
-  // copy constructed links to the new data scheme (temporary)
-
-  if( iSync==0 )
-    {
-      for( int irow=iBlock; irow<tracker.Param().NRows(); irow+=nBlocks ){
-       AliHLTTPCCARow &row = tracker.Rows()[irow];
-       Short_t *hitLinkUp = tracker.HitLinkUp() + row.FirstHit() ;
-       Short_t *hitLinkDown = tracker.HitLinkDown() + row.FirstHit();
-       Short_t *newUp = ((Short_t*)(tracker.TexHitsFullData() + row.FullOffset())) + row.FullLinkOffset();
-       Short_t *newDown = newUp + row.NHits();
-       
-       for( int ih=iThread; ih<row.NHits(); ih+=nThreads ){
-         newUp[ih] = hitLinkUp[ih];
-         newDown[ih] = hitLinkDown[ih];
-       }
-      }
-    }
-}
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCALinksWriter.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCALinksWriter.h
deleted file mode 100644 (file)
index 8dd5d71..0000000
+++ /dev/null
@@ -1,31 +0,0 @@
-//-*- 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                               *
-
-#ifndef ALIHLTTPCCALINKSWRITER_H
-#define ALIHLTTPCCALINKSWRITER_H
-
-
-#include "AliHLTTPCCADef.h"
-
-class AliHLTTPCCATracker;
-
-/**
- * 
- */
-class AliHLTTPCCALinksWriter
-{
- public:
-  class AliHLTTPCCASharedMemory{};
-  
-  GPUd() static Int_t NThreadSyncPoints(){ return 0; }  
-
-  GPUd() static void Thread( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-                            AliHLTTPCCASharedMemory &smem, AliHLTTPCCATracker &tracker );
-  
-};
-
-
-#endif
index f9923c1..8700d62 100644 (file)
@@ -17,9 +17,9 @@
 //***************************************************************************
 
 #include "AliHLTTPCCAMCTrack.h"
+#include "AliHLTTPCCAMath.h"
 #include "TParticle.h"
 #include "TDatabasePDG.h"
-#include "AliHLTTPCCAMath.h"
 
 
 AliHLTTPCCAMCTrack::AliHLTTPCCAMCTrack()
index ca6f9f7..a6b7231 100644 (file)
@@ -66,7 +66,7 @@ typedef AliHLTTPCCAMath CAMath;
 GPUd() inline Int_t AliHLTTPCCAMath::Nint(Float_t x)
 {  
 #if defined(HLTCA_STANDALONE) || defined( HLTCA_GPUCODE )
-  int i;
+  Int_t i;
   if (x >= 0) {
     i = int(x + 0.5);
     if (x + 0.5 == Float_t(i) && i & 1) i--;
index 0ada946..4e63b2c 100644 (file)
@@ -34,27 +34,27 @@ GPUd() void AliHLTTPCCANeighboursCleaner::Thread
        s.fNRows = tracker.Param().NRows();
        s.fIRow = iBlock+1;
        if( s.fIRow <= s.fNRows-2 ){
-         int iRowUp = s.fIRow+1;
-         int iRowDn = s.fIRow-1;  
-         int firstDn = tracker.Rows()[iRowDn].FirstHit();
+         Int_t iRowUp = s.fIRow+1;
+         Int_t iRowDn = s.fIRow-1;       
          s.fFirstHit = tracker.Rows()[s.fIRow].FirstHit(); 
-         int firstUp = tracker.Rows()[iRowUp].FirstHit();
-         Short_t *hhitLinkUp = tracker.HitLinkUp();
-         Short_t *hhitLinkDown = tracker.HitLinkDown();
-         s.fHitLinkUp = hhitLinkUp + s.fFirstHit;
-         s.fHitLinkDown = hhitLinkDown + s.fFirstHit;    
-         s.fNHits = firstUp - s.fFirstHit;
-         s.fUpHitLinkDown = hhitLinkDown + firstUp;
-         s.fDnHitLinkUp   = hhitLinkUp + firstDn;
+         AliHLTTPCCARow &row = tracker.Rows()[s.fIRow];
+         AliHLTTPCCARow &rowUp = tracker.Rows()[iRowUp];
+         AliHLTTPCCARow &rowDn = tracker.Rows()[iRowDn];
+         s.fHitLinkUp = ((Short_t*)(tracker.RowData() + row.FullOffset())) + row.FullLinkOffset();
+         s.fHitLinkDown = 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.fNHits = tracker.Rows()[s.fIRow].NHits();
        }
       }
     } 
   else if( iSync==1 )
     {
       if( s.fIRow <= s.fNRows-2 ){
-       for( int ih=iThread; ih<s.fNHits; ih+=nThreads ){
-         int up = s.fHitLinkUp[ih];
-         int dn = s.fHitLinkDown[ih];
+       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 );      
index 3991fb1..1f88e80 100644 (file)
@@ -33,18 +33,21 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
        s.fNRows = tracker.Param().NRows();
        s.fIRow = iBlock;
        if( s.fIRow < s.fNRows ){
-         s.fFirst = tracker.Rows()[s.fIRow].FirstHit();      
-         s.fHitLinkUp = tracker.HitLinkUp() + s.fFirst;
-         s.fHitLinkDn = tracker.HitLinkDown() + s.fFirst;
-         s.fNHits = tracker.Rows()[s.fIRow].NHits();
+         AliHLTTPCCARow &row = tracker.Rows()[s.fIRow];
+         s.fFirst = row.FirstHit();
+         s.fNHits = row.NHits();
+
+         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; 
            s.fFirstDn = tracker.Rows()[s.fIRowDn].FirstHit();
            s.fFirstUp = tracker.Rows()[s.fIRowUp].FirstHit();
-           float xDn = tracker.Rows()[s.fIRowDn].X();
-           float x = tracker.Rows()[s.fIRow].X();
-           float xUp = tracker.Rows()[s.fIRowUp].X();
+           Float_t xDn = tracker.Rows()[s.fIRowDn].X();
+           Float_t x = tracker.Rows()[s.fIRow].X();
+           Float_t xUp = tracker.Rows()[s.fIRowUp].X();
            s.fUpNHits = tracker.Rows()[s.fIRowUp].NHits();
            s.fDnNHits = s.fFirst - s.fFirstDn;
            s.fUpDx = xUp - x;
@@ -61,16 +64,21 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
     {
       if( s.fIRow < s.fNRows ){
        if( (s.fIRow==0) || (s.fIRow==s.fNRows-1) ){
-         for( int ih=iThread; ih<s.fNHits; ih+=nThreads ){
+         for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){
            s.fHitLinkUp[ih] = -1;
            s.fHitLinkDn[ih] = -1;
          }
-       }else if(0){
-         for( UInt_t ih=iThread; ih<s.fGridUp.N()+1; ih+=nThreads ){
-           s.fGridContentUp[ih] = tracker.GetGridContent(s.fGridUp.Offset()+ih);
+       }else {
+         AliHLTTPCCARow &rowUp = tracker.Rows()[s.fIRowUp];
+         AliHLTTPCCARow &rowDn = tracker.Rows()[s.fIRowDn];
+         UShort_t *gContentUp = (reinterpret_cast<UShort_t*>(tracker.RowData() + rowUp.FullOffset())) + rowUp.FullGridOffset();
+         UShort_t *gContentDn = (reinterpret_cast<UShort_t*>(tracker.RowData() + rowDn.FullOffset())) + rowDn.FullGridOffset();
+
+         for( UInt_t ih=iThread; ih<s.fGridUp.N()+s.fGridUp.Ny()+2; ih+=nThreads ){
+           s.fGridContentUp[ih] = gContentUp[ih];
          }
-         for( UInt_t ih=iThread; ih<s.fGridDn.N()+1; ih+=nThreads ){
-           s.fGridContentDn[ih] = tracker.GetGridContent(s.fGridDn.Offset()+ih);
+         for( UInt_t ih=iThread; ih<s.fGridDn.N()+s.fGridDn.Ny()+2; ih+=nThreads ){
+           s.fGridContentDn[ih] = gContentDn[ih];
          }
        }
       }
@@ -79,54 +87,75 @@ GPUd() void AliHLTTPCCANeighboursFinder::Thread
     {
       if( (s.fIRow<=0) || (s.fIRow >= s.fNRows-1) ) return;
       
-      const float kAreaSize = 3;     
-      float chi2Cut = 3.*3.*4*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx );
+      const Float_t kAreaSize = 3;     
+      Float_t chi2Cut = 3.*3.*4*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx );
       const Int_t kMaxN = 5;
+      
+      AliHLTTPCCARow &row = tracker.Rows()[s.fIRow];
+      AliHLTTPCCARow &rowUp = tracker.Rows()[s.fIRowUp];
+      AliHLTTPCCARow &rowDn = tracker.Rows()[s.fIRowDn];
+      Float_t y0 = row.Grid().YMin();
+      Float_t z0 = row.Grid().ZMin();
+      Float_t stepY = row.HstepY();
+      Float_t stepZ = row.HstepZ();
+      uint4* tmpint4 = tracker.RowData() + row.FullOffset();
+      ushort2 *hits = reinterpret_cast<ushort2*>(tmpint4);
 
-      for( int ih=iThread; ih<s.fNHits; ih+=nThreads ){        
+
+      for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){      
 
        UShort_t *neighUp = s.fB[iThread];
        float2 *yzUp = s.fA[iThread];
+       //UShort_t neighUp[5];
+       //float2 yzUp[5];
        
-       int linkUp = -1;
-       int linkDn = -1;
+       Int_t linkUp = -1;
+       Int_t linkDn = -1;
        
        if( s.fDnNHits>=1 && s.fUpNHits>=1 ){
          
-         int nNeighUp = 0;
-         AliHLTTPCCAHit h0 = tracker.GetHit( s.fFirst + ih );    
-         float y = h0.Y(); 
-         float z = h0.Z(); 
+         Int_t nNeighUp = 0;
+         AliHLTTPCCAHit h0;
+         {
+           ushort2 hh = hits[ih];
+           h0.Y() = y0 + hh.x*stepY;
+           h0.Z() = z0 + hh.y*stepZ;
+         }
+         //h0 = tracker.Hits()[ s.fFirst + ih ];         
+
+         Float_t y = h0.Y(); 
+         Float_t z = h0.Z(); 
+
          AliHLTTPCCAHitArea areaDn, areaUp;
-         areaUp.Init( tracker, s.fGridUp,  s.fFirstUp, y*s.fUpTx, z*s.fUpTx, kAreaSize, kAreaSize );
-         areaDn.Init(  tracker, s.fGridDn,  s.fFirstDn, y*s.fDnTx, z*s.fDnTx, kAreaSize, kAreaSize );      
+         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{
            AliHLTTPCCAHit h;
-           Int_t i = areaUp.GetNext( tracker,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);
 
-         int nNeighDn=0;
+         Int_t nNeighDn=0;
          if( nNeighUp>0 ){
 
-           int bestDn=-1, bestUp=-1;
-           float bestD=1.e10;
+           Int_t bestDn=-1, bestUp=-1;
+           Float_t bestD=1.e10;
 
            do{
              AliHLTTPCCAHit h;
-             Int_t i = areaDn.GetNext( tracker,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) );
              
-             for( int iUp=0; iUp<nNeighUp; iUp++ ){
+             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;
+               Float_t dy = yzdn.x - yzup.x;
+               Float_t dz = yzdn.y - yzup.y;
+               Float_t d = dy*dy + dz*dz;
                if( d<bestD ){
                  bestD = d;
                  bestDn = i;
index 45a1827..df2713c 100644 (file)
@@ -54,8 +54,8 @@ class AliHLTTPCCANeighboursFinder
       Short_t *fHitLinkDn; // links to the previous  row
       float2 fA[256][5]; // temp memory
       UShort_t fB[256][5]; // temp memory
-      UChar_t fGridContentUp[600]; // grid content for the next row
-      UChar_t fGridContentDn[600];// grid content for the previous row
+      UShort_t fGridContentUp[700]; // grid content for the next row
+      UShort_t fGridContentDn[700];// grid content for the previous row
     };
   
   GPUd() static Int_t NThreadSyncPoints(){ return 2; }  
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder1.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder1.cxx
deleted file mode 100644 (file)
index fb6441f..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-// @(#) $Id: AliHLTTPCCANeighboursFinder.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.                           *
-//                                                                          *
-// 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 "AliHLTTPCCANeighboursFinder1.h"
-#include "AliHLTTPCCATracker.h"
-
-GPUd() void AliHLTTPCCANeighboursFinder1::Thread
-( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-  SharedMemory &s, AliHLTTPCCATracker &tracker )
-{
-  int nRows = 159;
-  int iRow = iBlock;
-  int first = tracker.Rows()[iRow].FirstHit();      
-  Short_t *hitLinkUp = tracker.HitLinkUp() + first;
-  Short_t *hitLinkDn = tracker.HitLinkDown() + first;
-  int NHits = tracker.Rows()[iRow].NHits();
-  for( int ih=iThread; ih<NHits; ih+=nThreads ){       
-    hitLinkUp[ih] = -1;
-    hitLinkDn[ih] = -1;        
-  }
-}
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder1.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder1.h
deleted file mode 100644 (file)
index 891e05c..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-//-*- 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                               *
-
-#ifndef ALIHLTTPCCANEIGHBOURSFINDER1_H
-#define ALIHLTTPCCANEIGHBOURSFINDER1_H
-
-
-#include "AliHLTTPCCADef.h"
-class AliHLTTPCCATracker;
-
-/**
- * @class AliHLTTPCCANeighboursFinder
- * 
- */
-class AliHLTTPCCANeighboursFinder1
-{
- public:
-  class SharedMemory
-    {
-    public:
-    };
-  
-  GPUd() static Int_t NThreadSyncPoints(){ return 0; }  
-
-  GPUd() static void Thread( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-                            SharedMemory &smem, AliHLTTPCCATracker &tracker );
-  
-};
-
-
-#endif
index c3d9b43..dea1969 100644 (file)
@@ -149,40 +149,40 @@ GPUd() Float_t AliHLTTPCCAParam::GetClusterError2( Int_t yz, Int_t type, Float_t
 GPUh() void AliHLTTPCCAParam::WriteSettings( std::ostream &out ) const 
 {
   // write settings to the file
-  out << fISlice<<endl;
-  out << fNRows<<endl;
-  out << fAlpha<<endl;
-  out << fDAlpha<<endl;
-  out << fCosAlpha<<endl;
-  out << fSinAlpha<<endl;
-  out << fAngleMin<<endl;
-  out << fAngleMax<<endl;
-  out << fRMin<<endl;
-  out << fRMax<<endl;
-  out << fZMin<<endl;
-  out << fZMax<<endl;
-  out << fErrX<<endl;
-  out << fErrY<<endl;
-  out << fErrZ<<endl;
-  out << fPadPitch<<endl;
-  out << fBz<<endl;
-  out << fYErrorCorrection<<endl;
-  out << fZErrorCorrection<<endl;
-  out << fCellConnectionAngleXY<<endl;
-  out << fCellConnectionAngleXZ<<endl;
-  out << fMaxTrackMatchDRow<<endl;
-  out << fTrackConnectionFactor<<endl;
-  out << fTrackChiCut<<endl;
-  out << fTrackChi2Cut<<endl;
+  out << fISlice<<std::endl;
+  out << fNRows<<std::endl;
+  out << fAlpha<<std::endl;
+  out << fDAlpha<<std::endl;
+  out << fCosAlpha<<std::endl;
+  out << fSinAlpha<<std::endl;
+  out << fAngleMin<<std::endl;
+  out << fAngleMax<<std::endl;
+  out << fRMin<<std::endl;
+  out << fRMax<<std::endl;
+  out << fZMin<<std::endl;
+  out << fZMax<<std::endl;
+  out << fErrX<<std::endl;
+  out << fErrY<<std::endl;
+  out << fErrZ<<std::endl;
+  out << fPadPitch<<std::endl;
+  out << fBz<<std::endl;
+  out << fYErrorCorrection<<std::endl;
+  out << fZErrorCorrection<<std::endl;
+  out << fCellConnectionAngleXY<<std::endl;
+  out << fCellConnectionAngleXZ<<std::endl;
+  out << fMaxTrackMatchDRow<<std::endl;
+  out << fTrackConnectionFactor<<std::endl;
+  out << fTrackChiCut<<std::endl;
+  out << fTrackChi2Cut<<std::endl;
   for( Int_t iRow = 0; iRow<fNRows; iRow++ ){
-    out << fRowX[iRow]<<endl;
+    out << fRowX[iRow]<<std::endl;
   }
-  out<<endl;
+  out<<std::endl;
   for( Int_t i=0; i<2; i++ )
     for( Int_t j=0; j<3; j++ )
       for( Int_t k=0; k<7; k++ )
-       out << fParamS0Par[i][j][k]<<endl;
-  out<<endl;
+       out << fParamS0Par[i][j][k]<<std::endl;
+  out<<std::endl;
 }
 
 GPUh() void AliHLTTPCCAParam::ReadSettings( std::istream &in )
index 98ff857..a92c5de 100644 (file)
 
 #include "AliHLTTPCCADef.h"
 
-#if defined( HLTCA_STANDALONE )
-#include <iostream.h>
-#else
-#include "Riostream.h"
-#endif
+#include <iostream>
 
 
 /**
index eb893b9..f7592ed 100644 (file)
@@ -28,6 +28,7 @@
 
 #include "TMath.h"
 #include "TROOT.h"
+#include "Riostream.h"
 #include "TFile.h"
 #include "TH1.h"
 #include "TH2.h"
@@ -45,6 +46,7 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance()
   fNMCPoints(0),               
   fDoClusterPulls(0),         
   fStatNEvents(0),
+  fStatTime(0),
   fStatNRecTot(0),
   fStatNRecOut(0),
   fStatNGhost(0),
@@ -90,6 +92,7 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance()
   fhCellPurityVsPt(0),
   fhEffVsP(0), 
   fhGBEffVsP(0),
+  fhGBEffVsPt(0),
   fhNeighQuality(0),
   fhNeighEff(0),
   fhNeighQualityVsPt(0),
@@ -117,6 +120,7 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&)
   fNMCPoints(0),               
   fDoClusterPulls(0),         
   fStatNEvents(0),
+  fStatTime(0),
   fStatNRecTot(0),
   fStatNRecOut(0),
   fStatNGhost(0),
@@ -162,6 +166,7 @@ AliHLTTPCCAPerformance::AliHLTTPCCAPerformance(const AliHLTTPCCAPerformance&)
   fhCellPurityVsPt(0),
   fhEffVsP(0), 
   fhGBEffVsP(0),
+  fhGBEffVsPt(0),
   fhNeighQuality(0),
   fhNeighEff(0),
   fhNeighQualityVsPt(0),
@@ -320,6 +325,7 @@ void AliHLTTPCCAPerformance::CreateHistos()
 
   fhEffVsP = new TProfile("EffVsP", "Eff vs P", 100, 0., 5.);
   fhGBEffVsP = new TProfile("GBEffVsP", "Global tracker: Eff vs P", 100, 0., 5.);
+  fhGBEffVsPt = new TProfile("GBEffVsPt", "Global tracker: Eff vs Pt", 100, 0.2, 5.);
 
   gDirectory->mkdir("Clusters");
   gDirectory->cd("Clusters");  
@@ -538,7 +544,7 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
            Float_t darea = .2;
            Int_t nAreas = 15;
            Int_t nComb[nAreas];
-           for( int i=0; i<nAreas; i++ ) nComb[i]=0;
+           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());
@@ -556,12 +562,12 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
                if( d>D ) D = d;
                d = TMath::Abs( hN.Z()-zzN );
                if( d>D ) D = d;                
-               int ic = (int) (D/darea);
+               Int_t ic = (int) (D/darea);
                if( ic<nAreas ) nComb[ic]++;
              }
            }
-           int j=0;
-           for( int i=0; i<nAreas; i++ ){
+           Int_t j=0;
+           for( Int_t i=0; i<nAreas; i++ ){
              j+=nComb[i];
              if(j>0 ) fhNeighNCombVsArea->Fill(i*darea,j);
            }     
@@ -647,7 +653,7 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
 
        Bool_t okP=0, okN=0;
        if( h.FirstTriplet()>=0 ){
-         for( int it=h.FirstTriplet(); it<row.NTriplets(); it++ ){
+         for( Int_t it=h.FirstTriplet(); it<row.NTriplets(); it++ ){
            AliHLTTPCCATriplet &t = row.Triplets()[it];
            if( t.HitMid()!=ih ) break;
            //if( !t.Alive() ) continue;
@@ -669,14 +675,15 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
   }
   
 
-
   // Select reconstructable MC tracks
 
   {
     for (Int_t imc=0; imc<fNMCTracks; imc++) fMCTracks[imc].NHits() = 0;
-          
+        
     for( Int_t ih=firstSliceHit; ih<endSliceHit; ih++){
-      AliHLTTPCCAHitLabel &l = fHitLabels[fTracker->Hits()[ih].ID()];
+      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()++;
@@ -698,7 +705,7 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
     }
   }
 
-  Int_t traN = slice.NOutTracks();
+  Int_t traN = *slice.NOutTracks();
   Int_t *traLabels = 0; 
   Double_t *traPurity = 0;
   traLabels = new Int_t[traN];
@@ -841,7 +848,7 @@ void AliHLTTPCCAPerformance::SlicePerformance( Int_t iSlice, Bool_t PrintFlag )
 }
 
 
-void AliHLTTPCCAPerformance::Performance()
+void AliHLTTPCCAPerformance::Performance( fstream *StatFile )
 { 
   // main routine for performance calculation  
   //SG!!!
@@ -857,10 +864,9 @@ void AliHLTTPCCAPerformance::Performance()
     fStatNRecRef=0;
     fStatNClonesRef=0;
   */
-  fStatNEvents++;
-
+  fStatNEvents++;  
   for( Int_t islice=0; islice<fTracker->NSlices(); islice++){ 
-    SlicePerformance(islice,0);
+    SlicePerformance(islice,1);
   }
 
 
@@ -1024,6 +1030,7 @@ void AliHLTTPCCAPerformance::Performance()
       for (Int_t ipart=0; ipart<fNMCTracks; ipart++) {         
        AliHLTTPCCAMCTrack &mc = fMCTracks[ipart];
        if( mc.Set()>0 ) fhGBEffVsP->Fill(mc.P(), ( mc.NReconstructed()>0 ?1 :0));
+       if( mc.Set()>0 ) fhGBEffVsPt->Fill(mc.Pt(), ( mc.NReconstructed()>0 ?1 :0));
       }
 
       if( traLabels ) delete[] traLabels;
@@ -1239,9 +1246,61 @@ void AliHLTTPCCAPerformance::Performance()
        <<fTracker->StatTime(11)/fTracker->StatNEvents()*1.e3<<", "
        <<fTracker->StatTime(12)/fTracker->StatNEvents()*1.e3<<" "
        <<" msec/event "<<endl;
+
+    if( StatFile && StatFile->is_open() ){
+      fstream &out = *StatFile;
+
+      //out<<"\nGlobal tracker performance for "<<fStatNEvents<<" events: \n"<<endl;
+      //out<<" N tracks : "
+      //<<fStatGBNMCAll/fStatNEvents<<" mc all, "
+      //<<fStatGBNMCRef/fStatNEvents<<" mc ref, "
+      // <<fStatGBNRecTot/fStatNEvents<<" rec total, "
+      // <<fStatGBNRecAll/fStatNEvents<<" rec all, "
+      // <<fStatGBNClonesAll/fStatNEvents<<" clones all, "
+      // <<fStatGBNRecRef/fStatNEvents<<" rec ref, "
+      // <<fStatGBNClonesRef/fStatNEvents<<" clones ref, "
+      // <<fStatGBNRecOut/fStatNEvents<<" out, "
+      // <<fStatGBNGhost/fStatNEvents<<" ghost"<<endl;
+      fStatTime+=fTracker->SliceTrackerTime();
+      double timeHz=0;
+      if( fStatTime>1.e-4 ) timeHz = 1./fStatTime*fStatNEvents;
+
+      out<<"<table border>"<<endl;
+      out<<"<tr>"<<endl; 
+      out<<"<td>      </td> <td align=center> RefSet </td> <td align=center> AllSet </td> <td align=center> ExtraSet </td>"<<endl;
+      out<<"</tr>"<<endl;
+      out<<"<tr>"<<endl;
+      out<<"<td>Efficiency</td> <td align=center>"<<fStatGBNRecRef/dMCRef
+        <<"</td> <td align=center>"<<fStatGBNRecAll/dMCAll
+        <<"</td> <td align=center>"<<nRecExtr/dMCExtr
+        <<"</td>"<<endl;
+      out<<"</tr>"<<endl;
+      out<<"<tr> "<<endl;
+      out<<"<td>Clone</td>      <td align=center>"<<fStatGBNClonesRef/dRecRef
+        <<"</td> <td align=center>"<<fStatGBNClonesAll/dRecAll
+        <<"</td> <td align=center>"<<nClonesExtr/dRecExtr
+        <<"</td>"<<endl;
+      out<<"</tr>"<<endl;
+      out<<"<tr> "<<endl;
+      out<<"<td>Ghost</td>      <td colspan=3 align=center>"<<fStatGBNGhost/dRecTot
+        <<"</td>"<<endl;
+      out<<"</tr>"<<endl;
+      out<<"<tr> "<<endl;
+      out<<"<td>Time</td>      <td colspan=3 align=center>"<<timeHz 
+        <<" ev/s</td>"<<endl;
+      out<<"</tr>"<<endl;
+      out<<"<tr> "<<endl;
+      out<<"<td>N Events</td>      <td colspan=3 align=center>"<<fStatNEvents
+        <<"</td>"<<endl;
+      out<<"</tr>"<<endl;
+      out<<"</table>"<<endl;
+    }
+
   }
 
   WriteHistos();
+
+
 }
 
 void AliHLTTPCCAPerformance::WriteMCEvent( ostream &out ) const
index 12c47d2..1cf0f3c 100644 (file)
@@ -9,7 +9,6 @@
 #define ALIHLTTPCCAPERFORMANCE_H
 
 #include "AliHLTTPCCADef.h"
-#include "Riostream.h"
 
 class TObject;
 class TParticle;
@@ -57,7 +56,7 @@ class AliHLTTPCCAPerformance
   void CreateHistos();
   void WriteHistos();
   void SlicePerformance( Int_t iSlice, Bool_t PrintFlag  );
-  void Performance();
+  void Performance( fstream *StatFile = 0);
 
   void WriteMCEvent( ostream &out ) const;
   void ReadMCEvent( istream &in );
@@ -81,6 +80,7 @@ protected:
   Int_t fNMCPoints;                //* number of MC points
   Bool_t fDoClusterPulls;          //* do cluster pulls (very slow)
   Int_t fStatNEvents; //* n of events proceed
+  Double_t fStatTime; //* reco time;
   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
@@ -139,6 +139,7 @@ protected:
     *fhCellPurityVsPt,//* cell purity vs MC Pt
     *fhEffVsP, //* reconstruction efficiency vs P plot
     *fhGBEffVsP, //* global reconstruction efficiency vs P plot
+    *fhGBEffVsPt, //* global reconstruction efficiency vs P plot
     *fhNeighQuality, // quality for neighbours finder 
     *fhNeighEff,// efficiency for neighbours finder
     *fhNeighQualityVsPt,// quality for neighbours finder vs track Pt
index 64985cb..4d5bed7 100644 (file)
@@ -14,7 +14,7 @@
  */
 
 #include "AliHLTTPCCADef.h"
-#include "AliHLTTPCCATrackParam1.h"
+#include "AliHLTTPCCATrackParam.h"
 
 class AliHLTTPCCATracker;
 
@@ -39,7 +39,7 @@ GPUg() void AliHLTTPCCAProcess()
   GPUPROCESS(2)
   GPUPROCESS(3)
     
-    //for( int iSync=0; iSync<=TProcess::NThreadSyncPoints(); iSync++){
+    //for( Int_t iSync=0; iSync<=TProcess::NThreadSyncPoints(); iSync++){
     //__syncthreads();
     //TProcess::ThreadGPU( gridDim.x, blockDim.x, blockIdx.x, threadIdx.x, iSync, smem, tracker  ); 
     //}
@@ -70,13 +70,13 @@ template<typename TProcess>
 GPUg() void AliHLTTPCCAProcess1()
 {
   AliHLTTPCCATracker &tracker = *((AliHLTTPCCATracker*) cTracker);
-  AliHLTTPCCATrackParam1 tParam; 
+  AliHLTTPCCATrackParam tParam; 
   
   GPUshared() typename TProcess::AliHLTTPCCASharedMemory sMem;  
   
-  typename TProcess::ThreadMemory rMem;
+  typename TProcess::AliHLTTPCCAThreadMemory rMem;
 
-  for( int iSync=0; iSync<=TProcess::NThreadSyncPoints(); iSync++){
+  for( Int_t iSync=0; iSync<=TProcess::NThreadSyncPoints(); iSync++){
     GPUsync(); 
     TProcess::Thread( gridDim.x, blockDim.x, blockIdx.x, threadIdx.x, iSync, 
                      sMem, rMem, tracker, tParam  ); 
@@ -91,7 +91,7 @@ GPUg() void AliHLTTPCCAProcess1( Int_t nBlocks, Int_t nThreads, AliHLTTPCCATrack
   for( Int_t iB=0; iB<nBlocks; iB++ ){
     typename TProcess::AliHLTTPCCASharedMemory smem;
     typename TProcess::AliHLTTPCCAThreadMemory rMem[nThreads];
-    AliHLTTPCCATrackParam1 tParam[nThreads];
+    AliHLTTPCCATrackParam tParam[nThreads];
     for( Int_t iS=0; iS<=TProcess::NThreadSyncPoints(); iS++){
       for( Int_t iT=0; iT<nThreads; iT++ )
        TProcess::Thread( nBlocks, nThreads, iB, iT, iS, smem, rMem[iT], tracker, tParam[iT]  );
index 02f5a8e..4f52e98 100644 (file)
@@ -34,16 +34,16 @@ class AliHLTTPCCARow
   GPUhd() Float_t &MaxY()    { return fMaxY; }
   GPUhd() AliHLTTPCCAGrid &Grid(){ return fGrid; }  
 
-  GPUhd() float &Hy0() { return fHy0;}
-  GPUhd() float &Hz0() { return fHz0;}
-  GPUhd() float &HstepY() { return fHstepY;}
-  GPUhd() float &HstepZ() { return fHstepZ;}
-  GPUhd() float &HstepYi() { return fHstepYi;}
-  GPUhd() float &HstepZi() { return fHstepZi;}
-  GPUhd() int &FullSize() { return fFullSize;}
-  GPUhd() int &FullOffset() { return fFullOffset;}
-  GPUhd() int &FullGridOffset() { return fFullGridOffset;}
-  GPUhd() int &FullLinkOffset() { return fFullLinkOffset;}
+  GPUhd() Float_t &Hy0() { return fHy0;}
+  GPUhd() Float_t &Hz0() { return fHz0;}
+  GPUhd() Float_t &HstepY() { return fHstepY;}
+  GPUhd() Float_t &HstepZ() { return fHstepZ;}
+  GPUhd() Float_t &HstepYi() { return fHstepYi;}
+  GPUhd() Float_t &HstepZi() { return fHstepZi;}
+  GPUhd() Int_t &FullSize() { return fFullSize;}
+  GPUhd() Int_t &FullOffset() { return fFullOffset;}
+  GPUhd() Int_t &FullGridOffset() { return fFullGridOffset;}
+  GPUhd() Int_t &FullLinkOffset() { return fFullLinkOffset;}
 
 private:
 
@@ -53,8 +53,8 @@ private:
   Float_t fMaxY;           // maximal Y coordinate of the row
   AliHLTTPCCAGrid fGrid;   // grid of hits
 
-  float fHy0,fHz0, fHstepY,fHstepZ, fHstepYi, fHstepZi; // temporary variables
-  int fFullSize, fFullOffset, fFullGridOffset,fFullLinkOffset; // temporary variables
+  Float_t fHy0,fHz0, fHstepY,fHstepZ, fHstepYi, fHstepZi; // temporary variables
+  Int_t fFullSize, fFullOffset, fFullGridOffset,fFullLinkOffset; // temporary variables
 
 };
 
index 09bcb24..ff5bb14 100644 (file)
@@ -29,27 +29,28 @@ GPUd() void AliHLTTPCCAStartHitsFinder::Thread
   if( iSync==0 )
     {
       if( iThread==0 ){
-       Int_t *startHits = tracker.StartHits();
        if( iBlock==0 ){
-         CAMath::atomicExch(startHits,0); 
+         CAMath::atomicExch( tracker.NTracklets(),0); 
        }
        s.fNRows = tracker.Param().NRows();
        s.fIRow = iBlock+1;
        s.fNRowStartHits = 0;
-       if( s.fIRow <= s.fNRows-4 ){
-         int first = tracker.Rows()[s.fIRow].FirstHit();
+       if( s.fIRow <= s.fNRows-4 ){      
          s.fNHits = tracker.Rows()[s.fIRow].NHits(); 
          if( s.fNHits>=1024 ) s.fNHits = 1023;
-         s.fHitLinkUp = tracker.HitLinkUp() + first;
-         s.fHitLinkDown = tracker.HitLinkDown() + first;
+
+         AliHLTTPCCARow &row = tracker.Rows()[s.fIRow];
+         s.fHitLinkUp = ((Short_t*)(tracker.RowData() + row.FullOffset())) + row.FullLinkOffset();
+         s.fHitLinkDown = s.fHitLinkUp + row.NHits();
+
        } else s.fNHits = -1;
       }
     } 
   else if( iSync==1 )
     {
-      for( int ih=iThread; ih<s.fNHits; ih+=nThreads ){      
+      for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){      
        if( ( s.fHitLinkDown[ih]<0 ) && ( s.fHitLinkUp[ih]>=0 ) ){
-         int oldNRowStartHits = CAMath::atomicAdd(&s.fNRowStartHits,1);
+         Int_t oldNRowStartHits = CAMath::atomicAdd(&s.fNRowStartHits,1);
          s.fRowStartHits[oldNRowStartHits] = AliHLTTPCCATracker::IRowIHit2ID(s.fIRow, ih);
        }
       }
@@ -57,15 +58,14 @@ GPUd() void AliHLTTPCCAStartHitsFinder::Thread
   else if( iSync==2 )
     {
       if( iThread == 0 ){
-       Int_t *startHits = tracker.StartHits();
-       s.fNOldStartHits = CAMath::atomicAdd(startHits,s.fNRowStartHits);  
+       s.fNOldStartHits = CAMath::atomicAdd(tracker.NTracklets(),s.fNRowStartHits);  
       }
     }
   else if( iSync==3 )
     {
-      Int_t *startHits = tracker.StartHits();
-      for( int ish=iThread; ish<s.fNRowStartHits; ish+=nThreads ){    
-       startHits[1+s.fNOldStartHits+ish] = s.fRowStartHits[ish];
+      Int_t *startHits = tracker.TrackletStartHits();
+      for( Int_t ish=iThread; ish<s.fNRowStartHits; ish+=nThreads ){    
+       startHits[s.fNOldStartHits+ish] = s.fRowStartHits[ish];
       }
     }
 }
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackPar.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackPar.cxx
deleted file mode 100644 (file)
index cec6502..0000000
+++ /dev/null
@@ -1,462 +0,0 @@
-// @(#) $Id$
-//*************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
-// ALICE Experiment at CERN, All rights reserved.                         *
-//                                                                        *
-// Primary Authors: Jochen Thaeder <thaeder@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 "AliHLTTPCCATrackPar.h"
-#include "TMath.h"
-
-ClassImp(AliHLTTPCCATrackPar)
-
-void AliHLTTPCCATrackPar::Init()
-{
-  //* Initialization 
-
-  for( Int_t i=0; i<7; i++ ) fP[i] = 0;
-  for( Int_t i=0; i<28; i++ ) fC[i] = 0;
-  fC[0] = fC[2] = fC[5] = 100.;
-  fC[9] = fC[14] = fC[20] = 100.;
-  fC[27] = 10.;
-  fChi2 = 0;
-  fNDF = -5;
-}
-
-
-void AliHLTTPCCATrackPar::Normalize( Double_t Direction[3] )
-{
-  //* Normalize the track directions
-  //* (Px,Py,Pz,qp)-> (Px,Py,Pz,qp)/sqrt(Px²+Py²+Pz²)
-  //* 
-
-  Double_t p2 = fP[3]*fP[3] + fP[4]*fP[4] + fP[5]*fP[5];
-  if( p2<1.e-4 ) return;
-  Double_t a2 = 1./p2;
-  Double_t a = sqrt(a2);
-
-  if( Direction && ( fP[3]*Direction[0] + fP[4]*Direction[1] + fP[5]*Direction[2] < 0 ) ) a = -a;
-  
-  Double_t ex = fP[3]*a, ey = fP[4]*a, ez = fP[5]*a, qp = fP[6]*a;
-
-  fP[3] = ex;
-  fP[4] = ey;
-  fP[5] = ez;
-  fP[6] = qp;
-
-  Double_t 
-    h0 = fC[ 6]*ex + fC[10]*ey + fC[15]*ez,
-    h1 = fC[ 7]*ex + fC[11]*ey + fC[16]*ez, 
-    h2 = fC[ 8]*ex + fC[12]*ey + fC[17]*ez,
-    h3 = fC[ 9]*ex + fC[13]*ey + fC[18]*ez, 
-    h4 = fC[13]*ex + fC[14]*ey + fC[19]*ez, 
-    h5 = fC[18]*ex + fC[19]*ey + fC[20]*ez,
-    h6 = fC[24]*ex + fC[25]*ey + fC[26]*ez,
-    d  = h3*ex + h4*ey + h5*ez, 
-    hh = h6 - qp*d ;
-
-  fC[ 6]= a*(fC[ 6] -ex*h0); fC[ 7]= a*(fC[ 7] -ex*h1); fC[ 8]= a*(fC[ 8] -ex*h2); 
-  fC[10]= a*(fC[10] -ey*h0); fC[11]= a*(fC[11] -ey*h1); fC[12]= a*(fC[12] -ey*h2); 
-  fC[15]= a*(fC[15] -ez*h0); fC[16]= a*(fC[16] -ez*h1); fC[17]= a*(fC[17] -ez*h2); 
-  fC[21]= a*(fC[21] -qp*h0); fC[22]= a*(fC[22] -qp*h1); fC[23]= a*(fC[23] -qp*h2);     
-
-  fC[ 9]= a2*( fC[ 9] -h3*ex -h3*ex + d*ex*ex );
-  fC[13]= a2*( fC[13] -h4*ex -h3*ey + d*ey*ex ); 
-  fC[14]= a2*( fC[14] -h4*ey -h4*ey + d*ey*ey );
-
-  fC[18]= a2*( fC[18] -h5*ex -h3*ez + d*ez*ex ); 
-  fC[19]= a2*( fC[19] -h5*ey -h4*ez + d*ez*ey ); 
-  fC[20]= a2*( fC[20] -h5*ez -h5*ez + d*ez*ez );
-
-  fC[24]= a2*( fC[24] -qp*h3 - hh*ex ); 
-  fC[25]= a2*( fC[25] -qp*h4 - hh*ey ); 
-  fC[26]= a2*( fC[26] -qp*h5 - hh*ez );
-  fC[27]= a2*( fC[27] -qp*h6 - hh*qp  ); 
-}
-
-
-Double_t AliHLTTPCCATrackPar::GetDsToPointBz( Double_t Bz, const Double_t xyz[3], const Double_t *T0 ) const
-{
-  //* Get dS distance to the given space point for Bz field
-  //*
-
-  const Double_t kCLight = 0.000299792458;
-  Double_t bq = Bz*T0[6]*kCLight;
-  Double_t pt2 = T0[3]*T0[3] + T0[4]*T0[4];
-  if( pt2<1.e-4 ) return 0;
-  Double_t dx = xyz[0] - T0[0];
-  Double_t dy = xyz[1] - T0[1]; 
-  Double_t a = dx*T0[3]+dy*T0[4];
-  Double_t dS = 0;
-  if( TMath::Abs(bq)<1.e-8 ) dS = a/pt2;
-  else dS = TMath::ATan2( bq*a, pt2 + bq*(dy*T0[3] -dx*T0[4]) )/bq;
-  return dS;
-}
-
-Double_t AliHLTTPCCATrackPar::GetDsToPointBz( Double_t Bz, const Double_t xyz[3] ) const 
-{
-  return GetDsToPointBz( Bz, xyz, fP );
-}
-
-void AliHLTTPCCATrackPar::TransportBz( Double_t Bz, Double_t S, Double_t *T0 ) 
-{ 
-  //* Transport the particle on dS, for Bz field
-  const Double_t kCLight = 0.000299792458;
-  Bz = Bz*kCLight;
-  Double_t bs= Bz*S;
-  Double_t bqs= bs*T0[6];
-  Double_t s = TMath::Sin(bqs), c = TMath::Cos(bqs);
-  Double_t sB, cB, dsB, dcB;
-  if( TMath::Abs(bqs)>1.e-10){
-    sB= s/Bz/T0[6];
-    cB= (1-c)/Bz/T0[6];
-    dsB = (c*S - sB)/T0[6];
-    dcB = (s*S-cB)/T0[6];
-  }else{
-    sB = (1. - bqs*bqs/6.)*S;
-    cB = .5*sB*bqs;
-    dsB = - T0[6]*bs*bs/3.*S;
-    dcB = .5*(sB*bs - dsB*bqs);
-  }
-  
-  Double_t px = T0[3];
-  Double_t py = T0[4];
-  Double_t pz = T0[5];
-  
-  Double_t d[7] = { fP[0]-T0[0], fP[1]-T0[1], fP[2]-T0[2], 
-                   fP[3]-T0[3], fP[4]-T0[4], fP[5]-T0[5], fP[6]-T0[6] };
-
-  T0[0] = T0[0] + sB*px + cB*py;
-  T0[1] = T0[1] - cB*px + sB*py;
-  T0[2] = T0[2] +  S*pz                       ;
-  T0[3] =          c*px + s*py;
-  T0[4] =         -s*px + c*py;
-  T0[5] = T0[5];
-  T0[6] = T0[6];
-
-  //* The Jacobian matrix is:
-  //* J[7][7] = { {1,0,0,   sB, cB,  0,   dsB*px + dcB*py },
-  //*             {0,1,0,  -cB, sB,  0, - dcB*px + dsB*py },
-  //*             {0,0,1,    0,  0,  S,   0               },
-  //*             {0,0,0,    c,  s,  0,   (-s*px + c*py)*bs },
-  //*             {0,0,0,   -s,  c,  0,   (-c*px - s*py)*bs },
-  //*             {0,0,0,    0,  0,  1,   0                 },
-  //*             {0,0,0,    0,  0,  0,   1                 }  };
-  //*
-  //* below the fP=T0+J*(fP-T0) and fC=J*fC*Jt operations are performed
-  //*
-
-  Double_t h0 = dsB*px + dcB*py;
-  Double_t h1 = - dcB*px + dsB*py ;
-  Double_t h3 = (-s*px + c*py)*bs ;
-  Double_t h4 = (-c*px - s*py)*bs ;
-
-
-  fP[0] = T0[0] + d[0] + sB*d[3] + cB*d[4] + h0*d[6];
-  fP[1] = T0[1] + d[1] - cB*d[3] + sB*d[4] + h1*d[6];
-  fP[2] = T0[2] + d[2] + S*d[5];
-  fP[3] = T0[3] + c*d[3] + s*d[4] + h3*d[6];
-  fP[4] = T0[4] - s*d[3] + c*d[4] + h4*d[6];
-  fP[5] = T0[5] + d[5];
-  fP[6] = T0[6] + d[6];
-  
-
-  Double_t 
-    c00 = fC[ 0],
-    c01 = fC[ 1], c02 = fC[ 2],
-    c03 = fC[ 3], c04 = fC[ 4], c05 = fC[ 5],
-    c06 = fC[ 6], c07 = fC[ 7], c08 = fC[ 8], c09 = fC[ 9], 
-    c10 = fC[10], c11 = fC[11], c12 = fC[12], c13 = fC[13], c14 = fC[14], 
-    c15 = fC[15], c16 = fC[16], c17 = fC[17], c18 = fC[18], c19 = fC[19], c20 = fC[20], 
-    c21 = fC[21], c22 = fC[22], c23 = fC[23], c24 = fC[24], c25 = fC[25], c26 = fC[26], c27 = fC[27];
-
-  fC[ 0] = c00 + 2*c10*cB + c14*cB*cB + 2*c21*h0 + 2*c25*cB*h0 + c27*h0*h0 + 2*c06*sB + 2*c13*cB*sB + 2*c24*h0*sB + c09*sB*sB;
-  fC[ 1] = c01 - c06*cB + c21*h1 + c10*sB + sB*(c07 - c09*cB + c24*h1 + c13*sB) 
-    + cB*(c11 - c13*cB + c25*h1 + c14*sB) + h0*(c22 - c24*cB + c27*h1 + c25*sB);
-  fC[ 2] = c02 - 2*c07*cB + c09*cB*cB + 2*c22*h1 - 2*c24*cB*h1 + c27*h1*h1 
-    + 2*c11*sB - 2*c13*cB*sB + 2*c25*h1*sB + c14*sB*sB;
-  fC[ 3] = c03 + c12*cB + c23*h0 + c15*S + c19*cB*S + c26*h0*S + c08*sB + c18*S*sB;
-  fC[ 4] = c04 + c16*S  - cB*(c08 + c18*S) + h1*(c23 + c26*S) + (c12 + c19*S)*sB;
-  fC[ 5] = c05 + S*(2*c17 + c20*S);
-  fC[ 6] = c21*h3 + c25*cB*h3 + c27*h0*h3 + c10*s + c14*cB*s + c25*h0*s + c24*h3*sB + c13*s*sB + c*(c06 + c13*cB + c24*h0 + c09*sB);
-  fC[ 7] =  c*c07 + c22*h3 + c11*s - cB*(c*c09 + c24*h3 + c13*s) + 
-    h1*(c*c24 + c27*h3 + c25*s) + (c*c13 + c25*h3 + c14*s)*sB;
-  fC[ 8] = c23*h3 + c12*s + c26*h3*S + c19*s*S + c*(c08 + c18*S);
-  fC[ 9] = c*c*c09 + c27*h3*h3 + 2*c*(c24*h3 + c13*s) + s*(2*c25*h3 + c14*s);
-  fC[10] = c21*h4 + c25*cB*h4 + c27*h0*h4 - c06*s - c13*cB*s - c24*h0*s 
-    + c24*h4*sB - c09*s*sB + c*(c10 + c14*cB + c25*h0 + c13*sB);
-  fC[11] =  c22*h4 - c24*cB*h4 + c27*h1*h4 - c07*s + c09*cB*s - c24*h1*s + 
-    c25*h4*sB - c13*s*sB + c*(c11 - c13*cB + c25*h1 + c14*sB);
-  fC[12] =  c23*h4 - c08*s + c26*h4*S - c18*s*S + c*(c12 + c19*S);
-  fC[13] =  c*c*c13 + c27*h3*h4 - s*(c24*h3 - c25*h4 + c13*s) + c*(c25*h3 + c24*h4 - c09*s + c14*s);
-  fC[14] = c*c*c14 + 2*c*c25*h4 + c27*h4*h4 - 2*c*c13*s - 2*c24*h4*s + c09*s*s;
-  fC[15] = c15 + c19*cB + c26*h0 + c18*sB;
-  fC[16] = c16 - c18*cB + c26*h1 + c19*sB;
-  fC[17] = c17 + c20*S;
-  fC[18] = c*c18 + c26*h3 + c19*s;
-  fC[19] = c*c19 + c26*h4 - c18*s;
-  fC[20] = c20;
-  fC[21] = c21 + c25*cB + c27*h0 + c24*sB;
-  fC[22] = c22 - c24*cB + c27*h1 + c25*sB;
-  fC[23] = c23 + c26*S;
-  fC[24] = c*c24 + c27*h3 + c25*s;
-  fC[25] = c*c25 + c27*h4 - c24*s;
-  fC[26] = c26;
-  fC[27] = c27;
-}
-
-void AliHLTTPCCATrackPar::TransportBz( Double_t Bz, Double_t dS ) 
-{ 
-  //* Transport the particle on dS, for Bz field
-  TransportBz( Bz, dS, fP );
-}
-
-void AliHLTTPCCATrackPar::GetConnectionMatrix( Double_t B, const Double_t p[3], Double_t G[6], const Double_t *T0  ) const 
-{
-  //* Calculate connection matrix between track and point p
-  if( !G ) return;
-  const Double_t kLight = 0.000299792458;
-  B*=kLight;
-  Double_t dx = p[0]-T0[0], dy = p[1]-T0[1], dz = p[2]-T0[2];
-  Double_t px2= T0[3]*T0[3], py2= T0[4]*T0[4], pz2= T0[5]*T0[5];
-  //Double_t B2 = B*B;
-  Double_t s2 = (dx*dx + dy*dy + dz*dz);
-  Double_t p2 = px2 + py2 + pz2;
-  if( p2>1.e-4 ) s2/=p2;
-  Double_t x = T0[3]*s2;
-  Double_t xx= px2*s2, xy= x*T0[4], xz= x*T0[5], yy= py2*s2, yz= T0[4]*T0[5]*s2;
-  //Double_t Bxy= B*xy; 
-  G[ 0]= xx;
-  G[ 1]= xy;   G[ 2]= yy;
-  G[ 3]= xz;   G[ 4]= yz;   G[ 5]= pz2*s2;  
-  /*
-  C[ 0]+= xx;
-  C[ 1]+= xy;   C[ 2]+= yy;
-  C[ 3]+= xz;   C[ 4]+= yz;   C[ 5]+= pz2*s2;  
-  C[ 6]+= Bxy; C[ 7]+= B*yy; C[ 8]+= B*yz;    C[ 9]+=B2*yy;
-  C[10]-= B*xx; C[11]-= Bxy; C[12]-=B*xz;     C[13]-=B2*xy; C[14]+=B2*xx;  
-  */
-}
-
-
-void AliHLTTPCCATrackPar::Filter( const Double_t m[3], const Double_t V[6], const Double_t G[6] )
-{
-  //* Add the measurement m to the track using the Kalman Filter mathematics
-  //* m[3] is the measurement
-  //* V[6] is the low-triangular covariance matrix
-  //* G[6] is the track->measurement "connection matrix", additional to V[]
-  //*
-
-  Double_t 
-    c00 = fC[ 0],
-    c10 = fC[ 1], c11 = fC[ 2],
-    c20 = fC[ 3], c21 = fC[ 4], c22 = fC[ 5],
-    c30 = fC[ 6], c31 = fC[ 7], c32 = fC[ 8],
-    c40 = fC[10], c41 = fC[11], c42 = fC[12],
-    c50 = fC[15], c51 = fC[16], c52 = fC[17],
-    c60 = fC[21], c61 = fC[22], c62 = fC[23];
-  
-  Double_t
-    z0 = m[0]-fP[0],
-    z1 = m[1]-fP[1],
-    z2 = m[2]-fP[2];
-  
-  Double_t mS[6] = { c00+V[0]+G[0], c10+V[1]+G[1], c11+V[2]+G[2],
-                    c20+V[3]+G[3], c21+V[4]+G[4], c22+V[5]+G[5] };
-  Double_t mSi[6];
-  mSi[0] = mS[4]*mS[4] - mS[2]*mS[5];
-  mSi[1] = mS[1]*mS[5] - mS[3]*mS[4];
-  mSi[3] = mS[2]*mS[3] - mS[1]*mS[4];
-  Double_t det = (mS[0]*mSi[0] + mS[1]*mSi[1] + mS[3]*mSi[3]);
-  if( TMath::Abs(det)<1.e-10 ) return;
-  det = 1./det;
-  mSi[0] *= det;
-  mSi[1] *= det;
-  mSi[3] *= det;
-  mSi[2] = ( mS[3]*mS[3] - mS[0]*mS[5] )*det;
-  mSi[4] = ( mS[0]*mS[4] - mS[1]*mS[3] )*det;
-  mSi[5] = ( mS[1]*mS[1] - mS[0]*mS[2] )*det;
-  
-  fNDF  += 2;
-  fChi2 += ( +(mSi[0]*z0 + mSi[1]*z1 + mSi[3]*z2)*z0
-           +(mSi[1]*z0 + mSi[2]*z1 + mSi[4]*z2)*z1
-           +(mSi[3]*z0 + mSi[4]*z1 + mSi[5]*z2)*z2 );
-        
-  Double_t k0, k1, k2 ; // k = CHtS
-    
-  k0 = c00*mSi[0] + c10*mSi[1] + c20*mSi[3];
-  k1 = c00*mSi[1] + c10*mSi[2] + c20*mSi[4];
-  k2 = c00*mSi[3] + c10*mSi[4] + c20*mSi[5];
-    
-  fP[ 0]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[ 0]-= k0*c00 + k1*c10 + k2*c20;
-  
-  k0 = c10*mSi[0] + c11*mSi[1] + c21*mSi[3];
-  k1 = c10*mSi[1] + c11*mSi[2] + c21*mSi[4];
-  k2 = c10*mSi[3] + c11*mSi[4] + c21*mSi[5];
-  
-  fP[ 1]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[ 1]-= k0*c00 + k1*c10 + k2*c20;
-  fC[ 2]-= k0*c10 + k1*c11 + k2*c21;
-  
-  k0 = c20*mSi[0] + c21*mSi[1] + c22*mSi[3];
-  k1 = c20*mSi[1] + c21*mSi[2] + c22*mSi[4];
-  k2 = c20*mSi[3] + c21*mSi[4] + c22*mSi[5];
-  
-  fP[ 2]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[ 3]-= k0*c00 + k1*c10 + k2*c20;
-  fC[ 4]-= k0*c10 + k1*c11 + k2*c21;
-  fC[ 5]-= k0*c20 + k1*c21 + k2*c22;
-  
-  k0 = c30*mSi[0] + c31*mSi[1] + c32*mSi[3];
-  k1 = c30*mSi[1] + c31*mSi[2] + c32*mSi[4];
-  k2 = c30*mSi[3] + c31*mSi[4] + c32*mSi[5];
-  
-  fP[ 3]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[ 6]-= k0*c00 + k1*c10 + k2*c20;
-  fC[ 7]-= k0*c10 + k1*c11 + k2*c21;
-  fC[ 8]-= k0*c20 + k1*c21 + k2*c22;
-  fC[ 9]-= k0*c30 + k1*c31 + k2*c32;
-  
-  k0 = c40*mSi[0] + c41*mSi[1] + c42*mSi[3];
-  k1 = c40*mSi[1] + c41*mSi[2] + c42*mSi[4];
-  k2 = c40*mSi[3] + c41*mSi[4] + c42*mSi[5];
-    
-  fP[ 4]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[10]-= k0*c00 + k1*c10 + k2*c20;
-  fC[11]-= k0*c10 + k1*c11 + k2*c21;
-  fC[12]-= k0*c20 + k1*c21 + k2*c22;
-  fC[13]-= k0*c30 + k1*c31 + k2*c32;
-  fC[14]-= k0*c40 + k1*c41 + k2*c42;
-
-  k0 = c50*mSi[0] + c51*mSi[1] + c52*mSi[3];
-  k1 = c50*mSi[1] + c51*mSi[2] + c52*mSi[4];
-  k2 = c50*mSi[3] + c51*mSi[4] + c52*mSi[5];
-  
-  fP[ 5]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[15]-= k0*c00 + k1*c10 + k2*c20;
-  fC[16]-= k0*c10 + k1*c11 + k2*c21;
-  fC[17]-= k0*c20 + k1*c21 + k2*c22;
-  fC[18]-= k0*c30 + k1*c31 + k2*c32;
-  fC[19]-= k0*c40 + k1*c41 + k2*c42;
-  fC[20]-= k0*c50 + k1*c51 + k2*c52;
-
-  k0 = c60*mSi[0] + c61*mSi[1] + c62*mSi[3];
-  k1 = c60*mSi[1] + c61*mSi[2] + c62*mSi[4];
-  k2 = c60*mSi[3] + c61*mSi[4] + c62*mSi[5];
-  
-  fP[ 6]+= k0*z0  + k1*z1  + k2*z2 ;
-  fC[21]-= k0*c00 + k1*c10 + k2*c20;
-  fC[22]-= k0*c10 + k1*c11 + k2*c21;
-  fC[23]-= k0*c20 + k1*c21 + k2*c22;
-  fC[24]-= k0*c30 + k1*c31 + k2*c32;
-  fC[25]-= k0*c40 + k1*c41 + k2*c42;
-  fC[26]-= k0*c50 + k1*c51 + k2*c52;
-  fC[27]-= k0*c60 + k1*c61 + k2*c62;
-}
-
-
-void AliHLTTPCCATrackPar::Rotate( Double_t alpha )
-{
-  //* Rotate the track parameters on the alpha angle 
-
-  Double_t cA = TMath::Cos( alpha );
-  Double_t sA = TMath::Sin( alpha );
-  Double_t x= fP[0], y= fP[1], px= fP[3], py= fP[4];
-  fP[0] = x*cA + y*sA;
-  fP[1] =-x*sA + y*cA;
-  fP[2] = fP[2];
-  fP[3] = px*cA + py*sA;
-  fP[4] =-px*sA + py*cA;
-  fP[5] = fP[5];
-  fP[6] = fP[6];
-
-  Double_t mJ[7][7] = { { cA,sA, 0,  0,  0,  0,  0 },
-                        {-sA,cA, 0,  0,  0,  0,  0 },
-                        {  0, 0, 1,  0,  0,  0,  0 },
-                        {  0, 0, 0, cA, sA,  0,  0 },
-                        {  0, 0, 0,-sA, cA,  0,  0 },
-                        {  0, 0, 0,  0,  0,  1,  0 },
-                        {  0, 0, 0,  0,  0,  0,  1 }  };
-
-  Double_t mA[7][7];
-  for( Int_t k=0,i=0; i<7; i++)
-    for( Int_t j=0; j<=i; j++, k++ ) mA[i][j] = mA[j][i] = fC[k]; 
-
-  Double_t mJC[7][7];
-  for( Int_t i=0; i<7; i++ )
-    for( Int_t j=0; j<7; j++ ){
-      mJC[i][j]=0;
-      for( Int_t k=0; k<7; k++ ) mJC[i][j]+=mJ[i][k]*mA[k][j];
-    }
-  
-  for( Int_t k=0,i=0; i<7; i++)
-    for( Int_t j=0; j<=i; j++, k++ ){
-      fC[k] = 0;
-      for( Int_t l=0; l<7; l++ ) fC[k]+=mJC[i][l]*mJ[j][l];
-    }
-}
-
-
-void AliHLTTPCCATrackPar::ConvertTo5( Double_t alpha, Double_t T[], Double_t C[] )
-const 
-{
-  //* Convert the track parameterisation to {y,z,ty,tz,q/p,x}
-  //* The result is stored in T[], corresponding covariance matrix in C[]
-  //*
-  //* The method is used for debuging
-  //*
-
-  AliHLTTPCCATrackPar t = *this;
-  t.Rotate(alpha);
-  Double_t 
-    x= t.fP[0], y= t.fP[1], z = t.fP[2], 
-    ex= t.fP[3], ey= t.fP[4], ez = t.fP[5], qp = t.fP[6];
-
-  Double_t p2 = ex*ex+ey*ey+ez*ez;
-  if( p2<1.e-4 ) p2 = 1;
-  Double_t n2 = 1./p2;
-  Double_t n = sqrt(n2);
-
-  T[5] = x;
-  T[0] = y;
-  T[1] = z;
-  T[2] = ey/ex;
-  T[3] = ez/ex;
-  T[4] = qp*n;
-
-  Double_t mJ[5][7] = { { -T[2], 1, 0,  0,  0,  0,  0 },
-                        { -T[3], 0, 1,  0,  0,  0,  0 },
-                        { 0, 0, 0,  -T[2]/ex,  1./ex,  0,  0 },
-                        { 0, 0, 0, -T[3]/ex,  0,  1./ex,  0 },
-                        { 0, 0, 0, -T[4]*n2*ex, -T[4]*n2*ey, -T[4]*n2*ez, n }};
-
-  Double_t mA[7][7];
-  for( Int_t k=0,i=0; i<7; i++)
-    for( Int_t j=0; j<=i; j++, k++ ) mA[i][j] = mA[j][i] = t.fC[k]; 
-
-  Double_t mJC[5][7];
-  for( Int_t i=0; i<5; i++ )
-    for( Int_t j=0; j<7; j++ ){
-      mJC[i][j]=0;
-      for( Int_t k=0; k<7; k++ ) mJC[i][j]+=mJ[i][k]*mA[k][j];
-    }
-  
-  for( Int_t k=0,i=0; i<5; i++)
-    for( Int_t j=0; j<=i; j++, k++ ){
-      C[k] = 0;
-      for( Int_t l=0; l<7; l++ ) C[k]+=mJC[i][l]*mJ[j][l];
-    }
-}
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackPar.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackPar.h
deleted file mode 100644 (file)
index 6968e57..0000000
+++ /dev/null
@@ -1,94 +0,0 @@
-//-*- Mode: C++ -*-
-// @(#) $Id$
-//*************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
-// ALICE Experiment at CERN, All rights reserved.                         *
-//                                                                        *
-// Primary Authors: Jochen Thaeder <thaeder@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.                  *
-//*************************************************************************
-
-
-#ifndef ALIHLTTPCCATRACKPAR_H
-#define ALIHLTTPCCATRACKPAR_H
-
-#include "Rtypes.h"
-
-/**
- * @class AliHLTTPCCATrackPar
- *
- * AliHLTTPCCATrackPar class describes the track parametrisation
- * which is used by the AliHLTTPCCATracker slice tracker.
- * The class is under development.
- *
- */
-class AliHLTTPCCATrackPar 
-{
- public:
-
-  AliHLTTPCCATrackPar(): fChi2(0), fNDF(0){}
-  virtual ~AliHLTTPCCATrackPar(){}
-
-  Double_t *Par(){ return fP; }
-  Double_t *Cov(){ return fC; }
-  Double_t &Chi2(){ return fChi2; }
-  Int_t &NDF(){ return fNDF; }
-
-  void Init();
-  void Normalize( Double_t Direction[3]=0 );
-
-  void TransportBz( Double_t Bz, Double_t S );
-  void TransportBz( Double_t Bz, Double_t S, Double_t *T0 );
-
-  Double_t GetDsToPointBz( Double_t Bz, const Double_t xyz[3] ) const;
-  Double_t GetDsToPointBz( Double_t Bz, const Double_t xyz[3], const Double_t *T0 ) const;
-
-  void TransportBz( Double_t Bz, const Double_t xyz[3] )
-  { 
-    TransportBz( Bz,GetDsToPointBz(Bz, xyz)) ; 
-  }
-
-  void TransportBz( Double_t Bz, const Double_t xyz[3], Double_t *T0 )
-  { 
-    TransportBz( Bz,GetDsToPointBz(Bz, xyz, T0), T0) ; 
-  }
-
-  void TransportBz( Double_t Bz, Double_t x, Double_t y, Double_t z )
-  { 
-    Double_t xyz[3] = {x,y,z};
-    TransportBz(Bz, xyz);
-  }
-
-  void GetConnectionMatrix( Double_t Bz, const Double_t p[3], Double_t G[6], const Double_t *T0  ) const ;
-
-  void GetConnectionMatrix( Double_t Bz, const Double_t p[3], Double_t G[6] ) const 
-  {
-    GetConnectionMatrix( Bz, p, G, fP );
-  }
-
-  void Filter( const Double_t m[3], const Double_t V[6], const Double_t V1[6] );
-  void Rotate( Double_t alpha );
-  void ConvertTo5( Double_t alpha, Double_t T[], Double_t C[] ) const;
-
- private:
-
-  Double_t fP[7];  // track parameters:  X, Y, Z, ex, ey, ez, q/P
-  Double_t fC[28]; // the covariance matrix in the low-triangular form
-  Double_t fChi2;  // the chi^2 value
-  Int_t fNDF;      // the Number of Degrees of Freedom
-
-  ClassDef(AliHLTTPCCATrackPar, 0);
-
-};
-
-
-#endif
index 825a9af..018dbe4 100644 (file)
@@ -323,6 +323,65 @@ GPUd() Int_t  AliHLTTPCCATrackParam::TransportToX( Float_t x, Float_t maxSinPhi
   return 1;
 }
 
+GPUd() Int_t  AliHLTTPCCATrackParam::TransportToX0( Float_t x, Float_t /**/ )
+{
+  //* Transport the track parameters to X=x 
+
+  Float_t ex = fCosPhi;
+  if( CAMath::Abs(ex)<1.e-4 ) return 0;
+
+  Float_t ey = fP[2];
+  Float_t dx = x - fX;  
+  Float_t exi = 1./ex;
+  Float_t dS = dx*exi;
+  Float_t dy = dS*ey;
+  Float_t dz = dS*fP[3];
+  Float_t h2 = dS*exi*exi;
+  Float_t h4 = 0.5*dx*h2;
+  
+  fX = x;
+  fP[0]+= dy + h4*fP[4];
+  fP[1]+= dz;
+  fP[2]+= dx*fP[4];
+
+  //Float_t H0[5] = { 1,0, h2,  0, h4 };
+  //Float_t H1[5] = { 0, 1, 0, dS,  0 };
+  //Float_t H2[5] = { 0, 0, 1,  0, dx };
+  //Float_t H3[5] = { 0, 0, 0,  1,  0 };
+  //Float_t H4[5] = { 0, 0, 0,  0,  1 };
+
+
+  Float_t c00 = fC[0];
+  Float_t c11 = fC[2];
+  Float_t c20 = fC[3];
+  Float_t c22 = fC[5];
+  Float_t c31 = fC[7];
+  Float_t c33 = fC[9];
+  Float_t c40 = fC[10];
+  Float_t c42 = fC[12];
+  Float_t c44 = fC[14];
+
+  Float_t c40ph4c44 = c40 + h4*c44;
+  Float_t c20ph4c42 = c20 +  h4*c42;
+  Float_t c20ph2c22ph4c42 = h2*c22 + c20ph4c42;
+  Float_t fC10 = c40ph4c44 + h2*c42;
+  Float_t fC12 = c42 + dx*c44;
+  Float_t fC7 = c31 + dS*c33;
+
+  fC[10]= fC10;
+  fC[12]= fC12;
+  fC[7]= fC7;
+  fC[0]= c00  + h2*( c20ph2c22ph4c42 + c20ph4c42) + h4*(c40ph4c44 + c40 ) ; 
+  fC[3]= c20ph2c22ph4c42 + dx*fC10;
+  fC[5]= c22 + dx*( c42 + fC12 );
+  fC[2]= c11 + dS*(c31 + fC7);
+  return 1;
+}
+
+
+
+
 GPUd() Bool_t AliHLTTPCCATrackParam::TransportToXWithMaterial( Float_t Xto, Float_t Bz )
 {
   //* Transport the track parameters to X=Xto
@@ -751,6 +810,67 @@ GPUd() Bool_t AliHLTTPCCATrackParam::Filter2v1( Float_t y, Float_t z, Float_t er
   return 1;
 }
 
+GPUd() Bool_t AliHLTTPCCATrackParam::Filter20( Float_t y, Float_t z, Float_t err2Y, Float_t err2Z, Float_t maxSinPhi )
+{
+  //* Add the y,z measurement with the Kalman filter 
+
+  Float_t 
+    c00 = fC[ 0],
+    c11 = fC[ 2],
+    c20 = fC[ 3],
+    c31 = fC[ 7],
+    c40 = fC[10];
+
+  err2Y+=c00;
+  err2Z+=c11;
+
+  Float_t
+    z0 = y-fP[0],
+    z1 = z-fP[1];
+  
+  if( err2Y < 1.e-8 || err2Z<1.e-8 ) return 0;
+
+  Float_t mS0 = 1./err2Y;
+  Float_t mS2 = 1./err2Z;
+  // K = CHtS
+  
+  Float_t k00, k11, k20, k31, k40;
+    
+  k00 = c00*mS0;
+  k20 = c20*mS0;
+  k40 = c40*mS0;
+
+  k11 = c11*mS2;
+  k31 = c31*mS2;
+
+  Float_t sinPhi = fP[2] + k20*z0  ;
+  if( CAMath::Abs(sinPhi)>= maxSinPhi ) return 0;
+
+  Float_t cosPhi = CAMath::Sqrt(1-sinPhi*sinPhi);
+  fNDF  += 2;
+  fChi2 += mS0*z0*z0 + mS2*z1*z1 ;
+
+  fP[ 0]+= k00*z0 ;
+  fP[ 1]+= k11*z1 ;
+  fP[ 2] = sinPhi ;
+  fP[ 3]+= k31*z1 ;
+  fP[ 4]+= k40*z0 ;
+    
+  fC[ 0]-= k00*c00 ;    
+  fC[ 3]-= k20*c00 ;
+  fC[ 5]-= k20*c20 ;
+  fC[10]-= k40*c00 ;
+  fC[12]-= k40*c20 ;
+  fC[14]-= k40*c40 ;
+  fC[ 2]-= k11*c11 ;
+  fC[ 7]-= k31*c11 ;
+  fC[ 9]-= k31*c31 ;
+   
+  fCosPhi = ( fCosPhi >=0 ) ?cosPhi :-cosPhi;
+  return 1;
+}
 
 
 
@@ -894,11 +1014,7 @@ GPUd() void AliHLTTPCCATrackParam::FilterZ( Float_t z, Float_t errz )
 }
 
 #if !defined(HLTCA_GPUCODE)
-#if defined( HLTCA_STANDALONE )
-#include <iostream.h>
-#else
-#include "Riostream.h"
-#endif
+#include <iostream>
 #endif
 
 GPUd() void AliHLTTPCCATrackParam::Print() const
@@ -906,7 +1022,7 @@ GPUd() void AliHLTTPCCATrackParam::Print() const
   //* print parameters
  
 #if !defined(HLTCA_GPUCODE)
-  cout<<"track: "<<GetX()<<" "<<GetY()<<" "<<GetZ()<<" "<<GetSinPhi()<<" "<<GetDzDs()<<" "<<GetKappa()<<endl;
-  cout<<"errs2: "<<GetErr2Y()<<" "<<GetErr2Z()<<" "<<GetErr2SinPhi()<<" "<<GetErr2DzDs()<<" "<<GetErr2Kappa()<<endl;
+  std::cout<<"track: "<<GetX()<<" "<<GetY()<<" "<<GetZ()<<" "<<GetSinPhi()<<" "<<GetDzDs()<<" "<<GetKappa()<<std::endl;
+  std::cout<<"errs2: "<<GetErr2Y()<<" "<<GetErr2Z()<<" "<<GetErr2SinPhi()<<" "<<GetErr2DzDs()<<" "<<GetErr2Kappa()<<std::endl;
 #endif
 }
index 8f4ddf6..4c1b8f3 100644 (file)
@@ -89,6 +89,10 @@ class AliHLTTPCCATrackParam
   GPUd() Bool_t Rotate( Float_t alpha );
 
   GPUd() Bool_t Filter2( Float_t y, Float_t z, Float_t err2Y, Float_t err2Z, Float_t maxSinPhi=.99 );
+
+  GPUd() Int_t TransportToX0( Float_t X, Float_t /*maxSinPhi*/ );
+  GPUd() Bool_t Filter20( Float_t y, Float_t z, Float_t err2Y, Float_t err2Z, Float_t maxSinPhi=.99 );
+
   GPUd() Bool_t Filter2v1( Float_t y, Float_t z, Float_t err2Y, Float_t err2Z, Float_t maxSinPhi=.99 );
   GPUd() void FilterY( Float_t y, Float_t erry );
   GPUd() void FilterZ( Float_t z, Float_t errz );
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam1.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam1.cxx
deleted file mode 100644 (file)
index d334a1c..0000000
+++ /dev/null
@@ -1,949 +0,0 @@
-// $Id: AliHLTTPCCATrackParam1.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.                           *
-//                                                                          *
-// 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 "AliHLTTPCCATrackParam1.h"
-#include "AliHLTTPCCAMath.h"
-
-
-//
-// Circle in XY:
-// 
-// R  = 1/TMath::Abs(Kappa);
-// Xc = X - sin(Phi)/Kappa;
-// Yc = Y + cos(Phi)/Kappa;
-//
-
-
-
-GPUd() void AliHLTTPCCATrackParam1::ConstructXY3( const Float_t x[3], const Float_t y[3], 
-                                         const Float_t sigmaY2[3], Float_t CosPhi0 )
-{
-  //* Construct the track in XY plane by 3 points
-
-  Float_t x0 = x[0];
-  Float_t y0 = y[0];
-  Float_t x1 = x[1] - x0;
-  Float_t y1 = y[1] - y0;
-  Float_t x2 = x[2] - x0;
-  Float_t y2 = y[2] - y0;
-  
-  Float_t a1 = x1*x1 + y1*y1;
-  Float_t a2 = x2*x2 + y2*y2;
-  Float_t a = 2*(x1*y2 - y1*x2);
-  Float_t lx =  a1*y2 - a2*y1;
-  Float_t ly = -a1*x2 + a2*x1;
-  Float_t l = CAMath::Sqrt(lx*lx + ly*ly);
-  Float_t li = 1./l;
-  Float_t li2 = li*li;
-  Float_t li3 = li2*li;
-  Float_t cosPhi = ly*li;
-
-  Float_t sinPhi = -lx*li;
-  Float_t kappa = a/l;
-
-  Float_t dlx = a2 - a1;     //  D lx / D y0
-  Float_t dly = -a;          //  D ly / D y0
-  Float_t dA  = 2*(x2 - x1); // D a  / D y0
-  Float_t dl = (lx*dlx + ly*dly)*li;
-  
-  // D sinPhi,kappa / D y0
-
-  Float_t d0[2] = { -(dlx*ly-lx*dly)*ly*li3, (dA*l-a*dl)*li2 };
-
-  // D sinPhi,kappa / D y1 
-
-  dlx = -a2 + 2*y1*y2;
-  dly = -2*x2*y1;
-  dA  = -2*x2;
-  dl = (lx*dlx + ly*dly)*li;
-
-  Float_t d1[2] = { -(dlx*ly-lx*dly)*ly*li3, (dA*l-a*dl)*li2 };
-
-  // D sinPhi,kappa / D y2
-
-  dlx = a1 - 2*y1*y2;
-  dly = -2*x1*y2;
-  dA  = 2*x1;
-  dl = (lx*dlx + ly*dly)*li;
-
-  Float_t d2[2] = { -(dlx*ly-lx*dly)*ly*li3, (dA*l-a*dl)*li2 };
-   
-  if( CosPhi0*cosPhi <0 ){
-    cosPhi = -cosPhi;
-    sinPhi = -sinPhi;
-    kappa = -kappa;   
-    d0[0] = -d0[0];
-    d0[1] = -d0[1];
-    d1[0] = -d1[0];
-    d1[1] = -d1[1];
-    d2[0] = -d2[0];
-    d2[1] = -d2[1];
-  }
-  
-  X() = x0;  
-  Y() = y0;
-  SinPhi() = sinPhi;
-  Kappa() = kappa;
-  CosPhi() = cosPhi;
-
-  Float_t s0 = sigmaY2[0];
-  Float_t s1 = sigmaY2[1];
-  Float_t s2 = sigmaY2[2];
-
-  fC[0] = s0;
-  fC[1] = 0;
-  fC[2] = 100.;
-
-  fC[3] = d0[0]*s0;
-  fC[4] = 0;
-  fC[5] = d0[0]*d0[0]*s0 + d1[0]*d1[0]*s1 + d2[0]*d2[0]*s2;
-
-  fC[6] = 0;
-  fC[7] = 0;
-  fC[8] = 0;
-  fC[9] = 100.;
-
-  fC[10] = d0[1]*s0;
-  fC[11] = 0;
-  fC[12] = d0[0]*d0[1]*s0 + d1[0]*d1[1]*s1 + d2[0]*d2[1]*s2;
-  fC[13] = 0;
-  fC[14] = d0[1]*d0[1]*s0 + d1[1]*d1[1]*s1 + d2[1]*d2[1]*s2;
-}
-
-
-GPUd() Float_t  AliHLTTPCCATrackParam1::GetS( Float_t x, Float_t y ) const
-{
-  //* Get XY path length to the given point
-
-  Float_t k  = GetKappa();
-  Float_t ex = GetCosPhi();
-  Float_t ey = GetSinPhi();
-  x-= GetX();
-  y-= GetY();
-  Float_t dS = x*ex + y*ey;
-  if( CAMath::Abs(k)>1.e-4 ) dS = CAMath::ATan2( k*dS, 1+k*(x*ey-y*ex) )/k;
-  return dS;
-}
-
-GPUd() void  AliHLTTPCCATrackParam1::GetDCAPoint( Float_t x, Float_t y, Float_t z,
-                                          Float_t &xp, Float_t &yp, Float_t &zp ) const
-{
-  //* Get the track point closest to the (x,y,z)
-
-  Float_t x0 = GetX();
-  Float_t y0 = GetY();
-  Float_t k  = GetKappa();
-  Float_t ex = GetCosPhi();
-  Float_t ey = GetSinPhi();
-  Float_t dx = x - x0;
-  Float_t dy = y - y0; 
-  Float_t ax = dx*k+ey;
-  Float_t ay = dy*k-ex;
-  Float_t a = sqrt( ax*ax+ay*ay );
-  xp = x0 + (dx - ey*( (dx*dx+dy*dy)*k - 2*(-dx*ey+dy*ex) )/(a+1) )/a;
-  yp = y0 + (dy + ex*( (dx*dx+dy*dy)*k - 2*(-dx*ey+dy*ex) )/(a+1) )/a;
-  Float_t s = GetS(x,y);
-  zp = GetZ() + GetDzDs()*s;
-  if( CAMath::Abs(k)>1.e-2 ){
-    Float_t dZ = CAMath::Abs( GetDzDs()*CAMath::TwoPi()/k );
-    if( dZ>.1 ){
-      zp+= CAMath::Nint((z-zp)/dZ)*dZ;    
-    }
-  }
-}
-
-GPUd() void AliHLTTPCCATrackParam1::ConstructXYZ3( const Float_t p0[5], const Float_t p1[5], 
-                                          const Float_t p2[5], 
-                                          Float_t CosPhi0, Float_t t0[] )
-{      
-  //* Construct the track in XYZ by 3 points
-
-  Float_t px[3]   = { p0[0], p1[0], p2[0] };
-  Float_t py[3]   = { p0[1], p1[1], p2[1] };
-  Float_t pz[3]   = { p0[2], p1[2], p2[2] };
-  Float_t ps2y[3] = { p0[3]*p0[3], p1[3]*p1[3], p2[3]*p2[3] };
-  Float_t ps2z[3] = { p0[4]*p0[4], p1[4]*p1[4], p2[4]*p2[4] };
-
-  Float_t kold = t0 ?t0[4] :0;
-  ConstructXY3( px, py, ps2y, CosPhi0 );
-
-  Float_t pS[3] = { GetS(px[0],py[0]), GetS(px[1],py[1]), GetS(px[2],py[2]) };
-  Float_t k = Kappa();
-  if( CAMath::Abs(k)>1.e-2 ){    
-    Float_t dS = CAMath::Abs( CAMath::TwoPi()/k );
-    pS[1]+= CAMath::Nint( (pS[0]-pS[1])/dS )*dS; // not more than half turn
-    pS[2]+= CAMath::Nint( (pS[1]-pS[2])/dS )*dS;
-    if( t0 ){
-      Float_t dZ = CAMath::Abs(t0[3]*dS);
-      if( CAMath::Abs(dZ)>1. ){
-       Float_t dsDz = 1./t0[3];
-       if( kold*k<0 ) dsDz = -dsDz;
-       Float_t s0 = (pz[0]-t0[1])*dsDz;
-       Float_t s1 = (pz[1]-t0[1])*dsDz;
-       Float_t s2 = (pz[2]-t0[1])*dsDz;        
-       pS[0]+= CAMath::Nint( (s0-pS[0])/dS )*dS ;
-       pS[1]+= CAMath::Nint( (s1-pS[1])/dS )*dS ;
-       pS[2]+= CAMath::Nint( (s2-pS[2])/dS )*dS ;      
-      }
-    }
-  }
-
-  Float_t s = pS[0] + pS[1] + pS[2];
-  Float_t z = pz[0] + pz[1] + pz[2];
-  Float_t sz = pS[0]*pz[0] + pS[1]*pz[1] + pS[2]*pz[2];
-  Float_t ss = pS[0]*pS[0] + pS[1]*pS[1] + pS[2]*pS[2];
-  
-  Float_t a = 3*ss-s*s;
-  Z() = (z*ss-sz*s)/a; // z0
-  DzDs() = (3*sz-z*s)/a; // t = dz/ds
-    
-  Float_t dz0[3] = {ss - pS[0]*s,ss - pS[1]*s,ss - pS[2]*s };
-  Float_t dt [3] = {3*pS[0] - s, 3*pS[1] - s, 3*pS[2] - s };
-
-  fC[2] = (dz0[0]*dz0[0]*ps2z[0] + dz0[1]*dz0[1]*ps2z[1] + dz0[2]*dz0[2]*ps2z[2])/a/a;
-  fC[7]= (dz0[0]*dt [0]*ps2z[0] + dz0[1]*dt [1]*ps2z[1] + dz0[2]*dt [2]*ps2z[2])/a/a;  
-  fC[9]= (dt [0]*dt [0]*ps2z[0] + dt [1]*dt [1]*ps2z[1] + dt [2]*dt [2]*ps2z[2])/a/a;  
-}
-
-
-GPUd() Int_t  AliHLTTPCCATrackParam1::TransportToX( Float_t x, Float_t maxSinPhi )
-{
-  //* Transport the track parameters to X=x 
-
-  Float_t x0  = X();
-  //Float_t y0  = Y();
-  Float_t k   = Kappa();
-  Float_t ex = CosPhi();
-  Float_t ey = SinPhi();
-  Float_t dx = x - x0;
-
-  Float_t ey1 = k*dx + ey;
-  Float_t ex1;
-  if( CAMath::Abs(ey1)>maxSinPhi ){ // no intersection 
-    return 0;
-  }else{
-    ex1 = CAMath::Sqrt(1 - ey1*ey1);
-    if( ex<0 ) ex1 = -ex1;  
-  }
-  
-  Float_t dx2 = dx*dx;
-  Float_t ss = ey+ey1;
-  Float_t cc = ex+ex1;  
-
-  if( CAMath::Abs(cc)<1.e-4 || CAMath::Abs(ex)<1.e-4 || CAMath::Abs(ex1)<1.e-4 ) return 0;
-
-  Float_t tg = ss/cc; // tan((phi1+phi)/2)
-  
-  Float_t dy = dx*tg;
-  Float_t dl = dx*CAMath::Sqrt(1+tg*tg);
-
-  if( cc<0 ) dl = -dl;
-  Float_t dSin = dl*k/2;
-  if( dSin > 1 ) dSin = 1;
-  if( dSin <-1 ) dSin = -1;
-  Float_t dS = ( CAMath::Abs(k)>1.e-4)  ? (2*CAMath::ASin(dSin)/k) :dl;  
-  Float_t dz = dS*DzDs();
-
-  
-  Float_t cci = 1./cc;
-  Float_t exi = 1./ex;
-  Float_t ex1i = 1./ex1;
-  
-  CosPhi() = ex1;
-  X() += dx;
-  fP[0]+= dy;
-  fP[1]+= dz;
-  fP[2] = ey1;
-  fP[3] = fP[3];
-  fP[4] = fP[4];
-
-  Float_t h2 = dx*(1+ ex*ex1 + ey*ey1 )*cci*exi*ex1i;
-  Float_t h4 = dx2*(cc + ss*ey1*ex1i )*cci*cci;
-
- //Float_t H0[5] = { 1,0, h2,  0, h4 };
-  //Float_t H1[5] = { 0, 1, 0, dS,  0 };
-  //Float_t H2[5] = { 0, 0, 1,  0, dx };
-  //Float_t H3[5] = { 0, 0, 0,  1,  0 };
-  //Float_t H4[5] = { 0, 0, 0,  0,  1 };
-
-  Float_t c00 = fC[0];
-  Float_t c11 = fC[2];
-  Float_t c20 = fC[3];
-  Float_t c22 = fC[5];
-  Float_t c31 = fC[7];
-  Float_t c33 = fC[9];
-  Float_t c40 = fC[10];
-  Float_t c42 = fC[12];
-  Float_t c44 = fC[14];
-
-  float dSc33 = dS*c33;
-  float h2c22 = h2*c22;
-  float h4c42 = h4*c42;
-  float h4c44 = h4*c44;
-  float h2c42 = h2*c42;
-
-  Float_t fC10 = c40 + h2c42 + h4c44;
-  Float_t fC12 = c42 + dx*c44;
-  Float_t fC7 = c31 + dSc33;
-  fC[0]= c00  + h2*h2c22 + h4*h4c44 + 2*( h2*c20 + h4*c40 + h2*h4c42 ) ; 
-  fC[3]= c20 + h2c22 + h4c42 + dx*fC10;
-  fC[10]= fC10;
-  fC[12]= fC12;
-  fC[5]= c22 + dx*( c42 + fC12 );
-
-  fC[7]= fC7;
-  fC[2]= c11 + dS*(c31 + fC7);
-
-  return 1;
-}
-
-GPUd() Int_t  AliHLTTPCCATrackParam1::TransportToX0( Float_t x, Float_t /**/ )
-{
-  //* Transport the track parameters to X=x 
-
-  Float_t ex = fCosPhi;
-  if( CAMath::Abs(ex)<1.e-4 ) return 0;
-
-  Float_t ey = fP[2];
-  Float_t dx = x - fX;  
-  Float_t exi = 1./ex;
-  Float_t dS = dx*exi;
-  Float_t dy = dS*ey;
-  Float_t dz = dS*fP[3];
-  Float_t h2 = dS*exi*exi;
-  Float_t h4 = 0.5*dx*h2;
-  
-  fX = x;
-  fP[0]+= dy + h4*fP[4];
-  fP[1]+= dz;
-  fP[2]+= dx*fP[4];
-
-  //Float_t H0[5] = { 1,0, h2,  0, h4 };
-  //Float_t H1[5] = { 0, 1, 0, dS,  0 };
-  //Float_t H2[5] = { 0, 0, 1,  0, dx };
-  //Float_t H3[5] = { 0, 0, 0,  1,  0 };
-  //Float_t H4[5] = { 0, 0, 0,  0,  1 };
-
-
-  Float_t c00 = fC[0];
-  Float_t c11 = fC[2];
-  Float_t c20 = fC[3];
-  Float_t c22 = fC[5];
-  Float_t c31 = fC[7];
-  Float_t c33 = fC[9];
-  Float_t c40 = fC[10];
-  Float_t c42 = fC[12];
-  Float_t c44 = fC[14];
-
-  Float_t c40ph4c44 = c40 + h4*c44;
-  Float_t c20ph4c42 = c20 +  h4*c42;
-  Float_t c20ph2c22ph4c42 = h2*c22 + c20ph4c42;
-  Float_t fC10 = c40ph4c44 + h2*c42;
-  Float_t fC12 = c42 + dx*c44;
-  Float_t fC7 = c31 + dS*c33;
-
-  fC[10]= fC10;
-  fC[12]= fC12;
-  fC[7]= fC7;
-  fC[0]= c00  + h2*( c20ph2c22ph4c42 + c20ph4c42) + h4*(c40ph4c44 + c40 ) ; 
-  fC[3]= c20ph2c22ph4c42 + dx*fC10;
-  fC[5]= c22 + dx*( c42 + fC12 );
-  fC[2]= c11 + dS*(c31 + fC7);
-
-  return 1;
-}
-
-/*
-GPUd() Int_t  AliHLTTPCCATrackParam1::TransportToX0( Float_t x, Float_t maxSinPhi )
-{
-// Transport the track parameters to X=x 
-
-  Float_t x0  = X();
-  Float_t ex = CosPhi();
-  Float_t ey = SinPhi();
-  Float_t dx = x - x0;
-
-  if( CAMath::Abs(ex)<1.e-4 ) return 0;
-  
-  Float_t exi = 1./ex;
-
-  Float_t dl = dx*exi;
-  Float_t dy = dl*ey;
-  Float_t dS = dl;
-  Float_t dz = dS*DzDs(); 
-  
-  CosPhi() = ex;
-  X() += dx;
-  fP[0]+= dy;
-  fP[1]+= dz;
-  fP[2] = ey;
-  fP[3] = fP[3];
-  fP[4] = fP[4];
-
-  Float_t h2 = dx*exi*exi*exi;
-  Float_t h4 = dx*h2/2;
-
- //Float_t H0[5] = { 1,0, h2,  0, h4 };
-  //Float_t H1[5] = { 0, 1, 0, dS,  0 };
-  //Float_t H2[5] = { 0, 0, 1,  0, dx };
-  //Float_t H3[5] = { 0, 0, 0,  1,  0 };
-  //Float_t H4[5] = { 0, 0, 0,  0,  1 };
-
-  Float_t c00 = fC[0];
-  Float_t c11 = fC[2];
-  Float_t c20 = fC[3];
-  Float_t c22 = fC[5];
-  Float_t c31 = fC[7];
-  Float_t c33 = fC[9];
-  Float_t c40 = fC[10];
-  Float_t c42 = fC[12];
-  Float_t c44 = fC[14];
-
-  float dSc33 = dS*c33;
-  float h2c22 = h2*c22;
-  float h4c42 = h4*c42;
-  float h4c44 = h4*c44;
-  float h2c42 = h2*c42;
-
-  Float_t fC10 = c40 + h2c42 + h4c44;
-  Float_t fC12 = c42 + dx*c44;
-  Float_t fC7 = c31 + dSc33;
-  fC[0]= c00  + h2*h2c22 + h4*h4c44 + 2*( h2*c20 + h4*c40 + h2*h4c42 ) ; 
-  fC[3]= c20 + h2c22 + h4c42 + dx*fC10;
-  fC[10]= fC10;
-  fC[12]= fC12;
-  fC[5]= c22 + dx*( c42 + fC12 );
-
-  fC[7]= fC7;
-  fC[2]= c11 + dS*(c31 + fC7);
-
-  return 1;
-}
-*/
-
-GPUd() Int_t  AliHLTTPCCATrackParam1::TransportToXMatrix( Float_t x, 
-                                                          Float_t &OutY, Float_t &OutZ,
-                                                          Float_t &OutErr2Y, Float_t &OutErr2Z,
-                                                          Float_t &H2, Float_t &H4, 
-                                                          Float_t &dS, Float_t &dx,
-                                                          Float_t maxSinPhi ) 
-{
-  //* Transport the track parameters to X=x 
-
-  Float_t x0  = X();
-  //Float_t y0  = Y();
-  Float_t k   = Kappa();
-  Float_t ex = CosPhi();
-  Float_t ey = SinPhi();
-  dx = x - x0;
-
-  Float_t ey1 = k*dx + ey;
-  Float_t ex1;
-  if( CAMath::Abs(ey1)>maxSinPhi ){ // no intersection 
-    return 0;
-  }else{
-    ex1 = CAMath::Sqrt(1 - ey1*ey1);
-    if( ex<0 ) ex1 = -ex1;  
-  }
-  
-  Float_t dx2 = dx*dx;
-  Float_t ss = ey+ey1;
-  Float_t cc = ex+ex1;  
-
-  if( CAMath::Abs(cc)<1.e-4 || CAMath::Abs(ex)<1.e-4 || CAMath::Abs(ex1)<1.e-4 ) return 0;
-
-  Float_t tg = ss/cc; // tan((phi1+phi)/2)
-  
-  Float_t dy = dx*tg;
-  Float_t dl = dx*CAMath::Sqrt(1+tg*tg);
-
-  if( cc<0 ) dl = -dl;
-  Float_t dSin = dl*k/2;
-  if( dSin > 1 ) dSin = 1;
-  if( dSin <-1 ) dSin = -1;
-
-  dS = ( CAMath::Abs(k)>1.e-4)  ? (2*CAMath::ASin(dSin)/k) :dl;  
-
-  Float_t dz = dS*DzDs();
-
-  
-  Float_t cci = 1./cc;
-  Float_t exi = 1./ex;
-  Float_t ex1i = 1./ex1;
-  
-  Float_t h2 = dx*(1+ ex*ex1 + ey*ey1 )*cci*exi*ex1i;
-  Float_t h4 = dx2*(cc + ss*ey1*ex1i )*cci*cci;
-
- //Float_t H0[5] = { 1,0, h2,  0, h4 };
- //Float_t H1[5] = { 0, 1, 0, dS,  0 };
- //Float_t H2[5] = { 0, 0, 1,  0, dx };
- //Float_t H3[5] = { 0, 0, 0,  1,  0 };
- //Float_t H4[5] = { 0, 0, 0,  0,  1 };
-
-  Float_t c20 = fC[3];
-  Float_t c22 = fC[5];
-  Float_t c31 = fC[7];
-  Float_t c33 = fC[9];
-  Float_t c40 = fC[10];
-  Float_t c42 = fC[12];
-  Float_t c44 = fC[14];
-
-  float dSc33 = dS*c33;
-  float h2c22 = h2*c22;
-  float h4c42 = h4*c42;
-  float h4c44 = h4*c44;  
-
-  OutY = fP[0] + dy;
-  OutZ = fP[1] + dz;
-  OutErr2Y =  fC[0]  + h2*h2c22 + h4*h4c44 + 2*( h2*c20 + h4*c40 + h2*h4c42 ) ; 
-  OutErr2Z = fC[2] + dS*(c31 + c31 + dSc33);
-
-  H2 = h2;
-  H4 = h4;
-
-  return 1;
-}
-
-
-GPUd() Bool_t AliHLTTPCCATrackParam1::TransportToXWithMaterial( Float_t Xto, Float_t Bz )
-{
-  //* Transport the track parameters to X=x 
-  AliHLTTPCCATrackFitParam par;
-  CalculateFitParameters( par, Bz );
-  return TransportToXWithMaterial(Xto, par );
-}
-
-
-GPUd() Bool_t  AliHLTTPCCATrackParam1::TransportToXWithMaterial( Float_t x, AliHLTTPCCATrackFitParam &par )
-{
-  //* Transport the track parameters to X=x 
-
-  Bool_t ret = 1;
-
-  Float_t oldX=GetX();
-
-  Float_t x0  = X();
-  //Float_t y0  = Y();
-  Float_t k   = Kappa();
-  Float_t ex = CosPhi();
-  Float_t ey = SinPhi();
-  Float_t dx = x - x0;
-
-  Float_t ey1 = k*dx + ey;
-  Float_t ex1;
-  if( CAMath::Abs(ey1)>.99 ){ // no intersection -> check the border    
-    ey1 = ( ey1>0 ) ?1 :-1;
-    ex1 = 0;
-    dx = ( CAMath::Abs(k)>1.e-4) ? ( (ey1-ey)/k ) :0;
-    
-    Float_t ddx = CAMath::Abs(x0+dx - x)*k*k;
-    Float_t hx[] = {0, -k, 1+ey };
-    Float_t sx2 = hx[1]*hx[1]*fC[ 3] + hx[2]*hx[2]*fC[ 5];
-    if( ddx*ddx>3.5*3.5*sx2 ) ret = 0; // x not withing the error
-    ret = 0; // any case
-    return ret;
-  }else{
-    ex1 = CAMath::Sqrt(1 - ey1*ey1);
-    if( ex<0 ) ex1 = -ex1;  
-  }
-  
-  Float_t dx2 = dx*dx;
-  CosPhi() = ex1;
-  Float_t ss = ey+ey1;
-  Float_t cc = ex+ex1;  
-  Float_t tg = 0;
-  if( CAMath::Abs(cc)>1.e-4 ) tg = ss/cc; // tan((phi1+phi)/2)
-  else ret = 0; 
-  Float_t dy = dx*tg;
-  Float_t dl = dx*CAMath::Sqrt(1+tg*tg);
-
-  if( cc<0 ) dl = -dl;
-  Float_t dSin = dl*k/2;
-  if( dSin > 1 ) dSin = 1;
-  if( dSin <-1 ) dSin = -1;
-  Float_t dS = ( CAMath::Abs(k)>1.e-4)  ? (2*CAMath::ASin(dSin)/k) :dl;
-  Float_t dz = dS*DzDs();
-
-  Float_t cci = 0, exi = 0, ex1i = 0;
-  if( CAMath::Abs(cc)>1.e-4 ) cci = 1./cc;
-  else ret = 0;
-  if( CAMath::Abs(ex)>1.e-4 ) exi = 1./ex;
-  else ret = 0;
-  if( CAMath::Abs(ex1)>1.e-4 ) ex1i = 1./ex1;
-  else ret = 0;
-
-  if( !ret ) return ret;
-
-  X() += dx;
-  fP[0]+= dy;
-  fP[1]+= dz;  
-  fP[2] = ey1;
-  fP[3] = fP[3];
-  fP[4] = fP[4];
-
-  Float_t h2 = dx*(1+ ex*ex1 + ey*ey1 )*cci*exi*ex1i;
-  Float_t h4 = dx2*(cc + ss*ey1*ex1i )*cci*cci;
-
-  Float_t c00 = fC[0];
-  Float_t c11 = fC[2];
-  Float_t c20 = fC[3];
-  Float_t c22 = fC[5];
-  Float_t c31 = fC[7];
-  Float_t c33 = fC[9];
-  Float_t c40 = fC[10];
-  Float_t c42 = fC[12];
-  Float_t c44 = fC[14];
-
-  //Float_t H0[5] = { 1,0, h2,  0, h4 };
-  //Float_t H1[5] = { 0, 1, 0, dS,  0 };
-  //Float_t H2[5] = { 0, 0, 1,  0, dx };
-  //Float_t H3[5] = { 0, 0, 0,  1,  0 };
-  //Float_t H4[5] = { 0, 0, 0,  0,  1 };
-
-
-  fC[0]=( c00  + h2*h2*c22 + h4*h4*c44 
-         + 2*( h2*c20 + h4*c40 + h2*h4*c42 )  ); 
-
-  fC[2]= c11 + 2*dS*c31 + dS*dS*c33;
-
-  fC[3]= c20 + h2*c22 + h4*c42 + dx*( c40 + h2*c42 + h4*c44);
-  fC[5]= c22 +2*dx*c42 + dx2*c44;
-
-  fC[7]= c31 + dS*c33;
-  fC[9]= c33;
-
-  fC[10]= c40 + h2*c42 + h4*c44;
-  fC[12]= c42 + dx*c44;
-  fC[14]= c44;
-
-  Float_t d = CAMath::Sqrt(dS*dS + dz*dz );
-
-  if (oldX > GetX() ) d = -d;
-  {
-    Float_t rho=0.9e-3; 
-    Float_t radLen=28.94;
-    CorrectForMeanMaterial(d*rho/radLen,d*rho,par);
-  }
-
-  return ret;
-}
-
-
-
-GPUd() Float_t AliHLTTPCCATrackParam1::ApproximateBetheBloch( Float_t beta2 ) 
-{
-  //------------------------------------------------------------------
-  // This is an approximation of the Bethe-Bloch formula with 
-  // the density effect taken into account at beta*gamma > 3.5
-  // (the approximation is reasonable only for solid materials) 
-  //------------------------------------------------------------------
-  if (beta2 >= 1) return 0;
-
-  if (beta2/(1-beta2)>3.5*3.5)
-    return 0.153e-3/beta2*( log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2);
-  return 0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2);
-}
-
-
-GPUd() void AliHLTTPCCATrackParam1::CalculateFitParameters( AliHLTTPCCATrackFitParam &par, Float_t Bz, Float_t mass )
-{
-  //*!
-
-  const Float_t kCLight = 0.000299792458;  
-  Float_t c = Bz*kCLight;
-  Float_t p2 = (1.+ fP[3]*fP[3])*c*c;  
-  Float_t k2 = fP[4]*fP[4];
-  Float_t beta2= p2 / (p2 + mass*mass*k2);
-  Float_t bethe = ApproximateBetheBloch(beta2);
-
-  Float_t pp2 = (k2>1.e-8) ?p2/k2 :10000; // impuls 2
-  par.fBethe = bethe;
-  par.fE = CAMath::Sqrt( pp2 + mass*mass);
-  par.fTheta2 = 14.1*14.1/(beta2*p2*1e6)*k2;
-  par.fEP2 = par.fE/p2*k2;
-
-  // Approximate energy loss fluctuation (M.Ivanov)
-  
-  const Float_t knst=0.07; // To be tuned.  
-  par.fSigmadE2 = knst*par.fEP2*fP[4]; 
-  par.fSigmadE2 = par.fSigmadE2 * par.fSigmadE2;
-  
-  par.fK22 = (1. + fP[3]*fP[3]);
-  par.fK33 = par.fK22*par.fK22;
-  par.fK43 = fP[3]*fP[4]*par.fK22;
-  par.fK44 = fP[3]*fP[3]*fP[4]*fP[4];
-}
-
-
-GPUd() Bool_t AliHLTTPCCATrackParam1::CorrectForMeanMaterial( Float_t xOverX0,  Float_t xTimesRho, AliHLTTPCCATrackFitParam &par )
-{
-  //------------------------------------------------------------------
-  // This function corrects the track parameters for the crossed material.
-  // "xOverX0"   - X/X0, the thickness in units of the radiation length.
-  // "xTimesRho" - is the product length*density (g/cm^2). 
-  //------------------------------------------------------------------
-
-  Float_t &fC22=fC[5];
-  Float_t &fC33=fC[9];
-  Float_t &fC40=fC[10];
-  Float_t &fC42=fC[12];
-  Float_t &fC44=fC[14]; 
-
-  //Energy losses************************
-  
-  Float_t dE = par.fBethe*xTimesRho;
-  if ( CAMath::Abs(dE) > 0.3*par.fE ) return 0; //30% energy loss is too much!
-  Float_t corr = (1.- par.fEP2*dE);
-  if( corr<0.3 ) return 0;
-  fP[4]*= corr;
-  fC40*= corr;  
-  fC42*= corr;  
-  fC44*= corr*corr;
-  fC44+= par.fSigmadE2*CAMath::Abs(dE);
-  
-
-  //Multiple scattering******************
-  
-  Float_t theta2 = par.fTheta2*CAMath::Abs(xOverX0);
-  fC22 += theta2*par.fK22*(1.- fP[2]*fP[2]);
-  fC33 += theta2*par.fK33;
-  fC44 += theta2*par.fK44;
-    
-  return 1;
-}
-
-
-
-//#include "Riostream.h"
-
-GPUd() Bool_t AliHLTTPCCATrackParam1::Rotate( Float_t alpha )
-{
-  //* Rotate the coordinate system in XY on the angle alpha
-  
-  Float_t cA = CAMath::Cos( alpha );
-  Float_t sA = CAMath::Sin( alpha );
-  Float_t x = X(), y= Y(), sP= SinPhi(), cP= CosPhi();
-  Float_t cosPhi = cP*cA + sP*sA;
-  Float_t sinPhi =-cP*sA + sP*cA;
-  
-  if( CAMath::Abs(sinPhi)>.99 || CAMath::Abs(cosPhi)<1.e-2 || CAMath::Abs(cP)<1.e-2  ) return 0;
-  
-  Float_t j0 = cP/cosPhi; 
-  Float_t j2 = cosPhi/cP;
-  
-  X()      =   x*cA +  y*sA;
-  Y()      =  -x*sA +  y*cA;
-  CosPhi() =  cosPhi;
-  SinPhi() =  sinPhi;
-
-
-  //Float_t J[5][5] = { { j0, 0, 0,  0,  0 }, // Y
-  //                      {  0, 1, 0,  0,  0 }, // Z
-  //                      {  0, 0, j2, 0,  0 }, // SinPhi
-  //                     {  0, 0, 0,  1,  0 }, // DzDs
-  //                     {  0, 0, 0,  0,  1 } }; // Kappa
-  //cout<<"alpha="<<alpha<<" "<<x<<" "<<y<<" "<<sP<<" "<<cP<<" "<<j0<<" "<<j2<<endl;
-  //cout<<"      "<<fC[0]<<" "<<fC[1]<<" "<<fC[6]<<" "<<fC[10]<<" "<<fC[4]<<" "<<fC[5]<<" "<<fC[8]<<" "<<fC[12]<<endl;
-  fC[0]*= j0*j0;
-  //fC[3]*= j0;
-  fC[10]*= j0;
-
-  //fC[3]*= j2;
-  fC[5]*= j2*j2; 
-  fC[8]*= j2;
-  fC[12]*= j2;
-  //cout<<"      "<<fC[0]<<" "<<fC[1]<<" "<<fC[6]<<" "<<fC[10]<<" "<<fC[4]<<" "<<fC[5]<<" "<<fC[8]<<" "<<fC[12]<<endl;
-  return 1;
-}
-
-
-GPUd() Bool_t AliHLTTPCCATrackParam1::Filter2( Float_t y, Float_t z, Float_t err2Y, Float_t err2Z, Float_t maxSinPhi )
-{
-  //* Add the y,z measurement with the Kalman filter 
-
-  Float_t 
-    c00 = fC[ 0],
-    c11 = fC[ 2],
-    c20 = fC[ 3],
-    c31 = fC[ 7],
-    c40 = fC[10];
-
-  err2Y+=c00;
-  err2Z+=c11;
-
-  Float_t
-    z0 = y-fP[0],
-    z1 = z-fP[1];
-  
-  if( err2Y < 1.e-8 || err2Z<1.e-8 ) return 0;
-
-  Float_t mS0 = 1./err2Y;
-  Float_t mS2 = 1./err2Z;
-  // K = CHtS
-  
-  Float_t k00, k11, k20, k31, k40;
-    
-  k00 = c00*mS0;
-  k20 = c20*mS0;
-  k40 = c40*mS0;
-
-  k11 = c11*mS2;
-  k31 = c31*mS2;
-
-  Float_t sinPhi = fP[2] + k20*z0  ;
-  if( CAMath::Abs(sinPhi)>= maxSinPhi ) return 0;
-
-  Float_t cosPhi = CAMath::Sqrt(1-sinPhi*sinPhi);
-  fNDF  += 2;
-  fChi2 += mS0*z0*z0 + mS2*z1*z1 ;
-
-  fP[ 0]+= k00*z0 ;
-  fP[ 1]+= k11*z1 ;
-  fP[ 2] = sinPhi ;
-  fP[ 3]+= k31*z1 ;
-  fP[ 4]+= k40*z0 ;
-    
-  fC[ 0]-= k00*c00 ;    
-  fC[ 3]-= k20*c00 ;
-  fC[ 5]-= k20*c20 ;
-  fC[10]-= k40*c00 ;
-  fC[12]-= k40*c20 ;
-  fC[14]-= k40*c40 ;
-  fC[ 2]-= k11*c11 ;
-  fC[ 7]-= k31*c11 ;
-  fC[ 9]-= k31*c31 ;
-   
-  fCosPhi = ( fCosPhi >=0 ) ?cosPhi :-cosPhi;
-  return 1;
-}
-
-
-
-
-GPUd() void AliHLTTPCCATrackParam1::FilterY( Float_t y, Float_t erry )
-{
-  //* Add the y measurement with the Kalman filter 
-
-  Float_t 
-    c00 = fC[ 0],    
-    c20 = fC[ 3],
-    c40 = fC[10];
-  
-  Float_t
-    z0 = y-fP[0];
-
-  Float_t s = { c00+erry*erry };
-  if( CAMath::Abs(s)<1.e-4 ) return;
-
-  Float_t si = 1/s;
-
-  fNDF  += 1;
-  fChi2 += si*z0*z0;        
-
-  // K = CHtS
-  
-  Float_t k0, k2, k3, k4;
-    
-  k0 = c00*si;
-  k2 = c20*si;
-  k3 = 0;
-  k4 = c40*si;
-
-  Float_t sinPhi = fP[2] + k2*z0 ;
-  if( CAMath::Abs(sinPhi)>=0.99 ) return;
-
-  fP[ 0]+= k0*z0 ;
-  fP[ 2] = sinPhi;
-  fP[ 3]+= k3*z0 ;
-  fP[ 4]+= k4*z0 ;
-    
-  fC[ 0]-= k0*c00;
-  
-  fC[ 3]-= k2*c00;
-  fC[ 5]-= k2*c20;
-
-  fC[10]-= k4*c00;
-  fC[12]-= k4*c20;
-  fC[14]-= k4*c40;
-    
-  if( CosPhi()>=0 ){
-    CosPhi() = CAMath::Sqrt(1-SinPhi()*SinPhi());
-  }else{
-    CosPhi() = -CAMath::Sqrt(1-SinPhi()*SinPhi());
-  }   
-    
-}
-
-GPUd() void AliHLTTPCCATrackParam1::FilterZ( Float_t z, Float_t errz )
-{
-  //* Add the z measurement with the Kalman filter 
-
-  Float_t 
-    c11 = fC[ 2],
-    c31 = fC[ 7];
-  
-  Float_t
-    z1 = z-fP[1];
-
-  Float_t s = c11 + errz*errz;
-  if( CAMath::Abs(s)<1.e-4 ) return;
-
-  Float_t si = 1./s;
-  fNDF  += 1;
-  fChi2 += si*z1*z1;
-
-  // K = CHtS
-  
-  Float_t k1 , k3;
-    
-  k1 = c11*si;
-  k3 = c31*si;
-
-  fP[ 1]+= k1*z1 ;
-  fP[ 3]+= k3*z1 ;    
-  
-  fC[ 2]-= k1*c11 ;
-
-  fC[ 7]-= k3*c11 ;
-  fC[ 9]-= k3*c31 ;
-
-}
-
-#if !defined(HLTCA_GPUCODE)
-#if defined( HLTCA_STANDALONE )
-#include <iostream.h>
-#else
-#include "Riostream.h"
-#endif
-#endif
-
-GPUd() void AliHLTTPCCATrackParam1::Print() const
-{
-  //* Print parameters
-
-#if !defined(HLTCA_GPUCODE)
-  cout<<"track: "<<GetX()<<" "<<GetY()<<" "<<GetZ()<<" "<<GetSinPhi()<<" "<<GetDzDs()<<" "<<GetKappa()<<endl;
-  cout<<"errs2: "<<GetErr2Y()<<" "<<GetErr2Z()<<" "<<GetErr2SinPhi()<<" "<<GetErr2DzDs()<<" "<<GetErr2Kappa()<<endl;
-#endif
-}
-
diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam1.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam1.h
deleted file mode 100644 (file)
index 5759830..0000000
+++ /dev/null
@@ -1,117 +0,0 @@
-//-*- Mode: C++ -*-
-// $Id: AliHLTTPCCATrackParam1.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                                  *
-
-
-#ifndef ALIHLTTPCCATRACKPARAM1_H
-#define ALIHLTTPCCATRACKPARAM1_H
-
-#include "AliHLTTPCCADef.h"
-
-/**
- * @class AliHLTTPCCATrackParam1
- *
- * AliHLTTPCCATrackParam1 class describes the track parametrisation
- * which is used by the AliHLTTPCCATracker slice tracker.
- *
- */
-class AliHLTTPCCATrackParam1
-{
- public:
-
-  class AliHLTTPCCATrackFitParam
-  {
-  public:
-    Float_t fBethe, fE,fTheta2, fEP2, fSigmadE2, fK22,fK33,fK43,fK44; // fit parameters
-  };
-#if !defined(HLTCA_GPUCODE)
-  AliHLTTPCCATrackParam1(): fX(0),fCosPhi(1),fChi2(0), fNDF(0){}
-  ~AliHLTTPCCATrackParam1(){}
-#endif
-
-  GPUd() Float_t &X()     { return fX;    }
-  GPUd() Float_t &Y()     { return fP[0]; }
-  GPUd() Float_t &Z()     { return fP[1]; }
-  GPUd() Float_t &SinPhi(){ return fP[2]; }
-  GPUd() Float_t &DzDs()  { return fP[3]; }
-  GPUd() Float_t &Kappa() { return fP[4]; }
-  GPUd() Float_t &CosPhi(){ return fCosPhi; }
-  GPUd() Float_t &Chi2()  { return fChi2; }
-  GPUd() Int_t   &NDF()   { return fNDF; }
-
-  Float_t &Err2Y()      { return fC[0]; }
-  Float_t &Err2Z()      { return fC[2]; }
-  Float_t &Err2SinPhi() { return fC[5]; }
-  Float_t &Err2DzDs()   { return fC[9]; }
-  Float_t &Err2Kappa()  { return fC[14]; }
-
-  GPUd() Float_t GetX()      const { return fX; }
-  GPUd() Float_t GetY()      const { return fP[0]; }
-  GPUd() Float_t GetZ()      const { return fP[1]; }
-  GPUd() Float_t GetSinPhi() const { return fP[2]; }
-  GPUd() Float_t GetDzDs()   const { return fP[3]; }
-  GPUd() Float_t GetKappa()  const { return fP[4]; }
-  GPUd() Float_t GetCosPhi() const { return fCosPhi; }
-  GPUd() Float_t GetChi2()   const { return fChi2; }
-  GPUd() Int_t   GetNDF()    const { return fNDF; }
-
-  GPUd() Float_t GetErr2Y()      const { return fC[0]; }
-  GPUd() Float_t GetErr2Z()      const { return fC[2]; }
-  GPUd() Float_t GetErr2SinPhi() const { return fC[5]; }
-  GPUd() Float_t GetErr2DzDs()   const { return fC[9]; }
-  GPUd() Float_t GetErr2Kappa()  const { return fC[14]; }
-
-  GPUhd() Float_t *Par(){ return fP; }
-  GPUhd() Float_t *Cov(){ return fC; }
-
-  GPUd() const Float_t *GetPar() const { return fP; }
-  GPUd() const Float_t *GetCov() const { return fC; }
-
-  GPUd() void ConstructXY3( const Float_t x[3], const Float_t y[3], const Float_t sigmaY2[3], Float_t CosPhi0 );
-
-  GPUd() void ConstructXYZ3( const Float_t p0[5], const Float_t p1[5], const Float_t p2[5], 
-                             Float_t CosPhi0, Float_t t0[]=0 );
-
-  GPUd() Float_t GetS( Float_t x, Float_t y ) const;
-
-  GPUd() void GetDCAPoint( Float_t x, Float_t y, Float_t z,
-                   Float_t &px, Float_t &py, Float_t &pz ) const;
-  
-  GPUd() Int_t TransportToX( Float_t X, Float_t maxSinPhi );
-  GPUd() Int_t TransportToX0( Float_t X, Float_t maxSinPhi );
-  GPUd() Int_t TransportToXMatrix( Float_t X, 
-                                   Float_t &Y, Float_t &Z,
-                                   Float_t &Err2Y, Float_t &Err2Z,
-                                   Float_t &H2, Float_t &H4, 
-                                   Float_t &dS, Float_t &dx, Float_t maxSinPhi ) ;
-  GPUd() Bool_t TransportToXWithMaterial( Float_t X, AliHLTTPCCATrackFitParam &par );
-  GPUd() Bool_t TransportToXWithMaterial( Float_t X, Float_t Bz );
-  GPUd() Bool_t Rotate( Float_t alpha );
-
-  GPUd() Bool_t Filter2( Float_t y, Float_t z, Float_t err2Y, Float_t err2Z, Float_t maxSinPhi=.99 );
-
-  GPUd() void FilterY( Float_t y, Float_t erry );
-  GPUd() void FilterZ( Float_t z, Float_t errz );
-
-  GPUd() static Float_t ApproximateBetheBloch( Float_t beta2 );
-  GPUd() void CalculateFitParameters( AliHLTTPCCATrackFitParam &par, Float_t Bz, Float_t mass = 0.13957 );
-  GPUd() Bool_t CorrectForMeanMaterial( Float_t xOverX0,  Float_t xTimesRho, AliHLTTPCCATrackFitParam &par );
-  GPUd() void Print() const;
-
-private:
-
-  Float_t fX;      // x position
-  Float_t fCosPhi; // cosPhi
-  Float_t fP[5];   // 'active' track parameters: Y, Z, SinPhi, DzDs, Kappa
-  Float_t fC[15];  // the covariance matrix for Y,Z,SinPhi,..
-  Float_t fChi2;   // the chi^2 value
-  Int_t   fNDF;    // the Number of Degrees of Freedom
-  
-
-};
-
-
-#endif
index 6636643..78b28d9 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliHLTTPCCAGrid.h"
 #include "AliHLTTPCCARow.h"
 #include "AliHLTTPCCATrack.h"
+#include "AliHLTTPCCATracklet.h"
 #include "AliHLTTPCCAMath.h"
 #include "AliHLTTPCCAHit.h"
 
 #include "AliHLTTPCCATrackletConstructor.h"
 #include "AliHLTTPCCATrackletSelector.h"
 #include "AliHLTTPCCAProcess.h"
-#include "AliHLTTPCCALinksWriter.h"
 #include "AliHLTTPCCAUsedHitsInitialiser.h"
 
 #include "AliHLTTPCCATrackParam.h"
-#include "AliHLTTPCCATrackParam1.h"
 
 #if !defined(HLTCA_GPUCODE)
-#if defined( HLTCA_STANDALONE )
-#include <iostream.h>
-#else
-#include "Riostream.h"
-#endif
+#include <iostream>
 #endif
 
 //#define DRAW
@@ -60,63 +55,53 @@ ClassImp(AliHLTTPCCATracker)
 AliHLTTPCCATracker::AliHLTTPCCATracker()
   :
   fParam(),
-  fNHitsTotal(0),
-  fGridSizeTotal(0),
-  fGrid1SizeTotal(0),
-  fHits(0),
-  fHits1(0),
-  fGridContents(0),
-  fGrid1Contents(0),
-  fHitsID(0),
-  fHitLinkUp(0),
-  fHitLinkDown(0),
-  fHitIsUsed(0),
-  fStartHits(0),  
-  fTracklets(0),
-  fNTracks(0),
-  fTracks(0),
+  fNHitsTotal(0),  
+  fCommonMemory(0), 
+  fCommonMemorySize(0),
+  fInputEvent(0),     
+  fInputEventSize(0), 
+  fRowData(0),     
+  fRowDataSize(0), 
+  fHitInputIDs(0), 
+  fHitWeights(0),  
+  fNTracklets(0),
+  fTrackletStartHits(0),
+  fTracklets(0), 
+  fNTracks(0),   
+  fTracks(0), 
+  fNTrackHits(0),
   fTrackHits(0),
   fNOutTracks(0),
+  fOutTracks(0), 
   fNOutTrackHits(0),
-  fOutTracks(0),
-  fOutTrackHits(0),
-  fEventMemory(0),
-  fEventMemSize(0),
-  fTexHitsFullData(0),
-  fTexHitsFullSize(0)
+  fOutTrackHits(0)
 {
   // constructor
-  //fRows = new AliHLTTPCCARow[fParam.NRows()];
-  //Initialize( fParam );
 }
 
 AliHLTTPCCATracker::AliHLTTPCCATracker( const AliHLTTPCCATracker& )
   :
   fParam(),
   fNHitsTotal(0),
-  fGridSizeTotal(0),
-  fGrid1SizeTotal(0),
-  fHits(0),
-  fHits1(0),
-  fGridContents(0),
-  fGrid1Contents(0),
-  fHitsID(0),
-  fHitLinkUp(0),
-  fHitLinkDown(0),
-  fHitIsUsed(0),
-  fStartHits(0),  
-  fTracklets(0),
-  fNTracks(0),
-  fTracks(0),
+  fCommonMemory(0), 
+  fCommonMemorySize(0),
+  fInputEvent(0),     
+  fInputEventSize(0), 
+  fRowData(0),     
+  fRowDataSize(0), 
+  fHitInputIDs(0), 
+  fHitWeights(0),  
+  fNTracklets(0),
+  fTrackletStartHits(0),
+  fTracklets(0), 
+  fNTracks(0),   
+  fTracks(0), 
+  fNTrackHits(0),
   fTrackHits(0),
   fNOutTracks(0),
+  fOutTracks(0), 
   fNOutTrackHits(0),
-  fOutTracks(0),
-  fOutTrackHits(0),
-  fEventMemory(0),
-  fEventMemSize(0),
-  fTexHitsFullData(0),
-  fTexHitsFullSize(0)
+  fOutTrackHits(0)
 {
   // dummy
 }
@@ -124,60 +109,28 @@ AliHLTTPCCATracker::AliHLTTPCCATracker( const AliHLTTPCCATracker& )
 AliHLTTPCCATracker &AliHLTTPCCATracker::operator=( const AliHLTTPCCATracker& )
 {
   // dummy
-  fOutTrackHits=0;
-  fOutTracks=0;
-  fNOutTracks=0;
-  fTrackHits = 0;
-  fEventMemory = 0;
+  fCommonMemory = 0;
   return *this;
 }
 
 GPUd() AliHLTTPCCATracker::~AliHLTTPCCATracker()
 {
   // destructor
-  StartEvent();
+  if( fCommonMemory ) delete[] fCommonMemory;
 }
 #endif
 
 
-GPUd() UChar_t AliHLTTPCCATracker::GetGridContent(  UInt_t i ) const
-{
-  //* get grid content
-#if defined(HLTCA_GPUSTEP)
-  return (UChar_t) tex1Dfetch(texGrid,i).x;  
-#else
-  return fGridContents[i];
-#endif
-}
-
-
-GPUd() AliHLTTPCCAHit AliHLTTPCCATracker::GetHit(  UInt_t i ) const
-{
-  //* get hit
-#if defined(HLTCA_USE_GPU)
-  AliHLTTPCCAHit h;
-  float2 f = tex1Dfetch(texHits,i);
-  h.Y() = f.x;
-  h.Z() = f.y;
-  return h;
-#else
-  return fHits[i];
-#endif
-}
-
-
-
 
 // ----------------------------------------------------------------------------------
 GPUd() void AliHLTTPCCATracker::Initialize( AliHLTTPCCAParam &param )
 {
   // initialisation
-  StartEvent();
   fParam = param;
-  fParam.Update(); 
+  fParam.Update();
   for( Int_t irow=0; irow<fParam.NRows(); irow++ ){
-    fRows[irow].X() = fParam.RowX(irow);        
-    fRows[irow].MaxY() = CAMath::Tan( fParam.DAlpha()/2.)*fRows[irow].X();    
+    fRows[irow].X() = fParam.RowX(irow);
+    fRows[irow].MaxY() = CAMath::Tan( fParam.DAlpha()/2.)*fRows[irow].X();
   }
   StartEvent();
 }
@@ -186,119 +139,187 @@ GPUd() void AliHLTTPCCATracker::StartEvent()
 {
   // start new event and fresh the memory  
 
-  if( fEventMemory ) delete[] fEventMemory;
-  if( fOutTracks ) delete[] fOutTracks;
-  if( fOutTrackHits ) delete[] fOutTrackHits;
-  fEventMemory = 0;
-  fHits = 0;
-  fHits1 = 0;
-  fHitsID = 0;
-  fTrackHits = 0;
-  fTracks = 0;
-  fOutTrackHits = 0;
-  fOutTracks = 0;
-  fNTracks = 0;
-  fNOutTrackHits = 0;
-  fNOutTracks = 0;
   fNHitsTotal = 0;
+  Int_t oldSize = fCommonMemorySize;
+  SetPointers();
+  if( fCommonMemory && fCommonMemorySize > oldSize ){
+    delete[] fCommonMemory;
+    fCommonMemory = 0;
+  }
+  if( !fCommonMemory ){   
+    fCommonMemory = reinterpret_cast<Char_t*> ( new uint4 [ fCommonMemorySize/sizeof(uint4) + 100] );
+  }
+  SetPointers();  
+  *fNTracklets = 0;
+  *fNTracks = 0 ;
+  *fNTrackHits = 0;
+  *fNOutTracks = 0;
+  *fNOutTrackHits = 0;
 }
 
 GPUhd() void  AliHLTTPCCATracker::SetPointers()
 {
   // set all pointers to the event memory
 
-  fEventMemSize = 0;
-  UInt_t &size = fEventMemSize;
-  fHits = (AliHLTTPCCAHit*) (fEventMemory+ size);
-  size+= sizeof(AliHLTTPCCAHit)*fNHitsTotal;
-  fHits1 = (ushort2*) (fEventMemory+ size);
-  size+= sizeof(ushort2)*fNHitsTotal;
-  fGridContents = (UChar_t *) (fEventMemory + size);
-  size+= sizeof(Int_t)*fGridSizeTotal;
-  fGrid1Contents = (UInt_t *) (fEventMemory + size);
-  size+= sizeof(UInt_t)*fGrid1SizeTotal;
-  fHitsID = (Int_t *) (fEventMemory + size);
-  size+= sizeof(Int_t) * fNHitsTotal;
-  fHitLinkUp = (Short_t *) (fEventMemory + size);
-  size+= sizeof(Int_t) * fNHitsTotal;
-  fHitLinkDown = (Short_t *) (fEventMemory + size);
-  size+= sizeof(Int_t) * fNHitsTotal;
-  fHitIsUsed = (Int_t *) (fEventMemory + size);
-  size+= sizeof(Int_t) * fNHitsTotal;
-  fStartHits = (Int_t *) (fEventMemory + size);
-  size+= sizeof(Int_t) * (fNHitsTotal+1);
-  size = (size/16+1)*16;
-  fTexHitsFullData = (uint4*)(fEventMemory+ size);
-  size+= ((sizeof(UShort_t)*6*fNHitsTotal + sizeof(UShort_t)*2*fGrid1SizeTotal )/16+1)*16;
-
-  fTracklets = (Int_t *) (fEventMemory + size);
-  size+= sizeof(Int_t) * (1 + fNHitsTotal*(5+ sizeof(AliHLTTPCCATrackParam)/4 + 160 ));
-  fNTracks = (Int_t *) (fEventMemory + size);
-  size+= sizeof(Int_t);
-  fTracks = (AliHLTTPCCATrack* )(fEventMemory + size);
-  size+= sizeof(AliHLTTPCCATrack) * (fNHitsTotal+1);
-  fTrackHits = ( Int_t *)(fEventMemory + size);
-  size+= sizeof(Int_t) * (10*fNHitsTotal+1);
-
-  fOutTrackHits = 0;
-  fOutTracks = 0;
+  Int_t gridSizeTotal = 2*(2*fNHitsTotal + 10*Param().NRows());
+
+  ULong_t mem = (ULong_t) fCommonMemory;  
+  UInt_t sI = sizeof(Int_t);
+  UInt_t sF = sizeof(Float_t);
+  UInt_t sS = sizeof(Short_t);
+  UInt_t s4 = sizeof(uint4);
+
+  fInputEvent = (Char_t*) mem;  
+  fInputEventSize = (1+fParam.NRows()*2 + 1)*sI + (fNHitsTotal*2)*sF;
+  mem+= fInputEventSize;
+
+  mem = ( mem/s4 + 1 )*s4;
+  fRowData = (uint4*) mem;
+  fRowDataSize = ( 2*fNHitsTotal*sS +  //  yz
+                  gridSizeTotal*sS + // grid
+                  2*fNHitsTotal*sS +  // link up,link down
+                  fParam.NRows()*s4   // row alignment
+                  );
+  mem += fRowDataSize;
+
+  mem = ( mem/sI + 1 )*sI;
+
+  fHitInputIDs = (Int_t*) mem;
+  mem+= fNHitsTotal*sI;
+
+  fHitWeights = (Int_t*) mem;
+  mem+=  fNHitsTotal*sI;
+
+  fNTracklets = (Int_t*) mem;
+  mem+= sI;
+
+  fTrackletStartHits = (Int_t*) mem;
+  mem+= fNHitsTotal*sI;
+
+  mem = ( mem/sizeof(AliHLTTPCCATracklet) + 1 )*sizeof(AliHLTTPCCATracklet);
+
+  fTracklets = (AliHLTTPCCATracklet *) mem;
+  mem+= fNHitsTotal*sizeof(AliHLTTPCCATracklet);
+  
+  mem = ( mem/sI + 1 )*sI;
+
+  fNTracks = (Int_t*) mem;
+  mem+= sI;
+
+  mem = ( mem/sizeof(AliHLTTPCCATrack) + 1 )*sizeof(AliHLTTPCCATrack);
+
+  fTracks = (AliHLTTPCCATrack*) mem;
+  mem+= fNHitsTotal*sizeof(AliHLTTPCCATrack);
+  
+  mem = ( mem/sI + 1 )*sI;
+  fNTrackHits = (Int_t*) mem;
+  mem+= sI;
+
+  fTrackHits = (Int_t*) mem;
+  mem+= fNHitsTotal*sI;
+
+  fNOutTracks = (Int_t*) mem;
+  mem+= sI;
+
+  mem = ( mem/sizeof(AliHLTTPCCAOutTrack) + 1 )*sizeof(AliHLTTPCCAOutTrack);
+  
+  fOutTracks = (AliHLTTPCCAOutTrack*) mem;
+  mem+= fNHitsTotal*sizeof(AliHLTTPCCAOutTrack);
+
+  mem = ( mem/sI + 1 )*sI;
+  fNOutTrackHits = (Int_t*) mem;
+  mem+= sI;
+  fOutTrackHits = (Int_t*) mem;
+  mem+= fNHitsTotal*sI;
+
+  fCommonMemorySize = mem - (ULong_t) fCommonMemory;
 }
 
+
 GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits, Float_t *Y, Float_t *Z, Int_t NHits )
 {
   //* Read event
 
   fNHitsTotal = NHits;
-  fGridSizeTotal = 0;
-  fGrid1SizeTotal = 0;
-  fTexHitsFullSize = 0;
 
-  //cout<<"event mem = "<<fEventMemory<<endl;
+  {
+    Int_t oldSize = fCommonMemorySize;
+    SetPointers();
+    if( fCommonMemory && fCommonMemorySize > oldSize ){
+      delete[] fCommonMemory;
+      fCommonMemory = 0;
+    }
+    if( !fCommonMemory ){   
+      fCommonMemory = reinterpret_cast<Char_t*> ( new uint4 [ fCommonMemorySize/sizeof(uint4) + 100] );
+    }
+    SetPointers();  
+    *fNTracklets = 0;
+    *fNTracks = 0 ;
+    *fNOutTracks = 0;
+    *fNOutTrackHits = 0;
+  }
+
+  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;
+  Float_t *hitsYZ = reinterpret_cast<Float_t*>( fInputEvent ) + 1+fParam.NRows()*2+1;
+  for( Int_t iRow=0; iRow<fParam.NRows(); iRow++ ){
+    rowHeaders[iRow*2  ] = RowFirstHit[iRow];
+    rowHeaders[iRow*2+1] = RowNHits[iRow];
+  }
+  for( Int_t iHit=0; iHit<NHits; iHit++ ){
+    hitsYZ[iHit*2  ] = Y[iHit];
+    hitsYZ[iHit*2+1] = Z[iHit];
+  }
+  SetupRowData();
+}
+
+
+GPUd() void AliHLTTPCCATracker::SetupRowData()
+{
+  //* Convert input hits, create grids, etc.
+
+  fNHitsTotal = reinterpret_cast<Int_t*>( fInputEvent )[1+fParam.NRows()*2];
+  Int_t *rowHeaders = reinterpret_cast<Int_t*>( fInputEvent ) +1;
+  Float_t *hitsYZ = reinterpret_cast<Float_t*>( fInputEvent ) + 1+fParam.NRows()*2+1;
   for( Int_t iRow=0; iRow<fParam.NRows(); iRow++ ){
-    //cout<<"row, nhits="<<iRow<<" "<<RowNHits[iRow]<<endl;
-    //cout<<"row, firsthit="<<iRow<<" "<<RowFirstHit[iRow]<<endl;
     AliHLTTPCCARow &row = fRows[iRow];
-    row.FirstHit() = RowFirstHit[iRow];
-    row.NHits() = RowNHits[iRow];
+    row.FirstHit() = rowHeaders[iRow*2];
+    row.NHits() = rowHeaders[iRow*2+1];
     Float_t yMin=1.e3, yMax=-1.e3, zMin=1.e3, zMax=-1.e3;
-    Int_t nGrid =  row.NHits();   
-    for( Int_t i=0; i<row.NHits(); i++ ){       
-      Int_t j = RowFirstHit[iRow]+i;
-      if( yMax < Y[j] ) yMax = Y[j];
-      if( yMin > Y[j] ) yMin = Y[j];
-      if( zMax < Z[j] ) zMax = Z[j];
-      if( zMin > Z[j] ) zMin = Z[j];
+    Int_t nGrid =  row.NHits();
+    for( Int_t i=0; i<row.NHits(); i++ ){
+      Int_t j = row.FirstHit()+i;
+      Float_t y = hitsYZ[j*2];
+      Float_t z = hitsYZ[j*2+1];
+      if( yMax < y ) yMax = y;
+      if( yMin > y ) yMin = y;
+      if( zMax < z ) zMax = z;
+      if( zMin > z ) zMin = z;
     }
-    if( nGrid == 0 ){
+    if( nGrid <= 0 ){
       yMin = yMax = zMin = zMax = 0;
       nGrid = 1;
     }
 
     row.Grid().Create( yMin, yMax, zMin, zMax, nGrid );
-
-    float sy = ( CAMath::Abs( row.Grid().StepYInv() ) >1.e-4 ) ?1./row.Grid().StepYInv() :1;
-    float sz = ( CAMath::Abs( row.Grid().StepZInv() ) >1.e-4 ) ?1./row.Grid().StepZInv() :1;
-
+    
+    Float_t sy = ( CAMath::Abs( row.Grid().StepYInv() ) >1.e-4 ) ?1./row.Grid().StepYInv() :1;
+    Float_t sz = ( CAMath::Abs( row.Grid().StepZInv() ) >1.e-4 ) ?1./row.Grid().StepZInv() :1;
+    
     //cout<<"grid n = "<<row.Grid().N()<<" "<<sy<<" "<<sz<<" "<<yMin<<" "<<yMax<<" "<<zMin<<" "<<zMax<<endl;
     
-    bool recreate=0;
+    Bool_t recreate=0;
     if( sy < 2. ) { recreate = 1; sy = 2; }
     if( sz < 2. ) { recreate = 1; sz = 2; }
     if( recreate ) row.Grid().Create( yMin, yMax, zMin, zMax, sy, sz );
+    
+    //cout<<"grid row "<<iRow<<", n = "<<row.Grid().N()<<endl;
+  }    
 
-    fGridSizeTotal+=row.Grid().N()+3+10;    
-    //cout<<"grid n = "<<row.Grid().N()<<endl;
-  }
-  
-  fGrid1SizeTotal = fGridSizeTotal+10;
-
-  SetPointers();  
-
-  fEventMemory = (char*) ( new uint4 [ fEventMemSize/sizeof(uint4) + 100]);
-  SetPointers();
+  AliHLTTPCCAHit ffHits[fNHitsTotal];
 
-  fGridSizeTotal = 0;
-  fGrid1SizeTotal = 0;
+  Int_t rowDataOffset = 0;
 
   for( Int_t iRow=0; iRow<fParam.NRows(); iRow++ ){
     AliHLTTPCCARow &row = fRows[iRow];
@@ -311,8 +332,8 @@ GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits,
     for( UInt_t bin=0; bin<row.Grid().N()+3; bin++ ) filled[bin] = 0;  
 
     for( Int_t i=0; i<row.NHits(); i++ ){
-      Int_t j = RowFirstHit[iRow]+i;
-      Int_t bin = row.Grid().GetBin( Y[j], Z[j] );
+      Int_t j = row.FirstHit()+i;
+      Int_t bin = row.Grid().GetBin( hitsYZ[2*j], hitsYZ[2*j+1] );
       bins[i] = bin;
       filled[bin]++;
     }
@@ -327,70 +348,20 @@ GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits,
     for( Int_t i=0; i<row.NHits(); i++ ){ 
       Int_t bin = bins[i];
       Int_t ind = c[bin] + filled[bin]-1;
-      AliHLTTPCCAHit &h = fHits[RowFirstHit[iRow]+ind];
-      fHitsID[RowFirstHit[iRow]+ind] = RowFirstHit[iRow]+i;
-      h.Y() = Y[row.FirstHit()+i];
-      h.Z() = Z[row.FirstHit()+i];
+      AliHLTTPCCAHit &h = ffHits[row.FirstHit()+ind];
+      fHitInputIDs[row.FirstHit()+ind] = row.FirstHit()+i;
+      h.Y() = hitsYZ[2*(row.FirstHit()+i)];
+      h.Z() = hitsYZ[2*(row.FirstHit()+i)+1];
       filled[bin]--;
     }
 
-    grid.Offset() = fGridSizeTotal;
-    Int_t off= grid.N()+3+10;
-    fGridSizeTotal+=off;
-    Int_t n2 = grid.N()/2;
-    grid.Content2() = c[n2];
-    UChar_t *cnew = fGridContents + grid.Offset();
-
-    for( Int_t i=0; i<n2; i++ ){
-      Int_t v = c[i];
-      if( v>=256 ){
-       //cout<<" ERROR!!! "<<v<<endl;
-       v = 255;
-      }else if( v<0 ){
-       //cout<<" ERROR!!! "<<v<<endl;
-       v = 0;
-      }              
-      cnew[i] = (UChar_t ) v;
-    }
-    for( UInt_t i=n2; i<grid.N()+3; i++ ){
-      Int_t v = c[i] - grid.Content2();
-      if( v>=256 ){
-       //cout<<" ERROR 1 !!! "<<v<<endl;
-       v = 255;
-      }else if( v<0 ){
-       //cout<<" ERROR 1 !!! "<<v<<endl;
-       v = 0;
-      }
-      cnew[i] = (UChar_t) v;     
-    }
-
-    
-    UInt_t *cnew1 = fGrid1Contents + grid.Offset();
-
-    for( UInt_t i=0; i<grid.N()+1; i++ ){
-      UInt_t g0n = 0;
-      UInt_t g1n = 0;
-      UInt_t g1 = 0;
-      UInt_t g0 = c[i];// max [gN]
-      UInt_t g0e = c[i+2]; //max[gN+2]
-      g0n = g0e - g0;
-      if( i+grid.Ny()< grid.N()+1 ){// max [gN-gNy]
-       g1 = c[i+grid.Ny()]; // max [gN]
-       UInt_t g1e = c[i+grid.Ny()+2];//max [gN+2]
-       g1n = g1e - g1;  
-      }
-
-      if( g0n > 63 ) g0n = 63;
-      if( g1n > 63 ) g1n = 63;
-      cnew1[i] = (g1n<<26) + (g1<<16) + (g0n<<10) + g0;
-    }
     {
-      float y0 = row.Grid().YMin();
-      float stepY = (row.Grid().YMax() - y0)*(1./65535.);
-      float z0 = row.Grid().ZMin();
-      float stepZ = (row.Grid().ZMax() - z0)*(1./65535.);
-      float stepYi = 1./stepY;
-      float stepZi = 1./stepZ;
+      Float_t y0 = row.Grid().YMin();
+      Float_t stepY = (row.Grid().YMax() - y0)*(1./65535.);
+      Float_t z0 = row.Grid().ZMin();
+      Float_t stepZ = (row.Grid().ZMax() - z0)*(1./65535.);
+      Float_t stepYi = 1./stepY;
+      Float_t stepZi = 1./stepZ;
       
       row.Hy0() = y0;
       row.Hz0() = z0;
@@ -398,27 +369,19 @@ GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits,
       row.HstepZ() = stepZ;
       row.HstepYi() = stepYi;
       row.HstepZi() = stepZi;
-      
+
+      row.FullOffset() = rowDataOffset;
+      ushort2 *p= (ushort2*)( fRowData + row.FullOffset() );
       for( Int_t ih=0; ih<row.NHits(); ih++ ){
-       Int_t ihTot = RowFirstHit[iRow]+ih;
-       AliHLTTPCCAHit &hh = fHits[ihTot];
-       ushort2  &h = fHits1[ihTot];
-       float xx = ((hh.Y() - y0)*stepYi); //SG!!!
-       float yy = ((hh.Z() - z0)*stepZi);
+       Int_t ihTot = row.FirstHit()+ih;
+       AliHLTTPCCAHit &hh = ffHits[ihTot];
+       Float_t xx = ((hh.Y() - y0)*stepYi);
+       Float_t yy = ((hh.Z() - z0)*stepZi);
        if( xx<0 || yy<0 || xx>=65536 || yy>= 65536 ){
-         cout<<"!!!! hit packing error!!! "<<xx<<" "<<yy<<" "<<endl;
+         std::cout<<"!!!! hit packing error!!! "<<xx<<" "<<yy<<" "<<std::endl;
        }
-       h.x = (UShort_t) xx;//((hh.Y() - y0)*stepYi);
-       h.y = (UShort_t) yy;//((hh.Z() - z0)*stepZi);
-      }
-    }
-
-    if(1){       
-      row.FullOffset() = fTexHitsFullSize;
-      ushort2 *p= (ushort2*)(fTexHitsFullData+row.FullOffset());      
-      for( Int_t ih=0; ih<row.NHits(); ih++ ){
-       Int_t ihTot = RowFirstHit[iRow]+ih;
-       p[ih] = fHits1[ihTot];
+       p[ih].x = (UShort_t) xx;
+       p[ih].y = (UShort_t) yy;
       }
       Int_t size = row.NHits()*sizeof(ushort2);
 
@@ -430,28 +393,27 @@ GPUd() void AliHLTTPCCATracker::ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits,
        p1[i] = c[i];
       }     
       UShort_t a = c[n];
-      Int_t nn = n+grid.Ny()+2;
+      Int_t nn = n+grid.Ny()+3;
       for( Int_t i=n; i<nn; i++ ) p1[i] = a;
 
       size+= (nn)*sizeof(UShort_t);
       row.FullLinkOffset() = row.NHits()*2 + nn;
       size+= row.NHits()*2*sizeof(Short_t);
-      if( size%16 ) size = size/16+1;
-      else size = size/16;
+      if( size%16 ) size = size/sizeof(uint4)+1;
+      else size = size/sizeof(uint4);
       row.FullSize()=size;
-      //cout<<iRow<<", "<<row.fNHits<<"= "<<size*16<<"b: "<<row.fFullOffset<<" "<<row.fFullSize<<" "<<row.fFullGridOffset<<" "<<row.fFullLinkOffset<<endl;
+      //cout<<iRow<<", "<<row.fNHits<<"= "<<size*16<<"b: "<<row.fFullOffset<<" "<<row.fFullSize<<" "<<row.fFullGridOffset<<" "<<row.fFullLinkOffset<<std::endl;
 
-      fTexHitsFullSize+=size;
+      rowDataOffset+=size;
     }
-  }
-  fGrid1SizeTotal = fGridSizeTotal+10;
+  } 
 }
 
 
 GPUh() void AliHLTTPCCATracker::Reconstruct()
 {
   //* reconstruction of event
-  
+   
 #ifdef DRAW
   if( !gApplication ){
     TApplication *myapp = new TApplication("myapp",0,0);
@@ -477,16 +439,18 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
   fTimers[7] = 0;
 
   if( fNHitsTotal < 1 ) return;
-  //if( fParam.ISlice()!=3 ) return;
   TStopwatch timer0;
+
   *fNTracks = 0;
+  *fNTracklets = 0;
+
 #if !defined(HLTCA_GPUCODE)  
 
   AliHLTTPCCAProcess<AliHLTTPCCANeighboursFinder>( Param().NRows(), 1, *this );
   AliHLTTPCCAProcess<AliHLTTPCCANeighboursCleaner>( Param().NRows()-2, 1, *this );
   AliHLTTPCCAProcess<AliHLTTPCCAStartHitsFinder>( Param().NRows()-4, 1, *this );
 
-  Int_t nStartHits = *fStartHits;      
+  Int_t nStartHits = *fNTracklets;
   
   Int_t nThreads = 128;
   Int_t nBlocks = fNHitsTotal/nThreads + 1;
@@ -501,15 +465,7 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
 
   AliHLTTPCCAProcess<AliHLTTPCCAUsedHitsInitialiser>(nBlocks, nThreads,*this);
 
-  nThreads = 256;
-  nBlocks = 30;
-
-  nThreads = 1;
-  nBlocks = 1;
-  
-  AliHLTTPCCAProcess<AliHLTTPCCALinksWriter>(nBlocks, nThreads,*this);
-
-  Int_t nMemThreads = 128;
+  Int_t nMemThreads = AliHLTTPCCATrackletConstructor::NMemThreads();
   nThreads = 256;//96;
   nBlocks = nStartHits/nThreads + 1;
   if( nBlocks<30 ){
@@ -531,8 +487,8 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
       nThreads = nStartHits/12+1;
       nThreads = (nThreads/32+1)*32;
     }
-    *fStartHits = 0;
-    *fTrackHits = 0;
+    
+    *fNTrackHits = 0;
 
     nThreads = nStartHits;
     nBlocks = 1;
@@ -540,28 +496,14 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
 
     AliHLTTPCCAProcess<AliHLTTPCCATrackletSelector>(nBlocks, nThreads,*this);
 
-    //cudaMemcpy(cpuTrackerCopy.fNTracks, gpuTrackerCopy.fNTracks, sizeof(int), cudaMemcpyDeviceToHost);
-    //cudaMemcpy(cpuTrackerCopy.fTrackHits, gpuTrackerCopy.fTrackHits, sizeof(int), cudaMemcpyDeviceToHost);
-         
-    //Int_t size = sizeof(AliHLTTPCCATrack)*( *cpuTrackerCopy.fNTracks );
-    //cudaMemcpy(cpuTrackerCopy.fTracks, gpuTrackerCopy.fTracks, size, cudaMemcpyDeviceToHost);
-    //cout<<"Tracks size = "<<size<<endl;      
-    
-    //size = sizeof(Int_t)*( *cpuTrackerCopy.fTrackHits );
-    //cudaMemcpy(cpuTrackerCopy.fTrackHits+1, gpuTrackerCopy.fTrackHits+1, size, cudaMemcpyDeviceToHost);
-    //cout<<"Track hits size = "<<size<<endl;
-    //cpuTrackerCopy.WriteOutput();
-    Int_t nTracklets = *fStartHits;
-
-    //cout<<"Slice "<<Param().ISlice()<<": N start hits/tracklets/tracks = "<<nStartHits<<" "<<nTracklets<<" "<<*fNTracks<<endl;
-   WriteOutput();      
+    //cout<<"Slice "<<Param().ISlice()<<": N start hits/tracklets/tracks = "<<nStartHits<<" "<<nStartHits<<" "<<*fNTracks<<std::endl;
+    WriteOutput();      
   }
 
 #endif
 
-  timer0.Stop();
-  fTimers[0] = timer0.CpuTime();
+  timer0.Stop();  
+  fTimers[0] = timer0.CpuTime()/100.;
 
  }
 
@@ -573,54 +515,50 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
   // write output
 
   TStopwatch timer;
-  fOutTrackHits = new Int_t[fNHitsTotal*10];
-  fOutTracks = new AliHLTTPCCAOutTrack[*fNTracks];
-  fNOutTrackHits = 0;
-  fNOutTracks = 0;
-  //cout<<"NTracks = "<<*fNTracks<<endl;
-  //cout<<"NHits = "<<fNHitsTotal<<endl;
+  *fNOutTrackHits = 0;
+  *fNOutTracks = 0;
+
+  //cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<fNHitsTotal<<std::endl;  
+
   for( Int_t iTr=0; iTr<*fNTracks; iTr++){
-    //cout<<"iTr = "<<iTr<<endl;
+
     AliHLTTPCCATrack &iTrack = fTracks[iTr];
+
+    //cout<<"iTr = "<<iTr<<", nHits="<<iTrack.NHits()<<std::endl;
     if( !iTrack.Alive() ) continue;
-    if( iTrack.NHits()<3 ) continue;      
-    //cout<<10<<endl;
-    AliHLTTPCCAOutTrack &out = fOutTracks[fNOutTracks];
-    out.FirstHitRef() = fNOutTrackHits;
+    if( iTrack.NHits()<3 ) continue;          
+    AliHLTTPCCAOutTrack &out = fOutTracks[*fNOutTracks];
+    out.FirstHitRef() = *fNOutTrackHits;
     out.NHits() = 0;
     out.OrigTrackID() = iTr;
     {
       out.StartPoint() = iTrack.Param();
       out.EndPoint() = iTrack.Param();
     }
-    //cout<<11<<endl;
 
     Int_t iID = iTrack.FirstHitID();
-    Int_t fNOutTrackHitsOld = fNOutTrackHits;
-    //cout<<12<<" "<<iID<<" "<<iTrack.NHits()<<endl;
+    Int_t nOutTrackHitsOld = *fNOutTrackHits;
     for( Int_t ith=0; ith<iTrack.NHits(); ith++ ){
-      //cout<<ith<<":"<<endl;
       Int_t ic = (fTrackHits[iID+ith]);
-      //cout<<ic<<endl;
       AliHLTTPCCARow &row = ID2Row(ic);
       Int_t ih = ID2IHit(ic);
-      //cout<<"write row,hit="<<ID2IRow(ic)<<" "<<ih<<endl;
-      fOutTrackHits[fNOutTrackHits] = fHitsID[row.FirstHit()+ih];
-      fNOutTrackHits++;
-      //cout<<"ok"<<endl;
-      if( fNOutTrackHits>fNHitsTotal*10 ){
-       cout<<"fNOutTrackHits>fNHitsTotal"<<endl;
-       exit(0);//SG!!!
+      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 ){
+       std::cout<<"fNOutTrackHits>fNHitsTotal"<<std::endl;
+       //exit(0);
        return;
       }
       out.NHits()++;      
-    }
-    //cout<<13<<endl;
-    //cout<<fNOutTracks<<": itr = "<<iTr<<", n outhits = "<<out.NHits()<<endl;
+    }    
     if( out.NHits() >= 2 ){
-      fNOutTracks++;
+      (*fNOutTracks)++;
     }else {
-      fNOutTrackHits = fNOutTrackHitsOld;
+      (*fNOutTrackHits) = nOutTrackHitsOld;
     }
   }
   timer.Stop();
@@ -726,7 +664,7 @@ GPUh() void AliHLTTPCCATracker::FitTrack( AliHLTTPCCATrack &/*track*/, Float_t *
   Float_t sp0[5] = {row0.X(), c0.Y(), c0.Z(), c0.ErrY(), c0.ErrZ() };
   Float_t sp1[5] = {row1.X(), c1.Y(), c1.Z(), c1.ErrY(), c1.ErrZ() };
   Float_t sp2[5] = {row2.X(), c2.Y(), c2.Z(), c2.ErrY(), c2.ErrZ() };
-  //cout<<"Fit track, points ="<<sp0[0]<<" "<<sp0[1]<<" / "<<sp1[0]<<" "<<sp1[1]<<" / "<<sp2[0]<<" "<<sp2[1]<<endl;
+  //cout<<"Fit track, points ="<<sp0[0]<<" "<<sp0[1]<<" / "<<sp1[0]<<" "<<sp1[1]<<" / "<<sp2[0]<<" "<<sp2[1]<<std::endl;
   if( track.NHits()>=3 ){    
     p0.Param().ConstructXYZ3(sp0,sp1,sp2,p0.Param().CosPhi(), t0);
     p2.Param().ConstructXYZ3(sp2,sp1,sp0,p2.Param().CosPhi(), t0);
@@ -767,18 +705,127 @@ GPUd() void AliHLTTPCCATracker::GetErrors2( Int_t iRow, const AliHLTTPCCATrackPa
   Err2Z = fParam.GetClusterError2(1,type, z,angleZ);
 }
 
-GPUd() void AliHLTTPCCATracker::GetErrors2( Int_t iRow, const AliHLTTPCCATrackParam1 &t, Float_t &Err2Y, Float_t &Err2Z ) const
+
+#if !defined(HLTCA_GPUCODE)  
+
+GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out ) 
 {
-  //
-  // Use calibrated cluster error from OCDB
-  //
+  // write event to the file
+  for( Int_t iRow=0; iRow<fParam.NRows(); iRow++ ){
+    out<<fRows[iRow].FirstHit()<<" "<<fRows[iRow].NHits()<<std::endl;
+  } 
+  out<<fNHitsTotal<<std::endl;
 
-  Float_t z = CAMath::Abs((250.-0.275)-CAMath::Abs(t.GetZ()));
-  Int_t    type = (iRow<63) ? 0: (iRow>126) ? 1:2;
-  Float_t cosPhiInv = CAMath::Abs(t.GetCosPhi())>1.e-2 ?1./t.GetCosPhi() :0;
-  Float_t angleY = t.GetSinPhi()*cosPhiInv ;
-  Float_t angleZ = t.GetDzDs()*cosPhiInv ;
+  Float_t y[fNHitsTotal], z[fNHitsTotal];
+  for( Int_t iRow=0; iRow<fParam.NRows(); iRow++){
+    AliHLTTPCCARow &row = Rows()[iRow];
+    Float_t y0 = row.Grid().YMin();
+    Float_t z0 = row.Grid().ZMin();
+    Float_t stepY = row.HstepY();
+    Float_t stepZ = row.HstepZ();
+    uint4* tmpint4 = RowData() + row.FullOffset();
+    ushort2 *hits = reinterpret_cast<ushort2*>(tmpint4);
+    for( Int_t ih=0; ih<fRows[iRow].NHits(); ih++ ){
+      Int_t ihTot = row.FirstHit() + ih;
+      Int_t id = fHitInputIDs[ihTot];
+      ushort2 hh = hits[ih];
+      y[id] = y0 + hh.x*stepY;
+      z[id] = z0 + hh.y*stepZ;
+    }
+  }
+  for( Int_t ih=0; ih<fNHitsTotal; ih++ ){
+    out<<y[ih]<<" "<<z[ih]<<std::endl;
+  }
+}
 
-  Err2Y = fParam.GetClusterError2(0,type, z,angleY);  
-  Err2Z = fParam.GetClusterError2(1,type, z,angleZ);
+GPUh() void AliHLTTPCCATracker::ReadEvent( std::istream &in ) 
+{
+  //* Read event from file 
+
+  Int_t rowFirstHit[Param().NRows()], rowNHits[Param().NRows()];  
+  for( Int_t iRow=0; iRow<Param().NRows(); iRow++ ){
+    in>>rowFirstHit[iRow]>>rowNHits[iRow];
+  }
+  Int_t nHits;
+  in >> nHits;
+  Float_t y[nHits], z[nHits];
+  for( Int_t ih=0; ih<nHits; ih++ ){
+    in>>y[ih]>>z[ih];
+  }
+  ReadEvent( rowFirstHit, rowNHits, y, z, nHits );
+} 
+
+GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out ) 
+{
+  //* Write tracks to file 
+  out<<fTimers[0]<<std::endl;
+  out<<*fNOutTrackHits<<std::endl;
+  for( Int_t ih=0; ih<*fNOutTrackHits; ih++ ){
+    out<< fOutTrackHits[ih]<<" ";
+  }
+  out<<std::endl;
+  
+  out<<*fNOutTracks<<std::endl;
+
+  for( Int_t itr=0; itr<*fNOutTracks; itr++ ){
+    AliHLTTPCCAOutTrack &t = fOutTracks[itr];    
+    AliHLTTPCCATrackParam &p1 = t.StartPoint();        
+    AliHLTTPCCATrackParam &p2 = t.EndPoint();  
+    out<< t.NHits()<<" ";
+    out<< t.FirstHitRef()<<" ";
+    out<< t.OrigTrackID()<<" ";
+    out<<std::endl;
+    out<< p1.X()<<" ";
+    out<< p1.CosPhi()<<" ";
+    out<< p1.Chi2()<<" ";
+    out<< p1.NDF()<<std::endl;
+    for( Int_t i=0; i<5; i++ ) out<<p1.Par()[i]<<" ";
+    out<<std::endl;
+    for( Int_t i=0; i<15; i++ ) out<<p1.Cov()[i]<<" ";
+    out<<std::endl;
+    out<< p2.X()<<" ";
+    out<< p2.CosPhi()<<" ";
+    out<< p2.Chi2()<<" ";
+    out<< p2.NDF()<<std::endl;
+    for( Int_t i=0; i<5; i++ ) out<<p2.Par()[i]<<" ";
+    out<<std::endl;
+    for( Int_t i=0; i<15; i++ ) out<<p2.Cov()[i]<<" ";
+    out<<std::endl;
+  }
+}
+
+GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in )
+{
+  //* Read tracks  from file 
+  in>>fTimers[0];
+  in>>*fNOutTrackHits;  
+
+  for( Int_t ih=0; ih<*fNOutTrackHits; ih++ ){
+    in>>fOutTrackHits[ih];
+  }
+  in>>*fNOutTracks;
+
+  for( Int_t itr=0; itr<*fNOutTracks; itr++ ){
+    AliHLTTPCCAOutTrack &t = fOutTracks[itr];    
+    AliHLTTPCCATrackParam &p1 = t.StartPoint();        
+    AliHLTTPCCATrackParam &p2 = t.EndPoint();  
+    in>> t.NHits();
+    in>> t.FirstHitRef();
+    in>> t.OrigTrackID();    
+    in>> p1.X();
+    in>> p1.CosPhi();
+    in>> p1.Chi2();
+    in>> p1.NDF();
+    for( Int_t i=0; i<5; i++ ) in>>p1.Par()[i];
+    for( Int_t i=0; i<15; i++ ) in>>p1.Cov()[i];
+    in>> p2.X();
+    in>> p2.CosPhi();
+    in>> p2.Chi2();
+    in>> p2.NDF();
+    for( Int_t i=0; i<5; i++ ) in>>p2.Par()[i];
+    for( Int_t i=0; i<15; i++ ) in>>p2.Cov()[i];
+  }
 }
+#endif
index 549c88a..c32b515 100644 (file)
 #include "AliHLTTPCCAParam.h"
 #include "AliHLTTPCCARow.h"
 #include "AliHLTTPCCAHit.h"
+#include <iostream>
 
 class AliHLTTPCCATrack;
 class AliHLTTPCCAOutTrack;
 class AliHLTTPCCATrackParam;
-class AliHLTTPCCATrackParam1;
-
+class AliHLTTPCCATracklet;
 
 
 /**
@@ -51,28 +51,12 @@ class AliHLTTPCCATracker
 
   GPUd() void ReadEvent( Int_t *RowFirstHit, Int_t *RowNHits, Float_t *Y, Float_t *Z, Int_t NHits );
 
-  void Reconstruct();
+  GPUd() void SetupRowData();
 
+  void Reconstruct();
   void WriteOutput();
 
   GPUd() void GetErrors2( Int_t iRow,  const AliHLTTPCCATrackParam &t, Float_t &Err2Y, Float_t &Err2Z ) const;
-  GPUd() void GetErrors2( Int_t iRow,  const AliHLTTPCCATrackParam1 &t, Float_t &Err2Y, Float_t &Err2Z ) const;
-
-  GPUhd() AliHLTTPCCAParam &Param(){ return fParam; }
-  GPUhd() AliHLTTPCCARow *Rows(){ return fRows; }
-
-  Int_t * HitsID(){ return fHitsID; }
-
-  Int_t *OutTrackHits(){ return  fOutTrackHits; }
-  Int_t NOutTrackHits() const { return  fNOutTrackHits; }
-  GPUd() AliHLTTPCCAOutTrack *OutTracks(){ return  fOutTracks; }
-  GPUd() Int_t NOutTracks() const { return  fNOutTracks; }
-  GPUhd() Int_t *TrackHits(){ return fTrackHits; }
-
-  GPUhd() AliHLTTPCCATrack *Tracks(){ return  fTracks; }
-  GPUhd() Int_t &NTracks()  { return *fNTracks; }
-
-  Double_t *Timers(){ return fTimers; }
 
   GPUhd() static Int_t IRowIHit2ID( Int_t iRow, Int_t iHit ){ 
     return (iHit<<8)+iRow; 
@@ -84,9 +68,9 @@ class AliHLTTPCCATracker
     return ( HitID>>8 ); 
   }  
 
-  GPUhd() AliHLTTPCCAHit &ID2Hit( Int_t HitID ) {
-    return fHits[fRows[HitID%256].FirstHit() + (HitID>>8)];
-  }
+  //GPUhd() AliHLTTPCCAHit &ID2Hit( Int_t HitID ) {
+  //return fHits[fRows[HitID%256].FirstHit() + (HitID>>8)];
+  //}
   GPUhd() AliHLTTPCCARow &ID2Row( Int_t HitID ) {
     return fRows[HitID%256];
   }
@@ -95,63 +79,82 @@ class AliHLTTPCCATracker
   void FitTrackFull( AliHLTTPCCATrack &track, Float_t *t0 = 0 ) const;
   GPUhd() void SetPointers();
 
-  GPUhd() Short_t *HitLinkUp(){ return fHitLinkUp;}
-  GPUhd() Short_t *HitLinkDown(){ return fHitLinkDown;}
-  GPUhd() Int_t  *StartHits(){ return fStartHits;}
-  GPUhd() Int_t  *Tracklets(){ return fTracklets;}
-  GPUhd() Int_t  *HitIsUsed(){ return fHitIsUsed;}
-  GPUhd() AliHLTTPCCAHit *Hits(){ return fHits;}
+#if !defined(HLTCA_GPUCODE)  
+  GPUh() void WriteEvent( std::ostream &out );
+  GPUh() void ReadEvent( std::istream &in );
+  GPUh() void WriteTracks( std::ostream &out ) ;
+  GPUh() void ReadTracks( std::istream &in );
+#endif
+
+  GPUhd() AliHLTTPCCAParam &Param(){ return fParam; }
+  GPUhd() AliHLTTPCCARow *Rows(){ return fRows; }
+  GPUhd()  Double_t *Timers(){ return fTimers; }
   GPUhd() Int_t &NHitsTotal(){ return fNHitsTotal;}
-  GPUhd() uint4 *&TexHitsFullData(){ return fTexHitsFullData;}
-  GPUhd() Int_t &TexHitsFullSize(){ return fTexHitsFullSize;}
 
-  GPUd() UChar_t GetGridContent( UInt_t i ) const; 
-  GPUd() AliHLTTPCCAHit GetHit( UInt_t i ) const;
+  GPUhd() Char_t *InputEvent()    { return fInputEvent; }
+  GPUhd() Int_t  &InputEventSize(){ return fInputEventSize; }
 
-  private:
+  GPUhd() uint4  *RowData()       { return fRowData; }
+  GPUhd() Int_t  &RowDataSize()  { return fRowDataSize; }
  
-  //  
+  GPUhd() Int_t * HitInputIDs(){ return fHitInputIDs; }
+  GPUhd() Int_t  *HitWeights(){ return fHitWeights; }  
+  
+  GPUhd() Int_t  *NTracklets(){ return fNTracklets; }
+  GPUhd() Int_t  *TrackletStartHits(){ return fTrackletStartHits; }
+  GPUhd() AliHLTTPCCATracklet  *Tracklets(){ return fTracklets;}
+  
+  GPUhd() Int_t *NTracks()  { return fNTracks; }
+  GPUhd() AliHLTTPCCATrack *Tracks(){ return  fTracks; }
+  GPUhd() Int_t *NTrackHits()  { return fNTrackHits; }
+  GPUhd() Int_t *TrackHits(){ return fTrackHits; }
+
+  GPUhd()  Int_t *NOutTracks() const { return  fNOutTracks; }
+  GPUhd()  AliHLTTPCCAOutTrack *OutTracks(){ return  fOutTracks; }
+  GPUhd()  Int_t *NOutTrackHits() const { return  fNOutTrackHits; }
+  GPUhd()  Int_t *OutTrackHits(){ return  fOutTrackHits; }
+  GPUh() void SetCommonMemory( Char_t *mem ){ fCommonMemory = mem; }
+
+  private:  
 
   AliHLTTPCCAParam fParam; // parameters
   AliHLTTPCCARow fRows[200];// array of hit rows
   Double_t fTimers[10]; // running CPU time for different parts of the algorithm
   
   // event
+
   Int_t fNHitsTotal;// total number of hits in event
-  Int_t fGridSizeTotal; // total grid size
-  Int_t fGrid1SizeTotal;// total grid1 size
+  Char_t *fCommonMemory; // common event memory
+  Int_t   fCommonMemorySize; // size of the event memory [bytes]
 
-  AliHLTTPCCAHit *fHits; // hits
-  ushort2 *fHits1; // hits1
-  
-  UChar_t *fGridContents; // grid content
-  UInt_t *fGrid1Contents; // grid1 content
-  Int_t *fHitsID; // hit ID's
+  Char_t *fInputEvent;     // input event
+  Int_t   fInputEventSize; // size of the input event [bytes]
+
+  uint4  *fRowData;     // TPC rows: clusters, grid, links to neighbours
+  Int_t   fRowDataSize; // size of the row data
  
-  // temporary information
+  Int_t *fHitInputIDs; // cluster index in InputEvent  
+  Int_t *fHitWeights;  // the weight of the longest tracklet crossed the cluster
   
-  Short_t *fHitLinkUp; // array of up links
-  Short_t *fHitLinkDown;// array of down links
-  Int_t *fHitIsUsed; // array of used flags
-  Int_t  *fStartHits;   // array of start hits
-  Int_t *fTracklets; // array of tracklets
+  Int_t *fNTracklets;     // number of tracklets 
+  Int_t *fTrackletStartHits;   // start hits for the tracklets
+  AliHLTTPCCATracklet *fTracklets; // tracklets
 
-  Int_t *fNTracks;// number of reconstructed tracks
-  AliHLTTPCCATrack *fTracks;   // reconstructed tracks
-  Int_t *fTrackHits; // array of track hit numbers
+  // 
+  Int_t *fNTracks;            // number of reconstructed tracks
+  AliHLTTPCCATrack *fTracks;  // reconstructed tracks
+  Int_t *fNTrackHits;           // number of track hits
+  Int_t *fTrackHits;          // array of track hit numbers
 
   // output
 
-  Int_t fNOutTracks; // number of tracks in fOutTracks array
-  Int_t fNOutTrackHits;  // number of hits in fOutTrackHits array
+  Int_t *fNOutTracks; // number of tracks in fOutTracks array
   AliHLTTPCCAOutTrack *fOutTracks; // output array of the reconstructed tracks
+  Int_t *fNOutTrackHits;  // number of hits in fOutTrackHits array
   Int_t *fOutTrackHits;  // output array of ID's of the reconstructed hits
 
-  char *fEventMemory; // common event memory
-  UInt_t fEventMemSize; // size of the event memory
-
-  uint4 *fTexHitsFullData; // CUDA texture for hits
-  Int_t fTexHitsFullSize; // size of the CUDA texture
 };
 
 
index 3fc40d2..c1c6ab2 100644 (file)
@@ -26,7 +26,6 @@
 using namespace std;
 #endif
 
-#include <climits>
 #include "AliHLTTPCCATrackerComponent.h"
 #include "AliHLTTPCTransform.h"
 #include "AliHLTTPCCATracker.h"
@@ -141,7 +140,7 @@ AliHLTComponent* AliHLTTPCCATrackerComponent::Spawn()
   return new AliHLTTPCCATrackerComponent;
 }
 
-int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
+Int_t AliHLTTPCCATrackerComponent::DoInit( Int_t argc, const char** argv )
 {
   // Initialize the CA tracker component 
   //
@@ -160,7 +159,7 @@ int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
   
   // read command line
 
-  int i = 0;
+  Int_t i = 0;
   char* cpErr;
   while ( i < argc ){
     if ( !strcmp( argv[i], "solenoidBz" ) || !strcmp( argv[i], "-solenoidBz" ) ){
@@ -268,7 +267,7 @@ int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
   return 0;
 }
 
-int AliHLTTPCCATrackerComponent::DoDeinit()
+Int_t AliHLTTPCCATrackerComponent::DoDeinit()
 {
   // see header file for class documentation
   if ( fTracker ) delete fTracker;
@@ -284,7 +283,7 @@ Bool_t AliHLTTPCCATrackerComponent::CompareClusters(AliHLTTPCSpacePointData *a,
   return (a->fZ < b->fZ);
 }
 
-int AliHLTTPCCATrackerComponent::DoEvent
+Int_t AliHLTTPCCATrackerComponent::DoEvent
 ( 
  const AliHLTComponentEventData& evtData, 
  const AliHLTComponentBlockData* blocks, 
@@ -428,7 +427,7 @@ int AliHLTTPCCATrackerComponent::DoEvent
   // min and max patch numbers and row numbers
 
   Int_t row[2] = {0,0};
-  Int_t minPatch=INT_MAX, maxPatch = -1;
+  Int_t minPatch=100, maxPatch = -1;
 
   // total n Hits
 
@@ -553,13 +552,13 @@ int AliHLTTPCCATrackerComponent::DoEvent
 
   AliHLTTPCTrackSegmentData* currOutTracklet = outPtr->fTracklets;
 
-  Int_t ntracks = fTracker->NOutTracks();
+  Int_t ntracks = *fTracker->NOutTracks();
 
   UInt_t mySize =   ((AliHLTUInt8_t *)currOutTracklet) -  ((AliHLTUInt8_t *)outputPtr);
 
   outPtr->fTrackletCnt = 0; 
 
-  for( int itr=0; itr<ntracks; itr++ ){
+  for( Int_t itr=0; itr<ntracks; itr++ ){
     
     AliHLTTPCCAOutTrack &t = fTracker->OutTracks()[itr];    
 
index eeb1d72..a7845f0 100644 (file)
@@ -57,13 +57,13 @@ protected:
   // capabilities of the component. 
   
   /** @see component interface @ref AliHLTComponent::DoInit */
-  int DoInit( int argc, const char** argv );
+  Int_t DoInit( Int_t argc, const char** argv );
   
   /** @see component interface @ref AliHLTComponent::DoDeinit */
-  int DoDeinit();
+  Int_t DoDeinit();
   
   /** @see component interface @ref AliHLTProcessor::DoEvent */
-  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+  Int_t DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
               AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
               AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
   
index 0c0d24b..9350b8b 100644 (file)
 
 #include "AliHLTTPCCATracker.h"
 #include "AliHLTTPCCATrackParam.h"
-#include "AliHLTTPCCATrackParam1.h"
+#include "AliHLTTPCCATrackParam.h"
 #include "AliHLTTPCCAGrid.h"
 #include "AliHLTTPCCAHitArea.h"
 #include "AliHLTTPCCAMath.h"
 #include "AliHLTTPCCADef.h"
 #include "AliHLTTPCCATrackletConstructor.h"
 
-//GPUd() void myprintf1(int i, int j){
-  //printf("fwd: iS=%d, iRow=%d\n",i,j);
-//}
-//GPUd() void myprintf2(int i, int j){
-  //printf("bck: iS=%d, iRow=%d\n",i,j);
-//}
-
 
 GPUd() void AliHLTTPCCATrackletConstructor::Step0 
-( Int_t nBlocks, Int_t /*nThreads*/, Int_t iBlock, Int_t iThread, Int_t /*iSync*/,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &/*tParam*/ )
+( Int_t nBlocks, Int_t /*nThreads*/, Int_t iBlock, Int_t iThread,
+  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &/*tParam*/ )
 {
   // reconstruction of tracklets, step 0
   
-  const Int_t kNMemThreads = 128;
-  
-  r.fIsMemThread = ( iThread<kNMemThreads );
-  if( iThread==0 ){    
-    int nTracks = tracker.StartHits()[0];
-    if(iBlock==0) *tracker.Tracklets() = nTracks;
-    int nTrPerBlock = nTracks/nBlocks+1;
+  r.fIsMemThread = ( iThread<NMemThreads() );
+  if( iThread==0 ){
+    Int_t nTracks = *tracker.NTracklets();
+    Int_t nTrPerBlock = nTracks/nBlocks+1;
     s.fNRows = tracker.Param().NRows();
     s.fItr0 = nTrPerBlock*iBlock;
     s.fItr1 = s.fItr0 + nTrPerBlock;
     if( s.fItr1> nTracks ) s.fItr1 = nTracks;
-    s.fUsedHits = tracker.HitIsUsed();
+    s.fUsedHits = tracker.HitWeights();
     s.fMinStartRow = 158;
     s.fMaxStartRow = 0;
   }
@@ -62,14 +52,12 @@ GPUd() void AliHLTTPCCATrackletConstructor::Step0
 
 
 GPUd() void AliHLTTPCCATrackletConstructor::Step1 
-( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t iThread, Int_t /*iSync*/,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam )
+( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t iThread,
+  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam )
 {
-  // reconstruction of tracklets, step 1
-
-  const Int_t kNMemThreads = 128;
+  // reconstruction of tracklets, step 1  
 
-  r.fItr= s.fItr0 + ( iThread - kNMemThreads ); 
+  r.fItr= s.fItr0 + ( iThread - NMemThreads() ); 
   r.fGo = (!r.fIsMemThread) && ( r.fItr<s.fItr1 );
   r.fSave = r.fGo;
   r.fNHits=0;
@@ -77,18 +65,19 @@ 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;
   
-  r.fTrackStoreOffset = 1 + r.fItr*(5+ sizeof(AliHLTTPCCATrackParam)/4 + 160 );
-  r.fHitStoreOffset = r.fTrackStoreOffset + 5+ sizeof(AliHLTTPCCATrackParam)/4 ;
-  
-  int *hitstore = tracker.Tracklets() +r.fHitStoreOffset;
+  Int_t *hitstore = ((Int_t*) tracker.Tracklets()) +r.fHitStoreOffset;
   
   UInt_t kThread = iThread %32;//& 00000020;
-  if( SAVE() ) for( int i=0; i<160; i++ ) hitstore[i] = -1;
-  
-  int id = tracker.StartHits()[1 + r.fItr];
+  if( SAVE() ) for( Int_t i=0; i<160; i++ ) hitstore[i] = -1;
+    
+  Int_t id = tracker.TrackletStartHits()[r.fItr];
   r.fFirstRow = AliHLTTPCCATracker::ID2IRow(id);
   r.fCurrIH =  AliHLTTPCCATracker::ID2IHit(id);
+  
   CAMath::atomicMin( &s.fMinStartRow32[kThread], r.fFirstRow);    
   CAMath::atomicMax( &s.fMaxStartRow32[kThread], r.fFirstRow);    
   tParam.SinPhi() = 0;
@@ -118,76 +107,51 @@ GPUd() void AliHLTTPCCATrackletConstructor::Step1
   tParam.Cov()[13] = 0;
   tParam.Cov()[14] = 1.;
 
-  r.fLastRow = r.fFirstRow;
+  r.fLastRow = r.fFirstRow;  
 }
 
 GPUd() void AliHLTTPCCATrackletConstructor::Step2 
-( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t iThread, Int_t /*iSync*/,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &/*r*/, AliHLTTPCCATracker &/*tracker*/, AliHLTTPCCATrackParam1 &/*tParam*/ )
+( Int_t /*nBlocks*/, Int_t nThreads, Int_t /*iBlock*/, Int_t iThread,
+  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &/*r*/, AliHLTTPCCATracker &/*tracker*/, AliHLTTPCCATrackParam &/*tParam*/ )
 {  
   // reconstruction of tracklets, step 2
+  
   if( iThread==0 ){
     //CAMath::atomicMinGPU(&s.fMinRow, s.fMinRow32[iThread]);
-    int minStartRow = 158;
-    int maxStartRow = 0;
-    for( int i=0; i<32; i++ ){      
+    Int_t minStartRow = 158;
+    Int_t maxStartRow = 0;
+    Int_t n = (nThreads>32 ) ?32 :nThreads;
+    for( Int_t i=0; i<n; i++ ){      
       if( s.fMinStartRow32[i]<minStartRow ) minStartRow = s.fMinStartRow32[i];
       if( s.fMaxStartRow32[i]>maxStartRow ) maxStartRow = s.fMaxStartRow32[i];
     }   
     s.fMinStartRow = minStartRow;
     s.fMaxStartRow = maxStartRow;
-  }
+  } 
 }
 
 GPUd() void AliHLTTPCCATrackletConstructor::ReadData 
 ( Int_t iThread, AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, Int_t iRow )
-{  
-
+{    
   // reconstruction of tracklets, read data step
-  const Int_t kNMemThreads = 128;
+
   if( r.fIsMemThread ){
     AliHLTTPCCARow &row = tracker.Rows()[iRow];
-    bool jr = !r.fCurrentData;
+    Bool_t jr = !r.fCurrentData;
     Int_t n = row.FullSize();
-    uint4* gMem = tracker.TexHitsFullData() + row.FullOffset();
+    uint4* gMem = tracker.RowData() + row.FullOffset();
     uint4 *sMem = s.fData[jr];
-    for( int i=iThread; i<n; i+=kNMemThreads ) sMem[i] = gMem[i];
-  }
-}
-
-
-GPUd() void AliHLTTPCCATrackletConstructor::UnpackGrid 
-( Int_t /*nBlocks*/, Int_t nThreads, Int_t /*iBlock*/, Int_t iThread, Int_t /*iSync*/,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &/*tParam*/,Int_t iRow )
-{
-  // reconstruction of tracklets, grid unpacking step
-
-  AliHLTTPCCARow &row = tracker.Rows()[iRow];
-  int n = row.Grid().N()+1;
-  int nY = row.Grid().Ny();
-  uint4 *tmpint4 = s.fData[r.fCurrentData];
-  UShort_t *sGridP = (reinterpret_cast<UShort_t*>(tmpint4)) + row.FullGridOffset();
-  
-  UInt_t *sGrid = s.fGridContent1;      
-
-  for( int i=iThread; i<n; i+=nThreads ){
-    UInt_t s0 = sGridP[i];
-    UInt_t e0 = sGridP[i+2];
-    UInt_t s1 = sGridP[i+nY];
-    UInt_t e1 = sGridP[i+nY+2];
-    UInt_t nh0 = e0-s0;
-    UInt_t nh1 = e1-s1;
-    sGrid[i] = (nh1<<26)+(s1<<16)+( nh0<<10 ) + s0;
-  }
+    for( Int_t i=iThread; i<n; i+=NMemThreads() ) sMem[i] = gMem[i];
+  } 
 }
 
 
 GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet 
-( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t /*iThread*/, Int_t /*iSync*/,
-  AliHLTTPCCASharedMemory &/*s*/, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam )
+( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t /*iThread*/,
+  AliHLTTPCCASharedMemory &/*s*/, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam )
 {    
   // reconstruction of tracklets, tracklet store step
-
+  
   if( !r.fSave ) return;
 
   do{ 
@@ -199,8 +163,8 @@ GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
     {  
       Bool_t ok=1;
       Float_t *c = tParam.Cov();
-      for( int i=0; i<15; i++ ) ok = ok && CAMath::Finite(c[i]);
-      for( int i=0; i<5; i++ ) ok = ok && CAMath::Finite(tParam.Par()[i]);
+      for( Int_t i=0; i<15; i++ ) ok = ok && CAMath::Finite(c[i]);
+      for( Int_t i=0; i<5; i++ ) ok = ok && CAMath::Finite(tParam.Par()[i]);
       ok = ok && (tParam.X()>50);
       
       if( c[0]<=0 || c[2]<=0 || c[5]<=0 || c[9]<=0 || c[14]<=0 ) ok = 0;      
@@ -214,46 +178,46 @@ GPUd() void AliHLTTPCCATrackletConstructor::StoreTracklet
  
   if( !SAVE() ) return;
     
-  int *store = tracker.Tracklets() + r.fTrackStoreOffset;
-  int *hitstore = tracker.Tracklets() +r.fHitStoreOffset;
+  Int_t *store = ((Int_t*)tracker.Tracklets()) + r.fTrackStoreOffset;
+  Int_t *hitstore = ((Int_t*)tracker.Tracklets()) +r.fHitStoreOffset;
   store[0] = r.fNHits;
   
   if( r.fNHits>0 ){
     store[3] = r.fFirstRow;
     store[4] = r.fLastRow;   
     if( CAMath::Abs(tParam.Par()[4])<1.e-8 ) tParam.Par()[4] = 1.e-8;
-    *((AliHLTTPCCATrackParam1*)(store+5)) = tParam;
-    int w = (r.fNHits<<16)+r.fItr;
-    for( int iRow=0; iRow<160; iRow++ ){
+    *((AliHLTTPCCATrackParam*)(store+5)) = tParam;
+    Int_t w = (r.fNHits<<16)+r.fItr;
+    for( Int_t iRow=0; iRow<160; iRow++ ){
       Int_t ih = hitstore[iRow];
       if( ih>=0 ){
-       int ihTot = tracker.Rows()[iRow].FirstHit() + ih;
-       CAMath::atomicMax( tracker.HitIsUsed() + ihTot, w );
+       Int_t ihTot = tracker.Rows()[iRow].FirstHit() + ih;
+       CAMath::atomicMax( tracker.HitWeights() + ihTot, w );
       }
     }
   }  
 }
 
 GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
-( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t /*iThread*/, Int_t /*iSync*/,
-    AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam,Int_t iRow )
-{
+( Int_t /*nBlocks*/, Int_t /*nThreads*/, Int_t /*iBlock*/, Int_t /*iThread*/,
+    AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam,Int_t iRow )
+{  
   // reconstruction of tracklets, tracklets update step
 
   if( !r.fGo ) return;
          
   const Int_t kMaxRowGap = 5;  
   
-  int *hitstore = tracker.Tracklets() +r.fHitStoreOffset;
+  Int_t *hitstore = ((Int_t*) tracker.Tracklets()) +r.fHitStoreOffset;
   
   AliHLTTPCCARow &row = tracker.Rows()[iRow];
   
-  float y0 = row.Grid().YMin();
-  float stepY = row.HstepY();
-  float z0 = row.Grid().ZMin();
-  float stepZ = row.HstepZ();
-  float stepYi = row.HstepYi();
-  float stepZi = row.HstepZi();          
+  Float_t y0 = row.Grid().YMin();
+  Float_t stepY = row.HstepY();
+  Float_t z0 = row.Grid().ZMin();
+  Float_t stepZ = row.HstepZ();
+  Float_t stepYi = row.HstepYi();
+  Float_t stepZi = row.HstepZi();        
   
   if( r.fStage == 0 ){ // fitting part     
     do{
@@ -266,15 +230,15 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
       Int_t oldIH = r.fCurrIH;
       r.fCurrIH = reinterpret_cast<Short_t*>(tmpint4)[row.FullLinkOffset() + r.fCurrIH];         
       
-      float x = row.X();
-      float y = y0 + hh.x*stepY;
-      float z = z0 + hh.y*stepZ;
+      Float_t x = row.X();
+      Float_t y = y0 + hh.x*stepY;
+      Float_t z = z0 + hh.y*stepZ;
      
       if( iRow==r.fFirstRow ){
        tParam.X() = x;
        tParam.Y() = y;
        tParam.Z() = z;
-       float err2Y, err2Z;       
+       Float_t err2Y, err2Z;     
        tracker.GetErrors2( iRow, tParam, err2Y, err2Z );
        tParam.Cov()[0] = err2Y;
        tParam.Cov()[2] = err2Z;
@@ -283,9 +247,9 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
          if( SAVE() ) hitstore[iRow] = -1; 
          break; 
        }
-       float err2Y, err2Z;
+       Float_t err2Y, err2Z;
        tracker.GetErrors2( iRow, *((AliHLTTPCCATrackParam*)&tParam), err2Y, err2Z );
-       if( !tParam.Filter2( y, z, err2Y, err2Z, .95 ) ) { 
+       if( !tParam.Filter20( y, z, err2Y, err2Z, .95 ) ) { 
          if( SAVE() ) hitstore[iRow] = -1; 
          break; 
        }          
@@ -311,16 +275,15 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
        
        r.fNMissed++;   
        
-       float x = row.X();
-       float err2Y, err2Z;
+       Float_t x = row.X();
+       Float_t err2Y, err2Z;
        if( !tParam.TransportToX0( x, .95 ) ) break;
        uint4 *tmpint4 = s.fData[r.fCurrentData];   
 
        ushort2 *hits = reinterpret_cast<ushort2*>(tmpint4);
-       UInt_t *gridContent1 = ((UInt_t*)(s.fGridContent1));
-       
-       float fY = tParam.GetY();
-       float fZ = tParam.GetZ();
+               
+       Float_t fY = tParam.GetY();
+       Float_t fZ = tParam.GetZ();
        Int_t best = -1;                
        
        { // search for the closest hit
@@ -335,12 +298,16 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
          UInt_t fHitYfst=1, fHitYlst=0, fHitYfst1=1, fHitYlst1=0;
          
          fIndYmin = row.Grid().GetBin( (float)(fY-1.), (float)(fZ-1.) );
-         UInt_t c = gridContent1[fIndYmin];
-         fHitYfst = c & 0x000003FF;
-         fHitYlst = fHitYfst + ((c & 0x0000FC00)>>10);
-         fHitYfst1 = ( c & 0x03FF0000 )>>16;
-         fHitYlst1 = fHitYfst1 + ((c & 0xFC000000)>>26);         
-        
+
+         {                 
+           Int_t nY = row.Grid().Ny();
+           UShort_t *sGridP = (reinterpret_cast<UShort_t*>(tmpint4)) + row.FullGridOffset();
+           fHitYfst = sGridP[fIndYmin];
+           fHitYlst = sGridP[fIndYmin+2];
+           fHitYfst1 = sGridP[fIndYmin+nY];
+           fHitYlst1 = sGridP[fIndYmin+nY+2];
+         }
+         
          for( UInt_t fIh = fHitYfst; fIh<fHitYlst; fIh++ ){
            ushort2 hh = hits[fIh];       
            Int_t ddy = (Int_t)(hh.x) - fY0;
@@ -370,10 +337,10 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
        
        tracker.GetErrors2( iRow, *((AliHLTTPCCATrackParam*)&tParam), err2Y, err2Z );
        
-       float y = y0 + hh.x*stepY;
-       float z = z0 + hh.y*stepZ;
-       float dy = y - fY;
-       float dz = z - fZ;        
+       Float_t y = y0 + hh.x*stepY;
+       Float_t z = z0 + hh.y*stepZ;
+       Float_t dy = y - fY;
+       Float_t dz = z - fZ;      
        
        const Float_t kFactor = 3.5*3.5;
        Float_t sy2 = kFactor*( tParam.GetErr2Y() +  err2Y );
@@ -388,7 +355,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
        
        if( CAMath::fmul_rz(dy,dy)>sy2 || CAMath::fmul_rz(dz,dz)>sz2  ) break;
        
-       if( !tParam.Filter2( y, z, err2Y, err2Z, .95 ) ) break;
+       if( !tParam.Filter20( y, z, err2Y, err2Z, .95 ) ) break;
 
        if( SAVE() ) hitstore[ iRow ] = best;
        r.fNHits++;          
@@ -401,21 +368,21 @@ GPUd() void AliHLTTPCCATrackletConstructor::UpdateTracklet
 
 GPUd() void AliHLTTPCCATrackletConstructor::Thread
 ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam )
+  AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam )
 {    
 
   // reconstruction of tracklets
   if( iSync==0 )
     {  
-      Step0( nBlocks, nThreads, iBlock, iThread, iSync, s, r, tracker, tParam );
+      Step0( nBlocks, nThreads, iBlock, iThread, s, r, tracker, tParam );
     }
   else if( iSync==1 )
     { 
-      Step1( nBlocks, nThreads, iBlock, iThread, iSync, s, r, tracker, tParam );
+      Step1( nBlocks, nThreads, iBlock, iThread, s, r, tracker, tParam );
     }
   else if( iSync==2 )
     {
-      Step2( nBlocks, nThreads, iBlock, iThread, iSync, s, r, tracker, tParam );
+      Step2( nBlocks, nThreads, iBlock, iThread, s, r, tracker, tParam );
     }
   
   else if( iSync==3 )
@@ -426,8 +393,7 @@ GPUd() void AliHLTTPCCATrackletConstructor::Thread
       r.fCurrentData = 0;
       r.fNMissed = 0;           
     }
-  else if( iSync==3+159*2+1 )//322
-    
+  else if( iSync==3+159 +1 )    
     {
       r.fCurrentData = 1;
       Int_t nextRow = s.fMaxStartRow-1;
@@ -438,42 +404,33 @@ GPUd() void AliHLTTPCCATrackletConstructor::Thread
       r.fStage = 2;
     }
   
-  else if( iSync<=3+159*2+1+159*2+1 )
-    
+  else if( iSync<=3+159+1+159 )    
     {      
-      int iRow, nextRow;
-      if(  iSync<=3+159*2 ){
-       iRow = (iSync -4)/2;
-       //if( iBlock==0 && iThread==0 ) myprintf1(iSync,iRow);      
+      Int_t iRow, nextRow;
+      if(  iSync<=3+159 ){
+       iRow = iSync - 4;
        if( iRow < s.fMinStartRow ) return;
        nextRow = iRow+1;
        if( nextRow>158 ) nextRow = 158;
       }else{
-       iRow = 159 - (iSync - 4-159*2)/2;
-       //if( iBlock==0 && iThread==0 ) myprintf2(iSync,iRow);      
+       iRow = 158 - (iSync - 4-159-1);
        if( iRow >= s.fMaxStartRow ) return;
        nextRow = iRow-1;
        if( nextRow<0 ) nextRow = 0;
       }
       
-      if( iSync%2==0 ){
-       UnpackGrid( nBlocks, nThreads, iBlock, iThread, iSync,
-                   s, r, tracker, tParam, iRow );    
-      }else{   
-       if( r.fIsMemThread ){
-         ReadData( iThread, s, r, tracker, nextRow );  
-       }else{
-         UpdateTracklet( nBlocks, nThreads, iBlock, iThread, iSync,
-                         s, r, tracker, tParam, iRow );
-       }
-       r.fCurrentData = !r.fCurrentData;
-      }      
+      if( r.fIsMemThread ){
+       ReadData( iThread, s, r, tracker, nextRow );  
+      }else{
+       UpdateTracklet( nBlocks, nThreads, iBlock, iThread,
+                       s, r, tracker, tParam, iRow );
+      }
+      r.fCurrentData = !r.fCurrentData;          
     }    
   
-  else if( iSync== 4+159*4 +1+1+1 ) // 642
-    
+  else if( iSync== 4+159*2 +1+1 ) //     
     {
-      StoreTracklet( nBlocks, nThreads, iBlock, iThread, iSync, //SG!!!
+      StoreTracklet( nBlocks, nThreads, iBlock, iThread, 
                     s, r, tracker, tParam );
     }
 }
index 12e8cc5..d453181 100644 (file)
@@ -34,15 +34,14 @@ class AliHLTTPCCATrackletConstructor
 #endif
     protected:
       uint4 fData[2][(500+500+500)/4]; // temp memory
-      UInt_t fGridContent1[600]; // grid1 content
-      int fItr0; // start track index
-      int fItr1; // end track index
-      int fNRows; // n rows
+      Int_t fItr0; // start track index
+      Int_t fItr1; // end track index
+      Int_t fNRows; // n rows
       Int_t *fUsedHits;   // array of used hits
-      int fMinStartRow; // min start row
-      int fMinStartRow32[32]; // min start row for each thread in warp
-      int fMaxStartRow; // max start row
-      int fMaxStartRow32[32];// max start row for each thread in warp
+      Int_t fMinStartRow; // min start row
+      Int_t fMinStartRow32[32]; // min start row for each thread in warp
+      Int_t fMaxStartRow; // max start row
+      Int_t fMaxStartRow32[32];// max start row for each thread in warp
     };
 
   class  AliHLTTPCCAThreadMemory
@@ -75,37 +74,39 @@ class AliHLTTPCCATrackletConstructor
       Int_t fHitStoreOffset;   // offset in the global array
     };
 
-  GPUd() static Int_t NThreadSyncPoints(){ return 4+159*4 +1+1+1; }  
+  GPUd() static Int_t NThreadSyncPoints(){ return 4+159*2 +1+1; }  
 
   GPUd() static void Thread( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, 
                             Int_t iSync, AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, 
-                            AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam );
+                            AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam );
   
   GPUd() static void Step0
-    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam );
+    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread,
+      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam );
   GPUd() static void Step1
-    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam );
+    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread,
+      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam );
   GPUd() static void Step2
-    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam );
+    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread,
+      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam );
 
   GPUd() static void ReadData( Int_t iThread, AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, Int_t iRow );
 
   GPUd() static void UpdateTracklet
-    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam, Int_t iRow );
-
-  GPUd() static void UnpackGrid
-    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam, Int_t iRow );
+    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread,
+      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam, Int_t iRow );
 
   GPUd() static void StoreTracklet
-    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam1 &tParam);
-
-  static Bool_t SAVE(){ return 1; }
+    ( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread,
+      AliHLTTPCCASharedMemory &s, AliHLTTPCCAThreadMemory &r, AliHLTTPCCATracker &tracker, AliHLTTPCCATrackParam &tParam);
+
+  GPUd() static Bool_t SAVE(){ return 1; }
+#if defined(HLTCA_GPUCODE)
+  GPUhd() static Int_t NMemThreads(){ return 128; }
+#else
+  GPUhd() static Int_t NMemThreads(){ return 1; }
+#endif
 
 };
 
index 24b76a5..4fe8193 100644 (file)
@@ -32,13 +32,12 @@ GPUd() void AliHLTTPCCATrackletSelector::Thread
     {
       if( iThread==0 ){
        if(iBlock==0){
-         CAMath::atomicExch(&(tracker.NTracks()),0);
-         CAMath::atomicExch(tracker.TrackHits(),0);
+         CAMath::atomicExch(tracker.NTracks(),0);
+         CAMath::atomicExch(tracker.NTrackHits(),0);
        }
-       s.fNTracklets = tracker.Tracklets()[0];
+       s.fNTracklets = *tracker.NTracklets();
        s.fNThreadsTotal = nThreads*nBlocks;
-       s.fItr0 = nThreads*iBlock;
-       //if( iBlock==0 ) tracker.StartHits()[0] = 0;//SG!!!
+       s.fItr0 = nThreads*iBlock;      
       }
     }
   else if( iSync==1 )
@@ -47,11 +46,10 @@ GPUd() void AliHLTTPCCATrackletSelector::Thread
       Int_t trackHits[160];
        
       for( Int_t itr= s.fItr0 + iThread; itr<s.fNTracklets; itr+=s.fNThreadsTotal ){                   
-       Int_t *t = tracker.Tracklets() + 1 + itr*(5+ sizeof(AliHLTTPCCATrackParam)/4 + 160 );   
+       Int_t *t = ((Int_t*)tracker.Tracklets()) + itr*(5+ sizeof(AliHLTTPCCATrackParam)/4 + 160 );     
        Int_t tNHits = *t;
        if( tNHits<=0 ) continue;
        
-       CAMath::atomicAdd( tracker.StartHits(), 1);//SG!!!
        tout.NHits() = 0;
        Int_t *hitstore = t + 5+ sizeof(AliHLTTPCCATrackParam)/4 ;    
        Int_t w = (tNHits<<16)+itr;     
@@ -62,17 +60,17 @@ GPUd() void AliHLTTPCCATrackletSelector::Thread
          if( ih<0 ) continue;
          AliHLTTPCCARow &row = tracker.Rows()[irow];
          Int_t ihTot = row.FirstHit()+ih;      
-         if( tracker.HitIsUsed()[ihTot] > w ){
+         if( tracker.HitWeights()[ihTot] > w ){
             if( ++gap>6){ tout.NHits()=0; break; }
             continue;
-          }else gap = 0;
+          } else gap = 0;
          Int_t th = AliHLTTPCCATracker::IRowIHit2ID(irow,ih);
          trackHits[tout.NHits()] = th;
          tout.NHits()++;
        }       
        if( tout.NHits()<10 ) continue;//SG!!!
-       Int_t itrout = CAMath::atomicAdd(&(tracker.NTracks()),1);
-       tout.FirstHitID() = CAMath::atomicAdd( tracker.TrackHits(), tout.NHits() ) + 1;
+       Int_t itrout = CAMath::atomicAdd(tracker.NTracks(),1);
+       tout.FirstHitID() = CAMath::atomicAdd( tracker.NTrackHits(), tout.NHits() );
        tout.Param() = *( (AliHLTTPCCATrackParam*)( t+5) );
        tout.Alive() = 1;
        tracker.Tracks()[itrout] = tout;
index 9ced5a5..87bc190 100644 (file)
@@ -30,14 +30,14 @@ void AliHLTTPCCAUsedHitsInitialiser::Thread
     {
       if( iThread==0 ){
        s.fNHits = tracker.NHitsTotal();
-       s.fUsedHits = tracker.HitIsUsed();
+       s.fUsedHits = tracker.HitWeights();
        s.fNThreadsTotal = nThreads*nBlocks;
        s.fIh0 = nThreads*iBlock;
       }
     } 
   else if( iSync==1 )
     {
-      for( int ih=s.fIh0 + iThread; ih<s.fNHits; ih+=s.fNThreadsTotal ) s.fUsedHits[ih] = 0;         
+      for( Int_t ih=s.fIh0 + iThread; ih<s.fNHits; ih+=s.fNThreadsTotal ) s.fUsedHits[ih] = 0;       
     }
 }
 
index 4c70d10..3601822 100644 (file)
@@ -94,7 +94,7 @@ AliTPCtrackerCA::AliTPCtrackerCA(const AliTPCParam *par):
     fHLTPerformance->SetTracker( fHLTTracker );
   }
 
-  for( int iSlice=0; iSlice<fHLTTracker->NSlices(); iSlice++ ){
+  for( Int_t iSlice=0; iSlice<fHLTTracker->NSlices(); iSlice++ ){
   
     Float_t bz = AliTracker::GetBz();
 
@@ -258,12 +258,12 @@ Int_t AliTPCtrackerCA::LoadClusters (TTree * fromTree)
   fClusters = new AliTPCclusterMI [fNClusters];
   fHLTTracker->SetNHits( fNClusters );
   if( fDoHLTPerformance ) fHLTPerformance->SetNHits( fNClusters );
-  int ind=0;
+  Int_t ind=0;
   for (Int_t i=0; i<nEnt; i++) {
     br->GetEntry(i);
     Int_t sec,row;
     fParam->AdjustSectorRow(clrow->GetID(),sec,row);
-    int nClu = clrow->GetArray()->GetEntriesFast();
+    Int_t nClu = clrow->GetArray()->GetEntriesFast();
     Float_t x = fParam->GetPadRowRadii(sec,row);
     for (Int_t icl=0; icl<nClu; icl++){
       Int_t lab0 = -1;
@@ -393,7 +393,7 @@ Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
       tTPC.SetMass(0.13957);
       tTPC.SetdEdx( tCA.DeDx() );
       if( TMath::Abs(tTPC.GetSigned1Pt())>1./0.02 ) continue;
-      int nhits = tCA.NHits();
+      Int_t nhits = tCA.NHits();
       if( nhits>kMaxRow ) nhits = kMaxRow;
       tTPC.SetNumberOfClusters(nhits);      
       for( Int_t ih=0; ih<nhits; ih++ ){
@@ -426,7 +426,7 @@ Int_t AliTPCtrackerCA::Clusters2Tracks( AliESDEvent *event )
   }
   timer.Stop();
   static double time=0, time1 = 0;
-  static int ncalls = 0;
+  static Int_t ncalls = 0;
   time+=timer.CpuTime();
   time1+=timer.RealTime();
   ncalls++;