| |
| from __future__ import annotations |
|
|
| import csv |
| import math |
| import re |
| import subprocess |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| CASE = ROOT / "pipe_parallel" |
| RADIUS = 0.05 |
| RHO = 1.0 |
| RADIAL_CELLS = 20 |
|
|
|
|
| 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 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 patch(text: str, name: str) -> str: |
| return named_block(named_block(text, "boundaryField"), name) |
|
|
|
|
| def 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 = all( |
| len(value) == 3 and all(math.isfinite(component) for component in value) |
| for value in values |
| ) |
| else: |
| values = [float(value) for value in match.group(2).split()] |
| valid = all(math.isfinite(value) for value in values) |
| if ( |
| len(values) != int(match.group(1)) |
| or not valid |
| 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 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 mesh_geometry_is_valid(mesh: str) -> bool: |
| scale_match = re.search(r"\bconvertToMeters\s+([^;]+);", mesh) |
| vertices = [ |
| tuple(float(value) for value in item.split()) |
| for item in re.findall(r"\(([^()]+)\)", paren_section(mesh, "vertices")) |
| ] |
| if scale_match is None or len(vertices) != 6 or any(len(point) != 3 for point in vertices): |
| return False |
| scale = float(scale_match.group(1)) |
| points = [tuple(scale * value for value in point) for point in vertices] |
| xs = [point[0] for point in points] |
| outer = [point for point in points if math.hypot(point[1], point[2]) > 1e-12] |
| angles = sorted(math.degrees(math.atan2(point[2], point[1])) for point in outer) |
| return ( |
| abs(min(xs)) <= 1e-12 |
| and abs(max(xs) - 3.0) <= 1e-12 |
| and len(outer) == 4 |
| and all(abs(math.hypot(point[1], point[2]) - RADIUS) <= 1e-9 for point in outer) |
| and abs(angles[0] + 2.5) <= 1e-6 |
| and abs(angles[-1] - 2.5) <= 1e-6 |
| and re.search(r"hex\s*\([^)]*\)\s*\(\s*240\s+20\s+1\s*\)", mesh) is not None |
| ) |
|
|
|
|
| def numeric_entry(text: str, key: str) -> float: |
| match = re.search(rf"(?m)^\s*{re.escape(key)}\s+([^;]+);", text) |
| if not match: |
| raise ValueError(f"missing entry {key}") |
| return float(match.group(1)) |
|
|
|
|
| def dimensioned_value(text: str, key: str) -> float: |
| match = re.search(rf"(?m)^\s*{re.escape(key)}\s+\[[^]]+\]\s+([^;]+);", text) |
| if not match: |
| raise ValueError(f"missing dimensioned entry {key}") |
| return float(match.group(1)) |
|
|
|
|
| def label_list(path: Path) -> list[int]: |
| text = re.sub(r"/\*.*?\*/|//[^\n]*", "", read(path), flags=re.S) |
| match = re.search(r"\n\s*(\d+)\s*\n\s*\((.*?)\)\s*$", text, re.S) |
| if not match: |
| raise ValueError(f"invalid label list: {path}") |
| values = [int(value) for value in match.group(2).split()] |
| if len(values) != int(match.group(1)): |
| raise ValueError(f"label count mismatch: {path}") |
| return values |
|
|
|
|
| def log_finished(path: Path) -> bool: |
| text = read(path) |
| if "FOAM FATAL" in text: |
| return False |
| stripped = text.rstrip() |
| if path.name == "log.simpleFoam.parallel": |
| return "\nEnd\n" in text and stripped.endswith("Finalising parallel run") |
| return stripped.endswith("End") |
|
|
|
|
| def check_case() -> bool: |
| mesh = read(CASE / "system/blockMeshDict") |
| velocity = read(CASE / "0/U") |
| pressure = read(CASE / "0/p") |
| physical = read(CASE / "constant/physicalProperties") |
| momentum = read(CASE / "constant/momentumTransport") |
| control = read(CASE / "system/controlDict") |
| decomposition = read(CASE / "system/decomposeParDict") |
| schemes = read(CASE / "system/fvSchemes") |
| solution = read(CASE / "system/fvSolution") |
| return all( |
| ( |
| mesh_geometry_is_valid(mesh), |
| mesh.count("type wedge;") == 2, |
| has_entry(patch(velocity, "axis"), "type", r"empty"), |
| has_entry(patch(velocity, "inlet"), "value", r"uniform\s+\(1(?:\.0+)?\s+0(?:\.0+)?\s+0(?:\.0+)?\)"), |
| has_entry(patch(velocity, "outlet"), "type", r"zeroGradient"), |
| has_entry(patch(velocity, "wall"), "type", r"noSlip"), |
| all(has_entry(patch(velocity, name), "type", r"wedge") for name in ("wedgeLow", "wedgeHigh")), |
| has_entry(patch(pressure, "axis"), "type", r"empty"), |
| has_entry(patch(pressure, "inlet"), "type", r"zeroGradient"), |
| has_entry(patch(pressure, "outlet"), "type", r"fixedValue"), |
| has_entry(patch(pressure, "outlet"), "value", r"uniform\s+0(?:\.0+)?"), |
| all(has_entry(patch(pressure, name), "type", r"wedge") for name in ("wedgeLow", "wedgeHigh")), |
| abs(dimensioned_value(physical, "nu") - 1e-4) <= 1e-12, |
| abs(dimensioned_value(physical, "rho") - 1.0) <= 1e-12, |
| "simulationType laminar;" in momentum, |
| abs(numeric_entry(control, "endTime") - 1000.0) <= 1e-12, |
| re.search(r"\bwriteFormat\s+ascii\s*;", control) is not None, |
| has_entry(named_block(schemes, "divSchemes"), "div(phi,U)", r"bounded\s+Gauss\s+linearUpwind\s+grad\(U\)"), |
| "corrected" in named_block(schemes, "laplacianSchemes"), |
| has_entry(named_block(named_block(solution, "solvers"), "p"), "solver", r"GAMG"), |
| re.search(r"\bnumberOfSubdomains\s+4\s*;", decomposition) is not None, |
| re.search(r"\bmethod\s+simple\s*;", decomposition) is not None, |
| re.search(r"\bn\s*\(4 1 1\)\s*;", decomposition) is not None, |
| ) |
| ) |
|
|
|
|
| def calculate() -> tuple[float, float, list[tuple[float, ...]]]: |
| centres = field(CASE / "1000/C", "vector") |
| velocity = field(CASE / "1000/U", "vector") |
| pressure = field(CASE / "1000/p", "scalar") |
| if not (len(centres) == len(velocity) == len(pressure) == 4800): |
| raise ValueError("unexpected reconstructed field size") |
| indices = sorted( |
| (i for i, centre in enumerate(centres) if centre[0] > 2.99), |
| key=lambda i: math.hypot(centres[i][1], centres[i][2]), |
| ) |
| if len(indices) != RADIAL_CELLS: |
| raise ValueError("unexpected outlet-cell count") |
| mass_flow = 0.0 |
| square_error = 0.0 |
| area_sum = 0.0 |
| rows = [] |
| for radial_index, index in enumerate(indices): |
| radius = math.hypot(centres[index][1], centres[index][2]) |
| inner = radial_index * RADIUS / RADIAL_CELLS |
| outer = (radial_index + 1) * RADIUS / RADIAL_CELLS |
| area = math.pi * (outer**2 - inner**2) |
| ux = velocity[index][0] |
| theoretical = 2.0 * (1.0 - (radius / RADIUS) ** 2) |
| contribution = RHO * ux * area |
| mass_flow += contribution |
| square_error += area * (ux - theoretical) ** 2 |
| area_sum += area |
| rows.append((radius, ux, theoretical, area, contribution)) |
| return mass_flow, math.sqrt(square_error / area_sum), rows |
|
|
|
|
| def check() -> bool: |
| required = ( |
| ROOT / "build_case.py", |
| ROOT / "run_parallel.py", |
| ROOT / "postprocess.py", |
| ROOT / "summary.txt", |
| ROOT / "outlet_mass_flow.csv", |
| CASE / "log.blockMesh", |
| CASE / "log.checkMesh", |
| CASE / "log.decomposePar", |
| CASE / "log.simpleFoam.parallel", |
| CASE / "log.reconstructPar", |
| CASE / "log.cellCentres", |
| CASE / "1000/U", |
| CASE / "1000/p", |
| CASE / "1000/C", |
| ) |
| if any(not path.is_file() or path.stat().st_size == 0 for path in required): |
| return False |
| if any(not log_finished(path) for path in required[5:11]): |
| return False |
| if "Mesh OK." not in read(CASE / "log.checkMesh"): |
| return False |
| parallel_log = read(CASE / "log.simpleFoam.parallel") |
| if re.search(r"\bnProcs\s*:\s*4\b", parallel_log) is None: |
| return False |
| processor_addressing = [] |
| for processor in range(4): |
| directory = CASE / f"processor{processor}" |
| addressing = label_list(directory / "constant/polyMesh/cellProcAddressing") |
| processor_u = field(directory / "1000/U", "vector") |
| processor_p = field(directory / "1000/p", "scalar") |
| if not ( |
| len(addressing) == len(set(addressing)) == len(processor_u) == len(processor_p) == 1200 |
| ): |
| return False |
| processor_addressing.extend(addressing) |
| if len(set(processor_addressing)) != 4800 or set(processor_addressing) != set(range(4800)): |
| return False |
| mesh_check = subprocess.run( |
| [ |
| "bash", |
| "--noprofile", |
| "--norc", |
| "-c", |
| "trap - CHLD; . /opt/openfoam11/etc/bashrc && checkMesh -case /home/user/Desktop/pipe_parallel", |
| ], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=120, |
| ) |
| if mesh_check.returncode != 0 or "Mesh OK." not in mesh_check.stdout or not check_case(): |
| return False |
|
|
| mass_flow, profile_error, calculated_rows = calculate() |
| theoretical_flow = RHO * math.pi * RADIUS**2 |
| if not ( |
| abs(mass_flow - theoretical_flow) / theoretical_flow < 0.02 |
| and profile_error < 0.08 |
| ): |
| return False |
| keys = ("radius_m", "ux_m_s", "poiseuille_ux_m_s", "annulus_area_m2", "mass_flow_kg_s") |
| with (ROOT / "outlet_mass_flow.csv").open(encoding="utf-8", newline="") as stream: |
| rows = list(csv.DictReader(stream)) |
| if len(rows) != RADIAL_CELLS or set(rows[0]) != set(keys): |
| return False |
| for row, expected in zip(rows, calculated_rows): |
| 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 |
| reported = float(read(ROOT / "summary.txt").strip()) |
| return math.isfinite(reported) and abs(reported - mass_flow) <= 5.0e-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()) |
|
|
