cloudnetpy 1.55.20__py3-none-any.whl → 1.55.22__py3-none-any.whl

cloudnetpy/model_evaluation/products/advance_methods.py

@@ -17,6 +17,7 @@ class AdvanceProductMethods(DataSource):
     assumptions of model or observation data.
 
     Args:
+    ----
         model_obj (object): The :class:'ModelManager' object.
         obs_obj (object): The :class:'ObservationManager' object.
     """
@@ -38,30 +39,30 @@ class AdvanceProductMethods(DataSource):
         self._model_height = model_obj.data[model_obj.keys["height"]][:]
         self.generate_products()
 
-    def generate_products(self):
-        cls = getattr(importlib.import_module(__name__), "AdvanceProductMethods")
+    def generate_products(self) -> None:
+        cls = importlib.import_module(__name__).AdvanceProductMethods
         try:
             name = f"get_advance_{self.product}"
             getattr(cls, name)(self)
         except AttributeError as error:
-            logging.warning(f"No advance method for {self.product}: {error}")
+            logging.warning("No advance method for %s: %s", self.product, error)
 
-    def get_advance_cf(self):
+    def get_advance_cf(self) -> None:
         self.cf_cirrus_filter()
 
-    def cf_cirrus_filter(self):
+    def cf_cirrus_filter(self) -> None:
         cf = self.getvar_from_object("cf")
         h = self.getvar_from_object("h")
         temperature = self.getvar("temperature")
         t_screened = self.remove_extra_levels(temperature - 273.15)
-        iwc, lwc = [self._model_obj.get_water_content(var) for var in ["iwc", "lwc"]]
+        iwc, lwc = (self._model_obj.get_water_content(var) for var in ["iwc", "lwc"])
         tZT, tT, tZ, t = self.set_frequency_parameters()
         z_sen = self.fit_z_sensitivity(h)
         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])):
+        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])
             p_iwc = self.gamma_distribution(iwc_dist, variance_iwc[i], cloud_iwc[i])
             if np.sum(p_iwc) == 0 or p_iwc[-1] > 0.01 * np.sum(p_iwc):
@@ -92,7 +93,9 @@ class AdvanceProductMethods(DataSource):
         return self._model_obj.cut_off_extra_levels(arg)
 
     def set_frequency_parameters(self) -> tuple:
-        assert self._obs_obj.radar_freq is not None
+        if self._obs_obj.radar_freq is None:
+            msg = "No radar frequency in observation file"
+            raise ValueError(msg)
         if 30 <= self._obs_obj.radar_freq <= 40:
             return 0.000242, -0.0186, 0.0699, -1.63
         if 90 <= float(self._obs_obj.radar_freq) <= 100:
@@ -100,8 +103,12 @@ class AdvanceProductMethods(DataSource):
         raise ValueError
 
     def fit_z_sensitivity(self, h: np.ndarray) -> np.ndarray:
-        assert self._obs_obj.z_sensitivity is not None
-        assert self._obs_obj.height is not None
+        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)
         z_sen = [
             cl_tools.rebin_1d(self._obs_obj.height, self._obs_obj.z_sensitivity, h[i])
             for i in range(len(h))
@@ -109,16 +116,22 @@ class AdvanceProductMethods(DataSource):
         return np.asarray(z_sen)
 
     def filter_high_iwc_low_cf(
-        self, cf: np.ndarray, iwc: np.ndarray, lwc: np.ndarray
+        self,
+        cf: np.ndarray,
+        iwc: np.ndarray,
+        lwc: np.ndarray,
     ) -> np.ndarray:
         cf_filtered = self.mask_weird_indices(cf, iwc, lwc)
         if np.sum((iwc > 0) & (lwc < iwc / 10) & (cf_filtered > 0)) == 0:
-            raise ValueError("No ice clouds in a input data")
+            msg = "No ice clouds in a input data"
+            raise ValueError(msg)
         return cf_filtered
 
     @staticmethod
     def mask_weird_indices(
-        cf: np.ndarray, iwc: np.ndarray, lwc: np.ndarray
+        cf: np.ndarray,
+        iwc: np.ndarray,
+        lwc: np.ndarray,
     ) -> np.ndarray:
         cf_filtered = np.copy(cf)
         weird_ind = (iwc / cf > 0.5e-3) & (cf < 0.001)
@@ -127,7 +140,10 @@ class AdvanceProductMethods(DataSource):
         return cf_filtered
 
     def find_ice_in_clouds(
-        self, cf_filtered: np.ndarray, iwc: np.ndarray, lwc: np.ndarray
+        self,
+        cf_filtered: np.ndarray,
+        iwc: np.ndarray,
+        lwc: np.ndarray,
     ) -> tuple[np.ndarray, tuple]:
         ice_ind = self.get_ice_indices(cf_filtered, iwc, lwc)
         cloud_iwc = iwc[ice_ind] / cf_filtered[ice_ind] * 1e3
@@ -135,7 +151,9 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def get_ice_indices(
-        cf_filtered: np.ndarray, iwc: np.ndarray, lwc: np.ndarray
+        cf_filtered: np.ndarray,
+        iwc: np.ndarray,
+        lwc: np.ndarray,
     ) -> tuple:
         return tuple(np.where((cf_filtered > 0) & (iwc > 0) & (lwc < iwc / 10)))
 
@@ -145,8 +163,7 @@ class AdvanceProductMethods(DataSource):
         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)
-        variance_iwc = self.calculate_variance_iwc(w_shear, ice_ind)
-        return variance_iwc
+        return self.calculate_variance_iwc(w_shear, ice_ind)
 
     def calculate_variance_iwc(self, w_shear: np.ndarray, ice_ind: tuple) -> np.ndarray:
         return 10 ** (
@@ -157,7 +174,10 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def calculate_wind_shear(
-        wind, u: np.ndarray, v: np.ndarray, height: np.ndarray
+        wind,
+        u: np.ndarray,
+        v: np.ndarray,
+        height: np.ndarray,
     ) -> np.ndarray:
         grand_winds = []
         for w in (wind, u, v):
@@ -189,9 +209,11 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def gamma_distribution(
-        iwc_dist: np.ndarray, f_variance_iwc: float, cloud_iwc: float
+        iwc_dist: np.ndarray,
+        f_variance_iwc: float,
+        cloud_iwc: float,
     ) -> np.ndarray:
-        def calculate_gamma_dist():
+        def calculate_gamma_dist() -> float:
             alpha = 1 / f_variance_iwc
             return (
                 1
@@ -216,18 +238,16 @@ class AdvanceProductMethods(DataSource):
         temperature: float,
         z_sen: float,
     ) -> np.ndarray:
-        def calculate_min_iwc():
-            min_iwc = 10 ** (
-                tZT * z_sen * temperature + tT * temperature + tZ * z_sen + t
-            )
-            return min_iwc
+        def calculate_min_iwc() -> np.ndarray:
+            return 10 ** (tZT * z_sen * temperature + tT * temperature + tZ * z_sen + t)
 
         iwc_min = calculate_min_iwc()
-        obs_index = iwc_dist > iwc_min
-        return obs_index
+        return iwc_dist > iwc_min
 
     @staticmethod
     def filter_cirrus(
-        p_iwc: np.ndarray, obs_index: np.ndarray, cf_filtered: np.ndarray
+        p_iwc: np.ndarray,
+        obs_index: np.ndarray,
+        cf_filtered: np.ndarray,
     ) -> np.ndarray:
         return (np.sum(p_iwc * obs_index) / np.sum(p_iwc)) * cf_filtered

cloudnetpy/model_evaluation/products/grid_methods.py

@@ -11,9 +11,12 @@ class ProductGrid:
     """Class to generate downsampling of observation product to model grid.
 
     Args:
