完善AMESim可配置参数交互

补充气动孔口、动态管路、UD00 与弹性接触组件的离散选项、条件显示和折叠分组。

增加目录协议、非法选项和前端参数表交互回归测试，不修改现有求解公式。

tests/test_amesim_mechanical_public_components.py

@@ -280,6 +280,25 @@ class AmesimMechanicalPublicComponentTests(unittest.TestCase):
                         {name: value},
                     )
 
+    def test_lstp00a_registry_rejects_invalid_choice_values(self) -> None:
+        invalid_options = {
+            "stiffmode": (0.0, 1.5, 3.0),
+            "discContactOption": (0.0, 1.5, 3.0),
+        }
+
+        for name, values in invalid_options.items():
+            for value in values:
+                with self.subTest(name=name, value=value):
+                    with self.assertRaisesRegex(
+                        ValueError,
+                        "must be (?:one of|at least|at most)",
+                    ):
+                        COMPONENT_MODEL_REGISTRY["amesim_lstp00a"].create(
+                            "contact_1",
+                            self.medium,
+                            {name: value},
+                        )
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_amesim_pnl0001_component.py

@@ -45,7 +45,7 @@ class AmesimPnl0001ComponentTests(unittest.TestCase):
                 self.medium,
                 {"gi": 1.5},
             )
