openscvx 0.5.3.dev33__py3-none-any.whl → 0.5.3.dev35__py3-none-any.whl

openscvx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.3.dev33'
-__version_tuple__ = version_tuple = (0, 5, 3, 'dev33')
+__version__ = version = '0.5.3.dev35'
+__version_tuple__ = version_tuple = (0, 5, 3, 'dev35')
 
-__commit_id__ = commit_id = 'g3d6f6768a'
+__commit_id__ = commit_id = 'g43f7b7f31'

openscvx/algorithms/optimization_results.py

@@ -50,6 +50,14 @@ class OptimizationResults:
             Added by propagate_trajectory_results.
         ctcs_violation (Optional[np.ndarray]): Continuous-time constraint violations.
             Added by propagate_trajectory_results.
+        parameters (dict[str, np.ndarray]): Parameter values the solve used, recorded
+            by :meth:`~openscvx.problem.Problem.solve` and
+            :meth:`~openscvx.problem.Problem.solve_batched` (batched solves store every
+            value with a leading ``(B,)`` axis, shared values replicated). Results
+            record what happened: post-processing propagates with these values, and
+            the Problem's parameter dict only seeds the next solve. Empty when no
+            snapshot was recorded (e.g. ``solve_jax``, whose callers manage
+            parameters themselves).
         plotting_data (dict[str, Any]): Flexible storage for plotting and application data.
 
     !!! note "JAX pytree registration"
@@ -59,8 +67,9 @@ class OptimizationResults:
         ``converged``, ``t_final``, ``nodes``, ``trajectory``, ``X``, ``U``,
         and every ``*_history`` field — the data the user actually consumes.
         Post-process fields (``t_full``, ``x_full``, ``u_full``, ``cost``,
-        ``ctcs_violation``), ``plotting_data``, and the internal ``_states`` /
-        ``_controls`` metadata are stashed in the treedef's *aux* instead, so
+        ``ctcs_violation``), ``parameters``, ``plotting_data``, and the
+        internal ``_states`` / ``_controls`` metadata are stashed in the
+        treedef's *aux* instead, so
         a batched ``solve_jax`` doesn't force callers to handle ``None``
         leaves and ``post_process()`` outputs stay outside the vmap surface
         (post-process per element after the batched solve).
@@ -217,6 +226,10 @@ class OptimizationResults:
     cost: Optional[float] = field(default=None, metadata={"npz": "optional_scalar"})
     ctcs_violation: Optional[np.ndarray] = field(default=None, metadata={"npz": "optional_array"})
 
+    # Parameter values the solve used (recorded by Problem.solve() /
+    # Problem.solve_batched(); empty when nothing was recorded)
+    parameters: dict[str, np.ndarray] = field(default_factory=dict, metadata={"npz": "dict"})
+
     # Additional plotting/application data (added by user)
     plotting_data: dict[str, Any] = field(default_factory=dict, metadata={"npz": "dict"})
 
@@ -245,6 +258,7 @@ class OptimizationResults:
             self.u_full,
             self.cost,
             self.ctcs_violation,
+            self.parameters,
             self.plotting_data,
         )
         return children, aux
@@ -260,6 +274,7 @@ class OptimizationResults:
             u_full,
             cost,
             ctcs_violation,
+            parameters,
             plotting_data,
         ) = aux
         return cls(
@@ -271,6 +286,7 @@ class OptimizationResults:
             u_full=u_full,
             cost=cost,
             ctcs_violation=ctcs_violation,
+            parameters=parameters,
             plotting_data=plotting_data,
         )
 

openscvx/problem.py

@@ -23,6 +23,7 @@ import os
 import queue
 import threading
 import time
+import warnings
 from dataclasses import fields as dc_fields
 from dataclasses import replace as dc_replace
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -62,7 +63,11 @@ from openscvx.lowered.jax_constraints import (
     LoweredJaxConstraints,
     LoweredNodalConstraint,
 )