+    ----
         model_obj (object): The :class:'ModelManager' object.
         obs_obj (object): The :class:'ObservationManager' object.
+
     Notes:
+    -----
         Downsampled observation products data is added to a ModelManager
         object which is used for nc-file creation and writing
     """
@@ -28,13 +31,15 @@ class ProductGrid:
         self._model_time = model_obj.time
         self._model_height = model_obj.data[model_obj.keys["height"]][:]
         self._time_adv = tl.calculate_advection_time(
-            int(model_obj.resolution_h), ma.array(model_obj.wind), 1
+            int(model_obj.resolution_h),
+            ma.array(model_obj.wind),
+            1,
         )
         time_steps = utils.binvec(self._model_time)
         self._time_steps = tl.time2datetime(time_steps, self._date)
         self._generate_downsample_product()
 
-    def _generate_downsample_product(self):
+    def _generate_downsample_product(self) -> None:
         """Downsampling products are generated with different averaging methods
         for a selected size of model time-height window.
         """
@@ -42,7 +47,8 @@ class ProductGrid:
         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
+                (self._time_steps[i], self._time_steps[i + 1]),
+                self._obs_time,
             )
             if self._obs_obj.obs == "iwc":
                 x_ind_no_rain = tl.get_1d_indices(
@@ -53,10 +59,13 @@ class ProductGrid:
             y_steps = tl.rebin_edges(self._model_height[i])
             for j in range(len(y_steps) - 1):
                 x_ind_adv = tl.get_adv_indices(
-                    model_t[i], self._time_adv[i, j], self._obs_time
+                    model_t[i],
+                    self._time_adv[i, j],
+                    self._obs_time,
                 )
                 y_ind = tl.get_1d_indices(
-                    (y_steps[j], y_steps[j + 1]), self._obs_height
+                    (y_steps[j], y_steps[j + 1]),
+                    self._obs_height,
                 )
                 ind = np.outer(x_ind, y_ind)
                 ind_avd = np.outer(x_ind_adv, y_ind)
@@ -66,7 +75,9 @@ class ProductGrid:
                         continue
                     product_dict = self._regrid_cf(product_dict, i, j, data)
                     data_adv = self._reshape_data_to_window(ind_avd, x_ind_adv, y_ind)
-                    assert data_adv is not None
+                    if data_adv is None:
+                        msg = "No data for advection"
+                        raise RuntimeError(msg)
                     product_adv_dict = self._regrid_cf(product_adv_dict, i, j, data_adv)
                 elif self._obs_obj.obs == "iwc":
                     x_ind_no_rain_adv = tl.get_adv_indices(
@@ -78,19 +89,30 @@ class ProductGrid:
                     ind_no_rain = np.outer(x_ind_no_rain, y_ind)
                     ind_no_rain_adv = np.outer(x_ind_no_rain_adv, y_ind)
                     product_dict = self._regrid_iwc(
-                        product_dict, i, j, ind, ind_no_rain
+                        product_dict,
+                        i,
+                        j,
+                        ind,
+                        ind_no_rain,
                     )
                     product_adv_dict = self._regrid_iwc(
-                        product_adv_dict, i, j, ind_avd, ind_no_rain_adv
+                        product_adv_dict,
+                        i,
+                        j,
+                        ind_avd,
+                        ind_no_rain_adv,
                     )
                 else:
                     product_dict = self._regrid_product(product_dict, i, j, ind)
                     product_adv_dict = self._regrid_product(
-                        product_adv_dict, i, j, ind_avd
+                        product_adv_dict,
+                        i,
+                        j,
+                        ind_avd,
                     )
         self._append_data2object([product_dict, product_adv_dict])
 
-    def _get_method_storage(self):
+    def _get_method_storage(self) -> tuple[dict, dict]:
         if self._obs_obj.obs == "cf":
             return self._cf_method_storage()
         if self._obs_obj.obs == "iwc":
@@ -124,7 +146,7 @@ class ProductGrid:
     def _product_method_storage(self) -> tuple[dict, dict]:
         product_dict = {f"{self._obs_obj.obs}": np.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": np.zeros(self._model_height.shape),
         }
         return product_dict, product_adv_dict
 
@@ -139,18 +161,21 @@ class ProductGrid:
                     downsample[i, j] = np.nanmean(data)
                 else:
                     downsample[i, j] = np.nan
-                if "_A" in key:
-                    if not np.isnan(data).all() and not (
-                        isinstance(data, ma.MaskedArray) and data.mask.all()
-                    ):
-                        downsample[i, j] = tl.average_column_sum(data)
+                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, x_ind: np.ndarray, y_ind: np.ndarray
+        self,
+        ind: np.ndarray,
+        x_ind: np.ndarray,
+        y_ind: np.ndarray,
     ) -> np.ndarray | None:
         """Reshapes True observation values to windows shape"""
         window_size = tl.get_obs_window_size(x_ind, y_ind)
@@ -203,9 +228,9 @@ class ProductGrid:
             storage[key] = down_sample
         return storage
 
-    def _append_data2object(self, data_storage: list):
+    def _append_data2object(self, data_storage: list) -> None:
         for storage in data_storage:
-            for key in storage.keys():
+            for key in storage:
                 down_sample = storage[key]
                 self.model_obj.append_data(
                     down_sample,

cloudnetpy/model_evaluation/products/model_products.py

@@ -14,12 +14,14 @@ class ModelManager(DataSource):
     """Class to collect and manage model data.
 
     Args:
+    ----
         model_file (str): Path to source model file.
         model (str): Name of model
         output_file (str): name of output file name and path to save data
         product (str): name of product to generate
 
     Notes:
+    -----
         For this class to work, needed information of model in use should be found in
         model_metadata.py
 
@@ -36,6 +38,7 @@ class ModelManager(DataSource):
         model: str,
         output_file: str,
         product: str,
+        *,
         check_file: bool = True,
     ):
         super().__init__(model_file)
@@ -52,7 +55,7 @@ class ModelManager(DataSource):
         self.wind = self._calculate_wind_speed()
         self.resolution_h = self._get_horizontal_resolution()
 
-    def _read_cycle_name(self, model_file: str):
+    def _read_cycle_name(self, model_file: str) -> str:
         """Get cycle name from model_metadata.py for saving variable name(s)"""
         try:
             cycles = self.model_info.cycle
@@ -66,17 +69,18 @@ class ModelManager(DataSource):
             return ""
         return ""
 
-    def _generate_products(self):
+    def _generate_products(self) -> None:
         """Process needed data of model to a ModelManager object"""
-        cls = getattr(importlib.import_module(__name__), "ModelManager")
+        cls = importlib.import_module(__name__).ModelManager
         try:
             name = f"_get_{self._product}"
             getattr(cls, name)(self)
