cloudnetpy 1.61.11__py3-none-any.whl → 1.61.13__py3-none-any.whl

cloudnetpy/instruments/weather_station.py

@@ -8,7 +8,7 @@ from numpy import ma
 from cloudnetpy import output
 from cloudnetpy.categorize import atmos_utils
 from cloudnetpy.cloudnetarray import CloudnetArray
-from cloudnetpy.constants import SEC_IN_HOUR
+from cloudnetpy.constants import MM_H_TO_M_S, SEC_IN_HOUR
 from cloudnetpy.exceptions import ValidTimeStampError, WeatherStationDataError
 from cloudnetpy.instruments import instruments
 from cloudnetpy.instruments.cloudnet_instrument import CloudnetInstrument
@@ -51,6 +51,8 @@ def ws2nc(
             ws = GranadaWS(weather_station_file, site_meta)
         elif site_meta["name"] == "Kenttärova":
             ws = KenttarovaWS(weather_station_file, site_meta)
+        elif site_meta["name"] == "Hyytiälä":
+            ws = HyytialaWS(weather_station_file, site_meta)
         else:
             msg = "Unsupported site"
             raise ValueError(msg)  # noqa: TRY301
@@ -60,7 +62,10 @@ def ws2nc(
         ws.add_date()
         ws.add_site_geolocation()
         ws.add_data()
-        ws.convert_units()
+        ws.convert_temperature_and_humidity()
+        ws.convert_pressure()
+        ws.convert_rainfall_rate()
+        ws.convert_rainfall_amount()
         ws.calculate_rainfall_amount()
         attributes = output.add_time_attribute(ATTRIBUTES, ws.date)
         output.update_attributes(ws.data, attributes)
@@ -70,22 +75,24 @@ def ws2nc(
 
 
 class WS(CloudnetInstrument):
-    date: list[str]
-
-    def convert_time(self) -> None:
-        pass
+    def __init__(self):
+        super().__init__()
+        self._data: dict
 
-    def screen_timestamps(self, date: str) -> None:
-        pass
+    date: list[str]
 
     def add_date(self) -> None:
-        pass
+        first_date = self._data["time"][0].date()
+        self.date = [
+            str(first_date.year),
+            str(first_date.month).zfill(2),
+            str(first_date.day).zfill(2),
+        ]
 
     def add_data(self) -> None:
-        pass
-
-    def convert_units(self) -> None:
-        pass
+        for key, value in self._data.items():
+            parsed = datetime2decimal_hours(value) if key == "time" else ma.array(value)
+            self.data[key] = CloudnetArray(parsed, key)
 
     def calculate_rainfall_amount(self) -> None:
         if "rainfall_amount" in self.data:
@@ -94,6 +101,34 @@ class WS(CloudnetInstrument):
         rainfall_amount = ma.cumsum(self.data["rainfall_rate"].data * resolution)
         self.data["rainfall_amount"] = CloudnetArray(rainfall_amount, "rainfall_amount")
 
+    def screen_timestamps(self, date: str) -> None:
+        dates = [str(d.date()) for d in self._data["time"]]
+        valid_ind = [ind for ind, d in enumerate(dates) if d == date]
+        if not valid_ind:
+            raise ValidTimeStampError
+        for key in self._data:
+            self._data[key] = [
+                x for ind, x in enumerate(self._data[key]) if ind in valid_ind
+            ]
+
+    def convert_temperature_and_humidity(self) -> None:
+        temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
+        self.data["air_temperature"].data = temperature_kelvins
+        self.data["relative_humidity"].data = self.data["relative_humidity"][:] / 100
+
+    def convert_rainfall_rate(self) -> None:
+        rainfall_rate = self.data["rainfall_rate"][:]
+        self.data["rainfall_rate"].data = rainfall_rate / 60 / 1000  # mm/min -> m/s
+
+    def convert_pressure(self) -> None:
+        self.data["air_pressure"].data = self.data["air_pressure"][:] * 100  # hPa to Pa
+
+    def convert_time(self) -> None:
+        pass
+
+    def convert_rainfall_amount(self) -> None:
+        pass
+
 
 class PalaiseauWS(WS):
     def __init__(self, filenames: list[str], site_meta: dict):
@@ -141,14 +176,14 @@ class PalaiseauWS(WS):
         for title, identifier in zip(column_titles, expected_identifiers, strict=True):
             if identifier not in title:
                 raise ValueError(error_msg)
-        return {"timestamps": timestamps, "values": values}
+        return {"time": timestamps, "values": values}
 
     def convert_time(self) -> None:
-        decimal_hours = datetime2decimal_hours(self._data["timestamps"])
+        decimal_hours = datetime2decimal_hours(self._data["time"])
         self.data["time"] = CloudnetArray(decimal_hours, "time")
 
     def screen_timestamps(self, date: str) -> None:
-        dates = [str(d.date()) for d in self._data["timestamps"]]
+        dates = [str(d.date()) for d in self._data["time"]]
         valid_ind = [ind for ind, d in enumerate(dates) if d == date]
         if not valid_ind:
             raise ValidTimeStampError
@@ -157,14 +192,6 @@ class PalaiseauWS(WS):
                 x for ind, x in enumerate(self._data[key]) if ind in valid_ind
             ]
 
-    def add_date(self) -> None:
-        first_date = self._data["timestamps"][0].date()
-        self.date = [
-            str(first_date.year),
-            str(first_date.month).zfill(2),
-            str(first_date.day).zfill(2),
-        ]
-
     def add_data(self) -> None:
         keys = (
             "wind_speed",
@@ -180,13 +207,7 @@ class PalaiseauWS(WS):
             array_masked = ma.masked_invalid(array)
             self.data[key] = CloudnetArray(array_masked, key)
 
-    def convert_units(self) -> None:
-        temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
-        self.data["air_temperature"].data = temperature_kelvins
-        self.data["relative_humidity"].data = self.data["relative_humidity"][:] / 100
-        self.data["air_pressure"].data = self.data["air_pressure"][:] * 100  # hPa -> Pa
-        rainfall_rate = self.data["rainfall_rate"][:]
-        self.data["rainfall_rate"].data = rainfall_rate / 60 / 1000  # mm/min -> m/s
+    def convert_rainfall_amount(self) -> None:
         self.data["rainfall_amount"].data = (
             self.data["rainfall_amount"][:] / 1000
         )  # mm -> m
@@ -240,40 +261,6 @@ class GranadaWS(WS):
                 data[keymap[key]].append(parsed)
         return data
 
-    def convert_time(self) -> None:
-        pass
-
-    def screen_timestamps(self, date: str) -> None:
-        dates = [str(d.date()) for d in self._data["time"]]
-        valid_ind = [ind for ind, d in enumerate(dates) if d == date]
-        if not valid_ind:
-            raise ValidTimeStampError
-        for key in self._data:
-            self._data[key] = [
-                x for ind, x in enumerate(self._data[key]) if ind in valid_ind
-            ]
-
-    def add_date(self) -> None:
-        first_date = self._data["time"][0].date()
-        self.date = [
-            str(first_date.year),
-            str(first_date.month).zfill(2),
-            str(first_date.day).zfill(2),
-        ]
-
-    def add_data(self) -> None:
-        for key, value in self._data.items():
-            parsed = datetime2decimal_hours(value) if key == "time" else np.array(value)
-            self.data[key] = CloudnetArray(parsed, key)
-
-    def convert_units(self) -> None:
-        temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
-        self.data["air_temperature"].data = temperature_kelvins
-        self.data["relative_humidity"].data = self.data["relative_humidity"][:] / 100
-        self.data["air_pressure"].data = self.data["air_pressure"][:] * 100  # hPa -> Pa
-        rainfall_rate = self.data["rainfall_rate"][:]
-        self.data["rainfall_rate"].data = rainfall_rate / 60 / 1000  # mm/min -> m/s
-
 
 class KenttarovaWS(WS):
     def __init__(self, filenames: list[str], site_meta: dict):
@@ -322,41 +309,89 @@ class KenttarovaWS(WS):
             merged[key] = new_value
         return merged
 
-    def convert_time(self) -> None:
-        pass
+    def convert_rainfall_rate(self) -> None:
+        # Rainfall rate is 10-minute averaged in mm h-1
+        rainfall_rate = self.data["rainfall_rate"][:]
+        self.data["rainfall_rate"].data = rainfall_rate * MM_H_TO_M_S / 10
 
-    def screen_timestamps(self, date: str) -> None:
-        dates = [str(d.date()) for d in self._data["time"]]
-        valid_ind = [ind for ind, d in enumerate(dates) if d == date]
-        if not valid_ind:
-            raise ValidTimeStampError
-        for key in self._data:
-            self._data[key] = [
-                x for ind, x in enumerate(self._data[key]) if ind in valid_ind
-            ]
+    def convert_pressure(self) -> None:
+        # Magic number 10 to convert to realistic Pa
+        self.data["air_pressure"].data = self.data["air_pressure"][:] * 10
 
-    def add_date(self) -> None:
-        first_date = self._data["time"][0].date()
-        self.date = [
-            str(first_date.year),
-            str(first_date.month).zfill(2),
-            str(first_date.day).zfill(2),
-        ]
 
-    def add_data(self) -> None:
-        for key, value in self._data.items():
-            parsed = datetime2decimal_hours(value) if key == "time" else ma.array(value)
-            self.data[key] = CloudnetArray(parsed, key)
+class HyytialaWS(WS):
+    """
+    Hyytiälä rain-gauge variables: a = Pluvio400 and b = Pluvio200.
+    E.g.
+    - AaRNRT/mm = amount of non-real-time rain total (Pluvio400) [mm]
+    - BbRT/mm = Bucket content in real-time (Pluvio200) [mm]
+    """
 
-    def convert_units(self) -> None:
-        temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
-        self.data["air_temperature"].data = temperature_kelvins
-        self.data["relative_humidity"].data = self.data["relative_humidity"][:] / 100
-        self.data["air_pressure"].data = self.data["air_pressure"][:] * 100  # hPa -> Pa
-        rainfall_rate = self.data["rainfall_rate"][:]
-        self.data["rainfall_rate"].data = (
-            rainfall_rate / 3600 / 10 / 1000
-        )  # not sure about units
+    def __init__(self, filenames: list[str], site_meta: dict):
+        super().__init__()
+        self.filename = filenames[0]
+        self.site_meta = site_meta
+        self.instrument = instruments.GENERIC_WEATHER_STATION
+        self._data = self._read_data()
+
+    def _read_data(self) -> dict:
+        with open(self.filename, newline="") as f:
+            # Skip first two lines
+            for _ in range(2):
+                next(f)
+            # Read header
+            header_line = f.readline().strip()
+            fields = header_line[1:].strip().split()
+            reader = csv.DictReader(
+                f, delimiter=" ", skipinitialspace=True, fieldnames=fields
+            )
+            if reader.fieldnames is None:
+                raise ValueError
+            raw_data: dict = {key: [] for key in reader.fieldnames}
+            raw_data["time"] = []
+            # Read data
+            for row in reader:
+                for key, value in row.items():
+                    if key:
+                        parsed_value: float | datetime.datetime
+                        if key == "y":
+                            current_time = datetime.datetime(
+                                int(value),
+                                int(row["m"]),
+                                int(row["d"]),
+                                int(row["minute"]) // 60,
+                                int(row["minute"]) % 60,
+                            )
+                            raw_data["time"].append(current_time)
+                        else:
+                            try:
+                                parsed_value = float(value)
+                            except (TypeError, ValueError):
+                                parsed_value = math.nan
+                            if parsed_value == -99.99:
+                                parsed_value = math.nan
+                            raw_data[key].append(parsed_value)
+
+        data = {
+            "time": raw_data["time"],
+            "air_temperature": raw_data["Ta/dsC"],
+            "relative_humidity": raw_data["RH/pcnt"],
+            "air_pressure": raw_data["Pa/kPa"],
+            "wind_speed": raw_data["WS/(m/s)"],
+            "wind_direction": raw_data["WD/ds"],
+            "rainfall_rate": raw_data["AaNRT/mm"],
+        }
+        for key, value in data.items():
+            new_value = np.array(value)
+            if key != "time":
+                new_value = ma.masked_where(np.isnan(new_value), new_value)
+            data[key] = new_value
+        return data
+
+    def convert_pressure(self) -> None:
+        self.data["air_pressure"].data = (
+            self.data["air_pressure"][:] * 1000
+        )  # kPa to Pa
 
 
 ATTRIBUTES = {

cloudnetpy/plotting/plotting.py

@@ -4,6 +4,7 @@ import re
 import textwrap
 from dataclasses import dataclass
 from datetime import date
+from typing import Any
 
 import matplotlib.pyplot as plt
 import netCDF4
@@ -356,7 +357,7 @@ class Plot:
             raise ValueError(msg)
         max_gap_fraction_hour = _get_max_gap_in_minutes(figure_data) / 60
 
-        if figure_data.file.cloudnet_file_type == "model":
+        if getattr(figure_data.file, "cloudnet_file_type", "") == "model":
             time, data = screen_completely_masked_profiles(time, data)
 
         gap_indices = np.where(np.diff(time) > max_gap_fraction_hour)[0]
@@ -491,15 +492,28 @@ class Plot2D(Plot):
             smoothed_data = uniform_filter(self._data[valid_time_ind, :], sigma_units)
             self._data[valid_time_ind, :] = smoothed_data
 
-        image = self._ax.pcolorfast(
-            figure_data.time_including_gaps,
-            alt,
-            self._data.T[:-1, :-1],
-            cmap=plt.get_cmap(str(self._plot_meta.cmap)),
-            vmin=vmin,
-            vmax=vmax,
-            zorder=_get_zorder("data"),
-        )
+        pcolor_kwargs = {
+            "cmap": plt.get_cmap(str(self._plot_meta.cmap)),
+            "vmin": vmin,
+            "vmax": vmax,
+            "zorder": _get_zorder("data"),
+        }
+        image: Any
+        if getattr(figure_data.file, "cloudnet_file_type", "") == "model":
+            image = self._ax.pcolor(
+                figure_data.time_including_gaps,
+                alt,
+                self._data.T,
+                **pcolor_kwargs,
+                shading="nearest",
+            )
+        else:
+            image = self._ax.pcolorfast(
+                figure_data.time_including_gaps,
+                alt,
+                self._data.T[:-1, :-1],
+                **pcolor_kwargs,
+            )
         cbar = self._init_colorbar(image)
         cbar.set_label(str(self._plot_meta.clabel), fontsize=13)
 

cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
 MINOR = 61
-PATCH = 11
+PATCH = 13
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.61.11.dist-info → cloudnetpy-1.61.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudnetpy
-Version: 1.61.11
+Version: 1.61.13
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.61.11.dist-info → cloudnetpy-1.61.13.dist-info}/RECORD

@@ -8,7 +8,7 @@ cloudnetpy/metadata.py,sha256=v_VDo2vbdTxB0zIsfP69IcrwSKiRlLpsGdq6JPI4CoA,5306
 cloudnetpy/output.py,sha256=UzF0w51c6-QEBj-NfCJg5zTIKVzcmq1HyQb-3_qWTgk,14767
 cloudnetpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/utils.py,sha256=-8x7LQ6WDHxf2lDZfhG50WYe2iSVLQObnVXZG46JzKI,28468
-cloudnetpy/version.py,sha256=B3laILu3O0Nl0QccRB9qv-lhpfU5LAfqtgMUzrcUIHg,73
+cloudnetpy/version.py,sha256=s1z4RwSs7fLnDJ-S01W99lgOij26tF-b_d0xSRnP25k,73
 cloudnetpy/categorize/__init__.py,sha256=gP5q3Vis1y9u9OWgA_idlbjfWXYN_S0IBSWdwBhL_uU,69
 cloudnetpy/categorize/atmos.py,sha256=fWW8ye_8HZASRAiYwURFKWzcGOYIA2RKeVxCq0lVOuM,12389
 cloudnetpy/categorize/atmos_utils.py,sha256=wndpwJxc2-QnNTkV8tc8I11Vs_WkNz9sVMX1fuGgUC4,3777
@@ -47,7 +47,7 @@ cloudnetpy/instruments/rpg.py,sha256=yQpcKcgzRvVvkl6NhKvo4PUkv9nZ69_hzzPpS2Ei-Is
 cloudnetpy/instruments/rpg_reader.py,sha256=LAdXL3TmD5QzQbqtPOcemZji_qkXwmw6a6F8NmF6Zg8,11355
 cloudnetpy/instruments/toa5.py,sha256=1JnuYViD8c_tHJZ9lf4OU44iepEkXHsXOzDfVf_b0qc,1759
 cloudnetpy/instruments/vaisala.py,sha256=ektdXoID2X_V9H5Zp1fgHTUBapFMSyPVEWW_aoR6DEY,14655
-cloudnetpy/instruments/weather_station.py,sha256=R2b-VfCRkVluEbGd9NGuzf46k18X1BfZwJHhwWn_sVM,13801
+cloudnetpy/instruments/weather_station.py,sha256=WnU1z7JhgsAvqzUhYg1XeUkUBgvYRnt2LUWnea8IugM,15216
 cloudnetpy/instruments/disdrometer/__init__.py,sha256=lyjwttWvFvuwYxEkusoAvgRcbBmglmOp5HJOpXUqLWo,93
 cloudnetpy/instruments/disdrometer/common.py,sha256=g52iK2aNp3Z88kovUmGVpC54NZomPa9D871gzO0AmQ4,9267
 cloudnetpy/instruments/disdrometer/parsivel.py,sha256=WiL-vCjw9Gmb5irvW3AXddsyprp8MGOfqcVAlfy0zpc,25521
@@ -94,7 +94,7 @@ cloudnetpy/model_evaluation/tests/unit/test_statistical_methods.py,sha256=Ra3r4V
 cloudnetpy/model_evaluation/tests/unit/test_tools.py,sha256=Ia_VrLdV2NstX5gbx_3AZTOAlrgLAy_xFZ8fHYVX0xI,3817
 cloudnetpy/plotting/__init__.py,sha256=lg9Smn4BI0dVBgnDLC3JVJ4GmwoSnO-qoSd4ApvwV6Y,107
 cloudnetpy/plotting/plot_meta.py,sha256=cLdCZrhbP-gaobS_zjcf8d2xVALzl7zh2qpttxCHyrg,15983
-cloudnetpy/plotting/plotting.py,sha256=bve91iM9RcWmKaZOFWxVh2y3DPmupI1944MMYDdv17I,32459
+cloudnetpy/plotting/plotting.py,sha256=t6Bljy63HrBkBBNl6VuESV1utIS9mxrIxrNwDFNurRs,32926
 cloudnetpy/products/__init__.py,sha256=2hRb5HG9hNrxH1if5laJkLeFeaZCd5W1q3hh4ewsX0E,273
 cloudnetpy/products/classification.py,sha256=pzFQtgOKS7g_3LqiAY84EFUUste-VES7CJNgoq2Bs34,7914
 cloudnetpy/products/der.py,sha256=XZMbqDQUq0E9iBU3Axr-NfUJfRAhjsaGlyxJ4tKyGcw,12444
@@ -108,8 +108,8 @@ cloudnetpy/products/mie_lu_tables.nc,sha256=It4fYpqJXlqOgL8jeZ-PxGzP08PMrELIDVe5
 cloudnetpy/products/mwr_tools.py,sha256=RuzokxxqXlTGk7XAOrif_FDPUJdf0j_wJgNq-7a_nK8,4684
 cloudnetpy/products/product_tools.py,sha256=rhx_Ru9FLlQqCNM-awoiHx18-Aq1eBwL9LiUaQoJs6k,10412
 docs/source/conf.py,sha256=IKiFWw6xhUd8NrCg0q7l596Ck1d61XWeVjIFHVSG9Og,1490
-cloudnetpy-1.61.11.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
-cloudnetpy-1.61.11.dist-info/METADATA,sha256=MjuSUe-bVQa8CzRqFWeJBhqcbkcv5OkXSkM0srtkDpo,5785
-cloudnetpy-1.61.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cloudnetpy-1.61.11.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
-cloudnetpy-1.61.11.dist-info/RECORD,,
+cloudnetpy-1.61.13.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
+cloudnetpy-1.61.13.dist-info/METADATA,sha256=R09GyBfK_BYlnHuZyPPX8H7JXhkWNxFExGWTSP2h7D8,5785
+cloudnetpy-1.61.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cloudnetpy-1.61.13.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
+cloudnetpy-1.61.13.dist-info/RECORD,,