ROOT logo
// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

#if !defined(__CINT__) || defined(__MAKECINT__)
#include <TString.h>
#include <TSystem.h>
#include <TROOT.h>
#include <TMath.h>
#include <TGListTree.h>
#include <TEveVSDStructs.h>
#include <TEveManager.h>
#include <TEveTrackPropagator.h>

#include <AliESDtrackCuts.h>
#include <AliPWG0Helper.h>
#include <AliESDEvent.h>
#include <AliESDfriend.h>
#include <AliESDtrack.h>
#include <AliESDfriendTrack.h>
#include <AliExternalTrackParam.h>
#include <AliEveTrack.h>
#include <AliEveTrackCounter.h>
#include <AliEveMagField.h>
#include <AliEveEventManager.h>
#endif


// Use inner-tpc track params when its refit failed.
Bool_t g_esd_tracks_use_ip_on_failed_its_refit = kFALSE;

// Use magnetic-field as retrieved from GRP.
Bool_t g_esd_tracks_true_field = kTRUE;

// Use Runge-Kutta track stepper.
Bool_t g_esd_tracks_rk_stepper = kFALSE;


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

void esd_track_propagator_setup(TEveTrackPropagator* trkProp,
				Float_t magF, Float_t maxR)
{
  if (g_esd_tracks_true_field)
  {
    trkProp->SetMagFieldObj(new AliEveMagField);
  }
  else
  {
    trkProp->SetMagField(magF);
  }
  if (g_esd_tracks_rk_stepper)
  {
    trkProp->SetStepper(TEveTrackPropagator::kRungeKutta);
  }
  trkProp->SetMaxR(maxR);
}

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

TString esd_track_title(AliESDtrack* t)
{
  TString s;

  Int_t label = t->GetLabel(), index = t->GetID();
  TString idx(index == kMinInt ? "<undef>" : Form("%d", index));
  TString lbl(label == kMinInt ? "<undef>" : Form("%d", label));

  Double_t p[3], v[3];
  t->GetXYZ(v);
  t->GetPxPyPz(p);
  Double_t pt    = t->Pt();
  Double_t ptsig = TMath::Sqrt(t->GetSigma1Pt2());
  Double_t ptsq  = pt*pt;
  Double_t ptm   = pt / (1.0 + pt*ptsig);
  Double_t ptM   = pt / (1.0 - pt*ptsig);

  s = Form("Index=%s, Label=%s\nChg=%d, Pdg=%d\n"
	   "pT = %.3f + %.3f - %.3f [%.3f]\n"
           "P  = (%.3f, %.3f, %.3f)\n"
           "V  = (%.3f, %.3f, %.3f)\n",
	   idx.Data(), lbl.Data(), t->Charge(), 0,
	   pt, ptM - pt, pt - ptm, ptsig*ptsq,
           p[0], p[1], p[2],
           v[0], v[1], v[2]);

  Int_t   o;
  s += "Det (in,out,refit,pid):\n";
  o  = AliESDtrack::kITSin;
  s += Form("ITS (%d,%d,%d,%d)  ",  t->IsOn(o), t->IsOn(o<<1), t->IsOn(o<<2), t->IsOn(o<<3));
  o  = AliESDtrack::kTPCin;
  s += Form("TPC(%d,%d,%d,%d)\n",   t->IsOn(o), t->IsOn(o<<1), t->IsOn(o<<2), t->IsOn(o<<3));
  o  = AliESDtrack::kTRDin;
  s += Form("TRD(%d,%d,%d,%d) ",    t->IsOn(o), t->IsOn(o<<1), t->IsOn(o<<2), t->IsOn(o<<3));
  o  = AliESDtrack::kTOFin;
  s += Form("TOF(%d,%d,%d,%d)\n",   t->IsOn(o), t->IsOn(o<<1), t->IsOn(o<<2), t->IsOn(o<<3));
  o  = AliESDtrack::kHMPIDout;
  s += Form("HMPID(out=%d,pid=%d)\n", t->IsOn(o), t->IsOn(o<<1));
  s += Form("ESD pid=%d", t->IsOn(AliESDtrack::kESDpid));

  if (t->IsOn(AliESDtrack::kESDpid))
  {
    Double_t pid[5];
    t->GetESDpid(pid);
    s += Form("\n[%.2f %.2f %.2f %.2f %.2f]", pid[0], pid[1], pid[2], pid[3], pid[4]);
  }

  return s;
}

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

void esd_track_add_param(AliEveTrack* track, const AliExternalTrackParam* tp)
{
  // Add additional track parameters as a path-mark to track.

  if (tp == 0)
    return;

  Double_t pbuf[3], vbuf[3];
  tp->GetXYZ(vbuf);
  tp->GetPxPyPz(pbuf);

  TEvePathMark pm(TEvePathMark::kReference);
  pm.fV.Set(vbuf);
  pm.fP.Set(pbuf);
  track->AddPathMark(pm);
}

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

AliEveTrack* esd_make_track_TPC(AliESDtrack *at, AliESDfriendTrack* aft, TEveTrackList* cont)
{
  // Make a TPC track representation and put it into given container.

  AliEveTrack* track = new AliEveTrack(at, cont->GetPropagator());
  track->SetAttLineAttMarker(cont);
  track->SetName(Form("AliEveTrack %d", at->GetID()));
  track->SetElementTitle(esd_track_title(at));
  track->SetSourceObject(at);

  // Add inner/outer track parameters as start point and pathmark.
  if (at->GetInnerParam()) track->SetStartParams(at->GetInnerParam());
  else return NULL;
  if (aft->GetTPCOut()) esd_track_add_param(track, aft->GetTPCOut());
  else return NULL;

  return track;
}