-        except AttributeError as e:
-            logging.error(f"Invalid product name: {e}")
+        except AttributeError:
+            msg = f"Invalid product name: {self._product}"
+            logging.exception(msg)
             raise
 
-    def _get_cf(self):
+    def _get_cf(self) -> None:
         """Collect cloud fraction straight from model file."""
         cf_name = self.get_model_var_names(("cf",))[0]
         cf = self.getvar(cf_name)
@@ -85,13 +89,13 @@ class ModelManager(DataSource):
         self.append_data(cf, f"{self.model}{self.cycle}_cf")
         self.keys[self._product] = f"{self.model}{self.cycle}_cf"
 
-    def _get_iwc(self):
+    def _get_iwc(self) -> None:
         iwc = self.get_water_content("iwc")
         iwc[iwc < 1e-7] = ma.masked
         self.append_data(iwc, f"{self.model}{self.cycle}_iwc")
         self.keys[self._product] = f"{self.model}{self.cycle}_iwc"
 
-    def _get_lwc(self):
+    def _get_lwc(self) -> None:
         lwc = self.get_water_content("lwc")
         lwc[lwc < 1e-5] = ma.masked
         self.append_data(lwc, f"{self.model}{self.cycle}_lwc")
@@ -120,13 +124,15 @@ class ModelManager(DataSource):
     def _calc_water_content(q: np.ndarray, p: np.ndarray, t: np.ndarray) -> np.ndarray:
         return q * p / (287 * t)
 
-    def _add_variables(self):
+    def _add_variables(self) -> None:
         """Add basic variables off model and cycle"""
 
-        def _add_common_variables():
+        def _add_common_variables() -> None:
             """Model variables that are always the same within cycles"""
             wanted_vars = self.model_vars.common_var
-            assert wanted_vars is not None
+            if wanted_vars is None:
+                msg = f"Model {self.model} has no common variables"
+                raise ValueError(msg)
             wanted_vars_split = [x.strip() for x in wanted_vars.split(",")]
             for var in wanted_vars_split:
                 if var in self.dataset.variables:
@@ -135,10 +141,12 @@ class ModelManager(DataSource):
                         data = self.cut_off_extra_levels(self.dataset.variables[var][:])
                     self.append_data(data, f"{var}")
 
