对齐AMESim管阻孔口与储气耦合

app/simulation/systems/generic.py

@@ -9,6 +9,10 @@ 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.mechanical import MechanicalStateReducer
+from app.simulation.solvers.pneumatic_storage import (
+    IdealPneumaticStorageReducer,
+    ideal_storage_group_is_reducible,
+)
 from app.simulation.solvers.pneumatic_volume import PneumaticVolumeResolver
 from app.simulation.solvers.solver import ODESolution, SolveIVPConfig, integrate_ode
 from app.simulation.solvers.signal import SignalResolver
@@ -182,13 +186,19 @@ def simulation_preparation_issues(
                     for endpoint in pressure_ports:
                         storage_ports[endpoint] = component.name
 
-        storages_by_group: dict[Endpoint, set[str]] = {}
+        storages_by_group: dict[Endpoint, dict[Endpoint, str]] = {}
         for endpoint, component_name in storage_ports.items():
-            storages_by_group.setdefault(effort_groups.find(endpoint), set()).add(
-                component_name
-            )
-        for storage_names in storages_by_group.values():
+            storages_by_group.setdefault(effort_groups.find(endpoint), {})[
+                endpoint
+            ] = component_name
+        for storage_endpoints in storages_by_group.values():
+            storage_names = set(storage_endpoints.values())
             if len(storage_names) > 1:
+                if ideal_storage_group_is_reducible(
+                    network,
+                    storage_endpoints,
+                ):
+                    continue
                 issues.append(
                     SimulationPreparationIssue(
                         "IDEAL_STORAGE_COUPLING_UNSUPPORTED",
@@ -238,6 +248,10 @@ class GenericFluidSystem:
             network,
             self.dynamic_components,
         )
+        self.pneumatic_storage_reducer = IdealPneumaticStorageReducer(
+            network,
+            self.mechanical_state_reducer,
+        )
         self.pressure_flow_solver = PressureFlowSolver(network)
         self.pneumatic_volume_resolver = PneumaticVolumeResolver(network)
         self.signal_resolver = SignalResolver(network)
@@ -250,10 +264,15 @@ class GenericFluidSystem:
         self.pneumatic_volume_propagation_count = 0
 
     def initial_state_vector(self) -> list[float]:
-        return self.mechanical_state_reducer.initial_state_vector()
+        return self.pneumatic_storage_reducer.synchronize_state_vector(
+            self.mechanical_state_reducer.initial_state_vector(),
+            validate=True,
+        )
 
     def apply_state_vector(self, values: list[float]) -> None:
-        self.mechanical_state_reducer.apply_state_vector(values)
+        self.mechanical_state_reducer.apply_state_vector(
+            self.pneumatic_storage_reducer.synchronize_state_vector(values)
+        )
 
     def _close_current_state(self, time: float) -> dict[str, dict[str, float]]:
         signal = self.signal_resolver.solve(time)
@@ -298,7 +317,9 @@ class GenericFluidSystem:
     def rhs(self, _time: float, state_vector: list[float]) -> list[float]:
         self.apply_state_vector(state_vector)
         connected_h = self._close_current_state(_time)
-        return self.mechanical_state_reducer.state_derivatives(connected_h)
+        return self.pneumatic_storage_reducer.coupled_derivatives(
+            self.mechanical_state_reducer.state_derivatives(connected_h)
+        )
 
     def _append_current_state(self, series: dict[str, list[float]]) -> None:
         for component in self.network.components.values():