Files
make-cad/test/test_ap242_gmsh_example.py
T
NiJingzhe 237702c7a8 feat(examples): unnumbered self-contained layout with per-example out/
- rename every numbered example (04/08/10/11/7ep scripts, 12/16/20/21 dirs)
  to clean names; each example now writes artifacts to its own out/ folder
- examples/README rewritten as a category index (part / assembly / reverse
  engineering / FEM); stale run_examples.py reference removed
- flange_plate gains the quickstart FTC part (model.py + external verify.py
  + README); u_link/ap242/flange demo builders read the new asset paths
- ap242_gmsh_volume_mesh gains render_views.py for the demo gallery

fix(artifacts): round-trip-stable geometry fingerprint bounds

AddOptimal bounds wobble by one shape-tolerance quantum between a fresh
shape and the same shape read back from BRep bytes, so definitions sitting
on a quantization cell edge failed every package re-validation. Quantize
bounds at a fixed 1e-4 mm grid, far coarser than the wobble; full suite
green (1503 passed). Stored packages captured before this change must be
recaptured.
2026-09-07 05:46:15 +08:00

554 lines
20 KiB
Python

"""Contract tests for the optional AP242-to-Gmsh volume mesh example."""
from __future__ import annotations
import importlib.util
from pathlib import Path
import json
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
EXAMPLE_DIR = ROOT / "examples" / "ap242_gmsh_volume_mesh"
MODEL_EXAMPLE = EXAMPLE_DIR / "model.py"
DOWNSTREAM_EXAMPLES = {
"fcstd": EXAMPLE_DIR / "export_fcstd.py",
"step": EXAMPLE_DIR / "export_step.py",
"stl": EXAMPLE_DIR / "export_stl.py",
"obj": EXAMPLE_DIR / "export_obj.py",
"freecad_script": EXAMPLE_DIR / "translate_freecad_script.py",
"fusion360_script": EXAMPLE_DIR / "translate_fusion360_script.py",
"solidworks_script": EXAMPLE_DIR / "translate_solidworks_script.py",
}
MESH_EXAMPLE = EXAMPLE_DIR / "export_fem_mesh.py"
CALCULIX_EXAMPLE = EXAMPLE_DIR / "run_calculix.py"
VISUALIZATION_EXAMPLE = EXAMPLE_DIR / "visualize_calculix.py"
CONVERGENCE_EXAMPLE = EXAMPLE_DIR / "study_mesh_convergence.py"
def _load_example(path: Path, module_name: str):
spec = importlib.util.spec_from_file_location(module_name, path)
assert spec is not None and spec.loader is not None
module = importlib.util.module_from_spec(spec)
import sys
sys.modules[spec.name] = module
spec.loader.exec_module(module)
return module
class _Option:
def __init__(self):
self.strings = []
self.numbers = []
def setString(self, name, value):
self.strings.append((name, value))
def setNumber(self, name, value):
self.numbers.append((name, value))
class _Occ:
def __init__(self):
self.imported = []
self.synchronized = False
def importShapes(self, path):
self.imported.append(path)
return [(3, 9)]
def synchronize(self):
self.synchronized = True
class _Mesh:
def __init__(self, *, fail=False):
self.generated = []
self.fail = fail
def generate(self, dimension):
self.generated.append(dimension)
if self.fail:
raise RuntimeError("mesh failure")
def getNodes(self):
return [1, 2, 3, 4], [0.0] * 12, []
def getElements(self, dimension):
return [4], [[20, 21]], [[1, 2, 3, 4, 1, 2, 3, 4]]
class _Model:
def __init__(self, *, fail=False):
self.occ = _Occ()
self.mesh = _Mesh(fail=fail)
self.models = []
self.physical_groups = []
self.physical_names = []
def add(self, name):
self.models.append(name)
def getEntities(self, dimension):
return [(3, 9)] if dimension == 3 else []
def addPhysicalGroup(self, dimension, tags):
self.physical_groups.append((dimension, tags))
return 7
def setPhysicalName(self, dimension, tag, name):
self.physical_names.append((dimension, tag, name))
class _Gmsh:
def __init__(self, *, fail=False):
self.option = _Option()
self.model = _Model(fail=fail)
self.initialized = 0
self.finalized = 0
self.written = []
def initialize(self):
self.initialized += 1
def finalize(self):
self.finalized += 1
def write(self, path):
self.written.append(path)
Path(path).write_text(
"$MeshFormat\n4.1 0 8\n$EndMeshFormat\n", encoding="ascii"
)
class _CalculiXMesh:
def getNodes(self):
return (
[10, 20, 30, 40, 50],
[
0.0, 0.0, 0.0,
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 1.0, 0.0,
],
[],
)
def getElementType(self, family, order):
self.last_element_request = (family, order)
return {"Tetrahedron": 4, "Triangle": 2}[family]
def getElementTypes(self, dimension):
return [4] if dimension == 3 else []
def getElementsByType(self, element_type, tag=-1):
if element_type == 4:
return [100, 101], [10, 20, 30, 40, 20, 30, 40, 50]
if element_type == 2 and tag == 22:
return [200], [20, 30, 50]
return [], []
def getNodesForPhysicalGroup(self, dimension, tag):
self.last_node_group = (dimension, tag)
return [10, 30, 40], [0.0] * 9
class _CalculiXModel:
def __init__(self):
self.mesh = _CalculiXMesh()
def getPhysicalGroups(self, dimension):
return [(2, 2), (2, 4)] if dimension == 2 else []
def getPhysicalName(self, dimension, tag):
return {
(2, 2): "interface.fixed_support",
(2, 4): "interface.load_surface",
}[(dimension, tag)]
def getEntitiesForPhysicalGroup(self, dimension, tag):
return [22] if (dimension, tag) == (2, 4) else []
class _CalculiXGmsh:
def __init__(self):
self.model = _CalculiXModel()
self.initialized = 0
self.finalized = 0
self.opened = []
def initialize(self):
self.initialized += 1
def open(self, path):
self.opened.append(path)
def finalize(self):
self.finalized += 1
class TestAP242GmshExample(unittest.TestCase):
def test_split_example_modules_have_one_responsibility(self):
model = _load_example(MODEL_EXAMPLE, "ap242_model_example")
downstream = {
name: _load_example(path, f"ap242_{name}_example")
for name, path in DOWNSTREAM_EXAMPLES.items()
}
mesh = _load_example(MESH_EXAMPLE, "ap242_mesh_example")
calculix = _load_example(CALCULIX_EXAMPLE, "ap242_calculix_example")
visualization = _load_example(
VISUALIZATION_EXAMPLE,
"ap242_calculix_visualization_example",
)
self.assertTrue(callable(model.build_bracket))
self.assertFalse(hasattr(model, "mesh_step_with_gmsh"))
self.assertTrue(all(callable(module.main) for module in downstream.values()))
self.assertTrue(callable(mesh.mesh_step_with_gmsh))
self.assertTrue(callable(calculix.build_calculix_input))
self.assertTrue(callable(calculix.run_calculix_static))
self.assertTrue(callable(visualization.visualize_calculix_result))
self.assertFalse(hasattr(mesh, "build_bracket"))
self.assertEqual(
{
model.OUT_DIR,
mesh.OUT_DIR,
*(module.OUT_DIR for module in downstream.values()),
},
{EXAMPLE_DIR / "out"},
)
def test_example_covers_every_package_exporter_and_translator(self):
import simplecadapi as scad
self.assertEqual(
set(DOWNSTREAM_EXAMPLES),
{
"fcstd",
"step",
"stl",
"obj",
"freecad_script",
"fusion360_script",
"solidworks_script",
},
)
self.assertTrue(hasattr(scad.exporter, "export_product_package_to_step"))
self.assertTrue(hasattr(scad.exporter, "export_product_package_to_stl"))
self.assertTrue(hasattr(scad.exporter, "export_product_package_to_obj"))
self.assertTrue(
hasattr(
scad.translator.freecad_translator,
"translate_product_package_to_fcstd",
)
)
self.assertTrue(
hasattr(
scad.translator.freecad_translator,
"translate_product_package_to_freecad_script",
)
)
self.assertTrue(
hasattr(
scad.translator.fusion360_translator,
"translate_product_package_to_fusion360_script",
)
)
self.assertTrue(
hasattr(
scad.translator.solidworks_translator,
"translate_product_package_to_solidworks_script",
)
)
def test_mesh_step_uses_occ_volume_mesh_and_reports_counts(self):
module = _load_example(MESH_EXAMPLE, "ap242_mesh_success_example")
gmsh = _Gmsh()
with tempfile.TemporaryDirectory() as tmp_dir:
root = Path(tmp_dir)
step = root / "part.step"
step.write_text("STEP", encoding="ascii")
mesh = root / "part.msh"
report = module.mesh_step_with_gmsh(
step,
mesh,
mesh_size=1.25,
gmsh_module=gmsh,
)
self.assertEqual(gmsh.initialized, 1)
self.assertEqual(gmsh.finalized, 1)
self.assertEqual(gmsh.option.strings, [("Geometry.OCCTargetUnit", "MM")])
self.assertEqual(
gmsh.option.numbers,
[("Mesh.MeshSizeMin", 1.25), ("Mesh.MeshSizeMax", 1.25)],
)
self.assertEqual(gmsh.model.mesh.generated, [3])
self.assertEqual(gmsh.model.physical_groups, [(3, [9])])
self.assertEqual(report.volume_count, 1)
self.assertEqual(report.node_count, 4)
self.assertEqual(report.element_count, 2)
def test_gmsh_is_finalized_when_meshing_fails(self):
module = _load_example(MESH_EXAMPLE, "ap242_mesh_failure_example")
gmsh = _Gmsh(fail=True)
with tempfile.TemporaryDirectory() as tmp_dir:
step = Path(tmp_dir) / "part.step"
step.write_text("STEP", encoding="ascii")
with self.assertRaisesRegex(RuntimeError, "mesh failure"):
module.mesh_step_with_gmsh(
step,
Path(tmp_dir) / "part.msh",
gmsh_module=gmsh,
)
self.assertEqual(gmsh.initialized, 1)
self.assertEqual(gmsh.finalized, 1)
def test_calculix_input_preserves_node_ids_groups_and_total_load(self):
module = _load_example(CALCULIX_EXAMPLE, "ap242_calculix_input_example")
gmsh = _CalculiXGmsh()
with tempfile.TemporaryDirectory() as tmp_dir:
root = Path(tmp_dir)
mesh = root / "bracket.msh"
mesh.write_text("MSH", encoding="ascii")
input_path = root / "bracket.inp"
report = module.build_calculix_input(
mesh,
input_path,
load_z_n=-900.0,
gmsh_module=gmsh,
)
deck = input_path.read_text(encoding="ascii")
self.assertEqual(gmsh.initialized, 1)
self.assertEqual(gmsh.finalized, 1)
self.assertEqual(report.node_count, 5)
self.assertEqual(report.element_count, 2)
self.assertEqual(report.fixed_node_count, 3)
self.assertEqual(report.load_node_count, 3)
self.assertAlmostEqual(report.load_surface_area_mm2, 0.5)
self.assertAlmostEqual(report.applied_load_z_n, -900.0)
self.assertIn("10,0,0,0", deck)
self.assertIn("100,10,20,30,40", deck)
self.assertIn("FIXED_SUPPORT,1,3", deck)
self.assertIn("20,3,-300", deck)
self.assertIn("30,3,-300", deck)
self.assertIn("50,3,-300", deck)
self.assertIn("*NODE FILE\nU", deck)
self.assertIn("*NODE PRINT,NSET=FIXED_SUPPORT,TOTALS=ONLY\nRF", deck)
self.assertIn("*STATIC,SOLVER=SPOOLES", deck)
self.assertIn("*EL FILE\nS", deck)
def test_calculix_input_accepts_iterative_cholesky_solver(self):
module = _load_example(CALCULIX_EXAMPLE, "ap242_calculix_solver_example")
gmsh = _CalculiXGmsh()
with tempfile.TemporaryDirectory() as tmp_dir:
root = Path(tmp_dir)
mesh = root / "bracket.msh"
mesh.write_text("MSH", encoding="ascii")
input_path = root / "bracket.inp"
report = module.build_calculix_input(
mesh,
input_path,
linear_solver="iterative cholesky",
gmsh_module=gmsh,
)
deck = input_path.read_text(encoding="ascii")
self.assertEqual(report.linear_solver, "ITERATIVE CHOLESKY")
self.assertIn("*STATIC,SOLVER=ITERATIVE CHOLESKY", deck)
def test_calculix_dat_parser_reports_displacement_and_von_mises(self):
module = _load_example(CALCULIX_EXAMPLE, "ap242_calculix_parser_example")
with tempfile.TemporaryDirectory() as tmp_dir:
dat_path = Path(tmp_dir) / "result.dat"
dat_path.write_text(
" displacements (vx,vy,vz) for set NALL and time 1.0000000E+00\n"
" 10 3.0E-01 4.0E-01 0.0E+00\n"
" 20 0.0E+00 0.0E+00 -2.0E-01\n\n"
" total force (fx,fy,fz) for set FIXED_SUPPORT and time 1.0000000E+00\n"
" 0.0E+00 0.0E+00 9.0E+02\n\n"
" stresses (elem, integ.pnt.,sxx,syy,szz,sxy,sxz,syz) "
"for set EALL and time 1.0000000E+00\n"
" 100 1 1.0E+02 0.0E+00 0.0E+00 0.0E+00 0.0E+00 0.0E+00\n"
" 101 1 0.0E+00 0.0E+00 0.0E+00 5.0E+01 0.0E+00 0.0E+00\n",
encoding="ascii",
)
result = module.parse_calculix_dat(dat_path)
self.assertAlmostEqual(result["max_displacement_mm"], 0.5)
self.assertEqual(result["max_displacement_node"], 10)
self.assertAlmostEqual(result["max_von_mises_mpa"], 100.0)
self.assertEqual(result["max_von_mises_element"], 100)
self.assertAlmostEqual(result["reaction_force_z_n"], 900.0)
def test_calculix_runner_executes_job_and_writes_summary(self):
module = _load_example(CALCULIX_EXAMPLE, "ap242_calculix_runner_example")
with tempfile.TemporaryDirectory() as tmp_dir:
root = Path(tmp_dir)
input_path = root / "job.inp"
input_path.write_text("*HEADING\n", encoding="ascii")
executable = root / "ccx_2.23"
executable.write_text("#!/bin/sh\n", encoding="ascii")
executable.chmod(0o755)
report = module.CalculiXInputReport(
mesh_path=root / "mesh.msh",
input_path=input_path,
node_count=5,
element_count=2,
fixed_node_count=3,
load_node_count=3,
load_surface_area_mm2=0.5,
applied_load_z_n=-900.0,
linear_solver="ITERATIVE CHOLESKY",
)
def runner(command, **kwargs):
self.assertEqual(command, [str(executable.resolve()), "job"])
self.assertEqual(kwargs["cwd"], root.resolve())
(root / "job.dat").write_text(
" displacements (vx,vy,vz) for set NALL and time 1\n"
" 10 0.0 0.0 -0.2\n"
" total force (fx,fy,fz) for set FIXED_SUPPORT and time 1\n"
" 0 0 900\n"
" stresses (elem, integ.pnt.,sxx,syy,szz,sxy,sxz,syz) "
"for set EALL and time 1\n"
" 100 1 100 0 0 0 0 0\n",
encoding="ascii",
)
(root / "job.frd").write_text("FRD\n", encoding="ascii")
return type("Completed", (), {"returncode": 0, "stdout": "ok", "stderr": ""})()
result = module.run_calculix_static(
report,
ccx=executable,
runner=runner,
)
summary = json.loads(result.summary_path.read_text(encoding="utf-8"))
self.assertAlmostEqual(result.max_displacement_mm, 0.2)
self.assertAlmostEqual(result.max_von_mises_mpa, 100.0)
self.assertEqual(summary["units"], {"force": "N", "length": "mm", "stress": "MPa"})
self.assertEqual(summary["input"]["applied_load_z_n"], -900.0)
self.assertAlmostEqual(result.reaction_force_z_n, 900.0)
self.assertAlmostEqual(result.force_balance_z_n, 0.0)
self.assertAlmostEqual(summary["results"]["force_balance_z_n"], 0.0)
self.assertEqual(summary["input"]["applied_load_z_n"], -900.0)
self.assertEqual(summary["input"]["linear_solver"], "ITERATIVE CHOLESKY")
def test_mesh_convergence_requires_a_sustained_platform(self):
module = _load_example(
CONVERGENCE_EXAMPLE,
"ap242_mesh_convergence_assessment_example",
)
def level(mesh_size, displacement_change, stress_change):
return module.MeshConvergenceLevel(
mesh_size_mm=mesh_size,
node_count=1,
element_count=1,
fixed_node_count=1,
load_node_count=1,
max_displacement_mm=1.0,
max_von_mises_mpa=1.0,
reaction_force_z_n=1.0,
force_balance_z_n=0.0,
displacement_change_from_previous=displacement_change,
stress_change_from_previous=stress_change,
mesh_path="mesh.msh",
input_path="job.inp",
summary_path="job.json",
)
transient = module.assess_mesh_convergence(
[
level(3.0, None, None),
level(2.0, 0.04, 0.09),
level(1.5, 0.08, 0.05),
]
)
sustained = module.assess_mesh_convergence(
[
level(3.0, None, None),
level(2.0, 0.20, 0.20),
level(1.5, 0.04, 0.09),
level(1.0, 0.03, 0.08),
],
required_platform_pairs=2,
)
self.assertFalse(transient["platform_reached"])
self.assertIsNone(transient["recommended_mesh_size_mm"])
self.assertTrue(sustained["platform_reached"])
self.assertEqual(sustained["production_level_n_minus_1"], 3)
self.assertEqual(sustained["verification_level_n"], 4)
self.assertEqual(sustained["recommended_mesh_size_mm"], 1.5)
def test_mesh_convergence_reports_only_sustained_platform_as_independent(self):
module = _load_example(
CONVERGENCE_EXAMPLE,
"ap242_mesh_convergence_independence_example",
)
def level(mesh_size, displacement_change, stress_change):
return module.MeshConvergenceLevel(
mesh_size_mm=mesh_size,
node_count=1,
element_count=1,
fixed_node_count=1,
load_node_count=1,
max_displacement_mm=1.0,
max_von_mises_mpa=1.0,
reaction_force_z_n=1.0,
force_balance_z_n=0.0,
displacement_change_from_previous=displacement_change,
stress_change_from_previous=stress_change,
mesh_path="mesh.msh",
input_path="job.inp",
summary_path="job.json",
)
assessment = module.assess_mesh_convergence(
[
level(0.75, None, None),
level(0.5, 0.03, 0.19),
level(0.375, 0.01, 0.03),
]
)
self.assertFalse(assessment["mesh_independent"])
self.assertTrue(assessment["finest_pair_displacement_within_tolerance"])
self.assertTrue(assessment["finest_pair_stress_within_tolerance"])
self.assertIsNone(assessment["recommended_mesh_size_mm"])
def test_calculix_visualizer_converts_frd_to_nonempty_vtu(self):
module = _load_example(
VISUALIZATION_EXAMPLE,
"ap242_calculix_vtu_example",
)
with tempfile.TemporaryDirectory() as tmp_dir:
root = Path(tmp_dir)
frd = root / "job.frd"
frd.write_text("FRD\n", encoding="ascii")
class Converter:
def __init__(self, source, formats):
self.source = Path(source)
self.formats = formats
def run(self):
self.assert_formats = self.formats
self.source.with_suffix(".vtu").write_text("VTU\n", encoding="ascii")
vtu = module.convert_frd_to_vtu(frd, converter_class=Converter)
self.assertEqual(vtu.name, "job.vtu")
if __name__ == "__main__":
unittest.main()