| |
| from __future__ import annotations |
|
|
| import ast |
| import csv |
| import math |
| import os |
| import re |
| import shlex |
| import subprocess |
| from pathlib import Path |
|
|
|
|
| ROOT = Path(os.environ.get("ENGIWORLD_EVAL_ROOT", "/home/user/Desktop")) |
| CASE = ROOT / "dynamic" |
| FORCES = CASE / "postProcessing/bodyForces/0/forces.dat" |
| NUMBER = re.compile(r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?") |
|
|
|
|
| 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 scalar_entry(text: str, key: str) -> float: |
| match = re.search(rf"(?<!\w){re.escape(key)}\s+({NUMBER.pattern})\s*;", text) |
| if not match: |
| raise ValueError(f"missing scalar entry {key}") |
| return float(match.group(1)) |
|
|
|
|
| def dimensioned_scalar(text: str, key: str) -> float: |
| match = re.search( |
| rf"(?<!\w){re.escape(key)}\s+(?:\[[^\]]+\]\s+)?({NUMBER.pattern})\s*;", |
| text, |
| ) |
| if not match: |
| raise ValueError(f"missing dimensioned scalar entry {key}") |
| return float(match.group(1)) |
|
|
|
|
| def vector_entry(text: str, key: str) -> tuple[float, float, float]: |
| match = re.search( |
| rf"(?<!\w){re.escape(key)}\s+\(\s*({NUMBER.pattern})\s+({NUMBER.pattern})\s+({NUMBER.pattern})\s*\)\s*;", |
| text, |
| ) |
| if not match: |
| raise ValueError(f"missing vector entry {key}") |
| return tuple(float(match.group(index)) for index in range(1, 4)) |
|
|
|
|
| def patch(text: str, name: str) -> str: |
| return named_block(named_block(text, "boundaryField"), name) |
|
|
|
|
| def zone_labels(text: str, name: str) -> set[int]: |
| block = named_block(text, name) |
| match = re.search(r"\bcellLabels\s+List<label>\s+(\d+)\s*\((.*?)\)\s*;", block, re.S) |
| if not match: |
| raise ValueError(f"missing labels for zone {name}") |
| labels = [int(value) for value in match.group(2).split()] |
| if len(labels) != int(match.group(1)) or len(labels) != len(set(labels)): |
| raise ValueError("invalid cell-zone labels") |
| return set(labels) |
|
|
|
|
| def vector_field(path: Path) -> list[tuple[float, float, float]]: |
| match = re.search(r"internalField\s+nonuniform\s+List<vector>\s+(\d+)\s*\((.*?)\)\s*;", read(path), re.S) |
| if not match: |
| raise ValueError("missing vector field") |
| 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)): |
| raise ValueError("vector field count mismatch") |
| return values |
|
|
|
|
| def mesh_geometry_is_valid(mesh: str) -> bool: |
| vertices = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", paren_section(mesh, "vertices")) |
| ] |
| if len(vertices) != 64: |
| return False |
| xs, ys, zs = zip(*vertices) |
| inner = [point for point in vertices if abs(math.hypot(point[0], point[1]) - 1.0) <= 1.0e-5] |
| return ( |
| abs(min(xs) + 5.0) <= 1.0e-12 |
| and abs(max(xs) - 5.0) <= 1.0e-12 |
| and abs(min(ys) + 1.5) <= 1.0e-12 |
| and abs(max(ys) - 2.5) <= 1.0e-12 |
| and abs(min(zs) + 1.0) <= 1.0e-12 |
| and abs(max(zs) - 1.0) <= 1.0e-12 |
| and len(inner) == 16 |
| ) |
|
|
|
|
| def field_count(path: Path, kind: str, class_name: str) -> int: |
| text = read(path) |
| if not ( |
| re.search(r"(?m)^\s*format\s+ascii\s*;", text) |
| and re.search(rf"(?m)^\s*class\s+{re.escape(class_name)}\s*;", text) |
| ): |
| raise ValueError(f"invalid field header: {path}") |
| match = re.search( |
| rf"internalField\s+nonuniform\s+List<{kind}>\s+(\d+)\s*\((.*?)\)\s*;", |
| text, |
| re.S, |
| ) |
| if not match: |
| raise ValueError(f"missing nonuniform {kind} field") |
| declared = int(match.group(1)) |
| if kind == "vector": |
| values = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", match.group(2)) |
| ] |
| if any(len(value) != 3 for value in values): |
| raise ValueError("invalid vector width") |
| flattened = [value for vector in values for value in vector] |
| actual = len(values) |
| else: |
| flattened = [float(value) for value in NUMBER.findall(match.group(2))] |
| actual = len(flattened) |
| if declared != actual or not all(math.isfinite(value) for value in flattened): |
| raise ValueError("field declaration/value mismatch") |
| return declared |
|
|
|
|
| def force_history() -> list[tuple[float, float, float, float]]: |
| header = None |
| history = [] |
| for line in read(FORCES).splitlines(): |
| stripped = line.strip() |
| if stripped.startswith("# Time"): |
| header = " ".join(stripped.split()) |
| continue |
| if not stripped or stripped.startswith("#"): |
| continue |
| time_match = re.match(rf"^\s*({NUMBER.pattern})\s+", stripped) |
| vectors = re.findall( |
| rf"\(\s*({NUMBER.pattern})\s+({NUMBER.pattern})\s+({NUMBER.pattern})\s*\)", |
| stripped, |
| ) |
| if time_match is None or len(vectors) != 4: |
| raise ValueError("forces.dat row does not contain four pressure/viscous vectors") |
| pressure_fx = float(vectors[0][0]) |
| viscous_fx = float(vectors[1][0]) |
| history.append((float(time_match.group(1)), pressure_fx, viscous_fx, pressure_fx + viscous_fx)) |
| if header is None: |
| raise ValueError("missing forces.dat component header") |
| if "forces(pressure viscous)" not in header or "moments(pressure viscous)" not in header: |
| raise ValueError("unexpected forces.dat component header") |
| if "porous" in header.lower(): |
| raise ValueError("unexpected porous component in non-porous case") |
| return history |
|
|
|
|
| def log_completed(path: Path, required: tuple[str, ...] = ()) -> bool: |
| text = read(path) |
| low = text.lower() |
| return ( |
| "foam fatal" not in low |
| and text.rstrip().endswith("End") |
| and all(token in text for token in required) |
| ) |
|
|
|
|
| def postprocess_script_is_valid(path: Path) -> bool: |
| source = read(path) |
| ast.parse(source) |
| original = FORCES.read_bytes() |
| original_history = force_history() |
| delta = 0.123456789 |
| restored = False |
| mutation_ok = False |
| try: |
| text = original.decode("utf-8") |
| lines = text.splitlines() |
| data_indexes = [ |
| index |
| for index, line in enumerate(lines) |
| if line.strip() and not line.lstrip().startswith("#") |
| ] |
| if not data_indexes: |
| return False |
| last_index = data_indexes[-1] |
| first_vector = re.search( |
| rf"(\(\s*)({NUMBER.pattern})(\s+{NUMBER.pattern}\s+{NUMBER.pattern}\s*\))", |
| lines[last_index], |
| ) |
| if first_vector is None: |
| return False |
| mutated_pressure = float(first_vector.group(2)) + delta |
| lines[last_index] = ( |
| lines[last_index][: first_vector.start()] |
| + first_vector.group(1) |
| + f"{mutated_pressure:.12g}" |
| + first_vector.group(3) |
| + lines[last_index][first_vector.end() :] |
| ) |
| FORCES.write_text("\n".join(lines) + ("\n" if text.endswith("\n") else ""), encoding="utf-8") |
| environment = os.environ.copy() |
| environment["ENGIWORLD_TASK_ROOT"] = str(ROOT) |
| result = subprocess.run( |
| ["python3", str(path)], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=30, |
| env=environment, |
| ) |
| if result.returncode == 0: |
| reported = float(read(ROOT / "summary.txt").strip()) |
| with (ROOT / "force_history.csv").open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| expected = original_history[-1][3] + delta |
| mutation_ok = ( |
| len(rows) == 2001 |
| and tuple(rows[0]) == ("time_s", "pressure_fx_n", "viscous_fx_n", "total_fx_n") |
| and abs(float(rows[-1]["total_fx_n"]) - expected) <= 5.0e-7 |
| and abs(reported - expected) <= 5.0e-7 |
| ) |
| finally: |
| FORCES.write_bytes(original) |
| environment = os.environ.copy() |
| environment["ENGIWORLD_TASK_ROOT"] = str(ROOT) |
| restored = subprocess.run( |
| ["python3", str(path)], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=30, |
| env=environment, |
| ).returncode == 0 |
| return mutation_ok and restored |
|
|
|
|
| def check_case() -> bool: |
| mesh = read(CASE / "system/blockMeshDict") |
| motion = read(CASE / "constant/dynamicMeshDict") |
| mover = named_block(motion, "mover") |
| topology = read(CASE / "system/topoSetDict") |
| velocity = read(CASE / "0/U") |
| physical = read(CASE / "constant/physicalProperties") |
| momentum = read(CASE / "constant/momentumTransport") |
| pressure = read(CASE / "0/p") |
| control = read(CASE / "system/controlDict") |
| forces = named_block(named_block(control, "functions"), "bodyForces") |
| return all( |
| ( |
| mesh.count("hex (") == 20, |
| mesh_geometry_is_valid(mesh), |
| mesh.count("(10 10 1)") == 16, |
| mesh.count("(10 5 1)") == 4, |
| has_entry(mover, "type", r"motionSolver"), |
| has_entry(mover, "motionSolver", r"solidBody"), |
| has_entry(mover, "cellZone", r"movingZone"), |
| has_entry(mover, "solidBodyMotionFunction", r"oscillatingRotatingMotion"), |
| all(abs(value) <= 1.0e-12 for value in vector_entry(mover, "origin")), |
| all( |
| abs(left - right) <= 1.0e-12 |
| for left, right in zip(vector_entry(mover, "amplitude"), (0.0, 0.0, 5.0)) |
| ), |
| abs(scalar_entry(mover, "omega") - 2.0 * math.pi) <= 1.0e-12, |
| abs(scalar_entry(topology, "radius") - 1.41) <= 1.0e-12, |
| has_entry(patch(velocity, "left"), "value", r"uniform\s+\(0\.5\s+0(?:\.0+)?\s+0(?:\.0+)?\)"), |
| has_entry(patch(velocity, "right"), "type", r"zeroGradient"), |
| all(has_entry(patch(velocity, name), "type", r"slip") for name in ("down", "up")), |
| has_entry(patch(velocity, "cylinder"), "type", r"movingWallVelocity"), |
| has_entry(patch(pressure, "right"), "type", r"fixedValue"), |
| has_entry(patch(pressure, "right"), "value", r"uniform\s+0(?:\.0+)?"), |
| abs(dimensioned_scalar(physical, "nu") - 0.01) <= 1.0e-12, |
| has_entry(momentum, "simulationType", r"laminar"), |
| abs(scalar_entry(control, "endTime") - 2.0) <= 1.0e-12, |
| abs(scalar_entry(control, "deltaT") - 0.001) <= 1.0e-12, |
| abs(scalar_entry(control, "writeInterval") - 0.25) <= 1.0e-12, |
| has_entry(forces, "type", r"forces"), |
| has_entry(forces, "patches", r"\(\s*cylinder\s*\)"), |
| abs(scalar_entry(forces, "rhoInf") - 1.0) <= 1.0e-12, |
| all(abs(value) <= 1.0e-12 for value in vector_entry(forces, "CofR")), |
| ) |
| ) |
|
|
|
|
| def check() -> bool: |
| required = ( |
| ROOT / "postprocess.py", |
| ROOT / "summary.txt", |
| ROOT / "force_history.csv", |
| CASE / "log.blockMesh", |
| CASE / "log.checkMesh", |
| CASE / "log.topoSet", |
| CASE / "log.pimpleFoam", |
| CASE / "log.checkMeshFinal", |
| CASE / "constant/polyMesh/cellZones", |
| CASE / "0.25/polyMesh/points", |
| CASE / "2/U", |
| CASE / "2/p", |
| FORCES, |
| ) |
| if any(not path.is_file() or path.stat().st_size == 0 for path in required): |
| return False |
| if not postprocess_script_is_valid(ROOT / "postprocess.py"): |
| return False |
| if not ( |
| log_completed(CASE / "log.blockMesh", ("nCells: 1800",)) |
| and log_completed(CASE / "log.topoSet", ("movingZone now size 804",)) |
| and log_completed(CASE / "log.checkMesh", ("Mesh OK.",)) |
| and log_completed(CASE / "log.checkMeshFinal", ("Mesh OK.",)) |
| and log_completed(CASE / "log.pimpleFoam", ("Time = 2s",)) |
| and "movingZone" in read(CASE / "constant/polyMesh/cellZones") |
| and field_count(CASE / "2/U", "vector", "volVectorField") == 1800 |
| and field_count(CASE / "2/p", "scalar", "volScalarField") == 1800 |
| and (CASE / "0.25/polyMesh/points").read_bytes() != (CASE / "constant/polyMesh/points").read_bytes() |
| ): |
| return False |
| times = set() |
| for path in CASE.iterdir(): |
| if not path.is_dir(): |
| continue |
| try: |
| times.add(round(float(path.name), 9)) |
| except ValueError: |
| continue |
| expected_times = {round(index * 0.25, 9) for index in range(9)} |
| if not expected_times.issubset(times) or not times or max(times) != 2.0: |
| return False |
| mesh_check = subprocess.run( |
| [ |
| "bash", |
| "--noprofile", |
| "--norc", |
| "-c", |
| f"trap - CHLD; . /opt/openfoam11/etc/bashrc && checkMesh -latestTime -case {shlex.quote(str(CASE))}", |
| ], |
| 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 not mesh_check.stdout.rstrip().endswith("End") |
| or not check_case() |
| ): |
| return False |
|
|
| centres_result = subprocess.run( |
| [ |
| "bash", |
| "--noprofile", |
| "--norc", |
| "-c", |
| f"trap - CHLD; . /opt/openfoam11/etc/bashrc && postProcess -case {shlex.quote(str(CASE))} -latestTime -func writeCellCentres", |
| ], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| centres_output = centres_result.stdout |
| if ( |
| centres_result.returncode != 0 |
| or "foam fatal" in centres_output.lower() |
| or not centres_output.rstrip().endswith("End") |
| ): |
| return False |
| centres = vector_field(CASE / "2/C") |
| actual_zone = zone_labels(read(CASE / "constant/polyMesh/cellZones"), "movingZone") |
| expected_zone = { |
| index |
| for index, point in enumerate(centres) |
| if math.hypot(point[0], point[1]) <= 1.41 + 1.0e-9 and -2.0 <= point[2] <= 2.0 |
| } |
| if actual_zone != expected_zone or not actual_zone or len(actual_zone) >= 1800: |
| return False |
|
|
| history = force_history() |
| if len(history) != 2001: |
| return False |
| if not all(all(math.isfinite(value) for value in row) for row in history): |
| return False |
| if any(abs(row[0] - index * 0.001) > 1.0e-9 for index, row in enumerate(history)): |
| return False |
| totals = [row[3] for row in history] |
| if ( |
| max(abs(row[1]) for row in history) <= 0.1 |
| or max(abs(row[2]) for row in history) <= 0.01 |
| or max(totals) - min(totals) <= 0.1 |
| or abs(totals[-1]) <= 1.0e-6 |
| ): |
| return False |
| keys = ("time_s", "pressure_fx_n", "viscous_fx_n", "total_fx_n") |
| with (ROOT / "force_history.csv").open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| if len(rows) != len(history) or tuple(rows[0]) != keys: |
| return False |
| for row, expected in zip(rows, history): |
| actual = tuple(float(row[key]) for key in keys) |
| if any(abs(left - right) > 5e-7 for left, right in zip(actual, expected)): |
| return False |
|
|
| lines = [line.strip() for line in read(ROOT / "summary.txt").splitlines() if line.strip()] |
| if len(lines) != 1: |
| return False |
| reported = float(lines[0]) |
| return math.isfinite(reported) and abs(reported - history[-1][3]) <= 5e-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()) |
|
|
