| |
| from __future__ import annotations |
|
|
| import json |
| import os |
| from pathlib import Path |
|
|
| import numpy as np |
| import trimesh |
|
|
|
|
| CASE_SPEC = { |
| "case_id": "quant-cli-openscad-parametric-task-03-ubuntu", |
| "token": "EWQSCAD03", |
| "title": "long lightweight cable-tray bridge under a defined bending load case", |
| "objective": "Maximize calculated vertical bending stiffness per material volume.", |
| "metric_kind": "calculated_stiffness_per_volume", |
| "metric_description": "Euler-Bernoulli center-load stiffness 48*E*I_min/L^3 divided by material volume", |
| "envelope_min_mm": [0.0, 0.0, 0.0], |
| "envelope_max_mm": [130.0, 38.0, 45.0], |
| "min_bbox_mm": [124.0, 32.0, 36.0], |
| "min_volume_mm3": 52000.0, |
| "max_volume_mm3": 98000.0, |
| "material": { |
| "model": "isotropic linear elastic geometry proxy", |
| "youngs_modulus_n_per_mm2": 2000.0, |
| "allowable_bending_stress_mpa": 12.0, |
| }, |
| "load_case": { |
| "support_x_mm": [2.0, 128.0], |
| "span_mm": 126.0, |
| "center_load_n": 100.0, |
| "load_direction": "negative Z", |
| "support_z_mm": 0.0, |
| "support_zone_x_mm": [[0.0, 5.0], [125.0, 130.0]], |
| "min_support_contact_area_each_mm2": 170.0, |
| "load_patch_x_mm": [62.0, 68.0], |
| "load_patch_y_mm": [[5.0, 9.0], [29.0, 33.0]], |
| "min_load_area_each_mm2": 20.0, |
| "min_load_surface_z_mm": 40.0, |
| }, |
| "section_pitch_mm": 1.0, |
| "section_x_samples_mm": [round(float(value), 2) for value in np.arange(5.0, 125.01, 2.5)], |
| "min_effective_I_y_mm4": 75000.0, |
| "max_predicted_deflection_mm": 0.03, |
| "baseline_metrics": { |
| "bbox_mm": [130.0, 38.0, 21.1], |
| "volume_mm3": 83487.1923, |
| "effective_I_y_mm4": 202.6667, |
| "calculated_stiffness_n_per_mm": 9.726171, |
| "calculated_stiffness_per_volume": 0.00011650, |
| }, |
| "reference_metrics": { |
| "bbox_mm": [130.0, 38.0, 42.0], |
| "volume_mm3": 73024.0, |
| "effective_I_y_mm4": 81472.0, |
| "predicted_center_deflection_mm": 0.02557596, |
| "predicted_max_bending_stress_mpa": 1.005253, |
| "calculated_stiffness_n_per_mm": 3909.920935, |
| "calculated_stiffness_per_volume": 0.05354296, |
| }, |
| } |
|
|
| DESKTOP = Path(os.environ.get("ENGIWORLD_EVAL_DIR") or os.environ.get("OUTPUT_ROOT") or "/home/user/Desktop") |
| TOL = 0.15 |
|
|
|
|
| def clamp(value, low=0.0, high=1.0): |
| return max(low, min(high, float(value))) |
|
|
|
|
| def as_mesh(obj): |
| if isinstance(obj, trimesh.Scene): |
| meshes = [geometry for geometry in obj.geometry.values() if isinstance(geometry, trimesh.Trimesh)] |
| if not meshes: |
| raise ValueError("scene has no mesh geometry") |
| return trimesh.util.concatenate(meshes) |
| return obj |
|
|
|
|
| def load_stl(path: Path): |
| if not path.is_file() or path.stat().st_size < 500: |
| raise ValueError("optimized.stl missing or too small") |
| mesh = as_mesh(trimesh.load_mesh(str(path), file_type="stl", process=True)) |
| if mesh.vertices is None or len(mesh.vertices) < 8 or len(mesh.faces) < 12: |
| raise ValueError("optimized.stl has too little mesh geometry") |
| return mesh |
|
|
|
|
| def connected_shell_count(mesh): |
| faces = np.asarray(mesh.faces, dtype=np.int64) |
| parent = np.arange(len(faces), dtype=np.int64) |
|
|
| def find(item): |
| while parent[item] != item: |
| parent[item] = parent[parent[item]] |
| item = parent[item] |
| return int(item) |
|
|
| def union(a, b): |
| root_a, root_b = find(int(a)), find(int(b)) |
| if root_a != root_b: |
| parent[root_b] = root_a |
|
|
| edge_owner = {} |
| for face_index, face in enumerate(faces): |
| a, b, c = (int(value) for value in face) |
| for edge in ((a, b), (b, c), (c, a)): |
| key = tuple(sorted(edge)) |
| if key in edge_owner: |
| union(face_index, edge_owner[key]) |
| else: |
| edge_owner[key] = face_index |
| return len({find(index) for index in range(len(faces))}) |
|
|
|
|
| def projected_xy_hit(x, y, triangle): |
| a, b, c = triangle |
| v0 = c[:2] - a[:2] |
| v1 = b[:2] - a[:2] |
| v2 = np.asarray([x, y], dtype=float) - a[:2] |
| denominator = v0[0] * v1[1] - v1[0] * v0[1] |
| if abs(float(denominator)) < 1e-10: |
| return False |
| u = (v2[0] * v1[1] - v1[0] * v2[1]) / denominator |
| v = (v0[0] * v2[1] - v2[0] * v0[1]) / denominator |
| return bool(u >= -1e-9 and v >= -1e-9 and u + v <= 1.0 + 1e-9) |
|
|
|
|
| def projected_yz_hit_x(y, z, triangle): |
| a, b, c = triangle |
| v0 = c[1:] - a[1:] |
| v1 = b[1:] - a[1:] |
| v2 = np.asarray([y, z], dtype=float) - a[1:] |
| denominator = v0[0] * v1[1] - v1[0] * v0[1] |
| if abs(float(denominator)) < 1e-10: |
| return None |
| u = (v2[0] * v1[1] - v1[0] * v2[1]) / denominator |
| v = (v0[0] * v2[1] - v2[0] * v0[1]) / denominator |
| if u < -1e-9 or v < -1e-9 or u + v > 1.0 + 1e-9: |
| return None |
| return float(a[0] + u * (c[0] - a[0]) + v * (b[0] - a[0])) |
|
|
|
|
| def raster_xy_surface(mesh, selector): |
| pitch = CASE_SPEC["section_pitch_mm"] |
| width, depth = CASE_SPEC["envelope_max_mm"][:2] |
| xs = np.arange(0.5 * pitch, width, pitch) |
| ys = np.arange(0.5 * pitch, depth, pitch) |
| triangles = np.asarray(mesh.triangles, dtype=float) |
| normals = np.asarray(mesh.face_normals, dtype=float) |
| selected = [triangle for triangle, normal in zip(triangles, normals) if selector(triangle, normal)] |
| mask = np.zeros((len(ys), len(xs)), dtype=bool) |
| for row, y in enumerate(ys): |
| for column, x in enumerate(xs): |
| mask[row, column] = any(projected_xy_hit(x, y, triangle) for triangle in selected) |
| return mask |
|
|
|
|
| def boundary_contact_metrics(mesh): |
| pitch = CASE_SPEC["section_pitch_mm"] |
| bottom = raster_xy_surface( |
| mesh, |
| lambda triangle, normal: normal[2] < -0.9 |
| and np.max(np.abs(triangle[:, 2] - CASE_SPEC["load_case"]["support_z_mm"])) <= TOL, |
| ) |
| top = raster_xy_surface( |
| mesh, |
| lambda triangle, normal: normal[2] > 0.9 |
| and np.ptp(triangle[:, 2]) <= TOL |
| and np.mean(triangle[:, 2]) >= CASE_SPEC["load_case"]["min_load_surface_z_mm"] - TOL, |
| ) |
| support_areas = [] |
| for low, high in CASE_SPEC["load_case"]["support_zone_x_mm"]: |
| first, last = int(round(low / pitch)), int(round(high / pitch)) |
| support_areas.append(float(bottom[:, first:last].sum()) * pitch * pitch) |
| load_areas = [] |
| x_low, x_high = CASE_SPEC["load_case"]["load_patch_x_mm"] |
| x_first, x_last = int(round(x_low / pitch)), int(round(x_high / pitch)) |
| for y_low, y_high in CASE_SPEC["load_case"]["load_patch_y_mm"]: |
| y_first, y_last = int(round(y_low / pitch)), int(round(y_high / pitch)) |
| load_areas.append(float(top[y_first:y_last, x_first:x_last].sum()) * pitch * pitch) |
| return { |
| "support_contact_areas_mm2": [round(value, 4) for value in support_areas], |
| "load_patch_areas_mm2": [round(value, 4) for value in load_areas], |
| } |
|
|
|
|
| def yz_ray_hits(mesh): |
| """Compute X crossings once for every Y-Z cell; reuse them for all sections.""" |
| pitch = CASE_SPEC["section_pitch_mm"] |
| depth, height = CASE_SPEC["envelope_max_mm"][1], CASE_SPEC["envelope_max_mm"][2] |
| ys = np.arange(0.5 * pitch, depth, pitch) |
| zs = np.arange(0.5 * pitch, height, pitch) |
| triangles = np.asarray(mesh.triangles, dtype=float) |
| hit_grid = [[None for _ in ys] for _ in zs] |
| for z_index, z in enumerate(zs): |
| for y_index, y in enumerate(ys): |
| hits = [] |
| for triangle in triangles: |
| hit = projected_yz_hit_x(y, z, triangle) |
| if hit is not None and all(abs(hit - previous) > 1e-6 for previous in hits): |
| hits.append(hit) |
| hit_grid[z_index][y_index] = sorted(hits) |
| return ys, zs, hit_grid |
|
|
|
|
| def section_mask_at_x(hit_grid, x): |
| height = len(hit_grid) |
| width = len(hit_grid[0]) if height else 0 |
| mask = np.zeros((height, width), dtype=bool) |
| for row in range(height): |
| for column in range(width): |
| mask[row, column] = sum(hit > x + 1e-7 for hit in hit_grid[row][column]) % 2 == 1 |
| return mask |
|
|
|
|
| def component_count(mask): |
| visited = np.zeros_like(mask, dtype=bool) |
| count = 0 |
| rows, columns = mask.shape |
| for row in range(rows): |
| for column in range(columns): |
| if not mask[row, column] or visited[row, column]: |
| continue |
| count += 1 |
| visited[row, column] = True |
| stack = [(row, column)] |
| while stack: |
| current_row, current_column = stack.pop() |
| for next_row, next_column in ( |
| (current_row - 1, current_column), |
| (current_row + 1, current_column), |
| (current_row, current_column - 1), |
| (current_row, current_column + 1), |
| ): |
| if ( |
| 0 <= next_row < rows |
| and 0 <= next_column < columns |
| and mask[next_row, next_column] |
| and not visited[next_row, next_column] |
| ): |
| visited[next_row, next_column] = True |
| stack.append((next_row, next_column)) |
| return count |
|
|
|
|
| def section_structural_metrics(mesh): |
| pitch = CASE_SPEC["section_pitch_mm"] |
| ys, zs, hit_grid = yz_ray_hits(mesh) |
| z_grid = np.repeat(zs[:, None], len(ys), axis=1) |
| sections = [] |
| supports = CASE_SPEC["load_case"]["support_x_mm"] |
| load = CASE_SPEC["load_case"]["center_load_n"] |
| for x in CASE_SPEC["section_x_samples_mm"]: |
| mask = section_mask_at_x(hit_grid, x) |
| area = float(mask.sum()) * pitch * pitch |
| if area <= 0: |
| sections.append({"x": x, "area": 0.0, "I": 0.0, "stress": 1e30, "components": 0}) |
| continue |
| occupied_z = z_grid[mask] |
| centroid_z = float(np.mean(occupied_z)) |
| inertia = float(np.sum((occupied_z - centroid_z) ** 2 + pitch * pitch / 12.0) * pitch * pitch) |
| z_min = float(np.min(occupied_z) - 0.5 * pitch) |
| z_max = float(np.max(occupied_z) + 0.5 * pitch) |
| extreme_distance = max(centroid_z - z_min, z_max - centroid_z) |
| moment = 0.5 * load * min(max(x - supports[0], 0.0), max(supports[1] - x, 0.0)) |
| stress = moment * extreme_distance / max(inertia, 1e-9) |
| sections.append( |
| { |
| "x": x, |
| "area": area, |
| "centroid_z": centroid_z, |
| "I": inertia, |
| "stress": stress, |
| "components": component_count(mask), |
| } |
| ) |
| effective_I = min(section["I"] for section in sections) |
| minimum_area = min(section["area"] for section in sections) |
| maximum_stress = max(section["stress"] for section in sections) |
| maximum_components = max(section["components"] for section in sections) |
| E = CASE_SPEC["material"]["youngs_modulus_n_per_mm2"] |
| span = CASE_SPEC["load_case"]["span_mm"] |
| load = CASE_SPEC["load_case"]["center_load_n"] |
| stiffness = 48.0 * E * effective_I / (span**3) |
| deflection = load / max(stiffness, 1e-9) |
| governing_I_section = min(sections, key=lambda section: section["I"]) |
| governing_stress_section = max(sections, key=lambda section: section["stress"]) |
| return { |
| "section_sample_count": len(sections), |
| "minimum_section_area_mm2": round(minimum_area, 4), |
| "effective_I_y_mm4": round(effective_I, 4), |
| "governing_I_section_x_mm": governing_I_section["x"], |
| "maximum_section_component_count": maximum_components, |
| "predicted_center_deflection_mm": round(deflection, 8), |
| "predicted_max_bending_stress_mpa": round(maximum_stress, 6), |
| "governing_stress_section_x_mm": governing_stress_section["x"], |
| "calculated_stiffness_n_per_mm": round(stiffness, 6), |
| } |
|
|
|
|
| def metrics(mesh): |
| bounds = np.asarray(mesh.bounds, dtype=float) |
| dims = bounds[1] - bounds[0] |
| volume = float(mesh.volume) |
| result = { |
| "bounds_min_mm": [round(float(value), 4) for value in bounds[0]], |
| "bounds_max_mm": [round(float(value), 4) for value in bounds[1]], |
| "bbox_mm": [round(float(value), 4) for value in dims], |
| "volume_mm3": round(volume, 4), |
| "surface_area_mm2": round(float(mesh.area), 4), |
| "watertight": bool(mesh.is_watertight), |
| "winding_consistent": bool(mesh.is_winding_consistent), |
| "connected_shell_count": connected_shell_count(mesh), |
| } |
| result.update(boundary_contact_metrics(mesh)) |
| result.update(section_structural_metrics(mesh)) |
| result["calculated_stiffness_per_volume"] = round( |
| result["calculated_stiffness_n_per_mm"] / max(volume, 1e-9), 8 |
| ) |
| return result |
|
|
|
|
| def design_summary_errors(): |
| path = DESKTOP / "design_summary.json" |
| if not path.is_file(): |
| return ["design_summary:missing"] |
| try: |
| data = json.loads(path.read_text(encoding="utf-8")) |
| except Exception as exc: |
| return [f"design_summary:unreadable:{exc}"] |
| errors = [] |
| if data.get("case_id") != CASE_SPEC["case_id"]: |
| errors.append("design_summary:case_id_mismatch") |
| if data.get("token") != CASE_SPEC["token"]: |
| errors.append("design_summary:token_mismatch") |
| if not isinstance(data.get("design"), str) or not data["design"].strip(): |
| errors.append("design_summary:missing_design_text") |
| return errors |
|
|
|
|
| def score_from_metrics(measured): |
| efficiency = measured["calculated_stiffness_per_volume"] |
| baseline = CASE_SPEC["baseline_metrics"]["calculated_stiffness_per_volume"] |
| reference = CASE_SPEC["reference_metrics"]["calculated_stiffness_per_volume"] |
| raw = (efficiency - baseline) / max(reference - baseline, 1e-9) |
| volume_factor = clamp( |
| (CASE_SPEC["max_volume_mm3"] - measured["volume_mm3"]) |
| / max(CASE_SPEC["max_volume_mm3"] - CASE_SPEC["reference_metrics"]["volume_mm3"], 1.0), |
| 0.0, |
| 1.10, |
| ) |
| height_factor = clamp(measured["bbox_mm"][2] / CASE_SPEC["envelope_max_mm"][2], 0.75, 1.0) |
| score = clamp(0.88 * raw + 0.08 * volume_factor + 0.04 * height_factor) |
| return { |
| "metric_kind": CASE_SPEC["metric_kind"], |
| "metric_value": round(efficiency, 8), |
| "raw_efficiency_score": round(clamp(raw), 6), |
| "volume_factor": round(volume_factor, 6), |
| "height_factor": round(height_factor, 6), |
| "score": round(score, 6), |
| } |
|
|
|
|
| def hard_errors(measured): |
| errors = [] |
| for axis, (got, minimum) in enumerate(zip(measured["bounds_min_mm"], CASE_SPEC["envelope_min_mm"])): |
| if got < minimum - TOL: |
| errors.append(f"bounds_min_axis_{axis}:below_envelope:{got}<{minimum}") |
| if abs(measured["bounds_min_mm"][2] - CASE_SPEC["envelope_min_mm"][2]) > TOL: |
| errors.append( |
| f"support_contact_z:must_be_{CASE_SPEC['envelope_min_mm'][2]}:got_{measured['bounds_min_mm'][2]}" |
| ) |
| for axis, (got, maximum) in enumerate(zip(measured["bounds_max_mm"], CASE_SPEC["envelope_max_mm"])): |
| if got > maximum + TOL: |
| errors.append(f"bounds_max_axis_{axis}:too_large:{got}>{maximum}") |
| for axis, (got, minimum) in enumerate(zip(measured["bbox_mm"], CASE_SPEC["min_bbox_mm"])): |
| if got < minimum - TOL: |
| errors.append(f"bbox_axis_{axis}:too_small:{got}<{minimum}") |
| if not (CASE_SPEC["min_volume_mm3"] <= measured["volume_mm3"] <= CASE_SPEC["max_volume_mm3"]): |
| errors.append(f"volume:outside_range:{measured['volume_mm3']}") |
| if not measured["watertight"] or not measured["winding_consistent"] or measured["volume_mm3"] <= 0: |
| errors.append("solid:must_be_watertight_positive_and_winding_consistent") |
| if measured["connected_shell_count"] != 1: |
| errors.append(f"solid:must_have_one_edge_connected_shell:got_{measured['connected_shell_count']}") |
| for index, area in enumerate(measured["support_contact_areas_mm2"]): |
| if area < CASE_SPEC["load_case"]["min_support_contact_area_each_mm2"]: |
| errors.append(f"support_{index}:contact_area_too_small:{area}") |
| for index, area in enumerate(measured["load_patch_areas_mm2"]): |
| if area < CASE_SPEC["load_case"]["min_load_area_each_mm2"]: |
| errors.append(f"load_patch_{index}:bearing_area_too_small:{area}") |
| if measured["maximum_section_component_count"] != 1: |
| errors.append(f"load_path:cross_sections_must_be_connected:got_{measured['maximum_section_component_count']}") |
| if measured["effective_I_y_mm4"] < CASE_SPEC["min_effective_I_y_mm4"]: |
| errors.append(f"effective_I_y:too_small:{measured['effective_I_y_mm4']}") |
| if measured["predicted_center_deflection_mm"] > CASE_SPEC["max_predicted_deflection_mm"]: |
| errors.append(f"predicted_deflection:too_large:{measured['predicted_center_deflection_mm']}") |
| if measured["predicted_max_bending_stress_mpa"] > CASE_SPEC["material"]["allowable_bending_stress_mpa"]: |
| errors.append(f"predicted_bending_stress:too_large:{measured['predicted_max_bending_stress_mpa']}") |
| if measured["calculated_stiffness_per_volume"] <= 0: |
| errors.append("calculated_stiffness_metric:non_positive") |
| return errors |
|
|
|
|
| def write_result(result): |
| for name in ("score.json", "quant_metrics.json"): |
| try: |
| (DESKTOP / name).write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") |
| except Exception: |
| pass |
| print("True" if result.get("valid") else "False") |
|
|
|
|
| def main(): |
| try: |
| measured = metrics(load_stl(DESKTOP / "optimized.stl")) |
| errors = design_summary_errors() + hard_errors(measured) |
| score_bits = score_from_metrics(measured) |
| result = { |
| "case_id": CASE_SPEC["case_id"], |
| "valid": not errors, |
| "score": 0.0 if errors else score_bits["score"], |
| "errors": errors, |
| "metrics": measured | score_bits, |
| "baseline_metrics": CASE_SPEC["baseline_metrics"], |
| "reference_metrics": CASE_SPEC["reference_metrics"], |
| } |
| except Exception as exc: |
| result = {"case_id": CASE_SPEC["case_id"], "valid": False, "score": 0.0, "errors": [str(exc)], "metrics": {}} |
| write_result(result) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
