acados_solver.hpp

Go to the documentation of this file.

// Copyright 2023 ICUBE Laboratory, University of Strasbourg
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Thibault Poignonec (tpoignonec@unistra.fr)
 
#ifndef ACADOS_SOLVER_BASE__ACADOS_SOLVER_HPP_
#define ACADOS_SOLVER_BASE__ACADOS_SOLVER_HPP_
 
#include <Eigen/Dense>
 
#include <iostream>
#include <vector>
#include <exception>
 
#include "acados_solver_base/visibility_control.h"
#include "acados_solver_base/acados_types.hpp"
 
 
// Acados C interface
#include "acados_c/ocp_nlp_interface.h"
 
 
namespace acados
{
 
class AcadosSolver
{
public:
  class Dimensions
  {
public:
    // Basic dimensions
 
    unsigned int nx;
 
    unsigned int nz;
 
    unsigned int np;
 
    unsigned int nu;
 
    // Bounds on x and u
 
    unsigned int nbx;
 
    unsigned int nbx_0;
 
    unsigned int nbx_N;
 
    unsigned int nbu;
 
    // Polytope constraints
 
    unsigned int ng;
 
    unsigned int ng_N;
 
    // Non-linear constraints
 
    unsigned int nh;
 
    unsigned int nh_N;
 
    unsigned int nphi;
 
    unsigned int nphi_N;
 
    // Slack-related dimensions
 
    unsigned int ns;
 
    unsigned int ns_N;
 
    unsigned int nsbx;
 
    unsigned int nsbx_N;
 
    unsigned int nsbu;
 
    unsigned int nsh;
 
    unsigned int nsh_N;
 
    unsigned int nsg;
 
    unsigned int nsg_N;
 
 
    unsigned int nsphi;
 
    unsigned int nsphi_N;
 
    // Cost ref.
    unsigned int ny;
 
    unsigned int ny_0;
 
    unsigned int ny_N;
 
    // Misc.
 
    unsigned int nr;
  };
 
public:
// Acados solver public API
 
  AcadosSolver();
 
  virtual ~AcadosSolver();
 
// Solver management
 
  int init(unsigned int N, double Ts);
 
  int reset();
 
// Solve and introspection
 
  int solve();
 
// Setters
 
  int set_initial_state_values(ValueVector & x_0);
 
  int set_initial_state_values(ValueMap const & x_0_map);
 
  int set_state_bounds(
    unsigned int stage,
    IndexVector & idxbx,
    ValueVector & lbx,
    ValueVector & ubx);
 
  int set_state_bounds(
    IndexVector & idxbx,
    ValueVector & lbx,
    ValueVector & ubx);
 
  int set_control_bounds(
    unsigned int stage,
    IndexVector & idxbu,
    ValueVector & lbu,
    ValueVector & ubu);
  int set_control_bounds(
    IndexVector & idxbu,
    ValueVector & lbu,
    ValueVector & ubu);
 
// Runtime parameters
 
  int set_runtime_parameters(unsigned int stage, ValueVector & p_i);
 
  int set_runtime_parameters(unsigned int stage, ValueMap const & p_i_map);
 
 
  int set_runtime_parameters(ValueVector & p_i);
 
  int set_runtime_parameters(ValueMap const & p_i_map);
 
// Initialization state
 
  int initialize_state_values(unsigned int stage, ValueVector & x_i);
 
  int initialize_state_values(unsigned int stage, ValueMap const & x_i_map);
 
  int initialize_state_values(ValueVector & x_i);
 
  int initialize_state_values(ValueMap const & x_i_map);
 
// Initialization controls
 
  int initialize_control_values(unsigned int stage, ValueVector & u_i);
 
  int initialize_control_values(unsigned int stage, ValueMap const & u_i_map);
 
  int initialize_control_values(ValueVector & u_i);
 
  int initialize_control_values(ValueMap const & u_i_map);
 
// Getters
  ValueVector get_state_values(unsigned int stage);
 
  ValueMap get_state_values_as_map(unsigned int stage);
 
