disdrodb 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

disdrodb/l1/fall_velocity.py

@@ -14,10 +14,14 @@
 # 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 the drop fall velocity."""
-
-
+"""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.utils.warnings import suppress_warnings
 
 
 def get_fall_velocity_atlas_1973(diameter):
@@ -53,7 +57,7 @@ def get_fall_velocity_atlas_1973(diameter):
 
     """
     fall_velocity = 9.65 - 10.3 * np.exp(-0.6 * diameter)  # clip to 0 !
-    fall_velocity = np.clip(fall_velocity, 0, None)
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -80,6 +84,7 @@ def get_fall_velocity_brandes_2002(diameter):
 
     """
     fall_velocity = -0.1021 + 4.932 * diameter - 0.9551 * diameter**2 + 0.07934 * diameter**3 - 0.002362 * diameter**4
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -107,6 +112,7 @@ def get_fall_velocity_uplinger_1981(diameter):
     """
     # Valid between 0.1 and 7 mm
     fall_velocity = 4.874 * diameter * np.exp(-0.195 * diameter)
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -133,6 +139,7 @@ def get_fall_velocity_van_dijk_2002(diameter):
 
     """
     fall_velocity = -0.254 + 5.03 * diameter - 0.912 * diameter**2 + 0.0561 * diameter**3
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
@@ -147,9 +154,10 @@ def get_fall_velocity_beard_1976(diameter, ds_env):
         A dataset containing the following environmental variables:
         - 'altitude' :  Altitude in meters (m).
         - 'latitude' :  Latitude in degrees.
-        - 'temperature' : Temperature in degrees Celsius (°C).
+        - '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).
 
     Returns
@@ -166,121 +174,171 @@ def get_fall_velocity_beard_1976(diameter, ds_env):
         latitude=ds_env["latitude"],
         temperature=ds_env["temperature"],
         relative_humidity=ds_env["relative_humidity"],
-        # TODO: add air_pressure # TODO
+        air_pressure=ds_env.get("air_pressure", None),
         sea_level_air_pressure=ds_env["sea_level_air_pressure"],
         lapse_rate=ds_env["lapse_rate"],
     )
+    fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
 
-def ensure_valid_coordinates(ds, default_altitude=0, default_latitude=0, default_longitude=0):
-    """Ensure dataset valid coordinates for altitude, latitude, and longitude.
+RAINDROP_FALL_VELOCITY_MODELS = {
+    "Atlas1973": get_fall_velocity_atlas_1973,
+    "Beard1976": get_fall_velocity_beard_1976,
+    "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():
+    """Return a list of the available raindrop fall velocity models."""
+    return list(RAINDROP_FALL_VELOCITY_MODELS)
 
-    Invalid values are np.nan and -9999.
+
+def check_raindrop_fall_velocity_model(model):
+    """Check validity of the specified raindrop fall velocity model."""
+    available_models = available_raindrop_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):
+    """Return the specified raindrop fall velocity model.
 
     Parameters
     ----------
-    ds : xarray.Dataset
-        The dataset for which to ensure valid geolocation coordinates.
-    default_altitude : float, optional
-        The default value to use for invalid altitude values. Defaults to 0.
-    default_latitude : float, optional
-        The default value to use for invalid latitude values. Defaults to 0.
-    default_longitude : float, optional
-        The default value to use for invalid longitude values. Defaults to 0.
+    model : str
+        The model to use for calculating the rain drop fall velocity. Available models are:
+       'Atlas1973', 'Beard1976', 'Brandes2002', 'Uplinger1981', 'VanDijk2002'.
 
     Returns
     -------
-    xarray.Dataset
-        The dataset with invalid coordinates replaced by default values.
+    callable
+        A function which compute the raindrop fall velocity model
+        given the rain drop diameter in mm.
 
+    Notes
+    -----
+    This function serves as a wrapper to various raindrop fall velocity models.
+    It returns the appropriate model based on the `model` parameter.
     """
