cloudnetpy 1.78.0__py3-none-any.whl → 1.78.1__py3-none-any.whl

cloudnetpy/categorize/insects.py

@@ -83,7 +83,7 @@ def _get_smoothed_v(
     obs: ClassData,
     sigma: tuple[float, float] = (5, 5),
 ) -> ma.MaskedArray:
-    smoothed_v = gaussian_filter(obs.v, sigma)
+    smoothed_v = gaussian_filter(obs.v.filled(0), sigma)
     return ma.masked_where(obs.v.mask, smoothed_v)
 
 

cloudnetpy/categorize/radar.py

@@ -24,8 +24,6 @@ class Radar(DataSource):
         folding_velocity (float): Radar's folding velocity (m/s).
         location (str): Location of the radar, copied from the global attribute
             `location` of the input file.
-        sequence_indices (list): Indices denoting the different altitude
-            regimes of the radar.
         source_type (str): Type of the radar, copied from the global attribute
             `source` of the *radar_file*. Can be free form string but must
             include either 'rpg' or 'mira' denoting one of the two supported
@@ -39,21 +37,17 @@ class Radar(DataSource):
     def __init__(self, full_path: str):
         super().__init__(full_path, radar=True)
         self.radar_frequency = float(self.getvar("radar_frequency"))
-        self.folding_velocity = self._get_folding_velocity()
-        self.sequence_indices = self._get_sequence_indices()
         self.location = getattr(self.dataset, "location", "")
         self.source_type = getattr(self.dataset, "source", "")
         self.height: np.ndarray
         self.altitude: float
         self._init_data()
-        self._init_sigma_v()
-        self._get_folding_velocity_full()
 
     def rebin_to_grid(self, time_new: np.ndarray) -> list:
-        """Rebins radar data in time using mean.
+        """Rebins radar data in time.
 
         Args:
-            time_new: Target time array as fraction hour. Updates *time* attribute.
+            time_new: Target time array as fraction hour.
 
         """
         bad_time_indices = []
@@ -64,21 +58,25 @@ class Radar(DataSource):
                     bad_time_indices = array.rebin_data(self.time, time_new)
                     array.lin2db()
                 case "v":
-                    array.rebin_velocity(
-                        self.time,
+                    array.data = self._rebin_velocity(
+                        array.data,
                         time_new,
-                        self.folding_velocity,
-                        self.sequence_indices,
                     )
                 case "v_sigma":
-                    array.calc_linear_std(self.time, time_new)
+                    array.data, _ = utils.rebin_2d(
+                        self.time,
+                        array.data,
+                        time_new,
+                        "std",
+                        mask_zeros=True,
+                    )
                 case "width":
                     array.rebin_data(self.time, time_new)
                 case "rainfall_rate":
-                    array.rebin_data(self.time, time_new, mask_zeros=False)
+                    array.rebin_data(self.time, time_new)
                 case _:
                     continue
-        return bad_time_indices
+        return list(bad_time_indices)
 
     def remove_incomplete_pixels(self) -> None:
         """Mask radar pixels where one or more required quantities are missing.
@@ -337,63 +335,88 @@ class Radar(DataSource):
 
     def _init_data(self) -> None:
         self.append_data(self.getvar("Zh"), "Z", units="dBZ")
-        for key in ("v", "ldr", "width", "sldr", "rainfall_rate"):
-            try:
-                self._variables_to_cloudnet_arrays((key,))
-            except KeyError:
-                continue
-
-    def _init_sigma_v(self) -> None:
-        """Initializes std of the velocity field. The std will be calculated
-        later when re-binning the data.
-        """
         self.append_data(self.getvar("v"), "v_sigma")
+        for key in ("v", "ldr", "width", "sldr", "rainfall_rate", "nyquist_velocity"):
+            if key in self.dataset.variables:
+                data = self.dataset.variables[key]
+                self.append_data(data, key)
 
