jerlov 0.1.1__py3-none-any.whl

jerlov/__init__.py

@@ -0,0 +1,51 @@
+"""Inherent optical properties of Jerlov water types.
+
+Every coefficient carries its source, and values that a published table got
+wrong are flagged rather than quietly repaired.
+"""
+
+from .colour import (
+    CoverageWarning,
+    GamutWarning,
+    cie_1931_cmf,
+    d65,
+    integrate_response,
+    spectrum_to_srgb,
+    spectrum_to_xyz,
+    xyz_to_srgb,
+)
+from .scene import Observation, Scene, veiling_radiance_estimate
+from .sources import SOURCES, Source, get_source
+from .water import (
+    MissingQuantityError,
+    ProvenanceWarning,
+    Water,
+    b_from_c,
+    kd_spectrum,
+    water,
+)
+
+__all__ = [
+    "SOURCES",
+    "Scene",
+    "Observation",
+    "veiling_radiance_estimate",
+    "spectrum_to_xyz",
+    "spectrum_to_srgb",
+    "xyz_to_srgb",
+    "integrate_response",
+    "cie_1931_cmf",
+    "d65",
+    "GamutWarning",
+    "CoverageWarning",
+    "Source",
+    "get_source",
+    "Water",
+    "water",
+    "kd_spectrum",
+    "b_from_c",
+    "ProvenanceWarning",
+    "MissingQuantityError",
+]
+
+__version__ = "0.1.1"

jerlov/_data.py

