zero2geospatial3d-sdk 0.1.0__py3-none-any.whl

zero2geospatial3d/comfort.py

@@ -0,0 +1,687 @@
+"""Outdoor thermal comfort: UTCI, PET and mean radiant temperature.
+
+UTCI: the 6th-order polynomial approximation of Broede et al. (2012),
+"Deriving the operational procedure for the Universal Thermal Climate
+Index (UTCI)", Int J Biometeorol 56:481-494, doi:10.1007/s00484-011-0454-1.
+The polynomial and the saturation vapour pressure function are transcribed
+from pythermalcomfort (models/utci.py), MIT License, Copyright (c) 2019
+Federico Tartarini, and checked against its documented values
+(utci(25, 25, 1.0, 50) = 24.6; utci(40, 25, 1.0, 50) = 40.4).
+
+MRT: longwave exchange with sky and surroundings plus the SolarCal
+short-wave increment (Arens et al. 2015, "Modeling the comfort effects of
+short-wave solar radiation indoors", Building and Environment 88:3-9,
+doi:10.1016/j.buildenv.2014.09.004; ANSI/ASHRAE Standard 55, Appendix C).
+Surrounding surfaces are taken at air temperature unless given: a screening
+model, not a full surface energy balance.
+
+PET: Physiological Equivalent Temperature after Hoeppe (1999) / Walther and
+Goestchel (2018) MEMI, solved with a damped Newton iteration.
+
+Ported from the 02Geo3D QGIS plugin (``web/src/core/comfort.js``).
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Optional, Union
+
+import numpy as np
+
+__all__ = [
+    "PET_CATEGORIES",
+    "UTCI_CATEGORIES",
+    "mean_radiant_temperature",
+    "pet",
+    "pet_category",
+    "projected_area_factor",
+    "saturation_vapour_pressure",
+    "sky_temperature",
+    "utci",
+    "utci_category",
+]
+
+SIGMA = 5.67e-8
+
+ArrayLike = Union[float, np.ndarray]
+
+_SVP_G = (
+    -2836.5744,
+    -6028.076559,
+    19.54263612,
+    -0.02737830188,
+    0.000016261698,
+    7.0229056e-10,
+    -1.8680009e-13,
+)
+
+
+def saturation_vapour_pressure(tdb: ArrayLike) -> Any:
+    """Saturation vapour pressure over water, hPa (as in the UTCI reference code)."""
+    tk = np.asarray(tdb, dtype=float) + 273.15
+    es = 2.7150305 * np.log(tk)
+    for i, g in enumerate(_SVP_G):
+        es = es + g * tk ** float(i - 2)
+    out = np.exp(es) * 0.01
+    return float(out) if np.ndim(out) == 0 else out
+
+
+def utci(tdb: ArrayLike, tr: ArrayLike, v: ArrayLike, rh: ArrayLike, limit: bool = False) -> Any:
+    """UTCI equivalent temperature, degrees C.
+
+    Args:
+        tdb: air temperature, C.
+        tr: mean radiant temperature, C.
+        v: wind speed at 10 m, m/s.
+        rh: relative humidity, %.
+        limit: return NaN outside the model's validity range
+            (-50..50 C air, -30..70 K radiant difference, 0.5..17 m/s wind).
+
+    Scalars give a float; arrays broadcast and give an array.
+    """
+    tdb = np.asarray(tdb, dtype=float)
+    tr = np.asarray(tr, dtype=float)
+    v = np.asarray(v, dtype=float)
+    rh = np.asarray(rh, dtype=float)
+    pa = np.asarray(saturation_vapour_pressure(tdb)) * (rh / 100) / 10  # kPa
+    delta_t_tr = tr - tdb
+    out = (
+        tdb
+        + 0.607562052
+        + (-0.0227712343) * tdb
+        + (8.06470249 * (10 ** (-4))) * tdb * tdb
+        + (-1.54271372 * (10 ** (-4))) * tdb * tdb * tdb
+        + (-3.24651735 * (10 ** (-6))) * tdb * tdb * tdb * tdb
+        + (7.32602852 * (10 ** (-8))) * tdb * tdb * tdb * tdb * tdb
+        + (1.35959073 * (10 ** (-9))) * tdb * tdb * tdb * tdb * tdb * tdb
+        + (-2.25836520) * v
+        + 0.0880326035 * tdb * v
+        + 0.00216844454 * tdb * tdb * v
+        + (-1.53347087 * (10 ** (-5))) * tdb * tdb * tdb * v
+        + (-5.72983704 * (10 ** (-7))) * tdb * tdb * tdb * tdb * v
+        + (-2.55090145 * (10 ** (-9))) * tdb * tdb * tdb * tdb * tdb * v
+        + (-0.751269505) * v * v
+        + (-0.00408350271) * tdb * v * v
+        + (-5.21670675 * (10 ** (-5))) * tdb * tdb * v * v
+        + (1.94544667 * (10 ** (-6))) * tdb * tdb * tdb * v * v
+        + (1.14099531 * (10 ** (-8))) * tdb * tdb * tdb * tdb * v * v
+        + 0.158137256 * v * v * v
+        + (-6.57263143 * (10 ** (-5))) * tdb * v * v * v
+        + (2.22697524 * (10 ** (-7))) * tdb * tdb * v * v * v
+        + (-4.16117031 * (10 ** (-8))) * tdb * tdb * tdb * v * v * v
+        + (-0.0127762753) * v * v * v * v
+        + (9.66891875 * (10 ** (-6))) * tdb * v * v * v * v
+        + (2.52785852 * (10 ** (-9))) * tdb * tdb * v * v * v * v
+        + (4.56306672 * (10 ** (-4))) * v * v * v * v * v
+        + (-1.74202546 * (10 ** (-7))) * tdb * v * v * v * v * v
+        + (-5.91491269 * (10 ** (-6))) * v * v * v * v * v * v
+        + 0.398374029 * delta_t_tr
+        + (1.83945314 * (10 ** (-4))) * tdb * delta_t_tr
+        + (-1.73754510 * (10 ** (-4))) * tdb * tdb * delta_t_tr
+        + (-7.60781159 * (10 ** (-7))) * tdb * tdb * tdb * delta_t_tr
+        + (3.77830287 * (10 ** (-8))) * tdb * tdb * tdb * tdb * delta_t_tr
+        + (5.43079673 * (10 ** (-10))) * tdb * tdb * tdb * tdb * tdb * delta_t_tr
+        + (-0.0200518269) * v * delta_t_tr
+        + (8.92859837 * (10 ** (-4))) * tdb * v * delta_t_tr
+        + (3.45433048 * (10 ** (-6))) * tdb * tdb * v * delta_t_tr
+        + (-3.77925774 * (10 ** (-7))) * tdb * tdb * tdb * v * delta_t_tr
+        + (-1.69699377 * (10 ** (-9))) * tdb * tdb * tdb * tdb * v * delta_t_tr
+        + (1.69992415 * (10 ** (-4))) * v * v * delta_t_tr
+        + (-4.99204314 * (10 ** (-5))) * tdb * v * v * delta_t_tr
+        + (2.47417178 * (10 ** (-7))) * tdb * tdb * v * v * delta_t_tr
+        + (1.07596466 * (10 ** (-8))) * tdb * tdb * tdb * v * v * delta_t_tr
+        + (8.49242932 * (10 ** (-5))) * v * v * v * delta_t_tr
+        + (1.35191328 * (10 ** (-6))) * tdb * v * v * v * delta_t_tr
+        + (-6.21531254 * (10 ** (-9))) * tdb * tdb * v * v * v * delta_t_tr
+        + (-4.99410301 * (10 ** (-6))) * v * v * v * v * delta_t_tr
+        + (-1.89489258 * (10 ** (-8))) * tdb * v * v * v * v * delta_t_tr
+        + (8.15300114 * (10 ** (-8))) * v * v * v * v * v * delta_t_tr
+        + (7.55043090 * (10 ** (-4))) * delta_t_tr * delta_t_tr
+        + (-5.65095215 * (10 ** (-5))) * tdb * delta_t_tr * delta_t_tr
+        + (-4.52166564 * (10 ** (-7))) * tdb * tdb * delta_t_tr * delta_t_tr
+        + (2.46688878 * (10 ** (-8))) * tdb * tdb * tdb * delta_t_tr * delta_t_tr
+        + (2.42674348 * (10 ** (-10))) * tdb * tdb * tdb * tdb * delta_t_tr * delta_t_tr
+        + (1.54547250 * (10 ** (-4))) * v * delta_t_tr * delta_t_tr
+        + (5.24110970 * (10 ** (-6))) * tdb * v * delta_t_tr * delta_t_tr
+        + (-8.75874982 * (10 ** (-8))) * tdb * tdb * v * delta_t_tr * delta_t_tr
+        + (-1.50743064 * (10 ** (-9))) * tdb * tdb * tdb * v * delta_t_tr * delta_t_tr
+        + (-1.56236307 * (10 ** (-5))) * v * v * delta_t_tr * delta_t_tr
+        + (-1.33895614 * (10 ** (-7))) * tdb * v * v * delta_t_tr * delta_t_tr
+        + (2.49709824 * (10 ** (-9))) * tdb * tdb * v * v * delta_t_tr * delta_t_tr
+        + (6.51711721 * (10 ** (-7))) * v * v * v * delta_t_tr * delta_t_tr
+        + (1.94960053 * (10 ** (-9))) * tdb * v * v * v * delta_t_tr * delta_t_tr
+        + (-1.00361113 * (10 ** (-8))) * v * v * v * v * delta_t_tr * delta_t_tr
+        + (-1.21206673 * (10 ** (-5))) * delta_t_tr * delta_t_tr * delta_t_tr
+        + (-2.18203660 * (10 ** (-7))) * tdb * delta_t_tr * delta_t_tr * delta_t_tr
+        + (7.51269482 * (10 ** (-9))) * tdb * tdb * delta_t_tr * delta_t_tr * delta_t_tr
+        + (9.79063848 * (10 ** (-11))) * tdb * tdb * tdb * delta_t_tr * delta_t_tr * delta_t_tr
+        + (1.25006734 * (10 ** (-6))) * v * delta_t_tr * delta_t_tr * delta_t_tr
+        + (-1.81584736 * (10 ** (-9))) * tdb * v * delta_t_tr * delta_t_tr * delta_t_tr
+        + (-3.52197671 * (10 ** (-10))) * tdb * tdb * v * delta_t_tr * delta_t_tr * delta_t_tr
+        + (-3.36514630 * (10 ** (-8))) * v * v * delta_t_tr * delta_t_tr * delta_t_tr
+        + (1.35908359 * (10 ** (-10))) * tdb * v * v * delta_t_tr * delta_t_tr * delta_t_tr
+        + (4.17032620 * (10 ** (-10))) * v * v * v * delta_t_tr * delta_t_tr * delta_t_tr
+        + (-1.30369025 * (10 ** (-9))) * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr
+        + (4.13908461 * (10 ** (-10))) * tdb * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr
+        + (9.22652254 * (10 ** (-12)))
+        * tdb
+        * tdb
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        + (-5.08220384 * (10 ** (-9))) * v * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr
+        + (-2.24730961 * (10 ** (-11)))
+        * tdb
+        * v
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        + (1.17139133 * (10 ** (-10))) * v * v * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr
+        + (6.62154879 * (10 ** (-10)))
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        + (4.03863260 * (10 ** (-13)))
+        * tdb
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        + (1.95087203 * (10 ** (-12)))
+        * v
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        + (-4.73602469 * (10 ** (-12)))
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        + 5.12733497 * pa
+        + (-0.312788561) * tdb * pa
+        + (-0.0196701861) * tdb * tdb * pa
+        + (9.99690870 * (10 ** (-4))) * tdb * tdb * tdb * pa
+        + (9.51738512 * (10 ** (-6))) * tdb * tdb * tdb * tdb * pa
+        + (-4.66426341 * (10 ** (-7))) * tdb * tdb * tdb * tdb * tdb * pa
+        + 0.548050612 * v * pa
+        + (-0.00330552823) * tdb * v * pa
+        + (-0.00164119440) * tdb * tdb * v * pa
+        + (-5.16670694 * (10 ** (-6))) * tdb * tdb * tdb * v * pa
+        + (9.52692432 * (10 ** (-7))) * tdb * tdb * tdb * tdb * v * pa
+        + (-0.0429223622) * v * v * pa
+        + 0.00500845667 * tdb * v * v * pa
+        + (1.00601257 * (10 ** (-6))) * tdb * tdb * v * v * pa
+        + (-1.81748644 * (10 ** (-6))) * tdb * tdb * tdb * v * v * pa
+        + (-1.25813502 * (10 ** (-3))) * v * v * v * pa
+        + (-1.79330391 * (10 ** (-4))) * tdb * v * v * v * pa
+        + (2.34994441 * (10 ** (-6))) * tdb * tdb * v * v * v * pa
+        + (1.29735808 * (10 ** (-4))) * v * v * v * v * pa
+        + (1.29064870 * (10 ** (-6))) * tdb * v * v * v * v * pa
+        + (-2.28558686 * (10 ** (-6))) * v * v * v * v * v * pa
+        + (-0.0369476348) * delta_t_tr * pa
+        + 0.00162325322 * tdb * delta_t_tr * pa
+        + (-3.14279680 * (10 ** (-5))) * tdb * tdb * delta_t_tr * pa
+        + (2.59835559 * (10 ** (-6))) * tdb * tdb * tdb * delta_t_tr * pa
+        + (-4.77136523 * (10 ** (-8))) * tdb * tdb * tdb * tdb * delta_t_tr * pa
+        + (8.64203390 * (10 ** (-3))) * v * delta_t_tr * pa
+        + (-6.87405181 * (10 ** (-4))) * tdb * v * delta_t_tr * pa
+        + (-9.13863872 * (10 ** (-6))) * tdb * tdb * v * delta_t_tr * pa
+        + (5.15916806 * (10 ** (-7))) * tdb * tdb * tdb * v * delta_t_tr * pa
+        + (-3.59217476 * (10 ** (-5))) * v * v * delta_t_tr * pa
+        + (3.28696511 * (10 ** (-5))) * tdb * v * v * delta_t_tr * pa
+        + (-7.10542454 * (10 ** (-7))) * tdb * tdb * v * v * delta_t_tr * pa
+        + (-1.24382300 * (10 ** (-5))) * v * v * v * delta_t_tr * pa
+        + (-7.38584400 * (10 ** (-9))) * tdb * v * v * v * delta_t_tr * pa
+        + (2.20609296 * (10 ** (-7))) * v * v * v * v * delta_t_tr * pa
+        + (-7.32469180 * (10 ** (-4))) * delta_t_tr * delta_t_tr * pa
+        + (-1.87381964 * (10 ** (-5))) * tdb * delta_t_tr * delta_t_tr * pa
+        + (4.80925239 * (10 ** (-6))) * tdb * tdb * delta_t_tr * delta_t_tr * pa
+        + (-8.75492040 * (10 ** (-8))) * tdb * tdb * tdb * delta_t_tr * delta_t_tr * pa
+        + (2.77862930 * (10 ** (-5))) * v * delta_t_tr * delta_t_tr * pa
+        + (-5.06004592 * (10 ** (-6))) * tdb * v * delta_t_tr * delta_t_tr * pa
+        + (1.14325367 * (10 ** (-7))) * tdb * tdb * v * delta_t_tr * delta_t_tr * pa
+        + (2.53016723 * (10 ** (-6))) * v * v * delta_t_tr * delta_t_tr * pa
+        + (-1.72857035 * (10 ** (-8))) * tdb * v * v * delta_t_tr * delta_t_tr * pa
+        + (-3.95079398 * (10 ** (-8))) * v * v * v * delta_t_tr * delta_t_tr * pa
+        + (-3.59413173 * (10 ** (-7))) * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (7.04388046 * (10 ** (-7))) * tdb * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (-1.89309167 * (10 ** (-8))) * tdb * tdb * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (-4.79768731 * (10 ** (-7))) * v * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (7.96079978 * (10 ** (-9))) * tdb * v * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (1.62897058 * (10 ** (-9))) * v * v * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (3.94367674 * (10 ** (-8))) * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (-1.18566247 * (10 ** (-9)))
+        * tdb
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * pa
+        + (3.34678041 * (10 ** (-10))) * v * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr * pa
+        + (-1.15606447 * (10 ** (-10)))
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * delta_t_tr
+        * pa
+        + (-2.80626406) * pa * pa
+        + 0.548712484 * tdb * pa * pa
+        + (-0.00399428410) * tdb * tdb * pa * pa
+        + (-9.54009191 * (10 ** (-4))) * tdb * tdb * tdb * pa * pa
+        + (1.93090978 * (10 ** (-5))) * tdb * tdb * tdb * tdb * pa * pa
+        + (-0.308806365) * v * pa * pa
+        + 0.0116952364 * tdb * v * pa * pa
+        + (4.95271903 * (10 ** (-4))) * tdb * tdb * v * pa * pa
+        + (-1.90710882 * (10 ** (-5))) * tdb * tdb * tdb * v * pa * pa
+        + 0.00210787756 * v * v * pa * pa
+        + (-6.98445738 * (10 ** (-4))) * tdb * v * v * pa * pa
+        + (2.30109073 * (10 ** (-5))) * tdb * tdb * v * v * pa * pa
+        + (4.17856590 * (10 ** (-4))) * v * v * v * pa * pa
+        + (-1.27043871 * (10 ** (-5))) * tdb * v * v * v * pa * pa
+        + (-3.04620472 * (10 ** (-6))) * v * v * v * v * pa * pa
+        + 0.0514507424 * delta_t_tr * pa * pa
+        + (-0.00432510997) * tdb * delta_t_tr * pa * pa
+        + (8.99281156 * (10 ** (-5))) * tdb * tdb * delta_t_tr * pa * pa
+        + (-7.14663943 * (10 ** (-7))) * tdb * tdb * tdb * delta_t_tr * pa * pa
+        + (-2.66016305 * (10 ** (-4))) * v * delta_t_tr * pa * pa
+        + (2.63789586 * (10 ** (-4))) * tdb * v * delta_t_tr * pa * pa
+        + (-7.01199003 * (10 ** (-6))) * tdb * tdb * v * delta_t_tr * pa * pa
+        + (-1.06823306 * (10 ** (-4))) * v * v * delta_t_tr * pa * pa
+        + (3.61341136 * (10 ** (-6))) * tdb * v * v * delta_t_tr * pa * pa
+        + (2.29748967 * (10 ** (-7))) * v * v * v * delta_t_tr * pa * pa
+        + (3.04788893 * (10 ** (-4))) * delta_t_tr * delta_t_tr * pa * pa
+        + (-6.42070836 * (10 ** (-5))) * tdb * delta_t_tr * delta_t_tr * pa * pa
+        + (1.16257971 * (10 ** (-6))) * tdb * tdb * delta_t_tr * delta_t_tr * pa * pa
+        + (7.68023384 * (10 ** (-6))) * v * delta_t_tr * delta_t_tr * pa * pa
+        + (-5.47446896 * (10 ** (-7))) * tdb * v * delta_t_tr * delta_t_tr * pa * pa
+        + (-3.59937910 * (10 ** (-8))) * v * v * delta_t_tr * delta_t_tr * pa * pa
+        + (-4.36497725 * (10 ** (-6))) * delta_t_tr * delta_t_tr * delta_t_tr * pa * pa
+        + (1.68737969 * (10 ** (-7))) * tdb * delta_t_tr * delta_t_tr * delta_t_tr * pa * pa
+        + (2.67489271 * (10 ** (-8))) * v * delta_t_tr * delta_t_tr * delta_t_tr * pa * pa
+        + (3.23926897 * (10 ** (-9))) * delta_t_tr * delta_t_tr * delta_t_tr * delta_t_tr * pa * pa
+        + (-0.0353874123) * pa * pa * pa
+        + (-0.221201190) * tdb * pa * pa * pa
+        + 0.0155126038 * tdb * tdb * pa * pa * pa
+        + (-2.63917279 * (10 ** (-4))) * tdb * tdb * tdb * pa * pa * pa
+        + 0.0453433455 * v * pa * pa * pa
+        + (-0.00432943862) * tdb * v * pa * pa * pa
+        + (1.45389826 * (10 ** (-4))) * tdb * tdb * v * pa * pa * pa
+        + (2.17508610 * (10 ** (-4))) * v * v * pa * pa * pa
+        + (-6.66724702 * (10 ** (-5))) * tdb * v * v * pa * pa * pa
+        + (3.33217140 * (10 ** (-5))) * v * v * v * pa * pa * pa
+        + (-0.00226921615) * delta_t_tr * pa * pa * pa
+        + (3.80261982 * (10 ** (-4))) * tdb * delta_t_tr * pa * pa * pa
+        + (-5.45314314 * (10 ** (-9))) * tdb * tdb * delta_t_tr * pa * pa * pa
+        + (-7.96355448 * (10 ** (-4))) * v * delta_t_tr * pa * pa * pa
+        + (2.53458034 * (10 ** (-5))) * tdb * v * delta_t_tr * pa * pa * pa
+        + (-6.31223658 * (10 ** (-6))) * v * v * delta_t_tr * pa * pa * pa
+        + (3.02122035 * (10 ** (-4))) * delta_t_tr * delta_t_tr * pa * pa * pa
+        + (-4.77403547 * (10 ** (-6))) * tdb * delta_t_tr * delta_t_tr * pa * pa * pa
+        + (1.73825715 * (10 ** (-6))) * v * delta_t_tr * delta_t_tr * pa * pa * pa
+        + (-4.09087898 * (10 ** (-7))) * delta_t_tr * delta_t_tr * delta_t_tr * pa * pa * pa
+        + 0.614155345 * pa * pa * pa * pa
+        + (-0.0616755931) * tdb * pa * pa * pa * pa
+        + 0.00133374846 * tdb * tdb * pa * pa * pa * pa
+        + 0.00355375387 * v * pa * pa * pa * pa
+        + (-5.13027851 * (10 ** (-4))) * tdb * v * pa * pa * pa * pa
+        + (1.02449757 * (10 ** (-4))) * v * v * pa * pa * pa * pa
+        + (-0.00148526421) * delta_t_tr * pa * pa * pa * pa
+        + (-4.11469183 * (10 ** (-5))) * tdb * delta_t_tr * pa * pa * pa * pa
+        + (-6.80434415 * (10 ** (-6))) * v * delta_t_tr * pa * pa * pa * pa
+        + (-9.77675906 * (10 ** (-6))) * delta_t_tr * delta_t_tr * pa * pa * pa * pa
+        + 0.0882773108 * pa * pa * pa * pa * pa
+        + (-0.00301859306) * tdb * pa * pa * pa * pa * pa
+        + 0.00104452989 * v * pa * pa * pa * pa * pa
+        + (2.47090539 * (10 ** (-4))) * delta_t_tr * pa * pa * pa * pa * pa
+        + 0.00148348065 * pa * pa * pa * pa * pa * pa
+    )
+    if limit:
+        bad = (
+            (tdb < -50) | (tdb > 50) | (delta_t_tr < -30) | (delta_t_tr > 70) | (v < 0.5) | (v > 17)
+        )
+        out = np.where(bad, np.nan, out)
+    return float(out) if np.ndim(out) == 0 else out
+
+
+UTCI_CATEGORIES: list[dict[str, Any]] = [
+    {"max": -40, "label": "Extreme cold stress", "color": "#08306b"},
+    {"max": -27, "label": "Very strong cold stress", "color": "#08519c"},
+    {"max": -13, "label": "Strong cold stress", "color": "#2171b5"},
+    {"max": 0, "label": "Moderate cold stress", "color": "#6baed6"},
+    {"max": 9, "label": "Slight cold stress", "color": "#c6dbef"},
+    {"max": 26, "label": "No thermal stress", "color": "#a1d99b"},
+    {"max": 32, "label": "Moderate heat stress", "color": "#fdd0a2"},
+    {"max": 38, "label": "Strong heat stress", "color": "#fd8d3c"},
+    {"max": 46, "label": "Very strong heat stress", "color": "#d94801"},
+    {"max": math.inf, "label": "Extreme heat stress", "color": "#7f2704"},
+]
+
+
+def _finite(x: Any) -> bool:
+    try:
+        return x is not None and math.isfinite(float(x))
+    except (TypeError, ValueError):
+        return False
+
+
+def _category(table: list[dict[str, Any]], value: Any) -> Optional[dict[str, Any]]:
+    if not _finite(value):
+        return None
+    x = float(value)
+    for c in table:
+        if x < c["max"]:
+            return c
+    return table[-1]
+
+
+def utci_category(value: Optional[float]) -> Optional[dict[str, Any]]:
+    """UTCI heat/cold stress class (``{"max", "label", "color"}``), None if not finite."""
+    return _category(UTCI_CATEGORIES, value)
+
+
+def projected_area_factor(elevation_deg: float) -> float:
+    """Projected area factor of a standing person for a sun elevation in degrees.
+
+    Underwood and Ward (1966), as used by SOLWEIG: projected area over the
+    effective radiating area.
+    """
+    b = max(0.0, min(90.0, float(elevation_deg)))
+    return 0.308 * math.cos(math.radians(b * (0.998 - (b * b) / 50000)))
+
+
+def sky_temperature(air_temp: float, horizontal_ir: Optional[float] = None) -> float:
+    """Sky temperature (C) from EPW horizontal infrared, or Swinbank (1963) when missing."""
+    if _finite(horizontal_ir) and float(horizontal_ir) > 50:  # type: ignore[arg-type]
+        return float((float(horizontal_ir) / SIGMA) ** 0.25 - 273.15)  # type: ignore[arg-type]
+    ta = float(air_temp) + 273.15
+    return 0.0552 * ta**1.5 - 273.15
+
+
+def mean_radiant_temperature(
+    air_temp: float,
+    sky_temp: float,
+    svf: float,
+    sunlit: float,
+    dni: float,
+    dhi: float,
+    ghi: float,
+    elevation_deg: float,
+    albedo: float = 0.2,
+    absorptivity: float = 0.7,
+    ground_temp: Optional[float] = None,
+    wall_temp: Optional[float] = None,
+) -> float:
+    """Mean radiant temperature of a standing person outdoors, C.
+
+    Args:
+        air_temp: air temperature, C.
+        sky_temp: effective sky temperature, C (see :func:`sky_temperature`).
+        svf: sky view factor of the spot (0..1).
+        sunlit: 1 if the person is in the sun (a fraction is allowed).
+        dni: direct normal irradiance, W/m2.
+        dhi: diffuse horizontal irradiance, W/m2.
+        ghi: global horizontal irradiance, W/m2.
+        elevation_deg: sun elevation, degrees.
+        albedo: ground reflectance.
+        absorptivity: clothing/skin short-wave absorptivity.
+        ground_temp: ground surface temperature, C (None/NaN = air temperature).
+        wall_temp: surrounding wall temperature, C (None/NaN = air temperature).
+    """
+    f_eff = 0.725  # standing person
+    hr = 6.012  # W/m2K
+    emissivity = 0.95  # long-wave absorptivity
+    s = max(0.0, min(1.0, float(svf)))
+    t_sky = sky_temp + 273.15
+    t_air = air_temp + 273.15
+
+    if not _finite(ground_temp) and not _finite(wall_temp):
+        f_sky = 0.5 * s
+        t_lw = (f_sky * t_sky**4 + (1 - f_sky) * t_air**4) ** 0.25 - 273.15
+    else:
+        # Upper hemisphere (weight 0.5): svf sky at t_sky and (1 - svf) walls.
+        # Lower hemisphere (weight 0.5): ground.
+        t_wall = (float(wall_temp) if _finite(wall_temp) else air_temp) + 273.15  # type: ignore[arg-type]
+        t_gnd = (float(ground_temp) if _finite(ground_temp) else air_temp) + 273.15  # type: ignore[arg-type]
+        t_lw = (0.5 * s * t_sky**4 + 0.5 * (1 - s) * t_wall**4 + 0.5 * t_gnd**4) ** 0.25 - 273.15
+
+    if not (elevation_deg > 0) or not (ghi > 0):
+        return float(t_lw)
+    f_bes = max(0.0, min(1.0, float(sunlit)))
+    ap_over_ad = projected_area_factor(elevation_deg) * f_eff
+    e_diff = 0.5 * f_eff * s * (dhi + ghi * albedo)
+    e_dir = ap_over_ad * f_bes * dni
+    erf = (e_diff + e_dir) * (absorptivity / emissivity)
+    return float(t_lw + erf / (f_eff * hr))
+
+
+PET_CATEGORIES: list[dict[str, Any]] = [
+    {"max": 4, "label": "Extreme cold stress", "color": "#08306b"},
+    {"max": 8, "label": "Strong cold stress", "color": "#2171b5"},
+    {"max": 13, "label": "Moderate cold stress", "color": "#6baed6"},
+    {"max": 18, "label": "Slight cold stress", "color": "#c6dbef"},
+    {"max": 23, "label": "Comfortable", "color": "#a1d99b"},
+    {"max": 29, "label": "Slight heat stress", "color": "#fdd0a2"},
+    {"max": 35, "label": "Moderate heat stress", "color": "#fd8d3c"},
+    {"max": 41, "label": "Strong heat stress", "color": "#d94801"},
+    {"max": math.inf, "label": "Extreme heat stress", "color": "#7f2704"},
+]
+
+
+def pet_category(value: Optional[float]) -> Optional[dict[str, Any]]:
+    """PET thermal stress class (Matzarakis scale), None if not finite."""
+    return _category(PET_CATEGORIES, value)
+
+
+def _solve3(a: list[list[float]], f: list[float]) -> Optional[tuple[float, float, float]]:
+    """Newton step ``-J^-1 f`` for a 3x3 system by Cramer's rule (None if singular)."""
+    det = (
+        a[0][0] * (a[1][1] * a[2][2] - a[1][2] * a[2][1])
+        - a[0][1] * (a[1][0] * a[2][2] - a[1][2] * a[2][0])
+        + a[0][2] * (a[1][0] * a[2][1] - a[1][1] * a[2][0])
+    )
+    if abs(det) < 1e-12:
+        return None
+    d0 = (
+        -f[0] * (a[1][1] * a[2][2] - a[1][2] * a[2][1])
+        + f[1] * (a[0][1] * a[2][2] - a[0][2] * a[2][1])
+        - f[2] * (a[0][1] * a[1][2] - a[0][2] * a[1][1])
+    ) / det
+    d1 = (
+        f[0] * (a[1][0] * a[2][2] - a[1][2] * a[2][0])
+        - f[1] * (a[0][0] * a[2][2] - a[0][2] * a[2][0])
+        + f[2] * (a[0][0] * a[1][2] - a[0][2] * a[1][0])
+    ) / det
+    d2 = (
+        -f[0] * (a[1][0] * a[2][1] - a[1][1] * a[2][0])
+        + f[1] * (a[0][0] * a[2][1] - a[0][1] * a[2][0])
+        - f[2] * (a[0][0] * a[1][1] - a[0][1] * a[1][0])
+    ) / det
+    return d0, d1, d2
+
+
+def _facl(clo: float) -> float:
+    return max(0.0, min(1.0, (173.51 * clo - 2.36 - 100.76 * clo * clo + 19.28 * clo**3) / 100))
+
+
+def pet(
+    tdb: float,
+    tr: float,
+    v: Optional[float],
+    rh: Optional[float],
+    met: float = 80.0,
+    clo: float = 0.9,
+) -> float:
+    """Physiological Equivalent Temperature (PET), degrees C.
+
+    Args:
+        tdb: dry-bulb air temperature, C.
+        tr: mean radiant temperature, C.
+        v: wind speed, m/s (None/NaN -> 0.5; clamped to 0.1..20).
+        rh: relative humidity, % (None/NaN -> 50).
+        met: activity in W added to basal metabolism (default 80).
+        clo: clothing insulation (default 0.9).
+
+    Returns NaN when ``tdb`` or ``tr`` is not finite.
+    """
+    if not _finite(tdb) or not _finite(tr):
+        return math.nan
+    va = max(0.1, min(20.0, float(v) if _finite(v) else 0.5))  # type: ignore[arg-type]
+    rh_c = max(0.0, min(100.0, float(rh) if _finite(rh) else 50.0))  # type: ignore[arg-type]
+    ta = float(tdb)
+    tmrt = float(tr)
+    vpa = float(saturation_vapour_pressure(ta)) * (rh_c / 100)
+
+    age = 35
+    ht = 1.8
+    mbody = 75.0
+    p = 1013.25
+    cb = 3640.0
+    cair = 1010.0
+    emsk = 0.99
+    emcl = 0.95
+    lvap = 2.42e6
+    sigm = 5.67e-8
+    eta = 0.0
+    tc_set = 36.6
+    tsk_set = 34.0
+    tbody_set = 0.1 * tsk_set + 0.9 * tc_set
+
+    adu = 0.203 * mbody**0.425 * ht**0.725
+    feff = 0.725
+    fcl = 1.0 + 0.31 * clo
+    facl = _facl(clo)
+    aclo = adu * facl + adu * (fcl - 1.0)
+    aeffr = adu * feff
+
+    hc = 2.67 + 6.5 * va**0.67
+    metab_male = (
+        3.45
+        * mbody**0.75
+        * (1.0 + 0.004 * (30.0 - age) + 0.01 * (ht * 100.0 / mbody ** (1.0 / 3.0) - 43.4))
+    )
+    he = (met + metab_male) / adu
+    h = he * (1.0 - eta)
+
+    texp = 0.47 * ta + 21.0
+    dventpulm = he * 1.44e-6
+    eres = cair * (ta - texp) * dventpulm
+    vpexp = 6.11 * 10.0 ** (7.45 * texp / (235.0 + texp))
+    erel = 0.623 * (lvap / p) * (vpa - vpexp) * dventpulm
+    ere = eres + erel
+
+    rcl = clo / 6.45 if clo > 0.01 else 0.001
+    y = (ht - 0.2) / ht
+    r2 = adu * (fcl - 1.0 + facl) / (6.28 * ht * y)
+    r1 = facl * adu / (6.28 * ht * y)
+    di = r2 - r1
+    htcl = (6.28 * ht * y * di) / (rcl * math.log(r2 / r1) * aclo) if clo > 0.01 else 1e5
+
+    lw = 1.67
+    he_diff = hc * lw
+    fecl = 1.0 / (1.0 + 0.92 * hc * rcl)
+    r_ecl = (1.0 / (fcl * hc) + rcl) / (lw * 0.38)
+
+    def syst3(t: list[float]) -> list[float]:
+        tcr, tsk, tcl = t
+        sig_skin = max(0.0, tsk_set - tsk)
+        sig_core = max(0.0, tcr - tc_set)
+        qmblood = min(90.0, (6.3 + 75.0 * sig_core) / (1.0 + 0.5 * sig_skin))
+        alpha = 0.1
+        tbody = alpha * tsk + (1.0 - alpha) * tcr
+        sig_body = max(0.0, tbody - tbody_set)
+        qmsw = min(500.0, 304.94e-3 * sig_body * 1000.0)
+        esw = (lvap / 1000.0) * (qmsw / 3600.0)
+        pvsk = 6.105 * math.exp((17.27 * (tsk + 273.15) - 4717.03) / (237.7 + tsk))
+        emax = he_diff * fecl * (pvsk - vpa)
+        w = min(1.0, max(0.0, esw / emax)) if emax > 0 else 1.0
+        ediff = (1.0 - w) * (pvsk - vpa) / r_ecl
+        evap = -(ediff + esw)
+        t_mrt4 = (tmrt + 273.15) ** 4
+        rbare = aeffr * (1.0 - facl) * emsk * sigm * (t_mrt4 - (tsk + 273.15) ** 4) / adu
+        rclo = feff * aclo * emcl * sigm * (t_mrt4 - (tcl + 273.15) ** 4) / adu
+        cbare = hc * (ta - tsk) * (1.0 - facl)
+        cclo = hc * (ta - tcl) * aclo / adu
+        kcs = (qmblood / 3600.0) * cb + 5.28
+        return [
+            h + ere - kcs * (tcr - tsk),
+            rbare + cbare + evap + kcs * (tcr - tsk) - htcl * (tsk - tcl),
+            cclo + rclo + htcl * (tsk - tcl),
+        ]
+
+    # Damped Newton-Raphson on the three-node heat balance.
+    t = [37.0, 34.0, (ta + tmrt) / 2.0]
+    for _ in range(40):
+        f = syst3(t)
+        if max(abs(f[0]), abs(f[1]), abs(f[2])) < 1e-4:
+            break
+        jac = [[0.0] * 3 for _ in range(3)]
+        eps = 1e-5
+        for j in range(3):
+            tp = list(t)
+            tp[j] += eps
+            fp = syst3(tp)
+            for i in range(3):
+                jac[i][j] = (fp[i] - f[i]) / eps
+        step = _solve3(jac, f)
+        if step is None:
+            break
+        d0, d1, d2 = step
+        damping = min(1.0, 5.0 / (abs(d0) + abs(d1) + abs(d2) + 1e-6))
+        t[0] += damping * d0
+        t[1] += damping * d1
+        t[2] += damping * d2
+
+    # Indoor reference state: v = 0.1 m/s, rh = 50 % (vpa = 12 hPa), clo = 0.9, met = 80 W.
+    tcr, tsk, tcl = t
+    ref_icl = 0.9
+    ref_fcl = 1.0 + 0.31 * ref_icl
+    ref_facl = _facl(ref_icl)
+    ref_aclo = adu * ref_facl + adu * (ref_fcl - 1.0)
+    ref_rcl = ref_icl / 6.45
+    ref_hc = 2.67 + 6.5 * 0.1**0.67
+    ref_he_diff = ref_hc * lw
+    ref_fecl = 1.0 / (1.0 + 0.92 * ref_hc * ref_rcl)
+    ref_r_ecl = (1.0 / (ref_fcl * ref_hc) + ref_rcl) / (lw * 0.38)
+    ref_vpa = 12.0
+
+    tbody = 0.1 * tsk + 0.9 * tcr
+    sig_body = max(0.0, tbody - tbody_set)
+    qmsw = min(500.0, 304.94e-3 * sig_body * 1000.0)
+    esw = (lvap / 1000.0) * (qmsw / 3600.0)
+    pvsk = 6.105 * math.exp((17.27 * (tsk + 273.15) - 4717.03) / (237.7 + tsk))
+    emax = ref_he_diff * ref_fecl * (pvsk - ref_vpa)
+    w = min(1.0, max(0.0, esw / emax)) if emax > 0 else 1.0
+    ediff = (1.0 - w) * (pvsk - ref_vpa) / ref_r_ecl
+    evap = -(ediff + esw)
+
+    def eval_ref(tx: float) -> float:
+        texp_ref = 0.47 * tx + 21.0
+        eres_ref = cair * (tx - texp_ref) * dventpulm
+        vpexp_ref = 6.11 * 10.0 ** (7.45 * texp_ref / (235.0 + texp_ref))
+        erel_ref = 0.623 * (lvap / p) * (ref_vpa - vpexp_ref) * dventpulm
+        ere_ref = eres_ref + erel_ref
+        tx4 = (tx + 273.15) ** 4
+        rbare_ref = aeffr * (1.0 - ref_facl) * emsk * sigm * (tx4 - (tsk + 273.15) ** 4) / adu
+        rclo_ref = feff * ref_aclo * emcl * sigm * (tx4 - (tcl + 273.15) ** 4) / adu
+        cbare_ref = ref_hc * (tx - tsk) * (1.0 - ref_facl)
+        cclo_ref = ref_hc * (tx - tcl) * ref_aclo / adu
+        return h + ere_ref + rbare_ref + rclo_ref + cbare_ref + cclo_ref + evap
+
+    lo, hi = -50.0, 70.0
+    for _ in range(40):
+        mid = (lo + hi) / 2.0
+        if eval_ref(mid) < 0:
+            lo = mid
+        else:
+            hi = mid
+    return (lo + hi) / 2.0