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

disdrodb/routines/wrappers.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
@@ -22,6 +22,75 @@ from typing import Optional
 from disdrodb.api.search import available_stations, get_required_product
 from disdrodb.utils.cli import execute_cmd
 
+
+def validate_processing_flags_and_get_required_product(**processing_flags):
+    """Validate processing flags and determine the required input product.
+
+    Validates that the processing chain is logically consistent and returns
+    the product needed as input for the earliest requested processing step.
+
+    The processing chain must be contiguous - you cannot skip intermediate levels.
+    For example: l1_processing=True, l2e_processing=False, l2m_processing=True is invalid.
+
+    Raises
+    ------
+    ValueError
+        If no processing levels are enabled or if the processing chain has gaps.
+
+    Returns
+    -------
+    str
+        The required input product for the processing chain.
+    """
+    # Define processing chain order and their required inputs
+    PROCESSING_CHAIN = [
+        ("l0a_processing", "L0A"),
+        ("l0b_processing", "L0B"),
+        ("l0c_processing", "L0C"),
+        ("l1_processing", "L1"),
+        ("l2e_processing", "L2E"),
+        ("l2m_processing", "L2M"),
+    ]
+
+    # Filter only the processing flags we care about and get enabled levels
+    enabled_levels = []
+    for level, product in PROCESSING_CHAIN:
+        if processing_flags.get(level, False):
+            enabled_levels.append((level, product))
+
+    # Check if at least one processing level is enabled
+    if not enabled_levels:
+        raise ValueError("At least one processing level must be enabled.")
+
+    # Get indices of enabled levels in the original chain
+    enabled_indices = []
+    for level, _ in enabled_levels:
+        for i, (chain_level, _) in enumerate(PROCESSING_CHAIN):
+            if level == chain_level:
+                enabled_indices.append(i)
+                break
+
+    # Check for gaps: all indices between first and last enabled should be present
+    first_idx = min(enabled_indices)
+    last_idx = max(enabled_indices)
+
+    expected_indices = set(range(first_idx, last_idx + 1))
+    actual_indices = set(enabled_indices)
+
+    missing_indices = expected_indices - actual_indices
+    if missing_indices:
+        missing_levels = [PROCESSING_CHAIN[i][0] for i in missing_indices]
+        enabled_level_names = [level for level, _ in enabled_levels]
+        raise ValueError(
+            f"Processing chain has gaps. Enabled levels: {enabled_level_names}. "
+            f"Missing intermediate levels: {missing_levels}. "
+            f"All levels between the first and last enabled level must be enabled.",
+        )
+
+    # Return the required input product for the earliest enabled level
+    return get_required_product(enabled_levels[0][1])
+
+
 ####--------------------------------------------------------------------------.
 #### Run DISDRODB Station Processing
 
