disdrodb 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

disdrodb/psd/models.py

@@ -32,7 +32,7 @@ import xarray as xr
 from scipy.interpolate import PchipInterpolator, interp1d
 from scipy.special import gamma as gamma_f
 
-from disdrodb import DIAMETER_DIMENSION
+from disdrodb.constants import DIAMETER_DIMENSION
 from disdrodb.utils.warnings import suppress_warnings
 
 # Check if pytmatrix is available
@@ -79,7 +79,7 @@ def check_diameter_inputs(D):
             raise ValueError("Expecting a 1-dimensional diameter array.")
         if D.size == 0:
             raise ValueError("Expecting a non-empty diameter array.")
-        return xr.DataArray(D, dims=DIAMETER_DIMENSION)
+        return D  # If xr.DataArray(D, dims=DIAMETER_DIMENSION) make pytmatrix failing !
     raise TypeError(f"Invalid diameter type: {type(D)}")
 
 
@@ -121,6 +121,8 @@ class XarrayPSD(PSD):
     def __call__(self, D):
         """Compute the PSD."""
         D = check_diameter_inputs(D)
+        if self.has_xarray_parameters() and not np.isscalar(D):
+            D = xr.DataArray(D, dims=DIAMETER_DIMENSION)
         with suppress_warnings():
             return self.formula(D=D, **self.parameters)
 
@@ -302,7 +304,7 @@ class ExponentialPSD(XarrayPSD):
         Lambda: the inverse scale parameter
 
     Args (call):
-        D: the particle diameter.
+        D: the particle diameter in millimeter.
 
     Returns (call):
         The PSD value for the given diameter.
@@ -377,7 +379,7 @@ class GammaPSD(ExponentialPSD):
         mu: the shape parameter [-]
 
     Args (call):
-        D: the particle diameter.
+        D: the particle diameter in millimeter.
 
     Returns (call):
         The PSD value for the given diameter.
@@ -478,7 +480,7 @@ class NormalizedGammaPSD(XarrayPSD):
         mu: the shape parameter.
 
     Args (call):
-        D: the particle diameter.
+        D: the particle diameter in millimeter.
 
     Returns (call):
         The PSD value for the given diameter.
@@ -695,6 +697,7 @@ class BinnedPSD(PSD):
         """
         # Ensure D is numpy array of correct dimension
         D = np.asanyarray(check_diameter_inputs(D))
+
         # Define interpolator
         interpolator = define_interpolator(
             bin_edges=self.bin_edges,

disdrodb/routines.py

@@ -91,7 +91,7 @@ def run_l0_station(
     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 just the first 100 rows of 3 L0A 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.
@@ -794,7 +794,7 @@ def run_l0b(
         If ``False``, the files are processed sequentially in a single process.
     debugging_mode : bool
         If ``True``, it reduces the amount of data to process.
-        For L0B, it processes just the first 100 rows of 3 L0A 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.
@@ -1033,7 +1033,7 @@ def run_l0(
     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 just the first 100 rows of 3 L0A 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.

disdrodb/scattering/__init__.py

@@ -17,12 +17,24 @@
 """Implement PSD scattering routines."""
 
 
-from disdrodb.scattering.axis_ratio import available_axis_ratio, get_axis_ratio
-from disdrodb.scattering.routines import available_radar_bands, get_radar_parameters
+from disdrodb.scattering.axis_ratio import available_axis_ratio_models, get_axis_ratio_model
+from disdrodb.scattering.permittivity import available_permittivity_models, get_refractive_index
+from disdrodb.scattering.routines import (
+    RADAR_OPTIONS,
+    RADAR_VARIABLES,
+    available_radar_bands,
+    get_radar_parameters,
+    load_scatterer,
+)
 
 __all__ = [
-    "available_axis_ratio",
+    "RADAR_OPTIONS",
+    "RADAR_VARIABLES",
+    "available_axis_ratio_models",
+    "available_permittivity_models",
     "available_radar_bands",
-    "get_axis_ratio",
+    "get_axis_ratio_model",
     "get_radar_parameters",
+    "get_refractive_index",
+    "load_scatterer",
 ]

disdrodb/scattering/axis_ratio.py

@@ -14,70 +14,90 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
-"""Implement drop axis ratio theoretical models."""
+"""Implement drop (vertical-to-horizontal) axis ratio theoretical models."""
 
 import numpy as np
 import xarray as xr
 
 
-def available_axis_ratio():
-    """Return a list of the available drop axis ratio methods."""
-    return list(AXIS_RATIO_METHODS)
+def available_axis_ratio_models():
+    """Return a list of the available drop axis ratio models."""
+    return list(AXIS_RATIO_MODELS)
 
 
-def get_axis_ratio_method(method):
-    """Return the specified drop axis ratio method."""
-    method = check_axis_ratio(method)
-    return AXIS_RATIO_METHODS[method]
+def get_axis_ratio_model(model):
+    """Return the specified drop axis ratio model.
 
+    Parameters
+    ----------
+    model : str
+        The model to use for calculating the axis ratio. Available models are:
+        'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
+        'Pruppacher1970', 'Beard1987', 'Andsager1999'.
 
-def check_axis_ratio(method):
-    """Check validity of the specified drop axis ratio method."""
-    available_methods = available_axis_ratio()
-    if method not in available_methods:
-        raise ValueError(f"{method} is an invalid axis-ratio method. Valid methods: {available_methods}.")
-    return method
+    Returns
+    -------
+    callable
+        A function which compute the vertical-to-horizontal axis ratio given a
+        particle diameter in mm.
 
