disdrodb 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

disdrodb/fall_velocity/hail.py

@@ -0,0 +1,288 @@
+# -----------------------------------------------------------------------------.
+# Copyright (c) 2021-2026 DISDRODB developers
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# -----------------------------------------------------------------------------.
+"""Theoretical models to estimate hailstones fall velocity based on particle maximum diameter in mm."""
+
+import numpy as np
+import xarray as xr
+
+from disdrodb.constants import DIAMETER_DIMENSION
+from disdrodb.l0.l0b_processing import ensure_valid_geolocation
+from disdrodb.l1_env.routines import load_env_dataset
+from disdrodb.physics.wrappers import retrieve_air_pressure
+from disdrodb.utils.warnings import suppress_warnings
+
+
+def get_fall_velocity_laurie_1960(diameter):
+    """Get hailstones fall velocity based on Laurie 1960 data.
+
+    The parametrizazion is reported in Table 3 of Heymsfield et al., 2018.
+
+    Parameters
+    ----------
+    diameter : array-like or float
+        Particle maximum diameter in millimeters [mm].
+
+
+    Returns
+    -------
+    fall_velocity : array-like or float
+        Terminal fall velocity [m s⁻¹].
+
+    References
+    ----------
+    Heymsfield, A., M. Szakáll, A. Jost, I. Giammanco, and R. Wright, 2018.
+    A Comprehensive Observational Study of Graupel and Hail Terminal Velocity, Mass Flux, and Kinetic Energy.
+    J. Atmos. Sci., 75, 3861-3885, https://doi.org/10.1175/JAS-D-18-0035.1.
+    """
+    fall_velocity = 13.95 * (0.1 * diameter) ** 0.51
+    return fall_velocity
+
+
+def get_fall_velocity_knight_1983_low_density(diameter):
+    """Get low-density hailstones fall velocity based on Knight et al. 1983.
+
+    The parametrization is reported in Figure 3 of Knight et al. 1983.
+    It's valid for hail stone density between 0.31 and 0.61 g cm-3.
+
+    Parameters
+    ----------
+    diameter : array-like or float
+        Particle maximum diameter in millimeters [mm].
+
+
+    Returns
+    -------
+    fall_velocity : array-like or float
+        Terminal fall velocity [m s⁻¹].
+
+    References
+    ----------
+    Knight, N. C., and A. J. Heymsfield, 1983.
+    Measurement and Interpretation of Hailstone Density and Terminal Velocity.
+    J. Atmos. Sci., 40, 1510-1516. https://doi.org/10.1175/1520-0469(1983)040<1510:MAIOHD>2.0.CO;2.
+    """
+    fall_velocity = 8.445 * (0.1 * diameter) ** 0.553
+    return fall_velocity
+
+
+def get_fall_velocity_knight_1983_high_density(diameter):
+    """Get low-density hailstones fall velocity based on Knight et al. 1983.
+
+    The parametrization is reported in Figure 6 of Knight et al. 1983.
+    It's valid for hail stone density around 0.82 g cm-3.
+
+    Parameters
+    ----------
+    diameter : array-like or float
+        Particle maximum diameter in millimeters [mm].
+
+
+    Returns
+    -------
+    fall_velocity : array-like or float
+        Terminal fall velocity [m s⁻¹].
+
+    References
+    ----------
+    Knight, N. C., and A. J. Heymsfield, 1983.
+    Measurement and Interpretation of Hailstone Density and Terminal Velocity.
+    J. Atmos. Sci., 40, 1510-1516. https://doi.org/10.1175/1520-0469(1983)040<1510:MAIOHD>2.0.CO;2.
+    """
+    fall_velocity = 10.58 * (0.1 * diameter) ** 0.267
+    return fall_velocity
+
+
+def get_fall_velocity_heymsfield_2014(diameter):
+    """Get hail fall velocity from Heymsfield et al., 2014.
+
+    Use the Heymsfield et al., 2014 parameterization.
+
+    Parameters
+    ----------
+    diameter : array-like or float
+        Maximum Particle maximum diameter in millimeters [mm].
+
+    Returns
+    -------
+    fall_velocity : xarray.DataArray or numpy.ndarray
+        Terminal fall velocity [m s⁻¹].
+
+    References
+    ----------
+    Heymsfield, A. J., I. M. Giammanco, and R. Wright (2014).
+    Terminal velocities and kinetic energies of natural hailstones.
+    Geophys. Res. Lett., 41, 8666-8672, https://doi.org/10.1002/2014GL062324
+    """
+    fall_velocity = 12.28 * (0.1 * diameter) ** 0.57  # Dmax > 1.3 mm
+    return fall_velocity
+
+
+def get_fall_velocity_heymsfield_2018(diameter):
+    """Get hailstones fall velocity from Heymsfield et al., 2018.
+
+    Parameters
+    ----------
+    diameter : array-like or float
+        Particle maximum diameter in millimeters [mm].
+
+    Returns
+    -------
+    fall_velocity : array-like or float
+        Terminal fall velocity [m s⁻¹].
+
+    References
+    ----------
+    Heymsfield, A., M. Szakáll, A. Jost, I. Giammanco, and R. Wright, 2018.
+    A Comprehensive Observational Study of Graupel and Hail Terminal Velocity, Mass Flux, and Kinetic Energy.
+    J. Atmos. Sci., 75, 3861-3885, https://doi.org/10.1175/JAS-D-18-0035.1.
+
+    Heymsfield, A., M. Szakáll, A. Jost, I. Giammanco, R. Wright, and J. Brimelow, 2020.
+    CORRIGENDUM.
+    J. Atmos. Sci., 77, 405-412, https://doi.org/10.1175/JAS-D-19-0185.1.
+    """
+    # Original incorrect formula from Heymsfield et al., 2018
+    # fall_velocity = 6.1 * (0.1 * diameter) ** 0.72  # eq 7 and 15
+
+    # Corrected formula from Heymsfield et al., 2020 (Corrigendum)
+    fall_velocity = 8.39 * (0.1 * diameter) ** 0.67
+    return fall_velocity
+
+
+def get_fall_velocity_fehlmann_2020(diameter):
+    """Get hailstones fall velocity from Fehlmann et al., 2020."""
+    fall_velocity = 3.74 * diameter**0.5
+    return fall_velocity
+
+
+####------------------------------------------------------------------------------------
+#### Wrappers
+
+
+HAIL_FALL_VELOCITY_MODELS = {
+    "Laurie1960": get_fall_velocity_laurie_1960,
+    "Knight1983LD": get_fall_velocity_knight_1983_low_density,
+    "Knight1983HD": get_fall_velocity_knight_1983_high_density,
+    "Heymsfield2014": get_fall_velocity_heymsfield_2014,
+    "Heymsfield2018": get_fall_velocity_heymsfield_2018,
+    "Fehlmann2020": get_fall_velocity_fehlmann_2020,
+}
+
+
+def available_hail_fall_velocity_models():
+    """Return a list of the available hail fall velocity models."""
+    return list(HAIL_FALL_VELOCITY_MODELS)
+
+
+def check_hail_fall_velocity_model(model):
+    """Check validity of the specified hail fall velocity model."""
+    available_models = available_hail_fall_velocity_models()
+    if model not in available_models:
+        raise ValueError(f"{model} is an invalid hail fall velocity model. Valid models: {available_models}.")
+    return model
+
+
+def get_hail_fall_velocity_model(model):
+    """Return the specified hail fall velocity model.
+
+    Parameters
+    ----------
+    model : str
+        The model to use for calculating the rain drop fall velocity. Available models are:
+       'Laurie1960', 'Knight1983LD', 'Knight1983HD', 'Heymsfield2014', 'Heymsfield2018', 'Fehlmann2020'.
+
+    Returns
+    -------
+    callable
+        A function which compute the hail fall velocity model
+        given the rain drop diameter in mm.
+
+    Notes
+    -----
+    This function serves as a wrapper to various hail fall velocity models.
+    It returns the appropriate model based on the `model` parameter.
+    """
+    model = check_hail_fall_velocity_model(model)
+    return HAIL_FALL_VELOCITY_MODELS[model]
+
+
+def get_hail_fall_velocity(diameter, model, ds_env=None, minimum_diameter=4):
+    """Calculate the fall velocity of hails based on their diameter.
+
+    Parameters
+    ----------
+    diameter : array-like
+        The diameter of the hails in millimeters.
+    model : str
+        The model to use for calculating the hail fall velocity. Must be one of the following:
+       'Laurie1960', 'Knight1983LD', 'Knight1983HD', 'Heymsfield2014', 'Heymsfield2018', 'Fehlmann2020'.
+    ds_env : xr.Dataset, optional
+        A dataset containing the following environmental variables:
+        - 'altitude' (m)
+        - 'latitude' (°)
+        - 'temperature' : Temperature in degrees Kelvin (K).
+        - 'relative_humidity' :  Relative humidity. A value between 0 and 1.
+        - 'sea_level_air_pressure' : Sea level air pressure in Pascals (Pa).
+        - 'lapse_rate' : Lapse rate in degrees Celsius per meter (°C/m).
+        If not specified, sensible default values are used.
+
+    Returns
+    -------
+    fall_velocity : xr.DataArray
+        The calculated hail fall velocities per diameter.
+
+    """
+    # Check valid method
+    model = check_hail_fall_velocity_model(model)
+
+    # Copy diameter
+    if isinstance(diameter, xr.DataArray):
+        diameter = diameter.copy()
+    else:
+        diameter = np.atleast_1d(diameter)
+        diameter = xr.DataArray(diameter, dims=DIAMETER_DIMENSION, coords={DIAMETER_DIMENSION: diameter.copy()})
+
+    # Initialize ds_env if None
+    # --> Ensure valid altitude and geolocation
+    # - altitude requiredto correct for elevation (air_density)
+    # - latitude required for gravity
+    if ds_env is None:
+        ds_env = load_env_dataset()
+        for coord in ["altitude", "latitude"]:
+            ds_env = ensure_valid_geolocation(ds_env, coord=coord, errors="raise")
+
+    # Retrieve fall velocity
+    func = get_hail_fall_velocity_model(model)
+    with suppress_warnings():  # e.g. when diameter = 0
+        fall_velocity = func(diameter)
+
+    # Correct for altitude
+    air_pressure = retrieve_air_pressure(ds_env)
+    correction_factor = (101325 / air_pressure) ** 0.545
+    fall_velocity = fall_velocity * correction_factor
+
+    # Set to NaN for diameter outside [5, ...)
+    fall_velocity = fall_velocity.where(diameter > minimum_diameter)
+
+    # Ensure fall velocity is > 0 to avoid division by zero
+    # - Some models, at small diameter, can return negative/zero fall velocity
+    fall_velocity = fall_velocity.where(fall_velocity > 0)
+
+    # Add attributes
+    fall_velocity.name = "fall_velocity"
+    fall_velocity.attrs["units"] = "m/s"
+    fall_velocity.attrs["model"] = model
+    return fall_velocity.squeeze()

