| |
| from __future__ import annotations |
|
|
| from collections import deque |
| import os |
| import re |
| import struct |
| 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 |
| REQUIRED_FILES = ['summary.txt', 'fatigue_post.py', 'cycles.csv', 'fatigue_wind.inp', 'fatigue_wind.bts', |
| 'turbsim.log', 'fatigue.fst', 'inflow_fatigue.dat', 'fatigue.out', 'openfast.log'] |
| EXPECTED_ROWS = [[2698.728680, 2.374722]] |
| 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) -> str: |
| for line in text.splitlines(): |
| parts = line.split() |
| if len(parts) >= 2 and parts[1] == key: |
| return parts[0].strip('"') |
| raise KeyError(key) |
|
|
|
|
| def bts_ok(path: Path) -> bool: |
| header = path.read_bytes()[:42] |
| if len(header) != 42: |
| return False |
| _, nz, ny, _, nt, _, _, dt, uhub, zhub, _ = struct.unpack('<h4i6f', header) |
| return nz == 31 and ny == 31 and nt >= 12000 and abs(dt - 0.05) < 1e-4 and abs(uhub - 11.4) < 0.05 and abs(zhub - 90.0) < 0.05 |
|
|
|
|
| def reversals(series): |
| iterator = iter(enumerate(series)) |
| first_index, first = next(iterator) |
| second_index, second = next(iterator) |
| while second == first: |
| second_index, second = next(iterator) |
| yield first_index, first |
| previous_slope = second - first |
| current_index, current = second_index, second |
| for next_index, next_value in iterator: |
| slope = next_value - current |
| if slope == 0: |
| continue |
| if previous_slope * slope < 0: |
| yield current_index, current |
| previous_slope = slope |
| current_index, current = next_index, next_value |
| yield current_index, current |
|
|
|
|
| def extract_cycles(series): |
| points = deque() |
| for point in reversals(series): |
| points.append(point) |
| while len(points) >= 3: |
| newer = abs(points[-2][1] - points[-1][1]) |
| older = abs(points[-3][1] - points[-2][1]) |
| if newer < older: |
| break |
| if len(points) == 3: |
| yield older, 0.5 |
| points.popleft() |
| else: |
| yield older, 1.0 |
| last = points.pop() |
| points.pop() |
| points.pop() |
| points.append(last) |
| while len(points) > 1: |
| yield abs(points[0][1] - points[1][1]), 0.5 |
| points.popleft() |
|
|
|
|
| def output_dels(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', 'RootMyb1', 'TwrBsMyt')] |
| 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]] < 599.9: |
| raise ValueError('incomplete OpenFAST output') |
| tail = [row for row in rows if row[indices[0]] >= 60.0] |
| result = [] |
| for column, exponent in ((indices[1], 10), (indices[2], 4)): |
| cycles = [(load_range, count) for load_range, count in extract_cycles([row[column] for row in tail]) if load_range > 0] |
| result.append((sum(count * load_range ** exponent for load_range, count in cycles) / 1_000_000) ** (1 / exponent)) |
| return result[0], result[1] / 1000 |
|
|
|
|
| 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 |
|
|
| for row_a, row_e in zip(actual, EXPECTED_ROWS): |
| 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 |
|
|
| ts = (root / 'fatigue_wind.inp').read_text(encoding='utf-8', errors='ignore') |
| if keyed_value(ts, 'IECturbc') != 'B' or keyed_value(ts, 'RandSeed1') != '13428' or keyed_value(ts, 'RandSeed2') != 'RanLux': |
| return False |
| if float(keyed_value(ts, 'URef')) != 11.4 or float(keyed_value(ts, 'RefHt')) != 90 or keyed_value(ts, 'UsableTime').upper() != 'ALL': |
| return False |
| inflow = (root / 'inflow_fatigue.dat').read_text(encoding='utf-8', errors='ignore') |
| if float(keyed_value(inflow, 'WindType')) != 3 or keyed_value(inflow, 'FileName_BTS') != 'fatigue_wind.bts': |
| return False |
| if not bts_ok(root / 'fatigue_wind.bts'): |
| return False |
| if 'TurbSim terminated normally' not in (root / 'turbsim.log').read_text(errors='ignore'): |
| return False |
| if 'OpenFAST terminated normally' not in (root / 'openfast.log').read_text(errors='ignore'): |
| return False |
| if sum(1 for _ in (root / 'cycles.csv').open(errors='ignore')) < 100: |
| return False |
| blade, tower = output_dels(root / 'fatigue.out') |
| if not close_enough(blade, actual[0][0]) or not close_enough(tower, actual[0][1]): |
| 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()) |
|
|
