// $Id: AliHLTTPCCADisplay.cxx,v 1.3 2010/08/16 21:23:57 ikulakov Exp $
// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project          *
// ALICE Experiment at CERN, All rights reserved.                           *
//                                                                          *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
//                  for The ALICE HLT Project.                              *
//                                                                          *
// Developed by:   Igor Kulakov <I.Kulakov@gsi.de>                          *
//                 Maksym Zyzak <M.Zyzak@gsi.de>                            *
//                                                                          *
// Permission to use, copy, modify and distribute this software and its     *
// documentation strictly for non-commercial purposes is hereby granted     *
// without fee, provided that the above copyright notice appears in all     *
// copies and that both the copyright notice and this permission notice     *
// appear in the supporting documentation. The authors make no claims       *
// about the suitability of this software for any purpose. It is            *
// provided "as is" without express or implied warranty.                    *
//                                                                          *
//***************************************************************************

// TODO now we use right CS, so z change sign, but it wasn't changed everywhere in the Display-code

#include "AliHLTTPCCADisplay.h"

//#define DRAW_3D // infrequent use for drawing 3D pictures

#include "AliHLTTPCCAParameters.h"
using namespace AliHLTTPCCAParameters;

#include "AliHLTTPCCAGBTracker.h"
#include "AliHLTTPCCAGBTrack.h"
#include "AliHLTTPCCAGBHit.h"
#include "AliHLTTPCCAPerformance.h"
#include "AliHLTTPCCAMCTrack.h"
#include "AliHLTTPCCAParam.h"
#include "AliHLTTPCCAClusterData.h"

#include "AliHLTTPCCATrackPerformanceBase.h"

#include "ITSCAHits.h"
#include "ITSCAHitsV.h"
#include "ITSCASingletsV.h"
#include "ITSCADoubletsV.h"
#include "ITSCATripletsV.h"
#include "ITSCATracks.h"

#include "TString.h"
#include "Riostream.h"
#include "TMath.h"
#include "TStyle.h"
#include "TCanvas.h"
#include "TApplication.h"
#include "TLatex.h"

#ifdef DRAW_3D
  #include "TVector3.h"
#endif // DRAW_3D

class AliHLTTPCCADisplay::AliHLTTPCCADisplayTmpHit
{

  public:

    int ID() const { return fHitID; }
    double S() const { return fS; }
    double Z() const { return fZ; }

    void SetID( int v ) { fHitID = v; }
    void SetS( double v ) { fS = v; }
    void SetZ( double v ) { fZ = v; }

    static bool CompareHitDS( const AliHLTTPCCADisplayTmpHit &a,
                                const AliHLTTPCCADisplayTmpHit  &b ) {
      return ( a.fS < b.fS );
    }

    static bool CompareHitZ( const AliHLTTPCCADisplayTmpHit &a,
                               const AliHLTTPCCADisplayTmpHit  &b ) {
      return ( a.fZ < b.fZ );
    }

  private:

    int fHitID; // hit ID
    double fS;  // hit position on the XY track curve
    double fZ;  // hit Z position

};



AliHLTTPCCADisplay &AliHLTTPCCADisplay::Instance()
{
  // reference to static object
  static AliHLTTPCCADisplay gAliHLTTPCCADisplay;

  return gAliHLTTPCCADisplay;
}

AliHLTTPCCADisplay::AliHLTTPCCADisplay() : fYX( 0 ), fZX( 0 ), fAsk( 1 ), fGB( 0 ), fPerf( 0 ),
    fZMin( 0 ), fZMax( 100 ), fYMin( -210 ), fYMax( 210 ),
    fRInnerMin( 50. ), fRInnerMax( 133.3 ), fROuterMin( 50 ), fROuterMax( 50 ),
    fTPCZMin( 0. ), fTPCZMax( 110 ), fArc(), fLine(), fPLine(), fMarker(), fBox(), fCrown(), fLatex(), fDrawOnlyRef( 0 ) // iklm. This is just default. If they are not correct SetTPC(...) can and should be used!
{
  fPerf = &( AliHLTTPCCAPerformance::Instance() ); 
  // constructor
}

AliHLTTPCCADisplay::~AliHLTTPCCADisplay()
{
  // destructor
  delete fYX;
  delete fZX;
}

void AliHLTTPCCADisplay::Init()
{
  static bool firstCall = 1;
  if ( firstCall ) {
    if ( !gApplication ) new TApplication( "myapp", 0, 0 );

      // initialization
    gStyle->SetCanvasBorderMode( 0 );
    gStyle->SetCanvasBorderSize( 1 );
    gStyle->SetCanvasColor( 0 );
    fCanvas = new TCanvas( "CA", "CA Display", 1280, 645 );
    fCanvas->Divide( 2, 1 );
    fYX = static_cast<TPad *>( fCanvas->GetPrimitive( "CA_1" ) ); // ("YX", "YX window", -1, 0, 600, 600);
    fZX = static_cast<TPad *>( fCanvas->GetPrimitive( "CA_2" ) ); // ("ZX", "ZX window", -610, 0, 590, 600);
    fYX->SetCanvas( fCanvas );
    fYX->SetTitle( "YX" );
    fZX->SetCanvas( fCanvas );
    fZX->SetTitle( "ZX" );
    fMarker = TMarker( 0.0, 0.0, 20 );//6);
    fDrawOnlyRef = 0;
  
    firstCall = 0;
  }
}