@@ -0,0 +1,113 @@
+"""Loading of the packaged coefficient tables.
+
+Every table is a CSV shipped inside the package. Each row carries a ``status``
+column recording what is known about that particular value; nothing is
+silently cleaned up on the way in.
+"""
+
+from __future__ import annotations
+
+import csv
+from functools import lru_cache
+from importlib import resources
+
+import numpy as np
+
+#: Values whose ``status`` is one of these should not be used without the
+#: caller being told. See README sections 1-6.
+QUESTIONABLE = frozenset({"suspect", "missing", "extrapolated",
+                          "model_extrapolation", "reconstructed"})
+
+
+def _read(name: str) -> list[dict[str, str]]:
+    path = resources.files("jerlov.data").joinpath(name)
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+@lru_cache(maxsize=None)
+def _rows(name: str) -> tuple[dict[str, str], ...]:
+    return tuple(_read(name))
+
+
+def _to_float(text: str) -> float:
+    return float(text) if text.strip() else float("nan")
+
+
+@lru_cache(maxsize=None)
+def spectrum(
+    filename: str,
+    water_type: str,
+    quantity: str | None,
+    value_column: str,
+) -> tuple[np.ndarray, np.ndarray, tuple[str, ...]]:
+    """Return ``(wavelengths, values, statuses)`` for one series.
+
+    Rows whose value is empty are kept, with the value set to NaN, so that a
+    gap in the published table stays visible instead of being interpolated
+    across without comment.
+    """
+    wl: list[float] = []
+    values: list[float] = []
+    statuses: list[str] = []
+    for row in _rows(filename):
+        if row.get("water_type") != water_type:
+            continue
+        if quantity is not None and row.get("quantity") != quantity:
+            continue
+        wl.append(float(row["wavelength_nm"]))
+        values.append(_to_float(row[value_column]))
+        statuses.append(row.get("status", ""))
+    if not wl:
+        raise KeyError(
+            f"no rows in {filename} for water_type={water_type!r}"
+            + (f", quantity={quantity!r}" if quantity else "")
+        )
+    order = np.argsort(wl)
+    return (
+        np.asarray(wl, dtype=float)[order],
+        np.asarray(values, dtype=float)[order],
+        tuple(statuses[i] for i in order),
+    )
+
+
+@lru_cache(maxsize=None)
+def notes(filename: str, water_type: str, quantity: str | None) -> dict[float, str]:
+    """Map wavelength to the ``note`` column, for rows that carry one."""
+    out: dict[float, str] = {}
+    for row in _rows(filename):
+        if row.get("water_type") != water_type:
+            continue
+        if quantity is not None and row.get("quantity") != quantity:
+            continue
+        note = row.get("note", "").strip()
+        if note:
+            out[float(row["wavelength_nm"])] = note
+    return out
+
+
+@lru_cache(maxsize=None)
+def austin_model() -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return ``(wavelengths, M, Kw)`` from Austin & Petzold (1986) Table IV."""
+    rows = _rows("austin1986_model.csv")
+    wl = np.array([float(r["wavelength_nm"]) for r in rows])
+    m = np.array([float(r["M_slope"]) for r in rows])
+    kw = np.array([float(r["Kw_pure_seawater_per_m"]) for r in rows])
+    order = np.argsort(wl)
+    return wl[order], m[order], kw[order]
+
+
+@lru_cache(maxsize=None)
+def b_from_c_ratio() -> tuple[np.ndarray, dict[str, np.ndarray]]:
+    """Return ``(wavelengths, {statistic: ratio})`` from Smart (2007) Table 1."""
+    rows = _rows("smart2007_b_from_c.csv")
+    wl = sorted({float(r["wavelength_nm"]) for r in rows})
+    out: dict[str, np.ndarray] = {}
+    for stat in ("average", "min", "max"):
+        by_wl = {
+            float(r["wavelength_nm"]): float(r["b_minus_bw_over_c_minus_cw"])
+            for r in rows
+            if r["statistic"] == stat
+        }
+        out[stat] = np.array([by_wl[w] for w in wl])
+    return np.array(wl), out

jerlov/colour.py

@@ -0,0 +1,255 @@
+"""From a spectrum to a colour, or to whatever a sensor or an eye would see.
+
+Two things are easy to get wrong here and are checked rather than assumed.
+
+**Coverage.** Integrating a spectrum that only spans 450-650 nm against
+colour matching functions that span 360-830 nm silently drops the ends and
+shifts the result. Every integration reports how much of the observer's
+sensitivity the spectrum actually covered, and warns when the answer is not
+essentially all of it.
+
+**White.** A radiance spectrum has no colour until something is called white.
+There is no default; the caller states the reference. Underwater the sensible
+reference is usually the downwelling irradiance at that depth, which is what
+makes a grey card look grey there rather than blue.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+
+from . import _data
+
+#: sRGB primaries and white point, IEC 61966-2-1.
+SRGB_PRIMARIES = np.array([
+    [0.6400, 0.3300],   # red
+    [0.3000, 0.6000],   # green
+    [0.1500, 0.0600],   # blue
+])
+SRGB_WHITEPOINT_XY = np.array([0.3127, 0.3290])   # D65
+
+
+def _xy_to_xyz(xy: np.ndarray) -> np.ndarray:
+    """Chromaticity to XYZ with Y = 1."""
+    x, y = xy
+    return np.array([x / y, 1.0, (1 - x - y) / y])
+
+
+#: XYZ of the sRGB white, Y = 1. Adaptation maps a stated white onto this.
+SRGB_WHITEPOINT_XYZ = _xy_to_xyz(SRGB_WHITEPOINT_XY)
+
+
+class GamutWarning(UserWarning):
+    """A colour fell outside the range the display can show.
+
+    Underwater colours often do. Clipping changes them, so the caller is told
+    rather than left to wonder.
+    """
+
+
+class CoverageWarning(UserWarning):
+    """The spectrum did not span the observer's sensitivity.
+
+    The integral is then over the overlap only, and the result is biased by
+    however much was left out.
+    """
+
+
+def _rgb_matrix(primaries: np.ndarray, whitepoint_xy: np.ndarray) -> np.ndarray:
+    """Derive the XYZ to linear RGB matrix from chromaticities."""
+    x, y = primaries[:, 0], primaries[:, 1]
+    m = np.vstack([x / y, np.ones(3), (1 - x - y) / y])
+    scale = np.linalg.solve(m, _xy_to_xyz(whitepoint_xy))
+    return np.linalg.inv(m * scale)
+
+
+#: Derived here rather than hard-coded, so the primaries stay the source of
+#: truth. `tests/test_colour.py` checks it against the published matrix.
+XYZ_TO_LINEAR_SRGB = _rgb_matrix(SRGB_PRIMARIES, SRGB_WHITEPOINT_XY)
+
+
+def cie_1931_cmf() -> tuple[np.ndarray, np.ndarray]:
+    """Return ``(wavelengths, cmf)`` for the CIE 1931 2-degree observer.
+
+    ``cmf`` has shape ``(n, 3)``, columns x-bar, y-bar, z-bar, at 1 nm from
+    360 to 830 nm.
+    """
+    rows = _data._rows("cie1931_2deg_cmf.csv")
+    wl = np.array([float(r["wavelength_nm"]) for r in rows])
+    cmf = np.array([
+        [float(r["x_bar"]), float(r["y_bar"]), float(r["z_bar"])] for r in rows
+    ])
+    return wl, cmf
+
+
+def d65() -> tuple[np.ndarray, np.ndarray]:
+    """Return ``(wavelengths, relative power)`` for CIE illuminant D65.
+
+    This is the sRGB reference white, tabulated at 5 nm from 300 to 780 nm.
+
+    It is a daylight phase, so it is a reasonable stand-in for the solar
+    spectrum above the surface, but it is not a measurement of the light at
+    any particular place or time: the real spectrum depends on solar
+    elevation, atmosphere and the state of the surface.
+    """
+    rows = _data._rows("cie_d65.csv")
+    wl = np.array([float(r["wavelength_nm"]) for r in rows])
+    power = np.array([float(r["relative_spectral_power"]) for r in rows])
+    return wl, power
+
+
+def _resample(values, source_wl, target_wl) -> np.ndarray:
+    """Interpolate onto ``target_wl``, leaving zeros outside the source."""
+    return np.interp(target_wl, source_wl, values, left=0.0, right=0.0)
+
+
+def _coverage(spectrum_wl, weight_wl, weight) -> float:
+    """Fraction of the weight that the spectrum's range actually spans."""
+    total = np.trapezoid(weight, weight_wl)
+    if total == 0:
+        return 1.0
+    inside = (weight_wl >= spectrum_wl[0]) & (weight_wl <= spectrum_wl[-1])
+    if not inside.any():
+        return 0.0
+    return float(np.trapezoid(weight[inside], weight_wl[inside]) / total)
+
+
+def integrate_response(spectrum, wavelengths, response, response_wavelengths,
+                       *, name: str = "response") -> np.ndarray:
+    """Integrate a spectrum against one or more spectral sensitivities.
+
+    Parameters
+    ----------
+    spectrum:
+        Spectral radiance or irradiance, on ``wavelengths``.
+    response:
+        Shape ``(m,)`` for a single channel or ``(m, k)`` for ``k`` channels,
+        on ``response_wavelengths``. Camera sensitivities and photoreceptor
+        absorbances both fit here.
+
+    Returns
+    -------
+    Array of shape ``(k,)``: the integral of spectrum times each channel over
+    wavelength, in the units of the spectrum times nm.
+    """
+    spectrum = np.asarray(spectrum, dtype=float)
+    wavelengths = np.asarray(wavelengths, dtype=float)
+    response = np.atleast_2d(np.asarray(response, dtype=float))
+    if response.shape[0] != np.size(response_wavelengths):
+        response = response.T
+    response_wavelengths = np.asarray(response_wavelengths, dtype=float)
+    if spectrum.shape != wavelengths.shape:
+        raise ValueError("spectrum must have the same shape as wavelengths")
+    if response.shape[0] != response_wavelengths.shape[0]:
+        raise ValueError("response must be aligned with response_wavelengths")
+    if wavelengths.size < 2:
+        raise ValueError("at least two wavelengths are needed to integrate")
+
+    worst = min(
+        _coverage(wavelengths, response_wavelengths, response[:, k])
+        for k in range(response.shape[1])
+    )
+    if worst < 0.999:
+        warnings.warn(
+            f"the spectrum spans {wavelengths[0]:g}-{wavelengths[-1]:g} nm and "
+            f"covers only {worst:.1%} of the {name}; the integral is over the "
+            "overlap and is biased by what was left out",
+            CoverageWarning,
+            stacklevel=2,
+        )
+
+    resampled = np.stack(
+        [_resample(response[:, k], response_wavelengths, wavelengths)
+         for k in range(response.shape[1])],
+        axis=1,
+    )
+    return np.trapezoid(spectrum[:, None] * resampled, wavelengths, axis=0)
+
+
+def spectrum_to_xyz(spectrum, wavelengths) -> np.ndarray:
+    """Integrate a spectrum against the CIE 1931 2-degree observer.
+
+    The result is unnormalised: it carries the units of the spectrum. Divide
+    by the XYZ of whatever counts as white before converting to a display
+    colour, or use :func:`spectrum_to_srgb`, which requires that reference.
+    """
+    cmf_wl, cmf = cie_1931_cmf()
+    return integrate_response(
+        spectrum, wavelengths, cmf, cmf_wl, name="CIE 1931 2-degree observer"
+    )
+
+
+def xyz_to_srgb(xyz, *, clip: bool = True) -> np.ndarray:
+    """Convert XYZ, normalised so that white is Y = 1, to sRGB.
+
+    Applies the sRGB transfer function of IEC 61966-2-1. Warns if any channel
+    falls outside the display gamut, which underwater colours often do.
+    """
+    xyz = np.asarray(xyz, dtype=float)
+    linear = np.tensordot(xyz, XYZ_TO_LINEAR_SRGB.T, axes=([-1], [0]))
+
+    outside = np.any(linear < -1e-9) or np.any(linear > 1 + 1e-9)
+    if outside:
+        warnings.warn(
+            "the colour lies outside the sRGB gamut"
+            + (" and has been clipped" if clip else ""),
+            GamutWarning,
+            stacklevel=2,
+        )
+    if clip:
+        linear = np.clip(linear, 0.0, 1.0)
+
+    a = 0.055
+    with np.errstate(invalid="ignore"):
+        return np.where(
+            linear <= 0.0031308,
+            12.92 * linear,
+            (1 + a) * np.power(np.maximum(linear, 0.0), 1 / 2.4) - a,
+        )
+
+
+def spectrum_to_srgb(spectrum, wavelengths, *, white, clip: bool = True):
+    """Convert a spectrum to sRGB, relative to a stated white.
+
+    Parameters
+    ----------
+    white:
+        The spectrum that should come out white, on the same wavelengths.
+        There is no default: a radiance spectrum has no colour until
+        something is called white, and underwater the answer is usually the
+        downwelling irradiance at that depth rather than a surface daylight.
+
+    Notes
+    -----
+    The spectrum's XYZ is scaled component by component so that the stated
+    white lands on the sRGB white point, which makes it come out exactly
+    neutral. This is a von Kries-type adaptation carried out in XYZ rather
+    than in cone space: transparent, and less accurate than CAT02 or Bradford
+    for strongly coloured illumination.
+    Underwater illumination is strongly coloured, so treat the result as
+    "what a white-balanced camera would record" rather than as a prediction
+    of appearance.
+
+    Absolute brightness is lost: a perfect diffuser under the stated white
+    maps to white whatever the light level.
+    """
+    if white is None:
+        raise ValueError(
+            "white has no default: a spectrum has no colour until something "
+            "is called white. Underwater this is usually the downwelling "
+            "irradiance at that depth."
+        )
+    white = np.asarray(white, dtype=float)
+    if white.shape != np.shape(spectrum):
+        raise ValueError("white must have the same shape as the spectrum")
+
+    xyz = spectrum_to_xyz(spectrum, wavelengths)
+    white_xyz = spectrum_to_xyz(white, wavelengths)
+    if np.any(white_xyz <= 0):
+        raise ValueError(
+            "the white reference has no power in one of X, Y or Z, so it "
+            "cannot serve as a white"
+        )
+    return xyz_to_srgb(xyz / white_xyz * SRGB_WHITEPOINT_XYZ, clip=clip)

