cloudnetpy 1.65.7__tar.gz → 1.66.0__tar.gz

{cloudnetpy-1.65.7/cloudnetpy.egg-info → cloudnetpy-1.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudnetpy
-Version: 1.65.7
+Version: 1.66.0
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.65.7 → cloudnetpy-1.66.0}/cloudnetpy/categorize/__init__.py

@@ -1,2 +1 @@
 from .categorize import generate_categorize
-from .radar import Radar

cloudnetpy-1.66.0/cloudnetpy/categorize/atmos_utils.py

@@ -0,0 +1,342 @@
+import logging
+
+import numpy as np
+import numpy.typing as npt
+import scipy.constants
+from numpy import ma
+
+import cloudnetpy.constants as con
+from cloudnetpy import utils
+
+
+def calc_wet_bulb_temperature(model_data: dict) -> np.ndarray:
+    """Calculate wet-bulb temperature iteratively.
+
+    Args:
+        model_data: Model variables `temperature`, `pressure`, `q`.
+
+    Returns:
+        Wet-bulb temperature (K).
+
+    References:
+        Al-Ismaili, A. M., & Al-Azri, N. A. (2016). Simple Iterative Approach to
+        Calculate Wet-Bulb Temperature for Estimating Evaporative Cooling
+        Efficiency. Int. J. Agric. Innovations Res., 4, 1013-1018.
+    """
+    specific_humidity = model_data["q"]
+    pressure = model_data["pressure"]
+    td = k2c(model_data["temperature"])
+    vp = calc_vapor_pressure(pressure, specific_humidity)
+    W = calc_mixing_ratio(vp, pressure)
+    L_v_0 = 2501e3  # Latent heat of vaporization at 0degC (J kg-1)
+
+    def f(tw):
+        svp = calc_saturation_vapor_pressure(c2k(tw))
+        W_s = calc_mixing_ratio(svp, pressure)
+        C_p_w = 0.0265 * tw**2 - 1.7688 * tw + 4205.6  # Eq. 6 (J kg-1 C-1)
+        C_p_wv = 0.0016 * td**2 + 0.1546 * td + 1858.7  # Eq. 7 (J kg-1 C-1)
+        C_p_da = 0.0667 * ((td + tw) / 2) + 1005  # Eq. 8 (J kg-1 C-1)
+        a = (L_v_0 - (C_p_w - C_p_wv) * tw) * W_s - C_p_da * (td - tw)
+        b = L_v_0 + C_p_wv * td - C_p_w * tw
+        return a / b - W
+
+    min_err = 1e-6 * np.maximum(np.abs(td), 1)
+    delta = 1e-8
+    tw = td
+    max_iter = 20
+    for _ in range(max_iter):
+        f_tw = f(tw)
+        if np.all(np.abs(f_tw) < min_err):
+            break
+        df_tw = (f(tw + delta) - f_tw) / delta
+        tw = tw - f_tw / df_tw
+    else:
+        msg = (
+            "Wet-bulb temperature didn't converge after %d iterations: "
+            "error min %g, max %g, mean %g, median %g"
+        )
+        logging.warning(
+            msg, max_iter, np.min(f_tw), np.max(f_tw), np.mean(f_tw), np.median(f_tw)
+        )
+
+    return c2k(tw)
+
+
+def calc_vapor_pressure(
+    pressure: npt.NDArray, specific_humidity: npt.NDArray
+) -> npt.NDArray:
+    """Calculate vapor pressure of water based on pressure and specific
+    humidity.
+
+    Args:
+        pressure: Pressure (Pa)
+        specific_humidity: Specific humidity (1)
+
+    Returns:
+        Vapor pressure (Pa)
+
+    References:
+        Cai, J. (2019). Humidity Measures.
+        https://cran.r-project.org/web/packages/humidity/vignettes/humidity-measures.html
+    """
+    return (
+        specific_humidity
+        * pressure
+        / (con.MW_RATIO + (1 - con.MW_RATIO) * specific_humidity)
+    )
+
+
+def c2k(temp: np.ndarray) -> np.ndarray:
+    """Converts Celsius to Kelvins."""
+    return ma.array(temp) + 273.15
+
+
+def k2c(temp: np.ndarray) -> np.ndarray:
+    """Converts Kelvins to Celsius."""
+    return ma.array(temp) - 273.15
+
+
+def find_cloud_bases(array: np.ndarray) -> np.ndarray:
+    """Finds bases of clouds.
+
+    Args:
+        array: 2D boolean array denoting clouds or some other similar field.
+
+    Returns:
+        Boolean array indicating bases of the individual clouds.
+
+    """
+    zeros = np.zeros(array.shape[0])
+    array_padded = np.insert(array, 0, zeros, axis=1).astype(int)
+    return np.diff(array_padded, axis=1) == 1
+
+
+def find_cloud_tops(array: np.ndarray) -> np.ndarray:
+    """Finds tops of clouds.
+
+    Args:
+        array: 2D boolean array denoting clouds or some other similar field.
+
+    Returns:
+        Boolean array indicating tops of the individual clouds.
+
+    """
+    array_flipped = np.fliplr(array)
+    bases_of_flipped = find_cloud_bases(array_flipped)
+    return np.fliplr(bases_of_flipped)
+
+
+def find_lowest_cloud_bases(
+    cloud_mask: np.ndarray,
+    height: np.ndarray,
+) -> ma.MaskedArray:
+    """Finds altitudes of cloud bases."""
+    cloud_heights = cloud_mask * height
+    return _find_lowest_heights(cloud_heights)
+
+
+def find_highest_cloud_tops(
+    cloud_mask: np.ndarray,
+    height: np.ndarray,
+) -> ma.MaskedArray:
+    """Finds altitudes of cloud tops."""
+    cloud_heights = cloud_mask * height
+    cloud_heights_flipped = np.fliplr(cloud_heights)
+    return _find_lowest_heights(cloud_heights_flipped)
+
+
+def _find_lowest_heights(cloud_heights: np.ndarray) -> ma.MaskedArray:
+    inds = (cloud_heights != 0).argmax(axis=1)
+    heights = np.array([cloud_heights[i, ind] for i, ind in enumerate(inds)])
+    return ma.masked_equal(heights, 0.0)
+
+
+def fill_clouds_with_lwc_dz(
+    temperature: np.ndarray, pressure: np.ndarray, is_liquid: np.ndarray
+) -> np.ndarray:
+    """Fills liquid clouds with lwc change rate at the cloud bases.
+
+    Args:
+        temperature: 2D temperature array (K).
+        pressure: 2D pressure array (Pa).
+        is_liquid: Boolean array indicating presence of liquid clouds.
+
+    Returns:
+        Liquid water content change rate (kg m-3 m-1), so that for each cloud the base
+        value is filled for the whole cloud.
+
+    """
+    lwc_dz = get_lwc_change_rate_at_bases(temperature, pressure, is_liquid)
+    lwc_dz_filled = ma.zeros(lwc_dz.shape)
+    lwc_dz_filled[is_liquid] = utils.ffill(lwc_dz[is_liquid])
+    return lwc_dz_filled
+
+
+def get_lwc_change_rate_at_bases(
+    temperature: np.ndarray,
+    pressure: np.ndarray,
+    is_liquid: np.ndarray,
+) -> np.ndarray:
+    """Finds LWC change rate in liquid cloud bases.
+
+    Args:
+        temperature: 2D temperature array (K).
+        pressure: 2D pressure array (Pa).
+        is_liquid: Boolean array indicating presence of liquid clouds.
+
+    Returns:
+        Liquid water content change rate at cloud bases (kg m-3 m-1).
+
+    """
+    liquid_bases = find_cloud_bases(is_liquid)
+    lwc_dz = ma.zeros(liquid_bases.shape)
+    lwc_dz[liquid_bases] = calc_lwc_change_rate(
+        temperature[liquid_bases],
+        pressure[liquid_bases],
+    )
+
+    return lwc_dz
+
+
+def calc_lwc_change_rate(temperature: np.ndarray, pressure: np.ndarray) -> np.ndarray:
+    """Returns rate of change of condensable water (LWC).
+
+    Calculates the theoretical adiabatic rate of increase of LWC
+    with height, given the cloud base temperature and pressure.
+
+    Args:
+        temperature: Temperature of cloud base (K).
+        pressure: Pressure of cloud base (Pa).
+
+    Returns:
+        dlwc/dz (kg m-3 m-1)
+
+    References:
+        Brenguier, 1991, https://doi.org/10.1175/1520-0469(1991)048<0264:POTCPA>2.0.CO;2
+
+    """
+    svp = calc_saturation_vapor_pressure(temperature)
+    svp_mixing_ratio = calc_mixing_ratio(svp, pressure)
+    air_density = calc_air_density(pressure, temperature, svp_mixing_ratio)
+
+    e = 0.622
+    Cp = 1004  # J kg-1 K-1
+    Lv = 2.45e6  # J kg-1 = Pa m3 kg-1
+    qs = svp_mixing_ratio  # kg kg-1
+    pa = air_density  # kg m-3
+    es = svp  # Pa
+    P = pressure  # Pa
+    T = temperature  # K
+
+    # See Appendix B in Brenguier (1991) for the derivation of the following equation
+    dqs_dp = (
+        -(1 - (Cp * T) / (e * Lv))
+        * (((Cp * T) / (e * Lv)) + ((Lv * qs * pa) / (P - es))) ** -1
+        * (e * es)
+        * (P - es) ** -2
+    )
+
+    # Using hydrostatic equation to convert dqs_dp to dqs_dz
+    dqs_dz = dqs_dp * air_density * -scipy.constants.g
+
+    return dqs_dz * air_density
+
+
+def calc_saturation_vapor_pressure(temperature: np.ndarray) -> np.ndarray:
+    """Goff-Gratch formula for saturation vapor pressure over water adopted by WMO.
+
+    Args:
+        temperature: Temperature (K).
+
+    Returns:
+        Saturation vapor pressure (Pa).
+
+    """
+    ratio = con.T0 / temperature
+    inv_ratio = ratio**-1
+    return (
+        10
+        ** (
+            10.79574 * (1 - ratio)
+            - 5.028 * np.log10(inv_ratio)
+            + 1.50475e-4 * (1 - (10 ** (-8.2969 * (inv_ratio - 1))))
+            + 0.42873e-3 * (10 ** (4.76955 * (1 - ratio)) - 1)
+            + 0.78614
+        )
+    ) * con.HPA_TO_PA
+
+
+def calc_mixing_ratio(vapor_pressure: np.ndarray, pressure: np.ndarray) -> np.ndarray:
+    """Calculates mixing ratio from partial vapor pressure and pressure.
+
+    Args:
+        vapor_pressure: Partial pressure of water vapor (Pa).
+        pressure: Atmospheric pressure (Pa).
+
+    Returns:
+        Mixing ratio (kg kg-1).
+
+    """
+    return con.MW_RATIO * vapor_pressure / (pressure - vapor_pressure)
+
+
+def calc_air_density(
+    pressure: np.ndarray,
+    temperature: np.ndarray,
+    svp_mixing_ratio: np.ndarray,
+) -> np.ndarray:
+    """Calculates air density (kg m-3).
+
+    Args:
+        pressure: Pressure (Pa).
+        temperature: Temperature (K).
+        svp_mixing_ratio: Saturation vapor pressure mixing ratio (kg kg-1).
+
+    Returns:
+        Air density (kg m-3).
+
+    """
+    return pressure / (con.RS * temperature * (0.6 * svp_mixing_ratio + 1))
+
+
+def calc_adiabatic_lwc(lwc_dz: np.ndarray, height: np.ndarray) -> np.ndarray:
+    """Calculates adiabatic liquid water content (kg m-3).
+
+    Args:
+        lwc_dz: Liquid water content change rate (kg m-3 m-1) calculated at the
+            base of each cloud and filled to that cloud.
+        height: Height vector (m).
+
+    Returns:
+        Liquid water content (kg m-3).
+
+    """
+    is_cloud = lwc_dz != 0
+    cloud_indices = utils.cumsumr(is_cloud, axis=1)
+    dz = utils.path_lengths_from_ground(height) * np.ones_like(lwc_dz)
+    dz[cloud_indices < 1] = 0
+    return utils.cumsumr(dz, axis=1) * lwc_dz
+
+
+def normalize_lwc_by_lwp(
+    lwc_adiabatic: np.ndarray, lwp: np.ndarray, height: np.ndarray
+) -> np.ndarray:
+    """Finds LWC that would produce measured LWP.
+
+    Calculates LWP-weighted, normalized LWC. This is the measured
+    LWP distributed to liquid cloud pixels according to their
+    theoretical proportion.
+
+    Args:
+        lwc_adiabatic: Theoretical 2D liquid water content (kg m-3).
+        lwp: 1D liquid water path (kg m-2).
+        height: Height vector (m).
+
+    Returns:
+        2D LWP-weighted, scaled LWC (kg m-3) that would produce the observed LWP.
+
+    """
+    path_lengths = utils.path_lengths_from_ground(height)
+    theoretical_lwp = ma.sum(lwc_adiabatic * path_lengths, axis=1)
+    scaling_factors = lwp / theoretical_lwp
+    return lwc_adiabatic * utils.transpose(scaling_factors)

