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

cloudnetpy/products/classification.py

@@ -10,7 +10,9 @@ from cloudnetpy.products.product_tools import CategorizeBits
 
 
 def generate_classification(
-    categorize_file: str, output_file: str, uuid: str | None = None
+    categorize_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     """Generates Cloudnet classification product.
 
@@ -20,14 +22,17 @@ def generate_classification(
     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_classification
         >>> generate_classification('categorize.nc', 'classification.nc')
 
@@ -42,18 +47,22 @@ def generate_classification(
         product_container.append_data(bases, "cloud_base_height_amsl")
         product_container.append_data(tops, "cloud_top_height_amsl")
         product_container.append_data(
-            bases - product_container.altitude, "cloud_base_height_agl"
+            bases - product_container.altitude,
+            "cloud_base_height_agl",
         )
         product_container.append_data(
-            tops - product_container.altitude, "cloud_top_height_agl"
+            tops - product_container.altitude,
+            "cloud_top_height_agl",
         )
         date = product_container.get_date()
         attributes = output.add_time_attribute(CLASSIFICATION_ATTRIBUTES, date)
         output.update_attributes(product_container.data, attributes)
-        uuid = output.save_product_file(
-            "classification", product_container, output_file, uuid
+        return output.save_product_file(
+            "classification",
+            product_container,
+            output_file,
+            uuid,
         )
-    return uuid
 
 
 def _get_target_classification(
@@ -98,7 +107,8 @@ def _get_detection_status(categorize_bits: CategorizeBits) -> np.ndarray:
 
 
 def _get_cloud_base_and_top_heights(
-    classification: np.ndarray, product_container: DataSource
+    classification: np.ndarray,
+    product_container: DataSource,
 ) -> tuple[np.ndarray, np.ndarray]:
     height = product_container.getvar("height")
     cloud_mask = _find_cloud_mask(classification)
@@ -106,7 +116,9 @@ def _get_cloud_base_and_top_heights(
         return ma.masked_all(cloud_mask.shape[0]), ma.masked_all(cloud_mask.shape[0])
     lowest_bases = atmos.find_lowest_cloud_bases(cloud_mask, height)
     highest_tops = atmos.find_highest_cloud_tops(cloud_mask, height)
-    assert (highest_tops - lowest_bases >= 0).all()
+    if not (highest_tops - lowest_bases >= 0).all():
+        msg = "Cloud base higher than cloud top!"
+        raise ValueError(msg)
     return lowest_bases, highest_tops
 
 

cloudnetpy/products/der.py

@@ -1,7 +1,7 @@
 """Module for creating Cloudnet droplet effective radius
 using the Frisch et al. 2002 method.
 """
-from collections import namedtuple
+from typing import NamedTuple
 
 import numpy as np
 from numpy import ma
@@ -16,7 +16,14 @@ from cloudnetpy.products.product_tools import (
     get_is_rain,
 )
 
-Parameters = namedtuple("Parameters", "ddBZ N dN sigma_x dsigma_x dQ")
+
+class Parameters(NamedTuple):
+    ddBZ: float
+    N: float
+    dN: float
+    sigma_x: float
+    dsigma_x: float
+    dQ: float
 
 
 def generate_der(
@@ -34,6 +41,7 @@ def generate_der(
     liquid water path. 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.
@@ -42,9 +50,11 @@ def generate_der(
         used in Frisch approach.
 
     Returns:
+    -------
         UUID of the generated file.
 
     Examples:
+    --------
         >>> from cloudnetpy.products import generate_der
         >>> generate_der('categorize.nc', 'der.nc')
         >>>
@@ -53,6 +63,7 @@ def generate_der(
         >>> generate_der('categorize.nc', 'der.nc', parameters=params)
 
     References:
+    ----------
         Frisch, S., Shupe, M., Djalalova, I., Feingold, G., & Poellot, M. (2002).
         The Retrieval of Stratus Cloud Droplet Effective Radius with Cloud Radars,
         Journal of Atmospheric and Oceanic Technology, 19(6), 835-842.
@@ -113,9 +124,8 @@ class DerSource(DataSource):
         else:
             self.parameters = parameters
 
-    def append_der(self):
+    def append_der(self) -> None:
         """Estimate liquid droplet effective radius using Frisch et al. 2002."""
-
         params = self.parameters
         rho_l = 1000  # density of liquid water(kg m-3)
 
@@ -139,7 +149,11 @@ class DerSource(DataSource):
         liquid_bases = atmos.find_cloud_bases(is_droplet)
         liquid_tops = atmos.find_cloud_tops(is_droplet)
 
-        for base, top in zip(zip(*np.where(liquid_bases)), zip(*np.where(liquid_tops))):
+        for base, top in zip(
+            zip(*np.where(liquid_bases), strict=True),
+            zip(*np.where(liquid_tops), strict=True),
+            strict=True,
+        ):
             ind_t = base[0]
             idx_layer = np.arange(base[1], top[1] + 1)
             idx_layer = idx_layer[~Z[ind_t, idx_layer].mask]
@@ -159,7 +173,7 @@ class DerSource(DataSource):
             B = params.sigma_x * params.dsigma_x
             C = dZ[ind_t, idx_layer] / (6 * Z[ind_t, idx_layer])
             der_error[ind_t, idx_layer] = der[ind_t, idx_layer] * ma.sqrt(
-                A * A + B * B + C * C
+                A * A + B * B + C * C,
             )
 
             # der scaled formula (6)
@@ -176,7 +190,7 @@ class DerSource(DataSource):
             B = 4 * params.sigma_x * params.dsigma_x
             C = params.dQ / (3 * lwp[ind_t])
             der_scaled_error[ind_t, idx_layer] = der_scaled[ind_t, idx_layer] * ma.sqrt(
-                A * A + B * B + C * C
+                A * A + B * B + C * C,
             )
 
         N_scaled = ma.masked_less_equal(ma.masked_invalid(N_scaled), 0.0) * 1.0e-6
@@ -197,7 +211,8 @@ class DerSource(DataSource):
         self.append_data(der_scaled_error, "der_scaled_error")
 
     def append_retrieval_status(
-        self, droplet_classification: DropletClassification
+        self,
+        droplet_classification: DropletClassification,
     ) -> None:
         """Returns information about the status of der retrieval."""
         is_retrieved = ~self.data["der"][:].mask
@@ -224,7 +239,7 @@ DEFINITIONS = {
         "         of MWR but also the target reflectivity.\n"
         "Value 4: Surrounding ice: Less crucial! Ice crystals in the vicinity of a\n"
         "         droplet pixel may also bias its reflectivity.\n"
-    )
+    ),
 }
 
 
@@ -271,7 +286,7 @@ def _add_der_error_comment(attributes: dict, der_source: DerSource) -> dict:
         comment="This variable is an estimate of the random error in effective\n"
         f"radius assuming an error in Z of ddBZ = {params.ddBZ} in N of\n"
         f"dN = {params.dN} and in the spectral width dsigma_x = {params.dsigma_x}\n"
-        f"and in the LWP Q of {params.dQ} kg m-3."
+        f"and in the LWP Q of {params.dQ} kg m-3.",
     )
     return attributes
 

cloudnetpy/products/drizzle.py

@@ -16,7 +16,9 @@ from cloudnetpy.products.drizzle_tools import (
 
 
 def generate_drizzle(
-    categorize_file: str, output_file: str, uuid: str | None = None
+    categorize_file: str,
+    output_file: str,
+    uuid: str | None = None,
 ) -> str:
     """Generates Cloudnet drizzle product.
 
@@ -24,18 +26,22 @@ def generate_drizzle(
     cloud radar and lidar measurements. 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_drizzle
         >>> generate_drizzle('categorize.nc', 'drizzle.nc')
 
     References:
+    ----------
         O’Connor, E.J., R.J. Hogan, and A.J. Illingworth, 2005:
         Retrieving Stratocumulus Drizzle Parameters Using Doppler Radar and Lidar.
         J. Appl. Meteor., 44, 14–27, https://doi.org/10.1175/JAM-2181.1
@@ -59,18 +65,19 @@ def generate_drizzle(
         date = drizzle_source.get_date()
         attributes = output.add_time_attribute(DRIZZLE_ATTRIBUTES, date)
         output.update_attributes(drizzle_source.data, attributes)
-        uuid = output.save_product_file("drizzle", drizzle_source, output_file, uuid)
-    return uuid
+        return output.save_product_file("drizzle", drizzle_source, output_file, uuid)
 
 
 class DrizzleProducts:
     """Calculates additional quantities from the drizzle properties.
 
     Args:
+    ----
         drizzle_source: The :class:`DrizzleSource` instance.
         drizzle_solver: The :class:`DrizzleSolver` instance.
 
     Attributes:
+    ----------
         derived_products (dict): Dictionary containing derived drizzle products:
             'drizzle_N', 'drizzle_lwc', 'drizzle_lwf', 'v_drizzle', 'v_air'.
 
@@ -82,7 +89,7 @@ class DrizzleProducts:
         self._ind_drizzle, self._ind_lut = self._find_indices()
         self.derived_products = self._calc_derived_products()
 
-    def _find_indices(self):
+    def _find_indices(self) -> tuple:
         drizzle_ind = np.where(self._params["Do"])
         ind_mu = np.searchsorted(self._data.mie["mu"], self._params["mu"][drizzle_ind])
         ind_dia = np.searchsorted(self._data.mie["Do"], self._params["Do"][drizzle_ind])
@@ -91,7 +98,7 @@ class DrizzleProducts:
         ind_dia[ind_dia >= n_dia] = n_dia - 1
         return drizzle_ind, (ind_mu, ind_dia)
 
-    def _calc_derived_products(self):
+    def _calc_derived_products(self) -> dict:
         density = self._calc_density()
         lwc = self._calc_lwc()
         lwf = self._calc_lwf(lwc)
@@ -105,23 +112,23 @@ class DrizzleProducts:
             "v_air": v_air,
         }
 
-    def _calc_density(self):
+    def _calc_density(self) -> np.ndarray:
         """Calculates drizzle number density (m-3)."""
         a = self._data.z * 3.67**6
         b = self._params["Do"] ** 6
         return np.divide(a, b, out=np.zeros_like(a), where=b != 0)
 
-    def _calc_lwc(self):
+    def _calc_lwc(self) -> np.ndarray:
         """Calculates drizzle liquid water content (kg m-3)"""
         rho_water = 1000
-        dia, mu, s = [self._params.get(key) for key in ("Do", "mu", "S")]
-        assert isinstance(mu, np.ndarray)
-        assert isinstance(s, np.ndarray)
-        assert isinstance(dia, np.ndarray)
+        dia, mu, s = (self._params.get(key) for key in ("Do", "mu", "S"))
+        dia = ma.array(dia)
+        mu = ma.array(mu)
+        s = ma.array(s)
         gamma_ratio = gamma(4 + mu) / gamma(3 + mu) / (3.67 + mu)
         return rho_water / 3 * self._data.beta * s * dia * gamma_ratio
 
-    def _calc_lwf(self, lwc_in):
+    def _calc_lwf(self, lwc_in) -> np.ndarray:
         """Calculates drizzle liquid water flux."""
         flux = ma.copy(lwc_in)
         flux[self._ind_drizzle] *= (
@@ -130,13 +137,13 @@ class DrizzleProducts:
         )
         return flux
 
-    def _calc_fall_velocity(self):
+    def _calc_fall_velocity(self) -> np.ndarray:
         """Calculates drizzle droplet fall velocity (m s-1)."""
         velocity = np.zeros_like(self._params["Do"])
         velocity[self._ind_drizzle] = -self._data.mie["v"][self._ind_lut]
         return velocity
 
-    def _calc_v_air(self, droplet_velocity):
+    def _calc_v_air(self, droplet_velocity) -> np.ndarray:
         """Calculates vertical air velocity."""
         velocity = -np.copy(droplet_velocity)
         velocity[self._ind_drizzle] += self._data.v[self._ind_drizzle]
@@ -147,9 +154,11 @@ class RetrievalStatus:
     """Estimates the status of drizzle retrievals.
 
     Args:
+    ----
         drizzle_class: The :class:`DrizzleClassification` instance.
 
     Attributes:
+    ----------
         drizzle_class: The :class:`DrizzleClassification` instance.
         retrieval_status (ndarray): 2D array containing drizzle retrieval
             status information.
@@ -160,37 +169,39 @@ class RetrievalStatus:
         self.retrieval_status: np.ndarray = np.array([])
         self._get_retrieval_status()
 
-    def _get_retrieval_status(self):
+    def _get_retrieval_status(self) -> None:
         self.retrieval_status = np.copy(self.drizzle_class.drizzle).astype(int)
         self._find_retrieval_below_melting()
         self.retrieval_status[self.drizzle_class.would_be_drizzle == 1] = 3
         self._find_retrieval_in_warm_liquid()
         self.retrieval_status[self.drizzle_class.is_rain == 1, :] = 5
 
-    def _find_retrieval_below_melting(self):
+    def _find_retrieval_below_melting(self) -> None:
         cold_rain = utils.transpose(self.drizzle_class.cold_rain)
         below_melting = cold_rain * self.drizzle_class.drizzle
         self.retrieval_status[below_melting == 1] = 2
 
-    def _find_retrieval_in_warm_liquid(self):
+    def _find_retrieval_in_warm_liquid(self) -> None:
         in_warm_liquid = (self.retrieval_status == 0) * self.drizzle_class.warm_liquid
         self.retrieval_status[in_warm_liquid == 1] = 4
 
 
-def _screen_rain(results: dict, classification: DrizzleClassification):
+def _screen_rain(results: dict, classification: DrizzleClassification) -> dict:
     """Removes rainy profiles from drizzle variables.."""
-    for key in results.keys():
+    for key in results:
         if not utils.isscalar(results[key]):
             results[key][classification.is_rain, :] = 0
     return results
 
 
-def _append_data(drizzle_data: DrizzleSource, results: dict):
+def _append_data(drizzle_data: DrizzleSource, results: dict) -> None:
     """Save retrieved fields to the drizzle_data object."""
     for key, value in results.items():
         if key != "drizzle_retrieval_status":
-            value = ma.masked_where(value == 0, value)
-        drizzle_data.append_data(value, key)
+            arr = ma.masked_where(value == 0, value)
+        else:
+            arr = value
+        drizzle_data.append_data(arr, key)
 
 
 DRIZZLE_ATTRIBUTES = {
@@ -200,7 +211,8 @@ DRIZZLE_ATTRIBUTES = {
         ancillary_variables="drizzle_N_error drizzle_N_bias",
     ),
     "drizzle_N_error": MetaData(
-        long_name="Random error in drizzle number concentration", units="dB"
+        long_name="Random error in drizzle number concentration",
+        units="dB",
     ),
     "drizzle_N_bias": MetaData(
         long_name="Possible bias in drizzle number concentration",
@@ -240,7 +252,8 @@ DRIZZLE_ATTRIBUTES = {
         comment="Positive values are towards the ground.",
     ),
     "v_drizzle_error": MetaData(
-        long_name="Random error in drizzle droplet fall velocity", units="dB"
+        long_name="Random error in drizzle droplet fall velocity",
+        units="dB",
     ),
     "v_drizzle_bias": MetaData(
         long_name="Possible bias in drizzle droplet fall velocity",
@@ -254,7 +267,8 @@ DRIZZLE_ATTRIBUTES = {
         standard_name="upward_air_velocity",
     ),
     "v_air_error": MetaData(
-        long_name="Random error in vertical air velocity", units="dB"
+        long_name="Random error in vertical air velocity",
+        units="dB",
     ),
     "Do": MetaData(
         long_name="Drizzle median diameter",
@@ -289,6 +303,7 @@ DRIZZLE_ATTRIBUTES = {
     ),
     "beta_corr": MetaData(long_name="Lidar backscatter correction factor", units="1"),
     "drizzle_retrieval_status": MetaData(
-        long_name="Drizzle parameter retrieval status", units="1"
+        long_name="Drizzle parameter retrieval status",
+        units="1",
     ),
 }

cloudnetpy/products/drizzle_error.py

@@ -9,15 +9,18 @@ MU_ERROR_SMALL = 0.25
 
 
 def get_drizzle_error(
-    categorize: DrizzleSource, drizzle_parameters: DrizzleSolver
+    categorize: DrizzleSource,
+    drizzle_parameters: DrizzleSolver,
 ) -> dict:
     """Estimates error and bias for drizzle classification.
 
     Args:
+    ----
         categorize: The :class:`DrizzleSource` instance.
         drizzle_parameters: The :class:`DrizzleSolver` instance.
 
     Returns:
+    -------
         dict: Dictionary containing information of estimated error and bias for drizzle
 
     """
@@ -29,8 +32,7 @@ def get_drizzle_error(
         z_error = np.full(categorize.z.shape, z_error)
         error_input = z_error, bias_error
     bias_input = _read_input_uncertainty(categorize, "bias")
-    errors = _calc_errors(drizzle_indices, error_input, bias_input)
-    return errors
+    return _calc_errors(drizzle_indices, error_input, bias_input)
 
 
 def _get_drizzle_indices(diameter: np.ndarray) -> dict:
@@ -100,7 +102,9 @@ def _calc_parameter_biases(bias_input: tuple) -> dict:
 
 
 def _add_supplementary_errors(
-    results: dict, drizzle_indices: dict, error_input: tuple
+    results: dict,
+    drizzle_indices: dict,
+    error_input: tuple,
 ) -> dict:
     def _calc_n_error() -> ma.MaskedArray:
         z_error = error_input[0]
@@ -139,6 +143,7 @@ def _calc_error(
     scale: float,
     weights: tuple,
     error_input: tuple,
+    *,
     add_mu: bool = False,
     add_mu_small: bool = False,
 ) -> ma.MaskedArray:
@@ -156,7 +161,7 @@ def _stack_errors(
     error_small=None,
     error_tiny=None,
 ) -> ma.MaskedArray:
-    def _add_error_component(source: np.ndarray, ind: tuple):
+    def _add_error_component(source: np.ndarray, ind: tuple) -> None:
         error[ind] = source[ind]
 
     error = ma.zeros(error_in.shape)