disdrodb/{l1/fall_velocity.py → fall_velocity/rain.py}

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,12 +15,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Theoretical models to estimate the raindrop fall velocity based on drop diameter in mm."""
+
 import numpy as np
 import xarray as xr
 
 from disdrodb.constants import DIAMETER_DIMENSION
 from disdrodb.l0.l0b_processing import ensure_valid_geolocation
 from disdrodb.l1_env.routines import load_env_dataset
+from disdrodb.physics.wrappers import retrieve_air_density
 from disdrodb.utils.warnings import suppress_warnings
 
 
@@ -138,8 +140,159 @@ def get_fall_velocity_van_dijk_2002(diameter):
     return fall_velocity
 
 
-def get_fall_velocity_beard_1976(diameter, ds_env):
-    """Calculate the fall velocity of a particle using the Beard (1976) model.
+####---------------------------------------------------------------------------.
+#### Beard model
+
+
+def get_raindrop_reynolds_number(diameter, temperature, air_density, water_density, g):
+    """Compute raindrop Reynolds number.
+
+    It quantifies the relative strength of the convective inertia and linear viscous
+    forces acting on the drop at terminal velocity.
+
+    Estimates Reynolds number for drops with diameter between 19 um and 7 mm.
+    Coefficients are taken from Table 1 of Beard 1976.
+
+    Reference: Beard 1976; Pruppacher & Klett 1978
+    See also Table A1 in Rahman et al., 2020.
+
+    Parameters
+    ----------
+    diameter : float
+        Diameter of the raindrop in meters.
+    temperature : float
+        Temperature in Kelvin.
+    air_density : float
+        Density of air in kg/m^3.
+    water_density : float
+        Density of water in kg/m^3.
+    g : float
+        Gravitational acceleration in m/s^2.
+
+    Returns
+    -------
+    float
+        Reynolds number for the raindrop.
+    """
+    from disdrodb.physics.atmosphere import get_air_dynamic_viscosity
+    from disdrodb.physics.water import get_pure_water_surface_tension
+
+    # Define mask for small and large particles
+    small_diam_mask = diameter < 1.07e-3  # < 1mm
+
+    # Compute properties
+    pure_water_surface_tension = get_pure_water_surface_tension(temperature)  # N/m
+    air_viscosity = get_air_dynamic_viscosity(temperature)  # kg/(m*s) (aka Pa*s).
+    delta_density = water_density - air_density
+
+    # Compute Davies number for small droplets
+    davis_number = 4 * air_density * delta_density * g * diameter**3 / (3 * air_viscosity**2)
+
+    # Compute the slip correction (is approx 1 and can be discarded)
+    # l0 = 6.62*1e-8  # m
+    # v0 = 0.01818  # g / m / s
+    # p0 = 101_325_25 # Pa
+    # t0 = 293.15 # K
+    # c_sc = 1 + 2.51*l0*(air_viscosity/v0)*(air_pressure/p0)*((temperature/t0)**3)/diameter
+
+    # Compute modified Bond and physical property numbers for large droplets
+    bond_number = 4 * delta_density * g * diameter**2 / (3 * pure_water_surface_tension)
+    property_number = pure_water_surface_tension**3 * air_density**2 / (air_viscosity**4 * delta_density * g)
+
+    # Compute Reynolds_number_for small particles (diameter < 0.00107) (1 mm)
+    b = [-3.18657, 0.992696, -0.00153193, -0.000987059, -0.000578878, 0.0000855176, -0.00000327815]
+    x = np.log(davis_number)
+    y = b[0] + sum(b * x**i for i, b in enumerate(b[1:], start=1))
+    reynolds_number_small = np.exp(y)  # TODO: miss C_sc = slip correction factor ?
+
+    # Compute Reynolds_number_for large particles (diameter >= 0.00107)
+    b = [-5.00015, 5.23778, -2.04914, 0.475294, -0.0542819, 0.00238449]
+    log_property_number = np.log(property_number) / 6
+    x = np.log(bond_number) + log_property_number
+    y = b[0] + sum(b * x**i for i, b in enumerate(b[1:], start=1))
+    reynolds_number_large = np.exp(log_property_number + y)
+
+    # Define final reynolds number
+    reynolds_number = xr.where(small_diam_mask, reynolds_number_small, reynolds_number_large)
+    return reynolds_number
+
+
+def get_drag_coefficient(diameter, air_density, water_density, fall_velocity, g=9.81):
+    """
+    Computes the drag coefficient for a raindrop.
+
+    Parameters
+    ----------
+    diameter : float
+        Diameter of the raindrop in meters.
+    air_density : float
+        Density of air in kg/m^3.
+    water_density : float
+        Density of water in kg/m^3.
+    fall_velocity : float
+        Terminal fall velocity of the raindrop in m/s.
+    g : float
+        Gravitational acceleration in m/s^2.
+
+    Returns
+    -------
+    float
+        Drag coefficient of the raindrop.
+    """
+    delta_density = water_density - air_density
+    drag_coefficient = 4 * delta_density * g * diameter / (3 * air_density * fall_velocity**2)
+    return drag_coefficient
+
+
+def get_raindrop_beard1976_fall_velocity(diameter, temperature, air_density, water_density, g):
+    """
+    Computes the terminal fall velocity of a raindrop in still air.
+
+    Reference: Beard 1976; Pruppacher & Klett 1978
+
+    Parameters
+    ----------
+    diameter : float
+        Diameter of the raindrop in millimeters.
+    temperature : float
+        Temperature in Kelvin.
+    air_density : float
+        Density of air in kg/m^3.
+    water_density : float
+        Density of water in kg/m^3.
+    g : float
+        Gravitational acceleration in m/s^2.
+
+    Returns
+    -------
+    float
+        Terminal fall velocity of the raindrop in m/s.
+    """
+    from disdrodb.physics.atmosphere import get_air_dynamic_viscosity
+
+    # Convert diameter to meter
+    diameter = diameter / 1000
+
+    # Compute air viscotiy and reynolds number
+    air_viscosity = get_air_dynamic_viscosity(temperature)
+    reynolds_number = get_raindrop_reynolds_number(
+        diameter=diameter,
+        temperature=temperature,
+        air_density=air_density,
+        water_density=water_density,
+        g=g,
+    )
+    # Compute fall velocity
+    fall_velocity = air_viscosity * reynolds_number / (air_density * diameter)
+    return fall_velocity
+
+
+def retrieve_raindrop_beard_fall_velocity(
+    diameter,
+    ds_env,
+):
+    """
+    Computes the terminal fall velocity for liquid raindrops using the Beard (1976) model.
 
     Parameters
     ----------
@@ -150,56 +303,118 @@ def get_fall_velocity_beard_1976(diameter, ds_env):
         - 'altitude' :  Altitude in meters (m).
         - 'latitude' :  Latitude in degrees.
         - 'temperature' : Temperature in degrees Kelvin (K).
-        - 'relative_humidity' :  Relative humidity in percentage (%).
-        - 'sea_level_air_pressure' : Sea level air pressure in Pascals (Pa).
-        - 'air_pressure': Air pressure in Pascals (Pa).
-        - 'lapse_rate' : Lapse rate in degrees Celsius per meter (°C/m).
+        - 'relative_humidity' :  Relative humidity between 0 and 1.
+        - 'sea_level_air_pressure' : Standard atmospheric pressure at sea level in Pascals (Pa).
+        The default is 101_325 Pa.
+        - 'air_pressure': Air pressure in Pascals (Pa). If None, air_pressure at altitude is inferred.
+        - 'lapse_rate' : Atmospheric lapse rate in degrees Celsius or Kelvin per meter (°C/m).
+        The default is 0.0065 K/m.
+        - 'gas_constant_dry_air': Gas constant for dry air in J/(kg*K).
+        The default is 287.04 is J/(kg*K).
 
     Returns
     -------
     fall_velocity : array-like
-        The calculated fall velocities of the raindrops.
+        Terminal fall velocity for liquid raindrops.
     """
