ocp.hpp

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <stdint.h>
 
#include <chrono>
#include <utility>
 
#include "sleipnir/autodiff/variable_matrix.hpp"
#include "sleipnir/optimization/ocp/dynamics_type.hpp"
#include "sleipnir/optimization/ocp/timestep_method.hpp"
#include "sleipnir/optimization/ocp/transcription_method.hpp"
#include "sleipnir/optimization/problem.hpp"
#include "sleipnir/util/assert.hpp"
#include "sleipnir/util/concepts.hpp"
#include "sleipnir/util/function_ref.hpp"
#include "sleipnir/util/symbol_exports.hpp"
 
namespace slp {
 
template <typename Scalar>
class OCP : public Problem<Scalar> {
 public:
  OCP(int num_states, int num_inputs, std::chrono::duration<Scalar> dt,
      int num_steps,
      function_ref<VariableMatrix<Scalar>(const VariableMatrix<Scalar>& x,
                                          const VariableMatrix<Scalar>& u)>
          dynamics,
      DynamicsType dynamics_type = DynamicsType::EXPLICIT_ODE,
      TimestepMethod timestep_method = TimestepMethod::FIXED,
      TranscriptionMethod transcription_method =
          TranscriptionMethod::DIRECT_TRANSCRIPTION)
      : OCP{num_states,
            num_inputs,
            dt,
            num_steps,
            [=]([[maybe_unused]] const VariableMatrix<Scalar>& t,
                const VariableMatrix<Scalar>& x,
                const VariableMatrix<Scalar>& u,
                [[maybe_unused]] const VariableMatrix<Scalar>& dt)
                -> VariableMatrix<Scalar> { return dynamics(x, u); },
            dynamics_type,
            timestep_method,
            transcription_method} {}
 
  OCP(int num_states, int num_inputs, std::chrono::duration<Scalar> dt,
      int num_steps,
      function_ref<VariableMatrix<Scalar>(
          const Variable<Scalar>& t, const VariableMatrix<Scalar>& x,
          const VariableMatrix<Scalar>& u, const Variable<Scalar>& dt)>
          dynamics,
      DynamicsType dynamics_type = DynamicsType::EXPLICIT_ODE,
      TimestepMethod timestep_method = TimestepMethod::FIXED,
      TranscriptionMethod transcription_method =
          TranscriptionMethod::DIRECT_TRANSCRIPTION)
      : m_num_steps{num_steps},
        m_dynamics{std::move(dynamics)},
        m_dynamics_type{dynamics_type} {
    // u is num_steps + 1 so that the final constraint function evaluation works
    m_U = this->decision_variable(num_inputs, m_num_steps + 1);
 
    if (timestep_method == TimestepMethod::FIXED) {
      m_DT = VariableMatrix<Scalar>{1, m_num_steps + 1};
      for (int i = 0; i < num_steps + 1; ++i) {
        m_DT[0, i] = dt.count();
      }
    } else if (timestep_method == TimestepMethod::VARIABLE_SINGLE) {
      Variable single_dt = this->decision_variable();
      single_dt.set_value(dt.count());
 
      // Set the member variable matrix to track the decision variable
      m_DT = VariableMatrix<Scalar>{1, m_num_steps + 1};
      for (int i = 0; i < num_steps + 1; ++i) {
        m_DT[0, i] = single_dt;
      }
    } else if (timestep_method == TimestepMethod::VARIABLE) {
      m_DT = this->decision_variable(1, m_num_steps + 1);
      for (int i = 0; i < num_steps + 1; ++i) {
        m_DT[0, i].set_value(dt.count());
      }
    }
 
    if (transcription_method == TranscriptionMethod::DIRECT_TRANSCRIPTION) {
      m_X = this->decision_variable(num_states, m_num_steps + 1);
      constrain_direct_transcription();
    } else if (transcription_method ==
               TranscriptionMethod::DIRECT_COLLOCATION) {
      m_X = this->decision_variable(num_states, m_num_steps + 1);
      constrain_direct_collocation();
    } else if (transcription_method == TranscriptionMethod::SINGLE_SHOOTING) {
      // In single-shooting the states aren't decision variables, but instead
      // depend on the input and previous states
      m_X = VariableMatrix<Scalar>{num_states, m_num_steps + 1};
      constrain_single_shooting();
    }
  }
 
  template <typename T>
    requires ScalarLike<T> || MatrixLike<T>
  void constrain_initial_state(const T& initial_state) {
    this->subject_to(this->initial_state() == initial_state);
  }
 
  template <typename T>
    requires ScalarLike<T> || MatrixLike<T>
  void constrain_final_state(const T& final_state) {
    this->subject_to(this->final_state() == final_state);
  }
 
  void for_each_step(const function_ref<void(const VariableMatrix<Scalar>& x,
                                             const VariableMatrix<Scalar>& u)>
                         callback) {
    for (int i = 0; i < m_num_steps + 1; ++i) {
      auto x = X().col(i);
      auto u = U().col(i);
      callback(x, u);
    }
  }
 
  void for_each_step(
      const function_ref<
          void(const Variable<Scalar>& t, const VariableMatrix<Scalar>& x,
               const VariableMatrix<Scalar>& u, const Variable<Scalar>& dt)>
          callback) {
    Variable<Scalar> time{0};
 
    for (int i = 0; i < m_num_steps + 1; ++i) {
      auto x = X().col(i);
      auto u = U().col(i);
      auto dt = this->dt()[0, i];
      callback(time, x, u, dt);
 
      time += dt;
    }
  }
 
