openscvx 0.4.1.dev158__tar.gz → 0.4.1.dev159__tar.gz

{openscvx-0.4.1.dev158/openscvx.egg-info → openscvx-0.4.1.dev159}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev158
+Version: 0.4.1.dev159
 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.dev158 → openscvx-0.4.1.dev159}/examples/abstract/brachistochrone.py

@@ -87,8 +87,8 @@ problem = Problem(
     licq_max=1e-8,
     algorithm={
         "autotuner": "ConstantProximalWeight",
-        "lam_prox": 1e1,
-        "lam_cost": 1e0,
+        "lam_prox": 1e0,
+        "lam_cost": 1e-1,
     },
 )
 

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/abstract/impulsive.py

@@ -86,9 +86,9 @@ problem = Problem(
     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.lam_prox = 2e-4  # Weight on the Trust Region
+problem.algorithm.lam_vc = 1e0  # Weight on the Virtual Control
+problem.algorithm.lam_cost = 2e-2  # Weight on the Minimal Time Objective
 problem.algorithm.k_max = 100
 
 plotting_dict = {}

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/abstract/stl_integer_variable.py

@@ -87,7 +87,7 @@ problem = Problem(
     controls=controls,
     N=N,
     time=time,
-    algorithm={"autotuner": ox.ConstantProximalWeight(), "ep_vc": 1e-3, "lam_cost": 1e1},
+    algorithm={"autotuner": ox.ConstantProximalWeight(), "ep_vc": 1e-3, "lam_cost": 1e0},
     discretizer={"dis_type": "ZOH"},
     float_dtype="float64",
 )

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/arm/three_link_arm.py

@@ -201,7 +201,7 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    algorithm={"lam_vb": 1e1},
+    algorithm={"lam_vb": 1e0},
 )
 
 # Solver settings

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/car/dubins_car.py

@@ -97,8 +97,8 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    licq_max=1e-8,
-    algorithm={"lam_cost": 4e1, "lam_vc": 1e3},
+    licq_max=1e-6,
+    algorithm={"lam_prox": 1e-3, "lam_cost": 4e-2, "lam_vc": 1e0},
 )
 
 plotting_dict = {
@@ -118,7 +118,9 @@ 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.algorithm.lam_vc = 1e2  # Adjust virtual control weight
+    problem.algorithm.lam_prox = 1e-2
+    problem.algorithm.lam_vc = 1e0
+    problem.algorithm.lam_cost = 1e-3
     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.dev158 → openscvx-0.4.1.dev159}/examples/car/dubins_car_obstacle_conditional.py

