226 lines
7.8 KiB
Python
226 lines
7.8 KiB
Python
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
from pathlib import Path
|
|
|
|
from common_csv import as_float, as_int, read_required_csv
|
|
|
|
|
|
IPC_HEADERS = [
|
|
"step_id",
|
|
"solver_id",
|
|
"command_id",
|
|
"command_seq",
|
|
"ack_seq",
|
|
"worker_state",
|
|
"heartbeat_seq",
|
|
"elapsed_ms",
|
|
"error_code",
|
|
]
|
|
|
|
CONTACT_HEADERS = [
|
|
"step_id",
|
|
"pair_id",
|
|
"sph_id",
|
|
"facet_id",
|
|
"gap",
|
|
"penetration",
|
|
"normal_x",
|
|
"normal_y",
|
|
"normal_z",
|
|
"force_x",
|
|
"force_y",
|
|
"force_z",
|
|
"node_count",
|
|
]
|
|
|
|
FORCE_HEADERS = [
|
|
"step_id",
|
|
"sph_fx",
|
|
"sph_fy",
|
|
"sph_fz",
|
|
"fem_fx",
|
|
"fem_fy",
|
|
"fem_fz",
|
|
"total_fx",
|
|
"total_fy",
|
|
"total_fz",
|
|
"num_contacts",
|
|
"max_penetration",
|
|
"total_contact_force_norm",
|
|
"force_balance_error",
|
|
"moment_balance_error",
|
|
"nonfinite_contact_count",
|
|
"skipped_separated_count",
|
|
"skipped_degenerate_count",
|
|
"skipped_invalid_count",
|
|
]
|
|
|
|
|
|
def build_report(args: argparse.Namespace) -> dict:
|
|
output_dir = Path(args.output_dir)
|
|
ipc_path = output_dir / "ipc_report.csv"
|
|
contact_path = output_dir / "contact_report.csv"
|
|
force_path = output_dir / "force_balance.csv"
|
|
log_path = output_dir / "run.log"
|
|
failed: list[str] = []
|
|
metrics: dict[str, int | float] = {}
|
|
|
|
try:
|
|
_, ipc_rows = read_required_csv(ipc_path, IPC_HEADERS)
|
|
_, contact_rows = read_required_csv(contact_path, CONTACT_HEADERS)
|
|
_, force_rows = read_required_csv(force_path, FORCE_HEADERS)
|
|
except AssertionError as exc:
|
|
ipc_rows = []
|
|
contact_rows = []
|
|
force_rows = []
|
|
failed.append(str(exc))
|
|
|
|
if not log_path.exists():
|
|
failed.append(f"missing log file: {log_path}")
|
|
elif "contact_narrow_force" not in log_path.read_text(encoding="utf-8"):
|
|
failed.append("run.log missing contact_narrow_force diagnostics")
|
|
|
|
import_load_rows = 0
|
|
advance_rows = 0
|
|
stop_rows = 0
|
|
for index, row in enumerate(ipc_rows, start=1):
|
|
try:
|
|
command_seq = as_int(row, "command_seq")
|
|
ack_seq = as_int(row, "ack_seq")
|
|
command_id = as_int(row, "command_id")
|
|
error_code = as_int(row, "error_code")
|
|
except AssertionError as exc:
|
|
failed.append(f"ipc row {index}: {exc}")
|
|
continue
|
|
if command_seq != ack_seq:
|
|
failed.append(f"ipc row {index}: seq/ack mismatch {command_seq}/{ack_seq}")
|
|
if error_code != 0:
|
|
failed.append(f"ipc row {index}: nonzero error_code {error_code}")
|
|
if command_id == 5:
|
|
import_load_rows += 1
|
|
if command_id == 6:
|
|
advance_rows += 1
|
|
if command_id == 99:
|
|
stop_rows += 1
|
|
|
|
expected_worker_step_rows = args.expected_steps * 2
|
|
if import_load_rows != expected_worker_step_rows:
|
|
failed.append(f"expected {expected_worker_step_rows} IMPORT_LOADS rows, got {import_load_rows}")
|
|
if advance_rows != expected_worker_step_rows:
|
|
failed.append(f"expected {expected_worker_step_rows} ADVANCE rows, got {advance_rows}")
|
|
if stop_rows != 2:
|
|
failed.append(f"expected two STOP rows, got {stop_rows}")
|
|
|
|
contact_steps: set[int] = set()
|
|
for index, row in enumerate(contact_rows, start=1):
|
|
try:
|
|
step_id = as_int(row, "step_id")
|
|
penetration = as_float(row, "penetration")
|
|
normal_z = as_float(row, "normal_z")
|
|
force_z = as_float(row, "force_z")
|
|
node_count = as_int(row, "node_count")
|
|
except AssertionError as exc:
|
|
failed.append(f"contact row {index}: {exc}")
|
|
continue
|
|
contact_steps.add(step_id)
|
|
if node_count != 4:
|
|
failed.append(f"contact row {index}: node_count expected 4, got {node_count}")
|
|
if penetration <= 0.0:
|
|
failed.append(f"contact row {index}: penetration should be positive")
|
|
if abs(normal_z - 1.0) > 1.0e-12:
|
|
failed.append(f"contact row {index}: normal_z expected 1")
|
|
if force_z <= 0.0:
|
|
failed.append(f"contact row {index}: force_z should be positive")
|
|
|
|
expected_steps = set(range(1, args.expected_steps + 1))
|
|
if contact_steps != expected_steps:
|
|
failed.append(f"contact steps mismatch: expected {sorted(expected_steps)}, got {sorted(contact_steps)}")
|
|
|
|
force_steps: set[int] = set()
|
|
for index, row in enumerate(force_rows, start=1):
|
|
try:
|
|
step_id = as_int(row, "step_id")
|
|
num_contacts = as_int(row, "num_contacts")
|
|
max_penetration = as_float(row, "max_penetration")
|
|
total_force_norm = as_float(row, "total_contact_force_norm")
|
|
force_balance_error = as_float(row, "force_balance_error")
|
|
moment_balance_error = as_float(row, "moment_balance_error")
|
|
nonfinite_count = as_int(row, "nonfinite_contact_count")
|
|
totals = [as_float(row, key) for key in ("total_fx", "total_fy", "total_fz")]
|
|
except AssertionError as exc:
|
|
failed.append(f"force row {index}: {exc}")
|
|
continue
|
|
force_steps.add(step_id)
|
|
if num_contacts != 1:
|
|
failed.append(f"force row {index}: num_contacts expected 1, got {num_contacts}")
|
|
if max_penetration <= 0.0:
|
|
failed.append(f"force row {index}: max_penetration should be positive")
|
|
if total_force_norm <= 0.0:
|
|
failed.append(f"force row {index}: total_contact_force_norm should be positive")
|
|
if force_balance_error > args.tolerance:
|
|
failed.append(f"force row {index}: force_balance_error {force_balance_error}")
|
|
if moment_balance_error > args.tolerance:
|
|
failed.append(f"force row {index}: moment_balance_error {moment_balance_error}")
|
|
if nonfinite_count != 0:
|
|
failed.append(f"force row {index}: nonfinite_contact_count {nonfinite_count}")
|
|
if max(abs(value) for value in totals) > args.tolerance:
|
|
failed.append(f"force row {index}: total force columns are not balanced")
|
|
|
|
if force_steps != expected_steps:
|
|
failed.append(f"force steps mismatch: expected {sorted(expected_steps)}, got {sorted(force_steps)}")
|
|
|
|
metrics["ipc_rows"] = len(ipc_rows)
|
|
metrics["contact_rows"] = len(contact_rows)
|
|
metrics["force_rows"] = len(force_rows)
|
|
metrics["import_load_rows"] = import_load_rows
|
|
metrics["advance_rows"] = advance_rows
|
|
return make_report(args, failed, ipc_path, contact_path, force_path, log_path, metrics)
|
|
|
|
|
|
def make_report(
|
|
args: argparse.Namespace,
|
|
failed: list[str],
|
|
ipc_path: Path,
|
|
contact_path: Path,
|
|
force_path: Path,
|
|
log_path: Path,
|
|
metrics: dict,
|
|
) -> dict:
|
|
return {
|
|
"case_id": args.case_id,
|
|
"status": "PASS" if not failed else "FAIL",
|
|
"metrics": metrics,
|
|
"failed_checks": failed,
|
|
"input": str(Path(args.input)),
|
|
"output_files": {
|
|
"run_log": str(log_path),
|
|
"ipc_report": str(ipc_path),
|
|
"contact_report": str(contact_path),
|
|
"force_balance": str(force_path),
|
|
},
|
|
}
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--case-id", required=True)
|
|
parser.add_argument("--input", required=True)
|
|
parser.add_argument("--output-dir", required=True)
|
|
parser.add_argument("--report", required=True)
|
|
parser.add_argument("--expected-steps", type=int, default=2)
|
|
parser.add_argument("--tolerance", type=float, default=1.0e-7)
|
|
args = parser.parse_args()
|
|
|
|
report = build_report(args)
|
|
report_path = Path(args.report)
|
|
report_path.parent.mkdir(parents=True, exist_ok=True)
|
|
report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
|
print(f"{report['case_id']} {report['status']} -> {report_path}")
|
|
return 0 if report["status"] == "PASS" else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|