AliEveTrack* esd_make_track_ITS_standalone(AliESDtrack *at, AliESDfriendTrack* aft, TEveTrackList* cont)
{
  // Make a ITS standalone track representation and put it into given container.

  if ( !(!at->IsOn(AliESDtrack::kTPCin) &&
          at->IsOn(AliESDtrack::kITSout)) ) return NULL; //only ITS standalone
  AliEveTrack* track = new AliEveTrack(at, cont->GetPropagator());
  track->SetAttLineAttMarker(cont);
  track->SetName(Form("AliEveTrack %d", at->GetID()));
  track->SetElementTitle(esd_track_title(at));
  track->SetSourceObject(at);

  // Add inner/outer track parameters as path-marks.
  if (aft->GetITSOut())
  {
    esd_track_add_param(track, aft->GetITSOut());
  }
  else return NULL;

  return track;
}

AliEveTrack* esd_make_track_ITS(AliESDtrack *at, AliESDfriendTrack* aft, TEveTrackList* cont)
{
  // Make a ITS track representation and put it into given container.

  if ( (!at->IsOn(AliESDtrack::kTPCin) &&
         at->IsOn(AliESDtrack::kITSout)) ) return NULL; //ignore ITS standalone
  AliEveTrack* track = new AliEveTrack(at, cont->GetPropagator());
  track->SetAttLineAttMarker(cont);
  track->SetName(Form("AliEveTrack %d", at->GetID()));
  track->SetElementTitle(esd_track_title(at));
  track->SetSourceObject(at);

  // Add inner/outer track parameters as path-marks.
  if (aft->GetITSOut())
  {
    esd_track_add_param(track, aft->GetITSOut());
  }
  else return NULL;

  return track;
}

AliEveTrack* esd_make_track(AliESDtrack *at, TEveTrackList* cont)
{
  // Make a standard track representation and put it into given container.

  // Choose which parameters to use a track's starting point.
  // If gkFixFailedITSExtr is TRUE (FALSE by default) and
  // if ITS refit failed, take track parameters at inner TPC radius.

  const AliExternalTrackParam* tp = at;

  Bool_t innerTaken = kFALSE;
  if ( ! at->IsOn(AliESDtrack::kITSrefit) && g_esd_tracks_use_ip_on_failed_its_refit)
  {
    tp = at->GetInnerParam();
    innerTaken = kTRUE;
  }

  AliEveTrack* track = new AliEveTrack(at, cont->GetPropagator());
  track->SetAttLineAttMarker(cont);
  track->SetName(Form("AliEveTrack %d", at->GetID()));
  track->SetElementTitle(esd_track_title(at));
  track->SetSourceObject(at);

  // Add inner/outer track parameters as path-marks.
  if (at->IsOn(AliESDtrack::kTPCrefit))
  {
    if ( ! innerTaken)
    {
      esd_track_add_param(track, at->GetInnerParam());
    }
    esd_track_add_param(track, at->GetOuterParam());
  }

  return track;
}


//==============================================================================
// esd_tracks()
//==============================================================================

TEveTrackList* esd_tracks_TPC()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();
  AliESDfriend* esd_friend = AliEveEventManager::AssertESDfriend();

  TEveTrackList* cont = new TEveTrackList("TPC Tracks");
  cont->SetMainColor(kMagenta);

  esd_track_propagator_setup(cont->GetPropagator(),
			     0.1*esd->GetMagneticField(), 520);

  gEve->AddElement(cont);

  Int_t count = 0;
  for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
  {
    ++count;
    if (!esd->GetTrack(n)) continue;
    if (!esd_friend->GetTrack(n)) continue;
    AliEveTrack* track = esd_make_track_TPC(esd->GetTrack(n), esd_friend->GetTrack(n), cont);
    if (!track) continue;

    cont->AddElement(track);
  }
  cont->SetTitle(Form("N=%d", count));
  cont->MakeTracks();

  gEve->Redraw3D();

  return cont;
}

TEveTrackList* esd_tracks_ITS()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();
  AliESDfriend* esd_friend = AliEveEventManager::AssertESDfriend();

  TEveTrackList* cont = new TEveTrackList("ITS Tracks");
  cont->SetMainColor(kMagenta+3);

  esd_track_propagator_setup(cont->GetPropagator(),
			     0.1*esd->GetMagneticField(), 520);
  cont->GetPropagator()->SetMaxR(85.0);
  cont->SetLineWidth(1);

  gEve->AddElement(cont);

  Int_t count = 0;
  for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
  {
    ++count;
    if (!esd->GetTrack(n)) continue;
    if (!esd_friend->GetTrack(n)) continue;
    AliEveTrack* track = esd_make_track_ITS(esd->GetTrack(n), esd_friend->GetTrack(n), cont);
    if (!track) continue;

    cont->AddElement(track);
  }
  cont->SetTitle(Form("N=%d", count));
  cont->MakeTracks();

  gEve->Redraw3D();

  return cont;
}

TEveTrackList* esd_tracks_ITS_standalone()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();
  AliESDfriend* esd_friend = AliEveEventManager::AssertESDfriend();

  TEveTrackList* cont = new TEveTrackList("ITS Standalone Tracks");
  cont->SetMainColor(kBlue);

  esd_track_propagator_setup(cont->GetPropagator(),
			     0.1*esd->GetMagneticField(), 520);
  cont->GetPropagator()->SetMaxR(85.0);
  cont->SetLineWidth(1);

  gEve->AddElement(cont);

  Int_t count = 0;
  for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
  {
    ++count;
    if (!esd->GetTrack(n)) continue;
    if (!esd_friend->GetTrack(n)) continue;
    AliEveTrack* track = esd_make_track_ITS_standalone(esd->GetTrack(n), esd_friend->GetTrack(n), cont);
    if (!track) continue;

    cont->AddElement(track);
  }
  cont->SetTitle(Form("N=%d", count));
  cont->MakeTracks();

  gEve->Redraw3D();

  return cont;
}

