cloudnetpy 1.97.0__tar.gz → 1.97.2__tar.gz

{cloudnetpy-1.97.0/cloudnetpy.egg-info → cloudnetpy-1.97.2}/PKG-INFO

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

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/disdronator/parsivel.py

@@ -237,6 +237,32 @@ LEIPZIG_KEYS = {
 FLOAT_KEYS = {1, 2, 7, 16, 17, 24, 30, 31, 33, 34, 35}
 INT_KEYS = {3, 4, 8, 9, 10, 11, 12, 18, 25, 26, 27, 28, 60}
 
+KOLSASS_TELEGRAM: list[str | int | None] = [
+    "%Y-%m-%d %H:%M:%S",
+    18,
+    20,
+    25,
+    1,
+    2,
+    7,
+    9,
+    35,
+    11,
+    90,
+    91,
+    93,
+    13,
+    14,
+    15,
+    16,
+    17,
+    10,
+    12,
+    26,
+    27,
+    28,
+]
+
 
 def _read_lines(
     telegram: Sequence[str | int | None],
@@ -387,6 +413,17 @@ def _read_granada(filename: str | PathLike) -> ParsivelOutput:
     return _read_lines(telegram, content, b",", b".")
 
 
+def _read_kolsass(filename: str | PathLike) -> ParsivelOutput:
+    with open(filename, "rb") as f:
+        _header = f.readline()
+        content = f.read()
+    # Fix "0-9" to "-9" (e.g. 2025-01-01)
+    content = re.sub(rb",0-(\d),", rb",-\1,", content)
+    # Remove decimal part from integers (e.g. 2025-01-02)
+    content = re.sub(rb"(\d+)\.0,", rb"\1,", content, flags=re.MULTILINE)
+    return _read_lines(KOLSASS_TELEGRAM, content, b",", b".")
+
+
 def _read_headerless(
     filename: str | PathLike,
     telegram: Sequence[int | str | None],
@@ -516,6 +553,8 @@ def _read_parsivel(
         head = f.read(50)
     if head.startswith(b"datetime_utc;"):
         return _read_pyatmoslogger(filename)
+    if head.startswith(b"datetime_utc,sensor status,sensor time,"):
+        return _read_kolsass(filename)
     if head.startswith(b"Date;Time;"):
         return _read_asdo(filename)
     if head.startswith(b'"TOA5"'):

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/instruments/kazr.py

@@ -164,10 +164,10 @@ class Kazr(CloudnetInstrument):
 
     def read_files(self) -> None:
         """Reads and concatenates all input files."""
+        with netCDF4.Dataset(self._find_reference_file()) as nc:
+            self._init_metadata(nc)
         for file in self.files:
             with netCDF4.Dataset(file) as nc:
-                if not self.keymap:
-                    self._init_metadata(nc)
                 try:
                     self._read_file(nc)
                 except (KeyError, ValueError) as err:
@@ -350,6 +350,24 @@ class Kazr(CloudnetInstrument):
             msg = "All radar data are masked"
             raise RadarDataError(msg)
 
+    def _find_reference_file(self) -> Path:
+        """Returns the first file using the range grid with the most profiles."""
+        n_profiles: dict[int, int] = {}
+        first_file: dict[int, Path] = {}
+        for file in self.files:
+            with netCDF4.Dataset(file) as nc:
+                if "range" not in nc.dimensions or "time" not in nc.dimensions:
+                    continue
+                n_range = nc.dimensions["range"].size
+                n_profiles[n_range] = (
+                    n_profiles.get(n_range, 0) + nc.dimensions["time"].size
+                )
+                first_file.setdefault(n_range, file)
+        if not first_file:
+            msg = "No valid KAZR files found"
+            raise ValidTimeStampError(msg)
+        return first_file[max(n_profiles, key=lambda k: n_profiles[k])]
+
     def _init_metadata(self, nc: netCDF4.Dataset) -> None:
         if "reflectivity" in nc.variables:
             self.keymap = KEYMAP_CFR
@@ -366,6 +384,7 @@ class Kazr(CloudnetInstrument):
         if bias is not None:
             self.offset_applied = _parse_bias(bias)
         self.serial_number = getattr(nc, "serial_number", None) or None
+        self.date = _parse_time_units(nc["time"].units).date()
         self.append_data(np.array(nc["range"][:], dtype=float), "range")
         self.append_data(0.0, "zenith_angle")
         self.append_data(self._read_frequency(nc), "radar_frequency")
@@ -421,7 +440,11 @@ class Kazr(CloudnetInstrument):
     @staticmethod
     def _read_frequency(nc: netCDF4.Dataset) -> float:
         if "frequency" in nc.variables:
-            return float(np.mean(nc["frequency"][:]) / 1e9)  # Hz -> GHz
+            frequency = ma.mean(nc["frequency"][:])
+            if not ma.is_masked(frequency) and np.isfinite(frequency):
+                return float(frequency / 1e9)  # Hz -> GHz
+            # E.g. bnfkazr2cfrgeqcM1.b1 files have only a fill value
+            logging.warning("Radar frequency missing from file, using default")
         value = _parse_global_attribute(nc, "radar_operating_frequency")
         if value is not None:
             return value

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/metadata.py

@@ -171,7 +171,9 @@ REGRID_PRODUCT_ATTRIBUTES = {
             "This variable is the observed mean ice water content derived from radar\n"
             "reflectivity factor averaged onto the model grid with height and time.\n"
             "The formula has been applied where the categorization data has\n"
-            "diagnosed that the radar echo is due to ice."
+            "diagnosed that the radar echo is due to ice; pixels without ice count\n"
+            "as zero and unreliable retrievals (e.g. rain) are excluded, so the\n"
+            "value is a grid-box mean comparable to the model ice water content."
         ),
         dimensions=("time", "level"),
     ),

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/products/advance_methods.py

@@ -6,6 +6,7 @@ from numpy import ma
 
 import cloudnetpy.utils as cl_tools
 from cloudnetpy.constants import T_FREEZING
+from cloudnetpy.exceptions import InvalidSourceFileError
 from cloudnetpy.model_evaluation.model_metadata import MODEL_PREFIX
 from cloudnetpy.model_evaluation.products.model_products import ModelManager
 from cloudnetpy.model_evaluation.products.observation_products import ObservationManager
@@ -15,6 +16,8 @@ from cloudnetpy.products.product_tools import (
     z_to_iwc,
 )
 
+MAX_WIND_SHEAR = 20.0  # m s-1 km-1
+
 
 class AdvanceProductMethods:
     """Class that adds advance methods of product to nc-file.
@@ -53,7 +56,8 @@ class AdvanceProductMethods:
         t_screened = self.remove_extra_levels(temperature - T_FREEZING)
         iwc, lwc = (self._model_obj.get_water_content(var) for var in ["iwc", "lwc"])
         coeffs = self.set_frequency_parameters()
-        z_sen = self.fit_z_sensitivity(h)
+        # Same dielectric factor scaling of Z as in the IWC product.
+        z_sen = self.fit_z_sensitivity(h) + 10 * np.log10(coeffs.K2liquid0 / 0.93)
         cf_filtered = self.filter_high_iwc_low_cf(cf, iwc, lwc)
         cloud_iwc, ice_ind = self.find_ice_in_clouds(cf_filtered, iwc, lwc)
         variance_iwc = self.iwc_variance(h, ice_ind)
@@ -102,15 +106,14 @@ class AdvanceProductMethods:
         if self._obs_obj.z_sensitivity is None:
             msg = "No z_sensitivity in observation file"
             raise ValueError(msg)
-        if self._obs_obj.height is None:
-            msg = "No height in observation file"
-            raise ValueError(msg)
+        if self._obs_obj.height_agl is None:
+            msg = "Observation file is missing height or altitude"
+            raise InvalidSourceFileError(msg)
         # Interpolate at the model level heights: rebinning assumes evenly
         # spaced levels, which maps stretched model levels to wrong heights.
-        obs_height = self._obs_obj.height_agl
-        if obs_height is None:
-            obs_height = self._obs_obj.height
-        obs_height = np.asarray(ma.filled(obs_height, np.nan), dtype=float)
+        obs_height = np.asarray(
+            ma.filled(self._obs_obj.height_agl, np.nan), dtype=float
+        )
         z_obs = np.asarray(ma.filled(self._obs_obj.z_sensitivity, np.nan), dtype=float)
         is_valid = np.isfinite(obs_height) & np.isfinite(z_obs)
         model_height = np.asarray(ma.filled(h, np.nan), dtype=float)
@@ -167,36 +170,45 @@ class AdvanceProductMethods:
         v = self._model_obj.getvar("vwind")
         u = self.remove_extra_levels(u)
         v = self.remove_extra_levels(v)
-        w_shear = self.calculate_wind_shear(self._model_obj.wind, u, v, height)
+        w_shear = self.calculate_wind_shear(u, v, height)
         return self.calculate_variance_iwc(w_shear, ice_ind)
 
     def calculate_variance_iwc(
         self, w_shear: npt.NDArray, ice_ind: tuple
     ) -> npt.NDArray:
+        """Fractional variance of IWC within a grid box (Hogan and Illingworth
+        2003, eq. 11), with the horizontal resolution in km and the wind shear
+        in m s-1 km-1. The shear is capped and the constant is -1.03 as in the
+        original Cloudnet code (the published equation has -0.93).
+        """
+        shear = np.minimum(w_shear[ice_ind], MAX_WIND_SHEAR)
         return 10 ** (
-            0.3 * np.log10(self._model_obj.resolution_h)
-            - 0.04 * w_shear[ice_ind]
-            - 1.03
+            0.3 * np.log10(self._model_obj.resolution_h) - 0.04 * shear - 1.03
         )
 
     @staticmethod
     def calculate_wind_shear(
-        wind: npt.NDArray,
         u: npt.NDArray,
         v: npt.NDArray,
         height: npt.NDArray,
     ) -> npt.NDArray:
-        grand_winds = []
-        for w in (wind, u, v):
+        """Magnitude of the vertical shear of the horizontal wind (m s-1 km-1)
+        from (time, level) arrays.
+        """
+        height_km = height / 1000
+        gradients = []
+        for w in (u, v):
             grad_w = np.zeros(w.shape)
-            grad_w[0, :] = (w[1, :] - w[0, :]) / (height[1, :] - height[0, :])
-            grad_w[1:-1, :] = (w[2:, :] - w[:-2, :]) / (height[2:, :] - height[:-2, :])
-            grad_w[-1, :] = (w[-1, :] - w[-2, :]) / (height[-1, :] - height[-2, :])
-            grand_winds.append(grad_w)
-
-        w_shear = np.sqrt(np.power(grand_winds[1], 2) + np.power(grand_winds[-1], 2))
-        w_shear[grand_winds[0] < 0] = 0 - w_shear[grand_winds[0] < 0]
-        return w_shear
+            grad_w[:, 0] = (w[:, 1] - w[:, 0]) / (height_km[:, 1] - height_km[:, 0])
+            grad_w[:, 1:-1] = (w[:, 2:] - w[:, :-2]) / (
+                height_km[:, 2:] - height_km[:, :-2]
+            )
+            grad_w[:, -1] = (w[:, -1] - w[:, -2]) / (
+                height_km[:, -1] - height_km[:, -2]
+            )
+            gradients.append(grad_w)
+
+        return np.sqrt(np.power(gradients[0], 2) + np.power(gradients[1], 2))
 
     @staticmethod
     def calculate_iwc_distribution(

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/products/grid_methods.py

@@ -2,7 +2,7 @@ import numpy as np
 import numpy.typing as npt
 from numpy import ma
 
-from cloudnetpy import utils
+from cloudnetpy.exceptions import InvalidSourceFileError
 from cloudnetpy.model_evaluation.products import tools as tl
 from cloudnetpy.model_evaluation.products.model_products import ModelManager
 from cloudnetpy.model_evaluation.products.observation_products import ObservationManager
@@ -24,7 +24,12 @@ class ProductGrid:
         self._obs_obj = obs_obj
         self._date = obs_obj.date
         self._obs_time = tl.time2datetime(obs_obj.time, self._date)
-        self._obs_height = obs_obj.data["height"][:]
+        # Model heights are above ground; the observation file's height is
+        # above mean sea level.
+        if obs_obj.height_agl is None:
+            msg = "Observation file is missing height or altitude"
+            raise InvalidSourceFileError(msg)
+        self._obs_height = np.asarray(obs_obj.height_agl)
         self._obs_data = obs_obj.data[obs_obj.product][:]
         self.model_obj = model_obj
         self._model_time = model_obj.time
@@ -34,21 +39,22 @@ class ProductGrid:
             ma.array(model_obj.wind),
             1,
         )
-        time_steps = utils.binvec(self._model_time)
-        self._time_steps = tl.time2datetime(time_steps, self._date)
+        self._time_windows = [
+            tuple(tl.time2datetime(np.array(edges), self._date))
+            for edges in tl.time_windows(self._model_time)
+        ]
         self._generate_downsample_product()
 
     def _generate_downsample_product(self) -> None:
         """Downsampling products are generated with different averaging methods
         for a selected size of model time-height window.
+
+        Grid cells without any observation pixels stay masked.
         """
         product_dict, product_adv_dict = self._get_method_storage()
         model_t = tl.time2datetime(self._model_time, self._date)
-        for i in range(len(self._time_steps) - 1):
-            x_ind = tl.get_1d_indices(
-                (self._time_steps[i], self._time_steps[i + 1]),
-                self._obs_time,
-            )
+        for i, window in enumerate(self._time_windows):
+            x_ind = tl.get_1d_indices(window, self._obs_time)
             y_steps = tl.rebin_edges(self._model_height[i])
             for j in range(len(y_steps) - 1):
                 x_ind_adv = tl.get_adv_indices(
@@ -91,19 +97,21 @@ class ProductGrid:
 
     def _cf_method_storage(self) -> tuple[dict, dict]:
         cf_dict = {
-            "cf_V": ma.zeros(self._model_height.shape),
-            "cf_A": ma.zeros(self._model_height.shape),
+            "cf_V": ma.masked_all(self._model_height.shape),
+            "cf_A": ma.masked_all(self._model_height.shape),
         }
         cf_adv_dict = {
-            "cf_V_adv": ma.zeros(self._model_height.shape),
-            "cf_A_adv": ma.zeros(self._model_height.shape),
+            "cf_V_adv": ma.masked_all(self._model_height.shape),
+            "cf_A_adv": ma.masked_all(self._model_height.shape),
         }
         return cf_dict, cf_adv_dict
 
     def _product_method_storage(self) -> tuple[dict, dict]:
-        product_dict = {f"{self._obs_obj.product}": ma.zeros(self._model_height.shape)}
+        product_dict = {
+            f"{self._obs_obj.product}": ma.masked_all(self._model_height.shape)
+        }
         product_adv_dict = {
-            f"{self._obs_obj.product}_adv": ma.zeros(self._model_height.shape),
+            f"{self._obs_obj.product}_adv": ma.masked_all(self._model_height.shape),
         }
         return product_dict, product_adv_dict
 

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/products/observation_products.py

@@ -103,10 +103,14 @@ class ObservationManager(DataSource):
         """Keeps only reliable ice water content retrievals.
 
         Status 1 is a reliable retrieval and status 3 is a retrieval with the
-        radar corrected for liquid, rain and melting attenuation; everything
-        else (uncorrected attenuation, lidar-only, rain) is masked out.
+        radar corrected for liquid, rain and melting attenuation. Status 0 (no
+        ice) is set to zero so that the regridded value is a grid-box mean,
+        comparable to the model. Everything else (uncorrected attenuation,
+        lidar-only, rain) is masked out.
         """
         iwc = self.getvar("iwc")
-        iwc_status = self.getvar("iwc_retrieval_status")
-        iwc[~np.isin(iwc_status, (1, 3))] = ma.masked
+        status = ma.filled(self.getvar("iwc_retrieval_status"), -1)
+        no_ice = status == 0
+        invalid = (ma.getmaskarray(iwc) & ~no_ice) | ~np.isin(status, (0, 1, 3))
+        iwc = ma.array(ma.filled(iwc, 0), mask=invalid)
         self.append_data(iwc, "iwc")

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/products/tools.py

@@ -13,6 +13,17 @@ def time2datetime(time: npt.NDArray, date: datetime.datetime) -> npt.NDArray:
     return np.asarray([date + timedelta(hours=float(t)) for t in time])
 
 
+def time_windows(time: npt.NDArray) -> list[tuple[float, float]]:
+    """Averaging window around each model time step.
+
+    Each window is +/- half the smallest time step, so a gap in the time
+    vector (e.g. a missing forecast run) does not widen the windows.
+    """
+    time = np.asarray(time, dtype=float)
+    half = np.min(np.diff(time)) / 2 if time.size > 1 else 0.5
+    return [(t - half, t + half) for t in time]
+
+
 def rebin_edges(arr: npt.NDArray) -> npt.NDArray:
     """Rebins array bins by half and adds boundaries."""
     new_arr = [(arr[i] + arr[i + 1]) / 2 for i in range(len(arr) - 1)]

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py

@@ -229,19 +229,39 @@ def test_calculate_variance_iwc(obs_file, model_file) -> None:
     testing.assert_array_almost_equal(result, expected)
 
 
+def test_calculate_variance_iwc_shear_cap(obs_file, model_file) -> None:
+    obs = ObservationManager(PRODUCT, str(obs_file))
+    model = ModelManager(str(model_file), MODEL, PRODUCT)
+    advance = AdvanceProductMethods(model, obs)
+    shear = np.array([[20.0, 50.0]])
+    result = advance.calculate_variance_iwc(shear, (np.array([0, 0]), np.array([0, 1])))
+    assert result[0] == result[1]
+
+
 def test_calculate_wind_shear(obs_file, model_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, PRODUCT)
     advance = AdvanceProductMethods(model, obs)
-    u = np.array([[1, 2, 0, 1], [-1, 0, 1, -1], [1, 0, 1, -1]])
-    v = np.array([[1, 0, 1, -1], [1, 2, -1, 0], [1, 2, 0, 1]])
-    wind = np.sqrt(np.power(u, 2) + np.power(v, 2))
-    height = np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]])
-    expected = np.array([[2, 2.83, 2.24, -2.24], [0, 1.41, 0.71, 1.41], [2, 0, -1, 1]])
-    result = advance.calculate_wind_shear(wind, u, v, height)
+    # (time, level) arrays; shear is the vertical gradient in m s-1 km-1
+    u = np.array([[1, 2, 0, 1], [-1, 0, 1, -1], [1, 0, 1, -1]]).T
+    v = np.array([[1, 0, 1, -1], [1, 2, -1, 0], [1, 2, 0, 1]]).T
+    height = np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]]).T * 1000
+    expected = np.array([[2, 2.83, 2.24, 2.24], [0, 1.41, 0.71, 1.41], [2, 0, 1, 1]]).T
+    result = advance.calculate_wind_shear(u, v, height)
     testing.assert_array_almost_equal(np.round(result, 2), expected)
 
 
+def test_calculate_wind_shear_constant_height_in_time(obs_file, model_file) -> None:
+    obs = ObservationManager(PRODUCT, str(obs_file))
+    model = ModelManager(str(model_file), MODEL, PRODUCT)
+    advance = AdvanceProductMethods(model, obs)
+    u = np.array([[1.0, 3.0, 4.0], [1.0, 3.0, 4.0]])
+    v = np.zeros_like(u)
+    height = np.array([[0.0, 1000.0, 2000.0], [0.0, 1000.0, 2000.0]])
+    result = advance.calculate_wind_shear(u, v, height)
+    testing.assert_array_almost_equal(result, [[2, 1.5, 1], [2, 1.5, 1]])
+
+
 def test_calculate_iwc_distribution(obs_file, model_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, PRODUCT)

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/tests/unit/test_grid_methods.py

@@ -2,6 +2,7 @@ import numpy as np
 import pytest
 from numpy import ma, testing
 
+from cloudnetpy.exceptions import InvalidSourceFileError
 from cloudnetpy.model_evaluation.products.grid_methods import ProductGrid
 from cloudnetpy.model_evaluation.products.model_products import ModelManager
 from cloudnetpy.model_evaluation.products.observation_products import ObservationManager
@@ -42,6 +43,14 @@ def test_generate_regrid_product(model_file, obs_file, product, variables) -> No
         assert var in model.data
 
 
+def test_missing_height_agl_raises(model_file, obs_file) -> None:
+    obs = ObservationManager(PRODUCT, str(obs_file))
+    model = ModelManager(str(model_file), MODEL, PRODUCT)
+    obs.height_agl = None
+    with pytest.raises(InvalidSourceFileError):
+        ProductGrid(model, obs)
+
+
 @pytest.mark.parametrize("key, value", [("iwc", 1), ("lwc", 1), ("cf", 2)])
 def test_get_method_storage(key, value, model_file, obs_file) -> None:
     obs = ObservationManager(key, str(obs_file))

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/tests/unit/test_observation_products.py

@@ -113,6 +113,7 @@ def test_mask_iwc(obs_file) -> None:
     obs = ObservationManager("iwc", str(obs_file))
     iwc_status = obs.getvar("iwc_retrieval_status")
     expected = ma.copy(obs.getvar("iwc"))
-    expected[~np.isin(iwc_status, (1, 3))] = ma.masked
+    expected[iwc_status == 0] = 0
+    expected[~np.isin(iwc_status, (0, 1, 3))] = ma.masked
     obs._mask_iwc()
     testing.assert_array_almost_equal(expected, obs.data["iwc"][:])

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/model_evaluation/tests/unit/test_tools.py

@@ -128,3 +128,17 @@ def test_obs_windows_size_first_index() -> None:
     result = tools.get_obs_window_size(ind_x, ind_y)
     assert result is not None
     testing.assert_almost_equal(result, (1, 1))
+
+
+def test_time_windows_even_spacing() -> None:
+    result = tools.time_windows(np.array([0.0, 1.0, 2.0]))
+    testing.assert_array_almost_equal(result, [(-0.5, 0.5), (0.5, 1.5), (1.5, 2.5)])
+
+
+def test_time_windows_gap() -> None:
+    result = tools.time_windows(np.array([0.0, 1.0, 24.0]))
+    testing.assert_array_almost_equal(result, [(-0.5, 0.5), (0.5, 1.5), (23.5, 24.5)])
+
+
+def test_time_windows_single() -> None:
+    testing.assert_array_almost_equal(tools.time_windows(np.array([3.0])), [(2.5, 3.5)])

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/plotting/plot_meta.py

@@ -668,7 +668,7 @@ ATTRIBUTES = {
         ),
         "lwc_error": PlotMeta(
             cmap="RdYlGn_r",
-            plot_range=(0, 2),
+            plot_range=(0, 100),
         ),
         "lwc_retrieval_status": PlotMeta(
             clabel=_CLABEL["lwc_retrieval_status"],

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/plotting/plotting.py

@@ -464,6 +464,7 @@ class Plot:
             "air_pressure": (multiply, 0.01, "hPa"),
             "relative_humidity": (multiply, 100, "%"),
             "rh": (multiply, 100, "%"),
+            "lwc_error": (multiply, 100, "%"),
             "rainfall_amount": (multiply, con.M_TO_MM, "mm"),
             "snowfall_amount": (multiply, con.M_TO_MM, "mm"),
             "precipitation_amount": (multiply, con.M_TO_MM, "mm"),

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/products/lwc.py

@@ -117,7 +117,7 @@ class LwcSource(DataSource):
     ) -> None:
         self.append_data(lwc, "lwc", units="kg m-3")
         self.append_data(status, "lwc_retrieval_status")
-        self.append_data(error, "lwc_error", units="dB")
+        self.append_data(error, "lwc_error", units="1")
 
     @staticmethod
     def _get_atmosphere(
@@ -348,15 +348,16 @@ class LwcError:
         return self._fill_error_array(combined_error)
 
     def _calc_lwc_relative_error(self) -> npt.NDArray:
+        # Half a range gate uncertainty in cloud base and top height
         lwc_gradient = self._calc_lwc_gradient()
         error = lwc_gradient / self.lwc / 2
         return self._limit_error(error, 5)
 
     def _calc_lwc_gradient(self) -> npt.NDArray:
+        """Returns absolute vertical gradient of LWC per range gate."""
         if not isinstance(self.lwc, ma.MaskedArray):
             self.lwc = ma.array(self.lwc)
-        gradient_elements = np.gradient(self.lwc.filled(0))
-        return utils.l2norm(*gradient_elements)
+        return np.abs(np.gradient(self.lwc.filled(0), axis=1))
 
     def _calc_lwp_relative_error(self) -> npt.NDArray:
         err = self.lwc_source.lwp_error
@@ -412,9 +413,15 @@ COMMENTS = {
         "   liquid layers is difficult to ascertain."
     ),
     "lwc_error": (
-        "This variable is an estimate of the random error in liquid water content\n"
-        "due to the uncertainty in the microwave radiometer liquid water path\n"
-        "retrieval and the uncertainty in cloud base and/or cloud top height."
+        "This variable is an estimate of the one-standard-deviation random error\n"
+        "in liquid water content, expressed as a fraction of the liquid water\n"
+        "content. It combines the relative uncertainty in the microwave radiometer\n"
+        "liquid water path retrieval (limited to 10) and the uncertainty in cloud\n"
+        "base and cloud top height, taken as half a range gate and estimated from\n"
+        "the vertical gradient of liquid water content (limited to 5). If the liquid\n"
+        "layer is detected by the lidar only, there is the potential for cloud top\n"
+        "height to be underestimated. The error contribution from using the model\n"
+        "temperature and pressure at cloud base is assumed to be negligible."
     ),
     "lwc_retrieval_status": (
         "This variable describes whether a retrieval was performed for each pixel,\n"
@@ -469,9 +476,9 @@ LWC_ATTRIBUTES = {
         dimensions=("time", "height"),
     ),
     "lwc_error": MetaData(
-        long_name="Random error in liquid water content, one standard deviation",
+        long_name="Relative random error in liquid water content",
         comment=COMMENTS["lwc_error"],
-        units="dB",
+        units="1",
         dimensions=("time", "height"),
     ),
     "lwc_retrieval_status": MetaData(

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2}/cloudnetpy/version.py

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

{cloudnetpy-1.97.0 → cloudnetpy-1.97.2/cloudnetpy.egg-info}/PKG-INFO

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