simweave 0.8.0__tar.gz → 0.8.2__tar.gz

{simweave-0.8.0/src/simweave.egg-info → simweave-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simweave
-Version: 0.8.0
+Version: 0.8.2
 Summary: SimWeave: a hybrid discrete/continuous simulation engine with fault injection, currency, units, agents, supply chains, and Monte Carlo.
 Author: Stuart
 License: MIT

{simweave-0.8.0 → simweave-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simweave"
-version = "0.8.0"
+version = "0.8.2"
 description = "SimWeave: a hybrid discrete/continuous simulation engine with fault injection, currency, units, agents, supply chains, and Monte Carlo."
 readme = "README.md"
 requires-python = ">=3.10"

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/__init__.py

@@ -133,6 +133,7 @@ from simweave.viz import (
     plot_service_utilisation,
     plot_state_trajectories,
     plot_warehouse_stock,
+    plot_pareto_sweep,
     plot_fleet_availability,
     plot_sensitivity_surface,
     plot_road_occupancy,
@@ -144,7 +145,7 @@ from simweave.viz import (
     plot_health_index,
 )
 
-__version__ = "0.8.0"
+__version__ = "0.8.2"
 
 __all__ = [
     # Core
@@ -269,6 +270,7 @@ __all__ = [
     "plot_service_utilisation",
     "plot_state_trajectories",
     "plot_warehouse_stock",
+    "plot_pareto_sweep",
     "plot_fleet_availability",
     "plot_sensitivity_surface",
     "plot_road_occupancy",

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/continuous/control/suspension.py

@@ -21,7 +21,7 @@ class GroundhookDamper:
 
     def force(self, body_velocity: float, wheel_velocity: float) -> float:
         # For groundhook uses wheel velocity only, but signature makes modular/easy to toggle controller
-        return -self.c * wheel_velocity
+        return self.c * wheel_velocity
     
 class HybridActiveDamper:
     "Hybrid Skyhook & Groundhook."
@@ -30,10 +30,10 @@ class HybridActiveDamper:
         self.ground = GroundhookDamper(c_ground)
         self.alpha = float(alpha)
 
-    def force(self, body_v: float, wheel_v: float) -> float:
+    def force(self, body_velocity: float, wheel_velocity: float) -> float:
         return (
-            self.alpha * self.sky.force(body_v)
-            + (1 - self.alpha) * self.ground.force(wheel_v)
+            self.alpha * self.sky.force(body_velocity, 0)
+            + (1 - self.alpha) * self.ground.force(0, wheel_velocity)
         )
     
 class SemiActiveWrapper:

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/continuous/systems/mass_spring_damper.py

@@ -24,9 +24,9 @@ class MassSpringDamper(DynamicSystem):
         stiffness: float | SpringStiffness,
         x0: tuple[float, float] = (0.0, 0.0),
     ):
-        if mass <= 0:
-            raise ValueError("mass must be positive")
         self.mass = self._val(mass)
+        if self.mass <= 0:
+            raise ValueError("mass must be positive")
         self.damping = self._val(damping)
         self.stiffness = self._val(stiffness)
         self._x0 = np.asarray([self._val(v) for v in x0], dtype=float)

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/continuous/systems/pendulum.py

@@ -26,10 +26,10 @@ class SimplePendulum(DynamicSystem):
         damping: float | Damping = 0.0,
         x0: tuple[float, float] = (0.0, 0.0),
     ):
-        if length <= 0 or mass <= 0:
-            raise ValueError("length and mass must be positive")
         self.length = self._val(length)
         self.mass = self._val(mass)
+        if self.length <= 0 or self.mass <= 0:
+            raise ValueError("length and mass must be positive")
         self.gravity = self._val(gravity)
         self.damping = self._val(damping)
         self._x0 = np.asarray([self._val(v) for v in x0], dtype=float)

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/discrete/queues.py

@@ -212,13 +212,21 @@ class Queue(Entity):
     # Metrics
     # ------------------------------------------------------------------
     def average_length(self, elapsed: float) -> float:
-        """Mean queue length over the elapsed simulation time (L in Little's law)."""
+        """Time-averaged number waiting in the buffer (``Lq``), excluding items in service.
+
+        For M/M/1, ``Lq = rho**2 / (1 - rho)``; Little's law gives ``Lq = lambda * Wq``.
+        """
         if elapsed <= 0:
             return 0.0
         return self.cumulative_length_time / elapsed
 
     def average_wait(self) -> float:
-        """Mean residence time of completed items (W in Little's law)."""
+        """Mean queue-only wait (``Wq``) of items that have left the buffer.
+
+        Only time spent sitting in the buffer counts; service time does not. For
+        M/M/1, ``Wq = rho / (mu - lambda)`` and the total time in system is
+        ``W = Wq + 1/mu`` (see :meth:`Service.average_residence`).
+        """
         if self.departures == 0:
             return 0.0
         return self.cumulative_wait_time / self.departures

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/discrete/services.py

@@ -8,6 +8,7 @@ next queue is full) it sits in a "blocked-completion" slot until it clears.
 
 from __future__ import annotations
 
+import weakref
 from typing import TYPE_CHECKING, Callable
 
 import numpy as np
@@ -142,6 +143,9 @@ class Service(Queue):
         self.completed_total_time: float = (
             0.0  # sum of (wait + service) across completed
         )
+        self._entry_age: "weakref.WeakKeyDictionary[Entity, float]" = (
+            weakref.WeakKeyDictionary()
+        )
 
     # ------------------------------------------------------------------
     # next_q propagation to channels is implicit: they read parent.next_q.
@@ -168,14 +172,29 @@ class Service(Queue):
         return busy / (self.capacity * elapsed)
 
     def average_residence(self) -> float:
-        """Mean total time (waiting + service) for completed items."""
+        """Mean time in this service (buffer wait + service) per completed item.
+
+        This is ``W`` in Little's law (``L = lambda * W``); for M/M/1 it is
+        ``Wq + 1/mu = 1/(mu - lambda)``. Compare :meth:`Queue.average_wait`,
+        which is the buffer-only wait ``Wq``.
+        """
         if self.completed_count == 0:
             return 0.0
         return self.completed_total_time / self.completed_count
 
+    def enqueue(self, item: Entity) -> bool:
+        # ``age`` accrues both in the buffer and in service, so residence at
+        # this stage is the age delta between entry and completion. Recording
+        # the entry age keeps this correct for chained services too.
+        age_in = item.age
+        accepted = super().enqueue(item)
+        if accepted:
+            self._entry_age[item] = age_in
+        return accepted
+
     def _record_completion(self, item: Entity) -> None:
         self.completed_count += 1
-        self.completed_total_time += item.total_wait_time + item.age  # rough summary
+        self.completed_total_time += item.age - self._entry_age.pop(item, 0.0)
 
 
 # ---------------------------------------------------------------------------

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/supplychain/optimization.py

@@ -81,6 +81,12 @@ def poisson_reorder_points(
 
     return k, total_cost
 
+def _objective(x: np.ndarray, inv, quant) -> float:
+    return float(np.sum(inv.unit_cost * np.round(x) * quant))
+
+def _availability_con(x: np.ndarray, lam) -> float:
+    import scipy.stats as stats
+    return float(np.prod(stats.poisson.cdf(np.round(x), lam)))
 
 def cost_optimise_stock(
     warehouse: Warehouse,
@@ -90,14 +96,19 @@ def cost_optimise_stock(
     ub: float = 100.0,
     seed: int | None = 1,
     maxiter: int = 200,
+    workers: int = -1,
 ) -> tuple[np.ndarray, float]:
     """Differential-evolution cost minimisation with availability constraint.
 
     This balances cost vs availability on a whole-warehouse basis rather than
     per item -- cheap items should cover more risk, expensive items less.
+
+    workers defaults to -1 which is using all available cores (fastest).
+    For reproducibility, use 1.
+    Specify workers as desired on shared devices.
     """
     _ensure_scipy()
-    import scipy.stats as stats
+    from functools import partial
     from scipy.optimize import differential_evolution, NonlinearConstraint, Bounds
 
     if not 0.0 < target_availability < 0.999:
@@ -117,19 +128,26 @@ def cost_optimise_stock(
     lam = demand * logistics_delay
     quant = inv.batchsize if quantize_by_batchsize else np.ones(inv.n_items)
 
-    def objective(x: np.ndarray) -> float:
-        return float(np.sum(inv.unit_cost * np.round(x) * quant))
-
-    def availability_con(x: np.ndarray) -> float:
-        return float(np.prod(stats.poisson.cdf(np.round(x), lam)))
+    ## v0.8.2 we moved _objective and _availability_con outside this function, to be pickable, required for workers>1
+    ## partial is required, as scipy multiprocessing won't pickle lambda either (or any local-defined callable)
+    obj = partial(_objective, inv=inv, quant=quant)
+    con = partial(_availability_con, lam=lam)
 
     bounds = Bounds(lb=np.zeros(inv.n_items), ub=ub * np.ones(inv.n_items))
-    nlc = NonlinearConstraint(availability_con, target_availability, 1.0)
+    nlc = NonlinearConstraint(con, target_availability, 1.0)
 
     result = differential_evolution(
-        objective, bounds, constraints=nlc, seed=seed, maxiter=maxiter, polish=True
+        obj,
+        bounds,
+        constraints=nlc,
+        seed=seed,
+        maxiter=maxiter,
+        polish=False,
+        updating="deferred",
+        workers=workers
     )
 
+
     solution = np.round(result.x * quant)
     total_cost = float(np.sum(inv.unit_cost * (inv.batchsize + solution)))
 
@@ -141,25 +159,38 @@ def cost_optimise_stock(
 
 
 def pareto_sweep(
-    warehouse: Warehouse, availability_range: np.ndarray | None = None
+    warehouse: Warehouse,
+    availability_range: np.ndarray | None = None,
+    *,
+    method: str = "both",
 ) -> dict[str, np.ndarray]:
-    """Sweep availability targets and return costs for both heuristic and DE."""
+    """Sweep availability targets and return costs for Poisson and/or DE."""
+
     if availability_range is None:
         availability_range = np.clip(np.arange(0.1, 1.0, 0.05), 0.0, 0.99)
 
+    do_de = method in ("both", "de")
+    do_poisson = method in ("both", "poisson")
+
     costs_de = []
     costs_poisson = []
+
     for a in availability_range:
-        _, c_de = cost_optimise_stock(warehouse, target_availability=float(a))
-        _, c_p = poisson_reorder_points(warehouse, target_availability=float(a))
-        costs_de.append(c_de)
-        costs_poisson.append(c_p)
-
-    return {
-        "availability": np.asarray(availability_range),
-        "cost_cost_optimal": np.asarray(costs_de),
-        "cost_poisson": np.asarray(costs_poisson),
-    }
+        if do_de:
+            _, c_de = cost_optimise_stock(warehouse, target_availability=float(a))
+            costs_de.append(c_de)
+        if do_poisson:
+            _, c_p = poisson_reorder_points(warehouse, target_availability=float(a))
+            costs_poisson.append(c_p)
+
+    out = {"availability": np.asarray(availability_range)}
+
+    if do_de:
+        out["cost_cost_optimal"] = np.asarray(costs_de)
+    if do_poisson:
+        out["cost_poisson"] = np.asarray(costs_poisson)
+
+    return out
 
 
 # ---------------------------------------------------------------------------

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/viz/__init__.py

@@ -48,6 +48,7 @@ from simweave.viz.plots import (
     plot_service_utilisation,
     plot_state_trajectories,
     plot_warehouse_stock,
+    plot_pareto_sweep,
     plot_fleet_availability,
     plot_sensitivity_surface,
     plot_road_occupancy,
@@ -81,6 +82,7 @@ __all__ = [
     "plot_service_utilisation",
     "plot_state_trajectories",
     "plot_warehouse_stock",
+    "plot_pareto_sweep",
     "plot_fleet_availability",
     "plot_sensitivity_surface",
     "plot_road_occupancy",

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/viz/plots.py

@@ -41,6 +41,8 @@ import numpy as np
 
 from simweave.viz import _plotly
 from simweave.viz.themes import apply_theme
+from simweave.supplychain.warehouse import Warehouse
+from simweave.supplychain.optimization import pareto_sweep
 
 if TYPE_CHECKING:
     from simweave.core.time_axis import SimTimeAxis
@@ -349,6 +351,93 @@ def plot_warehouse_stock(
     )
     return apply_theme(_apply_time_axis(fig, time_axis), theme)
 
+# --------------------------------------------------------------------------- #
+# Inventory optimisation: pareto sweep                                        #
+# --------------------------------------------------------------------------- #
+
+
+def plot_pareto_sweep(
+    warehouse: Warehouse,
+    availability_range: np.ndarray | None = None,
+    *,
+    method: str = "both",
+    theme: str | None = None,
+    title: str | None = None,
+) -> Any:
+    """Plot cost vs availability with optional DE and Poisson curves.
+
+    Parameters
+    ----------
+    warehouse:
+        Warehouse instance to optimise.
+    availability_range:
+        Optional array of availability targets.
+    method:
+        "both" (default), "poisson", or "de".
+    theme:
+        Optional Plotly theme.
+    title:
+        Optional plot title.
+    """
+    go = _plotly.require_go()
+
+    sweep = pareto_sweep(warehouse, availability_range, method=method)
+    a = sweep["availability"]
+
+    fig = go.Figure()
+
+    # Poisson heuristic
+    if "cost_poisson" in sweep:
+        c_p = sweep["cost_poisson"]
+        fig.add_trace(
+            go.Scatter(
+                x=c_p,
+                y=a,
+                mode="lines+markers",
+                name="Poisson heuristic",
+                line={"dash": "dash", "width": 2},
+            )
+        )
+
+    # DE cost-optimal
+    if "cost_cost_optimal" in sweep:
+        c_de = sweep["cost_cost_optimal"]
+        fig.add_trace(
+            go.Scatter(
+                x=c_de,
+                y=a,
+                mode="lines+markers",
+                name="cost-optimal (DE)",
+                line={"width": 2},
+            )
+        )
+
+        # Shaded savings region (only if Poisson also present)
+        if "cost_poisson" in sweep:
+            fig.add_trace(
+                go.Scatter(
+                    x=np.concatenate([c_p, c_de[::-1]]),
+                    y=np.concatenate([a, a[::-1]]),
+                    fill="toself",
+                    fillcolor="rgba(0, 150, 0, 0.1)",
+                    line={"width": 0},
+                    name="savings region",
+                    hoverinfo="skip",
+                    showlegend=True,
+                )
+            )
+
+    wname = getattr(warehouse, "name", "warehouse")
+
+    fig.update_layout(
+        title=title or f"cost vs availability: {wname}",
+        xaxis_title="total cost",
+        yaxis_title="target availability",
+        legend_title_text="method",
+    )
+
+    return apply_theme(fig, theme)
+
 
 # --------------------------------------------------------------------------- #
 # Monte Carlo: percentile fan                                                 #
@@ -1126,6 +1215,7 @@ __all__ = [
     "plot_queue_length",
     "plot_service_utilisation",
     "plot_warehouse_stock",
+    "plot_pareto_sweep",
     "plot_mc_fan",
     "plot_agent_path",
     "plot_fleet_availability",

{simweave-0.8.0 → simweave-0.8.2}/src/simweave/viz/vehicle_dynamics.py

@@ -13,8 +13,6 @@ from simweave.units.si import (
         Force,
     )
 
-from plotly.subplots import make_subplots
-
 
 def plot_vehicle_metrics(
     result,
@@ -25,7 +23,8 @@ def plot_vehicle_metrics(
 ):
     """Plot vehicle metrics with adaptive layout and automatic units."""
 
-    go = _plotly.require_go()
+    go = _plotly.require_go()  # friendly ImportError if plotly is missing
+    from plotly.subplots import make_subplots
 
     metrics = compute_vehicle_metrics(result, model)
     t = np.asarray(result.time)

{simweave-0.8.0 → simweave-0.8.2/src/simweave.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simweave
-Version: 0.8.0
+Version: 0.8.2
 Summary: SimWeave: a hybrid discrete/continuous simulation engine with fault injection, currency, units, agents, supply chains, and Monte Carlo.
 Author: Stuart
 License: MIT