-    from disdrodb.l1.beard_model import retrieve_fall_velocity
-
-    # Input diameter in mmm
-    fall_velocity = retrieve_fall_velocity(
-        diameter=diameter / 1000,  # diameter expected in m !!!
-        altitude=ds_env["altitude"],
-        latitude=ds_env["latitude"],
-        temperature=ds_env["temperature"],
-        relative_humidity=ds_env["relative_humidity"],
-        air_pressure=ds_env.get("air_pressure", None),
-        sea_level_air_pressure=ds_env["sea_level_air_pressure"],
-        lapse_rate=ds_env["lapse_rate"],
+    from disdrodb.physics.atmosphere import (
+        get_air_density,
+        get_air_pressure_at_height,
+        get_gravitational_acceleration,
+        get_vapor_actual_pressure,
+    )
+    from disdrodb.physics.water import get_water_density
+
+    # Retrieve relevant variables from ENV dataset
+    altitude = ds_env["altitude"]
+    latitude = ds_env["latitude"]
+    temperature = ds_env["temperature"]
+    relative_humidity = ds_env["relative_humidity"]
+    air_pressure = ds_env.get("air_pressure", None)
+    sea_level_air_pressure = ds_env.get("sea_level_air_pressure", 101_325)
+    gas_constant_dry_air = ds_env.get("gas_constant_dry_air", 287.04)
+    lapse_rate = ds_env.get("lapse_rate", 0.0065)
+
+    # Retrieve air pressure at altitude if not specified
+    if air_pressure is None:
+        air_pressure = get_air_pressure_at_height(
+            altitude=altitude,
+            latitude=latitude,
+            temperature=temperature,
+            sea_level_air_pressure=sea_level_air_pressure,
+            lapse_rate=lapse_rate,
+            gas_constant_dry_air=gas_constant_dry_air,
+        )
+
+    # Retrieve vapour pressure (from relative humidity)
+    vapor_pressure = get_vapor_actual_pressure(
+        relative_humidity=relative_humidity,
+        temperature=temperature,
     )
+
+    # Retrieve air density
+    air_density = get_air_density(
+        temperature=temperature,
+        air_pressure=air_pressure,
+        vapor_pressure=vapor_pressure,
+        gas_constant_dry_air=gas_constant_dry_air,
+    )
+
+    # Retrieve water density
+    water_density = get_water_density(
+        temperature=temperature,
+        air_pressure=air_pressure,
+        sea_level_air_pressure=sea_level_air_pressure,
+    )
+
+    # Retrieve accurate gravitational_acceleration
+    g = get_gravitational_acceleration(altitude=altitude, latitude=latitude)
+
+    # Compute fall velocity
+    fall_velocity = get_raindrop_beard1976_fall_velocity(
+        diameter=diameter,
+        temperature=temperature,
+        air_density=air_density,
+        water_density=water_density,
+        g=g,
+    )
+
+    # drag_coefficient = get_drag_coefficient(diameter=diameter,
+    #                                         air_density=air_density,
+    #                                         water_density=water_density,
+    #                                         g=g.
+    #                                         fall_velocity=fall_velocity)
+
+    # Clip output
     fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
-RAINDROP_FALL_VELOCITY_MODELS = {
+#### --------------------------------------------------------------------------------------
+#### WRAPPERS
+RAIN_FALL_VELOCITY_MODELS = {
     "Atlas1973": get_fall_velocity_atlas_1973,
-    "Beard1976": get_fall_velocity_beard_1976,
+    "Beard1976": retrieve_raindrop_beard_fall_velocity,
     "Brandes2002": get_fall_velocity_brandes_2002,
     "Uplinger1981": get_fall_velocity_uplinger_1981,
     "VanDijk2002": get_fall_velocity_van_dijk_2002,
 }
 
 
-def available_raindrop_fall_velocity_models():
+def available_rain_fall_velocity_models():
     """Return a list of the available raindrop fall velocity models."""
-    return list(RAINDROP_FALL_VELOCITY_MODELS)
+    return list(RAIN_FALL_VELOCITY_MODELS)
 
 
-def check_raindrop_fall_velocity_model(model):
+def check_rain_fall_velocity_model(model):
     """Check validity of the specified raindrop fall velocity model."""
-    available_models = available_raindrop_fall_velocity_models()
+    available_models = available_rain_fall_velocity_models()
     if model not in available_models:
         raise ValueError(f"{model} is an invalid raindrop fall velocity model. Valid models: {available_models}.")
     return model
 
 
-def get_raindrop_fall_velocity_model(model):
+def get_rain_fall_velocity_model(model):
     """Return the specified raindrop fall velocity model.
 
     Parameters
@@ -219,11 +434,11 @@ def get_raindrop_fall_velocity_model(model):
     This function serves as a wrapper to various raindrop fall velocity models.
     It returns the appropriate model based on the `model` parameter.
     """
-    model = check_raindrop_fall_velocity_model(model)
-    return RAINDROP_FALL_VELOCITY_MODELS[model]
+    model = check_rain_fall_velocity_model(model)
+    return RAIN_FALL_VELOCITY_MODELS[model]
 
 
-def get_raindrop_fall_velocity(diameter, model, ds_env=None):
+def get_rain_fall_velocity(diameter, model, ds_env=None):
     """Calculate the fall velocity of raindrops based on their diameter.
 
     Parameters
@@ -261,7 +476,7 @@ def get_raindrop_fall_velocity(diameter, model, ds_env=None):
 
     """
     # Check valid method
-    model = check_raindrop_fall_velocity_model(model)
+    model = check_rain_fall_velocity_model(model)
 
     # Copy diameter
     if isinstance(diameter, xr.DataArray):
@@ -270,24 +485,31 @@ def get_raindrop_fall_velocity(diameter, model, ds_env=None):
         diameter = np.atleast_1d(diameter)
         diameter = xr.DataArray(diameter, dims=DIAMETER_DIMENSION, coords={DIAMETER_DIMENSION: diameter.copy()})
 
-    # Initialize ds_env if None and method == "Beard1976"
-    if model == "Beard1976":
-        if ds_env is None:
-            ds_env = load_env_dataset()
+    # Initialize ds_env
+    if ds_env is None:
+        ds_env = load_env_dataset()
 
-        # Ensure valid altitude and geolocation
-        # - altitude required by Beard
-        # - latitude required for gravity
-        for coord in ["altitude", "latitude"]:
-            ds_env = ensure_valid_geolocation(ds_env, coord=coord, errors="raise")
+    # Ensure valid altitude and geolocation
+    # - altitude required by Beard
+    # - latitude required for gravity
+    for coord in ["altitude", "latitude"]:
+        ds_env = ensure_valid_geolocation(ds_env, coord=coord, errors="raise")
 
     # Retrieve fall velocity
-    func = get_raindrop_fall_velocity_model(model)
+    func = get_rain_fall_velocity_model(model)
     with suppress_warnings():  # e.g. when diameter = 0 for Beard1976
         fall_velocity = func(diameter, ds_env=ds_env) if model == "Beard1976" else func(diameter)
 
+    # Correct for altitude
+    if model != "Beard1976":
+        air_density_height = retrieve_air_density(ds_env)
+        air_density_sea_surface = 1.225  # kg/m3 (International Standard Atmosphere air density at sea level)
+        correction_factor = (air_density_sea_surface / air_density_height) ** (diameter * 0.025 + 0.375)
+        fall_velocity = fall_velocity * correction_factor
+
     # Set to NaN for diameter outside [0, 10)
     fall_velocity = fall_velocity.where(diameter < 10).where(diameter > 0)
+
     # Ensure fall velocity is > 0 to avoid division by zero
     # - Some models, at small diameter, can return negative/zero fall velocity
     fall_velocity = fall_velocity.where(fall_velocity > 0)
@@ -299,7 +521,7 @@ def get_raindrop_fall_velocity(diameter, model, ds_env=None):
     return fall_velocity.squeeze()
 
 
-def get_raindrop_fall_velocity_from_ds(ds, ds_env=None, model="Beard1976"):
+def get_rain_fall_velocity_from_ds(ds, ds_env=None, model="Beard1976", diameter="diameter_bin_center"):
     """Compute the raindrop fall velocity.
 
     Parameters
@@ -349,6 +571,5 @@ def get_raindrop_fall_velocity_from_ds(ds, ds_env=None, model="Beard1976"):
         ds_env = load_env_dataset(ds)
 
     # Compute raindrop fall velocity
-    fall_velocity = get_raindrop_fall_velocity(diameter=ds["diameter_bin_center"], model=model, ds_env=ds_env)  # mn
-
+    fall_velocity = get_rain_fall_velocity(diameter=ds[diameter], model=model, ds_env=ds_env)  # mn
     return fall_velocity