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

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]: