openscvx 0.4.1.dev91__tar.gz → 0.4.1.dev117__tar.gz

{openscvx-0.4.1.dev91/openscvx.egg-info → openscvx-0.4.1.dev117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev91
+Version: 0.4.1.dev117
 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.dev91 → openscvx-0.4.1.dev117}/docs/Foundations/discretization.md

@@ -35,10 +35,10 @@ def dVdt(self,
         V = V.reshape(-1, self.i5)
 
         # Compute the interpolation factor based on the discretization type
-        if self.params.dis.dis_type == 'ZOH':
+        if self.dis_type == 'ZOH':
             beta = 0.
-        elif self.params.dis.dis_type == 'FOH':
-            beta = (tau) * self.params.scp.n
+        elif self.dis_type == 'FOH':
+            beta = (tau) * self.params.sim.n
         alpha = 1 - beta
 
         # Interpolate the control input

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/docs/Foundations/ocp.md

@@ -16,15 +16,17 @@ The state, constrol and additional parameters are defined as follows:
 
 lam_prox = cp.Parameter(nonneg = True, name='lam_prox')       # Weight on the Trust Region
 lam_cost = cp.Parameter(nonneg=True, name='lam_cost') # Weight on the Nonlinear Cost
+lam_vc = cp.Parameter((params.sim.n - 1, params.sim.n_states), nonneg=True, name='lam_vc')  # Weight on Virtual Control
+lam_vb = cp.Parameter(nonneg=True, name='lam_vb')     # Weight on Virtual Buffer
 
-x = cp.Variable((params.scp.n, params.sim.n_states), name='x')   # State
-dx = cp.Variable((params.scp.n, params.sim.n_states), name='dx') # State Trust Region
-x_bar = cp.Parameter((params.scp.n, params.sim.n_states), name='x_bar') # Previous SCP State
+x = cp.Variable((params.sim.n, params.sim.n_states), name='x')   # State
+dx = cp.Variable((params.sim.n, params.sim.n_states), name='dx') # State Trust Region
+x_bar = cp.Parameter((params.sim.n, params.sim.n_states), name='x_bar') # Previous SCP State
 
 
-u = cp.Variable((params.scp.n, params.sim.n_controls), name='u')   # Control
-du = cp.Variable((params.scp.n, params.sim.n_controls), name='du') # Control Trust Region
-u_bar = cp.Parameter((params.scp.n, params.sim.n_controls), name='u_bar') # Previous SCP Control
+u = cp.Variable((params.sim.n, params.sim.n_controls), name='u')   # Control
+du = cp.Variable((params.sim.n, params.sim.n_controls), name='du') # Control Trust Region
+u_bar = cp.Parameter((params.sim.n, params.sim.n_controls), name='u_bar') # Previous SCP Control
 
 ```
 
@@ -62,11 +64,11 @@ The discretized dynamics matrices are defined as follows:
 ```python
 
 # Discretized Augmented Dynamics Constraints
-A_d = cp.Parameter((params.scp.n - 1, params.sim.n_states, params.sim.n_states)), name='A_d')
-B_d = cp.Parameter((params.scp.n - 1, params.sim.n_states, params.sim.n_controls), name='B_d')
-C_d = cp.Parameter((params.scp.n - 1, params.sim.n_states, params.sim.n_controls), name='C_d')
-z_d = cp.Parameter((params.scp.n - 1, params.sim.n_states), name='z_d') # Nonlinear Propagation Defect
-nu  = cp.Variable((params.scp.n - 1, params.sim.n_states), name='nu')  # Virtual Control Slack Variable
+A_d = cp.Parameter((params.sim.n - 1, params.sim.n_states, params.sim.n_states)), name='A_d')
+B_d = cp.Parameter((params.sim.n - 1, params.sim.n_states, params.sim.n_controls), name='B_d')
+C_d = cp.Parameter((params.sim.n - 1, params.sim.n_states, params.sim.n_controls), name='C_d')
+z_d = cp.Parameter((params.sim.n - 1, params.sim.n_states), name='z_d') # Nonlinear Propagation Defect
+nu  = cp.Variable((params.sim.n - 1, params.sim.n_states), name='nu')  # Virtual Control Slack Variable
 
 ```
 
@@ -82,10 +84,10 @@ The nonconvex nodal parameters and variables are instantiated using the followin
         nu_vb = []
         for idx_ncvx, constraint in enumerate(params.sim.constraints_nodal):
             if not constraint.convex:
-                g.append(cp.Parameter(params.scp.n, name = 'g_' + str(idx_ncvx)))
-                grad_g_x.append(cp.Parameter((params.scp.n, params.sim.n_states), name='grad_g_x_' + str(idx_ncvx)))
-                grad_g_u.append(cp.Parameter((params.scp.n, params.sim.n_controls), name='grad_g_u_' + str(idx_ncvx)))
-                nu_vb.append(cp.Variable(params.scp.n, name='nu_vb_' + str(idx_ncvx))) # Virtual Control for VB
+                g.append(cp.Parameter(params.sim.n, name = 'g_' + str(idx_ncvx)))
+                grad_g_x.append(cp.Parameter((params.sim.n, params.sim.n_states), name='grad_g_x_' + str(idx_ncvx)))
+                grad_g_u.append(cp.Parameter((params.sim.n, params.sim.n_controls), name='grad_g_u_' + str(idx_ncvx)))
+                nu_vb.append(cp.Variable(params.sim.n, name='nu_vb_' + str(idx_ncvx))) # Virtual Control for VB
 ```
 
 
