| |
| 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 / "buoyant" |
| TIME = CASE / "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 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 completed_log(path: Path, required_fragment: str | None = None) -> bool: |
| text = read(path) |
| lines = [line.strip() for line in text.splitlines() if line.strip()] |
| return ( |
| bool(lines) |
| and lines[-1] == "End" |
| and "FOAM FATAL" not in text |
| and (required_fragment is None or required_fragment in text) |
| ) |
|
|
|
|
| def patch(text: str, name: str) -> str: |
| return named_block(named_block(text, "boundaryField"), name) |
|
|
|
|
| def face_count(block: str) -> int: |
| match = re.search(r"\bfaces\s*\((.*?)\)\s*;", block, re.S) |
| return len(re.findall(r"\([^()]+\)", match.group(1))) if match else 0 |
|
|
|
|
| def internal_field(path: Path, kind: str) -> list: |
| text = read(path) |
| header = named_block(text, "FoamFile") |
| match = re.search( |
| rf"internalField\s+nonuniform\s+List<{kind}>\s+(\d+)\s*\((.*?)\)\s*;", |
| text, |
| re.S, |
| ) |
| if not match: |
| raise ValueError(f"missing {kind} field") |
| if kind == "vector": |
| values = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", match.group(2)) |
| ] |
| valid_values = all( |
| len(value) == 3 and all(math.isfinite(item) for item in value) |
| for value in values |
| ) |
| elif kind == "scalar": |
| values = [float(value) for value in match.group(2).split()] |
| valid_values = all(math.isfinite(value) for value in values) |
| else: |
| raise ValueError(f"unsupported field kind {kind}") |
| if ( |
| len(values) != int(match.group(1)) |
| or not values |
| or not valid_values |
| or not has_entry(header, "format", r"ascii") |
| or not has_entry(header, "class", rf"vol{kind.capitalize()}Field") |
| or not has_entry(header, "object", re.escape(path.name)) |
| ): |
| raise ValueError(f"invalid {kind} field") |
| return values |
|
|
|
|
| def check_case() -> bool: |
| mesh = read(CASE / "system/blockMeshDict") |
| temperature = read(CASE / "0/T") |
| velocity = read(CASE / "0/U") |
| pressure = read(CASE / "0/p") |
| physical = read(CASE / "constant/physicalProperties") |
| momentum = read(CASE / "constant/momentumTransport") |
| gravity = read(CASE / "constant/g") |
| control = read(CASE / "system/controlDict") |
| schemes = read(CASE / "system/fvSchemes") |
| solution = read(CASE / "system/fvSolution") |
| boundary = read(CASE / "constant/polyMesh/boundary") |
| return all( |
| ( |
| "(0.1 0.1 0.01)" in mesh, |
| "(41 41 1)" in mesh, |
| has_entry(named_block(mesh, "hot"), "type", r"wall"), |
| face_count(named_block(mesh, "hot")) == 1, |
| has_entry(named_block(mesh, "cold"), "type", r"wall"), |
| face_count(named_block(mesh, "cold")) == 1, |
| has_entry(named_block(mesh, "topAndBottom"), "type", r"wall"), |
| face_count(named_block(mesh, "topAndBottom")) == 2, |
| has_entry(named_block(mesh, "frontAndBack"), "type", r"empty"), |
| face_count(named_block(mesh, "frontAndBack")) == 2, |
| re.search(r"\binternalField\s+uniform\s+300(?:\.0+)?\s*;", temperature) is not None, |
| has_entry(patch(temperature, "hot"), "value", r"uniform\s+310(?:\.0+)?"), |
| has_entry(patch(temperature, "cold"), "value", r"uniform\s+290(?:\.0+)?"), |
| has_entry(patch(temperature, "topAndBottom"), "type", r"zeroGradient"), |
| has_entry(patch(temperature, "frontAndBack"), "type", r"empty"), |
| re.search(r"\binternalField\s+uniform\s+\(0(?:\.0+)?\s+0(?:\.0+)?\s+0(?:\.0+)?\)\s*;", velocity) is not None, |
| all(has_entry(patch(velocity, name), "type", r"noSlip") for name in ("hot", "cold", "topAndBottom")), |
| has_entry(patch(velocity, "frontAndBack"), "type", r"empty"), |
| re.search(r"\binternalField\s+uniform\s+100000(?:\.0+)?\s*;", pressure) is not None, |
| re.search(r"\bmolWeight\s+28\.96\s*;", physical) is not None, |
| re.search(r"\bCp\s+1004\.4\s*;", physical) is not None, |
| re.search(r"\bmu\s+1\.846e-0?5\s*;", physical, re.I) is not None, |
| re.search(r"\bPr\s+0\.71\s*;", physical) is not None, |
| "simulationType laminar;" in momentum, |
| "value (0 -9.81 0);" in gravity, |
| re.search(r"\bendTime\s+1000\s*;", control) is not None, |
| re.search(r"\bwriteInterval\s+1000\s*;", control) is not None, |
| re.search(r"\bapplication\s+foamRun\s*;", control) is not None, |
| re.search(r"\bsolver\s+fluid\s*;", control) is not None, |
| re.search(r"\bwriteFormat\s+ascii\s*;", control) is not None, |
| has_entry(named_block(schemes, "ddtSchemes"), "default", r"steadyState"), |
| has_entry(named_block(schemes, "divSchemes"), "div(phi,U)", r"bounded\s+Gauss\s+upwind"), |
| has_entry(named_block(schemes, "divSchemes"), "div(phi,h)", r"bounded\s+Gauss\s+upwind"), |
| has_entry(named_block(named_block(solution, "solvers"), "p_rgh"), "solver", r"GAMG"), |
| re.search(r"\bfrontAndBack\b.*?type\s+empty;", boundary, re.S) |
| is not None, |
| ) |
| ) |
|
|
|
|
| def check() -> bool: |
| required = ( |
| ROOT / "build_case.py", |
| ROOT / "postprocess.py", |
| ROOT / "summary.txt", |
| ROOT / "center_sample.csv", |
| CASE / "log.blockMesh", |
| CASE / "log.checkMesh", |
| CASE / "log.foamRun", |
| CASE / "log.cellCentres", |
| TIME / "T", |
| TIME / "U", |
| TIME / "p", |
| TIME / "p_rgh", |
| TIME / "C", |
| ) |
| 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", |
| ("buoyant", "blockMeshDict", "physicalProperties", "foamRun", "p_rgh", "0/T", "0/U"), |
| ): |
| return False |
| if not python_script_is_valid( |
| ROOT / "postprocess.py", |
| ("buoyant", "1000", "center_sample.csv", "summary.txt", "max_speed"), |
| ): |
| return False |
| if not all( |
| ( |
| completed_log(CASE / "log.blockMesh"), |
| completed_log(CASE / "log.checkMesh"), |
| completed_log(CASE / "log.foamRun", "Time = 1000"), |
| completed_log(CASE / "log.cellCentres"), |
| ) |
| ): |
| return False |
| mesh_check = subprocess.run( |
| [ |
| "bash", |
| "--noprofile", |
| "--norc", |
| "-c", |
| "trap - CHLD; . /opt/openfoam11/etc/bashrc && checkMesh -case /home/user/Desktop/buoyant", |
| ], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| if mesh_check.returncode != 0 or "Mesh OK." not in mesh_check.stdout or not check_case(): |
| return False |
|
|
| centres = internal_field(TIME / "C", "vector") |
| temperatures = internal_field(TIME / "T", "scalar") |
| velocity = internal_field(TIME / "U", "vector") |
| pressure = internal_field(TIME / "p", "scalar") |
| pressure_rgh = internal_field(TIME / "p_rgh", "scalar") |
| if not ( |
| len(centres) |
| == len(temperatures) |
| == len(velocity) |
| == len(pressure) |
| == len(pressure_rgh) |
| == 1681 |
| ): |
| return False |
| target = (0.05, 0.05, 0.005) |
| index = min( |
| range(len(centres)), |
| key=lambda i: sum((centres[i][j] - target[j]) ** 2 for j in range(3)), |
| ) |
| point = centres[index] |
| if math.sqrt(sum((point[j] - target[j]) ** 2 for j in range(3))) > 1.0e-9: |
| return False |
| center_temp = temperatures[index] |
| max_speed = max(math.sqrt(sum(component**2 for component in item)) for item in velocity) |
| if not ( |
| 295.0 < center_temp < 305.0 |
| and min(temperatures) > 289.0 |
| and max(temperatures) < 311.0 |
| and max(temperatures) - min(temperatures) > 15.0 |
| and 1.0e-4 < max_speed < 1.0 |
| ): |
| return False |
|
|
| with (ROOT / "center_sample.csv").open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| if len(rows) != 1 or set(rows[0]) != { |
| "x", |
| "y", |
| "z", |
| "temperature_k", |
| "max_speed_m_s", |
| }: |
| return False |
| row = rows[0] |
| sample = tuple(float(row[key]) for key in ("x", "y", "z")) |
| if any(not close(a, b, 1.0e-10) for a, b in zip(sample, point)): |
| return False |
| if not close(float(row["temperature_k"]), center_temp, 5.0e-7): |
| return False |
| if not close(float(row["max_speed_m_s"]), max_speed, 5.0e-7): |
| return False |
|
|
| reported = float(read(ROOT / "summary.txt").strip()) |
| return math.isfinite(reported) and abs(reported - center_temp) <= 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()) |
|
|
