cloudnetpy 1.76.1__tar.gz → 1.77.1__tar.gz

{cloudnetpy-1.76.1/cloudnetpy.egg-info → cloudnetpy-1.77.1}/PKG-INFO

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

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/instruments/__init__.py

@@ -3,6 +3,7 @@ from .bowtie import bowtie2nc
 from .ceilo import ceilo2nc
 from .copernicus import copernicus2nc
 from .disdrometer import parsivel2nc, thies2nc
+from .fd12p import fd12p2nc
 from .galileo import galileo2nc
 from .hatpro import hatpro2l1c, hatpro2nc
 from .instruments import Instrument

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/instruments/cloudnet_instrument.py

@@ -109,17 +109,22 @@ class CSVFile(CloudnetInstrument):
             parsed = (
                 utils.datetime2decimal_hours(value)
                 if key == "time"
-                else ma.array(value)
+                else ma.masked_invalid(value)
             )
             self.data[key] = CloudnetArray(parsed, key)
 
-    def normalize_rainfall_amount(self) -> None:
-        if "rainfall_amount" in self.data:
-            amount = self.data["rainfall_amount"][:]
-            offset = 0
-            for i in range(1, len(amount)):
-                if amount[i] + offset < amount[i - 1]:
-                    offset += amount[i - 1]
-                amount[i] += offset
-            amount -= amount[0]
-            self.data["rainfall_amount"].data = amount
+    def normalize_cumulative_amount(self, key: str) -> None:
+        if key not in self.data:
+            return
+        amount = self.data[key][:]
+        offset = 0
+        last_valid = 0
+        for i in range(1, len(amount)):
+            if amount[i] is ma.masked:
+                continue
+            if amount[i] + offset < amount[last_valid]:
+                offset += amount[last_valid]
+            amount[i] += offset
+            last_valid = i
+        amount -= amount[0]
+        self.data[key].data = amount

cloudnetpy-1.77.1/cloudnetpy/instruments/fd12p.py