void AliHLTTPCCADisplay::Update()
{
  // update windows
  if ( !fAsk ) return;
  fYX->Update();
  fZX->Update();
//X   fYX->Print( "YX.pdf" );
//X   fZX->Print( "ZX.pdf" );

}

void AliHLTTPCCADisplay::ClearView()
{
  // clear windows
 fYX->Clear();
 fZX->Clear();
}

void AliHLTTPCCADisplay::Ask()
{
  // wait for the pressed key, when "r" pressed, don't ask anymore
  char symbol;
  if ( fAsk ) {
    Update();
    std::cout << "ask> ";
    do {
      std::cin.get( symbol );
      if ( symbol == 'r' )
        fAsk = false;
    } while ( symbol != '\n' );
  }
}

void AliHLTTPCCADisplay::SetTPCView()
{
  // switch to full TPC view
  fZMin = fTPCZMin;
  fZMax = fTPCZMax;
  fYMin = -fROuterMax;
  fYMax = fROuterMax;
}


void AliHLTTPCCADisplay::SetGB( const AliHLTTPCCAGBTracker * GBTracker )
{
  fGB = GBTracker;
}

void AliHLTTPCCADisplay::DrawTPC()
{
  // schematically draw TPC detector
  fYX->Range( -fROuterMax-2, -fROuterMax-2, fROuterMax+2, fROuterMax+2 );
  //fYX->Range( -fROuterMax*.7, -fROuterMax, fROuterMax*0., -fROuterMax*.5);
  fYX->Clear();
  {
    fArc.SetLineColor( kBlack );
    fArc.SetFillStyle( 0 );
    fYX->cd();

    TLatex Tl;
    Tl.SetTextSize(0.02);
    Tl.SetTextAlign(22);

  }
  fZX->cd();
  fZX->Range( fZMin*1.01, -fROuterMax*1.01, fZMax*1.01, fROuterMax*1.01 );
  //std::cout << fTPCZMin<<"  "<<fTPCZMax<<std::endl;
  //fZX->Range( fTPCZMax*.1, -fROuterMax, fTPCZMax*.3, -fROuterMax*0.5 );
  fZX->Clear();
  TBox ZX;
  ZX.SetFillStyle( 0 );
  ZX.SetFillColor(0);
  ZX.SetLineWidth(0.1);
  ZX.DrawBox(fZMin,-fROuterMax,fZMax,fROuterMax);
}

void  AliHLTTPCCADisplay::DrawArc(float x, float y, float r, int Start, Size_t width )
{
  fArc.SetLineWidth( width );
  fArc.SetLineColor( 2 +  Start);

  fYX->cd();
  fArc.DrawArc( x, y, r );
}

void  AliHLTTPCCADisplay::DrawPoint(float x, float y, float z, int Start, Size_t width )
{
  fMarker.SetMarkerSize( width );
  fMarker.SetMarkerColor( 2 +  Start);

  fYX->cd();
  fMarker.DrawMarker( x, y );
  fZX->cd();
  fMarker.DrawMarker( z, y );
}

void  AliHLTTPCCADisplay::DrawGBPoint(float x, float y, float z, int Start, Size_t width )
{

  fMarker.SetMarkerSize( width );
  fMarker.SetMarkerColor( 2 +  Start);

  fYX->cd();
  fMarker.DrawMarker( x, y );
  fZX->cd();
  fMarker.DrawMarker( z, y );
}

void  AliHLTTPCCADisplay::DrawGBPoint(float x, float y, float z, float angle, int Start, Size_t width )
{

  fMarker.SetMarkerSize( width );
  fMarker.SetMarkerColor( 2 +  Start);

 //   fArrow.SetAngle(h.Angle());
  fArrow.SetFillColor(  2 +  Start );
  fArrow.SetLineColor(  2 +  Start );
  fArrow.SetLineWidth( 1*width );

  double cosa = TMath::Cos(angle);
  double sina = TMath::Sin(angle);
  double ax2 = 0;
  double ay2 = -3;
  double ax0 = x + ax2*cosa - ay2*sina;
  double ay0 = y + ax2*sina + ay2*cosa;
  double ax1 = 0;
  double ay1 = 3;
  double ax = x + ax1*cosa - ay1*sina;
  double ay = y + ax1*sina + ay1*cosa;

  fYX->cd();
  fMarker.DrawMarker( x, y );
  fArrow.DrawArrow(ax0, ay0, ax, ay, 0.003, "|>");
  fZX->cd();
  fMarker.DrawMarker( z, y );
}

void  AliHLTTPCCADisplay::DrawGBLine(float x, float y, float z, float x2, float y2, float z2, int Start, Size_t width )
{
  fLine.SetLineWidth( width );
  fLine.SetLineColor( Start);
    
  fYX->cd();
  fLine.DrawLine( x, y, x2, y2 );
  fZX->cd();
  fLine.DrawLine( z, y, z2, y2 );
}

