openscvx 0.4.1.dev119__tar.gz → 0.4.1.dev121__tar.gz

{openscvx-0.4.1.dev119/openscvx.egg-info → openscvx-0.4.1.dev121}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev119
+Version: 0.4.1.dev121
 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.4.1.dev121/examples/abstract/impulsive.py

@@ -0,0 +1,103 @@
+"""Impulsive control example with mixed continuous/impulsive inputs.
+
+This example demonstrates a simple 1D position/velocity system with:
+
+- Continuous acceleration control
+- Impulsive delta-v control applied only at selected nodes
+- Time-dilation for minimum-time objective
+- CTCS bounds on states
+"""
+
+import os
+import sys
+
+import numpy as np
+
+# Add grandparent directory to path to import examples.plotting
+current_dir = os.path.dirname(os.path.abspath(__file__))
+grandparent_dir = os.path.dirname(os.path.dirname(current_dir))
+sys.path.append(grandparent_dir)
+
+import openscvx as ox
+from openscvx import Problem
+from openscvx.plotting import plot_controls, plot_states
+
+n = 10
+
+p = ox.State("position", shape=(1,))
+p.max = np.array([1.0])
+p.min = np.array([0.0])
+p.initial = np.array([0.0])
+p.final = np.array([1.0])
+p.guess = np.linspace(p.initial, p.final, n).reshape(-1, 1)
+
+v = ox.State("velocity", shape=(1,))  # Scalar speed
+v.max = np.array([1.0])
+v.min = np.array([-1.0])
+v.initial = np.array([0.0])
+v.final = np.array([0.0])
+v.guess = np.linspace(v.initial, v.final, n).reshape(-1, 1)
+
+dv = ox.Control(
+    "delta_v",
+    shape=(1,),
+    impulsive=True,
+    nodes=[0, n - 1],
+)
+dv.max = np.array([0.2])
+dv.min = np.array([-0.2])
+dv.guess = np.linspace(np.array([0]), np.array([0]), n)
+dv.scaling_min = np.array([-0.2])
+dv.scaling_max = np.array([0.2])
+
+a = ox.Control("acceleration", shape=(1,))
+a.max = np.array([0.01])
+a.min = np.array([-0.01])
+a.guess = np.linspace(np.array([0]), np.array([0]), n)
+a.scaling_min = np.array([-1])
+a.scaling_max = np.array([1])
+
+dynamics = {
+    "position": v,
+    "velocity": a,
+}
+
+dynamics_discrete = {
+    "position": p,
+    "velocity": v + ox.Power(ox.Max(ox.Abs(dv), 1e-6), 1.5) * dv,
+}
+
+states = [p, v]
+controls = [dv, a]
+
+constraints = []
+for state in states:
+    constraints.extend([ox.ctcs(state <= state.max), ox.ctcs(state.min <= state)])
+
+time = ox.Time(initial=0.0, final=ox.Minimize(10.0), min=0.0, max=20.0)
+
+problem = Problem(
+    dynamics=dynamics,
+    dynamics_discrete=dynamics_discrete,
+    states=states,
+    controls=controls,
+    time=time,
+    constraints=constraints,
+    N=n,
+)
+
+problem.algorithm.lam_prox = 1e-2  # Weight on the Trust Reigon
+problem.algorithm.lam_vc = 5e1  # Weight on the Trust Reigon
+problem.algorithm.lam_cost = 1e0  # Weight on the Minimal Time Objective
+problem.algorithm.k_max = 100
+
+plotting_dict = {}
+
+if __name__ == "__main__":
+    problem.initialize()
+    results = problem.solve()
+    results = problem.post_process()
+    results.update(plotting_dict)
+
+    plot_states(results).show()
+    plot_controls(results).show()

{openscvx-0.4.1.dev119 → openscvx-0.4.1.dev121}/examples/plotting_viser.py

@@ -21,6 +21,7 @@ from openscvx.plotting.viser import (
     add_animated_vector_norm_plot,
     add_animation_controls,
     add_attitude_frame,
+    add_circular_orbit,
     add_ellipsoid_obstacles,
     add_gates,
     add_ghost_trajectory,
@@ -1174,3 +1175,83 @@ def compute_velocity_colors_realtime(vel: np.ndarray, cmap) -> np.ndarray:
         dtype=np.uint8,
     )
     return colors