-from openscvx.propagation import get_propagation_solver, propagate_trajectory_results
+from openscvx.propagation import (
+    get_propagation_solver,
+    propagate_trajectory_results,
+    s_to_t,
+)
 from openscvx.solvers import ConvexSolver, resolve_solver_config
 from openscvx.symbolic.builder import preprocess_symbolic_problem
 from openscvx.symbolic.expr import CTCS, Constraint
@@ -672,6 +677,7 @@ class Problem:
         # Final solution state (saved after successful solve)
         self._solution: Optional[AlgorithmState] = None
         self._solution_history: Optional[AlgorithmHistory] = None
+        self._solution_parameters: Optional[Dict[str, np.ndarray]] = None
 
         # SCP algorithm (resolved from `algorithm` parameter above)
 
@@ -1287,6 +1293,7 @@ class Problem:
         # Reset solution
         self._solution = None
         self._solution_history = None
+        self._solution_parameters = None
 
         # Reset timing
         self.timing_solve = None
@@ -1355,7 +1362,10 @@ class Problem:
 
         Returns:
             OptimizationResults with trajectory and convergence info
-                (call post_process() for full propagation)
+                (call post_process() for full propagation). The parameter
+                values used for the solve are recorded on
+                ``results.parameters``; :meth:`post_process` propagates
+                with them.
         """
         # Sync parameters, boundary conditions, and SCP constants before solving
         self._sync_parameters()
@@ -1408,16 +1418,22 @@ class Problem:
 
         profiling.profiling_end(pr, "solve")
 
-        # Snapshot state + history for post_process() / plotting reuse.
+        # Snapshot state, history, and parameters for post_process() / plotting
+        # reuse.
         self._solution = self._state
         self._solution_history = copy.deepcopy(self._history)
+        self._solution_parameters = {
+            name: np.array(value) for name, value in self._parameters.items()
+        }
 
         timed_out = t_max is not None and self.timing_solve >= t_max
-        return self._format_result(
+        result = self._format_result(
             self._state,
             self._history,
             int(self._state.k) <= k_max and not timed_out,
         )
+        result.parameters = self._solution_parameters
+        return result
 
     def _default_state(self) -> AlgorithmState:
         """Fresh :class:`AlgorithmState` from settings and the algorithm's SCP constants.
@@ -1665,6 +1681,11 @@ class Problem:
             parameters: Problem parameters dict for the current solve. Use
                 this rather than mutating ``self.parameters`` if the
                 parameters are traced. ``None`` reuses ``self._parameters``.
+                Unlike :meth:`solve` / :meth:`solve_batched`, the merged
+                values are *not* recorded on the returned results — under a
+                caller's ``jit`` / ``vmap`` they are tracers, which must not
+                leak into the pytree's aux — so callers that post-process
+                manage parameter bookkeeping themselves.
             x_guess: Initial state trajectory guess, shape ``(N, n_states)``.
                 Replaces ``state.x``; ``None`` uses the default from
                 settings (``State.guess`` at ``initialize()``).
@@ -1846,7 +1867,12 @@ class Problem:
 
         Returns:
             :class:`OptimizationResults` pytree with a leading ``B`` axis on
-            every leaf and empty per-iteration histories.
+            every leaf and empty per-iteration histories. The merged
+            parameter values used for the solve are recorded on
+            ``results.parameters``, post-broadcast — every value carries the
+            leading ``(B,)`` axis, shared values replicated — and
+            :meth:`post_process_batched` propagates each element with its
+            own values.
         """
         if self._iteration_fn_jit_inner is None:
             raise ValueError(
@@ -1953,7 +1979,16 @@ class Problem:
             final_states = batched_solve(states, params_for_solve)
         jax.block_until_ready(final_states)
         self.timing_solve = time.time() - t_0_solve
-        return OptimizationResults.from_final_state(final_states, problem=self)
+        results = OptimizationResults.from_final_state(final_states, problem=self)
+        # Record the as-used parameter values with a leading (B,) axis on
+        # every leaf, so post_process_batched() can index element b directly.
+        results.parameters = {
+            name: np.array(np.moveaxis(np.asarray(value), param_axes[name], 0))
+            if param_axes[name] is not None
+            else np.broadcast_to(np.asarray(value), (B,) + np.shape(value)).copy()
+            for name, value in params_for_solve.items()
+        }
+        return results
 
     def post_process(self) -> OptimizationResults:
         """Propagate solution through full nonlinear dynamics for high-fidelity trajectory.
