cloudnetpy 1.49.9__py3-none-any.whl → 1.87.3__py3-none-any.whl

cloudnetpy/categorize/model.py

@@ -1,10 +1,20 @@
 """Model module, containing the :class:`Model` class."""
+
+import os.path
+from os import PathLike
+
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.interpolate import interp1d
 
 from cloudnetpy import utils
 from cloudnetpy.categorize import atmos_utils
+from cloudnetpy.categorize.itu import (
+    calc_gas_specific_attenuation,
+    calc_liquid_specific_attenuation,
+    calc_saturation_vapor_pressure,
+)
 from cloudnetpy.cloudnetarray import CloudnetArray
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.exceptions import ModelDataError
@@ -16,9 +26,10 @@ class Model(DataSource):
     Args:
         model_file: File name of the NWP model file.
         alt_site: Altitude of the site above mean sea level (m).
+        options: Dictionary containing optional parameters.
 
     Attributes:
-        type (str): Model type, e.g. 'gdas1' or 'ecwmf'.
+        source_type (str): Model type, e.g. 'gdas1' or 'ecwmf'.
         model_heights (ndarray): 2-D array of model heights (one for each time
             step).
         mean_height (ndarray): Mean of *model_heights*.
@@ -33,35 +44,37 @@ class Model(DataSource):
         "temperature",
         "pressure",
         "rh",
-        "gas_atten",
+        "q",
+    )
+    fields_sparse = (*fields_dense, "uwind", "vwind")
+    fields_atten = (
         "specific_gas_atten",
         "specific_saturated_gas_atten",
         "specific_liquid_atten",
     )
-    fields_sparse = fields_dense + ("q", "uwind", "vwind")
 
-    def __init__(self, model_file: str, alt_site: float):
+    def __init__(
+        self, model_file: str | PathLike, alt_site: float, options: dict | None = None
+    ) -> None:
         super().__init__(model_file)
-        self.type = _find_model_type(model_file)
+        self.options = options
+        self.source_type = _find_model_type(model_file)
         self.model_heights = self._get_model_heights(alt_site)
         self.mean_height = _calc_mean_height(self.model_heights)
-        self.height: np.ndarray
+        self.height: npt.NDArray
         self.data_sparse: dict = {}
         self.data_dense: dict = {}
+        self.alt_site = alt_site
         self._append_grid()
 
-    def interpolate_to_common_height(self, wl_band: int) -> None:
-        """Interpolates model variables to common height grid.
-
-        Args:
-            wl_band: Integer denoting the approximate wavelength band of the
-                cloud radar (0 = ~35.5 GHz, 1 = ~94 GHz).
-
-        """
+    def interpolate_to_common_height(self) -> None:
+        """Interpolates model variables to common height grid."""
 
         def _interpolate_variable(data_in: ma.MaskedArray) -> CloudnetArray:
             datai = ma.zeros((len(self.time), len(self.mean_height)))
-            for ind, (alt, prof) in enumerate(zip(self.model_heights, data_in)):
+            for ind, (alt, prof) in enumerate(
+                zip(self.model_heights, data_in, strict=True),
+            ):
                 if prof.mask.all():
                     datai[ind, :] = ma.masked
                 else:
@@ -73,34 +86,47 @@ class Model(DataSource):
             variable = self.dataset.variables[key]
             data = variable[:]
             units = variable.units
-            if "atten" in key:
-                data = data[wl_band, :, :]
             self.data_sparse[key] = _interpolate_variable(data)
 
     def interpolate_to_grid(
-        self, time_grid: np.ndarray, height_grid: np.ndarray
-    ) -> None:
+        self,
+        time_grid: npt.NDArray,
+        height_grid: npt.NDArray,
+    ) -> list:
         """Interpolates model variables to Cloudnet's dense time / height grid.
 
         Args:
             time_grid: The target time array (fraction hour).
             height_grid: The target height array (m).
 
+        Returns:
+            Indices fully masked profiles.
+
         """
-        for key in self.fields_dense:
+        half_height = height_grid - np.diff(height_grid, prepend=self.alt_site) / 2
+        for key in self.fields_dense + self.fields_atten:
             array = self.data_sparse[key][:]
             valid_profiles = _find_number_of_valid_profiles(array)
             if valid_profiles < 2:
                 raise ModelDataError
             self.data_dense[key] = utils.interpolate_2d_mask(
-                self.time, self.mean_height, array, time_grid, height_grid
+                self.time,
+                self.mean_height,
+                array,
+                time_grid,
+                half_height if "atten" in key else height_grid,
             )
         self.height = height_grid
+        return utils.find_masked_profiles_indices(self.data_dense["temperature"])
 
     def calc_wet_bulb(self) -> None:
         """Calculates wet-bulb temperature in dense grid."""
         wet_bulb_temp = atmos_utils.calc_wet_bulb_temperature(self.data_dense)
+        offset = (self.options or {}).get("temperature_offset", 0)
+        wet_bulb_temp += offset
         self.append_data(wet_bulb_temp, "Tw", units="K")
+        if offset:
+            self.data["Tw"].temperature_correction_applied = offset
 
     def screen_sparse_fields(self) -> None:
         """Removes model fields that we don't want to write in the output."""
