| |
| from __future__ import annotations |
|
|
| import math |
| import re |
| from collections import deque |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| M = 4.0 |
| N_EQ = 50.0 |
| EXPECTED = (4.104952, 0.225078, 0.571267) |
| REL_TOL = 2.0e-3 |
| ABS_TOL = 2.0e-5 |
|
|
|
|
| def read(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def close( |
| actual: float, |
| expected: float, |
| rel_tol: float = REL_TOL, |
| abs_tol: float = ABS_TOL, |
| ) -> bool: |
| return math.isfinite(actual) and abs(actual - expected) <= max( |
| abs_tol, rel_tol * max(1.0, abs(expected)) |
| ) |
|
|
|
|
| def parameter(text: str, name: str) -> str: |
| match = re.search( |
| rf"^\s*(\S+).*?\s{re.escape(name)}\s+-", |
| text, |
| re.MULTILINE, |
| ) |
| if not match: |
| raise ValueError(f"missing parameter {name}") |
| return match.group(1).strip('"').rstrip(",") |
|
|
|
|
| def reversals(series: list[float]) -> list[float]: |
| if not series: |
| raise ValueError("empty torque series") |
| cleaned = [series[0]] |
| for value in series[1:]: |
| if value != cleaned[-1]: |
| cleaned.append(value) |
| if len(cleaned) == 1: |
| return cleaned |
|
|
| points = [cleaned[0]] |
| for index in range(1, len(cleaned) - 1): |
| left = cleaned[index] - cleaned[index - 1] |
| right = cleaned[index + 1] - cleaned[index] |
| if left * right <= 0.0: |
| points.append(cleaned[index]) |
| points.append(cleaned[-1]) |
| return points |
|
|
|
|
| def rainflow_ranges( |
| series: list[float], |
| ) -> list[tuple[float, float]]: |
| stack: deque[float] = deque() |
| cycles: list[tuple[float, float]] = [] |
| for point in reversals(series): |
| stack.append(point) |
| while len(stack) >= 3: |
| newer = abs(stack[-1] - stack[-2]) |
| older = abs(stack[-2] - stack[-3]) |
| if newer < older: |
| break |
| if len(stack) == 3: |
| cycles.append((older, 0.5)) |
| stack.popleft() |
| else: |
| cycles.append((older, 1.0)) |
| last = stack.pop() |
| stack.pop() |
| stack.pop() |
| stack.append(last) |
| while len(stack) > 1: |
| first = stack.popleft() |
| cycles.append((abs(stack[0] - first), 0.5)) |
| return cycles |
|
|
|
|
| def output_metrics(path: Path) -> tuple[float, float, float]: |
| lines = read(path).splitlines() |
| if "at commit v5.0.0" not in "\n".join(lines[:5]): |
| raise ValueError("output was not generated by OpenFAST 5.0.0") |
|
|
| header_index = next( |
| index |
| for index, line in enumerate(lines) |
| if line.split()[:1] == ["Time"] |
| ) |
| headers = lines[header_index].split() |
| units = lines[header_index + 1].split() |
| time_i = headers.index("Time") |
| wind_i = headers.index("Wind1VelX") |
| speed_i = headers.index("RotSpeed") |
| torque_i = headers.index("RotTorq") |
| if ( |
| units[time_i] != "(s)" |
| or units[wind_i] != "(m/s)" |
| or units[speed_i] != "(rpm)" |
| or units[torque_i] != "(kN-m)" |
| ): |
| raise ValueError("unexpected native OpenFAST units") |
|
|
| rows: list[list[float]] = [] |
| for line in lines[header_index + 2 :]: |
| fields = line.split() |
| if len(fields) != len(headers): |
| continue |
| try: |
| rows.append([float(value) for value in fields]) |
| except ValueError: |
| continue |
| if len(rows) != 601: |
| raise ValueError("incorrect output sample count") |
| for index, row in enumerate(rows): |
| if not close( |
| row[time_i], |
| index / 10.0, |
| rel_tol=0.0, |
| abs_tol=2.0e-8, |
| ): |
| raise ValueError("output timestamps are not 0.1-second samples") |
|
|
| wind_values = [row[wind_i] for row in rows] |
| wind_mean = sum(wind_values) / len(wind_values) |
| wind_std = math.sqrt( |
| sum((value - wind_mean) ** 2 for value in wind_values) |
| / len(wind_values) |
| ) |
| if wind_std < 0.5: |
| raise ValueError("native output does not contain turbulent wind") |
|
|
| torque_mnm = [row[torque_i] / 1000.0 for row in rows[100:]] |
| if len(torque_mnm) != 501: |
| raise ValueError("incorrect 10-to-60-second sample count") |
| mean = sum(torque_mnm) / len(torque_mnm) |
| std = math.sqrt( |
| sum((value - mean) ** 2 for value in torque_mnm) |
| / len(torque_mnm) |
| ) |
| cycles = rainflow_ranges(torque_mnm) |
| if not cycles or not any(count == 1.0 for _, count in cycles): |
| raise ValueError("rainflow counting produced no closed cycles") |
| if not any(count == 0.5 for _, count in cycles): |
| raise ValueError("rainflow counting produced no residual cycles") |
| damage_sum = sum( |
| count * load_range**M |
| for load_range, count in cycles |
| ) |
| damage_equivalent = (damage_sum / N_EQ) ** (1.0 / M) |
| return mean, std, damage_equivalent |
|
|
|
|
| def parse_summary(path: Path) -> tuple[float, float, float]: |
| rows = [line.strip() for line in read(path).splitlines() if line.strip()] |
| if len(rows) != 1: |
| raise ValueError("summary must contain exactly one row") |
| values = tuple(float(field.strip()) for field in rows[0].split(",")) |
| if len(values) != 3 or not all(math.isfinite(value) for value in values): |
| raise ValueError("summary must contain three finite values") |
| return values |
|
|
|
|
| def check() -> bool: |
| required = ( |
| "build_case.py", |
| "postprocess.py", |
| "elasto_drivetrain.dat", |
| "aero_drivetrain.dat", |
| "servo_drivetrain.dat", |
| "drivetrain_case.fst", |
| "drivetrain_case.out", |
| "drivetrain_case.log", |
| "summary.txt", |
| "5MW_Baseline/NRELOffshrBsline5MW_InflowWind_12mps.dat", |
| "5MW_Baseline/Wind/90m_12mps_twr.bts", |
| "5MW_Baseline/ServoData/DISCON.dll", |
| ) |
| if any( |
| not (ROOT / name).is_file() or (ROOT / name).stat().st_size == 0 |
| for name in required |
| ): |
| return False |
|
|
| inflow = read( |
| ROOT / "5MW_Baseline/NRELOffshrBsline5MW_InflowWind_12mps.dat" |
| ) |
| if ( |
| parameter(inflow, "WindType") != "3" |
| or parameter(inflow, "FileName_BTS") |
| != "Wind/90m_12mps_twr.bts" |
| ): |
| return False |
|
|
| elasto = read(ROOT / "elasto_drivetrain.dat") |
| if ( |
| parameter(elasto, "DrTrDOF") != "True" |
| or parameter(elasto, "GenDOF") != "True" |
| or '"RotTorq"' not in elasto |
| or '"RotSpeed"' not in elasto |
| or '"../5MW_Baseline/' in elasto |
| ): |
| return False |
|
|
| aero = read(ROOT / "aero_drivetrain.dat") |
| servo = read(ROOT / "servo_drivetrain.dat") |
| if '"../5MW_Baseline/' in aero or '"../5MW_Baseline/' in servo: |
| return False |
| if ( |
| parameter(servo, "DLL_FileName") |
| != "5MW_Baseline/ServoData/DISCON.dll" |
| ): |
| return False |
|
|
| main = read(ROOT / "drivetrain_case.fst") |
| expected_main = { |
| "TMax": "60.0", |
| "DT_Out": "0.1", |
| "OutFileFmt": "1", |
| "EDFile": "elasto_drivetrain.dat", |
| "InflowFile": ( |
| "5MW_Baseline/" |
| "NRELOffshrBsline5MW_InflowWind_12mps.dat" |
| ), |
| "AeroFile": "aero_drivetrain.dat", |
| "ServoFile": "servo_drivetrain.dat", |
| } |
| if any( |
| parameter(main, name) != value |
| for name, value in expected_main.items() |
| ): |
| return False |
|
|
| log = read(ROOT / "drivetrain_case.log") |
| if ( |
| "OpenFAST-v5.0.0" not in log |
| or "OpenFAST terminated normally." not in log |
| or "Simulated Time: 60 seconds" not in log |
| or "FATAL ERROR" in log |
| ): |
| return False |
|
|
| calculated = output_metrics(ROOT / "drivetrain_case.out") |
| reported = parse_summary(ROOT / "summary.txt") |
| return ( |
| all( |
| close(actual, expected) |
| for actual, expected in zip(calculated, EXPECTED) |
| ) |
| and all( |
| close(actual, expected) |
| for actual, expected in zip(reported, EXPECTED) |
| ) |
| and all( |
| close( |
| actual, |
| calculated_value, |
| rel_tol=0.0, |
| abs_tol=2.0e-6, |
| ) |
| for actual, calculated_value in zip(reported, calculated) |
| ) |
| ) |
|
|
|
|
| def main() -> int: |
| try: |
| result = check() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
