task/single-software-execution/cli/openfoam/task-08/eval.py

#!/usr/bin/env python3
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 / "airfoil"
COEFFICIENTS = CASE / "postProcessing/forces/0/forceCoeffs.dat"


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 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 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)


def log_finished(path: Path) -> bool:
    text = read(path)
    return "foam fatal" not in text.lower() and text.rstrip().endswith("End")


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 mesh_vertices(mesh: str) -> list[tuple[float, float, float]]:
    number = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?"
    return [
        tuple(float(value) for value in match)
        for match in re.findall(
            rf"\(\s*({number})\s+({number})\s+({number})\s*\)",
            paren_section(mesh, "vertices"),
        )
    ]


def airfoil_geometry_is_valid(mesh: str) -> bool:
    count = 161
    vertices = mesh_vertices(mesh)
    if len(vertices) != 4 * count:
        return False
    inner0 = vertices[:count]
    outer0 = vertices[count : 2 * count]
    inner1 = vertices[2 * count : 3 * count]
    outer1 = vertices[3 * count :]

    expected: list[tuple[float, float]] = []
    for index in range(81):
        x = 0.5 * (1.0 + math.cos(math.pi * index / 80.0))
        y = 5.0 * 0.12 * (
            0.2969 * math.sqrt(x)
            - 0.1260 * x
            - 0.3516 * x**2
            + 0.2843 * x**3
            - 0.1015 * x**4
        )
        expected.append((x, y))
    for index in range(79, -1, -1):
        x = 0.5 * (1.0 + math.cos(math.pi * index / 80.0))
        y = -5.0 * 0.12 * (
            0.2969 * math.sqrt(x)
            - 0.1260 * x
            - 0.3516 * x**2
            + 0.2843 * x**3
            - 0.1015 * x**4
        )
        expected.append((x, y))

    for actual, target in zip(inner0, expected):
        if abs(actual[0] - target[0]) > 2.0e-10 or abs(actual[1] - target[1]) > 2.0e-10 or abs(actual[2]) > 1.0e-12:
            return False
    for lower, upper in zip(inner0, inner1):
        if abs(lower[0] - upper[0]) > 1.0e-12 or abs(lower[1] - upper[1]) > 1.0e-12 or abs(upper[2] - 0.01) > 1.0e-12:
            return False

    for index, (x, y, _) in enumerate(inner0):
        lower_outer = outer0[index]
        upper_outer = outer1[index]
        if (
            not all(math.isfinite(value) for value in lower_outer + upper_outer)
            or abs(lower_outer[0] - upper_outer[0]) > 1.0e-10
            or abs(lower_outer[1] - upper_outer[1]) > 1.0e-10
            or abs(lower_outer[2]) > 1.0e-12
            or abs(upper_outer[2] - 0.01) > 1.0e-12
        ):
            return False
        offset_x = lower_outer[0] - x
        offset_y = lower_outer[1] - y
        if abs(math.hypot(offset_x, offset_y) - 5.0) > 5.0e-6:
            return False
        if offset_x * (x - 0.5) + offset_y * y <= 0.0:
            return False
    return True


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 coefficient_history() -> list[tuple[float, float, float]]:
    history = []
    header = None
    for line in read(COEFFICIENTS).splitlines():
        stripped = line.strip()
        if stripped.startswith("# Time"):
            header = " ".join(stripped.split())
            continue
        if not stripped or stripped.startswith("#"):
            continue
        values = [float(value) for value in stripped.split()]
        if len(values) >= 4:
            history.append((values[0], values[2], values[3]))
    if header != "# Time Cm Cd Cl Cl(f) Cl(r)":
        raise ValueError("unexpected OpenFOAM 11 forceCoeffs header")
    return history


def history_is_complete(history: list[tuple[float, float, float]]) -> bool:
    if len(history) != 1001:
        return False
    return all(
        close(iteration, float(index), 1.0e-9)
        and math.isfinite(cd)
        and math.isfinite(cl)
        for index, (iteration, cd, cl) in enumerate(history)
    )


