#ifndef HKalSystem_h
#define HKalSystem_h

// from ROOT
#include "TClonesArray.h"
class     TObjArray;
#include "TRotation.h"
#include "TMatrixD.h"
class     TVector3;
#include "TVectorD.h"

//? daf test
#include "TFile.h"
#include "TNtupleD.h"

// from hydra
class HMdcTrackGField;

#include "hkaldef.h"
using namespace Kalman;
#include "hkalrungekutta.h"
#include "hkaltracksite.h"



class HKalSystem : public TObject {

private:

    Bool_t   bDoDeDx;        // Energy loss.
    Bool_t   bDoSmooth;      //! Do smoothing.
    Bool_t   bPrintWarn;     //! Print warning messages.
    Bool_t   bDoDaf;         // Run the Deterministic Annealing Filter.
    Bool_t   bTrackAccepted; // Track filtering done without errors.
    Double_t chi2;           // chi2 of track.
    Double_t chi2High;       //! The maximum chi^2 where the track fitting is still accepted.
    Bool_t   direction;      // Propagation direction: kIterForward/kIterBackward
    TMatrixD fProj;          //! Projector matrix.
    TMatrixD fProjTrans;     //! Transposed projector matrix.
    Int_t    nKalRuns;       // Number of Kalman filter iterations.
    Int_t    nHitsInTrack;   // Number of hits in a track.
    Int_t    pid;            // Geant particle id.
    Int_t    rotCoords;      // Option to tilt coordinate system for track fitting.

    HKalTrackSite  **sites;           //! Array of track sites.
    HKalRungeKutta   trackPropagator; //! The object that realizes the track propagation.
    TRotation       *pRotMat;         //! Rotation matrix for possible coordinate tilting.

    TNtupleD *hDafMonitor; //? daf test

protected:

    virtual void   calcIniStateVec(TVectorD &stateVec, Double_t iniQP) const;

    virtual void   calcIniTrackDir(TVector3 &dir) const;

public:

    HKalSystem(Int_t nHits, Int_t measDim, Int_t stateDim, Double_t chiHigh=500.);

    virtual ~HKalSystem();

    virtual void   calcIniCovMat             (TMatrixD &fCov) const;

    virtual void   calcIniStateVec           (TVectorD &stateVec, Double_t iniQP, const TObjArray &allhits) const;

    virtual void   calcIniTrackDir           (TVector3 &dir, const TObjArray &allhits) const;

    virtual void   calcProjector             (TMatrixD &fProj);

    virtual Bool_t fitTrack                  (const TObjArray &hits, Double_t iniQP, Int_t pid);

    virtual Bool_t fitTrack                  (const TObjArray &hits, const TVectorD &iniStateVec, const TMatrixD &iniCovMat, Int_t pId);

    virtual Bool_t predictAndFilter          (Int_t fromSite, Int_t toSite);

    virtual void   filter                    (Int_t iSite);

    virtual void   smoothAll                 ();

    virtual void   excludeSite               (Int_t iSite);

    virtual void   transformFromSectorToTrack();

    virtual void   transformFromTrackToSector();

    virtual void   updateSites               (const TObjArray &hits);

    virtual Double_t            getChi2         () const           { return chi2; }

    virtual TNtupleD*           getDafResults   () const           { return hDafMonitor; }

    virtual Bool_t              getDirection    () const           { return direction; }

    virtual Double_t            getFieldIntegral() const           { return trackPropagator.calcFieldIntegral().Mag(); }

    virtual Int_t               getNDF          () const;

    virtual Int_t               getNhits        () const           { return nHitsInTrack; }

    virtual inline HKalTrackSite* getSite       (UInt_t site) const {
#ifdef kalDebug
        if(site < (UInt_t)nHitsInTrack) {
            return sites[site];
        } else {
            Warning("getSite()", "Index out of range.");
            return NULL;
        }
#else
        return sites[site];
#endif
    }

    virtual Int_t               getMeasDim      () const           { return getSite(0)->getMeasDim(); }

    virtual Int_t               getStateDim     () const           { return getSite(0)->getStateDim(); }

    virtual void setFillPointsArrays(Bool_t fill)                          { trackPropagator.setFillPointsArrays(fill); }

    virtual void setFieldMap        (HMdcTrackGField *fMap, Double_t fpol) { trackPropagator.setFieldMap(fMap, fpol); }

    virtual void setFilterOptions   (Int_t kalRuns, Bool_t dir, Bool_t smooth, Kalman::kalRotateOptions rotate);

    virtual void setRotationAngles  (Double_t rotXAngle, Double_t rotYAngle);

    virtual void setPrintWarnings   (Bool_t print);

    virtual void switchMS           (Bool_t ms)   { trackPropagator.switchMS(ms); }

    virtual void switchDEDX         (Bool_t dedx) { bDoDeDx = dedx; trackPropagator.switchDEDX(dedx); }

    ClassDef(HKalSystem,0)
};

#endif // HKalSystem_h