| |
| """Validate the complete automotive-impact release package.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import sys |
| import time |
| import zipfile |
| from collections import Counter |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
|
|
| from load_case import ( |
| canonical_case_id, |
| load_case, |
| load_case_bytes, |
| load_mesh, |
| load_split, |
| shard_name, |
| ) |
|
|
|
|
| SPECS = { |
| "floorfrontdriver": {"nodes": 7408, "edges": 29572, "elements": 7374}, |
| "floorfrontR": {"nodes": 12011, "edges": 48138, "elements": 12055}, |
| "trunkfloor": {"nodes": 14440, "edges": 58074, "elements": 14589}, |
| } |
|
|
|
|
| def sha256_bytes(payload: bytes) -> str: |
| return hashlib.sha256(payload).hexdigest() |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def fail(errors: list[str], message: str) -> None: |
| errors.append(message) |
| print(f"ERROR: {message}", file=sys.stderr) |
|
|
|
|
| def validate_split(root: Path, errors: list[str]) -> dict: |
| split = load_split(root) |
| expected_sizes = {"train": 400, "val": 50, "test": 50} |
| for name, expected in expected_sizes.items(): |
| values = split.get(name) |
| if not isinstance(values, list) or len(values) != expected: |
| fail(errors, f"split {name!r}: expected {expected} entries") |
| continue |
| canonical = [canonical_case_id(value) for value in values] |
| if canonical != values: |
| fail(errors, f"split {name!r} contains non-canonical case IDs") |
| if len(set(values)) != len(values): |
| fail(errors, f"split {name!r} contains duplicates") |
| union = set().union(*(set(split.get(key, [])) for key in expected_sizes)) |
| if union != {f"case{index:03d}" for index in range(1, 501)}: |
| fail(errors, "split union is not exactly case001..case500") |
| names = list(expected_sizes) |
| for left_index, left in enumerate(names): |
| for right in names[left_index + 1 :]: |
| if set(split.get(left, [])) & set(split.get(right, [])): |
| fail(errors, f"split overlap: {left} and {right}") |
| return split |
|
|
|
|
| def validate_mesh(root: Path, geometry: str, spec: dict, errors: list[str]) -> dict: |
| mesh = load_mesh(root, geometry) |
| expected = { |
| "node_pos": (spec["nodes"], 3), |
| "edge_index": (2, spec["edges"]), |
| "element_node_index": (spec["elements"], 4), |
| "element_node_count": (spec["elements"],), |
| "boundary_mask": (spec["nodes"],), |
| } |
| for key, shape in expected.items(): |
| if key not in mesh: |
| fail(errors, f"{geometry} mesh missing {key}") |
| elif mesh[key].shape != shape: |
| fail(errors, f"{geometry} mesh {key}: {mesh[key].shape} != {shape}") |
| if "node_pos" in mesh and not np.isfinite(mesh["node_pos"]).all(): |
| fail(errors, f"{geometry} mesh node_pos is non-finite") |
| if "edge_index" in mesh: |
| edges = mesh["edge_index"] |
| if edges.min() < 0 or edges.max() >= spec["nodes"]: |
| fail(errors, f"{geometry} edge_index is out of range") |
| if "element_node_index" in mesh: |
| connectivity = mesh["element_node_index"] |
| if connectivity.min() < 0 or connectivity.max() >= spec["nodes"]: |
| fail(errors, f"{geometry} element_node_index is out of range") |
| if "element_node_count" in mesh and not np.isin( |
| mesh["element_node_count"], [3, 4] |
| ).all(): |
| fail(errors, f"{geometry} element_node_count contains values outside 3/4") |
| return { |
| "nodes": spec["nodes"], |
| "edges": spec["edges"], |
| "elements": spec["elements"], |
| } |
|
|
|
|
| def validate_case( |
| root: Path, |
| geometry: str, |
| case_id: str, |
| spec: dict, |
| expected_digest: str | None, |
| errors: list[str], |
| ) -> dict: |
| payload = load_case_bytes(root, geometry, case_id) |
| digest = sha256_bytes(payload) |
| if expected_digest and digest != expected_digest: |
| fail(errors, f"{geometry}/{case_id}: SHA-256 mismatch") |
| data = torch.load( |
| __import__("io").BytesIO(payload), map_location="cpu", weights_only=True |
| ) |
| if data.get("case") != case_id: |
| fail(errors, f"{geometry}/{case_id}: stored case identifier mismatch") |
| expected_shapes = { |
| "disp": (spec["nodes"], 17, 3), |
| "effective_stress": (spec["elements"], 17), |
| "time": (17,), |
| "element_time": (17,), |
| "valid_node_mask": (spec["nodes"],), |
| "boundary_mask": (spec["nodes"],), |
| "impact_xyz": (3,), |
| "velocity_xyz": (3,), |
| } |
| for key, shape in expected_shapes.items(): |
| value = data.get(key) |
| if not torch.is_tensor(value) or tuple(value.shape) != shape: |
| actual = None if value is None else getattr(value, "shape", type(value)) |
| fail(errors, f"{geometry}/{case_id} {key}: {actual} != {shape}") |
| for key in ("disp", "effective_stress", "time", "element_time"): |
| value = data.get(key) |
| if torch.is_tensor(value) and not torch.isfinite(value).all(): |
| fail(errors, f"{geometry}/{case_id}: {key} is non-finite") |
| time_values = data.get("time") |
| element_time = data.get("element_time") |
| if torch.is_tensor(time_values) and time_values.numel() == 17: |
| if not torch.all(time_values[1:] >= time_values[:-1]): |
| fail(errors, f"{geometry}/{case_id}: time is not monotonic") |
| if torch.is_tensor(element_time) and element_time.numel() == 17: |
| if not torch.all(element_time[1:] >= element_time[:-1]): |
| fail(errors, f"{geometry}/{case_id}: element_time is not monotonic") |
| if ( |
| torch.is_tensor(time_values) |
| and torch.is_tensor(element_time) |
| and tuple(time_values.shape) == (17,) |
| and tuple(element_time.shape) == (17,) |
| and not torch.allclose(time_values, element_time, rtol=0.0, atol=1.0e-8) |
| ): |
| fail(errors, f"{geometry}/{case_id}: displacement/stress time arrays differ") |
| return { |
| "bytes": len(payload), |
| "sha256": digest, |
| "material": str(data.get("material_name", "")), |
| } |
|
|
|
|
| def load_manifest(root: Path, errors: list[str]) -> dict[tuple[str, str], dict]: |
| path = root / "manifest.csv" |
| rows = {} |
| with path.open(encoding="utf-8", newline="") as handle: |
| for row in csv.DictReader(handle): |
| key = (row["geometry"], row["case"]) |
| if key in rows: |
| fail(errors, f"duplicate manifest row: {key}") |
| rows[key] = row |
| if len(rows) != 1500: |
| fail(errors, f"manifest has {len(rows)} rows, expected 1500") |
| return rows |
|
|
|
|
| def validate_archives(root: Path, errors: list[str]) -> dict: |
| archive_count = 0 |
| total_bytes = 0 |
| for geometry in SPECS: |
| for start in range(1, 501, 100): |
| end = start + 99 |
| path = root / "data" / geometry / f"cases_{start:03d}_{end:03d}.zip" |
| if not path.is_file(): |
| fail(errors, f"missing archive: {path.relative_to(root)}") |
| continue |
| archive_count += 1 |
| total_bytes += path.stat().st_size |
| with zipfile.ZipFile(path) as archive: |
| bad_member = archive.testzip() |
| if bad_member: |
| fail(errors, f"CRC failure in {path.name}: {bad_member}") |
| expected = { |
| f"cases/case{index:03d}.pt" for index in range(start, end + 1) |
| } |
| if set(archive.namelist()) != expected: |
| fail(errors, f"unexpected members in {path.relative_to(root)}") |
| return {"archives": archive_count, "archive_bytes": total_bytes} |
|
|
|
|
| def validate_checksums(root: Path, errors: list[str]) -> dict: |
| path = root / "checksums.sha256" |
| checked = 0 |
| with path.open(encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, start=1): |
| line = line.rstrip("\n") |
| if not line: |
| continue |
| try: |
| expected, relative = line.split(" ", 1) |
| except ValueError: |
| fail(errors, f"invalid checksum line {line_number}") |
| continue |
| target = root / relative |
| if not target.is_file(): |
| fail(errors, f"checksummed file missing: {relative}") |
| continue |
| if sha256_file(target) != expected: |
| fail(errors, f"file checksum mismatch: {relative}") |
| checked += 1 |
| if target.suffix == ".zip": |
| print(f"[file checksum] {relative}") |
| return {"checked_files": checked} |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset-root", type=Path, default=Path(".")) |
| parser.add_argument("--verify-checksums", action="store_true") |
| parser.add_argument("--report", type=Path) |
| args = parser.parse_args() |
|
|
| root = args.dataset_root.resolve() |
| started = time.time() |
| errors: list[str] = [] |
| split = validate_split(root, errors) |
| archives = validate_archives(root, errors) |
| manifest = load_manifest(root, errors) |
| geometry_reports = {} |
|
|
| for geometry, spec in SPECS.items(): |
| mesh_report = validate_mesh(root, geometry, spec, errors) |
| materials: Counter[str] = Counter() |
| total_bytes = 0 |
| for index in range(1, 501): |
| case_id = f"case{index:03d}" |
| row = manifest.get((geometry, case_id)) |
| expected_digest = row["source_sha256"] if row else None |
| case_report = validate_case( |
| root, geometry, case_id, spec, expected_digest, errors |
| ) |
| total_bytes += case_report["bytes"] |
| materials[case_report["material"]] += 1 |
| if index % 50 == 0: |
| print(f"[{geometry}] validated {index}/500") |
| geometry_reports[geometry] = { |
| **mesh_report, |
| "cases": 500, |
| "source_case_bytes": total_bytes, |
| "materials": dict(sorted(materials.items())), |
| } |
|
|
| checksum_report = ( |
| validate_checksums(root, errors) if args.verify_checksums else {"skipped": True} |
| ) |
| report = { |
| "dataset": "Automotive Underbody Panel Impact Dataset", |
| "version": "1.1.1", |
| "status": "passed" if not errors else "failed", |
| "cases_validated": 1500, |
| "split_sizes": {key: len(value) for key, value in split.items()}, |
| "archives": archives, |
| "geometries": geometry_reports, |
| "checksums": checksum_report, |
| "elapsed_seconds": time.time() - started, |
| "errors": errors, |
| "scope_note": ( |
| "Technical package validation only; provenance and remaining " |
| "configuration limitations are documented in the release metadata." |
| ), |
| } |
| rendered = json.dumps(report, indent=2, ensure_ascii=False) + "\n" |
| print(rendered) |
| if args.report: |
| args.report.write_text(rendered, encoding="utf-8") |
| if errors: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
