优化压力流量求解并达到四路性能门槛

app/simulation/components/amesim/boundary/sources.py

@@ -46,6 +46,9 @@ class AmesimPnpl01(AlgebraicComponent):
     ) -> AmesimPnpl01:
         return cls(name=name)
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (self.port_1.m_flow,)
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             EquationResidual(

app/simulation/components/amesim/flow/orifices.py

@@ -410,6 +410,12 @@ class AmesimPnor001(AlgebraicComponent):
             "gasvel": flow_direction * gas_velocity,
         }
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (
+            self.port_1.m_flow + self.port_2.m_flow,
+            self.port_1.m_flow - self.mass_flow(self.port_1.p, self.port_2.p),
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             EquationResidual(
@@ -832,6 +838,12 @@ class AmesimPnvo001FixedOpening(AlgebraicComponent):
             "gasvel": flow_direction * gas_velocity,
         }
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (
+            self.port_2.m_flow + self.port_3.m_flow,
+            self.port_2.m_flow - self.mass_flow(self.port_2.p, self.port_3.p),
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             EquationResidual(

app/simulation/components/amesim/flow/pipes.py

@@ -317,6 +317,12 @@ class AmesimPnl00r(AlgebraicComponent):
             "ff": self.friction_factor(reynolds),
         }
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (
+            self.port_1.m_flow + self.port_2.m_flow,
+            self.port_1.m_flow - self.mass_flow(self.port_1.p, self.port_2.p),
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             EquationResidual(
@@ -838,6 +844,13 @@ class AmesimPnl0001(ThermodynamicVolumeComponent):
             "ff": self.friction_factor(reynolds),
         }
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        props = self.medium.properties_from_mU(self.state.m, self.state.U, self.volume)
+        return (
+            self.port_2.p - props.p,
+            self.port_1.m_flow - self.mass_flow(self.port_1.p, props.p, props.T),
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         props = self.medium.properties_from_mU(self.state.m, self.state.U, self.volume)
         return (
@@ -1080,6 +1093,25 @@ class AmesimPnl0002(AmesimPnl0001):
             "ff": friction,
         }
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        props = self.medium.properties_from_mU(self.state.m, self.state.U, self.volume)
+        return (
+            self.port_1.m_flow
+            - self.port_mass_flow(
+                self.port_1.p,
+                props.p,
+                props.T,
+                port_name="port_1",
+            ),
+            self.port_2.m_flow
+            - self.port_mass_flow(
+                self.port_2.p,
+                props.p,
+                props.T,
+                port_name="port_2",
+            ),
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         props = self.medium.properties_from_mU(self.state.m, self.state.U, self.volume)
         return (
@@ -1411,6 +1443,14 @@ class AmesimPnl0003(DynamicComponent):
             "ff": self.friction_factor(reynolds),
         }
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        port_1 = self._properties(self.state_1)
+        port_2 = self._properties(self.state_2)
+        return (
+            self.port_1.p - port_1.p,
+            self.port_2.p - port_2.p,
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         port_1 = self._properties(self.state_1)
         port_2 = self._properties(self.state_2)

app/simulation/components/amesim/junctions/nodes.py

@@ -27,6 +27,19 @@ class _AmesimPneumaticNode(AlgebraicComponent):
         for definition in self.PORTS:
             setattr(self, definition.name, self.register_declared_port(definition.name))
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        reference = self.get_port(self.REFERENCE_PORT)
+        return tuple(
+            self.get_port(definition.name).p - reference.p
+            for definition in self.PORTS
+            if definition.name != self.REFERENCE_PORT
+        ) + (
+            sum(
+                self.get_port(definition.name).m_flow
+                for definition in self.PORTS
+            ),
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         reference = self.get_port(self.REFERENCE_PORT)
         residuals: list[EquationResidual] = []

app/simulation/components/amesim/mechanical/pistons.py

@@ -154,6 +154,22 @@ class AmesimPnrp17(AlgebraicComponent):
     def pressure_force(self) -> float:
         return (self.port_1.p - AMESIM_REFERENCE_PRESSURE_PA) * self.effective_area
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        values = [self.port_1.m_flow]
+        effort_pairs = (("port_2", "port_5"), ("port_3", "port_4"))
+        for first_name, second_name in effort_pairs:
+            first = self.get_port(first_name)
+            second = self.get_port(second_name)
+            values.extend((first.x - second.x, first.v - second.v))
+        force = self.pressure_force
+        values.extend(
+            (
+                self.port_2.f + self.port_5.f + force,
+                self.port_3.f + self.port_4.f - force,
+            )
+        )
+        return tuple(values)
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         effort_pairs = (("port_2", "port_5"), ("port_3", "port_4"))
         residuals: list[EquationResidual] = [

app/simulation/components/amesim/mechanical/translational.py

@@ -63,6 +63,9 @@ class AmesimF000(AlgebraicComponent):
     ) -> "AmesimF000":
         return cls(name=name)
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (self.port_1.f,)
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             EquationResidual(
@@ -140,6 +143,11 @@ class AmesimForc(AlgebraicComponent):
     def output_force(self) -> float:
         return self.direction * float(self.res.signal)
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (
+            self.port_2.f + self.output_force,
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             EquationResidual(
@@ -591,6 +599,14 @@ class AmesimMecmas21(DynamicComponent):
             port.x = self.x
             port.v = self.v
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        return (
+            self.port_1.x - self.x,
+            self.port_1.v - self.v,
+            self.port_2.x - self.x,
+            self.port_2.v - self.v,
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         return (
             self._state_residual("port_1", "x", self.port_1.x - self.x),
@@ -992,6 +1008,13 @@ class AmesimLstp00a(AlgebraicComponent):
         self._causal_port_1_v = float(self.port_1.v)
         self._causal_port_2_v = float(self.port_2.v)
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        force = self.contact_force
+        return (
+            self.port_1.f - force,
+            self.port_2.f + force,
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         force = self.contact_force
         return (
@@ -1110,6 +1133,10 @@ class AmesimLmechn1(AlgebraicComponent):
     def active_ports(self) -> tuple[str, ...]:
         return tuple(f"port_{index}" for index in range(1, self.v1 + 2))
 
+    @property
+    def active_port_definitions(self) -> tuple[PortDefinition, ...]:
+        return self.PORTS[: self.v1 + 1]
+
     @property
     def reference_port_name(self) -> str:
         return f"port_{self.v1 + 1}"
@@ -1129,6 +1156,15 @@ class AmesimLmechn1(AlgebraicComponent):
     def force_balance(self) -> float:
         return self.total_force + self.get_port(self.reference_port_name).f
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        reference = self.get_port(self.reference_port_name)
+        values: list[float] = []
+        for port_name in self.active_ports[:-1]:
+            port = self.get_port(port_name)
+            values.extend((port.x - reference.x, port.v - reference.v))
+        values.append(self.force_balance)
+        return tuple(values)
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         reference_name = self.reference_port_name
         reference = self.get_port(reference_name)
@@ -1168,39 +1204,6 @@ class AmesimLmechn1(AlgebraicComponent):
                 value=self.force_balance,
             )
         )
-        for definition in self.PORTS[self.v1 + 1 :]:
-            port = self.get_port(definition.name)
-            residuals.extend(
-                (
-                    EquationResidual(
-                        id=f"{self.name}:{definition.name}_inactive_x",
-                        owner="component",
-                        owner_id=self.name,
-                        relation="constitutive",
-                        variables=(f"{self.name}.{definition.name}.x",),
-                        role="effort",
-                        value=port.x,
-                    ),
-                    EquationResidual(
-                        id=f"{self.name}:{definition.name}_inactive_v",
-                        owner="component",
-                        owner_id=self.name,
-                        relation="constitutive",
-                        variables=(f"{self.name}.{definition.name}.v",),
-                        role="effort",
-                        value=port.v,
-                    ),
-                    EquationResidual(
-                        id=f"{self.name}:{definition.name}_inactive_force",
-                        owner="component",
-                        owner_id=self.name,
-                        relation="constitutive",
-                        variables=(f"{self.name}.{definition.name}.f",),
-                        role="flow",
-                        value=port.f,
-                    ),
-                )
-            )
         return tuple(residuals)
 
     def component_result_values(self) -> Mapping[str, float]:

app/simulation/components/amesim/storage/chambers.py

@@ -217,6 +217,17 @@ class AmesimPnch023(ThermodynamicVolumeComponent):
         )
         return derivative.as_vector()
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        pressure = self.medium.properties_from_mU(
+            self.state.m,
+            self.state.U,
+            self.cvol,
+        ).p
+        return (
+            self.port_1.p - pressure,
+            self.port_2.p - pressure,
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         pressure = self.medium.properties_from_mU(
             self.state.m,
@@ -507,6 +518,17 @@ class AmesimPnch012(ThermodynamicVolumeComponent):
         energy_derivative -= props.p * self.total_volume_rate()
         return VolumeState(m=mass_derivative, U=energy_derivative).as_vector()
 
+    def pressure_flow_equation_values(self) -> tuple[float, ...]:
+        pressure = self.medium.properties_from_mU(
+            self.state.m,
+            self.state.U,
+            self.total_volume(),
+        ).p
+        return tuple(
+            self.get_port(port_name).p - pressure
+            for port_name in ("port_1", "port_2", "port_3", "port_4")
+        )
+
     def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
         pressure = self.medium.properties_from_mU(
             self.state.m,