-    def _get_sequence_indices(self) -> list:
-        """Mira has only one sequence and one folding velocity. RPG has
-        several sequences with different folding velocities.
-        """
-        if self.height is None:
-            msg = "Height not found in the input file"
-            raise RuntimeError(msg)
-        all_indices = np.arange(len(self.height))
-        if not utils.isscalar(self.folding_velocity):
-            starting_indices = self.getvar("chirp_start_indices")
-            return np.split(all_indices, starting_indices[1:])
-        return [all_indices]
-
-    def _get_folding_velocity(self) -> np.ndarray | float:
+    def _rebin_velocity(
+        self,
+        data: np.ndarray,
+        time_new: np.ndarray,
+    ) -> np.ndarray:
+        """Rebins Doppler velocity in polar coordinates."""
+        folding_velocity = self._get_expanded_folding_velocity()
+        # with the new shape (maximum value in every bin)
+        max_folding_binned, _ = utils.rebin_2d(
+            self.time,
+            folding_velocity,
+            time_new,
+            "max",
+        )
+        # store this in the file
+        self.append_data(max_folding_binned, "nyquist_velocity")
+        # with original shape (repeat maximum value for each point in every bin)
+        max_folding_full, _ = utils.rebin_2d(
+            self.time,
+            folding_velocity,
+            time_new,
+            "max",
+            keepdim=True,
+        )
+        data_scaled = data * (np.pi / max_folding_full)
+        vel_x = ma.cos(data_scaled)
+        vel_y = ma.sin(data_scaled)
+        vel_x_mean, _ = utils.rebin_2d(self.time, vel_x, time_new)
+        vel_y_mean, _ = utils.rebin_2d(self.time, vel_y, time_new)
+        vel_scaled = ma.arctan2(vel_y_mean, vel_x_mean)
+        return vel_scaled / (np.pi / max_folding_binned)
+
+    def _get_expanded_folding_velocity(self) -> np.ndarray:
         if "nyquist_velocity" in self.dataset.variables:
-            return self.getvar("nyquist_velocity")
-        if "prf" in self.dataset.variables:
+            fvel = self.getvar("nyquist_velocity")
+        elif "prf" in self.dataset.variables:
             prf = self.getvar("prf")
-            return _prf_to_folding_velocity(prf, self.radar_frequency)
-        msg = "Unable to determine folding velocity"
-        raise RuntimeError(msg)
-
-    def _get_folding_velocity_full(self) -> None:
-        folding_velocity: list | np.ndarray = []
-        if utils.isscalar(self.folding_velocity):
-            folding_velocity = np.repeat(
-                self.folding_velocity,
-                len(self.sequence_indices[0]),
-            )
+            fvel = _prf_to_folding_velocity(prf, self.radar_frequency)
         else:
-            folding_velocity = list(folding_velocity)
-            self.folding_velocity = np.array(self.folding_velocity)
-            for indices, velocity in zip(
-                self.sequence_indices,
-                self.folding_velocity,
-                strict=True,
-            ):
-                folding_velocity.append(np.repeat(velocity, len(indices)))
-            folding_velocity = np.hstack(folding_velocity)
-        self.append_data(folding_velocity, "nyquist_velocity")
-
-
-def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> float:
+            msg = "Unable to determine folding velocity"
+            raise RuntimeError(msg)
+
+        n_time = self.getvar("time").size
+        n_height = self.height.size
+
+        if fvel.shape == (n_time, n_height):
+            # Folding velocity is already expanded in radar file
+            # Not yet in current files
+            return fvel
+        if utils.isscalar(fvel):
+            # e.g. MIRA
+            return np.broadcast_to(fvel, (n_time, n_height))
+
+        # RPG radars have chirp segments
+        starts = self.getvar("chirp_start_indices")
+        n_seg = starts.size if starts.ndim == 1 else starts.shape[1]
+
+        starts = np.broadcast_to(starts, (n_time, n_seg))
+        fvel = np.broadcast_to(fvel, (n_time, n_seg))
+
+        # Indices should start from zero (first range gate)
+        # In pre-processed RV Meteor files the first index is 1, so normalize:
+        # Normalize starts so indices begin from zero
+        first_values = starts[:, [0]]
+        if not np.all(np.isin(first_values, [0, 1])):
+            msg = "First value of chirp_start_indices must be 0 or 1"
+            raise ValueError(msg)
+        starts = starts - first_values
+
+        chirp_size = np.diff(starts, append=n_height)
+        return np.repeat(fvel.ravel(), chirp_size.ravel()).reshape((n_time, n_height))
+
+
+def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> np.ndarray:
     ghz_to_hz = 1e9
     if len(prf) != 1:
         msg = "Unable to determine folding velocity"
         raise RuntimeError(msg)
