OptiSol.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "janus/core/JanusTypes.hpp"
#include "janus/utils/JsonUtils.hpp"
#include <casadi/casadi.hpp>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace janus {

class OptiSol {
  public:
    explicit OptiSol(casadi::OptiSol cas_sol) : cas_sol_(std::move(cas_sol)) {}

    double value(const SymbolicScalar &var) const {
        casadi::DM result = cas_sol_.value(var);
        return static_cast<double>(result);
    }

    NumericVector value(const SymbolicVector &var) const {
        // Convert SymbolicVector (Eigen<MX>) to MX for CasADi
        casadi::MX mx_var = janus::to_mx(var);
        casadi::DM result = cas_sol_.value(mx_var);
 
        // Convert DM to NumericVector
        std::vector<double> elements = static_cast<std::vector<double>>(result);
        NumericVector vec(elements.size());
        for (size_t i = 0; i < elements.size(); ++i) {
            vec(static_cast<Eigen::Index>(i)) = elements[i];
        }
        return vec;
    }

    NumericMatrix value(const SymbolicMatrix &var) const {
        casadi::MX mx_var = janus::to_mx(var);
        casadi::DM result = cas_sol_.value(mx_var);
 
        std::vector<double> elements = static_cast<std::vector<double>>(result);
        NumericMatrix mat(result.size1(), result.size2());
 
        // CasADi uses column-major (Fortran) order
        for (casadi_int j = 0; j < result.size2(); ++j) {
            for (casadi_int i = 0; i < result.size1(); ++i) {
                mat(i, j) = elements[j * result.size1() + i];
            }
        }
        return mat;
    }

    casadi::Dict stats() const { return cas_sol_.stats(); }

    std::optional<int> num_function_evals() const {
        auto s = stats();
        if (s.count("n_call_nlp_f")) {
            return static_cast<int>(s.at("n_call_nlp_f"));
        }
        return std::nullopt;
    }

    std::optional<int> num_iterations() const {
        auto s = stats();
        if (s.count("iter_count")) {
            return static_cast<int>(s.at("iter_count"));
        }
        return std::nullopt;
    }

    const casadi::OptiSol &casadi_sol() const { return cas_sol_; }

    void save(const std::string &filename,
              const std::map<std::string, SymbolicScalar> &named_vars) const {
        std::map<std::string, std::vector<double>> data;
 
        for (const auto &[name, var] : named_vars) {
            // Evaluate variable using helper
            double val = value(var);
            data[name] = {val};
        }
 
        janus::utils::write_json(filename, data);
    }

    void save(const std::string &filename,
              const std::map<std::string, SymbolicVector> &named_vars) const {
        std::map<std::string, std::vector<double>> data;
 
        for (const auto &[name, var] : named_vars) {
            // Evaluate variable using helper
            NumericVector result = value(var);
 
            // Convert Eigen Vector to std::vector
            std::vector<double> elements(result.data(), result.data() + result.size());
            data[name] = elements;
        }
 
        janus::utils::write_json(filename, data);
    }

    static std::map<std::string, std::vector<double>> load(const std::string &filename) {
        return janus::utils::read_json(filename);
    }
 
  private:
    casadi::OptiSol cas_sol_;
};
 
} // namespace janus