完善建模交互、组件图标与系统协议

tests/test_amesim_mechanical_public_components.py

@@ -43,14 +43,36 @@ class AmesimMechanicalPublicComponentTests(unittest.TestCase):
         self.assertAlmostEqual(converter.output_force, 20.0)
         self.assertAlmostEqual(residuals[0].value, 0.0)
         self.assertEqual(converter.component_result_values(), {"force": 20.0})
+        self.assertEqual(converter.parameter_values, {"direction": 1.0})
 
-        converter.apply_layout_transform(rotation=180, mirrored=False)
+    def test_forc_negative_direction_reverses_applied_force(self) -> None:
+        converter = AmesimForc.create(
+            name="force_reverse",
+            medium=self.medium,
+            parameters={"direction": -1.0},
+        )
+        converter.res.signal = 20.0
         converter.port_2.f = 20.0
+
         self.assertAlmostEqual(
             converter.pressure_flow_equation_residuals()[0].value,
             0.0,
         )
-        self.assertEqual(converter.component_result_values(), {"force": 20.0})
+        self.assertEqual(converter.parameter_values, {"direction": -1.0})
+        self.assertEqual(converter.component_result_values(), {"force": -20.0})
+
+    def test_forc_direction_only_accepts_positive_or_negative_one(self) -> None:
+        definition = AmesimForc.PARAMETERS[0]
+
+        self.assertEqual(AmesimForc.MODEL_VERSION, "0.2.0")
+        self.assertEqual(definition.name, "direction")
+        self.assertEqual(definition.default, 1.0)
+        self.assertEqual(
+            tuple((option.value, option.label) for option in definition.options),
+            ((1.0, "正向"), (-1.0, "反向")),
+        )
+        with self.assertRaisesRegex(ValueError, "must be one of 1, -1"):
+            AmesimForc("invalid_force", direction=0.0)
 
     def test_mecmas21_acceleration_uses_connected_port_forces(self) -> None:
         mass = AmesimMecmas21(
@@ -113,6 +135,8 @@ class AmesimMechanicalPublicComponentTests(unittest.TestCase):
             "strib": ((1.0, "否"), (2.0, "是")),
             "frictionType": ((1.0, "简单"), (2.0, "高级")),
         }
+        self.assertEqual(definitions["useFriction"].default, 2.0)
+        self.assertEqual(definitions["stoptype"].default, 1.0)
 
         for name, options in expected_options.items():
             with self.subTest(name=name):
@@ -200,19 +224,25 @@ class AmesimMechanicalPublicComponentTests(unittest.TestCase):
         node.port_2.x = 0.2
         node.port_2.v = 0.3
         node.port_2.f = 6.0
-        node.port_9.x = 0.2
-        node.port_9.v = 0.3
-        node.port_9.f = -10.0
+        node.port_3.x = 0.2
+        node.port_3.v = 0.3
+        node.port_3.f = -10.0
 
         residuals = node.pressure_flow_equation_residuals()
 
-        self.assertEqual(node.active_ports, ("port_1", "port_2", "port_9"))
+        self.assertEqual(node.active_ports, ("port_1", "port_2", "port_3"))
         self.assertAlmostEqual(node.total_force, 10.0)
         self.assertAlmostEqual(node.force_balance, 0.0)
-        self.assertEqual(len(residuals), 5)
+        self.assertEqual(len(residuals), 5 + 18 * 3)
         self.assertTrue(all(abs(residual.value) <= 1.0e-12 for residual in residuals))
         self.assertEqual(node.component_result_values(), {"tforce": 10.0})
 
+    def test_lmechn1_defaults_to_two_right_ports(self) -> None:
+        node = AmesimLmechn1("node_default", self.medium)
+
+        self.assertEqual(node.v1, 2)
+        self.assertEqual(node.active_ports, ("port_1", "port_2", "port_3"))
+
     def test_lmechn1_registry_rejects_fractional_integer_options(self) -> None:
         with self.assertRaisesRegex(ValueError, "v1 must be an integer"):
             COMPONENT_MODEL_REGISTRY["amesim_lmechn1"].create(
@@ -221,6 +251,16 @@ class AmesimMechanicalPublicComponentTests(unittest.TestCase):
                 {"v1": 2.5},
             )
 
+    def test_lmechn1_supports_twenty_right_ports(self) -> None:
+        node = AmesimLmechn1("node_20", self.medium, v1=20.0, sum=1.0)
+
+        self.assertEqual(
+            node.active_ports,
+            tuple(f"port_{index}" for index in range(1, 22)),
+        )
+        with self.assertRaisesRegex(ValueError, "must be at most 20"):
+            AmesimLmechn1("node_21", self.medium, v1=21.0, sum=1.0)
+
     def test_lstp00a_generates_opposing_contact_forces(self) -> None:
         contact = AmesimLstp00a(
             "contact_1",