+
+
+def _as_3d(points: np.ndarray) -> np.ndarray:
+    """Ensure points are shape (..., 3) by appending z=0 when needed."""
+    points = np.asarray(points, dtype=np.float64)
+    if points.ndim == 1:
+        if points.shape[0] == 2:
+            return np.array([points[0], points[1], 0.0], dtype=np.float64)
+        if points.shape[0] == 3:
+            return points
+        raise ValueError(f"Expected 2D or 3D point, got shape {points.shape}")
+    if points.ndim == 2:
+        if points.shape[1] == 2:
+            z = np.zeros((points.shape[0], 1), dtype=np.float64)
+            return np.concatenate([points, z], axis=1)
+        if points.shape[1] == 3:
+            return points
+        raise ValueError(f"Expected points with 2 or 3 columns, got shape {points.shape}")
+    raise ValueError(f"Expected points with ndim 1 or 2, got ndim {points.ndim}")
+
+
+def create_hohmann_transfer_server(
+    results: OptimizationResults,
+    *,
+    r1: float,
+    r2: float,
+    position_key: str = "position",
+    velocity_key: str = "velocity",
+    loop_animation: bool = True,
+    show_grid: bool = False,
+    scene_scale: float = 1.0,
+    orbit_n_points: int = 512,
+    orbit_color_inner: tuple[int, int, int] = (120, 180, 255),
+    orbit_color_outer: tuple[int, int, int] = (255, 180, 120),
+    transfer_point_size: float = 0.10,
+    marker_radius: float = 0.6,
+) -> viser.ViserServer:
+    """Create an animated viser server for a planar Hohmann transfer.
+
+    Draws two static circular orbit rings (r1, r2) and animates the transfer
+    trajectory stored in ``results.trajectory``.
+    """
+    pos = results.trajectory.get(position_key)
+    if pos is None:
+        raise KeyError(f"results.trajectory is missing '{position_key}'")
+    pos_3d = _as_3d(pos) / scene_scale
+
+    vel = results.trajectory.get(velocity_key)
+    vel_3d = None if vel is None else _as_3d(vel)
+    colors = compute_velocity_colors(vel_3d, fallback_length=pos_3d.shape[0])
+
+    traj_time = np.asarray(results.trajectory["time"], dtype=np.float64).flatten()
+
+    server = create_server(pos_3d, show_grid=show_grid)
+
+    # Static orbit rings
+    add_circular_orbit(
+        server,
+        r1 / scene_scale,
+        name="inner_orbit",
+        n_points=orbit_n_points,
+        color=orbit_color_inner,
+        line_width=2.5,
+    )
+    add_circular_orbit(
+        server,
+        r2 / scene_scale,
+        name="outer_orbit",
+        n_points=orbit_n_points,
+        color=orbit_color_outer,
+        line_width=2.5,
+    )
+
+    # Static ghost + animated trail + marker
+    add_ghost_trajectory(server, pos_3d, colors, opacity=0.25, point_size=transfer_point_size)
+    _, update_trail = add_animated_trail(server, pos_3d, colors, point_size=transfer_point_size)
+    _, update_marker = add_position_marker(server, pos_3d, radius=marker_radius)
+
+    add_animation_controls(server, traj_time, [update_trail, update_marker], loop=loop_animation)
+    return server

openscvx-0.4.1.dev121/examples/spacecraft/hohmann_transfer.py