cloudnetpy-1.66.0/cloudnetpy/categorize/attenuation.py

@@ -0,0 +1,31 @@
+from numpy import ma
+
+from cloudnetpy.categorize.attenuations import (
+    RadarAttenuation,
+    gas_attenuation,
+    liquid_attenuation,
+    melting_attenuation,
+    rain_attenuation,
+)
+from cloudnetpy.categorize.containers import ClassificationResult, Observations
+
+
+def get_attenuations(
+    data: Observations, classification: ClassificationResult
+) -> RadarAttenuation:
+    rain = rain_attenuation.calc_rain_attenuation(data, classification)
+    gas = gas_attenuation.calc_gas_attenuation(data, classification)
+    liquid = liquid_attenuation.LiquidAttenuation(data, classification).attenuation
+    melting = melting_attenuation.calc_melting_attenuation(data, classification)
+
+    liquid.amount[rain.attenuated] = ma.masked
+    liquid.error[rain.attenuated] = ma.masked
+    liquid.attenuated[rain.attenuated] = False
+    liquid.uncorrected[rain.attenuated] = False
+
+    return RadarAttenuation(
+        gas=gas,
+        liquid=liquid,
+        rain=rain,
+        melting=melting,
+    )

cloudnetpy-1.66.0/cloudnetpy/categorize/attenuations/__init__.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+import numpy as np
+from numpy import ma
+from numpy.typing import NDArray
+
+from cloudnetpy import constants as con
+from cloudnetpy.utils import path_lengths_from_ground
+
+
+@dataclass
+class Attenuation:
+    amount: Annotated[ma.MaskedArray, "float32"]
+    error: Annotated[ma.MaskedArray, "float32"]
+    attenuated: NDArray[np.bool_]
+    uncorrected: NDArray[np.bool_]
+
+
+@dataclass
+class RadarAttenuation:
+    gas: Attenuation
+    liquid: Attenuation
+    rain: Attenuation
+    melting: Attenuation
+
+
+def calc_two_way_attenuation(
+    height: np.ndarray, specific_attenuation: ma.MaskedArray
+) -> ma.MaskedArray:
+    """Calculates two-way attenuation (dB) for given specific attenuation
+    (dB km-1) and height (m).
+    """
+    path_lengths = path_lengths_from_ground(height) * con.M_TO_KM  # km
+    one_way_attenuation = specific_attenuation * path_lengths
+    accumulated_attenuation = ma.cumsum(one_way_attenuation, axis=1)
+    return accumulated_attenuation * con.TWO_WAY