@@ -110,7 +110,7 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    algorithm={"lam_vc": 1e3},
+    algorithm={"lam_prox": 1e-3, "lam_vc": 1e0, "lam_cost": 1e-4},
 )
 
 plotting_dict = {

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/car/dubins_car_stl_or.py

@@ -105,10 +105,13 @@ problem = Problem(
     time=time,  # Time is already defined above as ox.Time
     constraints=constraints,
     N=n,
-    algorithm={"autotuner": ox.AugmentedLagrangian(eta_lambda=1e0), "lam_vb": 1e0},
+    algorithm={"autotuner": ox.AugmentedLagrangian(eta_lambda=1e0)},
     float_dtype="float64",
 )
 
+problem.algorithm.lam_vb = 1e0
+problem.algorithm.lam_vc = 1e1
+
 # Extract parameter values from problem.parameters (not Parameter objects)
 plotting_dict = {
     "wp1_center": problem.parameters.get("wp1_center", None),

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/car/dubins_car_waypoint_stl.py

@@ -126,15 +126,18 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    algorithm={"autotuner": ox.RampProximalWeight()},
+    algorithm={
+        "autotuner": ox.ConstantProximalWeight(),
+        "lam_prox": 1e-3,
+        "lam_vc": 1e1,
+        "lam_cost": 1e-3,
+        "ep_vc": 1e-6,
+        "ep_tr": 5e-4,
+    },
     float_dtype="float64",
     licq_max=1e-10,
 )
 
-# problem.algorithm.ep_vc = 1e-6
-# problem.algorithm.ep_tr = 5e-4
-problem.algorithm.lam_vc = 2e3
-
 plotting_dict = {
     "obs_radius": problem.parameters["obs_radius"],
     "obs_center": problem.parameters["obs_center"],

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/drone/cinema_vp.py

@@ -235,7 +235,7 @@ problem = Problem(
     constraints=constraints,
     N=n,
     licq_max=1e-8,
-    algorithm={"lam_prox": 4e0, "ep_tr": 1e-6},
+    algorithm={"lam_prox": 4e-1, "ep_tr": 1e-6},
 )
 
 plotting_dict = {

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/drone/dr_vp_nodal.py

@@ -226,10 +226,10 @@ problem = Problem(
     constraints=constraints,
     N=n,
     algorithm={
-        "lam_prox": 1e1,
-        "lam_cost": 1e1,
-        "lam_vc": 1e2,
-        "lam_vb": 4e0,
+        "lam_prox": 1e-1,
+        "lam_cost": 1e-1,
+        "lam_vc": 1e0,
+        "lam_vb": 4e-2,
     },
 )
 

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/drone/dr_vp_polytope.py

@@ -241,8 +241,8 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    algorithm={"lam_prox": 2e0, "lam_vc": 4e1, "ep_tr": 1e-5},
-    discretizer={"atol": 1e-4},
+    algorithm={"lam_prox": 5e-2, "lam_vc": 1e0, "lam_cost": 2.5e-3, "ep_tr": 1e-5},
+    discretizer=ox.VectorizeDiscretizeLinearize(diffrax_kwargs={"atol": 1e-4}),
 )
 
 plotting_dict = {

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/drone/logo.py

@@ -357,11 +357,12 @@ problem = Problem(
     byof=byof,
     algorithm={
         "autotuner": {"type": "RampProximalWeight", "ramp_factor": 1.06, "lam_prox_max": 1e3},
-        "lam_vc": 1e3,
-        "lam_cost": 6e0,
+        "lam_prox": 1e-3,
+        "lam_vc": 1e0,
+        "lam_cost": 6e-3,
     },
     float_dtype="float64",
-    discretizer=ox.DiscretizeLinearizeVectorize(atol=1e-4),
+    discretizer=ox.DiscretizeLinearizeVectorize(diffrax_kwargs={"atol": 1e-4}),
     solver={"solver_args": {"canon_backend": "COO", "enforce_dpp": True}},
 )
 

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/drone/obstacle_avoidance_nodal.py

@@ -150,7 +150,7 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    algorithm={"lam_vb": 1e0},
+    algorithm={"lam_vb": 1e-1, "lam_prox": 2e0},
 )
 
 plotting_dict = {

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/mpc/double_integrator_discrete.py

@@ -147,9 +147,9 @@ pz_data = np.tile(pz_lap, len(laps))
 n_mpc = 10  # Horizon nodes
 horizon_duration = 1.0  # Horizon length [s]
 
-Q_LAG = 1e0  # Lag error weight (high -> accurate progress tracking)
-Q_CONTOUR = 1e-1  # Contour error weight
-Q_PROGRESS = 1e-1
+Q_LAG = 1e-1  # Lag error weight (high -> accurate progress tracking)
+Q_CONTOUR = 1e-2  # Contour error weight
+Q_PROGRESS = 1e-2
 
 ###############################################################################
 # MPCC problem definition

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/mpc/double_integrator_drone_racing.py

@@ -211,9 +211,9 @@ obstacle_radius = 5.0
 n_mpc = 11  # Horizon nodes
 horizon_duration = 2.0  # Horizon length [s]
 
-Q_LAG = 1e0  # Lag error weight (high -> accurate progress tracking)
-Q_CONTOUR = 5e-2  # Contour error weight
-Q_PROGRESS = 1e-1
+Q_LAG = 1e-1  # Lag error weight (high -> accurate progress tracking)
+Q_CONTOUR = 5e-3  # Contour error weight
+Q_PROGRESS = 1e-2
 
 ###############################################################################
 # Main

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/mpc/dubins_car_circle_analytical.py

@@ -39,9 +39,9 @@ total_arc_length = 2 * np.pi * R_circle  # One full lap
 n_mpc = 8  # Horizon nodes
 horizon_duration = 1.5  # Horizon length [s]
 
-Q_LAG = 1e0  # Lag error weight (high -> accurate progress tracking)
-Q_CONTOUR = 1e-1  # Contour error weight
-Q_PROGRESS = 1e-1
+Q_LAG = 1e-1  # Lag error weight (high -> accurate progress tracking)
+Q_CONTOUR = 1e-2  # Contour error weight
+Q_PROGRESS = 1e-2
 
 ###############################################################################
 # MPCC problem definition

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/mpc/dubins_car_circle_discrete.py

@@ -61,9 +61,9 @@ py_data = np.tile(py_lap, len(laps))
 n_mpc = 10  # Horizon nodes
 horizon_duration = 1.0  # Horizon length [s]
 
-Q_LAG = 1e0  # Lag error weight (high -> accurate progress tracking)
-Q_CONTOUR = 1e-1  # Contour error weight
-Q_PROGRESS = 1e-1
+Q_LAG = 1e-1  # Lag error weight (high -> accurate progress tracking)
+Q_CONTOUR = 1e-2  # Contour error weight
+Q_PROGRESS = 1e-2
 
 ###############################################################################
 # MPCC problem definition

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/mpc/realtime_double_integrator_drone_racing.py

@@ -206,9 +206,9 @@ obstacle_radius = 5.0
 n_mpc = 11  # Horizon nodes
 horizon_duration = 2.0  # Horizon length [s]
 
-Q_LAG = 1e0  # Lag error weight (high -> accurate progress tracking)
-Q_CONTOUR = 5e-2  # Contour error weight
-Q_PROGRESS = 1e-1
+Q_LAG = 1e-1  # Lag error weight (high -> accurate progress tracking)
+Q_CONTOUR = 5e-3  # Contour error weight
+Q_PROGRESS = 1e-2
 
 ###############################################################################
 # Main

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/realtime/base_problems/cinema_vp_realtime_base.py

@@ -198,12 +198,13 @@ problem = Problem(
     N=n,
     licq_max=1e-8,
     algorithm={
-        "lam_prox": 4e0,
-        "lam_cost": 1e-2,
-        "lam_vc": 1e1,
+        "lam_prox": 4e-1,
+        "lam_cost": 1e-3,
+        "lam_vc": 1e0,
         "ep_tr": 1e-6,
         "ep_vb": 1e-4,
         "ep_vc": 1e-8,
+        "autotuner": ox.ConstantProximalWeight(),
     },
 )
 

openscvx-0.4.1.dev159/examples/realtime/base_problems/dubins_car_realtime_base.py

@@ -0,0 +1,138 @@
+"""Dubins car path planning with obstacle avoidance.
+
+This example demonstrates minimum-time path planning for a Dubins car
+(car-like vehicle with minimum turning radius) navigating around a
+circular obstacle. The problem includes:
+
+- 2D position and heading dynamics
+- Speed and angular rate control inputs
+- Circular obstacle avoidance constraint
+- Minimal time objective with free final heading
+- Parameter updates for multiple scenarios
+"""
+
+import os
+import sys
+
+import jax.numpy as jnp
+import numpy as np
+
+# Add repo root to path (this file lives in examples/realtime/base_problems/)
+_this_dir = os.path.dirname(os.path.abspath(__file__))
+_repo_root = os.path.dirname(os.path.dirname(os.path.dirname(_this_dir)))
+sys.path.append(_repo_root)
+
+import openscvx as ox
+from openscvx import Problem
+
+n = 8
+total_time = 1.2  # Total simulation time
+
+# Define state components
+position = ox.State("position", shape=(2,))  # 2D position [x, y]
+position.min = np.array([-5.0, -5.0])
+position.max = np.array([5.0, 5.0])
+position.initial = np.array([0, -2])
+position.final = np.array([0, 2])
+
+theta = ox.State("theta", shape=(1,))  # Heading angle
+theta.min = np.array([-2 * jnp.pi])
+theta.max = np.array([2 * jnp.pi])
+theta.initial = np.array([0])
+theta.final = [ox.Free(0)]
+
+# Define control components
+speed = ox.Control("speed", shape=(1,))  # Forward speed
+speed.min = np.array([0])
+speed.max = np.array([10])
+speed.guess = np.zeros((n, 1))
+
+angular_rate = ox.Control("angular_rate", shape=(1,))  # Angular velocity
+angular_rate.min = np.array([-5])
+angular_rate.max = np.array([5])
+angular_rate.guess = np.zeros((n, 1))
+
+# Define list of all states and controls
+states = [position, theta]
+controls = [speed, angular_rate]
+
+# Define Parameters with initial values for obstacle radius and center
+obs_center = ox.Parameter("obs_center", shape=(2,), value=np.array([-2.01, 0.0]))
+obs_radius = ox.Parameter("obs_radius", shape=(), value=1.0)
+
+# Generate box constraints for all states
+constraints = []
+for state in states:
+    constraints.extend([ox.ctcs(state <= state.max), ox.ctcs(state.min <= state)])
+
+# Add obstacle avoidance constraint
+constraints.append(ox.ctcs(obs_radius <= ox.linalg.Norm(position - obs_center)))
+
+
+# Define dynamics as dictionary mapping state names to their derivatives
+dynamics = {
+    "position": ox.Concat(
+        speed[0] * ox.Sin(theta[0]),  # x_dot
+        speed[0] * ox.Cos(theta[0]),  # y_dot
+    ),
+    "theta": angular_rate[0],
+}
+
+
+# Build the problem (parameters auto-collected from Parameter objects)
+time = ox.Time(
+    initial=0.0,
+    final=ox.Minimize(total_time),
+    min=0.0,
+    max=20,
+    time_dilation_min=0.02 * total_time,
+    uniform_time_grid=True,
+)
+
+problem = Problem(
+    dynamics=dynamics,
+    states=states,
+    controls=controls,
+    time=time,
+    constraints=constraints,
+    N=n,
+    licq_max=1e-6,
+    algorithm={
+        "lam_prox": 1e-1,
+        "lam_cost": 4e-2,
+        "lam_vc": 2e0,
+        "autotuner": ox.ConstantProximalWeight(),
+    },
+)
+
+plotting_dict = {
+    "obs_radius": problem.parameters["obs_radius"],
+    "obs_center": problem.parameters["obs_center"],
+}
+
+if __name__ == "__main__":
+    problem.initialize()
+    problem.solve()
+    results = problem.post_process()
+    results.update(plotting_dict)
+
+#     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.algorithm.lam_prox = 1e-2
+#     problem.algorithm.lam_vc = 1e0
+#     problem.algorithm.lam_cost = 1e-3
+#     position.guess = np.linspace([0, -2], [0, 2], n)
+#     theta.guess = np.zeros((n, 1))
+#     speed.guess = np.zeros((n, 1))
+#     angular_rate.guess = np.zeros((n, 1))
+
+#     plotting_dict["obs_center"] = np.array([0.5, 0.0])
+
+#     results = problem.solve()
+#     results = problem.post_process()
+#     results.update(plotting_dict)
+#     plot_dubins_car(results, problem.settings).show()

{openscvx-0.4.1.dev158 → openscvx-0.4.1.dev159}/examples/realtime/base_problems/obstacle_avoidance_realtime_base.py

@@ -152,7 +152,7 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    algorithm={"autotuner": "ConstantProximalWeight", "lam_cost": 1e0},
+    algorithm={"autotuner": "ConstantProximalWeight", "lam_cost": 1e-1},
 )
 
 plotting_dict = {