-        def _add_cycle_variables():
+        def _add_cycle_variables() -> None:
             """Add cycle depending variables"""
             wanted_vars = self.model_vars.cycle_var
-            assert wanted_vars is not None
+            if wanted_vars is None:
+                msg = f"Model {self.model} has no cycle variables"
+                raise ValueError(msg)
             wanted_vars_split = [x.strip() for x in wanted_vars.split(",")]
             for var in wanted_vars_split:
                 if var in self.dataset.variables:
@@ -160,11 +168,7 @@ class ModelManager(DataSource):
         except KeyError:
             return data
 
-        if data.ndim > 1:
-            data = data[:, :level]
-        else:
-            data = data[:level]
-        return data
+        return data[:, :level] if data.ndim > 1 else data[:level]
 
     def _calculate_wind_speed(self) -> np.ndarray:
         """Real wind from x- and y-components"""

cloudnetpy/model_evaluation/products/observation_products.py

@@ -1,5 +1,5 @@
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 
 import numpy as np
 from numpy import ma
@@ -13,10 +13,12 @@ class ObservationManager(DataSource):
     """Class to collect and manage observations for downsampling.
 
     Args:
+    ----
         obs (str): Name of observation product
         obs_file (str): Path to source observation file
 
     Notes:
+    -----
         Output is ObservationManager object where all product data and
         information is included.
 
@@ -42,6 +44,7 @@ class ObservationManager(DataSource):
             0,
             0,
             0,
+            tzinfo=timezone.utc,
         )
 
     def _get_radar_frequency(self) -> np.ndarray | None:
@@ -56,7 +59,7 @@ class ObservationManager(DataSource):
         except (KeyError, RuntimeError):
             return None
 
-    def _generate_product(self):
+    def _generate_product(self) -> None:
         """Process needed data of observation to a ObservationManager object"""
         try:
             if self.obs == "cf":
@@ -66,16 +69,16 @@ class ObservationManager(DataSource):
                 if self.obs == "iwc":
                     self._generate_iwc_masks()
             self.append_data(self.getvar("height"), "height")
-        except (KeyError, RuntimeError) as e:
-            logging.error(f"Invalid product name: {e}")
+        except (KeyError, RuntimeError):
+            msg = f"Failed to read {self.obs} from {self._file}"
+            logging.exception(msg)
             raise
 
     def _generate_cf(self) -> np.ndarray:
         """Generates cloud fractions using categorize bits and masking conditions"""
         categorize_bits = CategorizeBits(self._file)
         cloud_mask = self._classify_basic_mask(categorize_bits.category_bits)
-        cloud_mask = self._mask_cloud_bits(cloud_mask)
-        return cloud_mask
+        return self._mask_cloud_bits(cloud_mask)
 
     @staticmethod
     def _classify_basic_mask(bits: dict) -> np.ndarray:
@@ -101,12 +104,14 @@ class ObservationManager(DataSource):
         """Check if rainrate in file"""
         try:
             self.getvar("rainrate")
-            return True
         except RuntimeError:
             return False
+        return True
 
     def _get_rainrate_threshold(self) -> int:
-        assert self.radar_freq is not None
+        if self.radar_freq is None:
+            msg = "Radar frequency not found from file"
+            raise RuntimeError(msg)
         wband = utils.get_wl_band(float(self.radar_freq))
         rainrate_threshold = 8
         if 90 < wband < 100:
@@ -135,7 +140,8 @@ class ObservationManager(DataSource):
 
     def _mask_iwc_att(self, iwc: np.ndarray, iwc_status: np.ndarray) -> None:
         """Leaves only where reliable data, corrected liquid attenuation
-        and uncorrected liquid attenuation"""
+        and uncorrected liquid attenuation
+        """
         iwc_att = ma.copy(iwc)
         iwc_att[iwc_status > 3] = ma.masked
         self.append_data(iwc_att, "iwc_att")

cloudnetpy/model_evaluation/products/product_resampling.py

