cloudnetpy 1.90.0__tar.gz → 1.90.2__tar.gz

{cloudnetpy-1.90.0/cloudnetpy.egg-info → cloudnetpy-1.90.2}/PKG-INFO

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

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/categorize/categorize.py

@@ -22,7 +22,6 @@ from cloudnetpy.categorize.mwr import Mwr
 from cloudnetpy.categorize.radar import Radar
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.exceptions import DisdrometerDataError, ValidTimeStampError
-from cloudnetpy.instruments.rpg import RPG_ATTRIBUTES
 from cloudnetpy.metadata import COMMON_ATTRIBUTES, MetaData
 from cloudnetpy.products.product_tools import CategoryBits, QualityBits
 
@@ -436,7 +435,7 @@ CATEGORIZE_ATTRIBUTES = {
         units="m s-1",
         dimensions=("time", "height"),
     ),
-    "zdr": RPG_ATTRIBUTES["zdr"]._replace(dimensions=("time", "height")),
+    "zdr": COMMON_ATTRIBUTES["zdr"]._replace(dimensions=("time", "height")),
     "nyquist_velocity": COMMON_ATTRIBUTES["nyquist_velocity"]._replace(
         dimensions=("time", "height")
     ),

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/constants.py

@@ -27,9 +27,11 @@ G_TO_KG: Final = 1e-3
 M_TO_KM: Final = 1e-3
 KG_TO_G: Final = 1e3
 M_TO_MM: Final = 1e3
+CM_TO_M: Final = 1e-2
 M_S_TO_MM_H: Final = SEC_IN_HOUR / MM_TO_M
 MM_H_TO_M_S: Final = 1 / M_S_TO_MM_H
 GHZ_TO_HZ: Final = 1e9
+HZ_TO_GHZ: Final = 1e-9
 HPA_TO_PA: Final = 100
 PA_TO_HPA: Final = 1 / HPA_TO_PA
 KM_H_TO_M_S: Final = 1000 / SEC_IN_HOUR

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/instruments/__init__.py

@@ -13,4 +13,5 @@ from .pollyxt import pollyxt2nc
 from .radiometrics import radiometrics2nc
 from .rain_e_h3 import rain_e_h32nc
 from .rpg import rpg2nc
+from .weather_radar import wr2nc
 from .weather_station import ws2nc

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/instruments/instruments.py

