| |
| from __future__ import annotations |
|
|
| import math |
| import re |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| EXPECTED = (-0.01341792, 12.67647074) |
| ABS_TOL = 2e-6 |
| REL_TOL = 2e-4 |
| NODE_ROW = re.compile(r"^\s*(\d+)\s+([+\-0-9.Ee]+)\s+([+\-0-9.Ee]+)\s+([+\-0-9.Ee]+)") |
| STRESS_ROW = re.compile(r"^\s*\d+\s+\d+\s+" + r"\s+".join([r"([+\-0-9.Ee]+)"] * 6)) |
|
|
|
|
| def read(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def close(actual: float, expected: float) -> bool: |
| return math.isfinite(actual) and abs(actual - expected) <= max( |
| ABS_TOL, REL_TOL * max(1.0, abs(expected)) |
| ) |
|
|
|
|
| def mises(values: tuple[float, float, float, float, float, float]) -> float: |
| sx, sy, sz, txy, txz, tyz = values |
| return math.sqrt( |
| ((sx - sy) ** 2 + (sy - sz) ** 2 + (sz - sx) ** 2) / 2.0 |
| + 3.0 * (txy**2 + txz**2 + tyz**2) |
| ) |
|
|
|
|
| def parse_result(path: Path) -> tuple[float, float]: |
| lines = read(path).splitlines() |
| node2_uy: list[float] = [] |
| stresses: list[float] = [] |
| for index, line in enumerate(lines): |
| if re.search(r"displacements .* for set NALL", line, re.I): |
| for candidate in lines[index + 1 : index + 14]: |
| row = NODE_ROW.match(candidate) |
| if row and int(row.group(1)) == 2: |
| node2_uy.append(float(row.group(3))) |
| break |
| elif re.search(r"stresses .* for set EALL", line, re.I): |
| for candidate in lines[index + 1 :]: |
| row = STRESS_ROW.match(candidate) |
| if row: |
| stresses.append(mises(tuple(float(value) for value in row.groups()))) |
| elif stresses and not candidate.strip(): |
| break |
| if not node2_uy or not stresses: |
| raise ValueError("incomplete displacement or stress output") |
| return node2_uy[-1], max(stresses) |
|
|
|
|
| def parse_summary(path: Path) -> tuple[float, float]: |
| values = [float(value.strip()) for value in read(path).strip().split(",")] |
| if len(values) != 2: |
| raise ValueError("summary must contain two values") |
| return values[0], values[1] |
|
|
|
|
| def valid_inputs(step1: Path, step2: Path) -> bool: |
| first = re.sub(r"\s+", "", read(step1).lower()) |
| second = re.sub(r"\s+", "", read(step2).lower()) |
| return all( |
| token in first |
| for token in ("*restart,write,frequency=1", "*cload2,2,-100.0") |
| ) and all( |
| token in second |
| for token in ( |
| "*restart,read", |
| "*cload2,2,-200.0", |
| "*nodeprint,nset=nall,frequency=999", |
| "*elprint,elset=eall,frequency=999", |
| ) |
| ) |
|
|
|
|
| def check() -> bool: |
| required = ( |
| "step1.inp", "step1.frd", "step1.rout", "step1.sta", |
| "step2.inp", "step2.rin", "step2.dat", "step2.frd", "step2.sta", |
| "postprocess.py", "summary.txt", |
| ) |
| if any(not (ROOT / name).is_file() or (ROOT / name).stat().st_size == 0 for name in required): |
| return False |
| if (ROOT / "step1.rout").read_bytes() != (ROOT / "step2.rin").read_bytes(): |
| return False |
| if not valid_inputs(ROOT / "step1.inp", ROOT / "step2.inp"): |
| return False |
| calculated = parse_result(ROOT / "step2.dat") |
| reported = parse_summary(ROOT / "summary.txt") |
| return all( |
| close(actual, expected) |
| for actual, expected in zip((*calculated, *reported), (*EXPECTED, *EXPECTED)) |
| ) |
|
|
|
|
| def main() -> int: |
| try: |
| result = check() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