TEveTrackList* esd_tracks()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();

  TEveTrackList* cont = new TEveTrackList("ESD Tracks");
  cont->SetMainColor(6);

  esd_track_propagator_setup(cont->GetPropagator(),
			     0.1*esd->GetMagneticField(), 520);

  gEve->AddElement(cont);

  Int_t count = 0;
  for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
  {
    ++count;
    AliEveTrack* track = esd_make_track(esd->GetTrack(n), cont);

    cont->AddElement(track);
  }
  cont->SetTitle(Form("N=%d", count));
  cont->MakeTracks();

  gEve->Redraw3D();

  return cont;
}

TEveTrackList* esd_tracks_MI()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();

  TEveTrackList* cont = new TEveTrackList("ESD Tracks MI");
  cont->SetLineColor(5);
  gEve->AddElement(cont);

  Int_t count = 0;
  for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
  {
    ++count;
    AliESDtrack* at = esd->GetTrack(n);
    AliEveTrack* l = new AliEveTrack(at, cont->GetPropagator());
    l->SetName(Form("ESDTrackMI %d", at->GetID()));
    l->SetElementTitle(esd_track_title(at));
    l->SetAttLineAttMarker(cont);
    l->SetSourceObject(at);

    at->FillPolymarker(l, esd->GetMagneticField(), 0, 250, 5);

    l->SetLockPoints(kTRUE);
    cont->AddElement(l);
  }
  cont->SetTitle(Form("N=%d", count));

  gEve->Redraw3D();

  return cont;
}


//==============================================================================
// esd_tracks_from_array()
//==============================================================================

TEveTrackList* esd_tracks_from_array(TCollection* col, AliESDEvent* esd=0)
{
  // Retrieves AliESDTrack's from collection.
  // See example usage with AliAnalysisTrackCuts in the next function.

  if (esd == 0) esd = AliEveEventManager::AssertESD();

  TEveTrackList* cont = new TEveTrackList("ESD Tracks");
  cont->SetMainColor(6);

  esd_track_propagator_setup(cont->GetPropagator(),
			     0.1*esd->GetMagneticField(), 520);

  gEve->AddElement(cont);

  Int_t    count = 0;
  TIter    next(col);
  TObject *obj;
  while ((obj = next()) != 0)
  {
    if (obj->IsA()->InheritsFrom("AliESDtrack") == kFALSE)
    {
      Warning("esd_tracks_from_array", "Object '%s', '%s' is not an AliESDtrack.",
	      obj->GetName(), obj->GetTitle());
      continue;
    }

    ++count;
    AliESDtrack* at = reinterpret_cast<AliESDtrack*>(obj);

    AliEveTrack* track = esd_make_track(at, cont);
    cont->AddElement(track);
  }
  cont->SetTitle(Form("N=%d", count));
  cont->MakeTracks();

  gEve->Redraw3D();

  return cont;
}

void esd_tracks_alianalcuts_demo()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();

  AliESDtrackCuts atc;
  atc.SetPtRange(0.1, 5);
  atc.SetRapRange(-1, 1);

  esd_tracks_from_array(atc.GetAcceptedTracks(esd), esd);
}


//==============================================================================
// esd_tracks_by_category
//==============================================================================

Float_t get_sigma_to_vertex(AliESDtrack* esdTrack)
{
  // Taken from: PWG0/esdTrackCuts/AliESDtrackCuts.cxx
  // Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)

  Float_t b[2];
  Float_t bRes[2];
  Float_t bCov[3];
  esdTrack->GetImpactParameters(b,bCov);
  if (bCov[0] <= 0 || bCov[2] <= 0)
  {
    printf("Estimated b resolution lower or equal zero!\n");
    bCov[0] = bCov[2] = 0;
  }
  bRes[0] = TMath::Sqrt(bCov[0]);
  bRes[1] = TMath::Sqrt(bCov[2]);

  // -----------------------------------
  // How to get to a n-sigma cut?
  //
  // The accumulated statistics from 0 to d is
  //
  // ->  Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
  // ->  1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
  //
  // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2)
  // Can this be expressed in a different way?

  if (bRes[0] == 0 || bRes[1] == 0)
    return -1;

  Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));

  // stupid rounding problem screws up everything:
  // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
  if (TMath::Exp(-d * d / 2) < 1e-10)
    return 1000;

  d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
  return d;
}