@@ -216,31 +216,38 @@ RD80 = Instrument(
 PLUVIO2 = Instrument(
     manufacturer="OTT HydroMet",
     domain="rain-gauge",
-    category="rain-gauge",
+    category="rain gauge",
     model="Pluvio2",
 )
 
 PLUVIO2S = Instrument(
     manufacturer="OTT HydroMet",
     domain="rain-gauge",
-    category="rain-gauge",
+    category="rain gauge",
     model="Pluvio2S",
 )
 
 THIES_PT = Instrument(
     manufacturer="Thies Clima",
     domain="rain-gauge",
-    category="rain-gauge",
+    category="rain gauge",
     model="Precipitation Transmitter",
 )
 
 RAIN_E_H3 = Instrument(
     manufacturer="LAMBRECHT meteo GmbH",
     domain="rain-gauge",
-    category="rain-gauge",
+    category="rain gauge",
     model="rain[e]H3",
 )
 
+WRM200 = Instrument(
+    manufacturer="Vaisala",
+    domain="weather-radar",
+    category="weather radar",
+    model="WRM200",
+)
+
 GENERIC_WEATHER_STATION = Instrument(
     domain="weather-station",
     category="weather station",

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/instruments/rain_e_h3.py

@@ -19,7 +19,7 @@ def rain_e_h32nc(
     uuid: str | UUID | None = None,
     date: str | datetime.date | None = None,
 ) -> UUID:
-    """Converts rain_e_h3 rain-gauge into Cloudnet Level 1b netCDF file.
+    """Converts rain_e_h3 rain gauge into Cloudnet Level 1b netCDF file.
 
     Args:
         input_file: Filename of rain_e_h3 CSV file.

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/instruments/rpg.py

@@ -471,12 +471,6 @@ RPG_ATTRIBUTES = {
         dimensions=("time", "range"),
     ),
     # STSR-mode radars
-    "zdr": MetaData(
-        long_name="Differential reflectivity", units="dB", dimensions=("time", "range")
-    ),
-    "rho_hv": MetaData(
-        long_name="Correlation coefficient", units="1", dimensions=("time", "range")
-    ),
     "phi_dp": MetaData(
         long_name="Differential phase", units="rad", dimensions=("time", "range")
     ),

cloudnetpy-1.90.2/cloudnetpy/instruments/weather_radar.py

@@ -0,0 +1,199 @@
+import datetime
+from collections import defaultdict
+from collections.abc import Iterable, Sequence
+from os import PathLike
+from uuid import UUID
+
+import netCDF4
+import numpy as np
+import numpy.typing as npt
+from numpy import ma
+
+from cloudnetpy import output, utils
+from cloudnetpy.cloudnetarray import CloudnetArray
+from cloudnetpy.constants import CM_TO_M, HZ_TO_GHZ, M_TO_KM, SPEED_OF_LIGHT
+from cloudnetpy.instruments import instruments
+from cloudnetpy.instruments.cloudnet_instrument import CloudnetInstrument
+from cloudnetpy.metadata import MetaData
+
+
+def wr2nc(
+    input_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 OPERA HDF5 weather radar data into Cloudnet Level 1b netCDF file.
+
+    Args:
+        input_files: List of OPERA HDF5 files.
+        output_file: Output filename.
+        site_meta: Dictionary containing information about the site. Required
+            keys are `name`, `latitude`, `longitude` and `altitude`.
+        uuid: Set specific UUID for the file.
+        date: Expected date as YYYY-MM-DD.
+
+    Returns:
+        UUID of the generated file.
+    """
+    if isinstance(date, str):
+        date = datetime.date.fromisoformat(date)
+    uuid = utils.get_uuid(uuid)
+    if isinstance(input_files, str | PathLike):
+        input_files = [input_files]
+    wr = WeatherRadar(input_files, site_meta, date)
+    wr.sort_and_dedup_timestamps()
+    wr.convert_to_cloudnet_arrays()
+    wr.screen_noise()
+    wr.add_meta()
+    attributes = output.add_time_attribute(ATTRIBUTES, wr.date)
+    output.update_attributes(wr.data, attributes)
+    output.save_level1b(wr, output_file, uuid)
+    return uuid
+
+
+class WeatherRadar(CloudnetInstrument):
+    def __init__(
+        self,
+        filenames: Iterable[str | PathLike],
+        site_meta: dict,
+        expected_date: datetime.date | None = None,
+    ) -> None:
+        super().__init__()
+        self.site_meta = site_meta
+        self._read_data(filenames)
+        self._screen_time(expected_date)
+        self.instrument = instruments.WRM200
+
+    def _read_data(self, filenames: Iterable[str | PathLike]) -> None:
+        times = []
+        ranges = []
+        data = []
+        for filename in filenames:
+            file_time, file_range, file_data, file_scalars = _read_opera_h5(filename)
+            times.append(file_time)
+            ranges.append(file_range)
+            data.append(file_data)
+        target_range = max(ranges, key=lambda rng: rng[-1])
+        all_data = defaultdict(list)
+        for src_range, values in zip(ranges, data, strict=True):
+            for key, value in values.items():
+                block = ma.array([value])
+                if not np.array_equal(src_range, target_range):
+                    block = utils.interpolate_2D_along_y(src_range, block, target_range)
+                all_data[key].append(block)
+        self.raw_time = np.array(times)
+        self.raw_range = target_range
+        self.raw_data = {key: ma.concatenate(value) for key, value in all_data.items()}
+        self.scalars = file_scalars
+
+    def _screen_time(self, expected_date: datetime.date | None = None) -> None:
+        if expected_date is None:
+            self.date = self.raw_time[0].date()
+        else:
+            is_valid = [dt.date() == expected_date for dt in self.raw_time]
+            self.raw_time = self.raw_time[is_valid]
+            for key in self.raw_data:
+                self.raw_data[key] = self.raw_data[key][is_valid]
+            self.date = expected_date
+
+    def sort_and_dedup_timestamps(self) -> None:
+        self.raw_time, time_ind = np.unique(self.raw_time, return_index=True)
+        for key in self.raw_data:
+            self.raw_data[key] = self.raw_data[key][time_ind]
+
+    def add_meta(self) -> None:
+        valid_keys = ("latitude", "longitude", "altitude")
+        for key, value in self.site_meta.items():
+            name = key.lower()
+            if name in valid_keys:
+                self.data[name] = CloudnetArray(float(value), name)
+
+    def convert_to_cloudnet_arrays(self) -> None:
+        epoch = datetime.datetime.combine(self.date, datetime.time())
+        hour = (self.raw_time - epoch) / datetime.timedelta(hours=1)
+        height = self.site_meta["altitude"] + self.raw_range
+        self.data["time"] = CloudnetArray(hour.astype(np.float32), "time")
+        self.data["range"] = CloudnetArray(self.raw_range, "range")
+        self.data["height"] = CloudnetArray(height, "height")
+        self.data["SNR"] = CloudnetArray(self.raw_data["SNR"], "SNR")
+        self.data["Zh"] = CloudnetArray(self.raw_data["ZH"], "Zh")
+        self.data["v"] = CloudnetArray(self.raw_data["VRADH"], "v")
+        self.data["width"] = CloudnetArray(self.raw_data["WRADH"], "width")
+        self.data["zdr"] = CloudnetArray(self.raw_data["ZDR"], "zdr")
+        self.data["rho_hv"] = CloudnetArray(self.raw_data["RHOHV"], "rho_hv")
+        self.data["radar_frequency"] = CloudnetArray(
+            self.scalars["FREQ"], "radar_frequency"
+        )
+        self.data["nyquist_velocity"] = CloudnetArray(
+            self.scalars["NI"], "nyquist_velocity"
+        )
+        self.data["calibration_reflectivity_factor"] = CloudnetArray(
+            self.scalars["NEZ"], "calibration_reflectivity_factor"
+        )
+
+    def screen_noise(self) -> None:
+        is_noise = self.data["SNR"].data < 0
+        for cloudnet_array in self.data.values():
+            if cloudnet_array.data.ndim == 2:
+                cloudnet_array.mask_indices(is_noise)
+
+
+def _read_opera_h5(
+    file: str | PathLike,
+) -> tuple[datetime.datetime, npt.NDArray, dict[str, npt.NDArray], dict[str, float]]:
+    all_data = {}
+    with netCDF4.Dataset(file) as rootgrp:
+        date = rootgrp["what"].date
+        time = rootgrp["what"].time
+        dt = datetime.datetime.strptime(date + time, "%Y%m%d%H%M%S")
+
+        dataset = rootgrp["dataset1"]
+        nbins = dataset["where"].nbins
+        # NOTE: rstart is documented to be in km, but it's actually in m at
+        # least for FMI radars.
+        rstart = dataset["where"].nbins
+        rscale = dataset["where"].rscale  # m
+        halfbin = rscale / 2
+        rng = rstart + halfbin + rscale * np.arange(nbins)
+
+        nez = dataset["how"].NEZH
+        ni = dataset["how"].NI
+        wavelength = rootgrp["how"].wavelength * CM_TO_M
+        frequency = HZ_TO_GHZ * SPEED_OF_LIGHT / wavelength
+        scalars = {"NEZ": nez, "NI": ni, "FREQ": frequency}
+
+        grpnames = [group for group in dataset.groups if group.startswith("data")]
+        for grpname in grpnames:
+            grp = dataset[grpname]
+            quantity = grp["what"].quantity
+            is_db = quantity in ("ZDR", "SNR")
+            offset = grp["what"].offset
+            gain = grp["what"].gain
+            nodata = grp["what"].nodata
+            undetect = grp["what"].undetect
+            grpdata = grp["data"][:]
+            is_masked = (grpdata == nodata) | (grpdata == undetect)
+            grpdata = offset + gain * ma.masked_where(is_masked, grpdata)
+            if is_db:
+                grpdata = utils.db2lin(grpdata)
+            grpdata = ma.mean(grpdata, axis=0)
+            if is_db:
+                grpdata = utils.lin2db(grpdata)
+            all_data[quantity] = grpdata
+
+        all_data["ZH"] = all_data["SNR"] + nez + 20 * np.log10(rng * M_TO_KM)
+
+    return dt, rng, all_data, scalars
+
+
+ATTRIBUTES = {
+    "calibration_reflectivity_factor": MetaData(
+        long_name="Calibration reflectivity factor",
+        comment="This parameter is the equivalent radar reflectivity factor at 1 km\n"
+        "when the return signal power is equal to the noise power (SNR=0 dB).",
+        units="dBZ",
+        dimensions=(),
+    )
+}

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/instruments/weather_station.py

@@ -399,7 +399,7 @@ class KenttarovaWS(WS):
 
 
 class HyytialaWS(WS):
-    """Hyytiälä rain-gauge variables: a = Pluvio400 and b = Pluvio200.
+    """Hyytiälä rain gauge variables: a = Pluvio400 and b = Pluvio200.
     E.g.
     - AaRNRT/mm = amount of non-real-time rain total (Pluvio400) [mm]
     - BbRT/mm = Bucket content in real-time (Pluvio200) [mm].

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/metadata.py

@@ -170,6 +170,12 @@ COMMON_ATTRIBUTES = {
     "SNR": MetaData(
         long_name="Signal-to-noise ratio", units="dB", dimensions=("time", "range")
     ),
+    "zdr": MetaData(
+        long_name="Differential reflectivity", units="dB", dimensions=("time", "range")
+    ),
+    "rho_hv": MetaData(
+        long_name="Correlation coefficient", units="1", dimensions=("time", "range")
+    ),
     "relative_humidity": MetaData(
         long_name="Relative humidity",
         standard_name="relative_humidity",

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/plotting/plotting.py

@@ -710,9 +710,9 @@ class Plot2D(Plot):
         cbar, clabel = _hide_segments()
         alt = self._screen_data_by_max_y(figure_data)
         image = self._ax.pcolorfast(
-            figure_data.time_including_gaps,
-            alt,
-            self._data.T[:-1, :-1],
+            _make_edges(figure_data.time_including_gaps),
+            _make_edges(alt),
+            self._data.T,
             cmap=ListedColormap(cbar),
             vmin=-0.5,
             vmax=len(cbar) - 0.5,
@@ -752,21 +752,12 @@ class Plot2D(Plot):
             "zorder": _get_zorder("data"),
         }
         image: Any
-        if getattr(figure_data.file, "cloudnet_file_type", "") == "model":
-            image = self._ax.pcolor(
-                figure_data.time_including_gaps,
-                alt,
-                self._data.T,
-                **pcolor_kwargs,
-                shading="nearest",
-            )
-        else:
-            image = self._ax.pcolorfast(
-                figure_data.time_including_gaps,
-                alt,
-                self._data.T[:-1, :-1],
-                **pcolor_kwargs,
-            )
+        image = self._ax.pcolorfast(
+            _make_edges(figure_data.time_including_gaps),
+            _make_edges(alt),
+            self._data.T,
+            **pcolor_kwargs,
+        )
         cbar = self._init_colorbar(image)
         cbar.set_label(str(self._plot_meta.clabel), fontsize=13)
 
@@ -1212,6 +1203,7 @@ def _get_max_gap_in_minutes(figure_data: FigureData) -> float:
         "epsilon-lidar": 75,
         "radar": 5,
         "cpr-simulation": 60,
+        "weather-radar": 20,
     }
     return max_allowed_gap.get(file_type, 10)
 
@@ -1225,6 +1217,14 @@ def _get_zorder(name: str) -> int:
     return zorder.get(name, -1)
 
 
+def _make_edges(centers: npt.NDArray) -> npt.NDArray:
+    edges = np.empty(len(centers) + 1)
+    edges[0] = centers[0] - (centers[1] - centers[0]) / 2
+    edges[1:-1] = (centers[:-1] + centers[1:]) / 2
+    edges[-1] = centers[-1] + (centers[-1] - centers[-2]) / 2
+    return edges
+
+
 def find_batches_of_ones(array: ndarray) -> list[tuple[int, int]]:
     """Find batches of ones in a binary array."""
     starts = np.where(np.diff(np.hstack(([0], array))) == 1)[0]

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy/version.py

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

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2/cloudnetpy.egg-info}/PKG-INFO

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

{cloudnetpy-1.90.0 → cloudnetpy-1.90.2}/cloudnetpy.egg-info/SOURCES.txt

@@ -72,6 +72,7 @@ cloudnetpy/instruments/rpg.py
 cloudnetpy/instruments/rpg_reader.py
 cloudnetpy/instruments/toa5.py
 cloudnetpy/instruments/vaisala.py
+cloudnetpy/instruments/weather_radar.py
 cloudnetpy/instruments/weather_station.py
 cloudnetpy/instruments/disdrometer/__init__.py
 cloudnetpy/instruments/disdrometer/common.py