-    # TODO raise error if not present
-    invalid_altitude = np.logical_or(np.isnan(ds["altitude"]), ds["altitude"] == -9999)
-    ds["altitude"] = ds["altitude"].where(~invalid_altitude, default_altitude)
-
-    invalid_lat = np.logical_or(np.isnan(ds["latitude"]), ds["latitude"] == -9999)
-    ds["latitude"] = ds["latitude"].where(~invalid_lat, default_latitude)
+    model = check_raindrop_fall_velocity_model(model)
+    return RAINDROP_FALL_VELOCITY_MODELS[model]
 
-    invalid_lon = np.logical_or(np.isnan(ds["longitude"]), ds["longitude"] == -9999)
-    ds["longitude"] = ds["longitude"].where(~invalid_lon, default_longitude)
-    return ds
 
-
-def get_raindrop_fall_velocity(diameter, method, ds_env=None):
+def get_raindrop_fall_velocity(diameter, model, ds_env=None):
     """Calculate the fall velocity of raindrops based on their diameter.
 
     Parameters
     ----------
     diameter : array-like
         The diameter of the raindrops in millimeters.
-    method : str
-        The method to use for calculating the fall velocity. Must be one of the following:
+    model : str
+        The model to use for calculating the raindrop fall velocity. Must be one of the following:
         'Atlas1973', 'Beard1976', 'Brandes2002', 'Uplinger1981', 'VanDijk2002'.
     ds_env : xr.Dataset, optional
+        Only required if model is 'Beard1976'.
         A dataset containing the following environmental variables:
-        - 'altitude' :  Altitude in meters (m).
-        - 'latitude' :  Latitude in degrees.
-        - 'temperature' : Temperature in degrees Celsius (°C).
+        - '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).
-        It is required for for the 'Beard1976' method.
+        If not specified, sensible default values are used.
 
     Returns
     -------
-    fall_velocity : array-like
-        The calculated fall velocities of the raindrops.
+    fall_velocity : xr.DataArray
+        The calculated raindrop fall velocities per diameter.
 
     Notes
     -----
-    The 'Beard1976' method requires additional environmental parameters such as altitude and latitude.
-    These parameters can be provided through the `ds_env` argument. If not provided, default values will be used.
+    The 'Beard1976' model requires additional environmental parameters.
+    These parameters can be provided through the `ds_env` argument.
+    If not provided, default values are be used.
+
+    For D < 0.12, Atlas1973 relationship results output V = 0 m/s  !
+    For D < 0.05, VanDijk2002 relationship results output V = 0 m/s !
+    For D < 0.02, Brandes relationship results output V = 0 m/s !
+
     """
-    # Input diameter in mm
-    dict_methods = {
-        "Atlas1973": get_fall_velocity_atlas_1973,
-        "Beard1976": get_fall_velocity_beard_1976,
-        "Brandes2002": get_fall_velocity_brandes_2002,
-        "Uplinger1981": get_fall_velocity_uplinger_1981,
-        "VanDijk2002": get_fall_velocity_van_dijk_2002,
-    }
     # Check valid method
-    available_methods = list(dict_methods)
-    if method not in dict_methods:
-        raise ValueError(f"{method} is an invalid fall velocity method. Valid methods: {available_methods}.")
-    # Copy diameter
-    diameter = diameter.copy()
-    # Initialize ds_env if None
-    # if ds_env is None:
-    #     ds_env = load_env_dataset(ds_env)
+    model = check_raindrop_fall_velocity_model(model)
 
-    # TODO: wrapper for DISDRODB product !
+    # 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 and method == "Beard1976"
+    if model == "Beard1976":
+        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 (if missing set defaults)
-    # - altitude required by Beard
-    # - latitude required for gravity
-    ds_env = ensure_valid_coordinates(ds_env)
     # Retrieve fall velocity
