Files
make-cad/examples/arc_handle/fem_analysis.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

556 lines
21 KiB
Python

"""Run Gmsh and CalculiX linear-static load cases for the arched handle.
Units are mm, N, and MPa. The material is an isotropic FDM PVC proxy, not a
certification of a particular filament, infill, raster direction, or print.
Boundary condition: both Y=-2.5 mm mounting-ear back faces are rigidly fixed
against the wall. Load condition: forces are distributed over the middle 20 mm
of the exposed grip surface. Positive Y pulls away from the wall and negative
Z applies the requested transverse component.
"""
from __future__ import annotations
import argparse
import json
import math
import re
import subprocess
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Any, Iterable
import numpy as np
import simplecadapi as scad
EXAMPLE_DIR = Path(__file__).resolve().parent
OUTPUT_DIR = EXAMPLE_DIR / "out" / "fem"
PACKAGE_PATH = EXAMPLE_DIR / "out" / "arc_handle.scadpkg"
STEP_PATH = OUTPUT_DIR / "arc_handle.step"
MESH_PATH = OUTPUT_DIR / "arc_handle.msh"
MESH_REPORT_PATH = OUTPUT_DIR / "arc_handle.mesh.json"
SUMMARY_PATH = OUTPUT_DIR / "arc_handle.fem.json"
# Conservative linear-elastic proxy for unfilled FDM PVC. The printed object
# may be anisotropic and weaker across layers, so this supports comparison of
# hot spots, not a strength or safety claim.
MATERIAL_NAME = "FDM_PVC_ISOTROPIC_PROXY"
YOUNGS_MODULUS_MPA = 2_500.0
POISSON_RATIO = 0.38
MOUNTING_FACE_Y_MM = -2.5
MOUNTING_FACE_TOLERANCE_MM = 0.02
GRIP_HALF_WIDTH_MM = 10.0
GRIP_MIN_Y_MM = 15.0
CASE_DEFINITIONS = (
("normal_250N", 250.0 / math.sqrt(2.0), -250.0 / math.sqrt(2.0)),
("strong_500N", 500.0 / math.sqrt(2.0), -500.0 / math.sqrt(2.0)),
("combined_707N", 500.0, -500.0),
)
_FLOAT_PATTERN = re.compile(r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?")
@dataclass(frozen=True, slots=True)
class MeshData:
nodes: dict[int, tuple[float, float, float]]
tetrahedra: tuple[tuple[int, int, int, int, int], ...]
support_nodes: tuple[int, ...]
load_nodes: tuple[int, ...]
support_surface_tags: tuple[int, ...]
load_surface_node_count: int
@dataclass(frozen=True, slots=True)
class CaseResult:
name: str
amplified_png_path: str
force_y_n: float
force_z_n: float
resultant_force_n: float
input_path: str
dat_path: str
frd_path: str
png_path: str
max_displacement_mm: float
max_displacement_node: int
max_von_mises_mpa: float
max_von_mises_element: int
max_von_mises_centroid_mm: tuple[float, float, float]
stress_location: str
reaction_force_n: tuple[float, float, float]
balance_error_y_n: float
balance_error_z_n: float
def _import_gmsh() -> Any:
import gmsh
return gmsh
def _import_vtk() -> Any:
import vtk
return vtk
def _surface_nodes(gmsh: Any, surface_tags: Iterable[int]) -> set[int]:
nodes: set[int] = set()
for tag in surface_tags:
values, _coordinates, _parameters = gmsh.model.mesh.getNodes(
2, int(tag), includeBoundary=True
)
nodes.update(int(value) for value in values)
return nodes
def _mounting_surfaces(gmsh: Any) -> tuple[int, ...]:
tags: list[int] = []
for _dimension, tag in gmsh.model.getEntities(2):
bounds = gmsh.model.getBoundingBox(2, int(tag))
if (
abs(float(bounds[1]) - MOUNTING_FACE_Y_MM) <= MOUNTING_FACE_TOLERANCE_MM
and abs(float(bounds[4]) - MOUNTING_FACE_Y_MM) <= MOUNTING_FACE_TOLERANCE_MM
and gmsh.model.occ.getMass(2, int(tag)) > 50.0
):
tags.append(int(tag))
if len(tags) != 2:
raise RuntimeError(f"expected two mounting-wall faces, found {tags}")
return tuple(sorted(tags))
def export_step() -> Path:
if not PACKAGE_PATH.is_file():
raise FileNotFoundError(f"build the handle first: {PACKAGE_PATH}")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
report = scad.exporter.step.export_product_package_to_step(
data=PACKAGE_PATH,
output_path=STEP_PATH,
)
if not STEP_PATH.is_file() or STEP_PATH.stat().st_size <= 0:
raise RuntimeError(f"STEP export did not create {STEP_PATH}")
print("step", report.output_path)
print("step_schema", report.schema)
print("step_definitions", ",".join(report.definition_ids))
return STEP_PATH
def mesh_handle(*, mesh_size_mm: float) -> MeshData:
if mesh_size_mm <= 0.0:
raise ValueError("mesh_size_mm must be positive")
step_path = export_step()
gmsh = _import_gmsh()
initialized = False
try:
gmsh.initialize()
initialized = True
gmsh.option.setNumber("General.Terminal", 1)
gmsh.model.add("arc_handle_fem")
gmsh.option.setString("Geometry.OCCTargetUnit", "MM")
gmsh.model.occ.importShapes(str(step_path))
gmsh.model.occ.synchronize()
volumes = gmsh.model.getEntities(3)
if len(volumes) != 1:
raise RuntimeError(f"expected one imported solid, found {volumes}")
support_surface_tags = _mounting_surfaces(gmsh)
support_group = gmsh.model.addPhysicalGroup(2, list(support_surface_tags))
gmsh.model.setPhysicalName(2, support_group, "wall_mounting_faces")
volume_group = gmsh.model.addPhysicalGroup(3, [int(volumes[0][1])])
gmsh.model.setPhysicalName(3, volume_group, "arc_handle_body")
# Global 0.9 mm mesh, tightened near mounting holes and roots by the
# imported end-region faces. The refinement is intentionally limited
# so the long grip does not dominate element count.
gmsh.option.setNumber("Mesh.MeshSizeMin", min(0.55, mesh_size_mm))
gmsh.option.setNumber("Mesh.MeshSizeMax", mesh_size_mm)
gmsh.option.setNumber("Mesh.Algorithm3D", 1)
gmsh.model.mesh.generate(3)
node_tags, coordinates, _parameters = gmsh.model.mesh.getNodes()
coordinate_values = np.asarray(coordinates, dtype=float).reshape((-1, 3))
nodes = {
int(tag): (float(point[0]), float(point[1]), float(point[2]))
for tag, point in zip(node_tags, coordinate_values)
}
tetrahedron_type = int(gmsh.model.mesh.getElementType("Tetrahedron", 1))
element_tags, element_nodes = gmsh.model.mesh.getElementsByType(tetrahedron_type)
connectivity = np.asarray(element_nodes, dtype=np.int64).reshape((-1, 4))
tetrahedra = tuple(
(
int(element),
int(element_nodes_row[0]),
int(element_nodes_row[1]),
int(element_nodes_row[2]),
int(element_nodes_row[3]),
)
for element, element_nodes_row in zip(element_tags, connectivity)
)
if not tetrahedra:
raise RuntimeError("Gmsh generated no first-order tetrahedra")
support_nodes = tuple(sorted(_surface_nodes(gmsh, support_surface_tags)))
all_boundary_surfaces = [int(tag) for _dim, tag in gmsh.model.getEntities(2)]
boundary_nodes = _surface_nodes(gmsh, all_boundary_surfaces)
load_nodes = tuple(
sorted(
node
for node in boundary_nodes
if abs(nodes[node][0]) <= GRIP_HALF_WIDTH_MM
and nodes[node][1] >= GRIP_MIN_Y_MM
)
)
if not support_nodes:
raise RuntimeError("mounting-wall faces contain no mesh nodes")
if len(load_nodes) < 10:
raise RuntimeError(f"central grip load selection is too small: {len(load_nodes)} nodes")
gmsh.write(str(MESH_PATH))
finally:
if initialized:
gmsh.finalize()
payload = {
"units": {"length": "mm"},
"mesh_size_mm": mesh_size_mm,
"node_count": len(nodes),
"tetrahedron_count": len(tetrahedra),
"support_surface_tags": support_surface_tags,
"support_node_count": len(support_nodes),
"load_node_count": len(load_nodes),
"load_region": {
"abs_x_max_mm": GRIP_HALF_WIDTH_MM,
"y_min_mm": GRIP_MIN_Y_MM,
},
}
MESH_REPORT_PATH.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
print("mesh", MESH_PATH)
print("mesh_nodes", len(nodes))
print("mesh_tetrahedra", len(tetrahedra))
print("support_nodes", len(support_nodes))
print("load_nodes", len(load_nodes))
return MeshData(
nodes=nodes,
tetrahedra=tetrahedra,
support_nodes=support_nodes,
load_nodes=load_nodes,
support_surface_tags=support_surface_tags,
load_surface_node_count=len(load_nodes),
)
def _append_set(lines: list[str], name: str, node_ids: Iterable[int]) -> None:
values = list(node_ids)
lines.append(f"*NSET,NSET={name}")
for start in range(0, len(values), 16):
lines.append(",".join(str(value) for value in values[start : start + 16]))
def write_calculix_input(*, mesh: MeshData, case_name: str, force_y_n: float, force_z_n: float) -> Path:
input_path = OUTPUT_DIR / f"arc_handle_{case_name}.inp"
lines = [
"*HEADING",
f"Arched handle: {case_name} linear-static FDM PVC proxy",
"** Units: mm, N, MPa",
"*NODE,NSET=NALL",
]
lines.extend(
f"{node},{x:.12g},{y:.12g},{z:.12g}"
for node, (x, y, z) in sorted(mesh.nodes.items())
)
lines.append("*ELEMENT,TYPE=C3D4,ELSET=EALL")
lines.extend(
f"{element},{first},{second},{third},{fourth}"
for element, first, second, third, fourth in mesh.tetrahedra
)
_append_set(lines, "WALL_SUPPORT", mesh.support_nodes)
_append_set(lines, "GRIP_LOAD", mesh.load_nodes)
lines.extend(
[
f"*MATERIAL,NAME={MATERIAL_NAME}",
"*ELASTIC",
f"{YOUNGS_MODULUS_MPA:.12g},{POISSON_RATIO:.12g}",
f"*SOLID SECTION,ELSET=EALL,MATERIAL={MATERIAL_NAME}",
"*BOUNDARY",
"WALL_SUPPORT,1,3",
"*STEP",
"*STATIC,SOLVER=ITERATIVE CHOLESKY",
"*CLOAD",
]
)
per_node_y = force_y_n / len(mesh.load_nodes)
per_node_z = force_z_n / len(mesh.load_nodes)
for node in mesh.load_nodes:
lines.append(f"{node},2,{per_node_y:.12g}")
lines.append(f"{node},3,{per_node_z:.12g}")
lines.extend(
[
"*NODE PRINT,NSET=NALL",
"U",
"*NODE PRINT,NSET=WALL_SUPPORT,TOTALS=ONLY",
"RF",
"*EL PRINT,ELSET=EALL",
"S",
"*NODE FILE",
"U",
"*EL FILE",
"S",
"*END STEP",
]
)
input_path.write_text("\n".join(lines) + "\n", encoding="ascii")
return input_path
def _numbers(line: str) -> list[float]:
return [float(value) for value in _FLOAT_PATTERN.findall(line)]
def _von_mises(values: list[float]) -> float:
sxx, syy, szz, sxy, sxz, syz = values
return math.sqrt(
0.5 * ((sxx - syy) ** 2 + (syy - szz) ** 2 + (szz - sxx) ** 2)
+ 3.0 * (sxy**2 + sxz**2 + syz**2)
)
def parse_dat(path: Path) -> dict[str, Any]:
displacement: list[tuple[float, int]] = []
stress: list[tuple[float, int, int]] = []
reaction: tuple[float, float, float] | None = None
section: str | None = None
for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
lowered = line.lower()
if "displacements (vx,vy,vz)" in lowered:
section = "displacement"
displacement = []
continue
if "total force (fx,fy,fz) for set wall_support" in lowered:
section = "reaction"
reaction = None
continue
if "stresses (elem, integ.pnt." in lowered:
section = "stress"
stress = []
continue
values = _numbers(line)
if section == "displacement" and len(values) == 4:
magnitude = math.sqrt(sum(value * value for value in values[1:]))
displacement.append((magnitude, int(values[0])))
elif section == "stress" and len(values) >= 8:
stress.append((_von_mises(values[2:8]), int(values[0]), int(values[1])))
elif section == "reaction" and len(values) == 3:
reaction = (values[0], values[1], values[2])
if not displacement or not stress or reaction is None:
raise RuntimeError(f"could not parse complete CalculiX results from {path}")
max_displacement, displacement_node = max(displacement)
max_stress, stress_element, _integration_point = max(stress)
return {
"max_displacement_mm": max_displacement,
"max_displacement_node": displacement_node,
"max_von_mises_mpa": max_stress,
"max_von_mises_element": stress_element,
"reaction_force_n": reaction,
}
def _element_centroid(mesh: MeshData, element_id: int) -> tuple[float, float, float]:
found = next(element for element in mesh.tetrahedra if element[0] == element_id)
points = [mesh.nodes[node] for node in found[1:]]
return (
sum(point[0] for point in points) / 4.0,
sum(point[1] for point in points) / 4.0,
sum(point[2] for point in points) / 4.0,
)
def _classify_location(point: tuple[float, float, float]) -> str:
x, y, z = point
if abs(abs(x) - 55.0) < 8.0 and y < 4.0:
return "mounting-ear wall face / countersunk-hole region"
if abs(abs(x) - 50.0) < 8.0 and y < 16.0:
return "grip-to-mounting-ear transition"
if abs(x) < 15.0:
return "central grip"
return "arched grip"
def _render_von_mises(
*, frd_path: Path, png_path: Path, deformation_scale: float
) -> None:
from ccx2paraview import Converter
Converter(str(frd_path), ["vtu"]).run()
candidates = sorted(frd_path.parent.glob(f"{frd_path.stem}*.vtu"), key=lambda path: path.stat().st_mtime_ns, reverse=True)
if not candidates:
raise RuntimeError(f"ccx2paraview created no VTU file for {frd_path}")
vtu_path = candidates[0]
vtk = _import_vtk()
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(str(vtu_path))
reader.Update()
dataset = reader.GetOutput()
point_data = dataset.GetPointData()
stress_name = "S_Mises" if point_data.HasArray("S_Mises") else "S_Mises_Magnitude"
displacement_name = "U" if point_data.HasArray("U") else "DISP"
if not point_data.HasArray(stress_name) or not point_data.HasArray(displacement_name):
names = [point_data.GetArrayName(index) for index in range(point_data.GetNumberOfArrays())]
raise RuntimeError(f"VTU has no expected fields: {names}")
warp = vtk.vtkWarpVector()
warp.SetInputData(dataset)
warp.SetInputArrayToProcess(0, 0, 0, 0, displacement_name)
warp.SetScaleFactor(float(deformation_scale))
warp.Update()
surface = vtk.vtkDataSetSurfaceFilter()
surface.SetInputData(warp.GetOutput())
surface.Update()
array = warp.GetOutput().GetPointData().GetArray(stress_name)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(surface.GetOutputPort())
mapper.SetScalarModeToUsePointFieldData()
mapper.SelectColorArray(stress_name)
mapper.SetScalarRange(array.GetRange())
lookup = vtk.vtkLookupTable()
lookup.SetHueRange(0.667, 0.0)
lookup.SetNumberOfTableValues(256)
lookup.Build()
mapper.SetLookupTable(lookup)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetLookupTable(lookup)
scalar_bar.SetTitle("von Mises [MPa]")
scalar_bar.SetNumberOfLabels(5)
renderer = vtk.vtkRenderer()
renderer.SetBackground(0.96, 0.97, 0.98)
renderer.AddActor(actor)
renderer.AddViewProp(scalar_bar)
renderer.ResetCamera()
camera = renderer.GetActiveCamera()
camera.Azimuth(35.0)
camera.Elevation(22.0)
window = vtk.vtkRenderWindow()
window.SetOffScreenRendering(1)
window.SetSize(1280, 900)
window.AddRenderer(renderer)
window.Render()
capture = vtk.vtkWindowToImageFilter()
capture.SetInput(window)
capture.SetInputBufferTypeToRGBA()
capture.ReadFrontBufferOff()
capture.Update()
png_path.parent.mkdir(parents=True, exist_ok=True)
writer = vtk.vtkPNGWriter()
writer.SetFileName(str(png_path))
writer.SetInputConnection(capture.GetOutputPort())
writer.Write()
if not png_path.is_file() or png_path.stat().st_size <= 0:
raise RuntimeError(f"failed to write stress preview: {png_path}")
def run_case(*, mesh: MeshData, case_name: str, force_y_n: float, force_z_n: float, ccx: Path) -> CaseResult:
input_path = write_calculix_input(
mesh=mesh,
case_name=case_name,
force_y_n=force_y_n,
force_z_n=force_z_n,
)
completed = subprocess.run(
[str(ccx), input_path.stem],
cwd=OUTPUT_DIR,
capture_output=True,
text=True,
check=False,
timeout=1_200,
)
log_path = input_path.with_suffix(".ccx.log")
log_path.write_text((completed.stdout or "") + "\n" + (completed.stderr or ""), encoding="utf-8")
if completed.returncode != 0:
raise RuntimeError(f"CalculiX {case_name} failed; see {log_path}")
dat_path = input_path.with_suffix(".dat")
frd_path = input_path.with_suffix(".frd")
if not dat_path.is_file() or not frd_path.is_file():
raise RuntimeError(f"CalculiX {case_name} produced incomplete results")
parsed = parse_dat(dat_path)
centroid = _element_centroid(mesh, int(parsed["max_von_mises_element"]))
png_path = OUTPUT_DIR / f"arc_handle_{case_name}_von_mises.png"
amplified_png_path = OUTPUT_DIR / f"arc_handle_{case_name}_von_mises_20x.png"
_render_von_mises(frd_path=frd_path, png_path=png_path, deformation_scale=1.0)
_render_von_mises(
frd_path=frd_path,
png_path=amplified_png_path,
deformation_scale=20.0,
)
reaction = tuple(float(value) for value in parsed["reaction_force_n"])
return CaseResult(
name=case_name,
force_y_n=force_y_n,
force_z_n=force_z_n,
resultant_force_n=math.hypot(force_y_n, force_z_n),
input_path=str(input_path),
dat_path=str(dat_path),
frd_path=str(frd_path),
png_path=str(png_path),
max_displacement_mm=float(parsed["max_displacement_mm"]),
max_displacement_node=int(parsed["max_displacement_node"]),
max_von_mises_mpa=float(parsed["max_von_mises_mpa"]),
max_von_mises_element=int(parsed["max_von_mises_element"]),
max_von_mises_centroid_mm=centroid,
stress_location=_classify_location(centroid),
reaction_force_n=(float(reaction[0]), float(reaction[1]), float(reaction[2])),
balance_error_y_n=reaction[1] + force_y_n,
balance_error_z_n=reaction[2] + force_z_n,
amplified_png_path=str(amplified_png_path),
)
def main(*, mesh_size_mm: float, ccx: Path) -> None:
mesh = mesh_handle(mesh_size_mm=mesh_size_mm)
results = [
run_case(
mesh=mesh,
case_name=name,
force_y_n=force_y_n,
force_z_n=force_z_n,
ccx=ccx,
)
for name, force_y_n, force_z_n in CASE_DEFINITIONS
]
payload = {
"analysis": "linear_static",
"units": {"length": "mm", "force": "N", "stress": "MPa"},
"assumptions": {
"material": {
"name": MATERIAL_NAME,
"youngs_modulus_mpa": YOUNGS_MODULUS_MPA,
"poisson_ratio": POISSON_RATIO,
"scope": "isotropic FDM PVC proxy; no print-orientation, infill, layer-adhesion, creep, or failure model",
},
"support": "both mounting-ear back faces at Y=-2.5 mm fixed in X, Y, and Z",
"load": "uniform nodal force over exposed central 20 mm-wide grip surface region",
},
"mesh": json.loads(MESH_REPORT_PATH.read_text(encoding="utf-8")),
"cases": [asdict(result) for result in results],
}
SUMMARY_PATH.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
for result in results:
print("case", result.name)
print(" force_n", f"Fy={result.force_y_n:.3f}", f"Fz={result.force_z_n:.3f}", f"resultant={result.resultant_force_n:.3f}")
print(" max_von_mises_mpa", f"{result.max_von_mises_mpa:.6f}")
print(" max_displacement_mm", f"{result.max_displacement_mm:.6f}")
print(" location", result.stress_location, tuple(round(value, 3) for value in result.max_von_mises_centroid_mm))
print(" balance_error_n", f"Fy={result.balance_error_y_n:.6g}", f"Fz={result.balance_error_z_n:.6g}")
print(" stress_png", result.png_path)
print("summary", SUMMARY_PATH)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--mesh-size", type=float, default=0.9)
parser.add_argument("--ccx", type=Path, default=Path("/opt/homebrew/bin/ccx_2.23"))
arguments = parser.parse_args()
main(mesh_size_mm=arguments.mesh_size, ccx=arguments.ccx)