OCP result diagnostics

alphaville · alphaville · commit cf4991bd827a · 2026-03-18T21:51:17.000Z
- more unit tests (TCP + direct iface)
- opengen v0.10.0a2
- remove unnecessary log msg from low-level builder
- OcpSolution: number formatting
- website docs
diff --git a/docs/python-ocp.md b/docs/python-ocp.md
@@ -6,6 +6,30 @@ description: Optimal Control with OpEn/opengen
 
 <script type="text/x-mathjax-config">MathJax.Hub.Config({tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}});</script>
 <script type="text/javascript" async src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
+<style>
+.but{
+  border: none;
+  color: #348c4f;
+  padding: 15px 20px;
+  text-align: center;
+  text-decoration: none;
+  display: inline-block;
+  font-size: 16px;
+  margin: 0px 0px;
+  cursor: pointer;
+  width: 250px;
+  border-radius: 8px;
+}
+</style>
+<style>
+.but1 {
+    background-color: #e9e642;
+}
+</style><style>
+.but2 {
+    background-color: #008CBA;
+}
+</style>
 
 <div class="alert alert-warning">
 <b>Info:</b> The functionality presented here was introduced in <code>opengen</code> version <code>0.10.0a1</code>.
@@ -17,6 +41,8 @@ of optimal control problems. In an intuitive and straightforward way,
 the user defines the problem ingredients (stage/terminal costs, 
 state/input constraints, dynamics). 
 
+<a href="https://colab.research.google.com/drive/17vbVUbqcah9seIg17aN6bW0-T15FWrBo?usp=sharing" target="_blank"><button class="but but1" ><b>Try this on Google Colab</b></button></a>
+
 ## In a nutshell: quick overview
 
 Suppose you want to solve the optimal control problem 
@@ -25,9 +51,9 @@ Suppose you want to solve the optimal control problem
     \begin{align}
     \mathbb{P}_N(p){}:{}\operatorname*{Minimize}_{u_0, \ldots, u_{N-1}}& 
     \sum_{t=1}^{N - 1} 
-        \underbrace{\|x_t-x^{\mathrm{ref}}\|^2 + r \|u_t\|^2}_{\text{stage cost}} 
+        \underbrace{q\|x_t-x^{\mathrm{ref}}\|^2 + r \|u_t\|^2}_{\text{stage cost}} 
         + 
-        \underbrace{\|x_N-x^{\mathrm{ref}}\|^2}_{\text{terminal cost}}
+        \underbrace{10\|x_N-x^{\mathrm{ref}}\|^2}_{\text{terminal cost}}
     \\
     \text{subject to: }& x_{t+1} = F(x_t, u_t), t=0,\ldots, N-1
     \\
@@ -38,6 +64,37 @@ Suppose you want to solve the optimal control problem
     &x_0=x
     \end{align}
 \]</div>