int AliHLTTPCCADisplay::GetColor( int i ) const
{
  // Get color with respect to Z coordinate
  const Color_t kMyColor[9] = { kGreen, kBlue, kYellow, kCyan, kOrange,
                                kSpring, kTeal, kAzure, kViolet
                              };
  if ( i < 0 ) i = 0;
  if ( i == 0 ) return kBlack;
  return kMyColor[( i-1 )%9];
}

int AliHLTTPCCADisplay::GetColorZ( double z ) const
{
  // Get color with respect to Z coordinate
  const Color_t kMyColor[11] = { kGreen, kBlue, kYellow, kMagenta, kCyan,
                                 kOrange, kSpring, kTeal, kAzure, kViolet, kPink
                               };

  double zz = ( z - fZMin ) / ( fZMax - fZMin );
  int iz = ( int ) ( zz * 11 );
  if ( iz < 0 ) iz = 0;
  if ( iz > 10 ) iz = 10;
  return kMyColor[iz];
}

int AliHLTTPCCADisplay::GetColorY( double y ) const
{
  // Get color with respect to Z coordinate
  const Color_t kMyColor[11] = { kGreen, kBlue, kYellow, kMagenta, kCyan,
                                 kOrange, kSpring, kTeal, kAzure, kViolet, kPink
                               };

  double yy = ( y - fYMin ) / ( fYMax - fYMin );
  int iy = ( int ) ( yy * 11 );
  if ( iy < 0 ) iy = 0;
  if ( iy > 10 ) iy = 10;
  return kMyColor[iy];
}

int AliHLTTPCCADisplay::GetColorK( double k ) const
{
  // Get color with respect to Z coordinate
  const Color_t kMyColor[11] = { kRed, kBlue, kYellow, kMagenta, kCyan,
                                 kOrange, kSpring, kTeal, kAzure, kViolet, kPink
                               };
  const double kCLight = 0.000299792458;
  const double kBz = 5;
  double k2QPt = 100;
  if ( TMath::Abs( kBz ) > 1.e-4 ) k2QPt = 1. / ( kBz * kCLight );
  double qPt = k * k2QPt;
  double pt = 100;
  if ( TMath::Abs( qPt ) > 1.e-4 ) pt = 1. / TMath::Abs( qPt );

  double yy = ( pt - 0.1 ) / ( 1. - 0.1 );
  int iy = ( int ) ( yy * 11 );
  if ( iy < 0 ) iy = 0;
  if ( iy > 10 ) iy = 10;
  return kMyColor[iy];
}

void AliHLTTPCCADisplay::DrawGBHit( const AliHLTTPCCAGBTracker &tracker, int iHit, int color, Size_t width  )
{
  // draw hit
  const AliHLTTPCCAGBHit &h = tracker.Hits()[iHit];

  if ( color < 0 ) {
    if ( fPerf ) {
      int lab = fPerf->HitLabel( h.ID() ).fLab[0];
      color = GetColor( lab + 1 );
      if ( lab >= 0 ) {
        const AliHLTTPCCAMCTrack &mc = fPerf->MCTrack( lab );
        if ( mc.P() >= 1. ) color = kRed;
        else if ( fDrawOnlyRef ) return;
      }
    } else color = GetColorZ( h.Z() );
  }
  if ( width > 0 )fMarker.SetMarkerSize( width );
  else fMarker.SetMarkerSize( .3 );
  fMarker.SetMarkerColor( color );
  double vx = h.X(), vy = h.Y();

  fYX->cd();
  fMarker.DrawMarker( vx, vy );
  fZX->cd();
  fMarker.DrawMarker( h.Z(), vy );
}

void AliHLTTPCCADisplay::DrawGBHits( const AliHLTTPCCAGBTracker &tracker, int color, Size_t width, int hitsType)
{
  // draw hits

  if ( !fPerf ) return;
  if ( width < 0 ) width = .6;
  
  for ( int iHit = 0; iHit < tracker.NHits(); iHit++ ) {
    const AliHLTTPCCAGBHit &h = tracker.Hits()[iHit];
//     if ((hitsType == 1) && (h.ISlice() >= 12)) continue;
//     if ((hitsType == 2) && (h.ISlice() < 12) ) continue;
    int imc = fPerf->HitLabel( h.ID() ).fLab[0];
    const AliHLTTPCCAMCTrack *mc = ( imc >= 0 ) ? &( fPerf->MCTrack( imc ) ) : 0;
    if ( fDrawOnlyRef && ( !mc || ( mc->P() < 1 ) ) ) continue;
    int col = color;
    if ( color < 0 ) {
      if (hitsType == 1) {
        if (h.Z() >= 0) col = kBlue;
        if (h.Z() < 0) col = 8;
      }
      else{
        col = GetColor( imc + 1 ) ;
        if ( mc && ( mc->P() >= PParameters::RefThreshold ) ) col = kRed;
      }
    }

    fMarker.SetMarkerSize( width );
    fMarker.SetMarkerColor( col );
    double vx = h.X(), vy = h.Y();

 //   fArrow.SetAngle(h.Angle());
    fArrow.SetFillColor( col );
    fArrow.SetLineColor( col );
    fArrow.SetLineWidth( 1*width );

    double ax, ay;
    double cosA = TMath::Cos(h.Angle());
    double sinA = TMath::Sin(h.Angle());
    double ax1 = 0;
    double ay1 = 3;
    ax = vx + ax1*cosA - ay1*sinA;
    ay = vy + ax1*sinA + ay1*cosA;

    fYX->cd();
    fMarker.DrawMarker( vx, vy );
    // fArrow.DrawArrow(vx, vy, ax, ay, 0.003, "|>"); // draw module direction
    fZX->cd();
    fMarker.DrawMarker( h.Z(), vy );
  }
}