TEveElementList* esd_tracks_by_category()
{
   // Import ESD tracks, separate them into several containers
   // according to primary-vertex cut and ITS&TPC refit status.

   AliESDEvent* esd = AliEveEventManager::AssertESD();

   TEveElementList* cont = new TEveElementList("ESD Tracks by category");
   gEve->AddElement(cont);

   const Int_t   nCont = 9;
   const Float_t maxR  = 520;
   const Float_t magF  = 0.1*esd->GetMagneticField();

   TEveTrackList *tl[nCont];
   Int_t          tc[nCont];
   Int_t          count = 0;

   tl[0] = new TEveTrackList("Sigma < 3");
   tc[0] = 0;
   esd_track_propagator_setup(tl[0]->GetPropagator(), magF, maxR);
   tl[0]->SetMainColor(3);
   cont->AddElement(tl[0]);

   tl[1] = new TEveTrackList("3 < Sigma < 5");
   tc[1] = 0;
   esd_track_propagator_setup(tl[1]->GetPropagator(), magF, maxR);
   tl[1]->SetMainColor(7);
   cont->AddElement(tl[1]);

   tl[2] = new TEveTrackList("5 < Sigma");
   tc[2] = 0;
   esd_track_propagator_setup(tl[2]->GetPropagator(), magF, maxR);
   tl[2]->SetMainColor(46);
   cont->AddElement(tl[2]);

   tl[3] = new TEveTrackList("no ITS refit; Sigma < 5");
   tc[3] = 0;
   esd_track_propagator_setup(tl[3]->GetPropagator(), magF, maxR);
   tl[3]->SetMainColor(41);
   cont->AddElement(tl[3]);

   tl[4] = new TEveTrackList("no ITS refit; Sigma > 5");
   tc[4] = 0;
   esd_track_propagator_setup(tl[4]->GetPropagator(), magF, maxR);
   tl[4]->SetMainColor(48);
   cont->AddElement(tl[4]);

   tl[5] = new TEveTrackList("no TPC refit");
   tc[5] = 0;
   esd_track_propagator_setup(tl[5]->GetPropagator(), magF, maxR);
   tl[5]->SetMainColor(kRed);
   cont->AddElement(tl[5]);

   tl[6] = new TEveTrackList("ITS ncl>=3 & SPD Inner");
   tc[6] = 0;
   esd_track_propagator_setup(tl[6]->GetPropagator(), magF, maxR);
   tl[6]->SetMainColor(kGreen);
   cont->AddElement(tl[6]);

   tl[7] = new TEveTrackList("ITS ncl>=3 & b<3 cm");
   tc[7] = 0;
   esd_track_propagator_setup(tl[7]->GetPropagator(), magF, maxR);
   tl[7]->SetMainColor(kMagenta - 9);
   cont->AddElement(tl[7]);

   tl[8] = new TEveTrackList("ITS others");
   tc[8] = 0;
   esd_track_propagator_setup(tl[8]->GetPropagator(), magF, maxR);
   tl[8]->SetMainColor(kRed + 2);
   cont->AddElement(tl[8]);

   for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
   {
      AliESDtrack* at = esd->GetTrack(n);

      Float_t s  = get_sigma_to_vertex(at);
      Int_t   ti;
      if      (s <  3) ti = 0;
      else if (s <= 5) ti = 1;
      else             ti = 2;

      Int_t    nclits;
      Double_t dtobeam;

      if (at->IsOn(AliESDtrack::kITSin) && ! at->IsOn(AliESDtrack::kTPCin))
      {
         UChar_t itsclmap = at->GetITSClusterMap();
         Bool_t  spdinner = (itsclmap & 3) != 0;

         nclits = 0;
         for (Int_t iter = 0; iter < 6; ++iter)
            if (itsclmap & (1 << iter)) nclits ++;

         Double_t xyz[3];
         at->GetXYZ(xyz);
         dtobeam = TMath::Hypot(xyz[0], xyz[1]);

         if ((nclits >= 3) && (spdinner))
            ti = 6;
         else if ((nclits >= 3) && (dtobeam < 3.0))
            ti = 7;
         else
            ti = 8;
      }
      else if (at->IsOn(AliESDtrack::kTPCin) && ! at->IsOn(AliESDtrack::kTPCrefit))
      {
         ti = 5;
      }
      else if ( ! at->IsOn(AliESDtrack::kITSrefit))
      {
         ti = (ti == 2) ? 4 : 3;
      }

      TEveTrackList* tlist = tl[ti];
      ++tc[ti];
      ++count;

      AliEveTrack* track = esd_make_track(at, tlist);
      if (ti<6)
         track->SetName(Form("ESD Track idx=%d, sigma=%5.3f", at->GetID(), s));
      else
         track->SetName(Form("ESD Track idx=%d, dxy=%5.3f cl=%i", at->GetID(), dtobeam, nclits));
      tlist->AddElement(track);
   }

   for (Int_t ti = 0; ti < nCont; ++ti)
   {
      TEveTrackList* tlist = tl[ti];
      tlist->SetName(Form("%s [%d]", tlist->GetName(), tlist->NumChildren()));
      tlist->SetTitle(Form("N tracks=%d", tc[ti]));

      tlist->MakeTracks();

      //    Bool_t good_cont = ti <= 1;
      Bool_t good_cont = ((ti == 6) || (ti == 7));
      if (AliEveTrackCounter::IsActive())
      {
         AliEveTrackCounter::fgInstance->RegisterTracks(tlist, good_cont);
      }
      else
      {
         if ( ! good_cont)
            tlist->SetLineStyle(6);
      }
   }
   cont->SetTitle(Form("N all tracks = %d", count));
   // ??? The following does not always work:
   cont->FindListTreeItem(gEve->GetListTree())->SetOpen(kTRUE);

   gEve->Redraw3D();

   return cont;
}


//==============================================================================
// esd_tracks_by_anal_cuts
//==============================================================================

AliESDtrackCuts* g_esd_tracks_anal_cuts = 0;

