doppy 0.3.1__tar.gz → 0.3.3__tar.gz

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: doppy
-Version: 0.3.1
+Version: 0.3.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -44,8 +44,8 @@ Project-URL: Bug Tracker, https://github.com/actris-cloudnet/doppy/issues
 
 ## Products
 
-- [Stare](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/stare.py): [Examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar&dateFrom=2024-06-05&dateTo=2024-06-05)
-- [Wind](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/wind.py): [Examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar-wind&dateFrom=2024-06-05&dateTo=2024-06-05)
+- Stare: [src](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/stare.py), [Cloudnet examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar&dateFrom=2024-06-05&dateTo=2024-06-05)
+- Wind: [src](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/wind.py), [Cloudnet examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar-wind&dateFrom=2024-06-05&dateTo=2024-06-05)
 
 ## Instruments
 
@@ -61,6 +61,8 @@ pip install doppy
 
 ## Usage
 
+### Stare
+
 ```python
 import doppy
 
@@ -70,68 +72,68 @@ stare = doppy.product.Stare.from_halo_data(
     bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
 )
 
+stare.write_to_netcdf(FILENAME)
+```
+
+### Stare with depolarisation
+
+```python
+import doppy
+
+stare_depol = doppy.product.StareDepol.from_halo_data(
+    co_data=LIST_OF_STARE_CO_FILE_PATHS,
+    co_data_bg=LIST_OF_BACKGROUND_CO_FILE_PATHS,
+    cross_data=LIST_OF_STARE_CROSS_FILE_PATHS,
+    cross_data_bg=LIST_OF_BACKGROUND_CROSS_FILE_PATHS,
+    bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
+    polariser_bleed_through=0,
+)
+
+stare_depol.write_to_netcdf(FILENAME)
+```
+
+### Wind
+
+```python
+import doppy
+
+wind = doppy.product.Wind.from_halo_data(
+    data=LIST_OF_WIND_SCAN_HPL_FILES,
+)
+
+# You can also pass instrument azimuth offset in degrees as an option
+wind = doppy.product.Wind.from_halo_data(
+    data=LIST_OF_WIND_SCAN_HPL_FILES,
+    options=doppy.product.wind.Options(azimuth_offset_deg=30),
+)
+
+# For windcube wls200s use
+wind = doppy.product.Wind.from_windcube_data(
+    data=LIST_OF_VAD_NETCDF_FILES,
+)
+
+# For windcube wls70 use
+wind = doppy.product.Wind.from_wls70_data(
+    data=LIST_OF_RTD_FILES,
+)
+
+wind.write_to_netcdf(FILENAME)
+```
+
+### Raw files
+
+```python
+import doppy
+
+# Halo
+raws_hpl = doppy.raw.HaloHpl.from_srcs(LIST_OF_HPL_FILES)
+raws_bg = doppy.raw.HaloBg.from_srcs(LIST_OF_BACKGROUND_FILES)
+raw_system_params = doppy.raw.HaloSysParams.from_src(SYSTEM_PARAMS_FILENAME)
 
-(
-    doppy.netcdf.Dataset(FILENAME)
-    .add_dimension("time")
-    .add_dimension("range")
-    .add_time(
-        name="time",
-        dimensions=("time",),
-        standard_name="time",
-        long_name="Time UTC",
-        data=stare.time,
-        dtype="f8",
-    )
-    .add_variable(
-        name="range",
-        dimensions=("range",),
-        units="m",
-        data=stare.radial_distance,
-        dtype="f4",
-    )
-    .add_variable(
-        name="elevation",
-        dimensions=("time",),
-        units="degrees",
-        data=stare.elevation,
-        dtype="f4",
-        long_name="elevation from horizontal",
-    )
-    .add_variable(
-        name="beta_raw",
-        dimensions=("time", "range"),
-        units="sr-1 m-1",
-        data=stare.beta,
-        dtype="f4",
-    )
-    .add_variable(
-        name="beta",
-        dimensions=("time", "range"),
-        units="sr-1 m-1",
-        data=stare.beta,
-        dtype="f4",
-        mask=stare.mask,
-    )
-    .add_variable(
-        name="v",
-        dimensions=("time", "range"),
-        units="m s-1",
-        long_name="Doppler velocity",
-        data=stare.radial_velocity,
-        dtype="f4",
-        mask=stare.mask,
-    )
-    .add_scalar_variable(
-        name="wavelength",
-        units="m",
-        standard_name="radiation_wavelength",
-        data=stare.wavelength,
-        dtype="f4",
-    )
-    .add_attribute("serial_number", stare.system_id)
-    .add_attribute("doppy_version", doppy.__version__)
-).close()
+# Windcube WLS200S
+raws_wls200s = doppy.raw.WindCube.from_vad_srcs(LIST_OF_VAD_NETCDF_FILES)
 
+# Windcube WLS70
+raws_wls70 = doppy.raw.Wls70.from_srcs(LIST_OF_RTD_FILES)
 ```
 