void AliHLTTPCCADisplay::HitToGlobal( const ITSCAHit& h, float& x, float& y, float &z )
{
  CALocalToGlobal(h.X0(), h.X1(), h.X2(), h.Angle(), x, y, z);
}

void AliHLTTPCCADisplay::HitToGlobal( const ITSCAHitV& h, int iV, float& x, float& y, float &z )
{
  CALocalToGlobal(h.X0()[iV], h.X1()[iV], h.X2()[iV], h.Angle()[iV], x, y, z);
}

void AliHLTTPCCADisplay::DrawGBHits(const ITSCAHitsV& all) {

  for( int iS = 0, iColor = 0; iS < all.NStations(); ++iS, iColor++ ) {
    if ( iColor == kYellow )
      iColor++;
    if ( iColor == kWhite )
      iColor++;

    const ITSCAElementsOnStation<ITSCAHitV>& s = all.OnStation( iS );
    for( unsigned int i = 0; i < s.size(); ++i ) {
      const ITSCAHitV &h = s[i];
      foreach_bit( int iV, h.IsValid() ) {
        float gx, gy, gz;
        HitToGlobal( h, iV, gx, gy, gz );
        DrawGBPoint( gx, gy, gz, iS, 0.5 );
        // std::cout << iS << " " << i << " " << iV << " " << h.X1()[iV] << " " << h.X2()[iV] << " " << h.X0()[iV] << std::endl; // dbg
      }
    }
  }
}

void AliHLTTPCCADisplay::DrawGBSinglets(const ITSCASingletsV& all) {
  for( int iS = 0; iS < all.NStations(); ++iS ) {
    const ITSCAElementsOnStation<ITSCASingletV>& s = all.OnStation( iS );
    for( unsigned int i = 0; i < s.size(); ++i ) {
      foreach_bit( int iV, s[i].IsValid() ) {
        float gx, gy, gz;
        HitToGlobal( s.GetHit( iV, 0, i ), gx, gy, gz );
        DrawGBLine( 0,0,0, gx, gy, gz, kYellow, 1 );
        // std::cout << iS << " " << i << " " << iV << " " << hit0.GX() << " " << hit0.GY() << " " << hit0.GZ() << std::endl; // dbg
      }
    }
  }
}

void AliHLTTPCCADisplay::DrawGBDoublets(const ITSCADoubletsV& all) {
  for( int iS = 0; iS < all.NStations(); ++iS ) {
    const ITSCAElementsOnStation<ITSCADoubletV>& s = all.OnStation( iS );
    for( unsigned int i = 0; i < s.size(); ++i ) {
      foreach_bit( int iV, s[i].IsValid() ) {
        float gx0, gy0, gz0, gx1, gy1, gz1;
        HitToGlobal( s.GetHit( iV, 0, i ), gx0, gy0, gz0 );
        HitToGlobal( s.GetHit( iV, 1, i ), gx1, gy1, gz1 );
        DrawGBLine( gx0, gy0, gz0, gx1, gy1, gz1, kGreen, 1 );
      }
    }
  }
}

void AliHLTTPCCADisplay::DrawGBTriplets(const ITSCATripletsV& all) {
  for( int iS = 0; iS < all.NStations(); ++iS ) {
    const ITSCAElementsOnStation<ITSCATripletV>& s = all.OnStation( iS );
    for( unsigned int i = 0; i < s.size(); ++i ) {
      foreach_bit( int iV, s[i].IsValid() ) {
        float gx0, gy0, gz0, gx1, gy1, gz1, gx2, gy2, gz2;
        HitToGlobal( s.GetHit( iV, 0, i ), gx0, gy0, gz0 );
        HitToGlobal( s.GetHit( iV, 1, i ), gx1, gy1, gz1 );
        HitToGlobal( s.GetHit( iV, 2, i ), gx2, gy2, gz2 );
        DrawGBLine( gx0, gy0, gz0, gx1, gy1, gz1, kBlue, 1 );
        DrawGBLine( gx1, gy1, gz1, gx2, gy2, gz2, kBlue, 1 );
      }
    }
    // Ask();
  }
}

void AliHLTTPCCADisplay::DrawGBTracks(const ITSCATracks& all) {
  for( unsigned int i = 0; i < all.size(); ++i ) {
    const ITSCATrack& t = all[i];
    const unsigned int NTHits = t.NHits();
    ITSCAHit hitP = all.Hit(0, i);
    for( unsigned int iH=1; iH < NTHits; iH++) {
      const ITSCAHit& hit = all.Hit(iH, i);

      float gx0, gy0, gz0, gx1, gy1, gz1;
      HitToGlobal( hitP, gx0, gy0, gz0 );
      HitToGlobal( hit, gx1, gy1, gz1 );
      DrawGBLine( gx0, gy0, gz0, gx1, gy1, gz1, kRed, 1.5 );

      hitP = hit;
    }
  }
}

