| |
| from __future__ import annotations |
|
|
| import os |
| import re |
| from pathlib import Path |
|
|
|
|
| FLOAT_RE = re.compile(r"(?<![A-Za-z0-9_])[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?(?![A-Za-z0-9_])") |
| REL_TOL = 1e-2 |
| ABS_TOL = 1e-4 |
| SPEEDS = (4, 8, 11, 15, 20) |
| REQUIRED_FILES = ['summary.txt', 'run_cases.py', 'postprocess.py'] + [ |
| f'{stem}_ws{speed}{suffix}' |
| for speed in SPEEDS |
| for stem, suffix in (('inflow', '.dat'), ('case', '.fst'), ('case', '.out'), ('case', '.log')) |
| ] |
| EXPECTED_ROWS = [[4.0, 148.962779, 7.139224], [8.0, 1615.090892, 8.922937], [11.0, 4129.585441, 11.802749], [15.0, 4999.823664, 12.098685], [20.0, 5000.103239, 12.100202]] |
| SUMMARY_FILE = 'summary.txt' |
|
|
|
|
| def parse_floats(text: str) -> list[float]: |
| values: list[float] = [] |
| for token in FLOAT_RE.findall(text): |
| try: |
| values.append(float(token)) |
| except ValueError: |
| continue |
| return values |
|
|
|
|
| def parse_numeric_rows(path: Path) -> list[list[float]]: |
| rows: list[list[float]] = [] |
| for raw in path.read_text(encoding='utf-8', errors='ignore').splitlines(): |
| line = raw.strip() |
| if (not line) or line.startswith('#'): |
| continue |
| vals = parse_floats(line) |
| if vals: |
| rows.append(vals) |
| return rows |
|
|
|
|
| def file_ok(path: Path) -> bool: |
| return path.exists() and path.is_file() and path.stat().st_size > 0 |
|
|
|
|
| def close_enough(actual: float, expected: float) -> bool: |
| return abs(actual - expected) <= max(ABS_TOL, REL_TOL * max(1.0, abs(expected))) |
|
|
|
|
| def keyed_value(text: str, key: str) -> float: |
| line = next(line for line in text.splitlines() if re.search(rf'\b{re.escape(key)}\b', line)) |
| return float(line.split()[0]) |
|
|
|
|
| def output_means(path: Path) -> tuple[float, float]: |
| lines = path.read_text(encoding='utf-8', errors='ignore').splitlines() |
| header = next(i for i, line in enumerate(lines) if line.split() and line.split()[0] == 'Time') |
| names = lines[header].split() |
| indices = [names.index(name) for name in ('Time', 'GenPwr', 'RotSpeed')] |
| rows = [[float(value) for value in line.split()] for line in lines[header + 2:] if line.split()] |
| if not rows or rows[-1][indices[0]] < 59.9: |
| raise ValueError('incomplete OpenFAST output') |
| tail = [row for row in rows if row[indices[0]] >= 50.0] |
| return tuple(sum(row[index] for row in tail) / len(tail) for index in indices[1:]) |
|
|
|
|
| def check_task(root: Path) -> bool: |
| for rel in REQUIRED_FILES: |
| if not file_ok(root / rel): |
| return False |
|
|
| actual = parse_numeric_rows(root / SUMMARY_FILE) |
| if len(actual) != len(EXPECTED_ROWS): |
| return False |
|
|
| by_speed = {int(row[0]): row for row in actual if len(row) == 3} |
| for row_e in EXPECTED_ROWS: |
| speed = int(row_e[0]) |
| row_a = by_speed.get(speed, []) |
| if len(row_a) != len(row_e): |
| return False |
| for a, e in zip(row_a, row_e): |
| if not close_enough(a, e): |
| return False |
| inflow = (root / f'inflow_ws{speed}.dat').read_text(encoding='utf-8', errors='ignore') |
| if keyed_value(inflow, 'WindType') != 1 or keyed_value(inflow, 'HWindSpeed') != speed: |
| return False |
| fst = (root / f'case_ws{speed}.fst').read_text(encoding='utf-8', errors='ignore') |
| if f'"inflow_ws{speed}.dat"' not in fst: |
| return False |
| if 'OpenFAST terminated normally' not in (root / f'case_ws{speed}.log').read_text(errors='ignore'): |
| return False |
| power, rpm = output_means(root / f'case_ws{speed}.out') |
| if not close_enough(power, row_a[1]) or not close_enough(rpm, row_a[2]): |
| return False |
|
|
| return True |
|
|
|
|
| def evaluate() -> int: |
| root = Path(os.environ.get('EVAL_OUTPUT_ROOT', '/home/user/Desktop')) |
| try: |
| ok = check_task(root) |
| except Exception: |
| ok = False |
| return 1 if ok else 0 |
|
|
|
|
| def main() -> int: |
| result = evaluate() |
| print('True' if result == 1 else 'False') |
| return 0 |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