@@ -99,11 +101,13 @@ def OptimalControlProblem(params: Config):
     # Parameters
     lam_prox = cp.Parameter(nonneg = True, name='lam_prox')
     lam_cost = cp.Parameter(nonneg=True, name='lam_cost')
+    lam_vc = cp.Parameter((params.sim.n - 1, params.sim.n_states), nonneg=True, name='lam_vc')
+    lam_vb = cp.Parameter(nonneg=True, name='lam_vb')
 
     # State
-    x = cp.Variable((params.scp.n, params.sim.n_states), name='x') 
-    dx = cp.Variable((params.scp.n, params.sim.n_states), name='dx') # State Trust Region
-    x_bar = cp.Parameter((params.scp.n, params.sim.n_states), name='x_bar') # Previous SCP State
+    x = cp.Variable((params.sim.n, params.sim.n_states), name='x') 
+    dx = cp.Variable((params.sim.n, params.sim.n_states), name='dx') # State Trust Region
+    x_bar = cp.Parameter((params.sim.n, params.sim.n_states), name='x_bar') # Previous SCP State
 
     # Affine Scaling for State
     S_x = params.sim.S_x
@@ -111,9 +115,9 @@ def OptimalControlProblem(params: Config):
     c_x = params.sim.c_x
 
     # Control
-    u = cp.Variable((params.scp.n, params.sim.n_controls), name='u') 
-    du = cp.Variable((params.scp.n, params.sim.n_controls), name='du') # Control Trust Region
-    u_bar = cp.Parameter((params.scp.n, params.sim.n_controls), name='u_bar') # Previous SCP Control
+    u = cp.Variable((params.sim.n, params.sim.n_controls), name='u') 
+    du = cp.Variable((params.sim.n, params.sim.n_controls), name='du') # Control Trust Region
+    u_bar = cp.Parameter((params.sim.n, params.sim.n_controls), name='u_bar') # Previous SCP Control
 
     # Affine Scaling for Control
     S_u = params.sim.S_u
@@ -121,11 +125,11 @@ def OptimalControlProblem(params: Config):
     c_u = params.sim.c_u
 
     # Discretized Augmented Dynamics Constraints