int AliHLTTPCCADisplay::GetTrackMC( const AliHLTTPCCADisplayTmpHit *vHits, int NHits )
{
  // get MC label for the track

  const AliHLTTPCCAGBTracker &tracker = *fGB;

  int label = -1;
  double purity = 0;
  int *lb = new int[NHits*3];
  int nla = 0;
  //std::cout<<"\n\nTrack hits mc: "<<std::endl;
  for ( int ihit = 0; ihit < NHits; ihit++ ) {
    const AliHLTTPCCAGBHit &h = tracker.Hits()[vHits[ihit].ID()];
    const AliHLTTPCCAPerformance::AliHLTTPCCAHitLabel &l = fPerf->HitLabel( h.ID() );
    if ( l.fLab[0] >= 0 ) lb[nla++] = l.fLab[0];
    if ( l.fLab[1] >= 0 ) lb[nla++] = l.fLab[1];
    if ( l.fLab[2] >= 0 ) lb[nla++] = l.fLab[2];
    //std::cout<<ihit<<":  "<<l.fLab[0]<<" "<<l.fLab[1]<<" "<<l.fLab[2]<<std::endl;
  }
  sort( lb, lb + nla );
  int labmax = -1, labcur = -1, lmax = 0, lcurr = 0, nh = 0;
  //std::cout<<"MC track IDs :"<<std::endl;
  for ( int i = 0; i < nla; i++ ) {
    if ( lb[i] != labcur ) {
      if ( 0 && i > 0 && lb[i-1] >= 0 ) {
        const AliHLTTPCCAMCTrack &mc = fPerf->MCTrack( lb[i-1] );
        std::cout << lb[i-1] << ": nhits=" << nh << ", pdg=" << mc.PDG() << ", Pt=" << mc.Pt() << ", P=" << mc.P()
                  << ", par=" << mc.Par()[0] << " " << mc.Par()[1] << " " << mc.Par()[2]
                  << " " << mc.Par()[3] << " " << mc.Par()[4] << " " << mc.Par()[5] << " " << mc.Par()[6] << std::endl;

      }
      nh = 0;
      if ( labcur >= 0 && lmax < lcurr ) {
        lmax = lcurr;
        labmax = labcur;
      }
      labcur = lb[i];
      lcurr = 0;
    }
    lcurr++;
    nh++;
  }
  if ( 0 && nla - 1 > 0 && lb[nla-1] >= 0 ) {
    const AliHLTTPCCAMCTrack &mc = fPerf->MCTrack( lb[nla-1] );
    std::cout << lb[nla-1] << ": nhits=" << nh << ", pdg=" << mc.PDG() << ", Pt=" << mc.Pt() << ", P=" << mc.P()
              << ", par=" << mc.Par()[0] << " " << mc.Par()[1] << " " << mc.Par()[2]
              << " " << mc.Par()[3] << " " << mc.Par()[4] << " " << mc.Par()[5] << " " << mc.Par()[6] << std::endl;

  }
  if ( labcur >= 0 && lmax < lcurr ) {
    lmax = lcurr;
    labmax = labcur;
  }
  lmax = 0;
  for ( int ihit = 0; ihit < NHits; ihit++ ) {
    const AliHLTTPCCAGBHit &h = tracker.Hits()[vHits[ihit].ID()];
    const AliHLTTPCCAPerformance::AliHLTTPCCAHitLabel &l = fPerf->HitLabel( h.ID() );
    if ( l.fLab[0] == labmax || l.fLab[1] == labmax || l.fLab[2] == labmax
       ) lmax++;
  }
  label = labmax;
  purity = ( ( NHits > 0 ) ? double( lmax ) / double( NHits ) : 0 );
  if ( lb ) delete[] lb;
  if ( purity < .9 ) label = -1;
  return label;
}


