#ifndef STNTUPLE_TStnTrack
#define STNTUPLE_TStnTrack

#include "TLorentzVector.h"
#include "TArrayF.h"

#include "Stntuple/base/TMatrix55.hh"

class StnTrackBlock_t;
class CdfTrack;
class TCesCluster;
class TCesShower;
class TStnDataBlock;
class AbsEvent;

class TStnTrack: public TObject {

  friend Int_t StntupleInitTrack(TStnTrack*, const CdfTrack*, Int_t Mode);
  friend Int_t StnRun1InitTrack (TStnTrack* Vert,StnTrackBlock_t* R1V,Int_t I);
  friend Int_t StntupleInitTrackBlock(TStnDataBlock*, AbsEvent*, int);

  enum {
    kNIntegers52 = 10,
    kNFloats52   = 17
  };
				// added 3 chi*2's
  enum {
    kNIntegers53 = 10,
    kNFloats53   = 20
  };

  enum {                        // added 1 genp number Int_t
    kNIntegers54 = 11,
    kNFloats54   = 20
  };				
  enum {                        // added iExpected (Beate)
    kNIntegers57 = 12,
    kNFloats57   = 20
  };
  enum {                        // added dE/dx
    kNIntegers59 = 13,
    kNFloats59   = 20
  };


protected:
//------------------------------------------------------------------------------
//  data members
//------------------------------------------------------------------------------
  TLorentzVector fMomentum;		// 4-momentum in the primary vertex

  Float_t        fCot;			// cot(theta) of track
  Float_t        fCurv;			// track curvature
  Float_t        fZ0;			// z_0 of track in the point of CA
  Float_t        fD0;
  Float_t        fPhi0;

  Float_t        fPt;
  Float_t        fEta;
  Float_t        fT0;		        // T0 from Cot_tZero
  Float_t        fT0Sigma;		// error on T0

  Float_t        fBcZ0;			// beam-constrained parameters
  Float_t        fBcD0;                 //
  Float_t        fBcPhi0;
  Float_t        fBcC0;
  Float_t        fBcLam0;

  Float_t        fIso4;                 // relative isolation in cone 0.4
  Float_t        fUd0;			// D0 with respect to the beam axis
  Float_t        fUiso4;		// iso as returned by top/tkiso.F
  Float_t        fChi2;			// chi**2 of the COT+SVX fit
  Float_t        fChi2Cot;		// chi**2 of COT-only fit
  Float_t        fChi2Svx;		// chi**2 of SVX-only fit

  TMatrix55      fCov;			//|| track covariance matrix (5x5)
  Float_t        fBcp4[4];		// beam-constrained momentum

  Int_t          fAlgorithm;		// algorithm word (bit-packed)
  Int_t          fVind;			// vertex number
  Int_t          fBcvind;		// vertex # for beam-constrained fit

					// ***** added in v2.0 - will make it
					// an integer
					// track number & (obsp number << 16) 
  Int_t          fNumber;
					// COT hits (4 bytes), wiil make it an
					// integer later
					// fNTotalCotHits         ||
					// (fNAxialCotHits  << 8) ||
					// (fNStereoCotHits << 16)||
					// fNCotSeg
  Int_t          fCotHitWord;

  Int_t          fCotHitMask[3];	// mask of hit COT layers (96 bits)

					// SVX hit information
					// fNSvxHits || (fNSvxRPhiHits << 8) ||
					// (fNSvxSASHits << 16) ||
					// (fNSvxZHits   << 24) 
  Int_t          fSvxHitWord;
  Int_t          fSvxHitMask;		// SVX hit mask