doppy-0.3.3/README.md

@@ -0,0 +1,99 @@
+# Doppy – Doppler wind lidar processing
+
+[![CI](https://github.com/actris-cloudnet/doppy/actions/workflows/ci.yml/badge.svg)](https://github.com/actris-cloudnet/doppy/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/doppy.svg)](https://badge.fury.io/py/doppy)
+
+## Products
+
+- Stare: [src](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/stare.py), [Cloudnet examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar&dateFrom=2024-06-05&dateTo=2024-06-05)
+- Wind: [src](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/wind.py), [Cloudnet examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar-wind&dateFrom=2024-06-05&dateTo=2024-06-05)
+
+## Instruments
+
+- HALO Photonics Streamline lidars (stare, wind)
+- Leosphere WindCube WLS200S (wind)
+- Leosphere WindCube WLS70 (wind)
+
+## Install
+
+```sh
+pip install doppy
+```
+
+## Usage
+
+### Stare
+
+```python
+import doppy
+
+stare = doppy.product.Stare.from_halo_data(
+    data=LIST_OF_STARE_FILE_PATHS,
+    data_bg=LIST_OF_BACKGROUND_FILE_PATHS,
+    bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
+)
+
+stare.write_to_netcdf(FILENAME)
+```
+
+### Stare with depolarisation
+
+```python
+import doppy
+
+stare_depol = doppy.product.StareDepol.from_halo_data(
+    co_data=LIST_OF_STARE_CO_FILE_PATHS,
+    co_data_bg=LIST_OF_BACKGROUND_CO_FILE_PATHS,
+    cross_data=LIST_OF_STARE_CROSS_FILE_PATHS,
+    cross_data_bg=LIST_OF_BACKGROUND_CROSS_FILE_PATHS,
+    bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
+    polariser_bleed_through=0,
+)
+
+stare_depol.write_to_netcdf(FILENAME)
+```
+
+### Wind
+
+```python
+import doppy
+
+wind = doppy.product.Wind.from_halo_data(
+    data=LIST_OF_WIND_SCAN_HPL_FILES,
+)
+
+# You can also pass instrument azimuth offset in degrees as an option
+wind = doppy.product.Wind.from_halo_data(
+    data=LIST_OF_WIND_SCAN_HPL_FILES,
+    options=doppy.product.wind.Options(azimuth_offset_deg=30),
+)
+
+# For windcube wls200s use
+wind = doppy.product.Wind.from_windcube_data(
+    data=LIST_OF_VAD_NETCDF_FILES,
+)
+
+# For windcube wls70 use
+wind = doppy.product.Wind.from_wls70_data(
+    data=LIST_OF_RTD_FILES,
+)
+
+wind.write_to_netcdf(FILENAME)
+```
+
+### Raw files
+
+```python
+import doppy
+
+# Halo
+raws_hpl = doppy.raw.HaloHpl.from_srcs(LIST_OF_HPL_FILES)
+raws_bg = doppy.raw.HaloBg.from_srcs(LIST_OF_BACKGROUND_FILES)
+raw_system_params = doppy.raw.HaloSysParams.from_src(SYSTEM_PARAMS_FILENAME)
+
+# Windcube WLS200S
+raws_wls200s = doppy.raw.WindCube.from_vad_srcs(LIST_OF_VAD_NETCDF_FILES)
+
+# Windcube WLS70
+raws_wls70 = doppy.raw.Wls70.from_srcs(LIST_OF_RTD_FILES)
+```

{doppy-0.3.1 → doppy-0.3.3}/src/doppy/netcdf.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import pathlib
 import warnings
 from types import TracebackType
 from typing import Literal, TypeAlias
@@ -12,7 +13,7 @@ NetCDFDataType: TypeAlias = Literal["f4", "f8", "i4", "i8", "u4", "u8"]
 
 
 class Dataset:
-    def __init__(self, filename: str) -> None:
+    def __init__(self, filename: str | pathlib.Path) -> None:
         self.nc = netCDF4.Dataset(filename, mode="w")
 
     def __enter__(self) -> Dataset:

{doppy-0.3.1 → doppy-0.3.3}/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,
@@ -93,6 +115,67 @@ class Stare:
             system_id=raw.header.system_id,
         )
 
+    def write_to_netcdf(self, filename: str | Path) -> None:
+        with doppy.netcdf.Dataset(filename) as nc:
+            nc.add_dimension("time")
+            nc.add_dimension("range")
+            nc.add_time(
+                name="time",
+                dimensions=("time",),
+                standard_name="time",
+                long_name="Time UTC",
+                data=self.time,
+                dtype="f8",
+            )
+            nc.add_variable(
+                name="range",
+                dimensions=("range",),
+                units="m",
+                data=self.radial_distance,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="elevation",
+                dimensions=("time",),
+                units="degrees",
+                data=self.elevation,
+                dtype="f4",
+                long_name="elevation from horizontal",
+            )
+            nc.add_variable(
+                name="beta_raw",
+                dimensions=("time", "range"),
+                units="sr-1 m-1",
+                data=self.beta,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="beta",
+                dimensions=("time", "range"),
+                units="sr-1 m-1",
+                data=self.beta,
+                dtype="f4",
+                mask=self.mask,
+            )
+            nc.add_variable(
+                name="v",
+                dimensions=("time", "range"),
+                units="m s-1",
+                long_name="Doppler velocity",
+                data=self.radial_velocity,
+                dtype="f4",
+                mask=self.mask,
+            )
+            nc.add_scalar_variable(
+                name="wavelength",
+                units="m",
+                standard_name="radiation_wavelength",
+                data=self.wavelength,
+                dtype="f4",
+            )
+            nc.add_attribute("serial_number", self.system_id)
+            nc.add_attribute("doppy_version", doppy.__version__)
+
 
 def _compute_noise_mask(
     intensity: npt.NDArray[np.float64],

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

@@ -0,0 +1,281 @@
+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
+
+import doppy
+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)
+
+    def write_to_netcdf(self, filename: str | Path) -> None:
+        with doppy.netcdf.Dataset(filename) as nc:
+            nc.add_dimension("time")
+            nc.add_dimension("range")
+            nc.add_time(
+                name="time",
+                dimensions=("time",),
+                standard_name="time",
+                long_name="Time UTC",
+                data=self.time,
+                dtype="f8",
+            )
+            nc.add_variable(
+                name="range",
+                dimensions=("range",),
+                units="m",
+                data=self.radial_distance,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="elevation",
+                dimensions=("time",),
+                units="degrees",
+                data=self.elevation,
+                dtype="f4",
+                long_name="elevation from horizontal",
+            )
+            nc.add_variable(
+                name="beta_raw",
+                dimensions=("time", "range"),
+                units="sr-1 m-1",
+                data=self.beta,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="beta",
+                dimensions=("time", "range"),
+                units="sr-1 m-1",
+                data=self.beta,
+                dtype="f4",
+                mask=self.mask,
+            )
+            nc.add_variable(
+                name="v",
+                dimensions=("time", "range"),
+                units="m s-1",
+                long_name="Doppler velocity",
+                data=self.radial_velocity,
+                dtype="f4",
+                mask=self.mask,
+            )
+            nc.add_scalar_variable(
+                name="wavelength",
+                units="m",
+                standard_name="radiation_wavelength",
+                data=self.wavelength,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="depolarisation_raw",
+                dimensions=("time", "range"),
+                units="1",
+                data=self.depolarisation,
+                dtype="f4",
+                mask=self.mask_depolarisation,
+            )
+            nc.add_variable(
+                name="depolarisation",
+                dimensions=("time", "range"),
+                units="1",
+                data=self.depolarisation,
+                dtype="f4",
+                mask=self.mask | self.mask_depolarisation,
+            )
+            nc.add_variable(
+                name="beta_cross_raw",
+                dimensions=("time", "range"),
+                units="sr-1 m-1",
+                data=self.beta_cross,
+                mask=self.mask_beta_cross,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="beta_cross",
+                dimensions=("time", "range"),
+                units="sr-1 m-1",
+                data=self.beta_cross,
+                mask=self.mask | self.mask_beta_cross,
+                dtype="f4",
+            )
+            nc.add_scalar_variable(
+                name="polariser_bleed_through",
+                units="1",
+                long_name="Polariser bleed-through",
+                data=self.polariser_bleed_through,
+                dtype="f4",
+            )
+            nc.add_attribute("serial_number", self.system_id)
+            nc.add_attribute("doppy_version", doppy.__version__)

{doppy-0.3.1 → doppy-0.3.3}/src/doppy/product/wind.py

@@ -32,6 +32,7 @@ class Wind:
     vertical_wind: npt.NDArray[np.float64]
     mask: npt.NDArray[np.bool_]
     system_id: str
+    options: Options | None
 
     @functools.cached_property
     def horizontal_wind_speed(self) -> npt.NDArray[np.float64]:
@@ -104,6 +105,7 @@ class Wind:
             vertical_wind=wind[:, :, 2],
             mask=mask,
             system_id=raw.header.system_id,
+            options=options,
         )
 
     @classmethod