@@ -21,14 +21,17 @@ def process_L3_day_product(
     product_file: str,
     output_file: str,
     uuid: str | None = None,
+    *,
     overwrite: bool = False,
-):
+) -> str:
     """Main function to generate downsample of observations to match model grid.
 
     This function will generate a L3 product nc-file. It includes the information of
     downsampled observation products for each model cycles and model products
     and other variables of each cycles.
+
     Args:
+    ----
         model (str): Name of model
         obs (str): Name of product to generate
         model_files (list): List of model + cycles file path(s) to be generated
@@ -41,16 +44,19 @@ def process_L3_day_product(
                           default False
 
     Raises:
+    ------
         RuntimeError: Failed to create the L3 product file.
         ValueError (Warning): No ice clouds in model data
 
     Notes:
+    -----
         Model file(s) are given as a list to make all different cycles to be at same
         nc-file. If list includes more than one model file, nc-file is created within
         the first round. With rest of rounds, downsample observation and model data
         is added to same L3 day nc-file.
 
     Examples:
+    --------
         >>> from cloudnetpy.model_evaluation.products.product_resampling import \
         process_L3_day_product
         >>> product = 'cf'
@@ -65,7 +71,11 @@ def process_L3_day_product(
     tl.check_model_file_list(model, model_files)
     for m_file in model_files:
         model_obj = ModelManager(
-            m_file, model, output_file, obs, check_file=not overwrite
+            m_file,
+            model,
+            output_file,
+            obs,
+            check_file=not overwrite,
         )
         try:
             AdvanceProductMethods(model_obj, m_file, product_obj)
@@ -76,7 +86,7 @@ def process_L3_day_product(
         update_attributes(model_obj.data, attributes)
         if not file_exists(output_file) or overwrite:
             tl.add_date(model_obj, product_obj)
-            uuid = save_downsampled_file(
+            uuid_out = save_downsampled_file(
                 f"{obs}_{model}",
                 output_file,
                 (model_obj, product_obj),
@@ -85,4 +95,4 @@ def process_L3_day_product(
             )
         else:
             add_var2ncfile(model_obj, output_file)
-    return uuid
+    return uuid_out

cloudnetpy/model_evaluation/products/tools.py

@@ -14,7 +14,8 @@ def check_model_file_list(name: str, models: list) -> None:
     for m in models:
         if name not in m:
             logging.error("Invalid model file set")
-            raise AttributeError(f"{m} not from {name}")
+            msg = f"{m} not from {name}"
+            raise AttributeError(msg)
 
 
 def time2datetime(time: np.ndarray, date: datetime.datetime) -> np.ndarray:
@@ -30,18 +31,22 @@ def rebin_edges(arr: np.ndarray) -> np.ndarray:
 
 
 def calculate_advection_time(
-    resolution: int, wind: ma.MaskedArray, sampling: int
+    resolution: int,
+    wind: ma.MaskedArray,
+    sampling: int,
 ) -> np.ndarray:
     """Calculates time which variable takes to go through the time window
 
-    Notes:
+    Notes
+    -----
         Wind speed is stronger in upper levels, so advection time is more
         there then lower levels. Effect is small in a mid-latitudes,
         but visible in a tropics.
 
         sampling = 1 -> hour, sampling 1/6 -> 10min
 
-    References:
+    References
+    ----------
     """
     t_adv = resolution * 1000 / wind / 60**2
     t_adv[t_adv.mask] = 0
@@ -49,8 +54,12 @@ def calculate_advection_time(
     return np.asarray([[timedelta(hours=float(t)) for t in time] for time in t_adv])
 
 
-def get_1d_indices(window: tuple, data: np.ndarray, mask: np.ndarray | None = None):
-    indices = (window[0] <= data) & (data < window[-1])
+def get_1d_indices(
+    window: tuple,
+    data: np.ndarray,
+    mask: np.ndarray | None = None,
+) -> np.ndarray:
+    indices: np.ndarray = np.array((window[0] <= data) & (data < window[-1]))
     if mask is not None:
         indices[mask] = ma.masked
     return indices
@@ -61,7 +70,7 @@ def get_adv_indices(
     adv_t: float,
     data: np.ndarray,
     mask: np.ndarray | None = None,
-):
+) -> np.ndarray:
     adv_indices = ((model_t - adv_t / 2) <= data) & (data < (model_t + adv_t / 2))
     if mask is not None:
         adv_indices[mask] = ma.masked