cloudnetpy-1.66.0/cloudnetpy/categorize/attenuations/gas_attenuation.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+from cloudnetpy.categorize.attenuations import (
+    Attenuation,
+    calc_two_way_attenuation,
+)
+from cloudnetpy.categorize.containers import ClassificationResult, Observations
+
+
+def calc_gas_attenuation(
+    data: Observations, classification: ClassificationResult
+) -> Attenuation:
+    model_data = data.model.data_dense
+
+    specific_attenuation = model_data["specific_gas_atten"].copy()
+    saturated_attenuation = model_data["specific_saturated_gas_atten"]
+
+    liquid_in_pixel = classification.category_bits.droplet
+    specific_attenuation[liquid_in_pixel] = saturated_attenuation[liquid_in_pixel]
+
+    two_way_attenuation = calc_two_way_attenuation(
+        data.radar.height, specific_attenuation
+    )
+
+    return Attenuation(
+        amount=two_way_attenuation,
+        error=two_way_attenuation * 0.1,
+        attenuated=np.ones_like(two_way_attenuation, dtype=bool),
+        uncorrected=np.zeros_like(two_way_attenuation, dtype=bool),
+    )

cloudnetpy-1.66.0/cloudnetpy/categorize/attenuations/liquid_attenuation.py

@@ -0,0 +1,80 @@
+import numpy as np
+from numpy import ma
+
+import cloudnetpy.constants as con
+from cloudnetpy import utils
+from cloudnetpy.categorize import atmos_utils
+from cloudnetpy.categorize.attenuations import Attenuation, calc_two_way_attenuation
+from cloudnetpy.categorize.containers import ClassificationResult, Observations
+
+
+class LiquidAttenuation:
+    """Class for calculating liquid attenuation.
+
+    References:
+        Hogan, Robin & Connor, Ewan. (2004). Facilitating cloud radar and lidar
+        algorithms: the Cloudnet Instrument Synergy/Target Categorization product.
+    """
+
+    def __init__(self, data: Observations, classification: ClassificationResult):
+        self._model = data.model.data_dense
+        self._liquid_in_pixel = classification.category_bits.droplet
+        self._height = data.radar.height
+
+        if data.mwr is not None:
+            lwp = data.mwr.data["lwp"][:]
+            lwp_error = data.mwr.data["lwp_error"][:]
+        else:
+            lwp = ma.masked_all(data.radar.time.size)
+            lwp_error = ma.masked_all(data.radar.time.size)
+
+        lwc_dz = atmos_utils.fill_clouds_with_lwc_dz(
+            self._model["temperature"], self._model["pressure"], self._liquid_in_pixel
+        )
+
+        two_way_attenuation = self._calc_liquid_atten(lwp, lwc_dz)
+        two_way_attenuation_error = self._calc_liquid_atten_err(lwp_error, lwc_dz)
+
+        attenuated = utils.ffill(self._liquid_in_pixel)
+
+        two_way_attenuation[~attenuated] = ma.masked
+        two_way_attenuation_error[~attenuated] = ma.masked
+
+        uncorrected = attenuated & two_way_attenuation.mask
+
+        self.attenuation = Attenuation(
+            amount=two_way_attenuation,
+            error=two_way_attenuation_error,
+            attenuated=attenuated,
+            uncorrected=uncorrected,
+        )
+
+    def _calc_liquid_atten(
+        self, lwp: ma.MaskedArray, lwc_dz: np.ndarray
+    ) -> ma.MaskedArray:
+        """Finds radar liquid attenuation."""
+        lwp = lwp.copy()
+        lwp[lwp < 0] = 0
+        lwc_adiabatic = atmos_utils.calc_adiabatic_lwc(lwc_dz, self._height)
+        lwc_scaled = atmos_utils.normalize_lwc_by_lwp(lwc_adiabatic, lwp, self._height)
+        return self._calc_two_way_attenuation(lwc_scaled)
+
+    def _calc_liquid_atten_err(
+        self, lwp_error: ma.MaskedArray, lwc_dz: np.ndarray
+    ) -> ma.MaskedArray:
+        """Finds radar liquid attenuation error."""
+        lwc_err_scaled = atmos_utils.normalize_lwc_by_lwp(
+            lwc_dz, lwp_error, self._height
+        )
+        return self._calc_two_way_attenuation(lwc_err_scaled)
+
+    def _calc_two_way_attenuation(self, lwc_scaled: np.ndarray) -> ma.MaskedArray:
+        """Calculates liquid attenuation (dB).
+
+        Args:
+            lwc_scaled: Liquid water content (kg m-3).
+
+        """
+        specific_attenuation_rate = self._model["specific_liquid_atten"]
+        specific_attenuation = specific_attenuation_rate * lwc_scaled * con.KG_TO_G
+        return calc_two_way_attenuation(self._height, specific_attenuation)

