cloudnetpy 1.80.8__py3-none-any.whl → 1.81.1__py3-none-any.whl

cloudnetpy/model_evaluation/plotting/plot_tools.py

@@ -1,5 +1,7 @@
 import netCDF4
 import numpy as np
+import numpy.typing as npt
+from matplotlib.axes import Axes
 from numpy import ma
 
 from cloudnetpy.model_evaluation.model_metadata import MODELS
@@ -109,14 +111,14 @@ def mask_small_values(data: ma.MaskedArray, name: str) -> ma.MaskedArray:
     return data
 
 
-def reshape_1d2nd(one_d: np.ndarray, two_d: np.ndarray) -> np.ndarray:
+def reshape_1d2nd(one_d: npt.NDArray, two_d: npt.NDArray) -> npt.NDArray:
     new_arr = np.zeros(two_d.shape)
     for i in range(len(two_d[0])):
         new_arr[:, i] = one_d
     return new_arr
 
 
-def create_segment_values(model: ma.MaskedArray, obs: ma.MaskedArray) -> np.ndarray:
+def create_segment_values(model: ma.MaskedArray, obs: ma.MaskedArray) -> npt.NDArray:
     new_array = np.zeros(model.shape, dtype=int)
     new_array[model.mask & obs.mask] = 0  # No data
     new_array[~model.mask & obs.mask] = 1  # Only model
@@ -125,12 +127,12 @@ def create_segment_values(model: ma.MaskedArray, obs: ma.MaskedArray) -> np.ndar
     return new_array
 
 
-def set_yaxis(ax, max_y: float, min_y: float = 0.0) -> None:
+def set_yaxis(ax: Axes, max_y: float, min_y: float = 0.0) -> None:
     ax.set_ylim(min_y, max_y)
     ax.set_ylabel("Height (km)", fontsize=13)
 
 
-def rolling_mean(data: ma.MaskedArray, n: int = 4) -> np.ndarray:
+def rolling_mean(data: ma.MaskedArray, n: int = 4) -> npt.NDArray:
     mmr = []
     for i in range(len(data)):
         if not data[i : i + n].mask.all():
@@ -143,7 +145,7 @@ def rolling_mean(data: ma.MaskedArray, n: int = 4) -> np.ndarray:
 def change2one_dim_axes(
     x: ma.MaskedArray,
     y: ma.MaskedArray,
-    data: np.ndarray,
+    data: npt.NDArray,
 ) -> tuple:
     # If any mask in x or y, change 2d to 1d axes values
     # Common shape need to match 2d data.

cloudnetpy/model_evaluation/plotting/plotting.py

@@ -7,8 +7,10 @@ import matplotlib as mpl
 import matplotlib.pyplot as plt
 import netCDF4
 import numpy as np
+import numpy.typing as npt
 from matplotlib.axes import Axes
 from matplotlib.colorbar import Colorbar
+from matplotlib.colorizer import ColorizingArtist
 from matplotlib.colors import ListedColormap
 from matplotlib.patches import Patch
 from matplotlib.pyplot import Figure
@@ -17,7 +19,7 @@ from numpy import ma
 
 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.plotting.plot_meta import ATTRIBUTES, PlotMeta
 from cloudnetpy.model_evaluation.statistics.statistical_methods import DayStatistics
 from cloudnetpy.plotting.plotting import Dimensions, get_log_cbar_tick_labels, lin2log
 