  ValueVector get_algebraic_state_values(unsigned int stage);
 
 
  ValueMap get_algebraic_state_values_as_map(unsigned int stage);
 
  ValueVector get_control_values(unsigned int stage);
 
  ValueMap get_control_values_as_map(unsigned int stage);
 
// Getters variable mappings
 
  const IndexMap & x_index_map() const;
 
  const IndexMap & z_index_map() const;
 
  const IndexMap & p_index_map() const;
 
  const IndexMap & u_index_map() const;
 
// Values map utils
 
  static bool is_map_size_consistent(
    IndexMap const & index_map,
    unsigned int expected_total_indexes);
 
  static bool is_map_size_consistent(
    ValueMap const & values_map,
    unsigned int expected_total_indexes);
 
  static bool is_values_map_complete(IndexMap const & index_map, ValueMap const & values_map);
 
  static void fill_vector_from_map(
    IndexMap const & index_map,
    ValueMap const & values_map,
    unsigned int vector_size,
    ValueVector & values);
 
  static ValueVector value_vector_from_map(
    IndexMap const & index_map,
    ValueMap const & values_map,
    unsigned int vector_size);
 
  static ValueMap create_map_from_values(
    IndexMap const & index_map,
    ValueVector const & values);
 
// Problem dimensions and convenience getters for commonly used attributes
 
  const Dimensions & dims() const;
 
  unsigned int  nx() const;
 
  unsigned int  nz() const;
 
  unsigned int  np() const;
 
  unsigned int  nu() const;
 
  unsigned int  N() const;
 
  double Ts() const;
 
 
  std::vector<double> sampling_intervals() const;
 
protected:
  Dimensions _dims;
 
  IndexMap _x_index_map;
 
  IndexMap _z_index_map;
 
  IndexMap _p_index_map;
 
  IndexMap _u_index_map;
 
// Solver-specific functions
 
  virtual int create_index_maps() = 0;
 
protected:
  int free_memory();
 
// Imported Acados solver C-code interface ("internal" --> internal use only!)
 
  virtual int internal_create_capsule() = 0;
 
  virtual int internal_create_with_discretization(int n_time_steps, double * new_time_steps) = 0;
 
  virtual int internal_reset(int reset_qp_solver_mem = 1) = 0;
 
  virtual int internal_free() = 0;
 
  virtual int internal_free_capsule() = 0;
 
  virtual int internal_update_qp_solver_cond_N(int qp_solver_cond_N) = 0;
 
  virtual int internal_update_params(unsigned int stage, double * value, int np) = 0;
 
  virtual int internal_update_params_sparse(
    unsigned int stage,
    int * idx,
    double * p,
    int n_update) = 0;
 
  virtual int internal_solve() = 0;
 
  virtual void internal_print_stats() const = 0;
 
public:
  virtual ocp_nlp_in * get_nlp_in() const = 0;
 
  virtual ocp_nlp_out * get_nlp_out() const = 0;
 
  virtual ocp_nlp_out * get_sens_out() const = 0;
 
  virtual ocp_nlp_solver * get_nlp_solver() const = 0;
 
  virtual ocp_nlp_config * get_nlp_config() const = 0;
 
  virtual void * get_nlp_opts() const = 0;
 
  virtual ocp_nlp_dims * get_nlp_dims() const = 0;
 
  virtual ocp_nlp_plan_t * get_nlp_plan() const = 0;
 
  virtual unsigned int get_nlp_np() const = 0;
 
// Imported Acados SIM solver C-code interface (for internal use only!)
 
protected:
  // TODO(tpoignonec) : add sim solver private c-interface
 
public:
  // TODO(tpoignonec) : add sim solver public c-interface
 
  // Private own attributes
 
private:
  bool _is_initialized = false;
 
  double _Ts = -1;
// Runtime data
 
  int _rti_phase = 0;
};
 
}  // namespace acados
 
#endif  // ACADOS_SOLVER_BASE__ACADOS_SOLVER_HPP_