Solver.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <eigen3/Eigen/Dense>
#include "System.hpp"
 
namespace mimpc {
    enum SOLVER_RETURN {
        OPTIMAL = 1,
        NO_SOLUTION = 0,
        TIME_LIMIT_WITH_SOLUTION = 2,
        USER_INTERRUPT = -10
    };
 
    enum COST_TYPE {
        L1Linear = 0,
        L2Quadratic = 1
    };
 
    enum INTEGRATION_SCHEME {
        FORWARD_EULER = 0,
        BACKWARD_EULER = 1
    };
 
    template<class SystemType, int N, int min_steps_on, int min_steps_off, int max_steps_on, int num_steps_solver_delay, INTEGRATION_SCHEME integration_scheme> requires
    std::derived_from<SystemType, System<SystemType::NUM_STATES, SystemType::NUM_CONT_INPUTS, SystemType::NUM_BIN_INPUTS>>
    class Solver {
    public:
        using SYSTEM_TYPE = SystemType;
        static constexpr auto PRED_STEPS = N;
        static constexpr auto MIN_STEPS_ON = min_steps_on;
        static constexpr auto MIN_STEPS_OFF = min_steps_off;
        static constexpr auto MAX_STEPS_ON = max_steps_on;
        static constexpr auto NUM_STEPS_SOLVER_DELAY = num_steps_solver_delay;
        static constexpr auto INTEGRATION_SCHEME = integration_scheme;
 
        static constexpr int history_depth = std::max(
                {0, max_steps_on - num_steps_solver_delay, min_steps_off - num_steps_solver_delay,
                 min_steps_on - num_steps_solver_delay}); //retunrs 0 or biggest of thoose
        virtual ~Solver() = default;
 
        virtual void addInputConstraintOnIndex(int index, double lb, double ub) = 0;
 
        virtual void addStateConstraintOnIndex(int index, double lb, double ub) = 0;
 
        virtual void
        addInputConstraintOnStep(int step, const SystemType::InputVec &lb, const SystemType::InputVec &ub) = 0;
 
        virtual void
        addStateConstraintOnStep(int step, const SystemType::StateVec &lb, const SystemType::StateVec &ub) = 0;
 
        virtual void setFinalWeights(const SystemType::StateVec &final_weights) = 0;
 
        virtual void setStateWeights(const SystemType::StateVec &state_weights) = 0;
 
        virtual void setInputWeights(const SystemType::InputVec &state_weights) = 0;
 
        virtual void setCost(COST_TYPE cost_type) = 0;
 
        virtual void setSetPoint(const SystemType::StateVec &set_point) = 0;
 
        virtual void setState(const SystemType::StateVec &state) = 0;
 
        virtual void setInputHistory(
                const Eigen::Matrix<double, SystemType::NUM_INPUTS, history_depth> &bin_input_hist) = 0;
 
        virtual void
        setNextInputs(const Eigen::Matrix<double, SystemType::NUM_INPUTS, num_steps_solver_delay> &next_inputs) = 0;
 
        virtual void setSolverTimeLimit(double max_seconds) = 0;
 
        virtual unsigned int getStepsToCompensateControllerDelay() = 0;
 
        virtual SOLVER_RETURN
        solve(const Eigen::Matrix<double, SystemType::NUM_INPUTS, N, Eigen::RowMajor> &last_open_loop_input,
              const Eigen::Matrix<double, SystemType::NUM_STATES, N + 1, Eigen::RowMajor> &last_open_loop_state,
              Eigen::Matrix<double, SystemType::NUM_INPUTS, N, Eigen::RowMajor> &open_loop_input,
              Eigen::Matrix<double, SystemType::NUM_STATES, N + 1, Eigen::RowMajor> &open_loop_state) const = 0;
    };
};