@@ -1961,6 +1996,10 @@ class Problem:
         Integrates the converged SCP solution through the nonlinear dynamics to
         produce x_full, u_full, and t_full. Call after solve() for final results.
 
+        Propagation uses the parameter values recorded at solve time
+        (``results.parameters``), so mutating ``self.parameters`` between
+        :meth:`solve` and here only seeds the next solve.
+
         Returns:
             OptimizationResults with propagated trajectory fields
 
@@ -1980,9 +2019,11 @@ class Problem:
             int(self._solution.k) <= self._algorithm.k_max,
         )
 
+        result.parameters = self._solution_parameters
+
         t_0_post = time.time()
         result = propagate_trajectory_results(
-            self._parameters,
+            self._solution_parameters,
             self.settings,
             result,
             self._propagation_solver,
@@ -2022,9 +2063,11 @@ class Problem:
         - ``results.cost``    — ``(B,)``
         - ``results.ctcs_violation`` — ``(B, ...)`` or ``None``
 
-        Propagation runs sequentially over the batch in a Python loop;
-        all elements share ``self._parameters`` for any parameter values not
-        embedded in the trajectory state vector.
+        Propagation runs sequentially over the batch in a Python loop; each
+        element propagates with its own parameter values from the snapshot
+        :meth:`solve_batched` recorded on ``results.parameters``. Results
+        without a snapshot (e.g. loaded from an older save) fall back to
+        ``self.parameters`` with a warning.
 
         Args:
             results: Batched :class:`~openscvx.algorithms.OptimizationResults`
@@ -2035,7 +2078,12 @@ class Problem:
                 ``ceil(T_max / settings.prp.dt) + 1`` where ``T_max`` is the
                 longest terminal time across the batch.  All ``B`` elements are
                 interpolated to the **same** ``n_times`` so the output arrays
-                have uniform shape.
+                have uniform shape.  The requested (or default) value is capped
+                so no single segment of any element receives more dense samples
+                than the propagation solver's compiled per-segment capacity
+                (``settings.prp.max_tau_len``); the cap binds on the largest
+                segment-duration fraction across the batch, so trajectories with
+                near-uniform segments are left untouched.
 
         Returns:
             The same ``results`` object with ``t_full``, ``x_full``, ``u_full``,
@@ -2056,10 +2104,24 @@ class Problem:
             n_times = max(int(np.ceil(T_max / self.settings.prp.dt)) + 1, 2)
 
         # The propagation solver is compiled with a per-segment tau capacity of
-        # ``max_tau_len``.  A uniform ``linspace`` grid sized from the batch
-        # ``T_max`` can place more output times into one normalized segment than
-        # that capacity when shorter trajectories are padded to the same count.
-        n_times = min(n_times, self.settings.prp.max_tau_len)
+        # ``max_tau_len`` — the *per-segment* buffer width, not a total-point
+        # budget.  A uniform ``linspace`` grid over an element's real time span
+        # drops about ``(n_times - 1) * seg_dur / span`` points into each
+        # segment, so the binding quantity is the largest segment-duration
+        # fraction across the batch, not the total point count.  Bound
+        # ``n_times`` so the busiest segment of any element — plus the endpoint
+        # sample ``simulate_nonlinear_time`` appends — stays within
+        # ``max_tau_len``:
+        #     (n_times - 1) * frac_max + 2 <= max_tau_len.
+        u_batch = np.asarray(results.U[-1])  # (B, N, n_u)
+        frac_max = 0.0
+        for b in range(B):
+            t_b = np.asarray(
+                s_to_t(x_batch[b], u_batch[b], self.settings, self._discretizer)
+            ).reshape(-1)
+            frac_max = max(frac_max, float(np.diff(t_b).max() / (t_b[-1] - t_b[0])))
+        per_segment_bound = max(int((self.settings.prp.max_tau_len - 2) / frac_max) + 1, 2)
+        n_times = min(n_times, per_segment_bound)
 
         t_fulls: List[np.ndarray] = []
         x_fulls: List[np.ndarray] = []
@@ -2068,11 +2130,23 @@ class Problem:
         costs: List[float] = []
         ctcs_violations = []
 
+        # Empty for results saved before the snapshot existed — those fall
+        # back to the Problem's current values, the pre-snapshot behaviour.
+        snapshot = getattr(results, "parameters", None) or {}
+        if not snapshot and self._parameters:
+            warnings.warn(
+                "results carry no record of the parameter values they were solved "
+                "with; propagating every element with the Problem's current "
+                "parameters, which may differ from the solved values.",
+                UserWarning,
+                stacklevel=2,
+            )
+
         t_0_post = time.time()
         for b in range(B):
             single = _make_single_result(results, b)
             prop = propagate_trajectory_results(
-                self._parameters,
+                dict(self._parameters, **{k: np.asarray(v)[b] for k, v in snapshot.items()}),
                 self.settings,
                 single,
                 self._propagation_solver,

{openscvx-0.5.3.dev33.dist-info → openscvx-0.5.3.dev35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev33
+Version: 0.5.3.dev35
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.5.3.dev33.dist-info → openscvx-0.5.3.dev35.dist-info}/RECORD

@@ -1,15 +1,15 @@
 openscvx/__init__.py,sha256=sxiqBoS5jv9UmNSxnrokFXeFMnDSkAxUCtC4X-s-vHk,4456
 openscvx/__main__.py,sha256=Hwm7mtVg3tLdvoUPkpcQv8KF3wxl72PNLBp9axFu8GY,2991
-openscvx/_version.py,sha256=g5nYICDm7jUmHCfdE4DnOzSswCJ-WfqBIpwo1JvydrE,543
+openscvx/_version.py,sha256=zYvwhGhbvK9AbmgQE8S1Hgf833v_MnaaaIPnD1k7tlc,543
 openscvx/config.py,sha256=qfDDYoCe6WqJglKsx5b2W48YOglXenKr-PVRRdCFhYE,9898
 openscvx/loader.py,sha256=5WDLVA6CQxnyi1pRBfP8jQQc0r8RiAM2O_ItKgMXxAk,7660
-openscvx/problem.py,sha256=0hsAdpj74XXsYfOn8VBPzjCpO3mH5bSzHOwpezIBiYY,96230
+openscvx/problem.py,sha256=aJlXbpwQ9_8gP8N2Ff1pz8biF0FoIZTyDYvLX65DLfw,100224
 openscvx/algorithms/__init__.py,sha256=xEB2sZ_fFbQUSOJY4hOzsZe0cdCuD5LawvrF4fzSt8E,5645
 openscvx/algorithms/base.py,sha256=jMneNL5lc-qg24vvcGQ4NP93d71boRiUGh6uKBykOlM,11638
 openscvx/algorithms/history.py,sha256=aAS3VWT5d4kfsIl5a34YFYglHayPqn0hZGmhXVGbE0g,17456
 openscvx/algorithms/hyperparams.py,sha256=BmNDHerJ-eWi5wO5aryXMSe9jDzLsMxXNcCSeNHOCYY,4560
 openscvx/algorithms/loop.py,sha256=S03KlW_z4hWdrP50rfEzWmDRaOOl7XHmlzImpkKXGX4,3927
-openscvx/algorithms/optimization_results.py,sha256=TVZVeoUpbAmEILmxFrLZz0GT9ze4Apzwm_tXfpBOPjQ,23614
+openscvx/algorithms/optimization_results.py,sha256=BViVL39Y2QmqI-qfGN5NrZj9Cy9DK1cvjJnKff3Bzck,24548
 openscvx/algorithms/penalty.py,sha256=sqfH11bVr-ZG1VUUA4FjF6ETYDuA06ZXiOAvxBPBcts,4329
 openscvx/algorithms/state.py,sha256=-ooDqgPezM-GwcWj8Y4q7yB_GQGjlvVucIeGbl8271Q,15787
 openscvx/algorithms/weights.py,sha256=DQV9NOR_-59lISv6d_el3cpQ-EcFasSGb1oZr4ma-yA,20682
@@ -159,11 +159,11 @@ openscvx/utils/caching.py,sha256=Uw2e0G1UNn_vmMDqUZGszIH-O9LJhR4wdVKSPToHiy0,169
 openscvx/utils/printing.py,sha256=dsccZ9sXc3TBWShQvBg1Al4UFGMP77ApblfxteEJHLQ,16515
 openscvx/utils/profiling.py,sha256=k2x-i0CpG_kRe6dNcNBGu-ylrOtQw4B4C1UaOTjUMfU,1678
 openscvx/utils/utils.py,sha256=M25RHE_7DSr3Reaca0xCXnDSY9KHuqYvXdh5m1ZotEc,3047
-openscvx-0.5.3.dev33.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openscvx-0.5.3.dev33.dist-info/METADATA,sha256=ZnngKgG1V-Z76KjLfpkcyh2xzr2b8Om2FSxRwlldwNc,10924
-openscvx-0.5.3.dev33.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-openscvx-0.5.3.dev33.dist-info/entry_points.txt,sha256=1Oqek8Sy28hmAZFgZXDxFXYVf56YLYWlHjhh9RYJ7wE,52
-openscvx-0.5.3.dev33.dist-info/scm_file_list.json,sha256=LsBg6YSb5CTgXZVsnmrZNQ3_4o5wSJReFmZGCm66mI8,18001
-openscvx-0.5.3.dev33.dist-info/scm_version.json,sha256=gaYW5X0wxdBiVUwvFb3BD5j2X9LvNbsSoIEQCHp6dRg,161
-openscvx-0.5.3.dev33.dist-info/top_level.txt,sha256=nUT4Ybefzh40H8tVXqc1RzKESy_MAowElb-CIvAbd4Q,9
-openscvx-0.5.3.dev33.dist-info/RECORD,,
+openscvx-0.5.3.dev35.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openscvx-0.5.3.dev35.dist-info/METADATA,sha256=zPUnmSxAXkoEBCyp8VD6xerMp6zXIyMuix9WvCgrIUI,10924
+openscvx-0.5.3.dev35.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+openscvx-0.5.3.dev35.dist-info/entry_points.txt,sha256=1Oqek8Sy28hmAZFgZXDxFXYVf56YLYWlHjhh9RYJ7wE,52
+openscvx-0.5.3.dev35.dist-info/scm_file_list.json,sha256=SlBGAndk9F0hQaBc0H6_xbLqjPOhzhpxfYjAYRvf1M8,18093
+openscvx-0.5.3.dev35.dist-info/scm_version.json,sha256=Cx_YDZgQq_q8oE32xSp_vT9pYGqjZ26SBE6bmsrbdT4,161
+openscvx-0.5.3.dev35.dist-info/top_level.txt,sha256=nUT4Ybefzh40H8tVXqc1RzKESy_MAowElb-CIvAbd4Q,9
+openscvx-0.5.3.dev35.dist-info/RECORD,,

{openscvx-0.5.3.dev33.dist-info → openscvx-0.5.3.dev35.dist-info}/scm_file_list.json

@@ -220,6 +220,8 @@
     "tests/test_propagation.py",
     "tests/hohmann_analytical.py",
     "tests/test_expert.py",
+    "tests/test_results_parameters.py",
+    "tests/test_post_process_batched_tau_clamp.py",
     "tests/test_solve_batched_inference.py",
     "tests/test_solve_jax_bare_brachistochrone.py",
     "tests/test_cvxpygen_optional.py",

openscvx-0.5.3.dev35.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.2",
+  "distance": 35,
+  "node": "g43f7b7f313888f19e8586f108d8e11bed332f87f",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-07-06"
+}

openscvx-0.5.3.dev33.dist-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.2",
-  "distance": 33,
-  "node": "g3d6f6768a9d011c99ab12c85b6695002b0606580",
-  "dirty": false,
-  "branch": "main",
-  "node_date": "2026-07-05"
-}