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

cloudnetpy/categorize/__init__.py

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

cloudnetpy/categorize/atmos_utils.py

@@ -1,57 +1,245 @@
+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:
-    """Returns wet bulb temperature.
+    """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)
+
 
-    Returns wet bulb temperature for given temperature,
-    pressure and relative humidity. Algorithm is based on a Taylor
-    expansion of a simple expression for the saturated vapour pressure.
+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:
-        model_data: Model variables `temperature`, `pressure`, `rh`.
+        pressure: Pressure (Pa)
+        specific_humidity: Specific humidity (1)
 
     Returns:
-        Wet bulb temperature (K).
+        Vapor pressure (Pa)
 
     References:
-        J. Sullivan and L. D. Sanders: Method for obtaining wet-bulb
-        temperatures by modifying the psychrometric formula.
+        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 _screen_rh() -> np.ndarray:
-        rh = model_data["rh"]
-        rh_min = 1e-5
-        rh[rh < rh_min] = rh_min
-        return rh
-
-    def _vapor_derivatives() -> tuple:
-        m = 17.269
-        tn = 35.86
-        f1 = m * (tn - con.T0)
-        f2 = dew_point - tn
-        first = -vapor_pressure * f1 / (f2**2)
-        second = vapor_pressure * ((f1 / (f2**2)) ** 2 + 2 * f1 / (f2**3))
-        return first, second
-
-    relative_humidity = _screen_rh()
-    saturation_pressure = calc_saturation_vapor_pressure(model_data["temperature"])
-    vapor_pressure = saturation_pressure * relative_humidity
-    dew_point = calc_dew_point_temperature(vapor_pressure)
-    psychrometric_constant = calc_psychrometric_constant(model_data["pressure"])
-    first_der, second_der = _vapor_derivatives()
-    a = 0.5 * second_der
-    b = first_der + psychrometric_constant - dew_point * second_der
-    c = (
-        -model_data["temperature"] * psychrometric_constant
-        - dew_point * first_der
-        + 0.5 * dew_point**2 * second_der
+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 (-b + ma.sqrt(b * b - 4 * a * c)) / (2 * a)
+
+    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:
@@ -78,46 +266,77 @@ def calc_saturation_vapor_pressure(temperature: np.ndarray) -> np.ndarray:
     ) * con.HPA_TO_PA
 
 
-def calc_psychrometric_constant(pressure: np.ndarray) -> np.ndarray:
-    """Returns psychrometric constant.
-
-    Psychrometric constant relates the partial pressure
-    of water in air to the air temperature.
+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:
-        Psychrometric constant value (Pa K-1)
+        Mixing ratio (kg kg-1).
 
     """
-    return pressure * con.SPECIFIC_HEAT / (con.LATENT_HEAT * con.MW_RATIO)
+    return con.MW_RATIO * vapor_pressure / (pressure - vapor_pressure)
 
 
-def calc_dew_point_temperature(vapor_pressure: np.ndarray) -> np.ndarray:
-    """Returns dew point temperature.
+def calc_air_density(
+    pressure: np.ndarray,
+    temperature: np.ndarray,
+    svp_mixing_ratio: np.ndarray,
+) -> np.ndarray:
+    """Calculates air density (kg m-3).
 
     Args:
-        vapor_pressure: Water vapor pressure (Pa).
+        pressure: Pressure (Pa).
+        temperature: Temperature (K).
+        svp_mixing_ratio: Saturation vapor pressure mixing ratio (kg kg-1).
 
     Returns:
-        Dew point temperature (K).
+        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).
 
-    Notes:
-        Method from Vaisala's white paper: "Humidity conversion formulas".
+    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).
 
     """
-    vaisala_parameters_over_water = (6.116441, 7.591386, 240.7263)
-    a, m, tn = vaisala_parameters_over_water
-    dew_point_celsius = tn / ((m / np.log10(vapor_pressure * con.PA_TO_HPA / a)) - 1)
-    return c2k(dew_point_celsius)
+    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 c2k(temp: np.ndarray) -> np.ndarray:
-    """Converts Celsius to Kelvins."""
-    return ma.array(temp) + 273.15
+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.
 
-def k2c(temp: np.ndarray) -> np.ndarray:
-    """Converts Kelvins to Celsius."""
-    return ma.array(temp) - 273.15
+    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/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/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/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/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/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