@@ -87,7 +89,7 @@ def generate_L3_day_plots(
         >>>                       fig_type='statistic', stats=['error'])
     """
 
-    def _check_cycle_names():
+    def _check_cycle_names() -> None:
         if not c_names:
             raise AttributeError
 
@@ -342,7 +344,9 @@ def get_single_plots(
     return figs, axes
 
 
-def plot_colormesh(ax, data: np.ndarray, axes: tuple, variable_info) -> None:
+def plot_colormesh(
+    ax: Axes, data: npt.NDArray, axes: tuple, variable_info: PlotMeta
+) -> None:
     vmin, vmax = variable_info.plot_range
     if variable_info.plot_scale == "logarithmic":
         data, vmin, vmax = lin2log(data, vmin, vmax)
@@ -355,7 +359,8 @@ def plot_colormesh(ax, data: np.ndarray, axes: tuple, variable_info) -> None:
         colorbar.set_ticks(np.arange(vmin, vmax + 1).tolist())  # type: ignore[arg-type]
         colorbar.ax.set_yticklabels(tick_labels)
     ax.set_facecolor("white")
-    colorbar.set_label(variable_info.clabel, fontsize=13)
+    if variable_info.clabel is not None:
+        colorbar.set_label(variable_info.clabel, fontsize=13)
 
 
 def get_statistic_plots(
@@ -398,15 +403,15 @@ def get_statistic_plots(
     name = ""
     j = 0
 
-    def _check_data():
+    def _check_data() -> None:
         if model_missing and obs_missing:
             _raise()
 
-    def _check_data2():
+    def _check_data2() -> None:
         if "error" in stat and np.all(day_stat.model_stat.mask is True):
             _raise()
 
-    def _raise():
+    def _raise() -> None:
         err_msg = f"No data in {model_name} or observation"
         raise ValueError(err_msg)
 
@@ -476,13 +481,13 @@ def get_statistic_plots(
 def initialize_statistic_plots(
     j: int,
     max_len: int,
-    ax,
+    ax: Axes,
     method: str,
     day_stat: DayStatistics,
     model: ma.MaskedArray,
     obs: ma.MaskedArray,
     args: tuple,
-    variable_info,
+    variable_info: PlotMeta,
     *,
     title: bool = True,
     include_xlimits: bool = False,
@@ -542,7 +547,9 @@ def initialize_statistic_plots(
             )
 
 
-def plot_relative_error(ax, error: ma.MaskedArray, axes: tuple, method: str) -> None:
+def plot_relative_error(
+    ax: Axes, error: ma.MaskedArray, axes: tuple, method: str
+) -> None:
     pl = ax.pcolormesh(*axes, error[:-1, :-1].T, cmap="RdBu_r", vmin=-50, vmax=50)
     colorbar = init_colorbar(pl, ax)
     colorbar.set_label("%", fontsize=13)
@@ -569,7 +576,7 @@ def plot_relative_error(ax, error: ma.MaskedArray, axes: tuple, method: str) ->
 
 
 def plot_data_area(
-    ax,
+    ax: Axes,
     day_stat: DayStatistics,
     model: ma.MaskedArray,
     obs: ma.MaskedArray,
@@ -612,13 +619,13 @@ def plot_data_area(
     )
 
 
-def plot_histogram(ax, day_stat: DayStatistics, variable_info) -> None:
+def plot_histogram(ax: Axes, day_stat: DayStatistics, variable_info: PlotMeta) -> None:
     weights = np.ones_like(day_stat.model_stat) / float(len(day_stat.model_stat))
     hist_bins = np.histogram(day_stat.observation_stat, density=True)[-1]
     ax.hist(
         day_stat.model_stat,
         weights=weights,
-        bins=hist_bins,
+        bins=list(hist_bins),
         alpha=0.7,
         facecolor="khaki",
         edgecolor="k",
@@ -631,13 +638,14 @@ def plot_histogram(ax, day_stat: DayStatistics, variable_info) -> None:
     ax.hist(
         day_stat.observation_stat,
         weights=weights,
-        bins=hist_bins,
+        bins=list(hist_bins),
         alpha=0.7,
         facecolor="steelblue",
         edgecolor="k",
         label="Observation",
     )
-    ax.set_xlabel(variable_info.x_title, fontsize=13)
+    if variable_info.x_title is not None:
+        ax.set_xlabel(variable_info.x_title, fontsize=13)
     if variable_info.plot_scale == "logarithmic":
         ax.ticklabel_format(axis="x", style="sci", scilimits=(0, 0))
     ax.set_ylabel("Relative frequency %", fontsize=13)
@@ -646,10 +654,10 @@ def plot_histogram(ax, day_stat: DayStatistics, variable_info) -> None:
 
 
 def plot_vertical_profile(
-    ax,
+    ax: Axes,
     day_stat: DayStatistics,
     axes: tuple,
-    variable_info,
+    variable_info: PlotMeta,
 ) -> None:
     mrm = p_tools.rolling_mean(day_stat.model_stat)
     orm = p_tools.rolling_mean(day_stat.observation_stat)
@@ -686,7 +694,8 @@ def plot_vertical_profile(
     ax.plot(orm, axes, "-", color="green", lw=2, label="Mean of observation")
 
     ax.set_title(f"{day_stat.title[-1]}", fontsize=14)
-    ax.set_xlabel(variable_info.x_title, fontsize=13)
+    if variable_info.x_title is not None:
+        ax.set_xlabel(variable_info.x_title, fontsize=13)
     if variable_info.plot_scale == "logarithmic":
         ax.ticklabel_format(axis="x", style="sci", scilimits=(0, 0))
     ax.yaxis.grid(which="major")
@@ -740,17 +749,17 @@ def initialize_figure(n_subplots: int, stat: str = "") -> tuple[Figure, list[Axe
     return fig, axes_list
 
 
-def init_colorbar(plot, axis) -> Colorbar:
+def init_colorbar(plot: ColorizingArtist, axis: Axes) -> Colorbar:
     divider = make_axes_locatable(axis)
     cax = divider.append_axes("right", size="1%", pad=0.25)
     return plt.colorbar(plot, fraction=1.0, ax=axis, cax=cax)
 
 
 def _set_title(
-    ax,
+    ax: Axes,
     field_name: str,
     product: str,
-    variable_info,
+    variable_info: PlotMeta,
     model_name: str = "",
 ) -> None:
     """Generates subtitles for different product types."""
@@ -773,14 +782,14 @@ def _set_title(
             ax.set_title(f"Simulated {name}")
 
 
-def _get_cf_title(field_name: str, variable_info) -> str:
+def _get_cf_title(field_name: str, variable_info: PlotMeta) -> str:
     title = f"{variable_info.name}, Area"
     if "V" in field_name:
         title = f"{variable_info.name}, Volume"
     return title
 
 
-def _get_iwc_title(field_name: str, variable_info) -> str:
+def _get_iwc_title(field_name: str, variable_info: PlotMeta) -> str:
     name = variable_info.name
     if "att" in field_name:
         title = f"{name} with good attenuation"
@@ -791,11 +800,11 @@ def _get_iwc_title(field_name: str, variable_info) -> str:
     return title
 
 
-def _get_product_title(variable_info) -> str:
+def _get_product_title(variable_info: PlotMeta) -> str:
     return f"{variable_info.name}"
 
 
-def _get_stat_titles(field_name: str, product: str, variable_info) -> str:
+def _get_stat_titles(field_name: str, product: str, variable_info: PlotMeta) -> str:
     title = _get_product_title_stat(variable_info)
     if product == "cf":
         title = _get_cf_title_stat(field_name, variable_info)
@@ -807,7 +816,7 @@ def _get_stat_titles(field_name: str, product: str, variable_info) -> str:
     return title
 
 
-def _get_cf_title_stat(field_name: str, variable_info) -> str:
+def _get_cf_title_stat(field_name: str, variable_info: PlotMeta) -> str:
     name = variable_info.name
     title = f"{name} area"
     if "V" in field_name:
@@ -815,7 +824,7 @@ def _get_cf_title_stat(field_name: str, variable_info) -> str:
     return title
 
 
-def _get_iwc_title_stat(field_name: str, variable_info) -> str:
+def _get_iwc_title_stat(field_name: str, variable_info: PlotMeta) -> str:
     name = variable_info.name
     if "att" in field_name:
         title = f"{name} with good attenuation"
@@ -826,12 +835,12 @@ def _get_iwc_title_stat(field_name: str, variable_info) -> str:
     return title
 
 
-def _get_product_title_stat(variable_info) -> str:
+def _get_product_title_stat(variable_info: PlotMeta) -> str:
     name = variable_info.name
     return f"{name}"
 
 
-def set_yax(ax, max_y: float, ylabel: str | None, min_y: float = 0.0) -> None:
+def set_yax(ax: Axes, max_y: float, ylabel: str | None, min_y: float = 0.0) -> None:
     """Sets yticks, ylim and ylabel for yaxis of axis."""
     ax.set_ylim(min_y, max_y)
     ax.set_ylabel("Height (km)", fontsize=13)
@@ -839,7 +848,7 @@ def set_yax(ax, max_y: float, ylabel: str | None, min_y: float = 0.0) -> None:
         ax.set_ylabel(ylabel, fontsize=13)
 
 
-def set_xax(ax, *, include_xlimits: bool = False) -> None:
+def set_xax(ax: Axes, *, include_xlimits: bool = False) -> None:
     """Sets xticks and xtick labels for plt.imshow()."""
     ticks_x_labels = _get_standard_time_ticks(include_xlimits=include_xlimits)
     ax.set_xticks(np.arange(0, 25, 4, dtype=int))
@@ -864,7 +873,7 @@ def _get_standard_time_ticks(
     ]
 
 
-def set_labels(fig, ax, nc_file: str, *, sub_title: bool = True) -> date:
+def set_labels(fig: Figure, ax: Axes, nc_file: str, *, sub_title: bool = True) -> date:
     ax.set_xlabel("Time (UTC)", fontsize=13)
     case_date = read_date(nc_file)
     site_name = read_location(nc_file)
@@ -885,7 +894,7 @@ def read_date(nc_file: str) -> date:
         return date(int(nc.year), int(nc.month), int(nc.day))
 
 
-def add_subtitle(fig, case_date: date, site_name: str) -> None:
+def add_subtitle(fig: Figure, case_date: date, site_name: str) -> None:
     """Adds subtitle into figure."""
     text = _get_subtitle_text(case_date, site_name)
     fig.suptitle(

cloudnetpy/model_evaluation/products/advance_methods.py

@@ -1,7 +1,9 @@
 import importlib
 import logging
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 import scipy.special
 import scipy.stats
 from numpy import ma
@@ -25,9 +27,9 @@ class AdvanceProductMethods(DataSource):
     def __init__(
         self,
         model_obj: ModelManager,
-        model_file: str,
+        model_file: str | PathLike,
         obs_obj: ObservationManager,
-    ):
+    ) -> None:
         super().__init__(model_file)
         self._obs_obj = obs_obj
         self.product = obs_obj.obs
@@ -96,12 +98,12 @@ class AdvanceProductMethods(DataSource):
             f"{self._model_obj.model}{self._model_obj.cycle}_cf_cirrus",
         )
 
-    def getvar_from_object(self, arg: str) -> np.ndarray:
+    def getvar_from_object(self, arg: str) -> npt.NDArray:
         v_name = arg if arg == "cf" else self._model_obj.get_model_var_names((arg,))[0]
         key = f"{self._model_obj.model}{self._model_obj.cycle}_{v_name}"
         return self._model_obj.data[key][:]
 
-    def remove_extra_levels(self, arg: np.ndarray) -> np.ndarray:
+    def remove_extra_levels(self, arg: npt.NDArray) -> npt.NDArray:
         return self._model_obj.cut_off_extra_levels(arg)
 
     def set_frequency_parameters(self) -> tuple:
@@ -114,7 +116,7 @@ class AdvanceProductMethods(DataSource):
             return 0.00058, -0.00706, 0.0923, -0.992
         raise ValueError
 
-    def fit_z_sensitivity(self, h: np.ndarray) -> np.ndarray:
+    def fit_z_sensitivity(self, h: npt.NDArray) -> npt.NDArray:
         if self._obs_obj.z_sensitivity is None:
             msg = "No z_sensitivity in observation file"
             raise ValueError(msg)
@@ -129,10 +131,10 @@ class AdvanceProductMethods(DataSource):
 
     def filter_high_iwc_low_cf(
         self,
-        cf: np.ndarray,
-        iwc: np.ndarray,
-        lwc: np.ndarray,
-    ) -> np.ndarray:
+        cf: npt.NDArray,
+        iwc: npt.NDArray,
+        lwc: npt.NDArray,
+    ) -> npt.NDArray:
         cf_filtered = self.mask_weird_indices(cf, iwc, lwc)
         if np.sum((iwc > 0) & (lwc < iwc / 10) & (cf_filtered > 0)) == 0:
             msg = "No ice clouds in a input data"
@@ -141,10 +143,10 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def mask_weird_indices(
-        cf: np.ndarray,
-        iwc: np.ndarray,
-        lwc: np.ndarray,
-    ) -> np.ndarray:
+        cf: npt.NDArray,
+        iwc: npt.NDArray,
+        lwc: npt.NDArray,
+    ) -> npt.NDArray:
         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)
@@ -153,23 +155,23 @@ class AdvanceProductMethods(DataSource):
 
     def find_ice_in_clouds(
         self,
-        cf_filtered: np.ndarray,
-        iwc: np.ndarray,
-        lwc: np.ndarray,
-    ) -> tuple[np.ndarray, tuple]:
+        cf_filtered: npt.NDArray,
+        iwc: npt.NDArray,
+        lwc: npt.NDArray,
+    ) -> tuple[npt.NDArray, tuple]:
         ice_ind = self.get_ice_indices(cf_filtered, iwc, lwc)
         cloud_iwc = iwc[ice_ind] / cf_filtered[ice_ind] * 1e3
         return cloud_iwc, ice_ind
 
     @staticmethod
     def get_ice_indices(
-        cf_filtered: np.ndarray,
-        iwc: np.ndarray,
-        lwc: np.ndarray,
+        cf_filtered: npt.NDArray,
+        iwc: npt.NDArray,
+        lwc: npt.NDArray,
     ) -> tuple:
         return tuple(np.where((cf_filtered > 0) & (iwc > 0) & (lwc < iwc / 10)))
 
-    def iwc_variance(self, height: np.ndarray, ice_ind: tuple) -> np.ndarray:
+    def iwc_variance(self, height: npt.NDArray, ice_ind: tuple) -> npt.NDArray:
         u = self.getvar("uwind")
         v = self.getvar("vwind")
         u = self.remove_extra_levels(u)
@@ -177,7 +179,9 @@ class AdvanceProductMethods(DataSource):
         w_shear = self.calculate_wind_shear(self._model_obj.wind, u, v, height)
         return self.calculate_variance_iwc(w_shear, ice_ind)
 
-    def calculate_variance_iwc(self, w_shear: np.ndarray, ice_ind: tuple) -> np.ndarray:
+    def calculate_variance_iwc(
+        self, w_shear: npt.NDArray, ice_ind: tuple
+    ) -> npt.NDArray:
         return 10 ** (
             0.3 * np.log10(self._model_obj.resolution_h)
             - 0.04 * w_shear[ice_ind]
@@ -186,11 +190,11 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def calculate_wind_shear(
-        wind,
-        u: np.ndarray,
-        v: np.ndarray,
-        height: np.ndarray,
-    ) -> np.ndarray:
+        wind: npt.NDArray,
+        u: npt.NDArray,
+        v: npt.NDArray,
+        height: npt.NDArray,
+    ) -> npt.NDArray:
         grand_winds = []
         for w in (wind, u, v):
             grad_w = np.zeros(w.shape)
@@ -211,7 +215,7 @@ class AdvanceProductMethods(DataSource):
         f_variance_iwc: float,
         n_std: int = 5,
         n_dist: int = 250,
-    ) -> np.ndarray:
+    ) -> npt.NDArray:
         finish = cloud_iwc + n_std * (ma.sqrt(f_variance_iwc) * cloud_iwc)
         if isinstance(finish, ma.MaskedArray) and finish.mask.all():
             raise ValueError
@@ -223,16 +227,16 @@ class AdvanceProductMethods(DataSource):
 
     @staticmethod
     def gamma_distribution(
-        iwc_dist: np.ndarray, f_variance_iwc: float, cloud_iwc: float
-    ) -> np.ndarray:
+        iwc_dist: npt.NDArray, f_variance_iwc: float, cloud_iwc: float
+    ) -> npt.NDArray:
         alpha = 1 / f_variance_iwc
         theta = cloud_iwc / alpha
         return scipy.stats.gamma.pdf(iwc_dist, a=alpha, scale=theta)
 
     @staticmethod
     def filter_cirrus(
-        p_iwc: np.ndarray,
-        obs_index: np.ndarray,
-        cf_filtered: np.ndarray,
-    ) -> np.ndarray:
+        p_iwc: npt.NDArray,
+        obs_index: npt.NDArray,
+        cf_filtered: npt.NDArray,
+    ) -> npt.NDArray:
         return (ma.sum(p_iwc * obs_index) / ma.sum(p_iwc)) * cf_filtered

cloudnetpy/model_evaluation/products/grid_methods.py

@@ -1,4 +1,5 @@
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import utils
@@ -19,7 +20,7 @@ class ProductGrid:
         object which is used for nc-file creation and writing
     """
 
