| |
| from __future__ import annotations |
|
|
| import ast |
| import csv |
| import math |
| import re |
| import subprocess |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| CASE = ROOT / "cavity" |
|
|
|
|
| def read(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def named_block(text: str, name: str) -> str: |
| text = re.sub(r"/\*.*?\*/|//[^\n]*", "", text, flags=re.S) |
| match = re.search(rf"(?m)^\s*{re.escape(name)}\s*\{{", text) |
| if not match: |
| raise ValueError(f"missing block {name}") |
| start = text.find("{", match.start()) |
| depth = 0 |
| for index in range(start, len(text)): |
| depth += text[index] == "{" |
| depth -= text[index] == "}" |
| if depth == 0: |
| return text[start + 1 : index] |
| raise ValueError(f"unterminated block {name}") |
|
|
|
|
| def has_entry(block: str, key: str, value: str) -> bool: |
| return re.search(rf"(?<!\w){re.escape(key)}\s+{value}\s*;", block) is not None |
|
|
|
|
| def close(actual: float, expected: float, tolerance: float) -> bool: |
| return math.isfinite(actual) and abs(actual - expected) <= tolerance |
|
|
|
|
| def python_script_is_valid(path: Path, required_fragments: tuple[str, ...]) -> bool: |
| text = read(path) |
| try: |
| tree = ast.parse(text) |
| except SyntaxError: |
| return False |
| return bool(tree.body) and all(fragment in text for fragment in required_fragments) |
|
|
|
|
| def log_finished(path: Path) -> bool: |
| text = read(path) |
| return "foam fatal" not in text.lower() and text.rstrip().endswith("End") |
|
|
|
|
| def vectors(path: Path) -> list[tuple[float, float, float]]: |
| text = read(path) |
| header = named_block(text, "FoamFile") |
| match = re.search( |
| r"internalField\s+nonuniform\s+List<vector>\s+(\d+)\s*\((.*?)\)\s*;", |
| text, |
| re.S, |
| ) |
| if not match: |
| raise ValueError(f"missing vector field in {path}") |
| values = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", match.group(2)) |
| ] |
| if ( |
| len(values) != int(match.group(1)) |
| or not values |
| or not all(len(value) == 3 and all(math.isfinite(item) for item in value) for value in values) |
| or not has_entry(header, "class", r"volVectorField") |
| or not has_entry(header, "object", re.escape(path.name)) |
| ): |
| raise ValueError("invalid vector field") |
| return values |
|
|
|
|
| def latest_time() -> Path: |
| times = sorted( |
| (float(path.name), path) |
| for path in CASE.iterdir() |
| if path.is_dir() and re.fullmatch(r"\d+(?:\.\d+)?", path.name) |
| ) |
| if not times or abs(times[-1][0] - 30.0) > 1.0e-9: |
| raise ValueError("final time must be 30 s") |
| return times[-1][1] |
|
|
|
|
| def nearest( |
| centres: list[tuple[float, float, float]], |
| velocity: list[tuple[float, float, float]], |
| point: tuple[float, float, float], |
| ) -> tuple[float, float, float]: |
| indices = sorted( |
| range(len(centres)), |
| key=lambda i: sum((centres[i][j] - point[j]) ** 2 for j in range(3)), |
| )[:4] |
| return tuple(sum(velocity[i][j] for i in indices) / 4.0 for j in range(3)) |
|
|
|
|
| def velocity_signs_are_valid( |
| calculated: dict[str, tuple[float, float, float]], |
| ) -> bool: |
| return ( |
| calculated["center"][0] < 0.0 |
| and calculated["left_mid"][1] > 0.0 |
| and calculated["right_mid"][1] < 0.0 |
| ) |
|
|
|
|
| def check_case() -> bool: |
| mesh = read(CASE / "system/blockMeshDict") |
| velocity = read(CASE / "0/U") |
| pressure = read(CASE / "0/p") |
| physical = read(CASE / "constant/physicalProperties") |
| control = read(CASE / "system/controlDict") |
| schemes = read(CASE / "system/fvSchemes") |
| solution = read(CASE / "system/fvSolution") |
| u_boundary = named_block(velocity, "boundaryField") |
| p_boundary = named_block(pressure, "boundaryField") |
| moving_u = named_block(u_boundary, "movingWall") |
| walls_u = named_block(u_boundary, "fixedWalls") |
| empty_u = named_block(u_boundary, "frontAndBack") |
| moving_p = named_block(p_boundary, "movingWall") |
| walls_p = named_block(p_boundary, "fixedWalls") |
| empty_p = named_block(p_boundary, "frontAndBack") |
| piso = named_block(solution, "PISO") |
| return all( |
| ( |
| "(1 1 0)" in mesh, |
| "(1 1 0.01)" in mesh, |
| "(50 50 1)" in mesh, |
| "type empty;" in mesh, |
| has_entry(moving_u, "type", r"fixedValue"), |
| has_entry(moving_u, "value", r"uniform\s+\(1(?:\.0+)?\s+0(?:\.0+)?\s+0(?:\.0+)?\)"), |
| has_entry(walls_u, "type", r"noSlip"), |
| has_entry(empty_u, "type", r"empty"), |
| has_entry(moving_p, "type", r"zeroGradient"), |
| has_entry(walls_p, "type", r"zeroGradient"), |
| has_entry(empty_p, "type", r"empty"), |
| re.search(r"\bnu\s+\[0 2 -1 0 0 0 0\]\s+1(?:\.0)?e-?3\s*;", physical, re.I) |
| is not None, |
| re.search(r"\bendTime\s+30(?:\.0)?\s*;", control) is not None, |
| re.search(r"\bdeltaT\s+0\.005\s*;", control) is not None, |
| re.search(r"\bwriteInterval\s+1000\s*;", control) is not None, |
| re.search(r"\bwriteFormat\s+ascii\s*;", control) is not None, |
| has_entry(named_block(schemes, "ddtSchemes"), "default", r"Euler"), |
| has_entry(named_block(schemes, "divSchemes"), "div(phi,U)", r"Gauss\s+linear"), |
| has_entry(piso, "pRefCell", r"0"), |
| has_entry(piso, "pRefValue", r"0(?:\.0+)?"), |
| ) |
| ) |
|
|
|
|
| def check() -> bool: |
| required = ( |
| ROOT / "build_case.py", |
| ROOT / "postprocess.py", |
| ROOT / "summary.txt", |
| ROOT / "center_velocity.csv", |
| CASE / "log.blockMesh", |
| CASE / "log.icoFoam", |
| CASE / "log.cellCentres", |
| CASE / "system/blockMeshDict", |
| CASE / "system/controlDict", |
| CASE / "system/fvSchemes", |
| CASE / "system/fvSolution", |
| CASE / "constant/physicalProperties", |
| CASE / "0/U", |
| CASE / "0/p", |
| ) |
| if any(not path.is_file() or path.stat().st_size == 0 for path in required): |
| return False |
| if not python_script_is_valid( |
| ROOT / "build_case.py", |
| ("cavity", "blockMeshDict", "controlDict", "fvSchemes", "fvSolution", "0/U", "0/p"), |
| ): |
| return False |
| if not python_script_is_valid( |
| ROOT / "postprocess.py", |
| ("cavity", "center_velocity.csv", "summary.txt", "nearest", "30"), |
| ): |
| return False |
| if any(not log_finished(CASE / name) for name in ("log.blockMesh", "log.icoFoam", "log.cellCentres")): |
| return False |
| mesh_check = subprocess.run( |
| ["bash", "-lc", ". /opt/openfoam11/etc/bashrc && checkMesh -case /home/user/Desktop/cavity"], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| if ( |
| mesh_check.returncode != 0 |
| or "Mesh OK." not in mesh_check.stdout |
| or "Failed " in mesh_check.stdout |
| or "foam fatal" in mesh_check.stdout.lower() |
| or not mesh_check.stdout.rstrip().endswith("End") |
| or not check_case() |
| ): |
| return False |
|
|
| latest = latest_time() |
| centres = vectors(latest / "C") |
| velocity = vectors(latest / "U") |
| if len(centres) != 2500 or len(velocity) != len(centres): |
| return False |
| points = { |
| "center": (0.5, 0.5, 0.005), |
| "left_mid": (0.25, 0.5, 0.005), |
| "right_mid": (0.75, 0.5, 0.005), |
| } |
| calculated = {name: nearest(centres, velocity, point) for name, point in points.items()} |
| if not velocity_signs_are_valid(calculated): |
| return False |
|
|
| with (ROOT / "center_velocity.csv").open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| if [row.get("location") for row in rows] != list(points): |
| return False |
| for row in rows: |
| actual = tuple(float(row[key]) for key in ("ux_mps", "uy_mps", "uz_mps")) |
| if any( |
| not close(a, b, 5.0e-7) |
| for a, b in zip(actual, calculated[row["location"]]) |
| ): |
| return False |
|
|
| summary_lines = [line.strip() for line in read(ROOT / "summary.txt").splitlines() if line.strip()] |
| if len(summary_lines) != 1: |
| return False |
| reported = float(summary_lines[0]) |
| return math.isfinite(reported) and abs(reported - calculated["center"][0]) <= 5.0e-7 |
|
|
|
|
| def main() -> int: |
| try: |
| result = check() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
