| |
| from __future__ import annotations |
|
|
| import cmath |
| import math |
| import re |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| ONE_P_HZ = 9.0 / 60.0 |
| EXPECTED = ( |
| 12.214448, |
| 88.000774, |
| 7.204646, |
| 0.230884, |
| 1.874851, |
| ) |
| 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 output_metrics(path: Path) -> tuple[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") |
| power_i = headers.index("RtAeroPwr") |
| if ( |
| units[time_i] != "(s)" |
| or units[wind_i] != "(m/s)" |
| or units[speed_i] != "(rpm)" |
| or units[power_i] != "(W)" |
| ): |
| 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) != 301: |
| 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") |
| if not close(row[wind_i], 8.0, rel_tol=0.0, abs_tol=2.0e-6): |
| raise ValueError("output wind speed is not fixed at 8 m/s") |
| if not close(row[speed_i], 9.0, rel_tol=0.0, abs_tol=2.0e-6): |
| raise ValueError("rotor speed is not fixed at 9 rpm") |
|
|
| samples = [ |
| (row[time_i], row[power_i] / 1000.0) |
| for row in rows[100:] |
| ] |
| if len(samples) != 201: |
| raise ValueError("incorrect 10-to-30-second sample count") |
| mean = sum(value for _, value in samples) / len(samples) |
| std = math.sqrt( |
| sum((value - mean) ** 2 for _, value in samples) |
| / len(samples) |
| ) |
| coefficient = sum( |
| (value - mean) |
| * cmath.exp(-2j * math.pi * ONE_P_HZ * time) |
| for time, value in samples |
| ) |
| amplitude = 2.0 * abs(coefficient) / len(samples) |
| return std, amplitude |
|
|
|
|
| def parse_summary( |
| path: Path, |
| ) -> tuple[float, float, 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) != 5 or not all(math.isfinite(value) for value in values): |
| raise ValueError("summary must contain five finite values") |
| return values |
|
|
|
|
| def normalize_shadow_parameter(text: str) -> str: |
| updated, count = re.subn( |
| r"(?m)^\s*\S+(\s+TwrShadow\s+-.*)$", |
| r"<TwrShadow>\1", |
| text, |
| ) |
| if count != 1: |
| raise ValueError("expected exactly one TwrShadow parameter") |
| return updated |
|
|
|
|
| def check() -> bool: |
| required = ( |
| "build_case.py", |
| "postprocess.py", |
| "elasto_shadow.dat", |
| "aero_notower.dat", |
| "aero_tower.dat", |
| "case_notower.fst", |
| "case_tower.fst", |
| "case_notower.out", |
| "case_tower.out", |
| "case_notower.log", |
| "case_tower.log", |
| "summary.txt", |
| "5MW_Baseline/NRELOffshrBsline5MW_InflowWind_Steady8mps.dat", |
| ) |
| 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_Steady8mps.dat" |
| ) |
| if ( |
| parameter(inflow, "WindType") != "1" |
| or parameter(inflow, "HWindSpeed") != "8" |
| ): |
| return False |
|
|
| elasto = read(ROOT / "elasto_shadow.dat") |
| rigid_dofs = ( |
| "FlapDOF1", |
| "FlapDOF2", |
| "EdgeDOF", |
| "PitchDOF", |
| "TeetDOF", |
| "DrTrDOF", |
| "GenDOF", |
| "YawDOF", |
| "TwFADOF1", |
| "TwFADOF2", |
| "TwSSDOF1", |
| "TwSSDOF2", |
| ) |
| if any(parameter(elasto, name) != "False" for name in rigid_dofs): |
| return False |
| if ( |
| parameter(elasto, "RotSpeed") != "9.0" |
| or parameter(elasto, "OverHang") != "20.0" |
| or '"../5MW_Baseline/' in elasto |
| ): |
| return False |
|
|
| no_tower_aero = read(ROOT / "aero_notower.dat") |
| tower_aero = read(ROOT / "aero_tower.dat") |
| if ( |
| parameter(no_tower_aero, "TwrShadow") != "0" |
| or parameter(tower_aero, "TwrShadow") != "1" |
| or parameter(no_tower_aero, "Wake_Mod") != "1" |
| or parameter(tower_aero, "Wake_Mod") != "1" |
| or '"../5MW_Baseline/' in no_tower_aero |
| or '"../5MW_Baseline/' in tower_aero |
| or '"RtAeroPwr"' not in no_tower_aero |
| or '"RtAeroPwr"' not in tower_aero |
| or normalize_shadow_parameter(no_tower_aero) |
| != normalize_shadow_parameter(tower_aero) |
| ): |
| return False |
|
|
| for label in ("notower", "tower"): |
| main = read(ROOT / f"case_{label}.fst") |
| expected_main = { |
| "TMax": "30.0", |
| "DT_Out": "0.1", |
| "OutFileFmt": "1", |
| "CompInflow": "1", |
| "CompAero": "2", |
| "CompServo": "0", |
| "EDFile": "elasto_shadow.dat", |
| "InflowFile": ( |
| "5MW_Baseline/" |
| "NRELOffshrBsline5MW_InflowWind_Steady8mps.dat" |
| ), |
| "AeroFile": f"aero_{label}.dat", |
| } |
| if any( |
| parameter(main, name) != value |
| for name, value in expected_main.items() |
| ): |
| return False |
|
|
| log = read(ROOT / f"case_{label}.log") |
| if ( |
| "OpenFAST-v5.0.0" not in log |
| or "OpenFAST terminated normally." not in log |
| or "Simulated Time: 30 seconds" not in log |
| or "FATAL ERROR" in log |
| or "Tower strike" in log |
| ): |
| return False |
|
|
| no_tower_std, no_tower_amp = output_metrics( |
| ROOT / "case_notower.out" |
| ) |
| tower_std, tower_amp = output_metrics(ROOT / "case_tower.out") |
| calculated = ( |
| no_tower_std, |
| tower_std, |
| tower_std / no_tower_std, |
| no_tower_amp, |
| tower_amp, |
| ) |
| reported = parse_summary(ROOT / "summary.txt") |
| return ( |
| tower_std > 5.0 * no_tower_std |
| and 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()) |
|
|