-    def __init__(self, model_obj: ModelManager, obs_obj: ObservationManager):
+    def __init__(self, model_obj: ModelManager, obs_obj: ObservationManager) -> None:
         self._obs_obj = obs_obj
         self._date = obs_obj.date
         self._obs_time = tl.time2datetime(obs_obj.time, self._date)
@@ -150,10 +151,10 @@ class ProductGrid:
 
     def _reshape_data_to_window(
         self,
-        ind: np.ndarray,
-        x_ind: np.ndarray,
-        y_ind: np.ndarray,
-    ) -> np.ndarray | None:
+        ind: npt.NDArray,
+        x_ind: npt.NDArray,
+        y_ind: npt.NDArray,
+    ) -> npt.NDArray | None:
         """Reshapes True observation values to windows shape."""
         window_size = tl.get_obs_window_size(x_ind, y_ind)
         if window_size is not None:
@@ -161,7 +162,7 @@ class ProductGrid:
         return None
 
     @staticmethod
-    def _regrid_cf(storage: dict, i: int, j: int, data: np.ndarray) -> dict:
+    def _regrid_cf(storage: dict, i: int, j: int, data: npt.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():
@@ -176,8 +177,8 @@ class ProductGrid:
         storage: dict,
         i: int,
         j: int,
-        ind_rain: np.ndarray,
-        ind_no_rain: np.ndarray,
+        ind_rain: npt.NDArray,
+        ind_no_rain: npt.NDArray,
     ) -> dict:
         """Calculates average iwc value for each grid point."""
         for key, down_sample in storage.items():