@@ -0,0 +1,205 @@
+"""Hohmann transfer with impulsive delta-v controls (LEO → GEO).
+
+This example mirrors the Hohmann transfer calculation from
+[_Orbital Mechanics & Astrodynamics_](https://orbital-mechanics.space/orbital-maneuvers/hohmann-transfer-example.html)
+by Bryan Weber and embeds it in a trajectory optimization problem that uses impulsive
+delta-v controls.
+
+We consider a planar, two-body Earth-centered problem:
+
+- Initial circular orbit: 250 km altitude LEO
+- Final circular orbit: GEO with 1 sidereal-day period
+- 2D position/velocity states in an inertial frame (km, km/s)
+- Central gravity with mu = 3.986e5 km^3/s^2
+- Two impulsive delta-v maneuvers applied at the initial and final nodes
+- A scalar cost state that accumulates the L2 norm of each impulse and is
+  minimized at the final time (approximate minimum-fuel objective)
+
+Continuous dynamics between impulses:
+
+    x_dot = vx
+    y_dot = vy
+    vx_dot = -mu * x / r^3
+    vy_dot = -mu * y / r^3
+
+Discrete dynamics at impulsive nodes:
+
+- position unchanged
+- velocity += delta_v
+- cost += ||delta_v||
+
+The transfer time is fixed to the Hohmann half-period of the transfer ellipse.
+In the __main__ block we also compute and print the analytic Hohmann Δv and
+propellant mass from Weber's example for comparison.
+"""
+
+import os
+import sys
+
+import numpy as np
+
+# Add grandparent directory to path to import examples.plotting
+current_dir = os.path.dirname(os.path.abspath(__file__))
+grandparent_dir = os.path.dirname(os.path.dirname(current_dir))
+sys.path.append(grandparent_dir)
+
+import openscvx as ox
+from examples.plotting_viser import create_hohmann_transfer_server
+from openscvx import Problem
+from openscvx.plotting import plot_controls, plot_scp_iterations, plot_states
+
+# Problem configuration (match Weber's LEO → GEO example)
+n = 15
+
+mu = 3.986e5  # km^3 / s^2
+R_E = 6378.0  # km
+r_leo = 250.0 + R_E
+
+sidereal_day = 86164.0905  # s
+r_cubed = mu * sidereal_day**2 / (4 * np.pi**2)
+r_geo = r_cubed ** (1.0 / 3.0)
+
+r1 = r_leo
+r2 = r_geo
+
+# Hohmann transfer half-period for the transfer ellipse (fixed final time)
+a_transfer = 0.5 * (r1 + r2)
+T_transfer = np.pi * np.sqrt(a_transfer**3 / mu)
+
+# States: planar position, planar velocity, and scalar accumulated cost
+position = ox.State("position", shape=(2,))
+position.initial = np.array([r1, 0.0])
+position.final = np.array([-r2, 0.0])  # Opposite side for half-period transfer
+position.min = np.array([-(1.5 * r2), -(1.5 * r2)])
+position.max = np.array([1.5 * r2, 1.5 * r2])
+
+# Initial guess: follow an approximate Hohmann-like arc that never passes
+# through the origin (to avoid r ≈ 0 causing singular dynamics).
+theta_guess = np.linspace(0.0, np.pi, n)
+radius_guess = np.linspace(r1, r2, n)
+position_guess = np.stack(
+    [radius_guess * np.cos(theta_guess), radius_guess * np.sin(theta_guess)],
+    axis=1,
+)
+position.guess = position_guess
+
+velocity = ox.State("velocity", shape=(2,))
+v_c1 = np.sqrt(mu / r1)
+v_c2 = np.sqrt(mu / r2)
+velocity.initial = np.array([0.0, v_c1])
+velocity.final = np.array([0.0, -v_c2])
+velocity_min_mag = -2.0 * max(v_c1, v_c2)
+velocity_max_mag = 2.0 * max(v_c1, v_c2)
+velocity.min = np.array([velocity_min_mag, velocity_min_mag])
+velocity.max = np.array([velocity_max_mag, velocity_max_mag])
+velocity.guess = np.tile(np.array([0.0, (v_c1 + v_c2) / 2.0]), (n, 1))
+
+cost = ox.State("cost", shape=(1,))
+cost.initial = np.array([0.0])
+# Minimize final accumulated impulse norm with a loose upper bound
+cost.final = [("minimize", 10.0)]
+cost.min = np.array([0.0])
+cost.max = np.array([10.0])
+cost.guess = np.zeros((n, 1))
+
+# Impulsive delta-v control applied only at the first and last nodes
+dv = ox.Control(
+    "delta_v",
+    shape=(2,),
+    impulsive=True,
+    nodes=[0, n - 1],
+)
+dv_bound = 5.0  # km/s
+dv.min = np.array([-dv_bound, -dv_bound])
+dv.max = np.array([dv_bound, dv_bound])
+dv.guess = np.zeros((n, 2))
+
+states = [position, velocity, cost]
+controls = [dv]
+
+# Continuous dynamics: planar two-body gravity with no continuous thrust.
+# We clamp the radius away from zero for robustness in the linearization.
+r = ox.linalg.Norm(position)
+
+dynamics = {
+    "position": velocity,
+    "velocity": ox.Concat(
+        -mu * position[0] / r**3,
+        -mu * position[1] / r**3,
+    ),
+    "cost": 0.0,
+}
+
+# Discrete dynamics at impulsive nodes: update velocity and accumulate cost.
+# Use a small epsilon inside the norm to avoid NaNs in derivatives at dv = 0.
+eps_impulse = 1e-6
+d_impulse = ox.linalg.Norm(dv + eps_impulse)
+
+dynamics_discrete = {
+    "position": position,
+    "velocity": velocity + dv,
+    "cost": cost + d_impulse,
+}
+
+# Box constraints on all states
+constraints = []
+for state in states:
+    constraints.extend([ox.ctcs(state <= state.max), ox.ctcs(state.min <= state)])
+
+time = ox.Time(
+    initial=0.0,
+    final=T_transfer,
+    min=0.0,
+    max=T_transfer,
+)
+
+problem = Problem(
+    dynamics=dynamics,
+    dynamics_discrete=dynamics_discrete,
+    states=states,
+    controls=controls,
+    time=time,
+    constraints=constraints,
+    N=n,
+)
+
+problem.discretizer.ode_solver = "Dopri8"
+problem.settings.prp.dt = 10.0
+
+plotting_dict = {}
+
+if __name__ == "__main__":
+    # Analytic Hohmann values from Weber's example for reference
+    v_leo = np.sqrt(mu / r_leo)
+    v_geo = np.sqrt(mu / r_geo)
+    r_p = r_leo
+    r_a = r_geo
+    h_t = np.sqrt(2 * mu * r_a * r_p / (r_a + r_p))
+    v_tp = h_t / r_p
+    v_ta = h_t / r_a
+
+    Delta_v_analytic = abs(v_geo - v_ta) + abs(v_tp - v_leo)
+    I_sp = 450.5  # s
+    goes_mass = 5192.0  # kg
+    Delta_m_analytic = goes_mass * (1.0 - np.exp(-Delta_v_analytic / (I_sp * 9.81e-3)))
+
+    print(f"Analytic Hohmann Δv ≈ {Delta_v_analytic:.3f} km/s")
+    print(f"Analytic propellant mass ≈ {Delta_m_analytic:.3f} kg")
+
+    problem.initialize()
+    results = problem.solve()
+    results = problem.post_process()
+    results.update(plotting_dict)
+
+    # Always show standard Plotly diagnostics.
+    plot_states(results).show()
+    plot_controls(results).show()
+    plot_scp_iterations(results).show()
+
+    server = create_hohmann_transfer_server(
+        results,
+        r1=r1,
+        r2=r2,
+        scene_scale=1000.0,  # km -> Mm-ish for nicer viewing
+    )
+    server.sleep_forever()