-    func = dict_methods[method]
-    fall_velocity = func(diameter, ds_env=ds_env) if method == "Beard1976" else func(diameter)
-    return fall_velocity
+    func = get_raindrop_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)
+
+    # 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)
 
+    # Add attributes
+    fall_velocity.name = "fall_velocity"
+    fall_velocity.attrs["units"] = "m/s"
+    fall_velocity.attrs["model"] = model
+    return fall_velocity.squeeze()
 
-def get_dataset_fall_velocity(ds, method="Brandes2002"):
-    """Compute the fall velocity and add it to the dataset.
+
+def get_raindrop_fall_velocity_from_ds(ds, ds_env=None, model="Beard1976"):
+    """Compute the raindrop fall velocity.
 
     Parameters
     ----------
     ds : xarray.Dataset
-        DISDRODB L0C dataset.
-    method : str, optional
-        Method to compute fall velocity. The default method is ``"Brandes2002"``.
+        DISDRODB dataset with the ``'diameter_bin_center'`` coordinate.
+        The ``'altitude'`` and ``'latitude'`` coordinates are used if ``model='Beard1976'``.
+    model : str, optional
+        Model to compute rain drop fall velocity.
+        The default model is ``"Beard1976"``.
+    ds_env : xr.Dataset, optional
+        Only required if model is 'Beard1976'.
+        A dataset containing the following environmental variables:
+        - '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
     -------
-    xarray.Dataset
-        DISDRODB L0C dataset with an additional variable 'fall_velocity'.
+    xarray.DataArray
+        Rain drop fall velocity DataArray.
+
+    Notes
+    -----
+    The 'Beard1976' model requires additional environmental parameters.
+    These parameters can be provided through the `ds_env` argument.
+    If not provided, default values are be used.
+
+    For D < 0.12, Atlas1973 relationship results output V = 0 m/s
+    For D < 0.05, VanDijk2002 relationship results output V = 0 m/s
+    For D < 0.02, Brandes relationship results output V = 0 m/s
+
     """
     from disdrodb.constants import DIAMETER_DIMENSION
     from disdrodb.l1_env.routines import load_env_dataset
@@ -289,18 +347,13 @@ def get_dataset_fall_velocity(ds, method="Brandes2002"):
     if DIAMETER_DIMENSION not in ds.dims:
         raise ValueError(f"Diameter dimension '{DIAMETER_DIMENSION}' not found in dataset dimensions.")
 
-    # Retrieve diameter values (in mm)
-    diameter_bin_center = ds["diameter_bin_center"]
-
-    # Ensure valid altitude and geolocation (if missing set defaults)
-    # TODO: MOBILE CASE !
-    default_geolocation = {"altitude": 0, "latitude": 0, "longitude": 0}
-    dataset_coords = {key: ds[key] for key in default_geolocation if key in ds}
-    default_geolocation.update(dataset_coords)
-    ds = ds.assign_coords(default_geolocation)
+    # Retrieve ENV dataset
+    # - It checks and includes default geolocation if missing
+    # - For mobile disdrometer, infill missing geolocation with backward and forward filling
+    if ds_env is None:
+        ds_env = load_env_dataset(ds)
 
-    # TODO: deal with ENV dataset
-    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_raindrop_fall_velocity(diameter_bin_center, method=method, ds_env=ds_env)
     return fall_velocity

disdrodb/l1/filters.py

@@ -57,17 +57,15 @@ def filter_diameter_bins(ds, minimum_diameter=None, maximum_diameter=None):
         ds["diameter_bin_upper"] > minimum_diameter,
         ds["diameter_bin_lower"] < maximum_diameter,
     )
-
-    # Select bins with diameter values entirely inside the specified min/max values
-    # valid_indices = np.logical_and(
-    #     ds["diameter_bin_lower"] >= minimum_diameter,
-    #     ds["diameter_bin_upper"] <= maximum_diameter,
-    # )
     ds = ds.isel({DIAMETER_DIMENSION: valid_indices})
+
+    if ds.sizes[DIAMETER_DIMENSION] == 0:
+        msg = f"Filtering using {minimum_diameter=} removes all diameter bins."
+        raise ValueError(msg)
     return ds
 
 
-def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
+def filter_velocity_bins(ds, minimum_velocity=None, maximum_velocity=None):
     """
     Filter the dataset to include only velocity bins within specified bounds.
 