@@ -197,7 +198,7 @@ class ProductGrid:
             storage[key] = down_sample
         return storage
 
-    def _regrid_product(self, storage: dict, i: int, j: int, ind: np.ndarray) -> dict:
+    def _regrid_product(self, storage: dict, i: int, j: int, ind: npt.NDArray) -> dict:
         """Calculates average of standard product value for each grid point."""
         for key, down_sample in storage.items():
             obs_data_selected = ma.masked_invalid(self._obs_data[ind])

cloudnetpy/model_evaluation/products/model_products.py

@@ -1,7 +1,10 @@
 import importlib
 import logging
+import os.path
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy.datasource import DataSource
@@ -32,13 +35,13 @@ class ModelManager(DataSource):
 
     def __init__(
         self,
-        model_file: str,
+        model_file: str | PathLike,
         model: str,
-        output_file: str,
+        output_file: str | PathLike,
         product: str,
         *,
         check_file: bool = True,
-    ):
+    ) -> None:
         super().__init__(model_file)
         self.model = model
         self.model_info = MODELS[model]
@@ -53,15 +56,16 @@ class ModelManager(DataSource):
         self.wind = self._calculate_wind_speed()
         self.resolution_h = self._get_horizontal_resolution()
 
-    def _read_cycle_name(self, model_file: str) -> str:
+    def _read_cycle_name(self, model_file: str | PathLike) -> str:
         """Get cycle name from model_metadata.py for saving variable name(s)."""