@@ -100,6 +169,13 @@ def run_l0_station(
         in the DISDRODB active configuration.
     """
     # ---------------------------------------------------------------------.
+    # Validate processing flags
+    _ = validate_processing_flags_and_get_required_product(
+        l0a_processing=l0a_processing,
+        l0b_processing=l0b_processing,
+        l0c_processing=l0c_processing,
+    )
+    # ---------------------------------------------------------------------.
     t_i = time.time()
     print(f"L0 processing of station {station_name} has started.")
 
@@ -1075,13 +1151,12 @@ def run_l0(
         If ``None``, it uses the ``metadata_archive_dir`` path specified
         in the DISDRODB active configuration.
     """
-    # Define starting product
-    if l0c_processing:
-        required_product = get_required_product("L0C")
-    if l0b_processing:
-        required_product = get_required_product("L0B")
-    if l0a_processing:
-        required_product = get_required_product("L0A")
+    # Determine required product based on the lowest level processing requested
+    required_product = validate_processing_flags_and_get_required_product(
+        l0a_processing=l0a_processing,
+        l0b_processing=l0b_processing,
+        l0c_processing=l0c_processing,
+    )
 
     # Get list of available stations
     list_info = available_stations(
@@ -1438,6 +1513,354 @@ def run_l2m(
         print(f"{product} processing of {data_source} {campaign_name} {station_name} station ended.")
 
 
+####--------------------------------------------------------------------------.
+#### Full Processing Wrappers
+def run_station(
+    data_source,
+    campaign_name,
+    station_name,
+    # L0 archive options
+    l0a_processing: bool = True,
+    l0b_processing: bool = True,
+    l0c_processing: bool = True,
+    remove_l0a: bool = False,
+    remove_l0b: bool = False,
+    # Higher level processing options
+    l1_processing: bool = True,
+    l2e_processing: bool = True,
+    l2m_processing: bool = True,
+    # Processing options
+    force: bool = False,
+    verbose: bool = False,
+    debugging_mode: bool = False,
+    parallel: bool = True,
+    # DISDRODB root directories
+    data_archive_dir: Optional[str] = None,
+    metadata_archive_dir: Optional[str] = None,
+):
+    """Run the complete processing chain of a specific DISDRODB station from the terminal.
+
+    Parameters
+    ----------
+    data_source : str
+        Institution name (when campaign data spans more than 1 country),
+        or country (when all campaigns (or sensor networks) are inside a given country).
+        Must be UPPER CASE.
+    campaign_name : str
+        Campaign name. Must be UPPER CASE.
+    station_name : str
+        Station name
+    l0a_processing : bool
+        Whether to launch processing to generate L0A Apache Parquet file(s) from raw data.
+        The default value is ``True``.
+    l0b_processing : bool
+        Whether to launch processing to generate L0B netCDF4 file(s) from L0A data.
+        The default value is ``True``.
+    l0c_processing : bool
+        Whether to launch processing to generate L0C netCDF4 file(s) from L0B data.
+        The default value is ``True``.
+    remove_l0a : bool
+        Whether to keep the L0A files after having generated the L0B netCDF products.
+        The default value is ``False``.
+    remove_l0b : bool
+        Whether to remove the L0B files after having produced L0C netCDF files.
+        The default is False.
+    l1_processing : bool
+        Whether to launch processing to generate L1 netCDF4 file(s) from L0C data.
+        The default value is ``True``.
+    l2e_processing : bool
+        Whether to launch processing to generate L2E netCDF4 file(s) from L1 data.
+        The default value is ``True``.
+    l2m_processing : bool
+        Whether to launch processing to generate L2M netCDF4 file(s) from L1 data.
+        The default value is ``True``.
+    force : bool
+        If ``True``, overwrite existing data into destination directories.
+        If ``False``, raise an error if there are already data into destination directories.
+        The default value is ``False``.
+    verbose : bool
+        Whether to print detailed processing information into terminal.
+        The default value is ``True``.
+    parallel : bool
+        If ``True``, the files are processed simultaneously in multiple processes.
+        Each process will use a single thread to avoid issues with the HDF/netCDF library.
+        By default, the number of process is defined with ``os.cpu_count()``.
+        If ``False``, the files are processed sequentially in a single process.
+        If ``False``, multi-threading is automatically exploited to speed up I/0 tasks.
+    debugging_mode : bool
+        If ``True``, it reduces the amount of data to process.
+        For L0A, it processes just the first 3 raw data files for each station.
+        For L0B, it processes 100 rows sampled from 3 L0A files for each station.
+        The default value is ``False``.
+    data_archive_dir : str (optional)
+        The directory path where the DISDRODB Data Archive is located.
+        The directory path must end with ``<...>/DISDRODB``.
+        If ``None``, it uses the ``data_archive_dir`` path specified
+        in the DISDRODB active configuration.
+    metadata_archive_dir : str (optional)
+        The directory path where the DISDRODB Metadata Archive is located.
+        The directory path must end with ``<...>/DISDRODB-METADATA/DISDRODB``.
+        If ``None``, it uses the ``metadata_archive_dir`` path specified
+        in the DISDRODB active configuration.
+    """
+    # ---------------------------------------------------------------------.
+    # Validate processing flags
+    _ = validate_processing_flags_and_get_required_product(
+        l0a_processing=l0a_processing,
+        l0b_processing=l0b_processing,
+        l0c_processing=l0c_processing,
+        l1_processing=l1_processing,
+        l2e_processing=l2e_processing,
+        l2m_processing=l2m_processing,
+    )
+
+    # ---------------------------------------------------------------------.
+    t_i = time.time()
+    print(f"Complete processing of station {station_name} has started.")
+
+    # ------------------------------------------------------------------.
+    # L0 processing (L0A, L0B, L0C)
+    if l0a_processing or l0b_processing or l0c_processing:
+        run_l0_station(
+            # DISDRODB root directories
+            data_archive_dir=data_archive_dir,
+            metadata_archive_dir=metadata_archive_dir,
+            # Station arguments
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            # L0 archive options
+            l0a_processing=l0a_processing,
+            l0b_processing=l0b_processing,
+            l0c_processing=l0c_processing,
+            remove_l0a=remove_l0a,
+            remove_l0b=remove_l0b,
+            # Processing options
+            force=force,
+            verbose=verbose,
+            debugging_mode=debugging_mode,
+            parallel=parallel,
+        )
+
+    # ------------------------------------------------------------------.
+    # L1 processing
+    if l1_processing:
+        run_l1_station(
+            # DISDRODB root directories
+            data_archive_dir=data_archive_dir,
+            metadata_archive_dir=metadata_archive_dir,
+            # Station arguments
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            # Processing options
+            force=force,
+            verbose=verbose,
+            debugging_mode=debugging_mode,
+            parallel=parallel,
+        )
+
+    # ------------------------------------------------------------------.
+    # L2E processing
+    if l2e_processing:
+        run_l2e_station(
+            # DISDRODB root directories
+            data_archive_dir=data_archive_dir,
+            metadata_archive_dir=metadata_archive_dir,
+            # Station arguments
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            # Processing options
+            force=force,
+            verbose=verbose,
+            debugging_mode=debugging_mode,
+            parallel=parallel,
+        )
+
+    # ------------------------------------------------------------------.
+    # L2M processing
+    if l2m_processing:
+        run_l2m_station(
+            # DISDRODB root directories
+            data_archive_dir=data_archive_dir,
+            metadata_archive_dir=metadata_archive_dir,
+            # Station arguments
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            # Processing options
+            force=force,
+            verbose=verbose,
+            debugging_mode=debugging_mode,
+            parallel=parallel,
+        )
+
+    # -------------------------------------------------------------------------.
+    # End of complete processing for station
+    timedelta_str = str(datetime.timedelta(seconds=round(time.time() - t_i)))
+    print(f"Complete processing of station {station_name} completed in {timedelta_str}")
+
+
+def run(
+    data_sources=None,
+    campaign_names=None,
+    station_names=None,
+    # L0 archive options
+    l0a_processing: bool = True,
+    l0b_processing: bool = True,
+    l0c_processing: bool = True,
+    remove_l0a: bool = False,
+    remove_l0b: bool = False,
+    # Higher level processing options
+    l1_processing: bool = True,
+    l2e_processing: bool = True,
+    l2m_processing: bool = True,
+    # Processing options
+    force: bool = False,
+    verbose: bool = False,
+    debugging_mode: bool = False,
+    parallel: bool = True,
+    # DISDRODB root directories
+    data_archive_dir: Optional[str] = None,
+    metadata_archive_dir: Optional[str] = None,
+):
+    """Run the complete processing chain of DISDRODB stations.
+
+    This function allows to launch the complete processing of many DISDRODB stations with a single command.
+    From the list of all available DISDRODB stations, it runs the processing of the
+    stations matching the provided data_sources, campaign_names and station_names.
+
+    Parameters
+    ----------
+    data_sources : list
+        Name of data source(s) to process.
+        The name(s) must be UPPER CASE.
+        If campaign_names and station are not specified, process all stations.
+        The default value is ``None``.
+    campaign_names : list
+        Name of the campaign(s) to process.
+        The name(s) must be UPPER CASE.
+        The default value is ``None``.
+    station_names : list
+        Station names to process.
+        The default value is ``None``.
+    l0a_processing : bool
+        Whether to launch processing to generate L0A Apache Parquet file(s) from raw data.
+        The default value is ``True``.
+    l0b_processing : bool
+        Whether to launch processing to generate L0B netCDF4 file(s) from L0A data.
+        The default value is ``True``.
+    l0c_processing : bool
+        Whether to launch processing to generate L0C netCDF4 file(s) from L0B data.
+        The default value is ``True``.
+    remove_l0a : bool
+        Whether to keep the L0A files after having generated the L0B netCDF products.
+        The default value is ``False``.
+    remove_l0b : bool
+        Whether to remove the L0B files after having produced L0C netCDF files.
+        The default value is ``False``.
+    l1_processing : bool
+        Whether to launch processing to generate L1 netCDF4 file(s) from L0C data.
+        The default value is ``True``.
+    l2e_processing : bool
+        Whether to launch processing to generate L2E netCDF4 file(s) from L1 data.
+        The default value is ``True``.
+    l2m_processing : bool
+        Whether to launch processing to generate L2M netCDF4 file(s) from L1 data.
+        The default value is ``True``.
+    force : bool
+        If ``True``, overwrite existing data into destination directories.
+        If ``False``, raise an error if there are already data into destination directories.
+        The default value is ``False``.
+    verbose : bool
+        Whether to print detailed processing information into terminal.
+        The default value is ``False``.
+    parallel : bool
+        If ``True``, the files are processed simultaneously in multiple processes.
+        Each process will use a single thread to avoid issues with the HDF/netCDF library.
+        By default, the number of process is defined with ``os.cpu_count()``.
+        If ``False``, the files are processed sequentially in a single process.
+        If ``False``, multi-threading is automatically exploited to speed up I/0 tasks.
+    debugging_mode : bool
+        If ``True``, it reduces the amount of data to process.
+        For L0A, it processes just the first 3 raw data files.
+        For L0B, it processes 100 rows sampled from 3 L0A files.
+        The default value is ``False``.
+    data_archive_dir : str (optional)
+        The directory path where the DISDRODB Data Archive is located.
+        The directory path must end with ``<...>/DISDRODB``.
+        If ``None``, it uses the ``data_archive_dir`` path specified
+        in the DISDRODB active configuration.
+    metadata_archive_dir : str (optional)
+        The directory path where the DISDRODB Metadata Archive is located.
+        The directory path must end with ``<...>/DISDRODB-METADATA/DISDRODB``.
+        If ``None``, it uses the ``metadata_archive_dir`` path specified
+        in the DISDRODB active configuration.
+    """
+    # Determine required product based on the lowest level processing requested
+    required_product = validate_processing_flags_and_get_required_product(
+        l0a_processing=l0a_processing,
+        l0b_processing=l0b_processing,
+        l0c_processing=l0c_processing,
+        l1_processing=l1_processing,
+        l2e_processing=l2e_processing,
+        l2m_processing=l2m_processing,
+    )
+
+    # Get list of available stations
+    list_info = available_stations(
+        # DISDRODB root directories
+        data_archive_dir=data_archive_dir,
+        metadata_archive_dir=metadata_archive_dir,
+        # Stations arguments
+        data_sources=data_sources,
+        campaign_names=campaign_names,
+        station_names=station_names,
+        # Search options
+        product=required_product,
+        raise_error_if_empty=True,
+    )
+
+    # Print message
+    n_stations = len(list_info)
+    print(f"Complete processing of {n_stations} stations started.")
+
+    # Loop over stations
+    for data_source, campaign_name, station_name in list_info:
+        print(f"Complete processing of {data_source} {campaign_name} {station_name} station started.")
+        # Run processing
+        run_station(
+            # DISDRODB root directories
+            data_archive_dir=data_archive_dir,
+            metadata_archive_dir=metadata_archive_dir,
+            # Station arguments
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+            # L0 archive options
+            l0a_processing=l0a_processing,
+            l0b_processing=l0b_processing,
+            l0c_processing=l0c_processing,
+            remove_l0a=remove_l0a,
+            remove_l0b=remove_l0b,
+            # Higher level processing options
+            l1_processing=l1_processing,
+            l2e_processing=l2e_processing,
+            l2m_processing=l2m_processing,
+            # Process options
+            force=force,
+            verbose=verbose,
+            debugging_mode=debugging_mode,
+            parallel=parallel,
+        )
+        print(f"Complete processing of {data_source} {campaign_name} {station_name} station ended.")
+
+    print(f"Complete processing of {n_stations} stations completed.")
+
+
+####--------------------------------------------------------------------------.
+#### Summary Wrappers
 def create_summary(
     data_sources=None,
     campaign_names=None,
@@ -1508,6 +1931,3 @@ def create_summary(
             temporal_resolution=temporal_resolution,
         )
     print("Creation of station summaries has terminated.")
-
-
-####--------------------------------------------------------------------------.

disdrodb/scattering/__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/scattering/axis_ratio.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
@@ -79,9 +79,9 @@ def get_axis_ratio_andsager_1999(diameter):
     return axis_ratio
 
 
-def get_axis_ratio_battaglia_2010(diameter):
+def get_axis_ratio_parsivel(diameter):
     """
-    Compute the axis ratio of raindrops using the Battaglia et al. (2010) model.
+    Compute the axis ratio of raindrops as used by OTT Parsivel sensors.
 
     This axis ratio is assumed by OTT Parsivel sensors internally to compute the
     reported particle size (Deq).
@@ -279,7 +279,7 @@ def get_axis_ratio_thurai_2007(diameter):
 AXIS_RATIO_MODELS = {
     "Thurai2005": get_axis_ratio_thurai_2005,
     "Thurai2007": get_axis_ratio_thurai_2007,
-    "Battaglia2010": get_axis_ratio_battaglia_2010,
+    "Parsivel": get_axis_ratio_parsivel,
     "Brandes2002": get_axis_ratio_brandes_2002,
     "Pruppacher1970": get_axis_ratio_pruppacher_1970,
     "Beard1987": get_axis_ratio_beard_1987,
@@ -307,7 +307,7 @@ def get_axis_ratio_model(model):
     ----------
     model : str
         The model to use for calculating the axis ratio. Available models are:
-        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
+        'Thurai2005', 'Thurai2007', 'Parsivel', 'Brandes2002',
         'Pruppacher1970', 'Beard1987', 'Andsager1999'.
 
     Returns
@@ -339,7 +339,7 @@ def get_axis_ratio(diameter, model):
         Raindrops diameter in mm.
     model : str
         The axis ratio model to use for calculating the axis ratio. Available models are:
-        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
+        'Thurai2005', 'Thurai2007', 'Parsivel', 'Brandes2002',
         'Pruppacher1970', 'Beard1987', 'Andsager1999'.
 
     Returns

disdrodb/scattering/permittivity.py

@@ -1,5 +1,5 @@
 # -----------------------------------------------------------------------------.
-# Copyright (c) 2021-2023 DISDRODB developers
+# Copyright (c) 2021-2026 DISDRODB developers
 #
 # temperaturehis program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -56,7 +56,7 @@ def get_refractive_index_function(permittivity_model):
     ----------
     model : str
         The model to use for calculating the complex refractive index. Available models are:
-        'Liebe1991', 'Liebe1991v2', 'Ellison2005', 'Turner2016', 'Turner2016SLC'.
+        'Liebe1991', 'Liebe1991v2', 'Ellison2007', 'Turner2016', 'Turner2016SLC'.
 
     Returns
     -------
@@ -104,7 +104,7 @@ def get_refractive_index(temperature, frequency, permittivity_model):
         Frequency in GHz.
     permittivity_model : str
         The permittivity model to use for calculating the complex refractive index.
-        Available models are: 'Liebe1991', 'Liebe1991v2', 'Ellison2005', 'Turner2016', 'Turner2016SLC'.
+        Available models are: 'Liebe1991', 'Liebe1991v2', 'Ellison2007', 'Turner2016', 'Turner2016SLC'.
         See available models with ``disdrodb.scattering.available_permittivity_models()``.
 
     Returns
@@ -309,7 +309,7 @@ def get_rain_refractive_index_liebe1991(temperature, frequency):
     return m
 
 
-def get_rain_refractive_index_ellison2005(temperature, frequency):
+def get_rain_refractive_index_ellison2007(temperature, frequency):
     """Compute the complex refractive index according to Ellison (2005) model.
 
     Parameters
@@ -343,8 +343,8 @@ def get_rain_refractive_index_ellison2005(temperature, frequency):
     temperature = ensure_array(temperature)
 
     # Check frequency and temperature within validity range
-    temperature = check_temperature_validity_range(temperature, vmin=0, vmax=100, permittivity_model="Ellison2005")
-    frequency = check_frequency_validity_range(frequency, vmin=0, vmax=1000, permittivity_model="Ellison2005")
+    temperature = check_temperature_validity_range(temperature, vmin=0, vmax=100, permittivity_model="Ellison2007")
+    frequency = check_frequency_validity_range(frequency, vmin=0, vmax=1000, permittivity_model="Ellison2007")
 
     # Conversion of frequency to Hz
     frequency = frequency / 1e-9
@@ -479,7 +479,7 @@ def get_rain_refractive_index_turner2016(frequency, temperature):
 def get_rayleigh_dielectric_factor(m):
     """Compute the Rayleigh dielectric factor |K|**2 from the complex refractive index.
 
-    The magnitude squared of the complex dielectric contrast factor for liquid water,
+    The magnitude squared of the complex dielectric constant factor for liquid water,
     relative to the surrounding medium (typically air).
 
     This factor is used to compute the radar reflectivity.
@@ -505,6 +505,6 @@ def get_rayleigh_dielectric_factor(m):
 REFRACTIVE_INDEX_MODELS = {
     "Liebe1991": get_rain_refractive_index_liebe1991,
     "Liebe1991single": get_rain_refractive_index_liebe1991_single,
-    "Ellison2005": get_rain_refractive_index_ellison2005,
+    "Ellison2007": get_rain_refractive_index_ellison2007,
     "Turner2016": get_rain_refractive_index_turner2016,
 }

disdrodb/scattering/routines.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
@@ -26,7 +26,6 @@ import xarray as xr
 
 from disdrodb.configs import get_scattering_table_dir
 from disdrodb.constants import DIAMETER_DIMENSION
-from disdrodb.l1.filters import filter_diameter_bins
 from disdrodb.psd.models import BinnedPSD, create_psd, get_required_parameters
 from disdrodb.scattering.axis_ratio import check_axis_ratio_model, get_axis_ratio_model
 from disdrodb.scattering.permittivity import (
@@ -35,7 +34,7 @@ from disdrodb.scattering.permittivity import (
     get_refractive_index,
 )
 from disdrodb.utils.logger import log_info
-from disdrodb.utils.manipulations import get_diameter_bin_edges
+from disdrodb.utils.manipulations import filter_diameter_bins, get_diameter_bin_edges
 from disdrodb.utils.warnings import suppress_warnings
 
 logger = logging.getLogger(__name__)
@@ -76,15 +75,26 @@ def check_radar_band(radar_band):
     return radar_band
 
 
+def _is_valid_numeric_frequency(frequency):
+    numeric_value = float(frequency)
+    if numeric_value <= 0:
+        raise ValueError(f"Frequency must be positive, got {numeric_value}")
+    return numeric_value
+
+
 def _check_frequency(frequency):
     """Check the validity of the specified frequency."""
     if isinstance(frequency, str):
-        frequency = check_radar_band(frequency)
-        frequency = frequency_dict[frequency]
-        return frequency
-    if not isinstance(frequency, (int, float)):
-        raise TypeError(f"Frequency {frequency} must be a string or a number.")
-    return frequency
+        try:
+            frequency = float(frequency)
+
+        except ValueError:
+            # Not numeric, assume radar band name
+            frequency = check_radar_band(frequency)
+            frequency = frequency_dict[frequency]
+    if isinstance(frequency, (int, float)):
+        return _is_valid_numeric_frequency(frequency)
+    raise TypeError(f"Frequency {frequency} must be a string or a number.")
 
 
 def ensure_numerical_frequency(frequency):
@@ -476,6 +486,11 @@ def compute_radar_variables(scatterer):
 
     To speed up computations, this function should input a scatterer object with
     a preinitialized scattering table.
+
+    Note
+    ----
+    If this function is modified to compute additional radar variables, the global
+    variable RADAR_VARIABLES must be updated accordingly !
     """
     from pytmatrix import radar
 
@@ -495,10 +510,13 @@ def compute_radar_variables(scatterer):
         radar_vars["ZDR"] = 10 * np.log10(radar.Zdr(scatterer))  # dB
         radar_vars["ZDR"] = np.where(np.isfinite(radar_vars["ZDR"]), radar_vars["ZDR"], np.nan)
 
-        radar_vars["LDR"] = 10 * np.log10(radar.ldr(scatterer))  # dBZ
-        radar_vars["LDR"] = np.where(np.isfinite(radar_vars["LDR"]), radar_vars["LDR"], np.nan)
+        radar_vars["LDRH"] = 10 * np.log10(radar.ldr(scatterer, h_pol=True))  # dBZ
+        radar_vars["LDRH"] = np.where(np.isfinite(radar_vars["LDRH"]), radar_vars["LDRH"], np.nan)
+
+        radar_vars["LDRV"] = 10 * np.log10(radar.ldr(scatterer, h_pol=False))  # dBZ
+        radar_vars["LDRV"] = np.where(np.isfinite(radar_vars["LDRV"]), radar_vars["LDRV"], np.nan)
 
-        radar_vars["RHOHV"] = radar.rho_hv(scatterer)  # deg/km
+        radar_vars["RHOHV"] = radar.rho_hv(scatterer)  # [-]
         radar_vars["DELTAHV"] = radar.delta_hv(scatterer) * 180.0 / np.pi  # [deg]
 
         # Set forward scattering for attenuation and phase calculations
@@ -512,7 +530,7 @@ def compute_radar_variables(scatterer):
 
 # Radar variables computed by DISDRODB
 # - Must reflect dictionary order output of compute_radar_variables
-RADAR_VARIABLES = ["DBZH", "DBZV", "ZDR", "LDR", "RHOHV", "DELTAHV", "KDP", "AH", "AV", "ADP"]
+RADAR_VARIABLES = ["DBZH", "DBZV", "ZDR", "LDRH", "LDRV", "RHOHV", "DELTAHV", "KDP", "AH", "AV", "ADP"]
 
 
 def _try_compute_radar_variables(scatterer):