-    A_d = cp.Parameter((params.scp.n - 1, params.sim.n_states, params.sim.n_states), name='A_d')
-    B_d = cp.Parameter((params.scp.n - 1, params.sim.n_states, params.sim.n_controls), name='B_d')
-    C_d = cp.Parameter((params.scp.n - 1, params.sim.n_states, params.sim.n_controls), name='C_d')
-    z_d = cp.Parameter((params.scp.n - 1, params.sim.n_states), name='z_d')
-    nu  = cp.Variable((params.scp.n - 1, params.sim.n_states), name='nu') # Virtual Control
+    A_d = cp.Parameter((params.sim.n - 1, params.sim.n_states, params.sim.n_states), name='A_d')
+    B_d = cp.Parameter((params.sim.n - 1, params.sim.n_states, params.sim.n_controls), name='B_d')
+    C_d = cp.Parameter((params.sim.n - 1, params.sim.n_states, params.sim.n_controls), name='C_d')
+    z_d = cp.Parameter((params.sim.n - 1, params.sim.n_states), name='z_d')
+    nu  = cp.Variable((params.sim.n - 1, params.sim.n_states), name='nu') # Virtual Control
 
     # Linearized Nonconvex Nodal Constraints
     if params.sim.constraints_nodal:
@@ -135,15 +139,15 @@ def OptimalControlProblem(params: Config):
         nu_vb = []
         for idx_ncvx, constraint in enumerate(params.sim.constraints_nodal):
             if not constraint.convex:
-                g.append(cp.Parameter(params.scp.n, name = 'g_' + str(idx_ncvx)))
-                grad_g_x.append(cp.Parameter((params.scp.n, params.sim.n_states), name='grad_g_x_' + str(idx_ncvx)))
-                grad_g_u.append(cp.Parameter((params.scp.n, params.sim.n_controls), name='grad_g_u_' + str(idx_ncvx)))
-                nu_vb.append(cp.Variable(params.scp.n, name='nu_vb_' + str(idx_ncvx))) # Virtual Control for VB
+                g.append(cp.Parameter(params.sim.n, name = 'g_' + str(idx_ncvx)))
+                grad_g_x.append(cp.Parameter((params.sim.n, params.sim.n_states), name='grad_g_x_' + str(idx_ncvx)))
+                grad_g_u.append(cp.Parameter((params.sim.n, params.sim.n_controls), name='grad_g_u_' + str(idx_ncvx)))
+                nu_vb.append(cp.Variable(params.sim.n, name='nu_vb_' + str(idx_ncvx))) # Virtual Control for VB
 
     # Applying the affine scaling to state and control
     x_nonscaled = []
     u_nonscaled = []
-    for k in range(params.scp.n):
+    for k in range(params.sim.n):
         x_nonscaled.append(S_x @ x[k] + c_x)
         u_nonscaled.append(S_u @ u[k] + c_u)
 
@@ -157,7 +161,7 @@ def OptimalControlProblem(params: Config):
     if params.sim.constraints_nodal:
         for constraint in params.sim.constraints_nodal:
             if constraint.nodes is None:
-                nodes = range(params.scp.n)
+                nodes = range(params.sim.n)
             else:
                 nodes = constraint.nodes
 
@@ -182,38 +186,38 @@ def OptimalControlProblem(params: Config):
         if params.sim.final_state.type[i] == 'Maximize':
             cost += lam_cost * x_nonscaled[-1][i]
 
-    if params.scp.uniform_time_grid:
-        constr += [x_nonscaled[i][params.sim.idx_t] - x_nonscaled[i-1][params.sim.idx_t] == x_nonscaled[i-1][params.sim.idx_t] - x_nonscaled[i-2][params.sim.idx_t] for i in range(2, params.scp.n)] # Uniform Time Step
+    if params.sim._uniform_time_grid:
+        constr += [x_nonscaled[i][params.sim.idx_t] - x_nonscaled[i-1][params.sim.idx_t] == x_nonscaled[i-1][params.sim.idx_t] - x_nonscaled[i-2][params.sim.idx_t] for i in range(2, params.sim.n)] # Uniform Time Step
 