+        basename = os.path.basename(model_file)
         try:
             cycles = self.model_info.cycle
             if cycles is None:
                 return ""
             cycles_split = [x.strip() for x in cycles.split(",")]
             for cycle in cycles_split:
-                if cycle in model_file:
+                if cycle in basename:
                     return f"_{cycle}"
         except AttributeError:
             return ""
@@ -106,7 +110,7 @@ class ModelManager(DataSource):
             var.append(VARIABLES[arg].long_name)
         return var
 
-    def get_water_content(self, var: str) -> np.ndarray:
+    def get_water_content(self, var: str) -> npt.NDArray:
         p_name = self.get_model_var_names(("p",))[0]
         t_name = self.get_model_var_names(("T",))[0]
         lwc_name = self.get_model_var_names((var,))[0]
@@ -119,7 +123,9 @@ class ModelManager(DataSource):
         return wc
 
     @staticmethod
-    def _calc_water_content(q: np.ndarray, p: np.ndarray, t: np.ndarray) -> np.ndarray:
+    def _calc_water_content(
+        q: npt.NDArray, p: npt.NDArray, t: npt.NDArray
+    ) -> npt.NDArray:
         return q * p / (287 * t)
 
     def _add_variables(self) -> None:
@@ -159,7 +165,7 @@ class ModelManager(DataSource):
             _add_common_variables()
         _add_cycle_variables()
 
-    def cut_off_extra_levels(self, data: np.ndarray) -> np.ndarray:
+    def cut_off_extra_levels(self, data: npt.NDArray) -> npt.NDArray:
         """Remove unused levels (over 22km) from model data."""
         try:
             level = self.model_info.level
@@ -168,7 +174,7 @@ class ModelManager(DataSource):
 
         return data[:, :level] if data.ndim > 1 else data[:level]
 
-    def _calculate_wind_speed(self) -> np.ndarray:
+    def _calculate_wind_speed(self) -> npt.NDArray:
         """Real wind from x- and y-components."""
         u = self.getvar("uwind")
         v = self.getvar("vwind")