cloudnetpy 1.96.2__tar.gz → 1.96.4__tar.gz

{cloudnetpy-1.96.2/cloudnetpy.egg-info → cloudnetpy-1.96.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.96.2
+Version: 1.96.4
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/categorize/insects.py

@@ -58,7 +58,9 @@ def _insect_probability(obs: ClassData) -> tuple[npt.NDArray, npt.NDArray]:
     prob_from_ldr = _calc_prob_from_ldr(prob)
     prob_from_others = _calc_prob_from_all(prob)
     prob_from_others = _adjust_for_radar(obs, prob, prob_from_others)
-    prob_combined = _fill_missing_pixels(prob_from_ldr, prob_from_others)
+    prob_from_others = _adjust_for_lidar(obs, prob_from_others)
+    is_ldr = ~ma.getmaskarray(obs.ldr) if hasattr(obs, "ldr") else None
+    prob_combined = _fill_missing_pixels(prob_from_ldr, prob_from_others, is_ldr)
     return prob_combined, prob_from_others
 
 
@@ -147,11 +149,31 @@ def _adjust_for_radar(
     return prob_from_others
 
 
+def _adjust_for_lidar(
+    obs: ClassData,
+    prob_from_others: npt.NDArray,
+    weight: float = 0.8,
+) -> npt.NDArray:
+    """Reduces probability above the lidar signal, where liquid may be hidden."""
+    is_beta = ~ma.getmaskarray(obs.beta)
+    n_gates = is_beta.shape[1]
+    top = n_gates - np.argmax(is_beta[:, ::-1], axis=1)
+    top[~is_beta.any(axis=1)] = 0
+    above_lidar = np.arange(n_gates)[np.newaxis, :] >= top[:, np.newaxis]
+    prob_from_others[above_lidar] *= weight
+    return prob_from_others
+
+
 def _fill_missing_pixels(
     prob_from_ldr: npt.NDArray,
     prob_from_others: npt.NDArray,
+    is_ldr: npt.NDArray | None = None,
 ) -> npt.NDArray:
-    return np.maximum(prob_from_ldr, prob_from_others)
+    """Combines probabilities trusting measured ldr over other parameters."""
+    prob = np.maximum(prob_from_ldr, prob_from_others)
+    if is_ldr is not None:
+        prob[is_ldr] = prob_from_ldr[is_ldr]
+    return prob
 
 
 def _screen_insects(

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/categorize/melting.py

@@ -10,6 +10,10 @@ from cloudnetpy import utils
 from cloudnetpy.categorize import droplet
 from cloudnetpy.categorize.containers import ClassData
 
+MIN_LAPSE_RATE = 0.004  # K m-1
+MIN_LDR_COVERAGE = 0.5
+T0_TOLERANCE = 1  # K
+
 
 def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> npt.NDArray:
     """Finds melting layer from model temperature, ldr, and velocity.
@@ -27,11 +31,15 @@ def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> npt.NDArray:
     The peak in *ldr* is the primary parameter we analyze. If
     *ldr* has a proper peak, and *v* < -1 m/s in the base, melting layer
     has been found. If *ldr* is missing we only analyze the behaviour
-    of *v*, which is always present, to detect the melting layer.
+    of *v*, which is always present, to detect the melting layer. If *ldr*
+    covers the profile but shows no peak, there is no melting layer.
 
     Model temperature is used to limit the melting layer search to a certain
     temperature range around 0 C. For ECMWF the range is -4..+3, and for
-    the rest -8..+6.
+    the rest -8..+6. Model temperature must also reach -1 C in the profile,
+    and the search is limited in altitude above the highest 0 C level,
+    because in temperature inversions the temperature range alone may
+    span several kilometers.
 
     Notes:
         This melting layer detection method is novel and needs to be validated.
@@ -63,7 +71,7 @@ def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> npt.NDArray:
     t_range = _find_model_temperature_range(obs.model_type)
 
     for ind, t_prof in enumerate(obs.tw):
-        temp_indices = _get_temp_indices(t_prof, t_range)
+        temp_indices = _get_temp_indices(t_prof, t_range, obs.height)
         if len(temp_indices) <= 1:
             continue
         z_prof = obs.z[ind, temp_indices]
@@ -90,6 +98,8 @@ def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> npt.NDArray:
                     z_prof,
                 )
             except (ValueError, IndexError, AssertionError):
+                if _has_ldr_coverage(ldr_prof, v_prof):
+                    continue
                 height = obs.height[temp_indices]
                 if hasattr(obs, "width"):
                     width_prof = obs.width[ind, temp_indices]
@@ -104,6 +114,16 @@ def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> npt.NDArray:
     return melting_layer
 
 
+def _has_ldr_coverage(ldr_prof: npt.NDArray | None, v_prof: npt.NDArray) -> bool:
+    """Checks if ldr covers enough of the profile to rule out melting layer."""
+    if ldr_prof is None:
+        return False
+    is_v = ~ma.getmaskarray(v_prof)
+    is_ldr = ~ma.getmaskarray(ldr_prof)
+    n_ldr = np.count_nonzero(is_ldr & is_v)
+    return bool(n_ldr >= MIN_LDR_COVERAGE * np.count_nonzero(is_v))
+
+
 def _find_melting_layer_from_ldr(
     ldr_prof: npt.NDArray,
     ldr_dprof: npt.NDArray,
@@ -166,12 +186,28 @@ def _basetop(dprof: npt.NDArray, pind: int) -> tuple[int, int]:
     return base, top
 
 
-def _get_temp_indices(t_prof: npt.NDArray, t_range: tuple) -> npt.NDArray:
+def _get_temp_indices(
+    t_prof: npt.NDArray, t_range: tuple, height: npt.NDArray | None = None
+) -> npt.NDArray:
     """Finds indices of temperature profile covering the given range."""
-    ind = np.where((t_prof > min(t_range) + T0) & (t_prof < max(t_range) + T0))[0]
+    in_range = (t_prof > min(t_range) + T0) & (t_prof < max(t_range) + T0)
+    if height is not None:
+        in_range &= height <= _find_max_height(t_prof, t_range, height)
+    ind = np.where(in_range)[0]
     return np.array([]) if len(ind) == 0 else np.arange(np.min(ind), np.max(ind) + 1)
 
 
+def _find_max_height(t_prof: npt.NDArray, t_range: tuple, height: npt.NDArray) -> float:
+    """Finds maximum melting layer height assuming realistic lapse rate."""
+    warm = np.where(t_prof >= T0)[0]
+    if len(warm) == 0:
+        # Model may be slightly too cold when melting layer is near the ground
+        warm = np.where(t_prof >= T0 - T0_TOLERANCE)[0]
+    if len(warm) == 0:
+        return -np.inf
+    return height[warm[-1]] - min(t_range) / MIN_LAPSE_RATE
+
+
 def _find_model_temperature_range(model_type: str) -> tuple[float, float]:
     """Returns temperature range around 0C for given model type."""
     if model_type == "gdas1":

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/cli.py

@@ -928,9 +928,11 @@ def main() -> None:
     )
     parser.add_argument(
         "--show",
-        help="Show plotted image",
+        nargs="?",
+        const=True,
         default=False,
-        action=argparse.BooleanOptionalAction,
+        metavar="VARIABLES",
+        help="Show plotted image, optionally only given variables (comma-separated)",
     )
     parser.add_argument(
         "--dl",
@@ -980,6 +982,10 @@ def main() -> None:
         default=None,
     )
     args = parser.parse_args()
+    if isinstance(args.show, str):
+        if args.variables is None:
+            args.variables = args.show
+        args.show = True
 
     logger = logging.getLogger()
     logger.setLevel(logging.INFO)

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/disdronator/parsivel.py

@@ -475,6 +475,21 @@ def _read_leipzig(filename: str | PathLike) -> ParsivelOutput:
         return time, data
 
 
+def _read_cloudlab(filename: str | PathLike) -> ParsivelOutput:
+    # Data acquired with ASDO and converted to daily netCDF files. The netCDF
+    # files are similar to parsivel2nc files but without "number_concentration"
+    # and "fall_velocity" variables.
+    with netCDF4.Dataset(filename) as nc:
+        time = cftime.num2pydate(nc["time"][:], units=nc["time"].units)
+        data = {
+            num: nc[key][:]
+            for key, num in PARSIVEL2NC_KEYS.items()
+            if key in nc.variables
+        }
+        data[13] = np.repeat(int(nc.Sensor_ID), len(time))
+        return time, data
+
+
 def _read_parsivel(
     filename: str | PathLike,
     telegram: Sequence[int | str | None] | None = None,
@@ -483,6 +498,8 @@ def _read_parsivel(
 ) -> ParsivelOutput:
     try:
         with netCDF4.Dataset(filename) as nc:
+            if hasattr(nc, "Title") and "CLOUDLAB" in nc.Title:
+                return _read_cloudlab(filename)
             if "number_concentration" in nc.variables:
                 return _read_parsivel2nc(filename)
             if "fieldN" in nc.variables:

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/model_evaluation/products/advance_methods.py

@@ -105,11 +105,20 @@ class AdvanceProductMethods:
         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))
-        ]
-        return np.asarray(z_sen)
+        # Interpolate at the model level heights: rebinning assumes evenly
+        # spaced levels, which maps stretched model levels to wrong heights.
+        obs_height = self._obs_obj.height_agl
+        if obs_height is None:
+            obs_height = self._obs_obj.height
+        obs_height = np.asarray(ma.filled(obs_height, np.nan), dtype=float)
+        z_obs = np.asarray(ma.filled(self._obs_obj.z_sensitivity, np.nan), dtype=float)
+        is_valid = np.isfinite(obs_height) & np.isfinite(z_obs)
+        model_height = np.asarray(ma.filled(h, np.nan), dtype=float)
+        z_sen = np.interp(
+            model_height, obs_height[is_valid], z_obs[is_valid], right=np.nan
+        )
+        z_sen[~np.isfinite(model_height)] = np.nan
+        return z_sen
 
     def filter_high_iwc_low_cf(
         self,

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py

@@ -69,14 +69,30 @@ def test_fit_z_sensitivity(obs_file, model_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, PRODUCT)
     advance = AdvanceProductMethods(model, obs)
+    # obs heights above ground 7, 8, 11 and 14 km with sensitivities
+    # 0.1, 0.2, 0.0, 1.0; levels above the radar range are NaN
     height = np.array(
         [[5000, 9000, 13000], [10000, 15000, 20000], [8000, 12000, 16000]]
     )
-    expected = ma.masked_invalid([[np.nan, 0.15, 0.5], [0.1, 1, np.nan], [0.15, 0, 1]])
+    expected = np.array(
+        [[0.1, 0.4 / 3, 2 / 3], [0.2 / 3, np.nan, np.nan], [0.2, 1 / 3, np.nan]]
+    )
     result = advance.fit_z_sensitivity(height)
     testing.assert_array_almost_equal(result, expected)
 
 
+def test_fit_z_sensitivity_stretched_grid(obs_file, model_file) -> None:
+    obs = ObservationManager(PRODUCT, str(obs_file))
+    model = ModelManager(str(model_file), MODEL, PRODUCT)
+    advance = AdvanceProductMethods(model, obs)
+    # unevenly spaced model levels within the radar range must all get a value
+    height = np.array([[7000, 7100, 7300, 7700, 8500, 10000, 13000, 14000]])
+    result = advance.fit_z_sensitivity(height)
+    assert np.isfinite(result).all()
+    assert result[0, 0] == pytest.approx(0.1)
+    assert result[0, -1] == pytest.approx(1.0)
+
+
 def test_filter_high_iwc_low_cf(obs_file, model_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, PRODUCT)

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4}/cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
 MINOR = 96
-PATCH = 2
+PATCH = 4
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.96.2 → cloudnetpy-1.96.4/cloudnetpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.96.2
+Version: 1.96.4
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License