ROOT logo
//-*- Mode: C++ -*-
// **************************************************************************
// This file is property of and copyright by the ALICE ITSU Project         *
// ALICE Experiment at CERN, All rights reserved.                           *
//                                                                          *
// Primary Author: Maximiliano Puccio <maximiliano.puccio@cern.ch>          *
//                 for the ITS Upgrade project                              *
//                                                                          *
// Permission to use, copy, modify and distribute this software and its     *
// documentation strictly for non-commercial purposes is hereby granted     *
// without fee, provided that the above copyright notice appears in all     *
// copies and that both the copyright notice and this permission notice     *
// appear in the supporting documentation. The authors make no claims       *
// about the suitability of this software for any purpose. It is            *
// provided "as is" without express or implied warranty.                    *
//                                                                          *
//***************************************************************************

#include "AliITSUCATracker.h"

// STD
#include <algorithm>
#include <cassert>
// ROOT
#include <TBranch.h>
#include <TMath.h>
#include <TTree.h>
#include <Riostream.h>
// ALIROOT
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliLog.h"
// ALIROOT ITSU
#include "AliITSUAux.h"
#include "AliITSUClusterPix.h"
#include "AliITSURecoDet.h"
#include "AliITSUReconstructor.h"
#include "AliITSUTrackCooked.h"

using TMath::Abs;
using TMath::Sort;
using TMath::Sqrt;
using std::sort;
using std::cout;
using std::endl;
using std::flush;

ClassImp(AliITSUCATracker)


// tolerance for layer on-surface check
const Double_t AliITSUCATracker::fgkChi2Cut =  600.f;
const int AliITSUCATracker::fgkNumberOfIterations =  2;
const float AliITSUCATracker::fgkR[7] = {2.33959,3.14076,3.91924,19.6213,24.5597,34.388,39.3329};
//
const float kmaxDCAxy[5] = {0.05f,0.04f,0.05f,0.2f,0.4f};
const float kmaxDCAz[5] = {0.2f,0.4f,0.5f,0.6f,3.f};
const float kmaxDN[4] = {0.002f,0.009f,0.002f,0.005f};
const float kmaxDP[4] = {0.008f,0.0025f,0.003f,0.0035f};
const float kmaxDZ[6] = {0.1f,0.1f,0.3f,0.3f,0.3f,0.3f};
const float kDoublTanL = 0.025;
const float kDoublPhi = 0.14;

const float kmaxDCAxy1[5] = /*{1.f,0.5,0.5,1.7,3.};/*/{1.f,0.4f,0.4f,1.5f,3.f};
const float kmaxDCAz1[5] = /*{2.f,0.8,0.8,3.,5.};/*/{1.f,0.4f,0.4f,1.5f,3.f};
const float kmaxDN1[4] = /*{0.006f,0.0045f,0.01f,0.04f};/*/{0.005f,0.0035f,0.009f,0.03f};
const float kmaxDP1[4] = /*{0.04f,0.01f,0.012f,0.014f};/*/{0.02f,0.005f,0.006f,0.007f};
const float kmaxDZ1[6] = /*{1.5f,1.5f,2.f,2.f,2.f,2.f};/*/{1.f,1.f,1.5f,1.5f,1.5f,1.5f};
const float kDoublTanL1 = /*0.12f;/*/0.05f;
const float kDoublPhi1 = /*0.4f;/*/0.2f;

//__________________________________________________________________________________________________
static inline float invsqrt(float _x)
{
  //
  // The function calculates fast inverse sqrt. Google for 0x5f3759df.
  // Credits to ALICE HLT Project
  //

  union { float f; int i; } x = { _x };
  const float xhalf = 0.5f * x.f;
  x.i = 0x5f3759df - ( x.i >> 1 );
  x.f = x.f * ( 1.5f - xhalf * x.f * x.f );
  return x.f;
}

//__________________________________________________________________________________________________
static inline float Curvature(float x1, float y1, float x2, float y2, float x3, float y3)
{
  //
  // Initial approximation of the track curvature
  //
//  return - 2.f * ((x2 - x1) * (y3 - y2) - (x3 - x2) * (y2 - y1))
//               * invsqrt(((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) *
//                         ((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3)) *
//                         ((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1)));
  
  //calculates the curvature of track
  float den = (x3 - x1) * (y2 - y1) - (x2 - x1) * (y3 - y1);
  if(den * den < 1e-32) return 0.f;
  float a = ((y3-y1)*(x2*x2+y2*y2-x1*x1-y1*y1)-(y2-y1)*(x3*x3+y3*y3-x1*x1-y1*y1))/den;
  if((y2 - y1) * (y2 - y1) < 1e-32) return 0.f;
  float b = -(x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1 + a * (x2 - x1)) / (y2 - y1);
  float c = -x1 * x1 - y1 * y1 - a * x1 - b * y1;
  float xc = -a / 2.f;
  
  if((a * a + b * b - 4 * c) < 0) return 0.f;
  float rad = TMath::Sqrt(a * a + b * b - 4 * c) / 2.f;
  if(rad * rad < 1e-32) return 1e16;
  
  if((x1 > 0.f && y1 > 0.f && x1 < xc)) rad *= -1.f;
  if((x1 < 0.f && y1 > 0.f && x1 < xc)) rad *= -1.f;
  //  if((x1<0 && y1<0 && x1<xc)) rad*=-1;
  // if((x1>0 && y1<0 && x1<xc)) rad*=-1;
  
  return 1.f/rad;

}

