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

cloudnetpy/categorize/containers.py

@@ -24,10 +24,12 @@ class ClassData:
     """Container for observations that are used in the classification.
 
     Args:
+    ----
         data: Containing :class:`Radar`, :class:`Lidar`, :class:`Model`
             and :class:`Mwr` instances.
 
     Attributes:
+    ----------
         z (ndarray): 2D radar echo.
         ldr (ndarray): 2D linear depolarization ratio.
         v (ndarray): 2D radar velocity.
@@ -52,13 +54,13 @@ class ClassData:
         self.v = data["radar"].data["v"][:]
         self.v_sigma = data["radar"].data["v_sigma"][:]
         for key in ("width", "ldr", "sldr"):
-            if key in data["radar"].data.keys():
+            if key in data["radar"].data:
                 setattr(self, key, data["radar"].data[key][:])
         self.time = data["radar"].time
         self.height = data["radar"].height
-        self.radar_type = data["radar"].type
+        self.radar_type = data["radar"].source_type
         self.tw = data["model"].data["Tw"][:]
-        self.model_type = data["model"].type
+        self.model_type = data["model"].source_type
         self.beta = data["lidar"].data["beta"][:]
         self.lwp = data["mwr"].data["lwp"][:]
         self.is_rain = _find_rain_from_radar_echo(self.z, self.time)
@@ -70,7 +72,9 @@ class ClassData:
 
 
 def _find_rain_from_radar_echo(
-    z: np.ndarray, time: np.ndarray, time_buffer: int = 5
+    z: np.ndarray,
+    time: np.ndarray,
+    time_buffer: int = 5,
 ) -> np.ndarray:
     """Find profiles affected by rain.
 
