cloudnetpy 1.60.2__tar.gz → 1.60.4__tar.gz

{cloudnetpy-1.60.2/cloudnetpy.egg-info → cloudnetpy-1.60.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudnetpy
-Version: 1.60.2
+Version: 1.60.4
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.60.2 → cloudnetpy-1.60.4}/cloudnetpy/model_evaluation/model_metadata.py

@@ -28,7 +28,7 @@ MODELS = {
         level=88,
         cycle="1-12, 7-18",
     ),
-    "harmonie": ModelMetaData(
+    "harmonie-fmi-6-11": ModelMetaData(
         model_name="HARMONIE-AROME",
         long_name="the HIRLAM–ALADIN Research on Mesoscale Operational NWP in Euromed",  # noqa: RUF001
         level=65,

{cloudnetpy-1.60.2 → cloudnetpy-1.60.4}/cloudnetpy/model_evaluation/plotting/plotting.py

@@ -17,7 +17,7 @@ import cloudnetpy.model_evaluation.plotting.plot_tools as p_tools
 from cloudnetpy.model_evaluation.model_metadata import MODELS
 from cloudnetpy.model_evaluation.plotting.plot_meta import ATTRIBUTES
 from cloudnetpy.model_evaluation.statistics.statistical_methods import DayStatistics
-from cloudnetpy.plotting.plotting import get_log_cbar_tick_labels, lin2log
+from cloudnetpy.plotting.plotting import Dimensions, get_log_cbar_tick_labels, lin2log
 
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
@@ -34,7 +34,7 @@ def generate_L3_day_plots(
     save_path: str | None = None,
     image_name: str | None = None,
     show: bool | None = False,
-) -> None:
+) -> list[Dimensions]:
     """Generate visualizations for level 3 dayscale products.
     With figure type visualizations can be subplot in group, pair, single or
     statistic of given product. In group fig_type all different methods are plot
@@ -93,7 +93,11 @@ def generate_L3_day_plots(
     model_info = MODELS[model]
     model_name = model_info.model_name
     name_set = p_tools.parse_wanted_names(nc_file, product, model, var_list)
-    for names in name_set:
+    unique_tuples = {tuple(lst) for lst in name_set}
+    name_set_unique = tuple(list(tup) for tup in unique_tuples)
+
+    dimensions = []
+    for names in name_set_unique:
         if len(names) > 0:
             try:
                 cycle_names, cycles = p_tools.sort_cycles(names, model)
@@ -120,7 +124,11 @@ def generate_L3_day_plots(
                             save_path,
                             image_name,
                         ]
-                    getattr(cls, f"get_{fig_type}_plots")(*params, **kwargs)
+                    figs, axes = getattr(cls, f"get_{fig_type}_plots")(
+                        *params, **kwargs
+                    )
+                    for fig, ax in zip(figs, axes, strict=False):
+                        dimensions.append(Dimensions(fig, ax))
             except AttributeError:
                 params = [
                     product,
@@ -143,7 +151,10 @@ def generate_L3_day_plots(
                         save_path,
                         image_name,
                     ]
-                getattr(cls, f"get_{fig_type}_plots")(*params, **kwargs)
+                figs, axes = getattr(cls, f"get_{fig_type}_plots")(*params, **kwargs)
+                for fig, ax in zip(figs, axes, strict=False):
+                    dimensions.append(Dimensions(fig, ax))
+    return dimensions
 
 
 def get_group_plots(
@@ -159,7 +170,7 @@ def get_group_plots(
     cycle: str = "",
     title: bool = True,
     include_xlimits: bool = False,
-) -> None:
+) -> tuple:
     """Group subplot visualization for both standard and advection downsampling.
     Generates group subplot figure for product with model and all different
     downsampling methods. Generates separated figures for standard and advection
@@ -204,6 +215,7 @@ def get_group_plots(
         [product, model_run, "group"],
         show=show,
     )
+    return fig, ax
 
 
 def get_pair_plots(
@@ -280,7 +292,7 @@ def get_single_plots(
     cycle: str = "",
     title: bool = True,
     include_xlimits: bool = False,
-) -> None:
+) -> tuple[list, list]:
     """Generates figures of each product variable from given file in loop.
 
     Args:
@@ -295,9 +307,13 @@ def get_single_plots(
         cycle (str): Name of cycle if exists
         title (bool): True or False if wanted to add title to subfig
     """
+    figs = []
+    axes = []
     variable_info = ATTRIBUTES[product]
-    for _, name in enumerate(names):
+    for name in names:
         fig, ax = initialize_figure(1)
+        figs.append(fig)
+        axes.append(ax)
         set_yax(ax[0], 12, ylabel=None)
         set_xax(ax[0], include_xlimits=include_xlimits)
 
@@ -318,6 +334,7 @@ def get_single_plots(
             [name, "single"],
             show=show,
         )
+    return figs, axes
 
 
 def plot_colormesh(ax, data: np.ndarray, axes: tuple, variable_info) -> None:
@@ -349,7 +366,7 @@ def get_statistic_plots(
     show: bool,
     cycle: str = "",
     title: bool = True,
-) -> None:
+) -> tuple:
     """Statistical subplots for day scale products.
     Statistical analysis can be done by day scale with relative error ('error'),
     total data area analysis ('area'), histogram ('hist') or vertical profiles
@@ -387,12 +404,16 @@ def get_statistic_plots(
         err_msg = f"No data in {model_name} or observation"
         raise ValueError(err_msg)
 
+    figs = []
+    axes = []
     for stat in stats:
         try:
             obs_missing = False
             model_missing = False
             variable_info = ATTRIBUTES[product]
             fig, ax = initialize_figure(len(names) - 1, stat)
+            figs.append(fig)
+            axes.append(ax)
             model_data, _, _ = p_tools.read_data_characters(nc_file, names[0], model)
             if np.all(model_data.mask is True):
                 model_missing = True
@@ -443,6 +464,7 @@ def get_statistic_plots(
             [name, stat, model_run],
             show=show,
         )
+    return figs, axes
 
 
 def initialize_statistic_plots(

{cloudnetpy-1.60.2 → cloudnetpy-1.60.4}/cloudnetpy/model_evaluation/products/advance_methods.py

@@ -2,8 +2,9 @@ import importlib
 import logging
 
 import numpy as np
+import scipy.special
+import scipy.stats
 from numpy import ma
-from scipy.special import gamma
 
 import cloudnetpy.utils as cl_tools
 from cloudnetpy.datasource import DataSource
@@ -44,7 +45,7 @@ class AdvanceProductMethods(DataSource):
             name = f"get_advance_{self.product}"
             getattr(cls, name)(self)
         except AttributeError as error:
-            logging.warning("No advance method for %s: %s", self.product, error)
+            logging.debug("No advance method for %s: %s", self.product, error)
 
     def get_advance_cf(self) -> None:
         self.cf_cirrus_filter()
@@ -60,24 +61,36 @@ class AdvanceProductMethods(DataSource):
         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)
-        # Looks suspicious, check me:
+
         for i, ind in enumerate(zip(ice_ind[0], ice_ind[-1], strict=True)):
-            iwc_dist = self.calculate_iwc_distribution(cloud_iwc[i], variance_iwc[i])
+            try:
+                iwc_dist = self.calculate_iwc_distribution(
+                    cloud_iwc[i], variance_iwc[i]
+                )
+            except ValueError:
+                continue
+
             p_iwc = self.gamma_distribution(iwc_dist, variance_iwc[i], cloud_iwc[i])
+
+            if np.isinf(p_iwc).any():
+                cf_filtered[ind] = ma.masked
+                continue
+
             if np.sum(p_iwc) == 0 or p_iwc[-1] > 0.01 * np.sum(p_iwc):
-                cf_filtered[ind] = np.nan
+                cf_filtered[ind] = ma.masked
                 continue
-            obs_index = self.get_observation_index(
-                iwc_dist,
-                tZT,
-                tT,
-                tZ,
-                t,
-                float(t_screened[ind]),
-                float(z_sen[ind]),
+
+            min_iwc = 10 ** (
+                tZT * z_sen[ind] * t_screened[ind]
+                + tT * t_screened[ind]
+                + tZ * z_sen[ind]
+                + t
             )
+            obs_index = iwc_dist > min_iwc
             cf_filtered[ind] = self.filter_cirrus(p_iwc, obs_index, cf_filtered[ind])
+
         cf_filtered[cf_filtered < 0.05] = ma.masked
+
         self._model_obj.append_data(
             cf_filtered,
             f"{self._model_obj.model}{self._model_obj.cycle}_cf_cirrus",
@@ -132,7 +145,7 @@ class AdvanceProductMethods(DataSource):
         iwc: np.ndarray,
         lwc: np.ndarray,
     ) -> np.ndarray:
-        cf_filtered = np.copy(cf)
+        cf_filtered = ma.copy(cf)
         weird_ind = (iwc / cf > 0.5e-3) & (cf < 0.001)
         weird_ind = weird_ind | (iwc == 0) & (lwc == 0) & (cf == 0)
         cf_filtered[weird_ind] = ma.masked
@@ -199,7 +212,9 @@ class AdvanceProductMethods(DataSource):
         n_std: int = 5,
         n_dist: int = 250,
     ) -> np.ndarray:
-        finish = cloud_iwc + n_std * (np.sqrt(f_variance_iwc) * cloud_iwc)
+        finish = cloud_iwc + n_std * (ma.sqrt(f_variance_iwc) * cloud_iwc)
+        if isinstance(finish, ma.MaskedArray) and finish.mask.all():
+            raise ValueError
         iwc_dist = np.arange(0, finish, finish / (n_dist - 1))
         if cloud_iwc < iwc_dist[2]:
             finish = cloud_iwc * 10
@@ -208,40 +223,11 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def gamma_distribution(
-        iwc_dist: np.ndarray,
-        f_variance_iwc: float,
-        cloud_iwc: float,
-    ) -> np.ndarray:
-        def calculate_gamma_dist() -> float:
-            alpha = 1 / f_variance_iwc
-            return (
-                1
-                / gamma(alpha)
-                * (alpha / cloud_iwc) ** alpha
-                * iwc_dist[i] ** (alpha - 1)
-                * ma.exp(-(alpha * iwc_dist[i] / cloud_iwc))
-            )
-
-        p_iwc = np.zeros(iwc_dist.shape)
-        for i in range(len(iwc_dist)):
-            p_iwc[i] = calculate_gamma_dist()
-        return p_iwc
-
-    @staticmethod
-    def get_observation_index(
-        iwc_dist: np.ndarray,
-        tZT: float,
-        tT: float,
-        tZ: float,
-        t: np.ndarray,
-        temperature: float,
-        z_sen: float,
+        iwc_dist: np.ndarray, f_variance_iwc: float, cloud_iwc: float
     ) -> np.ndarray:
-        def calculate_min_iwc() -> np.ndarray:
-            return 10 ** (tZT * z_sen * temperature + tT * temperature + tZ * z_sen + t)
-
-        iwc_min = calculate_min_iwc()
-        return iwc_dist > iwc_min
+        alpha = 1 / f_variance_iwc
+        theta = cloud_iwc / alpha
+        return scipy.stats.gamma.pdf(iwc_dist, a=alpha, scale=theta)
 
     @staticmethod
     def filter_cirrus(
@@ -249,4 +235,4 @@ class AdvanceProductMethods(DataSource):
         obs_index: np.ndarray,
         cf_filtered: np.ndarray,
     ) -> np.ndarray:
-        return (np.sum(p_iwc * obs_index) / np.sum(p_iwc)) * cf_filtered
+        return (ma.sum(p_iwc * obs_index) / ma.sum(p_iwc)) * cf_filtered

{cloudnetpy-1.60.2 → cloudnetpy-1.60.4}/cloudnetpy/model_evaluation/products/grid_methods.py

@@ -119,56 +119,35 @@ class ProductGrid:
 
     def _cf_method_storage(self) -> tuple[dict, dict]:
         cf_dict = {
-            "cf_V": np.zeros(self._model_height.shape),
-            "cf_A": np.zeros(self._model_height.shape),
+            "cf_V": ma.zeros(self._model_height.shape),
+            "cf_A": ma.zeros(self._model_height.shape),
         }
         cf_adv_dict = {
-            "cf_V_adv": np.zeros(self._model_height.shape),
-            "cf_A_adv": np.zeros(self._model_height.shape),
+            "cf_V_adv": ma.zeros(self._model_height.shape),
+            "cf_A_adv": ma.zeros(self._model_height.shape),
         }
         return cf_dict, cf_adv_dict
 
     def _iwc_method_storage(self) -> tuple[dict, dict]:
         iwc_dict = {
-            "iwc": np.zeros(self._model_height.shape),
-            "iwc_att": np.zeros(self._model_height.shape),
-            "iwc_rain": np.zeros(self._model_height.shape),
+            "iwc": ma.zeros(self._model_height.shape),
+            "iwc_att": ma.zeros(self._model_height.shape),
+            "iwc_rain": ma.zeros(self._model_height.shape),
         }
         iwc_adv_dict = {
-            "iwc_adv": np.zeros(self._model_height.shape),
-            "iwc_att_adv": np.zeros(self._model_height.shape),
-            "iwc_rain_adv": np.zeros(self._model_height.shape),
+            "iwc_adv": ma.zeros(self._model_height.shape),
+            "iwc_att_adv": ma.zeros(self._model_height.shape),
+            "iwc_rain_adv": ma.zeros(self._model_height.shape),
         }
         return iwc_dict, iwc_adv_dict
 
     def _product_method_storage(self) -> tuple[dict, dict]:
-        product_dict = {f"{self._obs_obj.obs}": np.zeros(self._model_height.shape)}
+        product_dict = {f"{self._obs_obj.obs}": ma.zeros(self._model_height.shape)}
         product_adv_dict = {
-            f"{self._obs_obj.obs}_adv": np.zeros(self._model_height.shape),
+            f"{self._obs_obj.obs}_adv": ma.zeros(self._model_height.shape),
         }
         return product_dict, product_adv_dict
 
-    @staticmethod
-    def _regrid_cf(storage: dict, i: int, j: int, data: np.ndarray | None) -> dict:
-        """Calculates average cloud fraction value to grid point"""
-        for key, downsample in storage.items():
-            if data is not None:
-                if isinstance(data, ma.MaskedArray) and data.mask.all():
-                    downsample[i, j] = np.nan
-                elif not np.isnan(data).all():
-                    downsample[i, j] = np.nanmean(data)
-                else:
-                    downsample[i, j] = np.nan
-                if "_A" in key and (
-                    not np.isnan(data).all()
-                    and not (isinstance(data, ma.MaskedArray) and data.mask.all())
-                ):
-                    downsample[i, j] = tl.average_column_sum(data)
-            else:
-                downsample[i, j] = np.nan
-            storage[key] = downsample
-        return storage
-
     def _reshape_data_to_window(
         self,
         ind: np.ndarray,
@@ -181,6 +160,17 @@ class ProductGrid:
             return self._obs_data[ind].reshape(window_size)
         return None
 
+    @staticmethod
+    def _regrid_cf(storage: dict, i: int, j: int, data: np.ndarray) -> dict:
+        """Calculates average cloud fraction value to grid point."""
+        data_ma = ma.array(data) if not isinstance(data, ma.MaskedArray) else data
+        for key, downsample in storage.items():
+            downsample[i, j] = ma.mean(data_ma)
+            if "_A" in key and not data_ma.mask.all():
+                downsample[i, j] = tl.average_column_sum(data_ma)
+            storage[key] = downsample
+        return storage
+
     def _regrid_iwc(
         self,
         storage: dict,
@@ -189,40 +179,33 @@ class ProductGrid:
         ind_rain: np.ndarray,
         ind_no_rain: np.ndarray,
     ) -> dict:
-        """Calculates average iwc value for grid point"""
-        for key, downsample in storage.items():
-            if not self._obs_data[ind_no_rain].mask.all():
-                if np.isnan(self._obs_data[ind_no_rain]).all():
-                    downsample[i, j] = np.nan
-                else:
-                    no_rain_data = self._obs_data[ind_no_rain]
-                    if no_rain_data.size > 0:
-                        downsample[i, j] = np.nanmean(self._obs_data[ind_no_rain])
-                    else:
-                        downsample[i, j] = np.nan
-            elif "rain" in key and not self._obs_data[ind_rain].mask.all():
-                downsample[i, j] = np.nanmean(self._obs_data[ind_rain])
-            else:
-                downsample[i, j] = np.nan
+        """Calculates average iwc value for each grid point."""
+        for key, down_sample in storage.items():
+            down_sample[i, j] = ma.masked
+            if "rain" not in key:
+                no_rain_data = self._obs_data[ind_no_rain]
+                if ind_no_rain.any() and not no_rain_data.mask.all():
+                    down_sample[i, j] = ma.mean(no_rain_data)
+            if "rain" in key:
+                rain_data = self._obs_data[ind_rain]
+                if ind_rain.any() and not rain_data.mask.all():
+                    down_sample[i, j] = ma.mean(rain_data)
             if "att" in key:
-                iwc_att = self._obs_obj.data["iwc_att"][:]
-                if iwc_att[ind_no_rain].mask.all():
-                    downsample[i, j] = np.nan
-                else:
-                    downsample[i, j] = np.nanmean(iwc_att[ind_no_rain])
-            storage[key] = downsample
+                no_rain_att_data = self._obs_obj.data["iwc_att"][ind_no_rain]
+                if ind_no_rain.any() and not no_rain_att_data.mask.all():
+                    down_sample[i, j] = ma.mean(no_rain_att_data)
+            storage[key] = down_sample
         return storage
 
     def _regrid_product(self, storage: dict, i: int, j: int, ind: np.ndarray) -> dict:
-        """Calculates average of standard product value to grid point"""
+        """Calculates average of standard product value for each grid point."""
         for key, down_sample in storage.items():
-            if not self._obs_data[ind].mask.all() and ind.any():
-                if np.isnan(self._obs_data[ind]).all():
-                    down_sample[i, j] = np.nan
-                else:
-                    down_sample[i, j] = np.nanmean(self._obs_data[ind])
-            else:
-                down_sample[i, j] = np.nan
+            obs_data_selected = ma.masked_invalid(self._obs_data[ind])
+            down_sample[i, j] = (
+                ma.mean(obs_data_selected)
+                if not obs_data_selected.mask.all()
+                else ma.masked
+            )
             storage[key] = down_sample
         return storage
 

{cloudnetpy-1.60.2 → cloudnetpy-1.60.4}/cloudnetpy/model_evaluation/tests/unit/conftest.py

@@ -3,6 +3,7 @@ from datetime import date
 import netCDF4
 import numpy as np
 import pytest
+from numpy import ma
 
 
 @pytest.fixture(scope="session")
@@ -28,7 +29,7 @@ def model_file(tmpdir_factory, file_metadata) -> str:
     root_grp.createDimension("level", level)
     _create_global_attributes(root_grp, file_metadata)
     var = root_grp.createVariable("time", "f8", "time")
-    var[:] = np.array([2, 6, 10])
+    var[:] = ma.array([2, 6, 10])
     var = root_grp.createVariable("level", "f8", "level")
     var[:] = level
     var = root_grp.createVariable("latitude", "f8")
@@ -38,24 +39,24 @@ def model_file(tmpdir_factory, file_metadata) -> str:
     var = root_grp.createVariable("horizontal_resolution", "f8")
     var[:] = 9
     var = root_grp.createVariable("height", "f8", ("time", "level"))
-    var[:] = np.array([[10, 14], [8, 14], [9, 15]])
+    var[:] = ma.array([[10, 14], [8, 14], [9, 15]])
     var.units = "km"
     var = root_grp.createVariable("forecast_time", "f8", "time")
-    var[:] = np.array([1, 5, 10])
+    var[:] = ma.array([1, 5, 10])
     var = root_grp.createVariable("cloud_fraction", "f8", ("time", "level"))
-    var[:] = np.array([[0, 2], [3, 6], [5, 8]])
+    var[:] = ma.array([[0, 2], [3, 6], [5, 8]])
     var = root_grp.createVariable("qi", "f8", ("time", "level"))
-    var[:] = np.array([[0.01, 0.00], [0.02, 0.03], [0.06, 0.08]])
+    var[:] = ma.array([[0.01, 0.00], [0.02, 0.03], [0.06, 0.08]])
     var = root_grp.createVariable("ql", "f8", ("time", "level"))
-    var[:] = np.array([[0.008, 0.09], [0.004, 0.007], [0.0001, 0.0002]])
+    var[:] = ma.array([[0.008, 0.09], [0.004, 0.007], [0.0001, 0.0002]])
     var = root_grp.createVariable("temperature", "f8", ("time", "level"))
-    var[:] = np.array([[300, 301], [302, 299], [305, 298]])
+    var[:] = ma.array([[300, 301], [302, 299], [305, 298]])
     var = root_grp.createVariable("pressure", "f8", ("time", "level"))
-    var[:] = np.array([[1000, 1001], [1010, 1003], [1020, 1005]])
+    var[:] = ma.array([[1000, 1001], [1010, 1003], [1020, 1005]])
     var = root_grp.createVariable("uwind", "f8", ("time", "level"))
-    var[:] = np.array([[1, 2], [2, 2], [3, 1]])
+    var[:] = ma.array([[1, 2], [2, 2], [3, 1]])
     var = root_grp.createVariable("vwind", "f8", ("time", "level"))
-    var[:] = np.array([[3, 1], [2, 1], [5, 2]])
+    var[:] = ma.array([[3, 1], [2, 1], [5, 2]])
     root_grp.close()
     return file_name
 
@@ -70,9 +71,9 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
     root_grp.createDimension("height", height)
     _create_global_attributes(root_grp, file_metadata)
     var = root_grp.createVariable("time", "f8", "time")
-    var[:] = np.array([0, 2, 4, 6, 8, 10])
+    var[:] = ma.array([0, 2, 4, 6, 8, 10])
     var = root_grp.createVariable("height", "f8", "height")
-    var[:] = np.array([8, 9, 12, 15])
+    var[:] = ma.array([8, 9, 12, 15])
     var.units = "km"
     var = root_grp.createVariable("latitude", "f8")
     var[:] = 1
@@ -84,11 +85,11 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
     var = root_grp.createVariable("radar_frequency", "f8")
     var[:] = 35.5
     var = root_grp.createVariable("rainrate", "i4", "time")
-    var[:] = np.array([1, 2, 0, 10, 5, 13])
+    var[:] = ma.array([1, 2, 0, 10, 5, 13])
     var = root_grp.createVariable("Z_sensitivity", "f8", "height")
-    var[:] = np.array([0.1, 0.2, 0.0, 1.0])
+    var[:] = ma.array([0.1, 0.2, 0.0, 1.0])
     var = root_grp.createVariable("category_bits", "i4", ("time", "height"))
-    var[:] = np.array(
+    var[:] = ma.array(
         [
             [0, 1, 2, 0],
             [2, 8, 4, 1],
@@ -99,7 +100,7 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
         ],
     )
     var = root_grp.createVariable("quality_bits", "i4", ("time", "height"))
-    var[:] = np.array(
+    var[:] = ma.array(
         [
             [0, 1, 2, 4],
             [8, 16, 32, 16],
@@ -110,7 +111,7 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
         ],
     )
     var = root_grp.createVariable("iwc", "f8", ("time", "height"))
-    var[:] = np.array(
+    var[:] = ma.array(
         [
             [0.01, 0.02, 0.06, 0.01],
             [0.02, 0.06, 0.00, 0.03],
@@ -121,7 +122,7 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
         ],
     )
     var = root_grp.createVariable("iwc_retrieval_status", "f8", ("time", "height"))
-    var[:] = np.array(
+    var[:] = ma.array(
         [
             [1, 2, 6, 1],
             [2, 6, 5, 3],
@@ -132,7 +133,7 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
         ],
     )
     var = root_grp.createVariable("lwc", "f8", ("time", "height"))
-    var[:] = np.array(
+    var[:] = ma.array(
         [
             [0.08, 0.04, 0.01, 0.08],
             [0.04, 0.01, 0.09, 0.07],
@@ -143,7 +144,7 @@ def obs_file(tmpdir_factory, file_metadata) -> str:
         ],
     )
     var = root_grp.createVariable("data", "i4", ("time", "height"))
-    var[:] = np.array(
+    var[:] = ma.array(
         [
             [2, 4, 3, 6],
             [7, 1, 9, 7],
@@ -167,7 +168,7 @@ def regrid_file(tmpdir_factory, file_metadata) -> str:
     root_grp.createDimension("level", level)
     _create_global_attributes(root_grp, file_metadata)
     var = root_grp.createVariable("time", "f8", "time")
-    var[:] = np.array([2, 6, 10])
+    var[:] = ma.array([2, 6, 10])
     var = root_grp.createVariable("level", "f8", "level")
     var[:] = level
     var = root_grp.createVariable("latitude", "f8")
@@ -177,23 +178,23 @@ def regrid_file(tmpdir_factory, file_metadata) -> str:
     var = root_grp.createVariable("horizontal_resolution", "f8")
     var[:] = 9
     var = root_grp.createVariable("ecmwf_height", "f8", ("time", "level"))
-    var[:] = np.array([[10, 14], [8, 14], [9, 15]])
+    var[:] = ma.array([[10, 14], [8, 14], [9, 15]])
     var = root_grp.createVariable("ecmwf_forecast_time", "f8", "time")
-    var[:] = np.array([1, 5, 10])
+    var[:] = ma.array([1, 5, 10])
     var = root_grp.createVariable("ecmwf_cf", "f8", ("time", "level"))
-    var[:] = np.array([[0, 2], [3, 6], [5, 8]])
+    var[:] = ma.array([[0, 2], [3, 6], [5, 8]])
     var = root_grp.createVariable("ecmwf_cf_cirrus", "f8", ("time", "level"))
-    var[:] = np.array([[0, 2], [3, 6], [5, 7]])
+    var[:] = ma.array([[0, 2], [3, 6], [5, 7]])
     var = root_grp.createVariable("ecmwf_cf_snow", "f8", ("time", "level"))
-    var[:] = np.array([[0, 2], [4, 6], [5, 8]])
+    var[:] = ma.array([[0, 2], [4, 6], [5, 8]])
     var = root_grp.createVariable("cf_ecmwf", "f8", ("time", "level"))
-    var[:] = np.array([[0, 2], [3, 6], [5, 8]])
+    var[:] = ma.array([[0, 2], [3, 6], [5, 8]])
     var = root_grp.createVariable("cf_adv_ecmwf", "f8", ("time", "level"))
-    var[:] = np.array([[0, 2], [3, 6], [5, 8]])
+    var[:] = ma.array([[0, 2], [3, 6], [5, 8]])
     var = root_grp.createVariable("temperature", "f8", ("time", "level"))
-    var[:] = np.array([[300, 301], [302, 299], [305, 298]])
+    var[:] = ma.array([[300, 301], [302, 299], [305, 298]])
     var = root_grp.createVariable("pressure", "f8", ("time", "level"))
-    var[:] = np.array([[1000, 1001], [1010, 1003], [1020, 1005]])
+    var[:] = ma.array([[1000, 1001], [1010, 1003], [1020, 1005]])
     root_grp.close()
     return file_name
 

{cloudnetpy-1.60.2 → cloudnetpy-1.60.4}/cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py

@@ -248,31 +248,6 @@ def test_gamma_distribution(obs_file, model_file) -> None:
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_get_observation_index(obs_file, model_file) -> None:
-    obs = ObservationManager(PRODUCT, str(obs_file))
-    model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
-    adv_pro = AdvanceProductMethods(model, str(model_file), obs)
-    tZT = 0.01
-    z_sen = 0.02
-    temperature = -13
-    tT = 0.04
-    tZ = 0.05
-    t = 0.06
-    min_iwc = 10 ** (tZT * z_sen * temperature + tT * temperature + tZ * z_sen + t)
-    iwc_dist = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])
-    compare = iwc_dist > min_iwc
-    x = adv_pro.get_observation_index(
-        iwc_dist,
-        tZT,
-        tT,
-        tZ,
-        np.array([t]),
-        temperature,
-        z_sen,
-    )
-    testing.assert_array_almost_equal(x, compare)
-
-
 def test_filter_cirrus(obs_file, model_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)