cloudnetpy-1.66.0/cloudnetpy/categorize/attenuations/melting_attenuation.py

@@ -0,0 +1,75 @@
+import numpy as np
+from numpy import ma
+
+import cloudnetpy.constants as con
+from cloudnetpy import utils
+from cloudnetpy.categorize.attenuations import (
+    Attenuation,
+)
+from cloudnetpy.categorize.containers import ClassificationResult, Observations
+
+
+def calc_melting_attenuation(
+    data: Observations, classification: ClassificationResult
+) -> Attenuation:
+    shape = classification.category_bits.melting.shape
+    is_rain = classification.is_rain
+
+    affected_region = classification.category_bits.freezing.copy()
+
+    if data.disdrometer is None:
+        affected_region[~is_rain, :] = False
+        above_melting = utils.ffill(classification.category_bits.melting)
+        affected_region[~above_melting] = False
+        return Attenuation(
+            amount=ma.masked_all(shape),
+            error=ma.masked_all(shape),
+            attenuated=affected_region,
+            uncorrected=affected_region,
+        )
+
+    rainfall_rate = data.disdrometer.data["rainfall_rate"][:]
+    frequency = data.radar.radar_frequency
+
+    attenuation_array = _calc_melting_attenuation(rainfall_rate, frequency)
+
+    amount = affected_region * utils.transpose(attenuation_array)
+
+    affected_region[amount == 0] = False
+
+    amount[amount == 0] = ma.masked
+
+    band = utils.get_wl_band(data.radar.radar_frequency)
+    error_factor = 0.2 if band == 0 else 0.1
+
+    error = amount * error_factor
+    error[~affected_region] = ma.masked
+
+    return Attenuation(
+        amount=amount,
+        error=error,
+        attenuated=affected_region,
+        uncorrected=affected_region & amount.mask,
+    )
+
+
+def _calc_melting_attenuation(
+    rainfall_rate: np.ndarray, frequency: float
+) -> np.ndarray:
+    """Calculates total attenuation due to melting layer (dB).
+
+    References:
+        Li, H., & Moisseev, D. (2019). Melting layer attenuation
+        at Ka- and W-bands as derived from multifrequency radar
+        Doppler spectra observations. Journal of Geophysical
+        Research: Atmospheres, 124, 9520–9533. https://doi.org/10.1029/2019JD030316
+
+    """
+    if frequency > 34 and frequency < 37:
+        a, b = 0.97, 0.61
+    elif frequency > 93 and frequency < 96:
+        a, b = 2.9, 0.42
+    else:
+        msg = "Radar frequency not supported"
+        raise ValueError(msg)
+    return a * (rainfall_rate * con.M_S_TO_MM_H) ** b

