cloudnetpy 1.65.7__py3-none-any.whl → 1.66.0__py3-none-any.whl

cloudnetpy/categorize/itu.py

@@ -0,0 +1,243 @@
+import numpy as np
+import numpy.typing as npt
+
+import cloudnetpy.constants as con
+
+
+def calc_liquid_specific_attenuation(
+    temperature: npt.NDArray, frequency: float
+) -> npt.NDArray:
+    """Calculate cloud liquid water specific attenuation coefficient for
+    frequency up to 200 GHz.
+
+    Args:
+        temperature: Temperature (K)
+        frequency: Frequency (GHz)
+
+    Returns:
+        Cloud liquid water specific attenuation coefficient ((dB km-1)/(g m-3))
+
+    References:
+        ITU-R P.840-9: Attenuation due to clouds and fog.
+        https://www.itu.int/dms_pubrec/itu-r/rec/p/R-REC-P.840-9-202308-I!!PDF-E.pdf
+    """
+    theta1 = 300 / temperature - 1
+    e0 = 77.66 + 103.3 * theta1
+    e1 = 0.0671 * e0
+    e2 = 3.52
+    fp = 20.20 - 146 * theta1 + 316 * theta1**2
+    fs = 39.8 * fp
+    ei = frequency * (e0 - e1) / (fp * (1 + (frequency / fp) ** 2)) + frequency * (
+        e1 - e2
+    ) / (fs * (1 + (frequency / fs) ** 2))
+    er = (
+        (e0 - e1) / (1 + (frequency / fp) ** 2)
+        + (e1 - e2) / (1 + (frequency / fs) ** 2)
+        + e2
+    )
+    eta = (2 + er) / ei
+    return 0.819 * frequency / (ei * (1 + eta**2))
+
+
+def calc_gas_specific_attenuation(
+    pressure: npt.NDArray,
+    vapor_pressure: npt.NDArray,
+    temperature: npt.NDArray,
+    frequency: float,
+) -> npt.NDArray:
+    """Calculate specific attenuation due to dry air and water vapor for
+    frequency up to 1000 GHz.
+
+    Args:
+        pressure: Pressure (Pa)
+        vapor_pressure: Water vapor partial pressure (Pa)
+        temperature: Temperature (K)
+        frequency: Frequency (GHz)
+
+    References:
+        ITU-R P.676-13: Attenuation by atmospheric gases and related effects.
+        https://www.itu.int/dms_pubrec/itu-r/rec/p/R-REC-P.676-13-202208-I!!PDF-E.pdf
+    """
+    pressure = pressure * con.PA_TO_HPA
+    vapor_pressure = vapor_pressure * con.PA_TO_HPA
+    dry_pressure = pressure - vapor_pressure
+    theta = 300 / temperature
+    oxygen_refractivity = _calc_oxygen_refractivity(
+        dry_pressure, vapor_pressure, frequency, theta
+    )
+    vapor_refractivity = _calc_vapor_refractivity(
+        dry_pressure, vapor_pressure, frequency, theta
+    )
+    return 0.1820 * frequency * (oxygen_refractivity + vapor_refractivity)
+
+
+def _calc_line_shape(
+    frequency: float,
+    center: npt.NDArray,
+    width: npt.NDArray,
+    correction: npt.NDArray | float,
+) -> npt.NDArray:
+    return (
+        frequency
+        / center
+        * (
+            (width - correction * (center - frequency))
+            / ((center - frequency) ** 2 + width**2)
+            + (width - correction * (center + frequency))
+            / ((center + frequency) ** 2 + width**2)
+        )
+    )
+
+
+def _calc_oxygen_refractivity(
+    dry_pressure: npt.NDArray,
+    vapor_pressure: npt.NDArray,
+    frequency: float,
+    theta: npt.NDArray,
+) -> npt.NDArray:
+    f0, a1, a2, a3, a4, a5, a6 = OXYGEN_TABLE[:, :, np.newaxis, np.newaxis]
+    strength = a1 * 1e-7 * dry_pressure * theta**3 * np.exp(a2 * (1 - theta))
+    width = (
+        a3 * 1e-4 * (dry_pressure * theta ** (0.8 - a4) + 1.1 * vapor_pressure * theta)
+    )
+    width = np.sqrt(width**2 + 2.25e-6)
+    correction = (a5 + a6 * theta) * 1e-4 * (dry_pressure + vapor_pressure) * theta**0.8
+    shape = _calc_line_shape(frequency, f0, width, correction)
+    d = 5.6e-4 * (dry_pressure + vapor_pressure) * theta**0.8
+    continuum = (
+        frequency
+        * dry_pressure
+        * theta**2
+        * (
+            6.14e-5 / (d * (1 + (frequency / d) ** 2))
+            + ((1.4e-12 * dry_pressure * theta**1.5) / (1 + 1.9e-5 * frequency**1.5))
+        )
+    )
+    return np.sum(strength * shape, axis=0) + continuum
+
+
+def _calc_vapor_refractivity(
+    dry_pressure: npt.NDArray,
+    vapor_pressure: npt.NDArray,
+    frequency: float,
+    theta: npt.NDArray,
+) -> npt.NDArray:
+    f0, b1, b2, b3, b4, b5, b6 = VAPOR_TABLE[:, :, np.newaxis, np.newaxis]
+    strength = b1 * 1e-1 * vapor_pressure * theta**3.5 * np.exp(b2 * (1 - theta))
+    width = b3 * 1e-4 * (dry_pressure * theta**b4 + b5 * vapor_pressure * theta**b6)
+    width = 0.535 * width + np.sqrt(0.217 * width**2 + (2.1316e-12 * f0**2) / theta)
+    correction = 0.0
+    shape = _calc_line_shape(frequency, f0, width, correction)
+    return np.sum(strength * shape, axis=0)
+
+
+def calc_saturation_vapor_pressure(temperature: npt.NDArray) -> npt.NDArray:
+    """Calculate saturation vapor pressure using Tetens equation with respect to
+    water or ice depending on whether the temperature is above freezing or not.
+
+    Args:
+        temperature: Temperature (K)
+
+    Returns:
+        Saturation vapor pressure (Pa)
+
+    References:
+        Murray, F. W. (1967). On the Computation of Saturation Vapor Pressure.
+        Journal of Applied Meteorology and Climatology, 6(1), 203-204.
+        https://doi.org/10.1175/1520-0450(1967)006<0203:OTCOSV>2.0.CO;2
+    """
+    freezing = 273.16
+    is_freezing = temperature < freezing
+    a = np.where(is_freezing, 21.8745584, 17.2693882)
+    b = np.where(is_freezing, 7.66, 35.86)
+    return 610.78 * np.exp(a * (temperature - freezing) / (temperature - b))
+
+
+OXYGEN_TABLE = np.array(
+    [
+        [50.474214, 0.975, 9.651, 6.690, 0.0, 2.566, 6.850],
+        [50.987745, 2.529, 8.653, 7.170, 0.0, 2.246, 6.800],
+        [51.503360, 6.193, 7.709, 7.640, 0.0, 1.947, 6.729],
+        [52.021429, 14.320, 6.819, 8.110, 0.0, 1.667, 6.640],
+        [52.542418, 31.240, 5.983, 8.580, 0.0, 1.388, 6.526],
+        [53.066934, 64.290, 5.201, 9.060, 0.0, 1.349, 6.206],
+        [53.595775, 124.600, 4.474, 9.550, 0.0, 2.227, 5.085],
+        [54.130025, 227.300, 3.800, 9.960, 0.0, 3.170, 3.750],
+        [54.671180, 389.700, 3.182, 10.370, 0.0, 3.558, 2.654],
+        [55.221384, 627.100, 2.618, 10.890, 0.0, 2.560, 2.952],
+        [55.783815, 945.300, 2.109, 11.340, 0.0, -1.172, 6.135],
+        [56.264774, 543.400, 0.014, 17.030, 0.0, 3.525, -0.978],
+        [56.363399, 1331.800, 1.654, 11.890, 0.0, -2.378, 6.547],
+        [56.968211, 1746.600, 1.255, 12.230, 0.0, -3.545, 6.451],
+        [57.612486, 2120.100, 0.910, 12.620, 0.0, -5.416, 6.056],
+        [58.323877, 2363.700, 0.621, 12.950, 0.0, -1.932, 0.436],
+        [58.446588, 1442.100, 0.083, 14.910, 0.0, 6.768, -1.273],
+        [59.164204, 2379.900, 0.387, 13.530, 0.0, -6.561, 2.309],
+        [59.590983, 2090.700, 0.207, 14.080, 0.0, 6.957, -0.776],
+        [60.306056, 2103.400, 0.207, 14.150, 0.0, -6.395, 0.699],
+        [60.434778, 2438.000, 0.386, 13.390, 0.0, 6.342, -2.825],
+        [61.150562, 2479.500, 0.621, 12.920, 0.0, 1.014, -0.584],
+        [61.800158, 2275.900, 0.910, 12.630, 0.0, 5.014, -6.619],
+        [62.411220, 1915.400, 1.255, 12.170, 0.0, 3.029, -6.759],
+        [62.486253, 1503.000, 0.083, 15.130, 0.0, -4.499, 0.844],
+        [62.997984, 1490.200, 1.654, 11.740, 0.0, 1.856, -6.675],
+        [63.568526, 1078.000, 2.108, 11.340, 0.0, 0.658, -6.139],
+        [64.127775, 728.700, 2.617, 10.880, 0.0, -3.036, -2.895],
+        [64.678910, 461.300, 3.181, 10.380, 0.0, -3.968, -2.590],
+        [65.224078, 274.000, 3.800, 9.960, 0.0, -3.528, -3.680],
+        [65.764779, 153.000, 4.473, 9.550, 0.0, -2.548, -5.002],
+        [66.302096, 80.400, 5.200, 9.060, 0.0, -1.660, -6.091],
+        [66.836834, 39.800, 5.982, 8.580, 0.0, -1.680, -6.393],
+        [67.369601, 18.560, 6.818, 8.110, 0.0, -1.956, -6.475],
+        [67.900868, 8.172, 7.708, 7.640, 0.0, -2.216, -6.545],
+        [68.431006, 3.397, 8.652, 7.170, 0.0, -2.492, -6.600],
+        [68.960312, 1.334, 9.650, 6.690, 0.0, -2.773, -6.650],
+        [118.750334, 940.300, 0.010, 16.640, 0.0, -0.439, 0.079],
+        [368.498246, 67.400, 0.048, 16.400, 0.0, 0.000, 0.000],
+        [424.763020, 637.700, 0.044, 16.400, 0.0, 0.000, 0.000],
+        [487.249273, 237.400, 0.049, 16.000, 0.0, 0.000, 0.000],
+        [715.392902, 98.100, 0.145, 16.000, 0.0, 0.000, 0.000],
+        [773.839490, 572.300, 0.141, 16.200, 0.0, 0.000, 0.000],
+        [834.145546, 183.100, 0.145, 14.700, 0.0, 0.000, 0.000],
+    ]
+).T
+
+VAPOR_TABLE = np.array(
+    [
+        [22.235080, 0.1079, 2.144, 26.38, 0.76, 5.087, 1.00],
+        [67.803960, 0.0011, 8.732, 28.58, 0.69, 4.930, 0.82],
+        [119.995940, 0.0007, 8.353, 29.48, 0.70, 4.780, 0.79],
+        [183.310087, 2.273, 0.668, 29.06, 0.77, 5.022, 0.85],
+        [321.225630, 0.0470, 6.179, 24.04, 0.67, 4.398, 0.54],
+        [325.152888, 1.514, 1.541, 28.23, 0.64, 4.893, 0.74],
+        [336.227764, 0.0010, 9.825, 26.93, 0.69, 4.740, 0.61],
+        [380.197353, 11.67, 1.048, 28.11, 0.54, 5.063, 0.89],
+        [390.134508, 0.0045, 7.347, 21.52, 0.63, 4.810, 0.55],
+        [437.346667, 0.0632, 5.048, 18.45, 0.60, 4.230, 0.48],
+        [439.150807, 0.9098, 3.595, 20.07, 0.63, 4.483, 0.52],
+        [443.018343, 0.1920, 5.048, 15.55, 0.60, 5.083, 0.50],
+        [448.001085, 10.41, 1.405, 25.64, 0.66, 5.028, 0.67],
+        [470.888999, 0.3254, 3.597, 21.34, 0.66, 4.506, 0.65],
+        [474.689092, 1.260, 2.379, 23.20, 0.65, 4.804, 0.64],
+        [488.490108, 0.2529, 2.852, 25.86, 0.69, 5.201, 0.72],
+        [503.568532, 0.0372, 6.731, 16.12, 0.61, 3.980, 0.43],
+        [504.482692, 0.0124, 6.731, 16.12, 0.61, 4.010, 0.45],
+        [547.676440, 0.9785, 0.158, 26.00, 0.70, 4.500, 1.00],
+        [552.020960, 0.1840, 0.158, 26.00, 0.70, 4.500, 1.00],
+        [556.935985, 497.0, 0.159, 30.86, 0.69, 4.552, 1.00],
+        [620.700807, 5.015, 2.391, 24.38, 0.71, 4.856, 0.68],
+        [645.766085, 0.0067, 8.633, 18.00, 0.60, 4.000, 0.50],
+        [658.005280, 0.2732, 7.816, 32.10, 0.69, 4.140, 1.00],
+        [752.033113, 243.4, 0.396, 30.86, 0.68, 4.352, 0.84],
+        [841.051732, 0.0134, 8.177, 15.90, 0.33, 5.760, 0.45],
+        [859.965698, 0.1325, 8.055, 30.60, 0.68, 4.090, 0.84],
+        [899.303175, 0.0547, 7.914, 29.85, 0.68, 4.530, 0.90],
+        [902.611085, 0.0386, 8.429, 28.65, 0.70, 5.100, 0.95],
+        [906.205957, 0.1836, 5.110, 24.08, 0.70, 4.700, 0.53],
+        [916.171582, 8.400, 1.441, 26.73, 0.70, 5.150, 0.78],
+        [923.112692, 0.0079, 10.293, 29.00, 0.70, 5.000, 0.80],
+        [970.315022, 9.009, 1.919, 25.50, 0.64, 4.940, 0.67],
+        [987.926764, 134.6, 0.257, 29.85, 0.68, 4.550, 0.90],
+        [1780.000000, 17506.0, 0.952, 196.3, 2.00, 24.15, 5.00],
+    ]
+).T

