"""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()