| |
| from __future__ import annotations |
|
|
| import hashlib |
| import math |
| import os |
| import re |
| import shlex |
| import shutil |
| import subprocess |
| import tempfile |
| from pathlib import Path |
|
|
|
|
| FOAM_BASHRC = Path("/opt/openfoam11/etc/bashrc") |
| WORD_RE = re.compile(r"[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*") |
|
|
|
|
| def read_text(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def file_hash(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def run_foam(case: Path, args: list[str], timeout: int = 60) -> tuple[int, str]: |
| command = [args[0], "-case", str(case), *args[1:]] |
| script = f". {shlex.quote(str(FOAM_BASHRC))} && {shlex.join(command)}" |
| completed = subprocess.run( |
| ["bash", "-lc", script], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=timeout, |
| check=False, |
| ) |
| return completed.returncode, completed.stdout |
|
|
|
|
| def has_required_case_files(case: Path) -> bool: |
| required = ( |
| "0/U", |
| "0/p", |
| "constant/physicalProperties", |
| "system/blockMeshDict", |
| "system/controlDict", |
| "system/fvSchemes", |
| "system/fvSolution", |
| ) |
| return all((case / rel).is_file() and (case / rel).stat().st_size > 0 for rel in required) |
|
|
|
|
| def diagnosis_is_specific(path: Path) -> bool: |
| if not path.is_file() or path.stat().st_size == 0: |
| return False |
| text = read_text(path) |
| low = text.lower() |
| if len(WORD_RE.findall(text)) < 100: |
| return False |
| |
| duplicate = any(token in low for token in ("duplicat", "coincident", "same coordinate", "identical to vertex")) |
| orientation = any(token in low for token in ("inside-out", "right-handed", "right hand", "left-handed", "wrong-handed")) |
| bad_index = "99" in low and any(token in low for token in ("range", "nonexistent", "non-existent", "does not exist", "invalid", "undefined")) |
| corrected_corner = re.search(r"\(\s*0(?:\.0*)?\s+1(?:\.0*)?\s+0\.0*1\s*\)", low) is not None |
| return "blockmesh" in low and duplicate and orientation and bad_index and corrected_corner |
|
|
|
|
| def final_field_is_structured(path: Path, class_name: str, list_type: str) -> bool: |
| if not path.is_file() or path.stat().st_size == 0: |
| return False |
| text = read_text(path) |
| if not re.search(r"\bformat\s+ascii\s*;", text) or not re.search(rf"\bclass\s+{re.escape(class_name)}\s*;", text): |
| return False |
| declaration = re.search( |
| rf"internalField\s+nonuniform\s+List<{re.escape(list_type)}>\s+(\d+)\s*\(", |
| text, |
| flags=re.DOTALL, |
| ) |
| if not declaration or int(declaration.group(1)) != 400: |
| return False |
| return re.search(r"(?i)(?:^|[^A-Za-z])(?:nan|inf)(?:[^A-Za-z]|$)", text) is None |
|
|
|
|
| def field_payload(path: Path) -> dict: |
| """Parse ASCII field dictionaries without depending on whitespace or key order.""" |
| text = re.sub(r"/\*.*?\*/|//[^\n]*", "", read_text(path), flags=re.S) |
| tokens = re.findall(r'"(?:\\.|[^"\\])*"|[{}();\[\]]|[^\s{}();\[\]]+', text) |
| position = 0 |
|
|
| def dictionary(nested=False): |
| nonlocal position |
| result = {} |
| while position < len(tokens): |
| if tokens[position] == "}": |
| if not nested: |
| raise ValueError("unexpected dictionary end") |
| position += 1 |
| return result |
| key = tokens[position].strip('"') |
| position += 1 |
| if key in result or position >= len(tokens): |
| raise ValueError("duplicate or unfinished field entry") |
| if tokens[position] == "{": |
| position += 1 |
| result[key] = dictionary(True) |
| if position < len(tokens) and tokens[position] == ";": |
| position += 1 |
| else: |
| values = [] |
| depth = 0 |
| while position < len(tokens): |
| token = tokens[position] |
| position += 1 |
| if token == ";" and depth == 0: |
| break |
| if token in ("(", "["): |
| depth += 1 |
| elif token in (")", "]"): |
| depth -= 1 |
| if depth < 0 or token in ("{", "}"): |
| raise ValueError("invalid field syntax") |
| try: |
| value = float(token) |
| except ValueError: |
| value = token.strip('"') |
| else: |
| if not math.isfinite(value): |
| raise ValueError("nonfinite field value") |
| values.append(value) |
| else: |
| raise ValueError("unterminated field entry") |
| if depth: |
| raise ValueError("unbalanced field list") |
| result[key] = values |
| if nested: |
| raise ValueError("unterminated dictionary") |
| return result |
|
|
| result = dictionary() |
| header = result.pop("FoamFile", {}) |
| if header.get("format") != ["ascii"] or header.get("object") != [path.name]: |
| raise ValueError("field header mismatch") |
| expected = "volVectorField" if path.name == "U" else "volScalarField" |
| if header.get("class") != [expected]: |
| raise ValueError("field class mismatch") |
| if not {"dimensions", "internalField", "boundaryField"}.issubset(result): |
| raise ValueError("required field payload missing") |
| return result |
|
|
|
|
| def equivalent_fields(left: Path, right: Path) -> bool: |
| def equivalent(a, b): |
| if isinstance(a, dict) and isinstance(b, dict): |
| return a.keys() == b.keys() and all(equivalent(a[k], b[k]) for k in a) |
| if isinstance(a, list) and isinstance(b, list): |
| return len(a) == len(b) and all(equivalent(x, y) for x, y in zip(a, b)) |
| if isinstance(a, float) and isinstance(b, float): |
| return math.isclose(a, b, rel_tol=5e-6, abs_tol=1e-9) |
| return a == b |
| try: |
| return equivalent(field_payload(left), field_payload(right)) |
| except (ValueError, OSError): |
| return False |
|
|
|
|
| def remove_generated_mesh_and_times(case: Path) -> None: |
| poly_mesh = case / "constant" / "polyMesh" |
| if poly_mesh.exists(): |
| shutil.rmtree(poly_mesh) |
| for child in case.iterdir(): |
| if not child.is_dir(): |
| continue |
| try: |
| time_value = float(child.name) |
| except ValueError: |
| continue |
| if time_value > 0: |
| shutil.rmtree(child) |
|
|
|
|
| def check_task(root: Path) -> bool: |
| diagnosis = root / "diagnosis.txt" |
| broken = root / "broken_block" |
| fixed = root / "fixed" |
| if not FOAM_BASHRC.is_file(): |
| return False |
| if not diagnosis_is_specific(diagnosis): |
| return False |
| if not has_required_case_files(broken) or not has_required_case_files(fixed): |
| return False |
|
|
| submitted_u = fixed / "0.5" / "U" |
| submitted_p = fixed / "0.5" / "p" |
| if not final_field_is_structured(submitted_u, "volVectorField", "vector"): |
| return False |
| if not final_field_is_structured(submitted_p, "volScalarField", "scalar"): |
| return False |
| submitted_hashes = {"U": file_hash(submitted_u), "p": file_hash(submitted_p)} |
|
|
| with tempfile.TemporaryDirectory(prefix="engiworld-openfoam17-eval-") as tmp: |
| tmp_root = Path(tmp) |
| broken_copy = tmp_root / "broken_block" |
| fixed_copy = tmp_root / "fixed" |
| shutil.copytree(broken, broken_copy) |
| shutil.copytree(fixed, fixed_copy) |
|
|
| broken_poly_mesh = broken_copy / "constant" / "polyMesh" |
| if broken_poly_mesh.exists(): |
| shutil.rmtree(broken_poly_mesh) |
| broken_rc, broken_log = run_foam(broken_copy, ["blockMesh"]) |
| broken_low = broken_log.lower() |
| if broken_rc == 0 or "version: 11" not in broken_low: |
| return False |
| if "inside-out" not in broken_low or "fatal io error" not in broken_low: |
| return False |
|
|
| remove_generated_mesh_and_times(fixed_copy) |
| mesh_rc, mesh_log = run_foam(fixed_copy, ["blockMesh"]) |
| if mesh_rc != 0 or "Version: 11" not in mesh_log or not mesh_log.rstrip().endswith("End"): |
| return False |
| if "nCells: 400" not in mesh_log or "Number of undefined boundary faces : 0" not in mesh_log: |
| return False |
|
|
| check_rc, check_log = run_foam( |
| fixed_copy, |
| ["checkMesh", "-allTopology", "-allGeometry"], |
| ) |
| if check_rc != 0 or "Mesh OK." not in check_log or "Failed " in check_log: |
| return False |
| if "hexahedra: 400" not in check_log or "wedges: 0" not in check_log: |
| return False |
|
|
| solver_rc, solver_log = run_foam(fixed_copy, ["icoFoam"], timeout=90) |
| if solver_rc != 0 or "Version: 11" not in solver_log or not solver_log.rstrip().endswith("End"): |
| return False |
| if "Time = 0.5s" not in solver_log: |
| return False |
|
|
| rerun_u = fixed_copy / "0.5" / "U" |
| rerun_p = fixed_copy / "0.5" / "p" |
| if not final_field_is_structured(rerun_u, "volVectorField", "vector"): |
| return False |
| if not final_field_is_structured(rerun_p, "volScalarField", "scalar"): |
| return False |
| if not equivalent_fields(rerun_u, submitted_u): |
| return False |
| if not equivalent_fields(rerun_p, submitted_p): |
| return False |
|
|
| return True |
|
|
|
|
| def evaluate() -> int: |
| root = Path(os.environ.get("ENGIWORLD_EVAL_ROOT", "/home/user/Desktop")) |
| try: |
| return 1 if check_task(root) else 0 |
| except Exception: |
| return 0 |
|
|
|
|
| def main() -> int: |
| print("True" if evaluate() == 1 else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
