disdrodb 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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
@@ -21,6 +21,7 @@ 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
 
 
@@ -45,11 +46,6 @@ def get_fall_velocity_atlas_1973(diameter):
     Reviews of Geophysics, 11(1), 1-35.
     https://doi.org/10.1029/RG011i001p00001
 
-    Atlas, D., & Ulbrich, C. W. (1977).
-    Path- and area-integrated rainfall measurement by microwave attenuation in the 1-3 cm band.
-    Journal of Applied Meteorology, 16(12), 1322-1331.
-    https://doi.org/10.1175/1520-0450(1977)016<1322:PAAIRM>2.0.CO;2
-
     Gunn, R., & Kinzer, G. D. (1949).
     The terminal velocity of fall for water droplets in stagnant air.
     Journal of Meteorology, 6(4), 243-248.
@@ -111,7 +107,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 = 4.874 * diameter * np.exp(-0.195 * diameter)  # 4.854?
     fall_velocity = fall_velocity.clip(min=0, max=None)
     return fall_velocity
 
@@ -143,8 +139,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
     ----------
@@ -155,56 +302,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
@@ -224,11 +433,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
@@ -266,7 +475,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):
@@ -275,24 +484,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)
@@ -304,7 +520,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
@@ -354,6 +570,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

disdrodb/issue/__init__.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# 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

disdrodb/issue/checks.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# 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
@@ -173,7 +171,7 @@ def check_time_periods(time_periods):
 
 def _get_issue_timesteps(issue_dict):
     """Get timesteps from issue dictionary."""
-    timesteps = issue_dict.get("timesteps", None)
+    timesteps = issue_dict.get("timesteps")
     # Check validity
     timesteps = check_timesteps(timesteps)
     # Sort
@@ -183,7 +181,7 @@ def _get_issue_timesteps(issue_dict):
 
 def _get_issue_time_periods(issue_dict):
     """Get time_periods from issue dictionary."""
-    time_periods = issue_dict.get("time_periods", None)
+    time_periods = issue_dict.get("time_periods")
     time_periods = check_time_periods(time_periods)
     return time_periods
 

disdrodb/issue/reader.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# 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

disdrodb/issue/writer.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# 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

disdrodb/l0/__init__.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

disdrodb/l0/check_configs.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# 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
@@ -22,7 +20,7 @@ import os
 from typing import Optional, Union
 
 import numpy as np
