完善MECMAS21参数配置与分组交互

tests/test_amesim_mechanical_xml.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import unittest
+from xml.etree import ElementTree as ET
 
 from app.main import (
     ReactFlowProjectPayload,
     build_reactflow_system_xml,
     compile_reactflow_network,
+    reactflow_project_storage_data,
     run_system_xml_simulation,
 )
 from app.system_xml import validate_system_xml_document
@@ -61,9 +63,61 @@ def mechanical_port(name: str, side: str) -> dict[str, str]:
     return physical_port(name, "bidirectional", side, domain="mechanical")
 
 
+def mecmas_parameter_encoding_project(
+    use_friction: float,
+    strib: float,
+    *,
+    encoding_version: int | None,
+) -> ReactFlowProjectPayload:
+    parameters = {
+        **MECMAS21_DEFAULTS,
+        "useFriction": use_friction,
+        "strib": strib,
+    }
+    version = (
+        {"amesimParameterEncodingVersion": encoding_version}
+        if encoding_version is not None
+        else {}
+    )
+    return ReactFlowProjectPayload(
+        name="amesim-mecmas21-parameter-encoding",
+        nodes=[
+            component_node(
+                "mass_1",
+                "amesim_mecmas21",
+                [
+                    mechanical_port("port_1", "left"),
+                    mechanical_port("port_2", "right"),
+                ],
+                parameters,
+            ),
+        ],
+        edges=[],
+        simulation={
+            "t_start": 0.0,
+            "t_stop": 0.02,
+            "step": 0.01,
+            "max_step": 0.01,
+            "method": "BDF",
+        },
+        **version,
+    )
+
+
+def mecmas_xml_parameter_values(xml: bytes) -> tuple[ET.Element, dict[str, float]]:
+    root = ET.fromstring(xml)
+    component = root.find("./Components/Component[@id='mass_1']")
+    assert component is not None
+    return root, {
+        str(parameter.get("name")): float(str(parameter.get("value")))
+        for parameter in component.findall("Parameter")
+    }
+
+
 def zero_force_mass_project() -> ReactFlowProjectPayload:
     return ReactFlowProjectPayload(
         name="amesim-mechanical-zero-force-smoke",
+        amesimParameterEncodingVersion=1,
         nodes=[
             component_node("zero_left", "amesim_f000", [mechanical_port("port_1", "right")]),
             component_node(
@@ -87,6 +141,7 @@ def signal_force_mass_project() -> ReactFlowProjectPayload:
     parameters["mass"] = 2.0
     return ReactFlowProjectPayload(
         name="amesim-mechanical-signal-force-smoke",
+        amesimParameterEncodingVersion=1,
         nodes=[
             component_node(
                 "force_signal",
@@ -151,6 +206,7 @@ def elastic_contact_project() -> ReactFlowProjectPayload:
     right_parameters["x0"] = 0.0
     return ReactFlowProjectPayload(
         name="amesim-mechanical-elastic-contact-smoke",
+        amesimParameterEncodingVersion=1,
         nodes=[
             component_node("zero_left", "amesim_f000", [mechanical_port("port_1", "right")]),
             component_node(
@@ -196,6 +252,7 @@ def force_node_mass_project() -> ReactFlowProjectPayload:
     ]
     return ReactFlowProjectPayload(
         name="amesim-mechanical-node-smoke",
+        amesimParameterEncodingVersion=1,
         nodes=[
             component_node(
                 "step_1",
@@ -231,6 +288,229 @@ def force_node_mass_project() -> ReactFlowProjectPayload:
 
 class AmesimMechanicalXmlTests(unittest.TestCase):
 
+    def test_sparse_legacy_reactflow_mecmas_defaults_are_canonicalized(
+        self,
+    ) -> None:
+        project = mecmas_parameter_encoding_project(
+            1.0,
+            1.0,
+            encoding_version=None,
+        )
+        project.nodes[0].data.parameters.pop("useFriction")
+        project.nodes[0].data.parameters.pop("strib")
+
+        network = compile_reactflow_network(project)
+        mass = network.components["mass_1"]
+        self.assertEqual(mass.parameter_values["useFriction"], 2.0)
+        self.assertEqual(mass.parameter_values["strib"], 2.0)
+        self.assertTrue(mass.use_friction)
+
+        xml = build_reactflow_system_xml(project)
+        root, parameters = mecmas_xml_parameter_values(xml)
+        self.assertEqual(root.get("amesimParameterEncodingVersion"), "1")
+        self.assertEqual(parameters["useFriction"], 2.0)
+        self.assertEqual(parameters["strib"], 2.0)
+
+        report = validate_system_xml_document(xml)
+        self.assertTrue(report.valid, report.as_dict())
+        assert report.document is not None
+        normalized_project = ReactFlowProjectPayload(
+            **report.document.as_project_data()
+        )
+        normalized_mass = compile_reactflow_network(normalized_project).components[
+            "mass_1"
+        ]
+        self.assertEqual(normalized_mass.parameter_values["useFriction"], 2.0)
+        self.assertEqual(normalized_mass.parameter_values["strib"], 2.0)
+        self.assertTrue(normalized_mass.use_friction)
+
+        stored_data = reactflow_project_storage_data(project)
+        self.assertEqual(stored_data["amesimParameterEncodingVersion"], 1)
+        stored_parameters = stored_data["nodes"][0]["data"]["parameters"]
+        self.assertEqual(stored_parameters["useFriction"], 2.0)
+        self.assertEqual(stored_parameters["strib"], 2.0)
+        stored_mass = compile_reactflow_network(
+            ReactFlowProjectPayload(**stored_data)
+        ).components["mass_1"]
+        self.assertTrue(stored_mass.use_friction)
+
+    def test_legacy_reactflow_mecmas_codes_compile_and_export_as_canonical(
+        self,
+    ) -> None:
+        for legacy_value, canonical_value in ((0.0, 1.0), (1.0, 2.0)):
+            with self.subTest(legacy_value=legacy_value):
+                project = mecmas_parameter_encoding_project(
+                    legacy_value,
+                    legacy_value,
+                    encoding_version=None,
+                )
+
+                network = compile_reactflow_network(project)
+                mass = network.components["mass_1"]
+                self.assertEqual(
+                    mass.parameter_values["useFriction"],
+                    canonical_value,
+                )
+                self.assertEqual(
+                    mass.parameter_values["strib"],
+                    canonical_value,
+                )
+                self.assertEqual(
+                    mass.use_friction,
+                    canonical_value == 2.0,
+                )
+
+                root, parameters = mecmas_xml_parameter_values(
+                    build_reactflow_system_xml(project)
+                )
+                self.assertEqual(
+                    root.get("amesimParameterEncodingVersion"),
+                    "1",
+                )
+                self.assertEqual(
+                    parameters["useFriction"],
+                    canonical_value,
+                )
+                self.assertEqual(parameters["strib"], canonical_value)
+
+    def test_versioned_reactflow_mecmas_codes_are_not_reinterpreted(self) -> None:
+        project = mecmas_parameter_encoding_project(
+            1.0,
+            2.0,
+            encoding_version=1,
+        )
+
+        network = compile_reactflow_network(project)
+        mass = network.components["mass_1"]
+        self.assertEqual(mass.parameter_values["useFriction"], 1.0)
+        self.assertEqual(mass.parameter_values["strib"], 2.0)
+
+    def test_legacy_system_xml_mecmas_codes_are_migrated_with_warning(self) -> None:
+        for legacy_value, canonical_value in ((0.0, 1.0), (1.0, 2.0)):
+            with self.subTest(legacy_value=legacy_value):
+                root, _ = mecmas_xml_parameter_values(
+                    build_reactflow_system_xml(
+                        mecmas_parameter_encoding_project(
+                            1.0,
+                            1.0,
+                            encoding_version=1,
+                        )
+                    )
+                )
+                del root.attrib["amesimParameterEncodingVersion"]
+                component = root.find("./Components/Component[@id='mass_1']")
+                assert component is not None
+                for parameter in component.findall("Parameter"):
+                    if parameter.get("name") in {"useFriction", "strib"}:
+                        parameter.set("value", str(legacy_value))
+
+                report = validate_system_xml_document(
+                    ET.tostring(root, encoding="utf-8", xml_declaration=True)
+                )
+
+                self.assertTrue(report.valid, report.as_dict())
+                migration_issues = [
+                    issue
+                    for issue in report.issues
+                    if issue.code == "AMESIM_PARAMETER_ENCODING_MIGRATED"
+                ]
+                self.assertEqual(len(migration_issues), 1)
+                self.assertTrue(
+                    all(issue.severity == "warning" for issue in migration_issues)
+                )
+                assert report.document is not None
+                migrated = {
+                    parameter.name: parameter.value
+                    for parameter in report.document.components[0].parameters
+                }
+                self.assertEqual(
+                    migrated["useFriction"],
+                    canonical_value,
+                )
+                self.assertEqual(migrated["strib"], canonical_value)
+                self.assertEqual(
+                    report.document.amesim_parameter_encoding_version,
+                    "1",
+                )
+                self.assertEqual(
+                    report.document.as_project_data()[
+                        "amesimParameterEncodingVersion"
+                    ],
+                    1,
+                )
+
+    def test_sparse_legacy_system_xml_mecmas_defaults_are_migrated(self) -> None:
+        root, _ = mecmas_xml_parameter_values(
+            build_reactflow_system_xml(
+                mecmas_parameter_encoding_project(
+                    1.0,
+                    1.0,
+                    encoding_version=1,
+                )
+            )
+        )
+        del root.attrib["amesimParameterEncodingVersion"]
+        component = root.find("./Components/Component[@id='mass_1']")
+        assert component is not None
+        for parameter in list(component.findall("Parameter")):
+            if parameter.get("name") in {"useFriction", "strib"}:
+                component.remove(parameter)
+
+        report = validate_system_xml_document(
+            ET.tostring(root, encoding="utf-8", xml_declaration=True)
+        )
+
+        self.assertTrue(report.valid, report.as_dict())
+        migration_issues = [
+            issue
+            for issue in report.issues
+            if issue.code == "AMESIM_PARAMETER_ENCODING_MIGRATED"
+        ]
+        self.assertEqual(len(migration_issues), 1)
+        self.assertEqual(migration_issues[0].severity, "warning")
+        assert report.document is not None
+        self.assertEqual(report.document.amesim_parameter_encoding_version, "1")
+        parameters = {
+            parameter.name: parameter.value
+            for parameter in report.document.components[0].parameters
+        }
+        self.assertEqual(parameters["useFriction"], 2.0)
+        self.assertEqual(parameters["strib"], 2.0)
+
+        normalized_project = ReactFlowProjectPayload(
+            **report.document.as_project_data()
+        )
+        normalized_mass = compile_reactflow_network(normalized_project).components[
+            "mass_1"
+        ]
+        self.assertEqual(normalized_mass.parameter_values["useFriction"], 2.0)
+        self.assertEqual(normalized_mass.parameter_values["strib"], 2.0)
+        self.assertTrue(normalized_mass.use_friction)
+
+    def test_versioned_system_xml_mecmas_codes_are_not_migrated(self) -> None:
+        xml = build_reactflow_system_xml(
+            mecmas_parameter_encoding_project(
+                1.0,
+                1.0,
+                encoding_version=1,
+            )
+        )
+
+        report = validate_system_xml_document(xml)
+
+        self.assertTrue(report.valid, report.as_dict())
+        self.assertNotIn(
+            "AMESIM_PARAMETER_ENCODING_MIGRATED",
+            {issue.code for issue in report.issues},
+        )
+        assert report.document is not None
+        parameters = {
+            parameter.name: parameter.value
+            for parameter in report.document.components[0].parameters
+        }
+        self.assertEqual(parameters["useFriction"], 1.0)
+        self.assertEqual(parameters["strib"], 1.0)
+
 
     def test_force_node_mass_project_compiles_and_simulates(self) -> None:
         xml = build_reactflow_system_xml(force_node_mass_project())