@@ -111,29 +137,50 @@ class Model(DataSource):
         self.append_data(np.array(self.time), "model_time")
         self.append_data(self.mean_height, "model_height")
 
-    def _get_model_heights(self, alt_site: float) -> np.ndarray:
+    def _get_model_heights(self, alt_site: float) -> npt.NDArray:
         """Returns model heights for each time step."""
-        model_heights = self.dataset.variables["height"]
-        return self.km2m(model_heights) + alt_site
-
-
-def _calc_mean_height(model_heights: np.ndarray) -> np.ndarray:
+        try:
+            model_heights = self.dataset.variables["height"]
+        except KeyError as err:
+            msg = "No 'height' variable in the model file."
+            raise ModelDataError(msg) from err
+        return self.to_m(model_heights) + alt_site
+
+    def calc_attenuations(self, frequency: float) -> None:
+        temperature = self.getvar("temperature")
+        pressure = self.getvar("pressure")
+        specific_humidity = self.getvar("q")
+
+        self.data_sparse["specific_liquid_atten"] = calc_liquid_specific_attenuation(
+            temperature, frequency
+        )
+        vp = atmos_utils.calc_vapor_pressure(pressure, specific_humidity)
+        svp = calc_saturation_vapor_pressure(temperature)
+        self.data_sparse["specific_gas_atten"] = calc_gas_specific_attenuation(
+            pressure, vp, temperature, frequency
+        )
+        self.data_sparse["specific_saturated_gas_atten"] = (
+            calc_gas_specific_attenuation(pressure, svp, temperature, frequency)
+        )
+
+
+def _calc_mean_height(model_heights: npt.NDArray) -> npt.NDArray:
     mean_height = ma.mean(model_heights, axis=0)
     return np.array(mean_height)
 
 
-def _find_model_type(file_name: str) -> str:
+def _find_model_type(file_name: str | PathLike) -> str:
     """Finds model type from the model filename."""
-    possible_keys = utils.fetch_cloudnet_model_types()
+    possible_keys = ("gdas1", "icon", "ecmwf", "harmonie", "era5", "arpege")
+    basename = os.path.basename(file_name)
     for key in possible_keys:
-        if key in file_name:
+        if key in basename:
             return key
-    raise ValueError("Unknown model type")
+    msg = f"Unknown model type: {file_name}"
+    raise ValueError(msg)
 
 
-def _find_number_of_valid_profiles(array: np.ndarray) -> int:
-    n_good = 0
-    for row in array:
-        if not hasattr(row, "mask") or np.sum(row.mask.astype(int)) == 0:
-            n_good += 1
-    return n_good
+def _find_number_of_valid_profiles(array: npt.NDArray) -> int:
+    mask = ma.getmaskarray(array)
+    all_masked_profiles = np.all(mask, axis=1)
+    return int(np.count_nonzero(~all_masked_profiles))

cloudnetpy/categorize/mwr.py

@@ -1,8 +1,14 @@
 """Mwr module, containing the :class:`Mwr` class."""
-import numpy as np
+
+from os import PathLike
+
+import numpy.ma as ma
+import numpy.typing as npt
 
 from cloudnetpy import utils
+from cloudnetpy.constants import G_TO_KG
 from cloudnetpy.datasource import DataSource
+from cloudnetpy.utils import interpolate_1d
 
 
 class Mwr(DataSource):
@@ -13,33 +19,31 @@ class Mwr(DataSource):
 
     """
 
-    def __init__(self, full_path: str):
+    def __init__(self, full_path: str | PathLike) -> None:
         super().__init__(full_path)
         self._init_lwp_data()
         self._init_lwp_error()
 
-    def rebin_to_grid(self, time_grid: np.ndarray) -> None:
-        """Approximates lwp and its error in a grid using mean.
-
-        Args:
-            time_grid: 1D target time grid.
-
-        """
-        for array in self.data.values():
-            array.rebin_data(self.time, time_grid)
+    def interpolate_to_grid(self, time_grid: npt.NDArray, max_time: float = 1) -> None:
+        for key, array in self.data.items():
+            self.data[key].data = interpolate_1d(
+                self.time, array.data, time_grid, max_time=max_time
+            )
 
     def _init_lwp_data(self) -> None:
         lwp = self.dataset.variables["lwp"][:]
+        if "lwp_quality_flag" in self.dataset.variables:
+            quality_flag = self.dataset.variables["lwp_quality_flag"][:]
+            lwp[quality_flag != 0] = ma.masked
         self.append_data(lwp, "lwp")
 
     def _init_lwp_error(self) -> None:
         random_error, bias = 0.25, 20
-        g2kg = 1e-3
-        lwp_error = utils.l2norm(self.data["lwp"][:] * random_error, bias * g2kg)
+        lwp_error = utils.l2norm(self.data["lwp"][:] * random_error, bias * G_TO_KG)
         self.append_data(lwp_error, "lwp_error", units="kg m-2")
         self.data["lwp_error"].comment = (
             "This variable is a rough estimate of the one-standard-deviation\n"
             f"error in liquid water path, calculated as a combination of\n"
-            f"a {bias} g m-2 linear error and a {round(random_error*100)} %\n"
+            f"a {bias} g m-2 linear error and a {round(random_error * 100)} %\n"
             "fractional error."
         )