-from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
+from pydantic import Field, field_validator, model_validator
 
 from disdrodb.api.configs import available_sensor_names, get_sensor_configs_dir, read_config_file
 from disdrodb.l0.standards import (
@@ -36,6 +34,7 @@ from disdrodb.l0.standards import (
     get_velocity_bin_width,
 )
 from disdrodb.utils.directories import list_files
+from disdrodb.utils.pydantic import CustomBaseModel
 
 CONFIG_FILES_LIST = [
     "bins_diameter.yml",
@@ -104,28 +103,24 @@ def check_variable_consistency(sensor_name: str) -> None:
             raise ValueError(msg)
 
 
-class SchemaValidationException(Exception):
-    """Exception raised when schema validation fails."""
-
-
-def _schema_error(object_to_validate: Union[str, list], schema: BaseModel, message) -> bool:
+def _schema_error(object_to_validate: Union[str, list], schema: CustomBaseModel, message) -> bool:
     """Function that validate the schema of a given object with a given schema.
 
     Parameters
     ----------
     object_to_validate : Union[str,list]
         Object to validate.
-    schema : BaseModel
+    schema : CustomBaseModel
         Base model.
 
     """
     try:
         schema(**object_to_validate)
-    except ValidationError as e:
-        raise SchemaValidationException(f"Schema validation failed. {message} {e}")
+    except ValueError as e:
+        raise ValueError(f"{message} {e!s}") from None
 
 
-class L0BEncodingSchema(BaseModel):
+class L0BEncodingSchema(CustomBaseModel):
     """Pydantic model for DISDRODB netCDF encodings."""
 
     contiguous: bool
@@ -136,6 +131,8 @@ class L0BEncodingSchema(BaseModel):
     fletcher32: bool
     FillValue: Optional[Union[int, float]] = Field(default=None, alias="_FillValue")
     chunksizes: Optional[Union[int, list[int]]]
+    add_offset: Optional[float] = None
+    scale_factor: Optional[float] = None
 
     # if contiguous=False, chunksizes specified, otherwise should be not !
     @model_validator(mode="before")
@@ -200,6 +197,18 @@ class L0BEncodingSchema(BaseModel):
 
         return values
 
+    @model_validator(mode="after")
+    def remove_offset_and_scale_if_not_int(cls, values):
+        """Ensure add_offset and scale_factor only apply to integer/uint dtypes."""
+        integer_types = ["int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"]
+
+        if values.dtype not in integer_types:
+            # drop those keys to keep model clean
+            values.add_offset = None
+            values.scale_factor = None
+
+        return values
+
 
 def check_l0b_encoding(sensor_name: str) -> None:
     """Check ``l0b_encodings.yml`` file based on the schema defined in the class ``L0BEncodingSchema``.
@@ -216,7 +225,7 @@ def check_l0b_encoding(sensor_name: str) -> None:
         _schema_error(
             object_to_validate=value,
             schema=L0BEncodingSchema,
-            message=f"Sensore name : {sensor_name}. Key : {key}.",
+            message=f"Invalid {sensor_name} L0B Encoding YAML file '{key}' settings.",
         )
 
 
@@ -243,7 +252,7 @@ def check_l0a_encoding(sensor_name: str) -> None:
             raise TypeError(f"Expecting a string for {key} in l0a_encodings.yml for sensor {sensor_name}.")
 
 
-class RawDataFormatSchema(BaseModel):
+class RawDataFormatSchema(CustomBaseModel):
     """Pydantic model for the DISDRODB RAW Data Format YAML files."""
 
     n_digits: Optional[int]
@@ -251,7 +260,7 @@ class RawDataFormatSchema(BaseModel):
     n_decimals: Optional[int]
     n_naturals: Optional[int]
     data_range: Optional[list[float]]
-    nan_flags: Optional[Union[int, str]] = None
+    nan_flags: Optional[Union[int, float, str]] = None
     valid_values: Optional[list[float]] = None
     dimension_order: Optional[list[str]] = None
     n_values: Optional[int] = None
@@ -282,7 +291,7 @@ def check_raw_data_format(sensor_name: str) -> None:
         _schema_error(
             object_to_validate=value,
             schema=RawDataFormatSchema,
-            message=f"Sensore name : {sensor_name}. Key : {key}.",
+            message=f"Invalid {sensor_name} RawDataFormat YAML file '{key}' settings.",
         )
 
 

disdrodb/l0/check_standards.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 # -----------------------------------------------------------------------------.
-# 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

disdrodb/l0/configs/LPM/l0a_encodings.yml

@@ -1,4 +1,3 @@
-device_address: "float32" #  'uint8'
 weather_code_synop_4677_5min: "float32" # 'uint8'
 weather_code_synop_4680_5min: "float32" # 'uint8'
 weather_code_metar_4678_5min: "str"

disdrodb/l0/configs/LPM/l0b_cf_attrs.yml

@@ -1,7 +1,3 @@
-device_address:
-  description: "Device address (factory setting \u201E00\") (NN)"
-  long_name: Device address
-  units: ""
 weather_code_synop_4677_5min:
   description: 5M SYNOP Tab.4677 (5 minutes mean value) (NN)
   long_name: 5 min SYNOP Tab.4677

disdrodb/l0/configs/LPM/l0b_encodings.yml

@@ -7,15 +7,15 @@
 #   contiguous: false
 #   chunksizes: 5000
 #   _FillValue: 255
-device_address:
-  dtype: uint8
-  zlib: true
-  complevel: 3
-  shuffle: true
-  fletcher32: false
-  contiguous: false
-  chunksizes: 5000
-  _FillValue: 255
+# device_address:
+#   dtype: uint8
+#   zlib: true
+#   complevel: 3
+#   shuffle: true
+#   fletcher32: false
+#   contiguous: false
+#   chunksizes: 5000
+#   _FillValue: 255
 # sensor_serial_number:
 #   dtype: uint16
 #   zlib: false