cosmetical changes
authorsgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 13 Apr 2009 20:57:12 +0000 (20:57 +0000)
committersgorbuno <sgorbuno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 13 Apr 2009 20:57:12 +0000 (20:57 +0000)
66 files changed:
HLT/TPCLib/tracking-ca/AliHLT3DTrackParam.cxx
HLT/TPCLib/tracking-ca/AliHLT3DTrackParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADataCompressor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCADisplay.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBHit.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBHit.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGBTracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGlobalMergerComponent.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAGrid.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAGrid.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAHit.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAHitArea.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAHitArea.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCPoint.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCPoint.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMCTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMath.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMergedTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMerger.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAMerger.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAMergerOutput.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursCleaner.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursCleaner.h
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCANeighboursFinder.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAOutTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAParam.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAPerformance.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAPerformance.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAProcess.h
HLT/TPCLib/tracking-ca/AliHLTTPCCARow.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCARow.h
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
HLT/TPCLib/tracking-ca/AliHLTTPCCASliceTrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAStartHitsFinder.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAStartHitsFinder.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrack.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrack.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackConvertor.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackConvertor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackLinearisation.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackParam.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracklet.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletConstructor.h
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackletSelector.h
HLT/TPCLib/tracking-ca/AliHLTTPCCAUsedHitsInitialiser.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCAUsedHitsInitialiser.h
HLT/TPCLib/tracking-ca/AliTPCtrackerCA.cxx
HLT/TPCLib/tracking-ca/AliTPCtrackerCA.h

index b7f275e..99d37cd 100644 (file)
@@ -1,6 +1,6 @@
 // @(#) $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 #include "AliHLT3DTrackParam.h"
 #include "TMath.h"
 
-ClassImp(AliHLT3DTrackParam)
+ClassImp( AliHLT3DTrackParam )
 
 //* Transport utilities
-  
-Double_t AliHLT3DTrackParam::GetDStoPoint( Double_t Bz, const Double_t xyz[3], const Double_t *T0 ) const
+
+double AliHLT3DTrackParam::GetDStoPoint( double Bz, const double xyz[3], const double *T0 ) const
 {
   //* Get DS = Path/Momentum to a certain space point for Bz field
 
-  Double_t q = fSignQ;
-  if( !T0 ) T0 = fParam; 
+  double q = fSignQ;
+  if ( !T0 ) T0 = fParam;
   else q = T0[6];
 
-  const Double_t kCLight = 0.000299792458;
-  Double_t bq = Bz*q*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;
+  const double kCLight = 0.000299792458;
+  double bq = Bz * q * kCLight;
+  double pt2 = T0[3] * T0[3] + T0[4] * T0[4];
+  if ( pt2 < 1.e-4 ) return 0;
+  double dx = xyz[0] - T0[0];
+  double dy = xyz[1] - T0[1];
+  double a = dx * T0[3] + dy * T0[4];
+  double 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;
 }
 
 
-void AliHLT3DTrackParam::TransportToDS( Double_t Bz, Double_t DS, Double_t *T0 )
+void AliHLT3DTrackParam::TransportToDS( double Bz, double DS, double *T0 )
 {
-  //* Transport the particle on DS = Path/Momentum, for Bz field 
+  //* Transport the particle on DS = Path/Momentum, for Bz field
 
-  Double_t tmp[7];
-  if( !T0 ){
+  double tmp[7];
+  if ( !T0 ) {
     T0 = tmp;
     T0[0] = fParam[0];
     T0[1] = fParam[1];
@@ -60,71 +60,73 @@ void AliHLT3DTrackParam::TransportToDS( Double_t Bz, Double_t DS, Double_t *T0 )
     T0[5] = fParam[5];
     T0[6] = fSignQ;
   }
-  const Double_t kCLight = 0.000299792458;
-  Bz = Bz*T0[6]*kCLight;
-  Double_t bs= Bz*DS;
-  Double_t s = TMath::Sin(bs), c = TMath::Cos(bs);
-  Double_t sB, cB;
-  if( TMath::Abs(bs)>1.e-10){
-    sB= s/Bz;
-    cB= (1-c)/Bz;
-  }else{
-    sB = (1. - bs*bs/6.)*DS;
-    cB = .5*sB*bs;
+  const double kCLight = 0.000299792458;
+  Bz = Bz * T0[6] * kCLight;
+  double bs = Bz * DS;
+  double s = TMath::Sin( bs ), c = TMath::Cos( bs );
+  double sB, cB;
+  if ( TMath::Abs( bs ) > 1.e-10 ) {
+    sB = s / Bz;
+    cB = ( 1 - c ) / Bz;
+  } else {
+    sB = ( 1. - bs * bs / 6. ) * DS;
+    cB = .5 * sB * bs;
   }
-    
-  Double_t px = T0[3];
-  Double_t py = T0[4];
-  Double_t pz = T0[5];
-  
-  Double_t d[6] = { fParam[0]-T0[0], fParam[1]-T0[1], fParam[2]-T0[2], 
-                   fParam[3]-T0[3], fParam[4]-T0[4], fParam[5]-T0[5]  };
-
-  T0[0] = T0[0] + sB*px + cB*py;
-  T0[1] = T0[1] - cB*px + sB*py;
-  T0[2] = T0[2] + DS*pz                       ;
-  T0[3] =          c*px + s*py;
-  T0[4] =         -s*px + c*py;
+
+  double px = T0[3];
+  double py = T0[4];
+  double pz = T0[5];
+
+  double d[6] = { fParam[0] - T0[0], fParam[1] - T0[1], fParam[2] - T0[2],
+                    fParam[3] - T0[3], fParam[4] - T0[4], fParam[5] - T0[5]
+                  };
+
+  T0[0] = T0[0] + sB * px + cB * py;
+  T0[1] = T0[1] - cB * px + sB * py;
+  T0[2] = T0[2] + DS * pz                       ;
+  T0[3] =          c * px + s * py;
+  T0[4] =         -s * px + c * py;
   T0[5] = T0[5];
-  Double_t mJ[6][6] = { {1,0,0,   sB, cB,  0, },
-                        {0,1,0,  -cB, sB,  0, },
-                        {0,0,1,    0,  0, DS, },
-                        {0,0,0,    c,  s,  0, },
-                        {0,0,0,   -s,  c,  0, },
-                        {0,0,0,    0,  0,  1, }   };
-
-  for( Int_t i=0; i<6; i++){
+
+  double mJ[6][6] = { {1, 0, 0,   sB, cB,  0, },
+    {0, 1, 0,  -cB, sB,  0, },
+    {0, 0, 1,    0,  0, DS, },
+    {0, 0, 0,    c,  s,  0, },
+    {0, 0, 0,   -s,  c,  0, },
+    {0, 0, 0,    0,  0,  1, }
+  };
+
+  for ( int i = 0; i < 6; i++ ) {
     fParam[i] = T0[i];
-    for( Int_t j=0; j<6; j++) fParam[i] += mJ[i][j]*d[j];
+    for ( int j = 0; j < 6; j++ ) fParam[i] += mJ[i][j] * d[j];
   }
 
-  Double_t mA[6][6];
-  for( Int_t k=0,i=0; i<6; i++)
-    for( Int_t j=0; j<=i; j++, k++ ) mA[i][j] = mA[j][i] = fCov[k]; 
+  double mA[6][6];
+  for ( int k = 0, i = 0; i < 6; i++ )
+    for ( int j = 0; j <= i; j++, k++ ) mA[i][j] = mA[j][i] = fCov[k];
 
-  Double_t mJC[6][6];
-  for( Int_t i=0; i<6; i++ )
-    for( Int_t j=0; j<6; j++ ){
-      mJC[i][j]=0;
-      for( Int_t k=0; k<6; k++ ) mJC[i][j]+=mJ[i][k]*mA[k][j];
+  double mJC[6][6];
+  for ( int i = 0; i < 6; i++ )
+    for ( int j = 0; j < 6; j++ ) {
+      mJC[i][j] = 0;
+      for ( int k = 0; k < 6; k++ ) mJC[i][j] += mJ[i][k] * mA[k][j];
     }
-  
-  for( Int_t k=0,i=0; i<6; i++)
-    for( Int_t j=0; j<=i; j++, k++ ){
+
+  for ( int k = 0, i = 0; i < 6; i++ )
+    for ( int j = 0; j <= i; j++, k++ ) {
       fCov[k] = 0;
-      for( Int_t l=0; l<6; l++ ) fCov[k]+=mJC[i][l]*mJ[j][l];
+      for ( int l = 0; l < 6; l++ ) fCov[k] += mJC[i][l] * mJ[j][l];
     }
 }
 
 
-//* Fit utilities 
+//* Fit utilities
 
 void AliHLT3DTrackParam::InitializeCovarianceMatrix()
 {
   //* Initialization of covariance matrix
 
-  for( Int_t i=0; i<21; i++ ) fCov[i] = 0;
+  for ( int i = 0; i < 21; i++ ) fCov[i] = 0;
   fSignQ = 0;
   fCov[0] = fCov[ 2] = fCov[ 5] = 100.;
   fCov[9] = fCov[14] = fCov[20] = 10000.;
@@ -132,249 +134,252 @@ void AliHLT3DTrackParam::InitializeCovarianceMatrix()
   fNDF = -5;
 }
 
-void AliHLT3DTrackParam::GetGlueMatrix( const Double_t xyz[3], 
-                                       Double_t G[6], const Double_t *T0  ) const 
+void AliHLT3DTrackParam::GetGlueMatrix( const double xyz[3],
+                                        double G[6], const double *T0  ) const
 {
   //* !
 
-  if( !T0 ) T0 = fParam;
-
-  Double_t dx = xyz[0]-T0[0], dy = xyz[1]-T0[1], dz = xyz[2]-T0[2];
-  Double_t px2= T0[3]*T0[3], py2= T0[4]*T0[4], pz2= T0[5]*T0[5];
-  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;
-  G[ 0]= xx;
-  G[ 1]= xy;   G[ 2]= yy;
-  G[ 3]= xz;   G[ 4]= yz;   G[ 5]= pz2*s2;  
+  if ( !T0 ) T0 = fParam;
+
+  double dx = xyz[0] - T0[0], dy = xyz[1] - T0[1], dz = xyz[2] - T0[2];
+  double px2 = T0[3] * T0[3], py2 = T0[4] * T0[4], pz2 = T0[5] * T0[5];
+  double s2 = ( dx * dx + dy * dy + dz * dz );
+  double p2 = px2 + py2 + pz2;
+  if ( p2 > 1.e-4 ) s2 /= p2;
+  double x = T0[3] * s2;
+  double xx = px2 * s2, xy = x * T0[4], xz = x * T0[5], yy = py2 * s2, yz = T0[4] * T0[5] * s2;
+  G[ 0] = xx;
+  G[ 1] = xy;   G[ 2] = yy;
+  G[ 3] = xz;   G[ 4] = yz;   G[ 5] = pz2 * s2;
 }
 
 
 
-void AliHLT3DTrackParam::Filter( const Double_t m[3], const Double_t V[6], const Double_t G[6] )
-{ 
+void AliHLT3DTrackParam::Filter( const double m[3], const double V[6], const double G[6] )
+{
   //* !
-  
-  Double_t 
-    c00 = fCov[ 0],
-    c10 = fCov[ 1], c11 = fCov[ 2],
-    c20 = fCov[ 3], c21 = fCov[ 4], c22 = fCov[ 5],
-    c30 = fCov[ 6], c31 = fCov[ 7], c32 = fCov[ 8],
-    c40 = fCov[10], c41 = fCov[11], c42 = fCov[12],
-    c50 = fCov[15], c51 = fCov[16], c52 = fCov[17];
-  
+
   double
-    z0 = m[0]-fParam[0],
-    z1 = m[1]-fParam[1],
-    z2 = m[2]-fParam[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 = 1./(mS[0]*mSi[0] + mS[1]*mSi[1] + mS[3]*mSi[3]);
+  c00 = fCov[ 0],
+        c10 = fCov[ 1], c11 = fCov[ 2],
+                              c20 = fCov[ 3], c21 = fCov[ 4], c22 = fCov[ 5],
+                                                                    c30 = fCov[ 6], c31 = fCov[ 7], c32 = fCov[ 8],
+                                                                                                          c40 = fCov[10], c41 = fCov[11], c42 = fCov[12],
+                                                                                                                                                c50 = fCov[15], c51 = fCov[16], c52 = fCov[17];
+
+  double
+  z0 = m[0] - fParam[0],
+       z1 = m[1] - fParam[1],
+            z2 = m[2] - fParam[2];
+
+  double 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 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 det = 1. / ( mS[0] * mSi[0] + mS[1] * mSi[1] + mS[3] * mSi[3] );
   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;
-  
+  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];
-    
-  fParam[ 0]+= k0*z0  + k1*z1  + k2*z2 ;
-  fCov  [ 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];
-  
-  fParam[ 1]+= k0*z0  + k1*z1  + k2*z2 ;
-  fCov  [ 1]-= k0*c00 + k1*c10 + k2*c20;
-  fCov  [ 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];
-  
-  fParam[ 2]+= k0*z0  + k1*z1  + k2*z2 ;
-  fCov  [ 3]-= k0*c00 + k1*c10 + k2*c20;
-  fCov  [ 4]-= k0*c10 + k1*c11 + k2*c21;
-  fCov  [ 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];
-  
-  fParam[ 3]+= k0*z0  + k1*z1  + k2*z2 ;
-  fCov  [ 6]-= k0*c00 + k1*c10 + k2*c20;
-  fCov  [ 7]-= k0*c10 + k1*c11 + k2*c21;
-  fCov  [ 8]-= k0*c20 + k1*c21 + k2*c22;
-  fCov  [ 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];
-    
-  fParam[ 4]+= k0*z0  + k1*z1  + k2*z2 ;
-  fCov  [10]-= k0*c00 + k1*c10 + k2*c20;
-  fCov  [11]-= k0*c10 + k1*c11 + k2*c21;
-  fCov  [12]-= k0*c20 + k1*c21 + k2*c22;
-  fCov  [13]-= k0*c30 + k1*c31 + k2*c32;
-  fCov  [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];
-  
-  fParam[ 5]+= k0*z0  + k1*z1  + k2*z2 ;
-  fCov  [15]-= k0*c00 + k1*c10 + k2*c20;
-  fCov  [16]-= k0*c10 + k1*c11 + k2*c21;
-  fCov  [17]-= k0*c20 + k1*c21 + k2*c22;
-  fCov  [18]-= k0*c30 + k1*c31 + k2*c32;
-  fCov  [19]-= k0*c40 + k1*c41 + k2*c42;
-  fCov  [20]-= k0*c50 + k1*c51 + k2*c52;
+  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 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];
+
+  fParam[ 0] += k0 * z0  + k1 * z1  + k2 * z2 ;
+  fCov  [ 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];
+
+  fParam[ 1] += k0 * z0  + k1 * z1  + k2 * z2 ;
+  fCov  [ 1] -= k0 * c00 + k1 * c10 + k2 * c20;
+  fCov  [ 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];
+
+  fParam[ 2] += k0 * z0  + k1 * z1  + k2 * z2 ;
+  fCov  [ 3] -= k0 * c00 + k1 * c10 + k2 * c20;
+  fCov  [ 4] -= k0 * c10 + k1 * c11 + k2 * c21;
+  fCov  [ 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];
+
+  fParam[ 3] += k0 * z0  + k1 * z1  + k2 * z2 ;
+  fCov  [ 6] -= k0 * c00 + k1 * c10 + k2 * c20;
+  fCov  [ 7] -= k0 * c10 + k1 * c11 + k2 * c21;
+  fCov  [ 8] -= k0 * c20 + k1 * c21 + k2 * c22;
+  fCov  [ 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];
+
+  fParam[ 4] += k0 * z0  + k1 * z1  + k2 * z2 ;
+  fCov  [10] -= k0 * c00 + k1 * c10 + k2 * c20;
+  fCov  [11] -= k0 * c10 + k1 * c11 + k2 * c21;
+  fCov  [12] -= k0 * c20 + k1 * c21 + k2 * c22;
+  fCov  [13] -= k0 * c30 + k1 * c31 + k2 * c32;
+  fCov  [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];
+
+  fParam[ 5] += k0 * z0  + k1 * z1  + k2 * z2 ;
+  fCov  [15] -= k0 * c00 + k1 * c10 + k2 * c20;
+  fCov  [16] -= k0 * c10 + k1 * c11 + k2 * c21;
+  fCov  [17] -= k0 * c20 + k1 * c21 + k2 * c22;
+  fCov  [18] -= k0 * c30 + k1 * c31 + k2 * c32;
+  fCov  [19] -= k0 * c40 + k1 * c41 + k2 * c42;
+  fCov  [20] -= k0 * c50 + k1 * c51 + k2 * c52;
 
   // fit charge
 
-  Double_t px = fParam[3];
-  Double_t py = fParam[4];
-  Double_t pz = fParam[5];
-  
-  Double_t p = TMath::Sqrt( px*px + py*py + pz*pz );
-  Double_t pi = 1./p;
-  Double_t qp = fSignQ*pi;
-  Double_t qp3 = qp*pi*pi;
-  Double_t 
-    c60 = qp3*(c30+c40+c50),
-    c61 = qp3*(c31+c41+c51),
-    c62 = qp3*(c32+c42+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];
-  
-  qp+= k0*z0  + k1*z1  + k2*z2 ;
-  if( qp>0 ) fSignQ = 1;
-  else if(qp<0 ) fSignQ = -1;
+  double px = fParam[3];
+  double py = fParam[4];
+  double pz = fParam[5];
+
+  double p = TMath::Sqrt( px * px + py * py + pz * pz );
+  double pi = 1. / p;
+  double qp = fSignQ * pi;
+  double qp3 = qp * pi * pi;
+  double
+  c60 = qp3 * ( c30 + c40 + c50 ),
+        c61 = qp3 * ( c31 + c41 + c51 ),
+              c62 = qp3 * ( c32 + c42 + 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];
+
+  qp += k0 * z0  + k1 * z1  + k2 * z2 ;
+  if ( qp > 0 ) fSignQ = 1;
+  else if ( qp < 0 ) fSignQ = -1;
   else fSignQ = 0;
 }
 
 
 //* Other utilities
 
-void AliHLT3DTrackParam::SetDirection( Double_t Direction[3] )
+void AliHLT3DTrackParam::SetDirection( double Direction[3] )
 {
-  //* Change track direction 
+  //* Change track direction
 
-  if( fParam[3]*Direction[0] + fParam[4]*Direction[1] + fParam[5]*Direction[2] >= 0 ) return;
+  if ( fParam[3]*Direction[0] + fParam[4]*Direction[1] + fParam[5]*Direction[2] >= 0 ) return;
 
   fParam[3] = -fParam[3];
   fParam[4] = -fParam[4];
   fParam[5] = -fParam[5];
   fSignQ    = -fSignQ;
 
-  fCov[ 6]=-fCov[ 6]; fCov[ 7]=-fCov[ 7]; fCov[ 8]=-fCov[ 8];
-  fCov[10]=-fCov[10]; fCov[11]=-fCov[11]; fCov[12]=-fCov[12];
-  fCov[15]=-fCov[15]; fCov[16]=-fCov[16]; fCov[17]=-fCov[17];
+  fCov[ 6] = -fCov[ 6]; fCov[ 7] = -fCov[ 7]; fCov[ 8] = -fCov[ 8];
+  fCov[10] = -fCov[10]; fCov[11] = -fCov[11]; fCov[12] = -fCov[12];
+  fCov[15] = -fCov[15]; fCov[16] = -fCov[16]; fCov[17] = -fCov[17];
 }
 
 
-void AliHLT3DTrackParam::RotateCoordinateSystem( Double_t alpha )
+void AliHLT3DTrackParam::RotateCoordinateSystem( double alpha )
 {
   //* !
 
-  Double_t cA = TMath::Cos( alpha );
-  Double_t sA = TMath::Sin( alpha );
-  Double_t x= fParam[0], y= fParam[1], px= fParam[3], py= fParam[4];
-  fParam[0] = x*cA + y*sA;
-  fParam[1] =-x*sA + y*cA;
+  double cA = TMath::Cos( alpha );
+  double sA = TMath::Sin( alpha );
+  double x = fParam[0], y = fParam[1], px = fParam[3], py = fParam[4];
+  fParam[0] = x * cA + y * sA;
+  fParam[1] = -x * sA + y * cA;
   fParam[2] = fParam[2];
-  fParam[3] = px*cA + py*sA;
-  fParam[4] =-px*sA + py*cA;
-  fParam[5] = fParam[5];  
-
-  Double_t mJ[6][6] = { { cA,sA, 0,  0,  0,  0 },
-                        {-sA,cA, 0,  0,  0,  0 },
-                        {  0, 0, 1,  0,  0,  0 },
-                        {  0, 0, 0, cA, sA,  0 },
-                        {  0, 0, 0,-sA, cA,  0 },
-                        {  0, 0, 0,  0,  0,  1 }  };
-                  
-  Double_t mA[6][6];
-  for( Int_t k=0,i=0; i<6; i++)
-    for( Int_t j=0; j<=i; j++, k++ ) mA[i][j] = mA[j][i] = fCov[k]; 
-
-  Double_t mJC[6][6];
-  for( Int_t i=0; i<6; i++ )
-    for( Int_t j=0; j<6; j++ ){
-      mJC[i][j]=0;
-      for( Int_t k=0; k<6; k++ ) mJC[i][j]+=mJ[i][k]*mA[k][j];
+  fParam[3] = px * cA + py * sA;
+  fParam[4] = -px * sA + py * cA;
+  fParam[5] = fParam[5];
+
+  double mJ[6][6] = { { cA, sA, 0,  0,  0,  0 },
+    { -sA, cA, 0,  0,  0,  0 },
+    {  0, 0, 1,  0,  0,  0 },
+    {  0, 0, 0, cA, sA,  0 },
+    {  0, 0, 0, -sA, cA,  0 },
+    {  0, 0, 0,  0,  0,  1 }
+  };
+
+  double mA[6][6];
+  for ( int k = 0, i = 0; i < 6; i++ )
+    for ( int j = 0; j <= i; j++, k++ ) mA[i][j] = mA[j][i] = fCov[k];
+
+  double mJC[6][6];
+  for ( int i = 0; i < 6; i++ )
+    for ( int j = 0; j < 6; j++ ) {
+      mJC[i][j] = 0;
+      for ( int k = 0; k < 6; k++ ) mJC[i][j] += mJ[i][k] * mA[k][j];
     }
-  
-  for( Int_t k=0,i=0; i<6; i++)
-    for( Int_t j=0; j<=i; j++, k++ ){
+
+  for ( int k = 0, i = 0; i < 6; i++ )
+    for ( int j = 0; j <= i; j++, k++ ) {
       fCov[k] = 0;
-      for( Int_t l=0; l<6; l++ ) fCov[k]+=mJC[i][l]*mJ[j][l];
+      for ( int l = 0; l < 6; l++ ) fCov[k] += mJC[i][l] * mJ[j][l];
     }
 }
 
 
-void AliHLT3DTrackParam::Get5Parameters( Double_t alpha, Double_t T[6], Double_t C[15] ) const
+void AliHLT3DTrackParam::Get5Parameters( double alpha, double T[6], double C[15] ) const
 {
   //* !
 
   AliHLT3DTrackParam t = *this;
-  t.RotateCoordinateSystem(alpha);
-  Double_t 
-    x= t.fParam[0], y= t.fParam[1], z = t.fParam[2], 
-    px= t.fParam[3], py= t.fParam[4], pz = t.fParam[5], q = t.fSignQ;
+  t.RotateCoordinateSystem( alpha );
+  double
+  x = t.fParam[0], y = t.fParam[1], z = t.fParam[2],
+                                        px = t.fParam[3], py = t.fParam[4], pz = t.fParam[5], q = t.fSignQ;
 
-  Double_t p2 = px*px+py*py+pz*pz;
-  if( p2<1.e-8 ) p2 = 1;
-  Double_t n2 = 1./p2;
-  Double_t n = sqrt(n2);
+  double p2 = px * px + py * py + pz * pz;
+  if ( p2 < 1.e-8 ) p2 = 1;
+  double n2 = 1. / p2;
+  double n = sqrt( n2 );
 
   T[5] = x;
   T[0] = y;
   T[1] = z;
-  T[2] = py/px;
-  T[3] = pz/px;
-  T[4] = q*n;
-
-  Double_t mJ[5][6] = { { -T[2], 1, 0,  0,  0,  0 },
-                        { -T[3], 0, 1,  0,  0,  0 },
-                        { 0, 0, 0,  -T[2]/px,  1./px,  0 },
-                        { 0, 0, 0, -T[3]/px,  0,  1./px },
-                        { 0, 0, 0, -T[4]*n2*px, -T[4]*n2*py, -T[4]*n2*pz} };
-
-  Double_t mA[6][6];
-  for( Int_t k=0,i=0; i<6; i++)
-    for( Int_t j=0; j<=i; j++, k++ ) mA[i][j] = mA[j][i] = t.fCov[k]; 
-
-  Double_t mJC[5][6];
-  for( Int_t i=0; i<5; i++ )
-    for( Int_t j=0; j<6; j++ ){
-      mJC[i][j]=0;
-      for( Int_t k=0; k<6; k++ ) mJC[i][j]+=mJ[i][k]*mA[k][j];
+  T[2] = py / px;
+  T[3] = pz / px;
+  T[4] = q * n;
+
+  double mJ[5][6] = { { -T[2], 1, 0,  0,  0,  0 },
+    { -T[3], 0, 1,  0,  0,  0 },
+    { 0, 0, 0,  -T[2] / px,  1. / px,  0 },
+    { 0, 0, 0, -T[3] / px,  0,  1. / px },
+    { 0, 0, 0, -T[4]*n2*px, -T[4]*n2*py, -T[4]*n2*pz}
+  };
+
+  double mA[6][6];
+  for ( int k = 0, i = 0; i < 6; i++ )
+    for ( int j = 0; j <= i; j++, k++ ) mA[i][j] = mA[j][i] = t.fCov[k];
+
+  double mJC[5][6];
+  for ( int i = 0; i < 5; i++ )
+    for ( int j = 0; j < 6; j++ ) {
+      mJC[i][j] = 0;
+      for ( int k = 0; k < 6; 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++ ){
+
+  for ( int k = 0, i = 0; i < 5; i++ )
+    for ( int j = 0; j <= i; j++, k++ ) {
       C[k] = 0;
-      for( Int_t l=0; l<6; l++ ) C[k]+=mJC[i][l]*mJ[j][l];
+      for ( int l = 0; l < 6; l++ ) C[k] += mJC[i][l] * mJ[j][l];
     }
 }
index b23a66a..a800dc0 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
 // ***************************************************************************
-// This file is property of and copyright by the ALICE HLT Project           * 
+// 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                                  *
 //                                                                           *
 /**
  * @class AliHLT3DTrackParam
  */
-class AliHLT3DTrackParam :public TObject
+class AliHLT3DTrackParam : public TObject
 {
- public:
-
-  //*
-  //*  INITIALIZATION
-  //*
-
-  //* Constructor 
-
-  AliHLT3DTrackParam(): fChi2(0),fNDF(0),fSignQ(0){} 
-
-  //* Destructor (empty)
-
-  virtual ~AliHLT3DTrackParam(){}
-
-  //*
-  //*  ACCESSORS
-  //*
-
-
-  //* Simple accessors 
-
-  Double_t GetX()      const { return fParam[0]; }
-  Double_t GetY()      const { return fParam[1]; }
-  Double_t GetZ()      const { return fParam[2]; }
-  Double_t GetPx()     const { return fParam[3]; }
-  Double_t GetPy()     const { return fParam[4]; }
-  Double_t GetPz()     const { return fParam[5]; }
-  Double_t GetChi2()   const { return fChi2;  }
-  Int_t    GetNDF()    const { return fNDF;   }
-  Int_t    GetCharge() const { return fSignQ; }
-  
-  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
-  //*
-  
-  const Double_t *Param()  const { return fParam; }
-  const Double_t *Cov() const   { return fCov;   }
-  Double_t X()      const  { return fParam[0]; }
-  Double_t Y()      const  { return fParam[1]; }
-  Double_t Z()      const  { return fParam[2]; }
-  Double_t Px()     const  { return fParam[3]; }
-  Double_t Py()     const  { return fParam[4]; }
-  Double_t Pz()     const  { return fParam[5]; }
-  Double_t Chi2()   const  { return fChi2;  }
-  Int_t    NDF()    const  { return fNDF;   }
-  Int_t    Charge()  const { return fSignQ; }
-
-  //* Accessors with calculations( &value, &estimated sigma )
-  //* error flag returned (0 means no error during calculations) 
-
-
-  //*
-  //*  MODIFIERS
-  //*
-  
-  void SetParam( Int_t i, Double_t v )  { fParam[i] = v; }
-  void SetCov( Int_t i, Double_t v ){ fCov[i] = v;   }
-  void SetX( Double_t v )      { fParam[0] = v; }
-  void SetY( Double_t v )      { fParam[1] = v; }
-  void SetZ( Double_t v )      { fParam[2] = v; }
-  void SetPx( Double_t v )     { fParam[3] = v; }
-  void SetPy( Double_t v )     { fParam[4] = v; }
-  void SetPz( Double_t v )     { fParam[5] = v; }
-  void SetChi2( Double_t v )   { fChi2 = v;  }
-  void SetNDF( Int_t v )       { fNDF = v;   }
-  void SetCharge( Int_t v )    { fSignQ = v; }
-  
-
-  //*
-  //*  UTILITIES
-  //*
-  
-  //* Transport utilities
-  
-  Double_t GetDStoPoint( Double_t Bz, const Double_t xyz[3], const Double_t *T0=0 ) const;
-
-  void TransportToDS( Double_t Bz, Double_t DS, Double_t *T0=0 );
-
-  void TransportToPoint( Double_t Bz, const Double_t xyz[3], Double_t *T0=0 )
-    { 
-      TransportToDS( Bz,GetDStoPoint(Bz, xyz, T0), T0 ) ; 
+  public:
+
+    //*
+    //*  INITIALIZATION
+    //*
+
+    //* Constructor
+
+    AliHLT3DTrackParam(): fChi2( 0 ), fNDF( 0 ), fSignQ( 0 ) {}
+
+    //* Destructor (empty)
+
+    virtual ~AliHLT3DTrackParam() {}
+
+    //*
+    //*  ACCESSORS
+    //*
+
+
+    //* Simple accessors
+
+    double GetX()      const { return fParam[0]; }
+    double GetY()      const { return fParam[1]; }
+    double GetZ()      const { return fParam[2]; }
+    double GetPx()     const { return fParam[3]; }
+    double GetPy()     const { return fParam[4]; }
+    double GetPz()     const { return fParam[5]; }
+    double GetChi2()   const { return fChi2;  }
+    int    GetNDF()    const { return fNDF;   }
+    int    GetCharge() const { return fSignQ; }
+
+    double GetParameter ( int i ) const { return fParam[i]; }
+    double GetCovariance( int i ) const { return fCov[i]; }
+    double GetCovariance( int i, int j ) const { return fCov[( j<=i ) ? i*( i+1 )/2+j :j*( j+1 )/2+i]; }
+
+    //*
+    //* Accessors
+    //*
+
+    const double *Param()  const { return fParam; }
+    const double *Cov() const   { return fCov;   }
+    double X()      const  { return fParam[0]; }
+    double Y()      const  { return fParam[1]; }
+    double Z()      const  { return fParam[2]; }
+    double Px()     const  { return fParam[3]; }
+    double Py()     const  { return fParam[4]; }
+    double Pz()     const  { return fParam[5]; }
+    double Chi2()   const  { return fChi2;  }
+    int    NDF()    const  { return fNDF;   }
+    int    Charge()  const { return fSignQ; }
+
+    //* Accessors with calculations( &value, &estimated sigma )
+    //* error flag returned (0 means no error during calculations)
+
+
+    //*
+    //*  MODIFIERS
+    //*
+
+    void SetParam( int i, double v )  { fParam[i] = v; }
+    void SetCov( int i, double v ) { fCov[i] = v;   }
+    void SetX( double v )      { fParam[0] = v; }
+    void SetY( double v )      { fParam[1] = v; }
+    void SetZ( double v )      { fParam[2] = v; }
+    void SetPx( double v )     { fParam[3] = v; }
+    void SetPy( double v )     { fParam[4] = v; }
+    void SetPz( double v )     { fParam[5] = v; }
+    void SetChi2( double v )   { fChi2 = v;  }
+    void SetNDF( int v )       { fNDF = v;   }
+    void SetCharge( int v )    { fSignQ = v; }
+
+
+    //*
+    //*  UTILITIES
+    //*
+
+    //* Transport utilities
+
+    double GetDStoPoint( double Bz, const double xyz[3], const double *T0 = 0 ) const;
+
+    void TransportToDS( double Bz, double DS, double *T0 = 0 );
+
+    void TransportToPoint( double Bz, const double xyz[3], double *T0 = 0 ) {
+      TransportToDS( Bz, GetDStoPoint( Bz, xyz, T0 ), T0 ) ;
     }
 
-  void TransportToPoint( Double_t Bz, Double_t x, Double_t y, Double_t z, const Double_t *T0=0 )
-    { 
-      Double_t xyz[3] = {x,y,z};
+    void TransportToPoint( double Bz, double x, double y, double z, const double *T0 = 0 ) {
+      double xyz[3] = {x, y, z};
       TransportToPoint( Bz, xyz, T0 );
     }
 
-  //* Fit utilities 
+    //* Fit utilities
 
-  void InitializeCovarianceMatrix();
+    void InitializeCovarianceMatrix();
 
-  void GetGlueMatrix( const Double_t p[3], Double_t G[6], const Double_t *T0=0  ) const ;
+    void GetGlueMatrix( const double p[3], double G[6], const double *T0 = 0  ) const ;
 
-  void Filter( const Double_t m[3], const Double_t V[6], const Double_t G[6] );
+    void Filter( const double m[3], const double V[6], const double G[6] );
 
-  //* Other utilities
+    //* Other utilities
 
-  void SetDirection( Double_t Direction[3] );
+    void SetDirection( double Direction[3] );
 
-  void RotateCoordinateSystem( Double_t alpha );
+    void RotateCoordinateSystem( double alpha );
 
-  void Get5Parameters( Double_t alpha, Double_t T[6], Double_t C[15] ) const;
+    void Get5Parameters( double alpha, double T[6], double C[15] ) const;
 
- protected:
+  protected:
 
-  Double_t fParam[6]; // Parameters ( x, y, z, px, py, pz ): 3-position and 3-momentum
-  Double_t fCov[21];  // Covariance matrix
-  Double_t fChi2;     // Chi^2
-  Int_t    fNDF;      // Number of Degrees of Freedom
-  Int_t    fSignQ;    // Charge
+    double fParam[6]; // Parameters ( x, y, z, px, py, pz ): 3-position and 3-momentum
+    double fCov[21];  // Covariance matrix
+    double fChi2;     // Chi^2
+    int    fNDF;      // Number of Degrees of Freedom
+    int    fSignQ;    // Charge
 
-  ClassDef(AliHLT3DTrackParam, 1);
+    ClassDef( AliHLT3DTrackParam, 1 );
 
 };
 
index 05bc9bd..ed892d9 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCADataCompressor
 {
-public:
-  
-  GPUhd() static UInt_t IRowIClu2IDrc( UInt_t iRow, UInt_t iCluster ){ 
-    return (iCluster<<8)+iRow; 
-  }
+  public:
 
-  GPUhd() static UInt_t IDrc2IRow( UInt_t IDrc ){ return ( IDrc%256 ); }  
-  GPUhd() static UInt_t IDrc2IClu( UInt_t IDrc ){ return ( IDrc>>8  ); }  
+    GPUhd() static unsigned int IRowIClu2IDrc( unsigned int iRow, unsigned int iCluster ) {
+      return ( iCluster << 8 ) + iRow;
+    }
 
+    GPUhd() static unsigned int IDrc2IRow( unsigned int IDrc ) { return ( IDrc % 256 ); }
+    GPUhd() static unsigned int IDrc2IClu( unsigned int IDrc ) { return ( IDrc >> 8  ); }
 
-  GPUhd() static UInt_t ISliceIRowIClu2IDsrc( UInt_t iSlice, UInt_t iRow, UInt_t iCluster ){ 
-    return (iCluster<<14) + (iRow<<6) + iSlice; 
-  }
 
-  GPUhd() static UInt_t IDsrc2ISlice( UInt_t IDsrc ){  return (  IDsrc%64      ); }
-  GPUhd() static UInt_t IDsrc2IRow  ( UInt_t IDsrc ){  return ( (IDsrc>>6)%256 ); }  
-  GPUhd() static UInt_t IDsrc2IClu  ( UInt_t IDsrc ){  return (  IDsrc>>14     ); }  
+    GPUhd() static unsigned int ISliceIRowIClu2IDsrc( unsigned int iSlice, unsigned int iRow, unsigned int iCluster ) {
+      return ( iCluster << 14 ) + ( iRow << 6 ) + iSlice;
+    }
 
+    GPUhd() static unsigned int IDsrc2ISlice( unsigned int IDsrc ) {  return (  IDsrc % 64      ); }
+    GPUhd() static unsigned int IDsrc2IRow  ( unsigned int IDsrc ) {  return ( ( IDsrc >> 6 ) % 256 ); }
+    GPUhd() static unsigned int IDsrc2IClu  ( unsigned int IDsrc ) {  return (  IDsrc >> 14     ); }
+
+
+    GPUhd() static unsigned short YZ2UShort( float Y, float Z );
+    GPUhd() static float  UShort2Y ( unsigned short iYZ );
+    GPUhd() static float  UShort2Z ( unsigned short iYZ );
 
-  GPUhd() static UShort_t YZ2UShort( Float_t Y, Float_t Z );
-  GPUhd() static Float_t  UShort2Y ( UShort_t iYZ );
-  GPUhd() static Float_t  UShort2Z ( UShort_t iYZ );
-  
 };
 
 
 // Inline methods
 
 
-GPUhd() inline UShort_t AliHLTTPCCADataCompressor::YZ2UShort( Float_t Y, Float_t Z )
-{ 
+GPUhd() inline unsigned short AliHLTTPCCADataCompressor::YZ2UShort( float Y, float Z )
+{
   // compress Y and Z coordinates in range [-3., 3.] to 16 bits
 
-  const Float_t kMult = 255./6.;
-  Y = (Y+3.)*kMult;
-  Z = (Z+3.)*kMult;
-  if( Y<0. ) Y = 0.;
-  else if( Y>255. ) Y = 255.;
-  if( Z<0. ) Z = 0.;
-  else if( Z>255. ) Z = 255.;
-  return static_cast<UShort_t>( ( static_cast<UInt_t>( Y )<<8) + static_cast<UInt_t>( Z ) );
-}  
-
-GPUhd() inline Float_t AliHLTTPCCADataCompressor::UShort2Y( UShort_t iYZ )
-{ 
+  const float kMult = 255. / 6.;
+  Y = ( Y + 3. ) * kMult;
+  Z = ( Z + 3. ) * kMult;
+  if ( Y < 0. ) Y = 0.;
+  else if ( Y > 255. ) Y = 255.;
+  if ( Z < 0. ) Z = 0.;
+  else if ( Z > 255. ) Z = 255.;
+  return static_cast<unsigned short>( ( static_cast<unsigned int>( Y ) << 8 ) + static_cast<unsigned int>( Z ) );
+}
+
+GPUhd() inline float AliHLTTPCCADataCompressor::UShort2Y( unsigned short iYZ )
+{
   // extract Y coordinate from the compressed 16bits format to [-3.,3.]
 
-  const Float_t kMult = 6./255.; 
-  return (iYZ >> 8)*kMult - 3.;
-}  
+  const float kMult = 6. / 255.;
+  return ( iYZ >> 8 )*kMult - 3.;
+}
 
-GPUhd() inline Float_t AliHLTTPCCADataCompressor::UShort2Z( UShort_t iYZ )
-{ 
+GPUhd() inline float AliHLTTPCCADataCompressor::UShort2Z( unsigned short iYZ )
+{
   // extract Z coordinate from the compressed 16bits format to [-3.,3.]
 
-  const Float_t kMult = 6./255.; 
-  return (iYZ % 256)*kMult - 3.;
+  const float kMult = 6. / 255.;
+  return ( iYZ % 256 )*kMult - 3.;
 }
 
 #endif
index 7c2fab3..20fe866 100644 (file)
@@ -1,18 +1,18 @@
 //-*- Mode: C++ -*-
 
-//* This file is property of and copyright by the ALICE HLT Project        * 
+//* 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 ALIHLTTPCCADEF_H
 #define ALIHLTTPCCADEF_H
 
+
 /**
  * Definitions needed for AliHLTTPCCATracker
  *
- */  
+ */
+
 //#define HLTCA_STANDALONE // compilation w/o root
 #define HLTCA_INTERNAL_PERFORMANCE
 
 #define ClassDef(name,id)
 #define ClassImp(name)
 
-typedef char           Char_t;      //Signed Character 1 byte (char)
+typedef char           char;      //Signed Character 1 byte (char)
 typedef unsigned char  UChar_t;     //Unsigned Character 1 byte (unsigned char)
-typedef short          Short_t;     //Signed Short integer 2 bytes (short)
-typedef unsigned short UShort_t;    //Unsigned Short integer 2 bytes (unsigned short)
+typedef short          short;     //Signed Short integer 2 bytes (short)
+typedef unsigned short unsigned short;    //Unsigned Short integer 2 bytes (unsigned short)
 #ifdef R__INT16
-typedef long           Int_t;       //Signed integer 4 bytes
-typedef unsigned long  UInt_t;      //Unsigned integer 4 bytes
+typedef long           int;       //Signed integer 4 bytes
+typedef unsigned long  unsigned int;      //Unsigned integer 4 bytes
 #else
-typedef int            Int_t;       //Signed integer 4 bytes (int)
-typedef unsigned int   UInt_t;      //Unsigned integer 4 bytes (unsigned int)
+typedef int            int;       //Signed integer 4 bytes (int)
+typedef unsigned int   unsigned int;      //Unsigned integer 4 bytes (unsigned int)
 #endif
 #ifdef R__B64    // Note: Long_t and ULong_t are currently not portable types
 typedef int            Seek_t;      //File pointer (int)
@@ -49,12 +49,12 @@ typedef int            Seek_t;      //File pointer (int)
 typedef long           Long_t;      //Signed long integer 4 bytes (long)
 typedef unsigned long  ULong_t;     //Unsigned long integer 4 bytes (unsigned long)
 #endif
-typedef float          Float_t;     //Float 4 bytes (float)
+typedef float          float;     //Float 4 bytes (float)
 typedef float          Float16_t;   //Float 4 bytes written with a truncated mantissa
-typedef double         Double_t;    //Double 8 bytes
+typedef double         double;    //Double 8 bytes
 typedef double         Double32_t;  //Double 8 bytes in memory, written as a 4 bytes float
 typedef char           Text_t;      //General string (char)
-typedef bool           Bool_t;      //Boolean (0=false, 1=true) (bool)
+typedef bool           bool;      //Boolean (0=false, 1=true) (bool)
 typedef unsigned char  Byte_t;      //Byte (8 bits) (unsigned char)
 typedef short          Version_t;   //Class version identifier (short)
 typedef const char     Option_t;    //Option string (const char)
@@ -79,7 +79,7 @@ typedef double         Coord_t;     //Pad world coordinates (double)
 typedef float          Angle_t;     //Graphics angle (float)
 typedef float          Size_t;      //Attribute size (float)
 
-#else 
+#else
 
 #include "Rtypes.h"
 #include "AliHLTDataTypes.h"
@@ -94,30 +94,30 @@ namespace AliHLTTPCCADefinitions
 
 #ifdef HLTCA_GPUCODE
 
-#define GPUd() __device__ 
-#define GPUhd() __host__ __device__ 
-#define GPUh() __host__ inline 
-#define GPUg() __global__ 
+#define GPUd() __device__
+#define GPUhd() __host__ __device__
+#define GPUh() __host__ inline
+#define GPUg() __global__
 
-#define GPUshared() __shared__ 
+#define GPUshared() __shared__
 #define GPUsync() __syncthreads()
 
-__constant__ float4 gAliHLTTPCCATracker[30000/sizeof(float4)];
+__constant__ float4 gAliHLTTPCCATracker[30000/sizeof( float4 )];
 
 #else
 
-#define GPUd() 
+#define GPUd()
 #define GPUhd()
 #define GPUg()
-#define GPUh() 
-#define GPUshared() 
-#define GPUsync() 
-
-struct float2{ float x; float y; };
-struct uchar2{ unsigned char x; unsigned char y; };
-struct ushort2{ unsigned short x; unsigned short y; };
-struct uint1{ unsigned int x; };
-struct uint4{ unsigned int x,y,z,w; };
+#define GPUh()
+#define GPUshared()
+#define GPUsync()
+
+struct float2 { float x; float y; };
+struct uchar2 { unsigned char x; unsigned char y; };
+struct ushort2 { unsigned short x; unsigned short y; };
+struct uint1 { unsigned int x; };
+struct uint4 { unsigned int x, y, z, w; };
 
 #endif
 
index d89a15a..c0890b0 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 class AliHLTTPCCADisplay::AliHLTTPCCADisplayTmpHit
 {
 
-public:
-
-  Int_t ID() const { return fHitID; }
-  Double_t S() const { return fS; }
-  Double_t Z() const { return fZ; }
-  
-  void SetID( Int_t v ){ fHitID = v; }    
-  void SetS( Double_t v){ fS = v; }
-  void SetZ( Double_t v){ fZ = v; }
-  
-  static Bool_t CompareHitDS( const AliHLTTPCCADisplayTmpHit &a, 
-                             const AliHLTTPCCADisplayTmpHit  &b )
-  {    
-    return (a.fS < b.fS);
-  }
+  public:
 
-  static Bool_t CompareHitZ( const AliHLTTPCCADisplayTmpHit &a, 
-                            const AliHLTTPCCADisplayTmpHit  &b )
-  {    
-    return (a.fZ < b.fZ);
-  }
+    int ID() const { return fHitID; }
+    double S() const { return fS; }
+    double Z() const { return fZ; }
+
+    void SetID( int v ) { fHitID = v; }
+    void SetS( double v ) { fS = v; }
+    void SetZ( double v ) { fZ = v; }
 
-private:
+    static bool CompareHitDS( const AliHLTTPCCADisplayTmpHit &a,
+                                const AliHLTTPCCADisplayTmpHit  &b ) {
+      return ( a.fS < b.fS );
+    }
+
+    static bool CompareHitZ( const AliHLTTPCCADisplayTmpHit &a,
+                               const AliHLTTPCCADisplayTmpHit  &b ) {
+      return ( a.fZ < b.fZ );
+    }
 
-  Int_t fHitID; // hit ID
-  Double_t fS;  // hit position on the XY track curve 
-  Double_t fZ;  // hit Z position
+  private:
+
+    int fHitID; // hit ID
+    double fS;  // hit position on the XY track curve
+    double fZ;  // hit Z position
 
 };
 
@@ -78,68 +76,68 @@ AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
 {
   // reference to static object
   static AliHLTTPCCADisplay gAliHLTTPCCADisplay;
-  static Bool_t firstCall = 1;
-  if( firstCall ){
-    if( !gApplication ) new TApplication("myapp",0,0);
+  static bool firstCall = 1;
+  if ( firstCall ) {
+    if ( !gApplication ) new TApplication( "myapp", 0, 0 );
     gAliHLTTPCCADisplay.Init();
     firstCall = 0;
   }
-  return gAliHLTTPCCADisplay; 
+  return gAliHLTTPCCADisplay;
 }
 
-AliHLTTPCCADisplay::AliHLTTPCCADisplay() : fYX(0), fZX(0), fAsk(1), fSliceView(1), fSlice(0),fGB(0), fPerf(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(), fDrawOnlyRef(0)
+AliHLTTPCCADisplay::AliHLTTPCCADisplay() : fYX( 0 ), fZX( 0 ), fAsk( 1 ), fSliceView( 1 ), fSlice( 0 ), fGB( 0 ), fPerf( 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(), fDrawOnlyRef( 0 )
 {
-  fPerf = &(AliHLTTPCCAPerformance::Instance());
+  fPerf = &( AliHLTTPCCAPerformance::Instance() );
   // constructor
-} 
+}
 
 
-AliHLTTPCCADisplay::AliHLTTPCCADisplay( const AliHLTTPCCADisplay& ) 
-  : fYX(0), fZX(0), fAsk(1), fSliceView(1), fSlice(0), fGB(0), fPerf(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(), fDrawOnlyRef(0)
+AliHLTTPCCADisplay::AliHLTTPCCADisplay( const AliHLTTPCCADisplay& )
+    : fYX( 0 ), fZX( 0 ), fAsk( 1 ), fSliceView( 1 ), fSlice( 0 ), fGB( 0 ), fPerf( 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(), fDrawOnlyRef( 0 )
 {
   // dummy
 }
 
-const AliHLTTPCCADisplay& AliHLTTPCCADisplay::operator=( const AliHLTTPCCADisplay& ) const 
+const AliHLTTPCCADisplay& AliHLTTPCCADisplay::operator=( const AliHLTTPCCADisplay& ) const
 {
   // dummy
   return *this;
 }
+
 AliHLTTPCCADisplay::~AliHLTTPCCADisplay()
 {
   // destructor
-  delete fYX; 
+  delete fYX;
   delete fZX;
 }
 
 void AliHLTTPCCADisplay::Init()
 {
   // initialization
-  gStyle->SetCanvasBorderMode(0);
-  gStyle->SetCanvasBorderSize(1);
-  gStyle->SetCanvasColor(0);
-  fYX = new TCanvas ("YX", "YX window", -1, 0, 600, 600);
-  fZX = new TCanvas ("ZX", "ZX window", -610, 0, 590, 600);  
-  fMarker = TMarker(0.0, 0.0, 20);//6);
+  gStyle->SetCanvasBorderMode( 0 );
+  gStyle->SetCanvasBorderSize( 1 );
+  gStyle->SetCanvasColor( 0 );
+  fYX = new TCanvas ( "YX", "YX window", -1, 0, 600, 600 );
+  fZX = new TCanvas ( "ZX", "ZX window", -610, 0, 590, 600 );
+  fMarker = TMarker( 0.0, 0.0, 20 );//6);
   fDrawOnlyRef = 0;
 }
 
 void AliHLTTPCCADisplay::Update()
 {
   // update windows
-  if( !fAsk ) return;
+  if ( !fAsk ) return;
   fYX->Update();
   fZX->Update();
-  fYX->Print("YX.pdf");
-  fZX->Print("ZX.pdf");
+  fYX->Print( "YX.pdf" );
+  fZX->Print( "ZX.pdf" );
+
 }
 
 void AliHLTTPCCADisplay::ClearView()
@@ -153,14 +151,14 @@ void AliHLTTPCCADisplay::Ask()
 {
   // whait for the pressed key, when "r" pressed, don't ask anymore
   char symbol;
-  if (fAsk){
+  if ( fAsk ) {
     Update();
-    std::cout<<"ask> "<<std::endl;
-    do{
-      std::cin.get(symbol);
-      if (symbol == 'r')
-       fAsk = false;
-    } while (symbol != '\n');
+    std::cout << "ask> " << std::endl;
+    do {
+      std::cin.get( symbol );
+      if ( symbol == 'r' )
+        fAsk = false;
+    } while ( symbol != '\n' );
   }
 }
 
@@ -194,23 +192,23 @@ void AliHLTTPCCADisplay::SetCurrentSlice( AliHLTTPCCATracker *slice )
   // set reference to the current CA tracker, and read the current slice geometry
   fSlice = slice;
   SetSliceTransform( slice );
-  if( fSliceView ){
+  if ( fSliceView ) {
     fCos = slice->Param().SinAlpha();
     fSin = slice->Param().CosAlpha();
     fZMin = slice->Param().ZMin();
     fZMax = slice->Param().ZMax();
     ClearView();
-    Double_t r0 = .5*(slice->Param().RMax()+slice->Param().RMin());
-    Double_t dr = .5*(slice->Param().RMax()-slice->Param().RMin());
+    double r0 = .5 * ( slice->Param().RMax() + slice->Param().RMin() );
+    double 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());
-    Double_t dz = .5*(slice->Param().ZMax()-slice->Param().ZMin())*1.2;
-    fYX->Range(cx-dr, cy-dr*1.05, cx+dr, cy+dr);
-    fZX->Range(cz-dz, cy-dr*1.05, cz+dz, cy+dr);
-    
+    double cx = 0;
+    double cy = r0;
+    double cz = .5 * ( slice->Param().ZMax() + slice->Param().ZMin() );
+    double dz = .5 * ( slice->Param().ZMax() - slice->Param().ZMin() ) * 1.2;
+    fYX->Range( cx - dr, cy - dr*1.05, cx + dr, cy + dr );
+    fZX->Range( cz - dz, cy - dr*1.05, cz + dz, cy + dr );
+
     //fYX->Range(cx-dr*.3, cy-dr*1.05, cx+dr*.3, cy-dr*.35);
     //fZX->Range(cz-dz, cy-dr*1.05, cz+dz, cy-dr*.3);
 
@@ -219,45 +217,45 @@ void AliHLTTPCCADisplay::SetCurrentSlice( AliHLTTPCCATracker *slice )
 
     //fYX->Range(cx-dr*.08, cy-dr*1., cx-dr*.02, cy-dr*0.7);
     //fZX->Range(cz-dz*.2, cy-dr*1., cz-dz*.05, cy-dr*0.7);
-    
-    //Double_t x0 = cx-dr*.1, x1 = cx-dr*.05;
-    //Double_t y0 = cy-dr*1.05, y1 = cy-dr*0.7;
-    //Double_t z0 = cz-dz*.3, z1 = cz;
-    //Double_t xc = (x0+x1)/2, yc= (y0+y1)/2, zc=(z0+z1)/2;
-    //Double_t d = TMath::Max((x1-x0)/2,TMath::Max((y1-y0)/2,(z1-z0)/2));
+
+    //double x0 = cx-dr*.1, x1 = cx-dr*.05;
+    //double y0 = cy-dr*1.05, y1 = cy-dr*0.7;
+    //double z0 = cz-dz*.3, z1 = cz;
+    //double xc = (x0+x1)/2, yc= (y0+y1)/2, zc=(z0+z1)/2;
+    //double d = TMath::Max((x1-x0)/2,TMath::Max((y1-y0)/2,(z1-z0)/2));
     //fYX->Range(xc-d, yc-d, xc+d, yc+d);
     //fZX->Range(zc-d, yc-d, zc+d, yc+d);
-    
-   }
+
+  }
 }
 
-void AliHLTTPCCADisplay::SetSliceTransform( Double_t alpha )
+void AliHLTTPCCADisplay::SetSliceTransform( double alpha )
 {
   fSliceCos = TMath::Cos( alpha );
   fSliceSin = TMath::Sin( alpha );
-} 
+}
 
 void AliHLTTPCCADisplay::SetSliceTransform( AliHLTTPCCATracker *slice )
 {
-  SetSliceTransform(slice->Param().Alpha());
+  SetSliceTransform( slice->Param().Alpha() );
 }
 
 
 void AliHLTTPCCADisplay::DrawTPC()
 {
   // schematically draw TPC detector
-  fYX->Range(-fROuterMax, -fROuterMax, fROuterMax, fROuterMax);
+  fYX->Range( -fROuterMax, -fROuterMax, fROuterMax, fROuterMax );
   //fYX->Range( -fROuterMax*.7, -fROuterMax, fROuterMax*0., -fROuterMax*.5);
   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) );
+    fArc.SetLineColor( kBlack );
+    fArc.SetFillStyle( 0 );
+    fYX->cd();
+    for ( int 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();
@@ -266,55 +264,55 @@ void AliHLTTPCCADisplay::DrawTPC()
   fZX->Clear();
 }
 
-void AliHLTTPCCADisplay::DrawSlice( AliHLTTPCCATracker *slice, Bool_t DrawRows )
-{     
+void AliHLTTPCCADisplay::DrawSlice( AliHLTTPCCATracker *slice, bool DrawRows )
+{
   // 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 ){
+  double r0 = .5 * ( slice->Param().RMax() + slice->Param().RMin() );
+  double dr = .5 * ( slice->Param().RMax() - slice->Param().RMin() );
+  double cx = r0 * slice->Param().CosAlpha();
+  double cy = r0 * slice->Param().SinAlpha();
+  double raddeg = 180. / 3.1415;
+  double a0 = raddeg * .5 * ( slice->Param().AngleMax() + slice->Param().AngleMin() );
+  double 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()));
+    fLatex.DrawLatex( cx - dr + dr*.05, cy - dr + dr*.05, Form( "YX, Slice %2i", slice->Param().ISlice() ) );
   } else {
-    a0+= raddeg*TMath::ATan2(fSin, fCos );
+    a0 += raddeg * TMath::ATan2( fSin, fCos );
   }
-  fArc.SetLineColor(kBlack);
-  fArc.SetFillStyle(0);     
-  fCrown.SetLineColor(kBlack);
-  fCrown.SetFillStyle(0);
-  fCrown.DrawCrown(0,0, fRInnerMin, fRInnerMax, a0-da, a0+da );
-  fCrown.DrawCrown(0,0, fROuterMin, fROuterMax, a0-da, a0+da );
+  fArc.SetLineColor( kBlack );
+  fArc.SetFillStyle( 0 );
+  fCrown.SetLineColor( kBlack );
+  fCrown.SetFillStyle( 0 );
+  fCrown.DrawCrown( 0, 0, fRInnerMin, fRInnerMax, a0 - da, a0 + da );
+  fCrown.DrawCrown( 0, 0, fROuterMin, fROuterMax, a0 - da, a0 + da );
   //fCrown.DrawCrown(0,0, slice->Param().RMin(),slice->Param().RMax(), a0-da, a0+da );
-  
-  fLine.SetLineColor(kBlack);
+
+  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()));
-
-  if( DrawRows ){
-    fLine.SetLineWidth(1);
-    fLine.SetLineColor(kBlack);    
-    SetSliceTransform(fSlice);      
-    for( Int_t iRow=0; iRow<fSlice->Param().NRows(); iRow++ ){
-      Double_t x = fSlice->Row(iRow).X();
-      Double_t y = fSlice->Row(iRow).MaxY();
-      Double_t vx0, vy0, vx1, vy1;
-      Slice2View( x, y, &vx0, &vy0 );  
-      Slice2View( x, -y, &vx1, &vy1 );    
+  double cz = .5 * ( slice->Param().ZMax() + slice->Param().ZMin() );
+  double 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() ) );
+
+  if ( DrawRows ) {
+    fLine.SetLineWidth( 1 );
+    fLine.SetLineColor( kBlack );
+    SetSliceTransform( fSlice );
+    for ( int iRow = 0; iRow < fSlice->Param().NRows(); iRow++ ) {
+      double x = fSlice->Row( iRow ).X();
+      double y = fSlice->Row( iRow ).MaxY();
+      double vx0, vy0, vx1, vy1;
+      Slice2View( x, y, &vx0, &vy0 );
+      Slice2View( x, -y, &vx1, &vy1 );
       fYX->cd();
-      fLine.DrawLine(vx0, vy0,vx1,vy1);
+      fLine.DrawLine( vx0, vy0, vx1, vy1 );
       fZX->cd();
-      fLine.DrawLine(fTPCZMin, vy0,fTPCZMax,vy1);
+      fLine.DrawLine( fTPCZMin, vy0, fTPCZMax, vy1 );
     }
   }
 
@@ -327,277 +325,281 @@ void AliHLTTPCCADisplay::Set2Slices( AliHLTTPCCATracker * const slice )
 
   fSlice = slice;
   fSliceView = 0;
-  fCos = TMath::Cos(TMath::Pi()/2 - (slice->Param().Alpha()+10./180.*TMath::Pi()));
-  fSin = TMath::Sin(TMath::Pi()/2 - (slice->Param().Alpha()+10./180.*TMath::Pi()));
+  fCos = TMath::Cos( TMath::Pi() / 2 - ( slice->Param().Alpha() + 10. / 180.*TMath::Pi() ) );
+  fSin = TMath::Sin( TMath::Pi() / 2 - ( slice->Param().Alpha() + 10. / 180.*TMath::Pi() ) );
   fZMin = slice->Param().ZMin();
   fZMax = slice->Param().ZMax();
   ClearView();
-  Double_t r0 = .5*(slice->Param().RMax()+slice->Param().RMin());
-  Double_t dr = .5*(slice->Param().RMax()-slice->Param().RMin());
-  Double_t cx = 0;
-  Double_t cy = r0;    
-  fYX->Range(cx-1.3*dr, cy-1.1*dr, cx+1.3*dr, cy+1.1*dr);
+  double r0 = .5 * ( slice->Param().RMax() + slice->Param().RMin() );
+  double dr = .5 * ( slice->Param().RMax() - slice->Param().RMin() );
+  double cx = 0;
+  double cy = r0;
+  fYX->Range( cx - 1.3*dr, cy - 1.1*dr, cx + 1.3*dr, cy + 1.1*dr );
   fYX->cd();
-  Int_t islice = slice->Param().ISlice();
-  Int_t jslice = slice->Param().ISlice()+1;
-  if( islice==17 ) jslice = 0;
-  else if( islice==35 ) jslice = 18;
-  fLatex.DrawLatex(cx-1.3*dr+1.3*dr*.05,cy-dr+dr*.05, Form("YX, Slices %2i/%2i",islice,jslice));
-  Double_t cz = .5*(slice->Param().ZMax()+slice->Param().ZMin());
-  Double_t dz = .5*(slice->Param().ZMax()-slice->Param().ZMin())*1.2;
-  fZX->Range(cz-dz, cy-1.1*dr, cz+dz, cy+1.1*dr);//+dr);
-  fZX->cd();  
-  fLatex.DrawLatex(cz-dz+dz*.05,cy-dr+dr*.05, Form("ZX, Slices %2i/%2i",islice,jslice));
+  int islice = slice->Param().ISlice();
+  int jslice = slice->Param().ISlice() + 1;
+  if ( islice == 17 ) jslice = 0;
+  else if ( islice == 35 ) jslice = 18;
+  fLatex.DrawLatex( cx - 1.3*dr + 1.3*dr*.05, cy - dr + dr*.05, Form( "YX, Slices %2i/%2i", islice, jslice ) );
+  double cz = .5 * ( slice->Param().ZMax() + slice->Param().ZMin() );
+  double dz = .5 * ( slice->Param().ZMax() - slice->Param().ZMin() ) * 1.2;
+  fZX->Range( cz - dz, cy - 1.1*dr, cz + dz, cy + 1.1*dr );//+dr);
+  fZX->cd();
+  fLatex.DrawLatex( cz - dz + dz*.05, cy - dr + dr*.05, Form( "ZX, Slices %2i/%2i", islice, jslice ) );
 }
 
-Int_t AliHLTTPCCADisplay::GetColor( Int_t i ) const 
+int AliHLTTPCCADisplay::GetColor( int i ) const
 {
   // Get color with respect to Z coordinate
-  const Color_t kMyColor[9] = { kGreen, kBlue, kYellow, kCyan, kOrange, 
-                                kSpring, kTeal, kAzure, kViolet };
-  if( i<0 ) i= 0;
-  if( i==0 ) return kBlack;
-  return kMyColor[(i-1)%9];
+  const Color_t kMyColor[9] = { kGreen, kBlue, kYellow, kCyan, kOrange,
+                                kSpring, kTeal, kAzure, kViolet
+                              };
+  if ( i < 0 ) i = 0;
+  if ( i == 0 ) return kBlack;
+  return kMyColor[( i-1 )%9];
 }
 
-Int_t AliHLTTPCCADisplay::GetColorZ( Double_t z ) const 
+int AliHLTTPCCADisplay::GetColorZ( double z ) const
 {
   // 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 zz = (z-fZMin)/(fZMax-fZMin);    
-  Int_t iz = (int) (zz*11);
-  if( iz<0 ) iz = 0;
-  if( iz>10 ) iz = 10;
+  const Color_t kMyColor[11] = { kGreen, kBlue, kYellow, kMagenta, kCyan,
+                                 kOrange, kSpring, kTeal, kAzure, kViolet, kPink
+                               };
+
+  double zz = ( z - fZMin ) / ( fZMax - fZMin );
+  int iz = ( int ) ( zz * 11 );
+  if ( iz < 0 ) iz = 0;
+  if ( iz > 10 ) iz = 10;
   return kMyColor[iz];
 }
 
-Int_t AliHLTTPCCADisplay::GetColorY( Double_t y ) const 
+int AliHLTTPCCADisplay::GetColorY( double y ) const
 {
   // 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;
+  const Color_t kMyColor[11] = { kGreen, kBlue, kYellow, kMagenta, kCyan,
+                                 kOrange, kSpring, kTeal, kAzure, kViolet, kPink
+                               };
+
+  double yy = ( y - fYMin ) / ( fYMax - fYMin );
+  int iy = ( int ) ( yy * 11 );
+  if ( iy < 0 ) iy = 0;
+  if ( iy > 10 ) iy = 10;
   return kMyColor[iy];
 }
 
-Int_t AliHLTTPCCADisplay::GetColorK( Double_t k ) const 
+int AliHLTTPCCADisplay::GetColorK( double k ) const
 {
   // 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;
+  const Color_t kMyColor[11] = { kRed, kBlue, kYellow, kMagenta, kCyan,
+                                 kOrange, kSpring, kTeal, kAzure, kViolet, kPink
+                               };
+  const double kCLight = 0.000299792458;
+  const double kBz = 5;
+  double k2QPt = 100;
+  if ( TMath::Abs( kBz ) > 1.e-4 ) k2QPt = 1. / ( kBz * kCLight );
+  double qPt = k * k2QPt;
+  double pt = 100;
+  if ( TMath::Abs( qPt ) > 1.e-4 ) pt = 1. / TMath::Abs( qPt );
+
+  double yy = ( pt - 0.1 ) / ( 1. - 0.1 );
+  int iy = ( int ) ( yy * 11 );
+  if ( iy < 0 ) iy = 0;
+  if ( iy > 10 ) iy = 10;
   return kMyColor[iy];
 }
 
-void AliHLTTPCCADisplay::Global2View( Double_t x, Double_t y, Double_t *xv, Double_t *yv ) const
+void AliHLTTPCCADisplay::Global2View( double x, double y, double *xv, double *yv ) const
 {
   // convert coordinates global->view
-  *xv = x*fCos + y*fSin;
-  *yv = y*fCos - x*fSin;
+  *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
+void AliHLTTPCCADisplay::Slice2View( double x, double y, double *xv, double *yv ) const
 {
   // convert coordinates slice->view
-  Double_t xg = x*fSliceCos - y*fSliceSin;
-  Double_t yg = y*fSliceCos + x*fSliceSin;
-  *xv = xg*fCos - yg*fSin;
-  *yv = yg*fCos + xg*fSin;
+  double xg = x * fSliceCos - y * fSliceSin;
+  double yg = y * fSliceCos + x * fSliceSin;
+  *xv = xg * fCos - yg * fSin;
+  *yv = yg * fCos + xg * fSin;
 }
 
 
-void AliHLTTPCCADisplay::DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color, Size_t width  )
+void AliHLTTPCCADisplay::DrawGBHit( AliHLTTPCCAGBTracker &tracker, int iHit, int color, Size_t width  )
 {
   // draw hit
   AliHLTTPCCAGBHit &h = tracker.Hits()[iHit];
   AliHLTTPCCATracker &slice = tracker.Slices()[h.ISlice()];
-  SetSliceTransform(&slice);
-  
-  if( color<0 ){
-    if( fPerf ){
-      Int_t lab = fPerf->HitLabels()[h.ID()].fLab[0];
-      color = GetColor(lab+1);
-      if( lab>=0 ){
-       AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lab];
-       if( mc.P()>=1. ) color = kRed;  
-       else if(fDrawOnlyRef) return;
+  SetSliceTransform( &slice );
+
+  if ( color < 0 ) {
+    if ( fPerf ) {
+      int lab = fPerf->HitLabels()[h.ID()].fLab[0];
+      color = GetColor( lab + 1 );
+      if ( lab >= 0 ) {
+        AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lab];
+        if ( mc.P() >= 1. ) color = kRed;
+        else if ( fDrawOnlyRef ) return;
       }
-    }else color=GetColorZ( h.Z() );
+    } else color = GetColorZ( h.Z() );
   }
-  if( width>0 )fMarker.SetMarkerSize(width);
-  else fMarker.SetMarkerSize(.3);
-  fMarker.SetMarkerColor(color);
-  Double_t vx, vy;
-  Slice2View( h.X(), h.Y(), &vx, &vy );  
-  
+  if ( width > 0 )fMarker.SetMarkerSize( width );
+  else fMarker.SetMarkerSize( .3 );
+  fMarker.SetMarkerColor( color );
+  double vx, vy;
+  Slice2View( h.X(), h.Y(), &vx, &vy );
+
   fYX->cd();
-  fMarker.DrawMarker(vx, vy);
-  fZX->cd();  
-  fMarker.DrawMarker(h.Z(), vy); 
+  fMarker.DrawMarker( vx, vy );
+  fZX->cd();
+  fMarker.DrawMarker( h.Z(), vy );
 }
 
-void AliHLTTPCCADisplay::DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color, Size_t width )
+void AliHLTTPCCADisplay::DrawGBHits( AliHLTTPCCAGBTracker &tracker, int color, Size_t width )
 {
-  // draw hits 
+  // draw hits
+
+  if ( !fPerf ) return;
+  if ( width < 0 ) width = .3;
 
-  if( !fPerf ) return;
-  if( width<0 ) width = .3;
-    
-  for( Int_t iHit = 0; iHit<tracker.NHits(); iHit++ ){
+  for ( int iHit = 0; iHit < tracker.NHits(); iHit++ ) {
     AliHLTTPCCAGBHit &h = tracker.Hits()[iHit];
-    Int_t imc = fPerf->HitLabels()[h.ID()].fLab[0];
-    AliHLTTPCCAMCTrack *mc = (imc>=0) ?&(fPerf->MCTracks()[imc]) :0;
-    if(fDrawOnlyRef && (!mc || (mc->P()<1))) continue;
-    Int_t col = color;
-    if( color<0 ){
-      col = GetColor(imc+1) ;
-      if( mc && (mc->P()>=1.) ) col = kRed;        
-    }    
+    int imc = fPerf->HitLabels()[h.ID()].fLab[0];
+    AliHLTTPCCAMCTrack *mc = ( imc >= 0 ) ? &( fPerf->MCTracks()[imc] ) : 0;
+    if ( fDrawOnlyRef && ( !mc || ( mc->P() < 1 ) ) ) continue;
+    int col = color;
+    if ( color < 0 ) {
+      col = GetColor( imc + 1 ) ;
+      if ( mc && ( mc->P() >= 1. ) ) col = kRed;
+    }
 
     AliHLTTPCCATracker &slice = tracker.Slices()[h.ISlice()];
-    SetSliceTransform(&slice);
+    SetSliceTransform( &slice );
+
+    fMarker.SetMarkerSize( width );
+    fMarker.SetMarkerColor( col );
+    double vx, vy;
+    Slice2View( h.X(), h.Y(), &vx, &vy );
 
-    fMarker.SetMarkerSize(width);
-    fMarker.SetMarkerColor(col);
-    Double_t vx, vy;
-    Slice2View( h.X(), h.Y(), &vx, &vy );  
-      
     fYX->cd();
-    fMarker.DrawMarker(vx, vy);
-    fZX->cd();  
-    fMarker.DrawMarker(h.Z(), vy); 
+    fMarker.DrawMarker( vx, vy );
+    fZX->cd();
+    fMarker.DrawMarker( h.Z(), vy );
   }
 }
 
-void AliHLTTPCCADisplay::DrawSliceHit( Int_t iRow, Int_t iHit, Int_t color, Size_t width )
+void AliHLTTPCCADisplay::DrawSliceHit( int iRow, int iHit, int color, Size_t width )
 {
   // draw hit
-  if( !fSlice ) return;
-  const AliHLTTPCCARow &row = fSlice->Row(iRow);        
+  if ( !fSlice ) return;
+  const AliHLTTPCCARow &row = fSlice->Row( iRow );
   float y0 = row.Grid().YMin();
   float z0 = row.Grid().ZMin();
   float stepY = row.HstepY();
   float stepZ = row.HstepZ();
   const uint4* tmpint4 = fSlice->RowData() + row.FullOffset();
-  const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
+  const ushort2 *hits = reinterpret_cast<const ushort2*>( tmpint4 );
   ushort2 hh = hits[iHit];
-  Float_t x = row.X();
-  Float_t y = y0 + hh.x*stepY;
-  Float_t z = z0 + hh.y*stepZ;
-
-  SetSliceTransform(fSlice);
-  
-  if( color<0 ){
-    if( fPerf && fGB ){
-      Int_t id = fGB->FirstSliceHit()[fSlice->Param().ISlice()]+fSlice->HitInputIDs()[row.FirstHit()+iHit];
+  float x = row.X();
+  float y = y0 + hh.x * stepY;
+  float z = z0 + hh.y * stepZ;
+
+  SetSliceTransform( fSlice );
+
+  if ( color < 0 ) {
+    if ( fPerf && fGB ) {
+      int id = fGB->FirstSliceHit()[fSlice->Param().ISlice()] + fSlice->HitInputIDs()[row.FirstHit()+iHit];
       AliHLTTPCCAGBHit &h = fGB->Hits()[id];
-      Int_t lab = fPerf->HitLabels()[h.ID()].fLab[0];
-      color = GetColor(lab+1);
-      if( lab>=0 ){
-       AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lab];
-       if( mc.P()>=1. ) color = kRed;  
-       else if(fDrawOnlyRef) return;
+      int lab = fPerf->HitLabels()[h.ID()].fLab[0];
+      color = GetColor( lab + 1 );
+      if ( lab >= 0 ) {
+        AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lab];
+        if ( mc.P() >= 1. ) color = kRed;
+        else if ( fDrawOnlyRef ) return;
       }
-    }else color=GetColorZ( z );
+    } else color = GetColorZ( z );
   }
-  if( width>0 )fMarker.SetMarkerSize(width);
-  else fMarker.SetMarkerSize(.3);
-  fMarker.SetMarkerColor(color);
-  Double_t vx, vy;
-  Slice2View( x, y, &vx, &vy );    
+  if ( width > 0 )fMarker.SetMarkerSize( width );
+  else fMarker.SetMarkerSize( .3 );
+  fMarker.SetMarkerColor( color );
+  double vx, vy;
+  Slice2View( x, y, &vx, &vy );
   fYX->cd();
-  fMarker.DrawMarker(vx, vy);
-  fZX->cd();  
-  fMarker.DrawMarker(z, vy); 
+  fMarker.DrawMarker( vx, vy );
+  fZX->cd();
+  fMarker.DrawMarker( z, vy );
 }
 
-void AliHLTTPCCADisplay::DrawSliceHits( Int_t color, Size_t width )
+void AliHLTTPCCADisplay::DrawSliceHits( int color, Size_t width )
 {
 
-  // draw hits 
+  // draw hits
 
-  for( Int_t iRow=0; iRow<fSlice->Param().NRows(); iRow++ ){
-    const AliHLTTPCCARow &row = fSlice->Row(iRow);
-    for( Int_t ih=0; ih<row.NHits(); ih++ ){
-      DrawSliceHit( iRow, ih, color, width );     
+  for ( int iRow = 0; iRow < fSlice->Param().NRows(); iRow++ ) {
+    const AliHLTTPCCARow &row = fSlice->Row( iRow );
+    for ( int ih = 0; ih < row.NHits(); ih++ ) {
+      DrawSliceHit( iRow, ih, color, width );
     }
-  }  
+  }
 }
 
 
-void AliHLTTPCCADisplay::DrawSliceLink( Int_t iRow, Int_t iHit, Int_t colorUp, Int_t colorDn, Int_t width )
+void AliHLTTPCCADisplay::DrawSliceLink( int iRow, int iHit, int colorUp, int colorDn, int width )
 {
-  // draw link between clusters 
+  // draw link between clusters
 
-  if( !fPerf || !fGB) return;
+  if ( !fPerf || !fGB ) return;
   AliHLTTPCCAGBTracker &tracker = *fGB;
-  if( width<0 ) width = 1.;
+  if ( width < 0 ) width = 1.;
   fLine.SetLineWidth( width );
-  Int_t colUp = colorUp>=0 ? colorUp :kMagenta;
-  Int_t colDn = colorDn>=0 ? colorDn :kBlack;
-  if( iRow<1 || iRow>=fSlice->Param().NRows()-1 ) return;
-
-  const AliHLTTPCCARow& row = fSlice->Row(iRow);
-  const AliHLTTPCCARow& rowUp = fSlice->Row(iRow+1);
-  const AliHLTTPCCARow& rowDn = fSlice->Row(iRow-1);
-    
-  Int_t id = fSlice->HitInputIDs()[row.FirstHit()+iHit];
-  AliHLTTPCCAGBHit &h = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id]; 
-  Short_t iUp = ((Short_t*)(fSlice->RowData() + row.FullOffset()))[row.FullLinkOffset()+iHit];
-  Short_t iDn = ((Short_t*)(fSlice->RowData() + row.FullOffset()))[row.FullLinkOffset()+row.NHits()+iHit];
-
-  if( iUp>=0){
-    Int_t id1 =fSlice->HitInputIDs()[rowUp.FirstHit()+iUp];
-    AliHLTTPCCAGBHit &h1 = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id1]; 
-    Double_t vx, vy, vx1, vy1;
-    Slice2View( h.X(), h.Y(), &vx, &vy );  
-    Slice2View( h1.X(), h1.Y(), &vx1, &vy1 );  
+  int colUp = colorUp >= 0 ? colorUp : kMagenta;
+  int colDn = colorDn >= 0 ? colorDn : kBlack;
+  if ( iRow < 1 || iRow >= fSlice->Param().NRows() - 1 ) return;
+
+  const AliHLTTPCCARow& row = fSlice->Row( iRow );
+  const AliHLTTPCCARow& rowUp = fSlice->Row( iRow + 1 );
+  const AliHLTTPCCARow& rowDn = fSlice->Row( iRow - 1 );
+
+  int id = fSlice->HitInputIDs()[row.FirstHit()+iHit];
+  AliHLTTPCCAGBHit &h = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()] + id];
+  short iUp = ( ( short* )( fSlice->RowData() + row.FullOffset() ) )[row.FullLinkOffset()+iHit];
+  short iDn = ( ( short* )( fSlice->RowData() + row.FullOffset() ) )[row.FullLinkOffset()+row.NHits()+iHit];
+
+  if ( iUp >= 0 ) {
+    int id1 = fSlice->HitInputIDs()[rowUp.FirstHit()+iUp];
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()] + id1];
+    double vx, vy, vx1, vy1;
+    Slice2View( h.X(), h.Y(), &vx, &vy );
+    Slice2View( h1.X(), h1.Y(), &vx1, &vy1 );
     fLine.SetLineColor( colUp );
     fYX->cd();
-    fLine.DrawLine(vx-.1,vy,vx1-.1,vy1);
+    fLine.DrawLine( vx - .1, vy, vx1 - .1, vy1 );
     fZX->cd();
-    fLine.DrawLine(h.Z()-1.,vy,h1.Z()-1.,vy1);
+    fLine.DrawLine( h.Z() - 1., vy, h1.Z() - 1., vy1 );
   }
-  if( iDn>=0){
-    Int_t id1 =fSlice->HitInputIDs()[rowDn.FirstHit()+iDn];
-    AliHLTTPCCAGBHit &h1 = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id1]; 
-    Double_t vx, vy, vx1, vy1;
-    Slice2View( h.X(), h.Y(), &vx, &vy );  
-    Slice2View( h1.X(), h1.Y(), &vx1, &vy1 );  
+  if ( iDn >= 0 ) {
+    int id1 = fSlice->HitInputIDs()[rowDn.FirstHit()+iDn];
+    AliHLTTPCCAGBHit &h1 = tracker.Hits()[tracker.FirstSliceHit()[fSlice->Param().ISlice()] + id1];
+    double vx, vy, vx1, vy1;
+    Slice2View( h.X(), h.Y(), &vx, &vy );
+    Slice2View( h1.X(), h1.Y(), &vx1, &vy1 );
     fLine.SetLineColor( colDn );
     fYX->cd();
-    fLine.DrawLine(vx+.1,vy,vx1+.1,vy1);
+    fLine.DrawLine( vx + .1, vy, vx1 + .1, vy1 );
     fZX->cd();
-    fLine.DrawLine(h.Z()+1.,vy,h1.Z()+1.,vy1);
+    fLine.DrawLine( h.Z() + 1., vy, h1.Z() + 1., vy1 );
   }
 }
 
 
-void AliHLTTPCCADisplay::DrawSliceLinks( Int_t colorUp, Int_t colorDn, Int_t width )
+void AliHLTTPCCADisplay::DrawSliceLinks( int colorUp, int colorDn, int width )
 {
-  // draw links between clusters 
+  // draw links between clusters
 
-  for( Int_t iRow=1; iRow<fSlice->Param().NRows()-1; iRow++){
-    const AliHLTTPCCARow& row = fSlice->Row(iRow);
-    for( Int_t ih=0; ih<row.NHits(); ih++ ){
+  for ( int iRow = 1; iRow < fSlice->Param().NRows() - 1; iRow++ ) {
+    const AliHLTTPCCARow& row = fSlice->Row( iRow );
+    for ( int ih = 0; ih < row.NHits(); ih++ ) {
       DrawSliceLink( iRow, ih, colorUp, colorDn, width );
     }
   }
@@ -605,41 +607,41 @@ void AliHLTTPCCADisplay::DrawSliceLinks( Int_t colorUp, Int_t colorDn, Int_t wid
 
 
 
-Int_t AliHLTTPCCADisplay::GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, Int_t NHits )
+int AliHLTTPCCADisplay::GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, int NHits )
 {
   // get MC label for the track
-  
+
   AliHLTTPCCAGBTracker &tracker = *fGB;
 
-  Int_t label = -1; 
-  Double_t purity = 0;
-  Int_t *lb = new Int_t[NHits*3];
-  Int_t nla=0;
+  int label = -1;
+  double purity = 0;
+  int *lb = new int[NHits*3];
+  int nla = 0;
   //std::cout<<"\n\nTrack hits mc: "<<std::endl;
-  for( Int_t ihit=0; ihit<NHits; ihit++){
+  for ( int ihit = 0; ihit < NHits; ihit++ ) {
     AliHLTTPCCAGBHit &h = tracker.Hits()[vHits[ihit].ID()];
     AliHLTTPCCAPerformance::AliHLTTPCCAHitLabel &l = fPerf->HitLabels()[h.ID()];
-    if(l.fLab[0]>=0 ) lb[nla++]= l.fLab[0];
-    if(l.fLab[1]>=0 ) lb[nla++]= l.fLab[1];
-    if(l.fLab[2]>=0 ) lb[nla++]= l.fLab[2];
+    if ( l.fLab[0] >= 0 ) lb[nla++] = l.fLab[0];
+    if ( l.fLab[1] >= 0 ) lb[nla++] = l.fLab[1];
+    if ( l.fLab[2] >= 0 ) lb[nla++] = l.fLab[2];
     //std::cout<<ihit<<":  "<<l.fLab[0]<<" "<<l.fLab[1]<<" "<<l.fLab[2]<<std::endl;
   }
-  sort( lb, lb+nla );
-  Int_t labmax = -1, labcur=-1, lmax = 0, lcurr=0, nh=0;
+  sort( lb, lb + nla );
+  int labmax = -1, labcur = -1, lmax = 0, lcurr = 0, nh = 0;
   //std::cout<<"MC track IDs :"<<std::endl;
-  for( Int_t i=0; i<nla; i++ ){
-    if( lb[i]!=labcur ){
-      if( 0 && i>0 && lb[i-1]>=0 ){    
-       AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lb[i-1]];
-       std::cout<<lb[i-1]<<": nhits="<<nh<<", pdg="<< mc.PDG()<<", Pt="<<mc.Pt()<<", P="<<mc.P()
-                <<", par="<<mc.Par()[0]<<" "<<mc.Par()[1]<<" "<<mc.Par()[2]
-                <<" "<<mc.Par()[3]<<" "<<mc.Par()[4]<<" "<<mc.Par()[5]<<" "<<mc.Par()[6]<<std::endl;
-       
+  for ( int i = 0; i < nla; i++ ) {
+    if ( lb[i] != labcur ) {
+      if ( 0 && i > 0 && lb[i-1] >= 0 ) {
+        AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lb[i-1]];
+        std::cout << lb[i-1] << ": nhits=" << nh << ", pdg=" << mc.PDG() << ", Pt=" << mc.Pt() << ", P=" << mc.P()
+                  << ", par=" << mc.Par()[0] << " " << mc.Par()[1] << " " << mc.Par()[2]
+                  << " " << mc.Par()[3] << " " << mc.Par()[4] << " " << mc.Par()[5] << " " << mc.Par()[6] << std::endl;
+
       }
-      nh=0;
-      if( labcur>=0 && lmax<lcurr ){
-       lmax = lcurr;
-       labmax = labcur;
+      nh = 0;
+      if ( labcur >= 0 && lmax < lcurr ) {
+        lmax = lcurr;
+        labmax = labcur;
       }
       labcur = lb[i];
       lcurr = 0;
@@ -647,231 +649,231 @@ Int_t AliHLTTPCCADisplay::GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, Int
     lcurr++;
     nh++;
   }
-  if( 0 && nla-1>0 && lb[nla-1]>=0 ){  
+  if ( 0 && nla - 1 > 0 && lb[nla-1] >= 0 ) {
     AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lb[nla-1]];
-    std::cout<<lb[nla-1]<<": nhits="<<nh<<", pdg="<< mc.PDG()<<", Pt="<<mc.Pt()<<", P="<<mc.P()
-            <<", par="<<mc.Par()[0]<<" "<<mc.Par()[1]<<" "<<mc.Par()[2]
-            <<" "<<mc.Par()[3]<<" "<<mc.Par()[4]<<" "<<mc.Par()[5]<<" "<<mc.Par()[6]<<std::endl;
-    
+    std::cout << lb[nla-1] << ": nhits=" << nh << ", pdg=" << mc.PDG() << ", Pt=" << mc.Pt() << ", P=" << mc.P()
+              << ", par=" << mc.Par()[0] << " " << mc.Par()[1] << " " << mc.Par()[2]
+              << " " << mc.Par()[3] << " " << mc.Par()[4] << " " << mc.Par()[5] << " " << mc.Par()[6] << std::endl;
+
   }
-  if( labcur>=0 && lmax<lcurr ){
+  if ( labcur >= 0 && lmax < lcurr ) {
     lmax = lcurr;
     labmax = labcur;
   }
   lmax = 0;
-  for( Int_t ihit=0; ihit<NHits; ihit++){
+  for ( int ihit = 0; ihit < NHits; ihit++ ) {
     AliHLTTPCCAGBHit &h = tracker.Hits()[vHits[ihit].ID()];
     AliHLTTPCCAPerformance::AliHLTTPCCAHitLabel &l = fPerf->HitLabels()[h.ID()];
-    if( l.fLab[0] == labmax || l.fLab[1] == labmax || l.fLab[2] == labmax 
-       ) lmax++;
+    if ( l.fLab[0] == labmax || l.fLab[1] == labmax || l.fLab[2] == labmax
+       ) lmax++;
   }
   label = labmax;
-  purity = ( (NHits>0) ?double(lmax)/double(NHits) :0 );
-  if( lb ) delete[] lb;
-  if( purity<.9 ) label = -1;
+  purity = ( ( NHits > 0 ) ? double( lmax ) / double( NHits ) : 0 );
+  if ( lb ) delete[] lb;
+  if ( purity < .9 ) label = -1;
   return label;
 }
 
-Bool_t AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, const AliHLTTPCCADisplayTmpHit *vHits, 
-                                   Int_t NHits, Int_t color, Int_t width, Bool_t pPoint )
+bool AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, double Alpha, const AliHLTTPCCADisplayTmpHit *vHits,
+                                      int NHits, int color, int width, bool pPoint )
 {
   // draw track
 
-  if(NHits<2 ) return 0;
+  if ( NHits < 2 ) return 0;
 
   AliHLTTPCCAGBTracker &tracker = *fGB;
-  if( width<0 ) width = 2;
+  if ( width < 0 ) width = 2;
 
-  if(fDrawOnlyRef ){
-    Int_t lab = GetTrackMC(vHits, NHits);
-    if( lab<0 ) return 0;
+  if ( fDrawOnlyRef ) {
+    int lab = GetTrackMC( vHits, NHits );
+    if ( lab < 0 ) return 0;
     AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lab];
-    if(mc.P()<1) return 0;
+    if ( mc.P() < 1 ) return 0;
   }
 
-  if( color < 0 ){
+  if ( color < 0 ) {
     //color = GetColorZ( (vz[0]+vz[mHits-1])/2. );
     //color = GetColorK(t.GetKappa());
-    Int_t lab = GetTrackMC(vHits, NHits);
-    color = GetColor( lab +1 );
-    if( lab>=0 ){
+    int lab = GetTrackMC( vHits, NHits );
+    color = GetColor( lab + 1 );
+    if ( lab >= 0 ) {
       AliHLTTPCCAMCTrack &mc = fPerf->MCTracks()[lab];
-      if( mc.P()>=1. ) color = kRed;   
-    }  
+      if ( mc.P() >= 1. ) color = kRed;
+    }
   }
 
-  if( t.SinPhi()>.999 )  t.SetSinPhi( .999 );
-  else if( t.SinPhi()<-.999 )  t.SetSinPhi( -.999 );
+  if ( t.SinPhi() > .999 )  t.SetSinPhi( .999 );
+  else if ( t.SinPhi() < -.999 )  t.SetSinPhi( -.999 );
 
-  //  Int_t iSlice = fSlice->Param().ISlice();
+  //  int iSlice = fSlice->Param().ISlice();
 
   //sort(vHits, vHits + NHits, AliHLTTPCCADisplayTmpHit::CompareHitZ );
 
-  Double_t vx[2000], vy[2000], vz[2000];
-  Int_t mHits = 0;
+  double vx[2000], vy[2000], vz[2000];
+  int mHits = 0;
 
-  //Int_t oldSlice = -1;
-  Double_t alpha = ( TMath::Abs(Alpha+1)<1.e-4 ) ?fSlice->Param().Alpha() :Alpha;
+  //int oldSlice = -1;
+  double alpha = ( TMath::Abs( Alpha + 1 ) < 1.e-4 ) ? fSlice->Param().Alpha() : Alpha;
   AliHLTTPCCATrackParam tt = t;
 
-  for( Int_t iHit=0; iHit<NHits; iHit++ ){
+  for ( int iHit = 0; iHit < NHits; iHit++ ) {
 
     AliHLTTPCCAGBHit &h = tracker.Hits()[vHits[iHit].ID()];
 
-    Double_t hCos = TMath::Cos( alpha - tracker.Slices()[h.ISlice()].Param().Alpha());
-    Double_t hSin = TMath::Sin( alpha - tracker.Slices()[h.ISlice()].Param().Alpha());
-    Double_t x0=h.X(), y0=h.Y(), z1=h.Z();
-    Double_t x1 = x0*hCos + y0*hSin;
-    Double_t y1 = y0*hCos - x0*hSin;      
+    double hCos = TMath::Cos( alpha - tracker.Slices()[h.ISlice()].Param().Alpha() );
+    double hSin = TMath::Sin( alpha - tracker.Slices()[h.ISlice()].Param().Alpha() );
+    double x0 = h.X(), y0 = h.Y(), z1 = h.Z();
+    double x1 = x0 * hCos + y0 * hSin;
+    double y1 = y0 * hCos - x0 * hSin;
 
     {
-      Double_t dx = x1-tt.X();
-      Double_t dy = y1-tt.Y();
-      if( dx*dx+dy*dy>1. ){
-       Double_t dalpha = TMath::ATan2( dy, dx );
-       if( tt.Rotate(dalpha ) ){
-         alpha+=dalpha;
-         hCos = TMath::Cos( alpha - tracker.Slices()[h.ISlice()].Param().Alpha());
-         hSin = TMath::Sin( alpha - tracker.Slices()[h.ISlice()].Param().Alpha());
-         x1 = x0*hCos + y0*hSin;
-         y1 = y0*hCos - x0*hSin;      
-       }
+      double dx = x1 - tt.X();
+      double dy = y1 - tt.Y();
+      if ( dx*dx + dy*dy > 1. ) {
+        double dalpha = TMath::ATan2( dy, dx );
+        if ( tt.Rotate( dalpha ) ) {
+          alpha += dalpha;
+          hCos = TMath::Cos( alpha - tracker.Slices()[h.ISlice()].Param().Alpha() );
+          hSin = TMath::Sin( alpha - tracker.Slices()[h.ISlice()].Param().Alpha() );
+          x1 = x0 * hCos + y0 * hSin;
+          y1 = y0 * hCos - x0 * hSin;
+        }
       }
     }
     SetSliceTransform( alpha );
 
-    //t.GetDCAPoint( x1, y1, z1, x1, y1, z1 );      
-  std::cout<<"mark 3"<<std::endl;
-    Bool_t ok = tt.TransportToX(x1,.999);
-  std::cout<<"mark 4"<<std::endl;
-  if( 1||ok ){    
+    //t.GetDCAPoint( x1, y1, z1, x1, y1, z1 );
+    std::cout << "mark 3" << std::endl;
+    bool ok = tt.TransportToX( x1, .999 );
+    std::cout << "mark 4" << std::endl;
+    if ( 1 || ok ) {
       x1 = tt.X();
       y1 = tt.Y();
       z1 = tt.Z();
     }
 
-    Slice2View(x1, y1, &x1, &y1 );
+    Slice2View( x1, y1, &x1, &y1 );
     vx[mHits] = x1;
     vy[mHits] = y1;
     vz[mHits] = z1;
     mHits++;
-    for( int j=0; j<0; j++ ){
-      x0=h.X()+j; y0=h.Y(); z1=h.Z();
-      x1 = x0*hCos + y0*hSin;
-      y1 = y0*hCos - x0*hSin;
-      ok = tt.TransportToX(x1,.999);
-      if( ok ){    
-       x1 = tt.X();
-       y1 = tt.Y();
-       z1 = tt.Z();
+    for ( int j = 0; j < 0; j++ ) {
+      x0 = h.X() + j; y0 = h.Y(); z1 = h.Z();
+      x1 = x0 * hCos + y0 * hSin;
+      y1 = y0 * hCos - x0 * hSin;
+      ok = tt.TransportToX( x1, .999 );
+      if ( ok ) {
+        x1 = tt.X();
+        y1 = tt.Y();
+        z1 = tt.Z();
       }
-      
-      Slice2View(x1, y1, &x1, &y1 );
+
+      Slice2View( x1, y1, &x1, &y1 );
       vx[mHits] = x1;
       vy[mHits] = y1;
       vz[mHits] = z1;
       mHits++;
     }
   }
-  if( pPoint ){
-    Double_t x1=t.X(), y1=t.Y(), z1=t.Z();
-    Double_t a = ( TMath::Abs(Alpha+1)<1.e-4 ) ?fSlice->Param().Alpha() :Alpha;
+  if ( pPoint ) {
+    double x1 = t.X(), y1 = t.Y(), z1 = t.Z();
+    double a = ( TMath::Abs( Alpha + 1 ) < 1.e-4 ) ? fSlice->Param().Alpha() : Alpha;
     SetSliceTransform( a );
 
-    Slice2View(x1, y1, &x1, &y1 );
-    Double_t dx = x1 - vx[0];
-    Double_t dy = y1 - vy[0];
+    Slice2View( x1, y1, &x1, &y1 );
+    double dx = x1 - vx[0];
+    double dy = y1 - vy[0];
     //std::cout<<x1<<" "<<y1<<" "<<vx[0]<<" "<<vy[0]<<" "<<dx<<" "<<dy<<std::endl;
-    Double_t d0 = dx*dx + dy*dy;
+    double d0 = dx * dx + dy * dy;
     dx = x1 - vx[mHits-1];
     dy = y1 - vy[mHits-1];
     //std::cout<<x1<<" "<<y1<<" "<<vx[mHits-1]<<" "<<vy[mHits-1]<<" "<<dx<<" "<<dy<<std::endl;
-    Double_t d1 = dx*dx + dy*dy;
+    double d1 = dx * dx + dy * dy;
     //std::cout<<"d0, d1="<<d0<<" "<<d1<<std::endl;
-    if( d1<d0 ){
+    if ( d1 < d0 ) {
       vx[mHits] = x1;
       vy[mHits] = y1;
-      vz[mHits] = z1;   
+      vz[mHits] = z1;
       mHits++;
     } else {
-      for( Int_t i = mHits; i>0; i-- ){
-       vx[i] = vx[i-1];
-       vy[i] = vy[i-1];
-       vz[i] = vz[i-1];
+      for ( int i = mHits; i > 0; i-- ) {
+        vx[i] = vx[i-1];
+        vy[i] = vy[i-1];
+        vz[i] = vz[i-1];
       }
       vx[0] = x1;
       vy[0] = y1;
-      vz[0] = z1;   
+      vz[0] = z1;
       mHits++;
-    }  
+    }
   }
-  
-
-  fLine.SetLineColor(color);
-  fLine.SetLineWidth(width);    
-  fArc.SetFillStyle(0);
-  fArc.SetLineColor(color);    
-  fArc.SetLineWidth(width);        
-  TPolyLine pl;   
-  pl.SetLineColor(color); 
-  pl.SetLineWidth(width);
+
+
+  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(color); 
-  plZ.SetLineWidth(width);
-   
-  fMarker.SetMarkerSize(width/2.);
-  fMarker.SetMarkerColor(color);
+  plZ.SetLineColor( color );
+  plZ.SetLineWidth( width );
+
+  fMarker.SetMarkerSize( width / 2. );
+  fMarker.SetMarkerColor( color );
 
   fYX->cd();
-  pl.DrawPolyLine(mHits,vx,vy);
+  pl.DrawPolyLine( mHits, vx, vy );
   {
-    fMarker.DrawMarker(vx[0],vy[0]);
-    fMarker.DrawMarker(vx[mHits-1],vy[mHits-1]);
+    fMarker.DrawMarker( vx[0], vy[0] );
+    fMarker.DrawMarker( vx[mHits-1], vy[mHits-1] );
   }
   fZX->cd();
-  plZ.DrawPolyLine(mHits,vz,vy);
-  fMarker.DrawMarker(vz[0],vy[0]);
-  fMarker.DrawMarker(vz[mHits-1],vy[mHits-1]);
-  
-  fLine.SetLineWidth(1);   
+  plZ.DrawPolyLine( mHits, vz, vy );
+  fMarker.DrawMarker( vz[0], vy[0] );
+  fMarker.DrawMarker( vz[mHits-1], vy[mHits-1] );
+
+  fLine.SetLineWidth( 1 );
   return 1;
 }
 
 
-Bool_t AliHLTTPCCADisplay::DrawTracklet( AliHLTTPCCATrackParam &track, const Int_t *hitstore, Int_t color, Int_t width, Bool_t pPoint )
+bool AliHLTTPCCADisplay::DrawTracklet( AliHLTTPCCATrackParam &track, const int *hitstore, int color, int width, bool pPoint )
 {
   // draw tracklet
   AliHLTTPCCAGBTracker &tracker = *fGB;
   AliHLTTPCCADisplayTmpHit vHits[200];
-  Int_t nHits = 0; 
-  for( Int_t iRow=0; iRow<fSlice->Param().NRows(); iRow++ ){
-    Int_t iHit = hitstore[iRow];
-    if( iHit<0 ) continue;    
-    const AliHLTTPCCARow &row = fSlice->Row(iRow);
-    Int_t id = fSlice->HitInputIDs()[row.FirstHit()+iHit];
-    Int_t iGBHit = tracker.FirstSliceHit()[fSlice->Param().ISlice()]+id;
+  int nHits = 0;
+  for ( int iRow = 0; iRow < fSlice->Param().NRows(); iRow++ ) {
+    int iHit = hitstore[iRow];
+    if ( iHit < 0 ) continue;
+    const AliHLTTPCCARow &row = fSlice->Row( iRow );
+    int id = fSlice->HitInputIDs()[row.FirstHit()+iHit];
+    int iGBHit = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + id;
     AliHLTTPCCAGBHit &h = tracker.Hits()[iGBHit];
     vHits[nHits].SetID( iGBHit );
     vHits[nHits].SetS( 0 );
     vHits[nHits].SetZ( h.Z() );
     nHits++;
   }
-  return DrawTrack( track, -1, vHits, nHits, color,width,pPoint );
+  return DrawTrack( track, -1, vHits, nHits, color, width, pPoint );
 }
 
 
-void AliHLTTPCCADisplay::DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t alpha, Int_t itr, Int_t color, Int_t width )
+void AliHLTTPCCADisplay::DrawSliceOutTrack( AliHLTTPCCATrackParam &t, double alpha, int itr, int color, int width )
 {
   // draw slice track
-  
+
   AliHLTTPCCAOutTrack &track = fSlice->OutTracks()[itr];
-  if( track.NHits()<2 ) return;
+  if ( track.NHits() < 2 ) return;
 
   AliHLTTPCCAGBTracker &tracker = *fGB;
   AliHLTTPCCADisplayTmpHit vHits[200];
 
-  for( Int_t ih=0; ih<track.NHits(); ih++ ){
-    Int_t id = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + fSlice->OutTrackHits()[track.FirstHitRef()+ih];  
+  for ( int ih = 0; ih < track.NHits(); ih++ ) {
+    int id = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + fSlice->OutTrackHits()[track.FirstHitRef()+ih];
     AliHLTTPCCAGBHit &h = tracker.Hits()[id];
     vHits[ih].SetID( id );
     vHits[ih].SetS( 0 );
@@ -881,18 +883,18 @@ void AliHLTTPCCADisplay::DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t a
   DrawTrack( t, alpha, vHits, track.NHits(), color, width, 1 );
 }
 
-void AliHLTTPCCADisplay::DrawSliceOutTrack( Int_t itr, Int_t color, Int_t width )
+void AliHLTTPCCADisplay::DrawSliceOutTrack( int itr, int color, int width )
 {
   // draw slice track
-  
+
   AliHLTTPCCAOutTrack &track = fSlice->OutTracks()[itr];
-  if( track.NHits()<2 ) return;
+  if ( track.NHits() < 2 ) return;
 
   AliHLTTPCCAGBTracker &tracker = *fGB;
   AliHLTTPCCADisplayTmpHit vHits[200];
 
-  for( Int_t ih=0; ih<track.NHits(); ih++ ){
-    Int_t id = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + fSlice->OutTrackHits()[track.FirstHitRef()+ih];  
+  for ( int ih = 0; ih < track.NHits(); ih++ ) {
+    int id = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + fSlice->OutTrackHits()[track.FirstHitRef()+ih];
     AliHLTTPCCAGBHit &h = tracker.Hits()[id];
     vHits[ih].SetID( id );
     vHits[ih].SetS( 0 );
@@ -903,44 +905,44 @@ void AliHLTTPCCADisplay::DrawSliceOutTrack( Int_t itr, Int_t color, Int_t width
 }
 
 
-void AliHLTTPCCADisplay::DrawSliceTrack( Int_t itr, Int_t color )
+void AliHLTTPCCADisplay::DrawSliceTrack( int itr, int color )
 {
   // draw slice track
-  
+
   AliHLTTPCCATrack &track = fSlice->Tracks()[itr];
-  if( track.NHits()<2 ) return;
+  if ( track.NHits() < 2 ) return;
 
   AliHLTTPCCAGBTracker &tracker = *fGB;
-  AliHLTTPCCADisplayTmpHit vHits[200];  
-  for( Int_t ith=0; ith<track.NHits(); ith++ ){
-    Int_t ic = (fSlice->TrackHits()[track.FirstHitID()+ith]);
-    const AliHLTTPCCARow &row = fSlice->ID2Row(ic);
-    Int_t ih = fSlice->ID2IHit(ic);
+  AliHLTTPCCADisplayTmpHit vHits[200];
+  for ( int ith = 0; ith < track.NHits(); ith++ ) {
+    int ic = ( fSlice->TrackHits()[track.FirstHitID()+ith] );
+    const AliHLTTPCCARow &row = fSlice->ID2Row( ic );
+    int ih = fSlice->ID2IHit( ic );
     int id = fSlice->HitInputIDs()[row.FirstHit()+ih];
-    Int_t gbID = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + id;
+    int gbID = tracker.FirstSliceHit()[fSlice->Param().ISlice()] + id;
     AliHLTTPCCAGBHit &h = tracker.Hits()[gbID];
     vHits[ith].SetID( gbID );
     vHits[ith].SetS( 0 );
     vHits[ith].SetZ( h.Z() );
   }
 
-  DrawTrack( track.Param(), -1, vHits, track.NHits(), color,-1 );
+  DrawTrack( track.Param(), -1, vHits, track.NHits(), color, -1 );
   //track.Param().Print();
 }
 
 
-void AliHLTTPCCADisplay::DrawGBTrack( Int_t itr, Int_t color, Int_t width )
+void AliHLTTPCCADisplay::DrawGBTrack( int itr, int color, int width )
 {
   // draw global track
 
   AliHLTTPCCAGBTracker &tracker = *fGB;
   AliHLTTPCCADisplayTmpHit vHits[1000];
-  
+
   AliHLTTPCCAGBTrack &track = tracker.Tracks()[itr];
-  if( track.NHits()<2 ) return;
+  if ( track.NHits() < 2 ) return;
 
-  for( Int_t ih=0; ih<track.NHits(); ih++ ){
-    Int_t i = tracker.TrackHits()[ track.FirstHitRef() + ih];
+  for ( int ih = 0; ih < track.NHits(); ih++ ) {
+    int i = tracker.TrackHits()[ track.FirstHitRef() + ih];
     AliHLTTPCCAGBHit &h = tracker.Hits()[i];
     vHits[ih].SetID( i );
     vHits[ih].SetS( 0 );
@@ -951,142 +953,142 @@ void AliHLTTPCCADisplay::DrawGBTrack( Int_t itr, Int_t color, Int_t width )
 }
 
 
-void AliHLTTPCCADisplay::DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color )
+void AliHLTTPCCADisplay::DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, int itr, int color )
 {
   // draw global track
-  
+
   AliHLTTPCCAGBTrack &track = tracker.Tracks()[itr];
-  if( track.NHits()<2 ) return;
-  Int_t width = 1;
+  if ( track.NHits() < 2 ) return;
+  int 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]);
+
+  for ( int ih = 0; ih < track.NHits(); ih++ ) {
+    int i = tracker.TrackHits()[ track.FirstHitRef() + ih];
+    AliHLTTPCCAGBHit *h = &( tracker.Hits()[i] );
     vHits[ih].SetID( i );
     vHits[ih].SetS( 0 );
     vHits[ih].SetZ( h->Z() );
-  }  
+  }
 
-  sort(vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
-  Int_t colorY = color;
+  sort( vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
+  int colorY = color;
   {
     AliHLTTPCCAGBHit &h1 = tracker.Hits()[ vHits[0].ID()];
     AliHLTTPCCAGBHit &h2 = tracker.Hits()[ vHits[track.NHits()-1].ID()];
-    if( color<0 ) color = GetColorZ( (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.GetQPt());
+    if ( color < 0 ) color = GetColorZ( ( h1.Z() + h2.Z() ) / 2. );
+    double 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.GetQPt() );
   }
 
-  fMarker.SetMarkerColor(color);//kBlue);
-  fMarker.SetMarkerSize(1.);
-  fLine.SetLineColor(color);
-  fLine.SetLineWidth(width);    
-  fArc.SetFillStyle(0);
-  fArc.SetLineColor(color);    
-  fArc.SetLineWidth(width);        
+  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);
+  pl.SetLineColor( colorY );
+  pl.SetLineWidth( width );
 
-  Int_t oldSlice = -1;
-  Double_t alpha = track.Alpha();
+  int oldSlice = -1;
+  double 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;
-    
-    if( h1.ISlice() != oldSlice ){
-      t.Rotate( tracker.Slices()[h1.ISlice()].Param().Alpha() - alpha);
+    float x1, y1, z1, x2, y2, z2;
+    double 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]) );
+      SetSliceTransform( &( tracker.Slices()[oldSlice] ) );
     }
-    t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1, fSlice->Param().Bz()  );  
-    Slice2View(x1, y1, &vx1, &vy1 );
+    t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1, fSlice->Param().Bz()  );
+    Slice2View( x1, y1, &vx1, &vy1 );
 
-    if( h2.ISlice() != oldSlice ){
-      t.Rotate( tracker.Slices()[h2.ISlice()].Param().Alpha() - alpha);
+    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]) );
+      SetSliceTransform( &( tracker.Slices()[oldSlice] ) );
     }
     t.GetDCAPoint( h2.X(), h2.Y(), h2.Z(), x2, y2, z2, fSlice->Param().Bz()  );
-    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( fSlice->Param().Bz() );
-    Double_t ex = t.GetCosPhi();
-    Double_t ey = sinPhi;
-    if( TMath::Abs(k)>1.e-4 ){
-      
+    Slice2View( x2, y2, &vx2, &vy2 );
+
+    double x0 = t.GetX();
+    double y0 = t.GetY();
+    double sinPhi = t.GetSinPhi();
+    double k = t.GetKappa( fSlice->Param().Bz() );
+    double ex = t.GetCosPhi();
+    double 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;
+      double r = 1 / TMath::Abs( k );
+      double xc = x0 - ey * ( 1 / k );
+      double yc = y0 + ex * ( 1 / k );
+
+      double 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;    
+
+      double a1 = TMath::ATan2( vy1 - vy, vx1 - vx ) / TMath::Pi() * 180.;
+      double 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 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, a1, a2, "only" );
       //fArc.DrawArc(vx,vy,r, 0,360,"only");
-   } else {
+    } else {
       fYX->cd();
-      fLine.DrawLine(vx1,vy1, vx2, vy2 );
+      fLine.DrawLine( vx1, vy1, vx2, vy2 );
     }
   }
 
   // ZX
-  Double_t py[track.NHits()], pz[track.NHits()];
+  double py[track.NHits()], pz[track.NHits()];
 
-  for( Int_t iHit=0; iHit<track.NHits(); iHit++ ){
+  for ( int 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);
+    float x1, y1, z1;
+    double 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]) );
+      SetSliceTransform( &( tracker.Slices()[oldSlice] ) );
     }
-    t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1, fSlice->Param().Bz()  );  
-    Slice2View(x1, y1, &vx1, &vy1 );
+    t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1, fSlice->Param().Bz()  );
+    Slice2View( x1, y1, &vx1, &vy1 );
     py[iHit] = vy1;
     pz[iHit] = z1;
   }
 
 
   fZX->cd();
-  pl.DrawPolyLine(track.NHits(),pz,py);    
-  
-  fLine.SetLineWidth(1);     
-  delete[] vHits;  
+  pl.DrawPolyLine( track.NHits(), pz, py );
+
+  fLine.SetLineWidth( 1 );
+  delete[] vHits;
 }
 
 
@@ -1094,30 +1096,30 @@ void AliHLTTPCCADisplay::DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t i
 
 
 #ifdef XXXX
 
 
 
-void AliHLTTPCCADisplay::DrawMergedHit( Int_t iRow, Int_t iHit, Int_t color )
+
+void AliHLTTPCCADisplay::DrawMergedHit( int iRow, int iHit, int color )
 {
   // connect two cells on display
 
 #ifdef XXX
-  
-  const AliHLTTPCCARow &row = fSlice->Row(iRow);
+
+  const AliHLTTPCCARow &row = fSlice->Row( iRow );
   AliHLTTPCCAHit &h = row.Hits()[iHit];
   AliHLTTPCCAHit &hyz = row.HitsYZ()[iHit];
 
-  Double_t x = row.X();
-  Double_t y = hyz.Y();
-  Double_t z = hyz.Z();
-  Double_t x1 = x, x2 = x;
-  Double_t y1 = y, y2 = y;
-  Double_t z1 = z, z2 = z;
-  Int_t iRow1 = iRow, iHit1 = iHit;
-  Int_t iRow2 = iRow, iHit2 = iHit;
+  double x = row.X();
+  double y = hyz.Y();
+  double z = hyz.Z();
+  double x1 = x, x2 = x;
+  double y1 = y, y2 = y;
+  double z1 = z, z2 = z;
+  int iRow1 = iRow, iHit1 = iHit;
+  int iRow2 = iRow, iHit2 = iHit;
 
-  if( fSlice->HitLinksDown()[]>=0 ){    
+  if ( fSlice->HitLinksDown()[] >= 0 ) {
     iRow1 = iRow - 1;
     iHit1 = h.LinkDown();
     AliHLTTPCCARow &row1 = fSlice->Rows()[iRow1];
@@ -1126,8 +1128,8 @@ void AliHLTTPCCADisplay::DrawMergedHit( Int_t iRow, Int_t iHit, Int_t color )
     y1 = h1.Y();
     z1 = h1.Z();
   }
-  if( h.LinkUp()>=0 ){    
-    iRow2 = iRow+1;
+  if ( h.LinkUp() >= 0 ) {
+    iRow2 = iRow + 1;
     iHit2 = h.LinkUp();
     AliHLTTPCCARow &row2 = fSlice->Rows()[iRow2];
     AliHLTTPCCAHitYZ &h2 = row2.HitsYZ()[iHit2];
@@ -1135,52 +1137,52 @@ void AliHLTTPCCADisplay::DrawMergedHit( Int_t iRow, Int_t iHit, Int_t color )
     y2 = h2.Y();
     z2 = h2.Z();
   }
-  if( color<0 ) color = GetColorZ( (z+z1+z2)/3. );
+  if ( color < 0 ) color = GetColorZ( ( z + z1 + z2 ) / 3. );
 
 
-  Slice2View(x,y, &x, &y );
-  Slice2View(x1,y1, &x1, &y1 );
-  Slice2View(x2,y2, &x2, &y2 );
+  Slice2View( x, y, &x, &y );
+  Slice2View( x1, y1, &x1, &y1 );
+  Slice2View( x2, y2, &x2, &y2 );
 
-  Double_t lx[] = { x1, x, x2 };
-  Double_t ly[] = { y1, y, y2 };
-  Double_t lz[] = { z1, z, z2 };
+  double lx[] = { x1, x, x2 };
+  double ly[] = { y1, y, y2 };
+  double lz[] = { z1, z, z2 };
 
-  fPLine.SetLineColor(color);    
-  fPLine.SetLineWidth(1);        
+  fPLine.SetLineColor( color );
+  fPLine.SetLineWidth( 1 );
   //fPLine.SetFillColor(color);
-  fPLine.SetFillStyle(-1);
+  fPLine.SetFillStyle( -1 );
+
   fYX->cd();
-  fPLine.DrawPolyLine(3, lx, ly );
+  fPLine.DrawPolyLine( 3, lx, ly );
   fZX->cd();
-  fPLine.DrawPolyLine(3, lz, ly );   
+  fPLine.DrawPolyLine( 3, lz, ly );
   DrawHit( iRow, iHit, color );
   DrawHit( iRow1, iHit1, color );
-  DrawHit( iRow2, iHit2, color ); 
+  DrawHit( iRow2, iHit2, color );
 #endif
 }
 
 
-void AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrack &track, Int_t color, Bool_t DrawHits )
+void AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrack &track, int color, bool DrawHits )
 {
   // draw track
-  
-  if( track.NHits()<2 ) return;
-  Int_t width = 2;
+
+  if ( track.NHits() < 2 ) return;
+  int width = 2;
 
   AliHLTTPCCADisplayTmpHit *vHits = new AliHLTTPCCADisplayTmpHit[track.NHits()];
   AliHLTTPCCATrackParam &t = track.Param();
 
-  Int_t iID = track.FirstHitID();
-  Int_t nhits = 0;
-  { 
-    Int_t iHit = 0;
-    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);
-      vHits[iHit].ID() = i;    
+  int iID = track.FirstHitID();
+  int nhits = 0;
+  {
+    int iHit = 0;
+    for ( int ih = 0; ih < track.NHits(); ih++ ) {
+      int i = fSlice->TrackHits()[iID];
+      AliHLTTPCCAHit *h = &( fSlice->ID2Hit( i ) );
+      AliHLTTPCCARow &row = fSlice->ID2Row( i );
+      vHits[iHit].ID() = i;
       vHits[iHit].S() = t.GetS( row.X(), h->Y() );
       vHits[iHit].Z() = h->Z();
       iHit++;
@@ -1188,157 +1190,156 @@ void AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrack &track, Int_t color, Bool_t
       iID++;
     }
   }
-  sort(vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
+  sort( vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
   //cout<<"Draw track, nhits = "<<nhits<<endl;
   {
-    AliHLTTPCCAHit &c1 = fSlice->ID2Hit(vHits[0].ID());
-    AliHLTTPCCAHit &c2 = fSlice->ID2Hit(vHits[track.NHits()-1].ID());
-    if( color<0 ) color = GetColorZ( (c1.Z()+c2.Z())/2. );
+    AliHLTTPCCAHit &c1 = fSlice->ID2Hit( vHits[0].ID() );
+    AliHLTTPCCAHit &c2 = fSlice->ID2Hit( vHits[track.NHits()-1].ID() );
+    if ( color < 0 ) color = GetColorZ( ( c1.Z() + c2.Z() ) / 2. );
   }
-  
-  fMarker.SetMarkerColor(color);//kBlue);
-  fMarker.SetMarkerSize(1.);
+
+  fMarker.SetMarkerColor( color );//kBlue);
+  fMarker.SetMarkerSize( 1. );
   /*
-  for( Int_t i=0; i<3; i++){    
-    AliHLTTPCCAHit &c1 = fSlice->ID2Hit(track.HitID()[i]);    
+  for( int i=0; i<3; i++){
+    AliHLTTPCCAHit &c1 = fSlice->ID2Hit(track.HitID()[i]);
     AliHLTTPCCARow &row1 = fSlice->ID2Row(track.HitID()[i]);
-    Double_t vx1, vy1;
-    Slice2View(row1.X(), c1.Y(), &vx1, &vy1 ); 
+    double vx1, vy1;
+    Slice2View(row1.X(), c1.Y(), &vx1, &vy1 );
     fYX->cd();
     fMarker.DrawMarker(vx1,vy1);
     fZX->cd();
     fMarker.DrawMarker(c1.Z(),vy1);
   }
   */
-  
+
   //DrawTrackletPoint( fSlice->ID2Point(track.PointID()[0]).Param(), kBlack);//color );
   //DrawTrackletPoint( fSlice->ID2Point(track.PointID()[1]).Param(), kBlack);//color );
   //cout<<"DrawTrack end points x = "<<fSlice->ID2Point(track.PointID()[0]).Param().GetX()<<" "<<fSlice->ID2Point(track.PointID()[1]).Param().GetX()<<endl;
-  for( Int_t iHit=0; iHit<track.NHits()-1; iHit++ )
-  {
-    AliHLTTPCCAHit &c1 = fSlice->ID2Hit(vHits[iHit].ID());
-    AliHLTTPCCAHit &c2 = fSlice->ID2Hit(vHits[iHit+1].ID());
-    AliHLTTPCCARow &row1 = fSlice->ID2Row(vHits[iHit].ID());
-    AliHLTTPCCARow &row2 = fSlice->ID2Row(vHits[iHit+1].ID());
-    Float_t x1, y1, z1, x2, y2, z2;    
-    t.GetDCAPoint( row1.X(), c1.Y(), c1.Z(), x1, y1, z1,fSlice->Param().Bz()  );
-    t.GetDCAPoint( row2.X(), c2.Y(), c2.Z(), x2, y2, z2,fSlice->Param().Bz()  );
+  for ( int iHit = 0; iHit < track.NHits() - 1; iHit++ ) {
+    AliHLTTPCCAHit &c1 = fSlice->ID2Hit( vHits[iHit].ID() );
+    AliHLTTPCCAHit &c2 = fSlice->ID2Hit( vHits[iHit+1].ID() );
+    AliHLTTPCCARow &row1 = fSlice->ID2Row( vHits[iHit].ID() );
+    AliHLTTPCCARow &row2 = fSlice->ID2Row( vHits[iHit+1].ID() );
+    float x1, y1, z1, x2, y2, z2;
+    t.GetDCAPoint( row1.X(), c1.Y(), c1.Z(), x1, y1, z1, fSlice->Param().Bz()  );
+    t.GetDCAPoint( row2.X(), c2.Y(), c2.Z(), x2, y2, z2, fSlice->Param().Bz()  );
 
     //if( color<0 ) color = GetColorZ( (z1+z2)/2. );
-    Double_t vx1, vy1, vx2, vy2;
-    Slice2View(x1, y1, &vx1, &vy1 );
-    Slice2View(x2, y2, &vx2, &vy2 );
-    
+    double vx1, vy1, vx2, vy2;
+    Slice2View( x1, y1, &vx1, &vy1 );
+    Slice2View( x2, y2, &vx2, &vy2 );
+
     fLine.SetLineColor( color );
     fLine.SetLineWidth( width );
-    
-    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 ){
-
-      fArc.SetFillStyle(0);
-      fArc.SetLineColor(color);    
-      fArc.SetLineWidth(width);        
-      
+
+    double x0 = t.GetX();
+    double y0 = t.GetY();
+    double sinPhi = t.GetSinPhi();
+    double k = t.GetKappa();
+    double ex = t.GetCosPhi();
+    double ey = sinPhi;
+
+    if ( TMath::Abs( k ) > 1.e-4 ) {
+
+      fArc.SetFillStyle( 0 );
+      fArc.SetLineColor( color );
+      fArc.SetLineWidth( width );
+
       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;
+      double r = 1 / TMath::Abs( k );
+      double xc = x0 - ey * ( 1 / k );
+      double yc = y0 + ex * ( 1 / k );
+
+      double 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;    
+
+      double a1 = TMath::ATan2( vy1 - vy, vx1 - vx ) / TMath::Pi() * 180.;
+      double 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 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, a1, a2, "only" );
       //fArc.DrawArc(vx,vy,r, 0,360,"only");
-   } else {
+    } else {
       fYX->cd();
-      fLine.DrawLine(vx1,vy1, vx2, vy2 );
+      fLine.DrawLine( vx1, vy1, vx2, vy2 );
     }
   }
 
-  for( Int_t iHit=0; iHit<track.NHits()-1; iHit++ ){
-    AliHLTTPCCAHit &c1 = fSlice->ID2Hit(vHits[iHit].ID());
-    AliHLTTPCCAHit &c2 = fSlice->ID2Hit(vHits[iHit+1].ID());
-    AliHLTTPCCARow &row1 = fSlice->ID2Row(vHits[iHit].ID());
-    AliHLTTPCCARow &row2 = fSlice->ID2Row(vHits[iHit+1].ID());
-    
+  for ( int iHit = 0; iHit < track.NHits() - 1; iHit++ ) {
+    AliHLTTPCCAHit &c1 = fSlice->ID2Hit( vHits[iHit].ID() );
+    AliHLTTPCCAHit &c2 = fSlice->ID2Hit( vHits[iHit+1].ID() );
+    AliHLTTPCCARow &row1 = fSlice->ID2Row( vHits[iHit].ID() );
+    AliHLTTPCCARow &row2 = fSlice->ID2Row( vHits[iHit+1].ID() );
+
     //if( DrawHits ) ConnectHits( fSlice->ID2IRow(vHits[iHit].ID()),c1,
     //fSlice->ID2IRow(vHits[iHit+1].ID()),c2, color );
-    Float_t x1, y1, z1, x2, y2, z2;
-    t.GetDCAPoint( row1.X(), c1.Y(), c1.Z(), x1, y1, z1,fSlice->Param().Bz()  );
-    t.GetDCAPoint( row2.X(), c2.Y(), c2.Z(), x2, y2, z2,fSlice->Param().Bz()  );
-
-    Double_t vx1, vy1, vx2, vy2;
-    Slice2View(x1, y1, &vx1, &vy1 );
-    Slice2View(x2, y2, &vx2, &vy2 );
-    
-    fLine.SetLineColor(color);
-    fLine.SetLineWidth(width);    
-    
+    float x1, y1, z1, x2, y2, z2;
+    t.GetDCAPoint( row1.X(), c1.Y(), c1.Z(), x1, y1, z1, fSlice->Param().Bz()  );
+    t.GetDCAPoint( row2.X(), c2.Y(), c2.Z(), x2, y2, z2, fSlice->Param().Bz()  );
+
+    double vx1, vy1, vx2, vy2;
+    Slice2View( x1, y1, &vx1, &vy1 );
+    Slice2View( x2, y2, &vx2, &vy2 );
+
+    fLine.SetLineColor( color );
+    fLine.SetLineWidth( width );
+
     fZX->cd();
-    fLine.DrawLine(z1,vy1, z2, vy2 ); 
+    fLine.DrawLine( z1, vy1, z2, vy2 );
   }
-  fLine.SetLineWidth(1);     
-  delete[] vHits;  
+  fLine.SetLineWidth( 1 );
+  delete[] vHits;
 }
 
 
-void AliHLTTPCCADisplay::DrawTrackletPoint( AliHLTTPCCATrackParam &t, Int_t color )
+void AliHLTTPCCADisplay::DrawTrackletPoint( AliHLTTPCCATrackParam &t, int color )
 {
   // draw tracklet point
 
-  Double_t x = t.GetX();
-  Double_t y = t.GetY();
-  Double_t sinPhi = t.GetSinPhi();
-  Double_t z = t.GetZ();
-  Double_t dzds = t.GetDzDs();
-  Double_t ex = t.GetCosPhi();
-  Double_t ey = sinPhi;
-
-  Int_t width = 1;
-
-  if( color<0 ) color = GetColorZ( t.GetZ() );
-    
-  fMarker.SetMarkerColor(color);
-  fMarker.SetMarkerSize(.5);
-  fLine.SetLineWidth(width);  
-  fLine.SetLineColor(color);
-
-  Double_t vx, vy, vex, vey, vdx, vdy;
-  Double_t dz = TMath::Sqrt(t.GetErr2Z());
-  Slice2View( x, y, &vx, &vy ); 
-  Slice2View( ex, ey, &vex, &vey ); 
-  Slice2View( 0, TMath::Sqrt(t.GetErr2Y())*3.5, &vdx, &vdy);
-  Double_t d = TMath::Sqrt(vex*vex+vey*vey);
-  vex/=d;
-  vey/=d;
+  double x = t.GetX();
+  double y = t.GetY();
+  double sinPhi = t.GetSinPhi();
+  double z = t.GetZ();
+  double dzds = t.GetDzDs();
+  double ex = t.GetCosPhi();
+  double ey = sinPhi;
+
+  int width = 1;
+
+  if ( color < 0 ) color = GetColorZ( t.GetZ() );
+
+  fMarker.SetMarkerColor( color );
+  fMarker.SetMarkerSize( .5 );
+  fLine.SetLineWidth( width );
+  fLine.SetLineColor( color );
+
+  double vx, vy, vex, vey, vdx, vdy;
+  double dz = TMath::Sqrt( t.GetErr2Z() );
+  Slice2View( x, y, &vx, &vy );
+  Slice2View( ex, ey, &vex, &vey );
+  Slice2View( 0, TMath::Sqrt( t.GetErr2Y() )*3.5, &vdx, &vdy );
+  double d = TMath::Sqrt( vex * vex + vey * vey );
+  vex /= d;
+  vey /= d;
   fYX->cd();
-  fMarker.DrawMarker(vx,vy);
-  fLine.DrawLine(vx,vy,vx+vex*4, vy+vey*4);
-  fLine.DrawLine(vx-vdx,vy-vdy, vx+vdx, vy+vdy );
+  fMarker.DrawMarker( vx, vy );
+  fLine.DrawLine( vx, vy, vx + vex*4, vy + vey*4 );
+  fLine.DrawLine( vx - vdx, vy - vdy, vx + vdx, vy + vdy );
   fZX->cd();
-  fMarker.DrawMarker(z,vy);
-  fLine.DrawLine(z,vy,z+dzds*4, vy+vey*4);
-  fLine.DrawLine(z-3.5*dz,vy-vdy, z+3.5*dz, vy+vdy ); 
-  fLine.SetLineWidth(1);
+  fMarker.DrawMarker( z, vy );
+  fLine.DrawLine( z, vy, z + dzds*4, vy + vey*4 );
+  fLine.DrawLine( z - 3.5*dz, vy - vdy, z + 3.5*dz, vy + vdy );
+  fLine.SetLineWidth( 1 );
 }
 #endif //XXXX
index 75fa0d8..4b9e740 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
 //  *************************************************************************
-//  This file is property of and copyright by the ALICE HLT Project         * 
+//  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                                *
 //                                                                          *
@@ -36,92 +36,92 @@ class TCanvas;
 class AliHLTTPCCADisplay
 {
 
- public:
-  
-  class AliHLTTPCCADisplayTmpHit;
-
-  static AliHLTTPCCADisplay &Instance();
-  
-  AliHLTTPCCADisplay();
-  AliHLTTPCCADisplay( const AliHLTTPCCADisplay& );
-  const AliHLTTPCCADisplay& operator=(const AliHLTTPCCADisplay&) const ;
-
-  virtual ~AliHLTTPCCADisplay();
-
-  void Init();
-  void Update();
-  void ClearView();
-  void Ask();
-  void SetSliceView();
-  void SetTPCView();
-  void SetCurrentSlice( AliHLTTPCCATracker *slice ); 
-  void SetGB( AliHLTTPCCAGBTracker * const GBTracker );   
-  void Set2Slices( AliHLTTPCCATracker * const slice );
-
-  Int_t GetColor( Int_t i ) const;
-  Int_t GetColorZ( Double_t z ) const ;
-  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 ;
-  Int_t GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, Int_t NHits );
-
-  void DrawTPC();
-  void DrawSlice( AliHLTTPCCATracker *slice, Bool_t DrawRows=0 ); 
-  void DrawSliceOutTrack( Int_t itr, Int_t color=-1, Int_t width = -1  );
-  void DrawSliceOutTrack( AliHLTTPCCATrackParam &t, Double_t Alpha, Int_t itr, Int_t color=-1, Int_t width = -1  );
-  void DrawSliceTrack( Int_t itr, Int_t color=-1);
-  Bool_t DrawTrack( AliHLTTPCCATrackParam t, Double_t Alpha, const AliHLTTPCCADisplayTmpHit *vHits, 
-                   Int_t NHits, Int_t color=-1, Int_t width=-1, Bool_t pPoint=0 );
-
-  void DrawGBTrack( Int_t itr, Int_t color=-1, Int_t width=-1 );
-  void DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, Int_t itr, Int_t color=-1 );
-  Bool_t DrawTracklet( AliHLTTPCCATrackParam &track, const Int_t *hitstore, Int_t color=-1, Int_t width=-1, Bool_t pPoint=0 );
-  void DrawGBHit( AliHLTTPCCAGBTracker &tracker, Int_t iHit, Int_t color=-1, Size_t width =-1 );
-  void DrawGBHits( AliHLTTPCCAGBTracker &tracker, Int_t color=-1, Size_t width =-1 );
-
-  void DrawSliceHit( Int_t iRow,Int_t iHit, Int_t color=-1, Size_t width=-1 );
-  void DrawSliceHits(Int_t color=-1, Size_t width=-1 );
-  void DrawSliceLinks(Int_t colorUp=-1, Int_t colorDn=-1,Int_t width=-1 );
-  void DrawSliceLink(Int_t iRow, Int_t iHit, Int_t colorUp=-1, Int_t colorDn=-1,Int_t width=-1 );
+  public:
+
+    class AliHLTTPCCADisplayTmpHit;
+
+    static AliHLTTPCCADisplay &Instance();
+
+    AliHLTTPCCADisplay();
+    AliHLTTPCCADisplay( const AliHLTTPCCADisplay& );
+    const AliHLTTPCCADisplay& operator=( const AliHLTTPCCADisplay& ) const ;
+
+    virtual ~AliHLTTPCCADisplay();
+
+    void Init();
+    void Update();
+    void ClearView();
+    void Ask();
+    void SetSliceView();
+    void SetTPCView();
+    void SetCurrentSlice( AliHLTTPCCATracker *slice );
+    void SetGB( AliHLTTPCCAGBTracker * const GBTracker );
+    void Set2Slices( AliHLTTPCCATracker * const slice );
+
+    int GetColor( int i ) const;
+    int GetColorZ( double z ) const ;
+    int GetColorY( double y ) const ;
+    int GetColorK( double k ) const ;
+    void Global2View( double x, double y, double *xv, double *yv ) const ;
+    void Slice2View( double x, double y, double *xv, double *yv ) const ;
+    int GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, int NHits );
+
+    void DrawTPC();
+    void DrawSlice( AliHLTTPCCATracker *slice, bool DrawRows = 0 );
+    void DrawSliceOutTrack( int itr, int color = -1, int width = -1  );
+    void DrawSliceOutTrack( AliHLTTPCCATrackParam &t, double Alpha, int itr, int color = -1, int width = -1  );
+    void DrawSliceTrack( int itr, int color = -1 );
+    bool DrawTrack( AliHLTTPCCATrackParam t, double Alpha, const AliHLTTPCCADisplayTmpHit *vHits,
+                      int NHits, int color = -1, int width = -1, bool pPoint = 0 );
+
+    void DrawGBTrack( int itr, int color = -1, int width = -1 );
+    void DrawGBTrackFast( AliHLTTPCCAGBTracker &tracker, int itr, int color = -1 );
+    bool DrawTracklet( AliHLTTPCCATrackParam &track, const int *hitstore, int color = -1, int width = -1, bool pPoint = 0 );
+
+    void DrawGBHit( AliHLTTPCCAGBTracker &tracker, int iHit, int color = -1, Size_t width = -1 );
+    void DrawGBHits( AliHLTTPCCAGBTracker &tracker, int color = -1, Size_t width = -1 );
+
+    void DrawSliceHit( int iRow, int iHit, int color = -1, Size_t width = -1 );
+    void DrawSliceHits( int color = -1, Size_t width = -1 );
+    void DrawSliceLinks( int colorUp = -1, int colorDn = -1, int width = -1 );
+    void DrawSliceLink( int iRow, int iHit, int colorUp = -1, int colorDn = -1, int width = -1 );
 
 #ifdef XXXX
 
-  void DrawMergedHit( Int_t iRow, Int_t iHit, Int_t color=-1 );
+    void DrawMergedHit( int iRow, int iHit, int color = -1 );
 
-  void DrawTrack( AliHLTTPCCATrack &track, Int_t color=-1, Bool_t DrawCells=1 );
-  void DrawTrackletPoint( AliHLTTPCCATrackParam &t, Int_t color=-1 );
+    void DrawTrack( AliHLTTPCCATrack &track, int color = -1, bool DrawCells = 1 );
+    void DrawTrackletPoint( AliHLTTPCCATrackParam &t, int color = -1 );
 #endif // XXXX
 
-  void SetSliceTransform( Double_t alpha );
+    void SetSliceTransform( double alpha );
 
-  void SetSliceTransform( AliHLTTPCCATracker *slice );
+    void SetSliceTransform( AliHLTTPCCATracker *slice );
 
-  TCanvas *CanvasYX() const { return fYX; }
-  TCanvas *CanvasZX() const { return fZX; }
+    TCanvas *CanvasYX() const { return fYX; }
+    TCanvas *CanvasZX() const { return fZX; }
 
- protected:
+  protected:
 
-  TCanvas *fYX, *fZX;               // two views
-  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
-  AliHLTTPCCAGBTracker *fGB;      // the global tracker
-  AliHLTTPCCAPerformance *fPerf; // Performance class (mc labels etc)
-  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
+    TCanvas *fYX, *fZX;               // two views
+    bool fAsk;                      // flag to ask for the pressing key
+    bool fSliceView;               // switch between slice/TPC zoom
+    AliHLTTPCCATracker *fSlice;      // current CA tracker, includes slice geometry
+    AliHLTTPCCAGBTracker *fGB;      // the global tracker
+    AliHLTTPCCAPerformance *fPerf; // Performance class (mc labels etc)
+    double fCos, fSin, fZMin, fZMax, fYMin, fYMax;// view parameters
+    double fSliceCos, fSliceSin;        // current slice angle
+    double fRInnerMin, fRInnerMax, fROuterMin, fROuterMax, fTPCZMin, fTPCZMax; // view parameters
 
-  TArc fArc;       // parameters of drawing objects are copied from this members
-  TLine fLine;     //!
-  TPolyLine fPLine;//!
-  TMarker fMarker; //!
-  TBox fBox;       //!
-  TCrown fCrown;   //!
-  TLatex fLatex;   //!
+    TArc fArc;       // parameters of drawing objects are copied from this members
+    TLine fLine;     //!
+    TPolyLine fPLine;//!
+    TMarker fMarker; //!
+    TBox fBox;       //!
+    TCrown fCrown;   //!
+    TLatex fLatex;   //!
 
-  Bool_t fDrawOnlyRef; // draw only clusters from ref. mc tracks
+    bool fDrawOnlyRef; // draw only clusters from ref. mc tracks
 
 };
 
index 9519cf5..300b80b 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 
 //ClassImp(AliHLTTPCCAGBHit)
 
-Bool_t AliHLTTPCCAGBHit::Compare(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b)
+bool AliHLTTPCCAGBHit::Compare( const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b )
 {
   //* Comparison function for sorting hits
-  if( a.fISlice<b.fISlice ) return 1;
-  if( a.fISlice>b.fISlice ) return 0;
-  if( a.fIRow<b.fIRow ) return 1;
-  if( a.fIRow>b.fIRow ) return 0;
-  return (a.fZ < b.fZ);
+  if ( a.fISlice < b.fISlice ) return 1;
+  if ( a.fISlice > b.fISlice ) return 0;
+  if ( a.fIRow < b.fIRow ) return 1;
+  if ( a.fIRow > b.fIRow ) return 0;
+  return ( a.fZ < b.fZ );
 }
index 495d7da..687e062 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // $Id$
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCAGBHit
 {
- public:
-  AliHLTTPCCAGBHit()
-    :fX(0),fY(0),fZ(0),fErrX(0),fErrY(0),fErrZ(0),fAmp(0),
-    fISlice(0), fIRow(0), fID(0), fIsUsed(0){}
-
-  virtual ~AliHLTTPCCAGBHit(){}
-
-  Float_t X() const { return fX; }
-  Float_t Y() const { return fY; } 
-  Float_t Z() const { return fZ; } 
-
-  Float_t ErrX() const { return fErrX; }
-  Float_t ErrY() const { return fErrY; }
-  Float_t ErrZ() const { return fErrZ; }
-  Float_t Amp()  const { return fAmp; }
-
-  Int_t ISlice() const { return fISlice; }
-  Int_t IRow() const { return fIRow; }
-  Int_t ID() const { return fID; }
-  Bool_t IsUsed() const { return fIsUsed; };
-
-  void SetX( Float_t v ){  fX = v; }
-  void SetY( Float_t v ){  fY = v; } 
-  void SetZ( Float_t v ){  fZ = v; } 
-  void SetErrX( Float_t v ){  fErrX = v; }
-  void SetErrY( Float_t v ){  fErrY = v; }
-  void SetErrZ( Float_t v ){  fErrZ = v; }
-  void SetAmp( Float_t v ) {  fAmp = v; }
-  void SetISlice( Int_t v ){  fISlice = v; }
-  void SetIRow( Int_t v ){  fIRow = v; }
-  void SetID( Int_t v ){  fID = v; }
-  void SetIsUsed( Bool_t v ){  fIsUsed = v; };
-
-  static Bool_t Compare(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b);
-
-  static Bool_t CompareRowDown(const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b){
-    return ( a.fIRow>b.fIRow );
-  }
-  static Bool_t ComparePRowDown(const AliHLTTPCCAGBHit *a, const AliHLTTPCCAGBHit *b){
-    return ( a->fIRow>b->fIRow );
-  }
-
- protected:
-
-  Float_t fX; //* X position
-  Float_t fY; //* Y position
-  Float_t fZ; //* Z position
-
-  Float_t fErrX; //* X position error
-  Float_t fErrY; //* Y position error
-  Float_t fErrZ; //* Z position error
-
-  Float_t fAmp;   //* Maximal amplitude
-  Int_t fISlice; //* slice number
-  Int_t fIRow;   //* row number
-  Int_t fID;     //* external ID (id of AliTPCcluster) 
-  Bool_t fIsUsed; //* is used by GBTracks
-
-  //ClassDef(AliHLTTPCCAGBHit,1);
+  public:
+    AliHLTTPCCAGBHit()
+        : fX( 0 ), fY( 0 ), fZ( 0 ), fErrX( 0 ), fErrY( 0 ), fErrZ( 0 ), fAmp( 0 ),
+        fISlice( 0 ), fIRow( 0 ), fID( 0 ), fIsUsed( 0 ) {}
+
+    virtual ~AliHLTTPCCAGBHit() {}
+
+    float X() const { return fX; }
+    float Y() const { return fY; }
+    float Z() const { return fZ; }
+
+    float ErrX() const { return fErrX; }
+    float ErrY() const { return fErrY; }
+    float ErrZ() const { return fErrZ; }
+    float Amp()  const { return fAmp; }
+
+    int ISlice() const { return fISlice; }
+    int IRow() const { return fIRow; }
+    int ID() const { return fID; }
+    bool IsUsed() const { return fIsUsed; };
+
+    void SetX( float v ) {  fX = v; }
+    void SetY( float v ) {  fY = v; }
+    void SetZ( float v ) {  fZ = v; }
+    void SetErrX( float v ) {  fErrX = v; }
+    void SetErrY( float v ) {  fErrY = v; }
+    void SetErrZ( float v ) {  fErrZ = v; }
+    void SetAmp( float v ) {  fAmp = v; }
+    void SetISlice( int v ) {  fISlice = v; }
+    void SetIRow( int v ) {  fIRow = v; }
+    void SetID( int v ) {  fID = v; }
+    void SetIsUsed( bool v ) {  fIsUsed = v; };
+
+    static bool Compare( const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b );
+
+    static bool CompareRowDown( const AliHLTTPCCAGBHit &a, const AliHLTTPCCAGBHit &b ) {
+      return ( a.fIRow > b.fIRow );
+    }
+    static bool ComparePRowDown( const AliHLTTPCCAGBHit *a, const AliHLTTPCCAGBHit *b ) {
+      return ( a->fIRow > b->fIRow );
+    }
+
+  protected:
+
+    float fX; //* X position
+    float fY; //* Y position
+    float fZ; //* Z position
+
+    float fErrX; //* X position error
+    float fErrY; //* Y position error
+    float fErrZ; //* Z position error
+
+    float fAmp;   //* Maximal amplitude
+    int fISlice; //* slice number
+    int fIRow;   //* row number
+    int fID;     //* external ID (id of AliTPCcluster)
+    bool fIsUsed; //* is used by GBTracks
+
+    //ClassDef(AliHLTTPCCAGBHit,1);
 
 };
 
index 978475e..bff6027 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
@@ -21,9 +21,9 @@
 
 #include "AliHLTTPCCAGBTrack.h"
 
-ClassImp(AliHLTTPCCAGBTrack)
+ClassImp( AliHLTTPCCAGBTrack )
+
 void AliHLTTPCCAGBTrack::Dummy() const
-{ 
+{
   //* do nothing
 }
index 8ad0d46..f60dc6c 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // $Id$
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCAGBTrack
 {
- public:
+  public:
 
-  AliHLTTPCCAGBTrack():fFirstHitRef(0),fNHits(0),fParam(),fAlpha(0),fDeDx(0){ ; }
-  virtual ~AliHLTTPCCAGBTrack(){ ; }
+    AliHLTTPCCAGBTrack(): fFirstHitRef( 0 ), fNHits( 0 ), fParam(), fAlpha( 0 ), fDeDx( 0 ) { ; }
+    virtual ~AliHLTTPCCAGBTrack() { ; }
 
-  Int_t NHits()               const { return fNHits; }
-  Int_t FirstHitRef()         const { return fFirstHitRef; }
-  const AliHLTTPCCATrackParam &Param() const { return fParam; }
-  Float_t Alpha()            const { return fAlpha; }
-  Float_t DeDx()             const { return fDeDx; } 
+    int NHits()               const { return fNHits; }
+    int FirstHitRef()         const { return fFirstHitRef; }
+    const AliHLTTPCCATrackParam &Param() const { return fParam; }
+    float Alpha()            const { return fAlpha; }
+    float DeDx()             const { return fDeDx; }
 
 
-  void SetNHits( Int_t v )                 {  fNHits = v; }
-  void SetFirstHitRef( Int_t v )           {  fFirstHitRef = v; }
-  void SetParam( const AliHLTTPCCATrackParam &v ) {  fParam = v; }
-  void SetAlpha( Float_t v )               {  fAlpha = v; }
-  void SetDeDx( Float_t v )                {  fDeDx = v; } 
+    void SetNHits( int v )                 {  fNHits = v; }
+    void SetFirstHitRef( int v )           {  fFirstHitRef = v; }
+    void SetParam( const AliHLTTPCCATrackParam &v ) {  fParam = v; }
+    void SetAlpha( float v )               {  fAlpha = v; }
+    void SetDeDx( float v )                {  fDeDx = v; }
 
 
-  static Bool_t ComparePNClusters( const AliHLTTPCCAGBTrack *a, const AliHLTTPCCAGBTrack *b){
-    return (a->fNHits > b->fNHits);
-  }
+    static bool ComparePNClusters( const AliHLTTPCCAGBTrack *a, const AliHLTTPCCAGBTrack *b ) {
+      return ( a->fNHits > b->fNHits );
+    }
 
- protected:
-  
-  Int_t fFirstHitRef;        // index of the first hit reference in track->hit reference array
-  Int_t fNHits;              // number of track hits
-  AliHLTTPCCATrackParam fParam;// fitted track parameters
-  Float_t fAlpha;             //* Alpha angle of the parametrerisation
-  Float_t fDeDx;              //* DE/DX 
+  protected:
 
- private:
+    int fFirstHitRef;        // index of the first hit reference in track->hit reference array
+    int fNHits;              // number of track hits
+    AliHLTTPCCATrackParam fParam;// fitted track parameters
+    float fAlpha;             //* Alpha angle of the parametrerisation
+    float fDeDx;              //* DE/DX
 
-  void Dummy() const; // to make rulechecker happy by having something in .cxx file
+  private:
 
-  ClassDef(AliHLTTPCCAGBTrack,1)
+    void Dummy() const; // to make rulechecker happy by having something in .cxx file
+
+    ClassDef( AliHLTTPCCAGBTrack, 1 )
 };
 
 
index b93889c..f9ef1dd 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 
 
 AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker()
-  :
-    fSlices(0), 
-    fNSlices(0), 
-    fHits(0),
-    fExt2IntHitID(0),
-    fNHits(0),
-    fTrackHits(0), 
-    fTracks(0), 
-    fNTracks(0),
-    fMerger(0),    
-    fTime(0),
-    fStatNEvents(0),
-    fSliceTrackerTime(0)
+    :
+    fSlices( 0 ),
+    fNSlices( 0 ),
+    fHits( 0 ),
+    fExt2IntHitID( 0 ),
+    fNHits( 0 ),
+    fTrackHits( 0 ),
+    fTracks( 0 ),
+    fNTracks( 0 ),
+    fMerger( 0 ),
+    fTime( 0 ),
+    fStatNEvents( 0 ),
+    fSliceTrackerTime( 0 )
 {
   //* constructor
-  for( Int_t i=0; i<20; i++ ) fStatTime[i] = 0;
+  for ( int i = 0; i < 20; i++ ) fStatTime[i] = 0;
   fMerger = new AliHLTTPCCAMerger;
 }
 
-AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker(const AliHLTTPCCAGBTracker&)
-  : 
-    fSlices(0), 
-    fNSlices(0), 
-    fHits(0),
-    fExt2IntHitID(0),
-    fNHits(0),
-    fTrackHits(0), 
-    fTracks(0), 
-    fNTracks(0),
-    fMerger(0),
-    fTime(0),
-    fStatNEvents(0),
-    fSliceTrackerTime(0)
+AliHLTTPCCAGBTracker::AliHLTTPCCAGBTracker( const AliHLTTPCCAGBTracker& )
+    :
+    fSlices( 0 ),
+    fNSlices( 0 ),
+    fHits( 0 ),
+    fExt2IntHitID( 0 ),
+    fNHits( 0 ),
+    fTrackHits( 0 ),
+    fTracks( 0 ),
+    fNTracks( 0 ),
+    fMerger( 0 ),
+    fTime( 0 ),
+    fStatNEvents( 0 ),
+    fSliceTrackerTime( 0 )
 {
   //* dummy
 }
 
-const AliHLTTPCCAGBTracker &AliHLTTPCCAGBTracker::operator=(const AliHLTTPCCAGBTracker&) const
+const AliHLTTPCCAGBTracker &AliHLTTPCCAGBTracker::operator=( const AliHLTTPCCAGBTracker& ) const
 {
   //* dummy
   return *this;
@@ -86,59 +86,59 @@ AliHLTTPCCAGBTracker::~AliHLTTPCCAGBTracker()
 {
   //* destructor
   StartEvent();
-  if( fSlices ) delete[] fSlices;
-  fSlices=0;
+  if ( fSlices ) delete[] fSlices;
+  fSlices = 0;
   delete fMerger;
 }
 
-void AliHLTTPCCAGBTracker::SetNSlices( Int_t N )
+void AliHLTTPCCAGBTracker::SetNSlices( int N )
 {
   //* set N of slices
   StartEvent();
   fNSlices = N;
-  if( fSlices ) delete[] fSlices;
-  fSlices=0;
+  if ( fSlices ) delete[] fSlices;
+  fSlices = 0;
   fSlices = new AliHLTTPCCATracker[N];
 }
 
 void AliHLTTPCCAGBTracker::StartEvent()
 {
   //* clean up track and hit arrays
-  if( fTrackHits ) delete[] fTrackHits;
+  if ( fTrackHits ) delete[] fTrackHits;
   fTrackHits = 0;
-  if( fTracks ) delete[] fTracks;
+  if ( fTracks ) delete[] fTracks;
   fTracks = 0;
-  if( fHits ) delete[] fHits;
-  fHits=0;
-  if( fExt2IntHitID ) delete[] fExt2IntHitID;
+  if ( fHits ) delete[] fHits;
+  fHits = 0;
+  if ( fExt2IntHitID ) delete[] fExt2IntHitID;
   fExt2IntHitID = 0;
   fNHits = 0;
   fNTracks = 0;
-  for( Int_t i=0; i<fNSlices; i++) fSlices[i].StartEvent();
+  for ( int i = 0; i < fNSlices; i++ ) fSlices[i].StartEvent();
 }
 
 
-void AliHLTTPCCAGBTracker::SetNHits( Int_t nHits )
+void AliHLTTPCCAGBTracker::SetNHits( int nHits )
 {
   //* set the number of hits
-  if( fHits ) delete[] fHits;
+  if ( fHits ) delete[] fHits;
   fHits = 0;
-  if( fExt2IntHitID ) delete[] fExt2IntHitID;
+  if ( fExt2IntHitID ) delete[] fExt2IntHitID;
   fExt2IntHitID = 0;
   fHits = new AliHLTTPCCAGBHit[ nHits ];
-  fExt2IntHitID = new Int_t[ nHits ];
+  fExt2IntHitID = new int[ nHits ];
   fNHits = 0;
-}  
+}
 
-void AliHLTTPCCAGBTracker::ReadHit( Float_t x, Float_t y, Float_t z, 
-                                   Float_t errY, Float_t errZ, Float_t amp,
-                                   Int_t ID, Int_t iSlice, Int_t iRow )
+void AliHLTTPCCAGBTracker::ReadHit( float x, float y, float z,
+                                    float errY, float errZ, float amp,
+                                    int ID, int iSlice, int iRow )
 {
   //* read the hit to local array
   AliHLTTPCCAGBHit &hit = fHits[fNHits];
   hit.SetX( x );
   hit.SetY( y );
-  hit.SetZ( z );  
+  hit.SetZ( z );
   hit.SetErrX( 1.e-4 );//fSlices[iSlice].Param().ErrX();
   hit.SetErrY( errY );
   hit.SetErrZ( errZ );
@@ -147,91 +147,91 @@ void AliHLTTPCCAGBTracker::ReadHit( Float_t x, Float_t y, Float_t z,
   hit.SetISlice( iSlice );
   hit.SetIRow( iRow );
   hit.SetIsUsed( 0 );
-  fNHits++;  
+  fNHits++;
 }
 
 void AliHLTTPCCAGBTracker::FindTracks()
 {
   //* main tracking routine
   fTime = 0;
-  fStatNEvents++;  
+  fStatNEvents++;
 
 #ifdef DRAW
-  AliHLTTPCCADisplay::Instance().SetGB(this);
+  AliHLTTPCCADisplay::Instance().SetGB( this );
   AliHLTTPCCADisplay::Instance().SetTPCView();
   AliHLTTPCCADisplay::Instance().DrawTPC();
   AliHLTTPCCADisplay::Instance().Ask();
 #endif //DRAW  
 
-  
-  std::sort(fHits,fHits+fNHits, AliHLTTPCCAGBHit::Compare );  
 
-  for( Int_t i=0; i<fNHits; i++ )  fExt2IntHitID[fHits[i].ID()] = i;
+  std::sort( fHits, fHits + fNHits, AliHLTTPCCAGBHit::Compare );
+
+  for ( int i = 0; i < fNHits; i++ )  fExt2IntHitID[fHits[i].ID()] = i;
 
   // Read hits, row by row
 
-  Int_t nHitsTotal = fNHits;
-  Float_t *hitX = new Float_t [nHitsTotal];
-  Float_t *hitY = new Float_t [nHitsTotal];
-  Float_t *hitZ = new Float_t [nHitsTotal];
+  int nHitsTotal = fNHits;
+  float *hitX = new float [nHitsTotal];
+  float *hitY = new float [nHitsTotal];
+  float *hitZ = new float [nHitsTotal];
 
-  Int_t *sliceNHits = new Int_t[ fNSlices ];
-  Int_t **rowNHits = new Int_t* [fNSlices];
-  for( Int_t i=0; i<fNSlices; i++ ) rowNHits[i] = new Int_t[200];
+  int *sliceNHits = new int[ fNSlices ];
+  int **rowNHits = new int* [fNSlices];
+  for ( int i = 0; i < fNSlices; i++ ) rowNHits[i] = new int[200];
 
-  for( Int_t is=0; is<fNSlices; is++ ){
+  for ( int is = 0; is < fNSlices; is++ ) {
     sliceNHits[is] = 0;
-    for( Int_t ir=0; ir<200; ir++ ) rowNHits[is][ir] = 0;    
+    for ( int ir = 0; ir < 200; ir++ ) rowNHits[is][ir] = 0;
   }
 
-  for( Int_t ih=0; ih<nHitsTotal; ih++){
-    AliHLTTPCCAGBHit &h = fHits[ih];    
+  for ( int 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++ ){
+
+  int firstSliceHit = 0;
+  for ( int is = 0; is < fNSlices; is++ ) {
     fFirstSliceHit[is] = firstSliceHit;
-    Int_t rowFirstHits[200];
-    Int_t firstRowHit = 0;
-    for( Int_t ir=0; ir<200; ir++ ){
+    int rowFirstHits[200];
+    int firstRowHit = 0;
+    for ( int ir = 0; ir < 200; ir++ ) {
       rowFirstHits[ir] = firstRowHit;
-      for( Int_t ih=0; ih<rowNHits[is][ir]; ih++){
-       AliHLTTPCCAGBHit &h = fHits[firstSliceHit + firstRowHit + ih];    
-       hitX[firstRowHit + ih] = h.X();
-       hitY[firstRowHit + ih] = h.Y();
-       hitZ[firstRowHit + ih] = h.Z(); 
+      for ( int ih = 0; ih < rowNHits[is][ir]; ih++ ) {
+        AliHLTTPCCAGBHit &h = fHits[firstSliceHit + firstRowHit + ih];
+        hitX[firstRowHit + ih] = h.X();
+        hitY[firstRowHit + ih] = h.Y();
+        hitZ[firstRowHit + ih] = h.Z();
       }
-      firstRowHit+=rowNHits[is][ir];
-    }    
+      firstRowHit += rowNHits[is][ir];
+    }
     fSlices[is].ReadEvent( rowFirstHits, &*rowNHits[is], hitX, hitY, hitZ, sliceNHits[is] );
-   
-    //Int_t data[ rowNHits[is]]
+
+    //int data[ rowNHits[is]]
     //AliHLTTPCCAEventHeader event;
 
-    firstSliceHit+=sliceNHits[is];
+    firstSliceHit += sliceNHits[is];
   }
 
-  if( sliceNHits ) delete[] sliceNHits;
-  if( rowNHits ){
-    for( Int_t i=0; i<fNSlices; i++ ) delete[] rowNHits[i];
+  if ( sliceNHits ) delete[] sliceNHits;
+  if ( rowNHits ) {
+    for ( int i = 0; i < fNSlices; i++ ) delete[] rowNHits[i];
     delete[] rowNHits;
   }
 
   delete[] hitX;
   hitX = 0;
-  if( hitY ) delete[] hitY;
-  hitY=0;
-  if( hitZ ) delete[] hitZ;
-  hitZ=0;
-  if( fNHits<=0 ) return;
+  if ( hitY ) delete[] hitY;
+  hitY = 0;
+  if ( hitZ ) delete[] hitZ;
+  hitZ = 0;
+
+  if ( fNHits <= 0 ) return;
 
   TStopwatch timer1;
   TStopwatch timer2;
   //std::cout<<"Start CA reconstruction"<<std::endl;
-  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
+  for ( int iSlice = 0; iSlice < fNSlices; iSlice++ ) {
     //std::cout<<"Reconstruct slice "<<iSlice<<std::endl;
     TStopwatch timer;
     AliHLTTPCCATracker &slice = fSlices[iSlice];
@@ -240,31 +240,31 @@ void AliHLTTPCCAGBTracker::FindTracks()
     //fTime+= timer.CpuTime();
     //blaTime+= timer.CpuTime();
     fStatTime[0] += timer.CpuTime();
-    fStatTime[1]+=slice.Timer(0);
-    fStatTime[2]+=slice.Timer(1);
-    fStatTime[3]+=slice.Timer(2);
-    fStatTime[4]+=slice.Timer(3);
-    fStatTime[5]+=slice.Timer(4);
-    fStatTime[6]+=slice.Timer(5);
-    fStatTime[7]+=slice.Timer(6);
-    fStatTime[8]+=slice.Timer(7);
+    fStatTime[1] += slice.Timer( 0 );
+    fStatTime[2] += slice.Timer( 1 );
+    fStatTime[3] += slice.Timer( 2 );
+    fStatTime[4] += slice.Timer( 3 );
+    fStatTime[5] += slice.Timer( 4 );
+    fStatTime[6] += slice.Timer( 5 );
+    fStatTime[7] += slice.Timer( 6 );
+    fStatTime[8] += slice.Timer( 7 );
   }
 
   timer2.Stop();
   //std::cout<<"blaTime = "<<timer2.CpuTime()*1.e3<<std::endl;
   fSliceTrackerTime = timer2.CpuTime();
-  
+
   //std::cout<<"Start CA merging"<<std::endl;
 
   TStopwatch timerMerge;
-  Merge(); 
+  Merge();
   timerMerge.Stop();
-  fStatTime[9]+=timerMerge.CpuTime();  
+  fStatTime[9] += timerMerge.CpuTime();
   //fTime+=timerMerge.CpuTime();
   //std::cout<<"Merge time = "<<timerMerge.CpuTime()*1.e3<<"ms"<<std::endl;
   //std::cout<<"End CA merging"<<std::endl;
   timer1.Stop();
-  fTime+= timer1.CpuTime();
+  fTime += timer1.CpuTime();
 
 #ifdef DRAW
   AliHLTTPCCADisplay::Instance().Ask();
@@ -273,24 +273,24 @@ void AliHLTTPCCAGBTracker::FindTracks()
 
 void AliHLTTPCCAGBTracker::Merge()
 {
-  // test 
+  // test
 
 #ifdef DRAW
   AliHLTTPCCADisplay &disp = AliHLTTPCCADisplay::Instance();
   AliHLTTPCCADisplay::Instance().SetTPCView();
   AliHLTTPCCADisplay::Instance().DrawTPC();
   AliHLTTPCCADisplay::Instance().DrawGBHits( *this );
-  disp.Ask(); 
-  std::cout<<"Slice tracks:"<<std::endl;
-  for( Int_t iSlice=0; iSlice<fNSlices; iSlice++ ){
+  disp.Ask();
+  std::cout << "Slice tracks:" << std::endl;
+  for ( int iSlice = 0; iSlice < fNSlices; iSlice++ ) {
     AliHLTTPCCATracker &slice = fSlices[iSlice];
-    disp.SetCurrentSlice(&slice);    
-    for( Int_t itr=0; itr<*slice.NOutTracks(); itr++ ){
+    disp.SetCurrentSlice( &slice );
+    for ( int itr = 0; itr < *slice.NOutTracks(); itr++ ) {
       disp.DrawSliceOutTrack( itr, kBlue, 2. );
     }
   }
   //AliHLTTPCCADisplay::Instance().DrawGBHits( *this );
-  disp.Ask(); 
+  disp.Ask();
 #endif //DRAW  
 
 
@@ -299,26 +299,26 @@ void AliHLTTPCCAGBTracker::Merge()
   merger.Clear();
   merger.SetSliceParam( fSlices[0].Param() );
 
-  for( Int_t i=0; i<fNSlices; i++ ) {
+  for ( int i = 0; i < fNSlices; i++ ) {
     merger.SetSliceData( i, fSlices[i].Output() );
   }
 
   merger.Reconstruct();
 
-  const AliHLTTPCCAMergerOutput &out = *(merger.Output());
-  
-  
-  if( fTrackHits ) delete[] fTrackHits;
+  const AliHLTTPCCAMergerOutput &out = *( merger.Output() );
+
+
+  if ( fTrackHits ) delete[] fTrackHits;
   fTrackHits = 0;
-  if(fTracks ) delete[] fTracks;
+  if ( fTracks ) delete[] fTracks;
   fTracks = 0;
-  fTrackHits = new Int_t [out.NTrackClusters()];
-  fTracks = new AliHLTTPCCAGBTrack[out.NTracks()];  
+  fTrackHits = new int [out.NTrackClusters()];
+  fTracks = new AliHLTTPCCAGBTrack[out.NTracks()];
   fNTracks = 0;
 
-  Int_t nTrackHits = 0;
-  
-  for( Int_t itr=0; itr<out.NTracks(); itr++ ){
+  int nTrackHits = 0;
+
+  for ( int itr = 0; itr < out.NTracks(); itr++ ) {
     const AliHLTTPCCAMergedTrack &track = out.Track( itr );
 
     AliHLTTPCCAGBTrack &trackGB = fTracks[fNTracks];
@@ -328,26 +328,26 @@ void AliHLTTPCCAGBTracker::Merge()
     trackGB.SetAlpha( track.InnerAlpha() );
     trackGB.SetDeDx( 0 );
 
-    for( Int_t icl=0; icl<track.NClusters(); icl++ ){
-      UInt_t  iDsrc = out.ClusterIDsrc( track.FirstClusterRef() + icl );
-      UInt_t iSlice = AliHLTTPCCADataCompressor::IDsrc2ISlice( iDsrc );
-      UInt_t iRow   = AliHLTTPCCADataCompressor::IDsrc2IRow( iDsrc );
-      UInt_t iClu   = AliHLTTPCCADataCompressor::IDsrc2IClu( iDsrc );    
-      fTrackHits[nTrackHits+icl] = fFirstSliceHit[iSlice] + fSlices[iSlice].Row(iRow).FirstHit() + iClu;
-    }              
-    nTrackHits+= track.NClusters();
+    for ( int icl = 0; icl < track.NClusters(); icl++ ) {
+      unsigned int  iDsrc = out.ClusterIDsrc( track.FirstClusterRef() + icl );
+      unsigned int iSlice = AliHLTTPCCADataCompressor::IDsrc2ISlice( iDsrc );
+      unsigned int iRow   = AliHLTTPCCADataCompressor::IDsrc2IRow( iDsrc );
+      unsigned int iClu   = AliHLTTPCCADataCompressor::IDsrc2IClu( iDsrc );
+      fTrackHits[nTrackHits+icl] = fFirstSliceHit[iSlice] + fSlices[iSlice].Row( iRow ).FirstHit() + iClu;
+    }
+    nTrackHits += track.NClusters();
     fNTracks++;
   }
 
 #ifdef DRAW
-  std::cout<<"Global tracks: "<<std::endl;
+  std::cout << "Global tracks: " << std::endl;
   AliHLTTPCCADisplay::Instance().ClearView();
   AliHLTTPCCADisplay::Instance().SetTPCView();
   AliHLTTPCCADisplay::Instance().DrawTPC();
   AliHLTTPCCADisplay::Instance().DrawGBHits( *this );
-  for( Int_t itr=0; itr<fNTracks; itr++ ){
-    std::cout<<itr<<" nhits= "<<fTracks[itr].NHits()<<std::endl;
-    AliHLTTPCCADisplay::Instance().DrawGBTrack( itr, kBlue, 2. );    
+  for ( int itr = 0; itr < fNTracks; itr++ ) {
+    std::cout << itr << " nhits= " << fTracks[itr].NHits() << std::endl;
+    AliHLTTPCCADisplay::Instance().DrawGBTrack( itr, kBlue, 2. );
     //AliHLTTPCCADisplay::Instance().Ask();
   }
   AliHLTTPCCADisplay::Instance().Ask();
@@ -357,47 +357,47 @@ void AliHLTTPCCAGBTracker::Merge()
 
 
 
-Bool_t AliHLTTPCCAGBTracker::FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrackParam t0, 
-                                      Float_t &Alpha, Int_t hits[], Int_t &NTrackHits,
-                                      Bool_t dir )
+bool AliHLTTPCCAGBTracker::FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrackParam t0,
+                                       float &Alpha, int hits[], int &NTrackHits,
+                                       bool dir )
 {
   // Fit the track
-  
+
   //return fMerger->FitTrack( T, Alpha, t0, Alpha, hits, NTrackHits, dir );
 
-  Float_t alpha0 = Alpha;
+  float alpha0 = Alpha;
 
   AliHLTTPCCATrackParam::AliHLTTPCCATrackFitParam fitPar;
   AliHLTTPCCATrackParam t = t0;
-  AliHLTTPCCATrackLinearisation l(t0);
+  AliHLTTPCCATrackLinearisation l( t0 );
+
+  bool first = 1;
 
-  Bool_t first = 1;
   t.CalculateFitParameters( fitPar );
 
-  Int_t hitsNew[1000];
-  Int_t nHitsNew = 0;
+  int hitsNew[1000];
+  int nHitsNew = 0;
 
-  for( Int_t ihit=0; ihit<NTrackHits; ihit++){
-    
-    Int_t jhit = dir ?(NTrackHits-1-ihit) :ihit;
+  for ( int ihit = 0; ihit < NTrackHits; ihit++ ) {
+
+    int jhit = dir ? ( NTrackHits - 1 - ihit ) : ihit;
     AliHLTTPCCAGBHit &h = fHits[hits[jhit]];
 
-    Int_t iSlice = h.ISlice();
+    int iSlice = h.ISlice();
 
-    Float_t sliceAlpha =  fSlices[0].Param().Alpha( iSlice );
+    float sliceAlpha =  fSlices[0].Param().Alpha( iSlice );
 
-    if( CAMath::Abs( sliceAlpha - alpha0)>1.e-4 ){
-      if( ! t.Rotate(  sliceAlpha - alpha0, l, .999 ) ) continue;
+    if ( CAMath::Abs( sliceAlpha - alpha0 ) > 1.e-4 ) {
+      if ( ! t.Rotate(  sliceAlpha - alpha0, l, .999 ) ) continue;
       alpha0 = sliceAlpha;
     }
 
-    //Float_t x = fSliceParam.RowX( h.IRow() );
-    Float_t x = h.X();
-    
-    if( !t.TransportToXWithMaterial( x, l, fitPar, fSlices[0].Param().GetBz(t) ) ) continue;
-    
-    if( first ){
+    //float x = fSliceParam.RowX( h.IRow() );
+    float x = h.X();
+
+    if ( !t.TransportToXWithMaterial( x, l, fitPar, fSlices[0].Param().GetBz( t ) ) ) continue;
+
+    if ( first ) {
       t.SetCov( 0, 10 );
       t.SetCov( 1,  0 );
       t.SetCov( 2, 10 );
@@ -408,48 +408,48 @@ Bool_t AliHLTTPCCAGBTracker::FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrac
       t.SetCov( 7,  0 );
       t.SetCov( 8,  0 );
       t.SetCov( 9,  1 );
-      t.SetCov(10,  0 );
-      t.SetCov(11,  0 );
-      t.SetCov(12,  0 );
-      t.SetCov(13,  0 );
-      t.SetCov(14,  10 );
+      t.SetCov( 10,  0 );
+      t.SetCov( 11,  0 );
+      t.SetCov( 12,  0 );
+      t.SetCov( 13,  0 );
+      t.SetCov( 14,  10 );
       t.SetChi2( 0 );
       t.SetNDF( -5 );
       t.CalculateFitParameters( fitPar );
     }
 
-    
-    Float_t err2Y, err2Z;
+
+    float err2Y, err2Z;
     fSlices[0].Param().GetClusterErrors2( h.IRow(), h.Z(), l.SinPhi(), l.CosPhi(), l.DzDs(), err2Y, err2Z );
-    if( !t.Filter( h.Y(), h.Z(), err2Y, err2Z ) ) continue;                
+    if ( !t.Filter( h.Y(), h.Z(), err2Y, err2Z ) ) continue;
 
     first = 0;
 
     hitsNew[nHitsNew++] = hits[jhit];
   }
-  
-  if( CAMath::Abs(t.QPt())<1.e-8 ) t.SetQPt( 1.e-8 );
-  
-  Bool_t ok=1;
-  
-  const Float_t *c = t.Cov();
-  for( Int_t i=0; i<15; i++ ) ok = ok && finite(c[i]);
-  for( Int_t i=0; i<5; i++ ) ok = ok && finite(t.Par()[i]);
-  ok = ok && (t.GetX()>50);
-  
-  if( c[0]<=0 || c[2]<=0 || c[5]<=0 || c[9]<=0 || c[14]<=0 ) ok = 0;
-  if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2. ) ok = 0;
-  
-  if( CAMath::Abs(t.SinPhi())>.99 ) ok = 0;
-  else if( l.CosPhi()>=0 ) t.SetSignCosPhi( 1 );
+
+  if ( CAMath::Abs( t.QPt() ) < 1.e-8 ) t.SetQPt( 1.e-8 );
+
+  bool ok = 1;
+
+  const float *c = t.Cov();
+  for ( int i = 0; i < 15; i++ ) ok = ok && finite( c[i] );
+  for ( int i = 0; i < 5; i++ ) ok = ok && finite( t.Par()[i] );
+  ok = ok && ( t.GetX() > 50 );
+
+  if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0;
+  if ( c[0] > 5. || c[2] > 5. || c[5] > 2. || c[9] > 2 || c[14] > 2. ) ok = 0;
+
+  if ( CAMath::Abs( t.SinPhi() ) > .99 ) ok = 0;
+  else if ( l.CosPhi() >= 0 ) t.SetSignCosPhi( 1 );
   else t.SetSignCosPhi( -1 );
-  
-  if( ok ){
+
+  if ( ok ) {
     T = t;
     Alpha = alpha0;
     NTrackHits = nHitsNew;
-    for( Int_t i=0; i<NTrackHits; i++ ){
-      hits[dir ?(NTrackHits-1-i) :i] = hitsNew[i];
+    for ( int i = 0; i < NTrackHits; i++ ) {
+      hits[dir ?( NTrackHits-1-i ) :i] = hitsNew[i];
     }
   }
   return ok;
@@ -460,8 +460,8 @@ Bool_t AliHLTTPCCAGBTracker::FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrac
 void AliHLTTPCCAGBTracker::WriteSettings( std::ostream &out ) const
 {
   //* write settings to the file
-  out<< NSlices()<<std::endl;  
-  for( Int_t iSlice=0; iSlice<NSlices(); iSlice++ ){    
+  out << NSlices() << std::endl;
+  for ( int iSlice = 0; iSlice < NSlices(); iSlice++ ) {
     fSlices[iSlice].Param().WriteSettings( out );
   }
 }
@@ -469,13 +469,13 @@ void AliHLTTPCCAGBTracker::WriteSettings( std::ostream &out ) const
 void AliHLTTPCCAGBTracker::ReadSettings( std::istream &in )
 {
   //* Read settings from the file
-  Int_t nSlices=0;
+  int nSlices = 0;
   in >> nSlices;
   SetNSlices( nSlices );
-  for( Int_t iSlice=0; iSlice<NSlices(); iSlice++ ){    
+  for ( int iSlice = 0; iSlice < NSlices(); iSlice++ ) {
     AliHLTTPCCAParam param;
     param.ReadSettings ( in );
-    fSlices[iSlice].Initialize( param ); 
+    fSlices[iSlice].Initialize( param );
   }
 }
 
@@ -483,115 +483,115 @@ void AliHLTTPCCAGBTracker::WriteEvent( std::ostream &out ) const
 {
   // write event to the file
 
-  out<<NHits()<<std::endl;
-  for (Int_t ih=0; ih<NHits(); ih++) {
+  out << NHits() << std::endl;
+  for ( int ih = 0; ih < NHits(); ih++ ) {
     AliHLTTPCCAGBHit &h = fHits[ih];
-    out<<h.X()<<" ";
-    out<<h.Y()<<" ";
-    out<<h.Z()<<" ";
-    out<<h.ErrY()<<" ";
-    out<<h.ErrZ()<<" ";
-    out<<h.Amp()<<" ";
-    out<<h.ID()<<" ";
-    out<<h.ISlice()<<" ";
-    out<<h.IRow()<<std::endl;
+    out << h.X() << " ";
+    out << h.Y() << " ";
+    out << h.Z() << " ";
+    out << h.ErrY() << " ";
+    out << h.ErrZ() << " ";
+    out << h.Amp() << " ";
+    out << h.ID() << " ";
+    out << h.ISlice() << " ";
+    out << h.IRow() << std::endl;
   }
 }
 
-void AliHLTTPCCAGBTracker::ReadEvent( std::istream &in ) 
+void AliHLTTPCCAGBTracker::ReadEvent( std::istream &in )
 {
-  //* Read event from file 
+  //* Read event from file
 
   StartEvent();
-  Int_t nHits;
+  int nHits;
   in >> nHits;
-  SetNHits(nHits);
-  for (Int_t i=0; i<nHits; i++) {
-    Float_t x, y, z, errY, errZ;
-    Float_t amp;
-    Int_t id, iSlice, iRow;
-    in>>x>>y>>z>>errY>>errZ>>amp>>id>>iSlice>>iRow;
+  SetNHits( nHits );
+  for ( int i = 0; i < nHits; i++ ) {
+    float x, y, z, errY, errZ;
+    float amp;
+    int id, iSlice, iRow;
+    in >> x >> y >> z >> errY >> errZ >> amp >> id >> iSlice >> iRow;
     ReadHit( x, y, z, errY, errZ, amp, id, iSlice, iRow );
   }
 }
 
-void AliHLTTPCCAGBTracker::WriteTracks( std::ostream &out ) const 
+void AliHLTTPCCAGBTracker::WriteTracks( std::ostream &out ) const
 {
-  //* Write tracks to file 
+  //* Write tracks to file
 
-  out<<fSliceTrackerTime<<std::endl;
-  Int_t nTrackHits = 0;
-  for( Int_t itr=0; itr<fNTracks; itr++ ){
-    nTrackHits+=fTracks[itr].NHits();
+  out << fSliceTrackerTime << std::endl;
+  int nTrackHits = 0;
+  for ( int itr = 0; itr < fNTracks; itr++ ) {
+    nTrackHits += fTracks[itr].NHits();
   }
-  out<<nTrackHits<<std::endl;
-  for( Int_t ih=0; ih<nTrackHits; ih++ ){
-    out<< fTrackHits[ih]<<" ";
+  out << nTrackHits << std::endl;
+  for ( int ih = 0; ih < nTrackHits; ih++ ) {
+    out << fTrackHits[ih] << " ";
   }
-  out<<std::endl;
-  
-  out<<NTracks()<<std::endl;
-  for( Int_t itr=0; itr<fNTracks; itr++ ){
-    AliHLTTPCCAGBTrack &t = fTracks[itr];    
-    const AliHLTTPCCATrackParam &p = t.Param();        
-    out<< t.NHits()<<" ";
-    out<< t.FirstHitRef()<<" ";
-    out<< t.Alpha()<<" ";
-    out<< t.DeDx()<<std::endl;
-    out<< p.GetX()<<" ";
-    out<< p.GetCosPhi()<<" ";
-    out<< p.GetChi2()<<" ";
-    out<< p.GetNDF()<<std::endl;
-    for( Int_t i=0; i<5; i++ ) out<<p.GetPar()[i]<<" ";
-    out<<std::endl;
-    for( Int_t i=0; i<15; i++ ) out<<p.GetCov()[i]<<" ";
-    out<<std::endl;
+  out << std::endl;
+
+  out << NTracks() << std::endl;
+  for ( int itr = 0; itr < fNTracks; itr++ ) {
+    AliHLTTPCCAGBTrack &t = fTracks[itr];
+    const AliHLTTPCCATrackParam &p = t.Param();
+    out << t.NHits() << " ";
+    out << t.FirstHitRef() << " ";
+    out << t.Alpha() << " ";
+    out << t.DeDx() << std::endl;
+    out << p.GetX() << " ";
+    out << p.GetCosPhi() << " ";
+    out << p.GetChi2() << " ";
+    out << p.GetNDF() << std::endl;
+    for ( int i = 0; i < 5; i++ ) out << p.GetPar()[i] << " ";
+    out << std::endl;
+    for ( int i = 0; i < 15; i++ ) out << p.GetCov()[i] << " ";
+    out << std::endl;
   }
 }
 
 void AliHLTTPCCAGBTracker::ReadTracks( std::istream &in )
 {
-  //* Read tracks  from file 
+  //* Read tracks  from file
 
-  in>>fTime;
+  in >> fTime;
   fSliceTrackerTime = fTime;
-  fStatTime[0]+=fTime;
+  fStatTime[0] += fTime;
   fStatNEvents++;
-  if( fTrackHits ) delete[] fTrackHits;
-  fTrackHits = 0;  
-  Int_t nTrackHits = 0;
+  if ( fTrackHits ) delete[] fTrackHits;
+  fTrackHits = 0;
+  int nTrackHits = 0;
   in >> nTrackHits;
-  fTrackHits = new Int_t [nTrackHits];
-  for( Int_t ih=0; ih<nTrackHits; ih++ ){
+  fTrackHits = new int [nTrackHits];
+  for ( int ih = 0; ih < nTrackHits; ih++ ) {
     in >> TrackHits()[ih];
   }
-  if( fTracks ) delete[] fTracks;
-  fTracks = 0;  
+  if ( fTracks ) delete[] fTracks;
+  fTracks = 0;
   in >> fNTracks;
   fTracks = new AliHLTTPCCAGBTrack[fNTracks];
-  for( Int_t itr=0; itr<NTracks(); itr++ ){
-    AliHLTTPCCAGBTrack &t = Tracks()[itr];    
+  for ( int itr = 0; itr < NTracks(); itr++ ) {
+    AliHLTTPCCAGBTrack &t = Tracks()[itr];
     AliHLTTPCCATrackParam p;
-    Int_t i;
-    Float_t f;
-    in>>i;
-    t.SetNHits(i);
-    in>>i;
+    int i;
+    float f;
+    in >> i;
+    t.SetNHits( i );
+    in >> i;
     t.SetFirstHitRef( i );
-    in>>f;
-    t.SetAlpha(f);
-    in>>f;
+    in >> f;
+    t.SetAlpha( f );
+    in >> f;
     t.SetDeDx( f );
-    in>>f;
+    in >> f;
     p.SetX( f );
-    in>>f;
+    in >> f;
     p.SetSignCosPhi( f );
-    in>>f;
+    in >> f;
     p.SetChi2( f );
-    in>>i;
+    in >> i;
     p.SetNDF( i );
-    for( Int_t j=0; j<5; j++ ){ in>>f; p.SetPar( j, f); }
-    for( Int_t j=0; j<15; j++ ){ in>>f; p.SetCov(j,f); }
-    t.SetParam(p);     
+    for ( int j = 0; j < 5; j++ ) { in >> f; p.SetPar( j, f ); }
+    for ( int j = 0; j < 15; j++ ) { in >> f; p.SetCov( j, f ); }
+    t.SetParam( p );
   }
 }
index 1f64881..b4f8995 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -26,13 +26,13 @@ class  AliHLTTPCCAMerger;
 
 /**
  * @class AliHLTTPCCAGBTracker
- * 
+ *
  * Global Cellular Automaton-based HLT tracker for TPC detector
  * The class reconstructs tracks in the whole TPC
- * It calls the AliHLTTPCCATracker slice tracker and constructs 
- * the global TPC tracks by merging the slice tracks 
+ * It calls the AliHLTTPCCATracker slice tracker and constructs
+ * the global TPC tracks by merging the slice tracks
  *
- * The tracker is designed stand-alone. 
+ * The tracker is designed stand-alone.
  * It will be integrated to the HLT framework via AliHLTTPCCAGBTrackerComponent interface,
  * and to off-line framework via TPC/AliTPCtrackerCA class
  * The class is under construction.
@@ -41,73 +41,73 @@ class  AliHLTTPCCAMerger;
 class AliHLTTPCCAGBTracker
 {
 
-public:
+  public:
 
-  AliHLTTPCCAGBTracker();
-  AliHLTTPCCAGBTracker(const AliHLTTPCCAGBTracker&);
-  const AliHLTTPCCAGBTracker &operator=(const AliHLTTPCCAGBTracker&) const;
+    AliHLTTPCCAGBTracker();
+    AliHLTTPCCAGBTracker( const AliHLTTPCCAGBTracker& );
+    const AliHLTTPCCAGBTracker &operator=( const AliHLTTPCCAGBTracker& ) const;
 
-  ~AliHLTTPCCAGBTracker();
+    ~AliHLTTPCCAGBTracker();
 
-  void StartEvent();
-  void SetNSlices( Int_t N );
-  void SetNHits( Int_t nHits );
+    void StartEvent();
+    void SetNSlices( int N );
+    void SetNHits( int nHits );
 
-  void ReadHit( Float_t x, Float_t y, Float_t z, 
-               Float_t ErrY, Float_t ErrZ, Float_t amp,
-               Int_t ID, Int_t iSlice, Int_t iRow );
+    void ReadHit( float x, float y, float z,
+                  float ErrY, float ErrZ, float amp,
+                  int ID, int iSlice, int iRow );
 
-  void FindTracks();
+    void FindTracks();
 
-  void Merge();
+    void Merge();
 
-  AliHLTTPCCATracker *Slices() const { return fSlices; }
-  AliHLTTPCCAGBHit *Hits() const { return fHits; }
-  Int_t Ext2IntHitID( Int_t i ) const { return fExt2IntHitID[i]; }
+    AliHLTTPCCATracker *Slices() const { return fSlices; }
+    AliHLTTPCCAGBHit *Hits() const { return fHits; }
+    int Ext2IntHitID( int i ) const { return fExt2IntHitID[i]; }
 
-  Int_t NHits() const { return fNHits; }
-  Int_t NSlices() const { return fNSlices; }
-  Double_t Time() const { return fTime; }
-  Double_t StatTime( Int_t iTimer ) const { return fStatTime[iTimer]; }
-  Int_t StatNEvents() const { return fStatNEvents; }
-  Int_t NTracks() const { return fNTracks; }
-  AliHLTTPCCAGBTrack *Tracks() const { return fTracks; }
-  Int_t *TrackHits() const { return fTrackHits; }
+    int NHits() const { return fNHits; }
+    int NSlices() const { return fNSlices; }
+    double Time() const { return fTime; }
+    double StatTime( int iTimer ) const { return fStatTime[iTimer]; }
+    int StatNEvents() const { return fStatNEvents; }
+    int NTracks() const { return fNTracks; }
+    AliHLTTPCCAGBTrack *Tracks() const { return fTracks; }
+    int *TrackHits() const { return fTrackHits; }
 
-  Bool_t FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrackParam t0, 
-                  Float_t &Alpha, Int_t hits[], Int_t &NTrackHits, 
-                  Bool_t dir );
+    bool FitTrack( AliHLTTPCCATrackParam &T, AliHLTTPCCATrackParam t0,
+                     float &Alpha, int hits[], int &NTrackHits,
+                     bool dir );
 
-  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 );
+    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() const { return fSliceTrackerTime; }
-  void SetSliceTrackerTime( Double_t v ){ fSliceTrackerTime = v; }
-  const Int_t *FirstSliceHit() const { return fFirstSliceHit; }
+    double SliceTrackerTime() const { return fSliceTrackerTime; }
+    void SetSliceTrackerTime( double v ) { fSliceTrackerTime = v; }
+    const int *FirstSliceHit() const { return fFirstSliceHit; }
 
 
-protected:
+  protected:
 
-  AliHLTTPCCATracker *fSlices; //* array of slice trackers
-  Int_t fNSlices;              //* N slices
-  AliHLTTPCCAGBHit *fHits;     //* hit array
-  Int_t *fExt2IntHitID;        //* array of internal hit indices
-  Int_t fNHits;                //* N hits in event
-  Int_t *fTrackHits;           //* track->hits reference array
-  AliHLTTPCCAGBTrack *fTracks; //* array of tracks
-  Int_t fNTracks;              //* N tracks
-  AliHLTTPCCAMerger *fMerger;  //* global merger
+    AliHLTTPCCATracker *fSlices; //* array of slice trackers
+    int fNSlices;              //* N slices
+    AliHLTTPCCAGBHit *fHits;     //* hit array
+    int *fExt2IntHitID;        //* array of internal hit indices
+    int fNHits;                //* N hits in event
+    int *fTrackHits;           //* track->hits reference array
+    AliHLTTPCCAGBTrack *fTracks; //* array of tracks
+    int fNTracks;              //* N tracks
+    AliHLTTPCCAMerger *fMerger;  //* global merger
 
-  Double_t fTime; //* total time
-  Double_t fStatTime[20]; //* timers 
-  Int_t fStatNEvents;    //* n events proceed
-  Int_t fFirstSliceHit[100]; // hit array
+    double fTime; //* total time
+    double fStatTime[20]; //* timers
+    int fStatNEvents;    //* n events proceed
+    int fFirstSliceHit[100]; // hit array
 
-  Double_t fSliceTrackerTime; // reco time of the slice tracker;
+    double fSliceTrackerTime; // reco time of the slice tracker;
 
 };
 
index 1bf13f2..c948b5d 100644 (file)
@@ -1,5 +1,5 @@
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
@@ -61,7 +61,7 @@ ClassImp( AliHLTTPCCAGlobalMergerComponent )
 AliHLTTPCCAGlobalMergerComponent AliHLTTPCCAGlobalMergerComponent::fgAliHLTTPCCAGlobalMergerComponent;
 
 AliHLTTPCCAGlobalMergerComponent::AliHLTTPCCAGlobalMergerComponent()
-  : fGlobalMerger( 0 ), fSolenoidBz(5)
+    : fGlobalMerger( 0 ), fSolenoidBz( 5 )
 {
   // see header file for class documentation
 }
@@ -116,50 +116,50 @@ int AliHLTTPCCAGlobalMergerComponent::DoInit( int argc, const char** argv )
   fGlobalMerger = new AliHLTTPCCAMerger();
 
   AliHLTTPCCAParam param;
-  
+
   {
     // get gemetry
-    Int_t iSec = 0;
-    Float_t inRmin = 83.65; 
-    Float_t outRmax = 247.7;
-    Float_t plusZmin = 0.0529937; 
-    Float_t plusZmax = 249.778; 
-    Float_t minusZmin = -249.645; 
-    Float_t minusZmax = -0.0799937; 
-    Float_t dalpha = 0.349066;
-    Float_t alpha = 0.174533 + dalpha*iSec;    
-    Bool_t zPlus = (iSec<18 );
-    Float_t zMin =  zPlus ?plusZmin :minusZmin;
-    Float_t zMax =  zPlus ?plusZmax :minusZmax;
-    Int_t nRows = AliHLTTPCTransform::GetNRows();        
-    Float_t padPitch = 0.4;
-    Float_t sigmaZ = 0.228808;    
-    Float_t *rowX = new Float_t [nRows];
-    for( Int_t irow=0; irow<nRows; irow++){
+    int iSec = 0;
+    float inRmin = 83.65;
+    float outRmax = 247.7;
+    float plusZmin = 0.0529937;
+    float plusZmax = 249.778;
+    float minusZmin = -249.645;
+    float minusZmax = -0.0799937;
+    float dalpha = 0.349066;
+    float alpha = 0.174533 + dalpha * iSec;
+    bool zPlus = ( iSec < 18 );
+    float zMin =  zPlus ? plusZmin : minusZmin;
+    float zMax =  zPlus ? plusZmax : minusZmax;
+    int nRows = AliHLTTPCTransform::GetNRows();
+    float padPitch = 0.4;
+    float sigmaZ = 0.228808;
+    float *rowX = new float [nRows];
+    for ( int irow = 0; irow < nRows; irow++ ) {
       rowX[irow] = AliHLTTPCTransform::Row2X( irow );
     }
-     
+
     param.Initialize( iSec, nRows, rowX, alpha, dalpha,
-                     inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );    
+                      inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
     delete[] rowX;
   }
 
 
   fGlobalMerger->SetSliceParam( param );
 
-  Int_t iResult = 0;
+  int iResult = 0;
 
-  TString arguments=""; 
-  for (int i=0; i<argc; i++) {
-    TString argument=argv[i];
-    if (!arguments.IsNull()) arguments+=" ";
-    arguments+=argument;
+  TString arguments = "";
+  for ( int i = 0; i < argc; i++ ) {
+    TString argument = argv[i];
+    if ( !arguments.IsNull() ) arguments += " ";
+    arguments += argument;
   }
-  if (!arguments.IsNull()) {
-    iResult=Configure(arguments.Data());
+  if ( !arguments.IsNull() ) {
+    iResult = Configure( arguments.Data() );
   } else {
-    iResult=Reconfigure(NULL, NULL);
-  }  
+    iResult = Reconfigure( NULL, NULL );
+  }
   return iResult;
 }
 
@@ -173,17 +173,17 @@ int AliHLTTPCCAGlobalMergerComponent::DoDeinit()
 }
 
 int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &evtData,
-                                              const AliHLTComponentBlockData *blocks, AliHLTComponentTriggerData &/*trigData*/,
+    const AliHLTComponentBlockData *blocks, AliHLTComponentTriggerData &/*trigData*/,
     AliHLTUInt8_t *outputPtr, AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks )
 {
   // see header file for class documentation
   int iResult = 0;
-  UInt_t maxBufferSize = size;
+  unsigned int maxBufferSize = size;
 
   size = 0;
 
   if ( !outputPtr ) {
-      return -ENOSPC;
+    return -ENOSPC;
   }
   if ( !IsDataEvent() ) {
     return 0;
@@ -200,7 +200,7 @@ int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &e
     int slice = AliHLTTPCDefinitions::GetMinSliceNr( *block );
     if ( slice < 0 || slice >= AliHLTTPCTransform::GetNSlice() ) {
       HLTError( "invalid slice number %d extracted from specification 0x%08lx,  skipping block of type %s",
-          slice, block->fSpecification, DataType2Text(block->fDataType).c_str() );
+                slice, block->fSpecification, DataType2Text( block->fDataType ).c_str() );
       // just remember the error, if there are other valid blocks ignore the error, return code otherwise
       iResult = -EBADF;
       continue;
@@ -208,8 +208,8 @@ int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &e
 
     if ( slice != AliHLTTPCDefinitions::GetMaxSliceNr( *block ) ) {
       // the code was not written for/ never used with multiple slices in one data block/ specification
-      HLTWarning("specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
-          block->fSpecification, DataType2Text(block->fDataType).c_str());
+      HLTWarning( "specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
+                  block->fSpecification, DataType2Text( block->fDataType ).c_str() );
     }
     AliHLTTPCCASliceOutput *sliceOut =  reinterpret_cast<AliHLTTPCCASliceOutput *>( block->fPtr );
     sliceOut->SetPointers();
@@ -222,18 +222,18 @@ int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &e
 
   // Fill output tracks
 
-  UInt_t mySize = 0;
+  unsigned int mySize = 0;
 
   {
     // check if there was enough space in the output buffer
 
-    Int_t nTracks = mergerOutput->NTracks();
+    int nTracks = mergerOutput->NTracks();
 
     AliHLTTPCTrackArray array( nTracks );
 
-    Int_t nClusters=0;
-    for( Int_t itr=0; itr<nTracks; itr++){
+    int nClusters = 0;
+    for ( int itr = 0; itr < nTracks; itr++ ) {
+
       // convert AliHLTTPCCAMergedTrack to AliHLTTPCTrack
 
       const AliHLTTPCCAMergedTrack &track = mergerOutput->Track( itr );
@@ -242,70 +242,70 @@ int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &e
       // first convert to AliExternalTrackParam ( Kappa to Pt )
 
       AliExternalTrackParam tp, tpEnd;
-      AliHLTTPCCATrackConvertor::GetExtParam( track.InnerParam(), tp, 0 );      
-      AliHLTTPCCATrackConvertor::GetExtParam( track.OuterParam(), tpEnd, 0 );      
+      AliHLTTPCCATrackConvertor::GetExtParam( track.InnerParam(), tp, 0 );
+      AliHLTTPCCATrackConvertor::GetExtParam( track.OuterParam(), tpEnd, 0 );
 
       // set parameters, with rotation to global coordinates
-      
-      out.SetCharge((Int_t ) tp.GetSign());
-      out.SetPt( TMath::Abs(tp.GetSignedPt()) );
-      out.SetPsi( fmod( TMath::ASin( tp.GetSnp() ) + track.InnerAlpha() ,2*TMath::Pi() ) );
+
+      out.SetCharge( ( int ) tp.GetSign() );
+      out.SetPt( TMath::Abs( tp.GetSignedPt() ) );
+      out.SetPsi( fmod( TMath::ASin( tp.GetSnp() ) + track.InnerAlpha() , 2*TMath::Pi() ) );
       out.SetTgl( tp.GetTgl() );
       {
-       Float_t sinA = TMath::Sin( track.InnerAlpha() );
-       Float_t cosA = TMath::Cos( track.InnerAlpha() );
-       
-       out.SetFirstPoint( tp.GetX()*cosA - tp.GetY()*sinA,
-                          tp.GetX()*sinA + tp.GetY()*cosA, 
-                          tp.GetZ() );
+        float sinA = TMath::Sin( track.InnerAlpha() );
+        float cosA = TMath::Cos( track.InnerAlpha() );
+
+        out.SetFirstPoint( tp.GetX()*cosA - tp.GetY()*sinA,
+                           tp.GetX()*sinA + tp.GetY()*cosA,
+                           tp.GetZ() );
       }
-      
+
       {
-       Float_t sinA = TMath::Sin( track.OuterAlpha() );
-       Float_t cosA = TMath::Cos( track.OuterAlpha() );
-       
-       out.SetLastPoint( tpEnd.GetX()*cosA - tpEnd.GetY()*sinA,
-                         tpEnd.GetX()*sinA + tpEnd.GetY()*cosA, 
-                         tpEnd.GetZ() );
+        float sinA = TMath::Sin( track.OuterAlpha() );
+        float cosA = TMath::Cos( track.OuterAlpha() );
+
+        out.SetLastPoint( tpEnd.GetX()*cosA - tpEnd.GetY()*sinA,
+                          tpEnd.GetX()*sinA + tpEnd.GetY()*cosA,
+                          tpEnd.GetZ() );
       }
 
       // set parameter errors w/o rotation, as it is done in AliHLTTPCTrackArray
 
-      out.SetY0err(tp.GetSigmaY2());
-      out.SetZ0err(tp.GetSigmaZ2());
-      Float_t h = -out.GetPt()*out.GetPt();
+      out.SetY0err( tp.GetSigmaY2() );
+      out.SetZ0err( tp.GetSigmaZ2() );
+      float h = -out.GetPt() * out.GetPt();
       out.SetPterr( h*h*tp.GetSigma1Pt2() );
-      h = 1./TMath::Sqrt(1-out.GetSnp()*out.GetSnp());
-      out.SetPsierr(h*h*tp.GetSigmaSnp2());
-      out.SetTglerr(tp.GetSigmaTgl2());  
+      h = 1. / TMath::Sqrt( 1 - out.GetSnp() * out.GetSnp() );
+      out.SetPsierr( h*h*tp.GetSigmaSnp2() );
+      out.SetTglerr( tp.GetSigmaTgl2() );
+
       // set cluster ID's
 
-      UInt_t hitID[1000];
-      for( Int_t i=0; i<track.NClusters(); i++ ) hitID[i] = mergerOutput->ClusterIDsrc(track.FirstClusterRef()+i);
+      unsigned int hitID[1000];
+      for ( int i = 0; i < track.NClusters(); i++ ) hitID[i] = mergerOutput->ClusterIDsrc( track.FirstClusterRef() + i );
 
       out.SetNHits( track.NClusters() );
       out.SetHits( track.NClusters(), hitID );
-      
-      out.SetSector(-1);
+
+      out.SetSector( -1 );
       out.CalculateHelix();
-      if( !out.CheckConsistency() )  *(array.NextTrack()) = out;      
-      nClusters+=track.NClusters();
+      if ( !out.CheckConsistency() )  *( array.NextTrack() ) = out;
+      nClusters += track.NClusters();
     }
 
-    
-    if ( sizeof(AliHLTTPCTrackletData) + nTracks*sizeof(AliHLTTPCTrackSegmentData) + nClusters*sizeof(UInt_t)
-        > maxBufferSize ){
+
+    if ( sizeof( AliHLTTPCTrackletData ) + nTracks*sizeof( AliHLTTPCTrackSegmentData ) + nClusters*sizeof( unsigned int )
+         > maxBufferSize ) {
       iResult = -ENOSPC;
     } else {
-      AliHLTTPCTrackletData *outPtr = (AliHLTTPCTrackletData*)(outputPtr);
-      UInt_t nOutTracks = 0;
+      AliHLTTPCTrackletData *outPtr = ( AliHLTTPCTrackletData* )( outputPtr );
+      unsigned int nOutTracks = 0;
       mySize = array.WriteTracks( nOutTracks, outPtr->fTracklets );
-      mySize += sizeof(AliHLTTPCTrackletData);
+      mySize += sizeof( AliHLTTPCTrackletData );
       outPtr->fTrackletCnt = nOutTracks;
     }
   }
-  
+
   AliHLTComponentBlockData resultData;
   FillBlockData( resultData );
   resultData.fOffset = 0;
@@ -321,74 +321,72 @@ int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &e
 
 
 
-Int_t AliHLTTPCCAGlobalMergerComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
+int AliHLTTPCCAGlobalMergerComponent::Reconfigure( const char* /*cdbEntry*/, const char* /*chainId*/ )
 {
   // see header file for class documentation
 
 
-  HLTWarning("TODO: dummy Reconfigure() method" );
+  HLTWarning( "TODO: dummy Reconfigure() method" );
   return 0;
   /*
 
-  Int_t iResult=0;
+  int iResult=0;
   const char* pathBField=kAliHLTCDBSolenoidBz;
-  
+
   if (pathBField) {
     HLTInfo("reconfigure B-Field from entry %s, chain id %s", pathBField,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
     if (pEntry) {
       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
       if (pString) {
-       HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
-       iResult=Configure(pString->GetString().Data());
+  HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
+  iResult=Configure(pString->GetString().Data());
       } else {
-       HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
+  HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
       }
     } else {
       HLTError("cannot fetch object \"%s\" from CDB", pathBField);
     }
-  }  
-  return iResult;  
-*/
+  }
+  return iResult;
+  */
 }
 
 
-Int_t AliHLTTPCCAGlobalMergerComponent::Configure( const char* arguments )
+int AliHLTTPCCAGlobalMergerComponent::Configure( const char* arguments )
 {
   //* Set parameters
 
-  Int_t iResult=0;
-  if (!arguments) return iResult;
-  
-  TString allArgs=arguments;
+  int iResult = 0;
+  if ( !arguments ) return iResult;
+
+  TString allArgs = arguments;
   TString argument;
-  Int_t bMissingParam=0;
-  
-  TObjArray* pTokens=allArgs.Tokenize(" ");
+  int bMissingParam = 0;
 
-  Int_t nArgs =  pTokens ?pTokens->GetEntries() :0;
+  TObjArray* pTokens = allArgs.Tokenize( " " );
 
-  for (int i=0; i<nArgs; i++ ){
-    argument=((TObjString*)pTokens->At(i))->GetString();
-    if (argument.IsNull()){
-    }
-    else if (argument.CompareTo("-solenoidBz")==0 ){
-      if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; 
-      fSolenoidBz = ((TObjString*)pTokens->At(i))->GetString().Atof();
-      HLTInfo("Magnetic Field set to: %f", fSolenoidBz );
-    }
-    else {
-      HLTError("Unknown option %s ", argument.Data());
-      iResult=-EINVAL;
+  int nArgs =  pTokens ? pTokens->GetEntries() : 0;
+
+  for ( int i = 0; i < nArgs; i++ ) {
+    argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
+    if ( argument.IsNull() ) {
+    } else if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
+      if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
+      fSolenoidBz = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
+      HLTInfo( "Magnetic Field set to: %f", fSolenoidBz );
+    } else {
+      HLTError( "Unknown option %s ", argument.Data() );
+      iResult = -EINVAL;
     }
   }
   delete pTokens;
 
-  if (bMissingParam) {
-    HLTError("Specifier missed for %s", argument.Data());    
-    iResult=-EINVAL;
+  if ( bMissingParam ) {
+    HLTError( "Specifier missed for %s", argument.Data() );
+    iResult = -EINVAL;
   }
 
   return iResult;
 }
-  
+
index 2651af1..b554abf 100644 (file)
@@ -1,5 +1,5 @@
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -84,19 +84,19 @@ class AliHLTTPCCAGlobalMergerComponent : public AliHLTProcessor
     int DoDeinit();
 
     /** reconfigure **/
-    Int_t Reconfigure(const char* cdbEntry, const char* chainId);
+    int Reconfigure( const char* cdbEntry, const char* chainId );
 
     /**
      * @copydoc @ref AliHLTProcessor::DoEvent
      */
     int DoEvent( const AliHLTComponentEventData &evtData, const AliHLTComponentBlockData *blocks,
-        AliHLTComponentTriggerData &trigData, AliHLTUInt8_t *outputPtr,
-        AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks );
+                 AliHLTComponentTriggerData &trigData, AliHLTUInt8_t *outputPtr,
+                 AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks );
 
     using AliHLTProcessor::DoEvent;
 
   private:
-    
+
     static AliHLTTPCCAGlobalMergerComponent fgAliHLTTPCCAGlobalMergerComponent;
 
     // disable copy
@@ -104,12 +104,12 @@ class AliHLTTPCCAGlobalMergerComponent : public AliHLTProcessor
     AliHLTTPCCAGlobalMergerComponent &operator=( const AliHLTTPCCAGlobalMergerComponent & );
 
     /** set configuration parameters **/
-    Int_t Configure( const char* arguments );
+    int Configure( const char* arguments );
 
     /** the global merger object */
     AliHLTTPCCAMerger *fGlobalMerger; //!
 
-    Double_t fSolenoidBz;  // magnetic field  
+    double fSolenoidBz;  // magnetic field
 
     ClassDef( AliHLTTPCCAGlobalMergerComponent, 0 )
 };
index 2f546ae..89ab743 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 #include "AliHLTTPCCAMath.h"
 #include <iostream>
 
-GPUd() void AliHLTTPCCAGrid::Create( Float_t yMin, Float_t yMax, Float_t zMin, Float_t zMax, UInt_t n )
+GPUd() void AliHLTTPCCAGrid::Create( float yMin, float yMax, float zMin, float zMax, unsigned int n )
 {
   //* Create the grid
-  
-  fYMin = CAMath::Min(yMin,yMax);
-  fYMax = CAMath::Max(yMin,yMax)+.1;
-  fZMin = CAMath::Min(zMin,zMax);
-  fZMax = CAMath::Max(zMin,zMax)+.1;
-  fNy = (UInt_t) CAMath::Sqrt( CAMath::Abs( (Float_t) n ) );
-  fNy = CAMath::Max(fNy,1);
+
+  fYMin = CAMath::Min( yMin, yMax );
+  fYMax = CAMath::Max( yMin, yMax ) + .1;
+  fZMin = CAMath::Min( zMin, zMax );
+  fZMax = CAMath::Max( zMin, zMax ) + .1;
+  fNy = ( unsigned int ) CAMath::Sqrt( CAMath::Abs( ( float ) n ) );
+  fNy = CAMath::Max( fNy, 1 );
   fNz = fNy;
-  fN = fNy*fNz;
-  fStepYInv = (fYMax - fYMin);
-  fStepZInv = (fZMax - fZMin);
-  //Int_t ky = (fNy>1) ?fNy-1 :1;
-  //Int_t kz = (fNz>1) ?fNz-1 :1;
-  fStepYInv =  ( fStepYInv>1.e-4 ) ?fNy/fStepYInv :1;
-  fStepZInv =  ( fStepZInv>1.e-4 ) ?fNz/fStepZInv :1;
+  fN = fNy * fNz;
+  fStepYInv = ( fYMax - fYMin );
+  fStepZInv = ( fZMax - fZMin );
+  //int ky = (fNy>1) ?fNy-1 :1;
+  //int kz = (fNz>1) ?fNz-1 :1;
+  fStepYInv =  ( fStepYInv > 1.e-4 ) ? fNy / fStepYInv : 1;
+  fStepZInv =  ( fStepZInv > 1.e-4 ) ? fNz / fStepZInv : 1;
 }
 
-GPUd() void AliHLTTPCCAGrid::Create( Float_t yMin, Float_t yMax, Float_t zMin, Float_t zMax, Float_t sy, Float_t sz )
+GPUd() void AliHLTTPCCAGrid::Create( float yMin, float yMax, float zMin, float zMax, float sy, float sz )
 {
   //* Create the grid
-  
-  fYMin = CAMath::Min(yMin,yMax);
-  fYMax = CAMath::Max(yMin,yMax)+.1;
-  fZMin = CAMath::Min(zMin,zMax);
-  fZMax = CAMath::Max(zMin,zMax)+.1;
-  fStepYInv = 1./sy;
-  fStepZInv = 1./sz;
 
-  fNy = (UInt_t) ( (fYMax - fYMin)*fStepYInv + 1 );
-  fNz = (UInt_t) ( (fZMax - fZMin)*fStepZInv + 1 );
-  fYMax = fYMin + fNy*sy; 
-  fZMax = fZMin + fNz*sz; 
-  fN = fNy*fNz;
+  fYMin = CAMath::Min( yMin, yMax );
+  fYMax = CAMath::Max( yMin, yMax ) + .1;
+  fZMin = CAMath::Min( zMin, zMax );
+  fZMax = CAMath::Max( zMin, zMax ) + .1;
+  fStepYInv = 1. / sy;
+  fStepZInv = 1. / sz;
+
+  fNy = ( unsigned int ) ( ( fYMax - fYMin ) * fStepYInv + 1 );
+  fNz = ( unsigned int ) ( ( fZMax - fZMin ) * fStepZInv + 1 );
+  fYMax = fYMin + fNy * sy;
+  fZMax = fZMin + fNz * sz;
+  fN = fNy * fNz;
 }
 
-GPUd() UInt_t AliHLTTPCCAGrid::GetBin( Float_t Y, Float_t Z ) const
+GPUd() unsigned int AliHLTTPCCAGrid::GetBin( float Y, float Z ) const
 {
   //* get the bin pointer
-  
-  Int_t bbY = (Int_t) CAMath::FMulRZ( Y-fYMin, fStepYInv );
-  Int_t bbZ = (Int_t) CAMath::FMulRZ( Z-fZMin, fStepZInv );
-  if( bbY<0 ) bbY = 0;
-  else if( bbY>=(Int_t)fNy ) bbY = fNy - 1;  
-  if( bbZ<0 ) bbZ = 0;
-  else if( bbZ>=(Int_t)fNz ) bbZ = fNz - 1;
-  Int_t bin = CAMath::Mul24(bbZ,fNy) + bbY;    
-  return (UInt_t) bin;
+
+  int bbY = ( int ) CAMath::FMulRZ( Y - fYMin, fStepYInv );
+  int bbZ = ( int ) CAMath::FMulRZ( Z - fZMin, fStepZInv );
+  if ( bbY < 0 ) bbY = 0;
+  else if ( bbY >= ( int )fNy ) bbY = fNy - 1;
+  if ( bbZ < 0 ) bbZ = 0;
+  else if ( bbZ >= ( int )fNz ) bbZ = fNz - 1;
+  int bin = CAMath::Mul24( bbZ, fNy ) + bbY;
+  return ( unsigned int ) bin;
 }
 
-GPUd() void AliHLTTPCCAGrid::GetBin( Float_t Y, Float_t Z, UInt_t &bY, UInt_t &bZ ) const
+GPUd() void AliHLTTPCCAGrid::GetBin( float Y, float Z, unsigned int &bY, unsigned int &bZ ) const
 {
   //* get the bin pointer
 
-  Int_t bbY = (Int_t) ( (Y-fYMin)*fStepYInv );
-  Int_t bbZ = (Int_t) ( (Z-fZMin)*fStepZInv );  
-  
-  if( bbY<0 ) bbY = 0;
-  else if( bbY>=(Int_t)fNy ) bbY = fNy - 1;  
-  if( bbZ<0 ) bbZ = 0;
-  else if( bbZ>=(Int_t)fNz ) bbZ = fNz - 1;
-  bY = (UInt_t) bbY;
-  bZ = (UInt_t) bbZ;
+  int bbY = ( int ) ( ( Y - fYMin ) * fStepYInv );
+  int bbZ = ( int ) ( ( Z - fZMin ) * fStepZInv );
+
+  if ( bbY < 0 ) bbY = 0;
+  else if ( bbY >= ( int )fNy ) bbY = fNy - 1;
+  if ( bbZ < 0 ) bbZ = 0;
+  else if ( bbZ >= ( int )fNz ) bbZ = fNz - 1;
+  bY = ( unsigned int ) bbY;
+  bZ = ( unsigned int ) bbZ;
 }
index eb61e76..2825d75 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // $Id$
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCAGrid
 {
- public:
-  
-  GPUd() void Create( Float_t yMin, Float_t yMax, Float_t zMin, Float_t zMax, UInt_t n );
-  GPUd() void Create( Float_t yMin, Float_t yMax, Float_t zMin, Float_t zMax, Float_t sy, Float_t sz  );
-  
-  GPUd() UInt_t GetBin( Float_t Y, Float_t Z ) const;
-  GPUd() void GetBin( Float_t Y, Float_t Z, UInt_t &bY, UInt_t &bZ ) const ;
-  
-  GPUd() UInt_t GetBinNoCheck( Float_t Y, Float_t Z ) const {
-    UInt_t bY = (UInt_t) ( (Y-fYMin)*fStepYInv );
-    UInt_t bZ = (UInt_t) ( (Z-fZMin)*fStepZInv );
-    return bZ*fNy + bY;
-  }
-  
-  GPUd() void GetBinNoCheck( Float_t Y, Float_t Z, UInt_t &bY, UInt_t &bZ ) const {
-    bY = (UInt_t) ( (Y-fYMin)*fStepYInv );
-    bZ = (UInt_t) ( (Z-fZMin)*fStepZInv );    
-  }
+  public:
 
+    GPUd() void Create( float yMin, float yMax, float zMin, float zMax, unsigned int n );
+    GPUd() void Create( float yMin, float yMax, float zMin, float zMax, float sy, float sz  );
 
-  GPUd() UInt_t  N()        const { return fN;  }
-  GPUd() UInt_t  Ny()       const { return fNy; }
-  GPUd() UInt_t  Nz()       const { return fNz; }
-  GPUd() Float_t YMin()     const { return fYMin; }
-  GPUd() Float_t YMax()     const { return fYMax; }
-  GPUd() Float_t ZMin()     const { return fZMin; }
-  GPUd() Float_t ZMax()     const { return fZMax; }
-  GPUd() Float_t StepYInv() const { return fStepYInv; }
-  GPUd() Float_t StepZInv() const { return fStepZInv; }
+    GPUd() unsigned int GetBin( float Y, float Z ) const;
+    GPUd() void GetBin( float Y, float Z, unsigned int &bY, unsigned int &bZ ) const ;
 
-private:
+    GPUd() unsigned int GetBinNoCheck( float Y, float Z ) const {
+      unsigned int bY = ( unsigned int ) ( ( Y - fYMin ) * fStepYInv );
+      unsigned int bZ = ( unsigned int ) ( ( Z - fZMin ) * fStepZInv );
+      return bZ*fNy + bY;
+    }
 
-  UInt_t fNy;        //* N bins in Y
-  UInt_t fNz;        //* N bins in Z
-  UInt_t fN;         //* total N bins
-  Float_t fYMin;     //* minimal Y value
-  Float_t fYMax;     //* maximal Y value
-  Float_t fZMin;     //* minimal Z value
-  Float_t fZMax;     //* maximal Z value
-  Float_t fStepYInv; //* inverse bin size in Y
-  Float_t fStepZInv; //* inverse bin size in Z
+    GPUd() void GetBinNoCheck( float Y, float Z, unsigned int &bY, unsigned int &bZ ) const {
+      bY = ( unsigned int ) ( ( Y - fYMin ) * fStepYInv );
+      bZ = ( unsigned int ) ( ( Z - fZMin ) * fStepZInv );
+    }
+
+
+    GPUd() unsigned int  N()        const { return fN;  }
+    GPUd() unsigned int  Ny()       const { return fNy; }
+    GPUd() unsigned int  Nz()       const { return fNz; }
+    GPUd() float YMin()     const { return fYMin; }
+    GPUd() float YMax()     const { return fYMax; }
+    GPUd() float ZMin()     const { return fZMin; }
+    GPUd() float ZMax()     const { return fZMax; }
+    GPUd() float StepYInv() const { return fStepYInv; }
+    GPUd() float StepZInv() const { return fStepZInv; }
+
+  private:
+
+    unsigned int fNy;        //* N bins in Y
+    unsigned int fNz;        //* N bins in Z
+    unsigned int fN;         //* total N bins
+    float fYMin;     //* minimal Y value
+    float fYMax;     //* maximal Y value
+    float fZMin;     //* minimal Z value
+    float fZMax;     //* maximal Z value
+    float fStepYInv; //* inverse bin size in Y
+    float fStepZInv; //* inverse bin size in Z
 
 };
 
index 9ea624f..2e40059 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // @(#) $Id$
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCAHit
 {
-public:
-  
-  GPUhd() Float_t Y() const   { return fY;    }
-  GPUhd() Float_t Z() const  { return fZ;    }
-
-  GPUhd() void SetY( Float_t v ){ fY = v;    }
-  GPUhd() void SetZ( Float_t v ){ fZ = v;    }
-  
-protected:
-  
-  Float_t fY, fZ;       // Y and Z position of the TPC cluster
-  
+  public:
+
+    GPUhd() float Y() const   { return fY;    }
+    GPUhd() float Z() const  { return fZ;    }
+
+    GPUhd() void SetY( float v ) { fY = v;    }
+    GPUhd() void SetZ( float v ) { fZ = v;    }
+
+  protected:
+
+    float fY, fZ;       // Y and Z position of the TPC cluster
+
 };
 
 
index 5dde989..178db69 100644 (file)
@@ -1,5 +1,5 @@
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 #include "AliHLTTPCCAHit.h"
 
 /*
-GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a,  AliHLTTPCCAGrid &grid, const UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
-{ 
+GPUd() void AliHLTTPCCAHitAreaInit( AliHLTTPCCAHitArea &a,  AliHLTTPCCAGrid &grid, const unsigned short *content, unsigned int hitoffset, float y, float z, float dy, float dz )
+{
   // initialisation
 
   a.HitOffset() = hitoffset;
   a.Y() = y;
   a.Z() = z;
-  a.MinZ() = z-dz; 
+  a.MinZ() = z-dz;
   a.MaxZ() = z+dz;
   a.MinY() = y-dy;
   a.MaxY() = y+dy;
-  UInt_t bYmin, bZmin, bYmax;  
+  unsigned int bYmin, bZmin, bYmax;
   grid.GetBin(a.MinY(), a.MinZ(), bYmin, bZmin);
-  grid.GetBin(a.MaxY(), a.MaxZ(), bYmax, a.BZmax());  
+  grid.GetBin(a.MaxY(), a.MaxZ(), bYmax, a.BZmax());
   a.BDY() = bYmax - bYmin + 1;
   a.Ny() = grid.Ny();
   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(); 
+  a.HitYlst() = content[a.IndYmin() + a.BDY()];
+  a.Ih() = a.HitYfst();
 }
 */
 
 
-GPUd() void AliHLTTPCCAHitArea::Init( const AliHLTTPCCAGrid &grid, const UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz )
-{ 
+GPUd() void AliHLTTPCCAHitArea::Init( const AliHLTTPCCAGrid &grid, const unsigned short *content, unsigned int hitoffset, float y, float z, float dy, float dz )
+{
   //initialisation
 
   fHitOffset = hitoffset;
   fY = y;
   fZ = z;
-  fMinZ = z-dz; 
-  fMaxZ = z+dz;
-  fMinY = y-dy;
-  fMaxY = y+dy;
-  UInt_t bYmin, bZmin, bYmax;  
-  grid.GetBin( fMinY, fMinZ, bYmin, bZmin);
-  grid.GetBin( fMaxY, fMaxZ, bYmax, fBZmax);  
+  fMinZ = z - dz;
+  fMaxZ = z + dz;
+  fMinY = y - dy;
+  fMaxY = y + dy;
+  unsigned int bYmin, bZmin, bYmax;
+  grid.GetBin( fMinY, fMinZ, bYmin, bZmin );
+  grid.GetBin( fMaxY, fMaxZ, bYmax, fBZmax );
   fBDY = bYmax - bYmin + 1;
   fNy = grid.Ny();
-  fIndYmin = bZmin*fNy + bYmin;
+  fIndYmin = bZmin * fNy + bYmin;
   fIz = bZmin;
   fHitYfst = content[fIndYmin];
-  fHitYlst = content[fIndYmin + fBDY];    
-  fIh = fHitYfst; 
+  fHitYlst = content[fIndYmin + fBDY];
+  fIh = fHitYfst;
 }
 
 
-GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content, AliHLTTPCCAHit &h)
-{    
+GPUd() int AliHLTTPCCAHitArea::GetNext( AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const unsigned short *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();
+  float y0 = row.Grid().YMin();
+  float z0 = row.Grid().ZMin();
+  float stepY = row.HstepY();
+  float stepZ = row.HstepZ();
   const uint4* tmpint4 = tracker.RowData() + row.FullOffset();
-  const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
+  const ushort2 *hits = reinterpret_cast<const ushort2*>( tmpint4 );
 
-  Int_t ret = -1;
-  do{
-    while( fIh>=fHitYlst ){
-      if( fIz>=fBZmax ) return -1;
+  int ret = -1;
+  do {
+    while ( fIh >= fHitYlst ) {
+      if ( fIz >= fBZmax ) return -1;
       fIz++;
       fIndYmin += fNy;
       fHitYfst = content[fIndYmin];
@@ -96,39 +96,39 @@ GPUd() Int_t AliHLTTPCCAHitArea::GetNext(AliHLTTPCCATracker &tracker, const AliH
       h.SetY( y0 + hh.x*stepY );
       h.SetZ( z0 + hh.y*stepZ );
     }
-    //h = tracker.Hits()[ fHitOffset + fIh ];    
-    
-    if( 1 && (h.Z()>fMaxZ || h.Z()<fMinZ || h.Y()<fMinY || h.Y()>fMaxY )){ //SG!!!
+    //h = tracker.Hits()[ fHitOffset + fIh ];
+
+    if ( 1 && ( h.Z() > fMaxZ || h.Z() < fMinZ || h.Y() < fMinY || h.Y() > fMaxY ) ) { //SG!!!
       fIh++;
       continue;
     }
     ret = fIh;
     fIh++;
     break;
-  } while(1);
-  return ret; 
+  } while ( 1 );
+  return ret;
 }
 
 
 
-GPUd() Int_t AliHLTTPCCAHitArea::GetBest(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content, AliHLTTPCCAHit &h)
+GPUd() int AliHLTTPCCAHitArea::GetBest( AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const unsigned short *content, AliHLTTPCCAHit &h )
 {
   // get closest hit in the area
-  Int_t best = -1;
-  Float_t ds = 1.e10;
-  do{
+  int best = -1;
+  float ds = 1.e10;
+  do {
     AliHLTTPCCAHit hh;
-    Int_t ih=GetNext( tracker, row, content, hh ); 
-    if( ih<0 ) break;
-    Float_t dy = hh.Y() - fY;
-    Float_t dz = hh.Z() - fZ;
-    Float_t dds = dy*dy+dz*dz;
-    if( dds<ds ){
+    int ih = GetNext( tracker, row, content, hh );
+    if ( ih < 0 ) break;
+    float dy = hh.Y() - fY;
+    float dz = hh.Z() - fZ;
+    float dds = dy * dy + dz * dz;
+    if ( dds < ds ) {
       ds = dds;
       best = ih;
       h = hh;
     }
-  }while(1);
+  } while ( 1 );
 
   return best;
 }
index 18c4cc3..b6ce9a3 100644 (file)
@@ -1,7 +1,7 @@
 //-*- Mode: C++ -*-
 // @(#) $Id: AliHLTTPCCARow.h 27042 2008-07-02 12:06:02Z richterm $
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -24,35 +24,35 @@ class AliHLTTPCCARow;
  */
 class AliHLTTPCCAHitArea
 {
-public:
-  
-  GPUd() void Init( const AliHLTTPCCAGrid &grid, const UShort_t *content, UInt_t hitoffset, Float_t y, Float_t z, Float_t dy, Float_t dz );
-
-  GPUd() Int_t GetNext(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content,AliHLTTPCCAHit &h);
-
-  GPUd() Int_t GetBest(AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const UShort_t *content,AliHLTTPCCAHit &h );
-
-  GPUhd() Float_t Y() const { return fY;}
-  GPUhd() Float_t Z() const { return fZ;}
-  GPUhd() Float_t MinZ() const { return fMinZ;}
-  GPUhd() Float_t MaxZ() const { return fMaxZ;}
-  GPUhd() Float_t MinY() const { return fMinY;}
-  GPUhd() Float_t MaxY() const { return fMaxY;}
-  GPUhd() UInt_t  BZmax() const { return fBZmax;}
-  GPUhd() UInt_t  BDY() const { return fBDY;}
-  GPUhd() UInt_t  IndYmin() const { return fIndYmin;}
-  GPUhd() UInt_t  Iz() const { return fIz;}
-  GPUhd() UInt_t  HitYfst() const { return fHitYfst;}
-  GPUhd() UInt_t  HitYlst() const { return fHitYlst;}
-  GPUhd() UInt_t  Ih() const { return fIh;}
-  GPUhd() UInt_t  Ny() const { return fNy;}
-  GPUhd() UInt_t  HitOffset() const { return fHitOffset;}
+  public:
+
+    GPUd() void Init( const AliHLTTPCCAGrid &grid, const unsigned short *content, unsigned int hitoffset, float y, float z, float dy, float dz );
+
+    GPUd() int GetNext( AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const unsigned short *content, AliHLTTPCCAHit &h );
+
+    GPUd() int GetBest( AliHLTTPCCATracker &tracker, const AliHLTTPCCARow &row, const unsigned short *content, AliHLTTPCCAHit &h );
+
+    GPUhd() float Y() const { return fY;}
+    GPUhd() float Z() const { return fZ;}
+    GPUhd() float MinZ() const { return fMinZ;}
+    GPUhd() float MaxZ() const { return fMaxZ;}
+    GPUhd() float MinY() const { return fMinY;}
+    GPUhd() float MaxY() const { return fMaxY;}
+    GPUhd() unsigned int  BZmax() const { return fBZmax;}
+    GPUhd() unsigned int  BDY() const { return fBDY;}
+    GPUhd() unsigned int  IndYmin() const { return fIndYmin;}
+    GPUhd() unsigned int  Iz() const { return fIz;}
+    GPUhd() unsigned int  HitYfst() const { return fHitYfst;}
+    GPUhd() unsigned int  HitYlst() const { return fHitYlst;}
+    GPUhd() unsigned int  Ih() const { return fIh;}
+    GPUhd() unsigned int  Ny() const { return fNy;}
+    GPUhd() unsigned int  HitOffset() const { return fHitOffset;}
 
   protected:
 
-  Float_t fY, fZ, fMinZ, fMaxZ, fMinY, fMaxY;    // search coordinates
-  UInt_t fBZmax, fBDY, fIndYmin, fIz, fHitYfst, fHitYlst, fIh, fNy; // !
-  UInt_t fHitOffset; // global hit offset
+    float fY, fZ, fMinZ, fMaxZ, fMinY, fMaxY;    // search coordinates
+    unsigned int fBZmax, fBDY, fIndYmin, fIz, fHitYfst, fHitYlst, fIh, fNy; // !
+    unsigned int fHitOffset; // global hit offset
 };
 
 #endif
index e96acfb..64d14cb 100644 (file)
@@ -1,6 +1,6 @@
 // $Id: AliHLTTPCCAMCPoint.cxx 27042 2008-07-02 12:06:02Z richterm $
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
@@ -21,7 +21,7 @@
 
 
 AliHLTTPCCAMCPoint::AliHLTTPCCAMCPoint()
-  : fX(0), fY(0), fZ(0), fSx(0), fSy(0), fSz(0), fTime(0), fISlice(0), fTrackID(0)
+    : fX( 0 ), fY( 0 ), fZ( 0 ), fSx( 0 ), fSy( 0 ), fSz( 0 ), fTime( 0 ), fISlice( 0 ), fTrackID( 0 )
 {
   //* Default constructor
 }
index 9eea00f..5cbfaec 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCAMCPoint
 {
- public:
-
-  AliHLTTPCCAMCPoint();
-
-  Float_t  X()           const { return fX; }
-  Float_t  Y()           const { return fY; }
-  Float_t  Z()           const { return fZ; }
-  Float_t  Sx()          const { return fSx; }
-  Float_t  Sy()          const { return fSy; }
-  Float_t  Sz()          const { return fSz; }
-  Float_t  Time()        const { return fTime; }
-  Int_t    ISlice()      const { return fISlice; }
-  Int_t    TrackID()     const { return fTrackID; }
-
-  void SetX( Float_t v )           { fX=v; }
-  void SetY( Float_t v )           { fY=v; }
-  void SetZ( Float_t v )           { fZ=v; }
-  void SetSx( Float_t v )          { fSx=v; }
-  void SetSy( Float_t v )          { fSy=v; }
-  void SetSz( Float_t v )          { fSz=v; }
-  void SetTime( Float_t v )        { fTime=v; }
-  void SetISlice( Int_t v )      { fISlice=v; }
-  void SetTrackID( Int_t v )     { fTrackID=v; }
-
-  static Bool_t Compare( const AliHLTTPCCAMCPoint &p1, const AliHLTTPCCAMCPoint &p2 )
-    {
-      return (p1.fTrackID < p2.fTrackID);
+  public:
+
+    AliHLTTPCCAMCPoint();
+
+    float  X()           const { return fX; }
+    float  Y()           const { return fY; }
+    float  Z()           const { return fZ; }
+    float  Sx()          const { return fSx; }
+    float  Sy()          const { return fSy; }
+    float  Sz()          const { return fSz; }
+    float  Time()        const { return fTime; }
+    int    ISlice()      const { return fISlice; }
+    int    TrackID()     const { return fTrackID; }
+
+    void SetX( float v )           { fX = v; }
+    void SetY( float v )           { fY = v; }
+    void SetZ( float v )           { fZ = v; }
+    void SetSx( float v )          { fSx = v; }
+    void SetSy( float v )          { fSy = v; }
+    void SetSz( float v )          { fSz = v; }
+    void SetTime( float v )        { fTime = v; }
+    void SetISlice( int v )      { fISlice = v; }
+    void SetTrackID( int v )     { fTrackID = v; }
+
+    static bool Compare( const AliHLTTPCCAMCPoint &p1, const AliHLTTPCCAMCPoint &p2 ) {
+      return ( p1.fTrackID < p2.fTrackID );
     }
-  
- protected:
-
-  Float_t fX;         //* global X position
-  Float_t fY;         //* global Y position
-  Float_t fZ;         //* global Z position
-  Float_t fSx;        //* slice X position
-  Float_t fSy;        //* slice Y position
-  Float_t fSz;        //* slice Z position
-  Float_t fTime;      //* time 
-  Int_t   fISlice;    //* slice number
-  Int_t   fTrackID;   //* mc track number
+
+  protected:
+
+    float fX;         //* global X position
+    float fY;         //* global Y position
+    float fZ;         //* global Z position
+    float fSx;        //* slice X position
+    float fSy;        //* slice Y position
+    float fSz;        //* slice Z position
+    float fTime;      //* time
+    int   fISlice;    //* slice number
+    int   fTrackID;   //* mc track number
 };
 
 #endif
index 3064cdb..ae302ce 100644 (file)
@@ -1,6 +1,6 @@
 // $Id$
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 
 
 AliHLTTPCCAMCTrack::AliHLTTPCCAMCTrack()
-  : fPDG(0), fP(0), fPt(0), fNHits(0), fNMCPoints(0), fFirstMCPointID(0), fNReconstructed(0), fSet(0), fNTurns(0)
+    : fPDG( 0 ), fP( 0 ), fPt( 0 ), fNHits( 0 ), fNMCPoints( 0 ), fFirstMCPointID( 0 ), fNReconstructed( 0 ), fSet( 0 ), fNTurns( 0 )
 {
   //* Default constructor
 }
 
 
 AliHLTTPCCAMCTrack::AliHLTTPCCAMCTrack( const TParticle *part )
-  : fPDG(0), fP(0), fPt(0), fNHits(0), fNMCPoints(0), fFirstMCPointID(0), fNReconstructed(0), fSet(0), fNTurns(0)
+    : fPDG( 0 ), fP( 0 ), fPt( 0 ), fNHits( 0 ), fNMCPoints( 0 ), fFirstMCPointID( 0 ), fNReconstructed( 0 ), fSet( 0 ), fNTurns( 0 )
 {
   //* Constructor from TParticle
 
-  for( Int_t i=0; i<7; i++ ) fPar[i] = 0;
-  for( Int_t i=0; i<7; i++ ) fTPCPar[i] = 0;
+  for ( int i = 0; i < 7; i++ ) fPar[i] = 0;
+  for ( int i = 0; i < 7; i++ ) fTPCPar[i] = 0;
   fP = 0;
   fPt = 0;
 
-  if( !part ) return;
+  if ( !part ) return;
   TLorentzVector mom, vtx;
-  part->ProductionVertex(vtx);
-  part->Momentum(mom);
+  part->ProductionVertex( vtx );
+  part->Momentum( mom );
   fPar[0] = part->Vx();
   fPar[1] = part->Vy();
   fPar[2] = part->Vz();
   fP = part->P();
   fPt = part->Pt();
-  Double_t pi = ( fP >1.e-4 ) ?1./fP :0;
-  fPar[3] = part->Px()*pi;
-  fPar[4] = part->Py()*pi;
-  fPar[5] = part->Pz()*pi;
+  double pi = ( fP > 1.e-4 ) ? 1. / fP : 0;
+  fPar[3] = part->Px() * pi;
+  fPar[4] = part->Py() * pi;
+  fPar[5] = part->Pz() * pi;
   fPar[6] = 0;
-  fPDG  = part->GetPdgCode();    
-  if ( CAMath::Abs(fPDG) < 100000 ){
-    TParticlePDG *pPDG = TDatabasePDG::Instance()->GetParticle(fPDG);
-    if( pPDG ) fPar[6] = pPDG->Charge()/3.0*pi;
+  fPDG  = part->GetPdgCode();
+  if ( CAMath::Abs( fPDG ) < 100000 ) {
+    TParticlePDG *pPDG = TDatabasePDG::Instance()->GetParticle( fPDG );
+    if ( pPDG ) fPar[6] = pPDG->Charge() / 3.0 * pi;
   }
 }
 
-void AliHLTTPCCAMCTrack::SetTPCPar( Float_t X, Float_t Y, Float_t Z,
-                                   Float_t Px, Float_t Py, Float_t Pz )
+void AliHLTTPCCAMCTrack::SetTPCPar( float X, float Y, float Z,
+                                    float Px, float Py, float Pz )
 {
   //* Set parameters at TPC entrance
 
-  for( Int_t i=0; i<7; i++ ) fTPCPar[i] = 0;
+  for ( int i = 0; i < 7; i++ ) fTPCPar[i] = 0;
 
   fTPCPar[0] = X;
   fTPCPar[1] = Y;
   fTPCPar[2] = Z;
-  Double_t p = CAMath::Sqrt(Px*Px + Py*Py + Pz*Pz);
-  Double_t pi = ( p >1.e-4 ) ?1./p :0;
-  fTPCPar[3] = Px*pi;
-  fTPCPar[4] = Py*pi;
-  fTPCPar[5] = Pz*pi;
+  double p = CAMath::Sqrt( Px * Px + Py * Py + Pz * Pz );
+  double pi = ( p > 1.e-4 ) ? 1. / p : 0;
+  fTPCPar[3] = Px * pi;
+  fTPCPar[4] = Py * pi;
+  fTPCPar[5] = Pz * pi;
   fTPCPar[6] = 0;
-  if ( CAMath::Abs(fPDG) < 100000 ){
-    TParticlePDG *pPDG = TDatabasePDG::Instance()->GetParticle(fPDG);
-    if( pPDG ) fTPCPar[6] = pPDG->Charge()/3.0*pi;
+  if ( CAMath::Abs( fPDG ) < 100000 ) {
+    TParticlePDG *pPDG = TDatabasePDG::Instance()->GetParticle( fPDG );
+    if ( pPDG ) fTPCPar[6] = pPDG->Charge() / 3.0 * pi;
   }
 }
index d2c9d07..14c326e 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -20,51 +20,51 @@ class TParticle;
  */
 class AliHLTTPCCAMCTrack
 {
- public:
+  public:
 
-  AliHLTTPCCAMCTrack();
-  AliHLTTPCCAMCTrack( const TParticle *part );
+    AliHLTTPCCAMCTrack();
+    AliHLTTPCCAMCTrack( const TParticle *part );
 
-  void SetTPCPar( Float_t X, Float_t Y, Float_t Z, Float_t Px, Float_t Py, Float_t Pz );
+    void SetTPCPar( float X, float Y, float Z, float Px, float Py, float Pz );
 
-  Int_t     PDG()            const { return fPDG;}
-  const Double_t *Par()            const { return fPar; }
-  const Double_t *TPCPar()         const { return fTPCPar; }
-  Double_t  P()              const { return fP; }
-  Double_t  Pt()             const { return fPt; }
-  
-  Int_t     NHits()          const { return fNHits;}
-  Int_t     NMCPoints()      const { return fNMCPoints;}
-  Int_t     FirstMCPointID() const { return fFirstMCPointID;}
-  Int_t     NReconstructed() const { return fNReconstructed; }
-  Int_t     Set()            const { return fSet; }
-  Int_t     NTurns()         const { return fNTurns; }
+    int     PDG()            const { return fPDG;}
+    const double *Par()            const { return fPar; }
+    const double *TPCPar()         const { return fTPCPar; }
+    double  P()              const { return fP; }
+    double  Pt()             const { return fPt; }
 
-  void SetP ( Float_t v )          { fP = v; }
-  void SetPt( Float_t v )          { fPt = v; }
-  void SetPDG( Int_t v )         { fPDG = v; }
-  void SetPar( Int_t i, Double_t v)             { fPar[i] = v; }
-  void SetTPCPar( Int_t i, Double_t v)          { fTPCPar[i] = v; }
-  void SetNHits( Int_t v )         { fNHits = v; }
-  void SetNMCPoints( Int_t v)      { fNMCPoints = v; }
-  void SetFirstMCPointID( Int_t v ){ fFirstMCPointID = v;}
-  void SetNReconstructed( Int_t v ){ fNReconstructed = v; }
-  void SetSet( Int_t v )           { fSet = v; }
-  void SetNTurns( Int_t v )        { fNTurns = v; }
-  
- protected:
+    int     NHits()          const { return fNHits;}
+    int     NMCPoints()      const { return fNMCPoints;}
+    int     FirstMCPointID() const { return fFirstMCPointID;}
+    int     NReconstructed() const { return fNReconstructed; }
+    int     Set()            const { return fSet; }
+    int     NTurns()         const { return fNTurns; }
+
+    void SetP ( float v )          { fP = v; }
+    void SetPt( float v )          { fPt = v; }
+    void SetPDG( int v )         { fPDG = v; }
+    void SetPar( int i, double v )             { fPar[i] = v; }
+    void SetTPCPar( int i, double v )          { fTPCPar[i] = v; }
+    void SetNHits( int v )         { fNHits = v; }
+    void SetNMCPoints( int v )      { fNMCPoints = v; }
+    void SetFirstMCPointID( int v ) { fFirstMCPointID = v;}
+    void SetNReconstructed( int v ) { fNReconstructed = v; }
+    void SetSet( int v )           { fSet = v; }
+    void SetNTurns( int v )        { fNTurns = v; }
+
+  protected:
+
+    int    fPDG;            //* particle pdg code
+    double fPar[7];         //* x,y,z,ex,ey,ez,q/p
+    double fTPCPar[7];      //* x,y,z,ex,ey,ez,q/p at TPC entrance (x=y=0 means no information)
+    double fP, fPt;         //* momentum and transverse momentum
+    int    fNHits;          //* N TPC clusters
+    int    fNMCPoints;      //* N MC points
+    int    fFirstMCPointID; //* id of the first MC point in the points array
+    int    fNReconstructed; //* how many times is reconstructed
+    int    fSet;            //* set of tracks 0-OutSet, 1-ExtraSet, 2-RefSet
+    int    fNTurns;         //* N of turns in the current sector
 
-  Int_t    fPDG;            //* particle pdg code
-  Double_t fPar[7];         //* x,y,z,ex,ey,ez,q/p
-  Double_t fTPCPar[7];      //* x,y,z,ex,ey,ez,q/p at TPC entrance (x=y=0 means no information)
-  Double_t fP, fPt;         //* momentum and transverse momentum
-  Int_t    fNHits;          //* N TPC clusters
-  Int_t    fNMCPoints;      //* N MC points 
-  Int_t    fFirstMCPointID; //* id of the first MC point in the points array
-  Int_t    fNReconstructed; //* how many times is reconstructed
-  Int_t    fSet;            //* set of tracks 0-OutSet, 1-ExtraSet, 2-RefSet 
-  Int_t    fNTurns;         //* N of turns in the current sector
-  
 };
 
 #endif
index c52364b..66783d5 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  */
 class AliHLTTPCCAMath
 {
-public:
-  GPUd() static float2 MakeFloat2(float x, float y );
-
-  GPUd() static Float_t Min(Float_t x, Float_t y);
-  GPUd() static Float_t Max(Float_t x, Float_t y);
-  GPUd() static Int_t Min(Int_t x, Int_t y);
-  GPUd() static Int_t Max(Int_t x, Int_t y);
-  GPUd() static Float_t Sqrt(Float_t x );
-  GPUd() static Float_t Abs(Float_t x );
-  GPUd() static Double_t Abs(Double_t x );
-  GPUd() static Int_t Abs(Int_t x );
-  GPUd() static Float_t ASin(Float_t x );
-  GPUd() static Float_t ATan2( Float_t y, Float_t x );
-  GPUd() static Float_t Sin( Float_t x );
-  GPUd() static Float_t Cos( Float_t x );
-  GPUd() static Float_t Tan( Float_t x );
-  GPUd() static Float_t Copysign( Float_t x, Float_t y );  
-  GPUd() static Float_t TwoPi(){ return 6.28319; }
-  GPUd() static Float_t Pi(){ return 3.1415926535897; }
-  GPUd() static Int_t Nint(Float_t x );
-  GPUd() static Bool_t Finite(Float_t x );
-
-  GPUd()  static Int_t AtomicExch( Int_t *addr, Int_t val);
-  GPUd()  static Int_t AtomicAdd ( Int_t *addr, Int_t val);
-  GPUd()  static Int_t AtomicMax ( Int_t *addr, Int_t val);
-  GPUd()  static Int_t AtomicMin ( Int_t *addr, Int_t val);
-  GPUd()  static Int_t Mul24( Int_t a, Int_t b );
-  GPUd()  static Float_t FMulRZ( Float_t a, Float_t b );
+  public:
+    GPUd() static float2 MakeFloat2( float x, float y );
+
+    GPUd() static float Min( float x, float y );
+    GPUd() static float Max( float x, float y );
+    GPUd() static int Min( int x, int y );
+    GPUd() static int Max( int x, int y );
+    GPUd() static float Sqrt( float x );
+    GPUd() static float Abs( float x );
+    GPUd() static double Abs( double x );
+    GPUd() static int Abs( int x );
+    GPUd() static float ASin( float x );
+    GPUd() static float ATan2( float y, float x );
+    GPUd() static float Sin( float x );
+    GPUd() static float Cos( float x );
+    GPUd() static float Tan( float x );
+    GPUd() static float Copysign( float x, float y );
+    GPUd() static float TwoPi() { return 6.28319; }
+    GPUd() static float Pi() { return 3.1415926535897; }
+    GPUd() static int Nint( float x );
+    GPUd() static bool Finite( float x );
+
+    GPUd()  static int AtomicExch( int *addr, int val );
+    GPUd()  static int AtomicAdd ( int *addr, int val );
+    GPUd()  static int AtomicMax ( int *addr, int val );
+    GPUd()  static int AtomicMin ( int *addr, int val );
+    GPUd()  static int Mul24( int a, int b );
+    GPUd()  static float FMulRZ( float a, float b );
 };
 
 typedef AliHLTTPCCAMath CAMath;
@@ -65,168 +65,168 @@ typedef AliHLTTPCCAMath CAMath;
 #define choice(c1,c2,c3) c3
 #endif
 
-GPUd() inline float2 AliHLTTPCCAMath::MakeFloat2(float x, float y )
+GPUd() inline float2 AliHLTTPCCAMath::MakeFloat2( float x, float y )
 {
 #if !defined( HLTCA_GPUCODE )
-  float2 ret = {x,y};
+  float2 ret = {x, y};
   return ret;
 #else
-  return make_float2(x,y);
+  return make_float2( x, y );
 #endif
 }
 
 
-GPUd() inline Int_t AliHLTTPCCAMath::Nint(Float_t x)
-{  
+GPUd() inline int AliHLTTPCCAMath::Nint( float x )
+{
 #if defined(HLTCA_STANDALONE) || defined( HLTCA_GPUCODE )
-  Int_t i;
-  if (x >= 0) {
-    i = int(x + 0.5);
-    if (x + 0.5 == Float_t(i) && i & 1) i--;
+  int i;
+  if ( x >= 0 ) {
+    i = int( x + 0.5 );
+    if ( x + 0.5 == float( i ) && i & 1 ) i--;
   } else {
-    i = int(x - 0.5);
-    if (x - 0.5 == Float_t(i) && i & 1) i++;    
+    i = int( x - 0.5 );
+    if ( x - 0.5 == float( i ) && i & 1 ) i++;
   }
   return i;
 #else
-  return TMath::Nint(x);
+  return TMath::Nint( x );
 #endif
 }
 
-GPUd() inline Bool_t AliHLTTPCCAMath::Finite(Float_t x)
-{  
-  return choice( 1, finite(x), finite(x) );
+GPUd() inline bool AliHLTTPCCAMath::Finite( float x )
+{
+  return choice( 1, finite( x ), finite( x ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::ATan2(Float_t y, Float_t x)
-{ 
-  return choice(atan2f(y,x), atan2(y,x), TMath::ATan2(y,x) );
+GPUd() inline float AliHLTTPCCAMath::ATan2( float y, float x )
+{
+  return choice( atan2f( y, x ), atan2( y, x ), TMath::ATan2( y, x ) );
 }
 
 
-GPUd() inline Float_t AliHLTTPCCAMath::Copysign(Float_t x, Float_t y)
-{ 
+GPUd() inline float AliHLTTPCCAMath::Copysign( float x, float y )
+{
 #if defined( HLTCA_GPUCODE )
-  return copysignf(x,y);
+  return copysignf( x, y );
 #else
-  x = CAMath::Abs(x);
-  return (y>=0) ?x : -x;
+  x = CAMath::Abs( x );
+  return ( y >= 0 ) ? x : -x;
 #endif
 }
 
 
-GPUd() inline Float_t AliHLTTPCCAMath::Sin(Float_t x)
-{ 
-  return choice( sinf(x), sin(x), TMath::Sin(x) );
+GPUd() inline float AliHLTTPCCAMath::Sin( float x )
+{
+  return choice( sinf( x ), sin( x ), TMath::Sin( x ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::Cos(Float_t x)
-{ 
-  return choice( cosf(x), cos(x), TMath::Cos(x) );
+GPUd() inline float AliHLTTPCCAMath::Cos( float x )
+{
+  return choice( cosf( x ), cos( x ), TMath::Cos( x ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::Tan(Float_t x)
-{ 
-  return choice( tanf(x), tan(x), TMath::Tan(x) );
+GPUd() inline float AliHLTTPCCAMath::Tan( float x )
+{
+  return choice( tanf( x ), tan( x ), TMath::Tan( x ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::Min(Float_t x, Float_t y)
-{ 
-  return choice( fminf(x,y),  (x<y ?x :y), TMath::Min(x,y) );
+GPUd() inline float AliHLTTPCCAMath::Min( float x, float y )
+{
+  return choice( fminf( x, y ),  ( x < y ? x : y ), TMath::Min( x, y ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::Max(Float_t x, Float_t y)
-{ 
-  return choice( fmaxf(x,y),  (x>y ?x :y), TMath::Max(x,y) );
+GPUd() inline float AliHLTTPCCAMath::Max( float x, float y )
+{
+  return choice( fmaxf( x, y ),  ( x > y ? x : y ), TMath::Max( x, y ) );
 }
 
-GPUd() inline Int_t AliHLTTPCCAMath::Min(Int_t x, Int_t y)
-{ 
-  return choice( min(x,y),  (x<y ?x :y), TMath::Min(x,y) );
+GPUd() inline int AliHLTTPCCAMath::Min( int x, int y )
+{
+  return choice( min( x, y ),  ( x < y ? x : y ), TMath::Min( x, y ) );
 }
 
-GPUd() inline Int_t AliHLTTPCCAMath::Max(Int_t x, Int_t y)
-{ 
-  return choice( max(x,y),  (x>y ?x :y), TMath::Max(x,y) );
+GPUd() inline int AliHLTTPCCAMath::Max( int x, int y )
+{
+  return choice( max( x, y ),  ( x > y ? x : y ), TMath::Max( x, y ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::Sqrt(Float_t x )
-{ 
-  return choice( sqrtf(x), sqrt(x), TMath::Sqrt(x) );
+GPUd() inline float AliHLTTPCCAMath::Sqrt( float x )
+{
+  return choice( sqrtf( x ), sqrt( x ), TMath::Sqrt( x ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::Abs(Float_t x )
-{ 
-  return choice( fabsf(x), fabs(x), TMath::Abs(x) );
+GPUd() inline float AliHLTTPCCAMath::Abs( float x )
+{
+  return choice( fabsf( x ), fabs( x ), TMath::Abs( x ) );
 }
 
-GPUd() inline Double_t AliHLTTPCCAMath::Abs(Double_t x )
-{ 
-  return choice( fabs(x), fabs(x), TMath::Abs(x) );
+GPUd() inline double AliHLTTPCCAMath::Abs( double x )
+{
+  return choice( fabs( x ), fabs( x ), TMath::Abs( x ) );
 }
 
-GPUd() inline Int_t AliHLTTPCCAMath::Abs(Int_t x )
-{ 
-  return choice( abs(x), (x>=0 ?x :-x), TMath::Abs(x) );
+GPUd() inline int AliHLTTPCCAMath::Abs( int x )
+{
+  return choice( abs( x ), ( x >= 0 ? x : -x ), TMath::Abs( x ) );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::ASin(Float_t x )
-{ 
-  return choice( asinf(x), asin(x), TMath::ASin(x) );
+GPUd() inline float AliHLTTPCCAMath::ASin( float x )
+{
+  return choice( asinf( x ), asin( x ), TMath::ASin( x ) );
 }
 
 
-GPUd() inline Int_t AliHLTTPCCAMath::Mul24( Int_t a, Int_t b )
+GPUd() inline int AliHLTTPCCAMath::Mul24( int a, int b )
 {
-  return choice( __mul24(a,b), a*b, a*b );
+  return choice( __mul24( a, b ), a*b, a*b );
 }
 
-GPUd() inline Float_t AliHLTTPCCAMath::FMulRZ( Float_t a, Float_t b )
+GPUd() inline float AliHLTTPCCAMath::FMulRZ( float a, float b )
 {
-  return choice( __fmul_rz(a,b), a*b, a*b );
+  return choice( __fmul_rz( a, b ), a*b, a*b );
 }
 
 
-GPUd()  inline Int_t AliHLTTPCCAMath::AtomicExch( Int_t *addr, Int_t val)
+GPUd()  inline int AliHLTTPCCAMath::AtomicExch( int *addr, int val )
 {
 #if defined( HLTCA_GPUCODE )
-  return ::atomicExch(addr, val );
-#else  
-  Int_t old = *addr;
+  return ::atomicExch( addr, val );
+#else
+  int old = *addr;
   *addr = val;
   return old;
 #endif
 }
 
-GPUd()  inline Int_t AliHLTTPCCAMath::AtomicAdd ( Int_t *addr, Int_t val)
+GPUd()  inline int AliHLTTPCCAMath::AtomicAdd ( int *addr, int val )
 {
 #if defined( HLTCA_GPUCODE )
-  return ::atomicAdd(addr, val );
-#else  
-  Int_t old = *addr;
+  return ::atomicAdd( addr, val );
+#else
+  int old = *addr;
   *addr += val;
   return old;
 #endif
 }
 
-GPUd()  inline Int_t AliHLTTPCCAMath::AtomicMax ( Int_t *addr, Int_t val)
+GPUd()  inline int AliHLTTPCCAMath::AtomicMax ( int *addr, int val )
 {
 #if defined( HLTCA_GPUCODE )
-  return ::atomicMax(addr, val );
-#else  
-  Int_t old = *addr;
-  if( *addr< val ) *addr = val;
+  return ::atomicMax( addr, val );
+#else
+  int old = *addr;
+  if ( *addr < val ) *addr = val;
   return old;
 #endif
 }
 
-GPUd()  inline Int_t AliHLTTPCCAMath::AtomicMin ( Int_t *addr, Int_t val)
+GPUd()  inline int AliHLTTPCCAMath::AtomicMin ( int *addr, int val )
 {
 #if defined( HLTCA_GPUCODE )
-  return ::atomicMin(addr, val );
-#else  
-  Int_t old = *addr;
-  if( *addr> val ) *addr = val;
+  return ::atomicMin( addr, val );
+#else
+  int old = *addr;
+  if ( *addr > val ) *addr = val;
   return old;
 #endif
 }
index 771c4e3..1c8b6d0 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -16,9 +16,9 @@
  * @class AliHLTTPCCAMergedTrack
  * AliHLTTPCCAMergedTrack class is used to store TPC tracks,
  * which are reconstructed by the TPCCATracker slice tracker.
- * 
+ *
  * The class contains:
- * - fitted track parameters at its first row, the covariance matrix, \Chi^2, NDF (number of degrees of freedom ) 
+ * - fitted track parameters at its first row, the covariance matrix, \Chi^2, NDF (number of degrees of freedom )
  * - n of clusters assigned to the track
  * - index of its first cluster in corresponding cluster arrays
  *
  */
 class AliHLTTPCCAMergedTrack
 {
- public:
-
-  GPUhd() Int_t NClusters()                         const { return fNClusters;       }
-  GPUhd() Int_t FirstClusterRef()                   const { return fFirstClusterRef; }
-  GPUhd() const AliHLTTPCCATrackParam &InnerParam() const { return fInnerParam;      }
-  GPUhd() const AliHLTTPCCATrackParam &OuterParam() const { return fOuterParam;      }
-  GPUhd() Float_t InnerAlpha()                      const { return fInnerAlpha;      }
-  GPUhd() Float_t OuterAlpha()                      const { return fOuterAlpha;      }
-
-  GPUhd() void SetNClusters      ( Int_t v )                  { fNClusters = v;       }
-  GPUhd() void SetFirstClusterRef( Int_t v )                  { fFirstClusterRef = v; }
-  GPUhd() void SetInnerParam( const AliHLTTPCCATrackParam &v) { fInnerParam = v;      }
-  GPUhd() void SetOuterParam( const AliHLTTPCCATrackParam &v) { fOuterParam = v;      }
-  GPUhd() void SetInnerAlpha( Float_t v )                       { fInnerAlpha = v;      }
-  GPUhd() void SetOuterAlpha( Float_t v )                       { fOuterAlpha = v;      }
-
- private:
-  
-  AliHLTTPCCATrackParam fInnerParam; //* fitted track parameters at the TPC inner radius
-  AliHLTTPCCATrackParam fOuterParam; //* fitted track parameters at the TPC outer radius
-  Float_t fInnerAlpha;               //* alpha angle for the inner parameters
-  Float_t fOuterAlpha;               //* alpha angle for the outer parameters
-  Int_t fFirstClusterRef;            //* index of the first track cluster in corresponding cluster arrays
-  Int_t fNClusters;                  //* number of track clusters
+  public:
+
+    GPUhd() int NClusters()                         const { return fNClusters;       }
+    GPUhd() int FirstClusterRef()                   const { return fFirstClusterRef; }
+    GPUhd() const AliHLTTPCCATrackParam &InnerParam() const { return fInnerParam;      }
+    GPUhd() const AliHLTTPCCATrackParam &OuterParam() const { return fOuterParam;      }
+    GPUhd() float InnerAlpha()                      const { return fInnerAlpha;      }
+    GPUhd() float OuterAlpha()                      const { return fOuterAlpha;      }
+
+    GPUhd() void SetNClusters      ( int v )                  { fNClusters = v;       }
+    GPUhd() void SetFirstClusterRef( int v )                  { fFirstClusterRef = v; }
+    GPUhd() void SetInnerParam( const AliHLTTPCCATrackParam &v ) { fInnerParam = v;      }
+    GPUhd() void SetOuterParam( const AliHLTTPCCATrackParam &v ) { fOuterParam = v;      }
+    GPUhd() void SetInnerAlpha( float v )                       { fInnerAlpha = v;      }
+    GPUhd() void SetOuterAlpha( float v )                       { fOuterAlpha = v;      }
+
+  private:
+
+    AliHLTTPCCATrackParam fInnerParam; //* fitted track parameters at the TPC inner radius
+    AliHLTTPCCATrackParam fOuterParam; //* fitted track parameters at the TPC outer radius
+    float fInnerAlpha;               //* alpha angle for the inner parameters
+    float fOuterAlpha;               //* alpha angle for the outer parameters
+    int fFirstClusterRef;            //* index of the first track cluster in corresponding cluster arrays
+    int fNClusters;                  //* number of track clusters
 };
 
 
index 869713e..c7b61ea 100644 (file)
@@ -1,6 +1,6 @@
 // $Id: AliHLTTPCCAMerger.cxx 30732 2009-01-22 23:02:02Z sgorbuno $
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 
 class AliHLTTPCCAMerger::AliHLTTPCCAClusterInfo
 {
-  
-public:
-  
-  UInt_t  ISlice()    const { return fISlice;    }
-  UInt_t  IRow()      const { return fIRow;      }
-  UInt_t  IClu()      const { return fIClu;      }
-  UChar_t PackedAmp() const { return fPackedAmp; }
-  Float_t X()         const { return fX;         }
-  Float_t Y()         const { return fY;         }
-  Float_t Z()         const { return fZ;         }
-  Float_t Err2Y()     const { return fErr2Y;     }
-  Float_t Err2Z()     const { return fErr2Z;     }
-    
-  void SetISlice    ( UInt_t v  ) { fISlice    = v; }
-  void SetIRow      ( UInt_t v  ) { fIRow      = v; }
-  void SetIClu      ( UInt_t v  ) { fIClu      = v; }
-  void SetPackedAmp ( UChar_t v ) { fPackedAmp = v; }
-  void SetX         ( Float_t v ) { fX         = v; } 
-  void SetY         ( Float_t v ) { fY         = v; } 
-  void SetZ         ( Float_t v ) { fZ         = v; } 
-  void SetErr2Y     ( Float_t v ) { fErr2Y     = v; } 
-  void SetErr2Z     ( Float_t v ) { fErr2Z     = v; } 
-  
-private:
-  
-  UInt_t fISlice;            // slice number
-  UInt_t fIRow;              // row number
-  UInt_t fIClu;              // cluster number
-  UChar_t fPackedAmp; // packed cluster amplitude
-  Float_t fX;                // x position (slice coord.system)
-  Float_t fY;                // y position (slice coord.system)
-  Float_t fZ;                // z position (slice coord.system)
-  Float_t fErr2Y;            // Squared measurement error of y position
-  Float_t fErr2Z;            // Squared measurement error of z position
+
+  public:
+
+    unsigned int  ISlice()    const { return fISlice;    }
+    unsigned int  IRow()      const { return fIRow;      }
+    unsigned int  IClu()      const { return fIClu;      }
+    UChar_t PackedAmp() const { return fPackedAmp; }
+    float X()         const { return fX;         }
+    float Y()         const { return fY;         }
+    float Z()         const { return fZ;         }
+    float Err2Y()     const { return fErr2Y;     }
+    float Err2Z()     const { return fErr2Z;     }
+
+    void SetISlice    ( unsigned int v  ) { fISlice    = v; }
+    void SetIRow      ( unsigned int v  ) { fIRow      = v; }
+    void SetIClu      ( unsigned int v  ) { fIClu      = v; }
+    void SetPackedAmp ( UChar_t v ) { fPackedAmp = v; }
+    void SetX         ( float v ) { fX         = v; }
+    void SetY         ( float v ) { fY         = v; }
+    void SetZ         ( float v ) { fZ         = v; }
+    void SetErr2Y     ( float v ) { fErr2Y     = v; }
+    void SetErr2Z     ( float v ) { fErr2Z     = v; }
+
+  private:
+
+    unsigned int fISlice;            // slice number
+    unsigned int fIRow;              // row number
+    unsigned int fIClu;              // cluster number
+    UChar_t fPackedAmp; // packed cluster amplitude
+    float fX;                // x position (slice coord.system)
+    float fY;                // y position (slice coord.system)
+    float fZ;                // z position (slice coord.system)
+    float fErr2Y;            // Squared measurement error of y position
+    float fErr2Z;            // Squared measurement error of z position
 };
 
 
 class AliHLTTPCCAMerger::AliHLTTPCCASliceTrackInfo
 {
 
-public:
-
-  const AliHLTTPCCATrackParam &InnerParam() const { return fInnerParam;      }
-  const AliHLTTPCCATrackParam &OuterParam() const { return fOuterParam;      }  
-  Float_t InnerAlpha()                      const { return fInnerAlpha;      }
-  Float_t OuterAlpha()                      const { return fOuterAlpha;      }
-  Int_t   NClusters()                       const { return fNClusters;       }
-  Int_t   FirstClusterRef()                 const { return fFirstClusterRef; }
-  Int_t   PrevNeighbour()                   const { return fPrevNeighbour;   }
-  Int_t   NextNeighbour()                   const { return fNextNeighbour;   }
-  Bool_t  Used()                            const { return fUsed;            }
-  
-  void SetInnerParam( const AliHLTTPCCATrackParam &v ) { fInnerParam = v;      }
-  void SetOuterParam( const AliHLTTPCCATrackParam &v ) { fOuterParam = v;      }
-  void SetInnerAlpha( Float_t v )                      { fInnerAlpha = v;      }
-  void SetOuterAlpha( Float_t v )                      { fOuterAlpha = v;      }
-  void SetNClusters ( Int_t v )                        { fNClusters = v;       }
-  void SetFirstClusterRef( Int_t v )                   { fFirstClusterRef = v; }
-  void SetPrevNeighbour( Int_t v )                     { fPrevNeighbour = v;   }
-  void SetNextNeighbour( Int_t v )                     { fNextNeighbour = v;   }
-  void SetUsed( Bool_t v )                             { fUsed = v;            }
-
-private:
-
-  AliHLTTPCCATrackParam fInnerParam; // inner parameters
-  AliHLTTPCCATrackParam fOuterParam; // outer parameters
-  Float_t fInnerAlpha;               // alpha angle for inner parameters
-  Float_t fOuterAlpha;               // alpha angle for outer parameters
-  Int_t fNClusters;                  // N clusters
-  Int_t fFirstClusterRef;  // index of the first track cluster in the global cluster array
-  Int_t fPrevNeighbour;    // neighbour in the previous slise
-  Int_t fNextNeighbour;    // neighbour in the next slise
-  Bool_t fUsed;            // is the slice track already merged
+  public:
+
+    const AliHLTTPCCATrackParam &InnerParam() const { return fInnerParam;      }
+    const AliHLTTPCCATrackParam &OuterParam() const { return fOuterParam;      }
+    float InnerAlpha()                      const { return fInnerAlpha;      }
+    float OuterAlpha()                      const { return fOuterAlpha;      }
+    int   NClusters()                       const { return fNClusters;       }
+    int   FirstClusterRef()                 const { return fFirstClusterRef; }
+    int   PrevNeighbour()                   const { return fPrevNeighbour;   }
+    int   NextNeighbour()                   const { return fNextNeighbour;   }
+    bool  Used()                            const { return fUsed;            }
+
+    void SetInnerParam( const AliHLTTPCCATrackParam &v ) { fInnerParam = v;      }
+    void SetOuterParam( const AliHLTTPCCATrackParam &v ) { fOuterParam = v;      }
+    void SetInnerAlpha( float v )                      { fInnerAlpha = v;      }
+    void SetOuterAlpha( float v )                      { fOuterAlpha = v;      }
+    void SetNClusters ( int v )                        { fNClusters = v;       }
+    void SetFirstClusterRef( int v )                   { fFirstClusterRef = v; }
+    void SetPrevNeighbour( int v )                     { fPrevNeighbour = v;   }
+    void SetNextNeighbour( int v )                     { fNextNeighbour = v;   }
+    void SetUsed( bool v )                             { fUsed = v;            }
+
+  private:
+
+    AliHLTTPCCATrackParam fInnerParam; // inner parameters
+    AliHLTTPCCATrackParam fOuterParam; // outer parameters
+    float fInnerAlpha;               // alpha angle for inner parameters
+    float fOuterAlpha;               // alpha angle for outer parameters
+    int fNClusters;                  // N clusters
+    int fFirstClusterRef;  // index of the first track cluster in the global cluster array
+    int fPrevNeighbour;    // neighbour in the previous slise
+    int fNextNeighbour;    // neighbour in the next slise
+    bool fUsed;            // is the slice track already merged
 
 };
 
@@ -120,43 +120,43 @@ private:
 class AliHLTTPCCAMerger::AliHLTTPCCABorderTrack
 {
 
-public:
-  const AliHLTTPCCATrackParam &Param() const { return fParam;     }
-  Int_t   TrackID()                    const { return fTrackID;   }
-  Int_t   NClusters()                  const { return fNClusters; }
-  Int_t   IRow()                       const { return fIRow;      }
-  Float_t X()                          const { return fX;         }
-  Bool_t  OK()                         const { return fOK;        }
-  
-  void SetParam     ( const AliHLTTPCCATrackParam &v ) { fParam     = v; }
-  void SetTrackID   ( Int_t v )                        { fTrackID   = v; }
-  void SetNClusters ( Int_t v )                        { fNClusters = v; }
-  void SetIRow      ( Int_t v )                        { fIRow      = v; }
-  void SetX         ( Float_t v )                      { fX         = v; }
-  void SetOK        ( Bool_t v )                       { fOK        = v; }
-
-private:
-
-  AliHLTTPCCATrackParam fParam;  // track parameters at the border
-  Int_t   fTrackID;              // track index
-  Int_t   fNClusters;            // n clusters
-  Int_t   fIRow;                 // row number of the closest cluster
-  Float_t fX;                    // X coordinate of the closest cluster
-  Bool_t  fOK;                   // is the track rotated and extrapolated correctly
+  public:
+
+    const AliHLTTPCCATrackParam &Param() const { return fParam;     }
+    int   TrackID()                    const { return fTrackID;   }
+    int   NClusters()                  const { return fNClusters; }
+    int   IRow()                       const { return fIRow;      }
+    float X()                          const { return fX;         }
+    bool  OK()                         const { return fOK;        }
+
+    void SetParam     ( const AliHLTTPCCATrackParam &v ) { fParam     = v; }
+    void SetTrackID   ( int v )                        { fTrackID   = v; }
+    void SetNClusters ( int v )                        { fNClusters = v; }
+    void SetIRow      ( int v )                        { fIRow      = v; }
+    void SetX         ( float v )                      { fX         = v; }
+    void SetOK        ( bool v )                       { fOK        = v; }
+
+  private:
+
+    AliHLTTPCCATrackParam fParam;  // track parameters at the border
+    int   fTrackID;              // track index
+    int   fNClusters;            // n clusters
+    int   fIRow;                 // row number of the closest cluster
+    float fX;                    // X coordinate of the closest cluster
+    bool  fOK;                   // is the track rotated and extrapolated correctly
 
 };
 
 
 
 AliHLTTPCCAMerger::AliHLTTPCCAMerger()
-  :
-  fSliceParam(),
-  fOutput(0),  
-  fTrackInfos(0),
-  fMaxTrackInfos(0),
-  fClusterInfos(0),
-  fMaxClusterInfos(0)
+    :
+    fSliceParam(),
+    fOutput( 0 ),
+    fTrackInfos( 0 ),
+    fMaxTrackInfos( 0 ),
+    fClusterInfos( 0 ),
+    fMaxClusterInfos( 0 )
 {
   //* constructor
   Clear();
@@ -164,10 +164,10 @@ AliHLTTPCCAMerger::AliHLTTPCCAMerger()
 
 /*
 AliHLTTPCCAMerger::AliHLTTPCCAMerger(const AliHLTTPCCAMerger&)
-  : 
+  :
   fSliceParam(),
   fkSlices(0),
-  fOutput(0),  
+  fOutput(0),
   fTrackInfos(0),
   fMaxTrackInfos(0),
   fClusterInfos(0),
@@ -184,9 +184,9 @@ const AliHLTTPCCAMerger &AliHLTTPCCAMerger::operator=(const AliHLTTPCCAMerger&)
 AliHLTTPCCAMerger::~AliHLTTPCCAMerger()
 {
   //* destructor
-  if( fTrackInfos ) delete[] fTrackInfos;
-  if( fClusterInfos ) delete[] fClusterInfos;
-  if( fOutput ) delete[] ((char*)(fOutput));
+  if ( fTrackInfos ) delete[] fTrackInfos;
+  if ( fClusterInfos ) delete[] fClusterInfos;
+  if ( fOutput ) delete[] ( ( char* )( fOutput ) );
 }
 
 void AliHLTTPCCAMerger::Clear()
@@ -215,104 +215,104 @@ void AliHLTTPCCAMerger::UnpackSlices()
   //* unpack the cluster information from the slice tracks and initialize track info array
 
   // get N tracks and N clusters in event
-  
-  Int_t nTracksTotal=0;
-  Int_t nTrackClustersTotal=0;
-  for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
-    if( !fkSlices[iSlice] ) continue;
-    nTracksTotal+=fkSlices[iSlice]->NTracks();
-    nTrackClustersTotal+=fkSlices[iSlice]->NTrackClusters();    
+
+  int nTracksTotal = 0;
+  int nTrackClustersTotal = 0;
+  for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
+    if ( !fkSlices[iSlice] ) continue;
+    nTracksTotal += fkSlices[iSlice]->NTracks();
+    nTrackClustersTotal += fkSlices[iSlice]->NTrackClusters();
   }
 
   // book/clean memory if necessary
   {
-    if( nTracksTotal>fMaxTrackInfos || ( fMaxTrackInfos>100 && nTracksTotal< 0.5*fMaxTrackInfos ) ){
-      if( fTrackInfos ) delete[] fTrackInfos;
-      fMaxTrackInfos = (Int_t ) (nTracksTotal*1.2);
+    if ( nTracksTotal > fMaxTrackInfos || ( fMaxTrackInfos > 100 && nTracksTotal < 0.5*fMaxTrackInfos ) ) {
+      if ( fTrackInfos ) delete[] fTrackInfos;
+      fMaxTrackInfos = ( int ) ( nTracksTotal * 1.2 );
       fTrackInfos = new AliHLTTPCCASliceTrackInfo[fMaxTrackInfos];
     }
 
-    if( nTrackClustersTotal>fMaxClusterInfos || ( fMaxClusterInfos>1000 && nTrackClustersTotal< 0.5*fMaxClusterInfos ) ){
-      if( fClusterInfos ) delete[] fClusterInfos;
-      fMaxClusterInfos = (Int_t ) (nTrackClustersTotal*1.2);
+    if ( nTrackClustersTotal > fMaxClusterInfos || ( fMaxClusterInfos > 1000 && nTrackClustersTotal < 0.5*fMaxClusterInfos ) ) {
+      if ( fClusterInfos ) delete[] fClusterInfos;
+      fMaxClusterInfos = ( int ) ( nTrackClustersTotal * 1.2 );
       fClusterInfos = new AliHLTTPCCAClusterInfo [fMaxClusterInfos];
     }
 
-    if( fOutput ) delete[] ( (char*)(fOutput));
-    Int_t size = fOutput->EstimateSize(nTracksTotal, nTrackClustersTotal);
-    fOutput = (AliHLTTPCCAMergerOutput*)(new float2[size/sizeof(float2)+1]);
+    if ( fOutput ) delete[] ( ( char* )( fOutput ) );
+    int size = fOutput->EstimateSize( nTracksTotal, nTrackClustersTotal );
+    fOutput = ( AliHLTTPCCAMergerOutput* )( new float2[size/sizeof( float2 )+1] );
   }
 
   // unpack track and cluster information
-  
-  Int_t nTracksCurrent = 0; 
-  Int_t nClustersCurrent = 0;
 
-  for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
+  int nTracksCurrent = 0;
+  int nClustersCurrent = 0;
+
+  for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
 
     fSliceTrackInfoStart[ iSlice ] = nTracksCurrent;
     fSliceNTrackInfos[ iSlice ] = 0;
-    if( !fkSlices[iSlice] ) continue;
 
-    const AliHLTTPCCASliceOutput &slice = *(fkSlices[iSlice]);
+    if ( !fkSlices[iSlice] ) continue;
 
-    for( Int_t itr=0; itr<slice.NTracks(); itr++ ){
+    const AliHLTTPCCASliceOutput &slice = *( fkSlices[iSlice] );
+
+    for ( int itr = 0; itr < slice.NTracks(); itr++ ) {
 
       const AliHLTTPCCASliceTrack &sTrack = slice.Track( itr );
       AliHLTTPCCATrackParam t0 = sTrack.Param();
-      Int_t nCluNew = 0;
-      
-      for( Int_t iTrClu=0; iTrClu<sTrack.NClusters(); iTrClu++ ){
-
-       // unpack cluster information
-
-       AliHLTTPCCAClusterInfo &clu = fClusterInfos[nClustersCurrent + nCluNew];
-       Int_t ic = sTrack.FirstClusterRef() + iTrClu;
-
-       clu.SetISlice( iSlice );
-       clu.SetIRow( AliHLTTPCCADataCompressor::IDrc2IRow( slice.ClusterIDrc( ic ) ) );
-       clu.SetIClu( AliHLTTPCCADataCompressor::IDrc2IClu( slice.ClusterIDrc( ic ) ) ); 
-       clu.SetPackedAmp( slice.ClusterPackedAmp( ic ) );
-       float2 yz = slice.ClusterUnpackedYZ( ic );
-       clu.SetX( slice.ClusterUnpackedX( ic ) );
-       clu.SetY( yz.x );
-       clu.SetZ( yz.y );
-
-       if( !t0.TransportToX( fSliceParam.RowX( clu.IRow() ), fSliceParam.GetBz(t0), .999 ) ) continue;
-
-       Float_t err2Y, err2Z;
-       fSliceParam.GetClusterErrors2( clu.IRow(), clu.Z(), t0.SinPhi(), t0.GetCosPhi(), t0.DzDs(), err2Y, err2Z );
-       
-       clu.SetErr2Y( err2Y );
-       clu.SetErr2Z( err2Z );
-       nCluNew++ ;
+      int nCluNew = 0;
+
+      for ( int iTrClu = 0; iTrClu < sTrack.NClusters(); iTrClu++ ) {
+
+        // unpack cluster information
+
+        AliHLTTPCCAClusterInfo &clu = fClusterInfos[nClustersCurrent + nCluNew];
+        int ic = sTrack.FirstClusterRef() + iTrClu;
+
+        clu.SetISlice( iSlice );
+        clu.SetIRow( AliHLTTPCCADataCompressor::IDrc2IRow( slice.ClusterIDrc( ic ) ) );
+        clu.SetIClu( AliHLTTPCCADataCompressor::IDrc2IClu( slice.ClusterIDrc( ic ) ) );
+        clu.SetPackedAmp( slice.ClusterPackedAmp( ic ) );
+        float2 yz = slice.ClusterUnpackedYZ( ic );
+        clu.SetX( slice.ClusterUnpackedX( ic ) );
+        clu.SetY( yz.x );
+        clu.SetZ( yz.y );
+
+        if ( !t0.TransportToX( fSliceParam.RowX( clu.IRow() ), fSliceParam.GetBz( t0 ), .999 ) ) continue;
+
+        float err2Y, err2Z;
+        fSliceParam.GetClusterErrors2( clu.IRow(), clu.Z(), t0.SinPhi(), t0.GetCosPhi(), t0.DzDs(), err2Y, err2Z );
+
+        clu.SetErr2Y( err2Y );
+        clu.SetErr2Z( err2Z );
+        nCluNew++ ;
       }
 
-      if( nCluNew<.8*sTrack.NClusters() ) continue;
-      
-      // refit the track 
-      
-      Int_t hits[1000];
-      Int_t nHits = nCluNew; 
-      for( Int_t i=0; i<nHits; i++ ) hits[i] = nClustersCurrent + i;
+      if ( nCluNew < .8*sTrack.NClusters() ) continue;
+
+      // refit the track
+
+      int hits[1000];
+      int nHits = nCluNew;
+      for ( int i = 0; i < nHits; i++ ) hits[i] = nClustersCurrent + i;
 
       AliHLTTPCCATrackParam startPoint = sTrack.Param();
       AliHLTTPCCATrackParam endPoint = startPoint;
-      Float_t startAlpha = fSliceParam.Alpha( iSlice );
-      Float_t endAlpha = startAlpha;
-      if( !FitTrack( endPoint, endAlpha, startPoint, startAlpha, hits, nHits, 0 ) ) continue;
+      float startAlpha = fSliceParam.Alpha( iSlice );
+      float endAlpha = startAlpha;
+
+      if ( !FitTrack( endPoint, endAlpha, startPoint, startAlpha, hits, nHits, 0 ) ) continue;
 
       startPoint = endPoint;
       startAlpha = endAlpha;
-      if( !FitTrack( startPoint, startAlpha, endPoint, endAlpha, hits, nHits, 1 ) ) continue;
+      if ( !FitTrack( startPoint, startAlpha, endPoint, endAlpha, hits, nHits, 1 ) ) continue;
 
-      if( nHits<.8*sTrack.NClusters() ) continue;
+      if ( nHits < .8*sTrack.NClusters() ) continue;
 
       // store the track
-      
-      AliHLTTPCCASliceTrackInfo &track = fTrackInfos[nTracksCurrent];      
+
+      AliHLTTPCCASliceTrackInfo &track = fTrackInfos[nTracksCurrent];
 
       track.SetInnerParam( startPoint );
       track.SetInnerAlpha( startAlpha );
@@ -323,12 +323,12 @@ void AliHLTTPCCAMerger::UnpackSlices()
       track.SetPrevNeighbour( -1 );
       track.SetNextNeighbour( -1 );
       track.SetUsed( 0 );
-      
-      for( Int_t i=0; i<nHits; i++ ) 
-       fClusterInfos[nClustersCurrent + i] = fClusterInfos[hits[i]];
+
+      for ( int i = 0; i < nHits; i++ )
+        fClusterInfos[nClustersCurrent + i] = fClusterInfos[hits[i]];
       nTracksCurrent++;
       fSliceNTrackInfos[ iSlice ]++;
-      nClustersCurrent+=nHits;      
+      nClustersCurrent += nHits;
     }
     //std::cout<<"Unpack slice "<<iSlice<<": ntracks "<<slice.NTracks()<<"/"<<fSliceNTrackInfos[iSlice]<<std::endl;
   }
@@ -336,43 +336,43 @@ void AliHLTTPCCAMerger::UnpackSlices()
 
 
 
-Bool_t AliHLTTPCCAMerger::FitTrack( AliHLTTPCCATrackParam &T, Float_t &Alpha, 
-                                   AliHLTTPCCATrackParam t0, Float_t Alpha0, 
-                                   Int_t hits[], Int_t &NTrackHits, Bool_t dir )
+bool AliHLTTPCCAMerger::FitTrack( AliHLTTPCCATrackParam &T, float &Alpha,
+                                    AliHLTTPCCATrackParam t0, float Alpha0,
+                                    int hits[], int &NTrackHits, bool dir )
 {
   // Fit the track
 
   AliHLTTPCCATrackParam::AliHLTTPCCATrackFitParam fitPar;
   AliHLTTPCCATrackParam t = t0;
-  AliHLTTPCCATrackLinearisation l(t0);
+  AliHLTTPCCATrackLinearisation l( t0 );
+
+  bool first = 1;
 
-  Bool_t first = 1;
   t.CalculateFitParameters( fitPar );
 
-  Int_t hitsNew[1000];
-  Int_t nHitsNew = 0;
+  int hitsNew[1000];
+  int nHitsNew = 0;
+
+  for ( int ihit = 0; ihit < NTrackHits; ihit++ ) {
 
-  for( Int_t ihit=0; ihit<NTrackHits; ihit++){
-    
-    Int_t jhit = dir ?(NTrackHits-1-ihit) :ihit;
+    int jhit = dir ? ( NTrackHits - 1 - ihit ) : ihit;
     AliHLTTPCCAClusterInfo &h = fClusterInfos[hits[jhit]];
 
-    Int_t iSlice = h.ISlice();
+    int iSlice = h.ISlice();
 
-    Float_t sliceAlpha =  fSliceParam.Alpha( iSlice );
+    float sliceAlpha =  fSliceParam.Alpha( iSlice );
 
-    if( CAMath::Abs( sliceAlpha - Alpha0)>1.e-4 ){
-      if( ! t.Rotate(  sliceAlpha - Alpha0, l, .999 ) ) continue;
+    if ( CAMath::Abs( sliceAlpha - Alpha0 ) > 1.e-4 ) {
+      if ( ! t.Rotate(  sliceAlpha - Alpha0, l, .999 ) ) continue;
       Alpha0 = sliceAlpha;
     }
 
-    //Float_t x = fSliceParam.RowX( h.IRow() );
-    Float_t x = h.X();
-    
-    if( !t.TransportToXWithMaterial( x, l, fitPar, fSliceParam.GetBz(t) ) ) continue;
-    
-    if( first ){
+    //float x = fSliceParam.RowX( h.IRow() );
+    float x = h.X();
+
+    if ( !t.TransportToXWithMaterial( x, l, fitPar, fSliceParam.GetBz( t ) ) ) continue;
+
+    if ( first ) {
       t.SetCov( 0, 10 );
       t.SetCov( 1,  0 );
       t.SetCov( 2, 10 );
@@ -383,234 +383,234 @@ Bool_t AliHLTTPCCAMerger::FitTrack( AliHLTTPCCATrackParam &T, Float_t &Alpha,
       t.SetCov( 7,  0 );
       t.SetCov( 8,  0 );
       t.SetCov( 9,  1 );
-      t.SetCov(10,  0 );
-      t.SetCov(11,  0 );
-      t.SetCov(12,  0 );
-      t.SetCov(13,  0 );
-      t.SetCov(14,  10 );
+      t.SetCov( 10,  0 );
+      t.SetCov( 11,  0 );
+      t.SetCov( 12,  0 );
+      t.SetCov( 13,  0 );
+      t.SetCov( 14,  10 );
       t.SetChi2( 0 );
       t.SetNDF( -5 );
       t.CalculateFitParameters( fitPar );
     }
-  
-    if( !t.Filter( h.Y(), h.Z(), h.Err2Y(), h.Err2Z() ) ) continue;                
+
+    if ( !t.Filter( h.Y(), h.Z(), h.Err2Y(), h.Err2Z() ) ) continue;
 
     first = 0;
 
     hitsNew[nHitsNew++] = hits[jhit];
   }
-  
-  if( CAMath::Abs(t.QPt())<1.e-8 ) t.SetQPt( 1.e-8 );
-  
-  Bool_t ok=1;
-  
-  const Float_t *c = t.Cov();
-  for( Int_t i=0; i<15; i++ ) ok = ok && finite(c[i]);
-  for( Int_t i=0; i<5; i++ ) ok = ok && finite(t.Par()[i]);
-  ok = ok && (t.GetX()>50);
-  
-  if( c[0]<=0 || c[2]<=0 || c[5]<=0 || c[9]<=0 || c[14]<=0 ) ok = 0;
-  if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2. ) ok = 0;
-  
-  if( CAMath::Abs(t.SinPhi())>.99 ) ok = 0;
-  else if( l.CosPhi()>=0 ) t.SetSignCosPhi( 1 );
+
+  if ( CAMath::Abs( t.QPt() ) < 1.e-8 ) t.SetQPt( 1.e-8 );
+
+  bool ok = 1;
+
+  const float *c = t.Cov();
+  for ( int i = 0; i < 15; i++ ) ok = ok && finite( c[i] );
+  for ( int i = 0; i < 5; i++ ) ok = ok && finite( t.Par()[i] );
+  ok = ok && ( t.GetX() > 50 );
+
+  if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0;
+  if ( c[0] > 5. || c[2] > 5. || c[5] > 2. || c[9] > 2 || c[14] > 2. ) ok = 0;
+
+  if ( CAMath::Abs( t.SinPhi() ) > .99 ) ok = 0;
+  else if ( l.CosPhi() >= 0 ) t.SetSignCosPhi( 1 );
   else t.SetSignCosPhi( -1 );
 
-  if( ok ){
+  if ( ok ) {
     T = t;
     Alpha = Alpha0;
     NTrackHits = nHitsNew;
-    for( Int_t i=0; i<NTrackHits; i++ ){
-      hits[dir ?(NTrackHits-1-i) :i] = hitsNew[i];
+    for ( int i = 0; i < NTrackHits; i++ ) {
+      hits[dir ?( NTrackHits-1-i ) :i] = hitsNew[i];
     }
   }
   return ok;
 }
 
 
-Float_t AliHLTTPCCAMerger::GetChi2( Float_t x1, Float_t y1, Float_t a00, Float_t a10, Float_t a11, 
-                                   Float_t x2, Float_t y2, Float_t b00, Float_t b10, Float_t b11  )
+float AliHLTTPCCAMerger::GetChi2( float x1, float y1, float a00, float a10, float a11,
+                                    float x2, float y2, float b00, float b10, float b11  )
 {
-  //* Calculate Chi2/ndf deviation   
+  //* Calculate Chi2/ndf deviation
+
+  float d[2] = { x1 - x2, y1 - y2 };
 
-  Float_t d[2]={ x1-x2, y1-y2 };
+  float mSi[3] = { a00 + b00, a10 + b10, a11 + b11 };
 
-  Float_t mSi[3] = { a00 + b00, a10 + b10, a11 + b11 };
+  float s = ( mSi[0] * mSi[2] - mSi[1] * mSi[1] );
 
-  Float_t s = ( mSi[0]*mSi[2] - mSi[1]*mSi[1] );
+  if ( s < 1.E-10 ) return 10000.;
 
-  if( s < 1.E-10 ) return 10000.;
-    
-  Float_t mS[3] = { mSi[2], -mSi[1], mSi[0] };      
+  float mS[3] = { mSi[2], -mSi[1], mSi[0] };
 
   return TMath::Abs( ( ( mS[0]*d[0] + mS[1]*d[1] )*d[0]
-                      +(mS[1]*d[0] + mS[2]*d[1] )*d[1] )/s/2);
+                       + ( mS[1]*d[0] + mS[2]*d[1] )*d[1] ) / s / 2 );
 
 }
 
-  
 
-void AliHLTTPCCAMerger::MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLTTPCCABorderTrack B[], Int_t &nB )
+
+void AliHLTTPCCAMerger::MakeBorderTracks( int iSlice, int iBorder, AliHLTTPCCABorderTrack B[], int &nB )
 {
   //* prepare slice tracks for merging with next/previous/same sector
-  //* each track transported to the border line, 
-  //* in some cases both inner and outer parameters of the track are transported 
-
-  static int statAll=0, statOK=0;  
-  nB = 0;  
-  Float_t dAlpha = fSliceParam.DAlpha() /2;
-  Float_t x0 = 0;
-
-  if( iBorder==0 ){ // transport to the left age of the sector and rotate horisontally
-    dAlpha = dAlpha - CAMath::Pi()/2 ;
-  } else if( iBorder==1 ){ //  transport to the right age of the sector and rotate horisontally
-    dAlpha = -dAlpha - CAMath::Pi()/2 ;  
-  } else if( iBorder==2 ){ // transport to the left age of the sector and rotate vertically
+  //* each track transported to the border line,
+  //* in some cases both inner and outer parameters of the track are transported
+
+  static int statAll = 0, statOK = 0;
+  nB = 0;
+  float dAlpha = fSliceParam.DAlpha() / 2;
+  float x0 = 0;
+
+  if ( iBorder == 0 ) { // transport to the left age of the sector and rotate horisontally
+    dAlpha = dAlpha - CAMath::Pi() / 2 ;
+  } else if ( iBorder == 1 ) { //  transport to the right age of the sector and rotate horisontally
+    dAlpha = -dAlpha - CAMath::Pi() / 2 ;
+  } else if ( iBorder == 2 ) { // transport to the left age of the sector and rotate vertically
     dAlpha = dAlpha;
     x0 = fSliceParam.RowX( 63 );
-  }else if( iBorder==3 ){ // transport to the right age of the sector and rotate vertically
+  } else if ( iBorder == 3 ) { // transport to the right age of the sector and rotate vertically
     dAlpha = -dAlpha;
     x0 =  fSliceParam.RowX( 63 );
-  } else if( iBorder==4 ){ // transport to the middle of the sector, w/o rotation
+  } else if ( iBorder == 4 ) { // transport to the middle of the sector, w/o rotation
     dAlpha = 0;
-    x0 = fSliceParam.RowX(63);
+    x0 = fSliceParam.RowX( 63 );
   }
 
-  for (Int_t itr=0; itr<fSliceNTrackInfos[iSlice]; itr++) {
+  for ( int itr = 0; itr < fSliceNTrackInfos[iSlice]; itr++ ) {
 
     const AliHLTTPCCASliceTrackInfo &track = fTrackInfos[ fSliceTrackInfoStart[iSlice] + itr ];
 
     AliHLTTPCCATrackParam t0 = track.InnerParam();
     AliHLTTPCCATrackParam t1 = track.OuterParam();
 
-    const Float_t maxSin = CAMath::Sin(60./180.*CAMath::Pi());
+    const float maxSin = CAMath::Sin( 60. / 180.*CAMath::Pi() );
+
+    bool ok0 = t0.Rotate( dAlpha, maxSin );
+    bool ok1 = t1.Rotate( dAlpha, maxSin );
 
-    Bool_t ok0 = t0.Rotate( dAlpha, maxSin );
-    Bool_t ok1 = t1.Rotate( dAlpha, maxSin );
-    
-    Bool_t do0 = ok0;
-    Bool_t do1 = ok1 && ( !ok0 || t1.SignCosPhi()*t0.SignCosPhi()<0 );
-    
-    if( ok0 && !do1 && ok1 && (t1.X() < t0.X()) ){
+    bool do0 = ok0;
+    bool do1 = ok1 && ( !ok0 || t1.SignCosPhi() * t0.SignCosPhi() < 0 );
+
+    if ( ok0 && !do1 && ok1 && ( t1.X() < t0.X() ) ) {
       do0 = 0;
       do1 = 1;
     }
 
-    if( do0 ){
+    if ( do0 ) {
       AliHLTTPCCABorderTrack &b = B[nB];
       b.SetX( t0.GetX() );
-      if( t0.TransportToX( x0, fSliceParam.GetBz(t0), maxSin ) ){
-       b.SetOK( 1 );
-       b.SetTrackID( itr );
-       b.SetNClusters( track.NClusters() );
-       b.SetIRow( fClusterInfos[ track.FirstClusterRef() + 0 ].IRow() );
-       b.SetParam( t0 );
-       nB++;
+      if ( t0.TransportToX( x0, fSliceParam.GetBz( t0 ), maxSin ) ) {
+        b.SetOK( 1 );
+        b.SetTrackID( itr );
+        b.SetNClusters( track.NClusters() );
+        b.SetIRow( fClusterInfos[ track.FirstClusterRef() + 0 ].IRow() );
+        b.SetParam( t0 );
+        nB++;
       }
     }
-    if( do1 ){
+    if ( do1 ) {
       AliHLTTPCCABorderTrack &b = B[nB];
       b.SetX( t1.GetX() );
-      if( t1.TransportToX( x0, fSliceParam.GetBz(t1), maxSin ) ){
-       b.SetOK( 1 );
-       b.SetTrackID( itr );
-       b.SetNClusters( track.NClusters() );
-       b.SetIRow( fClusterInfos[ track.FirstClusterRef() + track.NClusters()-1 ].IRow() );
-       b.SetParam( t1 );  
-       nB++;
+      if ( t1.TransportToX( x0, fSliceParam.GetBz( t1 ), maxSin ) ) {
+        b.SetOK( 1 );
+        b.SetTrackID( itr );
+        b.SetNClusters( track.NClusters() );
+        b.SetIRow( fClusterInfos[ track.FirstClusterRef() + track.NClusters()-1 ].IRow() );
+        b.SetParam( t1 );
+        nB++;
       }
     }
-    if( do0 || do1 ) statOK++;
+    if ( do0 || do1 ) statOK++;
     statAll++;
   }
 }
 
 
 
-void AliHLTTPCCAMerger::SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTrack B1[], Int_t N1,
-                                          Int_t iSlice2, AliHLTTPCCABorderTrack B2[], Int_t N2 
-                                          )
+void AliHLTTPCCAMerger::SplitBorderTracks( int iSlice1, AliHLTTPCCABorderTrack B1[], int N1,
+    int iSlice2, AliHLTTPCCABorderTrack B2[], int N2
+                                         )
 {
   //* split two sets of tracks
 
-  Float_t factor2ys = 1.;//1.5;//SG!!!
-  Float_t factor2zt = 1.;//1.5;//SG!!!
-  Float_t factor2k = 2.0;//2.2;
+  float factor2ys = 1.;//1.5;//SG!!!
+  float factor2zt = 1.;//1.5;//SG!!!
+  float factor2k = 2.0;//2.2;
 
-  factor2k  = 3.5*3.5*factor2k*factor2k;
-  factor2ys = 3.5*3.5*factor2ys*factor2ys;
-  factor2zt = 3.5*3.5*factor2zt*factor2zt;
+  factor2k  = 3.5 * 3.5 * factor2k * factor2k;
+  factor2ys = 3.5 * 3.5 * factor2ys * factor2ys;
+  factor2zt = 3.5 * 3.5 * factor2zt * factor2zt;
 
-  Int_t minNPartHits = 10;//SG!!!
-  Int_t minNTotalHits = 20;
+  int minNPartHits = 10;//SG!!!
+  int minNTotalHits = 20;
 
-  //Float_t maxDX = fSliceParam.RowX(40) -  fSliceParam.RowX(0);
+  //float maxDX = fSliceParam.RowX(40) -  fSliceParam.RowX(0);
 
-  for (Int_t i1=0; i1<N1; i1++) {      
+  for ( int i1 = 0; i1 < N1; i1++ ) {
     AliHLTTPCCABorderTrack &b1 = B1[i1];
-    if( !b1.OK() ) continue;
-    if( b1.NClusters() < minNPartHits ) continue;
+    if ( !b1.OK() ) continue;
+    if ( b1.NClusters() < minNPartHits ) continue;
     const AliHLTTPCCATrackParam &t1 = b1.Param();
-    Int_t iBest2 = -1;
-    Int_t lBest2 = 0;
-    Int_t start2 = (iSlice1!=iSlice2) ?0 :i1+1;
-    for (Int_t i2=start2; i2<N2; i2++) {
+    int iBest2 = -1;
+    int lBest2 = 0;
+    int start2 = ( iSlice1 != iSlice2 ) ? 0 : i1 + 1;
+    for ( int i2 = start2; i2 < N2; i2++ ) {
       AliHLTTPCCABorderTrack &b2 = B2[i2];
-      if( !b2.OK() ) continue;
-      if( b2.NClusters() < minNPartHits ) continue;
-      if( b2.NClusters() < lBest2 ) continue;
-      if( b1.NClusters() + b2.NClusters() < minNTotalHits ) continue;
+      if ( !b2.OK() ) continue;
+      if ( b2.NClusters() < minNPartHits ) continue;
+      if ( b2.NClusters() < lBest2 ) continue;
+      if ( b1.NClusters() + b2.NClusters() < minNTotalHits ) continue;
 
       //if( TMath::Abs(b1.fX - b2.fX)>maxDX ) continue;
 
       const AliHLTTPCCATrackParam &t2 = b2.Param();
 
-      Float_t c= t2.SignCosPhi()*t1.SignCosPhi()>=0 ?1 :-1;
-      Float_t dk = t2.QPt() - c*t1.QPt(); 
-      Float_t s2k = t2.Err2QPt() + t1.Err2QPt();
-      
-      if( dk*dk>factor2k*s2k ) continue;     
+      float c = t2.SignCosPhi() * t1.SignCosPhi() >= 0 ? 1 : -1;
+      float dk = t2.QPt() - c * t1.QPt();
+      float s2k = t2.Err2QPt() + t1.Err2QPt();
+
+      if ( dk*dk > factor2k*s2k ) continue;
+
+
+      float chi2ys = GetChi2( t1.Y(), c * t1.SinPhi(), t1.Cov()[0], c * t1.Cov()[3], t1.Cov()[5],
+                                t2.Y(),  t2.SinPhi(), t2.Cov()[0],  t2.Cov()[3], t2.Cov()[5] );
 
+      if ( chi2ys > factor2ys ) continue;
 
-      Float_t chi2ys = GetChi2( t1.Y(),c*t1.SinPhi(),t1.Cov()[0],c*t1.Cov()[3],t1.Cov()[5], 
-                               t2.Y(),  t2.SinPhi(),t2.Cov()[0],  t2.Cov()[3],t2.Cov()[5] );
+      float chi2zt = GetChi2( t1.Z(), c * t1.DzDs(), t1.Cov()[2], c * t1.Cov()[7], t1.Cov()[9],
+                                t2.Z(),  t2.DzDs(), t2.Cov()[2],  t2.Cov()[7], t2.Cov()[9] );
 
-      if( chi2ys>factor2ys ) continue;
+      if ( chi2zt > factor2zt ) continue;
 
-      Float_t chi2zt = GetChi2( t1.Z(),c*t1.DzDs(),t1.Cov()[2],c*t1.Cov()[7],t1.Cov()[9], 
-                               t2.Z(),  t2.DzDs(),t2.Cov()[2],  t2.Cov()[7],t2.Cov()[9] );
-            
-      if( chi2zt>factor2zt ) continue;
-      
       lBest2 = b2.NClusters();
       iBest2 = b2.TrackID();
     }
-      
-    if( iBest2 <0 ) continue;
-
-    AliHLTTPCCASliceTrackInfo &newTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1]+b1.TrackID() ];    
-    AliHLTTPCCASliceTrackInfo &newTrack2 = fTrackInfos[fSliceTrackInfoStart[iSlice2]+iBest2 ];
-
-    Int_t old1 = newTrack2.PrevNeighbour();
-  
-    if( old1 >= 0 ){
-      AliHLTTPCCASliceTrackInfo &oldTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1]+old1];
-      if( oldTrack1.NClusters()  < newTrack1.NClusters() ){
-       newTrack2.SetPrevNeighbour(-1);
-       oldTrack1.SetNextNeighbour(-1); 
+
+    if ( iBest2 < 0 ) continue;
+
+    AliHLTTPCCASliceTrackInfo &newTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1] + b1.TrackID() ];
+    AliHLTTPCCASliceTrackInfo &newTrack2 = fTrackInfos[fSliceTrackInfoStart[iSlice2] + iBest2 ];
+
+    int old1 = newTrack2.PrevNeighbour();
+
+    if ( old1 >= 0 ) {
+      AliHLTTPCCASliceTrackInfo &oldTrack1 = fTrackInfos[fSliceTrackInfoStart[iSlice1] + old1];
+      if ( oldTrack1.NClusters()  < newTrack1.NClusters() ) {
+        newTrack2.SetPrevNeighbour( -1 );
+        oldTrack1.SetNextNeighbour( -1 );
       } else continue;
     }
-    Int_t old2 = newTrack1.NextNeighbour();
-    if( old2 >= 0 ){
-      AliHLTTPCCASliceTrackInfo &oldTrack2 = fTrackInfos[fSliceTrackInfoStart[iSlice2]+old2];
-      if( oldTrack2.NClusters() < newTrack2.NClusters() ){
-       oldTrack2.SetPrevNeighbour(-1);
+    int old2 = newTrack1.NextNeighbour();
+    if ( old2 >= 0 ) {
+      AliHLTTPCCASliceTrackInfo &oldTrack2 = fTrackInfos[fSliceTrackInfoStart[iSlice2] + old2];
+      if ( oldTrack2.NClusters() < newTrack2.NClusters() ) {
+        oldTrack2.SetPrevNeighbour( -1 );
       } else continue;
     }
-    newTrack1.SetNextNeighbour(iBest2); 
-    newTrack2.SetPrevNeighbour(b1.TrackID());  
-  }  
-  
+    newTrack1.SetNextNeighbour( iBest2 );
+    newTrack2.SetPrevNeighbour( b1.TrackID() );
+  }
+
 }
 
 
@@ -624,79 +624,79 @@ void AliHLTTPCCAMerger::Merging()
 
 
   // for each slice set number of the next neighbouring slice
-     
-  Int_t nextSlice[100], prevSlice[100];
 
-  for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
+  int nextSlice[100], prevSlice[100];
+
+  for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
     nextSlice[iSlice] = iSlice + 1;
     prevSlice[iSlice] = iSlice - 1;
   }
-  Int_t mid = fgkNSlices/2 - 1 ;
-  Int_t last = fgkNSlices - 1 ;
-  if( mid<0 ) mid = 0; // to avoid compiler warning
-  if( last<0 ) last = 0; // 
+  int mid = fgkNSlices / 2 - 1 ;
+  int last = fgkNSlices - 1 ;
+  if ( mid < 0 ) mid = 0; // to avoid compiler warning
+  if ( last < 0 ) last = 0; //
   nextSlice[ mid ] = 0;
   prevSlice[ 0 ] = mid;
-  nextSlice[ last ] = fgkNSlices/2;
+  nextSlice[ last ] = fgkNSlices / 2;
   prevSlice[ fgkNSlices/2 ] = last;
-  
-  Int_t maxNSliceTracks = 0;
-  for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
-    if( maxNSliceTracks < fSliceNTrackInfos[iSlice] ) maxNSliceTracks = fSliceNTrackInfos[iSlice];
+
+  int maxNSliceTracks = 0;
+  for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
+    if ( maxNSliceTracks < fSliceNTrackInfos[iSlice] ) maxNSliceTracks = fSliceNTrackInfos[iSlice];
   }
-  
-  if(1){// merging track segments withing one slice 
-    
+
+  if ( 1 ) {// merging track segments withing one slice
+
     AliHLTTPCCABorderTrack bord[maxNSliceTracks*10];
-    
+
     AliHLTTPCCASliceTrackInfo *tmpT = new AliHLTTPCCASliceTrackInfo[maxNSliceTracks];
     AliHLTTPCCAClusterInfo *tmpH = new AliHLTTPCCAClusterInfo[fMaxClusterInfos];
 
-    for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
-
-      Int_t nBord=0;
-      MakeBorderTracks( iSlice, 4, bord, nBord );   
-      SplitBorderTracks( iSlice, bord, nBord, iSlice, bord, nBord );    
-
-      Int_t nTr=0, nH=0;
-      Int_t sliceFirstClusterRef = 0;
-      for( Int_t itr=0; itr<fSliceNTrackInfos[iSlice]; itr++ ){
-       AliHLTTPCCASliceTrackInfo &track = fTrackInfos[ fSliceTrackInfoStart[iSlice]+itr];
-       if( itr==0 ) sliceFirstClusterRef = track.FirstClusterRef();
-       track.SetPrevNeighbour( -1 );
-       if( track.NextNeighbour() == -2 ){
-         track.SetNextNeighbour( -1 );
-         continue;
-       }
-       AliHLTTPCCASliceTrackInfo &trackNew = tmpT[nTr];
-       trackNew = track;
-       trackNew.SetFirstClusterRef( sliceFirstClusterRef + nH);
-
-       for( Int_t ih=0; ih<track.NClusters(); ih++ ) tmpH[nH+ih] = fClusterInfos[track.FirstClusterRef()+ih];
-       nTr++;
-       nH+=track.NClusters();
-
-       int jtr =  track.NextNeighbour();
-
-       if( jtr<0 ) continue;
-       AliHLTTPCCASliceTrackInfo &neighTrack = fTrackInfos[ fSliceTrackInfoStart[iSlice]+jtr];
-       
-       track.SetNextNeighbour(-1);
-       neighTrack.SetNextNeighbour(-2);
-
-       for( Int_t ih=0; ih<neighTrack.NClusters(); ih++ ) 
-         tmpH[nH+ih] = fClusterInfos[neighTrack.FirstClusterRef()+ih];
-
-       trackNew.SetNClusters( trackNew.NClusters() + neighTrack.NClusters() );
-       trackNew.SetNextNeighbour( -1 );
-       nH+=neighTrack.NClusters();
-       if( neighTrack.InnerParam().X() < track.InnerParam().X() ) trackNew.SetInnerParam( neighTrack.InnerParam());
-       if( neighTrack.OuterParam().X() > track.OuterParam().X() ) trackNew.SetOuterParam( neighTrack.OuterParam());
+    for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
+
+      int nBord = 0;
+      MakeBorderTracks( iSlice, 4, bord, nBord );
+      SplitBorderTracks( iSlice, bord, nBord, iSlice, bord, nBord );
+
+      int nTr = 0, nH = 0;
+      int sliceFirstClusterRef = 0;
+      for ( int itr = 0; itr < fSliceNTrackInfos[iSlice]; itr++ ) {
+        AliHLTTPCCASliceTrackInfo &track = fTrackInfos[ fSliceTrackInfoStart[iSlice] + itr];
+        if ( itr == 0 ) sliceFirstClusterRef = track.FirstClusterRef();
+        track.SetPrevNeighbour( -1 );
+        if ( track.NextNeighbour() == -2 ) {
+          track.SetNextNeighbour( -1 );
+          continue;
+        }
+        AliHLTTPCCASliceTrackInfo &trackNew = tmpT[nTr];
+        trackNew = track;
+        trackNew.SetFirstClusterRef( sliceFirstClusterRef + nH );
+
+        for ( int ih = 0; ih < track.NClusters(); ih++ ) tmpH[nH+ih] = fClusterInfos[track.FirstClusterRef()+ih];
+        nTr++;
+        nH += track.NClusters();
+
+        int jtr =  track.NextNeighbour();
+
+        if ( jtr < 0 ) continue;
+        AliHLTTPCCASliceTrackInfo &neighTrack = fTrackInfos[ fSliceTrackInfoStart[iSlice] + jtr];
+
+        track.SetNextNeighbour( -1 );
+        neighTrack.SetNextNeighbour( -2 );
+
+        for ( int ih = 0; ih < neighTrack.NClusters(); ih++ )
+          tmpH[nH+ih] = fClusterInfos[neighTrack.FirstClusterRef()+ih];
+
+        trackNew.SetNClusters( trackNew.NClusters() + neighTrack.NClusters() );
+        trackNew.SetNextNeighbour( -1 );
+        nH += neighTrack.NClusters();
+        if ( neighTrack.InnerParam().X() < track.InnerParam().X() ) trackNew.SetInnerParam( neighTrack.InnerParam() );
+        if ( neighTrack.OuterParam().X() > track.OuterParam().X() ) trackNew.SetOuterParam( neighTrack.OuterParam() );
       }
-      
+
       fSliceNTrackInfos[iSlice] = nTr;
-      for( Int_t itr=0; itr<nTr; itr++ ) fTrackInfos[ fSliceTrackInfoStart[iSlice]+itr] = tmpT[itr];
-      for( Int_t ih=0; ih<nH; ih++ ) fClusterInfos[sliceFirstClusterRef + ih] = tmpH[ih];
+      for ( int itr = 0; itr < nTr; itr++ ) fTrackInfos[ fSliceTrackInfoStart[iSlice] + itr] = tmpT[itr];
+      for ( int ih = 0; ih < nH; ih++ ) fClusterInfos[sliceFirstClusterRef + ih] = tmpH[ih];
 
     }
     delete[] tmpT;
@@ -704,184 +704,184 @@ void AliHLTTPCCAMerger::Merging()
   }
 
 
-  //* merging tracks between slices      
+  //* merging tracks between slices
+
 
-  
   // arrays for the rotated track parameters
 
-  AliHLTTPCCABorderTrack 
-    *bCurr0 = new AliHLTTPCCABorderTrack[maxNSliceTracks*10], 
-    *bNext0 = new AliHLTTPCCABorderTrack[maxNSliceTracks*10],
-    *bCurr = new AliHLTTPCCABorderTrack[maxNSliceTracks*10], 
-    *bNext = new AliHLTTPCCABorderTrack[maxNSliceTracks*10];
+  AliHLTTPCCABorderTrack
+  *bCurr0 = new AliHLTTPCCABorderTrack[maxNSliceTracks*10],
+  *bNext0 = new AliHLTTPCCABorderTrack[maxNSliceTracks*10],
+  *bCurr = new AliHLTTPCCABorderTrack[maxNSliceTracks*10],
+  *bNext = new AliHLTTPCCABorderTrack[maxNSliceTracks*10];
+
+  for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
 
-  for( Int_t iSlice=0; iSlice<fgkNSlices; iSlice++ ){
-    
-    Int_t jSlice = nextSlice[iSlice];
-    
-    Int_t nCurr0 = 0, nNext0 = 0;
-    Int_t nCurr = 0, nNext = 0;
+    int jSlice = nextSlice[iSlice];
+
+    int nCurr0 = 0, nNext0 = 0;
+    int nCurr = 0, nNext = 0;
 
     MakeBorderTracks( iSlice, 0, bCurr, nCurr );
     MakeBorderTracks( jSlice, 1, bNext, nNext );
     MakeBorderTracks( iSlice, 2, bCurr0, nCurr0 );
     MakeBorderTracks( jSlice, 3, bNext0, nNext0 );
-    
-    SplitBorderTracks( iSlice, bCurr0, nCurr0, jSlice, bNext0, nNext0 );   
-    SplitBorderTracks( iSlice, bCurr, nCurr, jSlice, bNext, nNext );    
+
+    SplitBorderTracks( iSlice, bCurr0, nCurr0, jSlice, bNext0, nNext0 );
+    SplitBorderTracks( iSlice, bCurr, nCurr, jSlice, bNext, nNext );
   }
 
-  if( bCurr0 ) delete[] bCurr0;
-  if( bNext0 ) delete[] bNext0;
-  if( bCurr  ) delete[] bCurr;
-  if( bNext  ) delete[] bNext;  
+  if ( bCurr0 ) delete[] bCurr0;
+  if ( bNext0 ) delete[] bNext0;
+  if ( bCurr  ) delete[] bCurr;
+  if ( bNext  ) delete[] bNext;
 
 
-  //static Int_t nRejected = 0;
-    
-  Int_t nOutTracks = 0;
-  Int_t nOutTrackClusters = 0;
+  //static int nRejected = 0;
+
+  int nOutTracks = 0;
+  int nOutTrackClusters = 0;
 
   AliHLTTPCCAMergedTrack *outTracks = new AliHLTTPCCAMergedTrack[fMaxTrackInfos];
-  UInt_t   *outClusterIDsrc = new UInt_t [fMaxClusterInfos];
+  unsigned int   *outClusterIDsrc = new unsigned int [fMaxClusterInfos];
   UChar_t  *outClusterPackedAmp = new UChar_t [fMaxClusterInfos];
-  
-  for( Int_t iSlice = 0; iSlice<fgkNSlices; iSlice++ ){
 
-    for( Int_t itr=0; itr<fSliceNTrackInfos[iSlice]; itr++ ){
+  for ( int iSlice = 0; iSlice < fgkNSlices; iSlice++ ) {
+
+    for ( int itr = 0; itr < fSliceNTrackInfos[iSlice]; itr++ ) {
 
-      AliHLTTPCCASliceTrackInfo &track = fTrackInfos[fSliceTrackInfoStart[iSlice]+itr];
+      AliHLTTPCCASliceTrackInfo &track = fTrackInfos[fSliceTrackInfoStart[iSlice] + itr];
 
-      if( track.Used() ) continue;
-      if( track.PrevNeighbour()>=0 ) continue;
+      if ( track.Used() ) continue;
+      if ( track.PrevNeighbour() >= 0 ) continue;
 
       AliHLTTPCCATrackParam startPoint = track.InnerParam(), endPoint = track.OuterParam();
-      Float_t startAlpha = track.InnerAlpha(), endAlpha = track.OuterAlpha();      
+      float startAlpha = track.InnerAlpha(), endAlpha = track.OuterAlpha();
 
-      Int_t hits[2000];
-      Int_t firstHit = 1000;
-      Int_t nHits = 0;
-      Int_t jSlice = iSlice;
-      Int_t jtr = itr;
+      int hits[2000];
+      int firstHit = 1000;
+      int nHits = 0;
+      int jSlice = iSlice;
+      int jtr = itr;
 
       {
-       track.SetUsed( 1 );
-       for( Int_t jhit=0; jhit<track.NClusters(); jhit++){
-         Int_t id = track.FirstClusterRef() + jhit;
-         hits[firstHit+jhit] = id;
-       }
-       nHits=track.NClusters();
-       jtr = track.NextNeighbour();
-       jSlice = nextSlice[iSlice];                     
+        track.SetUsed( 1 );
+        for ( int jhit = 0; jhit < track.NClusters(); jhit++ ) {
+          int id = track.FirstClusterRef() + jhit;
+          hits[firstHit+jhit] = id;
+        }
+        nHits = track.NClusters();
+        jtr = track.NextNeighbour();
+        jSlice = nextSlice[iSlice];
       }
 
-      while( jtr >=0 ){
-       AliHLTTPCCASliceTrackInfo &segment = fTrackInfos[fSliceTrackInfoStart[jSlice]+jtr];
-       if( segment.Used() ) break;
-       segment.SetUsed( 1 );
-       Bool_t dir = 0;
-       Int_t startHit = firstHit+ nHits;
-       Float_t d00 = startPoint.GetDistXZ2(segment.InnerParam() );
-       Float_t d01 = startPoint.GetDistXZ2(segment.OuterParam() );
-       Float_t d10 = endPoint.GetDistXZ2(segment.InnerParam() );
-       Float_t d11 = endPoint.GetDistXZ2(segment.OuterParam() );
-       if( d00<=d01 && d00<=d10 && d00<=d11 ){
-         startPoint = segment.OuterParam();
-         startAlpha = segment.OuterAlpha();
-         dir = 1;
-         firstHit -= segment.NClusters();
-         startHit = firstHit;
-       }else if( d01<=d10 && d01<=d11 ){
-         startPoint = segment.InnerParam();
-         startAlpha = segment.InnerAlpha();
-         dir = 0;
-         firstHit -= segment.NClusters();
-         startHit = firstHit;
-       }else if( d10<=d11 ){
-         endPoint = segment.OuterParam();
-         endAlpha = segment.OuterAlpha();
-         dir = 0;
-       }else{
-         endPoint = segment.InnerParam();
-         endAlpha = segment.InnerAlpha();
-         dir = 1;
-       }
-       
-       for( Int_t jhit=0; jhit<segment.NClusters(); jhit++){
-         Int_t id = segment.FirstClusterRef() + jhit;
-         hits[startHit+(dir ?(segment.NClusters()-1-jhit) :jhit)] = id;
-       }
-       nHits+=segment.NClusters();
-       jtr = segment.NextNeighbour();
-       jSlice = nextSlice[jSlice];                     
+      while ( jtr >= 0 ) {
+        AliHLTTPCCASliceTrackInfo &segment = fTrackInfos[fSliceTrackInfoStart[jSlice] + jtr];
+        if ( segment.Used() ) break;
+        segment.SetUsed( 1 );
+        bool dir = 0;
+        int startHit = firstHit + nHits;
+        float d00 = startPoint.GetDistXZ2( segment.InnerParam() );
+        float d01 = startPoint.GetDistXZ2( segment.OuterParam() );
+        float d10 = endPoint.GetDistXZ2( segment.InnerParam() );
+        float d11 = endPoint.GetDistXZ2( segment.OuterParam() );
+        if ( d00 <= d01 && d00 <= d10 && d00 <= d11 ) {
+          startPoint = segment.OuterParam();
+          startAlpha = segment.OuterAlpha();
+          dir = 1;
+          firstHit -= segment.NClusters();
+          startHit = firstHit;
+        } else if ( d01 <= d10 && d01 <= d11 ) {
+          startPoint = segment.InnerParam();
+          startAlpha = segment.InnerAlpha();
+          dir = 0;
+          firstHit -= segment.NClusters();
+          startHit = firstHit;
+        } else if ( d10 <= d11 ) {
+          endPoint = segment.OuterParam();
+          endAlpha = segment.OuterAlpha();
+          dir = 0;
+        } else {
+          endPoint = segment.InnerParam();
+          endAlpha = segment.InnerAlpha();
+          dir = 1;
+        }
+
+        for ( int jhit = 0; jhit < segment.NClusters(); jhit++ ) {
+          int id = segment.FirstClusterRef() + jhit;
+          hits[startHit+( dir ?( segment.NClusters()-1-jhit ) :jhit )] = id;
+        }
+        nHits += segment.NClusters();
+        jtr = segment.NextNeighbour();
+        jSlice = nextSlice[jSlice];
       }
 
-      if( endPoint.X() < startPoint.X() ){ // swap
-       for( Int_t i=0; i<nHits; i++ ) hits[i] = hits[firstHit+nHits-1-i];
-       firstHit = 0;
+      if ( endPoint.X() < startPoint.X() ) { // swap
+        for ( int i = 0; i < nHits; i++ ) hits[i] = hits[firstHit+nHits-1-i];
+        firstHit = 0;
       }
-      
-      if( nHits < 30 ) continue;     //SG!!!
 
-      // refit 
+      if ( nHits < 30 ) continue;    //SG!!!
+
+      // refit
 
       // need best t0!!!SG
 
       endPoint = startPoint;
-      if( !FitTrack( endPoint, endAlpha, startPoint, startAlpha, hits+firstHit, nHits, 0 ) ) continue;
-      if( !FitTrack( startPoint, startAlpha, endPoint, endAlpha, hits+firstHit, nHits, 1 ) ) continue;
+      if ( !FitTrack( endPoint, endAlpha, startPoint, startAlpha, hits + firstHit, nHits, 0 ) ) continue;
+      if ( !FitTrack( startPoint, startAlpha, endPoint, endAlpha, hits + firstHit, nHits, 1 ) ) continue;
+
+      if ( nHits < 30 ) continue;    //SG!!!
 
-      if( nHits < 30 ) continue;     //SG!!!    
-      
       AliHLTTPCCATrackParam &p = startPoint;
-      
+
       {
-       Double_t xTPC=83.65; //SG!!!
-       Double_t dAlpha = 0.00609235;
-       AliHLTTPCCATrackParam::AliHLTTPCCATrackFitParam fitPar;
-       p.CalculateFitParameters( fitPar );
-       
-       if( p.TransportToXWithMaterial( xTPC, fitPar, fSliceParam.GetBz( p ) ) ){
-         Double_t y=p.GetY();
-         Double_t ymax=xTPC*CAMath::Tan(dAlpha/2.); 
-         if (y > ymax) {
-           if( p.Rotate( dAlpha ) ){ startAlpha+=dAlpha;  p.TransportToXWithMaterial( xTPC, fitPar, fSliceParam.GetBz(p) ); }
-         } else if (y <-ymax) {
-           if( p.Rotate( -dAlpha ) ){  startAlpha-=dAlpha; p.TransportToXWithMaterial( xTPC, fitPar, fSliceParam.GetBz(p) );}
-         }
-       }
+        double xTPC = 83.65; //SG!!!
+        double dAlpha = 0.00609235;
+        AliHLTTPCCATrackParam::AliHLTTPCCATrackFitParam fitPar;
+        p.CalculateFitParameters( fitPar );
+
+        if ( p.TransportToXWithMaterial( xTPC, fitPar, fSliceParam.GetBz( p ) ) ) {
+          double y = p.GetY();
+          double ymax = xTPC * CAMath::Tan( dAlpha / 2. );
+          if ( y > ymax ) {
+            if ( p.Rotate( dAlpha ) ) { startAlpha += dAlpha;  p.TransportToXWithMaterial( xTPC, fitPar, fSliceParam.GetBz( p ) ); }
+          } else if ( y < -ymax ) {
+            if ( p.Rotate( -dAlpha ) ) {  startAlpha -= dAlpha; p.TransportToXWithMaterial( xTPC, fitPar, fSliceParam.GetBz( p ) );}
+          }
+        }
       }
-      
+
       {
-       Bool_t ok=1;
-       
-       const Float_t *c = p.Cov();
-       for( Int_t i=0; i<15; i++ ) ok = ok && finite(c[i]);
-       for( Int_t i=0; i<5; i++ ) ok = ok && finite(p.Par()[i]);
-       ok = ok && (p.GetX()>50);
-       
-       if( c[0]<=0 || c[2]<=0 || c[5]<=0 || c[9]<=0 || c[14]<=0 ) ok = 0;
-       if( c[0]>5. || c[2]>5. || c[5]>2. || c[9]>2 || c[14]>2 ) ok = 0;
-       if(!ok) continue;       
+        bool ok = 1;
+
+        const float *c = p.Cov();
+        for ( int i = 0; i < 15; i++ ) ok = ok && finite( c[i] );
+        for ( int i = 0; i < 5; i++ ) ok = ok && finite( p.Par()[i] );
+        ok = ok && ( p.GetX() > 50 );
+
+        if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0;
+        if ( c[0] > 5. || c[2] > 5. || c[5] > 2. || c[9] > 2 || c[14] > 2 ) ok = 0;
+        if ( !ok ) continue;
       }
 
       AliHLTTPCCAMergedTrack &mergedTrack = outTracks[nOutTracks];
-      mergedTrack.SetNClusters(nHits);
-      mergedTrack.SetFirstClusterRef(nOutTrackClusters);
-      mergedTrack.SetInnerParam(startPoint);
-      mergedTrack.SetInnerAlpha(startAlpha);
-      mergedTrack.SetOuterParam(endPoint);
-      mergedTrack.SetOuterAlpha(endAlpha);
-      for( Int_t i = 0; i<nHits; i++ ){
-       AliHLTTPCCAClusterInfo &clu = fClusterInfos[hits[firstHit+i]];
-       outClusterIDsrc[nOutTrackClusters+i] = 
-         AliHLTTPCCADataCompressor::ISliceIRowIClu2IDsrc(clu.ISlice(), clu.IRow(), clu.IClu());
-       outClusterPackedAmp[nOutTrackClusters+i]=clu.PackedAmp();
+      mergedTrack.SetNClusters( nHits );
+      mergedTrack.SetFirstClusterRef( nOutTrackClusters );
+      mergedTrack.SetInnerParam( startPoint );
+      mergedTrack.SetInnerAlpha( startAlpha );
+      mergedTrack.SetOuterParam( endPoint );
+      mergedTrack.SetOuterAlpha( endAlpha );
+
+      for ( int i = 0; i < nHits; i++ ) {
+        AliHLTTPCCAClusterInfo &clu = fClusterInfos[hits[firstHit+i]];
+        outClusterIDsrc[nOutTrackClusters+i] =
+          AliHLTTPCCADataCompressor::ISliceIRowIClu2IDsrc( clu.ISlice(), clu.IRow(), clu.IClu() );
+        outClusterPackedAmp[nOutTrackClusters+i] = clu.PackedAmp();
       }
-      
+
       nOutTracks++;
-      nOutTrackClusters+= nHits;
+      nOutTrackClusters += nHits;
     }
   }
 
@@ -889,13 +889,13 @@ void AliHLTTPCCAMerger::Merging()
   fOutput->SetNTrackClusters( nOutTrackClusters );
   fOutput->SetPointers();
 
-  for( Int_t itr=0; itr<nOutTracks; itr++ ) fOutput->SetTrack( itr, outTracks[itr] );
+  for ( int itr = 0; itr < nOutTracks; itr++ ) fOutput->SetTrack( itr, outTracks[itr] );
 
-  for( Int_t ic=0; ic<nOutTrackClusters; ic++ ){
+  for ( int ic = 0; ic < nOutTrackClusters; ic++ ) {
     fOutput->SetClusterIDsrc( ic, outClusterIDsrc[ic] );
     fOutput->SetClusterPackedAmp( ic, outClusterPackedAmp[ic] );
   }
+
   delete[] outTracks;
   delete[] outClusterIDsrc;
   delete[] outClusterPackedAmp;
index eebb864..034a9df 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -24,58 +24,58 @@ class AliHLTTPCCAMergerOutput;
 
 /**
  * @class AliHLTTPCCAMerger
- * 
+ *
  */
 class AliHLTTPCCAMerger
 {
 
-public:
-
-  AliHLTTPCCAMerger();
-  ~AliHLTTPCCAMerger();
-
-  void SetSliceParam( const AliHLTTPCCAParam &v ){ fSliceParam = v; }
-
-  void Clear();
-  void SetSliceData( int index, const AliHLTTPCCASliceOutput *SliceData );
-  void Reconstruct();
-
-  const AliHLTTPCCAMergerOutput * Output() const { return fOutput; }
-  
-  Bool_t FitTrack( AliHLTTPCCATrackParam &T, Float_t &Alpha, 
-                  AliHLTTPCCATrackParam t0, Float_t Alpha0, Int_t hits[], Int_t &NHits,  Bool_t dir=0 );
-
- private:
-
-  AliHLTTPCCAMerger(const AliHLTTPCCAMerger&);
-  const AliHLTTPCCAMerger &operator=(const AliHLTTPCCAMerger&) const;
-  
-  class AliHLTTPCCAClusterInfo;
-  class AliHLTTPCCASliceTrackInfo;
-  class AliHLTTPCCABorderTrack;
-
-  void MakeBorderTracks( Int_t iSlice, Int_t iBorder, AliHLTTPCCABorderTrack B[], Int_t &nB);
-  void SplitBorderTracks( Int_t iSlice1, AliHLTTPCCABorderTrack B1[], Int_t N1,
-                         Int_t iSlice2, AliHLTTPCCABorderTrack B2[], Int_t N2 );
-
-  static Float_t GetChi2( Float_t x1, Float_t y1, Float_t a00, Float_t a10, Float_t a11, 
-                         Float_t x2, Float_t y2, Float_t b00, Float_t b10, Float_t b11  );
-
-  void UnpackSlices();
-  void Merging();
-   
-
-  
-  static const Int_t fgkNSlices = 36;       //* N slices 
-  AliHLTTPCCAParam fSliceParam;           //* slice parameters (geometry, calibr, etc.)
-  const AliHLTTPCCASliceOutput *fkSlices[fgkNSlices]; //* array of input slice tracks
-  AliHLTTPCCAMergerOutput *fOutput;       //* array of output merged tracks  
-  AliHLTTPCCASliceTrackInfo *fTrackInfos; //* additional information for slice tracks
-  Int_t fMaxTrackInfos;                   //* booked size of fTrackInfos array
-  AliHLTTPCCAClusterInfo *fClusterInfos;  //* information about track clusters
-  Int_t fMaxClusterInfos;                 //* booked size of fClusterInfos array
-  Int_t fSliceTrackInfoStart[fgkNSlices];   //* slice starting index in fTrackInfos array;
-  Int_t fSliceNTrackInfos[fgkNSlices];                //* N of slice track infos in fTrackInfos array;
+  public:
+
+    AliHLTTPCCAMerger();
+    ~AliHLTTPCCAMerger();
+
+    void SetSliceParam( const AliHLTTPCCAParam &v ) { fSliceParam = v; }
+
+    void Clear();
+    void SetSliceData( int index, const AliHLTTPCCASliceOutput *SliceData );
+    void Reconstruct();
+
+    const AliHLTTPCCAMergerOutput * Output() const { return fOutput; }
+
+    bool FitTrack( AliHLTTPCCATrackParam &T, float &Alpha,
+                     AliHLTTPCCATrackParam t0, float Alpha0, int hits[], int &NHits,  bool dir = 0 );
+
+  private:
+
+    AliHLTTPCCAMerger( const AliHLTTPCCAMerger& );
+    const AliHLTTPCCAMerger &operator=( const AliHLTTPCCAMerger& ) const;
+
+    class AliHLTTPCCAClusterInfo;
+    class AliHLTTPCCASliceTrackInfo;
+    class AliHLTTPCCABorderTrack;
+
+    void MakeBorderTracks( int iSlice, int iBorder, AliHLTTPCCABorderTrack B[], int &nB );
+    void SplitBorderTracks( int iSlice1, AliHLTTPCCABorderTrack B1[], int N1,
+                            int iSlice2, AliHLTTPCCABorderTrack B2[], int N2 );
+
+    static float GetChi2( float x1, float y1, float a00, float a10, float a11,
+                            float x2, float y2, float b00, float b10, float b11  );
+
+    void UnpackSlices();
+    void Merging();
+
+
+
+    static const int fgkNSlices = 36;       //* N slices
+    AliHLTTPCCAParam fSliceParam;           //* slice parameters (geometry, calibr, etc.)
+    const AliHLTTPCCASliceOutput *fkSlices[fgkNSlices]; //* array of input slice tracks
+    AliHLTTPCCAMergerOutput *fOutput;       //* array of output merged tracks
+    AliHLTTPCCASliceTrackInfo *fTrackInfos; //* additional information for slice tracks
+    int fMaxTrackInfos;                   //* booked size of fTrackInfos array
+    AliHLTTPCCAClusterInfo *fClusterInfos;  //* information about track clusters
+    int fMaxClusterInfos;                 //* booked size of fClusterInfos array
+    int fSliceTrackInfoStart[fgkNSlices];   //* slice starting index in fTrackInfos array;
+    int fSliceNTrackInfos[fgkNSlices];                //* N of slice track infos in fTrackInfos array;
 };
 
 #endif
index c4341a3..8776182 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
  * and transport the output to AliHLTTPCCAMerger{Component}
  *
  * The class contains all the necessary information about TPC tracks, reconstructed in one slice.
- * This includes the reconstructed track parameters and some compressed information 
+ * This includes the reconstructed track parameters and some compressed information
  * about the assigned clusters: clusterId, position and amplitude.
  *
  */
 class AliHLTTPCCAMergerOutput
 {
- public:
+  public:
 
-  AliHLTTPCCAMergerOutput()
-    :fNTracks(0), fNTrackClusters(0),fTracks(0),fClusterIDsrc(0),fClusterPackedAmp(0) {}
+    AliHLTTPCCAMergerOutput()
+        : fNTracks( 0 ), fNTrackClusters( 0 ), fTracks( 0 ), fClusterIDsrc( 0 ), fClusterPackedAmp( 0 ) {}
 
-  AliHLTTPCCAMergerOutput( const AliHLTTPCCAMergerOutput & )
-    :fNTracks(0), fNTrackClusters(0),fTracks(0),fClusterIDsrc(0),fClusterPackedAmp(0) {}
-  
-  const AliHLTTPCCAMergerOutput& operator=( const AliHLTTPCCAMergerOutput &/*v*/ ) const { 
-    return *this; 
-  }
+    AliHLTTPCCAMergerOutput( const AliHLTTPCCAMergerOutput & )
+        : fNTracks( 0 ), fNTrackClusters( 0 ), fTracks( 0 ), fClusterIDsrc( 0 ), fClusterPackedAmp( 0 ) {}
 
-  ~AliHLTTPCCAMergerOutput(){}
+    const AliHLTTPCCAMergerOutput& operator=( const AliHLTTPCCAMergerOutput &/*v*/ ) const {
+      return *this;
+    }
 
+    ~AliHLTTPCCAMergerOutput() {}
 
-  GPUhd() Int_t NTracks()                    const { return fNTracks;              }
-  GPUhd() Int_t NTrackClusters()             const { return fNTrackClusters;       }
 
-  GPUhd() const AliHLTTPCCAMergedTrack &Track( Int_t i ) const { return fTracks[i]; }
-  GPUhd() UInt_t   ClusterIDsrc     ( Int_t i )  const { return fClusterIDsrc[i]; }
-  GPUhd() UChar_t  ClusterPackedAmp( Int_t i )  const { return fClusterPackedAmp[i]; }
+    GPUhd() int NTracks()                    const { return fNTracks;              }
+    GPUhd() int NTrackClusters()             const { return fNTrackClusters;       }
 
-  GPUhd() static Int_t EstimateSize( Int_t nOfTracks, Int_t nOfTrackClusters );
-  GPUhd() void SetPointers();
+    GPUhd() const AliHLTTPCCAMergedTrack &Track( int i ) const { return fTracks[i]; }
+    GPUhd() unsigned int   ClusterIDsrc     ( int i )  const { return fClusterIDsrc[i]; }
+    GPUhd() UChar_t  ClusterPackedAmp( int i )  const { return fClusterPackedAmp[i]; }
 
-  GPUhd() void SetNTracks       ( Int_t v )  { fNTracks = v;        }
-  GPUhd() void SetNTrackClusters( Int_t v )  { fNTrackClusters = v; }
+    GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
+    GPUhd() void SetPointers();
 
-  GPUhd() void SetTrack( Int_t i, const AliHLTTPCCAMergedTrack &v ) {  fTracks[i] = v; }
-  GPUhd() void SetClusterIDsrc( Int_t i, UInt_t v ) {  fClusterIDsrc[i] = v; }
-  GPUhd() void SetClusterPackedAmp( Int_t i, UChar_t v ) {  fClusterPackedAmp[i] = v; }
+    GPUhd() void SetNTracks       ( int v )  { fNTracks = v;        }
+    GPUhd() void SetNTrackClusters( int v )  { fNTrackClusters = v; }
 
- private:
-  
-  Int_t fNTracks;                 // number of reconstructed tracks
-  Int_t fNTrackClusters;          // total number of track clusters
-  AliHLTTPCCAMergedTrack *fTracks; // pointer to reconstructed tracks
-  UInt_t   *fClusterIDsrc;         // pointer to cluster IDs ( packed IRow and ICluster)
-  UChar_t  *fClusterPackedAmp;    // pointer to packed cluster amplitudes
+    GPUhd() void SetTrack( int i, const AliHLTTPCCAMergedTrack &v ) {  fTracks[i] = v; }
+    GPUhd() void SetClusterIDsrc( int i, unsigned int v ) {  fClusterIDsrc[i] = v; }
+    GPUhd() void SetClusterPackedAmp( int i, UChar_t v ) {  fClusterPackedAmp[i] = v; }
+
+  private:
+
+    int fNTracks;                 // number of reconstructed tracks
+    int fNTrackClusters;          // total number of track clusters
+    AliHLTTPCCAMergedTrack *fTracks; // pointer to reconstructed tracks
+    unsigned int   *fClusterIDsrc;         // pointer to cluster IDs ( packed IRow and ICluster)
+    UChar_t  *fClusterPackedAmp;    // pointer to packed cluster amplitudes
 
 };
 
 
 
-GPUhd() inline Int_t AliHLTTPCCAMergerOutput::EstimateSize( Int_t nOfTracks, Int_t nOfTrackClusters )
+GPUhd() inline int AliHLTTPCCAMergerOutput::EstimateSize( int nOfTracks, int nOfTrackClusters )
 {
   // calculate the amount of memory [bytes] needed for the event
 
-  const Int_t kClusterDataSize = sizeof(UInt_t) + sizeof(UChar_t);
+  const int kClusterDataSize = sizeof( unsigned int ) + sizeof( UChar_t );
 
-  return sizeof(AliHLTTPCCAMergerOutput) + sizeof(AliHLTTPCCAMergedTrack)*nOfTracks + kClusterDataSize*nOfTrackClusters;
+  return sizeof( AliHLTTPCCAMergerOutput ) + sizeof( AliHLTTPCCAMergedTrack )*nOfTracks + kClusterDataSize*nOfTrackClusters;
 }
 
 
@@ -84,9 +84,9 @@ GPUhd() inline void AliHLTTPCCAMergerOutput::SetPointers()
 {
   // set all pointers
 
-  fTracks            = (AliHLTTPCCAMergedTrack*)((&fClusterPackedAmp)+1);
-  fClusterIDsrc      = (UInt_t*)  ( fTracks            + fNTracks );
-  fClusterPackedAmp  = (UChar_t*) ( fClusterIDsrc + fNTrackClusters );
+  fTracks            = ( AliHLTTPCCAMergedTrack* )( ( &fClusterPackedAmp ) + 1 );
+  fClusterIDsrc      = ( unsigned int* )  ( fTracks            + fNTracks );
+  fClusterPackedAmp  = ( UChar_t* ) ( fClusterIDsrc + fNTrackClusters );
 }
 
 #endif
index febd747..41e485b 100644 (file)
@@ -1,6 +1,6 @@
 // @(#) $Id: AliHLTTPCCANeighboursCleaner.cxx 27042 2008-07-02 12:06:02Z richterm $
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 #include "AliHLTTPCCAMath.h"
 #include "AliHLTTPCCATracker.h"
 
-GPUd() void AliHLTTPCCANeighboursCleaner::Thread 
-( Int_t /*nBlocks*/, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
+GPUd() void AliHLTTPCCANeighboursCleaner::Thread
+( int /*nBlocks*/, int nThreads, int iBlock, int iThread, int iSync,
   AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
 {
   // *
   // * kill link to the neighbour if the neighbour is not pointed to the cluster
   // *
 
-  if( iSync==0 )
-    {
-      if( iThread==0 ){
-       s.fNRows = tracker.Param().NRows();
-       s.fIRow = iBlock+2;
-       if( s.fIRow <= s.fNRows-3 ){
-         s.fIRowUp = s.fIRow+2;
-         s.fIRowDn = s.fIRow-2;          
-         s.fFirstHit = tracker.Row(s.fIRow).FirstHit(); 
-         const AliHLTTPCCARow &row = tracker.Row(s.fIRow);
-         const AliHLTTPCCARow &rowUp = tracker.Row(s.fIRowUp);
-         const AliHLTTPCCARow &rowDn = tracker.Row(s.fIRowDn);
-         s.fHitLinkUp = ((Short_t*)(tracker.RowData() + row.FullOffset())) + row.FullLinkOffset();
-         s.fHitLinkDn = s.fHitLinkUp + row.NHits();
-         s.fDnHitLinkUp = ((Short_t*)(tracker.RowData() + rowDn.FullOffset())) + rowDn.FullLinkOffset();
-         s.fUpHitLinkDn = ((Short_t*)(tracker.RowData() + rowUp.FullOffset())) + rowUp.FullLinkOffset() + rowUp.NHits();
+  if ( iSync == 0 ) {
+    if ( iThread == 0 ) {
+      s.fNRows = tracker.Param().NRows();
+      s.fIRow = iBlock + 2;
+      if ( s.fIRow <= s.fNRows - 3 ) {
+        s.fIRowUp = s.fIRow + 2;
+        s.fIRowDn = s.fIRow - 2;
+        s.fFirstHit = tracker.Row( s.fIRow ).FirstHit();
+        const AliHLTTPCCARow &row = tracker.Row( s.fIRow );
+        const AliHLTTPCCARow &rowUp = tracker.Row( s.fIRowUp );
+        const AliHLTTPCCARow &rowDn = tracker.Row( s.fIRowDn );
+        s.fHitLinkUp = ( ( short* )( tracker.RowData() + row.FullOffset() ) ) + row.FullLinkOffset();
+        s.fHitLinkDn = s.fHitLinkUp + row.NHits();
+        s.fDnHitLinkUp = ( ( short* )( tracker.RowData() + rowDn.FullOffset() ) ) + rowDn.FullLinkOffset();
+        s.fUpHitLinkDn = ( ( short* )( tracker.RowData() + rowUp.FullOffset() ) ) + rowUp.FullLinkOffset() + rowUp.NHits();
 
-         s.fNHits = tracker.Row(s.fIRow).NHits();
-       }
+        s.fNHits = tracker.Row( s.fIRow ).NHits();
       }
-    } 
-  else if( iSync==1 )
-    {
-      if( s.fIRow <= s.fNRows-3 ){
+    }
+  } else if ( iSync == 1 ) {
+    if ( s.fIRow <= s.fNRows - 3 ) {
 
-       for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){
-         Int_t up = s.fHitLinkUp[ih];
-         if( up>=0 ){
-           Short_t upDn = s.fUpHitLinkDn[up];
-           if( (upDn!=ih) ) s.fHitLinkUp[ih]= -1;
-         }       
-         Int_t dn = s.fHitLinkDn[ih];
-         if( dn>=0 ){
-           Short_t dnUp = s.fDnHitLinkUp[dn];
-           if( dnUp!=ih ) s.fHitLinkDn[ih]= -1;
-         }
-       }
+      for ( int ih = iThread; ih < s.fNHits; ih += nThreads ) {
+        int up = s.fHitLinkUp[ih];
+        if ( up >= 0 ) {
+          short upDn = s.fUpHitLinkDn[up];
+          if ( ( upDn != ih ) ) s.fHitLinkUp[ih] = -1;
+        }
+        int dn = s.fHitLinkDn[ih];
+        if ( dn >= 0 ) {
+          short dnUp = s.fDnHitLinkUp[dn];
+          if ( dnUp != ih ) s.fHitLinkDn[ih] = -1;
+        }
       }
     }
+  }
 }
 
index 80e30af..b5bac26 100644 (file)
@@ -1,6 +1,6 @@
 //-*- Mode: C++ -*-
 // ************************************************************************
-// This file is property of and copyright by the ALICE HLT Project        * 
+// 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                               *
 //                                                                        *
@@ -16,39 +16,39 @@ class AliHLTTPCCATracker;
 
 /**
  * @class AliHLTTPCCANeighboursCleaner
- * 
+ *
  */
 class AliHLTTPCCANeighboursCleaner
 {
- public:
-  class AliHLTTPCCASharedMemory
+  public:
+    class AliHLTTPCCASharedMemory
     {
-     friend class AliHLTTPCCANeighboursCleaner;
-    public:
+        friend class AliHLTTPCCANeighboursCleaner;
+      public:
 #if !defined(HLTCA_GPUCODE)
-      AliHLTTPCCASharedMemory()
-       :fIRow(0),fIRowUp(0),fIRowDn(0),fNRows(0),fNHits(0),fHitLinkDn(0),fHitLinkUp(0),fUpHitLinkDn(0),fDnHitLinkUp(0),fFirstHit(0){}
-      AliHLTTPCCASharedMemory( const AliHLTTPCCASharedMemory& /*dummy*/) 
-       :fIRow(0),fIRowUp(0),fIRowDn(0),fNRows(0),fNHits(0),fHitLinkDn(0),fHitLinkUp(0),fUpHitLinkDn(0),fDnHitLinkUp(0),fFirstHit(0) {}
-      AliHLTTPCCASharedMemory& operator=(const AliHLTTPCCASharedMemory& /*dummy*/){ return *this; }
+        AliHLTTPCCASharedMemory()
+            : fIRow( 0 ), fIRowUp( 0 ), fIRowDn( 0 ), fNRows( 0 ), fNHits( 0 ), fHitLinkDn( 0 ), fHitLinkUp( 0 ), fUpHitLinkDn( 0 ), fDnHitLinkUp( 0 ), fFirstHit( 0 ) {}
+        AliHLTTPCCASharedMemory( const AliHLTTPCCASharedMemory& /*dummy*/ )
+            : fIRow( 0 ), fIRowUp( 0 ), fIRowDn( 0 ), fNRows( 0 ), fNHits( 0 ), fHitLinkDn( 0 ), fHitLinkUp( 0 ), fUpHitLinkDn( 0 ), fDnHitLinkUp( 0 ), fFirstHit( 0 ) {}
+        AliHLTTPCCASharedMemory& operator=( const AliHLTTPCCASharedMemory& /*dummy*/ ) { return *this; }
 #endif
-    protected:
-      Int_t fIRow; // current row index
-      Int_t fIRowUp; // current row index
-      Int_t fIRowDn; // current row index
-      Int_t fNRows; // number of rows
-      Int_t fNHits; // number of hits
-      Short_t *fHitLinkDn; // links to the previous row
-      Short_t *fHitLinkUp; // links to the next row
-      Short_t *fUpHitLinkDn; // links from next row
-      Short_t *fDnHitLinkUp; // links from previous row
-      Int_t fFirstHit; // index of the first row hit in global arrays 
+      protected:
+        int fIRow; // current row index
+        int fIRowUp; // current row index
+        int fIRowDn; // current row index
+        int fNRows; // number of rows
+        int fNHits; // number of hits
+        short *fHitLinkDn; // links to the previous row
+        short *fHitLinkUp; // links to the next row
+        short *fUpHitLinkDn; // links from next row
+        short *fDnHitLinkUp; // links from previous row
+        int fFirstHit; // index of the first row hit in global arrays
     };
 
-  GPUd() static Int_t NThreadSyncPoints(){ return 1; }  
+    GPUd() static int NThreadSyncPoints() { return 1; }
 
-  GPUd() static void Thread( Int_t /*nBlocks*/, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
-                            AliHLTTPCCASharedMemory &smem, AliHLTTPCCATracker &tracker );
+    GPUd() static void Thread( int /*nBlocks*/, int nThreads, int iBlock, int iThread, int iSync,
+                               AliHLTTPCCASharedMemory &smem, AliHLTTPCCATracker &tracker );
 };
 
 
index 4a2986b..ff1d3ee 100644 (file)
@@ -1,6 +1,6 @@
 // @(#) $Id: AliHLTTPCCANeighboursFinder1.cxx 27042 2008-07-02 12:06:02Z richterm $
 // **************************************************************************
-// This file is property of and copyright by the ALICE HLT Project          * 
+// 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> *
 #endif
 
 GPUd() void AliHLTTPCCANeighboursFinder::Thread
-( Int_t /*nBlocks*/, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
+( int /*nBlocks*/, int nThreads, int iBlock, int iThread, int iSync,
   AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
 {
   //* find neighbours
-  
-  if( iSync==0 )
-    {
-      if( iThread==0 ){
-       s.fNRows = tracker.Param().NRows();
-       s.fIRow = iBlock;
-       if( s.fIRow < s.fNRows ){
-         const AliHLTTPCCARow &row = tracker.Row(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>=2) && (s.fIRow<=s.fNRows-3) ){
-           s.fIRowUp = s.fIRow+2;
-           s.fIRowDn = s.fIRow-2; 
-           s.fFirstDn = tracker.Row(s.fIRowDn).FirstHit();
-           s.fFirstUp = tracker.Row(s.fIRowUp).FirstHit();
-           float xDn = tracker.Row(s.fIRowDn).X();
-           float x = tracker.Row(s.fIRow).X();
-           float xUp = tracker.Row(s.fIRowUp).X();
-           s.fUpNHits = tracker.Row(s.fIRowUp).NHits();
-           s.fDnNHits = s.fFirst - s.fFirstDn;
-           s.fUpDx = xUp - x;
-           s.fDnDx = xDn - x;
-           s.fUpTx = xUp/x;
-           s.fDnTx = xDn/x;
-           s.fGridUp = tracker.Row(s.fIRowUp).Grid();
-           s.fGridDn = tracker.Row(s.fIRowDn).Grid();
-         }
-       }
+
+  if ( iSync == 0 ) {
+    if ( iThread == 0 ) {
+      s.fNRows = tracker.Param().NRows();
+      s.fIRow = iBlock;
+      if ( s.fIRow < s.fNRows ) {
+        const AliHLTTPCCARow &row = tracker.Row( s.fIRow );
+        s.fFirst = row.FirstHit();
+        s.fNHits = row.NHits();
+
+        s.fHitLinkUp = ( ( short* )( tracker.RowData() + row.FullOffset() ) ) + row.FullLinkOffset();
+        s.fHitLinkDn = s.fHitLinkUp + row.NHits();
+
+        if ( ( s.fIRow >= 2 ) && ( s.fIRow <= s.fNRows - 3 ) ) {
+          s.fIRowUp = s.fIRow + 2;
+          s.fIRowDn = s.fIRow - 2;
+          s.fFirstDn = tracker.Row( s.fIRowDn ).FirstHit();
+          s.fFirstUp = tracker.Row( s.fIRowUp ).FirstHit();
+          float xDn = tracker.Row( s.fIRowDn ).X();
+          float x = tracker.Row( s.fIRow ).X();
+          float xUp = tracker.Row( s.fIRowUp ).X();
+          s.fUpNHits = tracker.Row( s.fIRowUp ).NHits();
+          s.fDnNHits = s.fFirst - s.fFirstDn;
+          s.fUpDx = xUp - x;
+          s.fDnDx = xDn - x;
+          s.fUpTx = xUp / x;
+          s.fDnTx = xDn / x;
+          s.fGridUp = tracker.Row( s.fIRowUp ).Grid();
+          s.fGridDn = tracker.Row( s.fIRowDn ).Grid();
+        }
       }
-    } 
-  else if( iSync==1 )
-    {
-      if( s.fIRow < s.fNRows ){
-       if( (s.fIRow==0) || (s.fIRow==s.fNRows-1) || (s.fIRow==1) || (s.fIRow==s.fNRows-2) ){
-         for( Int_t ih=iThread; ih<s.fNHits; ih+=nThreads ){
-           s.fHitLinkUp[ih] = -1;
-           s.fHitLinkDn[ih] = -1;
-         }
-       }else {
-         const AliHLTTPCCARow &rowUp = tracker.Row(s.fIRowUp);
-         const AliHLTTPCCARow &rowDn = tracker.Row(s.fIRowDn);
-         const UShort_t *gContentUp = (reinterpret_cast<const UShort_t*>(tracker.RowData() + rowUp.FullOffset())) + rowUp.FullGridOffset();
-         const UShort_t *gContentDn = (reinterpret_cast<const 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()+s.fGridDn.Ny()+2; ih+=nThreads ){
-           s.fGridContentDn[ih] = gContentDn[ih];
-         }
-       }
+    }
+  } else if ( iSync == 1 ) {
+    if ( s.fIRow < s.fNRows ) {
+      if ( ( s.fIRow == 0 ) || ( s.fIRow == s.fNRows - 1 ) || ( s.fIRow == 1 ) || ( s.fIRow == s.fNRows - 2 ) ) {
+        for ( int ih = iThread; ih < s.fNHits; ih += nThreads ) {
+          s.fHitLinkUp[ih] = -1;
+          s.fHitLinkDn[ih] = -1;
+        }
+      } else {
+        const AliHLTTPCCARow &rowUp = tracker.Row( s.fIRowUp );
+        const AliHLTTPCCARow &rowDn = tracker.Row( s.fIRowDn );
+        const unsigned short *gContentUp = ( reinterpret_cast<const unsigned short*>( tracker.RowData() + rowUp.FullOffset() ) ) + rowUp.FullGridOffset();
+        const unsigned short *gContentDn = ( reinterpret_cast<const unsigned short*>( tracker.RowData() + rowDn.FullOffset() ) ) + rowDn.FullGridOffset();
+
+        for ( unsigned int ih = iThread; ih < s.fGridUp.N() + s.fGridUp.Ny() + 2; ih += nThreads ) {
+          s.fGridContentUp[ih] = gContentUp[ih];
+        }
+        for ( unsigned int ih = iThread; ih < s.fGridDn.N() + s.fGridDn.Ny() + 2; ih += nThreads ) {
+          s.fGridContentDn[ih] = gContentDn[ih];
+        }
       }
     }
-  else if( iSync==2 )
-    {
-      if( (s.fIRow<=1) || (s.fIRow >= s.fNRows-2) ) return;
-      //const float kAreaSize = 3;     
-      float chi2Cut = 3.*3.*4*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx );
-      const float kAreaSize = 3;     
-      //float chi2Cut = 3.*3.*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx ); //SG
-      const Int_t kMaxN = 20;
-      
-      const AliHLTTPCCARow &row = tracker.Row(s.fIRow);
-      const AliHLTTPCCARow &rowUp = tracker.Row(s.fIRowUp);
-      const AliHLTTPCCARow &rowDn = tracker.Row(s.fIRowDn);
-      float y0 = row.Grid().YMin();
-      float z0 = row.Grid().ZMin();
-      float stepY = row.HstepY();
-      float stepZ = row.HstepZ();
-      const uint4* tmpint4 = tracker.RowData() + row.FullOffset();
-      const ushort2 *hits = reinterpret_cast<const ushort2*>(tmpint4);
-
-      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_t linkUp = -1;
-       Int_t linkDn = -1;
-       
-       if( s.fDnNHits>0 && s.fUpNHits>0 ){
-         
-         Int_t nNeighUp = 0;
-         AliHLTTPCCAHit h0;
-         {
-           ushort2 hh = hits[ih];
-           h0.SetY( y0 + hh.x*stepY );
-           h0.SetZ( z0 + hh.y*stepZ );
-         }
-         //h0 = tracker.Hits()[ s.fFirst + ih ];         
-
-         float y = h0.Y(); 
-         float z = h0.Z(); 
-
-         AliHLTTPCCAHitArea areaDn, areaUp;
-         areaUp.Init( s.fGridUp,  s.fGridContentUp,s.fFirstUp, y*s.fUpTx, z*s.fUpTx, kAreaSize, kAreaSize );
-         areaDn.Init( s.fGridDn,  s.fGridContentDn,s.fFirstDn, y*s.fDnTx, z*s.fDnTx, kAreaSize, kAreaSize );
-         
-         do{
-           AliHLTTPCCAHit h;
-           Int_t i = areaUp.GetNext( tracker, rowUp,s.fGridContentUp, h );
-           if( i<0 ) break;          
-           neighUp[nNeighUp] = (UShort_t) i;
-           yzUp[nNeighUp] = CAMath::MakeFloat2( s.fDnDx*(h.Y()-y), s.fDnDx*(h.Z()-z) );
-           if( ++nNeighUp>=kMaxN ) break;
-         }while(1);
-         
-         Int_t nNeighDn=0;
-         
-         if( nNeighUp>0 ){
-
-           Int_t bestDn=-1, bestUp=-1;
-           float bestD=1.e10;
-
-           do{
-             AliHLTTPCCAHit h;
-             Int_t i = areaDn.GetNext( tracker, rowDn,s.fGridContentDn,h );
-             if( i<0 ) break;
-             
-             nNeighDn++;
-             float2 yzdn = CAMath::MakeFloat2( s.fUpDx*(h.Y()-y), s.fUpDx*(h.Z()-z) );
-             
-             for( Int_t iUp=0; iUp<nNeighUp; iUp++ ){
-               float2 yzup = yzUp[iUp];
-               float dy = yzdn.x - yzup.x;
-               float dz = yzdn.y - yzup.y;
-               float d = dy*dy + dz*dz;
-               if( d<bestD ){
-                 bestD = d;
-                 bestDn = i;
-                 bestUp = iUp;
-               }               
-             }
-           }while(1);            
-
-           if( bestD <= chi2Cut ){      
-             linkUp = neighUp[bestUp];
-             linkDn = bestDn;      
-           }
-         }
+  } else if ( iSync == 2 ) {
+    if ( ( s.fIRow <= 1 ) || ( s.fIRow >= s.fNRows - 2 ) ) return;
+
+    //const float kAreaSize = 3;
+    float chi2Cut = 3.*3.*4 * ( s.fUpDx * s.fUpDx + s.fDnDx * s.fDnDx );
+    const float kAreaSize = 3;
+    //float chi2Cut = 3.*3.*(s.fUpDx*s.fUpDx + s.fDnDx*s.fDnDx ); //SG
+    const int kMaxN = 20;
+
+    const AliHLTTPCCARow &row = tracker.Row( s.fIRow );
+    const AliHLTTPCCARow &rowUp = tracker.Row( s.fIRowUp );
+    const AliHLTTPCCARow &rowDn = tracker.Row( s.fIRowDn );
+    float y0 = row.Grid().YMin();
+    float z0 = row.Grid().ZMin();
+    float stepY = row.HstepY();
+    float stepZ = row.HstepZ();
+    const uint4* tmpint4 = tracker.RowData() + row.FullOffset();
+    const ushort2 *hits = reinterpret_cast<const ushort2*>( tmpint4 );
+
+    for ( int ih = iThread; ih < s.fNHits; ih += nThreads ) {
+
+      unsigned short *neighUp = s.fB[iThread];
+      float2 *yzUp = s.fA[iThread];
+      //unsigned short neighUp[5];
+      //float2 yzUp[5];
+
+      int linkUp = -1;
+      int linkDn = -1;
+
+      if ( s.fDnNHits > 0 && s.fUpNHits > 0 ) {
+
+        int nNeighUp = 0;
+        AliHLTTPCCAHit h0;
+        {
+          ushort2 hh = hits[ih];
+          h0.SetY( y0 + hh.x*stepY );
+          h0.SetZ( z0 + hh.y*stepZ );
+        }
+        //h0 = tracker.Hits()[ s.fFirst + ih ];
+
+        float y = h0.Y();
+        float z = h0.Z();
+
+        AliHLTTPCCAHitArea areaDn, areaUp;
+        areaUp.Init( s.fGridUp,  s.fGridContentUp, s.fFirstUp, y*s.fUpTx, z*s.fUpTx, kAreaSize, kAreaSize );
+        areaDn.Init( s.fGridDn,  s.fGridContentDn, s.fFirstDn, y*s.fDnTx, z*s.fDnTx, kAreaSize, kAreaSize );
+
+        do {
+          AliHLTTPCCAHit h;
+          int i = areaUp.GetNext( tracker, rowUp, s.fGridContentUp, h );
+          if ( i < 0 ) break;
+          neighUp[nNeighUp] = ( unsigned short ) i;
+          yzUp[nNeighUp] = CAMath::MakeFloat2( s.fDnDx * ( h.Y() - y ), s.fDnDx * ( h.Z() - z ) );
+          if ( ++nNeighUp >= kMaxN ) break;
+        } while ( 1 );
+
+        int nNeighDn = 0;
+
+        if ( nNeighUp > 0 ) {
+
+          int bestDn = -1, bestUp = -1;
+          float bestD = 1.e10;
+
+          do {
+            AliHLTTPCCAHit h;
+            int i = areaDn.GetNext( tracker, rowDn, s.fGridContentDn, h );
+            if ( i < 0 ) break;
+
+            nNeighDn++;
+            float2 yzdn = CAMath::MakeFloat2( s.fUpDx * ( h.Y() - y ), s.fUpDx * ( h.Z() - z ) );
+
+            for ( int iUp = 0; iUp < nNeighUp; iUp++ ) {
+              float2 yzup = yzUp[iUp];
+              float dy = yzdn.x - yzup.x;
+              float dz = yzdn.y - yzup.y;
+              float d = dy * dy + dz * dz;
+              if ( d < bestD ) {
+                bestD = d;
+                bestDn = i;
+                bestUp = iUp;
+              }
+            }
+          } while ( 1 );
+
+          if ( bestD <= chi2Cut ) {
+            linkUp = neighUp[bestUp];
+            linkDn = bestDn;
+          }
+        }
 #ifdef DRAW
-         std::cout<<"n NeighUp = "<<nNeighUp<<", n NeighDn = "<<nNeighDn<<std::endl;
-#endif   
+        std::cout << "n NeighUp = " << nNeighUp << ", n NeighDn = " << nNeighDn << std::endl;
+#endif
 
-       }
-       
-       s.fHitLinkUp[ih] = linkUp;
-       s.fHitLinkDn[ih] = linkDn;
+      }
+
+      s.fHitLinkUp[ih] = linkUp;
+      s.fHitLinkDn[ih] = linkDn;
 #ifdef DRAW
-       std::cout<<"Links for row "<<s.fIRow<<", hit "<<ih<<": "<<linkUp<<" "<<linkDn<<std::endl;
-       if( s.fIRow==22 && ih==5 )
-         {
-         AliHLTTPCCADisplay::Instance().DrawSliceLink(s.fIRow, ih, -1, -1, 1);  
-         AliHLTTPCCADisplay::Instance().DrawSliceHit(s.fIRow, ih, kBlue, 1.);
-         AliHLTTPCCADisplay::Instance().Ask();
-       }
-#endif
+      std::cout << "Links for row " << s.fIRow << ", hit " << ih << ": " << linkUp << " " << linkDn << std::endl;
+      if ( s.fIRow == 22 && ih == 5 ) {
+        AliHLTTPCCADisplay::Instance().DrawSliceLink( s.fIRow, ih, -1, -1, 1 );
+        AliHLTTPCCADisplay::Instance().DrawSliceHit( s.fIRow, ih, kBlue, 1. );
+        AliHLTTPCCADisplay::Instance().Ask();
       }
+#endif
     }
+  }
 }