公开更多 AMESim 组件并接入信号机械闭环

app/simulation/systems/generic.py

@@ -9,6 +9,7 @@ from app.simulation.core.base import DynamicComponent
 from app.simulation.core.metadata import ResultVariableMetadata
 from app.simulation.solvers.algebraic import PressureFlowSolver
 from app.simulation.solvers.solver import ODESolution, SolveIVPConfig, integrate_ode
+from app.simulation.solvers.signal import SignalResolver
 from app.simulation.solvers.stream import StreamResolver
 from app.simulation.systems.network import Endpoint, SimulationNetwork
 
@@ -111,18 +112,6 @@ def simulation_preparation_issues(
             )
         )
 
-    if any(
-        definition.kind == "signal"
-        for component in network.components.values()
-        for definition in component.port_definitions
-    ):
-        issues.append(
-            SimulationPreparationIssue(
-                "SIGNAL_PORT_UNSUPPORTED",
-                "Signal-port simulation is not implemented in the current MVP solver.",
-            )
-        )
-
     structure = network.pressure_flow_structure_dict()
     if not structure["isSquare"]:
         issues.append(
@@ -244,11 +233,13 @@ class GenericFluidSystem:
         self.network = network
         self.dynamic_components = network.dynamic_components()
         self.pressure_flow_solver = PressureFlowSolver(network)
+        self.signal_resolver = SignalResolver(network)
         self.stream_resolver = StreamResolver(network)
         self.algebraic_solve_count = 0
         self.max_algebraic_residual = 0.0
         self.max_algebraic_evaluations = 0
         self.max_stream_iterations = 0
+        self.signal_propagation_count = 0
 
     def initial_state_vector(self) -> list[float]:
         return self.network.initial_state_vector()
@@ -256,7 +247,9 @@ class GenericFluidSystem:
     def apply_state_vector(self, values: list[float]) -> None:
         self.network.apply_state_vector(values)
 
-    def _close_current_state(self) -> dict[str, dict[str, float]]:
+    def _close_current_state(self, time: float) -> dict[str, dict[str, float]]:
+        signal = self.signal_resolver.solve(time)
+        self.signal_propagation_count += signal.propagated
         for component in self.dynamic_components:
             component.refresh_thermodynamic_ports()
         algebraic = self.pressure_flow_solver.solve()
@@ -279,12 +272,12 @@ class GenericFluidSystem:
     def consistent_initial_state_vector(self) -> list[float]:
         state = self.initial_state_vector()
         self.apply_state_vector(state)
-        self._close_current_state()
+        self._close_current_state(0.0)
         return state
 
     def rhs(self, _time: float, state_vector: list[float]) -> list[float]:
         self.apply_state_vector(state_vector)
-        connected_h = self._close_current_state()
+        connected_h = self._close_current_state(_time)
         derivatives: list[float] = []
         for component in self.dynamic_components:
             derivatives.extend(
@@ -395,7 +388,7 @@ class GenericFluidSystem:
             ]
             try:
                 self.apply_state_vector(state)
-                self._close_current_state()
+                self._close_current_state(times[time_index])
                 self._append_current_state(series)
                 series["time"].append(times[time_index])
             except Exception as exc:
@@ -433,6 +426,14 @@ class GenericFluidSystem:
                     else None
                 ),
             },
+            "signal": {
+                "propagations": self.signal_propagation_count,
+                "last": (
+                    self.signal_resolver.last_diagnostics.as_dict()
+                    if self.signal_resolver.last_diagnostics is not None
+                    else None
+                ),
+            },
             "stateCount": len(initial_state),
             "sampleCount": len(series["time"]),
         }