predictModel.hpp

/* $Id$ */

#ifndef FILTER_PREDICT_MODEL_HPP
#define FILTER_PREDICT_MODEL_HPP

#include "boost/date_time/posix_time/posix_time_types.hpp"

#include "kernel/jafarException.hpp"

#include "jmath/jblas.hpp"

namespace jafar {
  namespace filter {

    class KalmanFilter;
    class ExtendedKalmanFilter;
    class BlockExtendedKalmanFilter;

    class BasePredictModel {
      
    private:

      std::size_t m_sizeState;
    
    protected:

      boost::posix_time::time_duration m_timeStep;

    public:

      jblas::mat F;

      jblas::sym_mat Q;

      BasePredictModel(std::size_t sizeState) :
  m_sizeState(sizeState),
  m_timeStep(0,0,1,0),
  F(sizeState,sizeState),
  Q(sizeState,sizeState)
      {}

      virtual ~BasePredictModel() {}

      std::size_t sizeState() const {return m_sizeState;};

      boost::posix_time::time_duration const& getTimeStep() const {return m_timeStep;};

      virtual void setTimeStep(boost::posix_time::time_duration const& timeStep) {
  m_timeStep = timeStep;
      }

    }; // class BasePredictModel

    class BaseCommandPredictModel : public BasePredictModel {

    private:
      std::size_t m_sizeCommand;

    protected:
      jblas::sym_mat m_uCov;
      
    public:

      jblas::mat G;

      BaseCommandPredictModel(std::size_t sizeState, std::size_t sizeCommand) :
  BasePredictModel(sizeState),
  m_sizeCommand(sizeCommand),
  m_uCov(sizeCommand, sizeCommand),
  G(sizeState, sizeCommand)
      {
  m_uCov.clear();
      }

      virtual ~BaseCommandPredictModel() {}

      std::size_t sizeCommand() const {return m_sizeCommand;}

      void setUCov(jblas::sym_mat const& uCov) {
  m_uCov.assign(uCov);
      }

      jblas::sym_mat const& getUCov() const {return m_uCov;}

      virtual void computeUCov(jblas::vec const& u) {}

    };

    class LinearPredictModel : public BasePredictModel {

    public:

      LinearPredictModel(std::size_t sizeState) :
  BasePredictModel(sizeState) {}

      LinearPredictModel(const jblas::mat& F_,
                         const jblas::sym_mat& Q_);

      virtual ~LinearPredictModel() {}

    }; // class LinearPredictModel


    class LinearCommandPredictModel : public BaseCommandPredictModel {

    public:

      LinearCommandPredictModel(std::size_t sizeState, std::size_t sizeCommand) :
  BaseCommandPredictModel(sizeState, sizeCommand) {}

      LinearCommandPredictModel(const jblas::mat& F_,
        const jblas::mat& G_,
        const jblas::sym_mat& Q_);

      virtual ~LinearCommandPredictModel() {}

    };

    class JacobianPredictModel : public BasePredictModel {

    public:
      
      JacobianPredictModel(std::size_t sizeState) :
  BasePredictModel(sizeState) {}

      virtual ~JacobianPredictModel() {}

      virtual void predict(jblas::vec& x) = 0;

    }; // class JacobianPredictModel

    class JacobianCommandPredictModel : public BaseCommandPredictModel {
    
    public:

      JacobianCommandPredictModel(std::size_t sizeState, std::size_t sizeCommand) :
  BaseCommandPredictModel(sizeState, sizeCommand) {}
      virtual ~JacobianCommandPredictModel() {}

      virtual void predict(jblas::vec& x, jblas::vec const& u_) = 0;

    };
   

    class JacobianBlockPredictModel : public BasePredictModel {

    public:

      JacobianBlockPredictModel(std::size_t sizeState) :
  BasePredictModel(sizeState) {}

      virtual ~JacobianBlockPredictModel() {}

      virtual void predict(jblas::vec_range& x_r) = 0;

    }; // class JacobianBlockPredictModel


    class JacobianBlockCommandPredictModel : public BaseCommandPredictModel {
    
    public:

      JacobianBlockCommandPredictModel(std::size_t sizeState, std::size_t sizeCommand) :
  BaseCommandPredictModel(sizeState, sizeCommand) {}

      virtual ~JacobianBlockCommandPredictModel() {}

      virtual void predict(jblas::vec_range& x_r, jblas::vec const& u_) = 0;

    };

  } // namespace filter
} // namespace jafar

#endif // FILTER_PREDICT_MODEL_HPP