cloudnetpy 1.95.0__tar.gz → 1.95.2__tar.gz

{cloudnetpy-1.95.0/cloudnetpy.egg-info → cloudnetpy-1.95.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.95.0
+Version: 1.95.2
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/arm.py

@@ -20,6 +20,7 @@ from cloudnetpy.instruments import (
     armld2nc,
     kazr2nc,
     mmcr2nc,
+    mwr3c2nc,
     mwrlos2nc,
 )
 
@@ -63,6 +64,8 @@ class ArmInstrument(NamedTuple):
 ARM_INSTRUMENTS: Final = (
     # KAZR2 (approx. 2019 onwards, hourly files)
     ArmInstrument("radar", "kazr", "kazrcfrge.a1", kazr2nc, multi_file=True),
+    # KAZR2 at ENA (Dec 2019 onwards, hourly files)
+    ArmInstrument("radar", "kazr", "kazr2cfrge.a1", kazr2nc, multi_file=True),
     # KAZR corrected moments (approx. 2011-2019)
     ArmInstrument("radar", "kazr", "kazrcorge.c1", kazr2nc, multi_file=True),
     # KAZR moments (approx. 2011-2019, e.g. mobile facilities)
@@ -71,6 +74,8 @@ ARM_INSTRUMENTS: Final = (
     ArmInstrument("radar", "mmcr", "mmcrmom.b1", mmcr2nc, multi_file=False),
     ArmInstrument("lidar", "cl31", "ceil.b1", armceilo2nc, multi_file=False),
     ArmInstrument("mwr", "wvr-1100", "mwrlos.b1", mwrlos2nc, multi_file=True),
+    # 3-channel MWR (e.g. ENA)
+    ArmInstrument("mwr", "mwr-3c", "mwr3c.b1", mwr3c2nc, multi_file=True),
     ArmInstrument("disdrometer", "parsivel", "ld.b1", armld2nc, multi_file=False),
 )
 

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/categorize/model.py

@@ -101,6 +101,8 @@ class Model(DataSource):
         """
         half_height = height_grid - np.diff(height_grid, prepend=self.alt_site) / 2
         for key in self.fields_dense + self.fields_atten:
+            if key not in self.data_sparse:
+                continue
             array = self.data_sparse[key][:]
             valid_profiles = _find_number_of_valid_profiles(array)
             if valid_profiles < 2:

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/instruments/__init__.py

@@ -13,6 +13,7 @@ from .kazr import kazr2nc
 from .mira import mira2nc
 from .mmcr import mmcr2nc
 from .mrr import mrr2nc
+from .mwr3c import mwr3c2nc
 from .mwrlos import mwrlos2nc
 from .pollyxt import pollyxt2nc
 from .radiometrics import radiometrics2nc

cloudnetpy-1.95.2/cloudnetpy/instruments/arm_utils.py

@@ -0,0 +1,79 @@
+"""Helpers shared by the ARM instrument readers."""
+
+import os
+from collections.abc import Sequence
+from os import PathLike
+from pathlib import Path
+
+import netCDF4
+
+from cloudnetpy.exceptions import ValidTimeStampError
+
+
+def read_geolocation(nc: netCDF4.Dataset, site_meta: dict) -> dict:
+    """Returns site_meta with lat/lon/alt filled from the file if missing."""
+    site_meta = {**site_meta}
+    for key, names in (
+        ("latitude", ("latitude", "lat")),
+        ("longitude", ("longitude", "lon")),
+        ("altitude", ("altitude", "alt")),
+    ):
+        if key in site_meta:
+            continue
+        for name in names:
+            if name in nc.variables:
+                site_meta[key] = float(nc[name][:])
+                break
+    return site_meta
+
+
+def concatenate_files(
+    raw_files: str | PathLike | Sequence[str | PathLike],
+    temp_dir: str,
+    variables: Sequence[str],
+) -> str | PathLike:
+    """Concatenates time-dimensioned `variables` of several ARM files into one.
+
+    Returns the input file as is if only one file is given.
+    """
+    files: list[Path]
+    if isinstance(raw_files, (str, PathLike)):
+        if not os.path.isdir(raw_files):
+            return raw_files
+        files = [
+            Path(raw_files) / f
+            for f in os.listdir(raw_files)
+            if f.lower().endswith((".cdf", ".nc"))
+        ]
+    else:
+        files = [Path(f) for f in raw_files]
+    files = sorted(files, key=lambda f: f.name)
+    if len(files) == 1:
+        return files[0]
+    output_file = Path(temp_dir) / "concatenated.nc"
+    with netCDF4.Dataset(output_file, "w") as nc_out:
+        nc_out.createDimension("time", None)
+        for ind, file in enumerate(files):
+            with netCDF4.Dataset(file) as nc_in:
+                if ind == 0:
+                    nc_out.setncatts({k: nc_in.getncattr(k) for k in nc_in.ncattrs()})
+                    time_units = nc_in["time"].units
+                elif nc_in["time"].units != time_units:
+                    msg = "Inconsistent time units in ARM files"
+                    raise ValidTimeStampError(msg)
+                n_time = len(nc_out.dimensions["time"])
+                for key in nc_in.variables:
+                    if key not in variables and nc_in[key].ndim != 0:
+                        continue
+                    if key not in nc_out.variables:
+                        var = nc_out.createVariable(
+                            key, nc_in[key].dtype, nc_in[key].dimensions
+                        )
+                        var.setncatts(
+                            {k: nc_in[key].getncattr(k) for k in nc_in[key].ncattrs()}
+                        )
+                        if nc_in[key].ndim == 0:
+                            var[:] = nc_in[key][:]
+                    if nc_in[key].ndim != 0:
+                        nc_out[key][n_time:] = nc_in[key][:]
+    return output_file

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/instruments/instruments.py

@@ -306,6 +306,13 @@ WVR1100 = Instrument(
     model="WVR-1100",
 )
 
+MWR3C = Instrument(
+    manufacturer="Radiometrics",
+    domain="mwr",
+    category="microwave radiometer",
+    model="MWR-3C",
+)
+
 KAZR = Instrument(
     manufacturer="ProSensing",
     domain="radar",

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/instruments/kazr.py

@@ -212,8 +212,11 @@ class Kazr(CloudnetInstrument):
         """Screens LDR using the cross-polar SNR.
 
         LDR is removed completely if the cross-polar channel shows signal in
-        noise gates (broken channel). LDR calculated from reflectivities is
-        masked in gates where the cross-polar signal is below the noise.
+        noise gates (broken channel). Otherwise LDR is masked where the
+        cross-polar signal is below the noise: there the reported LDR is only
+        an upper bound set by the noise floor, which at low SNR mimics the
+        high LDR of insects. Corrected files use the fixed `snrx_limit`, the
+        others a limit estimated from the noise in the top range gates.
         """
         if "ldr" not in self.data or "SNRx" not in self.data:
             return
@@ -223,8 +226,12 @@ class Kazr(CloudnetInstrument):
         if np.any(is_noise) and ma.median(snrx[is_noise]) > snrx_limit:
             logging.warning("Cross-polar channel unreliable, removing LDR")
             del self.data["ldr"]
-        elif self.corrected:
-            self.data["ldr"].mask_indices(np.where(snrx < snrx_limit))
+        else:
+            limit: float | np.ndarray = snrx_limit
+            if not self.corrected:
+                limit = estimate_snr_limit(snrx)[:, np.newaxis]
+            is_below = ma.filled(snrx < limit, fill_value=True)
+            self.data["ldr"].mask_indices(np.where(is_below))
         del self.data["SNRx"]
 
     def correct_ldr_leakage(self, min_ldr: float = -30, n_sigma: float = 3) -> None:

cloudnetpy-1.95.2/cloudnetpy/instruments/mwr3c.py

@@ -0,0 +1,139 @@
+"""Module for reading ARM 3-channel microwave radiometer (mwr3c) data."""
+
+import datetime
+import tempfile
+from collections.abc import Sequence
+from os import PathLike
+from uuid import UUID
+
+import numpy as np
+from numpy import ma
+
+from cloudnetpy import output, utils
+from cloudnetpy.datasource import DataSource
+from cloudnetpy.exceptions import ValidTimeStampError
+from cloudnetpy.instruments.arm_utils import concatenate_files, read_geolocation
+from cloudnetpy.instruments.cloudnet_instrument import CloudnetInstrument
+from cloudnetpy.instruments.instruments import MWR3C
+from cloudnetpy.metadata import COMMON_ATTRIBUTES
+
+CM_TO_KG_M2 = 10
+MISSING_VALUE = -9999
+MAX_OFF_ZENITH = 1.0  # deg
+RAW_VARIABLES = (
+    "time",
+    "lwp",
+    "pwv",
+    "elevation",
+    "rain_flag",
+    "qc_tbsky23",
+    "qc_tbsky31",
+)
+
+
+def mwr3c2nc(
+    raw_files: str | PathLike | Sequence[str | PathLike],
+    output_file: str | PathLike,
+    site_meta: dict,
+    uuid: str | UUID | None = None,
+    date: str | datetime.date | None = None,
+) -> UUID:
+    """Converts ARM 3-channel microwave radiometer retrievals (mwr3c) into
+    Cloudnet Level 1b netCDF file.
+
+    Args:
+        raw_files: ARM `mwr3c` netCDF file (e.g.
+            `enamwr3cC1.b1.20240315.000004.nc`), a sequence of files, or a
+            folder containing the files of one day.
+        output_file: Output filename.
+        site_meta: Dictionary containing information about the site. Required key
+            value pair is `name`. Optional are `latitude`, `longitude` and
+            `altitude` (taken from the raw file if missing).
+        uuid: Set specific UUID for the file.
+        date: Expected date as YYYY-MM-DD of all profiles in the file.
+
+    Returns:
+        UUID of the generated file.
+
+    Raises:
+        ValidTimeStampError: No valid timestamps found.
+
+    Examples:
+          >>> from cloudnetpy.instruments import mwr3c2nc
+          >>> site_meta = {'name': 'Graciosa'}
+          >>> mwr3c2nc('enamwr3cC1.b1.20240315.000004.nc', 'mwr.nc', site_meta)
+
+    """
+    if isinstance(date, str):
+        date = datetime.date.fromisoformat(date)
+    uuid = utils.get_uuid(uuid)
+    with tempfile.TemporaryDirectory() as temp_dir:
+        raw_file = concatenate_files(raw_files, temp_dir, RAW_VARIABLES)
+        with Mwr3c(raw_file, site_meta) as mwr:
+            if date is not None:
+                mwr.check_date(date)
+            mwr.init_data()
+            mwr.sort_timestamps()
+            mwr.remove_duplicate_timestamps()
+            mwr.screen_invalid_values()
+            mwr.add_zenith_angle()
+            mwr.add_site_geolocation()
+    attributes = output.add_time_attribute(ATTRIBUTES, mwr.date)
+    output.update_attributes(mwr.data, attributes)
+    output.save_level1b(mwr, output_file, uuid)
+    return uuid
+
+
+class Mwr3c(DataSource, CloudnetInstrument):
+    """Class for ARM mwr3c data.
+
+    Args:
+        full_path: Filename of a daily ARM mwr3c netCDF file.
+        site_meta: Site properties in a dictionary. Required keys are: `name`.
+
+    """
+
+    def __init__(self, full_path: str | PathLike, site_meta: dict) -> None:
+        super().__init__(full_path)
+        self.site_meta = {**site_meta}
+        self.instrument = MWR3C
+        self.date = utils.get_epoch(self.dataset["time"].units).date()
+        serial_number = getattr(self.dataset, "serial_number", None)
+        self.serial_number = serial_number.strip() if serial_number else None
+        self._add_geolocation_from_file()
+
+    def init_data(self) -> None:
+        self.append_data(np.array(self.time), "time", dtype="f8")
+        for key, name, factor in (("lwp", "lwp", 1), ("pwv", "iwv", CM_TO_KG_M2)):
+            data = ma.masked_invalid(self.getvar(key))
+            data = ma.masked_equal(data, MISSING_VALUE) * factor
+            self.append_data(data, name)
+
+    def check_date(self, date: datetime.date) -> None:
+        if self.date != date:
+            raise ValidTimeStampError
+
+    def screen_invalid_values(self) -> None:
+        """Masks rainy, off-zenith and flagged retrievals."""
+        is_invalid = np.zeros(len(self.data["time"].data), dtype=bool)
+        if "rain_flag" in self.dataset.variables:
+            is_invalid |= ma.filled(self.getvar("rain_flag"), 0) > 0
+        if "elevation" in self.dataset.variables:
+            elevation = ma.filled(self.getvar("elevation"), MISSING_VALUE)
+            is_invalid |= np.abs(elevation - 90) > MAX_OFF_ZENITH
+        for key in ("qc_tbsky23", "qc_tbsky31"):
+            if key in self.dataset.variables:
+                is_invalid |= ma.filled(self.getvar(key), 0) != 0
+        for key in ("lwp", "iwv"):
+            self.data[key].data[is_invalid] = ma.masked
+
+    def add_zenith_angle(self) -> None:
+        self.append_data(0.0, "zenith_angle")
+
+    def _add_geolocation_from_file(self) -> None:
+        self.site_meta = read_geolocation(self.dataset, self.site_meta)
+
+
+ATTRIBUTES = {
+    "zenith_angle": COMMON_ATTRIBUTES["zenith_angle"]._replace(dimensions=None),
+}

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/instruments/mwrlos.py

@@ -1,26 +1,24 @@
 """Module for reading ARM microwave radiometer line-of-sight (mwrlos) data."""
 
 import datetime
-import os
 import tempfile
 from collections.abc import Sequence
 from os import PathLike
-from pathlib import Path
 from uuid import UUID
 
-import netCDF4
 import numpy as np
 from numpy import ma
 
 from cloudnetpy import output, utils
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.exceptions import ValidTimeStampError
-from cloudnetpy.instruments.arm_utils import read_geolocation
+from cloudnetpy.instruments.arm_utils import concatenate_files, read_geolocation
 from cloudnetpy.instruments.cloudnet_instrument import CloudnetInstrument
 from cloudnetpy.instruments.instruments import WVR1100
 from cloudnetpy.metadata import COMMON_ATTRIBUTES
 
 CM_TO_KG_M2 = 10
+RAW_VARIABLES = ("time", "liq", "vap", "qc_liq", "qc_vap", "wet_window")
 
 
 def mwrlos2nc(
@@ -60,7 +58,7 @@ def mwrlos2nc(
         date = datetime.date.fromisoformat(date)
     uuid = utils.get_uuid(uuid)
     with tempfile.TemporaryDirectory() as temp_dir:
-        raw_file = _concatenate(raw_files, temp_dir)
+        raw_file = concatenate_files(raw_files, temp_dir, RAW_VARIABLES)
         with MwrLos(raw_file, site_meta) as mwr:
             if date is not None:
                 mwr.check_date(date)
@@ -76,53 +74,6 @@ def mwrlos2nc(
     return uuid
 
 
-def _concatenate(
-    raw_files: str | PathLike | Sequence[str | PathLike], temp_dir: str
-) -> str | PathLike:
-    files: list[Path]
-    if isinstance(raw_files, (str, PathLike)):
-        if not os.path.isdir(raw_files):
-            return raw_files
-        files = [
-            Path(raw_files) / f
-            for f in os.listdir(raw_files)
-            if f.lower().endswith((".cdf", ".nc"))
-        ]
-    else:
-        files = [Path(f) for f in raw_files]
-    files = sorted(files, key=lambda f: f.name)
-    if len(files) == 1:
-        return files[0]
-    output_file = Path(temp_dir) / "mwrlos.nc"
-    variables = ("time", "liq", "vap", "qc_liq", "qc_vap", "wet_window")
-    with netCDF4.Dataset(output_file, "w") as nc_out:
-        nc_out.createDimension("time", None)
-        for ind, file in enumerate(files):
-            with netCDF4.Dataset(file) as nc_in:
-                if ind == 0:
-                    nc_out.setncatts({k: nc_in.getncattr(k) for k in nc_in.ncattrs()})
-                    time_units = nc_in["time"].units
-                elif nc_in["time"].units != time_units:
-                    msg = "Inconsistent time units in mwrlos files"
-                    raise ValidTimeStampError(msg)
-                n_time = len(nc_out.dimensions["time"])
-                for key in nc_in.variables:
-                    if key not in variables and nc_in[key].ndim != 0:
-                        continue
-                    if key not in nc_out.variables:
-                        var = nc_out.createVariable(
-                            key, nc_in[key].dtype, nc_in[key].dimensions
-                        )
-                        var.setncatts(
-                            {k: nc_in[key].getncattr(k) for k in nc_in[key].ncattrs()}
-                        )
-                        if nc_in[key].ndim == 0:
-                            var[:] = nc_in[key][:]
-                    if nc_in[key].ndim != 0:
-                        nc_out[key][n_time:] = nc_in[key][:]
-    return output_file
-
-
 class MwrLos(DataSource, CloudnetInstrument):
     """Class for ARM mwrlos data.
 

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/plotting/plotting.py

@@ -1293,6 +1293,7 @@ def _get_max_gap_in_minutes(figure_data: FigureData) -> float:
         "radar": 5,
         "cpr-simulation": 60,
         "weather-radar": 20,
+        "iwc-weather-radar": 20,
     }
     return max_allowed_gap.get(file_type, 10)
 

cloudnetpy-1.95.2/cloudnetpy/products/iwc_weather_radar.py

@@ -0,0 +1,106 @@
+from os import PathLike
+from uuid import UUID
+
+import numpy as np
+from numpy import ma
+
+from cloudnetpy import output, utils
+from cloudnetpy.categorize.disdrometer import DataSource
+from cloudnetpy.categorize.model import Model
+from cloudnetpy.cloudnetarray import CloudnetArray
+from cloudnetpy.constants import T0
+from cloudnetpy.metadata import COMMON_ATTRIBUTES, MetaData
+
+
+def generate_iwc_from_weather_radar(
+    weather_radar_file: str | PathLike,
+    model_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
+    uuid = utils.get_uuid(uuid)
+    radar = WrRadar(weather_radar_file)
+    if radar.altitude is None:
+        msg = "Altitude is missing"
+        raise ValueError(msg)
+    if radar.height is None or radar.height_agl is None:
+        msg = "Height is missing"
+        raise ValueError(msg)
+    model = Model(model_file, radar.altitude)
+    model.interpolate_to_common_height()
+    model.interpolate_to_grid(radar.time, radar.height)
+
+    height_agl = radar.height_agl
+    z = radar.data["Z"][:]
+    v = radar.data["v"][:]
+    rho_hv = radar.data["rho_hv"][:]
+    temp = model.data_dense["temperature"]
+
+    is_noise = (height_agl < 3000) & (rho_hv < 0.8) & (z < -20)
+    is_ice = (z > -30) & (np.abs(v) < 2) & (temp < T0)
+    is_rain = (z > 10) & (v < 0) & (temp > T0 - 10)
+
+    output_data = {
+        "time": CloudnetArray(radar.time, "time"),
+        "height": CloudnetArray(radar.height, "height"),
+        "radar_frequency": CloudnetArray(radar.radar_frequency, "radar_frequency"),
+    }
+
+    z_rain = ma.masked_where(is_noise | ~is_rain, z)
+    rainfall_rate = (utils.db2lin(z_rain) / 200) ** 0.625  # Marshall-Palmer
+    output_data["rainfall_rate"] = CloudnetArray(
+        rainfall_rate * 1e-3 / 3600, "rainfall_rate"
+    )
+
+    z_ice = ma.masked_where(is_noise | is_rain | ~is_ice, z)
+    iwc = ma.power(10, 0.060 * z_ice - 0.0197 * temp - 1.70)  # Hogan et al. (2006)
+    output_data["iwc"] = CloudnetArray(1000 * iwc, "iwc")
+
+    date = radar.get_date()
+    attributes = output.add_time_attribute(WEATHER_RADAR_RET_ATTRIBUTES, date)
+    output.update_attributes(output_data, attributes)
+
+    dimensions = {"time": len(radar.time), "height": len(radar.height)}
+    with output.init_file(output_file, dimensions, output_data, uuid) as nc:
+        nc.cloudnet_file_type = "iwc-weather-radar"
+        vars_from_source = (
+            "altitude",
+            "latitude",
+            "longitude",
+        )
+        output.copy_variables(radar.dataset, nc, vars_from_source)
+        output.copy_global(radar.dataset, nc, ("year", "month", "day", "location"))
+        nc.title = f"Ice water content (weather radar) retrieval from {radar.location}"
+        nc.source = "\n".join(sorted([radar.source, model.source]))
+        nc.source_file_uuids = output.get_source_uuids([radar, model])
+        output.merge_history(nc, nc.cloudnet_file_type, radar, (model,))
+
+    return uuid
+
+
+class WrRadar(DataSource):
+    def __init__(self, full_path: str | PathLike) -> None:
+        super().__init__(full_path, radar=True)
+        self.radar_frequency = float(self.getvar("radar_frequency"))
+        self.location = getattr(self.dataset, "location", "")
+        self._init_data()
+
+    def _init_data(self) -> None:
+        self.append_data(self.getvar("Zh"), "Z", units="dBZ")
+        self.append_data(self.getvar("v"), "v")
+        self.append_data(self.getvar("rho_hv"), "rho_hv")
+
+
+WEATHER_RADAR_RET_ATTRIBUTES = {
+    "height": COMMON_ATTRIBUTES["height"]._replace(dimensions=("height",)),
+    "iwc": MetaData(
+        long_name="Ice water content",
+        units="kg m-3",
+        dimensions=("time", "height"),
+    ),
+    "rainfall_rate": MetaData(
+        long_name="Rainfall rate",
+        units="m s-1",
+        dimensions=("time", "height"),
+    ),
+}

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
 MINOR = 95
-PATCH = 0
+PATCH = 2
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2/cloudnetpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.95.0
+Version: 1.95.2
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.95.0 → cloudnetpy-1.95.2}/cloudnetpy.egg-info/SOURCES.txt

@@ -71,6 +71,7 @@ cloudnetpy/instruments/lufft.py
 cloudnetpy/instruments/mira.py
 cloudnetpy/instruments/mmcr.py
 cloudnetpy/instruments/mrr.py
+cloudnetpy/instruments/mwr3c.py
 cloudnetpy/instruments/mwrlos.py
 cloudnetpy/instruments/nc_lidar.py
 cloudnetpy/instruments/nc_radar.py
@@ -136,6 +137,7 @@ cloudnetpy/products/epsilon_lidar.py
 cloudnetpy/products/epsilon_radar.py
 cloudnetpy/products/ier.py
 cloudnetpy/products/iwc.py
+cloudnetpy/products/iwc_weather_radar.py
 cloudnetpy/products/lwc.py
 cloudnetpy/products/mie_lu_tables.nc
 cloudnetpy/products/mwr_tools.py

cloudnetpy-1.95.0/cloudnetpy/instruments/arm_utils.py

@@ -1,20 +0,0 @@
-"""Helpers shared by the ARM instrument readers."""
-
-import netCDF4
-
-
-def read_geolocation(nc: netCDF4.Dataset, site_meta: dict) -> dict:
-    """Returns site_meta with lat/lon/alt filled from the file if missing."""
-    site_meta = {**site_meta}
-    for key, names in (
-        ("latitude", ("latitude", "lat")),
-        ("longitude", ("longitude", "lon")),
-        ("altitude", ("altitude", "alt")),
-    ):
-        if key in site_meta:
-            continue
-        for name in names:
-            if name in nc.variables:
-                site_meta[key] = float(nc[name][:])
-                break
-    return site_meta