@@ -163,6 +165,7 @@ class Wind:
             vertical_wind=wind[:, :, 2],
             mask=mask,
             system_id=raw.system_id,
+            options=options,
         )
 
     @classmethod
@@ -211,8 +214,74 @@ class Wind:
             vertical_wind=raw.vertical_wind,
             mask=mask,
             system_id=raw.system_id,
+            options=options,
         )
 
+    def write_to_netcdf(self, filename: str | Path) -> None:
+        with doppy.netcdf.Dataset(filename) as nc:
+            nc.add_dimension("time")
+            nc.add_dimension("height")
+            nc.add_time(
+                name="time",
+                dimensions=("time",),
+                standard_name="time",
+                long_name="Time UTC",
+                data=self.time,
+                dtype="f8",
+            )
+            nc.add_variable(
+                name="height",
+                dimensions=("height",),
+                units="m",
+                data=self.height,
+                dtype="f4",
+            )
+            nc.add_variable(
+                name="uwind_raw",
+                dimensions=("time", "height"),
+                units="m s-1",
+                data=self.zonal_wind,
+                dtype="f4",
+                long_name="Non-screened zonal wind",
+            )
+            nc.add_variable(
+                name="uwind",
+                dimensions=("time", "height"),
+                units="m s-1",
+                data=self.zonal_wind,
+                mask=self.mask,
+                dtype="f4",
+                long_name="Zonal wind",
+            )
+            nc.add_variable(
+                name="vwind_raw",
+                dimensions=("time", "height"),
+                units="m s-1",
+                data=self.meridional_wind,
+                dtype="f4",
+                long_name="Non-screened meridional wind",
+            )
+            nc.add_variable(
+                name="vwind",
+                dimensions=("time", "height"),
+                units="m s-1",
+                data=self.meridional_wind,
+                mask=self.mask,
+                dtype="f4",
+                long_name="Meridional wind",
+            )
+            nc.add_attribute("serial_number", self.system_id)
+            nc.add_attribute("doppy_version", doppy.__version__)
+            if self.options is not None and self.options.azimuth_offset_deg is not None:
+                nc.add_scalar_variable(
+                    name="azimuth_offset",
+                    units="degrees",
+                    data=self.options.azimuth_offset_deg,
+                    dtype="f4",
+                    long_name="Azimuth offset of the instrument "
+                    "(positive clockwise from north)",
+                )
+
 
 def _compute_wind(
     raw: doppy.raw.HaloHpl | doppy.raw.WindCube,

doppy-0.3.1/README.md

@@ -1,97 +0,0 @@
-# Doppy – Doppler wind lidar processing
-
-[![CI](https://github.com/actris-cloudnet/doppy/actions/workflows/ci.yml/badge.svg)](https://github.com/actris-cloudnet/doppy/actions/workflows/ci.yml)
-[![PyPI version](https://badge.fury.io/py/doppy.svg)](https://badge.fury.io/py/doppy)
-
-## Products
-
-- [Stare](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/stare.py): [Examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar&dateFrom=2024-06-05&dateTo=2024-06-05)
-- [Wind](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/wind.py): [Examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar-wind&dateFrom=2024-06-05&dateTo=2024-06-05)
-
-## Instruments
-
-- HALO Photonics Streamline lidars (stare, wind)
-- Leosphere WindCube WLS200S (wind)
-- Leosphere WindCube WLS70 (wind)
-
-## Install
-
-```sh
-pip install doppy
-```
-
-## Usage
-
-```python
-import doppy
-
-stare = doppy.product.Stare.from_halo_data(
-    data=LIST_OF_STARE_FILE_PATHS,
-    data_bg=LIST_OF_BACKGROUND_FILE_PATHS,
-    bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
-)
-
-
-(
-    doppy.netcdf.Dataset(FILENAME)
-    .add_dimension("time")
-    .add_dimension("range")
-    .add_time(
-        name="time",
-        dimensions=("time",),
-        standard_name="time",
-        long_name="Time UTC",
-        data=stare.time,
-        dtype="f8",
-    )
-    .add_variable(
-        name="range",
-        dimensions=("range",),
-        units="m",
-        data=stare.radial_distance,
-        dtype="f4",
-    )
-    .add_variable(
-        name="elevation",
-        dimensions=("time",),
-        units="degrees",
-        data=stare.elevation,
-        dtype="f4",
-        long_name="elevation from horizontal",
-    )
-    .add_variable(
-        name="beta_raw",
-        dimensions=("time", "range"),
-        units="sr-1 m-1",
-        data=stare.beta,
-        dtype="f4",
-    )
-    .add_variable(
-        name="beta",
-        dimensions=("time", "range"),
-        units="sr-1 m-1",
-        data=stare.beta,
-        dtype="f4",
-        mask=stare.mask,
-    )
-    .add_variable(
-        name="v",
-        dimensions=("time", "range"),
-        units="m s-1",
-        long_name="Doppler velocity",
-        data=stare.radial_velocity,
-        dtype="f4",
-        mask=stare.mask,
-    )
-    .add_scalar_variable(
-        name="wavelength",
-        units="m",
-        standard_name="radiation_wavelength",
-        data=stare.wavelength,
-        dtype="f4",
-    )
-    .add_attribute("serial_number", stare.system_id)
-    .add_attribute("doppy_version", doppy.__version__)
-).close()
-
-```

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