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

cloudnetpy/products/drizzle_tools.py

@@ -16,9 +16,11 @@ class DrizzleSource(DataSource):
     """Class holding the input data for drizzle calculations.
 
     Args:
+    ----
         categorize_file: Categorize file name.
 
     Attributes:
+    ----------
         mie (dict): Mie look-up table data.
         dheight (float): Median difference of height array.
         z (ndarray): 2D radar echo (linear units).
@@ -35,13 +37,13 @@ class DrizzleSource(DataSource):
         self.beta = self.getvar("beta")
         self.v = self.getvar("v")
 
-    def _convert_z_units(self):
+    def _convert_z_units(self) -> np.ndarray:
         """Converts reflectivity factor to SI units."""
         z = self.getvar("Z") - 180
         z[z > 0.0] = 0.0
         return utils.db2lin(z)
 
-    def _read_mie_lut(self):
+    def _read_mie_lut(self) -> dict:
         """Reads mie scattering look-up table."""
         mie_file = self._get_mie_file()
         with netCDF4.Dataset(mie_file) as nc:
@@ -59,16 +61,16 @@ class DrizzleSource(DataSource):
                     "width": mie[f"lu_width_{band}"][:],
                     "ray": mie[f"lu_mie_ray_{band}"][:],
                     "v": mie[f"lu_v_{band}"][:],
-                }
+                },
             )
         return lut
 
     @staticmethod
-    def _get_mie_file():
+    def _get_mie_file() -> str:
         module_path = os.path.dirname(os.path.abspath(__file__))
-        return "/".join((module_path, "mie_lu_tables.nc"))
+        return f"{module_path}/mie_lu_tables.nc"
 
-    def _get_wl_band(self):
+    def _get_wl_band(self) -> str:
         """Returns string corresponding the radar frequency."""
         radar_frequency = float(self.getvar("radar_frequency"))
         wl_band = utils.get_wl_band(radar_frequency)
@@ -80,9 +82,11 @@ class DrizzleClassification(ProductClassification):
     child of  :class:`ProductClassification`.
 
     Args:
+    ----
         categorize_file: Categorize file name.
 
     Attributes:
+    ----------
         is_v_sigma (ndarray): 2D array denoting finite v_sigma.
         warm_liquid (ndarray): 2D array denoting warm liquid.
         drizzle (ndarray): 2D array denoting drizzle presence.
@@ -100,14 +104,14 @@ class DrizzleClassification(ProductClassification):
         self.cold_rain = self._find_cold_rain()
 
     @staticmethod
-    def _find_v_sigma(cat_file: str):
+    def _find_v_sigma(cat_file: str) -> np.ndarray:
         v_sigma = product_tools.read_nc_fields(cat_file, "v_sigma")
         return np.isfinite(v_sigma)
 
-    def _find_warm_liquid(self):
+    def _find_warm_liquid(self) -> np.ndarray:
         return self.category_bits["droplet"] & ~self.category_bits["cold"]
 
-    def _find_drizzle(self):
+    def _find_drizzle(self) -> np.ndarray:
         return (
             ~utils.transpose(self.is_rain)
             & self.category_bits["falling"]
@@ -123,7 +127,7 @@ class DrizzleClassification(ProductClassification):
             & self.is_v_sigma
         )
 
-    def _find_would_be_drizzle(self):
+    def _find_would_be_drizzle(self) -> np.ndarray:
         return (
             ~utils.transpose(self.is_rain)
             & self.warm_liquid
@@ -135,7 +139,7 @@ class DrizzleClassification(ProductClassification):
             & ~self.quality_bits["molecular"]
         )
 
-    def _find_cold_rain(self):
+    def _find_cold_rain(self) -> np.ndarray:
         return np.any(self.category_bits["melting"], axis=1)
 
 
@@ -146,9 +150,11 @@ class SpectralWidth:
     spectral broadening of the Doppler velocity.
 
     Args:
+    ----
         categorize_file: Categorize file name.
 
     Attributes:
+    ----------
         categorize_file (str): Categorize file name.
         width_ht (ndarray): Spectral width containing the correction for turbulence
             broadening.
@@ -159,32 +165,33 @@ class SpectralWidth:
         self.cat_file = categorize_file
         self.width_ht = self._calculate_spectral_width()
 
-    def _calculate_spectral_width(self):
+    def _calculate_spectral_width(self) -> np.ndarray:
         v_sigma = product_tools.read_nc_fields(self.cat_file, "v_sigma")
         try:
             width = product_tools.read_nc_fields(self.cat_file, "width")
         except KeyError:
             width = [0]
-            logging.warning(f"No spectral width, assuming width = {width[0]}")
+            logging.warning("No spectral width, assuming width = %s", width[0])
         sigma_factor = self._calc_v_sigma_factor()
         return width - sigma_factor * v_sigma
 
-    def _calc_v_sigma_factor(self):
+    def _calc_v_sigma_factor(self) -> np.ndarray:
         beam_divergence = self._calc_beam_divergence()
         wind = self._calc_horizontal_wind()
         actual_wind = (wind + beam_divergence) ** (2 / 3)
         scaled_wind = (30 * wind + beam_divergence) ** (2 / 3)
         return actual_wind / (scaled_wind - actual_wind)
 
-    def _calc_beam_divergence(self):
+    def _calc_beam_divergence(self) -> np.ndarray:
         beam_width = 0.5
         height = product_tools.read_nc_fields(self.cat_file, "height")
         return height * np.deg2rad(beam_width)
 
-    def _calc_horizontal_wind(self):
+    def _calc_horizontal_wind(self) -> np.ndarray:
         """Calculates magnitude of horizontal wind.
 