  Int_t          fGenpNumber;           // Genp particle association
  Int_t          fSiExpWord;            // number of expected Si hits on track
                                        // and number of hits in cone of 0.4
  Int_t          fdEdxWord;             // bits 0:6 Nhits used, 7:31 10*dE/dx
//-----------------------------------------------------------------------------
//  transient data members, all the persistent ones should go above
//-----------------------------------------------------------------------------
  Int_t          fCdfTrackId;           // ! Do not stream the id
					//   variable since it is only
					//   used to make TrackLinkBlock.
  CdfTrack*      fCdfTrack;		// ! pointer to parent CdfTrack for 
				        //   internal use
  Float_t        fTmp[10];              // ! for temporary analysis needs
//------------------------------------------------------------------------------
// so far - transient-only variables, you have to define them before use
//------------------------------------------------------------------------------
public:
  TCesCluster*   fCesCluster[2];	// ! closest CES cluster [0]:s, [1]:w
  Int_t          fSide;			// !
  Int_t          fWedge;		// !
  Double_t       fXCes   [2];		// ! 
  Double_t       fDelXCes[2];           // ! residuals - to make it simple
  TCesShower*    fCesShower;	        // ! closest CES shower (development)
  Double_t       fCesDist;	        // ! dist to the closest shower (devel)
  Double_t       fXCesBc   [2];	        // ! beam-constrained extrapolation
  Double_t       fDelXCesBc[2];	        // ! beam-constrained extrapolation
  Double_t       fDZ0;                  // ! delta(Z) in the primary vertex
  Int_t          fNSh;                  // ! N(showers) within fMaxDist
  Double_t       fESh;                  // ! total E of the close showers
  Int_t          fSideBc;               // !
  Int_t          fWedgeBc;              // !
//------------------------------------------------------------------------------
//  functions
//------------------------------------------------------------------------------
public:
					// ****** constructors and destructor
  TStnTrack(Int_t Number = -1);
					// Flag=1: Cov is 5x5, Flag=2: upper
					// triangle of Cov is passed

  TStnTrack(double* Par, double* Cov, int Flag);
  virtual ~TStnTrack();
//-----------------------------------------------------------------------------
// accessors
//-----------------------------------------------------------------------------
  TLorentzVector* Momentum() { return &fMomentum; }
  
  Int_t  GetBcMomentum(TLorentzVector* BcMom   );
  Int_t  GetMomentum  (TLorentzVector* Momentum);
//-----------------------------------------------------------------------------
					// algorithm for the moment is integer
					// in principle need 4-5 bits

  Int_t           Algorithm    () const { return (fAlgorithm)      & 0xff; }
  Int_t           CotParentAlgo() const { return (fAlgorithm >> 8) & 0xff; }
  Int_t           IsCMUFid     () const { return (fAlgorithm >> 16) & 0x1; }
  Int_t           IsCMPFid     () const { return (fAlgorithm >> 17) & 0x1; }
  Int_t           IsCMXFid     () const { return (fAlgorithm >> 18) & 0x1; }
  Int_t           IsBMUFid     () const { return (fAlgorithm >> 19) & 0x1; }
  Int_t           IsCMUFid2    () const { return (fAlgorithm >> 20) & 0x1; }
  Int_t           IsCMPFid2    () const { return (fAlgorithm >> 21) & 0x1; }
  Int_t           IsCMXFid2    () const { return (fAlgorithm >> 22) & 0x1; }
  Int_t           IsBMUFid2    () const { return (fAlgorithm >> 23) & 0x1; }
  Int_t           FidEleStatus () const { return (fAlgorithm >> 24) & 0xff;}

  Float_t         Lam0   () const { return fCot;    }
  Float_t         Eta    () const { return fEta;    }
  Float_t         C0     () const { return fCurv;   }
  Float_t         D0     () const { return fD0;     }
  Float_t         Z0     () const { return fZ0;     }
  Float_t         X0     () const { return -fD0*sin(fPhi0)*Charge(); }
  Float_t         Y0     () const { return  fD0*cos(fPhi0)*Charge(); }
  Float_t         Phi0   () const { return fPhi0;   }
  Float_t         Pt     () const { return fPt;     }
  Float_t         Charge () const { return (fCurv > 0) ? 1. : -1.; }
  Float_t         T0     () const { return fT0;   }
  Float_t         T0Sigma() const { return fT0Sigma;}
  Float_t         Iso4   () const { return fIso4;   }
  Float_t         Chi2   () const { return fChi2; }
  Float_t         Chi2Cot() const { return fChi2Cot; }
  Float_t         PhoenixChi2DofSeed() const { return fChi2Cot; }
  Float_t         Chi2Svx() const { return fChi2Svx; }

  Float_t         Chi2CotDof() const { return fChi2Cot/(NCotHitsTot()-4.9999); }

  Float_t         BcLam0 () const { return fBcLam0;  }
  Float_t         BcC0   () const { return fBcC0;    }
  Float_t         BcZ0   () const { return fBcZ0;    }
  Float_t         BcPhi0 () const { return fBcPhi0;  }
  Float_t         BcD0   () const { return fBcD0;    }

  TMatrix55*      Cov    () { return &fCov;  }
//-----------------------------------------------------------------------------
// COT hit section
//-----------------------------------------------------------------------------
  Int_t           CotHitMask(int im) const { return fCotHitMask[im]; }

