ROOT logo
// $Id$
/*
 * Modified version of $ALICE_ROOT/TPC/AliTPCComparison.C for evaluating the
 * performance of the CA tracker. 
 * 
 * Usage:
 * <pre>
 *   aliroot AliHLTTPCTrackerEvaluation.C
 * </pre>
 *
 * documentation to be filled in when the macro is finalized 
 *
 *
 * @ingroup alihlt_tpc
 */
#if defined(__CINT__) && !defined(__MAKECINT__)

//Int_t AliHLTTPCTrackerEvaluation(const Char_t *dir=".", const char* input="AliHLTESDs.root", Float_t ptLowerCut=0.1, Float_t ptUpperCut=10., Bool_t bDedxAndClus=kFALSE)
{
  gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/TPC -I$ALICE/geant3/TGeant3");
  gROOT->LoadMacro("$ALICE_ROOT/HLT/TPCLib/macros/AliHLTTPCTrackerEvaluation.C++");
 
  AliHLTTPCTrackerEvaluation();
  // the attempt to pass the arguments with a self-called macro hasn't worked so far
  //AliHLTTPCTrackerEvaluation(dir, input, ptLowerCut, ptUpperCut, bDedxAndClus);
 
}
#else

#include <AliLog.h>
#include <TMath.h>
#include <TError.h>
#include <Riostream.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TF1.h>
#include <TTree.h>
#include <TParticle.h>
#include <TCanvas.h>
#include <TLegend.h>
#include <TLine.h>
#include <TText.h>
#include <TBenchmark.h>
#include <TStyle.h>
#include <TFile.h>
#include <TROOT.h>

#include "AliStack.h"
#include "AliHeader.h"
#include "AliTrackReference.h"
#include "AliRunLoader.h"
#include "AliRun.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliTPCtrack.h"

#include "AliSimDigits.h"
#include "AliTPC.h"
#include "AliTPCParamSR.h"
#include "AliTPCClustersArray.h"
#include "AliTPCClustersRow.h"
#include "AliTPCcluster.h"
#include "AliTPCLoader.h"
#include "TParticlePDG.h"
#include "TDatabasePDG.h"

#include "AliCDBManager.h"
#include "AliGRPManager.h"
#include "AliTPCcalibDB.h"
#include "TProfile.h"

//_______________________________________________________________________________________


Int_t GoodTPCTracks(const Char_t *dir = ".");

extern AliRun     *gAlice;
extern TBenchmark *gBenchmark;
extern TROOT      *gROOT;

static Int_t allgood     = 0;
static Int_t allselected = 0;
static Int_t allfound    = 0;



