fix: disambiguate WindIO cone / uptilt rad vs deg by magnitude

The WindIO v2 turbine schema annotates hub.cone_angle and drivetrain
uptilt as degrees, but the IEA reference ontologies store radians (IEA-22
cone_angle 0.0698 = 4 deg, uptilt 0.1047 = 6 deg, matched to <0.5 % on CM
against the ElastoDyn deck). A pure-radians reader rejects schema-
conforming degree files; a pure-degrees reader mis-reads the reference
files as ~0 precone. Physical precone and shaft tilt are small (well under
~20 deg), so the two encodings never overlap: interpret a stored magnitude
at or below 0.5 as radians and a larger one as degrees, and reject a value
non-physical under either (> 90). Both a 4 and a 0.0698 cone now assemble
to the same 4 deg RNA.

Author: SMI-Lab-Inha

src/pybmodes/io/windio.py

@@ -732,25 +732,32 @@ def _finite_float(value: Any, what: str) -> float:
     return f
 
 
-def _finite_angle(value: Any, what: str, max_abs: float = float(np.pi / 4)) -> float:
-    """Coerce ``value`` to a finite angle in radians within a physical bound.
-
-    WindIO stores angles in radians (SI). A rotor precone or shaft tilt beyond
-    ~45 deg is non-physical for a horizontal-axis turbine and almost always
-    means degrees were supplied by mistake (e.g. ``cone_angle: 4`` read as
-    4 rad = 229 deg instead of 4 deg), which would silently corrupt the coned
-    lever and axial offset. Reject it with a clear message rather than
-    evaluate the trig at the wrong angle.
+def _windio_angle(value: Any, what: str) -> float:
+    """Interpret a WindIO precone / shaft-tilt angle as radians, tolerant of
+    the rad/deg ambiguity across WindIO versions.
+
+    The WindIO v2 turbine schema annotates ``hub.cone_angle`` and drivetrain
+    ``uptilt`` as degrees, but the IEA reference ontologies store radians
+    (IEA-22 ``cone_angle`` 0.0698 = 4 deg, ``uptilt`` 0.1047 = 6 deg).
+    Physical rotor precone and shaft tilt are small (well under ~20 deg), so
+    the two encodings never overlap: a stored magnitude at or below 0.5 is
+    radians (0.5 rad = 29 deg, already larger than any real precone / tilt),
+    a larger one is degrees. Convert to radians on that basis, and reject a
+    value that is non-physical under either reading (> 90). This keeps the
+    validated radians reference files working while also accepting a
+    schema-conforming degrees file (issue #130 review).
     """
     ang = _finite_float(value, what)
-    if abs(ang) > max_abs:
-        raise ValueError(
-            f"{what} = {ang:.4f} rad ({np.degrees(ang):.1f} deg) is outside the "
-            f"physical range +/-{np.degrees(max_abs):.0f} deg. WindIO angles are "
-            f"in radians; a value near a small integer usually means degrees "
-            f"were supplied."
-        )
-    return ang
+    mag = abs(ang)
+    if mag <= 0.5:
+        return ang
+    if mag <= 90.0:
+        return float(np.radians(ang))
+    raise ValueError(
+        f"{what} = {ang!r} is non-physical as either radians "
+        f"({np.degrees(ang):.0f} deg) or degrees; expected a rotor precone / "
+        f"shaft tilt well under 90 deg."
+    )
 
 
 def _positive_mass(value: Any, what: str) -> float:
@@ -1076,7 +1083,7 @@ def _nac_geom(key: str) -> float:
         return _finite_float(val, f"nacelle.drivetrain.{key}")
 
     overhang = _nac_geom("overhang")
-    uptilt = _finite_angle(_nac_geom("uptilt"), "nacelle.drivetrain.uptilt")
+    uptilt = _windio_angle(_nac_geom("uptilt"), "nacelle.drivetrain.uptilt")
     dist_tt_hub = _nac_geom("distance_tt_hub")
 
     # --- Hub: components.<hub>.elastic_properties_mb ---
@@ -1103,7 +1110,7 @@ def _nac_geom(key: str) -> float:
     )
     if hub_r < 0.0:
         raise ValueError(f"hub diameter must be non-negative; got {hub_diam!r}.")
-    cone_ang = _finite_angle(hub.get("cone_angle", 0.0), "hub cone_angle")
+    cone_ang = _windio_angle(hub.get("cone_angle", 0.0), "hub cone_angle")
     cone_cos = float(np.cos(cone_ang))
     cone_sin = float(np.sin(cone_ang))
 

tests/test_windio_rna.py

@@ -200,28 +200,39 @@ def _mk(cone: float):
     assert coned.mass == pytest.approx(flat.mass)
 
 
-def test_rna_rejects_degree_valued_cone_angle(tmp_path: pathlib.Path) -> None:
-    """WindIO angles are radians; a degrees-valued cone_angle (e.g. 4 read as
-    4 rad = 229 deg) is non-physical and rejected rather than silently
-    evaluated at the wrong angle (Codex review on #130)."""
+def test_rna_cone_and_uptilt_degrees_match_radians(tmp_path: pathlib.Path) -> None:
+    """WindIO's rad/deg ambiguity: the v2 schema annotates cone_angle / uptilt
+    as degrees while the IEA reference files store radians. The reader
+    disambiguates by magnitude, so a degrees encoding (4, 6) and the
+    equivalent radians encoding (0.0698, 0.1047) assemble to the same RNA
+    (Codex review on #130)."""
     pytest.importorskip("yaml")
+    import numpy as np
+
     from pybmodes.io.windio import read_windio_rna
 
-    o = _base_ontology()
-    o["components"]["hub"]["cone_angle"] = 4.0  # 4 deg mistakenly left un-converted
-    with pytest.raises(ValueError, match="radians"):
-        read_windio_rna(_write(o, tmp_path, "cone_deg.yaml"))
+    def _mk(cone: float, uptilt: float):
+        o = _base_ontology()
+        o["components"]["hub"]["cone_angle"] = cone
+        o["components"]["nacelle"]["drivetrain"]["uptilt"] = uptilt
+        return read_windio_rna(_write(o, tmp_path, f"a_{cone}_{uptilt}.yaml"))
+
+    rad = _mk(float(np.radians(4.0)), float(np.radians(6.0)))  # 0.0698, 0.1047
+    deg = _mk(4.0, 6.0)  # degrees encoding of the same angles
+    for attr in ("mass", "cm_axial", "ixx", "iyy", "izz", "izx"):
+        assert getattr(deg, attr) == pytest.approx(getattr(rad, attr))
 
 
-def test_rna_rejects_degree_valued_uptilt(tmp_path: pathlib.Path) -> None:
-    """A degrees-valued uptilt is likewise rejected as out of physical range."""
+def test_rna_rejects_nonphysical_angle(tmp_path: pathlib.Path) -> None:
+    """A value non-physical as both radians and degrees (e.g. 200) is rejected
+    rather than silently evaluated at a meaningless angle."""
     pytest.importorskip("yaml")
     from pybmodes.io.windio import read_windio_rna
 
     o = _base_ontology()
-    o["components"]["nacelle"]["drivetrain"]["uptilt"] = 6.0  # 6 deg un-converted
-    with pytest.raises(ValueError, match="radians"):
-        read_windio_rna(_write(o, tmp_path, "uptilt_deg.yaml"))
+    o["components"]["hub"]["cone_angle"] = 200.0
+    with pytest.raises(ValueError, match="non-physical"):
+        read_windio_rna(_write(o, tmp_path, "cone_bad.yaml"))
 
 
 @pytest.mark.parametrize("n_bl", [1, 2])