-    return float(prf[0] * constants.c / (4 * radar_frequency * ghz_to_hz))
+    return prf[0] * constants.c / (4 * radar_frequency * ghz_to_hz)

cloudnetpy/cloudnetarray.py

@@ -1,6 +1,5 @@
 """CloudnetArray class."""
 
-import math
 from collections.abc import Sequence
 
 import netCDF4
@@ -58,29 +57,22 @@ class CloudnetArray:
         """Masks data from given indices."""
         self.data[ind] = ma.masked
 
-    def rebin_data(
-        self, time: np.ndarray, time_new: np.ndarray, *, mask_zeros: bool = True
-    ) -> list:
+    def rebin_data(self, time: np.ndarray, time_new: np.ndarray) -> np.ndarray:
         """Rebins `data` in time.
 
         Args:
             time: 1D time array.
             time_new: 1D new time array.
-            mask_zeros: Whether to mask 0 values in the returned array. Default is True.
 
         Returns:
             Time indices without data.
 
         """
         if self.data.ndim == 1:
-            self.data = utils.rebin_1d(time, self.data, time_new, mask_zeros=mask_zeros)
-            bad_indices = list(np.where(self.data == ma.masked)[0])
+            self.data = utils.rebin_1d(time, self.data, time_new)
+            bad_indices = np.nonzero(self.data.mask)[0]
         else:
-            if not isinstance(self.data, ma.MaskedArray):
-                self.data = ma.masked_array(self.data)
-            self.data, bad_indices = utils.rebin_2d(
-                time, self.data, time_new, mask_zeros=mask_zeros
-            )
+            self.data, bad_indices = utils.rebin_2d(time, self.data, time_new)
         return bad_indices
 
     def fetch_attributes(self) -> list:
@@ -108,6 +100,21 @@ class CloudnetArray:
             if data:
                 setattr(self, key, data)
 
+    def filter_isolated_pixels(self) -> None:
+        """Filters hot pixels from radar data."""
+        self._filter(utils.filter_isolated_pixels)
+
+    def filter_vertical_stripes(self) -> None:
+        """Filters vertical artifacts from radar data."""
+        self._filter(utils.filter_x_pixels)
+
+    def _filter(self, fun) -> None:
+        if not isinstance(self.data, ma.MaskedArray):
+            self.data = ma.masked_array(self.data)
+        is_data = (~self.data.mask).astype(int)
+        is_data_filtered = fun(is_data)
+        self.data[is_data_filtered == 0] = ma.masked
+
     def _init_data(self) -> np.ndarray:
         if isinstance(self.variable, netCDF4.Variable):
             return self.variable[:]
@@ -139,73 +146,3 @@ class CloudnetArray:
 
     def __getitem__(self, ind: tuple) -> np.ndarray:
         return self.data[ind]