def check_case() -> bool:
    mesh = read(CASE / "system/blockMeshDict")
    build_script = read(ROOT / "build_case.py")
    velocity = read(CASE / "0/U")
    pressure = read(CASE / "0/p")
    kinetic = read(CASE / "0/k")
    omega = read(CASE / "0/omega")
    nut = read(CASE / "0/nut")
    physical = read(CASE / "constant/physicalProperties")
    momentum = read(CASE / "constant/momentumTransport")
    control = read(CASE / "system/controlDict")
    schemes = read(CASE / "system/fvSchemes")
    solution = read(CASE / "system/fvSolution")
    boundary = read(CASE / "constant/polyMesh/boundary")
    mesh_boundary = mesh
    forces = named_block(named_block(control, "functions"), "forces")
    simple = named_block(solution, "SIMPLE")
    return all(
        (
            airfoil_geometry_is_valid(mesh),
            mesh.count("hex (") == 161,
            len(re.findall(r"\(\s*80\s+1\s+1\s*\)\s*simpleGrading\s*\(\s*80\s+1\s+1\s*\)", mesh)) == 161,
            has_entry(named_block(mesh_boundary, "FARFIELD"), "type", r"patch"),
            has_entry(named_block(mesh_boundary, "WALL10"), "type", r"wall"),
            has_entry(named_block(mesh_boundary, "SYMP3"), "type", r"empty"),
            face_count(named_block(mesh_boundary, "FARFIELD")) == 161,
            face_count(named_block(mesh_boundary, "WALL10")) == 161,
            face_count(named_block(mesh_boundary, "SYMP3")) == 322,
            any(
                re.search(r"\binternalField\s+uniform\s+\(0\.9961946981\s+0\.08715574275\s+0(?:\.0+)?\)\s*;", text) is not None
                for text in (velocity, build_script)
            ),
            has_entry(patch(velocity, "FARFIELD"), "type", r"freestreamVelocity"),
            has_entry(patch(velocity, "FARFIELD"), "freestreamValue", r"uniform\s+\(0\.9961946981\s+0\.08715574275\s+0(?:\.0+)?\)"),
            has_entry(patch(velocity, "WALL10"), "type", r"noSlip"),
            has_entry(patch(velocity, "SYMP3"), "type", r"empty"),
            has_entry(patch(pressure, "FARFIELD"), "type", r"freestreamPressure"),
            has_entry(patch(pressure, "FARFIELD"), "freestreamValue", r"uniform\s+0(?:\.0+)?"),
            has_entry(patch(pressure, "WALL10"), "type", r"zeroGradient"),
            has_entry(patch(kinetic, "FARFIELD"), "type", r"inletOutlet"),
            has_entry(patch(kinetic, "FARFIELD"), "inletValue", r"uniform\s+0\.001"),
            has_entry(patch(kinetic, "WALL10"), "type", r"kqRWallFunction"),
            has_entry(patch(omega, "FARFIELD"), "type", r"inletOutlet"),
            has_entry(patch(omega, "FARFIELD"), "inletValue", r"uniform\s+10(?:\.0+)?"),
            has_entry(patch(omega, "WALL10"), "type", r"omegaWallFunction"),
            has_entry(patch(nut, "WALL10"), "type", r"nutkWallFunction"),
            all(has_entry(patch(field_text, "SYMP3"), "type", r"empty") for field_text in (pressure, kinetic, omega, nut)),
            re.search(r"\bnu\s+\[0 2 -1 0 0 0 0\]\s+1e-?5\s*;", physical, re.I)
            is not None,
            has_entry(momentum, "model", r"kOmegaSST"),
            re.search(r"\bendTime\s+1000\s*;", control) is not None,
            re.search(r"\bwriteFormat\s+ascii\s*;", control) is not None,
            has_entry(forces, "type", r"forceCoeffs"),
            has_entry(forces, "writeInterval", r"1"),
            has_entry(forces, "patches", r"\(\s*WALL10\s*\)"),
            has_entry(forces, "rhoInf", r"1(?:\.0+)?"),
            has_entry(forces, "magUInf", r"1(?:\.0+)?"),
            has_entry(forces, "lRef", r"1(?:\.0+)?"),
            has_entry(forces, "Aref", r"0\.01"),
            has_entry(forces, "dragDir", r"\(0\.9961946981\s+0\.08715574275\s+0(?:\.0+)?\)"),
            has_entry(forces, "liftDir", r"\(-0\.08715574275\s+0\.9961946981\s+0(?:\.0+)?\)"),
            all(has_entry(named_block(schemes, "divSchemes"), key, r"bounded\s+Gauss\s+upwind") for key in ("div(phi,U)", "div(phi,k)", "div(phi,omega)")),
            "corrected" in named_block(schemes, "laplacianSchemes"),
            has_entry(named_block(named_block(solution, "solvers"), "p"), "solver", r"GAMG"),
            has_entry(simple, "nNonOrthogonalCorrectors", r"1"),
            re.search(r"\bSYMP3\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 / "force_coefficients.csv",
        CASE / "log.blockMesh",
        CASE / "log.checkMesh",
        CASE / "log.potentialFoam",
        CASE / "log.simpleFoam",
        CASE / "1000/U",
        CASE / "1000/p",
        CASE / "1000/k",
        CASE / "1000/omega",
        COEFFICIENTS,
    )
    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",
        ("airfoil", "naca_thickness", "blockMeshDict", "forceCoeffs", "0/U", "0/p"),
    ):
        return False
    if not python_script_is_valid(
        ROOT / "postprocess.py",
        ("forceCoeffs.dat", "force_coefficients.csv", "summary.txt", "avg_cd", "avg_cl"),
    ):
        return False
    solve_log = read(CASE / "log.simpleFoam")
    if any(
        not log_finished(path)
        for path in (CASE / "log.blockMesh", CASE / "log.checkMesh", CASE / "log.potentialFoam")
    ):
        return False
    if not log_finished(CASE / "log.simpleFoam") or "Time = 1000" not in solve_log:
        return False
    mesh_check = subprocess.run(
        [
            "bash",
            "--noprofile",
            "--norc",
            "-c",
            "trap - CHLD; . /opt/openfoam11/etc/bashrc && checkMesh -case /home/user/Desktop/airfoil",
        ],
        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
    velocity = internal_field(CASE / "1000/U", "vector")
    pressure = internal_field(CASE / "1000/p", "scalar")
    turbulent_k = internal_field(CASE / "1000/k", "scalar")
    omega = internal_field(CASE / "1000/omega", "scalar")
    if not (len(velocity) == len(pressure) == len(turbulent_k) == len(omega) == 12880):
        return False

    history = coefficient_history()
    if not history_is_complete(history):
        return False
    window = [row for row in history if 800.0 <= row[0] <= 1000.0]
    avg_cd = sum(row[1] for row in window) / len(window)
    avg_cl = sum(row[2] for row in window) / len(window)
    std_cd = math.sqrt(sum((row[1] - avg_cd) ** 2 for row in window) / len(window))
    std_cl = math.sqrt(sum((row[2] - avg_cl) ** 2 for row in window) / len(window))
    if not (0.1 < avg_cl < 2.0 and 0.001 < avg_cd < 0.2 and std_cl < 0.02 and std_cd < 0.01):
        return False

    keys = ("iteration", "cd", "cl")
    with (ROOT / "force_coefficients.csv").open(encoding="utf-8", newline="") as stream:
        rows = list(csv.DictReader(stream))
    if len(rows) != len(history) or set(rows[0]) != set(keys):
        return False
    for row, expected in zip(rows, history):
        actual = tuple(float(row[key]) for key in keys)
        if any(not close(a, b, 5.0e-7) for a, b in zip(actual, expected)):
            return False

    values = [item.strip() for item in read(ROOT / "summary.txt").strip().split(",")]
    if len(values) != 2:
        return False
    reported = tuple(float(value) for value in values)
    expected = (avg_cl, avg_cd)
    return all(math.isfinite(value) for value in reported) and all(
        abs(actual - target) <= 5.0e-7 for actual, target in zip(reported, 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())