| from pathlib import Path |
| from shutil import which |
| from contextlib import redirect_stderr, redirect_stdout |
| import glob |
| import io |
| import math |
| import os |
| import re |
| import subprocess |
| import tempfile |
|
|
|
|
| FLUENT_EXEC_FILE = r"C:\Program Files\ANSYS Inc\v261\fluent\ntbin\win64\fluent.exe" |
| DESKTOP = Path(r"C:\Users\user\Desktop") |
| CASE_FILE = DESKTOP / "pipe_laminar.cas" |
| DATA_FILE = DESKTOP / "pipe_laminar.dat" |
| REQUIRED_FILES = (CASE_FILE, DATA_FILE) |
| FLOAT_RE = r"[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?" |
|
|
|
|
| def is_nonempty_file(path: Path) -> bool: |
| return path.is_file() and path.stat().st_size > 0 |
|
|
|
|
| def find_fluent_executable() -> str: |
| explicit = Path(FLUENT_EXEC_FILE) |
| if explicit.is_file(): |
| return str(explicit) |
| cmd = which("fluent") |
| if cmd: |
| return cmd |
| candidates = [] |
| for key, value in os.environ.items(): |
| if key.startswith("AWP_ROOT"): |
| candidates.append(Path(value) / "fluent" / "ntbin" / "win64" / "fluent.exe") |
| for pattern in ( |
| r"C:\Program Files\ANSYS Inc\ANSYS Student\v*\fluent\ntbin\win64\fluent.exe", |
| r"C:\Program Files\ANSYS Inc\v*\fluent\ntbin\win64\fluent.exe", |
| ): |
| candidates.extend(Path(p) for p in glob.glob(pattern)) |
| for candidate in candidates: |
| if candidate.is_file(): |
| return str(candidate) |
| raise FileNotFoundError("Fluent executable not found") |
|
|
|
|
| def decode_case(path: Path) -> str: |
| return path.read_bytes().decode("latin-1", errors="ignore") |
|
|
|
|
| def extract_zone(text: str, zone_type: str, zone_name: str) -> str: |
| start = re.search( |
| rf"\(39\s+\([^\n]*\b{re.escape(zone_type)}\s+{re.escape(zone_name)}\s+1\)\(", |
| text, |
| flags=re.I, |
| ) |
| if not start: |
| return "" |
| following = text[start.start() :] |
| end = following.find("\n(39 ", 5) |
| return following if end < 0 else following[:end] |
|
|
|
|
| def case_configuration_is_valid(case_file: Path) -> bool: |
| text = decode_case(case_file) |
| low = text.lower() |
| required_tokens = ( |
| '(0 "fluent26.1.', |
| "(2 3)", |
| "(rp-3d? . #t)", |
| "(rp-double? . #t)", |
| "(rp-seg? . #t)", |
| "(rp-unsteady? . #f)", |
| "(rp-lam? . #t)", |
| "(rp-turb? . #f)", |
| "(rp-visc? . #t)", |
| "(flow/scheme 20)", |
| "(pressure/scheme 12)", |
| "(mom/scheme 1)", |
| "(density (constant . 998.2)", |
| "(viscosity (constant . 0.001003)", |
| "(material . water-liquid)", |
| "(cfd-post-mesh-info ((0 0 (fluid) (wall wall fluid) (outlet pressure-outlet fluid) (inlet velocity-inlet fluid)))", |
| ) |
| if not all(token in low for token in required_tokens): |
| return False |
|
|
| inlet = extract_zone(text, "velocity-inlet", "inlet").lower() |
| outlet = extract_zone(text, "pressure-outlet", "outlet").lower() |
| wall = extract_zone(text, "wall", "wall").lower() |
| if not inlet or not outlet or not wall: |
| return False |
| if "(vmag (constant . 0.1)" not in inlet: |
| return False |
| if "(flow-direction-component ((constant . 1)" not in inlet: |
| return False |
| if "(p (constant . 0)" not in outlet: |
| return False |
| if "(moving? . #f)" not in wall: |
| return False |
| return True |
|
|
|
|
| def extract_predictions(root: Path) -> dict: |
| journal = """/file/read-case-data pipe_laminar.cas |
| /mesh/check |
| /report/surface-integrals/area-weighted-avg outlet () x-velocity no |
| /exit yes |
| """ |
| with tempfile.NamedTemporaryFile( |
| mode="w", encoding="ascii", suffix=".jou", dir=root, delete=False |
| ) as stream: |
| stream.write(journal) |
| journal_path = Path(stream.name) |
| try: |
| proc = subprocess.run( |
| [find_fluent_executable(), "3ddp", "-g", "-i", journal_path.name], |
| cwd=root, |
| capture_output=True, |
| text=True, |
| timeout=300, |
| ) |
| output = (proc.stdout or "") + "\n" + (proc.stderr or "") |
| if ( |
| proc.returncode != 0 |
| or "Error:" in output |
| or 'Reading "pipe_laminar.cas"' not in output |
| or 'Reading "pipe_laminar.dat"' not in output |
| ): |
| raise RuntimeError("Fluent did not load the case and data cleanly") |
|
|
| extents = {} |
| for axis in "xyz": |
| match = re.search( |
| rf"{axis}-coordinate:\s*min \(m\) =\s*({FLOAT_RE}),\s*max \(m\) =\s*({FLOAT_RE})", |
| output, |
| flags=re.I, |
| ) |
| if not match: |
| raise RuntimeError(f"{axis} extent not found") |
| extents[axis] = (float(match.group(1)), float(match.group(2))) |
|
|
| cells = re.search(r"(\d+)\s+hexahedral cells", output, flags=re.I) |
| volume = re.search(rf"minimum volume \(m3\):\s*({FLOAT_RE})", output, flags=re.I) |
| values = re.findall(rf"^\s*outlet\s+({FLOAT_RE})\s*$", output, flags=re.I | re.M) |
| if not cells or not volume or not values: |
| raise RuntimeError("hex-cell count, mesh volume, or outlet velocity not found") |
| return { |
| "extents": extents, |
| "hexahedral_cells": int(cells.group(1)), |
| "minimum_cell_volume_m3": float(volume.group(1)), |
| "outlet_mean_x_velocity_m_s": float(values[-1]), |
| } |
| finally: |
| try: |
| journal_path.unlink() |
| except OSError: |
| pass |
|
|
|
|
| def solution_and_near_wall_layers_are_valid(root: Path, outlet_mean: float) -> bool: |
| import ansys.fluent.core as pyfluent |
| from ansys.fluent.core.services.field_data import SurfaceDataType |
|
|
| solver = pyfluent.launch_fluent( |
| mode="solver", |
| precision="double", |
| processor_count=1, |
| dimension=3, |
| ui_mode="no_gui", |
| start_watchdog=False, |
| ) |
| try: |
| solver.settings.file.read_case_data(file_name=str(root / CASE_FILE.stem)) |
| plane_name = "__eval_c15_mid_plane" |
| solver.settings.results.surfaces.plane_surface[plane_name] = { |
| "method": "yz-plane", |
| "x": 0.05, |
| } |
| data = solver.fields.field_data.get_surface_data( |
| data_types=[SurfaceDataType.Vertices, SurfaceDataType.FacesConnectivity], |
| surfaces=[plane_name], |
| )[plane_name] |
| vertices = data[SurfaceDataType.Vertices] |
| faces = data[SurfaceDataType.FacesConnectivity] |
| if len(vertices) < 25 or len(faces) < 16: |
| return False |
|
|
| radii = [math.hypot(float(row[1]), float(row[2])) for row in vertices] |
| if max(radii) > 0.00202 or abs(max(radii) - 0.002) > 2e-5: |
| return False |
|
|
| adjacency = [set() for _ in vertices] |
| for face in faces: |
| indices = [int(value) for value in face] |
| for index, first in enumerate(indices): |
| second = indices[(index + 1) % len(indices)] |
| adjacency[first].add(second) |
| adjacency[second].add(first) |
|
|
| wall_vertices = [index for index, radius in enumerate(radii) if radius >= 0.00198] |
| if len(wall_vertices) < 16: |
| return False |
| chains = 0 |
| for start in wall_vertices: |
| current = start |
| for _ in range(3): |
| candidates = [ |
| neighbor |
| for neighbor in adjacency[current] |
| if 1e-7 < radii[current] - radii[neighbor] < 5e-4 |
| ] |
| if not candidates: |
| break |
| current = min(candidates, key=lambda neighbor: radii[current] - radii[neighbor]) |
| else: |
| chains += 1 |
| if chains < 0.8 * len(wall_vertices): |
| return False |
|
|
| velocity = solver.fields.field_data.get_scalar_field_data( |
| field_name="x-velocity", |
| surfaces=[plane_name], |
| )[plane_name] |
| wall_velocity = [abs(float(velocity[index])) for index in wall_vertices] |
| core_velocity = [ |
| float(value) |
| for value, radius in zip(velocity, radii) |
| if radius <= 0.0005 |
| ] |
| if not core_velocity or max(float(value) for value in velocity) < 1.25 * outlet_mean: |
| return False |
| if sum(core_velocity) / len(core_velocity) < 1.15 * outlet_mean: |
| return False |
| if max(wall_velocity) > 0.05 * outlet_mean: |
| return False |
|
|
| pressure = solver.fields.field_data.get_scalar_field_data( |
| field_name="pressure", |
| surfaces=["inlet", "outlet"], |
| ) |
| inlet_pressure = sum(float(value) for value in pressure["inlet"]) / len(pressure["inlet"]) |
| outlet_pressure = sum(float(value) for value in pressure["outlet"]) / len(pressure["outlet"]) |
| return 1.0 < inlet_pressure - outlet_pressure < 1000.0 |
| finally: |
| solver.exit() |
|
|
|
|
| def predictions_are_valid(predictions: dict) -> bool: |
| extents = predictions["extents"] |
| targets = { |
| "x": (0.0, 0.100, 2e-5), |
| "y": (-0.002, 0.002, 2e-5), |
| "z": (-0.002, 0.002, 2e-5), |
| } |
| for axis, (expected_min, expected_max, tolerance) in targets.items(): |
| actual_min, actual_max = extents[axis] |
| if abs(actual_min - expected_min) > tolerance: |
| return False |
| if abs(actual_max - expected_max) > tolerance: |
| return False |
| if predictions["minimum_cell_volume_m3"] <= 0: |
| return False |
| if predictions["hexahedral_cells"] < 1000: |
| return False |
| return 0.095 <= predictions["outlet_mean_x_velocity_m_s"] <= 0.105 |
|
|
|
|
| def kill_ansys_related() -> None: |
| for image in ("fluent.exe", "cortex.exe"): |
| try: |
| subprocess.run( |
| ["taskkill", "/F", "/IM", image], |
| capture_output=True, |
| creationflags=0x08000000, |
| ) |
| except Exception: |
| pass |
|
|
|
|
| def evaluate() -> bool: |
| kill_ansys_related() |
| if any(not is_nonempty_file(path) for path in REQUIRED_FILES): |
| return False |
| try: |
| if not case_configuration_is_valid(CASE_FILE): |
| return False |
| predictions = extract_predictions(DESKTOP) |
| return predictions_are_valid(predictions) and solution_and_near_wall_layers_are_valid( |
| DESKTOP, |
| predictions["outlet_mean_x_velocity_m_s"], |
| ) |
| except Exception: |
| return False |
|
|
|
|
| def main() -> None: |
| with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()): |
| result = evaluate() |
| print("True" if result else "False") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