-
-    def filter_isolated_pixels(self) -> None:
-        """Filters hot pixels from radar data."""
-        self._filter(utils.filter_isolated_pixels)
-
-    def filter_vertical_stripes(self) -> None:
-        """Filters vertical artifacts from radar data."""
-        self._filter(utils.filter_x_pixels)
-
-    def _filter(self, fun) -> None:
-        if not isinstance(self.data, ma.MaskedArray):
-            self.data = ma.masked_array(self.data)
-        is_data = (~self.data.mask).astype(int)
-        is_data_filtered = fun(is_data)
-        self.data[is_data_filtered == 0] = ma.masked
-
-    def calc_linear_std(self, time: np.ndarray, time_new: np.ndarray) -> None:
-        """Calculates std of radar velocity.
-
-        Args:
-            time: 1D time array.
-            time_new: 1D new time array.
-
-        Notes:
-            The result is masked if the bin contains masked values.
-        """
-        data_as_float = self.data.astype(float)
-        data_as_float = ma.masked_array(data_as_float)
-        self.data, _ = utils.rebin_2d(time, data_as_float, time_new, "std")
-
-    def rebin_velocity(
-        self,
-        time: np.ndarray,
-        time_new: np.ndarray,
-        folding_velocity: float | np.ndarray,
-        sequence_indices: list,
-    ) -> None:
-        """Rebins Doppler velocity in polar coordinates.
-
-        Args:
-            time: 1D time array.
-            time_new: 1D new time array.
-            folding_velocity: Folding velocity (m/s). Can be a float when
-                it's the same for all altitudes, or np.ndarray when it
-                matches difference altitude regions (defined in `sequence_indices`).
-            sequence_indices: List containing indices of different folding regions,
-                e.g. [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10]].
-
-        """
-
-        def _get_scaled_vfold() -> np.ndarray:
-            vfold_scaled = math.pi / folding_velocity
-            if isinstance(vfold_scaled, float):
-                vfold_scaled = np.array([float(vfold_scaled)])
-            return vfold_scaled
-
-        def _scale_by_vfold(data_in: np.ndarray, fun) -> np.ndarray:
-            data_out = ma.copy(data_in)
-            for i, ind in enumerate(sequence_indices):
-                data_out[:, ind] = fun(data_in[:, ind], folding_velocity_scaled[i])
-            return data_out
-
-        folding_velocity_scaled = _get_scaled_vfold()
-        data_scaled = _scale_by_vfold(self.data, np.multiply)
-        vel_x = ma.cos(data_scaled)
-        vel_y = ma.sin(data_scaled)
-        vel_x_mean, _ = utils.rebin_2d(time, vel_x, time_new)
-        vel_y_mean, _ = utils.rebin_2d(time, vel_y, time_new)
-        mean_vel_scaled = np.arctan2(vel_y_mean, vel_x_mean)
-        self.data = _scale_by_vfold(mean_vel_scaled, np.divide)

cloudnetpy/datasource.py

@@ -182,53 +182,6 @@ class DataSource:
             return np.array(range_instrument + self.altitude)
         return None
 
-    def _variables_to_cloudnet_arrays(self, keys: tuple) -> None:
-        """Transforms netCDF4-variables into CloudnetArrays.
-
-        Args:
-            keys: netCDF4-variables to be converted. The results
-                are saved in *self.data* dictionary with *fields*
-                strings as keys.
-
-        Notes:
-            The attributes of the variables are not copied. Just the data.
-
-        """
-        for key in keys:
-            self.append_data(self.dataset.variables[key], key)
-
-    def _unknown_variable_to_cloudnet_array(
-        self,
-        possible_names: tuple,
-        key: str,
-        units: str | None = None,
-        *,
-        ignore_mask: bool = False,
-    ) -> None:
-        """Transforms single netCDF4 variable into CloudnetArray.
-
-        Args:
-            possible_names: Tuple of strings containing the possible
-                names of the variable in the input NetCDF file.
-            key: Key for self.data dictionary and name-attribute
-                for the saved CloudnetArray object.
-            units: Units attribute for the CloudnetArray object.
-            ignore_mask: If true, always writes an ordinary numpy array.
-
-        Raises:
-            RuntimeError: No variable found.
-
-        """
-        for name in possible_names:
-            if name in self.dataset.variables:
-                array: netCDF4.Variable | np.ndarray = self.dataset.variables[name]
-                if ignore_mask is True:
-                    array = np.array(array)
-                self.append_data(array, key, units=units)
-                return
-        msg = f"Missing variable {possible_names[0]} in the input file."
-        raise RuntimeError(msg)
-
     def __enter__(self):
         return self
 

cloudnetpy/model_evaluation/plotting/plot_tools.py

@@ -97,7 +97,7 @@ def read_data_characters(nc_file: str, name: str, model: str) -> tuple:
     try:
         mask = y.mask
         if mask.any():
-            x, y, data = change2one_dim_axes(x, y, data)
+            x, y, data = change2one_dim_axes(ma.array(x), y, data)
     except AttributeError:
         return data, x, y
     return data, x, y

cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py

