| |
| from __future__ import annotations |
|
|
| import math |
| import re |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| DT = 0.01 |
| T_MAX = 60.0 |
| G = 9.80665 |
| TARGET_PEAK_ACCELERATION = 0.2 * G |
| EXPECTED = (0.049626, 262.790752) |
| 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 pulse_kinematics(time: float, scale: float) -> tuple[float, float, float]: |
| if time < 30.0 or time > 60.0: |
| return 0.0, 0.0, 0.0 |
| tau = time - 30.0 |
| envelope_frequency = math.pi / 30.0 |
| carrier_frequency = 2.0 * math.pi |
| sine = math.sin(envelope_frequency * tau) |
| cosine = math.cos(envelope_frequency * tau) |
| envelope = sine**4 |
| envelope_d1 = 4.0 * envelope_frequency * sine**3 * cosine |
| envelope_d2 = 4.0 * envelope_frequency**2 * (3.0 * sine**2 * cosine**2 - sine**4) |
| carrier = math.sin(carrier_frequency * tau) |
| carrier_d1 = carrier_frequency * math.cos(carrier_frequency * tau) |
| carrier_d2 = -(carrier_frequency**2) * carrier |
| displacement = scale * envelope * carrier |
| velocity = scale * (envelope_d1 * carrier + envelope * carrier_d1) |
| acceleration = scale * ( |
| envelope_d2 * carrier + 2.0 * envelope_d1 * carrier_d1 + envelope * carrier_d2 |
| ) |
| return displacement, velocity, acceleration |
|
|
|
|
| def check_motion(path: Path) -> bool: |
| rows: list[list[float]] = [] |
| for line in read(path).splitlines(): |
| fields = line.split() |
| if len(fields) != 19: |
| return False |
| rows.append([float(value) for value in fields]) |
| if len(rows) != 6001: |
| return False |
|
|
| unscaled_peak = max( |
| abs(pulse_kinematics(step * DT, 1.0)[2]) |
| for step in range(round(T_MAX / DT) + 1) |
| ) |
| scale = TARGET_PEAK_ACCELERATION / unscaled_peak |
| peak_acceleration = 0.0 |
| for index, row in enumerate(rows): |
| time = index * DT |
| if not close(row[0], time, rel_tol=0.0, abs_tol=2.0e-9): |
| return False |
| expected = pulse_kinematics(time, scale) |
| actual = (row[1], row[7], row[13]) |
| if any(not close(value, target, rel_tol=2.0e-8, abs_tol=2.0e-9) for value, target in zip(actual, expected)): |
| return False |
| if any(abs(row[column]) > 1.0e-12 for column in (*range(2, 7), *range(8, 13), *range(14, 19))): |
| return False |
| peak_acceleration = max(peak_acceleration, abs(row[13])) |
| return close(peak_acceleration, TARGET_PEAK_ACCELERATION, rel_tol=0.0, abs_tol=2.0e-8) |
|
|
|
|
| def output_metrics(path: Path) -> tuple[float, float]: |
| lines = read(path).splitlines() |
| header_index = next(i for i, 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") |
| displacement_i = headers.index("Intf1TDXss") |
| moment_i = headers.index("ReactMYss") |
| if units[displacement_i] != "(m)" or units[moment_i] != "(N*m)": |
| raise ValueError("unexpected native SubDyn units") |
|
|
| all_rows: list[list[float]] = [] |
| for line in lines[header_index + 2 :]: |
| fields = line.split() |
| if len(fields) != len(headers): |
| continue |
| try: |
| all_rows.append([float(value) for value in fields]) |
| except ValueError: |
| continue |
| if len(all_rows) != 6000 or not close(all_rows[-1][time_i], 59.99, rel_tol=0.0, abs_tol=1.0e-8): |
| raise ValueError("incomplete SubDyn output") |
| rows = [row for row in all_rows if row[time_i] >= 30.0] |
| if len(rows) != 3000: |
| raise ValueError("incorrect excitation-window sample count") |
| return ( |
| max(abs(row[displacement_i]) for row in rows), |
| max(abs(row[moment_i]) for row in rows) / 1.0e6, |
| ) |
|
|
|
|
| def parse_summary(path: Path) -> tuple[float, float]: |
| rows = [line.strip() for line in read(path).splitlines() if line.strip()] |
| if len(rows) != 1: |
| raise ValueError("summary must contain one row") |
| values = tuple(float(value.strip()) for value in rows[0].split(",")) |
| if len(values) != 2 or not all(math.isfinite(value) for value in values): |
| raise ValueError("summary must contain two finite values") |
| return values |
|
|
|
|
| def check() -> bool: |
| required = ( |
| "build_case.py", |
| "postprocess.py", |
| "earthquake_motion.txt", |
| "subdyn_eq.dat", |
| "earthquake.dvr", |
| "earthquake_sd.SD.out", |
| "earthquake_sd.SD.sum.yaml", |
| "earthquake_sd.log", |
| "summary.txt", |
| ) |
| if any(not (ROOT / name).is_file() or (ROOT / name).stat().st_size == 0 for name in required): |
| return False |
|
|
| driver = read(ROOT / "earthquake.dvr") |
| expected_driver = { |
| "NSteps": "6000", |
| "TimeInterval": "0.01", |
| "nTP": "1", |
| "TP_RefPoint_X": "0.0", |
| "TP_RefPoint_Y": "0.0", |
| "TP_RefPoint_Z": "10.0", |
| "InputsMod": "2", |
| "InputsFile": "earthquake_motion.txt", |
| "nAppliedLoads": "0", |
| } |
| if any(parameter(driver, name) != value for name, value in expected_driver.items()): |
| return False |
| if "ALJointID Fx Fy Fz Mx My Mz UnsteadyFile" not in driver: |
| return False |
|
|
| subdyn = read(ROOT / "subdyn_eq.dat") |
| if "ExtLdMod" in subdyn: |
| return False |
| if re.search(r"(?<![-A-Za-z0-9_])ReactMYss(?![A-Za-z0-9_])", subdyn) is None: |
| return False |
| if re.search(r"(?<![-A-Za-z0-9_])Intf1TDXss(?![A-Za-z0-9_])", subdyn) is None: |
| return False |
| if re.search(r"(?<![A-Za-z0-9_])-ReactMYss(?![A-Za-z0-9_])", subdyn): |
| return False |
| if not check_motion(ROOT / "earthquake_motion.txt"): |
| return False |
|
|
| log = read(ROOT / "earthquake_sd.log") |
| if "Running SubDyn Driver a part of OpenFAST - v5.0.0" not in log: |
| return False |
| if "Simulated Time: 59.99 seconds" not in log or "Total Real Time:" not in log: |
| return False |
| if any(marker in log for marker in ("Premature EOF", "Invalid numerical input", "FATAL ERROR")): |
| return False |
|
|
| calculated = output_metrics(ROOT / "earthquake_sd.SD.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-5) 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()) |
|
|
