cloudnetpy 1.92.1__tar.gz → 1.92.2__tar.gz

{cloudnetpy-1.92.1/cloudnetpy.egg-info → cloudnetpy-1.92.2}/PKG-INFO

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

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2}/cloudnetpy/instruments/weather_station.py

@@ -76,6 +76,8 @@ def ws2nc(
         ws = MaidoWS(weather_station_file, site_meta)
     elif site_meta["name"] == "Cluj-Napoca":
         ws = ClujWS(weather_station_file, site_meta)
+    elif site_meta["name"] == "Falkenberg":
+        ws = FalkenbergWS(weather_station_file, site_meta)
     else:
         msg = "Unsupported site"
         raise ValueError(msg)
@@ -824,6 +826,54 @@ class ClujWS(WS):
         )  # mm/10min => m/s
 
 
+class FalkenbergWS(WS):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
+        if len(filenames) != 1:
+            raise ValueError
+        super().__init__(site_meta)
+        self.filename = filenames[0]
+        self._data = self._read_data()
+
+    def _read_data(self) -> dict:
+        keymap = {
+            "TIMESTAMP": "time",
+            "WS500_air_temperature": "air_temperature",
+            "WS500_relative_humidity": "relative_humidity",
+            "WS500_absolute_air_pressure": "air_pressure",
+            "WS500_wind_speed_avg": "wind_speed",
+            "WS500_wind_direction_avg": "wind_direction",
+        }
+        expected_units = {
+            "WS500_air_temperature": "degC",
+            "WS500_relative_humidity": "%",
+            "WS500_absolute_air_pressure": "hPa",
+            "WS500_wind_speed_avg": "m s-1",
+            "WS500_wind_direction_avg": "deg",
+        }
+        units, _process, rows = read_toa5(self.filename)
+        for key in units:
+            if key in expected_units and expected_units[key] != units[key]:
+                msg = (
+                    f"Expected {key} to have units {expected_units[key]},"
+                    f" got {units[key]} instead"
+                )
+                raise ValueError(msg)
+
+        data: dict[str, list] = {keymap[key]: [] for key in units if key in keymap}
+        for row in rows:
+            for key, value in row.items():
+                if key not in keymap:
+                    continue
+                parsed = value
+                if keymap[key] != "time":
+                    try:
+                        parsed = float(value)
+                    except ValueError:
+                        parsed = math.nan
+                data[keymap[key]].append(parsed)
+        return self.format_data(data)
+
+
 ATTRIBUTES = {
     "visibility": MetaData(
         long_name="Meteorological optical range (MOR) visibility",

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2}/cloudnetpy/plotting/plot_meta.py

@@ -317,7 +317,7 @@ ATTRIBUTES = {
             log_scale=True,
         ),
         "N_scaled": PlotMeta(
-            plot_range=(1.0e0, 1e3),
+            plot_range=(1.0e6, 1.0e9),
             log_scale=True,
         ),
         "der_error": PlotMeta(
@@ -414,6 +414,7 @@ ATTRIBUTES = {
         "cloud_fraction": PlotMeta(
             cmap="Blues",
             plot_range=(0, 1),
+            mask_zeros=True,
         ),
         "Tw": PlotMeta(
             cmap="RdBu_r",
@@ -428,7 +429,7 @@ ATTRIBUTES = {
             plot_range=(1e-5, 1e-2),
             log_scale=True,
         ),
-        "rh": PlotMeta(plot_range=(0, 1.2)),
+        "rh": PlotMeta(plot_range=(0, 120)),
         "number_concentration": PlotMeta(
             plot_range=(1e-2, 1e3), log_scale=True, mask_zeros=True
         ),

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2}/cloudnetpy/plotting/plotting.py

@@ -410,6 +410,7 @@ class Plot:
             "precipitation_rate": (multiply, 3600000, "mm h$^{-1}$"),
             "air_pressure": (multiply, 0.01, "hPa"),
             "relative_humidity": (multiply, 100, "%"),
+            "rh": (multiply, 100, "%"),
             "rainfall_amount": (multiply, 1000, "mm"),
             "snowfall_amount": (multiply, 1000, "mm"),
             "precipitation_amount": (multiply, 1000, "mm"),
@@ -635,8 +636,6 @@ class Plot2D(Plot):
         else:
             min_x, max_x = 0, 24
         self._mark_gaps(figure_data, min_x=min_x, max_x=max_x)
-        if self.sub_plot.variable.name == "cloud_fraction":
-            self._data[self._data == 0] = ma.masked
         if any(
             key in self.sub_plot.variable.name for key in ("status", "classification")
         ):

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2}/cloudnetpy/products/der.py

@@ -24,11 +24,11 @@ from cloudnetpy.products.product_tools import (
 
 class Parameters(NamedTuple):
     ddBZ: float
-    N: float
-    dN: float
+    N: float  # m-3
+    dN: float  # m-3
     sigma_x: float
     dsigma_x: float
-    dQ: float
+    dQ: float  # kg m-2
 
 
 def generate_der(
@@ -76,8 +76,8 @@ def generate_der(
         der_source.append_der()
         der_source.append_retrieval_status(droplet_classification)
         date = der_source.get_date()
-        attributes = output.add_time_attribute(REFF_ATTRIBUTES, date)
-        attributes = _add_der_error_comment(attributes, der_source)
+        attributes = output.add_time_attribute(DER_ATTRIBUTES, date)
+        attributes = _add_der_error_comments(attributes, der_source)
         output.update_attributes(der_source.data, attributes)
         output.save_product_file("der", der_source, output_file, uuid)
     return uuid
@@ -132,7 +132,7 @@ class DerSource(DataSource):
     def append_der(self) -> None:
         """Estimate liquid droplet effective radius using Frisch et al. 2002."""
         params = self.parameters
-        rho_l = 1000  # density of liquid water(kg m-3)
+        rho_l = 1000  # density of liquid water (kg m-3)
 
         var_x = params.sigma_x * params.sigma_x
 
@@ -140,7 +140,7 @@ class DerSource(DataSource):
         Z = utils.db2lin(Z)
         dZ = ma.abs(utils.db2lin(params.ddBZ)) * Z
 
-        lwp = self.getvar("lwp")
+        lwp = self.getvar("lwp")  # kg m-2
         lwp[lwp < 0] = 0
 
         der = np.zeros(Z.shape)
@@ -172,7 +172,7 @@ class DerSource(DataSource):
             # der formula (5)
             A = (Z[ind_t, idx_layer] / params.N) ** (1 / 6)
             B = ma.exp(-0.5 * var_x)
-            der[ind_t, idx_layer] = 0.5 * A * B
+            der[ind_t, idx_layer] = 0.5 * A * B  # mm
 
             # der error formula (7)
             A = params.dN / (6 * params.N)
@@ -180,26 +180,28 @@ class DerSource(DataSource):
             C = dZ[ind_t, idx_layer] / (6 * Z[ind_t, idx_layer])
             der_error[ind_t, idx_layer] = der[ind_t, idx_layer] * ma.sqrt(
                 A * A + B * B + C * C,
-            )
+            )  # mm
 
             # der scaled formula (6)
             A = Z[ind_t, idx_layer] ** (1 / 6) / (2 * lwp[ind_t] ** (1 / 3))
             B = (np.pi * rho_l / 6) ** (1 / 3)
             C = integral ** (1 / 3) * ma.exp(-2 * var_x)
-            der_scaled[ind_t, idx_layer] = 1.0e-3 * A * B * C
+            der_scaled[ind_t, idx_layer] = 1.0e-3 * A * B * C  # μm => mm
 
-            # der scaled formula (9)
+            # solve N in der formula (5) assuming rₑ from der scaled formula (6)
             N_scaled[ind_t, idx_layer] = Z[ind_t, idx_layer] / (
                 ((2 * der_scaled[ind_t, idx_layer]) / (ma.exp(-0.5 * var_x))) ** 6
-            )
+            )  # m-3
+
+            # der scaled error formula (9)
             A = dZ[ind_t, idx_layer] / (6 * Z[ind_t, idx_layer])
             B = 4 * params.sigma_x * params.dsigma_x
             C = params.dQ / (3 * lwp[ind_t])
             der_scaled_error[ind_t, idx_layer] = der_scaled[ind_t, idx_layer] * ma.sqrt(
                 A * A + B * B + C * C,
-            )
+            )  # mm
 
-        N_scaled = ma.masked_less_equal(ma.masked_invalid(N_scaled), 0.0) * 1.0e-6
+        N_scaled = ma.masked_less_equal(ma.masked_invalid(N_scaled), 0.0)
         der = ma.masked_less_equal(ma.masked_invalid(der), 0.0) * 1.0e-3
         der_error = ma.masked_less_equal(ma.masked_invalid(der_error), 0.0) * 1.0e-3
         der_scaled = ma.masked_less_equal(ma.masked_invalid(der_scaled), 0.0) * 1.0e-3
@@ -263,22 +265,20 @@ COMMENTS = {
     ),
     "der": (
         "This variable was calculated for the profiles where the categorization\n"
-        "data has diagnosed that liquid water is present the cloud droplet\n"
-        "effective radius is calculated after Frisch et al (2002), relating Z\n"
-        "with def by assuming a lognormal size distribution its width and the\n"
-        "number concentration of the cloud droplets."
+        "data has diagnosed that liquid water is present. The cloud droplet\n"
+        "effective radius is calculated using the method 1 of Frisch et al.\n"
+        "(2002), relating Z with effective radius by assuming a lognormal size\n"
+        "distribution and its width and the number concentration of the cloud\n"
+        "droplets."
     ),
     "der_scaled": (
-        "This variable was calculated for the profiles where the\n"
-        "categorization data has diagnosed that liquid water is present\n"
-        "the cloud droplet effective radius is calculated after\n"
-        "Frisch et al. (2002), relating Z with def by assuming a lognormal\n"
-        "size distribution and its width. The number concentration required\n"
-        "to represent the size distribution is derived by scaling the LWP\n "
-        "measured with microwave radiometer over the observed (single) cloud layer."
-    ),
-    "der_scaled_error": (
-        "This variable was calculated for the profiles where the categorization data"
+        "This variable was calculated for the profiles where the categorization\n"
+        "data has diagnosed that liquid water is present. The cloud droplet\n"
+        "effective radius is calculated using the method 2 of Frisch et al.\n"
+        "(2002), relating Z with effective radius by assuming a lognormal size\n"
+        "distribution and its width. The number concentration required to\n"
+        "represent the size distribution is derived by scaling the LWP measured\n"
+        "with microwave radiometer over the observed (single) cloud layer."
     ),
     "N_scaled": (
         "From scaled Frisch method the cloud droplet number concentration\n"
@@ -287,21 +287,28 @@ COMMENTS = {
 }
 
 
-def _add_der_error_comment(attributes: dict, der_source: DerSource) -> dict:
+def _add_der_error_comments(attributes: dict, der_source: DerSource) -> dict:
     params = der_source.parameters
     attributes["der_error"] = attributes["der_error"]._replace(
         comment="This variable is an estimate of the random error in effective\n"
-        f"radius assuming an error in Z of ddBZ = {params.ddBZ} in N of\n"
-        f"dN = {params.dN} and in the spectral width dsigma_x = {params.dsigma_x}\n"
-        f"and in the LWP Q of {params.dQ} kg m-3.",
+        f"radius assuming an error in Z of dZ = {params.ddBZ} dBZ, in N of\n"
+        f"dN = {params.dN} m-3, and in the spectral width of "
+        f"dsigma_x = {params.dsigma_x}."
+    )
+    attributes["der_scaled_error"] = attributes["der_scaled_error"]._replace(
+        comment="This variable is an estimate of the random error in scaled effective\n"
+        f"radius assuming an error in Z of dZ = {params.ddBZ} dBZ, in the spectral\n"
+        f"width of dsigma_x = {params.dsigma_x}, and in the LWP of dQ = {params.dQ} "
+        "kg m-2."
     )
     return attributes
 
 
-REFF_ATTRIBUTES = {
+DER_ATTRIBUTES = {
     "comment": COMMENTS["general"],
     "der": MetaData(
         long_name="Droplet effective radius",
+        standard_name="effective_radius_of_cloud_liquid_water_particles",
         units="m",
         ancillary_variables="der_error",
         comment=COMMENTS["der"],
@@ -315,6 +322,7 @@ REFF_ATTRIBUTES = {
     ),
     "der_scaled": MetaData(
         long_name="Droplet effective radius (scaled to LWP)",
+        standard_name="effective_radius_of_cloud_liquid_water_particles",
         units="m",
         ancillary_variables="der_scaled_error",
         comment=COMMENTS["der_scaled"],
@@ -323,13 +331,13 @@ REFF_ATTRIBUTES = {
     "der_scaled_error": MetaData(
         long_name="Absolute error in droplet effective radius (scaled to LWP)",
         units="m",
-        comment=COMMENTS["der_scaled_error"],
+        comment="",
         dimensions=("time", "height"),
     ),
     "N_scaled": MetaData(
         long_name="Cloud droplet number concentration",
-        units="1",
-        ancillary_variables="der_error der_scaled der_scaled_error",
+        standard_name="number_concentration_of_cloud_liquid_water_particles_in_air",
+        units="m-3",
         comment=COMMENTS["N_scaled"],
         dimensions=("time", "height"),
     ),

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2}/cloudnetpy/products/epsilon_radar.py

@@ -44,17 +44,15 @@ def generate_epsilon_from_radar(
         >>> generate_epsilon_from_radar('radar.nc', 'ecmwf.nc', 'epsilon.nc')
 
     References:
-        Griesche, H. J., Seifert, P., Ansmann, A., Baars, H., Barrientos
-        Velasco, C., Bühl, J., Engelmann, R., Radenz, M., Zhenping, Y., and
-        Macke, A. (2020): Application of the shipborne remote sensing
+        Griesche et al. (2020). Application of the shipborne remote sensing
         supersite OCEANET for profiling of Arctic aerosols and clouds during
-        Polarstern cruise PS106, Atmos. Meas. Tech., 13, 5335-5358,
-        https://doi.org/10.5194/amt-13-5335-2020.
+        Polarstern cruise PS106. Atmos. Meas. Tech., 13(10), 5335-5358.
+        https://doi.org/10.5194/amt-13-5335-2020
+
+        Borque et al. (2016). On the unified estimation of turbulence eddy
+        dissipation rate using Doppler cloud radars and lidars. JGR Atmospheres,
+        121(10), 5972-5989. https://doi.org/10.1002/2015JD024543
 
-        Borque, P., Luke, E., and Kollias, P. (2016): On the unified
-        estimation of turbulence eddy dissipation rate using Doppler cloud
-        radars and lidars, J. Geophys. Res. Atmos., 120, 5972-5989,
-        https://doi.org/10.1002/2015JD024543.
     """
     uuid = get_uuid(uuid)
     with (

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2}/cloudnetpy/version.py

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

{cloudnetpy-1.92.1 → cloudnetpy-1.92.2/cloudnetpy.egg-info}/PKG-INFO

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