-        Returns:
+        Returns
+        -------
             ndarray: Horizontal wind (m s-1).
 
         """
@@ -198,11 +205,13 @@ class DrizzleSolver:
     """Estimates drizzle parameters.
 
     Args:
+    ----
         drizzle_source: The :class:`DrizzleSource` instance.
         drizzle_class: The :class:`DrizzleClassification` instance.
         spectral_width: The :class:`SpectralWidth` instance.
 
     Attributes:
+    ----------
         params (dict): Dictionary of retrieved drizzle parameters 'Do', 'mu', 'S',
             'beta_corr'.
 
@@ -238,16 +247,18 @@ class DrizzleSolver:
     def _find_lut_indices(self, ind, dia_init, n_dia, n_widths) -> tuple[int, int]:
         ind_dia = bisect_left(self._data.mie["Do"], dia_init[ind], hi=n_dia - 1)
         ind_width = bisect_left(
-            self._width_lut[:, ind_dia], -self._width_ht[ind], hi=n_widths - 1
+            self._width_lut[:, ind_dia],
+            -self._width_ht[ind],
+            hi=n_widths - 1,
         )
         return ind_width, ind_dia
 
-    def _solve_drizzle(self, dia_init: np.ndarray):
+    def _solve_drizzle(self, dia_init: np.ndarray) -> None:
         drizzle_ind = np.where(self._drizzle_class.drizzle == 1)
         dia_init[drizzle_ind] = self._calc_dia(self._beta_z_ratio[drizzle_ind], k=18.8)
         n_widths, n_dia = self._width_lut.shape[0], len(self._data.mie["Do"])
         max_ite = 10
-        for ind in zip(*drizzle_ind):
+        for ind in zip(*drizzle_ind, strict=True):
             for _ in range(max_ite):
                 lut_ind = self._find_lut_indices(ind, dia_init, n_dia, n_widths)
                 dia = self._calc_dia(
@@ -261,13 +272,16 @@ class DrizzleSolver:
                     break
                 self._dia_init[ind] = dia
             beta_factor = np.exp(
-                2 * self.params["S"][ind] * self._data.beta[ind] * self._data.dheight
+                2 * self.params["S"][ind] * self._data.beta[ind] * self._data.dheight,
             )
             self.params["beta_corr"][ind[0], (ind[-1] + 1) :] *= beta_factor
 
     def _update_result_tables(
-        self, ind: tuple, dia: np.ndarray | float, lut_ind: tuple
-    ):
+        self,
+        ind: tuple,
+        dia: np.ndarray | float,
+        lut_ind: tuple,
+    ) -> None:
         self.params["Do"][ind] = dia
         self.params["mu"][ind] = self._data.mie["mu"][lut_ind[0]]
         self.params["S"][ind] = self._data.mie["S"][lut_ind]
