Functions
None	update_bounds (ControllerState state, np.ndarray x_prev, np.ndarray x_meas, np.ndarray u_prev, ControllerConfig cfg, Optional[EngineWrapper] engine_wrapper=None, Optional[float] mdot_F=None, Optional[float] mdot_O=None, Optional[float] dt=None)
Tuple[np.ndarray, np.ndarray]	tube_propagate (np.ndarray x_lo, np.ndarray x_hi, np.ndarray u, np.ndarray w_bar, float dt, DynamicsParams params, float mdot_F, float mdot_O)
np.ndarray	get_w_bar_array (ControllerState state)
None	set_w_bar_array (ControllerState state, np.ndarray w_bar)

Detailed Description

Robustness bounds and tube propagation for robust DDP controller.

Maintains residual bounds w_bar for each state component and propagates
uncertainty tubes for robust control.

Function Documentation

◆ get_w_bar_array()

np.ndarray engine.control.robust_ddp.robustness.get_w_bar_array ( ControllerState state )

Get w_bar as numpy array (per-state-component bounds).

Parameters:
-----------
state : ControllerState
    Controller state

Returns:
--------
w_bar : np.ndarray, shape (N_STATE,)
    Residual bounds for each state component

Definition at line 202 of file robustness.py.

◆ set_w_bar_array()

None engine.control.robust_ddp.robustness.set_w_bar_array	(	ControllerState	state,
		np.ndarray	w_bar )

Set w_bar from numpy array.

Parameters:
-----------
state : ControllerState
    Controller state (mutated in place)
w_bar : np.ndarray, shape (N_STATE,)
    Residual bounds for each state component

Definition at line 234 of file robustness.py.

◆ tube_propagate()

Tuple[np.ndarray, np.ndarray] engine.control.robust_ddp.robustness.tube_propagate	(	np.ndarray	x_lo,
		np.ndarray	x_hi,
		np.ndarray	u,
		np.ndarray	w_bar,
		float	dt,
		DynamicsParams	params,
		float	mdot_F,
		float	mdot_O )

Propagate uncertainty tube through dynamics.

Computes lower and upper bounds of state uncertainty after one step:
- x_lo_next = f(x_lo, u) - w_bar
- x_hi_next = f(x_hi, u) + w_bar

Parameters:
-----------
x_lo : np.ndarray, shape (N_STATE,)
    Lower bound of state uncertainty
x_hi : np.ndarray, shape (N_STATE,)
    Upper bound of state uncertainty
u : np.ndarray, shape (N_CONTROL,)
    Control input
w_bar : np.ndarray, shape (N_STATE,)
    Residual bounds (uncertainty per state component)
dt : float
    Time step [s]
params : DynamicsParams
    Dynamics parameters
mdot_F : float
    Fuel mass flow [kg/s]
mdot_O : float
    Oxidizer mass flow [kg/s]

Returns:
--------
x_lo_next : np.ndarray, shape (N_STATE,)
    Lower bound of next state uncertainty
x_hi_next : np.ndarray, shape (N_STATE,)
    Upper bound of next state uncertainty

Notes:
------
This implements a simple interval propagation. For more sophisticated
methods (e.g., zonotopes, polytopes), see advanced robust control literature.

Definition at line 127 of file robustness.py.

◆ update_bounds()

None engine.control.robust_ddp.robustness.update_bounds	(	ControllerState	state,
		np.ndarray	x_prev,
		np.ndarray	x_meas,
		np.ndarray	u_prev,
		ControllerConfig	cfg,
		Optional[EngineWrapper]	engine_wrapper = None,
		Optional[float]	mdot_F = None,
		Optional[float]	mdot_O = None,
		Optional[float]	dt = None )

Update residual bounds w_bar and disturbance bias beta.

Computes residual between measured and predicted state, then updates
bounds using exponential moving average with inflation.

Parameters:
-----------
state : ControllerState
    Controller state (mutated in place)
x_prev : np.ndarray, shape (N_STATE,)
    Previous state x[k-1]
x_meas : np.ndarray, shape (N_STATE,)
    Measured state x_meas[k]
u_prev : np.ndarray, shape (N_CONTROL,)
    Previous control u[k-1]
cfg : ControllerConfig
    Controller configuration (contains rho, eta)
engine_wrapper : EngineWrapper, optional
    Engine wrapper for computing mass flows (if not provided, uses mdot_F/mdot_O)
mdot_F : float, optional
    Fuel mass flow [kg/s] (required if engine_wrapper not provided)
mdot_O : float, optional
    Oxidizer mass flow [kg/s] (required if engine_wrapper not provided)
dt : float, optional
    Time step [s] (defaults to cfg.dt)

Notes:
------
Mutates state.w_bar and state.beta in place.

Algorithm:
1. Compute predicted state: x_pred = f(x_prev, u_prev)
2. Compute residual: residual = x_meas - x_pred
3. Update bounds: w_bar = rho * w_bar + (1 - rho) * abs(residual)
4. Inflate: w_bar *= eta
5. Update bias (optional): beta = rho_beta * beta + (1 - rho_beta) * residual

Definition at line 17 of file robustness.py.