cloudnetpy-1.66.0/cloudnetpy/categorize/attenuations/rain_attenuation.py

@@ -0,0 +1,84 @@
+import numpy as np
+from numpy import ma
+from numpy.typing import NDArray
+
+import cloudnetpy.constants as con
+from cloudnetpy import utils
+from cloudnetpy.categorize.attenuations import (
+    Attenuation,
+    calc_two_way_attenuation,
+)
+from cloudnetpy.categorize.containers import ClassificationResult, Observations
+
+
+def calc_rain_attenuation(
+    data: Observations, classification: ClassificationResult
+) -> Attenuation:
+    affected_region, inducing_region = _find_regions(classification)
+    shape = affected_region.shape
+
+    if data.disdrometer is None:
+        return Attenuation(
+            amount=ma.masked_all(shape),
+            error=ma.masked_all(shape),
+            attenuated=affected_region,
+            uncorrected=affected_region,
+        )
+
+    rainfall_rate = data.disdrometer.data["rainfall_rate"][:].copy()
+    rainfall_rate[classification.is_rain == 0] = ma.masked
+    frequency = data.radar.radar_frequency
+
+    specific_attenuation_array = _calc_rain_specific_attenuation(
+        rainfall_rate, frequency
+    )
+
+    specific_attenuation = utils.transpose(specific_attenuation_array) * ma.ones(shape)
+
+    two_way_attenuation = calc_two_way_attenuation(
+        data.radar.height, specific_attenuation
+    )
+
+    two_way_attenuation[~inducing_region] = 0
+    two_way_attenuation = ma.array(utils.ffill(two_way_attenuation.data))
+    two_way_attenuation[two_way_attenuation == 0] = ma.masked
+
+    return Attenuation(
+        amount=two_way_attenuation,
+        error=two_way_attenuation * 0.2,
+        attenuated=affected_region,
+        uncorrected=np.zeros_like(affected_region, dtype=bool),
+    )
+
+
+def _find_regions(
+    classification: ClassificationResult,
+) -> tuple[NDArray[np.bool_], NDArray[np.bool_]]:
+    """Finds regions where rain attenuation is present and can be corrected or not."""
+    warm_region = ~classification.category_bits.freezing
+    is_rain = utils.transpose(classification.is_rain).astype(bool)
+    affected_region = np.ones_like(warm_region, dtype=bool) * is_rain
+    inducing_region = warm_region * is_rain
+    return affected_region, inducing_region
+
+
+def _calc_rain_specific_attenuation(
+    rainfall_rate: np.ndarray, frequency: float
+) -> np.ndarray:
+    """Calculates specific attenuation due to rain (dB km-1).
+
+    References:
+        Crane, R. (1980). Prediction of Attenuation by Rain.
+        IEEE Transactions on Communications, 28(9), 1717–1733.
+        doi:10.1109/tcom.1980.1094844
+    """
+    if frequency > 8 and frequency < 12:
+        alpha, beta = 0.0125, 1.18
+    if frequency > 34 and frequency < 37:
+        alpha, beta = 0.242, 1.04
+    elif frequency > 93 and frequency < 96:
+        alpha, beta = 0.95, 0.72
+    else:
+        msg = "Radar frequency not supported"
+        raise ValueError(msg)
+    return alpha * (rainfall_rate * con.M_S_TO_MM_H) ** beta