@@ -282,15 +296,18 @@ class DrizzleSolver:
         """Drizzle diameter calculation.
 
         Args:
+        ----
             beta_z_ratio: Beta to z ratio, multiplied by (2 / pi).
             mu: Shape parameter for gamma calculations. Default is 0.
             ray: Mie to Rayleigh ratio for z. Default is 1.
             k: Alpha to beta ratio . Default is 1.
 
         Returns:
+        -------
             ndarray: Drizzle diameter.
 
         References:
+        ----------
             https://journals.ametsoc.org/doi/pdf/10.1175/JAM-2181.1
 
         """
@@ -299,7 +316,9 @@ class DrizzleSolver:
 
     @staticmethod
     def _is_converged(
-        ind: tuple, dia: np.ndarray | float, dia_init: np.ndarray
+        ind: tuple,
+        dia: np.ndarray | float,
+        dia_init: np.ndarray,
     ) -> bool:
         threshold = 1e-3
         return abs((dia - dia_init[ind]) / dia_init[ind]) < threshold

cloudnetpy/products/ier.py

@@ -8,7 +8,9 @@ from cloudnetpy.products.product_tools import IceClassification, IceSource
 
 
 def generate_ier(
-    categorize_file: str, output_file: str, uuid: str | None = None
+    categorize_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     """Generates Cloudnet ice effective radius product.
 
@@ -19,18 +21,22 @@ def generate_ier(
     and model temperature. The results are written in a netCDF file.
 
     Args:
+    ----
         categorize_file: Categorize file name.
         output_file: Output file name.
         uuid: Set specific UUID for the file.
 
     Returns:
+    -------
         UUID of the generated file.
 
     Examples:
+    --------
         >>> from cloudnetpy.products import generate_ier
         >>> generate_ier('categorize.nc', 'ier.nc')
 
     References:
+    ----------
         Hogan, R. J., Mittermaier, M. P., & Illingworth, A. J. (2006). The Retrieval
         of Ice Water Content from Radar Reflectivity Factor and Temperature and Its
         Use in Evaluating a Mesoscale Model, Journal of Applied Meteorology and
@@ -63,14 +69,13 @@ def generate_ier(
         attributes = output.add_time_attribute(IER_ATTRIBUTES, date)
         attributes = _add_ier_comment(attributes, ier_source)
         output.update_attributes(ier_source.data, attributes)
-        uuid = output.save_product_file(product, ier_source, output_file, uuid)
-    return uuid
+        return output.save_product_file(product, ier_source, output_file, uuid)
 
 
 class IerSource(IceSource):
     """Data container for ice effective radius calculations."""
 
-    def convert_units(self):
+    def convert_units(self) -> None:
         """Convert um to m."""
         for prod in ("ier", "ier_inc_rain"):
             self.data[prod].data[:] /= 1e6
@@ -105,7 +110,7 @@ def _add_ier_comment(attributes: dict, ier: IerSource) -> dict:
         "as ice. Missing data indicates either that ice cloud was present but it was\n"
         "only detected by the lidar so its ice water content could not be estimated,\n"
         "or than there was rain below the ice associated with uncertain attenuation\n"
-        "of the reflectivities in the ice.\n"
+        "of the reflectivities in the ice.\n",
     )
     return attributes
 

cloudnetpy/products/iwc.py

@@ -3,12 +3,15 @@ import numpy as np
 from numpy import ma
 
 from cloudnetpy import output, utils
+from cloudnetpy.constants import G_TO_KG
 from cloudnetpy.metadata import MetaData
 from cloudnetpy.products.product_tools import IceClassification, IceSource
 
 
 def generate_iwc(
-    categorize_file: str, output_file: str, uuid: str | None = None
+    categorize_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     """Generates Cloudnet ice water content product.
 
@@ -18,18 +21,22 @@ def generate_iwc(
     netCDF file.
 
     Args:
+    ----
         categorize_file: Categorize file name.
         output_file: Output file name.
         uuid: Set specific UUID for the file.
 
     Returns:
+    -------
         UUID of the generated file.
 
     Examples:
+    --------
         >>> from cloudnetpy.products import generate_iwc
         >>> generate_iwc('categorize.nc', 'iwc.nc')
 
     References:
+    ----------
         Hogan, R.J., M.P. Mittermaier, and A.J. Illingworth, 2006:
         The Retrieval of Ice Water Content from Radar Reflectivity Factor and
         Temperature and Its Use in Evaluating a Mesoscale Model.
@@ -50,8 +57,7 @@ def generate_iwc(
         attributes = _add_iwc_comment(attributes, iwc_source)
         attributes = _add_iwc_error_comment(attributes, lwp_prior, bias)
         output.update_attributes(iwc_source.data, attributes)
-        uuid = output.save_product_file(product, iwc_source, output_file, uuid)
-    return uuid
+        return output.save_product_file(product, iwc_source, output_file, uuid)
 
 
 class IwcSource(IceSource):
@@ -75,10 +81,10 @@ class IwcSource(IceSource):
             scaled_temperature += self.coefficients.Z
             return self.getvar("Z_error") * scaled_temperature * 10
 
-        def _calc_error_in_uncorrected_ice() -> np.ndarray:
+        def _calc_error_in_uncorrected_ice() -> float:
             spec_liq_atten = 1.0 if self.wl_band == 0 else 4.5
             liq_atten_scaled = spec_liq_atten * self.coefficients.Z
-            return lwp_prior * liq_atten_scaled * 2 * 1e-3 * 10
+            return lwp_prior * G_TO_KG * liq_atten_scaled * 2 * 10
 
         lwp_prior = 250  # g m-2
         retrieval_uncertainty = 1.7  # dB
@@ -86,7 +92,8 @@ class IwcSource(IceSource):
         error_uncorrected = _calc_error_in_uncorrected_ice()
         iwc_error = utils.l2norm(retrieval_uncertainty, random_error)
         iwc_error[ice_classification.uncorrected_ice] = utils.l2norm(
-            retrieval_uncertainty, error_uncorrected
+            retrieval_uncertainty,
+            error_uncorrected,
         )
         iwc_error[
             (~ice_classification.is_ice | ice_classification.ice_above_rain)
@@ -104,7 +111,7 @@ def _add_iwc_error_comment(attributes: dict, lwp_prior, uncertainty: float) -> d
         "present beneath the ice but no microwave radiometer data were available to\n"
         "correct for the associated attenuation, the error also includes a\n"
         f"contribution equivalent to approximately {lwp_prior} g m-2 of liquid water\n"
-        "path being uncorrected for."
+        "path being uncorrected for.",
     )
     return attributes
 
@@ -139,7 +146,7 @@ def _add_iwc_comment(attributes: dict, iwc: IwcSource) -> dict:
         "and liquid cloud occurred below the ice, the retrieval was still performed\n"
         "but its reliability is questionable due to the uncorrected liquid water\n"
         "attenuation. This is indicated by a value of 2 in the iwc_retrieval_status\n"
-        "variable, and an increase in the value of the iwc_error variable."
+        "variable, and an increase in the value of the iwc_error variable.",
     )
     return attributes
 
@@ -183,7 +190,7 @@ DEFINITIONS = {
         "Value 7: Drizzle or rain that would have been classified as ice if the\n"
         "         wet-bulb temperature were less than 0degC: may be ice if\n"
         "         temperature is in error."
-    )
+    ),
 }
 
 IWC_ATTRIBUTES = {

cloudnetpy/products/lwc.py

@@ -13,7 +13,9 @@ from cloudnetpy.products.product_tools import CategorizeBits, get_is_rain
 
 
 def generate_lwc(
-    categorize_file: str, output_file: str, uuid: str | None = None
+    categorize_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     """Generates Cloudnet liquid water content product.
 
@@ -23,18 +25,22 @@ def generate_lwc(
     content of observed liquid clouds. The results are written in a netCDF file.
 
     Args:
+    ----
         categorize_file: Categorize file name.
         output_file: Output file name.
         uuid: Set specific UUID for the file.
 
     Returns:
+    -------
         str: UUID of the generated file.
 
     Examples:
+    --------
         >>> from cloudnetpy.products import generate_lwc
         >>> generate_lwc('categorize.nc', 'lwc.nc')
 
     References:
+    ----------
         Illingworth, A.J., R.J. Hogan, E. O'Connor, D. Bouniol, M.E. Brooks,
         J. Delanoé, D.P. Donovan, J.D. Eastment, N. Gaussiat, J.W. Goddard,
         M. Haeffelin, H.K. Baltink, O.A. Krasnov, J. Pelon, J. Piriou, A. Protat,
@@ -51,7 +57,7 @@ def generate_lwc(
         date = lwc_source.get_date()
         attributes = output.add_time_attribute(LWC_ATTRIBUTES, date)
         output.update_attributes(lwc_source.data, attributes)
-        uuid = output.save_product_file(
+        return output.save_product_file(
             "lwc",
             lwc_source,
             output_file,
@@ -61,7 +67,6 @@ def generate_lwc(
                 "lwp_error",
             ),
         )
-    return uuid
 
 
 class LwcSource(DataSource):
@@ -71,9 +76,11 @@ class LwcSource(DataSource):
     structures and methods for holding the results.
 
     Args:
+    ----
         categorize_file: Categorize file name.
 
     Attributes:
+    ----------
         lwp (ndarray): 1D liquid water path.
         lwp_error (ndarray): 1D error of liquid water path.
         is_rain (ndarray): 1D array denoting presence of rain.
@@ -95,7 +102,10 @@ class LwcSource(DataSource):
         self.categorize_bits = CategorizeBits(categorize_file)
 
     def append_results(
-        self, lwc: np.ndarray, status: np.ndarray, error: np.ndarray
+        self,
+        lwc: np.ndarray,
+        status: np.ndarray,
+        error: np.ndarray,
     ) -> None:
         self.append_data(lwc, "lwc", units="kg m-3")
         self.append_data(status, "lwc_retrieval_status")
@@ -112,9 +122,11 @@ class Lwc:
     """Class handling the actual LWC calculations.
 
     Args:
+    ----
         lwc_source: The :class:`LwcSource` instance.
 
     Attributes:
+    ----------
         lwc_source (LwcSource): The :class:`LwcSource` instance.
         dheight (float): Median difference in height vector.
         is_liquid (ndarray): 2D array denoting liquid.
@@ -138,7 +150,8 @@ class Lwc:
     def _init_lwc_adiabatic(self) -> np.ndarray:
         """Returns theoretical adiabatic lwc in liquid clouds (kg/m3)."""
         lwc_dz = atmos.fill_clouds_with_lwc_dz(
-            self.lwc_source.atmosphere, self.is_liquid
+            self.lwc_source.atmosphere,
+            self.is_liquid,
         )
         return atmos.calc_adiabatic_lwc(lwc_dz, self.dheight)
 
@@ -148,7 +161,8 @@ class Lwc:
         Calculates LWC for ALL profiles (rain, lwp > theoretical, etc.),
         """
         lwc_scaled = atmos.distribute_lwp_to_liquid_clouds(
-            self.lwc_adiabatic, self.lwc_source.lwp
+            self.lwc_adiabatic,
+            self.lwc_source.lwp,
         )
         return lwc_scaled / self.dheight
 
@@ -161,10 +175,12 @@ class CloudAdjustor:
     """Adjusts clouds (where possible) so that theoretical and measured LWP agree.
 
     Args:
+    ----
         lwc_source: The :class:`LwcSource` instance.
         lwc:  The :class:`Lwc` instance.
 
     Attributes:
+    ----------
         lwc_source (LwcSource): The :class:`LwcSource` instance.
         lwc (ndarray): Liquid water content data.
         is_liquid (ndarray): 2D array denoting liquid.
@@ -196,7 +212,8 @@ class CloudAdjustor:
 
     def _adjust_cloud_tops(self, adjustable_clouds: np.ndarray) -> None:
         """Adjusts cloud top index so that measured lwc corresponds to theoretical
-        value."""
+        value.
+        """
         for time_index in np.unique(np.where(adjustable_clouds)[0]):
             base_index = np.where(adjustable_clouds[time_index, :])[0][0]
             self._update_status(time_index)
@@ -234,8 +251,7 @@ class CloudAdjustor:
         detection_type[~top_clouds] = 0
         lidar_only_clouds = self._find_lidar_only_clouds(detection_type)
         top_clouds[~lidar_only_clouds, :] = 0
-        top_clouds = self._remove_good_profiles(top_clouds)
-        return top_clouds
+        return self._remove_good_profiles(top_clouds)
 
     def _find_topmost_clouds(self) -> np.ndarray:
         top_clouds = np.copy(self.is_liquid)
@@ -256,9 +272,11 @@ class CloudAdjustor:
         """Finds top clouds that contain only lidar-detected pixels.
 
         Args:
+        ----
             detection: Array of integers where 1=lidar, 2=radar, 3=both.
 
         Returns:
+        -------
             Boolean array containing top-clouds that are detected only by lidar.
 
         """
@@ -295,10 +313,12 @@ class LwcError:
     """Calculates liquid water content error.
 
     Args:
+    ----
         lwc_source: The :class:`LwcSource` instance.
         lwc: The :class:`Lwc` instance.
 
     Attributes:
+    ----------
         lwc_source (LwcSource): The :class:`LwcSource` instance.
         lwc (ndarray): Liquid water content data.
         error (ndarray): 2D array storing lwc_error.
@@ -315,7 +335,8 @@ class LwcError:
         lwc_relative_error = self._calc_lwc_relative_error()
         lwp_relative_error = self._calc_lwp_relative_error()
         combined_error = self._calc_combined_error(
-            lwc_relative_error, lwp_relative_error
+            lwc_relative_error,
+            lwp_relative_error,
         )
         return self._fill_error_array(combined_error)
 
@@ -325,7 +346,8 @@ class LwcError:
         return self._limit_error(error, 5)
 
     def _calc_lwc_gradient(self) -> np.ndarray:
-        assert isinstance(self.lwc, ma.MaskedArray)
+        if not isinstance(self.lwc, ma.MaskedArray):
+            self.lwc = ma.masked_array(self.lwc)
         gradient_elements = np.gradient(self.lwc.filled(0))
         return utils.l2norm(*gradient_elements)
 
@@ -424,7 +446,7 @@ DEFINITIONS = {
         "         attenuated."
         "Value 6: Rain present: cloud extent is difficult to ascertain and liquid\n"
         "         water path also uncertain."
-    )
+    ),
 }
 
 

