| |
| from __future__ import annotations |
|
|
| import hashlib |
| import math |
| import re |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| GAIN_LABELS = ("PC_GS_KP", "PC_GS_KI") |
| GAIN_COUNT = 30 |
| EXPECTED = ( |
| 0.229181, |
| 0.225569, |
| 1.297634, |
| 1.745830, |
| 303.606000, |
| 336.553857, |
| ) |
| REL_TOL = 2.0e-3 |
| ABS_TOL = 2.0e-5 |
| BASE_DISCON_SHA256 = "455a2b0248301016fce55b908198c0992479de2490be73f69fde3ad83c37a26e" |
| LIBDISCON_SHA256 = "45111ec68ce797c9c6f6d0352642f1ebeff2315cff187a846ae1660c780dbfcf" |
| PERFORMANCE_SHA256 = "a8d9c2d88bd1d9073287256b042d7752d2202a01e611c08e283b9109504caf5b" |
|
|
|
|
| def read(path: Path) -> str: |
| return path.read_text(encoding="utf-8", errors="ignore") |
|
|
|
|
| def digest(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| 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 values_for_label(text: str, label: str) -> list[float]: |
| matches: list[list[float]] = [] |
| for line in text.splitlines(): |
| values, marker, comment = line.partition("!") |
| if marker and re.search(rf"\b{re.escape(label)}\b", comment): |
| matches.append([float(token) for token in values.split()]) |
| if len(matches) != 1: |
| raise ValueError(f"expected one {label} field") |
| return matches[0] |
|
|
|
|
| def non_gain_signature(text: str) -> str: |
| lines: list[str] = [] |
| for line in text.splitlines(): |
| values, marker, comment = line.partition("!") |
| if marker and any(re.search(rf"\b{label}\b", comment) for label in GAIN_LABELS): |
| lines.append(f"<pitch-gain-values>!{comment}") |
| else: |
| lines.append(line) |
| return "\n".join(lines) |
|
|
|
|
| def controller_ok(path: Path, factor: float, baseline: str) -> bool: |
| text = read(path) |
| if non_gain_signature(text) != non_gain_signature(baseline): |
| return False |
| if parameter(text, "PC_GS_n") != str(GAIN_COUNT): |
| return False |
| if values_for_label(text, "PC_GS_angles") != values_for_label( |
| baseline, "PC_GS_angles" |
| ): |
| return False |
| for label in GAIN_LABELS: |
| original = values_for_label(baseline, label) |
| actual = values_for_label(text, label) |
| if len(original) != GAIN_COUNT or len(actual) != GAIN_COUNT: |
| return False |
| if any( |
| not close(value, factor * source, rel_tol=2.0e-8, abs_tol=2.0e-12) |
| for value, source in zip(actual, original) |
| ): |
| return False |
| return True |
|
|
|
|
| def population_std(values: list[float]) -> float: |
| if not values: |
| raise ValueError("empty sample window") |
| mean = sum(values) / len(values) |
| return math.sqrt(sum((value - mean) ** 2 for value in values) / len(values)) |
|
|
|
|
| def output_metrics(path: Path) -> tuple[float, float, float]: |
| lines = read(path).splitlines() |
| if "at commit v5.0.0" not in "\n".join(lines[:6]): |
| 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() |
| indices = {name: headers.index(name) for name in ( |
| "Time", |
| "Wind1VelX", |
| "RotSpeed", |
| "BldPitch1", |
| "GenPwr", |
| )} |
| expected_units = { |
| "Time": "(s)", |
| "Wind1VelX": "(m/s)", |
| "RotSpeed": "(rpm)", |
| "BldPitch1": "(deg)", |
| "GenPwr": "(kW)", |
| } |
| if any(units[indices[name]] != unit for name, unit in expected_units.items()): |
| 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 native output sample count") |
| for index, row in enumerate(rows): |
| if not close( |
| row[indices["Time"]], |
| index / 10.0, |
| rel_tol=0.0, |
| abs_tol=2.0e-8, |
| ): |
| raise ValueError("output timestamps are not 0.1-second samples") |
|
|
| wind = [row[indices["Wind1VelX"]] for row in rows] |
| if population_std(wind) < 0.5: |
| raise ValueError("native output does not contain turbulent wind") |
| window = [row for row in rows if row[indices["Time"]] >= 10.0] |
| if len(window) != 501: |
| raise ValueError("incorrect 10-to-60-second sample count") |
| return tuple( |
| population_std([row[indices[channel]] for row in window]) |
| for channel in ("RotSpeed", "BldPitch1", "GenPwr") |
| ) |
|
|
|
|
| def parse_summary(path: Path) -> tuple[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) != 6 or not all(math.isfinite(value) for value in values): |
| raise ValueError("summary must contain six finite values") |
| return values |
|
|
|
|
| def check() -> bool: |
| required = ( |
| "DISCON.IN", |
| "Cp_Ct_Cq.NREL5MW.txt", |
| "libdiscon.so", |
| "postprocess.py", |
| "elasto_rosco.dat", |
| "aero_rosco.dat", |
| "rosco_soft.IN", |
| "rosco_stiff.IN", |
| "servo_soft.dat", |
| "servo_stiff.dat", |
| "rosco_soft.fst", |
| "rosco_stiff.fst", |
| "rosco_soft.out", |
| "rosco_stiff.out", |
| "rosco_soft.log", |
| "rosco_stiff.log", |
| "summary.txt", |
| ) |
| if any( |
| not (ROOT / name).is_file() or (ROOT / name).stat().st_size == 0 |
| for name in required |
| ): |
| return False |
| if ( |
| digest(ROOT / "DISCON.IN") != BASE_DISCON_SHA256 |
| or digest(ROOT / "libdiscon.so") != LIBDISCON_SHA256 |
| or digest(ROOT / "Cp_Ct_Cq.NREL5MW.txt") != PERFORMANCE_SHA256 |
| ): |
| return False |
|
|
| baseline = read(ROOT / "DISCON.IN") |
| if not controller_ok(ROOT / "rosco_soft.IN", 0.5, baseline): |
| return False |
| if not controller_ok(ROOT / "rosco_stiff.IN", 1.5, baseline): |
| return False |
|
|
| elasto = read(ROOT / "elasto_rosco.dat") |
| aero = read(ROOT / "aero_rosco.dat") |
| if '"../5MW_Baseline/' in elasto or '"../5MW_Baseline/' in aero: |
| return False |
|
|
| for case in ("soft", "stiff"): |
| servo = read(ROOT / f"servo_{case}.dat") |
| if ( |
| parameter(servo, "PCMode") != "5" |
| or parameter(servo, "VSContrl") != "5" |
| or parameter(servo, "DLL_FileName") != "libdiscon.so" |
| or parameter(servo, "DLL_InFile") != f"rosco_{case}.IN" |
| ): |
| return False |
| main = read(ROOT / f"rosco_{case}.fst") |
| expected_main = { |
| "TMax": "60.0", |
| "DT_Out": "0.1", |
| "OutFileFmt": "1", |
| "EDFile": "elasto_rosco.dat", |
| "InflowFile": ( |
| "5MW_Baseline/" |
| "NRELOffshrBsline5MW_InflowWind_12mps.dat" |
| ), |
| "AeroFile": "aero_rosco.dat", |
| "ServoFile": f"servo_{case}.dat", |
| } |
| if any( |
| parameter(main, name) != value |
| for name, value in expected_main.items() |
| ): |
| return False |
| log = read(ROOT / f"rosco_{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 |
|
|
| soft = output_metrics(ROOT / "rosco_soft.out") |
| stiff = output_metrics(ROOT / "rosco_stiff.out") |
| calculated = (soft[0], stiff[0], soft[1], stiff[1], soft[2], stiff[2]) |
| 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, expected, rel_tol=5.0e-7, abs_tol=5.0e-6) |
| for actual, expected 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()) |
|
|
