cloudnetpy 1.96.2__tar.gz → 1.96.3__tar.gz

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

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

{cloudnetpy-1.96.2 → cloudnetpy-1.96.3}/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.3}/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.3}/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.3}/cloudnetpy/version.py

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

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

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