upd_lin_pred.hpp

#ifndef DDF_UPD_LIN_PRED_HPP
#define DDF_UPD_LIN_PRED_HPP

#include <BayesFilter/bayesFlt.hpp>
#include <BayesFilter/infFlt.hpp>

//#include "kernel/jafarDebug.hpp"
#include "debugging.hpp"
#include "predictenginebase.hpp"
#include "infocontainer.hpp"
#include "tools.hpp"
#include "ctime.hpp"

namespace jafar
{
  namespace ddf
  {
    typedef enum {NEED_UPD_F, NEED_UPD_G, NEED_UPD_Q, NEED_UPD_END} NEED_UPD_TYPE;

    template<typename PARAMS>
    class Upd_lin_pred_model : public Bayesian_filter::Linear_invertable_predict_model, virtual public PredictionEngineGeneric<PARAMS>
    {
      std::vector<bool>                   m_need_update;    // one can choose what has to be updated (see NEED_UPD_TYPE)
      Bayesian_filter::Information_scheme m_info_engine;    // used for calling predict()
      InfoContainer                       m_yY;             // temporary (for speeding up GetPrediction)
      SpeedUpInfoStruct                   m_sp;
      Bayesian_filter::Information_scheme::Linear_predict_byproducts m_products;
      
    protected:

      using PredictionEngineGeneric<PARAMS>::m_fs_storage;
      using PredictionEngineGeneric<PARAMS>::m_horizon;
      using PredictionEngineGeneric<PARAMS>::m_info_mutex;
      using PredictionEngineGeneric<PARAMS>::m_current_time;
      using PredictionEngineGeneric<PARAMS>::m_params;
      using PredictionEngineGeneric<PARAMS>::m_model_need_update;
      using PredictionEngineGeneric<PARAMS>::m_predict_available;
      using PredictionEngineGeneric<PARAMS>::m_store_fstate;
   
      // don't forget to initialize the inverse of F in UpdateF
      virtual void UpdateF(PARAMS & param)=0;
      virtual void UpdateG(PARAMS & param)=0;
      virtual void Updateq(PARAMS & param)=0;

   
    public:
   
      Upd_lin_pred_model(unsigned short sv_size, unsigned short q_size) :
        PredictionEngineGeneric<PARAMS>(),
        Linear_invertable_predict_model(sv_size, q_size),
        m_need_update(NEED_UPD_END),
        m_info_engine(sv_size),
        m_yY(sv_size),
        m_sp(sv_size,1,q_size),
        m_products(sv_size, q_size)
        {
        // makes valgrind happy (prob with SymMatrix assignment)
        m_products.A.clear();     m_products.B.clear();
        m_products.tempG.clear(); m_products.y.clear();
  
        m_need_update.clear(); Constructor();
      }


      virtual ~Upd_lin_pred_model() {}

      // New functions brought by Upd_lin_pred_model
      unsigned short GetSvSize() { return m_info_engine.y.size(); }
      unsigned short GetqSize()  { return q.size(); }

      void SetNeedUpdate(NEED_UPD_TYPE what, bool needUpd) { JFR_PRECOND(what < NEED_UPD_END, "invalid field"); m_need_update[what] = needUpd; }
      void SetNoUpdate() { for(short w = 0; w < NEED_UPD_END; w++) m_need_update[w] = false; }
      std::vector<bool>  const& GetNeedUpdate() const { return m_need_update; }
      bool IsUpdated(NEED_UPD_TYPE what) { JFR_PRECOND(what < NEED_UPD_END, "invalid field"); return m_need_update[what]; }

      // Overload of virtual functions of PredictionEngineBase
      bool IsPSD(bool use_mutex);
      void PrintModel();
      void Predict(time const& horizon);
      void Init(InfoContainer const& inityY);
      void InitState(VEC const& x, MSYM const& X);
      void InitInformation(VEC const& y, MSYM const& Y);
      InfoContainer const& GetPrediction();
      InfoContainer const& GetInversePrediction();
      void UpdatePredictionWith(InfoContainer const& info);
      void UpdateModel();

      void PrintHistory();
      FSStorageBase<PARAMS> const& RecallStoredState(unsigned int idx) const {
        JFR_PRECOND(idx < m_fs_storage.size(), "index");
        return m_fs_storage[idx];
      }
      
      void ClearHistory() { m_fs_storage.clear(); }
      unsigned short GetHistorySize() const { return m_fs_storage.size(); }
      bool InsertDelayedMeasure(InfoContainer const& ICont, time const& avail_time);

    private:
      void Init();
      void StoreState(FS_STORE_TYPE fs_type);
      void StoreState(MSYM const& I, VEC const& i);
      void Constructor() { m_yY.ClearAll(); m_info_engine.y.clear(); m_info_engine.Y.clear(); m_info_engine.x.clear(); m_info_engine.X.clear(); }
    };

  } // namespace ddf
} // namespace jafar

#include "upd_lin_pred.tpp"

#endif