//----------------------------------------------------------------------------
// File and Version Information: 
// $Id: TSvtTrack.cc,v 1.4 2002/11/07 20:04:08 murat Exp $
//
// Description:   
// Implement TSvtTrack which contains the unpacked information 
//     from the SVTD bank  
//            
// Author List:
//     L. Moneta 
//     Subir Sarkar    Adapted to Stntuple
//----------------------------------------------------------------------------

#include <iostream>
#include <iomanip>
#include <cmath>
#include "Stntuple/data/TSvtTrack.hh"

using namespace std; 

// To convert from strip/16 to cm:  
// using SVXII layers 0, 1, 2, 3, 4 
const Float_t TSvtTrack::fgHitScale[] = {
     10000.*16./60., 
     10000.*16./62., 
     10000.*16./60., 
     10000.*16./60., 
     10000.*16./65.
}; 

// Other scale constants 
const Float_t TSvtTrack::fgPhiScale = 8192.0;
const Float_t TSvtTrack::fgD0Scale  = 0.0010;
const Float_t TSvtTrack::fgCurScale = 1.17e-5;
const Float_t TSvtTrack::fgChiScale = 1.;

ClassImp(TSvtTrack)
                                // **** Root Streamer
void TSvtTrack::Streamer(TBuffer &R__b) {
    // Stream an object of class TSvtTrack.
    // data members: The 7 tracks words
  Int_t size = SVTD_SIZE;
  if (R__b.IsReading()) {
    Version_t R__v = R__b.ReadVersion(); if (R__v) { }
    R__b.ReadFastArray(fWords, size);
  }
  else { 
    R__b.WriteVersion(TSvtTrack::IsA());
    R__b.WriteFastArray(fWords, size);
  }
}
                       // ***** Constructors
TSvtTrack::TSvtTrack() {
}
TSvtTrack::TSvtTrack(const Int_t size, Int_t *data) { 
  for (int i = 0; i < size; i++) {
    fWords[i] = data[i];
  }
}  
                       // ***** Destructor
TSvtTrack::~TSvtTrack() {
}

Float_t TSvtTrack::Phi() const { 
  return (fWords[0] & 0x1fff)*(2*M_PI/TSvtTrack::fgPhiScale); 
}
Int_t TSvtTrack::Zin() const {
  return (fWords[0] >> 13) & 0x7; 
}
Int_t TSvtTrack::Zout() const {
  return (fWords[0] >> 16) & 0x7; 
}
Float_t TSvtTrack::Curv() const {
  return (((fWords[1] >> 18) & 0x1) ? -1.0 : 1.0)*(fWords[1] >> 10 & 0xff)*TSvtTrack::fgCurScale;
}
Float_t TSvtTrack::D0() const {
  return ((fWords[1] >> 9 & 0x1) ? -1.0 : 1.0)*(fWords[1] & 0x1ff)*TSvtTrack::fgD0Scale;
}
Int_t TSvtTrack::Wedge() const {
  return (fWords[2] >> 17) & 0xf;
}
Int_t TSvtTrack::Road() const {
  return fWords[2] & 0x7fff;
} 
Float_t TSvtTrack::Chi2() const {
  return (fWords[5] >> 10 & 0x7ff)*TSvtTrack::fgChiScale; 
} 
Int_t TSvtTrack::XftNumber() const {
  return fWords[6] & 0x1ff;
} 
Int_t TSvtTrack::TFStatus() const {
  return (fWords[6] >> 9) & 0xfff;
} 
Int_t TSvtTrack::FitQuality() const {
  return TFStatus() & 0xf;
} 
Int_t TSvtTrack::TFError() const {
  return (TFStatus() >> 5) & 0x7f;
} 
Int_t TSvtTrack::HitOverflow() const {
  return TFError() & 0x1; 
} 
Int_t TSvtTrack::LayerOverflow() const {
  return (TFError() >> 1) & 0x1;
} 
Int_t TSvtTrack::CombOverflow() const {
  return (TFError() >> 2) & 0x1;
} 
Int_t TSvtTrack::InvalidData() const {
  return (TFError() >> 3) & 0x1;
} 
Int_t TSvtTrack::FitOverflow() const {
  return (TFError() >> 4) & 0x1;
} 
Int_t TSvtTrack::FifoOverflow() const {
  return (TFError() >> 5) & 0x1;
} 
Int_t TSvtTrack::ErrorOR() const {
  return (TFError() >> 6) & 0x1;
}
Float_t TSvtTrack::Hit(const Int_t layer) const {
  if (layer < 0 || layer > 4) return -1;
  return Hit16(layer)/TSvtTrack::fgHitScale[layer];
}
Int_t TSvtTrack::Hit16(const Int_t layer) const {
  Int_t value;
  switch (layer) {
    case 0:
      value = fWords[3] & 0xff;
      break;
    case 1:
      value = (fWords[3] >> 10) & 0xff;
      break;
    case 2:
      value = fWords[4] & 0xff;
      break;
    case 3:
      value = (fWords[4] >> 10) & 0xff;
      break;
    default:
      value = fWords[5] & 0xff;
      break;
  }
  return value;
}