{openscvx-0.4.1.dev119 → openscvx-0.4.1.dev121}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.1.dev119'
-__version_tuple__ = version_tuple = (0, 4, 1, 'dev119')
+__version__ = version = '0.4.1.dev121'
+__version_tuple__ = version_tuple = (0, 4, 1, 'dev121')
 
-__commit_id__ = commit_id = 'gc981f1ca1'
+__commit_id__ = commit_id = 'g87edfed70'

{openscvx-0.4.1.dev119 → openscvx-0.4.1.dev121}/openscvx/algorithms/augmented_lagrangian.py

@@ -130,8 +130,15 @@ class AugmentedLagrangian(AutotuningBase):
             weights: Normalized initial weights from the algorithm
         """
         # Calculate nonlinear penalty for current candidate
-        nonlinear_cost, nonlinear_penalty, nodal_penalty = self.calculate_nonlinear_penalty(
-            candidate.x_prop,
+        candidate_x_prop = (
+            candidate.x_prop_plus[1:] if candidate.x_prop_plus is not None else candidate.x_prop
+        )
+        (
+            nonlinear_cost,
+            nonlinear_penalty,
+            nodal_penalty,
+        ) = self.calculate_nonlinear_penalty(
+            candidate_x_prop,
             candidate.x,
             candidate.u,
             state.lam_vc,
@@ -155,18 +162,24 @@ class AugmentedLagrangian(AutotuningBase):
         lam_prox_k = deepcopy(state.lam_prox)
 
         if state.k > 1:
-            prev_nonlinear_cost, prev_nonlinear_penalty, prev_nodal_penalty = (
-                self.calculate_nonlinear_penalty(
-                    state.x_prop(),
-                    state.x,
-                    state.u,
-                    state.lam_vc,
-                    state.lam_vb,
-                    state.lam_cost,
-                    nodal_constraints,
-                    params,
-                    settings,
-                )
+            state_x_prop_plus = state.x_prop_plus()
+            state_x_prop = (
+                state_x_prop_plus[1:] if state_x_prop_plus is not None else state.x_prop()
+            )
+            (
+                prev_nonlinear_cost,
+                prev_nonlinear_penalty,
+                prev_nodal_penalty,
+            ) = self.calculate_nonlinear_penalty(
+                state_x_prop,
+                state.x,
+                state.u,
+                state.lam_vc,
+                state.lam_vb,
+                state.lam_cost,
+                nodal_constraints,
+                params,
+                settings,
             )
 
             J_nonlin_prev = prev_nonlinear_cost + prev_nonlinear_penalty + prev_nodal_penalty
@@ -208,7 +221,7 @@ class AugmentedLagrangian(AutotuningBase):
                 adaptive_state = "Accept Lower"
 
             # Update virtual control weight matrix
-            nu = (settings.sim.inv_S_x @ abs(candidate.x[1:] - candidate.x_prop).T).T
+            nu = (settings.sim.inv_S_x @ abs(candidate.x[1:] - candidate_x_prop).T).T
 
             # Vectorized update: use mask to select between two update rules
             mask = nu > self.ep

{openscvx-0.4.1.dev119 → openscvx-0.4.1.dev121}/openscvx/algorithms/base.py

@@ -7,7 +7,7 @@ during SCP iterations.
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Set, Tuple, Union
 
 import numpy as np
 
@@ -166,7 +166,11 @@ class CandidateIterate:
     x: Optional[np.ndarray] = None
     u: Optional[np.ndarray] = None
     V: Optional[np.ndarray] = None
+    W: Optional[np.ndarray] = None
     x_prop: Optional[np.ndarray] = None
+    x_prop_plus: Optional[np.ndarray] = None
+    D_d: Optional[np.ndarray] = None
+    E_d: Optional[np.ndarray] = None
     VC: Optional[np.ndarray] = None
     TR: Optional[np.ndarray] = None
     lam_vc: Optional[Union[float, np.ndarray]] = None
@@ -191,9 +195,18 @@ class DiscretizationResult:
     A_d: np.ndarray  # (N-1, n_x, n_x)
     B_d: np.ndarray  # (N-1, n_x, n_u)
     C_d: np.ndarray  # (N-1, n_x, n_u)
+    x_prop_plus: Optional[np.ndarray] = None  # (N, n_x), discrete dynamics on node states
+    D_d: Optional[np.ndarray] = None  # (N, n_x, n_x), d(x_prop_plus)/d(x_node)
+    E_d: Optional[np.ndarray] = None  # (N, n_x, n_u), d(x_prop_plus)/d(u_node)
 
     @classmethod
-    def from_V(cls, V: np.ndarray, n_x: int, n_u: int, N: int) -> "DiscretizationResult":
+    def from_V(
+        cls,
+        V: np.ndarray,
+        n_x: int,
+        n_u: int,
+        N: int,
+    ) -> "DiscretizationResult":
         """Unpack the final timestep of a raw discretization matrix ``V``."""
         i1, i2 = n_x, n_x + n_x * n_x
         i3, i4 = i2 + n_x * n_u, i2 + 2 * n_x * n_u
@@ -206,6 +219,37 @@ class DiscretizationResult:
             C_d=V_final[:, i3:i4].reshape(N - 1, n_x, n_u),
         )
 
+    @classmethod
+    def from_VW(
+        cls,
+        V: np.ndarray,
+        W: np.ndarray,
+        n_x: int,
+        n_u: int,
+        N: int,
+    ) -> "DiscretizationResult":
+        """Unpack continuous and impulsive discretization blocks from ``V`` and ``W``."""
+        base = cls.from_V(V=V, n_x=n_x, n_u=n_u, N=N)
+
+        W_arr = np.asarray(W)
+        i_w = n_x + n_x * n_x + n_x * n_u
+        i1 = n_x
+        i2 = i1 + n_x * n_x
+        i3 = i2 + n_x * n_u
+
+        W_final = W_arr[:, -1].reshape(-1, i_w)
+
+        return cls(
+            V=base.V,
+            x_prop=base.x_prop,
+            A_d=base.A_d,
+            B_d=base.B_d,
+            C_d=base.C_d,
+            x_prop_plus=W_final[:, :i1],
+            D_d=W_final[:, i1:i2].reshape(W_final.shape[0], n_x, n_x),
+            E_d=W_final[:, i2:i3].reshape(W_final.shape[0], n_x, n_u),
+        )
+
 
 class AutotuningBase(ABC):
     """Base class for autotuning methods in SCP algorithms.
