PhyCAD-Bench / tasks /020 /simulate.py
OrlaLabs's picture
Add PhyCAD-Bench benchmark
99510bd verified
Raw History Blame Contribute Delete
10.6 kB
"""Measure slider-guide side reaction for a STEP-derived connecting rod."""
import argparse
import hashlib
import json
import math
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
def measure(step: Path, setup: dict) -> dict:
import cadquery as cq
from OCP.BRepAdaptor import BRepAdaptor_Surface
from OCP.BRepGProp import BRepGProp
from OCP.GProp import GProp_GProps
shape = cq.importers.importStep(str(step)).val()
if shape.ShapeType() != "Solid" or not shape.isValid() or len(shape.Solids()) != 1:
raise ValueError(f"Expected one valid solid: {step}")
props = GProp_GProps()
BRepGProp.VolumeProperties_s(shape.wrapped, props)
if props.Mass() <= 0:
raise ValueError("Rod volume must be positive")
holes = []
for face in shape.Faces():
if face.geomType() != "CYLINDER":
continue
cylinder = BRepAdaptor_Surface(face.wrapped).Cylinder()
axis = cylinder.Axis().Location()
if abs(cylinder.Radius() - 5) < 1e-5:
holes.append([axis.X(), axis.Y()])
holes.sort()
if len(holes) != 2:
raise ValueError("Expected two 5 mm pivot bores")
bounds = shape.BoundingBox()
inertia = props.MatrixOfInertia()
density = setup["material_density_kg_m3"]
bores = [cq.Solid.makeCylinder(5, 10, cq.Vector(x, y, -5))
for x, y in holes]
return {
"step_sha256": hashlib.sha256(step.read_bytes()).hexdigest(),
"volume_mm3": props.Mass(),
"mass_kg": props.Mass() * density * 1e-9,
"center_of_mass_mm": list(props.CentreOfMass().Coord()),
"inertia_tensor_kg_m2": [
[inertia.Value(i, j) * density * 1e-15 for j in (1, 2, 3)]
for i in (1, 2, 3)
],
"bounds_mm": [bounds.xmin, bounds.xmax, bounds.ymin, bounds.ymax,
bounds.zmin, bounds.zmax],
"pivot_centers_mm": holes,
"bore_intrusion_mm3": sum(shape.intersect(bore).Volume()
for bore in bores),
}
def dynamics(properties: dict, setup: dict) -> dict:
import pychrono as ch
pivot0, pivot1 = properties["pivot_centers_mm"]
rod_vector = [(pivot1[i] - pivot0[i]) / 1000 for i in (0, 1)]
rod_length = math.hypot(*rod_vector)
crank_throw = setup["crank_throw_m"]
theta = math.radians(setup["initial_crank_angle_deg"])
a = (crank_throw * math.cos(theta), crank_throw * math.sin(theta))
root = rod_length ** 2 - a[1] ** 2
if root <= 0:
raise ValueError("Rod cannot close the fixed slider-crank")
b = (a[0] + math.sqrt(root), 0.0)
phi = (math.atan2(-a[1], b[0] - a[0]) -
math.atan2(rod_vector[1], rod_vector[0]))
center = [value / 1000 for value in properties["center_of_mass_mm"]]
center_from_pivot = (center[0] - pivot0[0] / 1000,
center[1] - pivot0[1] / 1000)
system = ch.ChSystemNSC()
system.SetGravitationalAcceleration(ch.ChVector3d(0, 0, 0))
ground = ch.ChBody()
ground.SetFixed(True)
system.Add(ground)
crank = ch.ChBodyEasyBox(crank_throw, 0.01, 0.01, 7800,
False, False)
crank.SetPos(ch.ChVector3d(a[0] / 2, a[1] / 2, 0))
crank.SetRot(ch.QuatFromAngleAxis(theta, ch.VECT_Z))
system.Add(crank)
rod = ch.ChBody()
rod.SetMass(properties["mass_kg"])
inertia = ch.ChMatrix33d()
inertia.SetMatr(properties["inertia_tensor_kg_m2"])
rod.SetInertia(inertia)
rod.SetPos(ch.ChVector3d(
a[0] + center_from_pivot[0] * math.cos(phi) -
center_from_pivot[1] * math.sin(phi),
a[1] + center_from_pivot[0] * math.sin(phi) +
center_from_pivot[1] * math.cos(phi), center[2]))
rod.SetRot(ch.QuatFromAngleAxis(phi, ch.VECT_Z))
system.Add(rod)
slider_size = (0.04, 0.04, 0.03)
slider_mass = 2.4
slider = ch.ChBodyEasyBox(
*slider_size, slider_mass / math.prod(slider_size), False, False)
slider.SetPos(ch.ChVector3d(b[0], 0, 0))
system.Add(slider)
motor = ch.ChLinkMotorRotationSpeed()
motor.Initialize(crank, ground, ch.ChFramed(ch.ChVector3d(0, 0, 0)))
motor.SetSpeedFunction(ch.ChFunctionConst(setup["crank_speed_rad_s"]))
system.Add(motor)
for first, second, point in ((crank, rod, a), (rod, slider, b)):
joint = ch.ChLinkLockRevolute()
joint.Initialize(first, second, ch.ChFramed(
ch.ChVector3d(point[0], point[1], 0)))
system.Add(joint)
guide = ch.ChLinkLockPrismatic()
guide.Initialize(slider, ground, ch.ChFramed(
ch.ChVector3d(b[0], 0, 0),
ch.QuatFromAngleAxis(math.pi / 2, ch.VECT_Y)))
system.Add(guide)
resistance = ch.ChForce()
slider.AddForce(resistance)
resistance.SetMode(ch.ChForce.FORCE)
resistance.SetDir(ch.ChVector3d(-1, 0, 0))
resistance.SetMforce(setup["slider_axial_resistance_N"])
def on_rod(point_mm: list) -> object:
return rod.TransformPointLocalToParent(ch.ChVector3d(
(point_mm[0] - properties["center_of_mass_mm"][0]) / 1000,
(point_mm[1] - properties["center_of_mass_mm"][1]) / 1000,
-center[2]))
dt = setup["time_step_s"]
steps = round(setup["duration_s"] / dt)
if dt <= 0 or abs(steps * dt - setup["duration_s"]) > 1e-12:
raise ValueError("Invalid simulation duration or time step")
side_loads = []
slider_x = []
maximum_joint_error = 0.0
for _ in range(steps):
system.DoStepDynamics(dt)
reaction = guide.GetReaction1().force
side_load = math.hypot(reaction.x, reaction.y)
slider_x.append(slider.GetPos().x)
side_loads.append(side_load)
at_a = on_rod(pivot0)
crank_tip = crank.TransformPointLocalToParent(ch.ChVector3d(
crank_throw / 2, 0, 0))
at_b = on_rod(pivot1)
slider_pin = slider.GetPos()
maximum_joint_error = max(
maximum_joint_error,
math.hypot(at_a.x - crank_tip.x, at_a.y - crank_tip.y),
math.hypot(at_b.x - slider_pin.x, at_b.y - slider_pin.y))
if not all(math.isfinite(value) for value in side_loads + slider_x):
raise ValueError("Nonfinite slider-crank trajectory")
width = max(1, round(setup["reaction_smoothing_s"] / dt))
filtered_peak = max(
sum(side_loads[max(0, i - width // 2):min(steps, i + width // 2 + 1)]) /
(min(steps, i + width // 2 + 1) - max(0, i - width // 2))
for i in range(steps))
return {
"filtered_peak_guide_side_load_N": filtered_peak,
"raw_peak_guide_side_load_N": max(side_loads),
"slider_travel_m": max(slider_x) - min(slider_x),
"motor_rotation_rad": motor.GetMotorAngle(),
"maximum_joint_closure_error_m": maximum_joint_error,
}
def invoke(python: str, phase: str, payload: dict) -> dict:
run = subprocess.run(
[python, str(Path(__file__).resolve()), "--phase", phase],
input=json.dumps(payload), text=True, capture_output=True, check=False,
)
if run.returncode:
raise RuntimeError(f"{phase} failed:\n{run.stderr[-1600:]}")
return json.loads(run.stdout)
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--cad-python", default=sys.executable)
parser.add_argument("--physics-python", default=sys.executable)
parser.add_argument("--phase", choices=("measure", "dynamics"))
args = parser.parse_args()
if args.phase:
payload = json.load(sys.stdin)
result = (measure(Path(payload["step"]), payload["setup"])
if args.phase == "measure"
else dynamics(payload["properties"], payload["setup"]))
print(json.dumps(result))
return
setup = json.loads((ROOT / "setup.json").read_text())
results = {}
for name in ("before", "after"):
properties = invoke(args.cad_python, "measure", {
"step": str(ROOT / f"{name}.step"), "setup": setup,
})
results[name] = {
"step_properties": properties,
"simulation_result": invoke(args.physics_python, "dynamics", {
"properties": properties, "setup": setup,
}),
}
before = results["before"]
after = results["after"]
bp = before["step_properties"]
ap = after["step_properties"]
bs = before["simulation_result"]
gs = after["simulation_result"]
baseline = bs["filtered_peak_guide_side_load_N"]
candidate = gs["filtered_peak_guide_side_load_N"]
checks = {
"baseline_side_load_measurable": baseline
>= setup["minimum_baseline_side_load_N"],
"guide_side_load_reduced": candidate <= baseline *
(1 - setup["required_relative_side_load_reduction"]),
"slider_travel_kept": min(bs["slider_travel_m"], gs["slider_travel_m"])
>= setup["minimum_slider_travel_m"] and abs(
bs["slider_travel_m"] - gs["slider_travel_m"])
<= setup["maximum_stroke_difference_m"],
"motor_completes_stroke": all(
setup["minimum_motor_rotation_rad"] <= result["motor_rotation_rad"]
<= setup["maximum_motor_rotation_rad"] for result in (bs, gs)),
"joints_stay_closed": max(bs["maximum_joint_closure_error_m"],
gs["maximum_joint_closure_error_m"])
<= setup["maximum_joint_closure_error_m"],
"mass_fixed": abs(ap["mass_kg"] / bp["mass_kg"] - 1)
<= setup["maximum_relative_mass_change"],
"envelope_fixed": all(abs(a - b) <= setup["maximum_envelope_change_mm"]
for a, b in zip(ap["bounds_mm"], bp["bounds_mm"])),
"first_bore_fixed": math.hypot(
ap["pivot_centers_mm"][0][0] - bp["pivot_centers_mm"][0][0],
ap["pivot_centers_mm"][0][1] - bp["pivot_centers_mm"][0][1])
<= setup["maximum_first_bore_shift_mm"],
"pivot_bores_clear": ap["bore_intrusion_mm3"]
<= setup["maximum_bore_intrusion_mm3"],
}
after["comparison_to_before"] = {
"relative_side_load_reduction": 1 - candidate / baseline,
"checks": checks, "passed": all(checks.values())}
for name, result in results.items():
(ROOT / f"{name}.results.json").write_text(json.dumps(result, indent=2) + "\n")
print(f"Filtered peak slider side load: {baseline} -> {candidate} N")
print(f"Task passed: {after['comparison_to_before']['passed']}")
if not after["comparison_to_before"]["passed"]:
raise SystemExit(1)
if __name__ == "__main__":
main()