"""Compare release speed for a STEP-derived catapult spring seat.""" 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("Arm 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() holes.append((cylinder.Radius(), axis.X(), axis.Y())) fixed = sorted([[x, y] for radius, x, y in holes if abs(radius - 5) < 1e-5]) seats = [[x, y] for radius, x, y in holes if abs(radius - 3) < 1e-5] if len(fixed) != 2 or len(seats) != 1: raise ValueError("Expected two 5 mm interface bores and one 3 mm spring seat") 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 ((0, 0), (100, 0))] return { "step_sha256": hashlib.sha256(step.read_bytes()).hexdigest(), "volume_mm3": props.Mass(), "arm_mass_kg": props.Mass() * density * 1e-9, "arm_center_of_mass_m": [value / 1000 for value in props.CentreOfMass().Coord()], "arm_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], "fixed_hole_centers_mm": fixed, "spring_seat_center_mm": seats[0], "fixed_bore_intrusion_mm3": sum(shape.intersect(bore).Volume() for bore in bores), } def dynamics(properties: dict, setup: dict) -> dict: import pychrono as ch pivot = [value / 1000 for value in properties["fixed_hole_centers_mm"][0]] payload = [value / 1000 for value in properties["fixed_hole_centers_mm"][1]] seat = [value / 1000 for value in properties["spring_seat_center_mm"]] payload = [payload[i] - pivot[i] for i in (0, 1)] seat = [seat[i] - pivot[i] for i in (0, 1)] arm_center = properties["arm_center_of_mass_m"] arm_center = [arm_center[i] - (pivot[i] if i < 2 else 0) for i in range(3)] arm_mass = properties["arm_mass_kg"] payload_mass = setup["payload_mass_kg"] total_mass = arm_mass + payload_mass combined_center = [ (arm_mass * arm_center[i] + payload_mass * (payload[i] if i < 2 else 0)) / total_mass for i in range(3) ] inertia = [row[:] for row in properties["arm_inertia_tensor_kg_m2"]] for mass, point in ((arm_mass, arm_center), (payload_mass, [payload[0], payload[1], 0])): delta = [point[i] - combined_center[i] for i in range(3)] length_sq = sum(value * value for value in delta) for i in range(3): for j in range(3): inertia[i][j] += mass * ((length_sq if i == j else 0) - delta[i] * delta[j]) angle = setup["initial_angle_rad"] 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") system = ch.ChSystemNSC() system.SetGravitationalAcceleration(ch.ChVector3d( 0, -setup["gravity_m_s2"], 0)) ground = ch.ChBody() ground.SetFixed(True) system.Add(ground) arm = ch.ChBody() arm.SetMass(total_mass) tensor = ch.ChMatrix33d() tensor.SetMatr(inertia) arm.SetInertia(tensor) arm.SetRot(ch.QuatFromAngleAxis(angle, ch.VECT_Z)) arm.SetPos(ch.ChVector3d( combined_center[0] * math.cos(angle) - combined_center[1] * math.sin(angle), combined_center[0] * math.sin(angle) + combined_center[1] * math.cos(angle), combined_center[2])) system.Add(arm) hinge = ch.ChLinkLockRevolute() hinge.Initialize(arm, ground, ch.ChFramed(ch.ChVector3d(0, 0, 0))) system.Add(hinge) spring = ch.ChForce() arm.AddForce(spring) spring.SetMode(ch.ChForce.FORCE) spring.SetDir(ch.ChVector3d(0, 1, 0)) damper = ch.ChForce() arm.AddForce(damper) damper.SetMode(ch.ChForce.TORQUE) damper.SetDir(ch.ChVector3d(0, 0, 1)) peak_reaction = 0.0 for i in range(steps): seat_world = arm.TransformPointLocalToParent(ch.ChVector3d( seat[0] - combined_center[0], seat[1] - combined_center[1], -combined_center[2])) spring.SetVpoint(seat_world) spring.SetMforce(setup["spring_preload_N"] - setup["spring_stiffness_N_m"] * seat_world.y) damper.SetMforce(-setup["pivot_damping_N_m_s_rad"] * arm.GetAngVelParent().z) system.DoStepDynamics(dt) omega = arm.GetAngVelParent().z angle += omega * dt reaction = hinge.GetReaction1().force peak_reaction = max(peak_reaction, math.hypot(reaction.x, reaction.y)) if not math.isfinite(angle) or not math.isfinite(peak_reaction): raise ValueError("Nonfinite catapult dynamics") if angle >= setup["release_angle_rad"]: return { "release_time_s": (i + 1) * dt, "release_speed_m_s": math.hypot(*payload) * abs(omega), "peak_pivot_reaction_N": peak_reaction, } return {"release_time_s": None, "release_speed_m_s": 0.0, "peak_pivot_reaction_N": peak_reaction} 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"] checks = { "baseline_releases": bs["release_time_s"] is not None and bs["release_speed_m_s"] >= setup["minimum_baseline_release_speed_m_s"], "release_speed_increased": gs["release_time_s"] is not None and gs["release_speed_m_s"] >= bs["release_speed_m_s"] * (1 + setup["required_relative_release_speed_gain"]), "pivot_reaction_limited": gs["peak_pivot_reaction_N"] <= setup["maximum_peak_pivot_reaction_N"], "mass_fixed": abs(ap["arm_mass_kg"] / bp["arm_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"])), "fixed_holes_intact": all( math.hypot(a[0] - b[0], a[1] - b[1]) <= setup["maximum_fixed_hole_shift_mm"] for a, b in zip(ap["fixed_hole_centers_mm"], bp["fixed_hole_centers_mm"])), "fixed_bores_clear": ap["fixed_bore_intrusion_mm3"] <= setup["maximum_fixed_bore_intrusion_mm3"], "spring_seat_inside_allowed_span": setup["minimum_spring_seat_x_mm"] <= ap["spring_seat_center_mm"][0] <= setup["maximum_spring_seat_x_mm"] and abs(ap["spring_seat_center_mm"][1]) <= setup["maximum_spring_seat_y_mm"], } after["comparison_to_before"] = {"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"Release speed: {bs['release_speed_m_s']} -> " f"{gs['release_speed_m_s']} m/s") print(f"Peak pivot reaction: {gs['peak_pivot_reaction_N']} N") print(f"Task passed: {after['comparison_to_before']['passed']}") if not after["comparison_to_before"]["passed"]: raise SystemExit(1) if __name__ == "__main__": main()