openscvx 0.3.2.dev339__tar.gz → 0.3.2.dev343__tar.gz

{openscvx-0.3.2.dev339/openscvx.egg-info → openscvx-0.3.2.dev343}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev339
+Version: 0.3.2.dev343
 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
@@ -10,7 +10,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cvxpy>=1.6
+Requires-Dist: cvxpy==1.7.5
 Requires-Dist: qoco
 Requires-Dist: numpy
 Requires-Dist: jax

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/docs/Foundations/ocp.md

@@ -14,7 +14,7 @@ The state, constrol and additional parameters are defined as follows:
 
 ```python
 
-w_tr = cp.Parameter(nonneg = True, name='w_tr')       # Weight on the Trust Region
+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
 
 x = cp.Variable((params.scp.n, params.sim.n_states), name='x')   # State
@@ -97,7 +97,7 @@ def OptimalControlProblem(params: Config):
     ########################
 
     # Parameters
-    w_tr = cp.Parameter(nonneg = True, name='w_tr')
+    lam_prox = cp.Parameter(nonneg = True, name='lam_prox')
     lam_cost = cp.Parameter(nonneg=True, name='lam_cost')
 
     # State
@@ -206,7 +206,7 @@ def OptimalControlProblem(params: Config):
     ########
     
     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(w_tr * cp.sum_squares(inv @ cp.hstack((dx[i], du[i]))) for i in range(params.scp.n))  # Trust Region Cost
+    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
     
     idx_ncvx = 0

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/docs/UsersGuide/03_obstacle_avoidance_vmap.md

@@ -258,11 +258,14 @@ problem = ox.Problem(
 The SCP algorithm has several tuning parameters that affect convergence. For this obstacle avoidance problem:
 
 ```python
-problem.settings.scp.w_tr = 1e1        # Trust region weight
+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
-problem.settings.scp.cost_drop = 4     # Iteration to start relaxing cost
-problem.settings.scp.cost_relax = 0.5  # Cost relaxation factor
+# 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
+)
 ```
 
 ### Solution
@@ -389,7 +392,7 @@ if step_result.J_vc < 1e-4:
     problem.settings.scp.lam_cost *= 1.1
 
 # Tighten trust region if solution is oscillating
-problem.settings.scp.w_tr = 2.0
+problem.settings.scp.lam_prox = 2.0
 ```
 
 ### Resetting the Problem

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/docs/UsersGuide/04_viewpoint_constraints.md

@@ -328,11 +328,14 @@ problem = ox.Problem(
 )
 
 # Tuning for this problem
-problem.settings.scp.w_tr = 2e0
+problem.settings.scp.lam_prox = 2e0
 problem.settings.scp.lam_cost = 1e-1
 problem.settings.scp.lam_vc = 1e2
-problem.settings.scp.cost_drop = 10
-problem.settings.scp.cost_relax = 0.8
+# Configure cost relaxation via autotuner
+problem.settings.scp.autotuner = ox.AugmentedLagrangian(
+    lam_cost_drop=10,
+    lam_cost_relax=0.8
+)
 
 problem.initialize()
 results = problem.solve()

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/abstract/brachistochrone.py

@@ -84,20 +84,15 @@ problem = Problem(
     constraints=constraint_exprs,
     N=n,
     licq_max=1e-8,
+    autotuner=ox.ConstantProximalWeight(),
 )
 
 problem.settings.prp.dt = 0.01
 
-# problem.settings.cvx.solver = "qocogen"
-# problem.settings.cvx.cvxpygen = True
-problem.settings.cvx.solver_args = {"abstol": 1e-6, "reltol": 1e-9}
-
-problem.settings.scp.w_tr = 1e1  # Weight on the Trust Reigon
+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.lam_vc = 1e1  # Weight on the Virtual Control Objective
 problem.settings.scp.uniform_time_grid = True
 
-problem.settings.sim.save_compiled = False
 
 plotting_dict = {}
 

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/arm/three_link_arm.py

@@ -28,7 +28,7 @@ sys.path.append(grandparent_dir)
 
 import openscvx as ox
 from openscvx import Problem
-from openscvx.plotting import plot_scp_iterations
+from openscvx.plotting import plot_scp_convergence_histories, plot_scp_iterations
 
 # =============================================================================
 # Robot Parameters