cloudnetpy/categorize/melting.py

@@ -107,9 +107,6 @@ def _find_melting_layer_from_ldr(
     v_prof: np.ndarray,
     z_prof: np.ndarray,
 ) -> np.ndarray | None:
-    if ldr_prof is None:
-        raise ValueError
-
     peak = int(np.argmax(ldr_prof))
     base, top = _basetop(ldr_dprof, peak)
     conditions = (

cloudnetpy/categorize/model.py

@@ -6,6 +6,11 @@ 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
@@ -35,12 +40,14 @@ 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, options: dict | None = None):
         super().__init__(model_file)
@@ -53,14 +60,8 @@ class Model(DataSource):
         self.data_dense: dict = {}
         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)))
@@ -78,8 +79,6 @@ 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(
@@ -97,7 +96,8 @@ class Model(DataSource):
             Indices fully masked profiles.
 
         """
-        for key in self.fields_dense:
+        half_height = height_grid - np.diff(height_grid, prepend=0) / 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:
@@ -107,7 +107,7 @@ class Model(DataSource):
                 self.mean_height,
                 array,
                 time_grid,
-                height_grid,
+                half_height if "atten" in key else height_grid,
             )
         self.height = height_grid
         return utils.find_masked_profiles_indices(self.data_dense["temperature"])
@@ -139,6 +139,23 @@ class Model(DataSource):
             raise ModelDataError(msg) from err
         return self.to_m(model_heights) + alt_site
 
+    def calc_attenuations(self, frequency: float):
+        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: np.ndarray) -> np.ndarray:
     mean_height = ma.mean(model_heights, axis=0)

cloudnetpy/categorize/radar.py

@@ -8,6 +8,7 @@ from numpy import ma
 from scipy import constants
 
 from cloudnetpy import utils
+from cloudnetpy.categorize.attenuations import RadarAttenuation
 from cloudnetpy.constants import GHZ_TO_HZ, SEC_IN_HOUR, SPEED_OF_LIGHT
 from cloudnetpy.datasource import DataSource
 
@@ -42,6 +43,8 @@ class Radar(DataSource):
         self.sequence_indices = self._get_sequence_indices()
         self.location = getattr(self.dataset, "location", "")
         self.source_type = getattr(self.dataset, "source", "")
+        self.height: np.ndarray
+        self.altitude: float
         self._init_data()
         self._init_sigma_v()
         self._get_folding_velocity_full()
@@ -200,26 +203,29 @@ class Radar(DataSource):
 
         return n_removed_total
 
-    def correct_atten(self, attenuations: dict) -> None:
+    def correct_atten(self, attenuations: RadarAttenuation) -> None:
         """Corrects radar echo for liquid and gas attenuation.
 
         Args:
-            attenuations: 2-D attenuations due to atmospheric gases and liquid:
-                `radar_gas_atten`, `radar_liquid_atten`.
+            attenuations: Radar attenuation object.
 
         References:
             The method is based on Hogan R. and O'Connor E., 2004,
             https://bit.ly/2Yjz9DZ and the original Cloudnet Matlab implementation.
 
         """
-        z_corrected = self.data["Z"][:] + attenuations["radar_gas_atten"]
-        ind = ma.where(attenuations["radar_liquid_atten"])
-        z_corrected[ind] += attenuations["radar_liquid_atten"][ind]
+        z_corrected = self.data["Z"][:] + attenuations.gas.amount
+        ind = ma.where(attenuations.liquid.amount)
+        z_corrected[ind] += attenuations.liquid.amount[ind]
+        ind = ma.where(attenuations.rain.amount)
+        z_corrected[ind] += attenuations.rain.amount[ind]
+        ind = ma.where(attenuations.melting.amount)
+        z_corrected[ind] += attenuations.melting.amount[ind]
         self.append_data(z_corrected, "Z")
 
     def calc_errors(
         self,
-        attenuations: dict,
+        attenuations: RadarAttenuation,
         is_clutter: np.ndarray,
     ) -> None:
         """Calculates uncertainties of radar echo.
@@ -239,7 +245,7 @@ class Radar(DataSource):
 
         def _calc_sensitivity() -> np.ndarray:
             """Returns sensitivity of radar as function of altitude."""
-            mean_gas_atten = ma.mean(attenuations["radar_gas_atten"], axis=0)
+            mean_gas_atten = ma.mean(attenuations.gas.amount, axis=0)
             z_sensitivity = z_power_min + log_range + mean_gas_atten
             zc = ma.median(ma.array(z, mask=~is_clutter), axis=0)
             valid_values = np.logical_not(zc.mask)
@@ -260,10 +266,20 @@ class Radar(DataSource):
             z_precision = ma.divide(ln_to_log10, np.sqrt(n_pulses)) * (
                 1 + (utils.db2lin(z_power_min - z_power) / noise_threshold)
             )
-            gas_error = attenuations["radar_gas_atten"] * 0.1
-            liq_error = attenuations["liquid_atten_err"].filled(0)
-            z_error = utils.l2norm(gas_error, liq_error, z_precision)
-            z_error[attenuations["liquid_uncorrected"]] = ma.masked
+
+            z_error = utils.l2norm(
+                z_precision,
+                attenuations.liquid.error.filled(0),
+                attenuations.rain.error.filled(0),
+                attenuations.melting.error.filled(0),
+            )
+
+            z_error[
+                attenuations.liquid.uncorrected
+                | attenuations.rain.uncorrected
+                | attenuations.melting.uncorrected
+            ] = ma.masked
+
             return z_error
 
         def _number_of_independent_pulses() -> float:

cloudnetpy/constants.py

@@ -8,12 +8,6 @@ T0: Final = 273.16
 # Ratio of the molecular weight of water vapor to dry air
 MW_RATIO: Final = 0.62198
 
-# Specific heat capacity of air at around 275K (J kg-1 K-1)
-SPECIFIC_HEAT: Final = 1004
-
-# Latent heat of evaporation (J kg-1)
-LATENT_HEAT: Final = 2.26e6
-
 # Specific gas constant for dry  air (J kg-1 K-1)
 RS: Final = 287.058
 
@@ -27,9 +21,12 @@ SEC_IN_HOUR: Final = 3600
 SEC_IN_DAY: Final = 86400
 MM_TO_M: Final = 1e-3
 G_TO_KG: Final = 1e-3
+KG_TO_G: Final = 1e3
 M_S_TO_MM_H: Final = SEC_IN_HOUR / MM_TO_M
 MM_H_TO_M_S: Final = 1 / M_S_TO_MM_H
 GHZ_TO_HZ: Final = 1e9
 HPA_TO_PA: Final = 100
 PA_TO_HPA: Final = 1 / HPA_TO_PA
 KM_H_TO_M_S: Final = 1000 / SEC_IN_HOUR
+M_TO_KM: Final = 1e-3
+TWO_WAY: Final = 2

cloudnetpy/model_evaluation/file_handler.py

@@ -94,7 +94,7 @@ def save_downsampled_file(
     output.copy_global(obj.dataset, root_group, ("location", "day", "month", "year"))
     if not hasattr(obj.dataset, "day"):
         root_group.year, root_group.month, root_group.day = obj.date
-    output.merge_history(root_group, id_mark, {"l3": obj})
+    output.merge_history(root_group, id_mark, obj)
     root_group.close()
     if not isinstance(uuid, str):
         msg = "UUID is not a string."
@@ -156,7 +156,7 @@ def _add_source(root_ground: netCDF4.Dataset, objects: tuple, files: tuple) -> N
         if i < len(model_files) - 1:
             source += "\n"
     root_ground.source = source
-    root_ground.source_file_uuids = output.get_source_uuids(model, obs)
+    root_ground.source_file_uuids = output.get_source_uuids([model, obs])
 
 
 def add_time_attribute(date: datetime) -> dict:

cloudnetpy/model_evaluation/products/observation_products.py

@@ -6,7 +6,7 @@ from numpy import ma
 
 from cloudnetpy import utils
 from cloudnetpy.datasource import DataSource
-from cloudnetpy.products.product_tools import CategorizeBits
+from cloudnetpy.products.product_tools import CategorizeBits, CategoryBits
 
 
 class ObservationManager(DataSource):
@@ -79,14 +79,14 @@ class ObservationManager(DataSource):
         return self._mask_cloud_bits(cloud_mask)
 
     @staticmethod
-    def _classify_basic_mask(bits: dict) -> np.ndarray:
-        cloud_mask = bits["droplet"] + bits["falling"] * 2
-        cloud_mask[bits["falling"] & bits["cold"]] = (
-            cloud_mask[bits["falling"] & bits["cold"]] + 2
+    def _classify_basic_mask(bits: CategoryBits) -> np.ndarray:
+        cloud_mask = bits.droplet + bits.falling * 2
+        cloud_mask[bits.falling & bits.freezing] = (
+            cloud_mask[bits.falling & bits.freezing] + 2
         )
-        cloud_mask[bits["aerosol"]] = 6
-        cloud_mask[bits["insect"]] = 7
-        cloud_mask[bits["aerosol"] & bits["insect"]] = 8
+        cloud_mask[bits.aerosol] = 6
+        cloud_mask[bits.insect] = 7
+        cloud_mask[bits.aerosol & bits.insect] = 8
         return cloud_mask
 
     @staticmethod

cloudnetpy/model_evaluation/tests/unit/test_grid_methods.py

@@ -174,7 +174,8 @@ def test_regrid_cf_area_all_nan(model_file, obs_file) -> None:
             [1, 1, 1],
             [1, 1, 1],
             [1, 1, 1],
-        ], mask=True
+        ],
+        mask=True,
     )
     d = {"cf_A": ma.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
@@ -413,7 +414,9 @@ def test_regrid_iwc_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
-    obj._obs_data = ma.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], mask=True)
+    obj._obs_data = ma.array(
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]], mask=True
+    )
     d = {"iwc": ma.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(

cloudnetpy/model_evaluation/tests/unit/test_observation_products.py

@@ -5,21 +5,21 @@ import pytest
 from numpy import ma, testing
 
 from cloudnetpy.model_evaluation.products.product_resampling import ObservationManager
-from cloudnetpy.products.product_tools import CategorizeBits
+from cloudnetpy.products.product_tools import CategorizeBits, CategoryBits
 
 PRODUCT = "iwc"
 
 
 class CatBits:
     def __init__(self) -> None:
-        self.category_bits = {
-            "droplet": np.asarray([[1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 0, 0]], dtype=bool),
-            "falling": np.asarray([[0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1]], dtype=bool),
-            "cold": np.asarray([[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 0, 1]], dtype=bool),
-            "melting": np.asarray([[1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0]], dtype=bool),
-            "aerosol": np.asarray([[1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0]], dtype=bool),
-            "insect": np.asarray([[1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]], dtype=bool),
-        }
+        self.category_bits = CategoryBits(
+            droplet=np.asarray([[1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 0, 0]], dtype=bool),
+            falling=np.asarray([[0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1]], dtype=bool),
+            freezing=np.asarray([[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 0, 1]], dtype=bool),
+            melting=np.asarray([[1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0]], dtype=bool),
+            aerosol=np.asarray([[1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0]], dtype=bool),
+            insect=np.asarray([[1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]], dtype=bool),
+        )
 
 
 def test_get_date(obs_file) -> None:
@@ -96,7 +96,7 @@ def test_mask_cloud_bits(obs_file) -> None:
 def test_basic_cloud_mask_all_values(obs_file) -> None:
     cat = CatBits()
     obj = ObservationManager("cf", str(obs_file))
-    x = obj._classify_basic_mask(cat.category_bits)
+    x = obj._classify_basic_mask(cat.category_bits)  # type: ignore
     compare = np.array([[8, 7, 6, 1, 3, 1], [0, 1, 7, 5, 2, 4]])
     testing.assert_array_almost_equal(x, compare)
 
@@ -104,7 +104,7 @@ def test_basic_cloud_mask_all_values(obs_file) -> None:
 def test_mask_cloud_bits_all_values(obs_file) -> None:
     cat = CatBits()
     obj = ObservationManager("cf", str(obs_file))
-    mask = obj._classify_basic_mask(cat.category_bits)
+    mask = obj._classify_basic_mask(cat.category_bits)  # type: ignore
     x = obj._mask_cloud_bits(mask)
     compare = np.array([[0, 0, 0, 1, 1, 1], [0, 1, 0, 1, 0, 1]])
     testing.assert_array_almost_equal(x, compare)