//__________________________________________________________________________________________________
static inline float TanLambda(float x1, float y1, float x2, float y2, float z1, float z2)
{
  //
  // Initial approximation of the tangent of the track dip angle
  //
  return (z1 - z2) * invsqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

//__________________________________________________________________________________________________
//static inline float XCenterOfCurvature(float x1, float y1, float x2, float y2, float x3, float y3)
//{
//    //
//    // Initial approximation of the x-coordinate of the center of curvature
//    //
//
//  const float k1 = (y2 - y1) / (x2 - x1), k2 = (y3 - y2) / (x3 - x2);
//  return TMath::Abs(k2 - k1) > kAlmost0 ?
//    0.5f * (k1 * k2 * (y1 - y3) + k2 * (x1 + x2) - k1 * (x2 + x3)) / (k2 - k1) : 1e12f;
//}

//__________________________________________________________________________________________________
static inline bool CompareAngles(float alpha, float beta, float tolerance)
{
	const float delta = TMath::Abs(alpha - beta);
	return (delta < tolerance || TMath::Abs(delta - TMath::TwoPi()) < tolerance);
}

//__________________________________________________________________________________________________
AliITSUCATracker::AliITSUCATracker(AliITSUReconstructor* rec) : AliITSUTrackerGlo(rec)
#ifdef _TUNING_
,fGood(0)
,fTan(NULL)
,fTanF(NULL)
,fPhi(NULL)
,fPhiF(NULL)
,fNEntries(NULL)
#endif
,fLayer()
,fUsedClusters()
,fChi2Cut(fgkChi2Cut)
,fPhiCut(1)
,fZCut(0.5f)
,fCandidates()
,fSAonly(kTRUE)
,fCPhi()
,fCDTanL()
,fCDPhi()
,fCZ()
,fCDCAz()
,fCDCAxy()
,fCDN()
,fCDP()
,fCDZ()
{
  // This default constructor needs to be provided
  for (int i = 0; i < 4; ++i)
  {
    fCandidates[i] = new TClonesArray("AliITSUTrackCooked",100000);
  }

#ifdef _TUNING_
  for (int i = 0; i < 6; ++i)
  {
    fGDZ[i] = new TH1F(Form("DGZ%i",i),Form("DZ%i;#Deltaz;Entries",i),500,0.f,5.f);
    fGDXY[i] = new TH1F(Form("DGPhi%i",i),Form("#Delta#Phi%i;#DeltaPhi;Entries",i),500,0.f,TMath::TwoPi());
    fFDZ[i] = new TH1F(Form("DFZ%i",i),Form("DZ%i;#Deltaz;Entries",i),500,0.f,5.f);
    fFDXY[i] = new TH1F(Form("DFPhi%i",i),Form("#Delta#Phi%i;#Delta#Phi;Entries",i),500,0.f,TMath::TwoPi());
  }
  for (int i = 0; i < 5; ++i)
  {
    fGDCAZ[i] = new TH1F(Form("DCAGZ%i",i),Form("DCAZ%i;#Deltaz;Entries",i),500,0.f,5.f);
    fGDCAXY[i] = new TH1F(Form("DCAGXY%i",i),Form("DCAXY%i;#Deltar;Entries",i),500,0.f,5.f);
    fFDCAZ[i] = new TH1F(Form("DCAFZ%i",i),Form("DCAZ%i;#Deltaz;Entries",i),500,0.f,5.f);
    fFDCAXY[i] = new TH1F(Form("DCAFXY%i",i),Form("DCAXY%i;#Deltar;Entries",i),500,0.f,5.f);
  }
  for(int i = 0; i < 4; ++i)
  {
    fGoodCombChi2[i] = new TH1F(Form("goodcombchi2%i",i),Form("%i;#chi^{2};Entries",i),2000,0,0.1);
    fFakeCombChi2[i] = new TH1F(Form("fakecombchi2%i",i),Form("%i;#chi^{2};Entries",i),2000,0,0.1);
    fGoodCombN[i] = new TH1F(Form("goodcombn%i",i),Form("%i;#Deltan;Entries",i),300,0.f,0.03f);
    fFakeCombN[i] = new TH1F(Form("fakecombn%i",i),Form("%i;#Deltan;Entries",i),300,0.f,0.03f);
  }
  fGoodCombChi2[4] = new TH1F("goodcomb4",";#chi^{2};Entries",200,0,500);
  fFakeCombChi2[4] = new TH1F("fakecomb4",";#chi^{2};Entries",200,0,500);
  fTan = new TH1F("tan","tan",2500,0,0.5);
  fTanF = new TH1F("tanF","tanF",2500,0,0.5);
  fPhi = new TH1F("phi","phi",2500,0,TMath::Pi());
  fPhiF = new TH1F("phi","phiF",2500,0,TMath::Pi());
  fNEntries = new TH1F("nentries","nentries",2001,-0.5,2000.5);
#endif
}

//__________________________________________________________________________________________________
AliITSUCATracker::~AliITSUCATracker()
{
  // d-tor
   for (int i = 0; i < 4; ++i)
  {
    if (fCandidates[i])
      delete fCandidates[i];
  }
//#ifdef _TUNING_
//  // Just cut and paste from the constructor
//  for (int i = 0; i < 6; ++i)
//  {
//    delete fGDZ[i];
//    delete fGDXY[i];
//    delete fFDZ[i];
//    delete fFDXY[i];
//  }
//  for (int i = 0; i < 5; ++i)
//  {
//    delete fGDCAZ[i]; 
//    delete fGDCAXY[i];
//    delete fFDCAZ[i]; 
//    delete fFDCAXY[i];
//  }
//  for(int i = 0; i < 4; ++i)
//  {
//    delete fGoodCombChi2[i];
//    delete fFakeCombChi2[i];
//    delete fGoodCombN[i];
//    delete fFakeCombN[i];
//  }
//  delete fGoodCombChi2[4];
//  delete fFakeCombChi2[4];
//  delete fTan; 
//  delete fTanF;
//  delete fPhi; 
//  delete fPhiF;
//  delete fNEntries;
//#endif
}

//__________________________________________________________________________________________________
bool AliITSUCATracker::CellParams(int l, ClsInfo_t* c1, ClsInfo_t* c2, ClsInfo_t* c3,
                                  float &curv, float n[3])
{
  // Calculation of cell params and filtering using a DCA cut wrt beam line position.
  // The hit are mapped on a paraboloid space: there a circle is described as plane.
  // The parameter n of the cells is the normal vector to the plane describing the circle in the
  // paraboloid.
  
  // Mapping the hits
  const float mHit0[3] = {c1->x, c1->y, c1->r * c1->r};
  const float mHit1[3] = {c2->x, c2->y, c2->r * c2->r};
  const float mHit2[3] = {c3->x, c3->y, c3->r * c3->r};
  // Computing the deltas
  const float mD10[3] = {mHit1[0] - mHit0[0],mHit1[1] - mHit0[1],mHit1[2] - mHit0[2]};
  const float mD20[3] = {mHit2[0] - mHit0[0],mHit2[1] - mHit0[1],mHit2[2] - mHit0[2]};
  // External product of the deltas -> n
  n[0] = (mD10[1] * mD20[2]) - (mD10[2] * mD20[1]);
  n[1] = (mD10[2] * mD20[0]) - (mD10[0] * mD20[2]);
  n[2] = (mD10[0] * mD20[1]) - (mD10[1] * mD20[0]);
  // Normalisation
  const float norm = TMath::Sqrt((n[0] * n[0]) + (n[1] * n[1]) + (n[2] * n[2]));
  if (norm < 1e-20f || fabs(n[2]) < 1e-20f)
    return false;
  n[0] /= norm;
  n[1] /= norm;
  n[2] /= norm;
  // Center of the circle
  const float c[2] = {-0.5f * n[0] / n[2], -0.5f * n[1] / n[2]};
  // Constant
  const float k = - n[0] * mHit1[0] - n[1] * mHit1[1] - n[2] * mHit1[2];
  // Radius of the circle
  curv = TMath::Sqrt((1.f - n[2] * n[2] - 4.f * k * n[2]) / (4.f * n[2] * n[2]));
  // Distance of closest approach to the beam line
  const float dca = fabs(curv - sqrt(c[0] * c[0] + c[1] * c[1]));
  // Cut on the DCA
  if (dca > fCDCAxy[l]) {
    return false;
  }
#ifdef _TUNING_
  if (fGood) {
    fGDCAXY[l]->Fill(dca);
  } else {
    fFDCAXY[l]->Fill(dca);
  }
#endif
  
  curv = 1.f / curv;
  return true;
}

//__________________________________________________________________________________________________
void AliITSUCATracker::CellsTreeTraversal(vector<AliITSUCARoad> &roads,
                                          const int &iD, const int &doubl)
{
  
  // Each cells contains a list of neighbours. Each neighbour has presumably other neighbours.
  // This chain of neighbours is, as a matter of fact, a tree and this function goes recursively
  // through it. This function implements a depth first tree browsing.
  
  // End of the road
  if (doubl < 0) return;
  
  // [1] add current cell to current cell
  roads.back().AddElement(doubl,iD);
  // We want the right number of elements in the roads also in the case of multiple neighbours
  const int currentN = roads.back().N;
  
  // [2] loop on the neighbours of the current cell
  for (size_t iN = 0; iN < fCells[doubl][iD].NumberOfNeighbours(); ++iN)
  {
    const int currD = doubl - 1;
    const int neigh = fCells[doubl][iD](iN);
    
    // [3] for each neighbour one road
    if (iN > 0)
    {
      roads.push_back(roads.back());
      roads.back().N = currentN;
    }
    // [4] play this game again until the end of the road
    CellsTreeTraversal(roads,neigh,currD);
  }
  
  fCells[doubl][iD].SetLevel(0u); // Level = -1
}

//__________________________________________________________________________________________________
Int_t AliITSUCATracker::Clusters2Tracks(AliESDEvent *event)
{
  // This is the main tracking function
  // The clusters must already be loaded
  
  if (!fSAonly) {
    AliITSUTrackerGlo::Clusters2Tracks(event);
    for (int iL = 0; iL < 7; ++iL) {
      for (int iC = 0; iC < fLayer[iL].GetNClusters(); ++iC)
        if (fLayer[iL].GetClusterUnSorted(iC)->IsClusterUsed())
          fUsedClusters[iL][iC] = true;
    }
  }

  int ntrk = 0, ngood = 0;
  for (int iteration = 0; iteration < fgkNumberOfIterations; ++iteration)
  {
    
    fCandidates[0]->Clear();
    fCandidates[1]->Clear();
    fCandidates[2]->Clear();
    fCandidates[3]->Clear();
    
    MakeCells(iteration);
    FindTracksCA(iteration);
    
    for (int iL = 3; iL >= 0; --iL)
    {
      const int nCand = fCandidates[iL]->GetEntries();
      int index[nCand];
      float chi2[nCand];
      
      for (int iC = 0; iC < nCand; ++iC)
      {
        AliITSUTrackCooked *tr = (AliITSUTrackCooked*)fCandidates[iL]->At(iC);
        chi2[iC] = tr->GetChi2();//(RefitTrack(tr,clInfo,0.,-1));
        index[iC] = iC;
        CookLabel(tr,0.f);
      }
      
      TMath::Sort(nCand,chi2,index,false);
      
      for (int iUC = 0; iUC < nCand; ++iUC)
      {
        const int iC = index[iUC];
        if (chi2[iC] < 0.f)
        {
          continue;
        }
        
        AliITSUTrackCooked *tr = (AliITSUTrackCooked*)fCandidates[iL]->At(iC);
        
        bool sharingCluster = false;
        for (int k = 0; k < tr->GetNumberOfClusters(); ++k)
        {
          const int layer = (tr->GetClusterIndex(k) & 0xf0000000) >> 28;
          const int idx = (tr->GetClusterIndex(k) & 0x0fffffff);
          if (fUsedClusters[layer][idx])
          {
            sharingCluster = true;
            break;
          }
        }
        
        if (sharingCluster)
          continue;
        
        for (int k = 0; k < tr->GetNumberOfClusters(); ++k)
        {
          const int layer = (tr->GetClusterIndex(k) & 0xf0000000) >> 28;
          const int idx = (tr->GetClusterIndex(k) & 0x0fffffff);
          fUsedClusters[layer][idx] = true;
        }
        
        AliESDtrack outTrack;
        CookLabel(tr,0.f);
        ntrk++;
        if(tr->GetLabel() >= 0)
        {
          ngood++;
#ifdef _TUNING_
          fGoodCombChi2[4]->Fill(chi2[iC] / (4 + iL));
        }
        else
        {
          fFakeCombChi2[4]->Fill(chi2[iC] / (4 + iL));
#endif
        }
        
        outTrack.UpdateTrackParams(tr,AliESDtrack::kITSin);
        outTrack.SetLabel(tr->GetLabel());
        event->AddTrack(&outTrack);
      }
    }
  }
  Info("Clusters2Tracks","Reconstructed tracks: %d",ntrk);
  if (ntrk)
    Info("Clusters2Tracks","Good tracks/reconstructed: %f",Float_t(ngood)/ntrk);
  //
  return 0;
}

//__________________________________________________________________________________________________
void AliITSUCATracker::FindTracksCA(int iteration)
{
  // Main pattern recognition routine. It has 4 steps (planning to split in different methods)
  // 1. Tracklet finding (using vertex position)
  // 2. Tracklet association, cells building
  // 3. Handshake between neighbour cells
  // 4. Candidates ("roads") finding and fitting
  
  // Road finding and fitting. The routine starts from cells with level 5 since they are the head
  // of a full road (candidate with 7 points). Minimum level is 2, so candidates at the end have
  // at least 4 points.
  const int itLevelLimit[3] = {4, 4, 1};
  for (int level = 5; level > itLevelLimit[iteration]; --level) {
    vector<AliITSUCARoad> roads;
    // Road finding. For each cell at level $(level) a loop on their neighbours to start building
    // the roads.
    for (int iCL = 4; iCL >= level - 1; --iCL) {
      for (size_t iCell = 0; iCell < fCells[iCL].size(); ++iCell) {
        if (fCells[iCL][iCell].GetLevel() != level)
        {
          continue;
        }
        // [1] Add current cell to road
        roads.push_back(AliITSUCARoad(iCL,iCell));
        // [2] Loop on current cell neighbours
        for(size_t iN = 0; iN < fCells[iCL][iCell].NumberOfNeighbours(); ++iN) {
          const int currD = iCL - 1;
          const int neigh = fCells[iCL][iCell](iN);
          // [3] if more than one neighbour => more than one road, one road for each neighbour
          if(iN > 0)
          {
            roads.push_back(AliITSUCARoad(iCL,iCell));
          }
          // [4] Essentially the neighbour became the current cell and then go to [1]
          CellsTreeTraversal(roads,neigh,currD);
        }
        fCells[iCL][iCell].SetLevel(0u); // Level = -1
      }
    }
    
    // Roads fitting
    for (size_t iR = 0; iR < roads.size(); ++iR)
    {
      if (roads[iR].N != level)
        continue;
      AliITSUTrackCooked tr;
      int first = -1,last = -1;
      ClsInfo_t *cl0 = 0x0,*cl1 = 0x0,*cl2 = 0x0;
      for(int i = 0; i < 5; ++i)
      {
        if (roads[iR][i] < 0)
          continue;
        
        if (first < 0)
        {
          cl0 = fLayer[i][fCells[i][roads[iR][i]].x()];
          tr.SetClusterIndex(i,fLayer[i][fCells[i][roads[iR][i]].x()]->index);
          tr.SetClusterIndex(i + 1,fLayer[i + 1][fCells[i][roads[iR][i]].y()]->index);
          first = i;
        }
        tr.SetClusterIndex(i + 2,fLayer[i + 2][fCells[i][roads[iR][i]].z()]->index);
        last = i;
      }
      AliITSUClusterPix* c = fLayer[last + 2].GetClusterSorted(fCells[last][roads[iR][last]].z());
      cl2 = fLayer[last + 2][fCells[last][roads[iR][last]].z()];
      first = (last + first) / 2;
      cl1 = fLayer[first + 1][fCells[first][roads[iR][first]].y()];
      // Init track parameters
      double cv = Curvature(cl0->x,cl0->y,cl1->x,cl1->y,cl2->x,cl2->y);
      double tgl = TanLambda(cl0->x,cl0->y,cl2->x,cl2->y,cl0->z,cl2->z);
      
      AliITSUCATrackingStation::ITSDetInfo_t det = fLayer[last + 2].GetDetInfo(cl2->detid);
      double x = det.xTF + c->GetX(); // I'd like to avoit using AliITSUClusterPix...
      double alp = det.phiTF;
      double par[5] = {c->GetY(),c->GetZ(),0,tgl,cv};
      double cov[15] = {
        5*5,
        0,  5*5,
        0,  0  , 0.7*0.7,
        0,  0,   0,       0.7*0.7,
        0,  0,   0,       0,       10
      };
      tr.Set(x,alp,par,cov);
      AliITSUTrackCooked tt(tr);
      tt.ResetClusters();
      if (RefitAt(2.1, &tt, &tr))
        new((*fCandidates[level - 2])[fCandidates[level - 2]->GetEntriesFast()]) AliITSUTrackCooked(tt);
    }
  }
}

//__________________________________________________________________________________________________
inline AliCluster* AliITSUCATracker::GetCluster(Int_t index) const
{
	const Int_t l=(index & 0xf0000000) >> 28;
	const Int_t c=(index & 0x0fffffff);
	return (AliCluster*)fLayer[l].GetClusterUnSorted(c) ;
}

//__________________________________________________________________________________________________
Double_t AliITSUCATracker::GetMaterialBudget(const double* pnt0,const double* pnt1, double& x2x0,
	                                           double& rhol) const
{
  double par[7];
  if (fUseMatLUT && fMatLUT) {
    double d = fMatLUT->GetMatBudget(pnt0,pnt1,par);
    x2x0 = par[AliITSUMatLUT::kParX2X0];
    rhol = par[AliITSUMatLUT::kParRhoL];
    return d;
  }
  else {
    MeanMaterialBudget(pnt0,pnt1,par);
    x2x0 = par[1];
    rhol = par[0]*par[4];
    return par[4];
  }
}

//__________________________________________________________________________________________________
Int_t AliITSUCATracker::LoadClusters(TTree *cluTree)
{
  // This function reads the ITSU clusters from the tree,
  // sort them, distribute over the internal tracker arrays, etc
  
  AliITSUTrackerGlo::LoadClusters(cluTree); // === fITS->LoadClusters(cluTree);
  if (fSAonly) fITS->ProcessClusters();

  // I consider a single vertex event for the moment.
  //TODO: pile-up (trivial here), fast reco of primary vertices (not so trivial)
  double vertex[3] = {GetX(),GetY(),GetZ()};
  for (int iL = 0; iL < 7; ++iL) {
    fLayer[iL].Init(fITS->GetLayerActive(iL),fITS->GetGeom());
    AliVertex v(vertex,1,1);
    fLayer[iL].SortClusters(&v);
    fUsedClusters[iL].resize(fLayer[iL].GetNClusters(),false);
  }
  return 0;
}

//__________________________________________________________________________________________________
void AliITSUCATracker::MakeCells(int iteration)
{
#ifdef _TUNING_
  unsigned int numberOfGoodDoublets = 0, totalNumberOfDoublets = 0;
  unsigned int numberOfGoodCells = 0, totalNumberOfCells = 0;
  unsigned int cellsCombiningSuccesses = 0, cellsWrongCombinations = 0;
#endif
  
  SetCuts(iteration);
  if (iteration >= 1) {
#ifdef _TUNING_
    ResetHistos();
#endif
    for (int i = 0; i < 5; ++i)
      fCells[i].clear();
    for (int i = 0; i < 6; ++i)
      fDoublets[i].clear();
  }
  
  // Trick to speed up the navigation of the doublets array. The lookup table is build like:
  // dLUT[l][i] = n;
  // where n is the index inside fDoublets[l+1] of the first doublets that uses the point
  // fLayer[l+1][i]
  vector<int> dLUT[5];
  for (int iL = 0; iL < 6; ++iL) {
    if (iL < 5) {
      dLUT[iL].resize(fLayer[iL + 1].GetNClusters(),-1);
    }
    for (int iC = 0; iC < fLayer[iL].GetNClusters(); ++iC) {
      ClsInfo_t* cls = fLayer[iL].GetClusterInfo(iC);
      if (fUsedClusters[iL][cls->index]) {
        continue;
      }
      const float tanL = (cls->z - GetZ()) / cls->r;
      const float extz = tanL * (fgkR[iL + 1] - cls->r) + cls->z;
      const int nClust = fLayer[iL + 1].SelectClusters(extz - 2 * fCZ, extz + 2 * fCZ,
                                                       cls->phi - fCPhi, cls->phi + fCPhi);
      bool first = true;
      
      for (int iC2 = 0; iC2 < nClust; ++iC2) {
        const int iD2 = fLayer[iL + 1].GetNextClusterInfoID();
        ClsInfo_t* cls2 = fLayer[iL + 1].GetClusterInfo(iD2);
        if (fUsedClusters[iL + 1][cls2->index]) {
          continue;
        }
        const float dz = tanL * (cls2->r - cls->r) + cls->z - cls2->z;
        if (TMath::Abs(dz) < fCDZ[iL] && CompareAngles(cls->phi, cls2->phi, fCPhi)) {
          if (first && iL > 0) {
            dLUT[iL - 1][iC] = fDoublets[iL].size();
            first = false;
          }
          const float dTanL = (cls->z - cls2->z) / (cls->r - cls2->r);
          const float phi = TMath::ATan2(cls->y - cls2->y, cls->x - cls2->x);
          fDoublets[iL].push_back(Doublets(iC,iD2,dTanL,phi));
#ifdef _TUNING_
          if (fLayer[iL].GetClusterSorted(iC)->GetLabel(0) ==
              fLayer[iL + 1].GetClusterSorted(iD2)->GetLabel(0) &&
              fLayer[iL].GetClusterSorted(iC)->GetLabel(0) > 0) {
            numberOfGoodDoublets++;
            fGDZ[iL]->Fill(dz);
            fGDXY[iL]->Fill(fabs(cls->phi - cls2->phi));
          } else {
            fFDZ[iL]->Fill(dz);
            fFDXY[iL]->Fill(fabs(cls->phi - cls2->phi));
          }
          totalNumberOfDoublets++;
#endif
        }
      }
      fLayer[iL + 1].ResetFoundIterator();
    }
  }
  
  // Trick to speed up the navigation of the cells array. The lookup table is build like:
  // tLUT[l][i] = n;
  // where n is the index inside fCells[l+1] of the first cells that uses the doublet
  // fDoublets[l+1][i]
  vector<int> tLUT[4];
  for (int iD = 0; iD < 5; ++iD)
  {
    if (iD < 4) {
      tLUT[iD].resize(fDoublets[iD + 1].size(),0);
    }
    for (size_t iD0 = 0; iD0 < fDoublets[iD].size(); ++iD0)
    {
      const int idx = fDoublets[iD][iD0].y;
      bool first = true;
      if (dLUT[iD][idx] == -1) continue;
      for (size_t iD1 = dLUT[iD][idx]; idx == fDoublets[iD + 1][iD1].x;++iD1)
      {
        if (TMath::Abs(fDoublets[iD][iD0].tanL - fDoublets[iD + 1][iD1].tanL) < fCDTanL &&
            TMath::Abs(fDoublets[iD][iD0].phi - fDoublets[iD + 1][iD1].phi) < fCDPhi) {
          const float tan = 0.5f * (fDoublets[iD][iD0].tanL + fDoublets[iD + 1][iD1].tanL);
          const float extz = -tan * fLayer[iD][fDoublets[iD][iD0].x]->r +
                              fLayer[iD][fDoublets[iD][iD0].x]->z;
          if (fabs(extz - GetZ()) < fCDCAz[iD]) {
#ifdef _TUNING_
            fGood = (fLayer[iD].GetClusterSorted(fDoublets[iD][iD0].x)->GetLabel(0) ==
                     fLayer[iD + 1].GetClusterSorted(fDoublets[iD][iD0].y)->GetLabel(0) &&
                     fLayer[iD].GetClusterSorted(fDoublets[iD][iD0].x)->GetLabel(0) ==
                     fLayer[iD + 2].GetClusterSorted(fDoublets[iD + 1][iD1].y)->GetLabel(0) &&
                     fLayer[iD].GetClusterSorted(fDoublets[iD][iD0].x)->GetLabel(0) > 0);
#endif
            float curv, n[3];
            if (CellParams(iD,fLayer[iD][fDoublets[iD][iD0].x],fLayer[iD + 1][fDoublets[iD][iD0].y],
                           fLayer[iD + 2][fDoublets[iD + 1][iD1].y],curv,n)) {
              if (first && iD > 0) {
                tLUT[iD - 1][iD0] = fCells[iD].size();
                first = false;
              }
              fCells[iD].push_back(AliITSUCACell(fDoublets[iD][iD0].x,fDoublets[iD][iD0].y,
                                                 fDoublets[iD + 1][iD1].y,iD0,iD1,curv,n));
#ifdef _TUNING_
              if (fGood) {
                fTan->Fill(TMath::Abs(fDoublets[iD][iD0].tanL - fDoublets[iD + 1][iD1].tanL));
                fPhi->Fill(TMath::Abs(fDoublets[iD][iD0].phi - fDoublets[iD + 1][iD1].phi));
                fGDCAZ[iD]->Fill(fabs(extz-GetZ()));
                numberOfGoodCells++;
              } else {
                fTanF->Fill(TMath::Abs(fDoublets[iD][iD0].tanL - fDoublets[iD + 1][iD1].tanL));
                fPhiF->Fill(TMath::Abs(fDoublets[iD][iD0].phi - fDoublets[iD + 1][iD1].phi));
                fFDCAZ[iD]->Fill(fabs(extz - GetZ()));
              }
              totalNumberOfCells++;
#endif
            }
          }
        }
      }
    }
  }
  
  // Adjacent cells: cells that share 2 points. In the following code adjacent cells are combined.
  // If they meet some requirements (~ same curvature, ~ same n) the innermost cell id is added
  // to the list of neighbours of the outermost cell. When the cell is added to the neighbours of
  // the outermost cell the "level" of the latter is set to the level of the innermost one + 1.
  // ( only if $(level of the innermost) + 1 > $(level of the outermost) )
  for (int iD = 0; iD < 4; ++iD) {
    for (size_t c0 = 0; c0 < fCells[iD].size(); ++c0) {
      const int idx = fCells[iD][c0].d1();
      for (size_t c1 = tLUT[iD][idx]; idx == fCells[iD + 1][c1].d0(); ++c1) {
#ifdef _TUNING_
        fGood = (fLayer[iD].GetClusterSorted(fCells[iD][c0].x())->GetLabel(0) ==
                 fLayer[iD + 1].GetClusterSorted(fCells[iD][c0].y())->GetLabel(0) &&
                 fLayer[iD + 1].GetClusterSorted(fCells[iD][c0].y())->GetLabel(0) ==
                 fLayer[iD + 2].GetClusterSorted(fCells[iD][c0].z())->GetLabel(0) &&
                 fLayer[iD + 2].GetClusterSorted(fCells[iD][c0].z())->GetLabel(0) ==
                 fLayer[iD + 3].GetClusterSorted(fCells[iD + 1][c1].z())->GetLabel(0) &&
                 fLayer[iD].GetClusterSorted(fCells[iD][c0].x())->GetLabel(0) > 0);
#endif
        float *n0 = fCells[iD][c0].GetN();
        float *n1 = fCells[iD + 1][c1].GetN();
        const float dn2 = ((n0[0] - n1[0]) * (n0[0] - n1[0]) + (n0[1] - n1[1]) * (n0[1] - n1[1]) +
                           (n0[2] - n1[2]) * (n0[2] - n1[2]));
        const float dp = fabs(fCells[iD][c0].GetCurvature() - fCells[iD + 1][c1].GetCurvature());
        if (dn2 < fCDN[iD] && dp < fCDP[iD]) {
#ifdef _TUNING_
          assert(fCells[iD + 1][c1].Combine(fCells[iD][c0], c0));
          if (fGood) {
            fGoodCombChi2[iD]->Fill(dp);
            fGoodCombN[iD]->Fill(dn2);
            cellsCombiningSuccesses++;
          } else {
            fFakeCombChi2[iD]->Fill(dp);
            fFakeCombN[iD]->Fill(dn2);
            cellsWrongCombinations++;
          }
#else
          fCells[iD + 1][c1].Combine(fCells[iD][c0], c0);
#endif
        }
      }
    }
  }
#ifdef _TUNING_
  Info("MakeCells","Good doublets: %d",numberOfGoodDoublets);
  Info("MakeCells","Number of doublets: %d",totalNumberOfDoublets);
  Info("MakeCells","Good cells: %d",numberOfGoodCells);
  Info("MakeCells","Number of cells: %d",totalNumberOfCells);
  Info("MakeCells","Cells combining successes: %d",cellsCombiningSuccesses);
  Info("MakeCells","Cells wrong combinations: %d",cellsWrongCombinations);
#endif
}

//__________________________________________________________________________________________________
Int_t AliITSUCATracker::PropagateBack(AliESDEvent * event)
{
  
  Int_t n=event->GetNumberOfTracks();
  Int_t ntrk=0;
  Int_t ngood=0;
  for (Int_t i=0; i<n; i++) {
    AliESDtrack *esdTrack=event->GetTrack(i);
    
    if ((esdTrack->GetStatus()&AliESDtrack::kITSin)==0) continue;
    if (esdTrack->IsOn(AliESDtrack::kTPCin)) continue; //skip a TPC+ITS track

    AliITSUTrackCooked track(*esdTrack);
    AliITSUTrackCooked temp(*esdTrack);
    
    temp.ResetCovariance(10.);
    temp.ResetClusters();
    
    if (RefitAt(40., &temp, &track)) {
      
      CookLabel(&temp, 0.); //For comparison only
      Int_t label = temp.GetLabel();
      if (label > 0) ngood++;
      
      esdTrack->UpdateTrackParams(&temp,AliESDtrack::kITSout);
      ntrk++;
    }
  }
  
  Info("PropagateBack","Back propagated tracks: %d",ntrk);
  if (ntrk)
    Info("PropagateBack","Good tracks/back propagated: %f",Float_t(ngood)/ntrk);
  
  if (!fSAonly) return AliITSUTrackerGlo::PropagateBack(event);
  return 0;
}

//__________________________________________________________________________________________________
Bool_t AliITSUCATracker::RefitAt(Double_t xx, AliITSUTrackCooked *t, const AliITSUTrackCooked *c)
{
  // This function refits the track "t" at the position "x" using
  // the clusters from "c"
  
  const int nLayers = 7;
  Int_t index[nLayers];
  Int_t k;
  for (k = 0; k < nLayers; k++) index[k] = -1;
  Int_t nc = c->GetNumberOfClusters();
  for (k = 0; k < nc; k++) {
    Int_t idx = c->GetClusterIndex(k), nl = (idx&0xf0000000)>>28;
    index[nl] = idx;
  }
  
  Int_t from, to, step;
  if (xx > t->GetX()) {
    from = 0;
    to = nLayers;
    step = +1;
  } else {
    from = nLayers - 1;
    to = -1;
    step = -1;
  }
  
  for (Int_t i = from; i != to; i += step) {
    Int_t idx = index[i];
    if (idx >= 0) {
      const AliCluster *cl = GetCluster(idx);
      Float_t xr,ar;
      cl->GetXAlphaRefPlane(xr, ar);
      if (!t->Propagate(Double_t(ar), Double_t(xr), GetBz())) {
        return kFALSE;
      }
      Double_t chi2 = t->GetPredictedChi2(cl);
      //      if (chi2 < 100)
      t->Update(cl, chi2, idx);
    } else {
      Double_t r = fgkR[i];
      Double_t phi,z;
      if (!t->GetPhiZat(r,phi,z)) {
        return kFALSE;
      }
      if (!t->Propagate(phi, r, GetBz())) {
        return kFALSE;
      }
    }
    Double_t xx0 = (i > 2) ? 0.008 : 0.003;  // Rough layer thickness
    Double_t x0  = 9.36; // Radiation length of Si [cm]
    Double_t rho = 2.33; // Density of Si [g/cm^3]
    Double_t mass = t->GetMass();
    t->CorrectForMeanMaterial(xx0, - step * xx0 * x0 * rho, mass, kTRUE);
  }
  
  if (!t->PropagateTo(xx,0.,0.)) return kFALSE;
  return kTRUE;
}

//__________________________________________________________________________________________________
Int_t AliITSUCATracker::RefitInward(AliESDEvent * event)
{
  // Some final refit, after the outliers get removed by the smoother ?
  // The clusters must be loaded
  
  Int_t n = event->GetNumberOfTracks();
  Int_t ntrk = 0;
  Int_t ngood = 0;
  for (Int_t i = 0; i < n; i++) {
    AliESDtrack *esdTrack = event->GetTrack(i);
    
    if ((esdTrack->GetStatus() & AliESDtrack::kITSout) == 0) continue;
    if (esdTrack->IsOn(AliESDtrack::kTPCin)) continue; //skip a TPC+ITS track
    AliITSUTrackCooked track(*esdTrack);
    AliITSUTrackCooked temp(*esdTrack);
    
    temp.ResetCovariance(10.);
    temp.ResetClusters();
  
    if (!RefitAt(2.1, &temp, &track)) continue;
    //Cross the beam pipe
    if (!temp.PropagateTo(1.8, 2.27e-3, 35.28 * 1.848)) continue;
    
    CookLabel(&temp, 0.); //For comparison only
    Int_t label = temp.GetLabel();
    if (label > 0) ngood++;
    
    esdTrack->UpdateTrackParams(&temp,AliESDtrack::kITSrefit);
    ntrk++;
  }
  
  Info("RefitInward","Refitted tracks: %d",ntrk);
  if (ntrk)
    Info("RefitInward","Good tracks/refitted: %f",Float_t(ngood)/ntrk);
  
  if (!fSAonly) return AliITSUTrackerGlo::RefitInward(event);
  return 0;
}

//__________________________________________________________________________________________________
void AliITSUCATracker::SetCuts(int it)
{
  switch (it) {
    case 0:
      fCPhi = fPhiCut;
      fCDTanL = kDoublTanL;
      fCDPhi = kDoublPhi;
      fCZ = fZCut;
      for (int i = 0; i < 5; ++i) {
        fCDCAxy[i] = kmaxDCAxy[i];
        fCDCAz[i] = kmaxDCAz[i];
      }
      for (int i = 0; i < 4; ++i) {
        fCDN[i] = kmaxDN[i];
        fCDP[i] = kmaxDP[i];
      }
      for (int i = 0; i < 6; ++i) {
        fCDZ[i] = kmaxDZ[i];
      }
      break;
    
    default:
      fCPhi = 3.f * fPhiCut;
      fCDTanL = kDoublTanL1;
      fCDPhi = kDoublPhi1;
      fCZ = fZCut;
      for (int i = 0; i < 5; ++i) {
        fCDCAxy[i] = kmaxDCAxy1[i];
        fCDCAz[i] = kmaxDCAz1[i];
      }
      for (int i = 0; i < 4; ++i) {
        fCDN[i] = kmaxDN1[i];
        fCDP[i] = kmaxDP1[i];
      }
      for (int i = 0; i < 6; ++i) {
        fCDZ[i] = kmaxDZ1[i];
      }

      break;
  }
}

//__________________________________________________________________________________________________
void AliITSUCATracker::UnloadClusters()
{
  // This function unloads ITSU clusters from the memory
  for (int i = 0;i < 7;++i) {
    fLayer[i].Clear();
    fUsedClusters[i].clear();
  }
  for (int i = 0; i < 6; ++i) {
    fDoublets[i].clear();
  }
  for (int i = 0; i < 5; ++i) {
    fCells[i].clear();
  }
  for (int i = 0; i < 4; ++i)
  {
    fCandidates[i]->Clear("C");
  }
  AliITSUTrackerGlo::UnloadClusters();
}

#ifdef _TUNING_
//__________________________________________________________________________________________________
void AliITSUCATracker::ResetHistos()
{
  for (int i = 0; i < 6; ++i) {
    fGDZ[i]->Reset();
    fGDXY[i]->Reset();
    fFDZ[i]->Reset();
    fFDXY[i]->Reset();
  }
  for (int i = 0; i < 5; ++i) {
    fGoodCombChi2[i]->Reset();
    fFakeCombChi2[i]->Reset();
    fGDCAZ[i]->Reset();
    fGDCAXY[i]->Reset();
    fFDCAZ[i]->Reset();
    fFDCAXY[i]->Reset();
  }
  for (int i = 0; i < 4; ++i) {
    fGoodCombN[i]->Reset();
    fFakeCombN[i]->Reset();
  }
  fTan->Reset();
  fTanF->Reset();
  fPhi->Reset();
  fPhiF->Reset();
  fNEntries->Reset();
}
#endif
 AliITSUCATracker.cxx:1
 AliITSUCATracker.cxx:2
 AliITSUCATracker.cxx:3
 AliITSUCATracker.cxx:4
 AliITSUCATracker.cxx:5
 AliITSUCATracker.cxx:6
 AliITSUCATracker.cxx:7
 AliITSUCATracker.cxx:8
 AliITSUCATracker.cxx:9
 AliITSUCATracker.cxx:10
 AliITSUCATracker.cxx:11
 AliITSUCATracker.cxx:12
 AliITSUCATracker.cxx:13
 AliITSUCATracker.cxx:14
 AliITSUCATracker.cxx:15
 AliITSUCATracker.cxx:16
 AliITSUCATracker.cxx:17
 AliITSUCATracker.cxx:18
 AliITSUCATracker.cxx:19
 AliITSUCATracker.cxx:20
 AliITSUCATracker.cxx:21
 AliITSUCATracker.cxx:22
 AliITSUCATracker.cxx:23
 AliITSUCATracker.cxx:24
 AliITSUCATracker.cxx:25
 AliITSUCATracker.cxx:26
 AliITSUCATracker.cxx:27
 AliITSUCATracker.cxx:28
 AliITSUCATracker.cxx:29
 AliITSUCATracker.cxx:30
 AliITSUCATracker.cxx:31
 AliITSUCATracker.cxx:32
 AliITSUCATracker.cxx:33
 AliITSUCATracker.cxx:34
 AliITSUCATracker.cxx:35
 AliITSUCATracker.cxx:36
 AliITSUCATracker.cxx:37
 AliITSUCATracker.cxx:38
 AliITSUCATracker.cxx:39
 AliITSUCATracker.cxx:40
 AliITSUCATracker.cxx:41
 AliITSUCATracker.cxx:42
 AliITSUCATracker.cxx:43
 AliITSUCATracker.cxx:44
 AliITSUCATracker.cxx:45
 AliITSUCATracker.cxx:46
 AliITSUCATracker.cxx:47
 AliITSUCATracker.cxx:48
 AliITSUCATracker.cxx:49
 AliITSUCATracker.cxx:50
 AliITSUCATracker.cxx:51
 AliITSUCATracker.cxx:52
 AliITSUCATracker.cxx:53
 AliITSUCATracker.cxx:54
 AliITSUCATracker.cxx:55
 AliITSUCATracker.cxx:56
 AliITSUCATracker.cxx:57
 AliITSUCATracker.cxx:58
 AliITSUCATracker.cxx:59
 AliITSUCATracker.cxx:60
 AliITSUCATracker.cxx:61
 AliITSUCATracker.cxx:62
 AliITSUCATracker.cxx:63
 AliITSUCATracker.cxx:64
 AliITSUCATracker.cxx:65
 AliITSUCATracker.cxx:66
 AliITSUCATracker.cxx:67
 AliITSUCATracker.cxx:68
 AliITSUCATracker.cxx:69
 AliITSUCATracker.cxx:70
 AliITSUCATracker.cxx:71
 AliITSUCATracker.cxx:72
 AliITSUCATracker.cxx:73
 AliITSUCATracker.cxx:74
 AliITSUCATracker.cxx:75
 AliITSUCATracker.cxx:76
 AliITSUCATracker.cxx:77
 AliITSUCATracker.cxx:78
 AliITSUCATracker.cxx:79
 AliITSUCATracker.cxx:80
 AliITSUCATracker.cxx:81
 AliITSUCATracker.cxx:82
 AliITSUCATracker.cxx:83
 AliITSUCATracker.cxx:84
 AliITSUCATracker.cxx:85
 AliITSUCATracker.cxx:86
 AliITSUCATracker.cxx:87
 AliITSUCATracker.cxx:88
 AliITSUCATracker.cxx:89
 AliITSUCATracker.cxx:90
 AliITSUCATracker.cxx:91
 AliITSUCATracker.cxx:92
 AliITSUCATracker.cxx:93
 AliITSUCATracker.cxx:94
 AliITSUCATracker.cxx:95
 AliITSUCATracker.cxx:96
 AliITSUCATracker.cxx:97
 AliITSUCATracker.cxx:98
 AliITSUCATracker.cxx:99
 AliITSUCATracker.cxx:100
 AliITSUCATracker.cxx:101
 AliITSUCATracker.cxx:102
 AliITSUCATracker.cxx:103
 AliITSUCATracker.cxx:104
 AliITSUCATracker.cxx:105
 AliITSUCATracker.cxx:106
 AliITSUCATracker.cxx:107
 AliITSUCATracker.cxx:108
 AliITSUCATracker.cxx:109
 AliITSUCATracker.cxx:110
 AliITSUCATracker.cxx:111
 AliITSUCATracker.cxx:112
 AliITSUCATracker.cxx:113
 AliITSUCATracker.cxx:114
 AliITSUCATracker.cxx:115
 AliITSUCATracker.cxx:116
 AliITSUCATracker.cxx:117
 AliITSUCATracker.cxx:118
 AliITSUCATracker.cxx:119
 AliITSUCATracker.cxx:120
 AliITSUCATracker.cxx:121
 AliITSUCATracker.cxx:122
 AliITSUCATracker.cxx:123
 AliITSUCATracker.cxx:124
 AliITSUCATracker.cxx:125
 AliITSUCATracker.cxx:126
 AliITSUCATracker.cxx:127
 AliITSUCATracker.cxx:128
 AliITSUCATracker.cxx:129
 AliITSUCATracker.cxx:130
 AliITSUCATracker.cxx:131
 AliITSUCATracker.cxx:132
 AliITSUCATracker.cxx:133
 AliITSUCATracker.cxx:134
 AliITSUCATracker.cxx:135
 AliITSUCATracker.cxx:136
 AliITSUCATracker.cxx:137
 AliITSUCATracker.cxx:138
 AliITSUCATracker.cxx:139
 AliITSUCATracker.cxx:140
 AliITSUCATracker.cxx:141
 AliITSUCATracker.cxx:142
 AliITSUCATracker.cxx:143
 AliITSUCATracker.cxx:144
 AliITSUCATracker.cxx:145
 AliITSUCATracker.cxx:146
 AliITSUCATracker.cxx:147
 AliITSUCATracker.cxx:148
 AliITSUCATracker.cxx:149
 AliITSUCATracker.cxx:150
 AliITSUCATracker.cxx:151
 AliITSUCATracker.cxx:152
 AliITSUCATracker.cxx:153
 AliITSUCATracker.cxx:154
 AliITSUCATracker.cxx:155
 AliITSUCATracker.cxx:156
 AliITSUCATracker.cxx:157
 AliITSUCATracker.cxx:158
 AliITSUCATracker.cxx:159
 AliITSUCATracker.cxx:160
 AliITSUCATracker.cxx:161
 AliITSUCATracker.cxx:162
 AliITSUCATracker.cxx:163
 AliITSUCATracker.cxx:164
 AliITSUCATracker.cxx:165
 AliITSUCATracker.cxx:166
 AliITSUCATracker.cxx:167
 AliITSUCATracker.cxx:168
 AliITSUCATracker.cxx:169
 AliITSUCATracker.cxx:170
 AliITSUCATracker.cxx:171
 AliITSUCATracker.cxx:172
 AliITSUCATracker.cxx:173
 AliITSUCATracker.cxx:174
 AliITSUCATracker.cxx:175
 AliITSUCATracker.cxx:176
 AliITSUCATracker.cxx:177
 AliITSUCATracker.cxx:178
 AliITSUCATracker.cxx:179
 AliITSUCATracker.cxx:180
 AliITSUCATracker.cxx:181
 AliITSUCATracker.cxx:182
 AliITSUCATracker.cxx:183
 AliITSUCATracker.cxx:184
 AliITSUCATracker.cxx:185
 AliITSUCATracker.cxx:186
 AliITSUCATracker.cxx:187
 AliITSUCATracker.cxx:188
 AliITSUCATracker.cxx:189
 AliITSUCATracker.cxx:190
 AliITSUCATracker.cxx:191
 AliITSUCATracker.cxx:192
 AliITSUCATracker.cxx:193
 AliITSUCATracker.cxx:194
 AliITSUCATracker.cxx:195
 AliITSUCATracker.cxx:196
 AliITSUCATracker.cxx:197
 AliITSUCATracker.cxx:198
 AliITSUCATracker.cxx:199
 AliITSUCATracker.cxx:200
 AliITSUCATracker.cxx:201
 AliITSUCATracker.cxx:202
 AliITSUCATracker.cxx:203
 AliITSUCATracker.cxx:204
 AliITSUCATracker.cxx:205
 AliITSUCATracker.cxx:206
 AliITSUCATracker.cxx:207
 AliITSUCATracker.cxx:208
 AliITSUCATracker.cxx:209
 AliITSUCATracker.cxx:210
 AliITSUCATracker.cxx:211
 AliITSUCATracker.cxx:212
 AliITSUCATracker.cxx:213
 AliITSUCATracker.cxx:214
 AliITSUCATracker.cxx:215
 AliITSUCATracker.cxx:216
 AliITSUCATracker.cxx:217
 AliITSUCATracker.cxx:218
 AliITSUCATracker.cxx:219
 AliITSUCATracker.cxx:220
 AliITSUCATracker.cxx:221
 AliITSUCATracker.cxx:222
 AliITSUCATracker.cxx:223
 AliITSUCATracker.cxx:224
 AliITSUCATracker.cxx:225
 AliITSUCATracker.cxx:226
 AliITSUCATracker.cxx:227
 AliITSUCATracker.cxx:228
 AliITSUCATracker.cxx:229
 AliITSUCATracker.cxx:230
 AliITSUCATracker.cxx:231
 AliITSUCATracker.cxx:232
 AliITSUCATracker.cxx:233
 AliITSUCATracker.cxx:234
 AliITSUCATracker.cxx:235
 AliITSUCATracker.cxx:236
 AliITSUCATracker.cxx:237
 AliITSUCATracker.cxx:238
 AliITSUCATracker.cxx:239
 AliITSUCATracker.cxx:240
 AliITSUCATracker.cxx:241
 AliITSUCATracker.cxx:242
 AliITSUCATracker.cxx:243
 AliITSUCATracker.cxx:244
 AliITSUCATracker.cxx:245
 AliITSUCATracker.cxx:246
 AliITSUCATracker.cxx:247
 AliITSUCATracker.cxx:248
 AliITSUCATracker.cxx:249
 AliITSUCATracker.cxx:250
 AliITSUCATracker.cxx:251
 AliITSUCATracker.cxx:252
 AliITSUCATracker.cxx:253
 AliITSUCATracker.cxx:254
 AliITSUCATracker.cxx:255
 AliITSUCATracker.cxx:256
 AliITSUCATracker.cxx:257
 AliITSUCATracker.cxx:258
 AliITSUCATracker.cxx:259
 AliITSUCATracker.cxx:260
 AliITSUCATracker.cxx:261
 AliITSUCATracker.cxx:262
 AliITSUCATracker.cxx:263
 AliITSUCATracker.cxx:264
 AliITSUCATracker.cxx:265
 AliITSUCATracker.cxx:266
 AliITSUCATracker.cxx:267
 AliITSUCATracker.cxx:268
 AliITSUCATracker.cxx:269
 AliITSUCATracker.cxx:270
 AliITSUCATracker.cxx:271
 AliITSUCATracker.cxx:272
 AliITSUCATracker.cxx:273
 AliITSUCATracker.cxx:274
 AliITSUCATracker.cxx:275
 AliITSUCATracker.cxx:276
 AliITSUCATracker.cxx:277
 AliITSUCATracker.cxx:278
 AliITSUCATracker.cxx:279
 AliITSUCATracker.cxx:280
 AliITSUCATracker.cxx:281
 AliITSUCATracker.cxx:282
 AliITSUCATracker.cxx:283
 AliITSUCATracker.cxx:284
 AliITSUCATracker.cxx:285
 AliITSUCATracker.cxx:286
 AliITSUCATracker.cxx:287
 AliITSUCATracker.cxx:288
 AliITSUCATracker.cxx:289
 AliITSUCATracker.cxx:290
 AliITSUCATracker.cxx:291
 AliITSUCATracker.cxx:292
 AliITSUCATracker.cxx:293
 AliITSUCATracker.cxx:294
 AliITSUCATracker.cxx:295
 AliITSUCATracker.cxx:296
 AliITSUCATracker.cxx:297
 AliITSUCATracker.cxx:298
 AliITSUCATracker.cxx:299
 AliITSUCATracker.cxx:300
 AliITSUCATracker.cxx:301
 AliITSUCATracker.cxx:302
 AliITSUCATracker.cxx:303
 AliITSUCATracker.cxx:304
 AliITSUCATracker.cxx:305
 AliITSUCATracker.cxx:306
 AliITSUCATracker.cxx:307
 AliITSUCATracker.cxx:308
 AliITSUCATracker.cxx:309
 AliITSUCATracker.cxx:310
 AliITSUCATracker.cxx:311
 AliITSUCATracker.cxx:312
 AliITSUCATracker.cxx:313
 AliITSUCATracker.cxx:314
 AliITSUCATracker.cxx:315
 AliITSUCATracker.cxx:316
 AliITSUCATracker.cxx:317
 AliITSUCATracker.cxx:318
 AliITSUCATracker.cxx:319
 AliITSUCATracker.cxx:320
 AliITSUCATracker.cxx:321
 AliITSUCATracker.cxx:322
 AliITSUCATracker.cxx:323
 AliITSUCATracker.cxx:324
 AliITSUCATracker.cxx:325
 AliITSUCATracker.cxx:326
 AliITSUCATracker.cxx:327
 AliITSUCATracker.cxx:328
 AliITSUCATracker.cxx:329
 AliITSUCATracker.cxx:330
 AliITSUCATracker.cxx:331
 AliITSUCATracker.cxx:332
 AliITSUCATracker.cxx:333
 AliITSUCATracker.cxx:334
 AliITSUCATracker.cxx:335
 AliITSUCATracker.cxx:336
 AliITSUCATracker.cxx:337
 AliITSUCATracker.cxx:338
 AliITSUCATracker.cxx:339
 AliITSUCATracker.cxx:340
 AliITSUCATracker.cxx:341
 AliITSUCATracker.cxx:342
 AliITSUCATracker.cxx:343
 AliITSUCATracker.cxx:344
 AliITSUCATracker.cxx:345
 AliITSUCATracker.cxx:346
 AliITSUCATracker.cxx:347
 AliITSUCATracker.cxx:348
 AliITSUCATracker.cxx:349
 AliITSUCATracker.cxx:350
 AliITSUCATracker.cxx:351
 AliITSUCATracker.cxx:352
 AliITSUCATracker.cxx:353
 AliITSUCATracker.cxx:354
 AliITSUCATracker.cxx:355
 AliITSUCATracker.cxx:356
 AliITSUCATracker.cxx:357
 AliITSUCATracker.cxx:358
 AliITSUCATracker.cxx:359
 AliITSUCATracker.cxx:360
 AliITSUCATracker.cxx:361
 AliITSUCATracker.cxx:362
 AliITSUCATracker.cxx:363
 AliITSUCATracker.cxx:364
 AliITSUCATracker.cxx:365
 AliITSUCATracker.cxx:366
 AliITSUCATracker.cxx:367
 AliITSUCATracker.cxx:368
 AliITSUCATracker.cxx:369
 AliITSUCATracker.cxx:370
 AliITSUCATracker.cxx:371
 AliITSUCATracker.cxx:372
 AliITSUCATracker.cxx:373
 AliITSUCATracker.cxx:374
 AliITSUCATracker.cxx:375
 AliITSUCATracker.cxx:376
 AliITSUCATracker.cxx:377
 AliITSUCATracker.cxx:378
 AliITSUCATracker.cxx:379
 AliITSUCATracker.cxx:380
 AliITSUCATracker.cxx:381
 AliITSUCATracker.cxx:382
 AliITSUCATracker.cxx:383
 AliITSUCATracker.cxx:384
 AliITSUCATracker.cxx:385
 AliITSUCATracker.cxx:386
 AliITSUCATracker.cxx:387
 AliITSUCATracker.cxx:388
 AliITSUCATracker.cxx:389
 AliITSUCATracker.cxx:390
 AliITSUCATracker.cxx:391
 AliITSUCATracker.cxx:392
 AliITSUCATracker.cxx:393
 AliITSUCATracker.cxx:394
 AliITSUCATracker.cxx:395
 AliITSUCATracker.cxx:396
 AliITSUCATracker.cxx:397
 AliITSUCATracker.cxx:398
 AliITSUCATracker.cxx:399
 AliITSUCATracker.cxx:400
 AliITSUCATracker.cxx:401
 AliITSUCATracker.cxx:402
 AliITSUCATracker.cxx:403
 AliITSUCATracker.cxx:404
 AliITSUCATracker.cxx:405
 AliITSUCATracker.cxx:406
 AliITSUCATracker.cxx:407
 AliITSUCATracker.cxx:408
 AliITSUCATracker.cxx:409
 AliITSUCATracker.cxx:410
 AliITSUCATracker.cxx:411
 AliITSUCATracker.cxx:412
 AliITSUCATracker.cxx:413
 AliITSUCATracker.cxx:414
 AliITSUCATracker.cxx:415
 AliITSUCATracker.cxx:416
 AliITSUCATracker.cxx:417
 AliITSUCATracker.cxx:418
 AliITSUCATracker.cxx:419
 AliITSUCATracker.cxx:420
 AliITSUCATracker.cxx:421
 AliITSUCATracker.cxx:422
 AliITSUCATracker.cxx:423
 AliITSUCATracker.cxx:424
 AliITSUCATracker.cxx:425
 AliITSUCATracker.cxx:426
 AliITSUCATracker.cxx:427
 AliITSUCATracker.cxx:428
 AliITSUCATracker.cxx:429
 AliITSUCATracker.cxx:430
 AliITSUCATracker.cxx:431
 AliITSUCATracker.cxx:432
 AliITSUCATracker.cxx:433
 AliITSUCATracker.cxx:434
 AliITSUCATracker.cxx:435
 AliITSUCATracker.cxx:436
 AliITSUCATracker.cxx:437
 AliITSUCATracker.cxx:438
 AliITSUCATracker.cxx:439
 AliITSUCATracker.cxx:440
 AliITSUCATracker.cxx:441
 AliITSUCATracker.cxx:442
 AliITSUCATracker.cxx:443
 AliITSUCATracker.cxx:444
 AliITSUCATracker.cxx:445
 AliITSUCATracker.cxx:446
 AliITSUCATracker.cxx:447
 AliITSUCATracker.cxx:448
 AliITSUCATracker.cxx:449
 AliITSUCATracker.cxx:450
 AliITSUCATracker.cxx:451
 AliITSUCATracker.cxx:452
 AliITSUCATracker.cxx:453
 AliITSUCATracker.cxx:454
 AliITSUCATracker.cxx:455
 AliITSUCATracker.cxx:456
 AliITSUCATracker.cxx:457
 AliITSUCATracker.cxx:458
 AliITSUCATracker.cxx:459
 AliITSUCATracker.cxx:460
 AliITSUCATracker.cxx:461
 AliITSUCATracker.cxx:462
 AliITSUCATracker.cxx:463
 AliITSUCATracker.cxx:464
 AliITSUCATracker.cxx:465
 AliITSUCATracker.cxx:466
 AliITSUCATracker.cxx:467
 AliITSUCATracker.cxx:468
 AliITSUCATracker.cxx:469
 AliITSUCATracker.cxx:470
 AliITSUCATracker.cxx:471
 AliITSUCATracker.cxx:472
 AliITSUCATracker.cxx:473
 AliITSUCATracker.cxx:474
 AliITSUCATracker.cxx:475
 AliITSUCATracker.cxx:476
 AliITSUCATracker.cxx:477
 AliITSUCATracker.cxx:478
 AliITSUCATracker.cxx:479
 AliITSUCATracker.cxx:480
 AliITSUCATracker.cxx:481
 AliITSUCATracker.cxx:482
 AliITSUCATracker.cxx:483
 AliITSUCATracker.cxx:484
 AliITSUCATracker.cxx:485
 AliITSUCATracker.cxx:486
 AliITSUCATracker.cxx:487
 AliITSUCATracker.cxx:488
 AliITSUCATracker.cxx:489
 AliITSUCATracker.cxx:490
 AliITSUCATracker.cxx:491
 AliITSUCATracker.cxx:492
 AliITSUCATracker.cxx:493
 AliITSUCATracker.cxx:494
 AliITSUCATracker.cxx:495
 AliITSUCATracker.cxx:496
 AliITSUCATracker.cxx:497
 AliITSUCATracker.cxx:498
 AliITSUCATracker.cxx:499
 AliITSUCATracker.cxx:500
 AliITSUCATracker.cxx:501
 AliITSUCATracker.cxx:502
 AliITSUCATracker.cxx:503
 AliITSUCATracker.cxx:504
 AliITSUCATracker.cxx:505
 AliITSUCATracker.cxx:506
 AliITSUCATracker.cxx:507
 AliITSUCATracker.cxx:508
 AliITSUCATracker.cxx:509
 AliITSUCATracker.cxx:510
 AliITSUCATracker.cxx:511
 AliITSUCATracker.cxx:512
 AliITSUCATracker.cxx:513
 AliITSUCATracker.cxx:514
 AliITSUCATracker.cxx:515
 AliITSUCATracker.cxx:516
 AliITSUCATracker.cxx:517
 AliITSUCATracker.cxx:518
 AliITSUCATracker.cxx:519
 AliITSUCATracker.cxx:520
 AliITSUCATracker.cxx:521
 AliITSUCATracker.cxx:522
 AliITSUCATracker.cxx:523
 AliITSUCATracker.cxx:524
 AliITSUCATracker.cxx:525
 AliITSUCATracker.cxx:526
 AliITSUCATracker.cxx:527
 AliITSUCATracker.cxx:528
 AliITSUCATracker.cxx:529
 AliITSUCATracker.cxx:530
 AliITSUCATracker.cxx:531
 AliITSUCATracker.cxx:532
 AliITSUCATracker.cxx:533
 AliITSUCATracker.cxx:534
 AliITSUCATracker.cxx:535
 AliITSUCATracker.cxx:536
 AliITSUCATracker.cxx:537
 AliITSUCATracker.cxx:538
 AliITSUCATracker.cxx:539
 AliITSUCATracker.cxx:540
 AliITSUCATracker.cxx:541
 AliITSUCATracker.cxx:542
 AliITSUCATracker.cxx:543
 AliITSUCATracker.cxx:544
 AliITSUCATracker.cxx:545
 AliITSUCATracker.cxx:546
 AliITSUCATracker.cxx:547
 AliITSUCATracker.cxx:548
 AliITSUCATracker.cxx:549
 AliITSUCATracker.cxx:550
 AliITSUCATracker.cxx:551
 AliITSUCATracker.cxx:552
 AliITSUCATracker.cxx:553
 AliITSUCATracker.cxx:554
 AliITSUCATracker.cxx:555
 AliITSUCATracker.cxx:556
 AliITSUCATracker.cxx:557
 AliITSUCATracker.cxx:558
 AliITSUCATracker.cxx:559
 AliITSUCATracker.cxx:560
 AliITSUCATracker.cxx:561
 AliITSUCATracker.cxx:562
 AliITSUCATracker.cxx:563
 AliITSUCATracker.cxx:564
 AliITSUCATracker.cxx:565
 AliITSUCATracker.cxx:566
 AliITSUCATracker.cxx:567
 AliITSUCATracker.cxx:568
 AliITSUCATracker.cxx:569
 AliITSUCATracker.cxx:570
 AliITSUCATracker.cxx:571
 AliITSUCATracker.cxx:572
 AliITSUCATracker.cxx:573
 AliITSUCATracker.cxx:574
 AliITSUCATracker.cxx:575
 AliITSUCATracker.cxx:576
 AliITSUCATracker.cxx:577
 AliITSUCATracker.cxx:578
 AliITSUCATracker.cxx:579
 AliITSUCATracker.cxx:580
 AliITSUCATracker.cxx:581
 AliITSUCATracker.cxx:582
 AliITSUCATracker.cxx:583
 AliITSUCATracker.cxx:584
 AliITSUCATracker.cxx:585
 AliITSUCATracker.cxx:586
 AliITSUCATracker.cxx:587
 AliITSUCATracker.cxx:588
 AliITSUCATracker.cxx:589
 AliITSUCATracker.cxx:590
 AliITSUCATracker.cxx:591
 AliITSUCATracker.cxx:592
 AliITSUCATracker.cxx:593
 AliITSUCATracker.cxx:594
 AliITSUCATracker.cxx:595
 AliITSUCATracker.cxx:596
 AliITSUCATracker.cxx:597
 AliITSUCATracker.cxx:598
 AliITSUCATracker.cxx:599
 AliITSUCATracker.cxx:600
 AliITSUCATracker.cxx:601
 AliITSUCATracker.cxx:602
 AliITSUCATracker.cxx:603
 AliITSUCATracker.cxx:604
 AliITSUCATracker.cxx:605
 AliITSUCATracker.cxx:606
 AliITSUCATracker.cxx:607
 AliITSUCATracker.cxx:608
 AliITSUCATracker.cxx:609
 AliITSUCATracker.cxx:610
 AliITSUCATracker.cxx:611
 AliITSUCATracker.cxx:612
 AliITSUCATracker.cxx:613
 AliITSUCATracker.cxx:614
 AliITSUCATracker.cxx:615
 AliITSUCATracker.cxx:616
 AliITSUCATracker.cxx:617
 AliITSUCATracker.cxx:618
 AliITSUCATracker.cxx:619
 AliITSUCATracker.cxx:620
 AliITSUCATracker.cxx:621
 AliITSUCATracker.cxx:622
 AliITSUCATracker.cxx:623
 AliITSUCATracker.cxx:624
 AliITSUCATracker.cxx:625
 AliITSUCATracker.cxx:626
 AliITSUCATracker.cxx:627
 AliITSUCATracker.cxx:628
 AliITSUCATracker.cxx:629
 AliITSUCATracker.cxx:630
 AliITSUCATracker.cxx:631
 AliITSUCATracker.cxx:632
 AliITSUCATracker.cxx:633
 AliITSUCATracker.cxx:634
 AliITSUCATracker.cxx:635
 AliITSUCATracker.cxx:636
 AliITSUCATracker.cxx:637
 AliITSUCATracker.cxx:638
 AliITSUCATracker.cxx:639
 AliITSUCATracker.cxx:640
 AliITSUCATracker.cxx:641
 AliITSUCATracker.cxx:642
 AliITSUCATracker.cxx:643
 AliITSUCATracker.cxx:644
 AliITSUCATracker.cxx:645
 AliITSUCATracker.cxx:646
 AliITSUCATracker.cxx:647
 AliITSUCATracker.cxx:648
 AliITSUCATracker.cxx:649
 AliITSUCATracker.cxx:650
 AliITSUCATracker.cxx:651
 AliITSUCATracker.cxx:652
 AliITSUCATracker.cxx:653
 AliITSUCATracker.cxx:654
 AliITSUCATracker.cxx:655
 AliITSUCATracker.cxx:656
 AliITSUCATracker.cxx:657
 AliITSUCATracker.cxx:658
 AliITSUCATracker.cxx:659
 AliITSUCATracker.cxx:660
 AliITSUCATracker.cxx:661
 AliITSUCATracker.cxx:662
 AliITSUCATracker.cxx:663
 AliITSUCATracker.cxx:664
 AliITSUCATracker.cxx:665
 AliITSUCATracker.cxx:666
 AliITSUCATracker.cxx:667
 AliITSUCATracker.cxx:668
 AliITSUCATracker.cxx:669
 AliITSUCATracker.cxx:670
 AliITSUCATracker.cxx:671
 AliITSUCATracker.cxx:672
 AliITSUCATracker.cxx:673
 AliITSUCATracker.cxx:674
 AliITSUCATracker.cxx:675
 AliITSUCATracker.cxx:676
 AliITSUCATracker.cxx:677
 AliITSUCATracker.cxx:678
 AliITSUCATracker.cxx:679
 AliITSUCATracker.cxx:680
 AliITSUCATracker.cxx:681
 AliITSUCATracker.cxx:682
 AliITSUCATracker.cxx:683
 AliITSUCATracker.cxx:684
 AliITSUCATracker.cxx:685
 AliITSUCATracker.cxx:686
 AliITSUCATracker.cxx:687
 AliITSUCATracker.cxx:688
 AliITSUCATracker.cxx:689
 AliITSUCATracker.cxx:690
 AliITSUCATracker.cxx:691
 AliITSUCATracker.cxx:692
 AliITSUCATracker.cxx:693
 AliITSUCATracker.cxx:694
 AliITSUCATracker.cxx:695
 AliITSUCATracker.cxx:696
 AliITSUCATracker.cxx:697
 AliITSUCATracker.cxx:698
 AliITSUCATracker.cxx:699
 AliITSUCATracker.cxx:700
 AliITSUCATracker.cxx:701
 AliITSUCATracker.cxx:702
 AliITSUCATracker.cxx:703
 AliITSUCATracker.cxx:704
 AliITSUCATracker.cxx:705
 AliITSUCATracker.cxx:706
 AliITSUCATracker.cxx:707
 AliITSUCATracker.cxx:708
 AliITSUCATracker.cxx:709
 AliITSUCATracker.cxx:710
 AliITSUCATracker.cxx:711
 AliITSUCATracker.cxx:712
 AliITSUCATracker.cxx:713
 AliITSUCATracker.cxx:714
 AliITSUCATracker.cxx:715
 AliITSUCATracker.cxx:716
 AliITSUCATracker.cxx:717
 AliITSUCATracker.cxx:718
 AliITSUCATracker.cxx:719
 AliITSUCATracker.cxx:720
 AliITSUCATracker.cxx:721
 AliITSUCATracker.cxx:722
 AliITSUCATracker.cxx:723
 AliITSUCATracker.cxx:724
 AliITSUCATracker.cxx:725
 AliITSUCATracker.cxx:726
 AliITSUCATracker.cxx:727
 AliITSUCATracker.cxx:728
 AliITSUCATracker.cxx:729
 AliITSUCATracker.cxx:730
 AliITSUCATracker.cxx:731
 AliITSUCATracker.cxx:732
 AliITSUCATracker.cxx:733
 AliITSUCATracker.cxx:734
 AliITSUCATracker.cxx:735
 AliITSUCATracker.cxx:736
 AliITSUCATracker.cxx:737
 AliITSUCATracker.cxx:738
 AliITSUCATracker.cxx:739
 AliITSUCATracker.cxx:740
 AliITSUCATracker.cxx:741
 AliITSUCATracker.cxx:742
 AliITSUCATracker.cxx:743
 AliITSUCATracker.cxx:744
 AliITSUCATracker.cxx:745
 AliITSUCATracker.cxx:746
 AliITSUCATracker.cxx:747
 AliITSUCATracker.cxx:748
 AliITSUCATracker.cxx:749
 AliITSUCATracker.cxx:750
 AliITSUCATracker.cxx:751
 AliITSUCATracker.cxx:752
 AliITSUCATracker.cxx:753
 AliITSUCATracker.cxx:754
 AliITSUCATracker.cxx:755
 AliITSUCATracker.cxx:756
 AliITSUCATracker.cxx:757
 AliITSUCATracker.cxx:758
 AliITSUCATracker.cxx:759
 AliITSUCATracker.cxx:760
 AliITSUCATracker.cxx:761
 AliITSUCATracker.cxx:762
 AliITSUCATracker.cxx:763
 AliITSUCATracker.cxx:764
 AliITSUCATracker.cxx:765
 AliITSUCATracker.cxx:766
 AliITSUCATracker.cxx:767
 AliITSUCATracker.cxx:768
 AliITSUCATracker.cxx:769
 AliITSUCATracker.cxx:770
 AliITSUCATracker.cxx:771
 AliITSUCATracker.cxx:772
 AliITSUCATracker.cxx:773
 AliITSUCATracker.cxx:774
 AliITSUCATracker.cxx:775
 AliITSUCATracker.cxx:776
 AliITSUCATracker.cxx:777
 AliITSUCATracker.cxx:778
 AliITSUCATracker.cxx:779
 AliITSUCATracker.cxx:780
 AliITSUCATracker.cxx:781
 AliITSUCATracker.cxx:782
 AliITSUCATracker.cxx:783
 AliITSUCATracker.cxx:784
 AliITSUCATracker.cxx:785
 AliITSUCATracker.cxx:786
 AliITSUCATracker.cxx:787
 AliITSUCATracker.cxx:788
 AliITSUCATracker.cxx:789
 AliITSUCATracker.cxx:790
 AliITSUCATracker.cxx:791
 AliITSUCATracker.cxx:792
 AliITSUCATracker.cxx:793
 AliITSUCATracker.cxx:794
 AliITSUCATracker.cxx:795
 AliITSUCATracker.cxx:796
 AliITSUCATracker.cxx:797
 AliITSUCATracker.cxx:798
 AliITSUCATracker.cxx:799
 AliITSUCATracker.cxx:800
 AliITSUCATracker.cxx:801
 AliITSUCATracker.cxx:802
 AliITSUCATracker.cxx:803
 AliITSUCATracker.cxx:804
 AliITSUCATracker.cxx:805
 AliITSUCATracker.cxx:806
 AliITSUCATracker.cxx:807
 AliITSUCATracker.cxx:808
 AliITSUCATracker.cxx:809
 AliITSUCATracker.cxx:810
 AliITSUCATracker.cxx:811
 AliITSUCATracker.cxx:812
 AliITSUCATracker.cxx:813
 AliITSUCATracker.cxx:814
 AliITSUCATracker.cxx:815
 AliITSUCATracker.cxx:816
 AliITSUCATracker.cxx:817
 AliITSUCATracker.cxx:818
 AliITSUCATracker.cxx:819
 AliITSUCATracker.cxx:820
 AliITSUCATracker.cxx:821
 AliITSUCATracker.cxx:822
 AliITSUCATracker.cxx:823
 AliITSUCATracker.cxx:824
 AliITSUCATracker.cxx:825
 AliITSUCATracker.cxx:826
 AliITSUCATracker.cxx:827
 AliITSUCATracker.cxx:828
 AliITSUCATracker.cxx:829
 AliITSUCATracker.cxx:830
 AliITSUCATracker.cxx:831
 AliITSUCATracker.cxx:832
 AliITSUCATracker.cxx:833
 AliITSUCATracker.cxx:834
 AliITSUCATracker.cxx:835
 AliITSUCATracker.cxx:836
 AliITSUCATracker.cxx:837
 AliITSUCATracker.cxx:838
 AliITSUCATracker.cxx:839
 AliITSUCATracker.cxx:840
 AliITSUCATracker.cxx:841
 AliITSUCATracker.cxx:842
 AliITSUCATracker.cxx:843
 AliITSUCATracker.cxx:844
 AliITSUCATracker.cxx:845
 AliITSUCATracker.cxx:846
 AliITSUCATracker.cxx:847
 AliITSUCATracker.cxx:848
 AliITSUCATracker.cxx:849
 AliITSUCATracker.cxx:850
 AliITSUCATracker.cxx:851
 AliITSUCATracker.cxx:852
 AliITSUCATracker.cxx:853
 AliITSUCATracker.cxx:854
 AliITSUCATracker.cxx:855
 AliITSUCATracker.cxx:856
 AliITSUCATracker.cxx:857
 AliITSUCATracker.cxx:858
 AliITSUCATracker.cxx:859
 AliITSUCATracker.cxx:860
 AliITSUCATracker.cxx:861
 AliITSUCATracker.cxx:862
 AliITSUCATracker.cxx:863
 AliITSUCATracker.cxx:864
 AliITSUCATracker.cxx:865
 AliITSUCATracker.cxx:866
 AliITSUCATracker.cxx:867
 AliITSUCATracker.cxx:868
 AliITSUCATracker.cxx:869
 AliITSUCATracker.cxx:870
 AliITSUCATracker.cxx:871
 AliITSUCATracker.cxx:872
 AliITSUCATracker.cxx:873
 AliITSUCATracker.cxx:874
 AliITSUCATracker.cxx:875
 AliITSUCATracker.cxx:876
 AliITSUCATracker.cxx:877
 AliITSUCATracker.cxx:878
 AliITSUCATracker.cxx:879
 AliITSUCATracker.cxx:880
 AliITSUCATracker.cxx:881
 AliITSUCATracker.cxx:882
 AliITSUCATracker.cxx:883
 AliITSUCATracker.cxx:884
 AliITSUCATracker.cxx:885
 AliITSUCATracker.cxx:886
 AliITSUCATracker.cxx:887
 AliITSUCATracker.cxx:888
 AliITSUCATracker.cxx:889
 AliITSUCATracker.cxx:890
 AliITSUCATracker.cxx:891
 AliITSUCATracker.cxx:892
 AliITSUCATracker.cxx:893
 AliITSUCATracker.cxx:894
 AliITSUCATracker.cxx:895
 AliITSUCATracker.cxx:896
 AliITSUCATracker.cxx:897
 AliITSUCATracker.cxx:898
 AliITSUCATracker.cxx:899
 AliITSUCATracker.cxx:900
 AliITSUCATracker.cxx:901
 AliITSUCATracker.cxx:902
 AliITSUCATracker.cxx:903
 AliITSUCATracker.cxx:904
 AliITSUCATracker.cxx:905
 AliITSUCATracker.cxx:906
 AliITSUCATracker.cxx:907
 AliITSUCATracker.cxx:908
 AliITSUCATracker.cxx:909
 AliITSUCATracker.cxx:910
 AliITSUCATracker.cxx:911
 AliITSUCATracker.cxx:912
 AliITSUCATracker.cxx:913
 AliITSUCATracker.cxx:914
 AliITSUCATracker.cxx:915
 AliITSUCATracker.cxx:916
 AliITSUCATracker.cxx:917
 AliITSUCATracker.cxx:918
 AliITSUCATracker.cxx:919
 AliITSUCATracker.cxx:920
 AliITSUCATracker.cxx:921
 AliITSUCATracker.cxx:922
 AliITSUCATracker.cxx:923
 AliITSUCATracker.cxx:924
 AliITSUCATracker.cxx:925
 AliITSUCATracker.cxx:926
 AliITSUCATracker.cxx:927
 AliITSUCATracker.cxx:928
 AliITSUCATracker.cxx:929
 AliITSUCATracker.cxx:930
 AliITSUCATracker.cxx:931
 AliITSUCATracker.cxx:932
 AliITSUCATracker.cxx:933
 AliITSUCATracker.cxx:934
 AliITSUCATracker.cxx:935
 AliITSUCATracker.cxx:936
 AliITSUCATracker.cxx:937
 AliITSUCATracker.cxx:938
 AliITSUCATracker.cxx:939
 AliITSUCATracker.cxx:940
 AliITSUCATracker.cxx:941
 AliITSUCATracker.cxx:942
 AliITSUCATracker.cxx:943
 AliITSUCATracker.cxx:944
 AliITSUCATracker.cxx:945
 AliITSUCATracker.cxx:946
 AliITSUCATracker.cxx:947
 AliITSUCATracker.cxx:948
 AliITSUCATracker.cxx:949
 AliITSUCATracker.cxx:950
 AliITSUCATracker.cxx:951
 AliITSUCATracker.cxx:952
 AliITSUCATracker.cxx:953
 AliITSUCATracker.cxx:954
 AliITSUCATracker.cxx:955
 AliITSUCATracker.cxx:956
 AliITSUCATracker.cxx:957
 AliITSUCATracker.cxx:958
 AliITSUCATracker.cxx:959
 AliITSUCATracker.cxx:960
 AliITSUCATracker.cxx:961
 AliITSUCATracker.cxx:962
 AliITSUCATracker.cxx:963
 AliITSUCATracker.cxx:964
 AliITSUCATracker.cxx:965
 AliITSUCATracker.cxx:966
 AliITSUCATracker.cxx:967
 AliITSUCATracker.cxx:968
 AliITSUCATracker.cxx:969
 AliITSUCATracker.cxx:970
 AliITSUCATracker.cxx:971
 AliITSUCATracker.cxx:972
 AliITSUCATracker.cxx:973
 AliITSUCATracker.cxx:974
 AliITSUCATracker.cxx:975
 AliITSUCATracker.cxx:976
 AliITSUCATracker.cxx:977
 AliITSUCATracker.cxx:978
 AliITSUCATracker.cxx:979
 AliITSUCATracker.cxx:980
 AliITSUCATracker.cxx:981
 AliITSUCATracker.cxx:982
 AliITSUCATracker.cxx:983
 AliITSUCATracker.cxx:984
 AliITSUCATracker.cxx:985
 AliITSUCATracker.cxx:986
 AliITSUCATracker.cxx:987
 AliITSUCATracker.cxx:988
 AliITSUCATracker.cxx:989
 AliITSUCATracker.cxx:990
 AliITSUCATracker.cxx:991
 AliITSUCATracker.cxx:992
 AliITSUCATracker.cxx:993
 AliITSUCATracker.cxx:994
 AliITSUCATracker.cxx:995
 AliITSUCATracker.cxx:996
 AliITSUCATracker.cxx:997
 AliITSUCATracker.cxx:998
 AliITSUCATracker.cxx:999
 AliITSUCATracker.cxx:1000