-        with self.assertRaisesRegex(ValueError, "mode must be an integer"):
+        with self.assertRaisesRegex(ValueError, "must be one of"):
             COMPONENT_MODEL_REGISTRY["amesim_pnl0001"].create(
                 "pnl_1",
                 self.medium,

tests/test_amesim_pnor001_component.py

@@ -28,7 +28,7 @@ class AmesimPnor001ComponentTests(unittest.TestCase):
         self.assertEqual(orifice.flowset, 1)
 
     def test_rejects_fractional_integer_parameters(self) -> None:
-        with self.assertRaisesRegex(ValueError, "flowset must be an integer"):
+        with self.assertRaisesRegex(ValueError, "must be one of"):
             COMPONENT_MODEL_REGISTRY["amesim_pnor001"].create(
                 "pnor_1",
                 self.medium,

tests/test_amesim_pnvo001_fixed_component.py

@@ -30,7 +30,7 @@ class AmesimPnvo001FixedOpeningComponentTests(unittest.TestCase):
         self.assertEqual(valve.opening, 1.0)
 
     def test_rejects_fractional_flowset(self) -> None:
-        with self.assertRaisesRegex(ValueError, "flowset must be an integer"):
+        with self.assertRaisesRegex(ValueError, "must be one of"):
             COMPONENT_MODEL_REGISTRY["amesim_pnvo001_fixed"].create(
                 "valve_1",
                 self.medium,

tests/test_amesim_signal_components.py

@@ -59,12 +59,31 @@ class AmesimSignalComponentTests(unittest.TestCase):
         self.assertEqual(signal.signal_event_times(0.0, 5.0), (1.0, 2.0, 3.0, 4.0))
 
     def test_ud00_registry_rejects_fractional_stage_controls(self) -> None:
-        with self.assertRaisesRegex(ValueError, "nstages must be an integer"):
+        with self.assertRaisesRegex(ValueError, "must be one of"):
             COMPONENT_MODEL_REGISTRY["amesim_ud00"].create(
                 "piecewise_1",
                 self.medium,
                 {"nstages": 1.5},
             )
+        for name, value in (("nstages", 9.0), ("iscyclic", 2.0)):
+            with self.subTest(name=name):
+                with self.assertRaisesRegex(
+                    ValueError,
+                    "must be (?:one of|at most)",
+                ):
+                    COMPONENT_MODEL_REGISTRY["amesim_ud00"].create(
+                        "piecewise_1",
+                        self.medium,
+                        {name: value},
+                    )
+
+    def test_pnvo001_registry_rejects_invalid_flowset_choice(self) -> None:
+        with self.assertRaisesRegex(ValueError, "must be one of"):
+            COMPONENT_MODEL_REGISTRY["amesim_pnvo001"].create(
+                "valve_1",
+                self.medium,
+                {"flowset": 1.5},
+            )
 
     def test_pnvo001_signal_opening_reads_res_port(self) -> None:
         valve = COMPONENT_MODEL_REGISTRY["amesim_pnvo001"].create(

tests/test_component_catalog.py

@@ -401,6 +401,174 @@ class ComponentCatalogTests(unittest.TestCase):
         self.assertEqual(pnl0003_parameters["p1_0"]["unit"], "Pa")
         self.assertEqual(pnl0003_parameters["T2_0"]["quantity"], "temperature")
 
+    def test_amesim_configurable_parameters_expose_choices_and_groups(self) -> None:
+        def parameters(model_type: str) -> dict[str, dict[str, object]]:
+            return {
+                parameter["name"]: parameter
+                for parameter in self.components[model_type]["parameters"]
+            }
+
+        flow_options = [
+            {"value": 1.0, "label": "Cq"},
+            {"value": 2.0, "label": "Cv"},
+            {"value": 3.0, "label": "Kv"},
+        ]
+        for model_type, area_name in (
+            ("amesim_pnor001", "area"),
+            ("amesim_pnvo001_fixed", "area0"),
+            ("amesim_pnvo001", "area0"),
+        ):
+            with self.subTest(model_type=model_type):
+                component = self.components[model_type]
+                model_parameters = parameters(model_type)
+                self.assertEqual(component["modelVersion"], "0.2.0")
+                self.assertEqual(model_parameters["flowset"]["editor"], "choice")
+                self.assertEqual(model_parameters["flowset"]["options"], flow_options)
+                self.assertEqual(
+                    model_parameters["cq"]["visibleWhen"],
+                    [{"parameter": "flowset", "values": [1.0]}],
+                )
+                self.assertEqual(
+                    model_parameters[area_name]["visibleWhen"],
+                    [{"parameter": "flowset", "values": [1.0]}],
+                )
+                self.assertEqual(
+                    model_parameters["Cv"]["visibleWhen"],
+                    [{"parameter": "flowset", "values": [2.0]}],
+                )
+                self.assertEqual(
+                    model_parameters["Kv"]["visibleWhen"],
+                    [{"parameter": "flowset", "values": [3.0]}],
+                )
+                self.assertEqual(
+                    component["parameterGroups"],
+                    [
+                        {
+                            "id": "flow_coefficient",
+                            "label": "流量系数",
+                            "parameters": ["cq", area_name, "Cv", "Kv"],
+                            "order": 10,
+                            "defaultExpanded": False,
+                        }
+                    ],
+                )
+
+        thermal_options = [
+            {"value": 1.0, "label": "多方过程"},
+            {"value": 2.0, "label": "带换热"},
+        ]
+        for model_type in ("amesim_pnl0001", "amesim_pnl0002", "amesim_pnl0003"):
+            with self.subTest(model_type=model_type):
+                component = self.components[model_type]
+                model_parameters = parameters(model_type)
+                self.assertEqual(component["modelVersion"], "0.2.0")
+                self.assertEqual(model_parameters["mode"]["editor"], "choice")
+                self.assertEqual(model_parameters["mode"]["options"], thermal_options)
+                self.assertEqual(
+                    model_parameters["k"]["visibleWhen"],
+                    [{"parameter": "mode", "values": [1.0]}],
+                )
+                for name in ("kth", "extemp"):
+                    self.assertEqual(
+                        model_parameters[name]["visibleWhen"],
+                        [{"parameter": "mode", "values": [2.0]}],
+                    )
+                self.assertEqual(
+                    component["parameterGroups"],
+                    [
+                        {
+                            "id": "thermodynamics",
+                            "label": "热力学",
+                            "parameters": ["k", "kth", "extemp"],
+                            "order": 10,
+                            "defaultExpanded": False,
+                        }
+                    ],
+                )
+
+        ud00 = self.components["amesim_ud00"]
+        ud00_parameters = parameters("amesim_ud00")
+        self.assertEqual(ud00["modelVersion"], "0.2.0")
+        self.assertEqual(ud00_parameters["nstages"]["editor"], "choice")
+        self.assertEqual(
+            ud00_parameters["nstages"]["options"],
+            [
+                {"value": float(stage_count), "label": str(stage_count)}
+                for stage_count in range(1, 9)
+            ],
+        )
+        self.assertEqual(
+            ud00_parameters["iscyclic"]["options"],
+            [{"value": 0.0, "label": "否"}, {"value": 1.0, "label": "是"}],
+        )
+        self.assertNotIn("visibleWhen", ud00_parameters["start1"])
+        self.assertEqual(
+            ud00_parameters["start2"]["visibleWhen"],
+            [{"parameter": "nstages", "values": [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]}],
+        )
+        self.assertEqual(
+            ud00_parameters["t8"]["visibleWhen"],
+            [{"parameter": "nstages", "values": [8.0]}],
+        )
+        self.assertEqual(
+            ud00["parameterGroups"][0]["parameters"],
+            [
+                name
+                for stage_index in range(1, 9)
+                for name in (
+                    f"start{stage_index}",
+                    f"end{stage_index}",
+                    f"t{stage_index}",
+                )
+            ],
+        )
+
+        lstp = self.components["amesim_lstp00a"]
+        lstp_parameters = parameters("amesim_lstp00a")
+        self.assertEqual(lstp["modelVersion"], "0.2.0")
+        self.assertEqual(
+            lstp_parameters["stiffmode"]["options"],
+            [
+                {"value": 1.0, "label": "数值刚度"},
+                {"value": 2.0, "label": "几何参数"},
+            ],
+        )
+        self.assertEqual(
+            lstp_parameters["discContactOption"]["options"],
+            [
+                {"value": 1.0, "label": "允许负接触力"},
+                {"value": 2.0, "label": "不允许负接触力"},
+            ],
+        )
+        self.assertEqual(
+            lstp_parameters["kcont"]["visibleWhen"],
+            [{"parameter": "stiffmode", "values": [1.0]}],
+        )
+        for name in ("na", "G", "sdiam", "wdiam"):
+            self.assertEqual(
+                lstp_parameters[name]["visibleWhen"],
+                [{"parameter": "stiffmode", "values": [2.0]}],
+            )
+        self.assertEqual(
+            lstp["parameterGroups"],
+            [
+                {
+                    "id": "stiffness",
+                    "label": "刚度",
+                    "parameters": ["kcont", "G", "sdiam", "wdiam", "na"],
+                    "order": 10,
+                    "defaultExpanded": False,
+                },
+                {
+                    "id": "contact",
+                    "label": "接触",
+                    "parameters": ["gap0", "rcont", "Pdis"],
+                    "order": 20,
+                    "defaultExpanded": False,
+                },
+            ],
+        )
+
     def test_every_registered_component_is_in_the_catalog(self) -> None:
         self.assertEqual(
             set(self.components),