@@ -65,7 +65,7 @@ def test_fit_z_sensitivity(obs_file, model_file) -> None:
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     adv_pro = AdvanceProductMethods(model, str(model_file), obs)
     h = np.array([[5000, 9000, 13000], [10000, 15000, 20000], [8000, 12000, 16000]])
-    compare = np.array([[0, 0.15, 0.5], [0.1, 1, 0], [0.15, 0, 1]])
+    compare = ma.masked_invalid([[np.nan, 0.15, 0.5], [0.1, 1, np.nan], [0.15, 0, 1]])
     x = adv_pro.fit_z_sensitivity(h)
     testing.assert_array_almost_equal(x, compare)
 

cloudnetpy/utils.py

@@ -3,7 +3,6 @@
 import base64
 import datetime
 import hashlib
-import logging
 import os
 import re
 import textwrap
@@ -11,7 +10,7 @@ import uuid
 import warnings
 from collections.abc import Iterator
 from datetime import timezone
-from typing import Literal, TypeVar
+from typing import Any, Literal, TypeVar
 
 import netCDF4
 import numpy as np
@@ -142,54 +141,42 @@ def binvec(x: np.ndarray | list) -> np.ndarray:
 
 def rebin_2d(
     x_in: np.ndarray,
-    array: ma.MaskedArray,
+    array: np.ndarray,
     x_new: np.ndarray,
-    statistic: Literal["mean", "std"] = "mean",
+    statistic: Literal["mean", "std", "max"] = "mean",
     n_min: int = 1,
     *,
-    mask_zeros: bool = True,
-) -> tuple[ma.MaskedArray, list]:
-    """Rebins 2-D data in one dimension.
+    keepdim: bool = False,
+    mask_zeros: bool = False,
+) -> tuple[ma.MaskedArray, np.ndarray]:
+    edges = binvec(x_new)
+    binn = np.digitize(x_in, edges) - 1
+    n_bins = len(x_new)
+    counts = np.bincount(binn[binn >= 0], minlength=n_bins)
 
-    Args:
-        x_in: 1-D array with shape (n,).
-        array: 2-D input data with shape (n, m).
-        x_new: 1-D target vector (center points) with shape (N,).
-        statistic: Statistic to be calculated. Possible statistics are 'mean', 'std'.
-            Default is 'mean'.
-        n_min: Minimum number of points to have good statistics in a bin. Default is 1.
-        mask_zeros: Whether to mask 0 values in the returned array. Default is True.
+    stat_fn: Any = {
+        "mean": ma.mean,
+        "std": ma.std,
+        "max": ma.max,
+    }[statistic]
 
-    Returns:
-        tuple: Rebinned data with shape (N, m) and indices of bins without enough data.
-    """
-    edges = binvec(x_new)
-    result = np.zeros((len(x_new), array.shape[1]))
-    array_screened = ma.masked_invalid(array, copy=True)  # data may contain nan-values
-    for ind, values in enumerate(array_screened.T):
-        mask = ~values.mask
-        if ma.any(values[mask]):
-            result[:, ind], _, _ = stats.binned_statistic(
-                x_in[mask],
-                values[mask],
-                statistic=statistic,
-                bins=edges,
-            )
-    result[~np.isfinite(result)] = 0
-    if mask_zeros is True:
-        masked_result = ma.masked_equal(result, 0)
-    else:
-        masked_result = ma.array(result)
+    shape = array.shape if keepdim else (n_bins, array.shape[1])
+    result: ma.MaskedArray = ma.masked_array(np.ones(shape, dtype="float32"), mask=True)
+
+    for bin_ind in range(n_bins):
+        if counts[bin_ind] < n_min:
+            continue
+        mask = binn == bin_ind
+        block = array[mask, :]
+        x_ind = mask if keepdim else bin_ind
+        result[x_ind, :] = stat_fn(block, axis=0)
 
-    # Fill bins with not enough profiles
-    x_hist, _ = np.histogram(x_in, bins=edges)
-    empty_mask = x_hist < n_min
-    masked_result[empty_mask, :] = ma.masked
-    empty_indices = list(np.nonzero(empty_mask)[0])
-    if len(empty_indices) > 0:
-        logging.debug("No data in %s bins", len(empty_indices))
+    empty_bins = np.where(counts < n_min)[0]
 
