| |
| from __future__ import annotations |
|
|
| import csv |
| import math |
| import re |
| import subprocess |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| SWEEP = ROOT / "cavity_sweep" |
| REYNOLDS = (100, 400, 1000) |
|
|
|
|
| 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 patch(text: str, name: str) -> str: |
| return named_block(named_block(text, "boundaryField"), name) |
|
|
|
|
| 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: {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 any( |
| len(value) != 3 or not all(math.isfinite(component) for component in value) |
| for value in values |
| ) |
| or not has_entry(header, "format", r"ascii") |
| or not has_entry(header, "class", r"volVectorField") |
| or not has_entry(header, "object", re.escape(path.name)) |
| ): |
| raise ValueError(f"invalid vector field: {path}") |
| return values |
|
|
|
|
| def scalars(path: Path) -> list[float]: |
| text = read(path) |
| header = named_block(text, "FoamFile") |
| match = re.search( |
| r"internalField\s+nonuniform\s+List<scalar>\s+(\d+)\s*\((.*?)\)\s*;", |
| text, |
| re.S, |
| ) |
| if not match: |
| raise ValueError(f"missing scalar field: {path}") |
| values = [float(value) for value in match.group(2).split()] |
| if ( |
| len(values) != int(match.group(1)) |
| or any(not math.isfinite(value) for value in values) |
| or not has_entry(header, "format", r"ascii") |
| or not has_entry(header, "class", r"volScalarField") |
| or not has_entry(header, "object", re.escape(path.name)) |
| ): |
| raise ValueError(f"invalid scalar field: {path}") |
| return values |
|
|
|
|
| def paren_section(text: str, name: str) -> str: |
| match = re.search(rf"(?m)^\s*{re.escape(name)}\s*\(", text) |
| if not match: |
| raise ValueError(f"missing section {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 section {name}") |
|
|
|
|
| def mesh_geometry_is_valid(mesh: str) -> bool: |
| scale_match = re.search(r"\bconvertToMeters\s+([^;]+);", mesh) |
| vertices = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", paren_section(mesh, "vertices")) |
| ] |
| if scale_match is None or len(vertices) != 8 or any(len(point) != 3 for point in vertices): |
| return False |
| scale = float(scale_match.group(1)) |
| xs, ys, zs = zip(*(tuple(scale * value for value in point) for point in vertices)) |
| return ( |
| abs(min(xs)) <= 1e-12 |
| and abs(max(xs) - 1.0) <= 1e-12 |
| and abs(min(ys)) <= 1e-12 |
| and abs(max(ys) - 1.0) <= 1e-12 |
| and abs(min(zs)) <= 1e-12 |
| and abs(max(zs) - 0.01) <= 1e-12 |
| and re.search(r"hex\s*\([^)]*\)\s*\(\s*50\s+50\s+1\s*\)", mesh) is not None |
| ) |
|
|
|
|
| def numeric_entry(text: str, key: str) -> float: |
| match = re.search(rf"(?m)^\s*{re.escape(key)}\s+([^;]+);", text) |
| if not match: |
| raise ValueError(f"missing entry {key}") |
| return float(match.group(1)) |
|
|
|
|
| def log_finished(path: Path) -> bool: |
| text = read(path) |
| return "FOAM FATAL" not in text and text.rstrip().endswith("End") |
|
|
|
|
| def case_inputs(case: Path, reynolds: int) -> 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") |
| boundary = read(case / "constant/polyMesh/boundary") |
| match = re.search(r"\bnu\s+\[[^]]+\]\s+([^;]+);", physical) |
| return all( |
| ( |
| mesh_geometry_is_valid(mesh), |
| has_entry(patch(velocity, "movingWall"), "value", r"uniform\s+\(1(?:\.0+)?\s+0(?:\.0+)?\s+0(?:\.0+)?\)"), |
| has_entry(patch(velocity, "fixedWalls"), "type", r"noSlip"), |
| has_entry(patch(velocity, "frontAndBack"), "type", r"empty"), |
| has_entry(patch(pressure, "movingWall"), "type", r"zeroGradient"), |
| has_entry(patch(pressure, "fixedWalls"), "type", r"zeroGradient"), |
| has_entry(patch(pressure, "frontAndBack"), "type", r"empty"), |
| match is not None and abs(float(match.group(1)) - 1.0 / reynolds) < 1.0e-12, |
| abs(numeric_entry(control, "endTime") - 30.0) <= 1e-12, |
| abs(numeric_entry(control, "deltaT") - 0.005) <= 1e-12, |
| 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(named_block(solution, "PISO"), "nCorrectors", r"2"), |
| re.search(r"\bfrontAndBack\b.*?type\s+empty;", boundary, re.S) |
| is not None, |
| ) |
| ) |
|
|
|
|
| def center_result(case: Path) -> tuple[tuple[float, float, float], float]: |
| final = case / "30" |
| centres = vectors(final / "C") |
| velocity = vectors(final / "U") |
| if len(centres) != 2500 or len(velocity) != len(centres): |
| raise ValueError("unexpected final field size") |
| target = (0.5, 0.5, 0.005) |
| indices = sorted( |
| range(len(centres)), |
| key=lambda i: sum((centres[i][j] - target[j]) ** 2 for j in range(3)), |
| )[:4] |
| center = tuple(sum(velocity[i][j] for i in indices) / 4.0 for j in range(3)) |
| max_speed = max(math.sqrt(sum(component**2 for component in item)) for item in velocity) |
| return center, max_speed |
|
|
|
|
| def check() -> bool: |
| required_root = ( |
| ROOT / "build_case.py", |
| ROOT / "run_sweep.py", |
| ROOT / "postprocess.py", |
| ROOT / "summary.txt", |
| ROOT / "sweep_results.csv", |
| ) |
| if any(not path.is_file() or path.stat().st_size == 0 for path in required_root): |
| return False |
| calculated = {} |
| for reynolds in REYNOLDS: |
| case = SWEEP / f"Re{reynolds}" |
| required = ( |
| case / "log.blockMesh", |
| case / "log.checkMesh", |
| case / "log.icoFoam", |
| case / "log.cellCentres", |
| case / "30/U", |
| case / "30/p", |
| case / "30/C", |
| ) |
| if any(not path.is_file() or path.stat().st_size == 0 for path in required): |
| return False |
| if any(not log_finished(path) for path in required[:4]): |
| return False |
| if "Mesh OK." not in read(case / "log.checkMesh") or not case_inputs(case, reynolds): |
| return False |
| mesh_check = subprocess.run( |
| [ |
| "bash", |
| "--noprofile", |
| "--norc", |
| "-c", |
| f"trap - CHLD; . /opt/openfoam11/etc/bashrc && checkMesh -case {case}", |
| ], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| if mesh_check.returncode != 0 or "Mesh OK." not in mesh_check.stdout: |
| return False |
| center, max_speed = center_result(case) |
| if len(scalars(case / "30/p")) != 2500: |
| return False |
| if not (-0.5 < center[0] < 0 and 0.5 < max_speed < 1.2): |
| return False |
| calculated[reynolds] = (1.0 / reynolds, *center, max_speed) |
|
|
| if not ( |
| calculated[100][1] |
| < calculated[400][1] |
| < calculated[1000][1] |
| < 0 |
| ): |
| return False |
|
|
| with (ROOT / "sweep_results.csv").open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| keys = ("nu_m2_s", "center_ux", "center_uy", "center_uz", "max_speed") |
| if [int(row["reynolds"]) for row in rows] != list(REYNOLDS): |
| return False |
| for row in rows: |
| reynolds = int(row["reynolds"]) |
| actual = tuple(float(row[key]) for key in keys) |
| if any(not close(a, b, 5.0e-7) for a, b in zip(actual, calculated[reynolds])): |
| return False |
|
|
| lines = [line.strip() for line in read(ROOT / "summary.txt").splitlines() if line.strip()] |
| if len(lines) != 3: |
| return False |
| for line, reynolds in zip(lines, REYNOLDS): |
| parts = [item.strip() for item in line.split(",")] |
| if len(parts) != 2 or int(parts[0]) != reynolds: |
| return False |
| if not close(float(parts[1]), calculated[reynolds][1], 5.0e-7): |
| return False |
| return True |
|
|
|
|
| def main() -> int: |
| try: |
| result = check() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