+    Notes
+    -----
+    This function serves as a wrapper to various axis ratio models for raindrops.
+    It returns the appropriate model based on the `model` parameter.
 
-def get_axis_ratio(diameter, method):
+    Please note that the axis ratio function to be provided to pyTmatrix expects to
+    return a horizontal-to-vertical axis ratio !
+
+    """
+    model = check_axis_ratio_model(model)
+    return AXIS_RATIO_MODELS[model]
+
+
+def check_axis_ratio_model(model):
+    """Check validity of the specified drop axis ratio model."""
+    available_models = available_axis_ratio_models()
+    if model not in available_models:
+        raise ValueError(f"{model} is an invalid axis-ratio model. Valid models: {available_models}.")
+    return model
+
+
+def get_axis_ratio(diameter, model):
     """
-    Compute the axis ratio of raindrops using the specified method.
+    Compute the axis ratio of raindrops using the specified model.
 
     Parameters
     ----------
     diameter : array-like
         Raindrops diameter in mm.
-    method : str
-        The method to use for calculating the axis ratio. Available methods are:
+    model : str
+        The axis ratio model to use for calculating the axis ratio. Available models are:
         'Thurai2005', 'Thurai2007', 'Battaglia2010', 'Brandes2002',
         'Pruppacher1970', 'Beard1987', 'Andsager1999'.
 
     Returns
     -------
     axis_ratio : array-like
-        Calculated axis ratios corresponding to the input diameters.
-
-    Raises
-    ------
-    ValueError
-        If the specified method is not one of the available methods.
+        The vertical-to-horizontal drop axis ratio corresponding to the input diameters.
+        Values of 1 indicate spherical particles, while values <1 indicate oblate particles.
+        Values >1 means prolate particles.
 
     Notes
     -----
     This function serves as a wrapper to various axis ratio models for raindrops.
-    It selects and applies the appropriate model based on the `method` parameter.
+    It selects and applies the appropriate model based on the `model` parameter.
 
     Examples
     --------
     >>> diameter = np.array([0.5, 1.0, 2.0, 3.0])
-    >>> axis_ratio = get_axis_ratio(diameter, method="Brandes2002")
+    >>> axis_ratio = get_axis_ratio(diameter, model="Brandes2002")
 
     """
     # Retrieve axis ratio function
-    func = get_axis_ratio_method(method)
+    axis_ratio_func = get_axis_ratio_model(model)
 
     # Retrieve axis ratio
-    axis_ratio = func(diameter)
+    axis_ratio = axis_ratio_func(diameter)
 
     # Clip values between 0 and 1
     axis_ratio = np.clip(axis_ratio, 0, 1)
@@ -86,7 +106,7 @@ def get_axis_ratio(diameter, method):
 
 def get_axis_ratio_andsager_1999(diameter):
     """
-    Compute the axis ratio of raindrops using the Andsager et al. (1999) method.
+    Compute the axis ratio of raindrops using the Andsager et al. (1999) model.
 
     Parameters
     ----------
@@ -145,7 +165,7 @@ def get_axis_ratio_andsager_1999(diameter):
 
 def get_axis_ratio_battaglia_2010(diameter):
     """
-    Compute the axis ratio of raindrops using the Battaglia et al. (2010) method.
+    Compute the axis ratio of raindrops using the Battaglia et al. (2010) model.
 
     Parameters
     ----------
@@ -185,7 +205,7 @@ def get_axis_ratio_battaglia_2010(diameter):
 
 def get_axis_ratio_beard_1987(diameter):
     """
-    Compute the axis ratio of raindrops using the Beard and Chuang (1987) method.
+    Compute the axis ratio of raindrops using the Beard and Chuang (1987) model.
 
     Parameters
     ----------
@@ -214,7 +234,7 @@ def get_axis_ratio_beard_1987(diameter):
 
 def get_axis_ratio_brandes_2002(diameter):
     """
-    Compute the axis ratio of raindrops using the Brandes et al. (2002) method.
+    Compute the axis ratio of raindrops using the Brandes et al. (2002) model.
 
     Parameters
     ----------
@@ -243,7 +263,7 @@ def get_axis_ratio_brandes_2002(diameter):
 
 def get_axis_ratio_pruppacher_1970(diameter):
     """
-    Compute the axis ratio of raindrops using the Pruppacher and Pitter (1971) method.
+    Compute the axis ratio of raindrops using the Pruppacher and Pitter (1971) model.
 
     Parameters
     ----------
@@ -273,7 +293,7 @@ def get_axis_ratio_pruppacher_1970(diameter):
 
 def get_axis_ratio_thurai_2005(diameter):
     """
-    Compute the axis ratio of raindrops using the Thurai et al. (2005) method.
+    Compute the axis ratio of raindrops using the Thurai et al. (2005) model.
 
     Parameters
     ----------
@@ -297,7 +317,7 @@ def get_axis_ratio_thurai_2005(diameter):
 
 
 def get_axis_ratio_thurai_2007(diameter):
-    """Compute the axis ratio of raindrops using the Thurai et al. (2007) method.
+    """Compute the axis ratio of raindrops using the Thurai et al. (2007) model.
 
     Parameters
     ----------
@@ -333,7 +353,7 @@ def get_axis_ratio_thurai_2007(diameter):
     return axis_ratio
 
 
-AXIS_RATIO_METHODS = {
+AXIS_RATIO_MODELS = {
     "Thurai2005": get_axis_ratio_thurai_2005,
     "Thurai2007": get_axis_ratio_thurai_2007,
     "Battaglia2010": get_axis_ratio_battaglia_2010,