-    return masked_result, empty_indices
+    if mask_zeros:
+        result[result == 0] = ma.masked
+
+    return result, empty_bins
 
 
 def rebin_1d(
@@ -197,8 +184,6 @@ def rebin_1d(
     array: np.ndarray | ma.MaskedArray,
     x_new: np.ndarray,
     statistic: str = "mean",
-    *,
-    mask_zeros: bool = True,
 ) -> ma.MaskedArray:
     """Rebins 1D array.
 
@@ -208,14 +193,13 @@ def rebin_1d(
         x_new: 1-D target vector (center points) with shape (N,).
         statistic: Statistic to be calculated. Possible statistics are 'mean', 'std'.
             Default is 'mean'.
-        mask_zeros: Whether to mask 0 values in the returned array. Default is True.
 
     Returns:
         Re-binned data with shape (N,).
 
     """
     edges = binvec(x_new)
-    result = np.zeros(len(x_new))
+    result = ma.zeros(len(x_new))
     array_screened = ma.masked_invalid(array, copy=True)  # data may contain nan-values
     mask = ~array_screened.mask
     if ma.any(array_screened[mask]):
@@ -225,10 +209,7 @@ def rebin_1d(
             statistic=statistic,
             bins=edges,
         )
-    result[~np.isfinite(result)] = 0
-    if mask_zeros:
-        return ma.masked_equal(result, 0)
-    return ma.array(result)
+    return ma.masked_invalid(result, copy=True)
 
 
 def filter_isolated_pixels(array: np.ndarray) -> np.ndarray:

cloudnetpy/version.py

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

{cloudnetpy-1.78.0.dist-info → cloudnetpy-1.78.1.dist-info}/METADATA

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

{cloudnetpy-1.78.0.dist-info → cloudnetpy-1.78.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 cloudnetpy/__init__.py,sha256=X_FqY-4yg5GUj5Edo14SToLEos6JIsC3fN-v1FUgQoA,43
 cloudnetpy/cli.py,sha256=lHkeAErmAijI-Ugpd4DHRHfbZP4SXOake0LIY5Ovv_Q,20782
-cloudnetpy/cloudnetarray.py,sha256=XFyXZwR4QWPyo7WLmvsu7DEELZQp1vi5FZ8F7tX_tM0,7307
+cloudnetpy/cloudnetarray.py,sha256=uOYgpQ8hHh5fuHyip1HjnhsEda9_7dg7orYnbCRkTtI,4796
 cloudnetpy/concat_lib.py,sha256=XQ5Sk8kfXqI0Q5HoomKWWhdZ1-m2thYDKGL7SKapITE,12851
 cloudnetpy/constants.py,sha256=YnoSzZm35NDooJfhlulSJBc7g0eSchT3yGytRaTaJEI,845
-cloudnetpy/datasource.py,sha256=FcWS77jz56gIzwnbafDLdj-HjAyu0P_VtY7gkeVZThU,7952
+cloudnetpy/datasource.py,sha256=Vx_I8S14nFAWKI0VbsW_-sllbVCRjTYxB7XH9b9PedQ,6268
 cloudnetpy/exceptions.py,sha256=hYbUtBwjCIfxnPe_5mELDEw87AWITBrwuo7WYIEKmJ8,1579
 cloudnetpy/metadata.py,sha256=lO7BCbVAzFoH3Nq-VuezYX0f7MnbG1Zp11g5GSiuQwM,6189
 cloudnetpy/output.py,sha256=gupxt4f_-eUrFsWMto8tnknoV-p9QauC9L6CJAqBILU,15988
 cloudnetpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cloudnetpy/utils.py,sha256=O57jqUX61V_Jodrs_04Js9cmTUbK0cymW9NcHzKVrx0,32926
-cloudnetpy/version.py,sha256=Umza9M-fEEsgi9FrAC0XLoVQcbh-gNPHmP_sNLxDOD4,72
+cloudnetpy/utils.py,sha256=HdcSNIgdxoZlP_jHl66ItheHLw_cDYZb7u6mZ5dfMNE,31952
+cloudnetpy/version.py,sha256=3xCJ6Zv7LkLahqubKZWS5YDwui01I7yk-Z-3oUGO9Us,72
 cloudnetpy/categorize/__init__.py,sha256=s-SJaysvVpVVo5kidiruWQO6p3gv2TXwY1wEHYO5D6I,44
 cloudnetpy/categorize/atmos_utils.py,sha256=RcmbKxm2COkE7WEya0mK3yX5rzUbrewRVh3ekm01RtM,10598
 cloudnetpy/categorize/attenuation.py,sha256=Y_-fzmQTltWTqIZTulJhovC7a6ifpMcaAazDJcnMIOc,990
@@ -20,13 +20,13 @@ cloudnetpy/categorize/disdrometer.py,sha256=sRSt2B932lrrkvycKoSaKEIaDVfq9Z7uU-4i
 cloudnetpy/categorize/droplet.py,sha256=t49KEsH5ZM68JQ4NvAf9kGgQ-evic1T4de2-jgJ2f4M,8683
 cloudnetpy/categorize/falling.py,sha256=lok0HMi1ewf9pS70mq62nRKL6wJzMyWbYmv1cdwrwnA,4404
 cloudnetpy/categorize/freezing.py,sha256=eSFD37R7vBrg7mgfSanrwhBjnFyWNBpjw2AtvRmSh48,3753
-cloudnetpy/categorize/insects.py,sha256=9J5agmktit8Or66GGNue-bThiaG9rB2SuPNZBXI7FCE,5243
+cloudnetpy/categorize/insects.py,sha256=MrxlWK-5JaMZxCBWFKR_6Kj5TAVXm-s9SVxsvcyNYJo,5253
 cloudnetpy/categorize/itu.py,sha256=ffXK27guyRS4d66VWQ2h4UEGjUIhGjPKbFmj7kh698c,10304
 cloudnetpy/categorize/lidar.py,sha256=YQrM_LOz8NQrrD9l9HyujV1GSGwkQ8LMqXN13bEJRW4,2605
 cloudnetpy/categorize/melting.py,sha256=ZnLeL_qWmiCdjXVOm9iBYHdo29Brqxu_DEErZPqUloQ,6217
 cloudnetpy/categorize/model.py,sha256=QFRCY0TvM2fzGRyP8BNkqbvu13XcQjt7TsN5fhjI_Uc,6654
 cloudnetpy/categorize/mwr.py,sha256=F7cquERWL6mBkgboqeaCIPf9gOlKI-NWUQIBdQXGT_I,1635
-cloudnetpy/categorize/radar.py,sha256=PmriTnrHbgZrau1RTNKpPI_-h5Uu0kGIMrMOaoMuROY,14821
+cloudnetpy/categorize/radar.py,sha256=z2bFF_wAKbzzXB3Pq1z33Y1RMv6NL-8CdZesU89qzpw,15502
 cloudnetpy/categorize/attenuations/__init__.py,sha256=CWFHVWeTIe2hrZtgkJaX2HGftbuffsFc39Mzv5B0Lw0,1037
 cloudnetpy/categorize/attenuations/gas_attenuation.py,sha256=emr-RCxQT0i2N8k6eBNhRsmsCBPHJzQsWJfjC4fVSTo,975
 cloudnetpy/categorize/attenuations/liquid_attenuation.py,sha256=0p0G79BPkw1itCXHMwbvkNHtJGBocJzow3gNHAirChI,3036
@@ -68,7 +68,7 @@ cloudnetpy/model_evaluation/model_metadata.py,sha256=CxpY6RPm7GOTBBmPhcNVVpm9ate
 cloudnetpy/model_evaluation/utils.py,sha256=Z9VqYVdtY9yTr2JeVfBn4nccIVWCN5Fd-BCyB_qYI-A,154
 cloudnetpy/model_evaluation/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/model_evaluation/plotting/plot_meta.py,sha256=K18Ugohh24uVAIxjZgJsmK80YwsMstm6B7ptVafONAw,3557
-cloudnetpy/model_evaluation/plotting/plot_tools.py,sha256=gV042W_AHidwPsRe2L57xdWbt3W-utcHMt_9FmfYK3M,5033
+cloudnetpy/model_evaluation/plotting/plot_tools.py,sha256=umI06tPIEs48cQ8GY8s3vGHwPcN--tUir4s1yxNQf64,5043
 cloudnetpy/model_evaluation/plotting/plotting.py,sha256=mGgSnQoRTh04v5RSJHsYPaqUEIR82eZqAuiszrh9rjY,31235
 cloudnetpy/model_evaluation/products/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/model_evaluation/products/advance_methods.py,sha256=rng3ZLR1Arv1AGUzq0Ehu-65628PC5LZVKpHSUpCIW8,8526
@@ -93,7 +93,7 @@ cloudnetpy/model_evaluation/tests/e2e/process_lwc/main.py,sha256=IFcPj-Vce9Yn0Cf
 cloudnetpy/model_evaluation/tests/e2e/process_lwc/tests.py,sha256=ANBA0LVao3Xrm-prRnwUmxM6BdQzqM7GZNKB3uz5BXQ,1725
 cloudnetpy/model_evaluation/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/model_evaluation/tests/unit/conftest.py,sha256=WL_FgrDeoUYGp4PKjb37HLu79D9uu33PGQL40_ctqS0,7446
-cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py,sha256=IkoAVtsWVFrPpFqQOLAPHKb9qgV-KjGGVEtWMudeiSo,10079
+cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py,sha256=UEF94sBN8pPOyoz5ARag3mc5A8KFjyY_-IJFqdKBGug,10098
 cloudnetpy/model_evaluation/tests/unit/test_grid_methods.py,sha256=AEUXN5HBhKliPsSNGDCUtWOtIx6Y8iqkywb_-RfXYU0,26277
 cloudnetpy/model_evaluation/tests/unit/test_model_products.py,sha256=FRbYLshSHH2E527uJPwvUIyZKTsPFSZrwDsPsNrFSSU,3475
 cloudnetpy/model_evaluation/tests/unit/test_observation_products.py,sha256=DN3yVqq8vFYca_9POjcrJ8XViMrJks_jM-aQznfN8QQ,4936
@@ -117,10 +117,10 @@ cloudnetpy/products/lwc.py,sha256=sl6Al2tuH3KkCBrPbWTmuz3jlD5UQJ4D6qBsn1tt2CQ,18
 cloudnetpy/products/mie_lu_tables.nc,sha256=It4fYpqJXlqOgL8jeZ-PxGzP08PMrELIDVe55y9ob58,16637951
 cloudnetpy/products/mwr_tools.py,sha256=8HPZpQMTojKZP1JS1S83IE0sxmbDE9bxlaWoqmGnUZE,6199
 cloudnetpy/products/product_tools.py,sha256=uu4l6reuGbPcW3TgttbaSrqIKbyYGhBVTdnC7opKvmg,11101
-cloudnetpy-1.78.0.dist-info/licenses/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
+cloudnetpy-1.78.1.dist-info/licenses/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
 docs/source/conf.py,sha256=IKiFWw6xhUd8NrCg0q7l596Ck1d61XWeVjIFHVSG9Og,1490
-cloudnetpy-1.78.0.dist-info/METADATA,sha256=4CkmH9P2aO02UADla12HiMWCqnPts65FVD6PrZYBre4,5796
-cloudnetpy-1.78.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-cloudnetpy-1.78.0.dist-info/entry_points.txt,sha256=HhY7LwCFk4qFgDlXx_Fy983ZTd831WlhtdPIzV-Y3dY,51
-cloudnetpy-1.78.0.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
-cloudnetpy-1.78.0.dist-info/RECORD,,
+cloudnetpy-1.78.1.dist-info/METADATA,sha256=AznJgGBfGvD7cbWAieBBM5xVu3Wn9GQebLBXaAVFJUE,5796
+cloudnetpy-1.78.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cloudnetpy-1.78.1.dist-info/entry_points.txt,sha256=HhY7LwCFk4qFgDlXx_Fy983ZTd831WlhtdPIzV-Y3dY,51
+cloudnetpy-1.78.1.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
+cloudnetpy-1.78.1.dist-info/RECORD,,

{cloudnetpy-1.78.0.dist-info → cloudnetpy-1.78.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any