@@ -0,0 +1,197 @@
+import datetime
+import logging
+import math
+import re
+from os import PathLike
+from uuid import UUID
+
+import numpy as np
+from numpy import ma
+
+from cloudnetpy import output
+from cloudnetpy.exceptions import ValidTimeStampError
+from cloudnetpy.instruments import instruments
+from cloudnetpy.instruments.cloudnet_instrument import CSVFile
+from cloudnetpy.metadata import MetaData
+
+
+def fd12p2nc(
+    input_file: str | PathLike,
+    output_file: str | PathLike,
+    site_meta: dict,
+    uuid: str | UUID | None = None,
+    date: str | datetime.date | None = None,
+):
+    """Converts Vaisala FD12P into Cloudnet Level 1b netCDF file.
+
+    Args:
+        input_file: Filename of input file.
+        output_file: Output filename.
+        site_meta: Dictionary containing information about the site. Required key
+            is `name`.
+        uuid: Set specific UUID for the file.
+        date: Expected date of the measurements as YYYY-MM-DD or datetime.date object.
+
+    Returns:
+        UUID of the generated file.
+
+    Raises:
+        ValidTimeStampError: No valid timestamps found.
+    """
+    if isinstance(date, str):
+        date = datetime.date.fromisoformat(date)
+    if isinstance(uuid, str):
+        uuid = UUID(uuid)
+    fd12p = FD12P(site_meta)
+    fd12p.parse_input_file(input_file, date)
+    fd12p.add_data()
+    fd12p.add_date()
+    fd12p.screen_all_masked()
+    fd12p.sort_timestamps()
+    fd12p.remove_duplicate_timestamps()
+    fd12p.convert_units()
+    fd12p.normalize_cumulative_amount("precipitation_amount")
+    fd12p.normalize_cumulative_amount("snowfall_amount")
+    fd12p.add_site_geolocation()
+    attributes = output.add_time_attribute(ATTRIBUTES, fd12p.date)
+    output.update_attributes(fd12p.data, attributes)
+    return output.save_level1b(fd12p, output_file, uuid)
+
+
+class FD12P(CSVFile):
+    def __init__(self, site_meta: dict):
+        super().__init__(site_meta)
+        self.instrument = instruments.FD12P
+        self._data = {
+            key: []
+            for key in (
+                "time",
+                "visibility",
+                "synop_WaWa",
+                "precipitation_rate",
+                "precipitation_amount",
+                "snowfall_amount",
+            )
+        }
+
+    def parse_input_file(
+        self, filename: str | PathLike, expected_date: datetime.date | None = None
+    ):
+        # In Lindenberg, format is date and time followed by Message 2 without
+        # non-printable characters.
+        with open(filename) as file:
+            invalid_lines = 0
+            for line in file:
+                try:
+                    columns = line.split()
+                    if len(columns) != 13:
+                        msg = "Invalid column count"
+                        raise ValueError(msg)  # noqa: TRY301
+                    date = _parse_date(columns[0])
+                    time = _parse_time(columns[1])
+                    visibility = _parse_int(columns[4])
+                    synop = _parse_int(columns[7])
+                    p_rate = _parse_float(columns[10])  # mm/h
+                    p_amount = _parse_float(columns[11])  # mm
+                    s_amount = _parse_int(columns[12])  # mm
+                    self._data["time"].append(datetime.datetime.combine(date, time))
+                    self._data["visibility"].append(visibility)
+                    self._data["synop_WaWa"].append(synop)
+                    self._data["precipitation_rate"].append(p_rate)
+                    self._data["precipitation_amount"].append(p_amount)
+                    self._data["snowfall_amount"].append(s_amount)
+                except ValueError:
+                    invalid_lines += 1
+                    continue
+        if invalid_lines:
+            logging.info("Skipped %d lines", invalid_lines)
+        for key in ("visibility", "synop_WaWa", "snowfall_amount"):
+            values = np.array(
+                [0 if x is math.nan else x for x in self._data[key]], dtype=np.int32
+            )
+            mask = np.array([x is math.nan for x in self._data[key]])
+            self._data[key] = ma.array(values, mask=mask)
+        self._data["snowfall_amount"] = self._data["snowfall_amount"].astype(np.float32)
+        if expected_date:
+            self._data["time"] = [
+                d for d in self._data["time"] if d.date() == expected_date
+            ]
+        if not self._data["time"]:
+            raise ValidTimeStampError
+
+    def convert_units(self) -> None:
+        precipitation_rate = self.data["precipitation_rate"][:]
+        self.data["precipitation_rate"].data = (
+            precipitation_rate / 3600 / 1000
+        )  # mm/h -> m/s
+        for key in ("precipitation_amount", "snowfall_amount"):
+            self.data[key].data = self.data[key][:] / 1000  # mm -> m
+
+    def screen_all_masked(self) -> None:
+        is_valid = np.ones_like(self.data["time"][:], dtype=np.bool)
+        for key in self.data:
+            if key == "time":
+                continue
+            is_valid &= ma.getmaskarray(self.data[key][:])
+        self.screen_time_indices(~is_valid)
+
+
+def _parse_date(date: str) -> datetime.date:
+    match = re.fullmatch(r"(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{4})", date)
+    if match is None:
+        msg = f"Invalid date: {date}"
+        raise ValueError(msg)
+    return datetime.date(int(match["year"]), int(match["month"]), int(match["day"]))
+
+
+def _parse_time(time: str) -> datetime.time:
+    match = re.fullmatch(
+        r"(?P<hour>\d{2}):(?P<minute>\d{2})(:(?P<second>\d{2}))?", time
+    )
+    if match is None:
+        msg = f"Invalid time: {time}"
+        raise ValueError(msg)
+    return datetime.time(
+        int(match["hour"]),
+        int(match["minute"]),
+        int(match["second"]) if match["second"] is not None else 0,
+    )
+
+
+def _parse_int(value: str) -> float:
+    if "/" in value:
+        return math.nan
+    return int(value)
+
+
+def _parse_float(value: str) -> float:
+    if "/" in value:
+        return math.nan
+    return float(value)
+
+
+ATTRIBUTES = {
+    "visibility": MetaData(
+        long_name="Meteorological optical range (MOR) visibility",
+        units="m",
+        standard_name="visibility_in_air",
+    ),
+    "precipitation_rate": MetaData(
+        long_name="Precipitation rate",
+        standard_name="lwe_precipitation_rate",
+        units="m s-1",
+    ),
+    "precipitation_amount": MetaData(
+        long_name="Precipitation amount",
+        standard_name="lwe_thickness_of_precipitation_amount",
+        units="m",
+        comment="Cumulated precipitation since 00:00 UTC",
+    ),
+    "snowfall_amount": MetaData(
+        long_name="Snowfall amount",
+        units="m",
+        standard_name="thickness_of_snowfall_amount",
+        comment="Cumulated snow since 00:00 UTC",
+    ),
+    "synop_WaWa": MetaData(long_name="Synop code WaWa", units="1"),
+}

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/instruments/instruments.py