-    constr += [0 == la.inv(S_x) @ (x_nonscaled[i] - x_bar[i] - dx[i]) for i in range(params.scp.n)] # State Error
-    constr += [0 == la.inv(S_u) @ (u_nonscaled[i] - u_bar[i] - du[i]) for i in range(params.scp.n)] # Control Error
+    constr += [0 == la.inv(S_x) @ (x_nonscaled[i] - x_bar[i] - dx[i]) for i in range(params.sim.n)] # State Error
+    constr += [0 == la.inv(S_u) @ (u_nonscaled[i] - u_bar[i] - du[i]) for i in range(params.sim.n)] # Control Error
 
     constr += [x_nonscaled[i] == \
                       A_d[i-1] @ x_nonscaled[i-1] \
                     + B_d[i-1] @ u_nonscaled[i-1] \
                     + C_d[i-1] @ u_nonscaled[i] \
                     + z_d[i-1] \
-                    + nu[i-1] for i in range(1, params.scp.n)] # Dynamics Constraint
+                    + nu[i-1] for i in range(1, params.sim.n)] # Dynamics Constraint
     
-    constr += [u_nonscaled[i] <= params.sim.max_control for i in range(params.scp.n)]
-    constr += [u_nonscaled[i] >= params.sim.min_control for i in range(params.scp.n)] # Control Constraints
+    constr += [u_nonscaled[i] <= params.sim.max_control for i in range(params.sim.n)]
+    constr += [u_nonscaled[i] >= params.sim.min_control for i in range(params.sim.n)] # Control Constraints
 
-    constr += [x_nonscaled[i][params.sim.idx_x_true] <= params.sim.max_state[params.sim.idx_x_true] for i in range(params.scp.n)]
-    constr += [x_nonscaled[i][params.sim.idx_x_true] >= params.sim.min_state[params.sim.idx_x_true] for i in range(params.scp.n)] # State Constraints (Also implemented in CTCS but included for numerical stability)
+    constr += [x_nonscaled[i][params.sim.idx_x_true] <= params.sim.max_state[params.sim.idx_x_true] for i in range(params.sim.n)]
+    constr += [x_nonscaled[i][params.sim.idx_x_true] >= params.sim.min_state[params.sim.idx_x_true] for i in range(params.sim.n)] # State Constraints (Also implemented in CTCS but included for numerical stability)
 
     ########
     # COSTS
     ########
     
     inv = block([[inv_S_x, np.zeros((S_x.shape[0], S_u.shape[1]))], [np.zeros((S_u.shape[0], S_x.shape[1])), inv_S_u]])
-    cost += sum(lam_prox * cp.sum_squares(inv @ cp.hstack((dx[i], du[i]))) for i in range(params.scp.n))  # Trust Region Cost
-    cost += sum(params.scp.lam_vc * cp.sum(cp.abs(nu[i-1])) for i in range(1, params.scp.n)) # Virtual Control Slack
+    cost += sum(lam_prox * cp.sum_squares(inv @ cp.hstack((dx[i], du[i]))) for i in range(params.sim.n))  # Trust Region Cost
+    cost += sum(lam_vc * cp.sum(cp.abs(nu[i-1])) for i in range(1, params.sim.n)) # Virtual Control Slack
     
     idx_ncvx = 0
     if params.sim.constraints_nodal:
         for constraint in params.sim.constraints_nodal:
             if not constraint.convex:
-                cost += params.scp.lam_vb * cp.sum(cp.pos(nu_vb[idx_ncvx]))
+                cost += lam_vb * cp.sum(cp.pos(nu_vb[idx_ncvx]))
                 idx_ncvx += 1
 
     for idx, nodes in zip(np.arange(params.sim.idx_y.start, params.sim.idx_y.stop), params.sim.ctcs_node_intervals):  