@@ -77,10 +75,10 @@ def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
         The dataset containing velocity bin data.
     minimum_velocity : float, optional
         The minimum velocity to include in the filter, in meters per second.
-        Defaults to 0 m/s.
+        Defaults to the minimum value in `ds["velocity_bin_lower"]`.
     maximum_velocity : float, optional
         The maximum velocity to include in the filter, in meters per second.
-        Defaults to 12 m/s.
+        Defaults to the maximum value in `ds["velocity_bin_upper"]`.
 
     Returns
     -------
@@ -103,16 +101,14 @@ def filter_velocity_bins(ds, minimum_velocity=0, maximum_velocity=12):
         ds["velocity_bin_lower"] < maximum_velocity,
     )
 
-    # Select bins with velocity values entirely inside the specified min/max values
-    # valid_indices = np.logical_and(
-    #     ds["velocity_bin_lower"] >= minimum_velocity,
-    #     ds["velocity_bin_upper"] <= maximum_velocity,
-    # )
     ds = ds.isel({VELOCITY_DIMENSION: valid_indices})
+    if ds.sizes[VELOCITY_DIMENSION] == 0:
+        msg = f"Filtering using {minimum_velocity=} removes all velocity bins."
+        raise ValueError(msg)
     return ds
 
 
-def define_spectrum_mask(
+def define_raindrop_spectrum_mask(
     drop_number,
     fall_velocity,
     above_velocity_fraction=None,
@@ -130,29 +126,29 @@ def define_spectrum_mask(
     drop_number : xarray.DataArray
         Array of drop counts per diameter and velocity bins.
     fall_velocity : array-like
-        The expected terminal fall velocities for drops of given sizes.
+        The expected terminal fall velocities for rain drops of given sizes.
     above_velocity_fraction : float, optional
-        Fraction of terminal fall velocity above which drops are considered too fast.
+        Fraction of terminal fall velocity above which rain drops are considered too fast.
         Either specify ``above_velocity_fraction`` or ``above_velocity_tolerance``.
     above_velocity_tolerance : float, optional
-        Absolute tolerance above which drops terminal fall velocities are considered too fast.
+        Absolute tolerance above which rain drops terminal fall velocities are considered too fast.
         Either specify ``above_velocity_fraction`` or ``above_velocity_tolerance``.
     below_velocity_fraction : float, optional
-        Fraction of terminal fall velocity below which drops are considered too slow.
+        Fraction of terminal fall velocity below which rain drops are considered too slow.
         Either specify ``below_velocity_fraction`` or ``below_velocity_tolerance``.
     below_velocity_tolerance : float, optional
-        Absolute tolerance below which drops terminal fall velocities are considered too slow.
+        Absolute tolerance below which rain drops terminal fall velocities are considered too slow.
          Either specify ``below_velocity_fraction`` or ``below_velocity_tolerance``.
     maintain_smallest : bool, optional
-        If True, ensures that the small drops in the spectrum are retained in the mask.
-        The smallest drops are characterized by ``small_diameter_threshold``
+        If True, ensures that the small rain drops in the spectrum are retained in the mask.
+        The smallest rain drops are characterized by ``small_diameter_threshold``
         and ``small_velocity_threshold`` arguments.
         Defaults to False.
     small_diameter_threshold : float, optional
-        The diameter threshold to use for keeping the smallest drop.
+        The diameter threshold to use for keeping the smallest rain drop.
         Defaults to 1 mm.
     small_velocity_threshold : float, optional
-        The fall velocity threshold to use for keeping the smallest drops.
+        The fall velocity threshold to use for keeping the smallest rain drops.
         Defaults to 2.5 m/s.
 
     Returns
@@ -178,6 +174,7 @@ def define_spectrum_mask(
         above_fall_velocity = fall_velocity + above_velocity_tolerance
     else:
         above_fall_velocity = np.inf
+
     if below_velocity_fraction is not None:
         below_fall_velocity = fall_velocity * (1 - below_velocity_fraction)
     elif below_velocity_tolerance is not None:
@@ -191,15 +188,15 @@ def define_spectrum_mask(
 
     # Define mask
     mask = np.logical_and(
-        np.logical_or(velocity_lower >= below_fall_velocity, velocity_upper >= below_fall_velocity),
-        np.logical_or(velocity_lower <= above_fall_velocity, velocity_upper <= above_fall_velocity),
+        velocity_upper > below_fall_velocity,
+        velocity_lower < above_fall_velocity,
     )
 
     # Maintant smallest drops
     if maintain_smallest_drops:
         mask_smallest = np.logical_and(
-            drop_number["diameter_bin_upper"] < small_diameter_threshold,
-            drop_number["velocity_bin_upper"] < small_velocity_threshold,
+            drop_number["diameter_bin_upper"] <= small_diameter_threshold,
+            drop_number["velocity_bin_upper"] <= small_velocity_threshold,
         )
         mask = np.logical_or(mask, mask_smallest)
 

disdrodb/l1/processing.py

@@ -19,8 +19,8 @@
 import xarray as xr
 
 from disdrodb.constants import DIAMETER_DIMENSION, VELOCITY_DIMENSION
-from disdrodb.l1.fall_velocity import get_raindrop_fall_velocity
-from disdrodb.l1.filters import define_spectrum_mask, filter_diameter_bins, filter_velocity_bins
+from disdrodb.l1.fall_velocity import get_raindrop_fall_velocity_from_ds
+from disdrodb.l1.filters import define_raindrop_spectrum_mask, filter_diameter_bins, filter_velocity_bins
 from disdrodb.l1.resampling import add_sample_interval
 from disdrodb.l1_env.routines import load_env_dataset
 from disdrodb.l2.empirical_dsd import (  # TODO: maybe move out of L2
@@ -34,7 +34,7 @@ from disdrodb.utils.writer import finalize_product
 def generate_l1(
     ds,
     # Fall velocity option
-    fall_velocity_method="Beard1976",
+    fall_velocity_model="Beard1976",
     # Diameter-Velocity Filtering Options
     minimum_diameter=0,
     maximum_diameter=10,
@@ -54,7 +54,7 @@ def generate_l1(
     ----------
     ds : xarray.Dataset
         DISDRODB L0C dataset.
-    fall_velocity_method : str, optional
+    fall_velocity_model : str, optional
         Method to compute fall velocity.
         The default method is ``"Beard1976"``.
     minimum_diameter : float, optional
@@ -106,7 +106,9 @@ def generate_l1(
 
     # ---------------------------------------------------------------------------
     # Retrieve ENV dataset or take defaults
-    # --> Used only for Beard fall velocity currently !
+    # - Used only for Beard fall velocity currently !
+    # - It checks and includes default geolocation if missing
+    # - For mobile disdrometer, infill missing geolocation with backward and forward filling
     ds_env = load_env_dataset(ds)
 
     # ---------------------------------------------------------------------------
@@ -120,7 +122,7 @@ def generate_l1(
     ds_l1 = add_sample_interval(ds_l1, sample_interval=sample_interval)
 
     # Add L0C coordinates that might got lost
-    if "time_qc" in ds_l1:
+    if "time_qc" in ds:
         ds_l1 = ds_l1.assign_coords({"time_qc": ds["time_qc"]})
 
     # -------------------------------------------------------------------------------------------
@@ -128,7 +130,7 @@ def generate_l1(
     if sensor_name in ["PARSIVEL", "PARSIVEL2"]:
         # - Remove first two bins because never reports data !
         # - If not removed, can alter e.g. L2M model fitting
-        ds_l1 = filter_diameter_bins(ds=ds_l1, minimum_diameter=0.312)  # it includes the 0.2495-0.3745 bin
+        ds_l1 = filter_diameter_bins(ds=ds_l1, minimum_diameter=0.2495)  # it includes the 0.2495-0.3745 bin
 
     # - Filter diameter bins
     ds_l1 = filter_diameter_bins(ds=ds_l1, minimum_diameter=minimum_diameter, maximum_diameter=maximum_diameter)
@@ -138,16 +140,12 @@ def generate_l1(
 
     # -------------------------------------------------------------------------------------------
     # Compute fall velocity
-    ds_l1["fall_velocity"] = get_raindrop_fall_velocity(
-        diameter=ds_l1["diameter_bin_center"],
-        method=fall_velocity_method,
-        ds_env=ds_env,  # mm
-    )
+    ds_l1["fall_velocity"] = get_raindrop_fall_velocity_from_ds(ds=ds_l1, ds_env=ds_env, model=fall_velocity_model)
 
     # -------------------------------------------------------------------------------------------
     # Define filtering mask according to fall velocity
     if has_velocity_dimension:
-        mask = define_spectrum_mask(
+        mask = define_raindrop_spectrum_mask(
             drop_number=ds_l1["raw_drop_number"],
             fall_velocity=ds_l1["fall_velocity"],
             above_velocity_fraction=above_velocity_fraction,

disdrodb/l1_env/routines.py

@@ -15,39 +15,68 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """Core functions for DISDRODB ENV production."""
+import numpy as np
 import xarray as xr
 
 from disdrodb.constants import GEOLOCATION_COORDS
+from disdrodb.l0.l0b_processing import ensure_valid_geolocation
+from disdrodb.utils.logger import log_warning
+
+DEFAULT_GEOLOCATION = {
+    "latitude": 46.159346,
+    "longitude": 8.774586,
+    "altitude": 0,
+}
 
 
 def get_default_environment_dataset():
     """Define defaults values for the ENV dataset."""
     ds_env = xr.Dataset()
-    ds_env["sea_level_air_pressure"] = 101_325
-    ds_env["gas_constant_dry_air"] = 287.04
-    ds_env["lapse_rate"] = 0.0065
-    ds_env["relative_humidity"] = 0.95  # Value between 0 and 1 !
-    ds_env["temperature"] = 20 + 273.15
+    ds_env["sea_level_air_pressure"] = 101_325  # Pa
+    ds_env["gas_constant_dry_air"] = 287.04  # J kg⁻¹ K⁻¹
+    ds_env["lapse_rate"] = 0.0065  # K m⁻¹
+    ds_env["relative_humidity"] = 0.95  # 0-1 !
+    ds_env["temperature"] = 20 + 273.15  # K
+    ds_env["water_density"] = 1000  # kg m⁻³   (T == 10 --> 999.7, T == 20 --> 998.2)
+    # get_water_density(temperature=temperature, air_pressure=air_pressure
     return ds_env
 
 
-def _assign_geolocation(ds_src, dst_dst):
+def _assign_geolocation(ds_src, dst_dst, logger=None):
+    dict_coords = {}
+    for coord in GEOLOCATION_COORDS:
+        if coord in ds_src:
+            # Check geolocation validity
+            ds_src = ensure_valid_geolocation(ds_src, coord=coord, errors="coerce")
+            # Assign valid geolocation (or default one if invalid)
+            if "time" not in ds_src[coord].dims:
+                dict_coords[coord] = ds_src[coord] if not np.isnan(ds_src[coord]) else DEFAULT_GEOLOCATION[coord]
+            else:  # If coordinates varies over time, infill NaN over time with forward and backward filling
+                dict_coords[coord] = ds_src[coord].ffill(dim="time").bfill(dim="time")
+        else:
+            dict_coords[coord] = DEFAULT_GEOLOCATION[coord]
+            log_warning(
+                logger=logger,
+                msg=f"{coord} not available. Setting {coord}={DEFAULT_GEOLOCATION[coord]}",
+                verbose=False,
+            )
 
-    dict_coords = {coord: ds_src[coord] for coord in GEOLOCATION_COORDS if coord in ds_src}
+    # Assign geolocation
     dst_dst = dst_dst.assign_coords(dict_coords)
     return dst_dst
 
 
-def load_env_dataset(ds):
+def load_env_dataset(ds=None, logger=None):
     """Load the ENV dataset."""
-    # TODO: Retrieve relative_humidity and temperature from L1-ENV
+    # TODO: Retrieve relative_humidity, lapse_rate and temperature from DISDRODB-ENV product
+
+    # Load default environment dataset
     ds_env = get_default_environment_dataset()
-    # Compute water density
-    # get_water_density(
-    # temperature=temperature,
-    # air_pressure=air_pressure,
-    # )
-    # -->  (T == 10 --> 999.7, T == 20 --> 998.2
-    ds_env["water_density"] = 1000  # kg / m3 # TODO as function of ENV (temperature, ...) ?
-    ds_env = _assign_geolocation(ds_src=ds, dst_dst=ds_env)
+
+    # Assign geolocation if input dataset provided
+    if ds is not None:
+        ds_env = _assign_geolocation(ds_src=ds, dst_dst=ds_env, logger=logger)
+    # Otherwise add default geolocation
+    else:
+        ds_env = ds_env.assign_coords(DEFAULT_GEOLOCATION)
     return ds_env

disdrodb/l2/empirical_dsd.py

@@ -236,6 +236,12 @@ def get_effective_sampling_area(sensor_name, diameter):
     if sensor_name == "RD80":
         sampling_area = 0.005  # m2
         return sampling_area
+    if sensor_name == "SWS250":  # TODO: L * (B - diameter / 2) ?
+        # Table 29 of the manual that the sample volume is 400cm3, path length?
+        # Distance between the end of the hood heaters is 291 mm.
+        # Adding a factor of 1.5 for better representation of the Tx-Rx distance: L= 436 mm.
+        sampling_area = 0.0091  # m2
+        return sampling_area
     raise NotImplementedError(f"Effective sampling area for {sensor_name} must yet to be specified in the software.")
 
 

disdrodb/l2/processing.py

@@ -441,7 +441,7 @@ def generate_l2m(
     diameter_spacing=0.05,
     # Processing options
     ds_env=None,
-    fall_velocity_method="Beard1976",
+    fall_velocity_model="Beard1976",
     # Filtering options
     minimum_ndrops=1,
     minimum_nbins=3,
@@ -548,7 +548,7 @@ def generate_l2m(
     drop_number_concentration = psd(diameter)
 
     # Retrieve fall velocity for each new diameter bin
-    velocity = get_raindrop_fall_velocity(diameter=diameter, method=fall_velocity_method, ds_env=ds_env)  # mm
+    velocity = get_raindrop_fall_velocity(diameter=diameter, model=fall_velocity_model, ds_env=ds_env)  # mm
 
     # Compute integral parameters
     ds_params = compute_integral_parameters(

disdrodb/metadata/geolocation.py

@@ -60,8 +60,6 @@ def infer_altitude(latitude, longitude, dem="aster30m"):
     ----------
     https://www.opentopodata.org/api/
     """
-    import requests
-
     url = f"https://api.opentopodata.org/v1/{dem}?locations={latitude},{longitude}"
     r = requests.get(url)