Int_t AliHLTTPCTrackerEvaluation(const Char_t *dir=".", const char* input="AliHLTESDs.root", Float_t ptLowerCut=0.1, Float_t ptUpperCut=10., Bool_t bDedxAndClus=kFALSE){
 
   if(!input){
       cerr << "please specify an input file" << endl;
       return 1;
   }

   gBenchmark->Start("AliHLTTPCTrackerEvaluation");

   AliCDBManager* man = AliCDBManager::Instance();
   man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
   man->SetRun(0);
   man->SetSpecificStorage("GRP/GRP/Data","local://$PWD");
   AliGRPManager grpman;
   if (!grpman.ReadGRPEntry() ||
       !grpman.SetMagField()) {
     cerr << "can not set magnetic field from GRP" << endl;
     return -1;
   }

   ::Info("AliHLTTPCTrackerEvaluation.C","Calculating reconstruction efficiency...");

   gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE/geant3/TGeant3");

   gStyle->SetTitleOffset(1.2,"X");
   gStyle->SetTitleOffset(1.1,"Y");

   
   // --------------- Efficiency histograms ------------------------

   TH1F *hClus      = new TH1F("hClus","# clusters on reconstructed tracks",300,0,300);  
  
   TH1F *hGood      = new TH1F("hGood",     "P_{t} distribution of MC tracks (selected for efficiency calculation)", 30, 0, 6);
   TH1F *hFake      = new TH1F("hFake",     "P_{t} distribution of fake tracks",                                     30, 0, 6);
   TH1F *hFound     = new TH1F("hFound",    "P_{t} distribution of reconstructed tracks",                            30, 0, 6);
   TH1F *hFoundMult = new TH1F("hFoundMult","P_{t} distribution of reconstructed tracks with clones",                30, 0, 6);
   TH1F *hClone     = new TH1F("hClone",    "P_{t} distribution of clone tracks",                                    30, 0, 6);
 
   TH1F *hEff      = new TH1F("hEff",     "Reconstruction efficiency based on selected MC tracks", 30, 0, 6);
   TH1F *hFakeEff  = new TH1F("hFakeEff", "Efficiency for fake tracks",                            30, 0, 6);
   TH1F *hCloneEff = new TH1F("hCloneEff","Efficiency for clone tracks",                           30, 0, 6);
 
   hEff->SetLineWidth(2);
   hEff->SetMaximum(1.4);
   hEff->SetYTitle("efficiency"); 
   hEff->GetYaxis()->CenterTitle();
   hEff->SetXTitle("P_{t} (GeV/c)");
 
   hFakeEff->SetLineColor(kRed); 
   hFakeEff->SetLineWidth(2);
 
   hCloneEff->SetLineColor(kBlue); 
   hCloneEff->SetLineWidth(2);
 
   TH2F *hDedx = new TH2F("hDedx","dE/dx vs. momentum", 50,0.,2.,50,0.,400.);
   hDedx->SetMarkerStyle(8);
   hDedx->SetMarkerSize(0.4);
   hDedx->SetXTitle("P (Gev/c)"); 
   hDedx->SetYTitle("dE/dx (a.u.)");

   TH1F *hnhit_ref = new TH1F("hnhit_ref","# clusters on reco tracks, used in fit performance",300,0,300);
   TH1F *he = new TH1F("he","dE/dx for pions with 0.4<p<0.5 GeV/c",50,0.,100.);

   // --------------- Resolution histograms ---------------------------
   
   TH2F *hPt     = new TH2F("hPt",     "", 30, 0, 6, 50,  -3,  3); 
   TH2F *hPhi    = new TH2F("hPhi",    "", 30, 0, 6, 50, -16, 16); 
   TH2F *hLambda = new TH2F("hLambda", "", 30, 0, 6, 50, -10, 10);
   TH2F *hY	 = new TH2F("hY",      "", 30, 0, 6, 30,  -5,  5); 
   TH2F *hZ	 = new TH2F("hZ",      "", 30, 0, 250, 30,  -5,  5); // fix the x axis, if this is z dependent 
   
   TProfile *hResPt     = new TProfile("hResPt",     "P_{t} resolution (%)",  30, 0, 6);
   TProfile *hResPhi    = new TProfile("hResPhi",    "#phi resolution (mrad)",   30, 0, 6);    
   TProfile *hResLambda = new TProfile("hResLambda", "#lambda resolution (mrad)",30, 0, 6);
   TProfile *hResY      = new TProfile("hResY",      "Y resolution (mm)",      30, 0, 6); 
   TProfile *hResZ      = new TProfile("hResZ",      "Z resolution (mm)",      30, 0, 250); // select appropriate x axis, KKK

   hResPt->SetXTitle("P_{t} (GeV/c)");
   hResPt->SetYTitle("#sigma_{(P_{t}-P_{t_{MC}})/P_{t_{MC}}} (%)");
   hResPt->GetYaxis()->CenterTitle(true);
   hResPt->GetYaxis()->CenterTitle(true);
  
   hResPhi->SetXTitle("P_{t} (GeV/c)");
   hResPhi->SetYTitle("#sigma_{(#phi_{rec}-#phi_{MC})} (mrad)");
   hResPhi->GetYaxis()->CenterTitle(true);

   hResLambda->SetXTitle("P_{t} (GeV/c)");
   hResLambda->SetYTitle("#sigma_{(#lambda_{rec}-#lambda_{MC})} (mrad)"); // KKK perhaps we should add the definition on the histo pad
   hResLambda->GetYaxis()->CenterTitle(true);
  
   hResY->SetXTitle("P_{t} (GeV/c)");
   hResY->SetYTitle("#sigma_{(Y_{rec}-Y_{MC})} (mm)");
   hResY->GetYaxis()->CenterTitle(true);
   
   hResZ->SetXTitle("Z (mm)");
   hResZ->SetYTitle("#sigma_{(Z_{rec}-Z_{MC})} (mm)");
   hResZ->GetYaxis()->CenterTitle(true);

   // KKK I leave the Z coordinate up to you. You can make the hResZ Z dependent.
   
   /* 
     
   TH1D *hProjPt[15], *hProjPhi[15], *hProjLambda[15], *hProjY[15], *hProjZ[15]; // I am not sure we need these histos to be pointers
   Char_t name[15];  Char_t title[100];
   
   for(Int_t i=0; i<15; i++){
       sprintf(name,"hProjPt%i",i+1);
       sprintf(title,"(Pt_{MC}-Pt_{Rec})/Pt_{MC} @ Pt#in[%f, %f] GeV/c", i-0.5, i+0.5);
       hProjPt[i] = new TH1D(name, title, 50, -3, -3); 
       
       sprintf(name,"hProjPhi%i",i+1);
       sprintf(title,"(#phi_{MC}-#phi_{Rec}) @ #phi#in[%f, %f] GeV/c", i-0.5, i+0.5);
       hProjPhi[i] = new TH1D(name, title, 50, -16, -16);        
      
       sprintf(name,"hProjLambda%i",i+1);
       sprintf(title,"(#lambda_{MC}-#lambda_{Rec}) @ #lambda#in[%f, %f] GeV/c", i-0.5, i+0.5);
       hProjLambda[i] = new TH1D(name, title, 50, -16, -16);        
       
       sprintf(name,"hProjY%i",i+1);
       sprintf(title,"(Y_{MC}-Y_{Rec}) @ Y#in[%f, %f] GeV/c", i-0.5, i+0.5);
       hProjY[i] = new TH1D(name, title, 50, -16, -16);   
       
       // here you add the hProjZ[] histograms    KKK 
   }
   */ 
   
     
   // --------------- Pull variable histograms ------------------------

   TH1F *hpullPhi  = new TH1F("hpullPhi", "SinPhi pull", 30,-10.,10.); 
   TH1F *hpullY    = new TH1F("hpullY",   "Y pull",      30,-10.,10.); 
   TH1F *hpullZ    = new TH1F("hpullZ",   "Z pull",      30,-10.,10.); 
   TH1F *hpullDzds = new TH1F("hpullDzds","Dzds pull",   30,-10.,10.); 
   TH1F *hpullK    = new TH1F("hpullK",   "Kappa pull",  30,-10.,10.); 

//---------------------------------------------------------------------------------------

   Char_t fname[100];
   sprintf(fname,"%s/GoodTPCTracks.root",dir);

   TFile *refFile = TFile::Open(fname,"old");
   if(!refFile || !refFile->IsOpen()){
      ::Info("AliHLTTPCTrackerEvaluation.C","Marking good tracks (will take a while)...");
      if(GoodTPCTracks(dir)){
         ::Error("AliHLTTPCTrackerEvaluation.C","Cannot generate the reference file!");
         return 1;
     }
   }
  
   refFile = TFile::Open(fname,"old");
   if(!refFile || !refFile->IsOpen()){
      ::Error("AliHLTTPCTrackerEvaluation.C","Cannot open the reference file!");
      return 2;
   }   
   
   //------------ access the contents of the tree created by the function GoodTracks() -------------
  
   TTree *tpcTree = (TTree*)refFile->Get("tpcTree");
   if(!tpcTree){
      ::Error("AliHLTTPCTrackerEvaluation.C","Cannot get the reference tree!");
      return 3;
   }
   
   TBranch *branch = tpcTree->GetBranch("TPC");
   if(!branch){
      ::Error("AliHLTTPCTrackerEvaluation.C","Cannot get the TPC branch!");
      return 4;
   }
  
   TClonesArray dummy("AliTrackReference",1000), *refs = &dummy;
   branch->SetAddress(&refs);

   //------------ access the HLT output --------------------

   sprintf(fname,"%s/%s", dir, input);
   TFile *ef = TFile::Open(fname);
   
   if( !ef || !ef->IsOpen() ){
      ::Error("AliHLTTPCTrackerEvaluation.C","Cannot open [%s]!",fname);
      return 5;   
   }
   
   AliESDEvent *event = new AliESDEvent();
   TTree *esdTree = NULL;
   TString tsinput = input;
   
   if(tsinput.CompareTo("AliESDs.root")==0){
      esdTree = (TTree*)ef->Get("HLTesdTree");
      if(!esdTree){
         ::Error("AliHLTTPCTrackerEvaluation.C", "no HLTESD tree found");
         return 6;
      }
   event->ReadFromTree(esdTree);
   } else if(tsinput.CompareTo("AliHLTESDs.root")==0){
      esdTree = (TTree*)ef->Get("esdTree");
      if(!esdTree){
         ::Error("AliHLTTPCTrackerEvaluation.C", "no ESD tree found");
         return 7;
      }
   event->ReadFromTree(esdTree);
   } else return 8;
      

   //---------- Loop over events -------------------

   Int_t iEvent = 0;
   while(esdTree->GetEvent(iEvent)){
     
      Int_t nEntries = event->GetNumberOfTracks();      
      cout << "********* Processing event number: " << iEvent << ", " << nEntries << " reconstructed tracks *******\n" << endl;

      allfound += nEntries;

      if(tpcTree->GetEvent(iEvent++)==0){
	 cerr << "No reconstructable tracks !\n";
         continue;
      }

      Int_t ngood = refs->GetEntriesFast(); // access the track references
      cout << ngood << " good MC tracks" << endl;
      allgood += ngood;

      const Int_t MAX = 15000;
  
      Int_t track_notfound[MAX],                            itrack_notfound   = 0;
      Int_t track_fake[MAX],                                itrack_fake       = 0;
      Int_t track_multifound[MAX], track_multifound_n[MAX], itrack_multifound = 0;

      for(Int_t i=0; i<nEntries; i++){
	  
	  hClus->Fill(event->GetTrack(i)->GetTPCNcls()); // filled but not displayed
	  cout << "TPC label for track " << i << " = " << event->GetTrack(i)->GetTPCLabel() << ", # clusters " << event->GetTrack(i)->GetTPCNcls() << endl;
      }
      
      Int_t i;
      for(Int_t k=0; k<ngood; k++){ // read the MC information

  	  AliTrackReference *ref = (AliTrackReference*)refs->UncheckedAt(k); 
         
	  Int_t  label = ref->Label();
	  Int_t tlabel = -1;
          Float_t ptMC = TMath::Sqrt(ref->Px()*ref->Px() + ref->Py()*ref->Py());
	  Float_t pMC  = TMath::Sqrt(ref->Px()*ref->Px() + ref->Py()*ref->Py()+ref->Pz()*ref->Pz());
	
          if (ptMC<1e-33 || ptMC<ptLowerCut || ptMC>ptUpperCut) continue; // first condition is for tracks not crossing padrow 0

          allselected++;

          hGood->Fill(ptMC);
	  
	  for(i=0; i<nEntries; i++){		   
	      Int_t ttlabel = event->GetTrack(i)->GetTPCLabel();
	      if( label==TMath::Abs(ttlabel) && ttlabel<0 ){
	         track_fake[itrack_fake++] = label;
	         hFake->Fill(ptMC);
	      }	      
	  }
	
          AliESDtrack *esdtrack = 0;
          for(i=0; i<nEntries; i++){            
	    esdtrack = event->GetTrack(i);
	    tlabel   = esdtrack->GetTPCLabel();
	    if(label==tlabel) break;
          }
        
	  if(i==nEntries){
	    track_notfound[itrack_notfound++] = label;
	    cout << "MC track " << label << " not reconstructed" << endl;
	    continue;
          }
      
          Int_t micount = 0;
          Int_t mi;
          AliESDtrack *mitrack;

          for(mi=0; mi<nEntries; mi++){
	      mitrack = event->GetTrack(mi);	      
	      if(label==mitrack->GetTPCLabel()) micount++;
          }
	
          if(micount>1){
	     track_multifound[itrack_multifound]   = label;
	     track_multifound_n[itrack_multifound] = micount;
	     itrack_multifound++;
	     hClone->Fill(ptMC,micount-1); 	    
          }
        
	//if((mitrack->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
        //if((mitrack->GetStatus()&AliESDtrack::kTPCin)==0)    continue;
	  cout << "MC track " << label << " reconstructed "<<micount<<" times" << endl;
	  
        if(label==tlabel){
	   hFound->Fill(ptMC);
	   //if( micount<1 ) cout<<"ERROR!!!!"<<endl;
	   hFoundMult->Fill(ptMC,micount);
	}	
	
	AliExternalTrackParam tpctrack =*(esdtrack->GetInnerParam());

	if( TMath::Abs(tpctrack.GetSigned1Pt()) <1.e-8 ) continue;
	
	Double_t mcxyz[3]   = { ref->X(), ref->Y(), ref->Z() };
	Double_t mclocal[3] = { ref->X(), ref->Y(), ref->Z() };
	
	if(1){
	  Double_t c = TMath::Cos(tpctrack.GetAlpha());
	  Double_t s = TMath::Sin(tpctrack.GetAlpha());
	  Double_t x = mclocal[0];
	  mclocal[0] = x*c + mclocal[1]*s;
	  mclocal[1] =-x*s + mclocal[1]*c;
	}
	
	if(0){	  
	  Double_t local[3] = { tpctrack.GetX(),tpctrack.GetY(),tpctrack.GetZ() };
// 	  cout << "label: "      << label << endl;
// 	  cout << "Z diff = "    << local[2] - mclocal[2] << endl;
// 	  cout << "orig rec: "   << local[0]<<" "<<local[1]<<" "<<local[2] <<" "<<TMath::Sqrt(local[0]*local[0]+local[1]*local[1])<<endl;
// 	  cout << "rotated mc: " << mclocal[0]<<" "<<mclocal[1]<<" "<<mclocal[2] <<" "<<TMath::Sqrt(mclocal[0]*mclocal[0]+mclocal[1]*mclocal[1])<<endl;
// 	  cout << "orig mc: "    << mcxyz[0]<<" "<<mcxyz[1]<<" "<<mcxyz[2]<<endl;
// 	  cout << "alpha = "     << tpctrack.GetAlpha()/TMath::Pi()*180.<<" "<<ref->Alpha()/TMath::Pi()*180.<<endl;
	}

	//cout << "X = " << mclocal[0] << " / " << tpctrack.GetX() << endl;	
	tpctrack.AliExternalTrackParam::PropagateTo(mclocal[0],5.);
       
        Double_t xyz[3], pxpypz[3]; 

	tpctrack.GetXYZ(xyz);       // GetInnerXYZ
        tpctrack.GetPxPyPz(pxpypz); // GetInnerPxPyPz
	
	Double_t local[3] = { tpctrack.GetX(),tpctrack.GetY(),tpctrack.GetZ() };
        Float_t phiRec = TMath::ATan2(pxpypz[1],pxpypz[0]);
        
	if(phiRec <= TMath::Pi()) phiRec += 2*TMath::Pi();
        if(phiRec >= TMath::Pi()) phiRec -= 2*TMath::Pi();
        
	Double_t ptRec = TMath::Sqrt(pxpypz[0]*pxpypz[0]+pxpypz[1]*pxpypz[1]);
	Double_t pRec  = TMath::Sqrt(pxpypz[0]*pxpypz[0]+pxpypz[1]*pxpypz[1]+pxpypz[2]*pxpypz[2]);
	
        Float_t  lambdaRec = TMath::ATan2(pxpypz[2],ptRec); 
        Float_t pt_1 = 1./ptRec;
	//Float_t pts_1 = tpctrack->GetSigned1Pt();
	//Float_t ptMCs_1 = ref->/ptMC;

	

        Int_t pdg = (Int_t)ref->GetLength();  // particle PDG
	const Double_t kCLight = 0.000299792458;  
	//Double_t Bz = 5.;
	Double_t q  = 0.;
	
	if( TMath::Abs(pdg)<10000 ){
	   TParticlePDG *ppdg = TDatabasePDG::Instance()->GetParticle(pdg);
	   if( ppdg ) q = ppdg->Charge()/3.;
	}
	
	Double_t kappaMC = q/ptMC; // /Bz/kCLight;
	hnhit_ref->Fill(esdtrack->GetTPCNcls());    
 
	hPt->Fill(ptMC, (ptRec - ptMC)/(ptMC)*100.);	       
	
	Float_t phiMC = TMath::ATan2(ref->Py(),ref->Px());
        hPhi->Fill(ptMC, (phiRec - phiMC)/phiMC*1000.);

        Float_t lambdaMC = TMath::ATan2(ref->Pz(),ptMC);
        hLambda->Fill(ptMC, (lambdaRec - lambdaMC)/lambdaMC*1000.);    
	
	hY->Fill(ptMC, (local[1]-mclocal[1])*10.);
	hZ->Fill( fabs(mclocal[2]), (local[2]-mclocal[2] ) *10.); // Please check hY and hZ! KKK
	
	if( tpctrack.GetSigmaY2()>0   && finite(tpctrack.GetSigmaY2())   )  hpullY   ->Fill( (local[1]-mclocal[1])/TMath::Sqrt(TMath::Abs(tpctrack.GetSigmaY2()))  );
	if( tpctrack.GetSigmaZ2()>0   && finite(tpctrack.GetSigmaZ2())   )  hpullZ   ->Fill( (local[2]-mclocal[2])/TMath::Sqrt(TMath::Abs(tpctrack.GetSigmaZ2()))  );
	if( tpctrack.GetSigmaSnp2()>0 && finite(tpctrack.GetSigmaSnp2()) )  hpullPhi ->Fill( (phiRec-phiMC)/TMath::Sqrt(TMath::Abs(tpctrack.GetSigmaSnp2()))	   );
	if( tpctrack.GetSigmaTgl2()>0 && finite(tpctrack.GetSigmaTgl2()) )  hpullDzds->Fill( (lambdaRec-lambdaMC)/TMath::Sqrt(TMath::Abs(tpctrack.GetSigmaTgl2())) );
	
	if( tpctrack.GetSigma1Pt2()>0 && finite(tpctrack.GetSigma1Pt2()) )
	if( q!=0 ) hpullK->Fill((tpctrack.GetSigned1Pt()-kappaMC)/TMath::Sqrt(TMath::Abs(tpctrack.GetSigma1Pt2())));	
 	
        Float_t dedx = esdtrack->GetTPCsignal();	
        hDedx->Fill(pRec,dedx,1.);
        
	if(TMath::Abs(pdg)==211) // pions
	   if(pRec>0.4 && pRec<0.5){
              he->Fill(dedx,1.);
           }
      } // end of loop over "good" tracks
            
      /*
      cout<<"\nList of Not found tracks :\n";
      for ( i = 0; i< itrack_notfound; i++){
        cout<<track_notfound[i]<<"\t";
        if ((i%5)==4) cout<<"\n";
      }
      cout<<"\nList of fake  tracks :\n";
      for ( i = 0; i< itrack_fake; i++){
        cout<<track_fake[i]<<"\t";
        if ((i%5)==4) cout<<"\n";
      }
      cout<<"\nList of multiple found tracks :\n";
      for ( i=0; i<itrack_multifound; i++) {
          cout<<"id.   "<<track_multifound[i]
              <<"     found - "<<track_multifound_n[i]<<"times\n";
      }

      cout<<"Number of found tracks ="<<nEntries<<endl;
      cout<<"Number of \"good\" tracks ="<<ngood<<endl;
      */
      
  refs->Clear();
  } // end of the loop over events

   delete event;
   delete esdTree;
   ef->Close();

   delete tpcTree;
   refFile->Close();

   Stat_t nGoodMC  = hGood->GetEntries();
   Stat_t nFakes   = hFake->GetEntries();
   Stat_t nClones  = hClone->GetEntries();
   Stat_t nRec     = hFound->GetEntries();
   Stat_t nRecMult = hFoundMult->GetEntries();
   
   
    if(nGoodMC!=0)         ::Info("\n\nAliHLTTPCTrackerEvaluation","Integral efficiency in (%) is about : %f\n", nRec/nGoodMC*100.); 
    if(nRecMult+nFakes!=0) ::Info("AliHLTTPCTrackerEvaluation","Integral fake rate in (%) is about  : %f\n", nFakes/(nRecMult+nFakes)*100.);
    if(nRecMult+nFakes!=0) ::Info("AliHLTTPCTrackerEvaluation","Integral clone rate in (%) is about : %f\n", nClones/(nRecMult+nFakes)*100.);
    
    ::Info("AliHLTTPCTrackerEvaluation", "Total number of selected MC tracks                    : %d\n", allgood);
    ::Info("AliHLTTPCTrackerEvaluation", "Total number of selected MC tracks with momentum cuts : %d\n", allselected);
    ::Info("AliHLTTPCTrackerEvaluation", "Total number of reconstructed tracks                  : %d\n", allfound);


   // ---------- Plotting the histograms ----------------------------------------------------------------------------
   
   hFound    ->Sumw2(); 
   hFoundMult->Sumw2(); 
   hGood     ->Sumw2(); 
   hFake     ->Sumw2(); 
   hClone    ->Sumw2();
  
   hEff     ->Divide(hFound,hGood,     1,1.,"b");
   hFakeEff ->Divide(hFake, hGood,     1,1.,"b");
   hCloneEff->Divide(hClone,hFoundMult,1,1.,"b"); 
   // KKK are you sure this is the correct definition? When plotted, it looks like we have 70% clones in the lower momenta...
   // perhaps fakes and clones should be displayed in another histogram??

   gROOT->SetStyle("Plain");
   gStyle->SetOptStat(""); //gStyle->SetOptStat(111110);
   gStyle->SetOptFit(0);  //gStyle->SetOptFit(1);
   gStyle->SetPalette(1);
 

   //--------------- canvas 0 for EFFICIENCY -------------------
   
   TCanvas *c0 = new TCanvas("c0","reconstruction efficiency",500,450);
   
   c0->cd();
   hEff     ->Draw();
   hCloneEff->Draw("histsame");
   hFakeEff ->Draw("histsame");
   
   TLegend *leg = new TLegend(0.3,0.5,0.85,0.8);
   leg->SetFillColor(10);
   leg->SetLineColor(10);
   leg->AddEntry(hEff,      "reconstruction eff.", "l");
   leg->AddEntry(hCloneEff, "clone contribution", "l");
   leg->AddEntry(hFakeEff,  "fake contribution",  "l");
   leg->Draw("same");
      
   TLine *line1 = new TLine(0,1,6,1); 
   line1->SetLineStyle(4);
   line1->Draw("same");
   
   Float_t fakeData  = nFakes/(nRecMult+nFakes)*100.;
   Float_t cloneData = nClones/(nRecMult+nFakes)*100.;
   Char_t  fakeBuf[100];
   Char_t  cloneBuf[100];

   sprintf(fakeBuf,"%d", (Int_t)fakeData);
   TString fakeStr = fakeBuf;
   fakeStr.Append(" %");
   
   sprintf(cloneBuf,"%d", (Int_t)cloneData);
   TString cloneStr = cloneBuf;
   cloneStr.Append(" %");
     
   TText *text = new TText(1.4,0.1,fakeStr.Data());
   text->SetTextSize(0.05);
   text->SetTextColor(kRed);
   text->Draw();
   text = new TText(0.6,0.3,cloneStr.Data());
   text->SetTextSize(0.05);
   text->SetTextColor(kBlue);
   text->Draw();
   
   
   //--------------- canvas 1 for RESOLUTIONS ----------------

   
   gStyle->SetOptStat(0);
   TCanvas *c1 = new TCanvas("c1","resolutions",1100,900); // please add the Y and Z projections

   TF1 *fGauss = new TF1("gauss","gaus");   
   for(Int_t i=0; i<15; i++){              
     Float_t pMin = i*6/15.;// -.5;
     Float_t pMax = (i+1)*6/15.;// +.5;
     Int_t binx1 = hPt->GetXaxis()->FindBin(pMin);
     Int_t binx2 = hPt->GetXaxis()->FindBin(pMax);
     Float_t zMin = i*250./15.;
     Float_t zMax = (i+1)*250./15.;
     Int_t binz1 = hZ->GetXaxis()->FindBin(zMin);
     Int_t binz2 = hZ->GetXaxis()->FindBin(zMax);
     //if(i>0) binx1++;
            
     TH1D *p;
     p = (hPt    ->ProjectionY("hPtProj", binx1, binx2));  
     //cout<<i<<" "<<pMin<<" "<<pMax<<" "<<binx1<<" "<<binx2<<": "<<p->GetEntries()<<endl;
     if(p->GetEntries()>50){
       fGauss->SetParameter(2,0);
       p->Fit("gauss","Q"); 
       hResPt->Fill(pMin, fGauss->GetParameter(2));fGauss->GetParError(2);
     }

     //KKK I am resetting only the sigma and its error, perhaps we should do this with all the fit parameters ???
     // SG I don't know;

     p    = (hPhi   ->ProjectionY("hPtProj2", binx1, binx2));  
     if(p->GetEntries()>50){
       fGauss->SetParameter(2,0);
       p->Fit("gauss","Q"); 
       hResPhi->Fill(pMin, fGauss->GetParameter(2)); fGauss->GetParError(2);
     }
     
     p = (hLambda->ProjectionY("hLambdaProj", binx1, binx2));  
     if(p->GetEntries()>50){
       fGauss->SetParameter(2,0);
       p->Fit("gauss","Q"); 
       hResLambda->Fill(pMin, fGauss->GetParameter(2)); fGauss->GetParError(2);
     }
     
     p     = (hY     ->ProjectionY("hYProj", binx1, binx2));  
     if(p->GetEntries()>50){
       fGauss->SetParameter(2,0);
       p->Fit("gauss","Q"); 
       hResY->Fill(pMin, fGauss->GetParameter(2)); fGauss->GetParError(2);
     }
       
     p      = (hZ     ->ProjectionY("hZProj", binz1, binz2));  
     //cout<<i<<" "<<zMin<<" "<<zMax<<" "<<binz1<<" "<<binz2<<endl;
     //cout<<p->GetEntries()<<endl;
     if(p->GetEntries()>50){
       fGauss->SetParameter(2,0);
       p->Fit("gauss","Q"); 
       hResZ->Fill(zMin, fGauss->GetParameter(2)); fGauss->GetParError(2);
     }
   }   
   
   c1->Clear(); c1->Divide(3,2);  
  
   TVirtualPad *p = c1->cd(1);
   p->SetGridy();
   hResPt->SetMarkerStyle(20);
   hResPt->Draw("P"); // KKK I haven't filled the errors for the sigma, perhaps a TGraph would make them easier to plot
  
   p = c1->cd(2);
   p->SetGridy();
   hResPhi->SetMarkerStyle(20);
   hResPhi->Draw("P");
   
   p=c1->cd(3);
   p->SetGridy();
   hResLambda->SetMarkerStyle(20);
   hResLambda->Draw("P");
   
   p=c1->cd(4);
   p->SetGridy();
   hResY->SetMarkerStyle(20);
   hResY->Draw("P");
   
   p=c1->cd(5);
   p->SetGridy();
   hResZ->SetMarkerStyle(20);
   hResZ->Draw("P");
   c1->Update();
// pad 6 stays empty
  

   //----------------- optional canvases 2 and 3 for dE/dx and clusters ----------------

   TCanvas *c2 = NULL;
   TCanvas *c3 = NULL;
   if(bDedxAndClus){     
      c2 = new TCanvas("c2","dE/dx",500,450);
      c2->cd();
      hDedx->Draw();  
        
      c3 = new TCanvas("c","clusters",500,450);
      c3->cd();   
      hClus->Draw();
      hnhit_ref->SetLineColor(kRed);
      hnhit_ref->Draw("same");
   }
   
   
   //----------------- canvas 3 for PULL VARIABLES --------------------

   TCanvas *c4 = new TCanvas("c4","pull variables",1100,900);
 
   gStyle->SetOptFit(2);
   gStyle->SetOptStat("e");

   c4->Divide(3,2);
   
   c4->cd(1);
   hpullY->Draw();
   hpullY->Fit("gaus","Q");
   
   c4->cd(2);
   hpullZ->Draw();
   hpullZ->Fit("gaus","Q");
   
   c4->cd(3);
   hpullPhi->Draw();
   hpullPhi->Fit("gaus","Q");

   c4->cd(4);
   hpullDzds->Draw();
   hpullDzds->Fit("gaus","Q");
   
   c4->cd(5);
   hpullK->Draw();
   hpullK->Fit("gaus","Q");



//-------------------- OUTPUT FILE ---------------------------------------- 
   
   TFile fc("CAtrackerEvaluation.root","RECREATE");
   c0->Write();
   c1->Write();
   if (c2) c2->Write();
   if (c3) c3->Write();
   c4->Write();
   fc.Close();
   
   gBenchmark->Stop("AliHLTTPCTrackerEvaluation");
   gBenchmark->Show("AliHLTTPCTrackerEvaluation");

   return 0;
}