bool AliHLTTPCCADisplay::DrawTrack( AliHLTTPCCATrackParam t, double Alpha, const AliHLTTPCCADisplayTmpHit *vHits,
                                    int NHits, int color, Size_t width, bool pPoint )
{
//   // draw track
// #ifndef DRAW_3D
//   bool drawEndPoints = 1;
// #else
  const bool drawEndPoints = 0;
// #endif // DRAW_3D
  
  if ( NHits < 2 ) return 0;

  const AliHLTTPCCAGBTracker &tracker = *fGB;
  if ( width < 0 ) width = 2;

  if ( fDrawOnlyRef ) {
    int lab = GetTrackMC( vHits, NHits );
    if ( lab < 0 ) return 0;
    const AliHLTTPCCAMCTrack &mc = fPerf->MCTrack( lab );
    if ( mc.P() < 1 ) return 0;
  }

  if ( color < 0 ) {
    //color = GetColorZ( (vz[0]+vz[mHits-1])/2. );
    //color = GetColorK(t.Kappa());
    int lab = GetTrackMC( vHits, NHits );
    color = GetColor( lab + 1 );
    if ( lab >= 0 ) {
      const AliHLTTPCCAMCTrack &mc = fPerf->MCTrack( lab );
      if ( mc.P() >= PParameters::RefThreshold ) color = kRed;
    }
  }

  //  int iSlice = fSlice->Param().ISlice();

  //sort(vHits, vHits + NHits, AliHLTTPCCADisplayTmpHit::CompareHitZ );

  vector<double> vx(NHits), vy(NHits), vz(NHits);
  int mHits = 0;

  //int oldSlice = -1;
  double alpha = Alpha;
  AliHLTTPCCATrackParam tt = t;

  for ( int iHit = 0; iHit < NHits; iHit++ ) {

    const AliHLTTPCCAGBHit &h = tracker.Hits()[vHits[iHit].ID()];

    double hCos = TMath::Cos( alpha );
    double hSin = TMath::Sin( alpha );
    double x0 = h.X(), y0 = h.Y(), z1 = h.Z();
    double x1 = x0 * hCos + y0 * hSin;
    double y1 = y0 * hCos - x0 * hSin;

    {
      double dx = x1 - tt.X();
      double dy = y1 - tt.Y();
      if ( dx*dx + dy*dy > 1. ) {
        double dalpha = TMath::ATan2( dy, dx );
        if ( tt.Rotate( dalpha ) ) {
          alpha += dalpha;
          hCos = TMath::Cos( alpha );
          hSin = TMath::Sin( alpha );
          x1 = x0 * hCos + y0 * hSin;
          y1 = y0 * hCos - x0 * hSin;
        }
      }
    }

    bool ok;

    vx[mHits] = x1;
    vy[mHits] = y1;
    vz[mHits] = z1;
    mHits++;
  }
  if ( pPoint ) {
    double x1 = t.X(), y1 = t.Y(), z1 = t.Z();

    double dx = x1 - vx[0];
    double dy = y1 - vy[0];
    //std::cout<<x1<<" "<<y1<<" "<<vx[0]<<" "<<vy[0]<<" "<<dx<<" "<<dy<<std::endl;
    double d0 = dx * dx + dy * dy;
    dx = x1 - vx[mHits-1];
    dy = y1 - vy[mHits-1];
    //std::cout<<x1<<" "<<y1<<" "<<vx[mHits-1]<<" "<<vy[mHits-1]<<" "<<dx<<" "<<dy<<std::endl;
    double d1 = dx * dx + dy * dy;
    //std::cout<<"d0, d1="<<d0<<" "<<d1<<std::endl;
    if ( d1 < d0 ) {
      vx[mHits] = x1;
      vy[mHits] = y1;
      vz[mHits] = z1;
      mHits++;
    } else {
      for ( int i = mHits; i > 0; i-- ) {
        vx[i] = vx[i-1];
        vy[i] = vy[i-1];
        vz[i] = vz[i-1];
      }
      vx[0] = x1;
      vy[0] = y1;
      vz[0] = z1;
      mHits++;
    }
  }
  
#ifdef DRAW_3D
  const float zoom = 0.6;
  const float z_zoom = 1.2;
  const float z0_zoom = 1000.;
  for ( int i = mHits - 1; i >= 0; i-- ) {
    TVector3 v(vx[i], -vz[i], vy[i]);

    v.RotateX(TMath::Pi()/70); 
    v.RotateZ(TMath::Pi()/12);
    vx[i] = v.X()*zoom;
    vy[i] = v.Z()*zoom;
    vz[i] = -v.Y()*zoom;

    vx[i] *= (z0_zoom-vz[i])/z0_zoom * z_zoom;
    vy[i] *= (z0_zoom-vz[i])/z0_zoom * z_zoom; 
  }
#endif // DRAW_3D


  fLine.SetLineColor( color );
  fLine.SetLineWidth( width );
  fArc.SetFillStyle( 0 );
  fArc.SetLineColor( color );
  fArc.SetLineWidth( width );
  TPolyLine pl;
  pl.SetLineColor( color );
  pl.SetLineWidth( width );
  TPolyLine plZ;
  plZ.SetLineColor( color );
  plZ.SetLineWidth( width );

  fMarker.SetMarkerSize( width / 2. );
  fMarker.SetMarkerColor( color );

  fYX->cd();
  pl.DrawPolyLine( mHits, &vx[0], &vy[0] );
  if (drawEndPoints) {
    fMarker.DrawMarker( vx[0], vy[0] );
    fMarker.DrawMarker( vx[mHits-1], vy[mHits-1] );
  }
  fZX->cd();
  plZ.DrawPolyLine( mHits, &vz[0], &vy[0] );
  if (drawEndPoints) {
    fMarker.DrawMarker( vz[0], vy[0] );
    fMarker.DrawMarker( vz[mHits-1], vy[mHits-1] );
  }

  fLine.SetLineWidth( 1 );
  return 1;
}