  Int_t           HasCotHit (int il) const { 
    int iw = il/32;
    int ib = il-iw*32;
    return (fCotHitMask[iw] >> ib) &0x1;
  }

  Int_t           NCotHits(Int_t Isl) const;

  Int_t           NCotHitsTot() const { return (fCotHitWord      ) & 0xff; }
  Int_t           NCotHitsAx () const { return (fCotHitWord >>  8) & 0xff; }
  Int_t           NCotHitsSt () const { return (fCotHitWord >> 16) & 0xff; }
  Int_t           NAxSeg     () const { return (fCotHitWord >> 24) & 0xf; }
  Int_t           NStSeg     () const { return (fCotHitWord >> 28) & 0xf; }

  Int_t           NCotStSeg(Int_t MinHits) const;
  Int_t           NCotAxSeg(Int_t MinHits) const;
//-----------------------------------------------------------------------------
//  SVX hit section
//-----------------------------------------------------------------------------
  Int_t           NSvxHits       () const { return (fSvxHitWord      ) & 0xff; }
  Int_t           NSvxRPhiHits   () const { return (fSvxHitWord >>  8) & 0xff; }
  Int_t           NSvxSASHits    () const { return (fSvxHitWord >> 16) & 0xff; }
  Int_t           NSvxZHits      () const { return (fSvxHitWord >> 24) & 0xff; }

  Int_t           NSvxStereoHits () const { return NSvxSASHits()+NSvxZHits(); }
  Int_t           SvxHitMask     () const { return fSvxHitMask; }

  Int_t           Is3D           () const { return (NStSeg() > 0); }

  Int_t           NSiExpected    () const {return (fSiExpWord         ) &0xff;}
  Int_t           NSiExpectedPhi () const {return (fSiExpWord >> 8    ) &0xff;}
  Int_t           NSiHitCone     () const {return (fSiExpWord >>16    ) &0xffff;}
//-----------------------------------------------------------------------------
// SVX geometry is such that in a given layer a track can have up to 4 hits  - 
// 2 on the stereo side and 2 on axial side
// 'HasSvxHit' returns 1 if a track has at least one hit in a given layer
//                     0 otherwise
// layers are numbered from 0(L00) to 7(outermost ISL layer)
//-----------------------------------------------------------------------------
  Int_t           HasSvxHit      (Int_t Layer);
  Int_t           HasSvxAxialHit (Int_t Layer);
  Int_t           HasSvxStereoHit(Int_t Layer);

  // the dEdx and the number of COT hits used in the dEdx
  Float_t         Dedx           () const {return float(fdEdxWord>>7)/10.0;}
  Int_t           NDedx          () const {return fdEdxWord&0x7F;}

  Int_t           Number      () const { return fNumber & 0xffff; }

  Int_t           McNumber    () const { 
    Warning("McNumber",
	    "deprecated, use TStnTrack::ObspNumber instead. -thanks, Pasha"); 
    return (fNumber >> 16) & 0xffff; 
  }

  Int_t           ObspNumber  () const { 
    return int (short ((fNumber >> 16) & 0xffff)); 
  } 

  Int_t           GenpNumber    () const { return fGenpNumber;   }
  Int_t           VertexNumber  () const { return fVind;         }

  Int_t           CotRefitStatus() const { return fBcvind & 0xffff; }
//-----------------------------------------------------------------------------
//  transient-only variables
//-----------------------------------------------------------------------------
  CdfTrack*       GetCdfTrack  ()       { return fCdfTrack;   }
  Int_t           GetCdfTrackId() const { return fCdfTrackId; }
//-----------------------------------------------------------------------------
//  accessors for transient-only data members - make sure those are 
//  initialized - initialization is up to you!
//-----------------------------------------------------------------------------
  Int_t           Side                () const { return fSide;    }
  Int_t           Wedge               () const { return fWedge;   }
  Float_t         ZCes                () const { return fXCes[0]; }
  Float_t         XCes                () const { return fXCes[1]; }
  Float_t         XCes         (Int_t I) const { return fXCes[I]; }
  TCesCluster*    GetCesCluster(Int_t I) const { return fCesCluster[I]; }
  Double_t        DelZCes             () const { return fDelXCes[0]; }
  Double_t        DelXCes             () const { return fDelXCes[1]; }
  Double_t        DelXCes      (Int_t I) const { return fDelXCes[I]; }