@@ -429,9 +473,25 @@ class AlgorithmState:
         self.U.append(cand.u)
 
         if cand.V is not None:
-            self.discretizations.append(
-                DiscretizationResult.from_V(cand.V, n_x=self.n_x, n_u=self.n_u, N=self.N)
-            )
+            if cand.W is not None:
+                self.discretizations.append(
+                    DiscretizationResult.from_VW(
+                        cand.V,
+                        cand.W,
+                        n_x=self.n_x,
+                        n_u=self.n_u,
+                        N=self.N,
+                    )
+                )
+            else:
+                self.discretizations.append(
+                    DiscretizationResult.from_V(
+                        cand.V,
+                        n_x=self.n_x,
+                        n_u=self.n_u,
+                        N=self.N,
+                    )
+                )
         if cand.VC is not None:
             self.VC_history.append(cand.VC)
         if cand.TR is not None:
@@ -473,6 +533,24 @@ class AlgorithmState:
             DiscretizationResult.from_V(V, n_x=self.n_x, n_u=self.n_u, N=self.N)
         )
 
+    def add_impulsive_discretization(
+        self,
+        W: np.ndarray,
+    ) -> None:
+        """Attach impulsive discretization data to the latest discretization entry."""
+        if not self.discretizations:
+            raise ValueError(
+                "Cannot attach impulsive discretization before adding the base discretization."
+            )
+        last = self.discretizations[-1]
+        self.discretizations[-1] = DiscretizationResult.from_VW(
+            V=last.V,
+            W=W,
+            n_x=self.n_x,
+            n_u=self.n_u,
+            N=self.N,
+        )
+
     @property
     def V_history(self) -> List[np.ndarray]:
         """Backward-compatible view of raw discretization matrices.
@@ -563,6 +641,24 @@ class AlgorithmState:
             return None
         return self.discretizations[index].C_d
 
+    def x_prop_plus(self, index: int = -1) -> np.ndarray:
+        """Extract discrete dynamics evaluated at x_prop."""
+        if not self.discretizations:
+            return None
+        return self.discretizations[index].x_prop_plus
+
+    def D_d(self, index: int = -1) -> np.ndarray:
+        """Extract Jacobian of x_prop_plus w.r.t. x_prop."""
+        if not self.discretizations:
+            return None
+        return self.discretizations[index].D_d
+
+    def E_d(self, index: int = -1) -> np.ndarray:
+        """Extract Jacobian of x_prop_plus w.r.t. discrete controls."""
+        if not self.discretizations:
+            return None
+        return self.discretizations[index].E_d
+
     @property
     def lam_prox(self) -> float:
         """Get current trust region weight.
@@ -753,6 +849,7 @@ class Algorithm(ABC):
         emitter: callable,
         params: dict,
         settings: "Config",
+        discretization_solver_impulsive: Optional[Callable] = None,
     ) -> None:
         """Initialize the algorithm and store compiled infrastructure.
 
@@ -767,6 +864,8 @@ class Algorithm(ABC):
             emitter: Callback for emitting iteration progress data
             params: Problem parameters dictionary (for warm-start only)
             settings: Configuration object (for warm-start only)
+            discretization_solver_impulsive: Optional solver for discrete/impulsive
+                dynamics evaluated on ``(x_prop, u_discrete)``
         """
         raise NotImplementedError