removing unused classes from repository
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Dec 2011 08:32:26 +0000 (08:32 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Dec 2011 08:32:26 +0000 (08:32 +0000)
14 files changed:
HLT/TPCLib/AliHLTTPCFitter.cxx [deleted file]
HLT/TPCLib/AliHLTTPCFitter.h [deleted file]
HLT/TPCLib/AliHLTTPCGlobalMerger.cxx [deleted file]
HLT/TPCLib/AliHLTTPCGlobalMerger.h [deleted file]
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx [deleted file]
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.h [deleted file]
HLT/TPCLib/AliHLTTPCInterMerger.cxx [deleted file]
HLT/TPCLib/AliHLTTPCInterMerger.h [deleted file]
HLT/TPCLib/AliHLTTPCMerger.cxx [deleted file]
HLT/TPCLib/AliHLTTPCMerger.h [deleted file]
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx [deleted file]
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.h [deleted file]
HLT/TPCLib/AliHLTTPCTrackMerger.cxx [deleted file]
HLT/TPCLib/AliHLTTPCTrackMerger.h [deleted file]

diff --git a/HLT/TPCLib/AliHLTTPCFitter.cxx b/HLT/TPCLib/AliHLTTPCFitter.cxx
deleted file mode 100644 (file)
index 0bb258a..0000000
+++ /dev/null
@@ -1,649 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTFitter.cxx,v 1.14 2005/06/14 10:55:21 cvetan 
-
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- *                                                                        *
- * Primary Authors: Anders Vestbo, maintained by                          *
- *                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
- *                  for The ALICE HLT Project.                            *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/** @file   AliHLTTPCFitter.cxx
-    @author Anders Vestbo, maintained by Matthias Richter
-    @date   
-    @brief  Fit class HLT for helix
-*/
-
-#include <math.h>
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPCFitter.h"
-#include "AliHLTTPCVertex.h"
-#include "AliHLTTPCTrack.h"
-#include "AliHLTTPCSpacePointData.h"
-#include "AliHLTTPCTransform.h"
-//#include "AliHLTTPC.h"
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-ClassImp(AliHLTTPCFitter)
-
-
-AliHLTTPCFitter::AliHLTTPCFitter()
-  :
-  fTrack(NULL),
-  fVertex(NULL),
-  fVertexConstraint(0)
-{
-  //constructor
-  // see header file for class documentation
-  // or
-  // refer to README to build package
-  // or
-  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-  memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
-  memset(fNcl,0,36*6*sizeof(UInt_t));
-}
-
-AliHLTTPCFitter::AliHLTTPCFitter(AliHLTTPCVertex *vertex,Bool_t vertexconstraint)
-  :
-  fTrack(NULL),
-  fVertex(vertex),
-  fVertexConstraint(vertexconstraint)
-{
-  //constructor
-  fTrack=0;
-  memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
-}
-
-AliHLTTPCFitter::~AliHLTTPCFitter()
-{
-  //destructor
-  for(Int_t i=0; i<36; i++)
-    {
-      for(Int_t j=0; j<6; j++)
-       {
-         if(fClusters[i][j])
-           delete [] fClusters[i][j];
-       }
-    }
-}
-
-void AliHLTTPCFitter::SortTrackClusters(AliHLTTPCTrack *track) const
-{
-  //Sort the internal cluster list in each track with respect to row numbering.
-  //This may be necessary when no conventional track follower has been
-  //applied, in which the cluster list has been maintained in a more
-  //arbitrary fashion.
-
-  Int_t nhits = track->GetNHits();
-  Int_t *ids = (Int_t*)track->GetHitNumbers();
-  Int_t *origids = new Int_t[nhits];
-  Int_t *mk = new Int_t[nhits];
-  Int_t k;
-
-  for(k=0; k<nhits; k++) {origids[k] = ids[k]; mk[k] = -1;}
-  
-  Int_t slice,patch,id,padrow,maxrow,maxk;
-  UInt_t pos;
-  for(Int_t j=0; j<nhits; j++)
-    {
-      maxrow=-1;
-      maxk=200;
-      for(k=0; k<nhits; k++)
-       {
-         id=ids[k];
-         if(id < 0) continue;
-         slice = AliHLTTPCSpacePointData::GetSlice(id);
-         patch = AliHLTTPCSpacePointData::GetPatch(id);
-         pos = AliHLTTPCSpacePointData::GetNumber(id);
-         AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-         padrow = points[pos].fPadRow;
-         if(padrow > maxrow)
-           {
-             maxrow = padrow;
-             maxk=k;
-           }
-       }
-      mk[j]=maxk;
-      ids[maxk]=-1;
-    }
-    
-  for(k=0; k<nhits; k++)
-    ids[k] = origids[mk[k]];
-  delete [] origids;
-  delete [] mk;
-}
-
-Int_t AliHLTTPCFitter::FitHelix(AliHLTTPCTrack *track)
-{
-  //fit helix parameters
-  fTrack = track;
-  if(FitCircle())
-    {
-      LOG(AliHLTTPCLog::kError,"AliHLTTPCFitter::FitHelix","TrackFit")<<AliHLTTPCLog::kDec<<
-       "Problems during circle fit"<<ENDLOG;
-      return 1;
-    }
-  if(FitLine())
-    {
-      LOG(AliHLTTPCLog::kError,"AliHLTTPCFitter::FitHelix","TrackFit")<<AliHLTTPCLog::kDec<<
-       "Problems during line fit"<<ENDLOG;
-      return 1;
-    }
-  return 0;
-}
-
-Int_t AliHLTTPCFitter::FitCircle()
-{
-  //-----------------------------------------------------------------
-  //Fits circle parameters using algorithm
-  //described by ChErnov and Oskov in Computer Physics
-  //Communications.
-  // 
-  //Written in FORTRAN by Jawluen Tang, Physics department , UT-Austin 
-  //Moved to C by Pablo Yepes
-  //Moved to AliROOT by ASV.
-  //------------------------------------------------------------------
-
-  if (!fTrack) return -1;
-  
-  Double_t wsum  = 0.0 ;
-  Double_t xav   = 0.0 ;
-  Double_t yav   = 0.0 ;
-  
-  //
-  //     Loop over hits calculating average
-  Double_t * fXYWeight = new Double_t[(fTrack->GetNHits())];
-  UInt_t *hitnum = fTrack->GetHitNumbers();
-  if (!fXYWeight || !hitnum) {
-    if (fXYWeight) delete [] fXYWeight;
-    return -1;
-  }
-  memset(fXYWeight, 0, fTrack->GetNHits()*sizeof(Double_t));
-  for(Int_t i=0; i<fTrack->GetNHits(); i++)
-    {
-      UInt_t id = hitnum[i];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-      fXYWeight[i] = 1./ (Double_t)(points[pos].fSigmaY2 + points[pos].fSigmaY2);
-      wsum += fXYWeight[i];
-      xav += fXYWeight[i]*points[pos].fX;
-      yav += fXYWeight[i]*points[pos].fY;
-    }
-  if (fVertexConstraint == kTRUE)
-    {    
-      wsum += fVertex->GetXYWeight() ;
-      xav  += fVertex->GetX() ;
-      yav  += fVertex->GetY() ;
-    }
-  
-  xav = xav / wsum ;
-  yav = yav / wsum ;
-//
-//  CALCULATE <X**2>, <XY>, AND <Y**2> WITH <X> = 0, & <Y> = 0
-//
-  Double_t xxav  = 0.0 ;
-  Double_t xyav  = 0.0 ; 
-  Double_t yyav  = 0.0 ;
-  Double_t xi, yi ;
-  
-  for(Int_t i=0; i<fTrack->GetNHits(); i++)
-    { 
-      UInt_t id = hitnum[i];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-
-      xi = points[pos].fX -xav;
-      yi        = points[pos].fY - yav ;
-      xxav     += xi * xi * fXYWeight[i];
-      xyav     += xi * yi * fXYWeight[i];
-      yyav     += yi * yi * fXYWeight[i];
-    }
-  
-  if (fVertexConstraint == kTRUE)
-    {
-      xi        = fVertex->GetX() - xav ;
-      yi        = fVertex->GetY() - yav ;
-      xxav     += xi * xi * fVertex->GetXYWeight() ;
-      xyav     += xi * yi * fVertex->GetXYWeight() ;
-      yyav     += yi * yi * fVertex->GetXYWeight() ; 
-    }
-  xxav = xxav / wsum ;
-  xyav = xyav / wsum ;
-  yyav = yyav / wsum ;
-//
-//-->  ROTATE COORDINATES SO THAT <XY> = 0
-//
-//-->  SIGN(C**2 - S**2) = SIGN(XXAV - YYAV) >
-//-->  &                                     > ==> NEW : (XXAV-YYAV) > 0
-//-->  SIGN(S) = SIGN(XYAV)                  >
-
-  Double_t a = fabs( xxav - yyav ) ;
-  Double_t b = 4.0 * xyav * xyav ;
-
-  Double_t asqpb  = a * a + b  ;
-  Double_t rasqpb = sqrt ( asqpb) ;
-
-  Double_t splus  = 1.0 + a / rasqpb ;
-  Double_t sminus = b / (asqpb * splus) ;
-
-  splus  = sqrt (0.5 * splus ) ;
-  sminus = sqrt (0.5 * sminus) ;
-//
-//->  FIRST REQUIRE : SIGN(C**2 - S**2) = SIGN(XXAV - YYAV)
-//
-  Double_t sinrot, cosrot ;
-  if ( xxav <= yyav ) {
-        cosrot = sminus ;
-        sinrot = splus  ;
-  }
-  else {
-         cosrot = splus ;
-         sinrot = sminus ;
-  }
-//
-//->  REQUIRE : SIGN(S) = SIGN(XYAV) * SIGN(C) (ASSUMING SIGN(C) > 0)
-//
-  if ( xyav < 0.0 ) sinrot = - sinrot ;
-//
-//-->  WE NOW HAVE THE SMALLEST ANGLE THAT GUARANTEES <X**2> > <Y**2>
-//-->  TO GET THE SIGN OF THE CHARGE RIGHT, THE NEW X-AXIS MUST POINT
-//-->  OUTWARD FROM THE ORGIN.  WE ARE FREE TO CHANGE SIGNS OF BOTH
-//-->  COSROT AND SINROT SIMULTANEOUSLY TO ACCOMPLISH THIS.
-//
-//-->  CHOOSE SIGN OF C WISELY TO BE ABLE TO GET THE SIGN OF THE CHARGE
-//
-  if ( cosrot*xav+sinrot*yav < 0.0 ) {
-         cosrot = -cosrot ;
-         sinrot = -sinrot ;
-  }
-//
-//->  NOW GET <R**2> AND RSCALE= SQRT(<R**2>)
-//
-  Double_t rrav   = xxav + yyav ;
-  Double_t rscale = sqrt(rrav) ;
-
-  xxav   = 0.0 ;
-  yyav   = 0.0 ;
-  xyav   = 0.0 ;
-  Double_t xrrav = 0.0 ;
-  Double_t yrrav = 0.0 ;
-  Double_t rrrrav  = 0.0 ;
-
-  Double_t xixi, yiyi, riri, wiriri, xold, yold ;
-  
-  for(Int_t i=0; i<fTrack->GetNHits(); i++)
-    { 
-      UInt_t id = hitnum[i];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-      
-      xold = points[pos].fX - xav ;
-      yold = points[pos].fY - yav ;
-      //
-      //-->  ROTATE SO THAT <XY> = 0 & DIVIDE BY RSCALE SO THAT <R**2> = 1
-      //
-      xi = (  cosrot * xold + sinrot * yold ) / rscale ;
-      yi = ( -sinrot * xold + cosrot * yold ) / rscale ;
-      
-      xixi   = xi * xi ;
-      yiyi   = yi * yi ;
-      riri   = xixi + yiyi ;
-      wiriri = fXYWeight[i] * riri ;
-      
-      xyav   += fXYWeight[i] * xi * yi ;
-      xxav   += fXYWeight[i] * xixi ;
-      yyav   += fXYWeight[i] * yiyi ;
-      
-      xrrav  += wiriri * xi ;
-      yrrav  += wiriri * yi ;
-      rrrrav += wiriri * riri ;
-    }
-//
-//   Include vertex if required
-//
-  if (fVertexConstraint == kTRUE)
-    {
-      xold = fVertex->GetX() - xav ;
-       yold = fVertex->GetY() - yav ;
-       //
-       //-->  ROTATE SO THAT <XY> = 0 & DIVIDE BY RSCALE SO THAT <R**2> = 1
-       //
-       xi = (  cosrot * xold + sinrot * yold ) / rscale ;
-       yi = ( -sinrot * xold + cosrot * yold ) / rscale ;
-       
-       xixi   = xi * xi ;
-       yiyi   = yi * yi ;
-       riri   = xixi + yiyi ;
-       wiriri = fVertex->GetXYWeight() * riri ;
-
-       xyav   += fVertex->GetXYWeight() * xi * yi ;
-       xxav   += fVertex->GetXYWeight() * xixi ;
-       yyav   += fVertex->GetXYWeight() * yiyi ;
-
-       xrrav  += wiriri * xi ;
-       yrrav  += wiriri * yi ;
-       rrrrav += wiriri * riri ;
-  }
-  //
-  //    
-  //
-  //-->  DIVIDE BY WSUM TO MAKE AVERAGES
-  //
-  xxav    = xxav   / wsum ;
-  yyav    = yyav   / wsum ;
-  xrrav   = xrrav  / wsum ;
-  yrrav   = yrrav  / wsum ;
-  rrrrav  = rrrrav / wsum ;
-  xyav    = xyav   / wsum ;
-
-  Int_t const kntry = 5 ;
-//
-//-->  USE THESE TO GET THE COEFFICIENTS OF THE 4-TH ORDER POLYNIMIAL
-//-->  DON'T PANIC - THE THIRD ORDER TERM IS ZERO !
-//
-  Double_t xrrxrr = xrrav * xrrav ;
-  Double_t yrryrr = yrrav * yrrav ;
-  Double_t rrrrm1 = rrrrav - 1.0  ;
-  Double_t xxyy   = xxav  * yyav  ;        
-
-  Double_t c0  =          rrrrm1*xxyy - xrrxrr*yyav - yrryrr*xxav ;
-  Double_t c1  =        - rrrrm1      + xrrxrr      + yrryrr   - 4.0*xxyy ;        
-  Double_t c2  =   4.0  + rrrrm1                               - 4.0*xxyy ;           
-  Double_t c4  = - 4.0  ;                
-//
-//-->  COEFFICIENTS OF THE DERIVATIVE - USED IN NEWTON-RAPHSON ITERATIONS
-//
-  Double_t c2d =   2.0 * c2 ;
-  Double_t c4d =   4.0 * c4 ;
-//
-//-->  0'TH VALUE OF LAMDA - LINEAR INTERPOLATION BETWEEN P(0) & P(YYAV)
-//
-//   LAMDA = YYAV * C0 / (C0 + YRRSQ * (XXAV-YYAV))
-  Double_t lamda  = 0.0 ;
-  Double_t dlamda = 0.0 ;
-//
-  Double_t chiscl = wsum * rscale * rscale ;
-  Double_t dlamax = 0.001 / chiscl ;   
-   
-  Double_t p, pd ;
-  for ( int itry = 1 ; itry <= kntry ; itry++ ) {
-     p      = c0 + lamda * (c1 + lamda * (c2 + lamda * lamda * c4 )) ;
-     pd     = (c1 + lamda * (c2d + lamda * lamda * c4d)) ;
-     dlamda = -p / pd ;
-     lamda  = lamda + dlamda ;
-     if (fabs(dlamda)<   dlamax) break ;
-  }
-
-  //Double_t chi2 = (Double_t)(chiscl * lamda) ;
-  //fTrack->SetChiSq1(chi2);
-  // Double_t dchisq = chiscl * dlamda ;            
-  //
-  //-->  NOW CALCULATE THE MATRIX ELEMENTS FOR ALPHA, BETA & KAPPA
-  //
-  Double_t h11   = xxav  -     lamda ;
-  Double_t h14   = xrrav ;
-  Double_t h22   = yyav  -     lamda ; 
-  Double_t h24   = yrrav ;
-  Double_t h34   = 1.0   + 2.0*lamda ;
-  if ( h11 == 0.0 || h22 == 0.0 ){
-    LOG(AliHLTTPCLog::kError,"AliHLTTPCFitter::FitCircle","TrackFit")<<AliHLTTPCLog::kDec<<
-      "Problems fitting circle"<<ENDLOG;
-    delete [] fXYWeight;
-    return 1 ;
-  }
-  Double_t rootsq = (h14*h14)/(h11*h11) + 4.0*h34 ;
-
-  Double_t ratio, kappa, beta ;
-  if ( fabs(h22) > fabs(h24) ) {
-     ratio  = h24 / h22 ;
-     rootsq = ratio * ratio + rootsq ;
-     kappa = 1.0 / sqrt(rootsq) ;
-     beta  = - ratio * kappa ;
-  }
-  else {
-     ratio  = h22 / h24 ;
-     rootsq = 1.0 + ratio * ratio * rootsq ;
-     beta  = 1.0 / sqrt(rootsq) ;
-     if ( h24 > 0 ) beta = - beta ;
-     kappa = -ratio * beta ;
-  }            
-  Double_t alpha = - (h14/h11) * kappa ;
-//
-//-->  transform these into the lab coordinate system
-//-->  first get kappa and back to real dimensions
-//
-  Double_t kappa1 = kappa / rscale ;
-  Double_t dbro   = 0.5   / kappa1 ;
-//
-//-->  next rotate alpha and beta and scale
-//
-  Double_t alphar = (cosrot * alpha - sinrot * beta)* dbro ;
-  Double_t betar  = (sinrot * alpha + cosrot * beta)* dbro ;
-//
-//-->  then translate by (xav,yav)
-//
-  Double_t acent  = (double)(xav - alphar) ;
-  Double_t bcent  = (double)(yav - betar ) ;
-  Double_t radius = (double)dbro ;
-//
-//   Get charge
-//
-  Int_t q = ( ( yrrav < 0 ) ? 1 : -1 ) ;
-  fTrack->SetCharge(q);
-  
-  //Set the first point on the track to the space point coordinates of the innermost track
-  //This will be updated to lie on the fit later on (AliHLTTPCTrack::UpdateToFirstPoint).
-  Double_t x0,y0,psi,pt ;
-  Int_t lastid=fTrack->GetNHits()-1;
-  UInt_t id = hitnum[lastid];
-  Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-  Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-  UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-  AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-  x0   =  points[pos].fX;
-  y0   =  points[pos].fY;
-  fTrack->SetFirstPoint(x0,y0,0); //Z-value is set in FitLine
-  
-  //Set the remaining fit parameters
-  psi  = (Double_t)atan2(bcent-y0,acent-x0) ;
-  psi  = psi + q * 0.5F * AliHLTTPCTransform::Pi() ;
-  if ( psi < 0 ) psi = psi + 2*AliHLTTPCTransform::Pi();
-  
-  pt   = (Double_t)(AliHLTTPCTransform::GetBFact() * AliHLTTPCTransform::GetBField() * radius ) ;
-  fTrack->SetPsi(psi);
-  fTrack->SetPt(pt);
-  fTrack->SetRadius(radius);
-  fTrack->SetCenterX(acent);
-  fTrack->SetCenterY(bcent);
-//
-//    Get errors from fast fit
-//
-  //if ( getPara()->getErrors ) getErrorsCircleFit ( acent, bcent, radius ) ;
-//
-  delete [] fXYWeight;
-  return 0 ;
-}
-
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//    Fit Line in s-z plane
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Int_t AliHLTTPCFitter::FitLine ( )
-{
-  // Fit Line in s-z plane
-  if (!fTrack) return -1;
-
-  //
-  //Initialization 
-  //
-  Double_t sum = 0.F ;
-  Double_t ss  = 0.F ;
-  Double_t sz  = 0.F ;
-  Double_t sss = 0.F ;
-  Double_t ssz = 0.F ;
-  //
-  //find sum , sums ,sumz, sumss 
-  // 
-  Double_t dx, dy ;
-  Double_t radius = (Double_t)(fTrack->GetPt() / ( AliHLTTPCTransform::GetBFact() * AliHLTTPCTransform::GetBField() ) ) ;
-
-  Double_t * fS = new Double_t[(fTrack->GetNHits())];
-  Double_t *fZWeight = new Double_t[fTrack->GetNHits()];
-  UInt_t *hitnum = fTrack->GetHitNumbers();
-  if (!fS || !fZWeight || !hitnum) {
-    if (fS) delete [] fS;
-    if (fZWeight) delete [] fZWeight;
-    return -1;
-  }
-  memset(fS, 0, fTrack->GetNHits()*sizeof(Double_t));
-  memset(fZWeight, 0, fTrack->GetNHits()*sizeof(Double_t));
-  if (0)//fVertexConstraint==kTRUE)
-    {
-      UInt_t id = hitnum[0];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-      
-      dx = points[pos].fX - fVertex->GetX();
-      dy = points[pos].fY - fVertex->GetY();
-    }
-  else 
-    {
-      UInt_t id = hitnum[0];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t posf = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *pointsf = fClusters[slice][patch];
-      id = hitnum[(fTrack->GetNHits()-1)];
-      slice = AliHLTTPCSpacePointData::GetSlice(id);
-      patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t posl = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *pointsl = fClusters[slice][patch];
-      dx = pointsf[posf].fX - pointsl[posl].fX;
-      dy = pointsf[posf].fY - pointsl[posl].fY;
-    }
-
-  Double_t localPsi = 0.5F * sqrt ( dx*dx + dy*dy ) / radius ;
-  Double_t totals ;
-  
-  if ( fabs(localPsi) < 1. ) 
-    {
-      totals = 2.0 * radius * asin ( localPsi ) ;
-    } 
-  else 
-    { 
-      totals = 2.0 * radius * AliHLTTPCTransform::Pi() ;
-    } 
-  
-  Double_t dpsi,s;
-  
-  for(Int_t i=0; i<fTrack->GetNHits(); i++)
-    { 
-      UInt_t id = hitnum[i];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-      
-      fZWeight[i] = 1./(Double_t)(points[pos].fSigmaZ2);
-      if(i>0)
-       {
-         id = hitnum[i-1];
-         slice = AliHLTTPCSpacePointData::GetSlice(id);
-         patch = AliHLTTPCSpacePointData::GetPatch(id);
-         UInt_t lastpos = AliHLTTPCSpacePointData::GetNumber(id);
-         AliHLTTPCSpacePointData *lastpoints = fClusters[slice][patch];
-         dx = points[pos].fX -lastpoints[lastpos].fX;
-         dy = points[pos].fY -lastpoints[lastpos].fY;
-         dpsi = 0.5 * (Double_t)sqrt ( dx*dx + dy*dy ) / radius ;
-         if(fabs(dpsi) > 1) {
-           delete [] fS;
-           delete [] fZWeight;
-           return 1;
-         }
-         fTrack->SetPsierr(dpsi);
-         s = fS[i-1] - 2.0 * radius * (Double_t)asin ( dpsi ) ;
-         fS[i]=s;
-       }
-      else
-       fS[i]=totals;
-      
-      sum += fZWeight[i];
-      ss  += fZWeight[i] * fS[i];
-      sz  += fZWeight[i] * points[pos].fZ;
-      sss += fZWeight[i] * fS[i] * fS[i];
-      ssz += fZWeight[i] * fS[i] * points[pos].fZ;
-      
-    }
-  
-  
-  Double_t chi2,det = sum * sss - ss * ss;
-  if ( fabs(det) < 1e-20)
-    { 
-      chi2 = 99999.F ;
-      //fTrack->SetChiSq2(chi2);
-      delete [] fS;
-      delete [] fZWeight;
-      return 0 ;
-    }
-  
-  //Compute the best fitted parameters A,B
-  Double_t tanl,z0,dtanl,dz0;
-
-  tanl = (Double_t)((sum * ssz - ss * sz ) / det );
-  z0   = (Double_t)((sz * sss - ssz * ss ) / det );
-
-  fTrack->SetTgl(tanl);
-  fTrack->SetZ0(z0);
-  
-  //calculate chi-square 
-  chi2 = 0.;
-  Double_t r1 ;
-  
-  for(Int_t i=0; i<fTrack->GetNHits(); i++)
-    { 
-      UInt_t id = hitnum[i];
-      Int_t slice = AliHLTTPCSpacePointData::GetSlice(id);
-      Int_t patch = AliHLTTPCSpacePointData::GetPatch(id);
-      UInt_t pos = AliHLTTPCSpacePointData::GetNumber(id);
-      AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-      r1   = points[pos].fZ - tanl * fS[i] - z0 ;
-      chi2 += (Double_t) ( (Double_t)(fZWeight[i]) * (r1 * r1) );
-    }
-  
-  //fTrack->SetChiSq2(chi2);
-  //
-  //calculate estimated variance
-  //varsq=chi/(double(n)-2.) 
-  //calculate covariance matrix 
-  //siga=sqrt(varsq*sxx/det) 
-  //sigb=sqrt(varsq*sum/det) 
-  //
-  dtanl = (Double_t) ( sum / det );
-  dz0   = (Double_t) ( sss / det );
-  
-  fTrack->SetTglerr(dtanl);
-  fTrack->SetZ0err(dz0);
-  delete [] fZWeight;
-  delete [] fS;
-  return 0 ;
-} 
diff --git a/HLT/TPCLib/AliHLTTPCFitter.h b/HLT/TPCLib/AliHLTTPCFitter.h
deleted file mode 100644 (file)
index 5d04bfe..0000000
+++ /dev/null
@@ -1,54 +0,0 @@
-// $Id$
-// Original: AliHLTFitter.h,v 1.7 2004/07/05 09:02:18 loizides 
-
-#ifndef ALIHLTTPCFITTER_H
-#define ALIHLTTPCFITTER_H
-//* 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                               *
-
-/// @file   AliHLTTPCFitter.h
-/// @author Anders Vestbo, maintained by Matthias Richter
-/// @date   
-/// @brief  Fit class HLT for helix
-///
-
-class AliHLTTPCTrack;
-class AliHLTTPCVertex;
-struct AliHLTTPCSpacePointData;
-
-/** 
- * @class AliHLTTPCFitter
- * Fit class HLT for helix
- *
- * @ingroup alihlt_tpc
- */
-class AliHLTTPCFitter {
-
-  public:
-  AliHLTTPCFitter();
-  AliHLTTPCFitter(AliHLTTPCVertex *vertex,Bool_t vertexconstraint=kTRUE);
-  virtual ~AliHLTTPCFitter();
-  
-  void SortTrackClusters(AliHLTTPCTrack *track) const;
-  Int_t FitHelix(AliHLTTPCTrack *track);
-  Int_t FitCircle();
-  Int_t FitLine();
-  void NoVertex() {fVertexConstraint=kFALSE;}
- private:
-  /** copy constructor prohibited */
-  AliHLTTPCFitter(const AliHLTTPCFitter& src);
-  /** assignment operator prohibited */
-  AliHLTTPCFitter& operator=(const AliHLTTPCFitter& src);
-
-  AliHLTTPCTrack *fTrack; //!                    actual track
-  AliHLTTPCVertex *fVertex; //!                  vertex info
-  Bool_t fVertexConstraint; //               include vertex constraint
-  AliHLTTPCSpacePointData *fClusters[36][6]; //! clusters
-  UInt_t fNcl[36][6]; //                     cluster numbers
-  ClassDef(AliHLTTPCFitter,0) //HLT fit class
-};
-
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCGlobalMerger.cxx b/HLT/TPCLib/AliHLTTPCGlobalMerger.cxx
deleted file mode 100644 (file)
index 577b70e..0000000
+++ /dev/null
@@ -1,353 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTGlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan 
-
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- *                                                                        *
- * Primary Authors: Uli Frankenfeld, maintained by                          *
- *                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
- *                  for The ALICE HLT Project.                            *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/** @file   AliHLTTPCGlobalMerger.cxx
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC slice merger
-*/
-
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPCGlobalMerger.h"
-#include "AliHLTTPCTrack.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrackArray.h"
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-ClassImp(AliHLTTPCGlobalMerger)
-
-AliHLTTPCGlobalMerger::AliHLTTPCGlobalMerger()
-  :
-  fNSlices(0),
-  fFirst(0),
-  fLast(0)
-{
-  //Default constructor. Use Setup to specify and setup the necessary parameters and arrays.
-  Is2Global(kTRUE);
-  SetParameter(0,0,0,0,0);
-}
-
-
-AliHLTTPCGlobalMerger::~AliHLTTPCGlobalMerger()
-{
-  //Destructor
-}
-
-void AliHLTTPCGlobalMerger::Setup(Int_t first,Int_t last)
-{
-  //Used to setup the arrays and everything
-  
-  fNSlices = last-first+1;
-  fFirst = first;
-  fLast = last;
-  InitMerger(last-first+1);
-}
-
-void AliHLTTPCGlobalMerger::InitSlice(Int_t slice)
-{
-  // 
-  // Select Sector The following FillTracks call will 
-  // fill this Sector
-  //
-  fSlice = slice;
-  fCurrentTracks = fSlice - fFirst; 
-}
-
-Double_t AliHLTTPCGlobalMerger::CheckTracks(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack,Int_t slice)
-{
-  //Compare the tracks by propagating the outermost track to the last and first point plane
-  //of the innermost track. This plane is defined by the padrow plane where these points
-  //are.
-  
-  if(innertrack->GetCharge()!=outertrack->GetCharge()) return -1;
-  
-  Float_t angle = 0;//perpendicular to the padrowplane (in local system)
-  AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
-  Double_t dx[2],dy[2],dz[2];
-  Double_t diff =-1;
-  AliHLTTPCTrack *tracks[2];
-  tracks[0] = innertrack;
-  tracks[1] = outertrack;
-  SortGlobalTracks(tracks,2);
-  innertrack = tracks[0]; 
-  outertrack = tracks[1];
-  
-  Float_t point[3];
-  
-  point[0]=innertrack->GetLastPointX();
-  point[1]=innertrack->GetLastPointY();
-  point[2]=innertrack->GetLastPointZ();
-  AliHLTTPCTransform::Global2LocHLT(point,slice);
-  
-  outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
-  if(!outertrack->IsPoint()) return diff;
-  dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
-  dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
-  dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
-  
-  point[0]=innertrack->GetFirstPointX();
-  point[1]=innertrack->GetFirstPointY();
-  point[2]=innertrack->GetFirstPointZ();
-  AliHLTTPCTransform::Global2LocHLT(point,slice);
-  
-  outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
-  if(!outertrack->IsPoint()) return diff;
-  dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
-  dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
-  dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
-  
-  diff=0;//This was a tough bug to find....
-  for(Int_t i=0; i<2; i++)
-    diff += sqrt(dx[i]*dx[i] + dy[i]*dy[i] + dz[i]*dz[i]);
-  return diff;
-}
-
-void AliHLTTPCGlobalMerger::SlowMerge(const Char_t *path)
-{
-  //Tuning of parameters. This matches _all_ tracks between two neighbouring
-  //slices, and merges the ones which are closest in space. The difference
-  //is written to a ntuppel, which can be used as a input for the SetParameters
-  //when using normal Merge function.
-  
-  
-  void* ntuple=GetNtuple();
-  AliHLTTPCTrack *track[2];
-  AliHLTTPCTrackArray *tout = GetOutTracks();
-  if(fNSlices<2)
-    {
-      LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::SlowMerge","Slice Number")
-       <<"Need more than one Slice!"<<ENDLOG;
-      return;
-    }
-  
-  for(Int_t i=0; i<fNSlices; i++)
-    {
-      //if(fNSlices!=18 && i+1 == fNSlices) continue; 
-      Int_t slice = fFirst + i;
-      AliHLTTPCTrackArray *ttt0=GetInTracks(i);
-      Int_t slice2 = i+1;
-      //if(slice2==fNSlices) slice2 =0; 
-      
-      //Make sure slices are on the same side of the TPC
-      if(slice2 == 18) slice2=0;
-      else if(slice2 == 36) slice2=18;
-      AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
-      //10 degrees -> the border of the slices in local coordinates
-      Float_t angle = AliHLTTPCTransform::Pi()/18; 
-      AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
-      
-      //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
-      //the calculation of crossing points to be correct.
-      if(slice==17 || slice==35) 
-       angle=0;
-      if(i==0)
-       ttt0->QSort();
-      ttt1->QSort();
-      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
-       {
-         AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
-         if(!track0) continue;
-         track0->CalculateHelix();
-         track0->CalculateEdgePoint(angle);
-         //      if(track0->IsPoint()) AddTrack(tout,track0);
-       }
-      for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
-       {
-         AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
-         if(!track1) continue;
-         track1->CalculateHelix();
-         track1->CalculateEdgePoint(angle);
-         //      if(track1->IsPoint())  AddTrack(tout,track1); 
-       }
-      Bool_t merge = kTRUE;
-      while(merge)
-       {
-         Int_t min0=-1,min1=-1;
-         Double_t min=5;
-         Int_t n0=ttt0->GetNTracks(),n1=ttt1->GetNTracks();
-         for(Int_t s0=0;s0<n0;s0++)
-           {
-             AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
-             if(!track0) continue;
-             if(!track0->IsPoint()) continue;
-             for(Int_t s1=0;s1<n1;s1++)
-               {
-                 AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
-                 if(!track1) continue;
-                 if(!track1->IsPoint()) continue;
-                 
-                 //Double_t diff = TrackDiff(track0,track1,angle);
-                 Double_t diff = CheckTracks(track0,track1,slice);
-                 //PrintDiff(track0,track1);
-                 if(diff>=0&&diff<min)
-                   {
-                     min=diff;
-                     min0=s0;
-                     min1=s1;
-                   }
-               }
-           }
-         if(min0>=0&&min1>=0)
-           {
-             AliHLTTPCTrack *track0=ttt0->GetTrack(min0);
-             AliHLTTPCTrack *track1=ttt1->GetTrack(min1);
-             track[0] = track0;
-             track[1] = track1;
-             SortGlobalTracks(track,2);
-             track1->CalculateEdgePoint((angle+AliHLTTPCTransform::Pi()/9));
-             if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
-               MultiMerge(ttt1,track,2);
-             else
-               MultiMerge(tout,track,2); 
-             track0->CalculateReferencePoint(angle);
-             track1->CalculateReferencePoint(angle);
-             //PrintDiff(track0,track1);
-             FillNtuple(ntuple,track0,track1);
-             ttt0->Remove(min0);
-             ttt1->Remove(min1);
-             
-           }
-         else merge = kFALSE;
-       }
-      ttt0->Compress();
-      ttt1->Compress();
-      LOG(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::SlowMerge","Result")
-       <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
-       <<angle<<ENDLOG;
-    }
-  const int namelen=1024;
-  Char_t fname[namelen];
-  snprintf(fname,namelen,"%s/merge_parameters.root",path);
-  WriteNtuple(fname,ntuple);
-}
-
-void AliHLTTPCGlobalMerger::Merge()
-{
-  //Normal merging procedure. Matches tracks which are within limits
-  //set by SetParameters. Parameters can be tuned by SlowMerge.
-  
-  AliHLTTPCTrack *track[2];
-  AliHLTTPCTrackArray *tout = GetOutTracks();
-  if(fNSlices<2)
-    {
-      LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::Merge","Slice Number")
-       <<"Need more than one Slice!"<<ENDLOG;
-      return;
-    }
-  for(Int_t i=0; i<fNSlices; i++)
-    {
-      //if(fNSlices!=18 && i+1 == fNSlices) continue; 
-      Int_t slice = fFirst + i;
-      AliHLTTPCTrackArray *ttt0=GetInTracks(i);
-      Int_t slice2 = i+1;
-      //if(slice2==fNSlices) slice2 =0;
-      
-      //Make sure slices are on the same side of the TPC
-      if(slice2 == 18) slice2=0;
-      else if(slice2 == 36) slice2=18;
-      AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
-      //10 degrees -> the border of the slices in local coordinates
-      Float_t angle = AliHLTTPCTransform::Pi()/18; 
-      AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
-      
-      //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
-      //the calculation of crossing points to be correct.
-      if(slice==17 || slice==35)
-       angle=0;
-      if(i==0)
-       ttt0->QSort();
-      ttt1->QSort();
-      Bool_t *ismatched0  = new Bool_t[ttt0->GetNTracks()];
-      Bool_t *ismatched1  = new Bool_t[ttt1->GetNTracks()];
-      Int_t n0=0,n1=0;
-      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
-       {
-         ismatched0[s0]=kFALSE;
-         AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
-         if(!track0) continue;
-         //track0->CalculateHelix();    //This it done in TrackArray
-         track0->CalculateEdgePoint(angle);
-         if(track0->IsPoint()) 
-           {
-             n0++;
-             track0->CalculateReferencePoint(angle);
-           }
-       }
-      for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
-       {
-         ismatched1[s1]=kFALSE;
-         AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
-         if(!track1) continue;
-         //track1->CalculateHelix();   //This is done in TrackArray
-         track1->CalculateEdgePoint(angle);
-         if(track1->IsPoint()) 
-           {
-             n1++;
-             track1->CalculateReferencePoint(angle);
-           }
-       }
-      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
-       {
-         if(ismatched0[s0]) continue;
-         AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
-         if(!track0) continue;
-         if(!track0->IsPoint()) continue;
-         for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
-           {
-             if(ismatched1[s1]) continue;
-             AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
-             if(!track1) continue;
-             if(!track1->IsPoint()) continue;
-             if(IsRTrack(track0,track1))
-               {
-                 track[0] = track0;
-                 track[1] = track1;
-                 SortGlobalTracks(track,2);
-                 Double_t r0 = pow(track[0]->GetLastPointX(),2)+
-                   pow(track[0]->GetLastPointY(),2);
-                 Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
-                   pow(track[1]->GetFirstPointY(),2);
-                 if(r0<r1)
-                   {
-                     MultiMerge(tout,track,2); 
-                     ismatched0[s0]=kTRUE;
-                     ismatched1[s1]=kTRUE;
-                     ttt0->Remove(s0);
-                     ttt1->Remove(s1);
-                     break;
-                     /*
-                       The track is merged, so we will _not_ look for more matches.
-                       Because there could easily be more matches, if a track is being
-                       split within the sector....
-                     */
-                   }
-               }
-           }
-       }
-      LOG(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::Merge","Result")
-       <<AliHLTTPCLog::kDec<<"slice0: "<<n0<<" slice1: "<<n1
-       <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
-      delete [] ismatched0;
-      delete [] ismatched1;
-    }
-}
diff --git a/HLT/TPCLib/AliHLTTPCGlobalMerger.h b/HLT/TPCLib/AliHLTTPCGlobalMerger.h
deleted file mode 100644 (file)
index b907b13..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTGlobalMerger.h,v 1.6 2004/02/02 15:00:34 loizides 
-
-#ifndef ALIHLTTPC_GLOBALMERGER_H
-#define ALIHLTTPC_GLOBALMERGER_H
-
-//* 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                               *
-
-/** @file   AliHLTTPCGlobalMerger.h
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC slice merger
-*/
-
-#ifndef  __CINT__
-#include "AliHLTTPCMerger.h"
-#endif
-
-#include "AliHLTTPCRootTypes.h"
-
-/** 
- * @class AliHLTTPCGlobalMerger
- * The HLTTPC Slice merger
- *
- * @ingroup alihlt_tpc
- */
-class AliHLTTPCGlobalMerger : public AliHLTTPCMerger{
-
- public:
-  AliHLTTPCGlobalMerger();
-  virtual ~AliHLTTPCGlobalMerger();
-  
-  void Setup(Int_t first,Int_t last);
-  void InitSlice(Int_t slice);
-  void SlowMerge(const Char_t *path="./");
-  void Merge();  //Loop over tracks from different sectors
-
- private:
-  Double_t CheckTracks(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack,Int_t slice);
-  
-  Int_t fNSlices; // no of slices
-  Int_t fFirst;   // first slice?
-  Int_t fLast;    // last slice?
-
-  ClassDef(AliHLTTPCGlobalMerger,0) //Slice merger
-};
-
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx b/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx
deleted file mode 100644 (file)
index db322e2..0000000
+++ /dev/null
@@ -1,319 +0,0 @@
-// $Id$
-
-//**************************************************************************
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//*                                                                        *
-//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
-//*                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
-//*                  for The ALICE HLT Project.                            *
-//*                                                                        *
-//* Permission to use, copy, modify and distribute this software and its   *
-//* documentation strictly for non-commercial purposes is hereby granted   *
-//* without fee, provided that the above copyright notice appears in all   *
-//* copies and that both the copyright notice and this permission notice   *
-//* appear in the supporting documentation. The authors make no claims     *
-//* about the suitability of this software for any purpose. It is          *
-//* provided "as is" without express or implied warranty.                  *
-//**************************************************************************
-
-/** @file   AliHLTTPCGlobalMergerComponent.cxx
-    @author Timm Steinbeck, Matthias Richter
-    @date   
-    @brief  HLT TPC global merger component.
-*/
-
-#if __GNUC__>= 3
-using namespace std;
-#endif
-
-#include <climits>
-#include "AliHLTTPCGlobalMergerComponent.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCGlobalMerger.h"
-#include "AliHLTTPCVertex.h"
-#include "AliHLTTPCVertexData.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTrackArray.h"
-#include "AliHLTTPCTrackletDataFormat.h"
-//#include "AliHLTTPCSpacePointData.h"
-//#include "AliHLTTPCClusterDataFormat.h"
-#include "AliHLTTPCDefinitions.h"
-#include <cstdlib>
-#include <cerrno>
-
-/** ROOT macro for the implementation of ROOT specific class methods */
-ClassImp(AliHLTTPCGlobalMergerComponent);
-
-AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent()
-  :
-  fGlobalMerger(NULL),
-  fVertex(NULL)
-{
-  // see header file for class documentation
-  // or
-  // refer to README to build package
-  // or
-  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-}
-
-AliHLTTPCGlobalMergerComponent::~AliHLTTPCGlobalMergerComponent()
-{
-  // see header file for class documentation
-}
-
-// Public functions to implement AliHLTComponent's interface.
-// These functions are required for the registration process
-
-const char* AliHLTTPCGlobalMergerComponent::GetComponentID()
-{
-  // see header file for class documentation
-  return "TPCGlobalMerger";
-}
-
-void AliHLTTPCGlobalMergerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
-{
-  // see header file for class documentation
-  list.clear();
-  list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
-  list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
-}
-
-AliHLTComponentDataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
-{
-  // see header file for class documentation
-  return AliHLTTPCDefinitions::fgkTracksDataType;
-}
-
-void AliHLTTPCGlobalMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-{
-  // see header file for class documentation
-  // XXX TODO: Find more realistic values.
-  constBase = 0;
-  inputMultiplier = 1.0;
-}
-
-AliHLTComponent* AliHLTTPCGlobalMergerComponent::Spawn()
-{
-  // see header file for class documentation
-  return new AliHLTTPCGlobalMergerComponent;
-}
-
-void AliHLTTPCGlobalMergerComponent::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
-{
-  // see header file for class documentation
-  fGlobalMerger->SetParameter( maxy, maxz, maxkappa, maxpsi, maxtgl );
-}
-
-int AliHLTTPCGlobalMergerComponent::DoInit( int /*argc*/, const char** /*argv*/ )
-{
-  // see header file for class documentation
-  if ( fGlobalMerger || fVertex )
-    return EINPROGRESS;
-  fGlobalMerger = new AliHLTTPCGlobalMerger();
-  fVertex = new AliHLTTPCVertex();
-  SetMergerParameters();
-  return 0;
-}
-
-int AliHLTTPCGlobalMergerComponent::DoDeinit()
-{
-  // see header file for class documentation
-  if ( fGlobalMerger )
-    delete fGlobalMerger;
-  fGlobalMerger = NULL;
-  if ( fVertex )
-    delete fVertex;
-  fVertex = NULL;
-  return 0;
-}
-
-int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                                             AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
-                                             AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
-{
-  // see header file for class documentation
-  int iResult=0;
-  AliHLTUInt32_t capacity=size;
-  size=0;
-
-  if (!IsDataEvent()) return 0;
-
-  const AliHLTComponentBlockData* iter = NULL;
-  const AliHLTComponentBlockData* lastVertexBlock = NULL;
-  unsigned long ndx;
-
-  std::vector<SliceData> slices;
-  std::vector<SliceData>::iterator sdIter, sdEnd;
-  int minSlice = INT_MAX, maxSlice = 0;
-  bool found;
-  AliHLTTPCTrackletData* inPtr;
-  AliHLTTPCTrackletData* outPtr;
-  UInt_t tSize = 0;
-  Int_t slice=0;
-
-  // Create sorted (by slice number) list of data (tracks and vertex) for each slice present.
-  // also note the min and max slice numbers
-  for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
-    {
-      iter = blocks+ndx;
-      bool bIsTrackSegDataBlock=false;
-      bool bIsVertexDataBlock=false;
-      if(!(bIsTrackSegDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkTrackSegmentsDataType)) &&
-        !(bIsVertexDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkVertexDataType))){
-       continue;
-      }
-
-      slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
-      if (slice<0 || slice>=AliHLTTPCTransform::GetNSlice()) {
-       HLTError("invalid slice number %d extracted from specification 0x%08lx,  skipping block of type %s",
-                slice, iter->fSpecification, DataType2Text(iter->fDataType).c_str());
-       // just remember the error, if there are other valid blocks ignore the
-       // error, return code otherwise
-       iResult=-EBADF;
-       continue;
-      }
-      if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr( *iter )) {
-       // 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",
-                  iter->fSpecification, DataType2Text(iter->fDataType).c_str());
-      }
-      found=false;
-      sdIter = slices.begin();
-      sdEnd = slices.end();
-      while ( sdIter != sdEnd )
-       {
-         if ( sdIter->fSlice > slice || sdIter->fSlice == slice )
-           break;
-         sdIter++;
-       }
-      if ( sdIter==sdEnd || sdIter->fSlice>slice )
-       {
-         if ( sdIter == sdEnd )
-           maxSlice = slice;
-         if ( sdIter==slices.begin() )
-           minSlice = slice;
-         SliceData sd;
-         sd.fSlice = slice;
-         sd.fVertexBlock = NULL;
-         sd.fVertexBlockIndex = 0;
-         sd.fTrackletBlock = NULL;
-         sd.fTrackletBlockIndex = 0;
-         sdIter = slices.insert( sdIter, sd );
-       }
-      if ( sdIter->fSlice == slice )
-       {
-         if (bIsTrackSegDataBlock)
-           {
-             if ( !sdIter->fTrackletBlock )
-               {
-                 sdIter->fTrackletBlock = iter;
-                 sdIter->fTrackletBlockIndex = ndx;
-               }
-             else
-               {
-                 Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate track data block",
-                          "Duplicate track data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
-                          slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
-               }
-           }
-         if (bIsVertexDataBlock)
-           {
-             lastVertexBlock = iter;
-             if ( !sdIter->fVertexBlock )
-               {
-                 sdIter->fVertexBlock = iter;
-                 sdIter->fVertexBlockIndex = ndx;
-               }
-             else
-               {
-                 Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate vertex data block",
-                          "Duplicate vertex data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
-                          slice, evtData.fEventID, evtData.fEventID, sdIter->fVertexBlockIndex, ndx );
-               }
-           }
-       }
-    }
-
-  // skip the processing if there was no track segment data
-  if (slices.size()==0) {
-    return iResult;
-  }
-  iResult=0;
-
-  //fGlobalMerger->Setup( minSlice, maxSlice );
-  fGlobalMerger->Setup( 0, 35 );
-
-  if ( !lastVertexBlock )
-    {
-      Logging( kHLTLogInfo, "HLT::GlobalMerger::DoEvent", "No vertex data block",
-              "No vertex data block found  for event  0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
-      fVertex->SetZero();
-    }
-  else
-    fVertex->Read( (AliHLTTPCVertexData*)( lastVertexBlock->fPtr ) );
-
-  // Add all tracks into the merger
-  sdIter = slices.begin();
-  sdEnd = slices.end();
-  int lastSlice = -1;
-  while ( sdIter != sdEnd )
-    {
-      if ( sdIter->fVertexBlock )
-       {
-         fVertex->Read( (AliHLTTPCVertexData*)( sdIter->fVertexBlock->fPtr ) );
-         fGlobalMerger->SetVertex( fVertex );
-       }
-      for ( int slNr=lastSlice+1; slNr<=sdIter->fSlice; slNr++ )
-       fGlobalMerger->InitSlice( slNr );
-      if ( sdIter->fTrackletBlock )
-       {
-         inPtr = (AliHLTTPCTrackletData*)( sdIter->fTrackletBlock->fPtr );
-         if ( !inPtr )
-           {
-             Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "No track data block",
-                      "No track data block found  for event  0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
-           }
-         else
-           {
-             //fGlobalMerger->InitSlice( sdIter->fSlice );
-             fGlobalMerger->FillTracks( inPtr->fTrackletCnt, inPtr->fTracklets );
-           } 
-       }
-      lastSlice = sdIter->fSlice;
-      sdIter++;
-    }
-  for ( int slNr=lastSlice+1; slNr<=35; slNr++ )
-    fGlobalMerger->InitSlice( slNr );
-    
-
-  // Now we can really merge
-  fGlobalMerger->Merge();
-  fGlobalMerger->AddAllTracks();
-
-  // check if there was enough space in the output buffer
-  UInt_t ntracks0=fGlobalMerger->GetOutTracks()->GetNTracks();
-  if (outputPtr==NULL || (sizeof(AliHLTTPCTrackletData)+ntracks0*sizeof(AliHLTTPCTrackSegmentData)>capacity)) {
-    iResult=-ENOSPC;
-  } else {
-  outPtr = (AliHLTTPCTrackletData*)(outputPtr);
-
-  tSize = fGlobalMerger->GetOutTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
-  outPtr->fTrackletCnt = ntracks0;
-
-  tSize += sizeof(AliHLTTPCTrackletData);
-
-  AliHLTComponentBlockData bd;
-  FillBlockData( bd );
-  bd.fOffset = 0;
-  bd.fSize = tSize;
-  bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, 0, 5 );
-  outputBlocks.push_back( bd );
-  }
-
-  size = tSize;
-  return iResult;
-}
-
-       
diff --git a/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.h b/HLT/TPCLib/AliHLTTPCGlobalMergerComponent.h
deleted file mode 100644 (file)
index 208ed67..0000000
+++ /dev/null
@@ -1,108 +0,0 @@
-// XEmacs -*-C++-*-
-// @(#) $Id$
-
-#ifndef ALIHLTTPCGLOBALMERGERCOMPONENT_H
-#define ALIHLTTPCGLOBALMERGERCOMPONENT_H
-//* 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                               *
-
-/** @file   AliHLTTPCGlobalMergerComponent.h
-    @author Timm Steinbeck, Matthias Richter
-    @date   
-    @brief  HLT TPC global merger component.
-*/
-
-#include "AliHLTProcessor.h"
-
-class AliHLTTPCGlobalMerger;
-class AliHLTTPCVertex;
-
-/**
- * @class AliHLTTPCGlobalMergerComponent
- * The TPC global merger component
- * The component is the interface to the AliHLTGlobalMerger processing
- * class.
- *
- * @ingroup alihlt_tpc_components
- */
-class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
-    {
-    public:
-      /** standard constructor */
-      AliHLTTPCGlobalMergerComponent();
-      /** standard destructor */
-      virtual ~AliHLTTPCGlobalMergerComponent();
-
-       // Public functions to implement AliHLTComponent's interface.
-       // These functions are required for the registration process
-
-      /** @see component interface AliHLTComponent::GetComponentID */
-       const char* GetComponentID();
-      
-      /** @see component interface AliHLTComponent::GetInputDataTypes */
-       void GetInputDataTypes(AliHLTComponentDataTypeList& list);
-
-      /** @see component interface AliHLTComponent::GetOutputDataType */
-       AliHLTComponentDataType GetOutputDataType();
-
-      /** @see component interface AliHLTComponent::GetOutputDataSize */
-       virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
-
-      /** @see component interface AliHLTComponent::Spawn */
-       AliHLTComponent* Spawn();
-
-    protected:
-       
-      /**
-       * Set the parameters
-       */
-       void SetMergerParameters(Double_t maxy=2.0,Double_t maxz=3.0,Double_t maxkappa=0.003,
-                                Double_t maxpsi=0.1,Double_t maxtgl=0.05);
-
-       // Protected functions to implement AliHLTComponent's interface.
-       // These functions provide initialization as well as the actual processing
-       // capabilities of the component. 
-
-
-      /** @see component interface AliHLTComponent::DoInit */
-       int DoInit( int argc, const char** argv );
-
-      /** @see component interface AliHLTComponent::DoDeinit */
-       int DoDeinit();
-
-      /** @see component interface @ref AliHLTProcessor::DoEvent */
-       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks );
-
-       using AliHLTProcessor::DoEvent;
-       
-    private:
-      /** copy constructor prohibited */
-      AliHLTTPCGlobalMergerComponent(const AliHLTTPCGlobalMergerComponent&);
-      /** assignment operator prohibited */
-      AliHLTTPCGlobalMergerComponent& operator=(const AliHLTTPCGlobalMergerComponent&);
-
-      /** the global merger object */
-      AliHLTTPCGlobalMerger* fGlobalMerger; //!
-      /** the vertexer object */
-      AliHLTTPCVertex* fVertex; //!
-
-      struct SliceData {
-       /** slice no */
-       int fSlice;                                                // see above
-       /** block descriptor for the vertex data block */
-       const AliHLTComponentBlockData* fVertexBlock;              //! transient
-       /** index of the vertex data block */
-       unsigned fVertexBlockIndex;                                // see above
-       /** block descriptor for the tracklet data block */
-       const AliHLTComponentBlockData* fTrackletBlock;            //! transient
-       /** index of the tracklet data block */
-       unsigned fTrackletBlockIndex;                              // see above
-      };
-
-       ClassDef(AliHLTTPCGlobalMergerComponent, 0)
-
-    };
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCInterMerger.cxx b/HLT/TPCLib/AliHLTTPCInterMerger.cxx
deleted file mode 100644 (file)
index 7e1cc40..0000000
+++ /dev/null
@@ -1,168 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTInterMerger.cxx,v 1.8 2005/06/14 10:55:21 cvetan
-
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- *                                                                        *
- * Primary Authors: Uli Frankenfeld, maintained by                          *
- *                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
- *                  for The ALICE HLT Project.                            *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/** @file   AliHLTTPCInterMerger.cxx
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC track segment merger
-*/
-
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPCInterMerger.h"
-#include "AliHLTTPCTrack.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrackArray.h"
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-ClassImp(AliHLTTPCInterMerger)
-
-AliHLTTPCInterMerger::AliHLTTPCInterMerger()
-  :
-  fPatch(0),
-  fRowMin(0),
-  fRowMax(0)
-{
-  //Default constructor
-  InitMerger(1);
-  Is2Global(kFALSE);
-//  SetParameter(2,2,.3,.3,.3);
-  SetParameter(1,0.5,0.0005,0.05,0.1);
-}
-
-
-AliHLTTPCInterMerger::~AliHLTTPCInterMerger(){
-  //Destructor
-  
-}
-
-void AliHLTTPCInterMerger::SlowMerge(){
-  Int_t nrow= fRowMax-fRowMin+1;
-  void *ntuple=GetNtuple();
-  AliHLTTPCTrackArray * tracks = GetInTracks(0);
-  const Int_t  kNIn =tracks->GetNTracks();
-  AliHLTTPCTrack *tr[2];
-  Bool_t merge = kTRUE;
-  for(Int_t in=0;in<kNIn;in++)
-    if (tracks->GetCheckedTrack(in)) tracks->GetCheckedTrack(in)->CalculateHelix();
-  while(merge){
-    Int_t inmin=-1,outmin=-1;
-    Double_t min=10;
-    for(Int_t out=0;out<kNIn;out++){
-    AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
-    if(!outertrack) continue;
-      for(Int_t in=0;in<kNIn;in++){
-        if(in==out) continue;
-        AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
-        if(!innertrack) continue;
-        if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
-
-        Double_t diff = TrackDiff(innertrack,outertrack);
-
-        if(diff>=0&&diff<min){
-          min=diff;
-          inmin=in;
-          outmin=out; 
-        }
-      } 
-    }
-    if(inmin>=0&&outmin>=0){
-      AliHLTTPCTrack *outertrack=tracks->GetTrack(outmin);
-      AliHLTTPCTrack *innertrack=tracks->GetTrack(inmin);
-      tr[0]=innertrack;
-      tr[1]=outertrack;
-      SortTracks(tr,2);
-      MultiMerge(tracks,tr,2);
-      outertrack->CalculatePoint(tr[0]->GetLastPointX());
-      innertrack->CalculatePoint(tr[0]->GetLastPointX());
-      PrintDiff(innertrack,outertrack);
-      FillNtuple(ntuple,innertrack,outertrack);
-      tracks->Remove(outmin);
-      tracks->Remove(inmin);
-    }
-    else merge = kFALSE;
-  }
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCInterMerger::SlowMerge","Result")
-  <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<tracks->GetNTracks()-kNIn<<ENDLOG;
-
-  const int namelen=256;
-  char name[namelen];
-  snprintf(name,namelen,"ntuple_i_%d.root",fPatch);
-  WriteNtuple(name,ntuple);
-}
-
-void AliHLTTPCInterMerger::MMerge(){
-  while(Merge()) {/*empty body*/};
-  GetOutTracks()->AddTracks(GetInTracks(0));
-}
-
-Int_t AliHLTTPCInterMerger::Merge(){
-  Int_t nrow= fRowMax-fRowMin+1;
-  Double_t xval =AliHLTTPCTransform::Row2X((fRowMax+fRowMin)/2);
-  AliHLTTPCTrackArray * tracks = GetInTracks(0);
-  const Int_t  kNIn =tracks->GetNTracks();
-  AliHLTTPCTrack *tr[2];
-  for(Int_t in=0;in<kNIn;in++){
-    AliHLTTPCTrack *t = tracks->GetCheckedTrack(in);
-    if(t){
-      t->CalculateHelix();
-      t->CalculatePoint(xval);
-    }
-  }
-  for(Int_t out=0;out<kNIn;out++){
-  AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
-  if(!outertrack) continue;
-    for(Int_t in=0;in<kNIn;in++){
-      if(in==out) continue;
-      AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
-      if(!innertrack) continue;
-      if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
-
-      if(IsTrack(innertrack,outertrack)){
-        tr[0]=innertrack;
-        tr[1]=outertrack;
-        SortGlobalTracks(tr,2);
-
-        Double_t r0 = pow(tr[0]->GetLastPointX(),2)+
-                      pow(tr[0]->GetLastPointY(),2);
-        Double_t r1 = pow(tr[1]->GetFirstPointX(),2)+
-                      pow(tr[1]->GetFirstPointY(),2);
-        if(r0<r1){
-          MultiMerge(tracks,tr,2);
-          tracks->Remove(out);
-          tracks->Remove(in);
-          break;
-        }
-      }
-    } 
-  }
-  Int_t nmerged = tracks->GetNTracks()-kNIn; 
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCInterMerger::Merge","Result")
-  <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
-  //add in tracks
-//  GetOutTracks()->AddTracks(GetInTracks(0)); 
-
-  return nmerged;
-}
-
-
diff --git a/HLT/TPCLib/AliHLTTPCInterMerger.h b/HLT/TPCLib/AliHLTTPCInterMerger.h
deleted file mode 100644 (file)
index 3b53d5b..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTInterMerger.h,v 1.4 2004/02/02 15:00:34 loizides Exp $
-
-#ifndef ALIHLTTPCINTERMERGER_H
-#define ALIHLTTPCINTERMERGER_H
-
-//* 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                               *
-
-/** @file   AliHLTTPCInterMerger.h
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC track segment merger
-*/
-
-#ifndef __CINT__ 
-#include "AliHLTTPCMerger.h"
-#endif
-
-#include "AliHLTTPCRootTypes.h"
-
-/** 
- * @class AliHLTTPCInterMerger
- * The HLTTPC track segment merger
- *
- * @ingroup alihlt_tpc
- */
-class AliHLTTPCInterMerger : public AliHLTTPCMerger {
-
- public:
-  AliHLTTPCInterMerger();
-  virtual ~AliHLTTPCInterMerger();
-
-  void Init(Int_t *row,Int_t p){fRowMin=row[0];fRowMax=row[1];fPatch=p;}
-  void SlowMerge();
-  Int_t Merge();
-  void MMerge();  //Loop over tracks from different subsectors
-  
- private:
-  AliHLTTPCInterMerger(const AliHLTTPCInterMerger&);
-  AliHLTTPCInterMerger& operator=(const AliHLTTPCInterMerger&);
-
-  Int_t fPatch;  // current patch
-  Int_t fRowMin; // min row
-  Int_t fRowMax; // max row
-
-  ClassDef(AliHLTTPCInterMerger,0) //Intermerging class
-};
-
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCMerger.cxx b/HLT/TPCLib/AliHLTTPCMerger.cxx
deleted file mode 100644 (file)
index 7337808..0000000
+++ /dev/null
@@ -1,543 +0,0 @@
-//$Id$
-// Original: AliHLTMerger.cxx,v 1.16 2005/06/14 10:55:21 cvetan 
-
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- *                                                                        *
- * Primary Authors: Uli Frankenfeld, maintained by                          *
- *                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
- *                  for The ALICE HLT Project.                            *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/** @file   AliHLTTPCMerger.cxx
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC merger base class
-*/
-
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPCMerger.h"
-#include "AliHLTTPCTrack.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrackArray.h"
-
-#ifdef use_root //use root ntuple for slow merge
-#include <TNtuple.h>
-#include <TTree.h>
-#include <TFile.h>
-#endif
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-ClassImp(AliHLTTPCMerger)
-
-AliHLTTPCMerger::AliHLTTPCMerger()
-  :
-  fCurrentTracks(0),
-  fSlice(0), // TODO its not quite clear were this member is set
-  fVertex(NULL),
-  f2Global(false), // TODO: initialization was missing at all, assuming false for the moment
-  fMaxY(0.0),
-  fMaxZ(0.0),
-  fMaxKappa(0.0),
-  fMaxPsi(0.0),
-  fMaxTgl(0.0),
-  fTrackType(0),
-  fInTrack(NULL),
-  fNIn(0),
-  fOutTrack(NULL)
-{
-  //Default constructor
-  fInTrack=0;
-  fOutTrack=0;
-  fCurrentTracks=0;
-  fNIn=0;
-}
-
-AliHLTTPCMerger::~AliHLTTPCMerger()
-{
-  //Destructor
-  DeleteArray();
-}
-
-void AliHLTTPCMerger::InitMerger(Int_t ntrackarrays,const Char_t *tracktype)
-{
-  //Used to setup all arrays
-  
-  if(strcmp(tracktype,"AliHLTTPCTrack")==0) fTrackType='t';
-  else if(strcmp(tracktype,"AliHLTTPCConfMapTrack")==0) fTrackType='c';
-#ifdef INCLUDE_TPC_HOUGH
-  else if(strcmp(tracktype,"AliHLTTPCHoughTrack")==0) fTrackType='h';
-#endif
-  else
-    LOG(AliHLTTPCLog::kError,"AliHLTTPCMerger::AliHLTTPCMerger","Track types")
-      <<"Unknown tracktype"<<ENDLOG;
-  SetArray(ntrackarrays);
-  fCurrentTracks=0;
-
-}
-
-void AliHLTTPCMerger::DeleteArray()
-{
-  //delete arrays
-  for(Int_t i=0; i<fNIn;i++)
-    {
-      if(!fInTrack[i]) continue;
-      delete fInTrack[i];
-      fInTrack[i]=0;
-    }
-  if(fInTrack)
-    delete[] fInTrack;
-  if(fOutTrack)
-    delete fOutTrack;
-  fInTrack=0;
-  fOutTrack=0;
-}
-
-void AliHLTTPCMerger::SetArray(Int_t nin)
-{ 
-  //set arrays
-  DeleteArray();//Make sure arrays are cleaned 
-  
-  fNIn = nin;
-  fInTrack = new AliHLTTPCTrackArray*[fNIn];
-  for(Int_t i=0; i<fNIn;i++)
-    {
-#ifdef INCLUDE_TPC_HOUGH
-      if(fTrackType=='h')
-       fInTrack[i] = new AliHLTTPCTrackArray("AliHLTTPCHoughTrack");
-      else
-#endif
-       fInTrack[i] = new AliHLTTPCTrackArray("AliHLTTPCTrack");
-      
-    }
-#ifdef INCLUDE_TPC_HOUGH
-  if(fTrackType=='h')
-    fOutTrack= new AliHLTTPCTrackArray("AliHLTTPCHoughTrack");
-  else
-#endif
-    fOutTrack= new AliHLTTPCTrackArray("AliHLTTPCTrack");
-}
-
-void AliHLTTPCMerger::Reset()
-{ 
-  //reset
-  for(Int_t i=0; i<fNIn;i++)
-    {
-      fInTrack[i]->Reset();
-    }
-  fOutTrack->Reset();
-}
-
-void AliHLTTPCMerger::FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr)
-{
-  //Read tracks from shared memory (or memory)
-  AliHLTTPCTrackArray *destination = GetInTracks(fCurrentTracks);
-  if(Is2Global())
-    destination->FillTracksChecked(tr, ntracks, 0, fSlice);
-  else
-    destination->FillTracksChecked(tr, ntracks, 0);
-}
-
-void AliHLTTPCMerger::AddAllTracks()
-{ 
-  //add all tracks
-  for(Int_t i=0; i<GetNIn();i++)
-    {
-      AliHLTTPCTrackArray *in = GetInTracks(i);
-      AliHLTTPCTrackArray *out = GetOutTracks();
-      out->AddTracks(in);
-    }
-}
-
-void AliHLTTPCMerger::SortGlobalTracks(AliHLTTPCTrack **tracks, Int_t ntrack)
-{ 
-  //sort global tracks
-  AliHLTTPCTrack **tmp = new AliHLTTPCTrack*[ntrack]; 
-  for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
-  Int_t *t = new Int_t[ntrack];
-  for(Int_t i=0;i<ntrack;i++) t[i]=-1;
-  
-  for(Int_t j=0;j<ntrack;j++)
-    {
-      Double_t minr=300;
-      Int_t    mini=0;
-      for(Int_t i=0;i<ntrack;i++)
-       {
-         if(!tracks[i]) continue;
-         Double_t rr=pow(tracks[i]->GetFirstPointX(),2)+pow(tracks[i]->GetFirstPointY(),2);
-         Double_t r=sqrt(rr);
-         if(r<minr){
-           minr=r;
-           mini=i;
-         }
-       }
-      t[j]=mini;
-      tracks[mini]=0;
-    }
-  for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
-  delete[] t;
-  delete[] tmp;
-}
-
-void AliHLTTPCMerger::SortTracks(AliHLTTPCTrack **tracks, Int_t ntrack) const
-{ 
-  //sort tracks
-  AliHLTTPCTrack **tmp = new  AliHLTTPCTrack*[ntrack];
-  for(Int_t i=0;i<ntrack;i++) tmp[i] = tracks[i];
-  Int_t *t = new Int_t[ntrack];
-  for(Int_t i=0;i<ntrack;i++) t[i]=-1;
-  
-  for(Int_t j=0;j<ntrack;j++)
-    {
-      Double_t minx=300; 
-      Int_t    mini=0;
-      for(Int_t i=0;i<ntrack;i++)
-       {
-         if(!tracks[i]) continue;
-         if(tracks[i]->GetFirstPointX()<minx)
-           {
-             minx=tracks[i]->GetFirstPointX();
-             mini=i;
-           }     
-       }
-      t[j]=mini;  
-      tracks[mini]=0;
-    }
-  for(Int_t i=0;i<ntrack;i++) tracks[i] = tmp[t[i]];
-  delete[] t;
-  delete[] tmp;
-}
-
-void AliHLTTPCMerger::AddTrack(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *track)
-{ 
-  // add tracks
-  AliHLTTPCTrack *t[1];
-  t[0] = track;
-  MultiMerge(mergedtrack,t,1);
-}
-
-AliHLTTPCTrack * AliHLTTPCMerger::MergeTracks(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *t0,AliHLTTPCTrack *t1)
-{ 
-  //merge tracks
-  AliHLTTPCTrack *t[2];
-  t[0] = t0; 
-  t[1] = t1;
-  SortTracks(t,2);
-  return MultiMerge(mergedtrack,t,2);
-}
-
-AliHLTTPCTrack * AliHLTTPCMerger::MultiMerge(AliHLTTPCTrackArray *mergedtracks,AliHLTTPCTrack **tracks, Int_t ntrack)
-{
-  //multi merge the tracks
-  //check npoints
-  Int_t nps = 0;
-  for(Int_t i=0;i<ntrack;i++)
-    {
-      nps+=tracks[i]->GetNHits();
-    }
-  if(nps>AliHLTTPCTransform::GetNRows())
-    {
-      LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMerger::MultiMerge","Adding Points")
-       <<AliHLTTPCLog::kDec<<"Too many Points: "<<nps<<ENDLOG;
-      return 0;
-    }
-  
-  //create new track
-  AliHLTTPCTrack *newtrack = mergedtracks->NextTrack();
-  //copy points
-  UInt_t * nn = new UInt_t[AliHLTTPCTransform::GetNRows()];
-  nps = 0;
-  
-  //  for(Int_t i=0;i<ntrack;i++){
-  for(Int_t i=ntrack-1;i>=0;i--)
-    {
-      memcpy(&nn[nps],tracks[i]->GetHitNumbers(),tracks[i]->GetNHits()*sizeof(UInt_t));
-      nps+=tracks[i]->GetNHits();
-    }
-  AliHLTTPCTrack *tpf=tracks[0];
-  AliHLTTPCTrack *tpl=tracks[ntrack-1];
-  AliHLTTPCTrack *best = tpf;
-  if(tpf->GetNHits()<tpl->GetNHits() && Is2Global())
-    best = tpl;//Best means = most points and therefore best fit (in global case)
-  
-  newtrack->SetNHits(nps);
-  newtrack->SetHits(nps,nn);
-  newtrack->SetFirstPoint(tpf->GetFirstPointX(),tpf->GetFirstPointY(),tpf->GetFirstPointZ());
-  newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
-  newtrack->SetPt(best->GetPt());
-  newtrack->SetPsi(best->GetPsi());
-  newtrack->SetTgl(best->GetTgl());
-  newtrack->SetCharge(tpf->GetCharge());
-  delete [] nn;
-  return newtrack;
-}
-
-void* AliHLTTPCMerger::GetNtuple(char *varlist) const
-{ 
-  //get ntuple
-#ifdef use_root
-  TNtuple* nt = new TNtuple("ntuple","ntuple",varlist);
-  return (void*) nt;
-#else
-  return 0;
-#endif
-}
-
-void* AliHLTTPCMerger::GetNtuple() const
-{ 
-  //get ntuple
-#ifdef use_root
-  TNtuple* nt = new TNtuple("ntuple","ntuple",
-                           "dx:dy:dz:dk:dpsi:dtgl:dq:disx:disy:disz:dis:n0:n1:diff:drx:dry:drz");
-  return (void*) nt;
-#else
-  return 0;
-#endif
-}
-
-Bool_t AliHLTTPCMerger::WriteNtuple(char *filename, void* nt) const
-{ 
-  //write ntuple
-#ifdef use_root
-  TNtuple *ntuple=(TNtuple *) nt;
-  TFile *f = new TFile(filename,"RECREATE");
-  ntuple->Write();
-  f->Close();
-  delete ntuple; 
-  return kTRUE; 
-#else
-  return kFALSE;
-#endif
-}
-
-void AliHLTTPCMerger::FillNtuple(void *nt,AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
-{ 
-  //fill ntuple
-  Float_t data[17];
-  if(outertrack->IsPoint()&&innertrack->IsPoint())
-    {
-      data[0] =Float_t(innertrack->GetPointX()-outertrack->GetPointX());
-      data[1] =Float_t(innertrack->GetPointY()-outertrack->GetPointY());
-      data[2] =Float_t(innertrack->GetPointZ()-outertrack->GetPointZ());
-      data[3] =Float_t(innertrack->GetKappa()-outertrack->GetKappa());
-      Double_t psi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
-      if(psi>AliHLTTPCTransform::Pi()) psi-=AliHLTTPCTransform::TwoPi();
-      else if(psi<-AliHLTTPCTransform::Pi()) psi+=AliHLTTPCTransform::TwoPi();
-      data[4] =Float_t(psi);
-      data[5] =Float_t(innertrack->GetTgl()-outertrack->GetTgl());
-      data[6] =Float_t(innertrack->GetCharge()-outertrack->GetCharge());
-      data[7] =Float_t(innertrack->GetLastPointX()-outertrack->GetFirstPointX());
-      data[8] =Float_t(innertrack->GetLastPointY()-outertrack->GetFirstPointY());
-      data[9] =Float_t(innertrack->GetLastPointZ()-outertrack->GetFirstPointZ());
-      data[10] =sqrt(pow(data[7],2)+pow(data[8],2)+pow(data[9],2));
-      data[11]= outertrack->GetNHits();
-      data[12]= innertrack->GetNHits();
-      data[13] = Float_t(TrackDiff(innertrack,outertrack));
-      data[14]=0;
-      data[15]=0;
-      data[16]=0;
-#ifdef use_root
-      TNtuple *ntuple = (TNtuple *) nt;
-      ntuple->Fill(data);
-#endif
-    }
-}
-
-void AliHLTTPCMerger::FillNtuple(void *nt,Float_t *data) const
-{ 
-  //fill ntuple
-#ifdef use_root
-  TNtuple *ntuple = (TNtuple *) nt;
-  ntuple->Fill(data);
-#endif
-}
-
-Double_t AliHLTTPCMerger::GetAngle(Double_t a1,Double_t a2)
-{ 
-  //get angle
-  Double_t da = a1 - a2 + 4*AliHLTTPCTransform::Pi();
-  da = fmod(da,AliHLTTPCTransform::TwoPi());
-  if(da>AliHLTTPCTransform::Pi()) da = AliHLTTPCTransform::TwoPi()-da;
-  return da;
-}
-
-void AliHLTTPCMerger::SetParameter(Double_t maxy, Double_t maxz, Double_t maxkappa, Double_t maxpsi, Double_t maxtgl)
-{ 
-  //set parameters for merger
-  fMaxY = maxy;
-  fMaxZ = maxz;
-  fMaxKappa = maxkappa;
-  fMaxPsi = maxpsi;
-  fMaxTgl = maxtgl;
-}
-
-Bool_t AliHLTTPCMerger::IsTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
-{
-  //is track to be merged
-  if(innertrack->GetCharge()!=outertrack->GetCharge()) return kFALSE;
-  if( (!innertrack->IsPoint()) || (!outertrack->IsPoint()) )  return kFALSE; 
-  if(innertrack->GetNHits()+outertrack->GetNHits()>AliHLTTPCTransform::GetNRows()) return kFALSE;
-  
-  if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
-  if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
-  if(fabs(innertrack->GetKappa()-outertrack->GetKappa())   >fMaxKappa) return kFALSE;
-  if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
-  if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
-  //if no rejection up to this point: merge!!
-  return kTRUE;
-}
-
-Bool_t AliHLTTPCMerger::IsRTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
-{ 
-  //same as IsTrack
-  return IsTrack(innertrack,outertrack);
-}
-
-Double_t AliHLTTPCMerger::TrackDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
-{ 
-  //return track difference
-  Double_t diff =-1;
-  Double_t x[4],y[4],z[4],dy[4],dz[4];
-  AliHLTTPCTrack *tracks[2]; 
-  
-  tracks[0] = innertrack;
-  tracks[1] = outertrack;
-  SortGlobalTracks(tracks,2);
-  innertrack = tracks[0]; 
-  outertrack = tracks[1];
-  
-  x[0] = innertrack->GetFirstPointX();
-  x[1] = innertrack->GetLastPointX();
-  x[2] = outertrack->GetFirstPointX();
-  x[3] = outertrack->GetLastPointX();
-  
-  y[0] = innertrack->GetFirstPointY();
-  y[1] = innertrack->GetLastPointY();
-  y[2] = outertrack->GetFirstPointY();
-  y[3] = outertrack->GetLastPointY();
-
-  z[0] = innertrack->GetFirstPointZ();
-  z[1] = innertrack->GetLastPointZ();
-  z[2] = outertrack->GetFirstPointZ();
-  z[3] = outertrack->GetLastPointZ();
-
-  
-  outertrack->CalculatePoint(x[0]);
-  if(!outertrack->IsPoint()) return diff;
-  dy[0] = fabs(y[0] - outertrack->GetPointY());
-  dz[0] = fabs(z[0] - outertrack->GetPointZ());
-  
-  outertrack->CalculatePoint(x[1]);
-  if(!outertrack->IsPoint()) return diff;
-  dy[1] = fabs(y[1] - outertrack->GetPointY());
-  dz[1] = fabs(z[1] - outertrack->GetPointZ());
-  
-  innertrack->CalculatePoint(x[2]);
-  if(!innertrack->IsPoint()) return diff;
-  dy[2] = fabs(y[2] - innertrack->GetPointY());
-  dz[2] = fabs(z[2] - innertrack->GetPointZ());
-  
-  innertrack->CalculatePoint(x[3]);
-  if(!innertrack->IsPoint()) return diff;
-  dy[3] = fabs(y[3] - innertrack->GetPointY());
-  dz[3] = fabs(z[3] - innertrack->GetPointZ());
-
-  diff=0;
-  for(Int_t i=0;i<4;i++)
-    diff+=sqrt(dy[i]*dy[i]+dz[i]*dz[i]);
-  return diff; 
-}
-
-void AliHLTTPCMerger::PrintDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack)
-{ 
-  // print difference
-  if(!innertrack->IsPoint()||!outertrack->IsPoint())
-    {
-      LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::PrintDiff","No Points")<<ENDLOG;
-      //cerr<<"AliHLTTPCMerger::PrintDiff: No Points"<<endl;
-      //cerr<<"---------------------------"<<endl;
-      return;
-    } 
-  
-  Double_t dx = innertrack->GetPointX()-outertrack->GetPointX();
-  Double_t dy = innertrack->GetPointY()-outertrack->GetPointY();
-  Double_t dz = innertrack->GetPointZ()-outertrack->GetPointZ();
-  Double_t dk = innertrack->GetKappa()-outertrack->GetKappa();
-  Double_t dpsi= innertrack->GetPointPsi() - outertrack->GetPointPsi();
-  if(dpsi>AliHLTTPCTransform::Pi()) dpsi-=AliHLTTPCTransform::TwoPi();
-  else if(dpsi<-AliHLTTPCTransform::Pi())dpsi+=AliHLTTPCTransform::TwoPi();
-  //Double_t dpsi = GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi());
-  Double_t dtgl= innertrack->GetTgl()-outertrack->GetTgl();
-  Double_t dq =innertrack->GetCharge()-outertrack->GetCharge();
-  
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::PrintDiff","Points") <<"dx: "<<dx<<" dy: "<<dy<<" dz: "<<dz<<" dk: "<<dk<<" dpsi: "<<dpsi<<" dtgl: "<<dtgl<<" dq: "<<dq<<ENDLOG;
-  //fprintf(stderr,"dx: %4f dy: %4f dz: %4f dk: %4f dpsi: %4f dtgl: %4f dq: %4f\n",dx,dy,dz,dk,dpsi,dtgl,dq);
-  //cerr<<"---------------------------"<<endl;
-  
-}
-
-void AliHLTTPCMerger::Print()
-{
-  // print some infos
-  for(Int_t i=0; i<fNIn; i++)
-    {
-      AliHLTTPCTrackArray *ttt= GetInTracks(i);
-      for(Int_t j =0;j<ttt->GetNTracks();j++)
-       {
-         AliHLTTPCTrack *track=ttt->GetCheckedTrack(j);
-         if(!track) continue;
-         track->CalculateHelix();
-         //      Double_t angle = atan2(track->GetLastPointY(),track->GetLastPointX());
-         //      if(angle<0) angle+=AliHLTTPCTransform::Pi();
-         if(track->CalculatePoint(135))
-           //      if(!track->CalculateEdgePoint(angle)) cerr<<"**************"<<endl;     
-           //      if(track->CalculatePoint(track->GetLastPointX()))
-           //      if(track->CalculatePoint(0))
-           {
-             //      PrintTrack(track);
-             //      track->CalculateReferencePoint(AliHLTTPCTransform::Pi()/180.);
-             track->CalculateReferencePoint(0.001);
-             Float_t dx=(float)track->GetPointX()-track->GetPointX();
-             Float_t dy=(float)track->GetPointY()-track->GetPointY();
-             Float_t dz=(float)track->GetPointZ()-track->GetPointZ();
-             LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMerger::Print","RefPoint") <<"npt: "<<track->GetNHits()<<" dx: "<<dx<<" dy: "<<dy<<" dz: "<<dz<<ENDLOG;
-             
-             //fprintf(stderr,"npt: %3d dx: %8.5f dy: %8.5f dz: %8.5f\n",track->GetNHits(),dx,dy,dz);
-             //cerr<<"---------------------------"<<endl;
-           }
-       }  
-    }
-}
-
-void AliHLTTPCMerger::PrintTrack(AliHLTTPCTrack *track)
-{ 
-  //print track info
-  fprintf(stderr,"npt: %3d pt: %.2f psi: %.2f tgl: %5.2f q: %2d\n",
-         track->GetNHits(),track->GetPt(),track->GetPsi(),
-         track->GetTgl(),track->GetCharge());
-  fprintf(stderr,
-         "x1: %6.2f y1: %6.2f z1: %6.2f xl: %6.2f yl: %6.2f zl: %6.2f\n",
-         track->GetFirstPointX(),track->GetFirstPointY(),track->GetFirstPointZ(),
-         track->GetLastPointX(),track->GetLastPointY(),track->GetLastPointZ());
-  if(track->IsPoint())
-    {
-      fprintf(stderr,
-             "R: %.2f Xc: %.2f Yc: %.2f Xp: %.2f Yp: %.2f Zp: %.2f Psip: %.2f\n",
-             track->GetRadius(),track->GetCenterX(),track->GetCenterY(),
-             track->GetPointX(),track->GetPointY(),track->GetPointZ(),
-             track->GetPointPsi());
-    }
-}
diff --git a/HLT/TPCLib/AliHLTTPCMerger.h b/HLT/TPCLib/AliHLTTPCMerger.h
deleted file mode 100644 (file)
index 4934f9e..0000000
+++ /dev/null
@@ -1,96 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTMerger.h,v 1.8 2004/06/11 16:06:33 loizides 
-#ifndef ALIHLTTPCMERGER_H
-#define ALIHLTTPCMERGER_H
-//* 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                               *
-
-/** @file   AliHLTTPCMerger.h
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC merger base class
-*/
-
-//#define PI 3.14159265358979312
-
-#include "AliHLTTPCRootTypes.h"
-
-class AliHLTTPCTrack;
-class AliHLTTPCTrackSegmentData;
-class AliHLTTPCVertex;
-class AliHLTTPCTrackArray;
-
-/** 
- * @class AliHLTTPCMerger
- * The HLTTPC merger base class
- *
- * @ingroup alihlt_tpc
- */
-class AliHLTTPCMerger {
- public:
-  AliHLTTPCMerger();
-  /** destructor */
-  virtual ~AliHLTTPCMerger();
-
-  Int_t GetNIn() const {return fNIn;}
-  AliHLTTPCTrackArray *GetInTracks(Int_t in){return fInTrack[in];}
-  AliHLTTPCTrackArray *GetOutTracks(){return fOutTrack;}
-
-  Bool_t Is2Global() const {return f2Global;}
-  void SetVertex(AliHLTTPCVertex *vertex){fVertex=vertex;}
-  void Reset();
-  void SetParameter(Double_t maxy=1., Double_t maxz=1., Double_t maxkappa=0.001, Double_t maxpsi=0.05, Double_t maxtgl=0.1);
-  void FillTracks(Int_t ntracks, AliHLTTPCTrackSegmentData* tr); //Fill tracks in fTrackArray[fCurrentTracks] 
-  Double_t GetAngle(Double_t a1,Double_t a2);
-  void* GetNtuple() const;
-  void* GetNtuple(char *varlist) const;
-  Bool_t WriteNtuple(char *filename,void* nt) const;
-  void FillNtuple(void* nt,Float_t *data) const ;
-  void FillNtuple(void* nt,AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack);
-  void AddAllTracks();//Copy all Tracks to Output Array
-  void SortGlobalTracks(AliHLTTPCTrack **tracks, Int_t ntrack);
-  virtual void SortTracks(AliHLTTPCTrack **tracks, Int_t ntrack) const;
-  virtual void AddTrack(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *track);
-  virtual AliHLTTPCTrack * MultiMerge(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack **tracks, Int_t ntrack);
-  AliHLTTPCTrack * MergeTracks(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrack *t0,AliHLTTPCTrack *t1);
-  virtual Bool_t IsTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack);
-  Bool_t IsRTrack(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack);
-  Double_t TrackDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack);
-  void Print();
-  void PrintDiff(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack);
-  void PrintTrack(AliHLTTPCTrack *track);
-  
- protected:
-  Int_t fCurrentTracks; //current number
-  Int_t fSlice;         //slice
-  AliHLTTPCVertex *fVertex; //!
-  Bool_t f2Global; //global
-  Bool_t Is2Global(Bool_t is){f2Global=is;return f2Global;}
-  void InitMerger(Int_t ntrackarrays,const Char_t *tracktype="AliHLTTPCTrack");
-  
- private:
-  /** copy constructor prohibited */
-  AliHLTTPCMerger(const AliHLTTPCMerger&);
-  /** assignment operator prohibited */
-  AliHLTTPCMerger& operator=(const AliHLTTPCMerger&);
-
-  void SetArray(Int_t nin);
-  void DeleteArray();
-
-  Double_t fMaxY;    //maxy
-  Double_t fMaxZ;    //maxz
-  Double_t fMaxKappa;//maxkappa
-  Double_t fMaxPsi;  //maxpsi
-  Double_t fMaxTgl;  //maxtgl
-  Char_t fTrackType; //track type to merge
-  
-  AliHLTTPCTrackArray **fInTrack;//!
-  Int_t fNIn; //ntracks
-
-  AliHLTTPCTrackArray *fOutTrack;//!
-
-  ClassDef(AliHLTTPCMerger,0) //Merging base class
-};
-
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx b/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx
deleted file mode 100644 (file)
index ab212ca..0000000
+++ /dev/null
@@ -1,946 +0,0 @@
-// $Id$
-
-//**************************************************************************
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//*                                                                        *
-//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
-//*                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
-//*                  for The ALICE HLT Project.                            *
-//*                                                                        *
-//* Permission to use, copy, modify and distribute this software and its   *
-//* documentation strictly for non-commercial purposes is hereby granted   *
-//* without fee, provided that the above copyright notice appears in all   *
-//* copies and that both the copyright notice and this permission notice   *
-//* appear in the supporting documentation. The authors make no claims     *
-//* about the suitability of this software for any purpose. It is          *
-//* provided "as is" without express or implied warranty.                  *
-//**************************************************************************
-
-/** @file   AliHLTTPCSliceTrackerComponent.cxx
-    @author Timm Steinbeck, Matthias Richter
-    @date   
-    @brief  The TPC conformal mapping tracker component.
-*/
-
-#if __GNUC__>= 3
-using namespace std;
-#endif
-
-#include <climits>
-#include "AliHLTTPCSliceTrackerComponent.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCConfMapper.h"
-#include "AliHLTTPCVertex.h"
-#include "AliHLTTPCVertexData.h"
-#include "AliHLTTPCClusterDataFormat.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTrackArray.h"
-#include "AliHLTTPCTrackletDataFormat.h"
-#include "AliHLTTPCInterMerger.h"
-#include "AliHLTTPCMemHandler.h"
-#include "AliHLTTPCDefinitions.h"
-#include "AliHLTCommonCDBEntries.h"
-#include "TString.h"
-#include "TObjString.h"
-#include "TObjArray.h"
-#include "AliCDBEntry.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "TGeoGlobalMagField.h"
-//#include "AliHLTTPC.h"
-//#include <stdlib.h>
-//#include <cerrno>
-
-/** ROOT macro for the implementation of ROOT specific class methods */
-ClassImp(AliHLTTPCSliceTrackerComponent)
-
-AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent()
-  :
-  fTracker(NULL),
-  fVertex(NULL),
-  fDoNonVertex(false),
-  fDoPP(false),
-  fDoPbPb(false),
-  fMultiplicity(4000),
-  fBField(0.5),
-  fnonvertextracking(kFALSE),
-  fmainvertextracking(kTRUE),
-  fPhisegment(50),
-  fEtasegment(100),
-  fTrackletlength(3),
-  fTracklength(60),
-  fRowscopetracklet(6),
-  fRowscopetrack(6),
-  fMinPtFit(0),
-  fMaxangle(0.1745),
-  fGoodDist(5),
-  fHitChi2Cut(100),
-  fGoodHitChi2(5),
-  fTrackChi2Cut(50),
-  fMaxdist(50),
-  fMaxphi(0.1),
-  fMaxeta(0.1),
-  fpInterMerger(NULL)
-{
-  // see header file for class documentation
-  // or
-  // refer to README to build package
-  // or
-  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-  fEta[0] = 0.;
-  fEta[1] = 1.1;
-}
-
-AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
-{
-  // see header file for class documentation
-}
-
-// Public functions to implement AliHLTComponent's interface.
-// These functions are required for the registration process
-
-const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
-{
-  // see header file for class documentation
-
-  return "TPCSliceTracker";
-}
-
-void AliHLTTPCSliceTrackerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
-{
-  // see header file for class documentation
-  list.clear();
-  list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
-  list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
-}
-
-AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
-{
-  // see header file for class documentation
-  return AliHLTTPCDefinitions::fgkTrackSegmentsDataType;
-}
-
-void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-{
-  // see header file for class documentation
-  // XXX TODO: Find more realistic values.
-  constBase = 0;
-  inputMultiplier = 1;
-}
-
-AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn()
-{
-  // see header file for class documentation
-  return new AliHLTTPCSliceTrackerComponent;
-}
-
-void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments,
-                                  Int_t trackletlength, Int_t tracklength,
-                                  Int_t rowscopetracklet, Int_t rowscopetrack,
-                                  Double_t minPtFit, Double_t maxangle,
-                                  Double_t goodDist, Double_t hitChi2Cut,
-                                  Double_t goodHitChi2, Double_t trackChi2Cut,
-                                  Int_t maxdist, Double_t maxphi,Double_t maxeta)
-{
-  // see header file for class documentation
-    //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ??
-    //Set parameters input to the tracker
-    //If no arguments are given, default parameters will be used
-    
-    fTracker->SetNSegments(phiSegments,etaSegments);
-    fTracker->SetMaxDca(minPtFit);
-    //   fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
-
-    Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
-
-    if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
-       fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
-       fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
-
-       fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);    
-       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
-    }
-    else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
-       fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
-       fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
-       fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
-       fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
-
-       fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
-       fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);     
-       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
-    }
-    else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
-       fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
-       fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
-
-       fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
-       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
-    }
-    
-    //fTracker->SetParamDone(true);
-    /* Matthias 13.12.2006
-     * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
-     * and has always been kTRUE.
-     * In order to remove the AliHLTTPC class (which is the old steering class for
-     * HLT (TPC) tracking) from the compilation, this function can not be activated
-     * again. We have to think about a more elegant way to specify the parameters
-     * anyway. The following line was surely for some testing, but was never active
-     * in a tested release.
-     */
-    //AliHLTTPC::SetVertexFit( kFALSE );
-    
-    fTracker->InitVolumes();
-    }
-
-
-void AliHLTTPCSliceTrackerComponent::SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity, 
-                                                     Double_t bField, Int_t etasegment, Double_t hitchi2cut, 
-                                                     Int_t rowscopetracklet, Int_t rowscopetrack, 
-                                                     Int_t trackletlength, Int_t tracklength )
-{
-  // see header file for class documentation
-  AliHLTTPCTransform::SetBField( bField );
-  Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField );
-  
-  if ( doPP )
-    {
-      //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
-      
-      SetTrackerParam( 50, 100, 3, 60,
-                      6, 6,
-                      0, 0.1745, 5, 100,
-                      5, 50, 50, 0.1, 0.1);
-    }
-  else if(doPbPb)
-    {
-      int mults[] = { 1000, 2000, 4000, 8000 };
-      int multCount = 4;
-      int closestMult = 0;
-      int i;
-      int multDist, tmpMultDist;
-      if ( multiplicity>mults[closestMult] )
-       multDist = multiplicity-mults[closestMult];
-      else
-       multDist = mults[closestMult]-multiplicity;
-      for ( i = 1; i < multCount; i++ )
-       {
-         if ( multiplicity>mults[i] )
-           tmpMultDist = multiplicity-mults[i];
-         else
-           tmpMultDist = mults[i]-multiplicity;
-         if ( tmpMultDist < multDist )
-           {
-             closestMult = i;
-             multDist = tmpMultDist;
-           }
-       }
-      
-      double bfs[] = { 0.2, 0.4 };
-      int bfCount = 2;
-      int closestBf = 0;
-      double bfDist, tmpBFDist;
-      if ( bField>bfs[closestBf] )
-       bfDist = bField-bfs[closestBf];
-      else
-       bfDist = bfs[closestBf]-bField;
-      for ( i = 1; i < bfCount; i++ )
-       {
-         if ( bField>bfs[i] )
-           tmpBFDist = bField-bfs[i];
-         else
-           tmpBFDist = bfs[i]-bField;
-         if ( tmpBFDist < bfDist )
-           {
-             closestBf = i;
-             bfDist = tmpBFDist;
-           }
-       }
-      
-      switch ( closestMult )
-       {
-       case 0: // 1000
-         switch ( closestBf )
-           {
-           case 0: // 0.2
-             SetTrackerParam( 50, 100, 3, 10,
-                              2, 4,
-                              0, 0.1745, 5, 100,
-                              5, 50, 50, 0.1, 0.1);
-             break;
-           case 1: // 0.4
-             SetTrackerParam( 50, 100, 3, 10,
-                              2, 4,
-                              0, 0.1745, 5, 100,
-                              5, 50, 50, 0.1, 0.1);
-             break;
-           }
-         break;
-       case 1: // 2000
-         switch ( closestBf )
-           {
-           case 0: // 0.2
-             SetTrackerParam( 50, 100, 3, 10,
-                              2, 4,
-                              0, 0.1745, 5, 30,
-                              5, 20, 50, 0.1, 0.1);
-             break;
-           case 1: // 0.4
-             SetTrackerParam( 50, 100, 3, 10,
-                              2, 5,
-                              0, 0.1745, 5, 30,
-                              5, 20, 50, 0.1, 0.1);
-             break;
-           }
-         break;
-       case 2: // 4000
-         switch ( closestBf )
-           {
-           case 0: // 0.2
-             SetTrackerParam( 50, 100, 3, 10,
-                              2 , 10,
-                              0, 0.1745, 5, 20,
-                              5, 10 , 50, 0.1, 0.1);
-             break;
-           case 1: // 0.4
-             SetTrackerParam( 50, 100, 3, 10,
-                              2, 10,
-                              0, 0.1745, 5, 20,
-                              5, 10, 50, 0.1, 0.1);
-             break;
-           }
-         break;
-       case 3: // 8000
-         switch ( closestBf )
-           {
-           case 0: // 0.2
-             SetTrackerParam( 50, 100, 3, 10,
-                              3, 15,
-                              0, 0.1745, 5, 10,
-                              5, 5, 50, 0.1, 0.1);
-             break;
-           case 1: // 0.4
-             SetTrackerParam( 50, 100, 3, 10,
-                              2, 15,
-                              0, 0.1745, 5, 15,
-                              5, 5, 50, 0.1, 0.1);
-             break;
-           }
-         break;
-       }
-      //       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
-      //       AliHLTTPCTransform::SetBField( bfs[closestBf] );
-      //       AliHLTTPCTransform::SetBField( bField );
-      //       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
-    }
-  else
-    {
-      SetTrackerParam( 50, etasegment, trackletlength, tracklength,
-                      rowscopetracklet, rowscopetrack,
-                      0, 0.1745, 5, hitchi2cut,
-                      5, 50, 50, 0.1, 0.1);
-    }
-}
-       
-int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv )
-    {
-  // see header file for class documentation
-    Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
-
-    if ( fTracker || fVertex )
-       return EINPROGRESS;
-    fTracker = new AliHLTTPCConfMapper();
-    fVertex = new AliHLTTPCVertex();
-    fEta[0] = 0.;
-    fEta[1] = 1.1;
-    fDoNonVertex = false;
-    fMultiplicity = 4000;
-    fBField = 0.5;
-    fDoPP = false;
-    fDoPbPb = false;
-    fPhisegment=50;
-    fEtasegment=100;
-    fTrackletlength=3;
-    fTracklength=60;
-    fRowscopetracklet=6;
-    fRowscopetrack=6;
-    fMinPtFit=0;
-    fMaxangle=0.1745;
-    fGoodDist=5;
-    fHitChi2Cut=100;
-    fGoodHitChi2=5;
-    fTrackChi2Cut=50;
-    fMaxdist=50;
-    fMaxphi=0.1;
-    fMaxeta=0.1;
-    int iResult=0;
-        
-    TString configuration="";
-    TString argument="";
-    for (int i=0; i<argc && iResult>=0; i++) {
-      argument=argv[i];
-      if (!configuration.IsNull()) configuration+=" ";
-      configuration+=argument;
-    }
-
-    if (!configuration.IsNull()) {
-      iResult=Configure(configuration.Data());
-    } else {
-      iResult=Reconfigure(NULL, NULL);
-    }
-    
-    return iResult;
-    }
-
-int AliHLTTPCSliceTrackerComponent::DoDeinit()
-{
-  // see header file for class documentation
-  if ( fTracker )
-    delete fTracker;
-  fTracker = NULL;
-  if ( fVertex )
-    delete fVertex;
-  fVertex = NULL;
-  if (fpInterMerger) {
-    delete fpInterMerger;
-  }
-  fpInterMerger=NULL;
-  return 0;
-}
-
-int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                                             AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
-                                             AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks )
-{
-  // see header file for class documentation
-  int iResult=0;
-  AliHLTUInt32_t capacity=size;
-  size=0;
-
-  if (!IsDataEvent()) return 0;
-
-    if ( evtData.fBlockCnt<=0 )
-      {
-       Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
-       return 0;
-      }
-    const AliHLTComponentBlockData* iter = NULL;
-    unsigned long ndx;
-    AliHLTTPCClusterData* inPtrSP;
-    AliHLTTPCVertexData* inPtrV = NULL;
-#ifdef FORWARD_VERTEX_BLOCK
-    const AliHLTComponentBlockData* vertexIter=NULL;
-#endif
-    AliHLTTPCTrackletData* outPtr;
-    AliHLTUInt8_t* outBPtr;
-    //AliHLTUInt32_t vSize = 0;
-    UInt_t offset=0, mysize, tSize = 0;
-    outBPtr = outputPtr;
-    Int_t slice=-1, patch=-1, row[2];
-    Int_t minPatch=INT_MAX, maxPatch = 0;
-    offset = 0;
-    std::vector<Int_t> slices;
-    std::vector<Int_t>::iterator slIter, slEnd;
-    std::vector<unsigned> sliceCnts;
-    std::vector<unsigned>::iterator slCntIter;
-    Int_t vertexSlice=-1;
-
-    // Find min/max rows used in total and find and read out vertex if it is present
-    // also determine correct slice number, if multiple slice numbers are present in event
-    // (which should not happen in the first place) we use the one that occurs the most times
-    row[0] = 0;
-    row[1] = 0;
-    bool found;
-    for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
-       {
-       iter = blocks+ndx;
-
-       bool bIsClusterDataBlock=false;
-       bool bIsVertexDataBlock=false;
-       if(!(bIsClusterDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkClustersDataType)) &&
-          !(bIsVertexDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkVertexDataType))){
-         continue;
-       }
-
-       slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
-       if (slice<0 || slice>=AliHLTTPCTransform::GetNSlice()) {
-         HLTError("invalid slice number %d extracted from specification 0x%08lx,  skipping block of type %s",
-                  slice, iter->fSpecification, DataType2Text(iter->fDataType).c_str());
-         // just remember the error, if there are other valid blocks ignore the
-         // error, return code otherwise
-         iResult=-EBADF;
-         continue;
-       }
-       if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr( *iter )) {
-         // 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",
-                    iter->fSpecification, DataType2Text(iter->fDataType).c_str());
-       }
-       found = false;
-       slIter = slices.begin();
-       slEnd = slices.end();
-       slCntIter = sliceCnts.begin();
-       while ( slIter != slEnd )
-           {
-           if ( *slIter == slice )
-               {
-               found = true;
-               break;
-               }
-           slIter++;
-           slCntIter++;
-           }
-       if ( !found )
-           {
-           slices.insert( slices.end(), slice );
-           sliceCnts.insert( sliceCnts.end(), 1 );
-           }
-       else
-           *slCntIter++;
-
-       if (bIsVertexDataBlock)
-           {
-           inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
-#ifdef FORWARD_VERTEX_BLOCK
-           vertexIter = iter;
-#endif
-           //vSize = iter->fSize;
-           fVertex->Read( inPtrV );
-           vertexSlice = slice;
-           }
-       if (bIsClusterDataBlock)
-           {
-           patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
-           if ( minPatch>patch )
-               {
-               minPatch = patch;
-               row[0] = AliHLTTPCTransform::GetFirstRow( patch );
-               }
-           if ( maxPatch<patch )
-               {
-               maxPatch = patch;
-               row[1] = AliHLTTPCTransform::GetLastRow( patch );
-               }
-           }
-       }
-
-    // Determine slice number to really use.
-    if ( slices.size()>1 )
-       {
-       Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
-                "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
-                evtData.fEventID, evtData.fEventID );
-       unsigned maxCntSlice=0;
-       slIter = slices.begin();
-       slEnd = slices.end();
-       slCntIter = sliceCnts.begin();
-       while ( slIter != slEnd )
-           {
-           Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
-                    "Slice %lu found %lu times.", *slIter, *slCntIter );
-           if ( maxCntSlice<*slCntIter )
-               {
-               maxCntSlice = *slCntIter;
-               slice = *slIter;
-               }
-           slIter++;
-           slCntIter++;
-           }
-       Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
-                "Using slice %lu.", slice );
-       }
-    else if ( slices.size()>0 )
-      {
-       slice = *(slices.begin());
-      }
-    else
-      {
-       // there is no sense in running the tracker without input, do not send an
-       // empty output block
-       return iResult;
-      }
-    
-    iResult=0;
-
-    if ( vertexSlice != slice )
-       {
-       // multiple vertex blocks in event and we used the wrong one...
-       found = false;
-       for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
-           {
-           iter = blocks+ndx;
-           if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
-               {
-               inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
-#ifdef FORWARD_VERTEX_BLOCK
-               vertexIter = iter;
-#endif
-               //vSize = iter->fSize;
-               fVertex->Read( inPtrV );
-               break;
-               }
-           }
-       }
-
-    fTracker->InitSector( slice, row, fEta );
-    fTracker->SetVertex(fVertex);
-    mysize = 0;
-    // read in all hits
-    std::vector<unsigned long> patchIndices;
-    std::vector<unsigned long>::iterator pIter, pEnd;
-    for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
-       {
-       iter = blocks+ndx;
-
-       if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
-           {
-           patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
-           pIter = patchIndices.begin();
-           pEnd = patchIndices.end();
-           while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
-               pIter++;
-           patchIndices.insert( pIter, ndx );
-           }
-       }
-    pIter = patchIndices.begin();
-    pEnd = patchIndices.end();
-    while ( pIter!=pEnd )
-       {
-       ndx = *pIter;
-       iter = blocks+ndx;
-
-       patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
-       inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
-           
-       Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
-                "Reading hits for slice %d - patch %d", slice, patch );
-       //fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
-       fTracker->ReadHitsChecked(inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints,iter->fSize );
-       pIter++;
-       }
-
-
-    if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){        
-      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
-      fTracker->MainVertexTrackingA();
-      fTracker->MainVertexTrackingB();
-      fTracker->FillTracks();
-    }
-    else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){    
-      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
-      fTracker->MainVertexTrackingA();
-      fTracker->MainVertexTrackingB();
-      fTracker->FillTracks();  
-      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
-      fTracker->NonVertexTracking();
-    }
-    else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
-      Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
-      fTracker->NonVertexTracking();   
-      fTracker->FillTracks();  
-    }
-
-    UInt_t ntracks0 =0;
-    if(fpInterMerger){
-      AliHLTTPCMemHandler memory;
-      AliHLTTPCTrackSegmentData *trackdata0  = 
-       (AliHLTTPCTrackSegmentData *) memory.Allocate(fTracker->GetTracks());
-      memory.TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
-      fpInterMerger->Reset();
-      fpInterMerger->Init(row,patch);
-      fpInterMerger->FillTracks(ntracks0,trackdata0);
-      fpInterMerger->Merge();
-    } 
-    ntracks0=0;
-    AliHLTTPCTrackArray* pArray=fTracker->GetTracks();
-    if (pArray->GetOutSize()+sizeof(AliHLTTPCTrackletData)<=capacity) {
-    outPtr = (AliHLTTPCTrackletData*)(outBPtr);
-    mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets );
-    outPtr->fTrackletCnt = ntracks0;
-
-    // Matthias 2009-05-22
-    // Somehow the ConfMapFit uses a different sign convention for the magnetic field.
-    // In order to avoid conversions further upstream we change the sign here.
-    // The CM tracker is not the first priority any more as the CA tracker is
-    // going to be used for online TPC reconstruction. But CM tracker has to
-    // remain functional.
-    // Further investigation is ongoing
-    AliHLTTPCTrackSegmentData* segment=outPtr->fTracklets;
-    for (unsigned int trackno=0; trackno<ntracks0; trackno++, segment++) {
-      segment->fCharge*=-1;
-    }
-
-    Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
-            "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.", 
-            ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
-
-    fTracker->Reset();
-
-    AliHLTComponentBlockData bd;
-    FillBlockData( bd );
-    bd.fOffset = offset;
-    bd.fSize = mysize+sizeof(AliHLTTPCTrackletData);
-    bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
-    outputBlocks.push_back( bd );
-
-    tSize += bd.fSize;
-    outBPtr += bd.fSize;
-    } else {
-      iResult=-ENOSPC;
-    }
-
-#ifdef FORWARD_VERTEX_BLOCK
-    if ( vertexIter )
-       {
-       // Copy the descriptor block for the vertex information.
-       bd = *vertexIter;
-       outputBlocks.push_back( bd );
-       }
-#endif // FORWARD_VERTEX_BLOCK
-
-    size = tSize;
-    return iResult;
-    }
-
-int AliHLTTPCSliceTrackerComponent::Configure(const char* arguments)
-{
-  // see header file for class documentation
-  int iResult=0;
-  if (!arguments) return iResult;
-  
-  // Check field
-  if (!TGeoGlobalMagField::Instance()) {
-    HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF");
-    return -ENODEV;
-  }
-
-  TString allArgs=arguments;
-  TString argument;
-  int bMissingParam=0;
-  Bool_t bDoMerger=kTRUE;
-
-  TObjArray* pTokens=allArgs.Tokenize(" ");
-  if (pTokens) {
-    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
-      argument=((TObjString*)pTokens->At(i))->GetString();
-      if (argument.IsNull()) continue;
-      
-      if (argument.CompareTo("-disable-merger")==0) {
-       HLTInfo("Disabled Inter Merger");
-       bDoMerger = kFALSE;
-       continue;
-      }
-      else if (argument.CompareTo("-pp-run")==0) {
-       HLTInfo("Using Trackparameters for pp-run");
-       fDoPP = true;
-       continue;
-      }
-      else if (argument.CompareTo("-PbPb-run")==0) {
-       HLTInfo("Using Trackparameters for Pb-Pb-run");
-       fDoPbPb = true;
-       continue;
-      }
-      else if (argument.CompareTo("-nonvertextracking")==0) {
-       HLTInfo("Doing Nonvertex Tracking");
-       fnonvertextracking = kTRUE;
-       continue;
-      }     
-      else if (argument.CompareTo("-mainvertextrackingoff")==0) {
-       HLTInfo("Mainvertex Tracking off");
-       fmainvertextracking = kFALSE;
-       continue;
-      }
-      else if (argument.CompareTo("-multiplicity")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Multiplicity set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fMultiplicity=((TObjString*)pTokens->At(i))->GetString().Atoi();
-       continue;
-      } 
-      else if (argument.CompareTo("-solenoidBz")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTWarning("parameter -solenoidBz deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
-       continue;
-      } 
-      else if (argument.CompareTo("-bfield")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTWarning("parameter -bfield deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField");
-       continue;
-      } 
-      else if (argument.CompareTo("-etarange")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Etarange set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fEta[1]=((TObjString*)pTokens->At(i))->GetString().Atof();
-       continue;
-      }
-      else if (argument.CompareTo("-etasegment")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Number of Etasegment: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fEtasegment=((TObjString*)pTokens->At(i))->GetString().Atoi();
-       continue;
-      }
-      else if (argument.CompareTo("-chi2cut")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("chi2cut set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fHitChi2Cut=((TObjString*)pTokens->At(i))->GetString().Atof();
-       continue;
-      }
-      else if (argument.CompareTo("-rowscopetracklet")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Number of row to look for next cluster for tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fRowscopetracklet=((TObjString*)pTokens->At(i))->GetString().Atoi();
-       continue;
-      }
-      else if (argument.CompareTo("-rowscopetrack")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Number of row to look for next cluster for track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fRowscopetrack=((TObjString*)pTokens->At(i))->GetString().Atoi();
-       continue;
-      }
-      else if (argument.CompareTo("-trackletlength")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Minimum number of clusters on a Tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fTrackletlength=((TObjString*)pTokens->At(i))->GetString().Atoi();
-       continue;
-      }
-      else if (argument.CompareTo("-tracklength")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fTracklength=((TObjString*)pTokens->At(i))->GetString().Atoi();
-       continue;
-      }
-      else if (argument.CompareTo("-clusterZ")==0) {
-       if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
-       HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
-       fTracker->SetClusterCutZ(((TObjString*)pTokens->At(i))->GetString().Atoi());
-       continue;
-      }
-      else {
-       HLTError("unknown argument %s", argument.Data());
-       iResult=-EINVAL;
-       break;
-      }
-    }
-    delete pTokens;
-  }
-  if (bMissingParam) {
-    HLTError("missing parameter for argument %s", argument.Data());
-    iResult=-EINVAL;
-  }
-  fBField=GetBz()/10.0;
-  if (fBField == 0.){
-    // parameter for B=0 T 
-    fDoPP = kTRUE;
-    fnonvertextracking = kTRUE;
-    fmainvertextracking = kFALSE;
-  }
-  if (bDoMerger)
-    fpInterMerger = new AliHLTTPCInterMerger();
-  else
-    fpInterMerger = NULL;
-
-  SetTrackerParam(fDoPP,fDoPbPb,fMultiplicity,fBField,fEtasegment,fHitChi2Cut,fRowscopetracklet,fRowscopetrack,fTrackletlength,fTracklength);
-  
-  return iResult;
-}
-
-int AliHLTTPCSliceTrackerComponent::ReadPreprocessorValues(const char* modules)
-{
-  // see header file for class documentation
-  
-  int iResult = 0;
-  TString str(modules);
-  if(str.Contains("HLT") || str.Contains("TPC") || str.Contains("GRP")){
-  
-    const char* pathBField=NULL;
-    if (pathBField) {
-
-      HLTInfo("reconfigure B-Field from entry %s, modules %s", pathBField,(modules!=NULL && modules[0]!=0)?modules:"<none>");
-      //AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField/*,GetRunNo()*/);
-      
-      AliCDBPath path(pathBField);
-      
-      AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage();
-      Int_t version    = stor->GetLatestVersion(pathBField, GetRunNo());
-      Int_t subVersion = stor->GetLatestSubVersion(pathBField, GetRunNo(), version);
-      AliCDBEntry *pEntry = stor->Get(path,GetRunNo(), version, subVersion);
-      
-      HLTImportant("RunNo %d, Version %d, subversion %d", GetRunNo(), version, subVersion);
-      
-      if (pEntry) {
-       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
-       if (pString) {
-         HLTImportant("received configuration object string: \'%s\'", pString->GetString().Data());
-         iResult=Configure(pString->GetString().Data());
-       } else {
-         HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
-       }
-      } else {
-       HLTError("cannot fetch object \"%s\" from CDB", pathBField);
-      }
-    }
-  }  
-  return iResult;
-}
-
-int AliHLTTPCSliceTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
-{
-  // see header file for class documentation
-
-  int iResult=0;
-  const char* path="HLT/ConfigTPC/SliceTrackerComponent";
-  const char* defaultNotify="";
-  if (cdbEntry) {
-    path=cdbEntry;
-    defaultNotify=" (default)";
-  }
-  if (path) {
-    HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
-    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,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());
-      } else {
-       HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
-      }
-    } else {
-      HLTError("cannot fetch object \"%s\" from CDB", path);
-    }
-  }
-
-  const char* pathBField=NULL;
-
-  if (pathBField) {
-    HLTInfo("reconfigure B-Field from entry %s, chain id %s", path,(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());
-      } else {
-       HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
-      }
-    } else {
-      HLTError("cannot fetch object \"%s\" from CDB", path);
-    }
-  }
-  
-  return iResult;
-
-}
-
-void AliHLTTPCSliceTrackerComponent::SetTrackerParam1()
-{
-  // see header file for class documentation
-  SetTrackerParam( 10, 20, 5, 10, 2,2,
-                  0, 1.31, 5, 100,
-                  50, 100, 50, 0.1, 0.1);
-}
-
-       
diff --git a/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.h b/HLT/TPCLib/AliHLTTPCSliceTrackerComponent.h
deleted file mode 100644 (file)
index e791196..0000000
+++ /dev/null
@@ -1,210 +0,0 @@
-// XEmacs -*-C++-*-
-// @(#) $Id$
-
-#ifndef ALIHLTTPCSLICETRACKERCOMPONENT_H
-#define ALIHLTTPCSLICETRACKERCOMPONENT_H
-//* 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                               *
-
-/** @file   AliHLTTPCSliceTrackerComponent.h
-    @author Timm Steinbeck, Matthias Richter
-    @date   
-    @brief  The TPC conformal mapping tracker component.
-*/
-
-#include "AliHLTProcessor.h"
-
-class AliHLTTPCConfMapper;
-class AliHLTTPCVertex;
-class AliHLTTPCInterMerger;
-
-/**
- * @class AliHLTTPCSliceTrackerComponent
- * The TPC conformal mapping tracker component.
- * 
- * Component ID: \b TPCSliceTracker <br>
- * Library: \b libAliHLTTPC.
- *
- * Mandatory arguments: <br>
- * \li -bfield     <i> magnetic field   </i> <br> 
- *      should allways be used. If there is no magnetic field, use 0.00001
- * 
- * Optional arguments: <br>
- * \li -pp-run <br>  
- *      will give fixed trackparameters for p-p runs.
- * \li -Pb-Pb-run <br>  
- *      will give fixed trackparameters for Pb-Pb runs.
- * \li -multiplicity     <i> multiplicity  </i> <br> 
- *      set the multiplicity of your collitions. Used for Pb-Pb events.
- * \li -disable-merger <br>
- *      turns off the intermerging on sectorlevel. Only use in spacial cases.
- * \li -nonvertextracking <br> 
- *      the tracking will do a reconstruction of clusters without vertex constraint.
- * \li -mainvertextrackingoff <br>
- *      will turn off the tracking with vertex constraint. Use together with -nonvertextracking.
- * \li -etarange   <i> eta range   </i> <br> 
- *      sets the eta range for the tracking.
- * \li -etasegment <i> eta segments   </i> <br> 
- *      let you set the number of eta segments in the trscker.
- * \li -chi2cut <i> chiĀ²   </i> <br> 
- *      set the chiĀ² for the tracker.
- * \li -rowscopetracklet <i> number of padrows   </i> <br> 
- *     tells the tracker how many padrows down it should look for the next cluster when making tracklets.
- * \li -rowscopetrack <i> number of padrows   </i> <br>
- *     tells the tracker how many padrows down it should look for the next cluster when making track.
- * \li -trackletlength <i> number of clusters   </i> <br>
- *     the minimum number of clusters to be on a tracklet.
- * \li -tracklength <i> number of clusters   </i> <br>
- *     the minimum number of clusters to be on a track.
- * \li -clusterZ <i> cutoff in z-direction (cm)   </i> <br>
- *     makes the tracker to not read in Clusters with a higher value then the
- *     one given in both directions
- *
- * @ingroup alihlt_tpc_components
- */
-class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
-{
-public:
-  /** default constructor */
-  AliHLTTPCSliceTrackerComponent();
-  /** destructor */
-  virtual ~AliHLTTPCSliceTrackerComponent();
-
-  // Public functions to implement AliHLTComponent's interface.
-  // These functions are required for the registration process
-
-  /** interface function, see AliHLTComponent for description */
-  const char* GetComponentID();
-  /** interface function, see AliHLTComponent for description */
-  void GetInputDataTypes(AliHLTComponentDataTypeList& list);
-  /** interface function, see AliHLTComponent for description */
-  AliHLTComponentDataType GetOutputDataType();
-  /** interface function, see AliHLTComponent for description */
-  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
-  /** interface function, see AliHLTComponent for description */
-  AliHLTComponent* Spawn();
-
-protected:
-
-  /**
-   * Set Tracker parameters
-   * Knowledge on that has been lost, so somebody has to insert more
-   * documentation.
-   */  
-  void SetTrackerParam(Int_t phiSegments=50,Int_t etaSegments=100,
-                      Int_t trackletlength=3,Int_t tracklength=5,
-                      Int_t rowscopetracklet=2,Int_t rowscopetrack=3,
-                      Double_t minPtFit=0,Double_t maxangle=1.31,
-                      Double_t goodDist=5,Double_t hitChi2Cut=10,
-                      Double_t goodHitChi2=20,Double_t trackChi2Cut=50,
-                      Int_t maxdist=50,Double_t maxphi=0.1,Double_t maxeta=0.1);
-
-  /**
-   * Set Tracker parameters
-   * Knowledge on that has been lost, so somebody has to insert more
-   * documentation.
-   */
-  void SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity, 
-                       Double_t bField, Int_t etasegment, Double_t hitchi2cut, 
-                       Int_t rowscopetracklet, Int_t rowscopetrack, 
-                       Int_t trackletlength, Int_t tracklength );
-
-  /**
-   * Set default tracker parameters
-   * Knowledge on that has been lost, so somebody has to insert more
-   * documentation.
-   */
-  void SetTrackerParam1();
-
-  // Protected functions to implement AliHLTComponent's interface.
-  // These functions provide initialization as well as the actual processing
-  // capabilities of the component. 
-
-  /** interface function, see AliHLTComponent for description */
-  int DoInit( int argc, const char** argv );
-  /** interface function, see AliHLTComponent for description */
-  int DoDeinit();
-  /** interface function, see AliHLTComponent for description */
-  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-              AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-              AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks );
-
-  int Reconfigure(const char* cdbEntry, const char* chainId);
-  int ReadPreprocessorValues(const char* modules);
-  
-  using AliHLTProcessor::DoEvent;
-  
-private:
-  /** copy constructor prohibited */
-  AliHLTTPCSliceTrackerComponent(const AliHLTTPCSliceTrackerComponent&);
-  /** assignment operator prohibited */
-  AliHLTTPCSliceTrackerComponent& operator=(const AliHLTTPCSliceTrackerComponent&);
-  /**
-   * Configure the component.
-   * Parse a string for the configuration arguments and set the component
-   * properties.
-   */  
-  int Configure(const char* arguments);
-
-  /** instance of the tracker */
-  AliHLTTPCConfMapper* fTracker;                                   //! transient
-  /** vertex object */
-  AliHLTTPCVertex* fVertex;                                        //! transient
-  /** eta range */
-  Float_t fEta[2];                                                 //  see above
-  /** switch for subsequent non-vertex tracking */
-  Bool_t fDoNonVertex;                                             //  see above
-  /** */
-  Bool_t  fDoPP;                                                   //  see above
-   /** */
-  Bool_t  fDoPbPb;                                                 //  see above
-  /** multiplicity estimate */
-  Int_t fMultiplicity;                                             //  see above
-  /** magnetic field */
-  Double_t fBField;                                                //  see above
-
-  Bool_t fnonvertextracking;   // enable NONVERTEX Tracking
-  Bool_t fmainvertextracking;  // enable MAINVERTEX Tracking
-
-  /** ParameterVariables for the trackeparameters */
-
-
-  /** phi_segments:     Devide the space into phi_segments */
-  Int_t fPhisegment;              //! transient    
-  /** ets_segments:     Devide the space into eta_segments */
-  Int_t fEtasegment;              //! transient
-  /** trackletlength:   Number of hits a tracklet has to have */
-  Int_t fTrackletlength;          //! transient
-  /** tracklength:      Number of hits a track has to have */
-  Int_t fTracklength;             //! transient
-  /** rowscopetracklet: Search range of rows for a tracklet */
-  Int_t fRowscopetracklet;        //! transient
-  /** rowscopetrack:    Search range of rows for a track */
-  Int_t fRowscopetrack;           //! transient
-  /** min_pt_fit:       Cut for moment fit, use:SetMaxDca(min_pt_fit) */
-  Double_t fMinPtFit;             //! transient
-  /** maxangle:         AliHLTTPCTransform::Deg2Rad(10), max angle for the three point look aheand */
-  Double_t fMaxangle;             //! transient
-  /** goodDist:         Threshold distancs between two hits when building tracklets */
-  Double_t fGoodDist;             //! transient
-  /** hitChi2Cut:       Max chi2 of added hit to track */
-  Double_t fHitChi2Cut;           //! transient
-  /** goodHitChi2:      Stop looking for next hit to add if chi2 is less then goodHitChi2 */
-  Double_t fGoodHitChi2;          //! transient
-  /** trackChi2Cut:     Max chi2 for track after final fit */
-  Double_t fTrackChi2Cut;         //! transient
-  /** maxdist:          Maximum distance between two clusters when forming segments */
-  Int_t fMaxdist;                 //! transient
-  /** maxphi:           Max phi difference for neighboring hits */
-  Double_t fMaxphi;               //! transient
-  /** maxeta:           Max eta difference for neighboring hits */
-  Double_t fMaxeta;               //! transient 
-  /** merger object */
-  AliHLTTPCInterMerger *fpInterMerger;                             //! transient
-
-  ClassDef(AliHLTTPCSliceTrackerComponent, 0);
-
-};
-#endif
diff --git a/HLT/TPCLib/AliHLTTPCTrackMerger.cxx b/HLT/TPCLib/AliHLTTPCTrackMerger.cxx
deleted file mode 100644 (file)
index 2655c01..0000000
+++ /dev/null
@@ -1,324 +0,0 @@
-// $Id$
-// Original: AliHLTTrackMerger.cxx,v 1.12 2005/06/14 10:55:21 cvetan 
-
-//**************************************************************************
-//* This file is property of and copyright by the ALICE HLT Project        * 
-//* ALICE Experiment at CERN, All rights reserved.                         *
-//*                                                                        *
-//* Primary Authors: Uli Frankenfeld, maintained by                        *
-//*                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
-//*                  for The ALICE HLT Project.                            *
-//*                                                                        *
-//* Permission to use, copy, modify and distribute this software and its   *
-//* documentation strictly for non-commercial purposes is hereby granted   *
-//* without fee, provided that the above copyright notice appears in all   *
-//* copies and that both the copyright notice and this permission notice   *
-//* appear in the supporting documentation. The authors make no claims     *
-//* about the suitability of this software for any purpose. It is          *
-//* provided "as is" without express or implied warranty.                  *
-//**************************************************************************
-
-/// @file   AliHLTTPCTrackMerger.cxx
-/// @author Uli Frankenfeld, maintained by Matthias Richter
-/// @date   
-/// @brief  The HLT TPC track segment merger
-///
-
-#include "AliHLTTPCLogging.h"
-#include "AliHLTTPCTrackMerger.h"
-#include "AliHLTTPCTrack.h"
-#include "AliHLTTPCTrackSegmentData.h"
-#include "AliHLTTPCTransform.h"
-#include "AliHLTTPCTrackArray.h"
-
-#if __GNUC__ >= 3
-using namespace std;
-#endif
-
-ClassImp(AliHLTTPCTrackMerger)
-
-AliHLTTPCTrackMerger::AliHLTTPCTrackMerger() 
-  :
-  AliHLTTPCMerger(),
-  fSubSector(0),
-  fNSubSector(0),
-  fRowMin(NULL),
-  fRowMax(NULL),
-  fSlow(0)
-{
-  //Default constructor
-  Is2Global(kFALSE);
-  SetParameter();
-}
-
-
-AliHLTTPCTrackMerger::AliHLTTPCTrackMerger(Int_t nsubsectors) 
-  :
-  AliHLTTPCMerger(),
-  fSubSector(0),
-  fNSubSector(nsubsectors),
-  fRowMin(new Int_t[nsubsectors]),
-  fRowMax(new Int_t[nsubsectors]),
-  fSlow(0)
-{
-  //Constructor.
-  InitMerger(nsubsectors);
-  Is2Global(kFALSE);
-  fSlow = kFALSE;
-  SetParameter();
-}
-
-AliHLTTPCTrackMerger::~AliHLTTPCTrackMerger()
-{
-  //Destructor
-  if (fRowMin) delete[] fRowMin;
-  if (fRowMax) delete[] fRowMax;
-}
-
-void AliHLTTPCTrackMerger::SetRows(Int_t *row){
-  //Set the indeces of the first and last
-  //TPC padrows
-  //
-  for(Int_t i=0;i<fNSubSector;i++){
-    fRowMin[i]=*(row+(2*i));
-    fRowMax[i]=*(row+(2*i+1));
-  }
-}
-
-void AliHLTTPCTrackMerger::InitSector(Int_t slice,Int_t subsector){
-  // 
-  // Select Sector and subsector. The following FillTracks call will 
-  // fill this subsector
-  //
-  fSlice = slice;
-  fSubSector = subsector;
-  fCurrentTracks = fSubSector;
-}
-
-void AliHLTTPCTrackMerger::SlowMerge(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrackArray *tracksin,AliHLTTPCTrackArray *tracksout,Double_t xval){
-  // 
-  // Slow merging of two AliHLTTPCTrackArrays
-  // at reference plane x=xval
-  //
-  void *ntuple=GetNtuple();
-  const Int_t  kNOut=tracksout->GetNTracks();
-  const Int_t  kNIn =tracksin->GetNTracks();
-  const Int_t  kNMerged =mergedtrack->GetNTracks();
-  AliHLTTPCTrack *tracks[2];
-  Bool_t merge = kTRUE;
-  while(merge){
-    Int_t inmin=-1,outmin=-1;
-    Double_t min=10;
-    for(Int_t out=0;out<kNOut;out++){
-    AliHLTTPCTrack *outertrack=tracksout->GetCheckedTrack(out);
-    if(!outertrack) continue;
-      for(Int_t in=0;in<kNIn;in++){
-        AliHLTTPCTrack *innertrack=tracksin->GetCheckedTrack(in);
-        if(!innertrack) continue;
-        Double_t diff = TrackDiff(innertrack,outertrack);
-        if(diff>=0&&diff<min){
-          min=diff;
-          inmin=in;
-          outmin=out; 
-        }
-      } 
-    }
-    if(inmin>=0&&outmin>=0){
-      AliHLTTPCTrack *outertrack=tracksout->GetTrack(outmin);
-      AliHLTTPCTrack *innertrack=tracksin->GetTrack(inmin);
-      tracks[0]=innertrack;
-      tracks[1]=outertrack;
-      SortTracks(tracks,2);
-      MultiMerge(mergedtrack,tracks,2);
-      outertrack->CalculatePoint(xval);
-      innertrack->CalculatePoint(xval);
-      PrintDiff(innertrack,outertrack);
-      //FillNtuple(ntuple,innertrack,outertrack);
-      tracksout->Remove(outmin);
-      tracksin->Remove(inmin);
-//      tracksout->Compress();
-//      tracksin->Compress(); 
-    }
-    else merge = kFALSE;
-  }
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::SlowMerge","Result")
-  <<AliHLTTPCLog::kDec<<"Merged Tracks: "
-  <<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
-  const int namelen=256;
-  char name[namelen] = "ntuple_t.root";
-  for(Int_t i=0;i<4;i++)
-    if(tracksin==GetInTracks(i))
-      snprintf(name,namelen,"ntuple_t_%d.root",i);
-  WriteNtuple(name,ntuple);
-}
-
-void AliHLTTPCTrackMerger::SlowMerge(){
-  fSlow = kTRUE;
-  Merge();
-}
-
-void AliHLTTPCTrackMerger::InterMerge(){
-  // 
-  // Merging of the tracks
-  // between readout patches
-  //
-  for(Int_t patch=0;patch< GetNIn();patch++){
-    AliHLTTPCTrackArray * tracks = GetInTracks(patch);
-    Double_t xval = AliHLTTPCTransform::Row2X((fRowMax[patch]+fRowMin[patch])/2);
-    Int_t nrow= fRowMax[patch]-fRowMin[patch]+1;
-    const Int_t  kNIn =tracks->GetNTracks();
-    AliHLTTPCTrack *tr[2];
-    for(Int_t in=0;in<kNIn;in++){
-      AliHLTTPCTrack *t = tracks->GetCheckedTrack(in);
-      if(t){
-        t->CalculateHelix();
-        t->CalculatePoint(xval);
-      }
-    }
-    for(Int_t out=0;out<kNIn;out++){
-    AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
-    if(!outertrack) continue;
-      for(Int_t in=0;in<kNIn;in++){
-        if(in==out) continue;
-        AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
-        if(!innertrack) continue;
-        if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
-
-        if(IsTrack(innertrack,outertrack)){
-          tr[0]=innertrack;
-          tr[1]=outertrack;
-          SortTracks(tr,2);
-          if(tr[0]->GetLastPointX()<tr[1]->GetFirstPointX()){
-            MultiMerge(tracks,tr,2);
-            tracks->Remove(out);
-            tracks->Remove(in);
-            break;
-          }
-        }
-      }
-    }
-    Int_t nmerged = tracks->GetNTracks()-kNIn;
-    LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::InterMerge","Result")
-    <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
-  }
-}
-
-void AliHLTTPCTrackMerger::Merge(){
-  //Loop over tracks and pass them to the track merger.
-  Double_t edge0 = AliHLTTPCTransform::Pi()/18;
-  Double_t edge1 = AliHLTTPCTransform::TwoPi() - edge0;
-  AliHLTTPCTrackArray *ttt = GetOutTracks();
-  if(fNSubSector==1) {
-    GetOutTracks()->AddTracks(GetInTracks(0)); 
-    LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
-    <<AliHLTTPCLog::kDec<<"Total Copied Tracks: "<<GetOutTracks()->GetNPresent()
-    <<ENDLOG;
-    return;
-  }
-  Int_t subsec = fNSubSector -2; 
-  for(Int_t i=subsec;i>=0;i--){
-    AliHLTTPCTrackArray *tout = GetOutTracks();
-    if(i==subsec) tout = GetInTracks(subsec+1);
-    AliHLTTPCTrackArray *tin = GetInTracks(i);
-    Double_t xval = AliHLTTPCTransform::Row2X(fRowMax[i]);
-    Double_t xmax = AliHLTTPCTransform::Row2X(fRowMax[i+1]);
-    Double_t ymax = xval*tan(edge0);
-    for(Int_t out=0;out<tout->GetNTracks();out++){
-      AliHLTTPCTrack *outtrack=tout->GetCheckedTrack(out);
-      if(!outtrack) continue;
-      outtrack->CalculateHelix();
-      outtrack->CalculatePoint(xval);
-      if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
-        if(outtrack->GetNHits()<10)
-          tout->Remove(out);
-      }
-    }
-//    tout->Compress();
-    for(Int_t in=0;in<tin->GetNTracks();in++){
-      AliHLTTPCTrack *intrack=(AliHLTTPCTrack*)tin->GetTrack(in);
-      intrack->CalculateHelix();
-      intrack->CalculatePoint(xval);
-    }
-    tin->QSort();
-    tout->QSort();
-
-    if(fSlow) SlowMerge(ttt,tin,tout,xval);
-    else Merge(ttt,tin,tout);
-    for(Int_t in=0;in<tin->GetNTracks();in++){
-      AliHLTTPCTrack *intrack=(AliHLTTPCTrack*)tin->GetCheckedTrack(in);
-      if(!intrack) continue;
-      if(intrack->CalculateEdgePoint(edge0)){
-        if(intrack->GetPointX()<xmax ){
-          AddTrack(ttt,intrack);
-          tin->Remove(in);
-        }
-      } 
-      else if(intrack->CalculateEdgePoint(edge1)){
-        if(intrack->GetPointX()<xmax ){
-          AddTrack(ttt,intrack);
-          tin->Remove(in);
-        }
-      }
-    }
-/*
-    for(Int_t in=0;in<tin->GetNTracks();in++){
-      AliHLTTPCTrack *intrack=(AliHLTTPCTrack*)tin->GetCheckedTrack(in);
-      if(!intrack) continue;
-      if(intrack->GetNHits()<10) continue;
-      AddTrack(ttt,intrack);
-      tin->Remove(in);
-    }
-*/
-  } // end subsector loop
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
-  <<AliHLTTPCLog::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
-  <<ENDLOG;
-}
-
-Int_t AliHLTTPCTrackMerger::Merge(AliHLTTPCTrackArray* mergedtrack,AliHLTTPCTrackArray *tracksin,AliHLTTPCTrackArray *tracksout){
-  //Loop over tracks and pass them to the track merger.
-  AliHLTTPCTrack *tracks[2];
-
-  const Int_t  kNOut=tracksout->GetNTracks();
-  const Int_t  kNIn =tracksin->GetNTracks();
-  const Int_t  kNMerged =mergedtrack->GetNTracks();
-
-  Bool_t *ismatchedin  = new Bool_t[kNIn];
-  for(Int_t in =0;in<kNIn;in++)
-    ismatchedin[in]=kFALSE;
-  Bool_t *ismatchedout = new Bool_t[kNOut];
-  for(Int_t out =0;out<kNOut;out++)
-    ismatchedout[out] = kFALSE;
-  for(Int_t out =0;out<kNOut;out++){
-    AliHLTTPCTrack *outertrack=(AliHLTTPCTrack*)tracksout->GetCheckedTrack(out);
-    if(!outertrack) continue;
-    for(Int_t in =0;in<kNIn;in++){
-      if(ismatchedin[in]) continue;
-      AliHLTTPCTrack *innertrack=(AliHLTTPCTrack*)tracksin->GetCheckedTrack(in);
-      if(!innertrack) continue;
-      if(outertrack==innertrack) continue;
-      if(outertrack->GetCharge()!=innertrack->GetCharge()) continue;
-      if(IsTrack(innertrack,outertrack)){
-        tracks[0]=innertrack; tracks[1]=outertrack; 
-        SortTracks(tracks,2);  
-        if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
-          MultiMerge(mergedtrack,tracks,2);
-          tracksout->Remove(out);
-          tracksin->Remove(in);
-          ismatchedin[in]=kTRUE;
-          ismatchedout[out]=kTRUE;
-          break;
-        }
-      }
-    }
-  }
-
-  Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
-  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
-  <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
-  delete[] ismatchedin;
-  delete[] ismatchedout;
-  return nmerged;
-}
-
-
diff --git a/HLT/TPCLib/AliHLTTPCTrackMerger.h b/HLT/TPCLib/AliHLTTPCTrackMerger.h
deleted file mode 100644 (file)
index 1e6567d..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// @(#) $Id$
-// Original: AliHLTTrackMerger.h,v 1.6 2005/04/19 04:29:01 cvetan 
-#ifndef ALIHLTTPCTRACKMERGER_H
-#define ALIHLTTPCTRACKMERGER_H
-
-//* 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                               *
-
-/** @file   AliHLTTPCTrackMerger.h
-    @author Uli Frankenfeld, maintained by Matthias Richter
-    @date   
-    @brief  The HLT TPC track segment merger
-*/
-
-#ifndef __CINT__ 
-#include "AliHLTTPCMerger.h"
-#endif
-
-#include "AliHLTTPCRootTypes.h"
-
-class AliHLTTPCMerger;
-
-/** 
- * @class AliHLTTPCTrackMerger
- * The HLTTPC track segment merger
- *
- *   This class is responsible for the merging of the HLT tracks
- *   between TPC sectors and readout patches
- *
- * @ingroup alihlt_tpc
- */
-class AliHLTTPCTrackMerger : public AliHLTTPCMerger {
-
- public:
-  AliHLTTPCTrackMerger();
-  AliHLTTPCTrackMerger(Int_t nsubsectors);
-  /** destructor */
-  virtual ~AliHLTTPCTrackMerger();
-
-  void SetRows(Int_t *row);
-  void InitSector(Int_t sector,Int_t subsector);
-  void SlowMerge();
-  void Merge();  //Loop over tracks from different subsectors
-  void InterMerge();
-
- private:
-  /** copy constructor prohibited */
-  AliHLTTPCTrackMerger(const AliHLTTPCTrackMerger&);
-  /** assignment operator prohibited */
-  AliHLTTPCTrackMerger& operator=(const AliHLTTPCTrackMerger&);
-
-  Int_t fSubSector;//Index of the readout patch inside given TPC sector
-  Int_t fNSubSector;//Number of readout patches inside given TPC sector
-  Int_t *fRowMin;//!
-  Int_t *fRowMax;//!
-  Bool_t fSlow;//Slow or fast merging
-  void SlowMerge(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrackArray *tracksin,AliHLTTPCTrackArray *tracksout,Double_t xval);
-  Int_t Merge(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrackArray *tracksin,AliHLTTPCTrackArray *tracksout);
-  
-  ClassDef(AliHLTTPCTrackMerger,0) //Track merging class 
-};
-
-#endif