+Suppose the state is two-dimensional and the input is one-dimensional.
+The dynamics is 
+<div class="math">
+\[
+    \begin{align}
+    F(x, u; a) = 
+        \begin{bmatrix}
+        ax_1 + 0.2x_1^2 - 1.2 x_2 + u \\
+        \sin(x_2) + 0.2 x_1^3 - u
+        \end{bmatrix},
+    \end{align}
+\]</div>
+where $a$ is a constant parameter. Suppose the stage cost
+function is
+<div class="math">
+\[
+    \begin{align}
+    \ell(x, u; x^{\rm ref}, q, r)
+    {}={}
+    q\| x - x^{\rm ref}\|^2 + r \|u\|^2,
+    \end{align}
+\]</div>
+where $x^{\rm ref}$, $q$, and $r$ are parameters. The terminal 
+cost function is 
+<div class="math">
+\[
+    \begin{align}
+    V_f(x; x^{\mathrm{ref}}) = 10\|x_N-x^{\mathrm{ref}}\|^2.
+    \end{align}
+\]</div>
+Lastly, we 
 This can be done as follows:
 
 ```python
diff --git a/open-codegen/VERSION b/open-codegen/VERSION
@@ -1 +1 @@
-0.10.0a1
+0.10.0a2
diff --git a/open-codegen/opengen/builder/optimizer_builder.py b/open-codegen/opengen/builder/optimizer_builder.py
@@ -659,7 +659,6 @@ def __check_user_provided_parameters(self):
                                               "For now we only support orthans (e.g., F1(u, p) <= 0).")
 
     def __generate_code_python_bindings(self):
-        self.__logger.info("Generating code for Python bindings")
         target_dir = self.__target_dir()
         python_bindings_dir_name = _PYTHON_BINDINGS_PREFIX + self.__meta.optimizer_name
         python_bindings_dir = os.path.join(
diff --git a/open-codegen/opengen/ocp/solution.py b/open-codegen/opengen/ocp/solution.py
@@ -1,5 +1,7 @@
 """High-level solution objects returned by OCP-generated optimizers."""
 
+from numbers import Real
+
 class OcpSolution:
     """High-level solution returned by :meth:`GeneratedOptimizer.solve`.
 
@@ -21,19 +23,46 @@ def __init__(self, raw, inputs, states):
         self.cost = getattr(raw, "cost", None)
         self.exit_status = getattr(raw, "exit_status", None)
         self.solve_time_ms = getattr(raw, "solve_time_ms", None)
+        self.penalty = getattr(raw, "penalty", None)
+        self.num_outer_iterations = getattr(raw, "num_outer_iterations", None)
+        self.num_inner_iterations = getattr(raw, "num_inner_iterations", None)
+        self.last_problem_norm_fpr = getattr(raw, "last_problem_norm_fpr", None)
+        self.f1_infeasibility = getattr(raw, "f1_infeasibility", None)
+        self.f2_norm = getattr(raw, "f2_norm", None)
         self.lagrange_multipliers = getattr(raw, "lagrange_multipliers", None)
 
     def __repr__(self):
         """Return a readable multi-line summary of the solution."""
+        def fmt(value):
+            if isinstance(value, bool):
+                return str(value)
+            if isinstance(value, Real):
+                numeric = float(value)
+                if numeric == 0.0:
+                    return "0.0"
+                text = f"{numeric:.4g}"
+                return "0.0" if text == "-0" else text
+            if isinstance(value, list):
+                return "[" + ", ".join(fmt(item) for item in value) + "]"
+            if isinstance(value, tuple):
+                return "(" + ", ".join(fmt(item) for item in value) + ")"
+            return str(value)
+
         return "\n".join([
             "OCP Solution:",
             f"  Exit status.......... {self.exit_status}",
-            f"  Cost................. {self.cost}",
-            f"  Solve time [ms]...... {self.solve_time_ms}",
-            f"  Decision variables... {self.solution}",
-            f"  Inputs............... {self.inputs}",
-            f"  States............... {self.states}",
-            f"  Lagrange multipliers. {self.lagrange_multipliers}",
+            f"  Cost................. {fmt(self.cost)}",
+            f"  Solve time [ms]...... {fmt(self.solve_time_ms)}",
+            f"  Penalty.............. {fmt(self.penalty)}",
+            f"  Outer iterations..... {fmt(self.num_outer_iterations)}",
+            f"  Inner iterations..... {fmt(self.num_inner_iterations)}",
+            f"  FPR.................. {fmt(self.last_problem_norm_fpr)}",
+            f"  ALM infeasibility.... {fmt(self.f1_infeasibility)}",
+            f"  PM infeasibility..... {fmt(self.f2_norm)}",
+            f"  Decision variables... {fmt(self.solution)}",
+            f"  Inputs............... {fmt(self.inputs)}",
+            f"  States............... {fmt(self.states)}",
+            f"  Lagrange multipliers. {fmt(self.lagrange_multipliers)}",
         ])
 
     __str__ = __repr__
diff --git a/open-codegen/test/test_ocp.py b/open-codegen/test/test_ocp.py
@@ -12,6 +12,12 @@ def __init__(self, solution):
         self.cost = 1.23
         self.exit_status = "Converged"
         self.solve_time_ms = 0.7
+        self.penalty = 12.5
+        self.num_outer_iterations = 3
+        self.num_inner_iterations = 27
+        self.last_problem_norm_fpr = 1e-6
+        self.f1_infeasibility = 2e-5
+        self.f2_norm = 3e-5
         self.lagrange_multipliers = []
 
 
@@ -71,7 +77,6 @@ def setUpOCP1(cls):
                 .with_max_inner_iterations(500)
                 .with_max_outer_iterations(10),
         ).build()
-        cls.ocp1_optimizer.save()
         cls.ocp1_manifest_path = os.path.join(cls.ocp1_optimizer.target_dir, "optimizer_manifest.json")
         cls.ocp1_rollout_path = os.path.join(cls.ocp1_optimizer.target_dir, "rollout.casadi")
 
@@ -132,8 +137,6 @@ def make_problem(shooting):
             solver_configuration=solver_config,
         ).build()
 
-        cls.ocp2_single_optimizer.save()
-        cls.ocp2_multiple_optimizer.save()
         cls.ocp2_single_manifest_path = os.path.join(
             cls.ocp2_single_optimizer.target_dir, "optimizer_manifest.json")
         cls.ocp2_multiple_manifest_path = os.path.join(
@@ -325,10 +328,46 @@ def test_multistep_rk4_codegen(self):
             initial_guess=[0.0] * 5,
         )
 
+        # Check the result has all necessary attributes
+        self.assertTrue(hasattr(result, "raw"))
+        self.assertTrue(hasattr(result, "solution"))
+        self.assertTrue(hasattr(result, "inputs"))
+        self.assertTrue(hasattr(result, "states"))
+        self.assertTrue(hasattr(result, "cost"))
+        self.assertTrue(hasattr(result, "exit_status"))
+        self.assertTrue(hasattr(result, "solve_time_ms"))
+        self.assertTrue(hasattr(result, "penalty"))
+        self.assertTrue(hasattr(result, "num_outer_iterations"))
+        self.assertTrue(hasattr(result, "num_inner_iterations"))
+        self.assertTrue(hasattr(result, "last_problem_norm_fpr"))
+        self.assertTrue(hasattr(result, "f1_infeasibility"))
+        self.assertTrue(hasattr(result, "f2_norm"))
+        self.assertTrue(hasattr(result, "lagrange_multipliers"))
+
+        # Check all attributes of `result`
         self.assertEqual("Converged", result.exit_status)
+        self.assertIsInstance(result.solution, list)
+        self.assertIsInstance(result.inputs, list)
+        self.assertIsInstance(result.states, list)
         self.assertEqual(5, len(result.solution))
         self.assertEqual(5, len(result.inputs))
         self.assertEqual(6, len(result.states))
+        self.assertIsInstance(result.cost, float)
+        self.assertGreaterEqual(result.cost, 0.0)
+        self.assertIsInstance(result.solve_time_ms, float)
+        self.assertGreater(result.solve_time_ms, 0.0)
+        self.assertIsInstance(result.penalty, float)
+        self.assertIsInstance(result.num_outer_iterations, int)
+        self.assertGreaterEqual(result.num_outer_iterations, 1)
+        self.assertIsInstance(result.num_inner_iterations, int)
+        self.assertGreaterEqual(result.num_inner_iterations, 1)
+        self.assertIsInstance(result.last_problem_norm_fpr, float)
+        self.assertGreaterEqual(result.last_problem_norm_fpr, 0.0)
+        self.assertIsInstance(result.f1_infeasibility, float)
+        self.assertGreaterEqual(result.f1_infeasibility, 0.0)
+        self.assertIsInstance(result.f2_norm, float)
+        self.assertGreaterEqual(result.f2_norm, 0.0)
+        self.assertIsInstance(result.lagrange_multipliers, list)
         self.assertAlmostEqual(result.states[0][0], 1.0)
         self.assertAlmostEqual(result.states[0][1], 0.0)
 
@@ -421,6 +460,12 @@ def test_generated_optimizer_defaults(self):
         self.assertEqual(result.states[0], [0.0, 0.0])
         self.assertAlmostEqual(result.states[-1][0], 0.6)
         self.assertAlmostEqual(result.states[-1][1], -0.6)
+        self.assertEqual(result.penalty, 12.5)
+        self.assertEqual(result.num_outer_iterations, 3)
+        self.assertEqual(result.num_inner_iterations, 27)
+        self.assertEqual(result.last_problem_norm_fpr, 1e-6)
+        self.assertEqual(result.f1_infeasibility, 2e-5)
+        self.assertEqual(result.f2_norm, 3e-5)
 
     def test_optimizer_manifest_roundtrip(self):
         manifest_path = self.ocp1_manifest_path
@@ -521,6 +566,58 @@ def test_multiple_shooting_state_extraction(self):
         self.assertEqual(result.inputs, [[0.1], [0.2], [0.4]])
         self.assertEqual(result.states, [[0.0, 0.0], [0.1, -0.1], [0.3, -0.3], [0.7, -0.7]])
 
+    def test_tcp_optimizer_result(self):
+        optimizer = og.ocp.GeneratedOptimizer.load(self.ocp2_single_manifest_path)
+
+        try:
+            result = optimizer.solve(
+                x0=[1.0, -1.0],
+                xref=[0.0, 0.0],
+            )
+
+            self.assertTrue(hasattr(result, "raw"))
+            self.assertTrue(hasattr(result, "solution"))
+            self.assertTrue(hasattr(result, "inputs"))
+            self.assertTrue(hasattr(result, "states"))
+            self.assertTrue(hasattr(result, "cost"))
+            self.assertTrue(hasattr(result, "exit_status"))
+            self.assertTrue(hasattr(result, "solve_time_ms"))
+            self.assertTrue(hasattr(result, "penalty"))
+            self.assertTrue(hasattr(result, "num_outer_iterations"))
+            self.assertTrue(hasattr(result, "num_inner_iterations"))
+            self.assertTrue(hasattr(result, "last_problem_norm_fpr"))
+            self.assertTrue(hasattr(result, "f1_infeasibility"))
+            self.assertTrue(hasattr(result, "f2_norm"))
+            self.assertTrue(hasattr(result, "lagrange_multipliers"))
+
+            self.assertEqual("Converged", result.exit_status)
+            self.assertIsInstance(result.solution, list)
+            self.assertIsInstance(result.inputs, list)
+            self.assertIsInstance(result.states, list)
+            self.assertEqual(5, len(result.inputs))
+            self.assertEqual(6, len(result.states))
+            self.assertIsInstance(result.cost, float)
+            self.assertGreaterEqual(result.cost, 0.0)
+            self.assertIsInstance(result.solve_time_ms, float)
+            self.assertGreater(result.solve_time_ms, 0.0)
+            self.assertIsInstance(result.penalty, float)
+            self.assertGreater(result.penalty, 0.0)
+            self.assertIsInstance(result.num_outer_iterations, int)
+            self.assertGreaterEqual(result.num_outer_iterations, 1)
+            self.assertIsInstance(result.num_inner_iterations, int)
+            self.assertGreaterEqual(result.num_inner_iterations, 1)
+            self.assertIsInstance(result.last_problem_norm_fpr, float)
+            self.assertGreaterEqual(result.last_problem_norm_fpr, 0.0)
+            self.assertIsInstance(result.f1_infeasibility, float)
+            self.assertGreaterEqual(result.f1_infeasibility, 0.0)
+            self.assertIsInstance(result.f2_norm, float)
+            self.assertGreaterEqual(result.f2_norm, 0.0)
+            self.assertIsInstance(result.lagrange_multipliers, list)
+            self.assertAlmostEqual(result.states[0][0], 1.0)
+            self.assertAlmostEqual(result.states[0][1], -1.0)
+        finally:
+            optimizer.kill()
+
     def test_single_vs_multiple(self):
         single_optimizer = og.ocp.GeneratedOptimizer.load(self.ocp2_single_manifest_path)
         multiple_optimizer = og.ocp.GeneratedOptimizer.load(self.ocp2_multiple_manifest_path)
