nomogram 0.1.1__tar.gz → 0.2.0__tar.gz

{nomogram-0.1.1 → nomogram-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nomogram
-Version: 0.1.1
+Version: 0.2.0
 Summary: Repository of scientific formulas: notations, units, validity domains
 Keywords: scientific computing,formulas,units,dimensional analysis,physics,thermodynamics,geoscience,atmospheric science,meteorology,hydrology,psychrometrics
 Author: miki4ia
@@ -41,6 +41,7 @@ Description-Content-Type: text/markdown
 [![codecov](https://codecov.io/gh/miki4iaml/nomogram/graph/badge.svg?branch=develop)](https://codecov.io/gh/miki4iaml/nomogram)
 [![Python](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fmiki4iaml%2Fnomogram%2Fdevelop%2Fpyproject.toml)](pyproject.toml)
 [![License](https://img.shields.io/github/license/miki4iaml/nomogram)](LICENSE)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23373134.svg)](https://doi.org/10.5281/zenodo.23373134)
 [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
@@ -111,7 +112,9 @@ ha.evaluate(RH=Q_(100, "percent"), T=Q_(20, "degC")).to("g/m^3")  # 17.29
 ```
 
 Each formulation keeps its units, validity domain, temperature scale and
-references. The vocabulary is mapped in [docs/rosetta.md](docs/rosetta.md).
+references. The vocabulary is mapped in [docs/rosetta.md](docs/rosetta.md);
+[How nomogram earns trust](docs/approach.md) explains what is checked and
+how.
 
 ## Contributing
 

{nomogram-0.1.1 → nomogram-0.2.0}/README.md

@@ -7,6 +7,7 @@
 [![codecov](https://codecov.io/gh/miki4iaml/nomogram/graph/badge.svg?branch=develop)](https://codecov.io/gh/miki4iaml/nomogram)
 [![Python](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fmiki4iaml%2Fnomogram%2Fdevelop%2Fpyproject.toml)](pyproject.toml)
 [![License](https://img.shields.io/github/license/miki4iaml/nomogram)](LICENSE)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23373134.svg)](https://doi.org/10.5281/zenodo.23373134)
 [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
@@ -77,7 +78,9 @@ ha.evaluate(RH=Q_(100, "percent"), T=Q_(20, "degC")).to("g/m^3")  # 17.29
 ```
 
 Each formulation keeps its units, validity domain, temperature scale and
-references. The vocabulary is mapped in [docs/rosetta.md](docs/rosetta.md).
+references. The vocabulary is mapped in [docs/rosetta.md](docs/rosetta.md);
+[How nomogram earns trust](docs/approach.md) explains what is checked and
+how.
 
 ## Contributing
 

{nomogram-0.1.1 → nomogram-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nomogram"
-version = "0.1.1"
+version = "0.2.0"
 description = "Repository of scientific formulas: notations, units, validity domains"
 readme = "README.md"
 requires-python = ">=3.12"

{nomogram-0.1.1 → nomogram-0.2.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "nomogram"
-version = "0.1.1"
+version = "0.2.0"
 description = "Repository of scientific formulas: notations, units, validity domains"
 readme = "README.md"
 authors = [

{nomogram-0.1.1 → nomogram-0.2.0}/src/nomogram/__init__.py

@@ -6,8 +6,8 @@
 Submodules are imported on demand, so that ``import nomogram`` stays
 light: :mod:`nomogram.units` (pint), :mod:`nomogram.expression`
 (SymPy), :mod:`nomogram.semantics` (bundled QUDT and CF subsets),
-:mod:`nomogram.model` and :mod:`nomogram.catalog` (formulations), and
-:mod:`nomogram.comparison`.
+:mod:`nomogram.model` and :mod:`nomogram.catalog` (formulations),
+:mod:`nomogram.comparison`, :mod:`nomogram.inversion` and :mod:`nomogram.plot`.
 """
 
 from importlib.metadata import version

{nomogram-0.1.1 → nomogram-0.2.0}/src/nomogram/catalog.py

@@ -67,7 +67,9 @@ _SECTIONS = (
 )
 
 #: Kinds that may carry a temperature scale, and the units allowed for them.
-_SCALED_KINDS = frozenset({"ThermodynamicTemperature", "CelsiusTemperature"})
+_SCALED_KINDS = frozenset(
+    {"ThermodynamicTemperature", "CelsiusTemperature", "DewPointTemperature"}
+)
 _SCALED_UNITS = frozenset({"K", "DEG_C"})
 
 

{nomogram-0.1.1 → nomogram-0.2.0}/src/nomogram/comparison.py

@@ -30,7 +30,7 @@ import numpy as np
 
 from nomogram.model import Basis, Outside, ScaleConversion, Variable
 
-__all__ = ["Comparison", "Composition", "Evaluable", "compare", "compose"]
+__all__ = ["Comparison", "Composition", "Evaluable", "compare", "compose", "feeds"]
 
 #: Kinds that express the same temperature state (SI Brochure 2.3.1).
 TEMPERATURE_POINTS = frozenset({"ThermodynamicTemperature", "CelsiusTemperature"})
@@ -63,6 +63,27 @@ def same_state(kind_a: str, kind_b: str) -> bool:
     return kind_a == kind_b or {kind_a, kind_b} <= TEMPERATURE_POINTS
 
 
+def feeds(output_kind: str, input_kind: str) -> bool:
+    """Whether a result of one kind may feed an input of another.
+
+    It may when the kinds are the same, or when the result's kind
+    specializes the input's (QUDT ``specializationOf``, directly or not):
+    a saturation vapour pressure is a vapour pressure. Never the other
+    way round.
+    """
+    from nomogram.catalog import catalog
+
+    kinds = catalog().kinds
+    kind = kinds.get(output_kind)
+    seen = set()
+    while kind is not None and kind.name not in seen:
+        if kind.name == input_kind:
+            return True
+        seen.add(kind.name)
+        kind = kinds.get(kind.specialization_of or "")
+    return output_kind == input_kind
+
+
 def _arguments(formulation: Evaluable, values: Mapping[str, Any]) -> dict[str, Any]:
     arguments = {}
     for variable in formulation.inputs:
@@ -263,7 +284,8 @@ def compose(
         The formulation evaluated last.
     inner : mapping of str to Formulation
         For some inputs of ``outer``, by identifier, the formulation that
-        computes them; its output kind must be the input's kind.
+        computes them; its output kind must be the input's kind or a
+        specialization of it (see :func:`feeds`).
     bind : mapping of str to str, optional
         Inputs of inner formulations to take from inputs of ``outer``, by
         identifier, for example ``{"t": "T"}``: the binding is declared,
@@ -286,7 +308,7 @@ def compose(
         if target is None:
             msg = f"{outer.key} has no input {identifier!r}"
             raise ValueError(msg)
-        if formulation.output.kind != target.kind:
+        if not feeds(formulation.output.kind, target.kind):
             msg = (
                 f"{formulation.key} computes {formulation.output.kind}, "
                 f"but {identifier} is {target.kind}"

{nomogram-0.1.1 → nomogram-0.2.0}/src/nomogram/data/catalog/humidity.toml

@@ -17,6 +17,15 @@ matches = [
   { target = "http://www.wikidata.org/entity/Q2387102", relation = "broad", verified = 2026-10-14 },
 ]
 
+[kinds.SaturationVapourPressureOverIce]
+label = "Saturation Vapour Pressure over Ice"
+specialization_of = "VapourPressure"
+description = "Pressure of water vapour in equilibrium with a plane surface of ice (ice Ih)."
+# The Wikidata item covers saturation over water and over ice: broader.
+matches = [
+  { target = "http://www.wikidata.org/entity/Q2387102", relation = "broad", verified = 2026-10-14 },
+]
+
 # --- References -----------------------------------------------------------
 
 [references.sonntag1990]
@@ -154,6 +163,61 @@ doi = "10.1088/0026-1394/27/1/002"
 status = "to-confirm"
 note = "Text and Table 6 (differences between ITS-90 and IPTS-68) read in a copy of the text, not in the journal; DOI not checked."
 
+[references.ecmwf_ifs_cy49r1]
+authors = "ECMWF"
+year = 2024
+title = "IFS Documentation CY49R1 - Part IV: Physical Processes"
+url = "https://www.ecmwf.int/en/elibrary/81626-ifs-documentation-cy49r1-part-iv-physical-processes"
+status = "verified"
+note = "Chapter 12, section 12.5 (p. 246): Md = 28.9644e-3 kg/mol, Mv = 18.0153e-3 kg/mol, Rd = 287.0597 and Rv = 461.5250 J/(kg K); their ratio Rd/Rv is 0.6219808."
+
+[references.metpy171]
+authors = "MetPy developers"
+year = 2025
+title = "MetPy 1.7.1, metpy.constants (src/metpy/constants/default.py)"
+url = "https://github.com/Unidata/MetPy/blob/v1.7.1/src/metpy/constants/default.py"
+status = "verified"
+note = "epsilon = Mw / Md, computed from Mw = 18.015268 g/mol and Md = 28.96546 g/mol (0.6219569); MetPy 0.12 used 18.01528 and 28.9644 g/mol. Released 2025-08-29."
+
+[references.iapws_r14_08]
+authors = "IAPWS"
+year = 2011
+title = "Revised Release on the Pressure along the Melting and Sublimation Curves of Ordinary Water Substance (R14-08(2011))"
+url = "https://iapws.org/technical-guidance/release/MeltSub"
+status = "verified"
+note = "Equation (6), coefficients, range (50 K to 273.16 K, ITS-90), uncertainty (Fig. 2, Eqs. 7a and 7b) and Table 3 read in the official release."
+
+[references.wagner2011]
+authors = "Wagner, W.; Riethmann, T.; Feistel, R.; Harvey, A. H."
+year = 2011
+title = "New equations for the sublimation pressure and melting pressure of H2O ice Ih"
+container = "Journal of Physical and Chemical Reference Data 40, 043103"
+status = "to-confirm"
+note = "Article behind IAPWS R14-08(2011), as cited by the release; not read."
+
+[references.wmo2008]
+authors = "World Meteorological Organization"
+year = 2008
+title = "Guide to Meteorological Instruments and Methods of Observation (WMO-No. 8), seventh edition"
+status = "to-confirm"
+note = "Cited by Vömel for the formulations over water and ice; not read."
+
+[references.marti_mauersberger1993]
+authors = "Marti, J.; Mauersberger, K."
+year = 1993
+title = "A survey and new measurements of ice vapor pressure at temperatures between 170 and 250 K"
+container = "Geophysical Research Letters 20, 363-366"
+status = "to-confirm"
+note = "Cited by Vömel; title and journal from memory, not checked."
+
+[references.murphy_koop2005]
+authors = "Murphy, D. M.; Koop, T."
+year = 2005
+title = "Review of the vapour pressures of ice and supercooled water for atmospheric applications"
+container = "Quarterly Journal of the Royal Meteorological Society 131, 1539-1565"
+status = "to-confirm"
+note = "Cited by Vömel; journal details from memory, not checked."
+
 [references.wmo2024]
 authors = "World Meteorological Organization"
 year = 2024
@@ -201,6 +265,30 @@ matches = [
   { target = "http://www.wikidata.org/entity/Q94372268", relation = "broad", verified = 2026-10-14 },
 ]
 
+[constants.epsilon_ashrae2017]
+identifier = "epsilon"
+value = 0.621945
+unit = "UNITLESS"
+description = "Ratio of the molar masses of water and dry air, M_w / M_d"
+reference = "ashrae2017"
+
+# Other values of the same ratio, read in their sources. The relative
+# spread (about 6e-5) is negligible against the deviations between
+# formulations, but the value used is part of a formulation.
+[constants.epsilon_ecmwf_ifs]
+identifier = "epsilon"
+value = 0.6219808
+unit = "UNITLESS"
+description = "Ratio of the molar masses of water and dry air, R_d / R_v of the ECMWF IFS"
+reference = "ecmwf_ifs_cy49r1"
+
+[constants.epsilon_metpy]
+identifier = "epsilon"
+value = 0.6219569
+unit = "UNITLESS"
+description = "Ratio of the molar masses of water and dry air, M_w / M_d of MetPy"
+reference = "metpy171"
+
 # --- Notations ------------------------------------------------------------
 
 [notations.wmo]
@@ -532,3 +620,188 @@ b5 = 0.42873e-3
 b6 = 4.76955
 b7 = 0.78614
 T_1 = { value = 273.16, unit = "K", note = "Triple point of water" }
+
+[formulations.vapour_pressure_from_relative_humidity]
+label = "Vapour pressure from relative humidity"
+expression = "RH * e_s"
+fixed_units = false
+note = "Relative humidity taken as e/e_s, its usual approximation in meteorology; definitions through mole fractions or mixing ratios differ slightly (source to read before stating which one a standard uses)."
+output = { identifier = "e", kind = "VapourPressure", unit = "PA", description = "Vapour pressure" }
+inputs = [
+  { identifier = "RH", kind = "RelativeHumidity", unit = "UNITLESS", description = "Relative humidity" },
+  { identifier = "e_s", kind = "SaturationVapourPressureOverWater", unit = "PA", description = "Saturation vapour pressure over water at the same temperature" },
+]
+
+[formulations.mixing_ratio_from_vapour_pressure]
+label = "Humidity mixing ratio from vapour pressure (ASHRAE 2017)"
+expression = "epsilon * e / (p - e)"
+fixed_units = false
+references = ["ashrae2017", "psychrolib"]
+note = "ASHRAE Handbook - Fundamentals (2017), chapter 1, equation 20, through PsychroLib: moist air as an ideal gas mixture."
+output = { identifier = "r", kind = "MassRatioOfWaterVapourToDryGas", unit = "KiloGM-PER-KiloGM", description = "Humidity mixing ratio" }
+inputs = [
+  { identifier = "e", kind = "VapourPressure", unit = "PA", description = "Vapour pressure" },
+  { identifier = "p", kind = "Pressure", unit = "PA", description = "Air pressure" },
+]
+constants = ["epsilon_ashrae2017"]
+
+[formulations.specific_humidity_from_mixing_ratio]
+label = "Specific humidity from mixing ratio"
+expression = "r / (1 + r)"
+fixed_units = false
+references = ["ashrae2017", "psychrolib"]
+note = "From the definitions (mass of water vapour per mass of moist air, per mass of dry air); ASHRAE Handbook - Fundamentals (2017), chapter 1, equation 9b, through PsychroLib."
+output = { identifier = "q", kind = "SpecificHumidity", unit = "KiloGM-PER-KiloGM", description = "Specific humidity" }
+inputs = [
+  { identifier = "r", kind = "MassRatioOfWaterVapourToDryGas", unit = "KiloGM-PER-KiloGM", description = "Humidity mixing ratio" },
+]
+
+# --- Saturation vapour pressure over ice -----------------------------------
+
+[formulations.iapws_r14_08_sublimation]
+label = "IAPWS R14-08(2011), sublimation pressure of ice Ih"
+expression = "p_t * exp((a1 * (T / T_t) ** b1 + a2 * (T / T_t) ** b2 + a3 * (T / T_t) ** b3) / (T / T_t))"
+fixed_units = true
+references = ["iapws_r14_08", "wagner2011"]
+accuracy = "0.0011 % at the triple point (expanded uncertainty, k = 2); see Fig. 2 of the release below"
+note = "Reference formulation over ice. Reproduces Table 3 of the release: 8.94735 Pa at 230 K; joins the IAPWS equation over water at the triple point."
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "PA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature (ITS-90)", temperature_scale = "its90", scale_basis = "stated" },
+]
+
+[formulations.iapws_r14_08_sublimation.coefficients]
+T_t = { value = 273.16, unit = "K", note = "Triple point temperature" }
+p_t = { value = 611.657, unit = "PA", note = "Triple point pressure" }
+a1 = -21.2144006
+a2 = 27.3203819
+a3 = -6.10598130
+b1 = 0.333333333e-2
+b2 = 1.20666667
+b3 = 1.70333333
+
+[[formulations.iapws_r14_08_sublimation.domains]]
+basis = "stated"
+bounds = { T = [50.0, 273.16] }
+criterion = "Solid-vapour equilibrium of ice Ih, endorsed by IAPWS (section 5)."
+reference = "iapws_r14_08"
+
+[formulations.goff_gratch1946_ice]
+label = "Goff-Gratch equation over ice (Smithsonian Tables form)"
+expression = "10 ** (c1 * (T_0 / T - 1) + c2 * log10(T_0 / T) + c3 * (1 - T / T_0) + log10(e_i0))"
+fixed_units = true
+references = ["goff_gratch1946", "smithsonian1984", "voemel_vp"]
+note = "As quoted by Vömel, who calls it the generally considered reference over ice."
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "HectoPA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature" },
+]
+
+[formulations.goff_gratch1946_ice.coefficients]
+c1 = -9.09718
+c2 = -3.56654
+c3 = 0.876793
+T_0 = { value = 273.16, unit = "K" }
+e_i0 = { value = 6.1071, unit = "HectoPA" }
+
+[[formulations.goff_gratch1946_ice.domains]]
+basis = "stated"
+bounds = { T = [173.15, 273.15] }
+criterion = "-100 to 0 degC, range of the equation over ice as stated by Vömel."
+reference = "voemel_vp"
+
+[formulations.hyland_wexler1983_ice]
+label = "Hyland and Wexler (1983) formulation over ice"
+expression = "exp(C1 / T + C2 + C3 * T + C4 * T ** 2 + C5 * T ** 3 + C6 * T ** 4 + C7 * ln(T))"
+fixed_units = true
+references = ["hyland_wexler1983", "ashrae2017", "psychrolib", "voemel_vp"]
+note = "ASHRAE Handbook - Fundamentals (2017), chapter 1, equation 5, through PsychroLib; same coefficients in Vömel. Range not read in the original. Temperature scale ITS-90, inferred from numbers: as over water, these coefficients agree with IAPWS R14-08 within 0.032 % from -80 to -1 degC without conversion, and drift to -0.18 % at -80 degC with the IPTS-68 conversion."
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "PA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature", temperature_scale = "its90", scale_basis = "inferred-from-numbers" },
+]
+coefficients = { C1 = -5.6745359e3, C2 = 6.3925247, C3 = -9.677843e-3, C4 = 6.2215701e-7, C5 = 2.0747825e-9, C6 = -9.484024e-13, C7 = 4.1635019 }
+
+[formulations.wmo2008_ice]
+label = "Magnus form over ice, WMO Guide (CIMO) coefficients"
+expression = "C * exp(A * t / (B + t))"
+fixed_units = true
+references = ["wmo2008", "voemel_vp"]
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "HectoPA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "t", kind = "CelsiusTemperature", unit = "DEG_C", description = "Celsius temperature", temperature_scale = "its90", scale_basis = "inferred-from-date" },
+]
+coefficients = { A = 22.46, B = 272.62, C = 6.112 }
+
+[formulations.murray1967_ice]
+label = "Magnus-Tetens form over ice, Murray (1967)"
+expression = "C * exp(A * (T - T_0) / (T - B))"
+fixed_units = true
+references = ["murray1967", "voemel_vp"]
+note = "As quoted by Vömel. Departs from the IAPWS equation by about -1.9 % at -40 degC and -11 % at -80 degC; original not read."
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "HectoPA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature" },
+]
+
+[formulations.murray1967_ice.coefficients]
+A = 21.8745584
+B = { value = 7.66, unit = "K" }
+C = { value = 6.1078, unit = "HectoPA" }
+T_0 = { value = 273.16, unit = "K" }
+
+[formulations.buck1981_ice]
+label = "Magnus form over ice, Buck (1981) coefficients"
+expression = "C * exp(A * t / (B + t))"
+fixed_units = true
+references = ["buck1981", "voemel_vp"]
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "HectoPA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "t", kind = "CelsiusTemperature", unit = "DEG_C", description = "Celsius temperature", temperature_scale = "ipts68", scale_basis = "inferred-from-date" },
+]
+coefficients = { A = 22.452, B = 272.55, C = 6.1115 }
+
+[formulations.buck1996_ice]
+label = "Buck (1996) equation over ice"
+expression = "C * exp((A - t / D) * t / (B + t))"
+fixed_units = true
+references = ["buck1996", "voemel_vp"]
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "HectoPA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "t", kind = "CelsiusTemperature", unit = "DEG_C", description = "Celsius temperature", temperature_scale = "its90", scale_basis = "inferred-from-date" },
+]
+coefficients = { A = 23.036, B = 279.82, C = 6.1115, D = 333.7 }
+
+[formulations.marti_mauersberger1993]
+label = "Marti and Mauersberger (1993) formulation over ice"
+expression = "10 ** (A / T + B)"
+fixed_units = true
+references = ["marti_mauersberger1993", "voemel_vp"]
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "PA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature", temperature_scale = "its90", scale_basis = "inferred-from-date" },
+]
+coefficients = { A = { value = -2663.5, unit = "K" }, B = 12.537 }
+
+[formulations.murphy_koop2005_ice]
+label = "Murphy and Koop (2005) formulation over ice"
+expression = "exp(c0 + c1 / T + c2 * ln(T) + c3 * T)"
+fixed_units = true
+references = ["murphy_koop2005", "voemel_vp"]
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "PA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature", temperature_scale = "its90", scale_basis = "inferred-from-date" },
+]
+coefficients = { c0 = 9.550426, c1 = -5723.265, c2 = 3.53068, c3 = -0.00728332 }
+
+[formulations.sonntag1990_ice]
+label = "Sonntag formulation over ice"
+expression = "exp(a0 / T + a1 + a2 * T + a3 * T ** 2 + a4 * ln(T))"
+fixed_units = true
+references = ["sonntag1990", "voemel_vp"]
+note = "As quoted by Vömel, who dates it 1994 (as for the formulation over water)."
+output = { identifier = "e_i", kind = "SaturationVapourPressureOverIce", unit = "HectoPA", description = "Saturation vapour pressure over ice" }
+inputs = [
+  { identifier = "T", kind = "ThermodynamicTemperature", unit = "K", description = "Thermodynamic temperature", temperature_scale = "its90", scale_basis = "inferred-from-date" },
+]
+coefficients = { a0 = -6024.5282, a1 = 24.721994, a2 = 1.0613868e-2, a3 = -1.3198825e-5, a4 = -0.49382577 }

{nomogram-0.1.1 → nomogram-0.2.0}/src/nomogram/data/semantics.json

@@ -1,9 +1,17 @@
 {
   "cf_standard_names": {
+    "air_pressure": {
+      "canonical_units": "Pa",
+      "pint": "Pa"
+    },
     "air_temperature": {
       "canonical_units": "K",
       "pint": "K"
     },
+    "dew_point_temperature": {
+      "canonical_units": "K",
+      "pint": "K"
+    },
     "humidity_mixing_ratio": {
       "canonical_units": "1",
       "pint": "dimensionless"
@@ -62,6 +70,23 @@
       "scale_type": "interval",
       "specialization_of": "Temperature"
     },
+    "DewPointTemperature": {
+      "added_units": [],
+      "applicable_units": [
+        "DEG_C",
+        "DEG_F"
+      ],
+      "cf_standard_names": [
+        "dew_point_temperature"
+      ],
+      "delta": false,
+      "dimension_vector": "A0E0L0I0M0H1T0D0",
+      "iri": "http://qudt.org/vocab/quantitykind/DewPointTemperature",
+      "label": "Dew Point Temperature",
+      "matches": [],
+      "scale_type": "interval",
+      "specialization_of": "Temperature"
+    },
     "MassConcentrationOfWaterVapour": {
       "added_units": [],
       "applicable_units": [
@@ -112,6 +137,30 @@
       "scale_type": "ratio",
       "specialization_of": null
     },
+    "Pressure": {
+      "added_units": [],
+      "applicable_units": [
+        "HectoPA",
+        "KiloPA",
+        "PA"
+      ],
+      "cf_standard_names": [
+        "air_pressure"
+      ],
+      "delta": false,
+      "dimension_vector": "A0E0L-1I0M1H0T-2D0",
+      "iri": "http://qudt.org/vocab/quantitykind/Pressure",
+      "label": "Pressure",
+      "matches": [
+        {
+          "relation": "close",
+          "target": "http://www.wikidata.org/entity/Q39552",
+          "verified": "2026-10-14"
+        }
+      ],
+      "scale_type": "ratio",
+      "specialization_of": "ForcePerArea"
+    },
     "RelativeHumidity": {
       "added_units": [
         "UNITLESS"

nomogram-0.2.0/src/nomogram/inversion.py

@@ -0,0 +1,480 @@
+# SPDX-FileCopyrightText: 2026 Miki
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Inverting formulations: closed form by symbolic computation, or numerically.
+
+A formulation y = f(x) of one input can be inverted into x = g(y). For
+the dew point, the saturation vapour pressure e_s = f(t) becomes
+t_d = g(e): the temperature at which a vapour pressure e saturates.
+
+:func:`invert` first looks for a closed form with SymPy, after taking the
+logarithm of both sides (which turns the usual exponential forms into
+rational equations). The closed form becomes an ordinary
+:class:`~nomogram.model.Formulation`, with an expression in the catalog
+syntax, LaTeX in any notation, validity domains carried through the
+function, and a :class:`~nomogram.model.Derivation` recording its
+origin. When there is none, or when the unknown appears more than
+:data:`SYMBOLIC_MAX_OCCURRENCES` times (to keep the search short), the
+result is a :class:`NumericalInverse`, solved by vectorised bisection
+over a search interval.
+
+Temperatures stay on ITS-90 at both ends: an inverse of a formulation
+fitted on another scale converts its result back.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from typing import Any, Literal
+
+import numpy as np
+
+from nomogram.expression import compile_numeric, parse_expression
+from nomogram.model import (
+    Basis,
+    Coefficient,
+    Derivation,
+    Formulation,
+    OutOfDomainError,
+    Outside,
+    ScaleConversion,
+    ValidityDomain,
+    ValidityWarning,
+    Variable,
+)
+from nomogram.semantics import semantic_catalog
+from nomogram.units import Q_, convert
+
+__all__ = [
+    "DEW_POINT_SEARCH_CELSIUS",
+    "SYMBOLIC_MAX_OCCURRENCES",
+    "InversionError",
+    "NumericalInverse",
+    "dew_point",
+    "invert",
+]
+
+#: Above this many occurrences of the unknown (after taking logarithms),
+#: no closed form is sought: SymPy would search for long and find none.
+SYMBOLIC_MAX_OCCURRENCES = 3
+
+#: Interval searched by :func:`dew_point` when the formulation states no
+#: validity domain, in degC: a search interval, not a validity domain.
+DEW_POINT_SEARCH_CELSIUS = (-100.0, 100.0)
+
+#: Name of the offset coefficient added when the result changes from K to
+#: degC (t = T - T0, SI Brochure, section 2.3.1).
+_OFFSET = "T_celsius_zero"
+
+Method = Literal["auto", "symbolic", "numerical"]
+
+
+class InversionError(ValueError):
+    """The formulation cannot be inverted as asked."""
+
+
+def _source(expr: Any) -> str:
+    """The catalog-syntax source of a SymPy expression (``ln`` for ``log``)."""
+    from sympy.printing.str import StrPrinter
+
+    class Printer(StrPrinter):  # type: ignore[misc]
+        def _print_log(self, node: Any) -> str:
+            return f"ln({self._print(node.args[0])})"
+
+    return str(Printer().doprint(expr))
+
+
+def _check(
+    formulation: Formulation, solve_for: str, output: Variable, input: Variable
+) -> None:
+    if len(formulation.inputs) != 1:
+        msg = f"{formulation.key}: only formulations of one input can be inverted"
+        raise InversionError(msg)
+    if formulation.inputs[0].identifier != solve_for:
+        msg = f"{formulation.key} has no input {solve_for!r}"
+        raise InversionError(msg)
+    if input.unit != formulation.output.unit:
+        msg = (
+            f"the new input must keep the unit of {formulation.key}'s output "
+            f"({formulation.output.unit}), the unit its coefficients hold in"
+        )
+        raise InversionError(msg)
+    from nomogram.catalog import catalog
+
+    kinds = catalog().kinds
+    for variable in (output, input):
+        kind = kinds.get(variable.kind)
+        if kind is None or variable.unit not in kind.applicable_units:
+            msg = f"{variable.identifier}: {variable.unit} does not apply to {variable.kind}"
+            raise InversionError(msg)
+    if (
+        formulation.inputs[0].kind == "TemperatureDifference"
+        or output.kind == "TemperatureDifference"
+    ):
+        msg = "inverting temperature differences is not supported"
+        raise InversionError(msg)
+
+
+def _forward(formulation: Formulation) -> Any:
+    """The formulation's numeric function of its single input, in its units."""
+    function = compile_numeric(formulation.sympy_expression, formulation.names)
+    fixed = [c.value for c in formulation.coefficients] + [
+        k.value for k in formulation.constants
+    ]
+    factor = formulation.output_factor
+
+    def forward(x: Any) -> Any:
+        with np.errstate(invalid="ignore", divide="ignore", over="ignore"):
+            return np.asarray(function(x, *fixed), dtype=float) * factor
+
+    return forward
+
+
+def _bounds(formulation: Formulation, solve_for: str) -> tuple[float, float] | None:
+    """Intersection of the stated domains on the input, if any."""
+    stated = [
+        d.bounds[solve_for]
+        for d in formulation.domains
+        if d.basis.value == "stated" and solve_for in d.bounds
+    ]
+    if not stated:
+        return None
+    return max(low for low, _ in stated), min(high for _, high in stated)
+
+
+def _offset(source_unit: str, target_unit: str) -> float:
+    """What to add to the solved value to express it in the target unit."""
+    if source_unit == target_unit:
+        return 0.0
+    if (source_unit, target_unit) == ("K", "DEG_C"):
+        return -273.15
+    if (source_unit, target_unit) == ("DEG_C", "K"):
+        return 273.15
+    msg = f"cannot express a result solved in {source_unit} in {target_unit}"
+    raise InversionError(msg)
+
+
+def _symbolic(
+    formulation: Formulation,
+    solve_for: str,
+    output: Variable,
+    input: Variable,
+    key: str,
+    label: str,
+    samples: Any,
+) -> Formulation | None:
+    import sympy
+
+    x = sympy.Symbol(solve_for, real=True)
+    y = sympy.Symbol(input.identifier, positive=True)
+    lhs = sympy.expand_log(sympy.log(formulation.sympy_expression), force=True)
+    if lhs.count(x) > SYMBOLIC_MAX_OCCURRENCES:
+        return None
+    # ln f(x) = k + g(x): solve g(x) = z, then z = ln(y) - k, combined
+    # into one logarithm (ln(e/C) for the Magnus form).
+    constant, varying = lhs.as_independent(x, as_Add=True)
+    z = sympy.Dummy("z", real=True)
+    try:
+        solutions = sympy.solve(varying - z, x)
+    except NotImplementedError:
+        return None
+    rhs = sympy.logcombine(sympy.log(y) - constant, force=True)
+    solutions = [s.subs(z, rhs) for s in solutions]
+    shift = _offset(formulation.inputs[0].unit, output.unit)
+    coefficients = list(formulation.coefficients)
+    if shift:
+        coefficients.append(
+            Coefficient(_OFFSET, -shift, "K", "t = T - T0 (SI Brochure, section 2.3.1)")
+        )
+    names = (
+        [input.identifier]
+        + [c.identifier for c in coefficients]
+        + [k.identifier for k in formulation.constants]
+    )
+    forward = _forward(formulation)
+    targets = forward(samples)
+    for solution in solutions:
+        expr = solution
+        if shift:
+            expr = expr - sympy.Symbol(_OFFSET, real=True)
+        source = _source(expr)
+        try:
+            parsed = parse_expression(source, names)
+        except ValueError:
+            continue
+        values = [c.value for c in coefficients] + [
+            k.value for k in formulation.constants
+        ]
+        with np.errstate(invalid="ignore", divide="ignore"):
+            back = np.asarray(
+                compile_numeric(parsed, tuple(names))(targets, *values), dtype=float
+            )
+        if np.allclose(back, samples + shift, rtol=1e-9, atol=1e-9):
+            return Formulation(
+                key=key,
+                label=label,
+                output=output,
+                inputs=(input,),
+                coefficients=tuple(coefficients),
+                constants=formulation.constants,
+                expression=source,
+                fixed_units=formulation.fixed_units,
+                domains=_carried_domains(
+                    formulation, solve_for, input.identifier, forward
+                ),
+                accuracy=formulation.accuracy,
+                references=formulation.references,
+                note=f"Derived by symbolic inversion of {formulation.key}.",
+                matches=(),
+                derivation=Derivation(formulation.key, "symbolic inversion", solve_for),
+            )
+    return None
+
+
+def _carried_domains(
+    formulation: Formulation, solve_for: str, identifier: str, forward: Any
+) -> tuple[ValidityDomain, ...]:
+    """The domains on the input, carried through the function onto its output."""
+    carried = []
+    for domain in formulation.domains:
+        if solve_for not in domain.bounds:
+            continue
+        low, high = domain.bounds[solve_for]
+        ends = sorted(float(v) for v in forward(np.array([low, high])))
+        criterion = f"Carried by inversion from {formulation.key}: {domain.criterion or 'no criterion'}"
+        carried.append(
+            ValidityDomain(
+                domain.basis,
+                {identifier: (ends[0], ends[1])},
+                criterion,
+                domain.reference,
+            )
+        )
+    return tuple(carried)
+
+
+@dataclass(frozen=True)
+class NumericalInverse:
+    """The inverse of a formulation, solved numerically.
+
+    Evaluable like a formulation (see :func:`nomogram.comparison.compare`
+    and :func:`~nomogram.comparison.compose`). The source is assumed
+    monotonic over the search interval; values outside its image give
+    NaN, and results outside the source's validity domains follow the
+    ``outside`` option.
+
+    Attributes
+    ----------
+    key, label : str
+        Identification.
+    output, input : Variable
+        The solved variable and the new input.
+    source : Formulation
+        The formulation inverted.
+    search : tuple of float
+        Interval of the source's input searched, in its unit.
+    derivation : Derivation
+        Origin, with ``method="numerical inversion"``.
+    """
+
+    key: str
+    label: str
+    output: Variable
+    input: Variable
+    source: Formulation
+    search: tuple[float, float]
+    derivation: Derivation
+    references: tuple[str, ...] = field(default=())
+
+    @property
+    def inputs(self) -> tuple[Variable, ...]:
+        """The single input, as for a formulation."""
+        return (self.input,)
+
+    def evaluate(
+        self,
+        *,
+        outside: Outside = "nan",
+        basis: Basis = "stated",
+        scale: ScaleConversion = "convert",
+        **inputs: Any,
+    ) -> Any:
+        """Solve for the output, by vectorised bisection."""
+        if set(inputs) != {self.input.identifier}:
+            msg = f"{self.key}: expected the input {self.input.identifier}"
+            raise TypeError(msg)
+        units = semantic_catalog().units
+        source_input = self.source.inputs[0]
+        target = np.asarray(
+            convert(
+                inputs[self.input.identifier], units[self.input.unit].pint
+            ).magnitude,
+            dtype=float,
+        )
+        forward = _forward(self.source)
+        low = np.full(target.shape, self.search[0])
+        high = np.full(target.shape, self.search[1])
+        increasing = forward(np.array(self.search[1])) > forward(
+            np.array(self.search[0])
+        )
+        for _ in range(100):
+            middle = (low + high) / 2
+            below = forward(middle) < target
+            go_up = below if increasing else ~below
+            low = np.where(go_up, middle, low)
+            high = np.where(go_up, high, middle)
+        solved = (low + high) / 2
+        ends = forward(np.array(self.search))
+        unreachable = (
+            (target < ends.min()) | (target > ends.max()) | ~np.isfinite(target)
+        )
+        solved = np.where(unreachable, np.nan, solved)
+        mask = self.source.outside_mask({source_input.identifier: solved}, basis)
+        if mask.any() and outside != "ignore":
+            message = f"{self.key}: {int(mask.sum())} value(s) outside the {basis} domain of {self.source.key}"
+            if outside == "raise":
+                raise OutOfDomainError(message)
+            if outside == "warn":
+                import warnings
+
+                warnings.warn(message, ValidityWarning, stacklevel=2)
+            else:
+                solved = np.where(mask, np.nan, solved)
+        quantity = Q_(solved, units[source_input.unit].pint)
+        scale_of_source = source_input.temperature_scale
+        if scale == "convert" and scale_of_source is not None and scale_of_source.t90:
+            celsius = scale_of_source.to_its90(convert(quantity, "degC").magnitude)
+            quantity = Q_(celsius, "degC")
+        result = np.asarray(
+            convert(quantity, units[self.output.unit].pint).magnitude, dtype=float
+        )
+        magnitude = result.item() if result.ndim == 0 else result
+        return Q_(magnitude, units[self.output.unit].pint)
+
+
+def invert(
+    formulation: Formulation,
+    solve_for: str,
+    *,
+    output: Variable,
+    input: Variable,
+    key: str | None = None,
+    label: str | None = None,
+    method: Method = "auto",
+    search: tuple[float, float] | None = None,
+) -> Formulation | NumericalInverse:
+    """Invert a formulation of one input.
+
+    Parameters
+    ----------
+    formulation : Formulation
+        The formulation y = f(x).
+    solve_for : str
+        Identifier of its input x, which becomes the output.
+    output : Variable
+        The new output (x's identifier, kind and unit; K and degC are
+        interchangeable for temperatures).
+    input : Variable
+        The new input, in the unit of the formulation's output.
+    key, label : str, optional
+        Identification of the result; derived from the source otherwise.
+    method : {"auto", "symbolic", "numerical"}
+        ``"auto"`` tries a closed form, then falls back to numerical
+        inversion; the others force one method.
+    search : (float, float), optional
+        Interval of x searched by numerical inversion, in x's unit;
+        defaults to the source's stated validity domain.
+
+    Returns
+    -------
+    Formulation or NumericalInverse
+        A formulation when a closed form was found; its ``derivation``
+        records the source and the method.
+
+    Raises
+    ------
+    InversionError
+        If the formulation cannot be inverted as asked.
+    """
+    _check(formulation, solve_for, output, input)
+    source_input = formulation.inputs[0]
+    output = replace(
+        output,
+        temperature_scale=source_input.temperature_scale,
+        scale_basis=source_input.scale_basis,
+    )
+    key = key or f"{formulation.key}_inverse"
+    label = label or f"Inverse of: {formulation.label}"
+    interval = search or _bounds(formulation, solve_for)
+    if method != "numerical":
+        if interval is not None:
+            samples = np.linspace(interval[0], interval[1], 7)[1:-1]
+        else:
+            # Ordinary temperatures, to pick the right branch of a solution.
+            samples = np.array([5.0, 20.0, 35.0]) + (
+                273.15 if source_input.unit == "K" else 0.0
+            )
+        closed = _symbolic(formulation, solve_for, output, input, key, label, samples)
+        if closed is not None:
+            return closed
+        if method == "symbolic":
+            msg = f"{formulation.key}: no closed form found for {solve_for}"
+            raise InversionError(msg)
+    if interval is None:
+        msg = (
+            f"{formulation.key} states no validity domain on {solve_for}: "
+            "give a search interval for numerical inversion"
+        )
+        raise InversionError(msg)
+    return NumericalInverse(
+        key=key,
+        label=label,
+        output=output,
+        input=input,
+        source=formulation,
+        search=(float(interval[0]), float(interval[1])),
+        derivation=Derivation(formulation.key, "numerical inversion", solve_for),
+        references=formulation.references,
+    )
+
+
+def dew_point(
+    formulation: Formulation,
+    *,
+    method: Method = "auto",
+    search: tuple[float, float] | None = None,
+) -> Formulation | NumericalInverse:
+    """The dew point formulation obtained by inverting a saturation vapour pressure.
+
+    Parameters
+    ----------
+    formulation : Formulation
+        A saturation vapour pressure formulation e_s = f(T).
+    method, search
+        As for :func:`invert`. Without a stated validity domain, numerical
+        inversion searches :data:`DEW_POINT_SEARCH_CELSIUS`.
+
+    Returns
+    -------
+    Formulation or NumericalInverse
+        t_d = g(e), with e a vapour pressure (in the unit of e_s) and t_d
+        a dew point temperature in degC.
+    """
+    temperature = formulation.inputs[0]
+    if search is None and _bounds(formulation, temperature.identifier) is None:
+        # A search interval only, not a validity domain.
+        search = DEW_POINT_SEARCH_CELSIUS
+        if temperature.unit == "K":
+            search = (search[0] + 273.15, search[1] + 273.15)
+    return invert(
+        formulation,
+        temperature.identifier,
+        output=Variable("t_d", "DewPointTemperature", "DEG_C", "Dew point temperature"),
+        input=Variable(
+            "e", "VapourPressure", formulation.output.unit, "Vapour pressure"
+        ),
+        key=f"{formulation.key}_dew_point",
+        label=f"Dew point, inverse of: {formulation.label}",
+        method=method,
+        search=search,
+    )

{nomogram-0.1.1 → nomogram-0.2.0}/src/nomogram/model.py

@@ -43,6 +43,7 @@ from nomogram.units import Q_, convert
 
 __all__ = [
     "Coefficient",
+    "Derivation",
     "DomainBasis",
     "Formulation",
     "Notation",
@@ -198,6 +199,42 @@ class TemperatureScale:
         shift = np.interp(values, self.t90, self.difference)
         return np.where(outside, np.nan, values - shift), outside
 
+    def to_its90(self, celsius: Any) -> Any:
+        """ITS-90 Celsius temperatures, from temperatures on this scale.
+
+        Inverts :meth:`from_its90` by fixed-point iteration (the
+        differences are millikelvins and vary slowly); NaN beyond the
+        table.
+        """
+        values = np.asarray(celsius, dtype=float)
+        if not self.t90:
+            return values
+        t90 = values
+        for _ in range(4):
+            t90 = values + np.interp(t90, self.t90, self.difference)
+        outside = (t90 < self.t90[0]) | (t90 > self.t90[-1])
+        return np.where(outside, np.nan, t90)
+
+
+@dataclass(frozen=True)
+class Derivation:
+    """How a formulation was derived from another one.
+
+    Attributes
+    ----------
+    source : str
+        Key of the formulation it derives from.
+    method : str
+        ``"symbolic inversion"`` (closed form found by SymPy) or
+        ``"numerical inversion"``.
+    solved_for : str
+        Identifier of the source's input that became the output.
+    """
+
+    source: str
+    method: str
+    solved_for: str
+
 
 @dataclass(frozen=True)
 class Variable:
@@ -411,6 +448,9 @@ class Formulation:
         Remark.
     matches : tuple of ExternalMatch
         Links to external vocabularies (Wikidata item of the formula...).
+    derivation : Derivation or None
+        For a formulation derived from another one (see
+        :mod:`nomogram.inversion`), how it was derived.
     """
 
     key: str
@@ -426,6 +466,7 @@ class Formulation:
     references: tuple[str, ...]
     note: str | None
     matches: tuple[ExternalMatch, ...]
+    derivation: Derivation | None = None
 
     @property
     def names(self) -> tuple[str, ...]:
@@ -461,11 +502,14 @@ class Formulation:
         if self.fixed_units:
             return 1.0
         units = semantic_catalog().units
-        ones: list[Any] = [Q_(1.0, units[v.unit].pint) for v in self.inputs]
-        ones += [1.0 for _ in self.coefficients]
-        ones += [Q_(1.0, units[k.unit].pint) for k in self.constants]
-        result = Q_(self._function(*ones))
-        return float(result.to(units[self.output.unit].pint).magnitude)
+        # Distinct probe values, so that no difference such as p - e
+        # vanishes; only the unit of the result matters.
+        probe = iter(1.5 ** (i + 1) for i in range(len(self.names)))
+        values: list[Any] = [Q_(next(probe), units[v.unit].pint) for v in self.inputs]
+        values += [next(probe) for _ in self.coefficients]
+        values += [Q_(next(probe), units[k.unit].pint) for k in self.constants]
+        result = Q_(self._function(*values))
+        return float(Q_(1.0, result.units).to(units[self.output.unit].pint).magnitude)
 
     def latex(self, notation: Notation | None = None) -> str:
         """The formulation as a LaTeX equation, in a given notation."""
@@ -590,5 +634,13 @@ class Formulation:
                 warnings.warn(message, ValidityWarning, stacklevel=2)
             else:
                 result = np.where(mask, np.nan, result)
+        output_unit = units[self.output.unit].pint
+        output_scale = self.output.temperature_scale
+        if scale == "convert" and output_scale is not None and output_scale.t90:
+            # A temperature computed on the formulation's scale goes back to
+            # ITS-90, the scale of inputs and results.
+            celsius = convert(Q_(result, output_unit), "degC").magnitude
+            its90 = Q_(output_scale.to_its90(celsius), "degC")
+            result = np.asarray(convert(its90, output_unit).magnitude, dtype=float)
         magnitude = result.item() if result.ndim == 0 else result
-        return Q_(magnitude, units[self.output.unit].pint)
+        return Q_(magnitude, output_unit)