@@ -229,15 +233,15 @@ def OptimalControlProblem(params: Config):
     # PROBLEM
     #########
     prob = cp.Problem(cp.Minimize(cost), constr)
-    if params.cvx.cvxpygen:
+    if solver.cvxpygen:
         # Check to see if solver directory exists
         if not os.path.exists('solver'):
-            cpg.generate_code(prob, solver = params.cvx.solver, code_dir='solver', wrapper = True)
+            cpg.generate_code(prob, solver = solver.cvx_solver, code_dir='solver', wrapper = True)
         else:
             # Prompt the use to indicate if they wish to overwrite the solver directory or use the existing compiled solver
             overwrite = input("Solver directory already exists. Overwrite? (y/n): ")
             if overwrite.lower() == 'y':
-                cpg.generate_code(prob, solver = params.cvx.solver, code_dir='solver', wrapper = True)
+                cpg.generate_code(prob, solver = solver.cvx_solver, code_dir='solver', wrapper = True)
             else:
                 pass
     return prob

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/docs/UsersGuide/03_obstacle_avoidance_vmap.md

@@ -235,6 +235,8 @@ These are continuous-time constraints (CTCS), so the drone avoids obstacles not
 
 ### Problem Setup
 
+The SCP algorithm has several tuning parameters that affect convergence. These can be passed directly to the `Problem` constructor via the `algorithm` argument. For this obstacle avoidance problem:
+
 ```python
 time = ox.Time(
     initial=0.0,
@@ -250,21 +252,15 @@ problem = ox.Problem(
     time=time,
     constraints=constraints,
     N=n,
-)
-```
-
-### Solver Settings
-
-The SCP algorithm has several tuning parameters that affect convergence. For this obstacle avoidance problem:
-
-```python
-problem.settings.scp.lam_prox = 1e1        # Trust region weight
-problem.settings.scp.lam_cost = 1e1    # Cost objective weight
-problem.settings.scp.lam_vc = 1e2      # Virtual control weight
-# Configure cost relaxation via autotuner
-problem.settings.scp.autotuner = ox.AugmentedLagrangian(
-    lam_cost_drop=4,     # Iteration to start relaxing cost
-    lam_cost_relax=0.5  # Cost relaxation factor
+    algorithm={
+        "lam_prox": 1e1,       # Trust region weight
+        "lam_cost": 1e1,       # Cost objective weight
+        "lam_vc": 1e2,         # Virtual control weight
+        "autotuner": ox.AugmentedLagrangian(
+            lam_cost_drop=4,     # Iteration to start relaxing cost
+            lam_cost_relax=0.5,  # Cost relaxation factor
+        ),
+    },
 )
 ```
 
@@ -382,17 +378,17 @@ while running:
 
 Parameter updates take effect immediately on the next `step()` call without any recompilation.
 
-### Adjusting Solver Settings
+### Adjusting Algorithm Weights
 
 You can also adjust SCP weights at runtime to change solver behavior:
 
 ```python
 # Increase cost weight as solution converges
 if step_result.J_vc < 1e-4:
-    problem.settings.scp.lam_cost *= 1.1
+    problem.algorithm.lam_cost *= 1.1
 
 # Tighten trust region if solution is oscillating
-problem.settings.scp.lam_prox = 2.0
+problem.algorithm.lam_prox = 2.0
 ```
 
 ### Resetting the Problem

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/docs/UsersGuide/04_viewpoint_constraints.md

@@ -325,16 +325,15 @@ problem = ox.Problem(
     time=time,
     constraints=constraints,
     N=n,
-)
-
-# Tuning for this problem
-problem.settings.scp.lam_prox = 2e0
-problem.settings.scp.lam_cost = 1e-1
-problem.settings.scp.lam_vc = 1e2
-# Configure cost relaxation via autotuner
-problem.settings.scp.autotuner = ox.AugmentedLagrangian(
-    lam_cost_drop=10,
-    lam_cost_relax=0.8
+    algorithm={
+        "lam_prox": 2e0,
+        "lam_cost": 1e-1,
+        "lam_vc": 1e2,
+        "autotuner": ox.AugmentedLagrangian(
+            lam_cost_drop=10,
+            lam_cost_relax=0.8,
+        ),
+    },
 )
 
 problem.initialize()

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/abstract/brachistochrone.py