@@ -246,3 +246,10 @@ MRR_PRO = Instrument(
     model="MRR-PRO",
     frequency=24.23,
 )
+
+FD12P = Instrument(
+    manufacturer="Vaisala",
+    domain="weather-station",
+    category="present weather sensor",
+    model="FD12P",
+)

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/instruments/rain_e_h3.py

@@ -40,7 +40,7 @@ def rain_e_h32nc(
     rain.add_data()
     rain.add_date()
     rain.convert_units()
-    rain.normalize_rainfall_amount()
+    rain.normalize_cumulative_amount("rainfall_amount")
     rain.add_site_geolocation()
     rain.sort_timestamps()
     rain.remove_duplicate_timestamps()

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/instruments/weather_station.py

@@ -77,7 +77,7 @@ def ws2nc(
     ws.convert_pressure()
     ws.convert_rainfall_rate()
     ws.convert_rainfall_amount()
-    ws.normalize_rainfall_amount()
+    ws.normalize_cumulative_amount("rainfall_amount")
     ws.calculate_rainfall_amount()
     attributes = output.add_time_attribute({}, ws.date)
     output.update_attributes(ws.data, attributes)

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/plotting/plotting.py

@@ -361,9 +361,12 @@ class Plot:
         units_conversion = {
             "rainfall_rate": (multiply, 3600000, "mm h$^{-1}$"),
             "snowfall_rate": (multiply, 3600000, "mm h$^{-1}$"),
+            "precipitation_rate": (multiply, 3600000, "mm h$^{-1}$"),
             "air_pressure": (multiply, 0.01, "hPa"),
             "relative_humidity": (multiply, 100, "%"),
             "rainfall_amount": (multiply, 1000, "mm"),
+            "snowfall_amount": (multiply, 1000, "mm"),
+            "precipitation_amount": (multiply, 1000, "mm"),
             "air_temperature": (add, -273.15, "\u00b0C"),
             "r_accum_RT": (multiply, 1000, "mm"),
             "r_accum_NRT": (multiply, 1000, "mm"),

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
-MINOR = 76
+MINOR = 77
 PATCH = 1
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1/cloudnetpy.egg-info}/PKG-INFO

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

{cloudnetpy-1.76.1 → cloudnetpy-1.77.1}/cloudnetpy.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ cloudnetpy/instruments/ceilometer.py
 cloudnetpy/instruments/cl61d.py
 cloudnetpy/instruments/cloudnet_instrument.py
 cloudnetpy/instruments/copernicus.py
+cloudnetpy/instruments/fd12p.py
 cloudnetpy/instruments/galileo.py
 cloudnetpy/instruments/hatpro.py
 cloudnetpy/instruments/instruments.py