jerlov/data/__init__.py

@@ -0,0 +1 @@
+"""Packaged coefficient tables. See the project README for provenance."""

jerlov/data/austin1986_kd.csv

@@ -0,0 +1,91 @@
+water_type,wavelength_nm,Kd_downwelling_per_m,status,note
+I,350,0.0510,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,375,0.0302,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,400,0.0217,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,425,0.0185,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,450,0.0176,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,475,0.0184,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,500,0.0280,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,525,0.0504,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,550,0.0640,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,575,0.0931,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,600,0.2408,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,625,0.3174,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,650,0.3559,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,675,0.4372,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+I,700,0.6513,pure_seawater,the type I row is pure sea water Kw; Jerlov's own values fall below it
+IA,350,0.0632,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,375,0.0412,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,400,0.0316,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,425,0.0280,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,450,0.0257,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,475,0.0250,jerlov_original,475 nm is identical to Jerlov (1976) Table XXVII
+IA,500,0.0332,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,525,0.0545,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,550,0.0674,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,575,0.0960,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,600,0.2437,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,625,0.3206,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,650,0.3601,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,675,0.4410,model,computed from K(475) by Austin & Petzold Eq. (6)
+IA,700,0.6530,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,350,0.0782,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,375,0.0546,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,400,0.0438,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,425,0.0395,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,450,0.0355,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,475,0.0330,jerlov_original,475 nm is identical to Jerlov (1976) Table XXVII
+IB,500,0.0396,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,525,0.0596,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,550,0.0715,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,575,0.0995,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,600,0.2471,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,625,0.3245,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,650,0.3652,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,675,0.4457,model,computed from K(475) by Austin & Petzold Eq. (6)
+IB,700,0.6550,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,350,0.1325,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,375,0.1031,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,400,0.0878,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,425,0.0814,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,450,0.0714,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,475,0.0620,jerlov_original,475 nm is identical to Jerlov (1976) Table XXVII
+II,500,0.0627,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,525,0.0779,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,550,0.0863,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,575,0.1122,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,600,0.2595,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,625,0.3389,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,650,0.3837,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,675,0.4626,model,computed from K(475) by Austin & Petzold Eq. (6)
+II,700,0.6623,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,350,0.2335,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,375,0.1935,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,400,0.1697,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,425,0.1594,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,450,0.1381,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,475,0.1160,jerlov_original,475 nm is identical to Jerlov (1976) Table XXVII
+III,500,0.1056,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,525,0.1120,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,550,0.1139,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,575,0.1359,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,600,0.2826,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,625,0.3655,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,650,0.4181,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,675,0.4942,model,computed from K(475) by Austin & Petzold Eq. (6)
+III,700,0.6760,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,350,0.3345,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,375,0.2839,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,400,0.2516,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,425,0.2374,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,450,0.2048,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,475,0.1700,jerlov_original,475 nm is identical to Jerlov (1976) Table XXVII
+1C,500,0.1486,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,525,0.1461,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,550,0.1415,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,575,0.1596,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,600,0.3057,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,625,0.3922,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,650,0.4525,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,675,0.5257,model,computed from K(475) by Austin & Petzold Eq. (6)
+1C,700,0.6896,model,computed from K(475) by Austin & Petzold Eq. (6)