void AliHLTTPCCADisplay::DrawHelix(float p0, float c, float z, float zStart, float z0, float xc, float yc, float r, float b, int color, Size_t width)
{
  fLine.SetLineColor(color);
  fLine.SetLineWidth(width);  
  // draw slice track
  float x,y,p;
  p = p0 + c*(zStart-z0)/b;
  y = yc + r*sin(p);
  x = xc + c*r*cos(p);

  float zPrev = zStart;
  float xPrev = x;
  float yPrev = y;
  float zEnd = z;

  for(int i=1; i<100; i++)
  {
    z = zStart + (zEnd-zStart)/100*i;
    p = p0 + c*(z-z0)/b;
    y = yc + r*sin(p);
    x = xc + c*r*cos(p);

    fYX->cd();
    fLine.DrawLine( x, y, xPrev, yPrev);
    fZX->cd();
    fLine.DrawLine( z, y, zPrev, yPrev);

    xPrev = x;
    yPrev = y;
    zPrev = z;
  }
}

void AliHLTTPCCADisplay::DrawGBTrack( int itr, int color, int width )
{
  // draw global track

  const AliHLTTPCCAGBTracker &tracker = *fGB;
  
  const AliHLTTPCCAGBTrack &track = tracker.Track( itr );
  if ( track.NHits() < 2 ) return;
    
  vector<AliHLTTPCCADisplayTmpHit> vHits( track.NHits() );

  for ( int ih = 0; ih < track.NHits(); ih++ ) {
    const int i = tracker.TrackHit( track.FirstHitRef() + ih );
    const AliHLTTPCCAGBHit &h = tracker.Hit( i );
    vHits[ih].SetID( i );
    vHits[ih].SetS( 0 );
    vHits[ih].SetZ( h.Z() );
  }
  
  DrawTrack( track.Param(), track.Param().Angle(), &(vHits[0]), track.NHits(), color, width );
}

void AliHLTTPCCADisplay::DrawRecoTrack( int itr, int color, int width )
{
  const AliHLTTPCCAGBTracker &tracker = *fGB;
  
  const AliHLTTPCCAGBTrack &track = tracker.Track( itr );
  if ( track.NHits() < 2 ) return;

  AliHLTTPCCAGBHit hLast = tracker.Hit( tracker.TrackHit( track.FirstHitRef() ) );
  for ( int ih = 1; ih < track.NHits(); ih++ ) {
    const int i = tracker.TrackHit( track.FirstHitRef() + ih );
    const AliHLTTPCCAGBHit& h = tracker.Hit( i );
    DrawGBLine( hLast.X(), hLast.Y(), hLast.Z(), h.X(), h.Y(), h.Z(), color, width );
    hLast = h;
  }
}

void AliHLTTPCCADisplay::DrawMCTrack( int itr, int color, int width )
{
  AliHLTTPCCAPerformance& perf = AliHLTTPCCAPerformance::Instance();

  const AliHLTResizableArray<AliHLTTPCCAMCTrack>& mcTs = *perf.GetMCTracks();
  const AliHLTResizableArray<AliHLTTPCCALocalMCPoint>& mcPs = *perf.GetMCPoints();

  const AliHLTTPCCAMCTrack &track = mcTs[itr];
  if ( track.NMCPoints() < 2 ) return;
  AliHLTTPCCALocalMCPoint mcPLast = mcPs[ track.FirstMCPointID() ];
  for ( int ih = 1; ih < track.NMCPoints(); ih++ ) {
    const AliHLTTPCCALocalMCPoint& mcP = mcPs[ track.FirstMCPointID() + ih ];
    DrawGBLine( mcPLast.X(), mcPLast.Y(), mcPLast.Z(), mcP.X(), mcP.Y(), mcP.Z(), color, width );
    mcPLast = mcP;
  }

}


