cloudnetpy 1.72.3__tar.gz → 1.73.1__tar.gz

{cloudnetpy-1.72.3/cloudnetpy.egg-info → cloudnetpy-1.73.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.72.3
+Version: 1.73.1
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/categorize/disdrometer.py

@@ -37,18 +37,18 @@ class Disdrometer(DataSource):
             self.append_data(self.dataset.variables[key][:], key)
 
     def _interpolate(self, y: ma.MaskedArray, x_new: np.ndarray) -> np.ndarray:
-        if ma.getmask(y) is ma.nomask:
-            non_masked_indices = np.arange(len(y))
-        elif y.mask.all():
-            return ma.masked_all(x_new.shape)
-        else:
-            non_masked_indices = np.where(~y.mask)[0]
-        non_masked_values = y[non_masked_indices]
-        non_masked_time = self.time[non_masked_indices]
-        fun = interp1d(non_masked_time, non_masked_values, fill_value="extrapolate")
+        time = self.time
+        mask = ma.getmask(y)
+        if mask is not ma.nomask:
+            if np.all(mask):
+                return ma.masked_all(x_new.shape)
+            not_masked = ~mask
+            y = y[not_masked]
+            time = time[not_masked]
+        fun = interp1d(time, y, fill_value="extrapolate")
         interpolated_array = ma.array(fun(x_new))
         max_time = 1 / 60  # min -> fraction hour
-        mask_ind = get_gap_ind(non_masked_time, x_new, max_time)
+        mask_ind = get_gap_ind(time, x_new, max_time)
 
         if len(mask_ind) > 0:
             msg = f"Unable to interpolate disdrometer for {len(mask_ind)} time steps"

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/categorize/itu.py

@@ -5,7 +5,7 @@ import cloudnetpy.constants as con
 
 
 def calc_liquid_specific_attenuation(
-    temperature: npt.NDArray, frequency: float
+    temperature: npt.NDArray, frequency: float | np.floating
 ) -> npt.NDArray:
     """Calculate cloud liquid water specific attenuation coefficient for
     frequency up to 200 GHz.
@@ -43,7 +43,7 @@ def calc_gas_specific_attenuation(
     pressure: npt.NDArray,
     vapor_pressure: npt.NDArray,
     temperature: npt.NDArray,
-    frequency: float,
+    frequency: float | np.floating,
 ) -> npt.NDArray:
     """Calculate specific attenuation due to dry air and water vapor for
     frequency up to 1000 GHz.
@@ -72,7 +72,7 @@ def calc_gas_specific_attenuation(
 
 
 def _calc_line_shape(
-    frequency: float,
+    frequency: float | np.floating,
     center: npt.NDArray,
     width: npt.NDArray,
     correction: npt.NDArray | float,
@@ -92,7 +92,7 @@ def _calc_line_shape(
 def _calc_oxygen_refractivity(
     dry_pressure: npt.NDArray,
     vapor_pressure: npt.NDArray,
-    frequency: float,
+    frequency: float | np.floating,
     theta: npt.NDArray,
 ) -> npt.NDArray:
     f0, a1, a2, a3, a4, a5, a6 = OXYGEN_TABLE[:, :, np.newaxis, np.newaxis]
@@ -119,7 +119,7 @@ def _calc_oxygen_refractivity(
 def _calc_vapor_refractivity(
     dry_pressure: npt.NDArray,
     vapor_pressure: npt.NDArray,
-    frequency: float,
+    frequency: float | np.floating,
     theta: npt.NDArray,
 ) -> npt.NDArray:
     f0, b1, b2, b3, b4, b5, b6 = VAPOR_TABLE[:, :, np.newaxis, np.newaxis]

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/categorize/melting.py

@@ -166,7 +166,7 @@ def _basetop(dprof: np.ndarray, pind: int) -> tuple[int, int]:
 def _get_temp_indices(t_prof: np.ndarray, t_range: tuple) -> np.ndarray:
     """Finds indices of temperature profile covering the given range."""
     ind = np.where((t_prof > min(t_range) + T0) & (t_prof < max(t_range) + T0))[0]
-    return np.array([]) if len(ind) == 0 else np.arange(min(ind), max(ind) + 1)
+    return np.array([]) if len(ind) == 0 else np.arange(np.min(ind), np.max(ind) + 1)
 
 
 def _find_model_temperature_range(model_type: str) -> tuple[float, float]:

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/__init__.py

@@ -1,4 +1,5 @@
 from .basta import basta2nc
+from .bowtie import bowtie2nc
 from .ceilo import ceilo2nc
 from .copernicus import copernicus2nc
 from .disdrometer import parsivel2nc, thies2nc

cloudnetpy-1.73.1/cloudnetpy/instruments/bowtie.py

@@ -0,0 +1,95 @@
+from os import PathLike
+
+from cloudnetpy import output
+from cloudnetpy.constants import G_TO_KG, MM_H_TO_M_S
+from cloudnetpy.exceptions import ValidTimeStampError
+from cloudnetpy.instruments.instruments import FMCW94
+from cloudnetpy.instruments.nc_radar import NcRadar
+from cloudnetpy.metadata import MetaData
+
+
+def bowtie2nc(
+    bowtie_file: str | PathLike,
+    output_file: str,
+    site_meta: dict,
+    uuid: str | None = None,
+    date: str | None = None,
+) -> str:
+    """Converts data from 'BOW-TIE' campaign cloud radar on RV-Meteor into
+       Cloudnet Level 1b netCDF file.
+
+    Args:
+        bowtie_file: Input filename.
+        output_file: Output filename.
+        site_meta: Dictionary containing information about the site. Required key
+            value pair is `name`. Optional are `latitude`, `longitude`, `altitude`.
+        uuid: Set specific UUID for the file.
+        date: Expected date as YYYY-MM-DD of all profiles in the file.
+
+    Returns:
+        UUID of the generated file.
+
+    Raises:
+        ValidTimeStampError: No valid timestamps found.
+
+    """
+    keymap = {
+        "Zh": "Zh",
+        "v": "v",
+        "width": "width",
+        "ldr": "ldr",
+        "kurt": "kurtosis",
+        "Skew": "skewness",
+        "SNR": "SNR",
+        "time": "time",
+        "range": "range",
+        "lwp": "lwp",
+        "SurfRelHum": "relative_humidity",
+        "rain": "rainfall_rate",
+        "Nyquist_velocity": "nyquist_velocity",
+        "range_offsets": "chirp_start_indices",
+    }
+
+    with Bowtie(bowtie_file, site_meta) as bowtie:
+        bowtie.init_data(keymap)
+        bowtie.add_time_and_range()
+        if date is not None:
+            bowtie.check_date(date)
+        bowtie.add_radar_specific_variables()
+        bowtie.add_site_geolocation()
+        bowtie.add_height()
+        bowtie.convert_units()
+        bowtie.test_if_all_masked()
+    attributes = output.add_time_attribute(ATTRIBUTES, bowtie.date)
+    output.update_attributes(bowtie.data, attributes)
+    return output.save_level1b(bowtie, output_file, uuid)
+
+
+class Bowtie(NcRadar):
+    def __init__(self, full_path: str | PathLike, site_meta: dict):
+        super().__init__(full_path, site_meta)
+        self.instrument = FMCW94
+        self.date = self.get_date()
+
+    def convert_units(self):
+        self.data["lwp"].data *= G_TO_KG
+        self.data["rainfall_rate"].data *= MM_H_TO_M_S
+        self.data["relative_humidity"].data /= 100
+
+    def check_date(self, date: str):
+        if "-".join(self.date) != date:
+            raise ValidTimeStampError
+
+
+ATTRIBUTES: dict = {
+    "v": MetaData(
+        long_name="Doppler velocity",
+        units="m s-1",
+        comment=(
+            "This parameter is the radial component of the velocity, with positive\n"
+            "velocities are away from the radar. It was corrected for the heave\n"
+            "motion of the ship. A rolling average over 3 time steps has been\n"
+            "applied to it."
+        ),
+    ),
+}

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/ceilo.py

@@ -105,6 +105,7 @@ def ceilo2nc(
     ceilo_obj.screen_invalid_values()
     ceilo_obj.prepare_data()
     ceilo_obj.data_to_cloudnet_arrays()
+    ceilo_obj.add_site_geolocation()
     attributes = output.add_time_attribute(ATTRIBUTES, ceilo_obj.date)
     output.update_attributes(ceilo_obj.data, attributes)
     for key in ("beta", "beta_smooth"):

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/ceilometer.py

@@ -93,9 +93,6 @@ class Ceilometer:
             msg = "Instrument wavelength not defined"
             raise RuntimeError(msg)
         self.data["wavelength"] = float(self.instrument.wavelength)
-        for key in ("latitude", "longitude", "altitude"):
-            if key in self.site_meta:
-                self.data[key] = float(self.site_meta[key])
 
     def get_date_and_time(self, epoch: Epoch) -> None:
         if "time" not in self.data:
@@ -113,6 +110,9 @@ class Ceilometer:
             else:
                 self.data[key] = CloudnetArray(array, key)
 
+    def add_site_geolocation(self):
+        utils.add_site_geolocation(self.data, gps=False, site_meta=self.site_meta)
+
     def screen_depol(self) -> None:
         key = "depolarisation"
         if key in self.data:

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/cloudnet_instrument.py

@@ -1,13 +1,16 @@
 import logging
+from typing import TYPE_CHECKING
 
-import netCDF4
 import numpy as np
 from numpy import ma
 
 from cloudnetpy import utils
 from cloudnetpy.cloudnetarray import CloudnetArray
 from cloudnetpy.exceptions import ValidTimeStampError
-from cloudnetpy.instruments.instruments import BASTA, FMCW35, FMCW94, Instrument
+from cloudnetpy.instruments.instruments import BASTA, FMCW35, FMCW94, HATPRO, Instrument
+
+if TYPE_CHECKING:
+    import netCDF4
 
 
 class CloudnetInstrument:
@@ -20,77 +23,13 @@ class CloudnetInstrument:
         self.instrument: Instrument | None = None
 
     def add_site_geolocation(self) -> None:
-        for key in ("latitude", "longitude", "altitude"):
-            value = None
-            source = None
-            # From source data (BASTA, RPG-FMCW).
-            # Should be the accurate GPS coordinates.
-            # HATPRO is handled elsewhere.
-            if (
-                value is None
-                and self.instrument is not None
-                and self.instrument in (BASTA, FMCW94, FMCW35)
-            ):
-                data = None
-                if (
-                    hasattr(self, "dataset")
-                    and isinstance(self.dataset, netCDF4.Dataset)
-                    and key in self.dataset.variables
-                ):
-                    data = self.dataset[key][:]
-                elif key in self.data:
-                    data = self.data[key].data
-                if (
-                    data is not None
-                    and not np.all(ma.getmaskarray(data))
-                    and np.any(data != 0)
-                ):
-                    value = data[data != 0]
-                    source = "GPS"
-            # User-supplied site coordinate.
-            if value is None and key in self.site_meta:
-                value = self.site_meta[key]
-                source = "site coordinates"
-            # From source data (CHM15k, CL61, MRR-PRO, Copernicus, Galileo...).
-            # Assume value is manually set, so cannot trust it.
-            if (
-                value is None
-                and hasattr(self, "dataset")
-                and isinstance(self.dataset, netCDF4.Dataset)
-                and key in self.dataset.variables
-                and not np.all(ma.getmaskarray(self.dataset[key][:]))
-            ):
-                value = self.dataset[key][:]
-                source = "raw file"
-            # From source global attributes (MIRA).
-            # Seems to be manually set, so cannot trust it.
-            if (
-                value is None
-                and hasattr(self, "dataset")
-                and isinstance(self.dataset, netCDF4.Dataset)
-                and hasattr(
-                    self.dataset,
-                    key.capitalize(),
-                )
-            ):
-                value = self._parse_global_attribute_numeral(key.capitalize())
-                source = "raw file"
-            if value is not None:
-                value = float(ma.mean(value))
-                # Convert from 0...360 to -180...180
-                if key == "longitude" and value > 180:
-                    value -= 360
-                self.data[key] = CloudnetArray(value, key, source=source)
-
-    def _parse_global_attribute_numeral(self, key: str) -> float | None:
-        new_str = ""
-        attr = getattr(self.dataset, key)
-        if attr == "Unknown":
-            return None
-        for char in attr:
-            if char.isdigit() or char == ".":
-                new_str += char
-        return float(new_str)
+        has_gps = self.instrument in (BASTA, FMCW94, FMCW35, HATPRO)
+        utils.add_site_geolocation(
+            self.data,
+            gps=has_gps,
+            site_meta=self.site_meta,
+            dataset=self.dataset if hasattr(self, "dataset") else None,
+        )
 
     def add_height(self) -> None:
         zenith_angle = self._get_zenith_angle()

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/hatpro.py

@@ -106,21 +106,7 @@ def hatpro2l1c(
     if "irt" in hatpro.data:
         hatpro.data["irt"].dimensions = ("time", "ir_channel")
 
-    lat = hatpro.data["latitude"].data
-    lon = hatpro.data["longitude"].data
-    valid_latlon = (lat != 0) | (lon != 0)
-    if np.any(valid_latlon):
-        lat = float(ma.mean(lat[valid_latlon]))
-        lon = float(ma.mean(lon[valid_latlon]))
-        latlon_source = "GPS"
-    else:
-        lat = site_meta["latitude"]
-        lon = site_meta["longitude"]
-        latlon_source = "site coordinates"
-    alt = float(site_meta["altitude"])
-    hatpro.data["latitude"] = CloudnetArray(lat, "latitude", source=latlon_source)
-    hatpro.data["longitude"] = CloudnetArray(lon, "longitude", source=latlon_source)
-    hatpro.data["altitude"] = CloudnetArray(alt, "altitude", source="site coordinates")
+    utils.add_site_geolocation(hatpro.data, gps=True, site_meta=site_meta)
 
     attrs_copy = ATTRIBUTES_1B01.copy()
     attributes = output.add_time_attribute(attrs_copy, hatpro.date)

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/pollyxt.py

@@ -60,6 +60,7 @@ def pollyxt2nc(
     polly.prepare_data()
     polly.screen_completely_masked_profiles()
     polly.data_to_cloudnet_arrays(time_dtype="f8")
+    polly.add_site_geolocation()
     attributes = output.add_time_attribute(ATTRIBUTES, polly.date)
     output.update_attributes(polly.data, attributes)
     polly.add_snr_info("beta", snr_limit)

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/instruments/rpg.py

@@ -445,10 +445,6 @@ RPG_ATTRIBUTES = {
         long_name="Number of spectral samples in each chirp sequence",
         units="1",
     ),
-    "chirp_start_indices": MetaData(
-        long_name="Chirp sequences start indices",
-        units="1",
-    ),
     "number_of_averaged_chirps": MetaData(
         long_name="Number of averaged chirps in sequence",
         units="1",
@@ -517,10 +513,6 @@ RPG_ATTRIBUTES = {
         long_name="PC temperature",
         units="K",
     ),
-    "skewness": MetaData(
-        long_name="Skewness of spectra",
-        units="1",
-    ),
     "kurtosis": MetaData(
         long_name="Kurtosis of spectra",
         units="1",

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/metadata.py

@@ -93,6 +93,10 @@ COMMON_ATTRIBUTES = {
         long_name="Kurtosis of spectra",
         units="1",
     ),
+    "skewness": MetaData(
+        long_name="Skewness of spectra",
+        units="1",
+    ),
     "nyquist_velocity": MetaData(long_name="Nyquist velocity", units="m s-1"),
     "radar_frequency": MetaData(long_name="Radar transmit frequency", units="GHz"),
     "beta": MetaData(
@@ -190,4 +194,8 @@ COMMON_ATTRIBUTES = {
         units="dB",
         comment="SNR threshold used in data screening.",
     ),
+    "chirp_start_indices": MetaData(
+        long_name="Chirp sequences start indices",
+        units="1",
+    ),
 }

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/model_evaluation/plotting/plotting.py

@@ -352,7 +352,7 @@ def plot_colormesh(ax, data: np.ndarray, axes: tuple, variable_info) -> None:
     colorbar = init_colorbar(pl, ax)
     if variable_info.plot_scale == "logarithmic":
         tick_labels = get_log_cbar_tick_labels(vmin, vmax)
-        colorbar.set_ticks(np.arange(vmin, vmax + 1).tolist())
+        colorbar.set_ticks(np.arange(vmin, vmax + 1).tolist())  # type: ignore[arg-type]
         colorbar.ax.set_yticklabels(tick_labels)
     ax.set_facecolor("white")
     colorbar.set_label(variable_info.clabel, fontsize=13)

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/plotting/plotting.py

@@ -589,7 +589,7 @@ class Plot2D(Plot):
         cbar.set_label(str(self._plot_meta.clabel), fontsize=13)
 
         if self._is_log:
-            cbar.set_ticks(np.arange(vmin, vmax + 1).tolist())
+            cbar.set_ticks(np.arange(vmin, vmax + 1).tolist())  # type: ignore[arg-type]
             tick_labels = get_log_cbar_tick_labels(vmin, vmax)
             cbar.ax.set_yticklabels(tick_labels)
 

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/utils.py

@@ -15,10 +15,12 @@ from typing import Literal, TypeVar
 
 import netCDF4
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy import ndimage, stats
 from scipy.interpolate import RectBivariateSpline, RegularGridInterpolator, griddata
 
+from cloudnetpy.cloudnetarray import CloudnetArray
 from cloudnetpy.constants import SEC_IN_DAY, SEC_IN_HOUR, SEC_IN_MINUTE
 from cloudnetpy.exceptions import ValidTimeStampError
 
@@ -1050,3 +1052,100 @@ def _calc_hash_sum(filename, method, *, is_base64: bool) -> str:
     if is_base64:
         return base64.encodebytes(hash_sum.digest()).decode("utf-8").strip()
     return hash_sum.hexdigest()
+
+
+def add_site_geolocation(
+    data: dict,
+    *,
+    gps: bool,
+    site_meta: dict | None = None,
+    dataset: netCDF4.Dataset | None = None,
+):
+    tmp_data = {}
+    tmp_source = {}
+
+    for key in ("latitude", "longitude", "altitude"):
+        value = None
+        source = None
+        # Prefer accurate GPS coordinates.
+        if gps:
+            values = None
+            if isinstance(dataset, netCDF4.Dataset) and key in dataset.variables:
+                values = dataset[key][:]
+            elif key in data:
+                values = data[key].data
+            if (
+                values is not None
+                and not np.all(ma.getmaskarray(values))
+                and np.any(values != 0)
+            ):
+                value = ma.masked_where(values == 0, values)
+                source = "GPS"
+        # User-supplied site coordinate.
+        if value is None and site_meta is not None and key in site_meta:
+            value = float(site_meta[key])
+            source = "site coordinates"
+        # From source data (CHM15k, CL61, MRR-PRO, Copernicus, Galileo...).
+        # Assume value is manually set, so cannot trust it.
+        if (
+            value is None
+            and isinstance(dataset, netCDF4.Dataset)
+            and key in dataset.variables
+            and not np.all(ma.getmaskarray(dataset[key][:]))
+        ):
+            value = dataset[key][:]
+            source = "raw file"
+        # From source global attributes (MIRA).
+        # Seems to be manually set, so cannot trust it.
+        if (
+            value is None
+            and isinstance(dataset, netCDF4.Dataset)
+            and hasattr(dataset, key.capitalize())
+        ):
+            value = _parse_global_attribute_numeral(dataset, key.capitalize())
+            source = "raw file"
+        if value is not None:
+            tmp_data[key] = value
+            tmp_source[key] = source
+
+    if "latitude" in tmp_data and "longitude" in tmp_data:
+        lat = np.atleast_1d(tmp_data["latitude"])
+        lon = np.atleast_1d(tmp_data["longitude"])
+        lon[lon > 180] - 360
+        if _are_stationary(lat, lon):
+            tmp_data["latitude"] = float(ma.mean(lat))
+            tmp_data["longitude"] = float(ma.mean(lon))
+        else:
+            tmp_data["latitude"] = lat
+            tmp_data["longitude"] = lon
+
+    if "altitude" in tmp_data:
+        alt = np.atleast_1d(tmp_data["altitude"])
+        if ma.max(alt) - ma.min(alt) < 100:
+            tmp_data["altitude"] = float(ma.mean(alt))
+
+    for key in ("latitude", "longitude", "altitude"):
+        if key in tmp_data:
+            data[key] = CloudnetArray(tmp_data[key], key, source=tmp_source[key])
+
+
+def _parse_global_attribute_numeral(dataset: netCDF4.Dataset, key: str) -> float | None:
+    new_str = ""
+    attr = getattr(dataset, key)
+    if attr == "Unknown":
+        return None
+    for char in attr:
+        if char.isdigit() or char == ".":
+            new_str += char
+    return float(new_str)
+
+
+def _are_stationary(latitude: npt.NDArray, longitude: npt.NDArray) -> bool:
+    min_lat, max_lat = np.min(latitude), np.max(latitude)
+    min_lon, max_lon = np.min(longitude), np.max(longitude)
+    lat_threshold = 0.01  # deg, around 1 km
+    avg_lat = (min_lat + max_lat) / 2
+    lon_threshold = lat_threshold / np.cos(np.radians(avg_lat))
+    lat_diff = max_lat - min_lat
+    lon_diff = max_lon - min_lon
+    return lat_diff <= lat_threshold and lon_diff <= lon_threshold

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
-MINOR = 72
-PATCH = 3
+MINOR = 73
+PATCH = 1
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1/cloudnetpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.72.3
+Version: 1.73.1
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.72.3 → cloudnetpy-1.73.1}/cloudnetpy.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ cloudnetpy/categorize/attenuations/melting_attenuation.py
 cloudnetpy/categorize/attenuations/rain_attenuation.py
 cloudnetpy/instruments/__init__.py
 cloudnetpy/instruments/basta.py
+cloudnetpy/instruments/bowtie.py
 cloudnetpy/instruments/ceilo.py
 cloudnetpy/instruments/ceilometer.py
 cloudnetpy/instruments/cl61d.py