@@ -80,17 +84,22 @@ def _find_rain_from_radar_echo(
     detections as raining.
 
     Args:
+    ----
         z: Radar echo.
         time: Time vector.
         time_buffer: Time in minutes.
 
     Returns:
+    -------
         1D Boolean array denoting profiles with rain.
 
     """
-    is_rain = ma.array(z[:, 3] > 0, dtype=bool).filled(False)
+    filled = False
+    is_rain = ma.array(z[:, 3] > 0, dtype=bool).filled(filled)
     is_rain = skimage.morphology.remove_small_objects(
-        is_rain, 2, connectivity=1
+        is_rain,
+        2,
+        connectivity=1,
     )  # Filter hot pixels
     n_profiles = len(time)
     n_steps = utils.n_elements(time, time_buffer, "time")
@@ -122,16 +131,19 @@ def _find_clutter(
     """Estimates clutter from doppler velocity.
 
     Args:
+    ----
         n_gates: Number of range gates from the ground where clutter is expected
             to be found. Default is 10.
         v_lim: Velocity threshold. Smaller values are classified as clutter.
             Default is 0.05 (m/s).
 
     Returns:
+    -------
         2-D boolean array denoting pixels contaminated by clutter.
 
     """
     is_clutter = np.zeros(v.shape, dtype=bool)
-    tiny_velocity = (np.abs(v[:, :n_gates]) < v_lim).filled(False)
+    filled = False
+    tiny_velocity = (np.abs(v[:, :n_gates]) < v_lim).filled(filled)
     is_clutter[:, :n_gates] = tiny_velocity * utils.transpose(~is_rain)
     return is_clutter

cloudnetpy/categorize/droplet.py

@@ -1,4 +1,4 @@
-""" This module has functions for liquid layer detection.
+"""This module has functions for liquid layer detection.
 """
 import numpy as np
 import scipy.signal
@@ -18,6 +18,7 @@ def correct_liquid_top(
     """Corrects lidar detected liquid cloud top using radar data.
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
         is_liquid: 2-D boolean array denoting liquid clouds from lidar data.
         is_freezing: 2-D boolean array of sub-zero temperature, derived from the model
@@ -25,16 +26,18 @@ def correct_liquid_top(
         limit: The maximum correction distance (m) above liquid cloud top.
 
     Returns:
+    -------
         Corrected liquid cloud array.
 
     References:
+    ----------
         Hogan R. and O'Connor E., 2004, https://bit.ly/2Yjz9DZ.
 
     """
     is_liquid_corrected = np.copy(is_liquid)
     liquid_tops = cloudnetpy.categorize.atmos.find_cloud_tops(is_liquid)
     top_above = utils.n_elements(obs.height, limit)
-    for prof, top in zip(*np.where(liquid_tops)):
+    for prof, top in zip(*np.where(liquid_tops), strict=True):
         ind = _find_ind_above_top(is_freezing[prof, top:], top_above)
         rad = obs.z[prof, top : top + ind + 1]
         if not (rad.mask.all() or ~rad.mask.any()):
@@ -61,6 +64,7 @@ def find_liquid(
     """Estimate liquid layers from SNR-screened attenuated backscatter.
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
         peak_amp: Minimum value of peak. Default is 1e-6.
         max_width: Maximum width of peak. Default is 300 (m).
@@ -72,15 +76,17 @@ def find_liquid(
         min_alt: Minimum altitude of the peak from the ground. Default is 100 (m).
 
     Returns:
+    -------
         2-D boolean array denoting liquid layers.
 
     References:
+    ----------
         The method is based on Tuononen, M. et.al, 2019,
         https://acp.copernicus.org/articles/19/1985/2019/.
 
     """
 
-    def _is_proper_peak():
+    def _is_proper_peak() -> bool:
         conditions = (
             npoints >= min_points,
             peak_width < max_width,
@@ -97,13 +103,12 @@ def find_liquid(
     is_liquid = np.zeros(beta.shape, dtype=bool)
     base_below_peak = utils.n_elements(height, 200)
     top_above_peak = utils.n_elements(height, 150)
-    difference = np.diff(beta, axis=1)
-    assert isinstance(difference, ma.MaskedArray)
+    difference = ma.array(np.diff(beta, axis=1))
     beta_diff = difference.filled(0)
     beta = beta.filled(0)
     peak_indices = _find_strong_peaks(beta, peak_amp)
 
-    for n, peak in zip(*peak_indices):
+    for n, peak in zip(*peak_indices, strict=True):
         lprof = beta[n, :]
         dprof = beta_diff[n, :]
         try:
@@ -129,6 +134,7 @@ def ind_base(dprof: np.ndarray, ind_peak: int, dist: int, lim: float) -> int:
     below the peak exceed a threshold value.
 
     Args:
+    ----
         dprof: 1-D array of 1st discrete difference. Masked values should
             be 0, e.g. dprof = np.diff(masked_prof).filled(0)
         ind_peak: Index of (possibly local) peak in the original profile.
@@ -143,13 +149,16 @@ def ind_base(dprof: np.ndarray, ind_peak: int, dist: int, lim: float) -> int:
             in the profile.
 
     Returns:
+    -------
         Base index of the peak.
 
     Raises:
+    ------
         IndexError: Can't find proper base index (probably too many masked
             values in the profile).
 
     Examples:
+    --------
         Consider a profile
 
         >>> x = np.array([0, 0.5, 1, -99, 4, 8, 5])
@@ -177,7 +186,8 @@ def ind_base(dprof: np.ndarray, ind_peak: int, dist: int, lim: float) -> int:
         >>> ind_base(dx, 5, 4, 10)
             1
 
-    See also:
+    See Also:
+    --------
         droplet.ind_top()
 
     """
@@ -194,6 +204,7 @@ def ind_top(dprof: np.ndarray, ind_peak: int, nprof: int, dist: int, lim: float)
     above the peak exceed a threshold value.
 
     Args:
+    ----
         dprof: 1-D array of 1st discrete difference. Masked values should be 0, e.g.
             dprof = np.diff(masked_prof).filled(0)
         nprof: Length of the profile. Top index can't be higher than this.
@@ -207,13 +218,16 @@ def ind_top(dprof: np.ndarray, ind_peak: int, nprof: int, dist: int, lim: float)
             likely accept some other point, higher in the profile.
 
     Returns:
+    -------
         Top index of the peak.
 
     Raises:
+    ------
         IndexError: Can not find proper top index (probably too many masked
             values in the profile).
 
-    See also:
+    See Also:
+    --------
         droplet.ind_base()
 
     """
@@ -227,9 +241,11 @@ def interpolate_lwp(obs: ClassData) -> np.ndarray:
     """Linear interpolation of liquid water path to fill masked values.
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
 
     Returns:
+    -------
         Liquid water path where the masked values are filled by interpolation.
 
     """

cloudnetpy/categorize/falling.py

@@ -8,7 +8,9 @@ from cloudnetpy.constants import T0
 
 
 def find_falling_hydrometeors(
-    obs: ClassData, is_liquid: np.ndarray, is_insects: np.ndarray
+    obs: ClassData,
+    is_liquid: np.ndarray,
+    is_insects: np.ndarray,
 ) -> np.ndarray:
     """Finds falling hydrometeors.
 
@@ -19,21 +21,25 @@ def find_falling_hydrometeors(
     temperatures.
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
         is_liquid: 2-D boolean array of liquid droplets.
         is_insects: 2-D boolean array of insects.
 
     Returns:
+    -------
         2-D boolean array containing falling hydrometeors.
 
     References:
+    ----------
         Hogan R. and O'Connor E., 2004, https://bit.ly/2Yjz9DZ.
 
     """
-
     falling_from_radar = _find_falling_from_radar(obs, is_insects)
     falling_from_radar_fixed = _fix_liquid_dominated_radar(
-        obs, falling_from_radar, is_liquid
+        obs,
+        falling_from_radar,
+        is_liquid,
     )
     cold_aerosols = _find_cold_aerosols(obs, is_liquid)
     return falling_from_radar_fixed | cold_aerosols
@@ -60,7 +66,7 @@ def _find_cold_aerosols(obs: ClassData, is_liquid: np.ndarray) -> np.ndarray:
     cold_aerosol_min_altitude = 2000
     is_beta = ~obs.beta.mask
     lidar_ice_indices = np.where(
-        (obs.tw.data < cold_aerosol_temperature_limit) & is_beta & ~is_liquid
+        (obs.tw.data < cold_aerosol_temperature_limit) & is_beta & ~is_liquid,
     )
     cold_aerosols[lidar_ice_indices] = True
     low_range_indices = np.where(lidar_range < cold_aerosol_min_altitude)
@@ -85,7 +91,9 @@ def _find_cold_aerosols(obs: ClassData, is_liquid: np.ndarray) -> np.ndarray:
 
 
 def _fix_liquid_dominated_radar(
-    obs: ClassData, falling_from_radar: np.ndarray, is_liquid: np.ndarray
+    obs: ClassData,
+    falling_from_radar: np.ndarray,
+    is_liquid: np.ndarray,
 ) -> np.ndarray:
     """Radar signals inside liquid clouds are NOT ice if Z is
     increasing in height inside the cloud.
@@ -95,10 +103,12 @@ def _fix_liquid_dominated_radar(
     base_indices = np.where(liquid_bases)
     top_indices = np.where(liquid_tops)
 
-    for n, base, _, top in zip(*base_indices, *top_indices):
+    for n, base, _, top in zip(*base_indices, *top_indices, strict=True):
         z_prof = obs.z[n, :]
         if _is_z_missing_above_liquid(z_prof, top) and _is_z_increasing(
-            z_prof, base, top
+            z_prof,
+            base,
+            top,
         ):
             falling_from_radar[n, base : top + 1] = False
 

cloudnetpy/categorize/freezing.py

@@ -20,13 +20,16 @@ def find_freezing_region(obs: ClassData, melting_layer: np.ndarray) -> np.ndarra
     interpolated for all profiles.
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
         melting_layer: 2-D boolean array denoting melting layer.
 
     Returns:
+    -------
         2-D boolean array denoting the sub-zero region.
 
     Notes:
+    -----
         It is not clear how model temperature and melting layer should be
         ideally combined to determine the sub-zero region. This current
         method differs slightly from the original Matlab code and should
@@ -59,7 +62,9 @@ def find_freezing_region(obs: ClassData, melting_layer: np.ndarray) -> np.ndarra
 
 
 def _is_all_freezing(
-    mean_melting_alt: np.ndarray, t0_alt: np.ndarray, height: np.ndarray
+    mean_melting_alt: np.ndarray,
+    t0_alt: np.ndarray,
+    height: np.ndarray,
 ) -> bool:
     no_detected_melting = mean_melting_alt.all() is ma.masked
     all_temperatures_below_freezing = (t0_alt <= height[0]).all()
@@ -67,7 +72,9 @@ def _is_all_freezing(
 
 
 def _find_mean_melting_alt(obs: ClassData, melting_layer: np.ndarray) -> ma.MaskedArray:
-    assert melting_layer.dtype == bool
+    if melting_layer.dtype != bool:
+        msg = "melting_layer data type should be boolean"
+        raise ValueError(msg)
     alt_array = np.tile(obs.height, (len(obs.time), 1))
     melting_alts = ma.array(alt_array, mask=~melting_layer)
     return ma.median(melting_alts, axis=1)
@@ -77,10 +84,12 @@ def _find_t0_alt(temperature: np.ndarray, height: np.ndarray) -> np.ndarray:
     """Interpolates altitudes where temperature goes below freezing.
 
     Args:
+    ----
         temperature: 2-D temperature (K).
         height: 1-D altitude grid (m).
 
     Returns:
+    -------
         1-D array denoting altitudes where the temperature drops below 0 deg C.
 
     """
@@ -90,8 +99,13 @@ def _find_t0_alt(temperature: np.ndarray, height: np.ndarray) -> np.ndarray:
         if ind == 0:
             alt = np.append(alt, height[0])
         else:
-            x = prof[ind - 1 : ind + 1]
-            y = height[ind - 1 : ind + 1]
-            x, y = zip(*sorted(zip(x, y)))
+            x, y = zip(
+                *sorted(
+                    zip(
+                        prof[ind - 1 : ind + 1], height[ind - 1 : ind + 1], strict=True
+                    ),
+                ),
+                strict=True,
+            )
             alt = np.append(alt, np.interp(T0, x, y))
     return alt

cloudnetpy/categorize/insects.py

@@ -29,6 +29,7 @@ def find_insects(
     above melting layer.
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
         melting_layer: 2D array denoting melting layer.
         liquid_layers: 2D array denoting liquid layers.
@@ -36,12 +37,14 @@ def find_insects(
             Default is 0.8.
 
     Returns:
+    -------
         tuple: 2-element tuple containing
 
         - 2-D boolean flag of insects presence.
         - 2-D probability of pixel containing insects.
 
     Notes:
+    -----
         This insect detection method is novel and needs to be validated.
 
     """
@@ -65,9 +68,9 @@ def _get_probabilities(obs: ClassData) -> dict:
     lwp_interp = droplet.interpolate_lwp(obs)
     fun = utils.array_to_probability
     return {
-        "width": fun(obs.width, 1, 0.3, True) if hasattr(obs, "width") else 1,
-        "z_strong": fun(obs.z, 0, 8, True),
-        "z_weak": fun(obs.z, -20, 8, True),
+        "width": fun(obs.width, 1, 0.3, invert=True) if hasattr(obs, "width") else 1,
+        "z_strong": fun(obs.z, 0, 8, invert=True),
+        "z_weak": fun(obs.z, -20, 8, invert=True),
         "ldr": fun(obs.ldr, -25, 5) if hasattr(obs, "ldr") else None,
         "sldr": fun(obs.sldr, -25, 5) if hasattr(obs, "sldr") else None,
         "temp_loose": fun(obs.tw, 268, 2),
@@ -79,11 +82,11 @@ def _get_probabilities(obs: ClassData) -> dict:
 
 
 def _get_smoothed_v(
-    obs: ClassData, sigma: tuple[float, float] = (5, 5)
+    obs: ClassData,
+    sigma: tuple[float, float] = (5, 5),
 ) -> ma.MaskedArray:
     smoothed_v = gaussian_filter(obs.v, sigma)
-    smoothed_v = ma.masked_where(obs.v.mask, smoothed_v)
-    return smoothed_v
+    return ma.masked_where(obs.v.mask, smoothed_v)
 
 
 def _calc_prob_from_ldr(prob: dict) -> np.ndarray:
@@ -102,12 +105,15 @@ def _calc_prob_from_ldr(prob: dict) -> np.ndarray:
 def _calc_prob_from_all(prob: dict) -> np.ndarray:
     """This can be tried when LDR is not available. To detect insects without LDR
     unambiguously is difficult and might result in many false positives and/or false
-    negatives."""
+    negatives.
+    """
     return prob["z_weak"] * prob["temp_strict"] * prob["width"] * prob["v"]
 
 
 def _adjust_for_radar(
-    obs: ClassData, prob: dict, prob_from_others: np.ndarray
+    obs: ClassData,
+    prob: dict,
+    prob_from_others: np.ndarray,
 ) -> np.ndarray:
     """Adds radar-specific weighting to insect probabilities."""
     if "mira" in obs.radar_type.lower():
@@ -116,7 +122,8 @@ def _adjust_for_radar(
 
 
 def _fill_missing_pixels(
-    prob_from_ldr: np.ndarray, prob_from_others: np.ndarray
+    prob_from_ldr: np.ndarray,
+    prob_from_others: np.ndarray,
 ) -> np.ndarray:
     prob_combined = np.copy(prob_from_ldr)
     no_ldr = np.where(prob_from_ldr == 0)
@@ -124,19 +131,25 @@ def _fill_missing_pixels(
     return prob_combined
 
 
-def _screen_insects(insect_prob, insect_prob_no_ldr, melting_layer, liquid_layers, obs):
-    def _screen_liquid_layers():
+def _screen_insects(
+    insect_prob,
+    insect_prob_no_ldr,
+    melting_layer,
+    liquid_layers,
+    obs,
+) -> np.ndarray:
+    def _screen_liquid_layers() -> None:
         prob[liquid_layers == 1] = 0
 
-    def _screen_above_melting():
+    def _screen_above_melting() -> None:
         above_melting = utils.ffill(melting_layer)
         prob[above_melting == 1] = 0
 
-    def _screen_above_liquid():
+    def _screen_above_liquid() -> None:
         above_liquid = utils.ffill(liquid_layers)
         prob[(above_liquid == 1) & (insect_prob_no_ldr > 0)] = 0
 
-    def _screen_rainy_profiles():
+    def _screen_rainy_profiles() -> None:
         prob[obs.is_rain == 1, :] = 0
 
     prob = np.copy(insect_prob)

cloudnetpy/categorize/lidar.py

@@ -1,5 +1,6 @@
 """Lidar module, containing the :class:`Lidar` class."""
 import logging
+from typing import Literal
 
 import numpy as np
 from numpy import ma
@@ -12,6 +13,7 @@ class Lidar(DataSource):
     """Lidar class, child of DataSource.
 
     Args:
+    ----
         full_path: Cloudnet Level 1 lidar netCDF file.
 
     """
@@ -21,42 +23,46 @@ class Lidar(DataSource):
         self.append_data(self.getvar("beta"), "beta")
         self._add_meta()
 
-    def interpolate_to_grid(self, time_new: np.ndarray, height_new: np.ndarray) -> list:
+    def interpolate_to_grid(
+        self, time_new: np.ndarray, height_new: np.ndarray
+    ) -> list[int]:
         """Interpolate beta using nearest neighbor."""
-        max_height = 100.0  # m
-        max_time = 1.0  # min
+        max_height = 100  # m
+        max_time = 1 / 60  # min -> fraction hour
 
-        # Remove completely masked profiles from the interpolation
+        if self.height is None:
+            msg = "Unable to interpolate lidar: no height information"
+            raise RuntimeError(msg)
+
+        # Interpolate beta to new grid but ignore profiles that are completely masked
         beta = self.data["beta"][:]
-        indices = []
-        for ind, b in enumerate(beta):
-            if not ma.all(b) is ma.masked:
-                indices.append(ind)
-        assert self.height is not None
-        beta_interpolated = interpolate_2d_nearest(
+        indices = [ind for ind, b in enumerate(beta) if ma.all(b) is not ma.masked]
+        beta_interp = interpolate_2d_nearest(
             self.time[indices],
             self.height,
             beta[indices, :],
             time_new,
             height_new,
         )
+        # Mask data points that are too far from the original grid
+        time_gap_ind = _get_gap_ind(self.time[indices], time_new, max_time)
+        height_gap_ind = _get_gap_ind(self.height, height_new, max_height)
+        self._mask_profiles(beta_interp, time_gap_ind, "time")
+        self._mask_profiles(beta_interp, height_gap_ind, "height")
+        self.data["beta"].data = beta_interp
+        return time_gap_ind
 
-        # Filter profiles and range gates having data gap
-        max_time /= 60  # to fraction hour
-        bad_time_indices = _get_bad_indices(self.time[indices], time_new, max_time)
-        bad_height_indices = _get_bad_indices(self.height, height_new, max_height)
-        if bad_time_indices:
-            logging.warning(
-                f"Unable to interpolate lidar for {len(bad_time_indices)} time steps"
-            )
-        beta_interpolated[bad_time_indices, :] = ma.masked
-        if bad_height_indices:
-            logging.warning(
-                f"Unable to interpolate lidar for {len(bad_height_indices)} altitudes"
-            )
-        beta_interpolated[:, bad_height_indices] = ma.masked
-        self.data["beta"].data = beta_interpolated
-        return bad_time_indices
+    @staticmethod
+    def _mask_profiles(
+        data: ma.MaskedArray, ind: list[int], dim: Literal["time", "height"]
+    ) -> None:
+        prefix = f"Unable to interpolate lidar for {len(ind)}"
+        if dim == "time" and ind:
+            logging.warning("%s time steps", prefix)
+            data[ind, :] = ma.masked
+        elif dim == "height" and ind:
+            logging.warning("%s altitudes", prefix)
+            data[:, ind] = ma.masked
 
     def _add_meta(self) -> None:
         self.append_data(float(self.getvar("wavelength")), "lidar_wavelength")
@@ -64,13 +70,9 @@ class Lidar(DataSource):
         self.append_data(3.0, "beta_bias")
 
 
-def _get_bad_indices(
-    original_grid: np.ndarray, new_grid: np.ndarray, threshold: float
-) -> list:
-    indices = []
-    for ind, value in enumerate(new_grid):
-        diffu = np.abs(original_grid - value)
-        distance = diffu[diffu.argmin()]
-        if distance > threshold:
-            indices.append(ind)
-    return indices
+def _get_gap_ind(grid: np.ndarray, new_grid: np.ndarray, threshold: float) -> list[int]:
+    return [
+        ind
+        for ind, value in enumerate(new_grid)
+        if np.min(np.abs(grid - value)) > threshold
+    ]

cloudnetpy/categorize/melting.py

@@ -9,7 +9,7 @@ from cloudnetpy.categorize.containers import ClassData
 from cloudnetpy.constants import T0
 
 
-def find_melting_layer(obs: ClassData, smooth: bool = True) -> np.ndarray:
+def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> np.ndarray:
     """Finds melting layer from model temperature, ldr, and velocity.
 
     Melting layer is detected using linear depolarization ratio, *ldr*,
@@ -32,17 +32,20 @@ def find_melting_layer(obs: ClassData, smooth: bool = True) -> np.ndarray:
     the rest -8..+6.
 
     Notes:
+    -----
         This melting layer detection method is novel and needs to be validated.
         Also note that there might be some detection problems with strong
         updrafts of air. In these cases the absolute values for speed do not
         make sense (rain drops can even move upwards instead of down).
 
     Args:
+    ----
         obs: The :class:`ClassData` instance.
         smooth: If True, apply a small Gaussian smoother to the
             melting layer. Default is True.
 
     Returns:
+    -------
         2-D boolean array denoting the melting layer.
 
     """
@@ -55,8 +58,7 @@ def find_melting_layer(obs: ClassData, smooth: bool = True) -> np.ndarray:
 
     if hasattr(obs, "ldr"):
         # Required for peak detection
-        diffu = np.diff(obs.ldr, axis=1)
-        assert isinstance(diffu, ma.MaskedArray)
+        diffu = ma.array(np.diff(obs.ldr, axis=1))
         ldr_diff = diffu.filled(0)
 
     t_range = _find_model_temperature_range(obs.model_type)
@@ -69,15 +71,22 @@ def find_melting_layer(obs: ClassData, smooth: bool = True) -> np.ndarray:
         v_prof = obs.v[ind, temp_indices]
 
         if ldr_diff is not None:
-            assert hasattr(obs, "ldr")
+            if not hasattr(obs, "ldr"):
+                msg = "ldr_diff is not None but obs.ldr does not exist"
+                raise RuntimeError(msg)
             ldr_prof = obs.ldr[ind, temp_indices]
             ldr_dprof = ldr_diff[ind, temp_indices]
 
         if ma.count(ldr_prof) > 3 or ma.count(v_prof) > 3:
             try:
-                assert ldr_prof is not None and ldr_dprof is not None
+                if ldr_prof is None or ldr_dprof is None:
+                    msg = "ldr_prof or ldr_dprof is None"
+                    raise AssertionError(msg)  # noqa: TRY301
                 indices = _find_melting_layer_from_ldr(
-                    ldr_prof, ldr_dprof, v_prof, z_prof
+                    ldr_prof,
+                    ldr_dprof,
+                    v_prof,
+                    z_prof,
                 )
             except (ValueError, IndexError, AssertionError):
                 height = obs.height[temp_indices]
@@ -114,13 +123,14 @@ def _find_melting_layer_from_ldr(
 
     if all(conditions):
         base = int(np.floor(base + (peak - base) / 2))
-        indices = np.arange(base, top)
-        return indices
+        return np.arange(base, top)
     return None
 
 
 def _find_melting_layer_from_v(
-    v_prof: np.ndarray, width_prof: np.ndarray | None, height: np.ndarray
+    v_prof: np.ndarray,
+    width_prof: np.ndarray | None,
+    height: np.ndarray,
 ) -> np.ndarray | None:
     v = np.copy(v_prof[:-1])
     v_diff = np.diff(v_prof)