  Int_t           SideBc              () const { return fSideBc;  }
  Int_t           WedgeBc             () const { return fWedgeBc; }
  Float_t         ZCesBc              () const { return fXCesBc[0]; }
  Float_t         XCesBc              () const { return fXCesBc[1]; }
  Float_t         XCesBc       (Int_t I) const { return fXCesBc[I]; }
  Double_t        DelZCesBc           () const { return fDelXCesBc[0]; }
  Double_t        DelXCesBc           () const { return fDelXCesBc[1]; }
  Double_t        DelXCesBc    (Int_t I) const { return fDelXCesBc[I]; }
  Double_t        DZ0                 () const { return fDZ0;          }

  TCesShower*     GetCesShower () const { return fCesShower; }
  Double_t        CesDist      () const { return fCesDist  ; }
  Int_t           NSh          () const { return fNSh      ; }
  Double_t        ESh          () const { return fESh      ; }

  Float_t&        Tmp   (Int_t I)       { return fTmp[I]; }
//-----------------------------------------------------------------------------
//  modifiers
//-----------------------------------------------------------------------------
  void            SetVertexNumber(int    iv  ) { fVind     = iv; }
  void            SetIso4        (float  Iso4) { fIso4     = Iso4; }
  void            SetCdfTrack    (CdfTrack* Track) { fCdfTrack = Track; }
  void            SetCdfTrackId  (Int_t    Id) { fCdfTrackId = Id; }

  void            SetNumber      (int it) {
    fNumber = (fNumber & 0xffff0000) | (it & 0xffff);
  }
  void            SetObspNumber   (int it) {
    fNumber = (fNumber & 0x0000ffff) | ((it << 16) & 0xffff0000);
  }
  void            SetGenpNumber   (int it ) { fGenpNumber = it; }

  void            SetLam0   (Float_t  Lam0) { fCot   = Lam0; }
  void            SetC0     (Float_t  C0  ) { fCurv  = C0;   }
  void            SetZ0     (Float_t  Z0  ) { fZ0    = Z0;   }
  void            SetPhi0   (Float_t  Phi0) { fPhi0  = Phi0; }
  void            SetD0     (Float_t  D0  ) { fD0    = D0;   }
  void            SetDZ0    (Float_t  DZ0 ) { fDZ0   = DZ0;  }

  void            SetParameters(Float_t Lam0, Float_t C0, Float_t Z0, 
				Float_t Phi0, Float_t D0);

  void            SetParameters(Float_t*   Par);
  void            SetParameters(Double_t*  Par);
  void            SetCovariance(Float_t*   Cov);
  void            SetCovariance(Double_t*  Cov);
  void            SetCovariance(TMatrix55& Cov);

  void            SetCesParameters(Int_t    Side, Int_t    Wedge, 
				   Double_t XCes, Double_t ZCes ,
				   Int_t    BeamConstrained = 0) 
  {
    if (BeamConstrained == 0) { 
      fSide   = Side; fWedge   = Wedge; fXCes  [0] = ZCes; fXCes  [1] = XCes; 
    }
    else { 
      fSideBc = Side; fWedgeBc = Wedge; fXCesBc[0] = ZCes; fXCesBc[1] = XCes; 
    }
  }

  void            SetCesCluster(Int_t I, TCesCluster* Cluster, 
				Double_t DelX, int Bc = 0) {
    fCesCluster[I] = Cluster;
    fDelXCes   [I] = DelX;
    if (Bc != 0) fDelXCesBc[I] = DelX;
  }

  void            SetCesShower(TCesShower* Shower, Double_t Dist) {
    fCesShower = Shower;
    fCesDist   = Dist;
  }

  void            SetShowerInfo(Int_t NSh, Double_t ESh) {
    fNSh       = NSh;
    fESh       = ESh;
  }

  void            SetCesBcResiduals(Double_t DelZ, Double_t DelX) {
    fDelXCesBc[0] = DelZ;
    fDelXCesBc[1] = DelX;
  }
//-----------------------------------------------------------------------------
//  overloaded methods of TObject
//-----------------------------------------------------------------------------
  void Print(Option_t* option = "") const;
//-----------------------------------------------------------------------------
// schema evolution
//-----------------------------------------------------------------------------
  void     ReadV51   (TBuffer& R__b);
  void     ReadV52   (TBuffer& R__b);
  void     ReadV53   (TBuffer& R__b);
  void     ReadV54_56(TBuffer& R__b);
  void     ReadV57_58(TBuffer& R__b);

  ClassDef(TStnTrack,59)
};

#endif