jerlov/data/austin1986_model.csv

@@ -0,0 +1,72 @@
+wavelength_nm,M_slope,Kw_pure_seawater_per_m,status,note
+350,2.1442,0.0510,extrapolated,the paper states this M was extrapolated and should be used with caution
+355,2.0968,0.0453,extrapolated,the paper states this M was extrapolated and should be used with caution
+360,2.0504,0.0405,extrapolated,the paper states this M was extrapolated and should be used with caution
+365,2.0051,0.0365,ok,
+370,1.9610,0.0331,ok,
+375,1.9183,0.0302,ok,
+380,1.8772,0.0278,ok,
+385,1.8379,0.0258,ok,
+390,1.8009,0.0242,ok,
+395,1.7671,0.0228,ok,
+400,1.7383,0.0217,ok,
+405,1.7463,0.0208,ok,
+410,1.7591,0.0200,ok,
+415,1.7312,0.0194,ok,
+420,1.6974,0.0189,ok,
+425,1.6550,0.0185,ok,
+430,1.6108,0.0182,ok,
+435,1.5648,0.0180,ok,
+440,1.5169,0.0178,ok,
+445,1.4673,0.0176,ok,
+450,1.4158,0.0176,ok,
+455,1.3627,0.0175,ok,
+460,1.3077,0.0176,ok,
+465,1.2521,0.0177,ok,
+470,1.1982,0.0179,ok,
+475,1.1460,0.0184,ok,
+480,1.0955,0.0193,ok,
+485,1.0469,0.0206,ok,
+490,1.0000,0.0224,ok,
+495,0.9550,0.0248,ok,
+500,0.9118,0.0280,ok,
+505,0.8704,0.0320,ok,
+510,0.8310,0.0369,ok,
+515,0.7934,0.0428,ok,
+520,0.7578,0.0498,ok,
+525,0.7241,0.0504,ok,
+530,0.6924,0.0526,ok,
+535,0.6627,0.0550,ok,
+540,0.6350,0.0577,ok,
+545,0.6094,0.0607,ok,
+550,0.5860,0.0640,ok,
+555,0.5647,0.0678,ok,
+560,0.5457,0.0723,ok,
+565,0.5289,0.0776,ok,
+570,0.5146,0.0842,ok,
+575,0.5027,0.0931,ok,
+580,0.4935,0.1065,ok,
+585,0.4871,0.1341,ok,
+590,0.4840,0.1578,ok,
+595,0.4853,0.2043,ok,
+600,0.4903,0.2409,ok,
+605,0.4983,0.2688,ok,
+610,0.5090,0.2892,ok,
+615,0.5223,0.3040,ok,
+620,0.5380,0.3124,ok,
+625,0.5659,0.3174,ok,
+630,0.6231,0.3196,ok,
+635,0.6683,0.3227,ok,
+640,0.7001,0.3290,ok,
+645,0.7201,0.3397,ok,
+650,0.7300,0.3559,ok,
+655,0.7323,0.3789,ok,
+660,0.7301,0.4105,ok,
+665,0.7205,0.4208,ok,
+670,0.7008,0.4278,ok,
+675,0.6693,0.4372,ok,
+680,0.6245,0.4521,ok,
+685,0.5651,0.4755,ok,
+690,0.4901,0.5116,ok,
+695,0.3984,0.5671,ok,
+700,0.2891,0.6514,ok,