Int_t TSvtTrack::HitLCF(const Int_t layer) const {
  Int_t value;
  switch (layer) {
    case 0:
      value = (fWords[3] >>  8) & 0x1;
      break;
    case 1:
      value = (fWords[3] >> 18) & 0x1;
      break;
    case 2:
      value = (fWords[4] >>  8) & 0x1;
      break;
    case 3:
      value = (fWords[4] >> 18) & 0x1;
      break;
    default:
      value = (fWords[5] >>  8) & 0x1;
      break;
  }
  return value;
}

Int_t TSvtTrack::HitEF(const Int_t layer) const {
  Int_t value;
  switch (layer) {
    case 0:
      value = (fWords[3] >>  9) & 0x1;
      break;
    case 1:
      value = (fWords[3] >> 19) & 0x1;
      break;
    case 2:
      value = (fWords[4] >>  9) & 0x1;
      break;
    case 3:
      value = (fWords[4] >> 19) & 0x1;
      break;
    default:
      value = (fWords[5] >>  9) & 0x1;
      break;
  }
  return value;
}

Float_t TSvtTrack::Pt() const {
  static const Float_t SCALE_PT_TO_CURV = 0.002116;
  Float_t curv = Curv();
  return ( (fabs(curv) > 1.0e-10) ? SCALE_PT_TO_CURV / fabs(curv)
                                  : 1.0e10 ); 
}  
                        // **** Overload methods
//_____________________________________________________________________________
void TSvtTrack::Clear(Option_t *opt) 
{
}

//_____________________________________________________________________________
void TSvtTrack::Print(Option_t *opt) const
{
  // Print variables in a nice format
  if (!strcmp(opt, "banner") || !strcmp(opt, "Banner")) {
    cout << " Trk    Phi     D0      Curv       Pt     Chi2  Wedge  Zin  Zout  Road  XFT" 
         << " Hit(0)  Hit(1)  Hit(2)  Hit(3)  Hit(4)   QFit  TFSt  TFErr" << endl;
  }
  else {
    cout  << setiosflags(ios::fixed);
    cout  << setprecision(4) 
          << setw(9)  << Phi() 
          << setw(8)  << D0()
          << setw(10) << setprecision(6) << Curv()
          << setw(8) << setprecision(2) 
          << ( (fabs(Pt()) > 999.99) ? ( (Pt() < 0.0 ? -1 : 1) * 999.99 )
                                     : Pt() )
          << setw(7)  << dec << static_cast<Int_t>(Chi2())
          << setw(6)  << dec << Wedge()
          << setw(6)  << Zin()
          << setw(6)  << Zout()
          << setw(7)  << dec << Road()
          << setw(4)  << dec << XftNumber() 
          << setw(8)  << setprecision(4) << Hit(0)  
          << setw(8)  << Hit(1)  
          << setw(8)  << Hit(2)   
          << setw(8)  << Hit(3)
          << setw(8)  << Hit(4)
          << setw(6)  << hex << FitQuality() 
          << setw(6)  << hex << TFStatus()
          << setw(6)  << hex << TFError() << dec << endl;
  }
}