cloudnetpy 1.95.7__tar.gz → 1.96.1__tar.gz

{cloudnetpy-1.95.7/cloudnetpy.egg-info → cloudnetpy-1.96.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.95.7
+Version: 1.96.1
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License
@@ -38,7 +38,7 @@ Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: atmoslib>=2.0.0
+Requires-Dist: atmoslib>=2.4.2
 Requires-Dist: ceilopyter>=0.2.0
 Requires-Dist: cloudnet-api-client
 Requires-Dist: doppy>=0.5.0

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/cli.py

@@ -62,9 +62,11 @@ def run(args: argparse.Namespace, tmpdir: str, client: APIClient) -> None:
     process_categorize = "categorize" in args.products
     cat_filepath = None
     if is_arm and cat_products and not process_categorize:
-        # ARM categorize files are not in the data portal: use a local one
+        # Prefer a local file, then the portal; process only if neither exists
         if not ARM_PRODUCTS & set(args.products):
             cat_filepath = _find_existing_categorize(args)
+        if cat_filepath is None:
+            cat_filepath = _fetch_product(args, "categorize", client)
         process_categorize = cat_filepath is None
 
     # Instrument based products

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/disdronator/lpm.py

@@ -1,4 +1,5 @@
 import datetime
+import logging
 from collections import defaultdict
 from os import PathLike
 from typing import TypeAlias
@@ -109,9 +110,18 @@ def read_lpm(filename: str | PathLike) -> tuple[npt.NDArray, dict[int, npt.NDArr
 
 
 def read_lpm_l1(
-    time: npt.NDArray, l0: dict[int, npt.NDArray], au: int | None = None
+    time: npt.NDArray,
+    l0: dict[int, npt.NDArray],
+    au: int | None = None,
+    altitude: float | None = None,
 ) -> DisdroL1:
-    area_nom = 4600 * 1000 / au if au is not None else 4560
+    if au is None:
+        area_nom = 4560.0
+        logging.warning(
+            "No AU parameter given, assuming nominal sampling area: %d mm2", area_nom
+        )
+    else:
+        area_nom = 4600.0 * 1000.0 / au
     area_eff = area_nom * (1 - D / (2 * LASER_WIDTH))
     data_raw = np.stack([l0[i] for i in range(81, 521)], axis=1).reshape(
         (len(time), len(D), len(V))
@@ -128,6 +138,7 @@ def read_lpm_l1(
         area_nom=area_nom,
         area_eff=area_eff,
         data_raw=data_raw,
+        altitude=altitude,
     )
 
 

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/disdronator/parsivel.py

@@ -522,7 +522,9 @@ def read_parsivel(
     return np.array(time), convert_to_numpy(data, {}, INT_KEYS, FLOAT_KEYS)
 
 
-def read_parsivel_l1(time: npt.NDArray, l0: dict[int, npt.NDArray]) -> DisdroL1:
+def read_parsivel_l1(
+    time: npt.NDArray, l0: dict[int, npt.NDArray], altitude: float | None = None
+) -> DisdroL1:
     if 93 not in l0:
         msg = "No raw data"
         raise ValueError(msg)
@@ -544,6 +546,7 @@ def read_parsivel_l1(time: npt.NDArray, l0: dict[int, npt.NDArray]) -> DisdroL1:
         area_nom=AREA_NOM,
         area_eff=AREA_EFF,
         data_raw=data_raw,
+        altitude=altitude,
     )
 
 

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/disdronator/process.py

@@ -20,6 +20,7 @@ class DisdroL1:
     area_nom: float
     area_eff: npt.NDArray | None
     data_raw: npt.NDArray
+    altitude: float | None
 
 
 @dataclass
@@ -43,6 +44,7 @@ class DisdroL2:
     radar_refl: npt.NDArray
     energy_flux: npt.NDArray
     visibility: npt.NDArray
+    altitude: float | None
 
 
 def process_l2(l1: DisdroL1) -> DisdroL2:
@@ -112,7 +114,7 @@ def process_l2(l1: DisdroL1) -> DisdroL2:
         fall_velocity = ma.divide(
             np.sum(l1.velocity * spec, axis=2), np.sum(spec, axis=2)
         )
-        is_rain = make_rain_mask(l1.diameter, l1.velocity)
+        is_rain = make_rain_mask(l1.diameter, l1.velocity, altitude=l1.altitude)
         spec_rain = np.copy(spec)
         spec_rain[:, ~is_rain] = 0
         rain_amount = (
@@ -190,4 +192,5 @@ def process_l2(l1: DisdroL1) -> DisdroL2:
         radar_refl=radar_refl_db,
         energy_flux=energy_flux,
         visibility=visibility,
+        altitude=l1.altitude,
     )

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/disdronator/rd80.py

@@ -1,4 +1,5 @@
 import datetime
+import logging
 from os import PathLike
 
 import numpy as np
@@ -35,7 +36,14 @@ def read_rd80(filename: str | PathLike) -> tuple[npt.NDArray, dict[str, npt.NDAr
     return np.array(time), convert_to_numpy(data)
 
 
-def read_rd80_l1(time: npt.NDArray, l0: dict[str, npt.NDArray]) -> DisdroL1:
+def read_rd80_l1(
+    time: npt.NDArray, l0: dict[str, npt.NDArray], altitude: float | None = None
+) -> DisdroL1:
+    if altitude is not None:
+        logging.warning(
+            "Altitude given but the correction for non-sea-level "
+            "conditions is not implemented for RD-80."
+        )
     return DisdroL1(
         diameter=D,
         diameter_spread=D_SPREAD,
@@ -48,6 +56,7 @@ def read_rd80_l1(time: npt.NDArray, l0: dict[str, npt.NDArray]) -> DisdroL1:
         area_nom=AREA_NOM,
         area_eff=None,
         data_raw=l0["n"],
+        altitude=altitude,
     )
 
 

cloudnetpy-1.96.1/cloudnetpy/disdronator/utils.py

@@ -0,0 +1,69 @@
+import logging
+from collections.abc import Container
+
+import numpy as np
+import numpy.typing as npt
+from atmoslib import isa_air_density
+from atmoslib.constants import RHO_STD
+from numpy import ma
+
+
+def convert_to_numpy(
+    data: dict,
+    fill_values: dict | None = None,
+    int_keys: Container | None = None,
+    float_keys: Container | None = None,
+) -> dict:
+    output = {}
+    for key, value in data.items():
+        arr = np.array(value)
+        if fill_values is not None and key in fill_values:
+            arr = ma.masked_where(arr == fill_values[key], arr)
+        if int_keys is not None and key in int_keys:
+            new_arr = arr.astype(np.int32)
+            if not np.all(arr == new_arr):
+                msg = "Cannot convert non-integer float to integer"
+                raise ValueError(msg)
+            arr = new_arr
+        elif float_keys is not None and key in float_keys:
+            arr = arr.astype(np.float32)
+        output[key] = arr
+    return output
+
+
+def make_rain_mask(
+    diameter: npt.NDArray[np.floating],
+    velocity: npt.NDArray[np.floating],
+    threshold: float = 0.5,
+    altitude: float | None = None,
+) -> npt.NDArray[np.bool]:
+    """Make mask for rain bins based on theoretical diameter-velocity relation.
+
+    Args:
+        diameter: Diameter (mm)
+        velocity: Velocity (m s-1)
+        threshold: Maximum error to theoretical relation (1)
+        altitude: Site altitude for optional altitude correction (m)
+
+    References:
+        Atlas, D., Srivastava, R. C., & Sekhon, R. S. (1973). Doppler Radar
+        Characteristics of Precipitation at Vertical Incidence. Reviews of
+        Geophysics and Space Physics, 11(1), 1-35.
+        https://doi.org/10.1029/RG011i001p00001
+
+        Beard, K. V. (1985). Simple Altitude Adjustments to Raindrop Velocities
+        for Doppler Radar Analysis. Journal of Atmospheric and Oceanic
+        Technology, 2(4), 468-471.
+        https://doi.org/10.1175/1520-0426(1985)002%3C0468:SAATRV%3E2.0.CO;2
+    """
+    v = 9.65 - 10.3 * np.exp(-0.6 * diameter)  # Eq. 24, Atlas et al. (1973)
+    if altitude is None:
+        logging.warning(
+            "No altitude given, no correction applied for non-sea-level conditions."
+        )
+    else:
+        rho = isa_air_density(altitude)
+        m = 0.375 + 0.025 * diameter  # Eq. 3, Beard (1985)
+        v = (RHO_STD / rho) ** m * v  # Eq. 1, Beard (1985)
+    e = np.abs((velocity - v[:, np.newaxis]) / v[:, np.newaxis])
+    return e < threshold

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/instruments/disdrometer.py

@@ -71,7 +71,7 @@ def parsivel2nc(
             field_separator=field_separator,
             decimal_separator=decimal_separator,
         ),
-        read_parsivel_l1,
+        functools.partial(read_parsivel_l1, altitude=site_meta.get("altitude")),
         ATTRIBUTES,
         disdrometer_file,
         output_file,
@@ -117,7 +117,7 @@ def thies2nc(
     return _process_disdrometer(
         Thies,
         read_lpm,
-        functools.partial(read_lpm_l1, au=au),
+        functools.partial(read_lpm_l1, au=au, altitude=site_meta.get("altitude")),
         ATTRIBUTES,
         disdrometer_file,
         output_file,
@@ -160,7 +160,7 @@ def rd802nc(
     return _process_disdrometer(
         Rd80,
         read_rd80,
-        read_rd80_l1,
+        functools.partial(read_rd80_l1, altitude=site_meta.get("altitude")),
         RD80_ATTRIBUTES,
         input_file,
         output_file,

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/instruments/mmcr.py

@@ -7,6 +7,7 @@ from uuid import UUID
 
 import netCDF4
 import numpy as np
+from numpy import ma
 
 from cloudnetpy import output, utils
 from cloudnetpy.exceptions import ValidTimeStampError
@@ -19,7 +20,19 @@ from cloudnetpy.instruments.dealias import (
 )
 from cloudnetpy.instruments.instruments import MMCR
 from cloudnetpy.instruments.nc_radar import NcRadar
-from cloudnetpy.metadata import COMMON_ATTRIBUTES
+from cloudnetpy.metadata import COMMON_ATTRIBUTES, MetaData
+
+CDR_SNR_LIMIT = -5.0  # dB, co-polar SNR required for a valid CDR pixel
+# Conservative fallback: the highest floor observed at SGP (2005). The
+# floor drifted from -11 dB in early 2005 to -16...-19 dB from late 2005 on.
+# Over-subtracting only weakens the depolarization signal, whereas
+# under-subtracting turns rain and cloud into false insects.
+CDR_FLOOR_DEFAULT = -11.0  # dB, cross-talk floor if it cannot be estimated
+CDR_FLOOR_MARGIN = 1.5  # dB, added to the floor before subtraction
+CDR_FLOOR_RANGE = 4000  # m, pixels above this are used to estimate the floor
+CDR_FLOOR_MIN_PIXELS = 200
+CDR_MAX_TIME_DIFF = 15  # s, max distance to the nearest dual-pol profile
+LDR_MIN = -35.0  # dB
 
 
 def mmcr2nc(
@@ -36,8 +49,10 @@ def mmcr2nc(
     resolutions and sensitivities. Only profiles from a single mode are used.
     Doppler velocities are folded at the Nyquist velocity of the mode, which
     is only about 5 m/s in the default general (GE) mode, and are dealiased
-    using velocity continuity. Depolarization ratio is not available in the
-    GE mode.
+    using velocity continuity. Circular depolarization ratio is measured
+    only in the dual-polarization mode (about one profile per 25 s). It is
+    mapped to the selected mode by nearest time, corrected for the antenna
+    cross-talk floor and stored as `ldr`.
 
     Args:
         raw_file: Daily ARM `mmcrmom` netCDF file, e.g.
@@ -81,6 +96,7 @@ def mmcr2nc(
         mmcr.init_data(keymap)
         mmcr.init_mode(mode)
         mmcr.screen_mode()
+        mmcr.add_depolarization()
         if date is not None:
             mmcr.check_date(date)
         mmcr.sort_timestamps()
@@ -95,6 +111,8 @@ def mmcr2nc(
         mmcr.add_height()
         mmcr.test_if_all_masked()
     attributes = output.add_time_attribute(ATTRIBUTES, mmcr.date)
+    if mmcr.cdr_floor is not None:
+        attributes["ldr"] = _ldr_attributes(mmcr.cdr_floor)
     output.update_attributes(mmcr.data, attributes)
     output.save_level1b(mmcr, output_file, uuid)
     return uuid
@@ -114,6 +132,7 @@ class Mmcr(NcRadar):
         self.instrument = MMCR
         self.date = utils.get_epoch(self.dataset["time"].units).date()
         self.mode_index: int = 0
+        self.cdr_floor: float | None = None
         self._add_geolocation_from_file()
 
     def init_mode(self, mode: str) -> None:
@@ -164,6 +183,87 @@ class Mmcr(NcRadar):
         # MMCR is a fixed vertically pointing radar
         self.append_data(0.0, "zenith_angle")
 
+    def add_depolarization(self) -> None:
+        """Adds cross-talk corrected circular depolarization ratio as ldr.
+
+        CDR is available only in the dual-polarization mode. Each profile of
+        the selected mode gets the CDR of the nearest dual-pol profile in
+        time. The antenna cross-talk floor, estimated as the median CDR of
+        high-altitude pixels, is subtracted in linear units.
+        """
+        if "CircularDepolarizationRatio" not in self.dataset.variables:
+            return
+        try:
+            ind_co, ind_cross = self._find_dualpol_modes()
+        except ValueError:
+            logging.info("No dual-polarization mode found, ldr not available")
+            return
+        mode_num = np.array(self.dataset["ModeNum"][:])
+        time_raw = np.array(self.dataset["time"][:])
+        co_ind = np.where(mode_num == ind_co)[0]
+        cross_ind = np.where(mode_num == ind_cross)[0]
+        if len(co_ind) == 0 or len(cross_ind) == 0:
+            logging.info("No dual-polarization profiles found, ldr not available")
+            return
+        # Pair each cross-pol profile with the co-pol profile of the same pulse
+        pair_ind = co_ind[_nearest_index(time_raw[co_ind], time_raw[cross_ind])]
+        n_heights = int(self.dataset["NumHeights"][ind_cross])
+        cdr = ma.masked_invalid(
+            self.dataset["CircularDepolarizationRatio"][cross_ind, :n_heights]
+        )
+        snr = ma.masked_invalid(
+            self.dataset["SignalToNoiseRatio"][pair_ind, :n_heights]
+        )
+        cdr[ma.filled(snr < CDR_SNR_LIMIT, fill_value=True)] = ma.masked
+        altitude = float(self.dataset["alt"][:])
+        range_cross = (
+            np.array(self.dataset["heights"][ind_cross, :n_heights]) - altitude
+        )
+        self.cdr_floor = self._estimate_cdr_floor(cdr, range_cross)
+        ldr = _remove_cdr_floor(cdr, self.cdr_floor)
+        # Map to the profiles and range gates of the selected mode
+        time_sel = np.array(self.data["time"][:]) * 3600
+        time_ind = _nearest_index(time_raw[cross_ind], time_sel)
+        range_ind = _nearest_index(range_cross, self.data["range"][:])
+        ldr = ldr[time_ind][:, range_ind]
+        too_far = np.abs(time_raw[cross_ind][time_ind] - time_sel) > CDR_MAX_TIME_DIFF
+        ldr[too_far, :] = ma.masked
+        self.append_data(ldr, "ldr")
+
+    def _estimate_cdr_floor(
+        self, cdr: ma.MaskedArray, range_cross: np.ndarray
+    ) -> float:
+        is_high = ~ma.getmaskarray(cdr) & (range_cross[np.newaxis, :] > CDR_FLOOR_RANGE)
+        if np.count_nonzero(is_high) < CDR_FLOOR_MIN_PIXELS:
+            logging.warning(
+                "Not enough high-altitude pixels to estimate CDR floor, "
+                "using conservative default %s dB",
+                CDR_FLOOR_DEFAULT,
+            )
+            return CDR_FLOOR_DEFAULT
+        floor = float(np.median(cdr[is_high].compressed()))
+        logging.info("Estimated CDR cross-talk floor: %.1f dB", floor)
+        return floor
+
+    def _find_dualpol_modes(self) -> tuple[int, int]:
+        """Returns indices of the co- and cross-polar dual-pol receiver modes.
+
+        Mode names vary between files (e.g. "PO_Receiver0" in 2005,
+        "DualPol_Receiver0" in 2008), so the receiver metadata is used.
+        """
+        for key in ("NumReceivers", "ReceiverNumber"):
+            if key not in self.dataset.variables:
+                msg = f"Variable {key} not found"
+                raise ValueError(msg)
+        n_receivers = ma.filled(self.dataset["NumReceivers"][:], 0)
+        receiver = ma.filled(self.dataset["ReceiverNumber"][:], 0)
+        co = np.where((n_receivers == 2) & (receiver == 1))[0]
+        cross = np.where((n_receivers == 2) & (receiver == 2))[0]
+        if len(co) != 1 or len(cross) != 1:
+            msg = "Dual-polarization modes not found"
+            raise ValueError(msg)
+        return int(co[0]), int(cross[0])
+
     def _find_mode_index(self, mode: str) -> int:
         var = self.dataset["ModeDescription"]
         var.set_auto_mask(False)
@@ -180,6 +280,39 @@ class Mmcr(NcRadar):
         self.site_meta = read_geolocation(self.dataset, self.site_meta)
 
 
+def _nearest_index(reference: np.ndarray, query: np.ndarray) -> np.ndarray:
+    """Returns index of the nearest `reference` value for each `query` value."""
+    if len(reference) < 2:
+        return np.zeros(len(query), dtype=int)
+    order = np.argsort(reference)
+    sorted_ref = reference[order]
+    pos = np.searchsorted(sorted_ref, query)
+    pos = np.clip(pos, 1, len(sorted_ref) - 1)
+    use_left = np.abs(query - sorted_ref[pos - 1]) <= np.abs(sorted_ref[pos] - query)
+    return order[np.where(use_left, pos - 1, pos)]
+
+
+def _remove_cdr_floor(cdr: ma.MaskedArray, floor: float) -> ma.MaskedArray:
+    """Subtracts the cross-talk floor in linear units, clipping at LDR_MIN."""
+    linear = 10 ** (cdr / 10) - 10 ** ((floor + CDR_FLOOR_MARGIN) / 10)
+    ldr = ma.masked_where(linear <= 0, linear)
+    ldr = 10 * ma.log10(ldr)
+    ldr = ldr.filled(LDR_MIN)
+    ldr = np.maximum(ldr, LDR_MIN)
+    return ma.masked_where(ma.getmaskarray(cdr), ldr)
+
+
+def _ldr_attributes(floor: float) -> MetaData:
+    return COMMON_ATTRIBUTES["ldr"]._replace(
+        comment=(
+            "Circular depolarization ratio from the dual-polarization mode, "
+            "mapped to the selected mode by nearest time. The antenna cross-talk "
+            f"floor of {floor:.1f} dB has been subtracted in linear units, "
+            f"and values are clipped at {LDR_MIN} dB."
+        ),
+    )
+
+
 ATTRIBUTES = {
     "correction_bits": CORRECTION_BITS_ATTRIBUTES,
     "v": DEALIASED_V_ATTRIBUTES,

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/output.py

@@ -181,7 +181,7 @@ def get_references(identifier: str | None = None, extra: list | None = None) ->
     match identifier:
         case "der":
             references += (
-                ", https://doi.org/10.1175/1520-0426(2002)019<0835:TROSCD>2.0.CO;2"
+                ", https://doi.org/10.1175/1520-0426(2002)019%3C0835:TROSCD%3E2.0.CO;2"
             )
         case "ier":
             references += (
@@ -195,6 +195,14 @@ def get_references(identifier: str | None = None, extra: list | None = None) ->
             references += ", https://doi.org/10.1175/JAM2340.1"
         case "drizzle":
             references += ", https://doi.org/10.1175/JAM-2181.1"
+        case "cod":
+            references += (
+                ", https://doi.org/10.1175/BAMS-88-6-883"
+                ", https://doi.org/10.1175/1520-0426(2002)019%3C0835:TROSCD%3E2.0.CO;2"
+                ", https://doi.org/10.1175/JAM2340.1"
+                ", https://doi.org/10.1175/JAM2543.1"
+                ", https://doi.org/10.5194/amt-13-5335-2020"
+            )
         case "epsilon-radar":
             references += (
                 ", https://doi.org/10.5194/amt-13-5335-2020"
@@ -472,6 +480,7 @@ def _get_identifier(short_id: str) -> str:
         "classification",
         "der",
         "ier",
+        "cod",
         "classification-voodoo",
         "epsilon-radar",
     )
@@ -486,6 +495,8 @@ def _get_identifier(short_id: str) -> str:
         return "ice effective radius"
     if short_id == "der":
         return "droplet effective radius"
+    if short_id == "cod":
+        return "cloud optical depth"
     if short_id == "epsilon-radar":
         return "dissipation rate of turbulent kinetic energy"
     return short_id

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/plotting/plot_meta.py

@@ -170,6 +170,15 @@ _CLABEL = {
         ("Unquantifiable", _COLORS["seaweed_roll"]),
         ("Undetected", _COLORS["skyblue"]),
     ),
+    "extinction_retrieval_status": (
+        ("_No cloud", _COLORS["white"]),
+        ("Liquid", _COLORS["lightblue"]),
+        ("Liquid, assumed radius", _COLORS["yellow"]),
+        ("Ice", _COLORS["lightsteel"]),
+        ("Ice, corrected atten.", _COLORS["skyblue"]),
+        ("Liquid & ice", _COLORS["darkpurple"]),
+        ("No retrieval", _COLORS["seaweed_roll"]),
+    ),
     "dominant_hydrometeor_type": (
         ("_Clear sky", _COLORS["white"]),
         ("Ice", _COLORS["lightgray"]),
@@ -684,5 +693,40 @@ ATTRIBUTES = {
         "dominant_hydrometeor_type": PlotMeta(
             clabel=_CLABEL["dominant_hydrometeor_type"],
         ),
+        "extinction_liquid": PlotMeta(
+            cmap="Blues",
+            plot_range=(1e-4, 1e-1),
+            log_scale=True,
+        ),
+        "extinction_ice": PlotMeta(
+            plot_range=(1e-5, 1e-2),
+            log_scale=True,
+        ),
+        "extinction_retrieval_status": PlotMeta(
+            clabel=_CLABEL["extinction_retrieval_status"],
+        ),
+        "extinction_liquid_error": PlotMeta(
+            cmap="RdYlGn_r",
+            plot_range=(0, 5),
+        ),
+        "extinction_ice_error": PlotMeta(
+            cmap="RdYlGn_r",
+            plot_range=(0, 5),
+        ),
+        "optical_depth_error": PlotMeta(
+            zero_line=True,
+        ),
+        "optical_depth": PlotMeta(
+            plot_range=(0.02, 1000),
+            log_scale=True,
+        ),
+        "optical_depth_liquid": PlotMeta(
+            plot_range=(0.02, 1000),
+            log_scale=True,
+        ),
+        "optical_depth_ice": PlotMeta(
+            plot_range=(0.02, 1000),
+            log_scale=True,
+        ),
     },
 }

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/plotting/plotting.py

@@ -904,6 +904,9 @@ class Plot1D(Plot):
         units = self._convert_units()
         if self._plot_meta.mask_zeros:
             self._mask_zeros()
+        is_zero = ~ma.getmaskarray(self._data) & (ma.filled(self._data, 1) == 0)
+        if self._is_log:
+            self._mask_non_positive()
         self._mark_gaps(figure_data)
         self._ax.plot(
             figure_data.time_including_gaps,
@@ -914,14 +917,34 @@ class Plot1D(Plot):
         )
         if self._plot_meta.moving_average:
             self._plot_moving_average(figure_data, hacky_freq_ind)
-        if self._plot_meta.zero_line:
+        if self._plot_meta.zero_line and not self._is_log:
             self._ax.axhline(0, color="black", alpha=0.5, label="_nolegend_")
         self._fill_between_data_gaps(figure_data)
-        self.sub_plot.set_yax(ylabel=units, y_limits=self._get_y_limits())
+        if self._is_log:
+            self._ax.set_yscale("log")
+        y_limits = self._get_y_limits()
+        self.sub_plot.set_yax(ylabel=units, y_limits=y_limits)
+        if self._is_log and np.any(is_zero):
+            self._plot_zeros(figure_data.time[is_zero], y_limits[0])
         pos = self._ax.get_position()
         self._ax.set_position((pos.x0, pos.y0, pos.width * 0.965, pos.height))
         self._plot_flags(figure_data)
 
+    def _plot_zeros(self, time: ndarray, y_min: float) -> None:
+        """Marks zero values along the bottom of a logarithmic axis."""
+        is_cloud_variable = self.sub_plot.variable.name.startswith("optical_depth")
+        self._ax.plot(
+            time,
+            np.full(len(time), y_min * 1.3),
+            color="lightgrey",
+            marker=".",
+            lw=0,
+            markersize=3,
+            label="Clear sky" if is_cloud_variable else "Zero",
+            zorder=_get_zorder("data"),
+        )
+        self._ax.legend(markerscale=3, numpoints=1, frameon=False)
+
     def _plot_flags(self, figure_data: FigureData) -> None:
         if figure_data.is_mwrpy_product():
             flags = self._read_flagged_data(figure_data)
@@ -1021,9 +1044,18 @@ class Plot1D(Plot):
             frameon=False,
         )
 
+    def _mask_non_positive(self) -> None:
+        self._data = ma.masked_less_equal(self._data, 0)
+        self._data_orig = ma.masked_less_equal(self._data_orig, 0)
+
     def _get_y_limits(self) -> tuple[float, float]:
         percent_gap = 0.05
         fallback = (-percent_gap, percent_gap)
+        if self._is_log:
+            if self._plot_meta.plot_range is not None:
+                return self._plot_meta.plot_range
+            valid = self._data[~ma.getmaskarray(self._data)]
+            return (valid.min() / 2, valid.max() * 2) if valid.size else (0.1, 10)
         if ma.all(self._data.mask):
             return fallback
         min_data = self._data.min()
@@ -1066,6 +1098,9 @@ class Plot1D(Plot):
     ) -> None:
         time = figure_data.time.copy()
         data = self._data_orig.copy()
+        if self._is_log:
+            # Average in log space so large values do not dominate
+            data = ma.log10(ma.masked_less_equal(data, 0))
 
         if figure_data.is_mwrpy_product() or self.sub_plot.variable.name in (
             "tb",
@@ -1097,6 +1132,8 @@ class Plot1D(Plot):
                 )
             else:
                 sma = self._calculate_moving_average(data1, time1, window=5)
+                if self._is_log:
+                    sma = 10**sma
             gap_time = _get_max_gap_in_minutes(figure_data)
             gaps = self._find_time_gap_indices(time1, max_gap_min=gap_time) + 1
 

{cloudnetpy-1.95.7 → cloudnetpy-1.96.1}/cloudnetpy/products/__init__.py

@@ -1,4 +1,5 @@
 from .classification import generate_classification
+from .cod import generate_cod
 from .der import generate_der
 from .drizzle import generate_drizzle
 from .epsilon_lidar import generate_epsilon_from_lidar