cloudnetpy 1.88.2__tar.gz → 1.89.0__tar.gz

{cloudnetpy-1.88.2/cloudnetpy.egg-info → cloudnetpy-1.89.0}/PKG-INFO

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

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/categorize/classify.py

@@ -91,6 +91,7 @@ def classify_measurements(data: Observations) -> ClassificationResult:
     bits.aerosol = _find_aerosols(obs, bits)
     bits.aerosol[filtered_ice] = False
     _fix_super_cold_liquid(obs, bits)
+    _reclassify_ice_with_high_ldr(obs, bits)
 
     return ClassificationResult(
         category_bits=bits,
@@ -122,6 +123,27 @@ def fetch_quality(
     )
 
 
+def _reclassify_ice_with_high_ldr(obs: ClassData, bits: CategoryBits) -> None:
+    """Reclassifies ice pixels with high LDR as insects.
+
+    Ice particles typically have LDR below -13 dB. Higher values in the
+    freezing region (excluding the melting layer) indicate insects, which
+    can be present in temperatures down to about -10 C.
+    """
+    if not hasattr(obs, "ldr"):
+        return
+    ldr_limit = -13
+    temp_limit = T0 - 10
+    is_ice = bits.falling & bits.freezing & ~bits.droplet & ~bits.melting
+    high_ldr = ~ma.getmaskarray(obs.ldr) & (obs.ldr > ldr_limit)
+    warm_enough = obs.tw > temp_limit
+    reclassify = is_ice & high_ldr & warm_enough
+    bits.insect[reclassify] = True
+    bits.falling[reclassify] = False
+    has_lidar = ~obs.beta.mask
+    bits.aerosol[reclassify & has_lidar] = True
+
+
 def _fix_super_cold_liquid(obs: ClassData, bits: CategoryBits) -> None:
     """Supercooled liquid droplets do not exist in atmosphere below around -38 C."""
     t_limit = T0 - 38

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/categorize/model.py

@@ -16,6 +16,7 @@ from cloudnetpy.categorize.itu import (
     calc_saturation_vapor_pressure,
 )
 from cloudnetpy.cloudnetarray import CloudnetArray
+from cloudnetpy.constants import G
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.exceptions import ModelDataError
 
@@ -115,6 +116,7 @@ class Model(DataSource):
                 array,
                 time_grid,
                 half_height if "atten" in key else height_grid,
+                extrapolate=True,
             )
         self.height = height_grid
         return utils.find_masked_profiles_indices(self.data_dense["temperature"])
@@ -144,7 +146,26 @@ class Model(DataSource):
         except KeyError as err:
             msg = "No 'height' variable in the model file."
             raise ModelDataError(msg) from err
-        return self.to_m(model_heights) + alt_site
+        surface_altitude = self._get_model_surface_altitude(alt_site)
+        return self.to_m(model_heights) + surface_altitude
+
+    def _get_model_surface_altitude(self, alt_site: float) -> float | npt.NDArray:
+        """Returns model surface altitude from geopotential if available.
+
+        For sites in complex terrain (e.g. mountains), the model grid cell
+        surface height can differ significantly from the actual site altitude.
+        Using the model's own surface height ensures that thermodynamic fields
+        are placed at their physically correct absolute heights.
+
+        Note: Model surface altitude might be higher than the site altitude.
+        """
+        if "sfc_height" in self.dataset.variables:
+            sfc_height = self.dataset.variables["sfc_height"][:]
+            return sfc_height[:, np.newaxis]
+        if "sfc_geopotential" in self.dataset.variables:
+            geopotential = self.dataset.variables["sfc_geopotential"][:]
+            return geopotential[:, np.newaxis] / G
+        return alt_site
 
     def calc_attenuations(self, frequency: float) -> None:
         temperature = self.getvar("temperature")

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/categorize/radar.py

@@ -123,26 +123,12 @@ class Radar(DataSource):
         if variable not in self.data:
             return
         data = ma.copy(self.data[variable][:])
