同步仿真框架并接入AMESim气动组件

app/simulation/solvers/__init__.py

@@ -0,0 +1 @@
+"""Numerical solvers used by simulation systems."""

app/simulation/solvers/algebraic.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from math import sqrt
+
+from app.simulation.core.ports import PortState, VariableRole
+from app.simulation.systems.network import SimulationNetwork
+
+
+class AlgebraicSolveError(RuntimeError):
+    def __init__(self, message: str, diagnostics: "AlgebraicSolveDiagnostics") -> None:
+        super().__init__(message)
+        self.diagnostics = diagnostics
+
+
+@dataclass(frozen=True)
+class AlgebraicUnknown:
+    component: str
+    port: str
+    variable: str
+    role: VariableRole
+    state: PortState
+
+    @property
+    def id(self) -> str:
+        return f"{self.component}.{self.port}.{self.variable}"
+
+    def read(self) -> float:
+        return float(getattr(self.state, self.variable))
+
+    def write(self, value: float) -> None:
+        setattr(self.state, self.variable, float(value))
+
+
+@dataclass(frozen=True)
+class AlgebraicSolveDiagnostics:
+    success: bool
+    message: str
+    evaluations: int
+    pressure_scale: float
+    flow_scale: float
+    max_scaled_residual: float
+    max_raw_residual: float
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "success": self.success,
+            "message": self.message,
+            "evaluations": self.evaluations,
+            "pressureScale": self.pressure_scale,
+            "flowScale": self.flow_scale,
+            "maxScaledResidual": self.max_scaled_residual,
+            "maxRawResidual": self.max_raw_residual,
+        }
+
+
+class PressureFlowSolver:
+    """Solve the acausal pressure-flow subsystem for a compiled network."""
+
+    def __init__(
+        self,
+        network: SimulationNetwork,
+        *,
+        residual_tolerance: float = 1e-7,
+        max_evaluations: int = 500,
+    ) -> None:
+        self.network = network
+        self.residual_tolerance = residual_tolerance
+        self.max_evaluations = max_evaluations
+        self.unknowns = self._build_unknowns()
+        self.last_diagnostics: AlgebraicSolveDiagnostics | None = None
+
+    def _build_unknowns(self) -> tuple[AlgebraicUnknown, ...]:
+        unknowns: list[AlgebraicUnknown] = []
+        for component in self.network.components.values():
+            for definition in component.port_definitions:
+                if definition.kind != "physical":
+                    continue
+                state = component.get_port(definition.name)
+                for variable in definition.variables:
+                    if variable.role not in {"effort", "flow"}:
+                        continue
+                    unknowns.append(
+                        AlgebraicUnknown(
+                            component=component.name,
+                            port=definition.name,
+                            variable=variable.name,
+                            role=variable.role,
+                            state=state,
+                        )
+                    )
+        return tuple(unknowns)
+
+    def _seed_equal_pressures(self) -> None:
+        for _ in range(max(2, len(self.network.connections))):
+            changed = False
+            for connection in self.network.connections:
+                if connection.kind != "physical":
+                    continue
+                first = self.network.components[
+                    connection.endpoint_a.component
+                ].get_port(connection.endpoint_a.port)
+                second = self.network.components[
+                    connection.endpoint_b.component
+                ].get_port(connection.endpoint_b.port)
+                if first.p > 0.0 and second.p <= 0.0:
+                    second.p = first.p
+                    changed = True
+                elif second.p > 0.0 and first.p <= 0.0:
+                    first.p = second.p
+                    changed = True
+
+            for component in self.network.components.values():
+                equal_pressure_equations = [
+                    equation
+                    for equation in component.pressure_flow_equation_residuals()
+                    if equation.relation == "equal" and equation.role == "effort"
+                ]
+                for equation in equal_pressure_equations:
+                    states = []
+                    for variable in equation.variables:
+                        _, port_name, variable_name = variable.rsplit(".", 2)
+                        if variable_name == "p":
+                            states.append(component.get_port(port_name))
+                    if len(states) != 2:
+                        continue
+                    first, second = states
+                    if first.p > 0.0 and second.p <= 0.0:
+                        second.p = first.p
+                        changed = True
+                    elif second.p > 0.0 and first.p <= 0.0:
+                        first.p = second.p
+                        changed = True
+            if not changed:
+                break
+
+    def _scales(self) -> tuple[float, float]:
+        pressure_scale = max(
+            [
+                abs(unknown.read())
+                for unknown in self.unknowns
+                if unknown.role == "effort" and unknown.read() > 0.0
+            ]
+            + [1e5]
+        )
+        estimated_flows = [
+            abs(float(getattr(component, "K_eff"))) * sqrt(pressure_scale)
+            for component in self.network.components.values()
+            if hasattr(component, "K_eff")
+        ]
+        flow_scale = max(
+            estimated_flows
+            + [
+                abs(unknown.read())
+                for unknown in self.unknowns
+                if unknown.role == "flow"
+            ]
+            + [1e-3]
+        )
+        return pressure_scale, flow_scale
+
+    def solve(self) -> AlgebraicSolveDiagnostics:
+        try:
+            import numpy as np
+            from scipy.optimize import least_squares
+        except ImportError as exc:
+            raise RuntimeError(
+                "Topology-driven simulation requires SciPy; install requirements.txt."
+            ) from exc
+
+        self._seed_equal_pressures()
+        pressure_scale, flow_scale = self._scales()
+        positive_pressures = [
+            unknown.read()
+            for unknown in self.unknowns
+            if unknown.role == "effort" and unknown.read() > 0.0
+        ]
+        fallback_pressure = (
+            sum(positive_pressures) / len(positive_pressures)
+            if positive_pressures
+            else pressure_scale
+        )
+
+        def variable_scale(unknown: AlgebraicUnknown) -> float:
+            return pressure_scale if unknown.role == "effort" else flow_scale
+
+        x0 = np.asarray(
+            [
+                (
+                    unknown.read()
+                    if unknown.role != "effort" or unknown.read() > 0.0
+                    else fallback_pressure
+                )
+                / variable_scale(unknown)
+                for unknown in self.unknowns
+            ],
+            dtype=float,
+        )
+        lower = np.asarray(
+            [
+                1.0 / pressure_scale if unknown.role == "effort" else -np.inf
+                for unknown in self.unknowns
+            ]
+        )
+        upper = np.full(len(self.unknowns), np.inf)
+
+        def assign(values) -> None:
+            for unknown, value in zip(self.unknowns, values):
+                unknown.write(float(value) * variable_scale(unknown))
+
+        def scaled_residuals(values):
+            assign(values)
+            equations = self.network.pressure_flow_equation_residuals()
+            return np.asarray(
+                [
+                    equation.value
+                    / (pressure_scale if equation.role == "effort" else flow_scale)
+                    for equation in equations
+                ],
+                dtype=float,
+            )
+
+        result = least_squares(
+            scaled_residuals,
+            x0,
+            bounds=(lower, upper),
+            x_scale="jac",
+            ftol=1e-10,
+            xtol=1e-10,
+            gtol=1e-10,
+            max_nfev=self.max_evaluations,
+        )
+        assign(result.x)
+        equations = self.network.pressure_flow_equation_residuals()
+        scaled = [
+            abs(
+                equation.value
+                / (pressure_scale if equation.role == "effort" else flow_scale)
+            )
+            for equation in equations
+        ]
+        success = bool(result.success) and max(scaled, default=0.0) <= self.residual_tolerance
+        diagnostics = AlgebraicSolveDiagnostics(
+            success=success,
+            message=str(result.message),
+            evaluations=int(result.nfev),
+            pressure_scale=pressure_scale,
+            flow_scale=flow_scale,
+            max_scaled_residual=max(scaled, default=0.0),
+            max_raw_residual=max((abs(item.value) for item in equations), default=0.0),
+        )
+        self.last_diagnostics = diagnostics
+        if not success:
+            raise AlgebraicSolveError(
+                "Pressure-flow equations did not converge to the requested tolerance.",
+                diagnostics,
+            )
+        return diagnostics

