motion_model_base.h

Go to the documentation of this file.

#ifndef MOTION_MODEL_BASE_H
#define MOTION_MODEL_BASE_H
 
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
 
#include "boost/noncopyable.hpp"
#include <memory>
#include <string>
#include <vector>
 
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)
{
}
 
} // namespace dynamics
} // namespace bitrl
 
#endif // MOTION_MODEL_BASE_H