void AliHLTTPCCADisplay::DrawGBTrackFast( const AliHLTTPCCAGBTracker &tracker, int itr, int color )
{ // TODO
  assert(0);
//   // draw global track

//   AliHLTTPCCAGBTrack &track = tracker.Tracks()[itr];
//   if ( track.NHits() < 2 ) return;
//   int width = 1;

//   AliHLTTPCCADisplayTmpHit *vHits = new AliHLTTPCCADisplayTmpHit[track.NHits()];
//   AliHLTTPCCATrackParam t = track.Param();

//   for ( int ih = 0; ih < track.NHits(); ih++ ) {
//     int i = tracker.TrackHits()[ track.FirstHitRef() + ih];
//     const AliHLTTPCCAGBHit *h = &( tracker.Hits()[i] );
//     vHits[ih].SetID( i );
//     vHits[ih].SetS( 0 );
//     vHits[ih].SetZ( h->Z() );
//   }

//   sort( vHits, vHits + track.NHits(), AliHLTTPCCADisplayTmpHit::CompareHitZ );
//   int colorY = color;
//   {
//     const AliHLTTPCCAGBHit &h1 = tracker.Hits()[ vHits[0].ID()];
//     const AliHLTTPCCAGBHit &h2 = tracker.Hits()[ vHits[track.NHits()-1].ID()];
//     if ( color < 0 ) color = GetColorZ( ( h1.Z() + h2.Z() ) / 2. );
//     double gy1 = h1.Y(), gy2 = h2.Y();
//     if ( colorY < 0 ) colorY = GetColorY( ( gy1 + gy2 ) / 2. );
//     color = colorY = GetColorK( t.QPt() );
//   }

//   fMarker.SetMarkerColor( color );//kBlue);
//   fMarker.SetMarkerSize( 1. );
//   fLine.SetLineColor( color );
//   fLine.SetLineWidth( width );
//   fArc.SetFillStyle( 0 );
//   fArc.SetLineColor( color );
//   fArc.SetLineWidth( width );
//   TPolyLine pl;
//   pl.SetLineColor( colorY );
//   pl.SetLineWidth( width );

//   // YX
//   {

//     const AliHLTTPCCAGBHit &h1 = tracker.Hits()[vHits[0].ID()];
//     const AliHLTTPCCAGBHit &h2 = tracker.Hits()[vHits[track.NHits()-1].ID()];
//     float x1, y1, z1, x2, y2, z2;
//     double vx1, vy1, vx2, vy2;

//     t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1, tracker.GetParameters().Bz()  );
//     vx1 = x1;
//     vy1 = y1;

//     t.GetDCAPoint( h2.X(), h2.Y(), h2.Z(), x2, y2, z2, tracker.GetParameters().Bz()  );
//     vx2 = x2;
//     vy2 = y2;

//     double x0 = t.GetX();
//     double y0 = t.Y();
//     double sinPhi = t.SinPhi();
//     double k = t.Kappa( tracker.GetParameters().Bz() );
//     double ex = t.CosPhi();
//     double ey = sinPhi;

//     if ( TMath::Abs( k ) > 1.e-4 ) {

//       fYX->cd();

//       double r = 1 / TMath::Abs( k );
//       double xc = x0 - ey * ( 1 / k );
//       double yc = y0 + ex * ( 1 / k );

//       double vx = xc, vy = yc;

//       double a1 = TMath::ATan2( vy1 - vy, vx1 - vx ) / TMath::Pi() * 180.;
//       double a2 = TMath::ATan2( vy2 - vy, vx2 - vx ) / TMath::Pi() * 180.;
//       if ( a1 < 0 ) a1 += 360;
//       if ( a2 < 0 ) a2 += 360;
//       if ( a2 < a1 ) a2 += 360;
//       double da = TMath::Abs( a2 - a1 );
//       if ( da > 360 ) da -= 360;
//       if ( da > 180 ) {
//         da = a1;
//         a1 = a2;
//         a2 = da;
//         if ( a2 < a1 ) a2 += 360;
//       }
//       fArc.DrawArc( vx, vy, r, a1, a2, "only" );
//       //fArc.DrawArc(vx,vy,r, 0,360,"only");
//     } else {
//       fYX->cd();
//       fLine.DrawLine( vx1, vy1, vx2, vy2 );
//     }
//   }

//   // ZX
//   AliHLTResizableArray<double> py( track.NHits() ), pz( track.NHits() );

//   for ( int iHit = 0; iHit < track.NHits(); iHit++ ) {

//     const AliHLTTPCCAGBHit &h1 = tracker.Hits()[vHits[iHit].ID()];
//     float x1, y1, z1;
//     double vx1, vy1;
//     t.GetDCAPoint( h1.X(), h1.Y(), h1.Z(), x1, y1, z1, tracker.GetParameters().Bz()  );
//     vx1 = x1;
//     vy1 = y1;
//     py[iHit] = vy1;
//     pz[iHit] = z1;
//   }


//   fZX->cd();
//   pl.DrawPolyLine( track.NHits(), pz.Data(), py.Data() );

//   fLine.SetLineWidth( 1 );
//   delete[] vHits;
// }

// void AliHLTTPCCADisplay::DrawTrackParam( TrackParam t, int color )
// {
//   const AliHLTTPCCAGBTracker &tracker = *fGB;

//   for ( int i = 0; i < 100; ++i ) {
//     double x = t.X();
//     double y = t.Y();
//     double sinPhi = t.SinPhi();
//     double z = t.Z();
//     double dzds = t.DzDs();
//     double ex = t.CosPhi();
//     double ey = sinPhi;

//     fLine.SetLineWidth( 1 );
//     fLine.SetLineColor( color );

//     double vx = x, vy = y, vex = ex, vey = ey;
//     double d = CAMath::RSqrt( vex * vex + vey * vey );
//     vex *= d;
//     vey *= d;

//     fYX->cd();
//     fLine.DrawLine( vx, vy, vx + vex*4, vy + vey*4 );
//     fZX->cd();
//     fLine.DrawLine( z, vy, z + dzds*4, vy + vey*4 );

//     t.TransportToX( x + ex * CAMath::RSqrt( ex * ex + ey * ey ), tracker.GetParameters().cBz() );
//   }
}

void AliHLTTPCCADisplay::SaveCanvasToFile( TString fileName){
  fCanvas->SaveAs(fileName);
}

void AliHLTTPCCADisplay::SetTPC( const AliHLTTPCCAParam& tpcParam){ // iklm
  UNUSED_PARAM1(tpcParam); // TODO
  fZMin = 0;
  fZMax = 100;
  fYMin = -250; // s potolka?
  fYMax = 250;
  fRInnerMin = //tpcParam.RMin();
  fRInnerMax = 123.; // approximate TODO: from file!
  fROuterMin = 123.;
  fROuterMax = 50;//tpcParam.RMax();
}