app/simulation/solvers/solver.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Literal
+
+
+CancellationCheck = Callable[[], bool]
+AcceptedStepCallback = Callable[[float], None]
+IntegrationStatus = Literal["completed", "cancelled", "failed"]
+
+
+class _IntegrationCancelled(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class SolveIVPConfig:
+    t_start: float = 0.0
+    t_stop: float = 20.0
+    method: str = "BDF"
+    rtol: float = 1e-6
+    atol: float = 1e-8
+    max_step: float = 1e-3
+
+
+@dataclass(frozen=True)
+class ODESolution:
+    t: list[float]
+    y: list[list[float]]
+    success: bool
+    message: str
+    status: IntegrationStatus = "completed"
+    error: Exception | None = None
+
+
+def _vector_add(a: list[float], b: list[float], scale: float = 1.0) -> list[float]:
+    return [x + scale * y for x, y in zip(a, b)]
+
+
+def _append_solution_sample(
+    times: list[float],
+    states: list[list[float]],
+    time: float,
+    state: list[float],
+) -> None:
+    if times and time <= times[-1] + 1e-12:
+        return
+    times.append(float(time))
+    for index, value in enumerate(state):
+        states[index].append(float(value))
+
+
+def _runge_kutta_4(
+    rhs: Callable[[float, list[float]], list[float]],
+    initial_state: list[float],
+    config: SolveIVPConfig,
+    t_eval: list[float] | None,
+    cancel_check: CancellationCheck | None = None,
+    accepted_step_callback: AcceptedStepCallback | None = None,
+) -> ODESolution:
+    if t_eval is None:
+        point_count = max(
+            2,
+            int((config.t_stop - config.t_start) / max(config.max_step, 1e-6)) + 1,
+        )
+        step = (config.t_stop - config.t_start) / (point_count - 1)
+        t_eval = [config.t_start + index * step for index in range(point_count)]
+
+    state = list(initial_state)
+    states = [[value] for value in state]
+    times = [float(t_eval[0])]
+    current_time = float(t_eval[0])
+    status: IntegrationStatus = "completed"
+    message = "Integrated with built-in RK4 fallback because SciPy is unavailable."
+    error: Exception | None = None
+
+    try:
+        for target_time in t_eval[1:]:
+            while current_time < target_time - 1e-15:
+                if cancel_check is not None and cancel_check():
+                    raise _IntegrationCancelled
+                dt = min(config.max_step, target_time - current_time)
+                k1 = rhs(current_time, state)
+                k2 = rhs(current_time + 0.5 * dt, _vector_add(state, k1, 0.5 * dt))
+                k3 = rhs(current_time + 0.5 * dt, _vector_add(state, k2, 0.5 * dt))
+                k4 = rhs(current_time + dt, _vector_add(state, k3, dt))
+                state = [
+                    value + (dt / 6.0) * (a + 2.0 * b + 2.0 * c + d)
+                    for value, a, b, c, d in zip(state, k1, k2, k3, k4)
+                ]
+                current_time += dt
+                if accepted_step_callback is not None:
+                    accepted_step_callback(current_time)
+
+            _append_solution_sample(times, states, target_time, state)
+    except _IntegrationCancelled:
+        status = "cancelled"
+        message = "Simulation was stopped before reaching the requested end time."
+        _append_solution_sample(times, states, current_time, state)
+    except Exception as exc:
+        status = "failed"
+        message = str(exc)
+        error = exc
+        _append_solution_sample(times, states, current_time, state)
+
+    return ODESolution(
+        t=times,
+        y=states,
+        success=status == "completed",
+        message=message,
+        status=status,
+        error=error,
+    )
+
+
+def _integrate_scipy_stepwise(
+    rhs: Callable[[float, list[float]], list[float]],
+    initial_state: list[float],
+    config: SolveIVPConfig,
+    t_eval: list[float] | None,
+    cancel_check: CancellationCheck,
+    accepted_step_callback: AcceptedStepCallback | None,
+) -> ODESolution:
+    import numpy as np
+    from scipy.integrate import BDF, DOP853, LSODA, RK23, RK45, Radau
+
+    solver_types = {
+        "BDF": BDF,
+        "DOP853": DOP853,
+        "LSODA": LSODA,
+        "RK23": RK23,
+        "RK45": RK45,
+        "Radau": Radau,
+    }
+    solver_type = solver_types.get(config.method)
+    if solver_type is None:
+        raise ValueError(f"Unsupported integration method: {config.method}")
+
+    times = [float(config.t_start)]
+    states = [[float(value)] for value in initial_state]
+    last_accepted_time = float(config.t_start)
+    last_accepted_state = [float(value) for value in initial_state]
+    sample_times = list(t_eval or [])
+    sample_index = 0
+    while (
+        sample_index < len(sample_times)
+        and sample_times[sample_index] <= config.t_start + 1e-12
+    ):
+        sample_index += 1
+
+    def cancellable_rhs(time, state):
+        if cancel_check():
+            raise _IntegrationCancelled
+        return rhs(float(time), [float(value) for value in state])
+
+    if cancel_check():
+        return ODESolution(
+            t=times,
+            y=states,
+            success=False,
+            message="Simulation was stopped before integration started.",
+            status="cancelled",
+        )
+
+    try:
+        solver = solver_type(
+            cancellable_rhs,
+            config.t_start,
+            np.asarray(initial_state, dtype=float),
+            config.t_stop,
+            rtol=config.rtol,
+            atol=config.atol,
+            max_step=config.max_step,
+        )
+    except _IntegrationCancelled:
+        return ODESolution(
+            t=times,
+            y=states,
+            success=False,
+            message="Simulation was stopped before integration started.",
+            status="cancelled",
+        )
+    except Exception as exc:
+        return ODESolution(
+            t=times,
+            y=states,
+            success=False,
+            message=str(exc),
+            status="failed",
+            error=exc,
+        )
+
+    status: IntegrationStatus = "completed"
+    message = "The solver successfully reached the end of the integration interval."
+    error: Exception | None = None
+
+    while solver.status == "running":
+        if cancel_check():
+            status = "cancelled"
+            message = "Simulation was stopped before reaching the requested end time."
+            break
+        try:
+            step_message = solver.step()
+        except _IntegrationCancelled:
+            status = "cancelled"
+            message = "Simulation was stopped before reaching the requested end time."
+            break
+        except Exception as exc:
+            status = "failed"
+            message = str(exc)
+            error = exc
+            break
+
+        if solver.status == "failed":
+            status = "failed"
+            message = str(step_message or "Integration step failed.")
+            break
+
+        last_accepted_time = float(solver.t)
+        last_accepted_state = [float(value) for value in solver.y]
+        if sample_times:
+            dense_output = solver.dense_output()
+            while (
+                sample_index < len(sample_times)
+                and sample_times[sample_index] <= last_accepted_time + 1e-12
+            ):
+                sample_time = float(sample_times[sample_index])
+                sample_state = [float(value) for value in dense_output(sample_time)]
+                _append_solution_sample(times, states, sample_time, sample_state)
+                sample_index += 1
+        else:
+            _append_solution_sample(
+                times,
+                states,
+                last_accepted_time,
+                last_accepted_state,
+            )
+        if accepted_step_callback is not None:
+            accepted_step_callback(last_accepted_time)
+
+    if status != "completed":
+        _append_solution_sample(
+            times,
+            states,
+            last_accepted_time,
+            last_accepted_state,
+        )
+
+    return ODESolution(
+        t=times,
+        y=states,
+        success=status == "completed",
+        message=message,
+        status=status,
+        error=error,
+    )
+
+
+def integrate_ode(
+    rhs: Callable[[float, list[float]], list[float]],
+    initial_state: list[float],
+    config: SolveIVPConfig,
+    t_eval: list[float] | None = None,
+    cancel_check: CancellationCheck | None = None,
+    accepted_step_callback: AcceptedStepCallback | None = None,
+):
+    """Thin wrapper around scipy.integrate.solve_ivp with a pure-Python fallback."""
+
+    if abs(config.t_stop - config.t_start) <= 1e-15:
+        return ODESolution(
+            t=[float(config.t_start)],
+            y=[[value] for value in initial_state],
+            success=True,
+            message="Skipped integration because t_start equals t_stop.",
+        )
+
+    try:
+        from scipy.integrate import solve_ivp
+    except ImportError:
+        return _runge_kutta_4(
+            rhs,
+            initial_state,
+            config,
+            t_eval,
+            cancel_check,
+            accepted_step_callback,
+        )
+
+    if cancel_check is not None:
+        return _integrate_scipy_stepwise(
+            rhs,
+            initial_state,
+            config,
+            t_eval,
+            cancel_check,
+            accepted_step_callback,
+        )
+
+    return solve_ivp(
+        fun=rhs,
+        t_span=(config.t_start, config.t_stop),
+        y0=initial_state,
+        method=config.method,
+        rtol=config.rtol,
+        atol=config.atol,
+        max_step=config.max_step,
+        t_eval=t_eval,
+    )

app/simulation/solvers/stream.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from app.simulation.core.base import DynamicComponent
+from app.simulation.systems.network import Endpoint, SimulationNetwork
+
+
+class StreamSolveError(RuntimeError):
+    def __init__(self, message: str, diagnostics: "StreamSolveDiagnostics") -> None:
+        super().__init__(message)
+        self.diagnostics = diagnostics
+
+
+@dataclass(frozen=True)
+class StreamSolveDiagnostics:
+    converged: bool
+    iterations: int
+    max_delta: float
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "converged": self.converged,
+            "iterations": self.iterations,
+            "maxDelta": self.max_delta,
+        }
+
+
+class StreamResolver:
+    """Resolve outflow enthalpy propagation after pressure and flow are known."""
+
+    def __init__(
+        self,
+        network: SimulationNetwork,
+        *,
+        relative_tolerance: float = 1e-9,
+        max_iterations: int = 100,
+    ) -> None:
+        self.network = network
+        self.relative_tolerance = relative_tolerance
+        self.max_iterations = max_iterations
+        self._connected_endpoint = self._build_connection_map()
+        self.last_diagnostics: StreamSolveDiagnostics | None = None
+
+    def _build_connection_map(self) -> dict[Endpoint, Endpoint]:
+        result: dict[Endpoint, Endpoint] = {}
+        for connection in self.network.connections:
+            if connection.kind != "physical":
+                continue
+            first, second = connection.endpoints
+            result[first] = second
+            result[second] = first
+        return result
+
+    def connected_enthalpies(self) -> dict[str, dict[str, float]]:
+        values: dict[str, dict[str, float]] = {
+            component.name: {} for component in self.network.components.values()
+        }
+        for endpoint, connected in self._connected_endpoint.items():
+            connected_port = self.network.components[connected.component].get_port(
+                connected.port
+            )
+            values[endpoint.component][endpoint.port] = connected_port.h_outflow
+        return values
+
+    def solve(self) -> tuple[StreamSolveDiagnostics, dict[str, dict[str, float]]]:
+        dynamic_components = [
+            component
+            for component in self.network.components.values()
+            if isinstance(component, DynamicComponent)
+        ]
+        for component in dynamic_components:
+            component.refresh_thermodynamic_ports()
+
+        max_delta = 0.0
+        for iteration in range(1, self.max_iterations + 1):
+            previous = {
+                (component.name, port_name): port.h_outflow
+                for component in self.network.components.values()
+                for port_name, port in component.ports.items()
+            }
+            connected = self.connected_enthalpies()
+            for component in self.network.components.values():
+                if isinstance(component, DynamicComponent):
+                    component.refresh_thermodynamic_ports()
+                else:
+                    component.update_stream_outflows(connected[component.name])
+
+            deltas = [
+                abs(port.h_outflow - previous[(component.name, port_name)])
+                for component in self.network.components.values()
+                for port_name, port in component.ports.items()
+            ]
+            magnitudes = [
+                abs(port.h_outflow)
+                for component in self.network.components.values()
+                for port in component.ports.values()
+            ]
+            max_delta = max(deltas, default=0.0)
+            scale = max(magnitudes + [1.0])
+            if max_delta <= self.relative_tolerance * scale:
+                diagnostics = StreamSolveDiagnostics(
+                    converged=True,
+                    iterations=iteration,
+                    max_delta=max_delta,
+                )
+                self.last_diagnostics = diagnostics
+                return diagnostics, self.connected_enthalpies()
+
+        diagnostics = StreamSolveDiagnostics(
+            converged=False,
+            iterations=self.max_iterations,
+            max_delta=max_delta,
+        )
+        self.last_diagnostics = diagnostics
+        raise StreamSolveError(
+            "Stream enthalpy propagation did not converge.",
+            diagnostics,
+        )