| """Measure both STEP wheels and roll each with the same PyChrono setup.""" |
|
|
| 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, density: float) -> dict: |
| import cadquery as cq |
| 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(): |
| raise ValueError(f"Expected one valid solid: {step}") |
| props = GProp_GProps() |
| BRepGProp.VolumeProperties_s(shape.wrapped, props) |
| box = shape.BoundingBox() |
| inertia = props.MatrixOfInertia() |
| return { |
| "step_sha256": hashlib.sha256(step.read_bytes()).hexdigest(), |
| "volume_mm3": props.Mass(), |
| "mass_kg": props.Mass() * density * 1e-9, |
| "outer_diameter_mm": max(box.xlen, box.ylen), |
| "axial_thickness_mm": box.zlen, |
| "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) |
| ], |
| } |
|
|
|
|
| def dynamics(p: dict, setup: dict) -> dict: |
| import pychrono as ch |
|
|
| if max(abs(v) for v in p["center_of_mass_mm"]) > 1e-6: |
| raise ValueError("Wheel must be centered on the origin") |
| radius = p["outer_diameter_mm"] / 2000 |
| thickness = p["axial_thickness_mm"] / 1000 |
| angle = math.radians(setup["ramp_angle_deg"]) |
| system = ch.ChSystemNSC() |
| system.SetCollisionSystemType(ch.ChCollisionSystem.Type_BULLET) |
| system.SetGravitationalAcceleration(ch.ChVector3d( |
| setup["gravity_m_s2"] * math.sin(angle), |
| -setup["gravity_m_s2"] * math.cos(angle), 0, |
| )) |
| material = ch.ChContactMaterialNSC() |
| material.SetFriction(setup["contact_friction"]) |
| floor = ch.ChBodyEasyBox(3, 0.1, 0.3, 1000, False, True, material) |
| floor.SetPos(ch.ChVector3d(0, -0.05, 0)) |
| floor.SetFixed(True) |
| system.Add(floor) |
|
|
| |
| wheel = ch.ChBodyEasyCylinder( |
| ch.ChAxis_Z, radius, thickness, 1000, False, True, material |
| ) |
| wheel.SetMass(p["mass_kg"]) |
| inertia = ch.ChMatrix33d() |
| inertia.SetMatr(p["inertia_tensor_kg_m2"]) |
| wheel.SetInertia(inertia) |
| wheel.SetPos(ch.ChVector3d(setup["initial_x_m"], radius, 0)) |
| system.Add(wheel) |
|
|
| 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("Duration must contain whole time steps") |
| for _ in range(steps): |
| system.DoStepDynamics(dt) |
| vx = wheel.GetLinVel().x |
| omega = wheel.GetAngVelParent().z |
| distance = wheel.GetPos().x - setup["initial_x_m"] |
| return { |
| "down_ramp_displacement_m": distance, |
| "final_linear_speed_m_s": vx, |
| "final_angular_velocity_z_rad_s": omega, |
| "rolling_slip_ratio": abs(vx + radius * omega) / max(abs(vx), 1e-12), |
| "steps": steps, |
| } |
|
|
|
|
| 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}") |
| 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) |
| print(json.dumps( |
| measure(Path(payload["step"]), payload["density"]) |
| if args.phase == "measure" |
| else dynamics(payload["properties"], payload["setup"]) |
| )) |
| return |
|
|
| setup_path = ROOT / "setup.json" |
| setup = json.loads(setup_path.read_text()) |
| hashes = { |
| "setup_sha256": hashlib.sha256(setup_path.read_bytes()).hexdigest(), |
| "simulation_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), |
| "engine": setup["engine"], |
| "engine_version": setup["engine_version"], |
| } |
| results = {} |
| for name in ("before", "after"): |
| step = ROOT / f"{name}.step" |
| p = invoke(args.cad_python, "measure", { |
| "step": str(step), "density": setup["material_density_kg_m3"], |
| }) |
| results[name] = { |
| "step": step.name, "setup": "setup.json", "simulation": "simulate.py", |
| "step_properties": p, |
| "simulation_result": invoke(args.physics_python, "dynamics", { |
| "properties": p, "setup": setup, |
| }), |
| "provenance": hashes, |
| } |
|
|
| b, a = results["before"], results["after"] |
| bp, ap = b["step_properties"], a["step_properties"] |
| bd = b["simulation_result"]["down_ramp_displacement_m"] |
| ad = a["simulation_result"]["down_ramp_displacement_m"] |
| gain = ad / bd - 1 |
| checks = { |
| "displacement_gain": gain >= setup["required_relative_displacement_gain"], |
| "mass_fixed": abs(ap["mass_kg"] / bp["mass_kg"] - 1) |
| <= setup["maximum_relative_mass_change"], |
| "outer_diameter_fixed": abs(ap["outer_diameter_mm"] - bp["outer_diameter_mm"]) |
| <= setup["maximum_outer_diameter_change_mm"], |
| "both_wheels_roll_without_material_slip": all( |
| results[n]["simulation_result"]["rolling_slip_ratio"] |
| <= setup["maximum_rolling_slip_ratio"] |
| for n in ("before", "after") |
| ), |
| } |
| a["comparison_to_before"] = { |
| "relative_displacement_gain": gain, "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"Ramp displacement: {bd:.6f} -> {ad:.6f} m ({gain:.1%} gain)") |
| print(f"Task passed: {a['comparison_to_before']['passed']}") |
| if not a["comparison_to_before"]["passed"]: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