@@ -205,9 +205,6 @@ problem = Problem(
 
 # Solver settings
 problem.settings.prp.dt = 0.01
-problem.settings.scp.w_tr = 1e0
-problem.settings.scp.lam_cost = 1e0
-problem.settings.scp.lam_vc = 1e1
 problem.settings.scp.lam_vb = 1e1
 
 if __name__ == "__main__":
@@ -243,7 +240,7 @@ if __name__ == "__main__":
         return T_final[:3, 3]
 
     plot_scp_iterations(results).show()
-
+    plot_scp_convergence_histories(results).show()
     tgt = target.value
     final_ee = compute_ee_position(final_q)
     error = np.linalg.norm(final_ee - tgt)

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/car/dubins_car.py

@@ -100,22 +100,10 @@ problem = Problem(
 )
 
 # Set solver parameters
-problem.settings.prp.dt = 0.01
-# problem.settings.scp.w_tr_adapt = 1.3
-problem.settings.scp.w_tr = 1e0
 problem.settings.scp.lam_cost = 4e1
 problem.settings.scp.lam_vc = 1e3
 problem.settings.scp.uniform_time_grid = True
 
-# Enable CLI printing for optimization iterations
-problem.settings.dev.printing = True
-
-# problem.settings.cvx.cvxpygen = True
-# problem.settings.cvx.solver = "qocogen"
-problem.settings.cvx.solver_args = {}
-# problem.settings.cvx.cvxpygen_override = True
-
-
 plotting_dict = {
     "obs_radius": problem.parameters["obs_radius"],
     "obs_center": problem.parameters["obs_center"],
@@ -130,10 +118,9 @@ if __name__ == "__main__":
     plot_dubins_car(results, problem.settings).show()
 
     # Second run with different parameters
+    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_cost = 1e-1  # Disable minimal time objective for second run
-    problem.settings.scp.w_tr = 1e0
     problem.settings.scp.lam_vc = 1e2  # Adjust virtual control weight
     position.guess = np.linspace([0, -2], [0, 2], n)
     theta.guess = np.zeros((n, 1))

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/car/dubins_car_conditional.py

@@ -27,7 +27,7 @@ from examples.plotting import plot_dubins_car, plot_velocity_vs_distance
 from openscvx import Problem
 
 n = 8
-total_time = 2.0  # Total simulation time
+total_time = 3.0  # Total simulation time
 
 # Define state components
 position = ox.State("position", shape=(2,))  # 2D position [x, y]
@@ -112,10 +112,6 @@ problem = Problem(
 )
 
 # Set solver parameters
-problem.settings.scp.w_tr = 1e0
-problem.settings.scp.w_tr_adapt = 1.1
-problem.settings.scp.w_tr_max_scaling_factor = 1e2
-problem.settings.scp.lam_cost = 1e0
 problem.settings.scp.lam_vc = 1e3
 problem.settings.scp.uniform_time_grid = True
 

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/car/dubins_car_disjoint.py

@@ -113,10 +113,6 @@ problem = Problem(
     N=n,
 )
 # Set solver parameters
-problem.settings.prp.dt = 0.01
-problem.settings.scp.w_tr_adapt = 1.1
-problem.settings.scp.w_tr = 1e0
-problem.settings.scp.lam_cost = 1e-1
 problem.settings.scp.lam_vc = 6e2
 problem.settings.scp.uniform_time_grid = True
 plotting_dict = {

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/car/dubins_car_stljax.py

@@ -105,10 +105,6 @@ problem = Problem(
     N=n,
 )
 # Set solver parameters
-problem.settings.prp.dt = 0.01
-problem.settings.scp.w_tr_adapt = 1.1
-problem.settings.scp.w_tr = 1e0
-problem.settings.scp.lam_cost = 1e-1
 problem.settings.scp.lam_vc = 6e2
 problem.settings.scp.uniform_time_grid = True
 # Extract parameter values from problem.parameters (not Parameter objects)

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/cinema_vp.py

@@ -238,15 +238,8 @@ problem = Problem(
 )
 
 
-problem.settings.scp.w_tr = 4e0  # Weight on the Trust Reigon
-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.lam_prox = 4e0  # Weight on the Trust Reigon
 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.w_tr_adapt = 1.3  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e3  # Maximum Trust Region Weight
 
 plotting_dict = {
     "n_subs": n_subs,

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/dr_double_integrator.py

@@ -137,21 +137,7 @@ problem = Problem(
     N=n,
 )
 
-problem.settings.prp.dt = 0.01
-problem.settings.dis.custom_integrator = True
-
-problem.settings.scp.w_tr = 2e0  # Weight on the Trust Reigon
-problem.settings.scp.lam_cost = 1e-1  # 0e-1,  # Weight on the Minimal Time Objective
-problem.settings.scp.lam_vc = (
-    1e1  # 1e1,  # Weight on the Virtual Control Objective (not including CTCS Augmentation)
-)
 problem.settings.scp.ep_tr = 1e-3  # 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.cost_drop = 10  # SCP iteration to relax minimal final time objective
-problem.settings.scp.cost_relax = 0.8  # Minimal Time Relaxation Factor
-problem.settings.scp.w_tr_adapt = 1.4  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e2  # Maximum Trust Region Weight
 
 plotting_dict = {"vertices": vertices}
 

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/dr_vp.py

@@ -226,21 +226,7 @@ problem = Problem(
     N=n,
 )
 
-problem.settings.prp.dt = 0.01
-
-
-problem.settings.scp.w_tr = 2e0  # Weight on the Trust Reigon
-problem.settings.scp.lam_cost = 1e-1  # 0e-1,  # Weight on the Minimal Time Objective
-problem.settings.scp.lam_vc = (
-    1e2  # 1e1,  # Weight on the Virtual Control Objective (not including CTCS Augmentation)
-)
 problem.settings.scp.ep_tr = 1e-3  # Trust Region Tolerance
-problem.settings.scp.ep_vb = 1e-4  # Virtual Control Tolerance
-problem.settings.scp.ep_vc = 1e-8  # Virtual Control Tolerance
-problem.settings.scp.cost_drop = 10  # SCP iteration to relax minimal final time objective
-problem.settings.scp.cost_relax = 0.8  # Minimal Time Relaxation Factor
-problem.settings.scp.w_tr_adapt = 1.4  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e2  # Maximum Trust Region Weight
 
 plotting_dict = {
     "vertices": vertices,

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/dr_vp_nodal.py

@@ -28,6 +28,7 @@ from examples.plotting_viser import (
     create_scp_animated_plotting_server,
 )
 from openscvx import Problem
+from openscvx.plotting import plot_scp_convergence_histories
 from openscvx.utils import gen_vertices, rot
 
 n = 33  # Number of Nodes
@@ -226,23 +227,12 @@ problem = Problem(
     N=n,
 )
 
-problem.settings.prp.dt = 0.1
 
-problem.settings.scp.w_tr = 8e1  # Weight on the Trust Reigon
+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 (not including CTCS Augmentation)
-)
-problem.settings.scp.lam_vb = (
-    4e0  # Weight on the Virtual Control Objective (not including CTCS Augmentation)
-)
+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
-problem.settings.scp.ep_vb = 1e-4  # Virtual Control Tolerance
-problem.settings.scp.ep_vc = 1e-8  # Virtual Control Tolerance
-problem.settings.scp.cost_drop = 10  # SCP iteration to relax minimal final time objective
-problem.settings.scp.cost_relax = 0.8  # Minimal Time Relaxation Factor
-problem.settings.scp.w_tr_adapt = 1.05  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e2  # Maximum Trust Region Weight
 
 plotting_dict = {
     "vertices": vertices,
@@ -261,6 +251,8 @@ if __name__ == "__main__":
 
     results.update_plotting_data(**plotting_dict)
 
+    plot_scp_convergence_histories(results).show()
+
     # Create both visualization servers (viser auto-assigns ports)
     traj_server = create_animated_plotting_server(
         results,

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/dr_vp_polytope.py

@@ -243,19 +243,11 @@ problem = Problem(
     N=n,
 )
 
-problem.settings.prp.dt = 0.01
-
-problem.settings.scp.w_tr = 2e0  # 2e0,  # Weight on the Trust Reigon
-problem.settings.scp.lam_cost = 2e-1  # 0e-1,  # Weight on the Minimal Time Objective
+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
-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.cost_drop = 10  # SCP iteration to relax minimal final time objective
-problem.settings.scp.cost_relax = 0.8  # Minimal Time Relaxation Factor
-problem.settings.scp.w_tr_adapt = 1.2  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e2  # Maximum Trust Region Weight
+
 plotting_dict = {
     "vertices": vertices,
     "n_subs": n_subs,
@@ -265,6 +257,7 @@ plotting_dict = {
     "init_poses": init_poses,
     "norm_type": norm_type,
 }
+
 if __name__ == "__main__":
     problem.initialize()
     results = problem.solve()

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/drone_racing.py

@@ -140,85 +140,11 @@ for node, gate_center_param in zip(gate_nodes, gate_center_params):
     )
     constraints.append(gate_constraint)
 
-
-# Define symbolic utility functions
-def symbolic_qdcm(q):
-    """Quaternion to Direction Cosine Matrix conversion using symbolic expressions"""
-    # Normalize quaternion
-    q_norm = ox.Sqrt(ox.Sum(q * q))
-    q_normalized = q / q_norm
-
-    w, x, y, z = q_normalized[0], q_normalized[1], q_normalized[2], q_normalized[3]
-
-    # Create DCM elements and assemble into 3x3 matrix
-    return ox.Block(
-        [
-            [1.0 - 2.0 * (y * y + z * z), 2.0 * (x * y - z * w), 2.0 * (x * z + y * w)],
-            [2.0 * (x * y + z * w), 1.0 - 2.0 * (x * x + z * z), 2.0 * (y * z - x * w)],
-            [2.0 * (x * z - y * w), 2.0 * (y * z + x * w), 1.0 - 2.0 * (x * x + y * y)],
-        ]
-    )
-
-
-def symbolic_ssmp(w):
-    """Angular rate to 4x4 skew symmetric matrix for quaternion dynamics"""
-    x, y, z = w[0], w[1], w[2]
-
-    return ox.Block(
-        [
-            [0.0, -x, -y, -z],
-            [x, 0.0, z, -y],
-            [y, -z, 0.0, x],
-            [z, y, -x, 0.0],
-        ]
-    )
-
-
-def symbolic_ssm(w):
-    """Angular rate to 3x3 skew symmetric matrix"""
-    x, y, z = w[0], w[1], w[2]
-
-    return ox.Block(
-        [
-            [0.0, -z, y],
-            [z, 0.0, -x],
-            [-y, x, 0.0],
-        ]
-    )
-
-
-def symbolic_diag(v):
-    """Create diagonal matrix from vector"""
-    if len(v) == 3:
-        return ox.Block(
-            [
-                [v[0], 0.0, 0.0],
-                [0.0, v[1], 0.0],
-                [0.0, 0.0, v[2]],
-            ]
-        )
-    else:
-        raise NotImplementedError("Only 3x3 diagonal matrices supported")
-
-
 # Create symbolic dynamics
 # Normalize quaternion for dynamics
 q_norm = ox.linalg.Norm(attitude)
 attitude_normalized = attitude / q_norm
 
-# Option 1: Full symbolic dynamics (more flexible but potentially slower)
-# r_dot = velocity
-# v_dot = (Constant(1.0 / m)) * symbolic_qdcm(attitude) @ thrust_force + Constant(
-#     np.array([0, 0, g_const], dtype=np.float64)
-# )
-# q_dot = Constant(0.5) * symbolic_ssmp(angular_velocity) @ attitude
-# J_b_inv = Constant(1.0 / J_b)
-# J_b_diag = symbolic_diag([Constant(J_b[0]), Constant(J_b[1]), Constant(J_b[2])])
-# w_dot = symbolic_diag([J_b_inv[0], J_b_inv[1], J_b_inv[2]]) @ (
-#     torque - symbolic_ssm(angular_velocity) @ J_b_diag @ angular_velocity
-# )
-
-# Option 2: Efficient dynamics using direct JAX lowering (better performance)
 J_b_inv = 1.0 / J_b
 J_b_diag = ox.linalg.Diag(J_b)
 
@@ -255,21 +181,9 @@ problem = Problem(
     # licq_max=1E-8
 )
 
-problem.settings.prp.dt = 0.01
-
-problem.settings.scp.w_tr = 2e0  # Weight on the Trust Reigon
-problem.settings.scp.lam_cost = 1e-1  # 0e-1,  # Weight on the Minimal Time Objective
-problem.settings.scp.lam_vc = (
-    1e1  # 1e1,  # Weight on the Virtual Control Objective (not including CTCS Augmentation)
-)
 problem.settings.scp.ep_tr = 1e-3  # 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.cost_drop = 10  # SCP iteration to relax minimal final time objective
-# problem.settings.scp.cost_relax = 0.8  # Minimal Time Relaxation Factor
-problem.settings.scp.w_tr_adapt = 1.4  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e2  # Maximum Trust Region Weight
 
+problem.settings.cvx.solver_args = {"abstol": 1e-6, "reltol": 1e-9}
 plotting_dict = {
     "vertices": vertices,
     "gate_centers": modified_centers,

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/obstacle_avoidance.py

@@ -154,15 +154,6 @@ problem = Problem(
     N=n,
 )
 
-problem.settings.prp.dt = 0.001
-problem.settings.scp.lam_vb = 1e0
-problem.settings.scp.w_tr_adapt = 1.8
-problem.settings.scp.w_tr = 1e1
-problem.settings.scp.lam_cost = 1e1  # Weight on the Nonlinear Cost
-problem.settings.scp.lam_vc = 1e2  # Weight on the Virtual Control Objective
-problem.settings.scp.cost_drop = 4  # SCP iteration to relax minimal final time objective
-problem.settings.scp.cost_relax = 0.5  # Minimal Time Relaxation Factor
-
 plotting_dict = {
     "obstacles_centers": obstacle_center_positions,
     "obstacles_axes": axes,

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/obstacle_avoidance_nodal.py

@@ -152,10 +152,7 @@ problem = Problem(
     N=n,
 )
 
-problem.settings.prp.dt = 0.01
 problem.settings.scp.lam_vb = 1e0
-problem.settings.scp.cost_drop = 4  # SCP iteration to relax minimal final time objective
-problem.settings.scp.cost_relax = 0.5  # Minimal Time Relaxation Factor
 
 plotting_dict = {
     "obstacles_centers": obstacle_center_positions,

{openscvx-0.3.2.dev339 → openscvx-0.3.2.dev343}/examples/drone/obstacle_avoidance_vmap.py

@@ -136,11 +136,6 @@ constraints.extend(
 # =============================================================================
 # Obstacle Avoidance
 # =============================================================================
-# Two approaches are shown below for benchmarking. Comment/uncomment to toggle.
-
-# --- APPROACH 1: Vmap (single constraint, vectorized) ---
-# - Single CTCS constraint with vectorized evaluation
-# - Vmap computes distance to all obstacles in parallel
 
 obstacle_avoidance = ox.ctcs(
     obstacle_radii
@@ -151,18 +146,6 @@ obstacle_avoidance = ox.ctcs(
 )
 constraints.append(obstacle_avoidance)
 
-# --- APPROACH 2: Individual constraints (loop, no vmap) ---
-# - Creates n_obstacles separate CTCS constraints
-# - Each constraint is lowered and traced independently
-
-# for i in range(n_obstacles):
-#     obs_center = obstacle_centers[i]
-#     radius = obstacle_radii[i]
-#     obstacle_constraint = ox.ctcs(
-#         radius <= ox.linalg.Norm(position - obs_center)
-#     )
-#     constraints.append(obstacle_constraint)
-
 # =============================================================================
 # Initial Guesses
 # =============================================================================
@@ -192,17 +175,7 @@ problem = Problem(
     N=n,
 )
 
-# SCP settings
-problem.settings.prp.dt = 0.01
-problem.settings.scp.w_tr = 5e0
-problem.settings.scp.lam_cost = 1e0
-problem.settings.scp.lam_vc = 1e2
 problem.settings.scp.ep_tr = 1e-3
-problem.settings.scp.ep_vb = 1e-4
-problem.settings.scp.ep_vc = 1e-8
-problem.settings.scp.cost_drop = 5
-problem.settings.scp.cost_relax = 0.7
-problem.settings.scp.w_tr_adapt = 1.5
 
 # =============================================================================
 # Solve and Visualize

{openscvx-0.3.2.dev339/examples/drone → openscvx-0.3.2.dev343/examples/realtime/base_problems}/cinema_vp_realtime_base.py

@@ -199,15 +199,15 @@ problem = Problem(
     licq_max=1e-8,
 )
 
-problem.settings.scp.w_tr = 4e0  # Weight on the Trust Region
+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.w_tr_adapt = 1.3  # Trust Region Adaptation Factor
-problem.settings.scp.w_tr_max_scaling_factor = 1e3  # Maximum Trust Region Weight
+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,