@@ -74,6 +74,7 @@ time = ox.Time(
     final=("minimize", total_time),
     min=0.0,
     max=total_time,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -84,16 +85,15 @@ problem = Problem(
     constraints=constraint_exprs,
     N=n,
     licq_max=1e-8,
-    autotuner=ox.ConstantProximalWeight(),
+    algorithm={
+        "autotuner": "ConstantProximalWeight",
+        "lam_prox": 1e1,
+        "lam_cost": 1e0,
+    },
 )
 
 problem.settings.prp.dt = 0.01
 
-problem.settings.scp.lam_prox = 1e1  # Weight on the Trust Reigon
-problem.settings.scp.lam_cost = 1e0  # Weight on the Minimal Time Objective
-problem.settings.scp.uniform_time_grid = True
-
-
 plotting_dict = {}
 
 if __name__ == "__main__":

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/arm/three_link_arm.py

@@ -201,11 +201,11 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={"lam_vb": 1e1},
 )
 
 # Solver settings
 problem.settings.prp.dt = 0.01
-problem.settings.scp.lam_vb = 1e1
 
 if __name__ == "__main__":
     print("3-Link Arm Trajectory Optimization with Product of Exponentials FK")

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/car/dubins_car.py

@@ -86,6 +86,8 @@ time = ox.Time(
     final=ox.Minimize(total_time),
     min=0.0,
     max=20,
+    time_dilation_min=0.02 * total_time,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -96,14 +98,9 @@ problem = Problem(
     constraints=constraints,
     N=n,
     licq_max=1e-8,
-    time_dilation_factor_min=0.02,
+    algorithm={"lam_cost": 4e1, "lam_vc": 1e3},
 )
 
-# Set solver parameters
-problem.settings.scp.lam_cost = 4e1
-problem.settings.scp.lam_vc = 1e3
-problem.settings.scp.uniform_time_grid = True
-
 plotting_dict = {
     "obs_radius": problem.parameters["obs_radius"],
     "obs_center": problem.parameters["obs_center"],
@@ -121,7 +118,7 @@ if __name__ == "__main__":
     problem.reset()
     problem.parameters["obs_center"] = np.array([0.5, 0.0])
     total_time = 0.7  # Adjust total time for second run
-    problem.settings.scp.lam_vc = 1e2  # Adjust virtual control weight
+    problem.algorithm.lam_vc = 1e2  # Adjust virtual control weight
     position.guess = np.linspace([0, -2], [0, 2], n)
     theta.guess = np.zeros((n, 1))
     speed.guess = np.zeros((n, 1))

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/car/dubins_car_conditional.py

@@ -99,6 +99,7 @@ time = ox.Time(
     final=ox.Minimize(total_time),
     min=0.0,
     max=20,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -109,13 +110,9 @@ problem = Problem(
     constraints=constraints,
     N=n,
     licq_max=1e-6,
+    algorithm={"lam_vc": 1e3},
 )
 
-# Set solver parameters
-problem.settings.scp.lam_vc = 1e3
-problem.settings.scp.uniform_time_grid = True
-
-
 plotting_dict = {
     "obs_radius": problem.parameters["obs_radius"],
     "obs_center": problem.parameters["obs_center"],

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/car/dubins_car_disjoint.py

@@ -102,6 +102,7 @@ time = ox.Time(
     final=("minimize", total_time),
     min=0.0,
     max=20,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -111,10 +112,9 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={"lam_vc": 6e2},
 )
-# Set solver parameters
-problem.settings.scp.lam_vc = 6e2
-problem.settings.scp.uniform_time_grid = True
+
 plotting_dict = {
     "wp1_radius": problem.parameters["wp1_radius"],
     "wp1_center": problem.parameters["wp1_center"],

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/car/dubins_car_stljax.py

@@ -57,7 +57,9 @@ angular_rate.guess = np.zeros((n, 1))
 
 # Define time (needed for time-dependent constraints)
 # Time is a State subclass, so it can be used directly in expressions
-time = ox.Time(initial=0.0, final=("minimize", total_time), min=0.0, max=10.0)
+time = ox.Time(
+    initial=0.0, final=("minimize", total_time), min=0.0, max=10.0, uniform_time_grid=True
+)
 
 
 # Define list of all states and controls
@@ -103,10 +105,9 @@ problem = Problem(
     time=time,  # Time is already defined above as ox.Time
     constraints=constraints,
     N=n,
+    algorithm={"lam_vc": 6e2},
 )
-# Set solver parameters
-problem.settings.scp.lam_vc = 6e2
-problem.settings.scp.uniform_time_grid = True
+
 # Extract parameter values from problem.parameters (not Parameter objects)
 plotting_dict = {
     "wp1_center": problem.parameters.get("wp1_center", None),

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/cinema_vp.py

@@ -235,12 +235,9 @@ problem = Problem(
     constraints=constraints,
     N=n,
     licq_max=1e-8,
+    algorithm={"lam_prox": 4e0, "ep_tr": 1e-6},
 )
 
-
-problem.settings.scp.lam_prox = 4e0  # Weight on the Trust Reigon
-problem.settings.scp.ep_tr = 1e-6  # Trust Region Tolerance
-
 plotting_dict = {
     "n_subs": n_subs,
     "alpha_x": alpha_x,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/dr_double_integrator.py

@@ -135,10 +135,9 @@ problem = Problem(
     time=t,
     constraints=constraint_exprs,
     N=n,
+    algorithm={"ep_tr": 1e-3},
 )
 
-problem.settings.scp.ep_tr = 1e-3  # Trust Region Tolerance
-
 plotting_dict = {"vertices": vertices}
 
 if __name__ == "__main__":

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/dr_vp.py

@@ -224,10 +224,9 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={"ep_tr": 1e-3},
 )
 
-problem.settings.scp.ep_tr = 1e-3  # Trust Region Tolerance
-
 plotting_dict = {
     "vertices": vertices,
     "n_subs": n_subs,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/dr_vp_nodal.py

@@ -225,15 +225,15 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={
+        "lam_prox": 8e1,
+        "lam_cost": 2e1,
+        "lam_vc": 1e2,
+        "lam_vb": 4e0,
+        "ep_tr": 1e-3,
+    },
 )
 
-
-problem.settings.scp.lam_prox = 8e1  # Weight on the Trust Reigon
-problem.settings.scp.lam_cost = 2e1  # Weight on the Minimal Time Objective
-problem.settings.scp.lam_vc = 1e2  # Weight on the Virtual Control Objective
-problem.settings.scp.lam_vb = 4e0  # Weight on the Virtual Buffer Objective
-problem.settings.scp.ep_tr = 1e-3  # Trust Region Tolerance
-
 plotting_dict = {
     "vertices": vertices,
     "n_subs": n_subs,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/dr_vp_polytope.py

@@ -241,13 +241,9 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={"lam_prox": 2e0, "lam_vc": 4e1, "ep_tr": 1e-5},
 )
 
-problem.settings.scp.lam_prox = 2e0  # Weight on the Trust Reigon
-problem.settings.scp.lam_vc = 4e1  # Weight on the Virtual Control Objective
-
-problem.settings.scp.ep_tr = 1e-5  # Trust Region Tolerance
-
 plotting_dict = {
     "vertices": vertices,
     "n_subs": n_subs,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/drone_racing.py

@@ -179,11 +179,10 @@ problem = Problem(
     constraints=constraints,
     N=n,
     # licq_max=1E-8
+    algorithm={"ep_tr": 1e-3},
 )
 
-problem.settings.scp.ep_tr = 1e-3  # Trust Region Tolerance
-
-problem.settings.cvx.solver_args = {"abstol": 1e-6, "reltol": 1e-9}
+problem.solver.solver_args = {"abstol": 1e-6, "reltol": 1e-9}
 plotting_dict = {
     "vertices": vertices,
     "gate_centers": modified_centers,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/logo.py

@@ -127,6 +127,8 @@ time_state = ox.Time(
     final=total_time,
     min=0.0,
     max=total_time,
+    time_dilation_min=0.001 * total_time,
+    time_dilation_max=3.0 * total_time,
 )
 
 # Control components
@@ -353,20 +355,15 @@ problem = Problem(
     constraints=constraints,
     N=n,
     byof=byof,
-    time_dilation_factor_min=0.001,
-    time_dilation_factor_max=3.0,
-    autotuner=ox.RampProximalWeight(),
+    algorithm={
+        "autotuner": {"type": "RampProximalWeight", "ramp_factor": 1.06, "lam_prox_max": 1e3},
+        "lam_vc": 1e3,
+        "lam_cost": 6e0,
+    },
     float_dtype="float64",
+    solver={"solver_args": {"canon_backend": "COO", "enforce_dpp": True}},
 )
 
-# problem.settings.scp.ep_tr = 1.6e-3
-problem.settings.scp.autotuner.ramp_factor = 1.06
-problem.settings.scp.autotuner.lam_prox_max = 1e3
-
-problem.settings.scp.lam_vc = 1e3
-problem.settings.scp.lam_cost = 6e0
-problem.settings.cvx.solver_args = {"canon_backend": "COO", "enforce_dpp": True}
-
 
 plotting_dict = {
     "svg_path_function": svg_path_function,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/obstacle_avoidance_nodal.py

@@ -150,10 +150,9 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={"lam_vb": 1e0},
 )
 
-problem.settings.scp.lam_vb = 1e0
-
 plotting_dict = {
     "obstacles_centers": obstacle_center_positions,
     "obstacles_axes": axes,

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/drone/obstacle_avoidance_vmap.py

@@ -173,10 +173,9 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
+    algorithm={"ep_tr": 1e-3},
 )
 
-problem.settings.scp.ep_tr = 1e-3
-
 # =============================================================================
 # Solve and Visualize
 # =============================================================================

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev117}/examples/realtime/base_problems/cinema_vp_realtime_base.py

@@ -197,18 +197,16 @@ problem = Problem(
     constraints=constraints,
     N=n,
     licq_max=1e-8,
+    algorithm={
+        "lam_prox": 4e0,
+        "lam_cost": 1e-2,
+        "lam_vc": 1e1,
+        "ep_tr": 1e-6,
+        "ep_vb": 1e-4,
+        "ep_vc": 1e-8,
+    },
 )
 
-problem.settings.scp.lam_prox = 4e0  # Weight on the Trust Region
-problem.settings.scp.lam_cost = 1e-2  # Weight on the Minimal Fuel Objective
-problem.settings.scp.lam_vc = 1e1  # Weight on the Virtual Control Objective
-
-problem.settings.scp.ep_tr = 1e-6  # Trust Region Tolerance
-problem.settings.scp.ep_vb = 1e-4  # Virtual Control Tolerance
-problem.settings.scp.ep_vc = 1e-8  # Virtual Control Tolerance for CTCS
-problem.settings.scp.lam_prox_adapt = 1.3  # Trust Region Adaptation Factor
-problem.settings.scp.lam_prox_max_scaling_factor = 1e3  # Maximum Trust Region Weight
-
 plotting_dict = {
     "n_subs": n_subs,
     "alpha_x": alpha_x,