TEveElementList* esd_tracks_by_anal_cuts()
{
  AliESDEvent* esd = AliEveEventManager::AssertESD();

  if (g_esd_tracks_anal_cuts == 0)
  {
    gSystem->Load("libPWGUDbase");
    gROOT->ProcessLine(".L $ALICE_ROOT/PWGUD/CreateStandardCuts.C");
    Int_t mode = AliPWG0Helper::kTPC;
    if (TMath::Abs(esd->GetMagneticField()) > 0.01)
      mode |= AliPWG0Helper::kFieldOn;
    gROOT->ProcessLine(Form("g_esd_tracks_anal_cuts = CreateTrackCuts(%d, kFALSE)", mode));
  }

  TEveElementList* cont = new TEveElementList("ESD Tracks by Analysis Cuts");
  gEve->AddElement(cont);

  const Int_t   nCont = 2;
  const Float_t maxR  = 520;
  const Float_t magF  = 0.1*esd->GetMagneticField();

  TEveTrackList *tl[nCont];
  Int_t          tc[nCont];
  Int_t          count = 0;

  tl[0] = new TEveTrackList("Passed");
  tc[0] = 0;
  esd_track_propagator_setup(tl[0]->GetPropagator(), magF, maxR);
  tl[0]->SetMainColor(3);
  cont->AddElement(tl[0]);

  tl[1] = new TEveTrackList("Rejected");
  tc[1] = 0;
  esd_track_propagator_setup(tl[1]->GetPropagator(), magF, maxR);
  tl[1]->SetMainColor(kRed);
  cont->AddElement(tl[1]);

  for (Int_t n = 0; n < esd->GetNumberOfTracks(); ++n)
  {
    AliESDtrack* at = esd->GetTrack(n);

    Float_t s  = get_sigma_to_vertex(at);
    Int_t   ti = (g_esd_tracks_anal_cuts->AcceptTrack(at)) ? 0 : 1;

    TEveTrackList* tlist = tl[ti];
    ++tc[ti];
    ++count;

    AliEveTrack* track = esd_make_track(at, tlist);
    track->SetName(Form("ESD Track idx=%d, sigma=%5.3f", at->GetID(), s));
    tlist->AddElement(track);
  }

  for (Int_t ti = 0; ti < nCont; ++ti)
  {
    TEveTrackList* tlist = tl[ti];
    tlist->SetName(Form("%s [%d]", tlist->GetName(), tlist->NumChildren()));
    tlist->SetTitle(Form("N tracks=%d", tc[ti]));

    tlist->MakeTracks();

    Bool_t good_cont = ti < 1;
    if (AliEveTrackCounter::IsActive())
    {
      AliEveTrackCounter::fgInstance->RegisterTracks(tlist, good_cont);
    }
    else
    {
      if ( ! good_cont)
        tlist->SetLineStyle(6);
    }
  }
  cont->SetTitle(Form("N all tracks = %d", count));
  // ??? The following does not always work:
  cont->FindListTreeItem(gEve->GetListTree())->SetOpen(kTRUE);

  gEve->Redraw3D();

  return cont;
}
 esd_tracks.C:1
 esd_tracks.C:2
 esd_tracks.C:3
 esd_tracks.C:4
 esd_tracks.C:5
 esd_tracks.C:6
 esd_tracks.C:7
 esd_tracks.C:8
 esd_tracks.C:9
 esd_tracks.C:10
 esd_tracks.C:11
 esd_tracks.C:12
 esd_tracks.C:13
 esd_tracks.C:14
 esd_tracks.C:15
 esd_tracks.C:16
 esd_tracks.C:17
 esd_tracks.C:18
 esd_tracks.C:19
 esd_tracks.C:20
 esd_tracks.C:21
 esd_tracks.C:22
 esd_tracks.C:23
 esd_tracks.C:24
 esd_tracks.C:25
 esd_tracks.C:26
 esd_tracks.C:27
 esd_tracks.C:28
 esd_tracks.C:29
 esd_tracks.C:30
 esd_tracks.C:31
 esd_tracks.C:32
 esd_tracks.C:33
 esd_tracks.C:34
 esd_tracks.C:35
 esd_tracks.C:36
 esd_tracks.C:37
 esd_tracks.C:38
 esd_tracks.C:39
 esd_tracks.C:40
 esd_tracks.C:41
 esd_tracks.C:42
 esd_tracks.C:43
 esd_tracks.C:44
 esd_tracks.C:45
 esd_tracks.C:46
 esd_tracks.C:47
 esd_tracks.C:48
 esd_tracks.C:49
 esd_tracks.C:50
 esd_tracks.C:51
 esd_tracks.C:52
 esd_tracks.C:53
 esd_tracks.C:54
 esd_tracks.C:55
 esd_tracks.C:56
 esd_tracks.C:57
 esd_tracks.C:58
 esd_tracks.C:59
 esd_tracks.C:60
 esd_tracks.C:61
 esd_tracks.C:62
 esd_tracks.C:63
 esd_tracks.C:64
 esd_tracks.C:65
 esd_tracks.C:66
 esd_tracks.C:67
 esd_tracks.C:68
 esd_tracks.C:69
 esd_tracks.C:70
 esd_tracks.C:71
 esd_tracks.C:72
 esd_tracks.C:73
 esd_tracks.C:74
 esd_tracks.C:75
 esd_tracks.C:76
 esd_tracks.C:77
 esd_tracks.C:78
 esd_tracks.C:79
 esd_tracks.C:80
 esd_tracks.C:81
 esd_tracks.C:82
 esd_tracks.C:83
 esd_tracks.C:84
 esd_tracks.C:85
 esd_tracks.C:86
 esd_tracks.C:87
 esd_tracks.C:88
 esd_tracks.C:89
 esd_tracks.C:90
 esd_tracks.C:91
 esd_tracks.C:92
 esd_tracks.C:93
 esd_tracks.C:94
 esd_tracks.C:95
 esd_tracks.C:96
 esd_tracks.C:97
 esd_tracks.C:98
 esd_tracks.C:99
 esd_tracks.C:100
 esd_tracks.C:101
 esd_tracks.C:102
 esd_tracks.C:103
 esd_tracks.C:104
 esd_tracks.C:105
 esd_tracks.C:106
 esd_tracks.C:107
 esd_tracks.C:108
 esd_tracks.C:109
 esd_tracks.C:110
 esd_tracks.C:111
 esd_tracks.C:112
 esd_tracks.C:113
 esd_tracks.C:114
 esd_tracks.C:115
 esd_tracks.C:116
 esd_tracks.C:117
 esd_tracks.C:118
 esd_tracks.C:119
 esd_tracks.C:120
 esd_tracks.C:121
 esd_tracks.C:122
 esd_tracks.C:123
 esd_tracks.C:124
 esd_tracks.C:125
 esd_tracks.C:126
 esd_tracks.C:127
 esd_tracks.C:128
 esd_tracks.C:129
 esd_tracks.C:130
 esd_tracks.C:131
 esd_tracks.C:132
 esd_tracks.C:133
 esd_tracks.C:134
 esd_tracks.C:135
 esd_tracks.C:136
 esd_tracks.C:137
 esd_tracks.C:138
 esd_tracks.C:139
 esd_tracks.C:140
 esd_tracks.C:141
 esd_tracks.C:142
 esd_tracks.C:143
 esd_tracks.C:144
 esd_tracks.C:145
 esd_tracks.C:146
 esd_tracks.C:147
 esd_tracks.C:148
 esd_tracks.C:149
 esd_tracks.C:150
 esd_tracks.C:151
 esd_tracks.C:152
 esd_tracks.C:153
 esd_tracks.C:154
 esd_tracks.C:155
 esd_tracks.C:156
 esd_tracks.C:157
 esd_tracks.C:158
 esd_tracks.C:159
 esd_tracks.C:160
 esd_tracks.C:161
 esd_tracks.C:162
 esd_tracks.C:163
 esd_tracks.C:164
 esd_tracks.C:165
 esd_tracks.C:166
 esd_tracks.C:167
 esd_tracks.C:168
 esd_tracks.C:169
 esd_tracks.C:170
 esd_tracks.C:171
 esd_tracks.C:172
 esd_tracks.C:173
 esd_tracks.C:174
 esd_tracks.C:175
 esd_tracks.C:176
 esd_tracks.C:177
 esd_tracks.C:178
 esd_tracks.C:179
 esd_tracks.C:180
 esd_tracks.C:181
 esd_tracks.C:182
 esd_tracks.C:183
 esd_tracks.C:184
 esd_tracks.C:185
 esd_tracks.C:186
 esd_tracks.C:187
 esd_tracks.C:188
 esd_tracks.C:189
 esd_tracks.C:190
 esd_tracks.C:191
 esd_tracks.C:192
 esd_tracks.C:193
 esd_tracks.C:194
 esd_tracks.C:195
 esd_tracks.C:196
 esd_tracks.C:197
 esd_tracks.C:198
 esd_tracks.C:199
 esd_tracks.C:200
 esd_tracks.C:201
 esd_tracks.C:202
 esd_tracks.C:203
 esd_tracks.C:204
 esd_tracks.C:205
 esd_tracks.C:206
 esd_tracks.C:207
 esd_tracks.C:208
 esd_tracks.C:209
 esd_tracks.C:210
 esd_tracks.C:211
 esd_tracks.C:212
 esd_tracks.C:213
 esd_tracks.C:214
 esd_tracks.C:215
 esd_tracks.C:216
 esd_tracks.C:217
 esd_tracks.C:218
 esd_tracks.C:219
 esd_tracks.C:220
 esd_tracks.C:221
 esd_tracks.C:222
 esd_tracks.C:223
 esd_tracks.C:224
 esd_tracks.C:225
 esd_tracks.C:226
 esd_tracks.C:227
 esd_tracks.C:228
 esd_tracks.C:229
 esd_tracks.C:230
 esd_tracks.C:231
 esd_tracks.C:232
 esd_tracks.C:233
 esd_tracks.C:234
 esd_tracks.C:235
 esd_tracks.C:236
 esd_tracks.C:237
 esd_tracks.C:238
 esd_tracks.C:239
 esd_tracks.C:240
 esd_tracks.C:241
 esd_tracks.C:242
 esd_tracks.C:243
 esd_tracks.C:244
 esd_tracks.C:245
 esd_tracks.C:246
 esd_tracks.C:247
 esd_tracks.C:248
 esd_tracks.C:249
 esd_tracks.C:250
 esd_tracks.C:251
 esd_tracks.C:252
 esd_tracks.C:253
 esd_tracks.C:254
 esd_tracks.C:255
 esd_tracks.C:256
 esd_tracks.C:257
 esd_tracks.C:258
 esd_tracks.C:259
 esd_tracks.C:260
 esd_tracks.C:261
 esd_tracks.C:262
 esd_tracks.C:263
 esd_tracks.C:264
 esd_tracks.C:265
 esd_tracks.C:266
 esd_tracks.C:267
 esd_tracks.C:268
 esd_tracks.C:269
 esd_tracks.C:270
 esd_tracks.C:271
 esd_tracks.C:272
 esd_tracks.C:273
 esd_tracks.C:274
 esd_tracks.C:275
 esd_tracks.C:276
 esd_tracks.C:277
 esd_tracks.C:278
 esd_tracks.C:279
 esd_tracks.C:280
 esd_tracks.C:281
 esd_tracks.C:282
 esd_tracks.C:283
 esd_tracks.C:284
 esd_tracks.C:285
 esd_tracks.C:286
 esd_tracks.C:287
 esd_tracks.C:288
 esd_tracks.C:289
 esd_tracks.C:290
 esd_tracks.C:291
 esd_tracks.C:292
 esd_tracks.C:293
 esd_tracks.C:294
 esd_tracks.C:295
 esd_tracks.C:296
 esd_tracks.C:297
 esd_tracks.C:298
 esd_tracks.C:299
 esd_tracks.C:300
 esd_tracks.C:301
 esd_tracks.C:302
 esd_tracks.C:303
 esd_tracks.C:304
 esd_tracks.C:305
 esd_tracks.C:306
 esd_tracks.C:307
 esd_tracks.C:308
 esd_tracks.C:309
 esd_tracks.C:310
 esd_tracks.C:311
 esd_tracks.C:312
 esd_tracks.C:313
 esd_tracks.C:314
 esd_tracks.C:315
 esd_tracks.C:316
 esd_tracks.C:317
 esd_tracks.C:318
 esd_tracks.C:319
 esd_tracks.C:320
 esd_tracks.C:321
 esd_tracks.C:322
 esd_tracks.C:323
 esd_tracks.C:324
 esd_tracks.C:325
 esd_tracks.C:326
 esd_tracks.C:327
 esd_tracks.C:328
 esd_tracks.C:329
 esd_tracks.C:330
 esd_tracks.C:331
 esd_tracks.C:332
 esd_tracks.C:333
 esd_tracks.C:334
 esd_tracks.C:335
 esd_tracks.C:336
 esd_tracks.C:337
 esd_tracks.C:338
 esd_tracks.C:339
 esd_tracks.C:340
 esd_tracks.C:341
 esd_tracks.C:342
 esd_tracks.C:343
 esd_tracks.C:344
 esd_tracks.C:345
 esd_tracks.C:346
 esd_tracks.C:347
 esd_tracks.C:348
 esd_tracks.C:349
 esd_tracks.C:350
 esd_tracks.C:351
 esd_tracks.C:352
 esd_tracks.C:353
 esd_tracks.C:354
 esd_tracks.C:355
 esd_tracks.C:356
 esd_tracks.C:357
 esd_tracks.C:358
 esd_tracks.C:359
 esd_tracks.C:360
 esd_tracks.C:361
 esd_tracks.C:362
 esd_tracks.C:363
 esd_tracks.C:364
 esd_tracks.C:365
 esd_tracks.C:366
 esd_tracks.C:367
 esd_tracks.C:368
 esd_tracks.C:369
 esd_tracks.C:370
 esd_tracks.C:371
 esd_tracks.C:372
 esd_tracks.C:373
 esd_tracks.C:374
 esd_tracks.C:375
 esd_tracks.C:376
 esd_tracks.C:377
 esd_tracks.C:378
 esd_tracks.C:379
 esd_tracks.C:380
 esd_tracks.C:381
 esd_tracks.C:382
 esd_tracks.C:383
 esd_tracks.C:384
 esd_tracks.C:385
 esd_tracks.C:386
 esd_tracks.C:387
 esd_tracks.C:388
 esd_tracks.C:389
 esd_tracks.C:390
 esd_tracks.C:391
 esd_tracks.C:392
 esd_tracks.C:393
 esd_tracks.C:394
 esd_tracks.C:395
 esd_tracks.C:396
 esd_tracks.C:397
 esd_tracks.C:398
 esd_tracks.C:399
 esd_tracks.C:400
 esd_tracks.C:401
 esd_tracks.C:402
 esd_tracks.C:403
 esd_tracks.C:404
 esd_tracks.C:405
 esd_tracks.C:406
 esd_tracks.C:407
 esd_tracks.C:408
 esd_tracks.C:409
 esd_tracks.C:410
 esd_tracks.C:411
 esd_tracks.C:412
 esd_tracks.C:413
 esd_tracks.C:414
 esd_tracks.C:415
 esd_tracks.C:416
 esd_tracks.C:417
 esd_tracks.C:418
 esd_tracks.C:419
 esd_tracks.C:420
 esd_tracks.C:421
 esd_tracks.C:422
 esd_tracks.C:423
 esd_tracks.C:424
 esd_tracks.C:425
 esd_tracks.C:426
 esd_tracks.C:427
 esd_tracks.C:428
 esd_tracks.C:429
 esd_tracks.C:430
 esd_tracks.C:431
 esd_tracks.C:432
 esd_tracks.C:433
 esd_tracks.C:434
 esd_tracks.C:435
 esd_tracks.C:436
 esd_tracks.C:437
 esd_tracks.C:438
 esd_tracks.C:439
 esd_tracks.C:440
 esd_tracks.C:441
 esd_tracks.C:442
 esd_tracks.C:443
 esd_tracks.C:444
 esd_tracks.C:445
 esd_tracks.C:446
 esd_tracks.C:447
 esd_tracks.C:448
 esd_tracks.C:449
 esd_tracks.C:450
 esd_tracks.C:451
 esd_tracks.C:452
 esd_tracks.C:453
 esd_tracks.C:454
 esd_tracks.C:455
 esd_tracks.C:456
 esd_tracks.C:457
 esd_tracks.C:458
 esd_tracks.C:459
 esd_tracks.C:460
 esd_tracks.C:461
 esd_tracks.C:462
 esd_tracks.C:463
 esd_tracks.C:464
 esd_tracks.C:465
 esd_tracks.C:466
 esd_tracks.C:467
 esd_tracks.C:468
 esd_tracks.C:469
 esd_tracks.C:470
 esd_tracks.C:471
 esd_tracks.C:472
 esd_tracks.C:473
 esd_tracks.C:474
 esd_tracks.C:475
 esd_tracks.C:476
 esd_tracks.C:477
 esd_tracks.C:478
 esd_tracks.C:479
 esd_tracks.C:480
 esd_tracks.C:481
 esd_tracks.C:482
 esd_tracks.C:483
 esd_tracks.C:484
 esd_tracks.C:485
 esd_tracks.C:486
 esd_tracks.C:487
 esd_tracks.C:488
 esd_tracks.C:489
 esd_tracks.C:490
 esd_tracks.C:491
 esd_tracks.C:492
 esd_tracks.C:493
 esd_tracks.C:494
 esd_tracks.C:495
 esd_tracks.C:496
 esd_tracks.C:497
 esd_tracks.C:498
 esd_tracks.C:499
 esd_tracks.C:500
 esd_tracks.C:501
 esd_tracks.C:502
 esd_tracks.C:503
 esd_tracks.C:504
 esd_tracks.C:505
 esd_tracks.C:506
 esd_tracks.C:507
 esd_tracks.C:508
 esd_tracks.C:509
 esd_tracks.C:510
 esd_tracks.C:511
 esd_tracks.C:512
 esd_tracks.C:513
 esd_tracks.C:514
 esd_tracks.C:515
 esd_tracks.C:516
 esd_tracks.C:517
 esd_tracks.C:518
 esd_tracks.C:519
 esd_tracks.C:520
 esd_tracks.C:521
 esd_tracks.C:522
 esd_tracks.C:523
 esd_tracks.C:524
 esd_tracks.C:525
 esd_tracks.C:526
 esd_tracks.C:527
 esd_tracks.C:528
 esd_tracks.C:529
 esd_tracks.C:530
 esd_tracks.C:531
 esd_tracks.C:532
 esd_tracks.C:533
 esd_tracks.C:534
 esd_tracks.C:535
 esd_tracks.C:536
 esd_tracks.C:537
 esd_tracks.C:538
 esd_tracks.C:539
 esd_tracks.C:540
 esd_tracks.C:541
 esd_tracks.C:542
 esd_tracks.C:543
 esd_tracks.C:544
 esd_tracks.C:545
 esd_tracks.C:546
 esd_tracks.C:547
 esd_tracks.C:548
 esd_tracks.C:549
 esd_tracks.C:550
 esd_tracks.C:551
 esd_tracks.C:552
 esd_tracks.C:553
 esd_tracks.C:554
 esd_tracks.C:555
 esd_tracks.C:556
 esd_tracks.C:557
 esd_tracks.C:558
 esd_tracks.C:559
 esd_tracks.C:560
 esd_tracks.C:561
 esd_tracks.C:562
 esd_tracks.C:563
 esd_tracks.C:564
 esd_tracks.C:565
 esd_tracks.C:566
 esd_tracks.C:567
 esd_tracks.C:568
 esd_tracks.C:569
 esd_tracks.C:570
 esd_tracks.C:571
 esd_tracks.C:572
 esd_tracks.C:573
 esd_tracks.C:574
 esd_tracks.C:575
 esd_tracks.C:576
 esd_tracks.C:577
 esd_tracks.C:578
 esd_tracks.C:579
 esd_tracks.C:580
 esd_tracks.C:581
 esd_tracks.C:582
 esd_tracks.C:583
 esd_tracks.C:584
 esd_tracks.C:585
 esd_tracks.C:586
 esd_tracks.C:587
 esd_tracks.C:588
 esd_tracks.C:589
 esd_tracks.C:590
 esd_tracks.C:591
 esd_tracks.C:592
 esd_tracks.C:593
 esd_tracks.C:594
 esd_tracks.C:595
 esd_tracks.C:596
 esd_tracks.C:597
 esd_tracks.C:598
 esd_tracks.C:599
 esd_tracks.C:600
 esd_tracks.C:601
 esd_tracks.C:602
 esd_tracks.C:603
 esd_tracks.C:604
 esd_tracks.C:605
 esd_tracks.C:606
 esd_tracks.C:607
 esd_tracks.C:608
 esd_tracks.C:609
 esd_tracks.C:610
 esd_tracks.C:611
 esd_tracks.C:612
 esd_tracks.C:613
 esd_tracks.C:614
 esd_tracks.C:615
 esd_tracks.C:616
 esd_tracks.C:617
 esd_tracks.C:618
 esd_tracks.C:619
 esd_tracks.C:620
 esd_tracks.C:621
 esd_tracks.C:622
 esd_tracks.C:623
 esd_tracks.C:624
 esd_tracks.C:625
 esd_tracks.C:626
 esd_tracks.C:627
 esd_tracks.C:628
 esd_tracks.C:629
 esd_tracks.C:630
 esd_tracks.C:631
 esd_tracks.C:632
 esd_tracks.C:633
 esd_tracks.C:634
 esd_tracks.C:635
 esd_tracks.C:636
 esd_tracks.C:637
 esd_tracks.C:638
 esd_tracks.C:639
 esd_tracks.C:640
 esd_tracks.C:641
 esd_tracks.C:642
 esd_tracks.C:643
 esd_tracks.C:644
 esd_tracks.C:645
 esd_tracks.C:646
 esd_tracks.C:647
 esd_tracks.C:648
 esd_tracks.C:649
 esd_tracks.C:650
 esd_tracks.C:651
 esd_tracks.C:652
 esd_tracks.C:653
 esd_tracks.C:654
 esd_tracks.C:655
 esd_tracks.C:656
 esd_tracks.C:657
 esd_tracks.C:658
 esd_tracks.C:659
 esd_tracks.C:660
 esd_tracks.C:661
 esd_tracks.C:662
 esd_tracks.C:663
 esd_tracks.C:664
 esd_tracks.C:665
 esd_tracks.C:666
 esd_tracks.C:667
 esd_tracks.C:668
 esd_tracks.C:669
 esd_tracks.C:670
 esd_tracks.C:671
 esd_tracks.C:672
 esd_tracks.C:673
 esd_tracks.C:674
 esd_tracks.C:675
 esd_tracks.C:676
 esd_tracks.C:677
 esd_tracks.C:678
 esd_tracks.C:679
 esd_tracks.C:680
 esd_tracks.C:681
 esd_tracks.C:682
 esd_tracks.C:683
 esd_tracks.C:684
 esd_tracks.C:685
 esd_tracks.C:686
 esd_tracks.C:687
 esd_tracks.C:688
 esd_tracks.C:689
 esd_tracks.C:690
 esd_tracks.C:691
 esd_tracks.C:692
 esd_tracks.C:693
 esd_tracks.C:694
 esd_tracks.C:695
 esd_tracks.C:696
 esd_tracks.C:697
 esd_tracks.C:698
 esd_tracks.C:699
 esd_tracks.C:700
 esd_tracks.C:701
 esd_tracks.C:702
 esd_tracks.C:703
 esd_tracks.C:704
 esd_tracks.C:705
 esd_tracks.C:706
 esd_tracks.C:707
 esd_tracks.C:708
 esd_tracks.C:709
 esd_tracks.C:710
 esd_tracks.C:711
 esd_tracks.C:712
 esd_tracks.C:713
 esd_tracks.C:714
 esd_tracks.C:715
 esd_tracks.C:716
 esd_tracks.C:717
 esd_tracks.C:718
 esd_tracks.C:719
 esd_tracks.C:720
 esd_tracks.C:721
 esd_tracks.C:722
 esd_tracks.C:723
 esd_tracks.C:724
 esd_tracks.C:725
 esd_tracks.C:726
 esd_tracks.C:727
 esd_tracks.C:728
 esd_tracks.C:729
 esd_tracks.C:730
 esd_tracks.C:731
 esd_tracks.C:732
 esd_tracks.C:733
 esd_tracks.C:734
 esd_tracks.C:735
 esd_tracks.C:736
 esd_tracks.C:737
 esd_tracks.C:738
 esd_tracks.C:739
 esd_tracks.C:740
 esd_tracks.C:741
 esd_tracks.C:742
 esd_tracks.C:743
 esd_tracks.C:744
 esd_tracks.C:745
 esd_tracks.C:746