346 lines
13 KiB
Python
346 lines
13 KiB
Python
from __future__ import annotations
|
|
|
|
import unittest
|
|
|
|
from app.simulation.components.amesim.mechanical.translational import (
|
|
AmesimF000,
|
|
AmesimForc,
|
|
AmesimMecmas21,
|
|
AmesimLstp00a,
|
|
AmesimLmechn1,
|
|
)
|
|
from app.simulation.core.medium import IdealGasMedium
|
|
from app.simulation.registry import COMPONENT_MODEL_REGISTRY
|
|
|
|
|
|
class AmesimMechanicalPublicComponentTests(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self.medium = IdealGasMedium()
|
|
|
|
def test_mecmas21_catalog_ports_follow_amesim_icon_sides(self) -> None:
|
|
self.assertEqual(
|
|
tuple((port.name, port.side) for port in AmesimMecmas21.DISPLAY.ports),
|
|
(("port_2", "left"), ("port_1", "right")),
|
|
)
|
|
|
|
def test_f000_constrains_mechanical_port_force_to_zero(self) -> None:
|
|
source = AmesimF000("zero_1")
|
|
source.port_1.f = 12.5
|
|
|
|
residuals = source.pressure_flow_equation_residuals()
|
|
|
|
self.assertEqual(len(residuals), 1)
|
|
self.assertEqual(residuals[0].variables, ("zero_1.port_1.f",))
|
|
self.assertAlmostEqual(residuals[0].value, 12.5)
|
|
|
|
def test_forc_converts_signal_to_opposing_source_port_force(self) -> None:
|
|
converter = AmesimForc("force_1")
|
|
converter.res.signal = 20.0
|
|
converter.port_2.f = -20.0
|
|
|
|
residuals = converter.pressure_flow_equation_residuals()
|
|
|
|
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})
|
|
|
|
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.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(
|
|
"mass_1",
|
|
self.medium,
|
|
mass=2.0,
|
|
fcoul=0.0,
|
|
rvisc=0.0,
|
|
wind=0.0,
|
|
x0=0.1,
|
|
v0=0.2,
|
|
)
|
|
mass.port_1.f = 10.0
|
|
mass.port_2.f = -2.0
|
|
|
|
self.assertEqual(mass.get_state_vector(), [0.2, 0.1])
|
|
self.assertAlmostEqual(mass.acceleration(), 4.0)
|
|
self.assertEqual(mass.state_derivative_from_ports({}), [4.0, 0.2])
|
|
self.assertAlmostEqual(mass.port_1.x, 0.1)
|
|
self.assertAlmostEqual(mass.port_2.v, 0.2)
|
|
|
|
def test_mecmas21_uses_amesim_one_two_friction_encoding(self) -> None:
|
|
disabled = AmesimMecmas21(
|
|
"mass_disabled",
|
|
self.medium,
|
|
useFriction=1.0,
|
|
fcoul=5.0,
|
|
v0=2.0,
|
|
)
|
|
enabled = AmesimMecmas21(
|
|
"mass_enabled",
|
|
self.medium,
|
|
useFriction=2.0,
|
|
fcoul=5.0,
|
|
v0=2.0,
|
|
)
|
|
|
|
self.assertFalse(disabled.use_friction)
|
|
self.assertEqual(disabled._dry_friction_force(), 0.0)
|
|
self.assertTrue(enabled.use_friction)
|
|
self.assertEqual(enabled._dry_friction_force(), -5.0)
|
|
|
|
def test_mecmas21_choice_metadata_preserves_amesim_codes(self) -> None:
|
|
definitions = {
|
|
definition.name: definition
|
|
for definition in AmesimMecmas21.PARAMETERS
|
|
}
|
|
expected_options = {
|
|
"useFriction": ((1.0, "否"), (2.0, "是")),
|
|
"stoptype": (
|
|
(1.0, "理想限位"),
|
|
(2.0, "弹性限位"),
|
|
(3.0, "恢复碰撞"),
|
|
(4.0, "无限位"),
|
|
),
|
|
"discContactOption": (
|
|
(1.0, "允许负接触力"),
|
|
(2.0, "不允许负接触力"),
|
|
),
|
|
"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):
|
|
definition = definitions[name]
|
|
self.assertEqual(definition.editor, "choice")
|
|
self.assertEqual(
|
|
tuple((option.value, option.label) for option in definition.options),
|
|
options,
|
|
)
|
|
self.assertIn("尚未实现", definitions["frictionType"].description)
|
|
self.assertIn("尚未实现", definitions["strib"].description)
|
|
self.assertEqual(definitions["theta"].label, "倾角（度）")
|
|
self.assertIn("+90°", definitions["theta"].description)
|
|
self.assertIn("-90°", definitions["theta"].description)
|
|
self.assertIn("重力分量", definitions["theta"].description)
|
|
self.assertEqual(AmesimMecmas21.MODEL_VERSION, "0.2.0")
|
|
|
|
def test_mecmas21_visibility_matches_amesim_parameter_dependencies(self) -> None:
|
|
definitions = {
|
|
definition.name: definition
|
|
for definition in AmesimMecmas21.PARAMETERS
|
|
}
|
|
expected_visibility = {
|
|
"fstick": (
|
|
("stoptype", (1.0, 2.0, 4.0)),
|
|
("useFriction", (2.0,)),
|
|
),
|
|
"fcoul": (
|
|
("stoptype", (1.0, 2.0, 4.0)),
|
|
("useFriction", (2.0,)),
|
|
),
|
|
"rvisc": (("useFriction", (2.0,)),),
|
|
"wind": (("useFriction", (2.0,)),),
|
|
"dvel": (
|
|
("stoptype", (1.0, 2.0, 4.0)),
|
|
("useFriction", (2.0,)),
|
|
("frictionType", (2.0,)),
|
|
),
|
|
"restdvel": (("stoptype", (3.0,)),),
|
|
"restcoeff": (("stoptype", (3.0,)),),
|
|
"astrib": (
|
|
("stoptype", (1.0, 2.0, 4.0)),
|
|
("useFriction", (2.0,)),
|
|
("frictionType", (2.0,)),
|
|
("strib", (2.0,)),
|
|
),
|
|
"xmin": (("stoptype", (1.0, 2.0, 3.0)),),
|
|
"Kbmin": (("stoptype", (2.0,)),),
|
|
"Dbmin": (("stoptype", (2.0,)),),
|
|
"Pdmin": (("stoptype", (2.0,)),),
|
|
"xmax": (("stoptype", (1.0, 2.0, 3.0)),),
|
|
"Kbmax": (("stoptype", (2.0,)),),
|
|
"Dbmax": (("stoptype", (2.0,)),),
|
|
"Pdmax": (("stoptype", (2.0,)),),
|
|
"discContactOption": (("stoptype", (2.0,)),),
|
|
"strib": (
|
|
("stoptype", (1.0, 2.0, 4.0)),
|
|
("useFriction", (2.0,)),
|
|
("frictionType", (2.0,)),
|
|
),
|
|
"frictionType": (
|
|
("stoptype", (1.0, 2.0, 4.0)),
|
|
("useFriction", (2.0,)),
|
|
),
|
|
}
|
|
|
|
for name, expected in expected_visibility.items():
|
|
with self.subTest(name=name):
|
|
self.assertEqual(
|
|
tuple(
|
|
(condition.parameter, condition.values)
|
|
for condition in definitions[name].visible_when
|
|
),
|
|
expected,
|
|
)
|
|
for name in ("mass", "theta", "useFriction", "stoptype", "v0", "x0"):
|
|
with self.subTest(always_visible=name):
|
|
self.assertEqual(definitions[name].visible_when, ())
|
|
|
|
def test_lmechn1_ties_active_port_kinematics_and_balances_force(self) -> None:
|
|
node = AmesimLmechn1("node_1", self.medium, v1=2.0, sum=1.0)
|
|
node.port_1.x = 0.2
|
|
node.port_1.v = 0.3
|
|
node.port_1.f = 4.0
|
|
node.port_2.x = 0.2
|
|
node.port_2.v = 0.3
|
|
node.port_2.f = 6.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_3"))
|
|
self.assertAlmostEqual(node.total_force, 10.0)
|
|
self.assertAlmostEqual(node.force_balance, 0.0)
|
|
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(
|
|
"node_1",
|
|
self.medium,
|
|
{"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",
|
|
self.medium,
|
|
gap0=0.0,
|
|
kcont=1000.0,
|
|
rcont=10.0,
|
|
)
|
|
contact.port_1.x = 0.002
|
|
contact.port_2.x = 0.0
|
|
contact.port_1.v = 0.1
|
|
contact.port_2.v = 0.0
|
|
contact.port_1.f = 3.0
|
|
contact.port_2.f = -3.0
|
|
|
|
self.assertAlmostEqual(contact.gap, -0.002)
|
|
self.assertAlmostEqual(contact.penetration, 0.002)
|
|
self.assertAlmostEqual(contact.contact_force, 3.0)
|
|
self.assertEqual(
|
|
contact.component_result_values(),
|
|
{"gap": -0.002, "penetration": 0.002, "force": 3.0},
|
|
)
|
|
residuals = contact.pressure_flow_equation_residuals()
|
|
self.assertAlmostEqual(residuals[0].value, 0.0)
|
|
self.assertAlmostEqual(residuals[1].value, 0.0)
|
|
|
|
def test_lstp00a_returns_zero_before_contact(self) -> None:
|
|
contact = AmesimLstp00a("contact_1", self.medium, gap0=0.001, kcont=1000.0)
|
|
contact.port_1.x = 0.0005
|
|
contact.port_2.x = 0.0
|
|
|
|
self.assertAlmostEqual(contact.gap, 0.0005)
|
|
self.assertAlmostEqual(contact.contact_force, 0.0)
|
|
|
|
def test_mecmas21_registry_rejects_fractional_choice_value(self) -> None:
|
|
with self.assertRaisesRegex(ValueError, "must be one of"):
|
|
COMPONENT_MODEL_REGISTRY["amesim_mecmas21"].create(
|
|
"mass_1",
|
|
self.medium,
|
|
{"useFriction": 0.5},
|
|
)
|
|
|
|
def test_mecmas21_registry_rejects_unknown_integer_options(self) -> None:
|
|
invalid_options = {
|
|
"useFriction": 0.0,
|
|
"stoptype": 0.0,
|
|
"discContactOption": 3.0,
|
|
"strib": 0.0,
|
|
"frictionType": 3.0,
|
|
}
|
|
|
|
for name, value in invalid_options.items():
|
|
with self.subTest(name=name):
|
|
with self.assertRaisesRegex(ValueError, "must be one of"):
|
|
COMPONENT_MODEL_REGISTRY["amesim_mecmas21"].create(
|
|
"mass_1",
|
|
self.medium,
|
|
{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()
|