#ifndef HKALTRACK_H
#define HKALTRACK_H

// from ROOT
#include "TObject.h"

// from hydra
#include "hbasetrack.h"

class HKalTrack : public HBaseTrack {

private:

    static const Int_t nDafs = 5; // Number of iterations done in the annealing filter.

    Bool_t  bAccepted;      // Track reconstruction with Kalman filter was successful or failed.
    Float_t chi2;           // Chi2.
    Float_t dafChi2Cut;     // Cut-off parameter of the deterministic annealing filter.
    Float_t dafT[nDafs];    // Annealing factors.
    Float_t momInput;       // Starting estimation of momentum.
    Float_t ndf;            // Number degrees of freedom.
    Int_t   nIter;          // Number of Kalman filtering iterations.
    Float_t trackLength;    // Track length through all MDCs
    Int_t   pid;            // Geant particle id.

    Bool_t direction;    // kIterForward or kIterBackward.
    Bool_t doDaf;        // Used the annealing filter.
    Bool_t doEnerLoss;   // Included energy loss.
    Bool_t doMultScat;   // Included multiple scattering.
    Bool_t isSegHit;     // Is a 2d hit.
    Bool_t isWireHit;    // Is a drift chamber wire hit.

    Int_t idxFirst;      // Index of first hit in the track.
    Int_t idxLast;       // Indes of last hit in the track.

public:

    HKalTrack();

    virtual ~HKalTrack() { ; }

    virtual Bool_t  getAccepted      () const { return bAccepted; }

    virtual Float_t getChi2          () const { return chi2; }

    virtual Float_t getDafChi2Cut    () const { return dafChi2Cut; }

    virtual Float_t getDafT          (Int_t i) { if(i >=0 && i < nDafs) { return dafT[i]; } return -1.F; }

    virtual Bool_t  getDirection     () const { return direction; }

    virtual Bool_t  getDoDaf         () const { return doDaf; }

    virtual Bool_t  getDoMultScat    () const { return doMultScat; }

    virtual Bool_t  getDoEnerLoss    () const { return doEnerLoss; }

    virtual Int_t   getIdxFirst      () const { return idxFirst; }

    virtual Int_t   getIdxLast       () const { return idxLast; }

    virtual Bool_t  getIsSegHit      () const { return isSegHit; }

    virtual Bool_t  getIsWireHit     () const { return isWireHit; }

    static  Int_t   getMaxNdafs      ()       { return nDafs; }

    virtual Float_t getMomInput      () const { return momInput; }

    virtual Int_t   getNdafs         () const;

    virtual Float_t getNdf           () const { return ndf; }

    virtual Int_t   getNiter         () const { return nIter; }

    virtual Float_t getTrackLength   () const { return trackLength; }

    virtual Int_t   getPid           () const { return pid; }

    virtual void    setAccepted      (Bool_t bAcc) { bAccepted = bAcc; }

    virtual void    setChi2          (Float_t c)   { chi2 = c;}

    virtual void    setDafChi2Cut    (Float_t c)   { dafChi2Cut = c; }

    virtual void    setDafT          (Float_t t, Int_t i) { if(i >= 0 && i < nDafs) dafT[i] = t; }

    virtual void    setDirection     (Bool_t dir)  { direction = dir; }

    virtual void    setDoDaf         (Bool_t daf)  { doDaf = daf; }

    virtual void    setDoMultScat    (Bool_t ms)   { doMultScat = ms; }

    virtual void    setDoEnerLoss    (Bool_t dedx) { doEnerLoss = dedx; }

    virtual void    setIdxFirst      (Int_t i)     { idxFirst = i; }

    virtual void    setIdxLast       (Int_t i)     { idxLast = i; }

    virtual void    setIsSegHit      (Bool_t seg)  { isSegHit = seg; }

    virtual void    setIsWireHit     (Bool_t wire) { isWireHit = wire; }

    virtual void    setMomInput      (Float_t mom) { momInput = mom; }

    virtual void    setNdf           (Float_t n)   { ndf = n; }

    virtual void    setNiter         (Int_t n)     { nIter = n; }

    virtual void    setTrackLength   (Float_t l)   { trackLength = l; }

    virtual void    setPid           (Int_t id)    { pid = id; }

    ClassDef (HKalTrack,1)
};

#endif