//============================================================================

Int_t GoodTPCTracks(const Char_t *dir){

  Char_t fname[100];
  sprintf(fname,"%s/galice.root",dir);

  AliRunLoader *runLoader = AliRunLoader::Open(fname,"COMPARISON");
  if (!runLoader) {
     ::Error("GoodTPCTracks","Cannot start session!");
     return 1;
  }
  
  // load MC information
  
  runLoader->LoadgAlice();
  runLoader->LoadHeader();
  runLoader->LoadKinematics();
  runLoader->LoadTrackRefs();

  AliTPCLoader *tpcLoader = (AliTPCLoader*)runLoader->GetLoader("TPCLoader");
  if (tpcLoader == 0x0) {
     ::Error("GoodTPCTracks","Cannot find TPCLoader!");
     delete runLoader;
     return 2;
  }
     
  AliTPC *TPC = (AliTPC*)runLoader->GetAliRun()->GetDetector("TPC");
  Int_t tpcVersion = TPC->IsVersion(); 
  
  //cout << "TPC version "<< tpcVersion << " has been found!\n";
   
  if      (tpcVersion==1) tpcLoader->LoadRecPoints();
  else if (tpcVersion==2) tpcLoader->LoadDigits();
  else {
     ::Error("GoodTPCTracks","Wrong TPC version!");
     delete runLoader;
     return 3;
  } 

  AliCDBManager *manager = AliCDBManager::Instance();
  manager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  manager->SetRun(0);
  
  // loading the TPC parameters
  AliTPCParamSR *digp = (AliTPCParamSR*)(AliTPCcalibDB::Instance()->GetParameters());
  if (!digp) { 
    ::Error("AliHLTTPCTrackerEvaluation.C","TPC parameters have not been found!");
    delete runLoader;
    return 4; 
  }

  Int_t nrow_up     = digp->GetNRowUp();                           //get the number of pad rows in up sector
  Int_t nrows       = digp->GetNRowLow()+nrow_up;                  //get the number of pad rows in low sector and add 
  Int_t zeroSup     = digp->GetZeroSup();
  Int_t gap         = Int_t(0.125*nrows), shift = Int_t(0.5*gap);
  Int_t good_number = Int_t(0.4*nrows);                            // will be used for selecting tracks with hits in 40% of the rows

  Int_t nEvents = runLoader->GetNumberOfEvents();
  ::Info("GoodTPCTracks","Number of events : %d\n", nEvents);  

  sprintf(fname,"%s/GoodTPCTracks.root",dir);
  TFile *file = TFile::Open(fname,"recreate");

  TClonesArray dummy("AliTrackReference",1000), *refs = &dummy;
  TTree tpcTree("tpcTree","Tree with information about the reconstructable TPC tracks");
  tpcTree.Branch("TPC",&refs);

  
  
  //-------------- Loop over generated events ------------------------------
  
  for(Int_t iEvent=0; iEvent<nEvents; iEvent++){

      Int_t nt = 0;
      refs->Clear();

      Int_t i;

      runLoader->GetEvent(iEvent);  
      file->cd();

      Int_t nParticles = runLoader->GetHeader()->GetNtrack();
      //cout << "Event " << iEvent << ", Number of particles: " << nParticles << endl;

      // ------- Set the selection criteria for the MC sample that will be used for the efficiency -------
      
      Int_t *good = new Int_t[nParticles]; for(i=0; i<nParticles; i++) good[i] = 0;
      
      switch (tpcVersion){
      case 1: // not used any more
         {
           AliTPCClustersArray *pca = new AliTPCClustersArray, &ca=*pca;
           ca.Setup(digp);
           ca.SetClusterType("AliTPCcluster");
           ca.ConnectTree(tpcLoader->TreeR());
           Int_t nrows=Int_t(ca.GetTree()->GetEntries());
           for (Int_t n=0; n<nrows; n++) {
    	     AliSegmentID *s=ca.LoadEntry(n);
    	     Int_t sec,row;
    	     digp->AdjustSectorRow(s->GetID(),sec,row);
    	     AliTPCClustersRow &clrow = *ca.GetRow(sec,row);
    	     Int_t ncl=clrow.GetArray()->GetEntriesFast();
    	     while (ncl--) {
    	   	 AliTPCcluster *c=(AliTPCcluster*)clrow[ncl];
    	   	 Int_t label=c->GetLabel(0);
    	   	 if (label<0) continue; //noise cluster
    	   	 label=TMath::Abs(label);

    	   	 if (sec>=digp->GetNInnerSector())
    	   	    if (row==nrow_up-1) good[label]|=0x4000;
    	   	 if (sec>=digp->GetNInnerSector())
    	   	    if (row==nrow_up-1-gap) good[label]|=0x1000;

    	   	 if (sec>=digp->GetNInnerSector())
    	   	    if (row==nrow_up-1-shift) good[label]|=0x2000;
    	   	 if (sec>=digp->GetNInnerSector())
    	   	    if (row==nrow_up-1-gap-shift) good[label]|=0x800;

    	   	 good[label]++;
    	     }
    	     ca.ClearRow(sec,row);
           }
           delete pca;
           }
         break;
     
      case 2:
         {
           TTree *TD = tpcLoader->TreeD(); // get the digits tree
       
           AliSimDigits da, *digits = &da;
           TD->GetBranch("Segment")->SetAddress(&digits);

           Int_t *count = new Int_t[nParticles];
           Int_t i;
           for (i=0; i<nParticles; i++) count[i] = 0;

           Int_t sectors_by_rows = (Int_t)TD->GetEntries();
           
	   for(i=0; i<sectors_by_rows; i++){

    	     if (!TD->GetEvent(i)) continue;
    	     Int_t sec,row;
    	     
	     digp->AdjustSectorRow(digits->GetID(),sec,row);
             if(digits->First()){
               do { 
    	   	 Int_t it    = digits->CurrentRow();
	   	 Int_t ip    = digits->CurrentColumn(); 	 
    	   	 Short_t dig = digits->GetDigit(it,ip);
    	   	 Int_t idx0  = digits->GetTrackID(it,ip,0); 
    	   	 Int_t idx1  = digits->GetTrackID(it,ip,1);
    	   	 Int_t idx2  = digits->GetTrackID(it,ip,2);
    	   	 if(idx0>=0 && dig>=zeroSup && idx0<nParticles) count[idx0]+=1;
    	   	 if(idx1>=0 && dig>=zeroSup && idx1<nParticles) count[idx1]+=1;
    	   	 if(idx2>=0 && dig>=zeroSup && idx2<nParticles) count[idx2]+=1;
               } while (digits->Next());
             }
            
	     for(Int_t j=0; j<nParticles; j++){
    	   	
		 if(count[j]>1){
    	   	    if(sec>=digp->GetNInnerSector())
          	    if(row==nrow_up-1)  	     good[j]|=0x4000;
    	   	    if(sec>=digp->GetNInnerSector())
          	    if(row==nrow_up-1-gap)	     good[j]|=0x1000;

    	   	    if(sec>=digp->GetNInnerSector())
          	    if(row==nrow_up-1-shift)         good[j]|=0x2000;
    	   	    if(sec>=digp->GetNInnerSector())
          	    if(row==nrow_up-1-gap-shift)     good[j]|=0x800;

		    good[j]++;
    	   	 }
    	   	 count[j] = 0;
    	     } // end of loop over particles
           } // end of loop over sectors_by_rows
           delete [] count;
         } // end of case 2
         break;
      } // end of switch




    // ---------------- Select sample of MC particles that will be used for forming the efficiency ------------------
   
    AliStack *stack = runLoader->Stack();

    for(i=0; i<nParticles; i++){ // loop over stack

        if ((good[i]&0x5000) != 0x5000)//SG!!!
        if ((good[i]&0x2800) != 0x2800)     continue;
        if ((good[i]&0x7FF ) < good_number) continue;
	// N TPC rows with digits >= 64 => common checks of cluster finder & tracker
        // There are digits in rows (159&&139) || (149&&129)


        TParticle *part = (TParticle*)stack->Particle(i);
        if(part == 0x0){
	   cerr << "Cannot get particle "<< i << endl;
      	   continue;
        }
       
        if(part->Pt()<0.100) continue;                        // skip particles with pt below 0.1 GeV/c
        if(TMath::Abs(part->Pz()/part->Pt())>0.999) continue; // reject tracks outside the TPC acceptance, below 45 degrees 

        Double_t vx = part->Vx();
	Double_t vy = part->Vy();
	Double_t vz = part->Vz();
        //if (TMath::Sqrt(vx*vx+vy*vy)>3.5) continue; // vertex cuts
        //if (TMath::Abs(vz) > 50.) continue;

        AliTrackReference *ref = new((*refs)[nt])AliTrackReference();

        ref->SetLabel(i);
        Int_t pdg = part->GetPdgCode();
        ref->SetLength(pdg);  //This will the particle's PDG !
        ref->SetMomentum(0.,0.,0.);  
        ref->SetPosition(0.,0.,0.);

        nt++;
    } // end of loop over stack

    //----------- Check whether there is also information at the entrance of the TPC
    
    TTree   *TR     = runLoader->TreeTR();
    TBranch *branch = TR->GetBranch("TrackReferences");
    if(branch==0){
       ::Error("GoodTPCTracks","No track references!");
       delete runLoader;
       return 5;
    }
    
    TClonesArray tpcdummy("AliTrackReference",1000), *tpcRefs = &tpcdummy;
    branch->SetAddress(&tpcRefs);

    for(Int_t r=0; r<(Int_t)TR->GetEntries(); r++){ 

  	//cerr<<r<<' '<<(Int_t)TR->GetEntries()<<'\r';
  	TR->GetEvent(r);

	if(!tpcRefs->GetEntriesFast()) continue;
  	
	AliTrackReference *tpcRef = 0x0; 	        
	for(Int_t iref=0; iref<tpcRefs->GetEntriesFast(); ++iref){

            tpcRef = (AliTrackReference*)tpcRefs->UncheckedAt(iref);
            if(tpcRef->DetectorId() == AliTrackReference::kTPC) break;
            tpcRef = 0x0;
        }

        if(!tpcRef) continue;

  	Int_t j;
        AliTrackReference *ref = 0;
  	
	for(j=0; j<nt; j++){

          ref = (AliTrackReference*)refs->UncheckedAt(j);
  	  if(ref->Label()==tpcRef->Label()) break;
  	  ref = 0;
        }  
  	if(ref==0) continue;
        
  	ref->SetMomentum(tpcRef->Px(),tpcRef->Py(),tpcRef->Pz());
  	ref->SetPosition(tpcRef->X(), tpcRef->Y(), tpcRef->Z());

        tpcRefs->Clear();
    }

    tpcTree.Fill();

    delete [] good;
  } //---------- end of the loop over generated events
  
  tpcTree.Write();
  file->Close();

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