STEER/AliTPCComparisonMI.C

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 //                                                                           //
  19 //  Time Projection Chamber                                                  //
  20 //  Comparison macro for TPC                                                 //
  21 //  responsible:
  22 //  marian.ivanov@cern.ch                                                    //
  23 //
  24 //
  25 /*
  26 //
  27
  28
  29 .L $ALICE_ROOT/STEER/AliGenInfo.C+
  30 .L $ALICE_ROOT/STEER/AliTPCComparisonMI.C+
  31
  32
  33 TPCCmpTr *t2 = new TPCCmpTr("genTracks.root","cmpTracks.root","galice.root",-1,1,0);
  34 t2->Exec();
  35
  36
  37 TCut cprim("cprim","MC.fVDist[3]<1");
  38 TCut csec("cprim","MC.fVDist[3]>1");
  39 TCut crec("crec","fReconstructed==1");
  40 TCut cteta1("cteta1","abs(MC.fTrackRef.Theta()/3.1415-0.5)<0.25");
  41 TCut cpos1("cpos1","abs(MC.fParticle.fVz/sqrt(MC.fParticle.fVx*MC.fParticle.fVx+MC.fParticle.fVy*MC.fParticle.fVy))<1");
  42 TCut csens("csens","abs(sqrt(fVDist[0]**2+fVDist[1]**2)-170)<50");
  43 TCut cmuon("cmuon","abs(MC.fParticle.fPdgCode==-13)");
  44 AliTPCComparisonDraw comp;
  45 comp.SetIO();
  46
  47
  48 //example
  49 comp.DrawXY("fTPCinP0[3]","fTPCDelta[4]/fTPCinP1[3]","fReconstructed==1&&fPdg==-211"+cprim,"1",4,0.2,1.5,-0.06,0.06)
  50 comp.fRes->Draw();
  51 comp.fMean->Draw();
  52 comp.Eff("fTPCinP0[3]","fRowsWithDigits>120"+cteta1+cpos1,"fReconstructed>0",10,0,1.5)
  53 comp.fRes->Draw();
  54 */
  55
  56
  57
  58
  59
  60 #if !defined(__CINT__) || defined(__MAKECINT__)
  61 #include <stdio.h>
  62 #include <string.h>
  63 //ROOT includes
  64 #include "Rtypes.h"
  65 #include "TFile.h"
  66 #include "TTree.h"
  67 #include "TChain.h"
  68 #include "TCut.h"
  69 #include "TString.h"
  70 #include "TBenchmark.h"
  71 #include "TStopwatch.h"
  72 #include "TParticle.h"
  73 #include "TSystem.h"
  74 #include "TTimer.h"
  75 #include "TVector3.h"
  76 #include "TPad.h"
  77 #include "TCanvas.h"
  78 #include "TH1F.h"
  79 #include "TH2F.h"
  80 #include "TF1.h"
  81 #include "TText.h"
  82 #include "Getline.h"
  83 #include "TStyle.h"
  84
  85 //ALIROOT includes
  86 #include "AliRun.h"
  87 #include "AliStack.h"
  88 #include "AliTPCtrack.h"
  89 #include "AliSimDigits.h"
  90 #include "AliTPCParam.h"
  91 #include "AliTPC.h"
  92 #include "AliTPCLoader.h"
  93 #include "AliDetector.h"
  94 #include "AliTrackReference.h"
  95 #include "AliRun.h"
  96 #include "AliTPCParamSR.h"
  97 #include "AliTracker.h"
  98 #include "AliComplexCluster.h"
  99 #include "AliMagF.h"
 100 #endif
 101 #include "AliGenInfo.h"
 102 #include "AliTPCComparisonMI.h"
 103
 104 //
 105 //
 106
 107
 108
 109 void AliTPCRecInfo::Update(AliMCInfo* info,AliTPCParam * param, Bool_t reconstructed, Int_t direction)
 110 {
 111   //
 112   //
 113   //calculates derived variables
 114   //
 115
 116   if (reconstructed==kFALSE){
 117     fReconstructed = kFALSE;
 118     return;
 119   }
 120   fReconstructed = kTRUE;
 121   // Find the nearest track reference
 122   //
 123   Double_t radius = TMath::Sqrt(fTrack.GetX()*fTrack.GetX()+fTrack.GetY()*fTrack.GetY());
 124   TClonesArray * tpcreferences = info->fTPCReferences;
 125   Int_t nentries = tpcreferences->GetEntriesFast();
 126   AliTrackReference * ref = 0;
 127   Double_t dr = 1000000;
 128   for (Int_t i=0;i<nentries;i++){
 129     AliTrackReference * refi = (AliTrackReference*)tpcreferences->UncheckedAt(i);
 130     if (!refi) continue;
 131     //if  ( (direction<0) && (refi->R()<radius-10)) continue;
 132     //if  ( (direction>0) && (refi->R()>radius+10)) continue;
 133     if  (TMath::Abs(refi->R()-radius)<dr){
 134       dr = TMath::Abs(refi->R()-radius);
 135       ref = refi;
 136     }
 137   }
 138   if (ref==0) {
 139     fReconstructed = kFALSE;
 140     return;
 141   }
 142   //
 143   //
 144   fdEdx = fTrack.GetdEdx();
 145   //
 146   // propagate track to nearest reference in direction
 147   TVector3 local = TPCCmpTr::TR2Local(ref,param);
 148   local.GetXYZ(fTRLocalCoord);
 149   //
 150   // rotate if neccessary
 151   Float_t ymax = local.X()*TMath::Tan(0.5*param->GetInnerAngle());
 152   Float_t y = fTrack.GetYat(local.X());
 153   if (y > ymax) {
 154     fTrack.Rotate(param->GetInnerAngle());
 155   } else if (y <-ymax) {
 156     fTrack.Rotate(-param->GetInnerAngle());
 157   }
 158   Double_t xtrack = fTrack.GetX();
 159   Double_t delta = (local.X()-xtrack)*0.1;
 160   for (Int_t i=0;i<9;i++){
 161     fTrack.PropagateTo(xtrack+delta*float(i));
 162   }
 163   fTrack.PropagateTo(local.X());
 164
 165   Double_t par[5], cov[15], localX;
 166   fTrack.GetExternalParameters(localX,par);
 167   fTrack.GetExternalCovariance(cov);
 168   //
 169   //
 170   fRecPhi=TMath::ASin(par[2]) + fTrack.GetAlpha();
 171   Double_t phi2 =TMath::ATan2(ref->Py(),ref->Px());
 172   if (phi2<0) phi2+=2*TMath::Pi();
 173   fGenPhi =phi2;
 174   //
 175   if (fRecPhi<0) fRecPhi+=2*TMath::Pi();
 176   if (fRecPhi>=2*TMath::Pi()) fRecPhi-=2*TMath::Pi();
 177   fLambda = TMath::ATan(par[3]);
 178   fRecPt_1 = TMath::Abs(par[4]);
 179   //TPC
 180   //
 181   //
 182   Double_t phi=TMath::ATan2(par[0],localX) + fTrack.GetAlpha();
 183   Double_t r=TMath::Sqrt(localX*localX + par[0]*par[0]);
 184   fTPCinR1[0]= r*TMath::Cos(phi);
 185   fTPCinR1[1]= r*TMath::Sin(phi);
 186   fTPCinR1[2]= par[1];
 187   fTPCinR1[3] = TMath::Sqrt(fTPCinR1[0]*fTPCinR1[0]+fTPCinR1[1]*fTPCinR1[1]);
 188   fTPCinR1[4] = TMath::ATan2(fTPCinR1[1],fTPCinR1[0]);
 189   //
 190   fTPCinP1[0] = fTrack.Px();
 191   fTPCinP1[1] = fTrack.Py();
 192   fTPCinP1[2] = fTrack.Pz();
 193   fTPCinP1[3] = TMath::Sqrt(fTPCinP1[0]*fTPCinP1[0]+fTPCinP1[1]*fTPCinP1[1]);
 194   //
 195   fTPCinR0[0] = ref->X();
 196   fTPCinR0[1] = ref->Y();
 197   fTPCinR0[2] = ref->Z();
 198   fTPCinR0[3] = TMath::Sqrt(fTPCinR0[0]*fTPCinR0[0]+fTPCinR0[1]*fTPCinR0[1]);
 199   fTPCinR0[4] = TMath::ATan2(fTPCinR0[1],fTPCinR0[0]);
 200   //
 201   fTPCinP0[0]=ref->Px();
 202   fTPCinP0[1]=ref->Py();
 203   fTPCinP0[2]=ref->Pz();
 204   fTPCinP0[3]=ref->Pt();
 205   //
 206   //
 207   if (fTPCinP1[3]>0.0000001){
 208     fTPCAngle1[0] = TMath::ATan2(fTPCinP1[1],fTPCinP1[0]);
 209     fTPCAngle1[1] = TMath::ATan(fTPCinP1[2]/fTPCinP1[3]);
 210     //
 211     fTPCAngle0[0] = TMath::ATan2(fTPCinP0[1],fTPCinP0[0]);
 212     fTPCAngle0[1] = TMath::ATan(fTPCinP0[2]/fTPCinP0[3]);
 213   }
 214   //
 215   fTPCDelta[0] = (fTPCinR0[4]-fTPCinR1[4])*fTPCinR1[3];  //delta rfi
 216   fTPCPools[0] = fTPCDelta[0]/TMath::Sqrt(cov[0]);
 217   fTPCDelta[1] = (fTPCinR0[2]-fTPCinR1[2]);              //delta z
 218   fTPCPools[1] = fTPCDelta[1]/TMath::Sqrt(cov[2]);
 219   //
 220   fTPCDelta[2] = (fTPCAngle0[0]-fTPCAngle1[0]);
 221   fTPCPools[2] = fTPCDelta[2]/TMath::Sqrt(cov[5]);
 222   //
 223   fTPCDelta[3] = TMath::Tan(fTPCAngle0[1])-TMath::Tan(fTPCAngle1[1]);
 224   fTPCPools[3] = fTPCDelta[3]/TMath::Sqrt(cov[9]);
 225   fTPCDelta[4] = (fTPCinP0[3]-fTPCinP1[3]);
 226   Double_t sign = (fTrack.GetC()>0) ? 1:-1;
 227   fTPCPools[4] = sign*(1./fTPCinP0[3]-1./fTPCinP1[3])/TMath::Sqrt(cov[14]);
 228
 229 }
 230
 231
 232
 233
 234 ////////////////////////////////////////////////////////////////////////
 235 TPCCmpTr::TPCCmpTr()
 236 {
 237   Reset();
 238 }
 239
 240 ////////////////////////////////////////////////////////////////////////
 241 TPCCmpTr::TPCCmpTr(const char* fnGenTracks,
 242                    const char* fnCmp,
 243                    const char* fnGalice, Int_t direction,
 244                    Int_t nEvents, Int_t firstEvent)
 245 {
 246   Reset();
 247   //  fFnGenTracks = fnGenTracks;
 248   //  fFnCmp = fnCmp;
 249   sprintf(fFnGenTracks,"%s",fnGenTracks);
 250   sprintf(fFnCmp,"%s",fnCmp);
 251
 252   fFirstEventNr = firstEvent;
 253   fEventNr = firstEvent;
 254   fNEvents = nEvents;
 255   fDirection = direction;
 256   //
 257   fLoader = AliRunLoader::Open(fnGalice);
 258   if (gAlice){
 259     //delete gAlice->GetRunLoader();
 260     delete gAlice;
 261     gAlice = 0x0;
 262   }
 263   if (fLoader->LoadgAlice()){
 264     cerr<<"Error occured while l"<<endl;
 265   }
 266   Int_t nall = fLoader->GetNumberOfEvents();
 267   if (nEvents==0) {
 268     nEvents =nall;
 269     fNEvents=nall;
 270     fFirstEventNr=0;
 271   }
 272
 273   if (nall<=0){
 274     cerr<<"no events available"<<endl;
 275     fEventNr = 0;
 276     return;
 277   }
 278   if (firstEvent+nEvents>nall) {
 279     fEventNr = nall-firstEvent;
 280     cerr<<"restricted number of events availaible"<<endl;
 281   }
 282   AliMagF * magf = gAlice->Field();
 283   AliTracker::SetFieldMap(magf);
 284
 285 }
 286
 287
 288 ////////////////////////////////////////////////////////////////////////
 289 TPCCmpTr::~TPCCmpTr()
 290 {
 291   //if (fLoader) {
 292   //  delete fLoader;
 293   //}
 294 }
 295
 296 //////////////////////////////////////////////////////////////
 297 Int_t TPCCmpTr::SetIO()
 298 {
 299   //
 300   //
 301   CreateTreeCmp();
 302   if (!fTreeCmp) return 1;
 303   fParamTPC = GetTPCParam();
 304   //
 305   if (!ConnectGenTree()) {
 306     cerr<<"Cannot connect tree with generated tracks"<<endl;
 307     return 1;
 308   }
 309   return 0;
 310 }
 311
 312 //////////////////////////////////////////////////////////////
 313
 314 Int_t TPCCmpTr::SetIO(Int_t eventNr)
 315 {
 316   //
 317   //
 318   // SET INPUT
 319   //gAlice->GetEvent(eventNr);
 320   //  fLoader->SetEventNumber(eventNr);
 321   //fLoader = AliRunLoader::Open("galice.root");
 322   fLoader->GetEvent(eventNr);
 323   //
 324   AliTPCLoader * tpcl = (AliTPCLoader*)fLoader->GetLoader("TPCLoader");
 325   tpcl->LoadTracks();
 326   fTreeRecTracks = tpcl->TreeT();
 327
 328   //
 329   return 0;
 330 }
 331
 332
 333
 334 ////////////////////////////////////////////////////////////////////////
 335 void TPCCmpTr::Reset()
 336 {
 337   fEventNr = 0;
 338   fNEvents = 0;
 339   fTreeCmp = 0;
 340   //
 341   fFileGenTracks = 0;
 342   fDebug = 0;
 343   //
 344   fParamTPC = 0;
 345   fTreeRecTracks = 0;
 346   fTreePoints =0;
 347
 348   fTPCTrack = 0;
 349   fTracks   = 0;
 350   fTrackPoints =0;
 351 }
 352
 353 ////////////////////////////////////////////////////////////////////////
 354 Int_t TPCCmpTr::Exec(Int_t nEvents, Int_t firstEventNr)
 355 {
 356   fNEvents = nEvents;
 357   fFirstEventNr = firstEventNr;
 358   return Exec();
 359 }
 360
 361 ////////////////////////////////////////////////////////////////////////
 362 Int_t TPCCmpTr::Exec()
 363 {
 364   TStopwatch timer;
 365   timer.Start();
 366
 367   if (SetIO()==1)
 368     return 1;
 369
 370   cerr<<"fFirstEventNr, fNEvents: "<<fFirstEventNr<<" "<<fNEvents<<endl;
 371   for (Int_t eventNr = fFirstEventNr; eventNr < fFirstEventNr+fNEvents;
 372        eventNr++) {
 373     fEventNr=eventNr;
 374     SetIO(fEventNr);
 375     fNParticles = gAlice->GetEvent(fEventNr);
 376
 377     fIndexRecTracks = new Int_t[fNParticles*4];  //write at maximum 4 tracks corresponding to particle
 378     fFakeRecTracks = new Int_t[fNParticles];
 379     fMultiRecTracks = new Int_t[fNParticles];
 380     for (Int_t i = 0; i<fNParticles; i++) {
 381       fIndexRecTracks[4*i] = -1;
 382       fIndexRecTracks[4*i+1] = -1;
 383       fIndexRecTracks[4*i+2] = -1;
 384       fIndexRecTracks[4*i+3] = -1;
 385
 386       fFakeRecTracks[i] = 0;
 387       fMultiRecTracks[i] = 0;
 388     }
 389
 390     cout<<"Start to process event "<<fEventNr<<endl;
 391     cout<<"\tfNParticles = "<<fNParticles<<endl;
 392     if (fDebug>2) cout<<"\tStart loop over TreeT"<<endl;
 393     if (TreeTLoop(eventNr)>0) return 1;
 394
 395     if (fDebug>2) cout<<"\tStart loop over tree genTracks"<<endl;
 396     if (TreeGenLoop(eventNr)>0) return 1;
 397     if (fDebug>2) cout<<"\tEnd loop over tree genTracks"<<endl;
 398
 399     delete [] fIndexRecTracks;
 400     delete [] fFakeRecTracks;
 401     delete [] fMultiRecTracks;
 402   }
 403
 404   CloseOutputFile();
 405
 406   cerr<<"Exec finished"<<endl;
 407   timer.Stop();
 408   timer.Print();
 409   return 0;
 410
 411 }
 412 ////////////////////////////////////////////////////////////////////////
 413 Bool_t TPCCmpTr::ConnectGenTree()
 414 {
 415 //
 416 // connect all branches from the genTracksTree
 417 // use the same variables as for the new cmp tree, it may work
 418 //
 419   fFileGenTracks = TFile::Open(fFnGenTracks,"READ");
 420   if (!fFileGenTracks) {
 421     cerr<<"Error in ConnectGenTree: cannot open file "<<fFnGenTracks<<endl;
 422     return kFALSE;
 423   }
 424   fTreeGenTracks = (TTree*)fFileGenTracks->Get("genTracksTree");
 425   if (!fTreeGenTracks) {
 426     cerr<<"Error in ConnectGenTree: cannot find genTracksTree in the file "
 427         <<fFnGenTracks<<endl;
 428     return kFALSE;
 429   }
 430   //
 431   fMCInfo = new AliMCInfo;
 432   fTreeGenTracks->SetBranchAddress("MC",&fMCInfo);
 433
 434
 435   if (fDebug > 1) {
 436     cout<<"Number of gen. tracks with TR: "<<fTreeGenTracks->GetEntries()<<endl;
 437   }
 438   return kTRUE;
 439 }
 440
 441
 442 ////////////////////////////////////////////////////////////////////////
 443 void TPCCmpTr::CreateTreeCmp()
 444 {
 445   fFileCmp = TFile::Open(fFnCmp,"RECREATE");
 446   if (!fFileCmp) {
 447     cerr<<"Error in CreateTreeCmp: cannot open file "<<fFnCmp<<endl;
 448     return;
 449   }
 450
 451
 452   fTreeCmp    = new TTree("TPCcmpTracks","TPCcmpTracks");
 453   //
 454   fMCInfo = new AliMCInfo;
 455   fRecInfo = new AliTPCRecInfo;
 456   //
 457   fTPCTrack = new AliTPCtrack;
 458    //
 459   fTreeCmp->Branch("MC","AliMCInfo",&fMCInfo);
 460   fTreeCmp->Branch("RC","AliTPCRecInfo",&fRecInfo);
 461   fTreeCmp->Branch("fTPCTrack","AliTPCtrack",&fTPCTrack);
 462   //
 463   fTreeCmp->AutoSave();
 464
 465 }
 466 ////////////////////////////////////////////////////////////////////////
 467 void TPCCmpTr::CloseOutputFile()
 468 {
 469   if (!fFileCmp) {
 470     cerr<<"File "<<fFnCmp<<" not found as an open file."<<endl;
 471     return;
 472   }
 473   fFileCmp->cd();
 474   fTreeCmp->Write();
 475   delete fTreeCmp;
 476
 477   fFileCmp->Close();
 478   delete fFileCmp;
 479   return;
 480 }
 481 ////////////////////////////////////////////////////////////////////////
 482
 483 TVector3 TPCCmpTr::TR2Local(AliTrackReference *trackRef,
 484                             AliTPCParam *paramTPC) {
 485
 486   Float_t x[3] = { trackRef->X(),trackRef->Y(),trackRef->Z()};
 487   Int_t index[4];
 488   paramTPC->Transform0to1(x,index);
 489   paramTPC->Transform1to2(x,index);
 490   return TVector3(x);
 491 }
 492 ////////////////////////////////////////////////////////////////////////
 493
 494 Int_t TPCCmpTr::TreeTLoop(Int_t eventNr)
 495 {
 496   //
 497   // loop over all TPC reconstructed tracks and store info in memory
 498   //
 499   TStopwatch  timer;
 500   timer.Start();
 501
 502   if (!fTreeRecTracks) {
 503     cerr<<"Can't get a tree with TPC rec. tracks  "<<endl;
 504     return 1;
 505   }
 506   //fTreePoints=(TTree*)fFileRecTracks->Get("trackDebug");
 507
 508   Int_t nEntries = (Int_t) fTreeRecTracks->GetEntries();
 509   if (fDebug > 2) cout<<"Event, rec. tracks: "<<eventNr<<" "
 510                       <<nEntries<<endl;
 511   TBranch * br= fTreeRecTracks->GetBranch("tracks");
 512   br->SetAddress(&fTPCTrack);
 513   TBranch *brp = 0;
 514   if (fTreePoints) brp = fTreePoints->GetBranch("debug");
 515
 516   if (fTracks){
 517     fTracks->Delete();
 518     delete fTracks;
 519   }
 520   if (fTrackPoints){
 521     fTrackPoints->Delete();
 522     delete fTrackPoints;
 523     fTrackPoints =0;
 524   }
 525   fTracks      = new TObjArray(nEntries);
 526   if (brp){
 527     fTrackPoints = new TObjArray(nEntries);
 528   }
 529   else fTrackPoints = 0;
 530
 531   //
 532   //load tracks to the memory
 533   for (Int_t i=0; i<nEntries;i++){
 534     AliTPCtrack * track = new AliTPCtrack;
 535     br->SetAddress(&track);
 536     br->GetEntry(i);
 537     fTracks->AddAt(track,i);
 538   }
 539   //
 540   //load track points to the memory
 541   if (brp) for (Int_t i=0; i<nEntries;i++){
 542     TClonesArray * arr = new TClonesArray("AliTPCTrackPoint2");
 543     brp->SetAddress(&arr);
 544     brp->GetEntry(i);
 545     if (arr!=0)
 546       for (Int_t j=0;j<arr->GetEntriesFast();j++){
 547         AliTPCTrackPoint2 * point = (AliTPCTrackPoint2*)arr->UncheckedAt(j);
 548         if (point && point->fID>=0){
 549           fTrackPoints->AddAt(arr,point->fID);
 550           break;
 551         }
 552       }
 553   }
 554   //
 555
 556   //
 557   for (Int_t iEntry=0; iEntry<nEntries;iEntry++){
 558     //br->GetEntry(iEntry);
 559     fTPCTrack = (AliTPCtrack*)fTracks->UncheckedAt(iEntry);
 560     //
 561     Int_t label = fTPCTrack->GetLabel();
 562     Int_t absLabel = abs(label);
 563     if (absLabel < fNParticles) {
 564       //      fIndexRecTracks[absLabel] =  iEntry;
 565       if (label < 0) fFakeRecTracks[absLabel]++;
 566
 567       if (fMultiRecTracks[absLabel]>0){
 568         if (fMultiRecTracks[absLabel]<4)
 569           fIndexRecTracks[absLabel*4+fMultiRecTracks[absLabel]] =  iEntry;
 570       }
 571       else
 572         fIndexRecTracks[absLabel*4] =  iEntry;
 573       fMultiRecTracks[absLabel]++;
 574     }
 575   }
 576   printf("Time spended in TreeTLoop\n");
 577   timer.Print();
 578
 579   if (fDebug > 2) cerr<<"end of TreeTLoop"<<endl;
 580
 581   return 0;
 582 }
 583
 584 ////////////////////////////////////////////////////////////////////////
 585 Int_t TPCCmpTr::TreeGenLoop(Int_t eventNr)
 586 {
 587 //
 588 // loop over all entries for a given event, find corresponding
 589 // rec. track and store in the fTreeCmp
 590 //
 591   TStopwatch timer;
 592   timer.Start();
 593   Int_t entry = 0;
 594   Double_t nParticlesTR = fTreeGenTracks->GetEntriesFast();
 595   TBranch * branch = fTreeCmp->GetBranch("RC");
 596   branch->SetAddress(&fRecInfo); // set all pointers
 597
 598   while (entry < nParticlesTR) {
 599     fTreeGenTracks->GetEntry(entry);
 600     entry++;
 601     if (eventNr < fMCInfo->fEventNr) continue;
 602     if (eventNr > fMCInfo->fEventNr) continue;
 603     //
 604     if (fDebug > 2 && fMCInfo->fLabel < 10) {
 605       cerr<<"Fill track with a label "<<fMCInfo->fLabel<<endl;
 606     }
 607     fRecInfo->Reset();
 608     //
 609     if (fIndexRecTracks[fMCInfo->fLabel*4] >= 0) {
 610       fTPCTrack= (AliTPCtrack*)fTracks->UncheckedAt(fIndexRecTracks[fMCInfo->fLabel*4]);
 611
 612       //      if (nBytes > 0) {
 613       if (fTPCTrack) {
 614         //
 615         //
 616         //if multifound find track with biggest pt - returning tracks - loos energy
 617         //
 618         if (fIndexRecTracks[fMCInfo->fLabel*4]+1){
 619           Double_t pt = fTPCTrack-Pt();
 620           for (Int_t i=1;i<4;i++){
 621             if (fIndexRecTracks[fMCInfo->fLabel*4+i]>=0){
 622               AliTPCtrack * track = (AliTPCtrack*)fTracks->UncheckedAt(fIndexRecTracks[fMCInfo->fLabel*4+i]);
 623               Double_t pt2 = TMath::Abs(1/track->Get1Pt());
 624               if  (pt2>pt)
 625                 fTPCTrack = track;
 626             }
 627           }
 628         }
 629         //
 630         fRecInfo->fTP=0;
 631         fRecInfo->fTrack =*fTPCTrack;
 632         fRecInfo->fReconstructed = 1;
 633         fRecInfo->fFake = fFakeRecTracks[fMCInfo->fLabel];
 634         fRecInfo->fMultiple = fMultiRecTracks[fMCInfo->fLabel];
 635         fRecInfo->Update(fMCInfo, fParamTPC, kTRUE, 1);
 636       }
 637     }
 638     else{
 639       fRecInfo->Update(fMCInfo, fParamTPC, kFALSE, 1);
 640     }
 641     fTreeCmp->Fill();
 642   }
 643   fTreeCmp->AutoSave();
 644   fTracks->Delete();
 645   fTPCTrack =0;
 646   if (fTrackPoints){
 647     fTrackPoints->Delete();
 648     delete fTrackPoints;
 649     fTrackPoints =0;
 650   }
 651   printf("Time spended in TreeGenLoop\n");
 652   timer.Print();
 653   if (fDebug > 2) cerr<<"end of TreeGenLoop"<<endl;
 654   return 0;
 655 }
 656
 657
 658 ////////////////////////////////////////////////////////////////////////
 659 ////////////////////////////////////////////////////////////////////////
 660
 661 void AliTPCComparisonDraw::SetIO(const char *fname)
 662 {
 663   TFile *file = TFile::Open(fname);
 664   if (!file){
 665     printf("Comparison file couldn't be generated\n");
 666     return;
 667    }
 668   //
 669   fTree = (TTree*) file->Get("TPCcmpTracks");
 670   if (!fTree) {
 671     printf("no track comparison tree found\n");
 672     file->Close();
 673     delete file;
 674   }
 675
 676 }
 677
 678 void AliTPCComparisonDraw::Eff()
 679 {
 680
 681 }
 682
 683 void AliTPCComparisonDraw::ResPt()
 684 {
 685 }