-        n_points_in_profiles = ma.count(data, axis=1)
-        n_profiles_with_data = np.count_nonzero(n_points_in_profiles)
+        n_profiles_with_data = np.count_nonzero(ma.count(data, axis=1))
         if n_profiles_with_data < 300:
             return
-        n_vertical = self._filter(
-            data,
-            axis=1,
-            min_coverage=0.5,
-            z_limit=10,
-            distance=4,
-            n_blocks=100,
-        )
-        n_horizontal = self._filter(
-            data,
-            axis=0,
-            min_coverage=0.3,
-            z_limit=-30,
-            distance=3,
-            n_blocks=20,
-        )
+
+        n_vertical = self._filter_stripes_axis(data, variable, axis=1)
+        n_horizontal = self._filter_stripes_axis(data, variable, axis=0)
         if n_vertical > 0 or n_horizontal > 0:
             logging.debug(
                 "Filtered %s vertical and %s horizontal stripes "
@@ -152,57 +138,74 @@ class Radar(DataSource):
                 variable,
             )
 
-    def _filter(
+    def _filter_stripes_axis(
         self,
         data: npt.NDArray,
+        variable: str,
         axis: int,
-        min_coverage: float,
-        z_limit: float,
-        distance: float,
-        n_blocks: int,
     ) -> int:
-        if axis == 0:
-            data = data.T
-            echo = self.data["Z"][:].T
-        else:
-            echo = self.data["Z"][:]
-
-        len_block = int(np.floor(data.shape[0] / n_blocks))
-        block_indices = np.arange(len_block)
-        n_removed_total = 0
-
-        for block_number in range(n_blocks):
-            data_block = data[block_indices, :]
-            n_values = ma.count(data_block, axis=1)
-            try:
-                q1 = np.quantile(n_values, 0.25)
-                q3 = np.quantile(n_values, 0.75)
-            except IndexError:
-                continue
-
-            if q1 == q3:
-                continue
-
-            threshold = distance * (q3 - q1) + q3
-
-            indices = np.where(
-                (n_values > threshold) & (n_values > (min_coverage * data.shape[1])),
-            )[0]
-            true_ind = [int(x) for x in (block_number * len_block + indices)]
-            n_removed = len(indices)
-
-            if n_removed > 5:
+        n_values = ma.count(data, axis=axis)
+        n = len(n_values)
+        margin = 5
+
+        spike_indices: set[int] = set()
+        for i in range(margin, n - margin):
+            window = [n_values[i + j] for j in range(-margin, margin + 1) if j != 0]
+            q1, q3 = np.percentile(window, [25, 75])
+            iqr = q3 - q1
+            if iqr == 0 and q3 > 0:
                 continue
+            threshold = q3 + 3 * max(iqr, 1)
+            if n_values[i] > max(threshold, 20):
+                spike_indices.add(i)
+
+        for ind in sorted(spike_indices):
+            below = ind - 1
+            while below >= 0 and below in spike_indices:
+                below -= 1
+            above = ind + 1
+            while above < n and above in spike_indices:
+                above += 1
+            self._mask_stripe_pixels(variable, ind, axis, below, above, n)
+
+        return len(spike_indices)
+
+    def _mask_stripe_pixels(
+        self,
+        variable: str,
+        ind: int,
+        axis: int,
+        below: int,
+        above: int,
+        dim_size: int,
+    ) -> None:
+        self._mask_isolated("v", "Z", ind, axis, below, above, dim_size)
+        if variable != "v" and variable in self.data:
+            self._mask_isolated(variable, variable, ind, axis, below, above, dim_size)
 
-            if n_removed > 0:
-                n_removed_total += n_removed
-                for ind in true_ind:
-                    ind2 = np.where(echo[ind, :] < z_limit)
-                    bad_indices = (ind, ind2) if axis == 1 else (ind2, ind)
-                    self.data["v"][:][bad_indices] = ma.masked
-            block_indices += len_block
-
-        return n_removed_total
+    def _mask_isolated(
+        self,
+        target: str,
+        source: str,
+        ind: int,
+        axis: int,
+        below: int,
+        above: int,
+        dim_size: int,
+    ) -> None:
+        mask = ma.getmaskarray(self.data[source][:])
+        has = ~mask[:, ind] if axis == 0 else ~mask[ind, :]
+        lo = (mask[:, below] if axis == 0 else mask[below, :]) if below >= 0 else True
+        hi = (
+            (mask[:, above] if axis == 0 else mask[above, :])
+            if above < dim_size
+            else True
+        )
+        isolated = has & lo & hi
+        if axis == 0:
+            self.data[target][:][isolated, ind] = ma.masked
+        else:
+            self.data[target][:][ind, isolated] = ma.masked
 
     def correct_atten(self, attenuations: RadarAttenuation) -> None:
         """Corrects radar echo for liquid and gas attenuation.

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/cli.py

@@ -153,6 +153,9 @@ def _process_instrument_product(
     fun: Callable
     match (product, instrument.instrument_id):
         case ("radar", _id) if "mira" in _id:
+            site_meta["range_correction_factor"] = calibration.get(
+                "range_correction_factor"
+            )
             fun = instruments.mira2nc
         case ("radar", _id) if "rpg" in _id:
             fun = instruments.rpg2nc
@@ -388,16 +391,18 @@ def _fetch_product(
         meta = [meta[0]]
     suffix = "geophysical" if "geophysical" in meta[0].product.type else "instrument"
     folder = _create_output_folder(suffix, args)
-    return _download_product_file(meta, folder, client)
+    return _download_product_file(meta, folder, client, force=args.force_download)
 
 
 def _fetch_model(args: argparse.Namespace, client: APIClient) -> str | None:
-    files = client.files(product_id="model", date=args.date, site_id=args.site)
+    files = client.files(
+        product_id="model", model_id=args.model, date=args.date, site_id=args.site
+    )
     if not files:
         logging.info("No model data available for this date")
         return None
     folder = _create_output_folder("instrument", args)
-    return _download_product_file(files, folder, client)
+    return _download_product_file(files, folder, client, force=args.force_download)
 
 
 def _fetch_raw(
@@ -406,19 +411,32 @@ def _fetch_raw(
     pid = _shorten_pid(metadata[0].instrument.pid)
     instrument = f"{metadata[0].instrument.instrument_id}_{pid}"
     folder = _create_input_folder(instrument, args)
+    if args.force_download:
+        for meta in metadata:
+            filepath = folder / meta.download_url.split("/")[-1]
+            if filepath.exists():
+                logging.info("Removing existing file: %s", filepath)
+                filepath.unlink()
     return client.download(metadata, output_directory=folder)
 
 
 def _download_product_file(
-    meta: list[ProductMetadata], folder: Path, client: APIClient
+    meta: list[ProductMetadata],
+    folder: Path,
+    client: APIClient,
+    *,
+    force: bool = False,
 ) -> str:
     if len(meta) > 1:
         msg = "Multiple product files found"
         raise ValueError(msg)
     filepath = folder / meta[0].filename
-    if filepath.exists():
+    if filepath.exists() and not force:
         logging.info("Existing file found: %s", filepath)
         return str(filepath)
+    if filepath.exists():
+        logging.info("Removing existing file: %s", filepath)
+        filepath.unlink()
     logging.info("Downloading file: %s", filepath)
     return str(client.download(meta, output_directory=folder)[0])
 
@@ -438,10 +456,13 @@ def _plot(
 ) -> None:
     if filepath is None or (not args.plot and not args.show):
         return
-    res = requests.get(f"{cloudnet_api_url}products/variables", timeout=60)
-    res.raise_for_status()
-    variables = next(var["variables"] for var in res.json() if var["id"] == product)
-    variables = [var["id"].split("-")[-1] for var in variables]
+    if args.variables is not None:
+        variables = args.variables.split(",")
+    else:
+        res = requests.get(f"{cloudnet_api_url}products/variables", timeout=60)
+        res.raise_for_status()
+        variables = next(var["variables"] for var in res.json() if var["id"] == product)
+        variables = [var["id"].split("-")[-1] for var in variables]
     image_name = str(filepath).replace(".nc", ".png") if args.plot else None
     try:
         generate_figure(
@@ -486,6 +507,21 @@ def _parse_products(product_argument: str, client: APIClient) -> list[str]:
     return valid_products
 
 
+def _parse_model(model_id: str, client: APIClient) -> str:
+    models = client.models()
+    found = False
+    for model in models:
+        if model_id == model.source_model_id and model.id != model.source_model_id:
+            msg = f"Use {model.id} or similar instead of {model_id}"
+            raise argparse.ArgumentTypeError(msg)
+        if model_id == model.id:
+            found = True
+    if not found:
+        msg = f"Invalid model: {model_id}"
+        raise argparse.ArgumentTypeError(msg)
+    return model_id
+
+
 def main() -> None:
     client = APIClient()
     parser = argparse.ArgumentParser(
@@ -501,7 +537,11 @@ def main() -> None:
         metavar="SITE",
     )
     parser.add_argument(
-        "-d", "--date", type=str, help="Date in YYYY-MM-DD", required=True
+        "-d",
+        "--date",
+        type=str,
+        help="Date in YYYY-MM-DD (default: today)",
+        default=datetime.datetime.now(tz=datetime.timezone.utc).date().isoformat(),
     )
     parser.add_argument(
         "-p",
@@ -514,6 +554,12 @@ def main() -> None:
         ),
         required=True,
     )
+    parser.add_argument(
+        "-m",
+        "--model",
+        type=lambda arg: _parse_model(arg, client),
+        help="Model to use in categorize.",
+    )
     parser.add_argument("--input", type=Path, help="Input path", default="input/")
     parser.add_argument("--output", type=Path, help="Output path", default="output/")
     parser.add_argument(
@@ -534,6 +580,19 @@ def main() -> None:
         default=False,
         action=argparse.BooleanOptionalAction,
     )
+    parser.add_argument(
+        "--force-download",
+        help="Force re-download of input files even if they exist locally",
+        default=False,
+        action=argparse.BooleanOptionalAction,
+    )
+    parser.add_argument(
+        "-v",
+        "--variables",
+        type=str,
+        help="Variables to plot (comma-separated), e.g. 'target_classification'",
+        default=None,
+    )
     args = parser.parse_args()
 
     logger = logging.getLogger()

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/instruments/mira.py

@@ -156,6 +156,7 @@ class Mira(NcRadar):
         if "tpow" not in self.data:
             logging.warning("Variable tpow is missing")
             return
+        self._correct_fzk_tpow()
         tpow = self.data["tpow"][:]
         # Threshold for abnormally low power e.g. Limassol 2024-10-20. Average
         # power should 30 to 60 W according to MIRA-35 data sheet. Based on a
@@ -169,6 +170,27 @@ class Mira(NcRadar):
             )
             self.screen_time_indices(~is_low)
 
+    def _correct_fzk_tpow(self) -> None:
+        """Corrects tpow for old FZK-serial instruments missing the FZK100 fix.
+
+        Some MIRA-35 instruments with serial number 'fzk' had a firmware bug
+        where tpow was reported 100x too small. Files produced after the
+        firmware fix contain 'FZK100' in the 'hrd' global attribute. Files
+        without this field need tpow multiplied by 100.
+        """
+        hrd = getattr(self.dataset, "hrd", "")
+        if "FZK100" in hrd:
+            return
+        sn_lines = [line for line in hrd.split("\n") if line.strip().startswith("SN:")]
+        if not sn_lines:
+            return
+        sn = sn_lines[0].split(":", 1)[1].strip()
+        if sn != "fzk":
+            return
+        logging.info("Correcting tpow by factor 100 for old FZK instrument firmware")
+        self.data["tpow"].data[:] *= 100
+        self.data["tpow"].correction_factor = 100
+
     def screen_invalid_ldr(self) -> None:
         """Masks LDR in MIRA STSR mode data.
         Is there a better way to identify this mode?

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/instruments/nc_radar.py

@@ -53,8 +53,13 @@ class NcRadar(DataSource, CloudnetInstrument):
         range_instru = np.array(
             self.getvar("range", "height"),
         )  # "height" in old BASTA files
+        range_correction_factor = self.site_meta.get("range_correction_factor")
+        if range_correction_factor is not None:
+            range_instru = range_instru * range_correction_factor
         time = np.array(self.time)
         self.append_data(range_instru, "range")
+        if range_correction_factor is not None:
+            self.data["range"].correction_factor = range_correction_factor
         self.append_data(time, "time", dtype=time_dtype)
 
     def screen_by_snr(self, snr_limit: float) -> None:
@@ -120,23 +125,18 @@ class NcRadar(DataSource, CloudnetInstrument):
             raise ValidTimeStampError(msg)
 
         elevation_diff = ma.diff(elevation, prepend=elevation[1])
-        azimuth_diff = ma.diff(azimuth, prepend=azimuth[1])
-
-        # if azimuth_diff is large, it can be due to wrapping around 360 degrees
-        azimuth_diff[azimuth_diff > 180] -= 360
-        azimuth_diff[azimuth_diff < -180] += 360
-
         is_stable = np.abs(elevation - 90) < elevation_threshold
         is_stable &= np.abs(elevation_diff) < elevation_diff_threshold
-        is_stable &= np.abs(azimuth_diff) < azimuth_diff_threshold
 
-        # If scanning unit is broken, data are missing
-        # (assume it's vertically pointing)
-        missing_info = elevation.mask & azimuth.mask
-        is_stable[missing_info] = True
+        if not ma.getmaskarray(azimuth).all():
+            azimuth_diff = ma.diff(azimuth, prepend=azimuth[1])
+            azimuth_diff[azimuth_diff > 180] -= 360
+            azimuth_diff[azimuth_diff < -180] += 360
+            is_stable &= np.abs(azimuth_diff) < azimuth_diff_threshold
 
-        if ma.isMaskedArray(is_stable):
-            is_stable[is_stable.mask] = False
+        # Masked values indicate missing scanning info
+        # (assume vertically pointing)
+        is_stable = np.array(ma.filled(is_stable, fill_value=True))
         n_removed = np.count_nonzero(~is_stable)
 
         if n_removed >= len(elevation) - 1:

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/model_evaluation/plotting/plot_meta.py

@@ -61,8 +61,8 @@ ATTRIBUTES = {
     "temperature": PlotMeta(
         name="Model temperature",
         cbar="RdBu_r",
-        clabel="K",
-        plot_range=(223.15, 323.15),
+        clabel="\u00b0C",
+        plot_range=(-50, 50),
         plot_scale=_LIN,
         plot_type="model",
     ),

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/model_evaluation/plotting/plotting.py

@@ -348,6 +348,8 @@ def plot_colormesh(
     ax: Axes, data: npt.NDArray, axes: tuple, variable_info: PlotMeta
 ) -> None:
     vmin, vmax = variable_info.plot_range
+    if variable_info.clabel == "\u00b0C":
+        data = data - 273.15
     if variable_info.plot_scale == "logarithmic":
         data, vmin, vmax = lin2log(data, vmin, vmax)
     cmap = plt.get_cmap(variable_info.cbar, 22)

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/plotting/plot_meta.py

@@ -19,6 +19,7 @@ class PlotMeta(NamedTuple):
         moving_average: Whether to plot a moving average in a 1d plot.
         contour: Whether to plot contours on top of a filled colormap.
         zero_line: Whether to plot a zero line in a 1d plot.
+        contour_levels: Specific contour levels to draw on 2D plots.
         mask_zeros: Whether to mask zero values in the plot.
         time_smoothing_duration: The duration of the time smoothing window
             (in 2d plots) in minutes.
@@ -31,6 +32,7 @@ class PlotMeta(NamedTuple):
     moving_average: bool = True
     contour: bool = False
     zero_line: bool = False
+    contour_levels: tuple[float, ...] | None = None
     mask_zeros: bool = False
     time_smoothing_duration: int = 0
 
@@ -185,7 +187,7 @@ ATTRIBUTES = {
     "mwr": {
         "temperature": PlotMeta(
             cmap="coolwarm",
-            plot_range=(223.15, 323.15),
+            plot_range=(-50, 50),
             contour=True,
             time_smoothing_duration=_MWR_SINGLE_SMOOTHING,
         ),
@@ -204,7 +206,7 @@ ATTRIBUTES = {
     "mwr-single": {
         "temperature": PlotMeta(
             cmap="coolwarm",
-            plot_range=(223.15, 323.15),
+            plot_range=(-50, 50),
             contour=True,
             time_smoothing_duration=_MWR_SINGLE_SMOOTHING,
         ),
@@ -235,7 +237,7 @@ ATTRIBUTES = {
     "mwr-multi": {
         "temperature": PlotMeta(
             cmap="coolwarm",
-            plot_range=(223.15, 323.15),
+            plot_range=(-50, 50),
             contour=True,
             time_smoothing_duration=_MWR_MULTI_SMOOTHING,
         ),
@@ -406,7 +408,8 @@ ATTRIBUTES = {
         ),
         "temperature": PlotMeta(
             cmap="RdBu_r",
-            plot_range=(223.15, 323.15),
+            plot_range=(-50, 50),
+            contour_levels=(-38, -10, 0),
         ),
         "cloud_fraction": PlotMeta(
             cmap="Blues",
@@ -414,7 +417,8 @@ ATTRIBUTES = {
         ),
         "Tw": PlotMeta(
             cmap="RdBu_r",
-            plot_range=(223.15, 323.15),
+            plot_range=(-50, 50),
+            contour_levels=(-38, -10, 0),
         ),
         "specific_humidity": PlotMeta(
             plot_range=(1e-5, 1e-2),

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/plotting/plotting.py

@@ -16,6 +16,7 @@ from matplotlib.axes import Axes
 from matplotlib.colorbar import Colorbar
 from matplotlib.colorizer import ColorizingArtist
 from matplotlib.colors import ListedColormap
+from matplotlib.contour import QuadContourSet
 from matplotlib.pyplot import Figure
 from matplotlib.ticker import AutoMinorLocator
 from matplotlib.transforms import Affine2D, Bbox
@@ -402,6 +403,7 @@ class Plot:
 
     def _convert_units(self) -> str:
         multiply, add = "multiply", "add"
+        k_to_c = (add, -273.15, "\u00b0C")
         units_conversion = {
             "rainfall_rate": (multiply, 3600000, "mm h$^{-1}$"),
             "snowfall_rate": (multiply, 3600000, "mm h$^{-1}$"),
@@ -411,7 +413,16 @@ class Plot:
             "rainfall_amount": (multiply, 1000, "mm"),
             "snowfall_amount": (multiply, 1000, "mm"),
             "precipitation_amount": (multiply, 1000, "mm"),
-            "air_temperature": (add, -273.15, "\u00b0C"),
+            "air_temperature": k_to_c,
+            "temperature": k_to_c,
+            "Tw": k_to_c,
+            "T_sensor": k_to_c,
+            "T_ambient": k_to_c,
+            "T_interior": k_to_c,
+            "T_laser_driver": k_to_c,
+            "transmitter_temperature": k_to_c,
+            "receiver_temperature": k_to_c,
+            "pc_temperature": k_to_c,
             "r_accum_RT": (multiply, 1000, "mm"),
             "r_accum_NRT": (multiply, 1000, "mm"),
             "cloud_top_height_agl": (multiply, con.M_TO_KM, "Height (km AGL)"),
@@ -773,32 +784,37 @@ class Plot2D(Plot):
                 linewidths=0.5,
             )
 
-        if self.sub_plot.variable.name == "Tw":
-            self._plot_contour(
+        if self._plot_meta.contour_levels is not None:
+            cs = self._plot_contour(
                 figure_data,
                 alt,
-                levels=np.array([con.T0]),
+                levels=np.array(self._plot_meta.contour_levels),
                 colors="gray",
                 linewidths=1.25,
                 linestyles="dashed",
             )
+            if cs is not None:
+                self._ax.clabel(cs, fmt="%g \u00b0C", fontsize=8)
 
     def _plot_contour(
         self,
         figure_data: FigureData,
         alt: npt.NDArray,
         **options,  # noqa: ANN003
-    ) -> None:
+    ) -> QuadContourSet | None:
         time_length = len(figure_data.time_including_gaps)
         step = max(1, time_length // 200)
         ind_time = np.arange(0, time_length, step)
-        self._ax.contour(
-            figure_data.time_including_gaps[ind_time],
-            alt,
-            self._data[ind_time, :].T,
-            **options,
-            zorder=_get_zorder("contour"),
-        )
+        try:
+            return self._ax.contour(
+                figure_data.time_including_gaps[ind_time],
+                alt,
+                self._data[ind_time, :].T,
+                **options,
+                zorder=_get_zorder("contour"),
+            )
+        except ValueError:
+            return None
 
     def _screen_data_by_max_y(self, figure_data: FigureData) -> ndarray:
         if figure_data.height is None:

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/products/classification.py

@@ -317,7 +317,11 @@ def _find_cloud_mask(classification: npt.NDArray) -> npt.NDArray:
         Target.ICE_AND_SUPERCOOLED,
     ]:
         cloud_mask[classification == value] = 1
-    return cloud_mask
+    return utils.remove_small_objects(
+        cloud_mask.astype(bool),
+        max_size=20,
+        connectivity=1,
+    ).astype(int)
 
 
 COMMENTS = {

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/utils.py

@@ -354,6 +354,8 @@ def interpolate_2d_mask(
     z: ma.MaskedArray,
     x_new: npt.NDArray,
     y_new: npt.NDArray,
+    *,
+    extrapolate: bool = False,
 ) -> ma.MaskedArray:
     """2D linear interpolation preserving the mask.
 
@@ -363,13 +365,14 @@ def interpolate_2d_mask(
         z: 2D masked array, data values.
         x_new: 1D array, new x-coordinates.
         y_new: 1D array, new y-coordinates.
+        extrapolate: If True, linearly extrapolate along the y-axis for points
+            outside the original range. Default is False (NaN / masked).
 
     Returns:
         Interpolated 2D masked array.
 
     Notes:
-        Points outside the original range will be nans (and masked). Uses linear
-        interpolation. Input data may contain nan-values.
+        Uses linear interpolation. Input data may contain nan-values.
 
     """
     z = ma.array(ma.masked_invalid(z, copy=True))
@@ -386,6 +389,15 @@ def interpolate_2d_mask(
         (xx_new, yy_new),
         method="linear",
     )
+    if extrapolate:
+        y_new_arr = np.asarray(y_new)
+        for i in range(data.shape[0]):
+            row = data[i, :]
+            nans = np.isnan(row)
+            if nans.any() and np.sum(~nans) >= 2:
+                valid = ~nans
+                f = interp1d(y_new_arr[valid], row[valid], fill_value="extrapolate")
+                data[i, nans] = f(y_new_arr[nans])
     # Preserve mask:
     mask_fun = RectBivariateSpline(x, y, ma.getmaskarray(z), kx=1, ky=1)
     mask = mask_fun(x_new, y_new)

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0}/cloudnetpy/version.py

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

{cloudnetpy-1.88.2 → cloudnetpy-1.89.0/cloudnetpy.egg-info}/PKG-INFO

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