103 lines
4.4 KiB
Python
103 lines
4.4 KiB
Python
from __future__ import annotations
|
|
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
from PythonModels.reporting.amesim_results import load_test_mql_amesim_results
|
|
from PythonModels.reporting.test_mql_variables import build_test_mql_variable_catalog
|
|
from PythonModels.systems.test_mql_mechanical import (
|
|
build_test_mql_mechanical_assembly,
|
|
circular_area,
|
|
mm_to_m,
|
|
n_per_mm_per_s_to_n_per_m_per_s,
|
|
n_per_mm_to_n_per_m,
|
|
)
|
|
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parents[1]
|
|
TEST_MQL_AME = REPO_ROOT / "AmesimModels" / "test_mql.ame"
|
|
|
|
|
|
class TestMqlMechanicalAssemblyTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls) -> None:
|
|
cls.amesim_results = load_test_mql_amesim_results(TEST_MQL_AME)
|
|
cls.variable_catalog = build_test_mql_variable_catalog(cls.amesim_results)
|
|
cls.assembly = build_test_mql_mechanical_assembly(
|
|
amesim_results=cls.amesim_results,
|
|
variable_catalog=cls.variable_catalog,
|
|
)
|
|
|
|
def test_assembles_expected_mechanical_component_counts(self) -> None:
|
|
self.assertEqual(len(self.assembly.pistons), 8)
|
|
self.assertEqual(len(self.assembly.masses), 10)
|
|
self.assertEqual(len(self.assembly.elastic_endstops), 8)
|
|
self.assertEqual(len(self.assembly.mechanical_nodes), 2)
|
|
self.assertEqual(len(self.assembly.zero_force_sources), 16)
|
|
self.assertEqual(len(self.assembly.force_connectors), 2)
|
|
self.assertEqual(self.assembly.component_count, 46)
|
|
|
|
def test_piston_geometry_is_converted_to_si_units(self) -> None:
|
|
piston = self.assembly.pistons["pn_brp2_8"]
|
|
|
|
self.assertAlmostEqual(piston.piston_diameter_m, 0.2)
|
|
self.assertAlmostEqual(piston.rod_diameter_m, 0.001)
|
|
self.assertAlmostEqual(piston.zero_displacement_m, 0.0)
|
|
self.assertAlmostEqual(piston.piston_area_m2, circular_area(0.2))
|
|
self.assertAlmostEqual(piston.rod_area_m2, circular_area(0.001))
|
|
self.assertAlmostEqual(piston.annulus_area_m2, piston.piston_area_m2 - piston.rod_area_m2)
|
|
self.assertIn("vvol1@pn_brp2_8", piston.data_paths)
|
|
self.assertIn("f2@pn_brp2_8", piston.data_paths)
|
|
|
|
def test_mass_endstop_parameters_are_converted_to_si_units(self) -> None:
|
|
mass = self.assembly.masses["mass_friction_endstops_10"]
|
|
|
|
self.assertEqual(mass.mass_kg, 50.0)
|
|
self.assertEqual(mass.xmin_m, -1.0)
|
|
self.assertEqual(mass.xmax_m, 0.8)
|
|
self.assertEqual(mass.min_stiffness_n_per_m, 1.0e9)
|
|
self.assertEqual(mass.max_stiffness_n_per_m, 1.0e9)
|
|
self.assertEqual(mass.min_damping_n_per_m_per_s, 1.0e4)
|
|
self.assertEqual(mass.max_damping_n_per_m_per_s, 1.0e4)
|
|
self.assertAlmostEqual(mass.min_penetration_m, 1.0e-4)
|
|
self.assertAlmostEqual(mass.max_penetration_m, 1.0e-4)
|
|
self.assertEqual(mass.rest_coeff, 0.65)
|
|
self.assertIn("v1@mass_friction_endstops_10", mass.data_paths)
|
|
self.assertIn("x1@mass_friction_endstops_10", mass.data_paths)
|
|
|
|
def test_large_load_masses_keep_distinct_limits(self) -> None:
|
|
front = self.assembly.masses["mass_friction_endstops_18"]
|
|
rear = self.assembly.masses["mass_friction_endstops_19"]
|
|
|
|
self.assertEqual(front.mass_kg, 170000.0)
|
|
self.assertEqual(front.xmin_m, 0.0)
|
|
self.assertEqual(front.xmax_m, 0.37)
|
|
self.assertEqual(rear.mass_kg, 90000.0)
|
|
self.assertEqual(rear.xmin_m, -0.72)
|
|
self.assertEqual(rear.xmax_m, 0.0)
|
|
|
|
def test_elastic_endstop_parameters_are_converted_to_si_units(self) -> None:
|
|
endstop = self.assembly.elastic_endstops["elasticendstop_8"]
|
|
|
|
self.assertEqual(endstop.gap_m, 0.0)
|
|
self.assertEqual(endstop.contact_stiffness_n_per_m, 1.0e11)
|
|
self.assertEqual(endstop.contact_damping_n_per_m_per_s, 1.0e11)
|
|
self.assertAlmostEqual(endstop.spring_diameter_m, 0.02)
|
|
self.assertAlmostEqual(endstop.wire_diameter_m, 0.002)
|
|
|
|
def test_mechanical_nodes_keep_port_count(self) -> None:
|
|
node = self.assembly.mechanical_nodes["dynamic_mechanical_node_alternative_2"]
|
|
|
|
self.assertEqual(node.port_count, 8)
|
|
self.assertEqual(node.sum_mode, 1)
|
|
self.assertIn("dynamic_mechanical_node_alternative_2", self.assembly.aliases)
|
|
|
|
def test_unit_helpers(self) -> None:
|
|
self.assertAlmostEqual(mm_to_m(20.0), 0.02)
|
|
self.assertAlmostEqual(n_per_mm_to_n_per_m(1.0e6), 1.0e9)
|
|
self.assertAlmostEqual(n_per_mm_per_s_to_n_per_m_per_s(10.0), 1.0e4)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|