Program Listing for File motion_model_base.h

↰ Return to documentation for file (src/bitrl/dynamics/motion_model_base.h)

#ifndef MOTION_MODEL_BASE_H
#define MOTION_MODEL_BASE_H

#include "bitrl/bitrl_types.h"
#include "bitrl/bitrl_consts.h"

#include "boost/noncopyable.hpp"
#include <memory>
#include <vector>
#include <string>

namespace bitrl{
namespace dynamics{

template<typename StateTp, typename MatrixDescriptor, typename InputTp>
class MotionModelDynamicsBase: private boost::noncopyable
{
public:

    typedef StateTp state_type;
    typedef state_type output_type;
    typedef InputTp input_type;
    typedef MatrixDescriptor matrix_descriptor_type;
    typedef typename matrix_descriptor_type::matrix_type matrix_type;
    typedef typename matrix_descriptor_type::vector_type vector_type;

    static const uint_t state_dimension = StateTp::dimension;

    virtual ~MotionModelDynamicsBase()=default;

    virtual state_type& evaluate(const input_type& input)=0;

    const state_type& get_state()const{return state_;}

    state_type& get_state(){return state_;}

    std::vector<std::string_view> get_state_variables_names()const
    {return state_.get_names();}

    matrix_type& get_matrix(const std::string& name){return matrix_description_.get_matrix(name);}
    const matrix_type& get_matrix(const std::string& name)const{return matrix_description_.get_matrix(name);}
    void set_matrix(const std::string& name, const matrix_type& mat){matrix_description_.set_matrix(name, mat);}

    vector_type& get_vector(const std::string& name){return matrix_description_.get_vector(name);}
    const vector_type& get_vector(const std::string& name)const {return matrix_description_.get_vector(name);}
    void set_vector(const std::string& name, const vector_type& vec){matrix_description_.set_vector(name, vec);}

    void set_matrix_update_flag(bool f){update_description_matrices_on_evaluate_ = f;}

    bool allows_matrix_updates()const{return update_description_matrices_on_evaluate_;}

    bool has_matrix(const std::string& name)const
    {return matrix_description_.has_matrix(name);}

    real_t get_state_property(const std::string& name)const{return state_.get(name);}

    void set_state_property(const std::string& name, real_t value)
    {state_.set(name,value);}

    void set_state_name_value(uint_t i, const std::string& name, real_t val)
    {state_.set(i, {name, val});}

    void set_state_name_value(uint_t i, const std::pair<std::string, real_t>&  val)
    {state_.set(i, val);}

    void set_time_step(real_t dt){dt_ = dt;}

    real_t get_time_step()const{return dt_;}

    real_t get_tolerance()const{return tol_;}

    void set_tolerance(real_t tol){tol_ = tol;}

protected:

    explicit MotionModelDynamicsBase(bool update_description_matrices_on_evaluate = true);


    MotionModelDynamicsBase(const state_type& init_state,
                            bool update_description_matrices_on_evaluate = true);

    state_type state_;

    matrix_descriptor_type matrix_description_;

    bool update_description_matrices_on_evaluate_;

    real_t dt_;

    real_t tol_;

};

template<typename StateTp, typename MatrixDescriptor, typename InputTp>
MotionModelDynamicsBase<StateTp,
                        MatrixDescriptor,
                        InputTp>::MotionModelDynamicsBase(bool update_description_matrices_on_evaluate)
    :
      state_(),
      matrix_description_(),
      update_description_matrices_on_evaluate_(update_description_matrices_on_evaluate),
      dt_(0.0),
      tol_(bitrl::consts::TOLERANCE)
{}

template<typename StateTp, typename MatrixDescriptor, typename InputTp>
MotionModelDynamicsBase<StateTp,
                        MatrixDescriptor,
                        InputTp>::MotionModelDynamicsBase(const typename MotionModelDynamicsBase<StateTp,
                                                                                                 MatrixDescriptor,
                                                                                                 InputTp>::state_type& init_state,
                                                          bool update_description_matrices_on_evaluate)
    :
    state_(init_state),
    matrix_description_(),
    update_description_matrices_on_evaluate_(update_description_matrices_on_evaluate),
    dt_(0.0),
    tol_(bitrl::consts::TOLERANCE)
{}


}
}

#endif // MOTION_MODEL_BASE_H