simweave 0.5.0__tar.gz → 0.7.2__tar.gz

{simweave-0.5.0/src/simweave.egg-info → simweave-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simweave
-Version: 0.5.0
+Version: 0.7.2
 Summary: SimWeave: a hybrid discrete/continuous simulation engine with currency, units, agents, supply chains, and Monte Carlo.
 Author: Stuart
 License: MIT
@@ -115,6 +115,20 @@ t2 = Temperature(20, "C")
 
 delta = t1 - t2
 ```
+Finally, we can also use fractional powers when they produce valid physical dimensions
+(e.g. √area → distance) using either:
+```python
+area = sw.Area(np.array([1, 4, 9]))
+length = area ** 0.5 # Distance([1.0, 2.0, 3.0]) [m]
+length = area.sqrt() # Distance([1.0, 2.0, 3.0]) [m]
+```
+or indeed:
+```python
+volume = sw.Volume(np.array([1, 8, 27]))
+length = volume ** (1/3) # Distance([1.0, 2.0, 3.0]) [m]
+length = volume.cbrt() # Distance([1.0, 2.0, 3.0]) [m]
+```
+
 ✔ Prevents invalid operations (e.g. distance + time)
 
 ✔ Automatically derives units (e.g. m/s → Velocity)
@@ -328,9 +342,6 @@ sim_engine/
 
 ## Next steps on the roadmap
 
-- **Numpy aware SIUnits.** Ensure our improved system works on arrays
-  not just scalars, with no regression. Add new classes such as
-  Voltage, Current, Resistance.
 - **PID Controllers.** To extend utility of dynamic simulations, allow
   controllers which are easily exposed to EdgeWeave.
 - **Fault injection.** This should be suitable for ML datasets with use

{simweave-0.5.0 → simweave-0.7.2}/README.md

@@ -66,6 +66,20 @@ t2 = Temperature(20, "C")
 
 delta = t1 - t2
 ```
+Finally, we can also use fractional powers when they produce valid physical dimensions
+(e.g. √area → distance) using either:
+```python
+area = sw.Area(np.array([1, 4, 9]))
+length = area ** 0.5 # Distance([1.0, 2.0, 3.0]) [m]
+length = area.sqrt() # Distance([1.0, 2.0, 3.0]) [m]
+```
+or indeed:
+```python
+volume = sw.Volume(np.array([1, 8, 27]))
+length = volume ** (1/3) # Distance([1.0, 2.0, 3.0]) [m]
+length = volume.cbrt() # Distance([1.0, 2.0, 3.0]) [m]
+```
+
 ✔ Prevents invalid operations (e.g. distance + time)
 
 ✔ Automatically derives units (e.g. m/s → Velocity)
@@ -279,9 +293,6 @@ sim_engine/
 
 ## Next steps on the roadmap
 
-- **Numpy aware SIUnits.** Ensure our improved system works on arrays
-  not just scalars, with no regression. Add new classes such as
-  Voltage, Current, Resistance.
 - **PID Controllers.** To extend utility of dynamic simulations, allow
   controllers which are easily exposed to EdgeWeave.
 - **Fault injection.** This should be suitable for ML datasets with use

{simweave-0.5.0 → simweave-0.7.2}/pyproject.toml

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

{simweave-0.5.0 → simweave-0.7.2}/src/simweave/__init__.py

@@ -13,6 +13,7 @@ from simweave.core import (
     SimEnvironment,
     configure as configure_logging,
     get_logger,
+    SimTimeAxis,
 )
 from simweave.discrete import (
     EntityProperties,
@@ -37,6 +38,9 @@ from simweave.continuous import (
     MassSpringDamper,
     SimplePendulum,
     QuarterCarModel,
+    HalfCarModel,
+    RollCarModel,
+    FullCarModel,
     SeriesRLC,
     ThermalRC,
     TwoMassThermal,
@@ -53,6 +57,32 @@ from simweave.agents import (
     chebyshev,
 )
 from simweave.supplychain import InventoryItems, Warehouse
+from simweave.reliability import (
+    SubsystemSpec,
+    SubsystemState,
+    SubsystemStatus,
+    RepairJob,
+    RepairCentre,
+    ReliableEntity,
+    Fleet,
+    FleetAvailabilityRecorder,
+    SweepResult,
+    sensitivity_sweep,
+)
+from simweave.roads import (
+    Vehicle,
+    VehicleArrivalProcess,
+    Road,
+    DualCarriageway,
+    SignalPhase,
+    TrafficSignal,
+    Intersection,
+    Handedness,
+    Roundabout,
+    RoadNetwork,
+    RoadOccupancyRecorder,
+    IntersectionQueueRecorder,
+)
 from simweave.mc import MCResult, run_monte_carlo, run_batched_mc
 from simweave.units import (
     SIUnit,
@@ -96,11 +126,16 @@ from simweave.viz import (
     plot_service_utilisation,
     plot_state_trajectories,
     plot_warehouse_stock,
+    plot_fleet_availability,
+    plot_sensitivity_surface,
+    plot_road_occupancy,
+    plot_intersection_queues,
     register_theme,
     set_default_theme,
+    plot_vehicle_metrics,
 )
 
-__version__ = "0.5.0"
+__version__ = "0.7.2"
 
 __all__ = [
     # Core
@@ -109,6 +144,7 @@ __all__ = [
     "ScheduledEvent",
     "Entity",
     "SimEnvironment",
+    "SimTimeAxis",
     "configure_logging",
     "get_logger",
     # Discrete
@@ -133,6 +169,9 @@ __all__ = [
     "MassSpringDamper",
     "SimplePendulum",
     "QuarterCarModel",
+    "HalfCarModel",
+    "RollCarModel",
+    "FullCarModel",
     "SeriesRLC",
     "ThermalRC",
     "TwoMassThermal",
@@ -150,6 +189,30 @@ __all__ = [
     # Supply chain
     "InventoryItems",
     "Warehouse",
+    # Roads
+    "Vehicle",
+    "VehicleArrivalProcess",
+    "Road",
+    "DualCarriageway",
+    "SignalPhase",
+    "TrafficSignal",
+    "Intersection",
+    "Handedness",
+    "Roundabout",
+    "RoadNetwork",
+    "RoadOccupancyRecorder",
+    "IntersectionQueueRecorder",
+    # Reliability
+    "SubsystemSpec",
+    "SubsystemState",
+    "SubsystemStatus",
+    "RepairJob",
+    "RepairCentre",
+    "ReliableEntity",
+    "Fleet",
+    "FleetAvailabilityRecorder",
+    "SweepResult",
+    "sensitivity_sweep",
     # Monte Carlo
     "MCResult",
     "run_monte_carlo",
@@ -191,6 +254,11 @@ __all__ = [
     "plot_service_utilisation",
     "plot_state_trajectories",
     "plot_warehouse_stock",
+    "plot_fleet_availability",
+    "plot_sensitivity_surface",
+    "plot_road_occupancy",
+    "plot_intersection_queues",
+    "plot_vehicle_metrics",
     "register_theme",
     "set_default_theme",
     # Meta

simweave-0.7.2/src/simweave/analysis/vehicle.py

@@ -0,0 +1,207 @@
+import numpy as np
+from simweave.continuous.systems.full_car import FullCarModel
+
+def compute_quarter_car_metrics(result, model=None):
+    state = np.asarray(result.state)
+
+    z_s = state[:, 0]
+    z_s_dot = state[:, 1]
+    z_u = state[:, 2]
+
+    dt = np.mean(np.diff(result.time))
+    z_s_ddot = np.gradient(z_s_dot, dt)
+
+    rms = np.sqrt(np.mean(z_s_ddot**2))
+
+    travel = {
+        "single": z_s - z_u,
+    }
+
+    if model is not None:
+        k_t = model.k_t
+        z_r = result.inputs[:, 0] if result.inputs is not None else 0.0
+
+        tyre = {
+            "single": k_t * (z_u - z_r),
+        }
+        tyre_metric = {"name": "Tyre Load", "unit": "N"}
+    else:
+        tyre = {"single": z_u}
+        tyre_metric = {"name": "Tyre deflection", "unit": "m"}
+
+    return {
+        "body_accel": z_s_ddot,
+        "body_accel_RMS": rms,
+        "pitch": None,
+        "roll": None,
+        "suspension_travel": travel,
+        "tyre": tyre,
+        "tyre_metric": tyre_metric,
+    }
+
+def compute_half_car_pitch_metrics(result, model=None):
+    state = np.asarray(result.state)
+
+    z_s = state[:, 0]
+    z_s_dot = state[:, 1]
+    theta = state[:, 2]
+
+    z_uf = state[:, 4]
+    z_ur = state[:, 6]
+
+    dt = np.mean(np.diff(result.time))
+    z_s_ddot = np.gradient(z_s_dot, dt)
+    rms = np.sqrt(np.mean(z_s_ddot**2))
+
+    travel = {
+        "front": z_s - z_uf,
+        "rear": z_s - z_ur,
+    }
+
+    tyre = {
+        "front": z_uf,
+        "rear": z_ur,
+    }
+
+    return {
+        "body_accel": z_s_ddot,
+        "body_accel_RMS": rms,
+        "pitch": theta,
+        "roll": None,
+        "suspension_travel": travel,
+        "tyre": tyre,
+        "tyre_metric": {"name": "Tyre deflection", "unit": "m"},
+    }
+
+def compute_half_car_roll_metrics(result, model=None):
+    state = np.asarray(result.state)
+
+    z_s = state[:, 0]
+    z_s_dot = state[:, 1]
+    phi = state[:, 2]
+
+    z_ul = state[:, 4]
+    z_ur = state[:, 6]
+
+    dt = np.mean(np.diff(result.time))
+    z_s_ddot = np.gradient(z_s_dot, dt)
+    rms = np.sqrt(np.mean(z_s_ddot**2))
+
+    travel = {
+        "left": z_s - z_ul,
+        "right": z_s - z_ur,
+    }
+
+    tyre = {
+        "left": z_ul,
+        "right": z_ur,
+    }
+
+    return {
+        "body_accel": z_s_ddot,
+        "body_accel_RMS": rms,
+        "pitch": None,
+        "roll": phi,
+        "suspension_travel": travel,
+        "tyre": tyre,
+        "tyre_metric": {"name": "Tyre deflection", "unit": "m"},
+    }
+
+
+def compute_full_car_metrics(result, model: FullCarModel | None = None):
+    """
+    Compute relevant engineering metrics.
+    Use optional 'model' input for tyre forces or default to displacement only.
+    """
+    state = np.asarray(result.state)
+
+    z_s = state[:, 0]
+    theta = state[:, 2]
+    phi = state[:, 4]
+
+    # velocities
+    z_s_dot = state[:, 1]
+
+    # numerical acceleration
+    dt = np.mean(np.diff(result.time))
+    z_s_ddot = np.gradient(z_s_dot, dt)
+    
+    # rms of acceleration
+    body_accel = z_s_ddot
+    rms = np.sqrt(np.mean(body_accel**2))
+
+    # suspension travel
+    z_ufl = state[:, 6]
+    z_ufr = state[:, 8]
+    z_url = state[:, 10]
+    z_urr = state[:, 12]
+
+    travel = {
+        "fl": z_s - z_ufl,
+        "fr": z_s - z_ufr,
+        "rl": z_s - z_url,
+        "rr": z_s - z_urr,
+    }
+
+    
+    if model is not None and result.inputs is not None:
+        # tyre stiffness
+        k_t = model.k_t
+
+        # gather road positions
+        z_rfl = result.inputs[:, 0]
+        z_rfr = result.inputs[:, 1]
+        z_rrl = result.inputs[:, 2]
+        z_rrr = result.inputs[:, 3]
+
+        # tyre force loads
+        F_fl = k_t * (z_ufl - z_rfl)
+        F_fr = k_t * (z_ufr - z_rfr)
+        F_rl = k_t * (z_url - z_rrl)
+        F_rr = k_t * (z_urr - z_rrr)
+
+        tyre = {
+            "fl": F_fl,
+            "fr": F_fr,
+            "rl": F_rl,
+            "rr": F_rr,
+        }
+        tyre_metric = {
+            "name": "Tyre Loads",
+            "unit": "N"
+        } 
+    else:
+        # tyre deflection (proxy for load)
+        tyre = {
+            "fl": z_ufl,
+            "fr": z_ufr,
+            "rl": z_url,
+            "rr": z_urr,
+        }   
+        tyre_metric = {
+            "name": "Tyre deflection",
+            "unit": "m"
+        } 
+
+    return {
+        "body_accel": body_accel,
+        "body_accel_RMS": rms,
+        "pitch": theta,
+        "roll": phi,
+        "suspension_travel": travel,
+        "tyre": tyre,
+        "tyre_metric": tyre_metric
+    }
+
+def compute_vehicle_metrics(result, model=None):
+    n = result.state.shape[1]
+
+    if n == 4:
+        return compute_quarter_car_metrics(result, model)
+    elif n == 8:
+        # ambiguous → assume pitch (or detect via labels)
+        return compute_half_car_pitch_metrics(result, model)
+    elif n == 14:
+        return compute_full_car_metrics(result, model)
+    else:
+        raise ValueError(f"Unsupported system with {n} states")

{simweave-0.5.0 → simweave-0.7.2}/src/simweave/continuous/__init__.py

@@ -7,10 +7,20 @@ from simweave.continuous.solver import (
     simulate,
     ContinuousProcess,
 )
+from simweave.continuous.control import (
+    PIDController,
+    SkyhookDamper,
+    GroundhookDamper,
+    HybridActiveDamper,
+    SemiActiveWrapper,
+)
 from simweave.continuous.systems import (
     MassSpringDamper,
     SimplePendulum,
     QuarterCarModel,
+    HalfCarModel,
+    RollCarModel,
+    FullCarModel,
     SeriesRLC,
     ThermalRC,
     TwoMassThermal,
@@ -22,9 +32,17 @@ __all__ = [
     "SimulationResult",
     "simulate",
     "ContinuousProcess",
+    "PIDController",
+    "SkyhookDamper",
+    "GroundhookDamper",
+    "HybridActiveDamper",
+    "SemiActiveWrapper",
     "MassSpringDamper",
     "SimplePendulum",
     "QuarterCarModel",
+    "HalfCarModel",
+    "RollCarModel",
+    "FullCarModel",
     "SeriesRLC",
     "ThermalRC",
     "TwoMassThermal",

simweave-0.7.2/src/simweave/continuous/control/__init__.py

@@ -0,0 +1,17 @@
+from simweave.continuous.control.pid import (
+    PIDController,
+)
+from simweave.continuous.control.suspension import (
+    SkyhookDamper,
+    GroundhookDamper,
+    HybridActiveDamper,
+    SemiActiveWrapper,
+)
+
+__all__ = [
+    "PIDController",
+    "SkyhookDamper",
+    "GroundhookDamper",
+    "HybridActiveDamper",
+    "SemiActiveWrapper",
+]

simweave-0.7.2/src/simweave/continuous/control/pid.py

@@ -0,0 +1,48 @@
+# ---------------------------------------------------------------------------
+# PID Controller for Control Systems Engineering
+# ---------------------------------------------------------------------------
+
+class PIDController:
+    """Generic PID controller.
+
+    u(t) = Kp * e + Ki * ∫e dt + Kd * de/dt
+    """
+
+    def __init__(
+        self,
+        Kp: float,
+        Ki: float = 0.0,
+        Kd: float = 0.0,
+        setpoint: float = 0.0,
+    ):
+        self.Kp = float(Kp)
+        self.Ki = float(Ki)
+        self.Kd = float(Kd)
+        self.setpoint = float(setpoint)
+
+        self._integral = 0.0
+        self._prev_error = None
+
+    def reset(self):
+        self._integral = 0.0
+        self._prev_error = None
+
+    def __call__(self, measurement: float, dt: float) -> float:
+        error = self.setpoint - measurement
+
+        # integral
+        self._integral += error * dt
+
+        # derivative
+        if self._prev_error is None:
+            derivative = 0.0
+        else:
+            derivative = (error - self._prev_error) / dt
+
+        self._prev_error = error
+
+        return (
+            self.Kp * error
+            + self.Ki * self._integral
+            + self.Kd * derivative
+        )

simweave-0.7.2/src/simweave/continuous/control/suspension.py

@@ -0,0 +1,54 @@
+class SkyhookDamper:
+    """Skyhook damping controller.
+
+    Applies force proportional to body velocity.
+    """
+
+    def __init__(self, damping: float):
+        self.c = float(damping)
+
+    def force(self, body_velocity: float, wheel_velocity: float) -> float:
+        # For skyhook uses body velocity only, but signature makes modular/easy to toggle controller
+        return -self.c * body_velocity
+    
+class GroundhookDamper:
+    """Groundhook damping controller.
+    
+    Applies force proportional to wheel velocity."""
+
+    def __init__(self, damping: float):
+        self.c = float(damping)
+
+    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
+    
+class HybridActiveDamper:
+    "Hybrid Skyhook & Groundhook."
+    def __init__(self, c_sky: float, c_ground: float, alpha: float = 0.5):
+        self.sky = SkyhookDamper(c_sky)
+        self.ground = GroundhookDamper(c_ground)
+        self.alpha = float(alpha)
+
+    def force(self, body_v: float, wheel_v: float) -> float:
+        return (
+            self.alpha * self.sky.force(body_v)
+            + (1 - self.alpha) * self.ground.force(wheel_v)
+        )
+    
+class SemiActiveWrapper:
+    """Enforces passive (dissipative) behaviour: F * v_rel <= 0."""
+
+    def __init__(self, controller):
+        self.controller = controller
+
+    def force(self, body_velocity: float, wheel_velocity: float) -> float:
+        F = self.controller.force(body_velocity, wheel_velocity)
+
+        v_rel = body_velocity - wheel_velocity
+
+        # enforce dissipative constraint
+        if F * v_rel > 0:
+            return 0.0
+
+        return F

{simweave-0.5.0 → simweave-0.7.2}/src/simweave/continuous/solver.py

@@ -19,7 +19,7 @@ from typing import Callable, Iterable, Optional, Protocol, runtime_checkable
 import numpy as np
 
 from simweave.core.entity import Entity
-
+from simweave.units.si import SIUnit
 
 ArrayLike = np.ndarray
 InputFunc = Callable[[float], np.ndarray | float | int | None]
@@ -32,6 +32,7 @@ class SimulationResult:
     state_labels: tuple[str, ...]
     system_name: str
     method: str
+    inputs: np.ndarray | None = None
 
     def final_state(self) -> np.ndarray:
         return self.state[-1].copy()
@@ -51,9 +52,29 @@ class SupportsDynamics(Protocol):
     ) -> np.ndarray: ...
 
 
+class WrappedResult:
+    def __init__(self, data):
+        self._data = data
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+
 class DynamicSystem:
     """Base class for first-order state-space dynamic systems."""
 
+    STATE_UNITS: dict[str, type] = {}
+
+    @staticmethod
+    def _val(x):
+        """ Allow SIUnits to be supplied despite float for internal calcs """
+
+        if isinstance(x, SIUnit):
+            return x.value
+        if isinstance(x, (int, float, np.ndarray)):
+            return x
+        raise TypeError(f"Unsupported type for numeric value: {type(x)}")
+
     def initial_state(self) -> np.ndarray:
         raise NotImplementedError
 
@@ -75,6 +96,25 @@ class DynamicSystem:
     def validate_state(self, state: np.ndarray) -> None:
         if state.ndim != 1:
             raise ValueError("State must be a 1D array.")
+        
+    def get_state_unit(self, label: str):
+        return self.STATE_UNITS.get(label)
+    
+    def wrap_states(self, result):
+        wrapped = {}
+
+        labels = result.state_labels
+        state = result.state
+
+        for i, label in enumerate(labels):
+            unit_cls = self.STATE_UNITS.get(label)
+
+            if unit_cls is not None:
+                wrapped[label] = unit_cls(state[:, i])
+            else:
+                wrapped[label] = state[:, i]
+
+        return WrappedResult(wrapped)
 
     @property
     def name(self) -> str:
@@ -152,10 +192,33 @@ def simulate(
     state = np.zeros((time.size, x_init.size), dtype=float)
     state[0] = x_init
 
+    t0_input = _resolve_inputs(system, inputs, time[0])
+    inputs_log = [np.atleast_1d(t0_input).astype(float) if t0_input is not None else np.zeros(1)]
+
     stepper = _STEPPERS[method]
     for i in range(1, time.size):
+        t_prev = time[i - 1]
+
+        # --- resolve inputs ---
+        if inputs is not None:
+            u = inputs(t_prev)
+        else:
+            u = system.inputs(t_prev)
+
+        # normalise to array for storage
+        if u is None:
+            u_arr = np.zeros(1)
+        else:
+            u_arr = np.atleast_1d(u).astype(float)
+
+        inputs_log.append(u_arr)
+
+        # --- step ---
         state[i] = stepper(system, time[i - 1], state[i - 1], dt, inputs)
 
+    # gather inputs
+    inputs_array = np.vstack(inputs_log)
+
     labels = (
         tuple(system.state_labels())
         if hasattr(system, "state_labels")
@@ -167,6 +230,7 @@ def simulate(
         state_labels=labels,
         system_name=getattr(system, "name", system.__class__.__name__),
         method=method,
+        inputs=inputs_array,
     )
 
 
@@ -234,4 +298,4 @@ class ContinuousProcess(Entity):
             else tuple(f"x{i}" for i in range(self.state.size)),
             system_name=getattr(self.system, "name", self.system.__class__.__name__),
             method=self.method,
-        )
+        )