doppy 0.3.1__tar.gz → 0.3.2__tar.gz

{doppy-0.3.1 → doppy-0.3.2}/Cargo.lock

@@ -106,7 +106,7 @@ checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
 
 [[package]]
 name = "doppy_rs"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "doprs",
  "numpy",
@@ -115,7 +115,7 @@ dependencies = [
 
 [[package]]
 name = "doprs"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "chrono",
  "rayon",

{doppy-0.3.1 → doppy-0.3.2}/Cargo.toml

@@ -4,6 +4,6 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.3.1"
+version = "0.3.2"
 authors = ["Niko Leskinen <niko.leskinen@fmi.fi>"]
 license-file = "LICENSE"

{doppy-0.3.1 → doppy-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: doppy
-Version: 0.3.1
+Version: 0.3.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10

{doppy-0.3.1 → doppy-0.3.2}/src/doppy/product/stare.py

@@ -29,6 +29,28 @@ class Stare:
     wavelength: float
     system_id: str
 
+    def __getitem__(
+        self,
+        index: int
+        | slice
+        | list[int]
+        | npt.NDArray[np.int64]
+        | npt.NDArray[np.bool_]
+        | tuple[slice, slice],
+    ) -> Stare:
+        if isinstance(index, (int, slice, list, np.ndarray)):
+            return Stare(
+                time=self.time[index],
+                radial_distance=self.radial_distance,
+                elevation=self.elevation[index],
+                beta=self.beta[index],
+                radial_velocity=self.radial_velocity[index],
+                mask=self.mask[index],
+                wavelength=self.wavelength,
+                system_id=self.system_id,
+            )
+        raise TypeError
+
     @classmethod
     def from_halo_data(
         cls,

doppy-0.3.2/src/doppy/product/stare_depol.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from io import BufferedIOBase
+from pathlib import Path
+from typing import Sequence
+
+import numpy as np
+import numpy.typing as npt
+
+from doppy import options
+from doppy.product.stare import Stare
+
+
+@dataclass
+class StareDepol:
+    """
+    Stare product with depolarisation ratio derived from co-polarised and
+    cross-polarised stare data.
+
+    Attributes:
+    -----------
+    time
+        An array of datetime64 objects representing the observation times.
+    radial_distance
+        An array of radial distances from the observation point, in meters.
+    elevation
+        An array of elevation angles corresponding to the observation points, in
+        degrees.
+    beta
+        An array of backscatter coefficients for the co-polarised signal, in
+        sr-1 m-1.
+    beta_cross
+        An array of backscatter coefficients for the cross-polarised signal, in
+        sr-1 m-1.
+    radial_velocity
+        An array of radial velocities of the co-polarised signal, in m s-1.
+    mask
+        A boolean array indicating signal (True) or noise (False) data points.
+    depolarisation
+        An array of depolarisation ratios calculated as the ratio of
+        co-polarised to cross-polarised backscatter coefficients.
+    wavelength
+        The wavelength of the lidar, in meters.
+    system_id
+        A string identifier for the lidar.
+
+
+    Raises
+    ------
+    ValueError
+        If the input `co` and `cross` products have mismatched wavelengths,
+        system IDs, radial distances, or elevation angles, this exception is
+        raised.
+
+
+    References
+    ----------
+    Aerosol particle depolarization ratio at 1565 nm measured with a Halo Doppler lidar
+        authors: Ville Vakkari, Holger Baars, Stephanie Bohlmann, Johannes Bühl,
+            Mika Komppula, Rodanthi-Elisavet Mamouri, and Ewan James O'Connor
+        doi: https://doi.org/10.5194/acp-21-5807-2021
+    """
+
+    time: npt.NDArray[np.datetime64]
+    radial_distance: npt.NDArray[np.float64]
+    elevation: npt.NDArray[np.float64]
+    beta: npt.NDArray[np.float64]
+    beta_cross: npt.NDArray[np.float64]
+    radial_velocity: npt.NDArray[np.float64]
+    mask: npt.NDArray[np.bool_]
+    depolarisation: npt.NDArray[np.float64]
+    mask_depolarisation: npt.NDArray[np.bool_]
+    mask_beta_cross: npt.NDArray[np.bool_]
+    polariser_bleed_through: float
+    wavelength: float
+    system_id: str
+
+    def __init__(
+        self,
+        co: Stare,
+        cross: Stare,
+        polariser_bleed_through: float = 0.0,
+    ):
+        """
+        Parameters
+        ----------
+        co: Stare
+            The co-polarised data.
+        cross: Stare
+            The cross-polarised data. The `cross.time` array is expected to be sorted.
+        polariser_bleed_through: float, default=0.0
+            The amount of bleed-through from the polariser.
+        """
+
+        if not np.isclose(co.wavelength, cross.wavelength):
+            raise ValueError(
+                "Different wavelength in co and cross: "
+                f"{co.wavelength} vs {cross.wavelength}"
+            )
+        if co.system_id != cross.system_id:
+            raise ValueError(
+                "Different system ID in co and cross: "
+                f"{co.system_id} vs {cross.system_id}"
+            )
+        if not np.allclose(co.radial_distance, cross.radial_distance, atol=1):
+            raise ValueError("Different radial distance in co and cross")
+
+        if co.beta.shape[1] != cross.beta.shape[1]:
+            raise ValueError(
+                "Range dimension mismatch in co and cross: "
+                f"{co.beta.shape[1]} vs {cross.beta.shape[1]}"
+            )
+
+        ind = np.searchsorted(cross.time, co.time, side="left")
+        pick_ind = ind < len(cross.time)
+        time_diff_threshold = 2 * np.median(np.diff(co.time))
+        co_cross_timediff_below_threshold = (
+            cross.time[ind[pick_ind]] - co.time[pick_ind] < time_diff_threshold
+        )
+        pick_ind[pick_ind] &= co_cross_timediff_below_threshold
+
+        if not np.allclose(
+            co.elevation[pick_ind], cross.elevation[ind[pick_ind]], atol=1
+        ):
+            raise ValueError("Different elevation in co and cross")
+
+        depolarisation = np.full_like(co.beta, np.nan)
+        co_beta = co.beta[pick_ind]
+        depolarisation[pick_ind] = (
+            cross.beta[ind[pick_ind]] - polariser_bleed_through * co_beta
+        ) / co_beta
+        cross_beta = np.full_like(co.beta, np.nan)
+        cross_beta[pick_ind] = cross.beta[ind[pick_ind]]
+
+        self.time = co.time
+        self.radial_distance = co.radial_distance
+        self.elevation = co.elevation
+        self.beta = co.beta
+        self.beta_cross = cross_beta
+        self.radial_velocity = co.radial_velocity
+        self.mask = co.mask
+        self.depolarisation = depolarisation
+        self.mask_depolarisation = np.isnan(depolarisation)
+        self.mask_beta_cross = np.isnan(self.beta_cross)
+        self.polariser_bleed_through = polariser_bleed_through
+        self.wavelength = co.wavelength
+        self.system_id = co.system_id
+
+    @classmethod
+    def from_halo_data(
+        cls,
+        co_data: Sequence[str]
+        | Sequence[Path]
+        | Sequence[bytes]
+        | Sequence[BufferedIOBase],
+        co_data_bg: Sequence[str]
+        | Sequence[Path]
+        | Sequence[tuple[bytes, str]]
+        | Sequence[tuple[BufferedIOBase, str]],
+        cross_data: Sequence[str]
+        | Sequence[Path]
+        | Sequence[bytes]
+        | Sequence[BufferedIOBase],
+        cross_data_bg: Sequence[str]
+        | Sequence[Path]
+        | Sequence[tuple[bytes, str]]
+        | Sequence[tuple[BufferedIOBase, str]],
+        bg_correction_method: options.BgCorrectionMethod,
+        polariser_bleed_through: float = 0,
+    ) -> StareDepol:
+        co = Stare.from_halo_data(
+            data=co_data, data_bg=co_data_bg, bg_correction_method=bg_correction_method
+        )
+        cross = Stare.from_halo_data(
+            data=cross_data,
+            data_bg=cross_data_bg,
+            bg_correction_method=bg_correction_method,
+        )
+        return cls(co, cross, polariser_bleed_through)

doppy-0.3.1/src/doppy/product/stare_depol.py

@@ -1,83 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-
-from doppy.product.stare import Stare
-
-
-class StareDepol:
-    """
-    Stare product with depolarisation ratio derived from co-polarised and
-    cross-polarised stare data.
-
-    Attributes:
-    -----------
-    time
-        An array of datetime64 objects representing the observation times.
-    radial_distance
-        An array of radial distances from the observation point, in meters.
-    elevation
-        An array of elevation angles corresponding to the observation points, in
-        degrees.
-    beta
-        An array of backscatter coefficients for the co-polarised signal, in
-        sr-1 m-1.
-    radial_velocity
-        An array of radial velocities of the co-polarised signal, in m s-1.
-    mask
-        A boolean array indicating signal (True) or noise (False) data points.
-    depolarisation
-        An array of depolarisation ratios calculated as the ratio of
-        co-polarised to cross-polarised backscatter coefficients.
-    wavelength
-        The wavelength of the lidar, in meters.
-    system_id
-        A string identifier for the lidar.
-
-    Raises
-    ------
-    ValueError
-        If the input `co` and `cross` products have mismatched wavelengths,
-        system IDs, radial distances, or elevation angles, this exception is
-        raised.
-    """
-
-    time: npt.NDArray[np.datetime64]
-    radial_distance: npt.NDArray[np.float64]
-    elevation: npt.NDArray[np.float64]
-    beta: npt.NDArray[np.float64]
-    radial_velocity: npt.NDArray[np.float64]
-    mask: npt.NDArray[np.bool_]
-    depolarisation: npt.NDArray[np.float64]
-    wavelength: float
-    system_id: str
-
-    def __init__(self, co: Stare, cross: Stare):
-        if co.wavelength != cross.wavelength:
-            raise ValueError(
-                "Different wavelength in co and cross: "
-                f"{co.wavelength} vs {cross.wavelength}"
-            )
-        if co.system_id != cross.system_id:
-            raise ValueError(
-                "Different system ID in co and cross: "
-                f"{co.system_id} vs {cross.system_id}"
-            )
-        if not np.allclose(co.radial_distance, cross.radial_distance, atol=1):
-            raise ValueError("Different radial distance in co and cross")
-
-        time_ind = np.argmin(np.abs(co.time - cross.time[:, np.newaxis]), axis=0)
-        cross_elevation = cross.elevation[time_ind]
-        cross_beta = cross.beta[time_ind, :]
-
-        if not np.allclose(co.elevation, cross_elevation, atol=1):
-            raise ValueError("Different elevation in co and cross")
-
-        self.time = co.time
-        self.radial_distance = co.radial_distance
-        self.elevation = co.elevation
-        self.beta = co.beta
-        self.radial_velocity = co.radial_velocity
-        self.mask = co.mask
-        self.depolarisation = cross_beta / co.beta
-        self.wavelength = co.wavelength
-        self.system_id = co.system_id