  template <typename T>
    requires ScalarLike<T> || MatrixLike<T>
  void set_lower_input_bound(const T& lower_bound) {
    for (int i = 0; i < m_num_steps + 1; ++i) {
      this->subject_to(U().col(i) >= lower_bound);
    }
  }
 
  template <typename T>
    requires ScalarLike<T> || MatrixLike<T>
  void set_upper_input_bound(const T& upper_bound) {
    for (int i = 0; i < m_num_steps + 1; ++i) {
      this->subject_to(U().col(i) <= upper_bound);
    }
  }
 
  void set_min_timestep(std::chrono::duration<Scalar> min_timestep) {
    this->subject_to(dt() >= min_timestep.count());
  }
 
  void set_max_timestep(std::chrono::duration<Scalar> max_timestep) {
    this->subject_to(dt() <= max_timestep.count());
  }
 
  VariableMatrix<Scalar>& X() { return m_X; }
 
  VariableMatrix<Scalar>& U() { return m_U; }
 
  VariableMatrix<Scalar>& dt() { return m_DT; }
 
  VariableMatrix<Scalar> initial_state() { return m_X.col(0); }
 
  VariableMatrix<Scalar> final_state() { return m_X.col(m_num_steps); }
 
 private:
  int m_num_steps;
 
  function_ref<VariableMatrix<Scalar>(
      const Variable<Scalar>& t, const VariableMatrix<Scalar>& x,
      const VariableMatrix<Scalar>& u, const Variable<Scalar>& dt)>
      m_dynamics;
  DynamicsType m_dynamics_type;
 
  VariableMatrix<Scalar> m_X;
  VariableMatrix<Scalar> m_U;
  VariableMatrix<Scalar> m_DT;
 
  template <typename F, typename State, typename Input, typename Time>
  State rk4(F&& f, State x, Input u, Time t0, Time dt) {
    auto halfdt = dt * Scalar(0.5);
    State k1 = f(t0, x, u, dt);
    State k2 = f(t0 + halfdt, x + k1 * halfdt, u, dt);
    State k3 = f(t0 + halfdt, x + k2 * halfdt, u, dt);
    State k4 = f(t0 + dt, x + k3 * dt, u, dt);
 
    return x + (k1 + k2 * Scalar(2) + k3 * Scalar(2) + k4) * (dt / Scalar(6));
  }
 
  void constrain_direct_collocation() {
    slp_assert(m_dynamics_type == DynamicsType::EXPLICIT_ODE);
 
    Variable<Scalar> time{0};
 
    // Derivation at https://mec560sbu.github.io/2016/09/30/direct_collocation/
    for (int i = 0; i < m_num_steps; ++i) {
      Variable h = dt()[0, i];
 
      auto& f = m_dynamics;
 
      auto t_begin = time;
      auto t_end = t_begin + h;
 
      auto x_begin = X().col(i);
      auto x_end = X().col(i + 1);
 
      auto u_begin = U().col(i);
      auto u_end = U().col(i + 1);
 
      auto xdot_begin = f(t_begin, x_begin, u_begin, h);
      auto xdot_end = f(t_end, x_end, u_end, h);
      auto xdot_c = Scalar(-3) / (Scalar(2) * h) * (x_begin - x_end) -
                    Scalar(0.25) * (xdot_begin + xdot_end);
 
      auto t_c = t_begin + Scalar(0.5) * h;
      auto x_c = Scalar(0.5) * (x_begin + x_end) +
                 h / Scalar(8) * (xdot_begin - xdot_end);
      auto u_c = Scalar(0.5) * (u_begin + u_end);
 
      this->subject_to(xdot_c == f(t_c, x_c, u_c, h));
 
      time += h;
    }
  }
 
  void constrain_direct_transcription() {
    Variable<Scalar> time{0};
 
    for (int i = 0; i < m_num_steps; ++i) {
      auto x_begin = X().col(i);
      auto x_end = X().col(i + 1);
      auto u = U().col(i);
      Variable dt = this->dt()[0, i];
 
      if (m_dynamics_type == DynamicsType::EXPLICIT_ODE) {
        this->subject_to(
            x_end == rk4<const decltype(m_dynamics)&, VariableMatrix<Scalar>,
                         VariableMatrix<Scalar>, Variable<Scalar>>(
                         m_dynamics, x_begin, u, time, dt));
      } else if (m_dynamics_type == DynamicsType::DISCRETE) {
        this->subject_to(x_end == m_dynamics(time, x_begin, u, dt));
      }
 
      time += dt;
    }
  }
 
  void constrain_single_shooting() {
    Variable<Scalar> time{0};
 
    for (int i = 0; i < m_num_steps; ++i) {
      auto x_begin = X().col(i);
      auto x_end = X().col(i + 1);
      auto u = U().col(i);
      Variable dt = this->dt()[0, i];
 
      if (m_dynamics_type == DynamicsType::EXPLICIT_ODE) {
        x_end = rk4<const decltype(m_dynamics)&, VariableMatrix<Scalar>,
                    VariableMatrix<Scalar>, Variable<Scalar>>(
            m_dynamics, x_begin, u, time, dt);
      } else if (m_dynamics_type == DynamicsType::DISCRETE) {
        x_end = m_dynamics(time, x_begin, u, dt);
      }
 
      time += dt;
    }
  }
};
 
extern template class EXPORT_TEMPLATE_DECLARE(SLEIPNIR_DLLEXPORT) OCP<double>;
 
}  // namespace slp