cloudnetpy/products/mwr_multi.py

@@ -11,7 +11,9 @@ from cloudnetpy.products import product_tools
 
 
 def generate_mwr_multi(
-    mwr_l1c_file: str, output_file: str, uuid: str | None = None
+    mwr_l1c_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     file_uuid = uuid if uuid is not None else utils.get_uuid()
 
@@ -28,6 +30,7 @@ def generate_mwr_multi(
         for prod, file in zip(
             ("2P02", "2P03", "2P04", "2P07", "2P08"),
             (temp_file, abs_hum_file, rel_hum_file, t_pot_file, eq_temp_file),
+            strict=True,
         ):
             try:
                 lev2_to_nc(

cloudnetpy/products/mwr_single.py

@@ -10,7 +10,9 @@ from cloudnetpy.products import product_tools
 
 
 def generate_mwr_single(
-    mwr_l1c_file: str, output_file: str, uuid: str | None = None
+    mwr_l1c_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     file_uuid = uuid if uuid is not None else utils.get_uuid()
 
@@ -26,6 +28,7 @@ def generate_mwr_single(
         for prod, file in zip(
             ("2I01", "2I02", "2P01", "2P03"),
             (lwp_file, iwv_file, t_prof_file, abs_hum_file),
+            strict=True,
         ):
             lev2_to_nc(prod, mwr_l1c_file, file.name, coeff_files=coeffs)