| |
| 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 / "channel" |
| HEIGHT = 0.1 |
| MEAN_SPEED = 0.1 |
| THEORY_MAX = 0.15 |
|
|
|
|
| def read(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def close(actual: float, expected: float, tolerance: float) -> bool: |
| return math.isfinite(actual) and abs(actual - expected) <= tolerance |
|
|
|
|
| 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)): |
| if text[index] == "{": |
| depth += 1 |
| elif text[index] == "}": |
| depth -= 1 |
| 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 vector_entry(block: str, key: str) -> tuple[float, float, float]: |
| match = re.search(rf"(?<!\w){re.escape(key)}\s+\(([^()]+)\)\s*;", block) |
| if not match: |
| raise ValueError(f"missing vector entry {key}") |
| values = tuple(float(value) for value in match.group(1).split()) |
| if len(values) != 3 or not all(math.isfinite(value) for value in values): |
| raise ValueError(f"invalid vector entry {key}") |
| return values |
|
|
|
|
| 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 summary(path: Path) -> tuple[float, float, float]: |
| rows = [line.strip() for line in read(path).splitlines() if line.strip()] |
| if len(rows) != 1: |
| raise ValueError("summary must contain one row") |
| values = tuple(float(field.strip()) for field in rows[0].split(",")) |
| if len(values) != 3 or not all(math.isfinite(value) for value in values): |
| raise ValueError("summary must contain three finite values") |
| return values |
|
|
|
|
| def latest_time() -> float: |
| times = [ |
| float(path.name) |
| for path in CASE.iterdir() |
| if path.is_dir() and re.fullmatch(r"\d+(?:\.\d+)?", path.name) |
| ] |
| if not times: |
| raise ValueError("no OpenFOAM time directory") |
| return max(times) |
|
|
|
|
| def final_time_is_valid() -> bool: |
| return close(latest_time(), 30.0, 1.0e-9) |
|
|
|
|
| def resample() -> Path: |
| command = ( |
| ". /opt/openfoam11/etc/bashrc && " |
| "postProcess -case /home/user/Desktop/channel -latestTime -func sampleDict" |
| ) |
| result = subprocess.run( |
| ["bash", "-lc", command], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| if ( |
| result.returncode != 0 |
| or "foam fatal" in result.stdout.lower() |
| or not result.stdout.rstrip().endswith("End") |
| ): |
| raise RuntimeError("postProcess sampling failed") |
| candidates = list((CASE / "postProcessing/sampleDict").glob("*/outletLine.xy")) |
| if not candidates: |
| raise FileNotFoundError("missing sampled outlet profile") |
| return max(candidates, key=lambda path: float(path.parent.name)) |
|
|
|
|
| def mesh_is_valid() -> bool: |
| command = ". /opt/openfoam11/etc/bashrc && checkMesh -case /home/user/Desktop/channel" |
| result = subprocess.run( |
| ["bash", "-lc", command], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| return ( |
| result.returncode == 0 |
| and "Mesh OK." in result.stdout |
| and "Failed " not in result.stdout |
| and "foam fatal" not in result.stdout.lower() |
| and result.stdout.rstrip().endswith("End") |
| ) |
|
|
|
|
| def profile_rows(path: Path) -> list[tuple[float, float, float, float]]: |
| rows: list[tuple[float, float]] = [] |
| for line in read(path).splitlines(): |
| fields = line.split() |
| if len(fields) < 4 or fields[0].startswith("#"): |
| continue |
| y, ux, uy, uz = (float(value) for value in fields[:4]) |
| if not 0.0 < y < HEIGHT or abs(uy) > 1.0e-5 or abs(uz) > 1.0e-5: |
| raise ValueError("invalid outlet sample") |
| rows.append((y, ux)) |
| if len(rows) != 80: |
| raise ValueError("outlet profile must contain 80 samples") |
| result = [] |
| for y, ux in rows: |
| theory = 6.0 * MEAN_SPEED * y * (HEIGHT - y) / HEIGHT**2 |
| result.append((y, ux, theory, abs(ux - theory))) |
| return result |
|
|
|
|
| def csv_matches(path: Path, expected: list[tuple[float, float, float, float]]) -> bool: |
| with path.open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| keys = ("y_m", "ux_cfd_mps", "ux_theory_mps", "abs_error_mps") |
| if len(rows) != 80 or set(rows[0]) != set(keys): |
| return False |
| for row, wanted in zip(rows, expected): |
| actual = tuple(float(row[key]) for key in keys) |
| if any(not close(value, target, 5.0e-9) for value, target in zip(actual, wanted)): |
| return False |
| return True |
|
|
|
|
| def check_case_definition() -> 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") |
| sampling = read(CASE / "system/sampleDict") |
|
|
| velocity_boundary = named_block(velocity, "boundaryField") |
| inlet_u = named_block(velocity_boundary, "inlet") |
| outlet_u = named_block(velocity_boundary, "outlet") |
| walls_u = named_block(velocity_boundary, "walls") |
| empty_u = named_block(velocity_boundary, "frontAndBack") |
| pressure_boundary = named_block(pressure, "boundaryField") |
| inlet_p = named_block(pressure_boundary, "inlet") |
| outlet_p = named_block(pressure_boundary, "outlet") |
| walls_p = named_block(pressure_boundary, "walls") |
| empty_p = named_block(pressure_boundary, "frontAndBack") |
| profile_match = re.search( |
| r"value\s+nonuniform\s+List<vector>\s+80\s*\((.*?)\)\s*;", inlet_u, re.S |
| ) |
| if not profile_match: |
| return False |
| profile = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", profile_match.group(1)) |
| ] |
| expected = [ |
| 6.0 * MEAN_SPEED * ((i + 0.5) * HEIGHT / 80.0) * (HEIGHT - (i + 0.5) * HEIGHT / 80.0) / HEIGHT**2 |
| for i in range(80) |
| ] |
| outlet_sample = named_block(sampling, "outletLine") |
| sample_start = vector_entry(outlet_sample, "start") |
| sample_end = vector_entry(outlet_sample, "end") |
|
|
| return all( |
| ( |
| "(1.0 0 0)" in mesh, |
| "(1.0 0.1 0)" in mesh, |
| "(100 80 1)" in mesh, |
| "type empty;" in mesh, |
| has_entry(inlet_u, "type", r"fixedValue"), |
| len(profile) == 80, |
| all(close(vector[0], target, 1.0e-10) and close(vector[1], 0.0, 1.0e-12) and close(vector[2], 0.0, 1.0e-12) for vector, target in zip(profile, expected)), |
| has_entry(outlet_u, "type", r"zeroGradient"), |
| has_entry(walls_u, "type", r"noSlip"), |
| has_entry(empty_u, "type", r"empty"), |
| has_entry(inlet_p, "type", r"zeroGradient"), |
| has_entry(outlet_p, "type", r"fixedValue"), |
| has_entry(outlet_p, "value", r"uniform\s+0(?:\.0+)?"), |
| 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-0?5\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\.02\s*;", control) is not None, |
| re.search(r"\bwriteFormat\s+ascii\s*;", control) is not None, |
| has_entry(outlet_sample, "type", r"lineUniform"), |
| has_entry(outlet_sample, "axis", r"y"), |
| has_entry(outlet_sample, "nPoints", r"80"), |
| all( |
| close(actual, expected, 1.0e-12) |
| for actual, expected in zip(sample_start, (0.99, 0.000625, 0.005)) |
| ), |
| all( |
| close(actual, expected, 1.0e-12) |
| for actual, expected in zip(sample_end, (0.99, 0.099375, 0.005)) |
| ), |
| ) |
| ) |
|
|
|
|
| def check() -> bool: |
| required = ( |
| ROOT / "build_case.py", |
| ROOT / "postprocess.py", |
| ROOT / "summary.txt", |
| ROOT / "outlet_profile.csv", |
| CASE / "log.blockMesh", |
| CASE / "log.icoFoam", |
| CASE / "log.sample", |
| CASE / "system/blockMeshDict", |
| CASE / "system/controlDict", |
| CASE / "system/fvSchemes", |
| CASE / "system/fvSolution", |
| CASE / "system/sampleDict", |
| CASE / "constant/transportProperties", |
| 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", |
| ("channel", "blockMeshDict", "controlDict", "fvSchemes", "fvSolution", "sampleDict", "0/U", "0/p"), |
| ): |
| return False |
| if not python_script_is_valid( |
| ROOT / "postprocess.py", |
| ("postProcess", "sampleDict", "log.sample", "outlet_profile.csv", "summary.txt"), |
| ): |
| return False |
| if not final_time_is_valid() or not log_finished(CASE / "log.icoFoam"): |
| return False |
| if not log_finished(CASE / "log.blockMesh") or not log_finished(CASE / "log.sample") or not mesh_is_valid() or not check_case_definition(): |
| return False |
|
|
| calculated_rows = profile_rows(resample()) |
| calculated_max = max(row[1] for row in calculated_rows) |
| calculated_error = max(row[3] for row in calculated_rows) / THEORY_MAX * 100.0 |
| if not csv_matches(ROOT / "outlet_profile.csv", calculated_rows): |
| return False |
| reported_max, reported_theory, reported_error = summary(ROOT / "summary.txt") |
| if calculated_error > 2.0: |
| return False |
| return ( |
| close(calculated_max, THEORY_MAX, 0.003) |
| and close(reported_max, calculated_max, 2.0e-5) |
| and close(reported_theory, THEORY_MAX, 1.0e-8) |
| and close(reported_error, calculated_error, 2.0e-3) |
| ) |
|
|
|
|
| def main() -> int: |
| try: |
| result = check() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
