cloudnetpy 1.56.4__py3-none-any.whl → 1.56.6__py3-none-any.whl

cloudnetpy/exceptions.py

@@ -23,6 +23,13 @@ class RadarDataError(CloudnetException):
         super().__init__(msg)
 
 
+class PlottingError(CloudnetException):
+    """Internal exception class."""
+
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+
 class WeatherStationDataError(CloudnetException):
     """Internal exception class."""
 

cloudnetpy/instruments/hatpro.py

@@ -4,10 +4,10 @@ import logging
 from collections import defaultdict
 from pathlib import Path
 
-import mwrpy
 import netCDF4
 import numpy as np
 from mwrpy.level1.lev1_meta_nc import ATTRIBUTES_1B01
+from mwrpy.level1.write_lev1_nc import lev1_to_nc
 from mwrpy.version import __version__ as mwrpy_version
 from numpy import ma
 
@@ -45,7 +45,7 @@ def hatpro2l1c(
     """
     coeff_files = site_meta.get("coefficientFiles", None)
 
-    hatpro_raw = mwrpy.lev1_to_nc(
+    hatpro_raw = lev1_to_nc(
         "1C01",
         mwr_dir,
         output_file=output_file,
@@ -99,7 +99,7 @@ def hatpro2l1c(
 
 
 class HatproL1c:
-    def __init__(self, hatpro: mwrpy.Rpg, site_meta: dict):
+    def __init__(self, hatpro, site_meta: dict):
         self.raw_data = hatpro.raw_data
         self.data = hatpro.data
         self.date = hatpro.date.split("-")

cloudnetpy/plotting/plot_meta.py

@@ -224,12 +224,19 @@ ATTRIBUTES = {
         ),
         "potential_temperature": PlotMeta(
             cmap="RdBu_r",
-            plot_range=(260, 330),
+            plot_range=(260, 320),
+        ),
+        "equivalent_potential_temperature": PlotMeta(
+            cmap="RdBu_r",
+            plot_range=(260, 320),
         ),
         "absolute_humidity": PlotMeta(
-            plot_range=(1e-5, 1e-2),
+            plot_range=(1e-4, 1e-2),
             log_scale=True,
         ),
+        "relative_humidity": PlotMeta(
+            plot_range=(0, 120),
+        ),
         "cloud_fraction": PlotMeta(
             cmap="Blues",
             plot_range=(0, 1),

cloudnetpy/plotting/plotting.py

@@ -16,6 +16,7 @@ from matplotlib.transforms import Affine2D, Bbox
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 from numpy import ma, ndarray
 
+from cloudnetpy.exceptions import PlottingError
 from cloudnetpy.plotting.plot_meta import ATTRIBUTES, PlotMeta
 
 
@@ -129,7 +130,7 @@ class FigureData:
                 variable_indices.append(extracted_ind)
         if not valid_variables:
             msg = f"None of the variables {requested_variables} found in the file."
-            raise ValueError(msg)
+            raise PlottingError(msg)
         return valid_variables, variable_indices
 
     def _get_height(self) -> np.ndarray | None:
@@ -143,6 +144,10 @@ class FigureData:
             return self.file.variables["range"][:] * m2km
         return None
 
+    def is_mwrpy_product(self) -> bool:
+        cloudnet_file_type = getattr(self.file, "cloudnet_file_type", "")
+        return cloudnet_file_type in ("mwr-single", "mwr-multi")
+
     def __len__(self) -> int:
         return len(self.variables)
 
@@ -177,7 +182,7 @@ class SubPlot:
         ylabel: str | None = None,
         y_limits: tuple[float, float] | None = None,
     ) -> None:
-        label = ylabel or "Height (km)"
+        label = ylabel if ylabel is not None else "Height (km)"
         self.ax.set_ylabel(label, fontsize=13)
         if y_limits is not None:
             self.ax.set_ylim(*y_limits)
@@ -236,9 +241,7 @@ class SubPlot:
         if self.options.plot_meta is not None:
             return self.options.plot_meta
         fallback = ATTRIBUTES["fallback"].get(self.variable.name, PlotMeta())
-        if file_type is None:
-            return fallback
-        file_attributes = ATTRIBUTES.get(file_type, {})
+        file_attributes = ATTRIBUTES.get(file_type or "", {})
         plot_meta = file_attributes.get(self.variable.name, fallback)
         if plot_meta.clabel is None:
             plot_meta = plot_meta._replace(clabel=_reformat_units(self.variable.units))
@@ -249,10 +252,34 @@ class Plot:
     def __init__(self, sub_plot: SubPlot):
         self.sub_plot = sub_plot
         self._data = sub_plot.variable[:]
+        self._data_orig = self._data.copy()
         self._plot_meta = sub_plot.plot_meta
         self._is_log = sub_plot.plot_meta.log_scale
         self._ax = sub_plot.ax
 
+    def _convert_units(self) -> str | None:
+        multiply, add = "multiply", "add"
+        units_conversion = {
+            "rainfall_rate": (multiply, 360000, "mm h$^{-1}$"),
+            "air_pressure": (multiply, 0.01, "hPa"),
+            "relative_humidity": (multiply, 100, "%"),
+            "rainfall_amount": (multiply, 1000, "mm"),
+            "air_temperature": (add, -273.15, "\u00B0C"),
+        }
+        conversion_method, conversion, units = units_conversion.get(
+            self.sub_plot.variable.name, (multiply, 1, None)
+        )
+        if conversion_method == multiply:
+            self._data *= conversion
+            self._data_orig *= conversion
+        elif conversion_method == add:
+            self._data += conversion
+            self._data_orig += conversion
+        if units is not None:
+            return units
+        units = getattr(self.sub_plot.variable, "units", "")
+        return _reformat_units(units)
+
     def _get_y_limits(self) -> tuple[float, float]:
         return 0, self.sub_plot.options.max_y
 
@@ -273,6 +300,7 @@ class Plot:
                 facecolor="grey",
                 edgecolor="black",
                 alpha=0.15,
+                label="_nolegend_",
             )
 
     def _mark_gaps(self, figure_data: FigureData) -> None:
@@ -282,6 +310,10 @@ class Plot:
             msg = "Time values outside the range 0-24."
             raise ValueError(msg)
         max_gap_fraction_hour = _get_max_gap_in_minutes(figure_data) / 60
+
+        if 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]
         if not ma.is_masked(data):
             mask_new = np.zeros(data.shape)
@@ -319,9 +351,21 @@ class Plot:
         self._data = data_new
         figure_data.time_including_gaps = time_new
 
+    def _read_flagged_data(self, figure_data: FigureData) -> np.ndarray:
+        flag_names = [
+            f"{self.sub_plot.variable.name}_quality_flag",
+            "temperature_quality_flag",
+            "quality_flag",
+        ]
+        for flag_name in flag_names:
+            if flag_name in figure_data.file.variables:
+                return figure_data.file.variables[flag_name][:] > 0
+        return np.array([])
+
 
 class Plot2D(Plot):
     def plot(self, figure_data: FigureData):
+        self._convert_units()
         self._mark_gaps(figure_data)
         if self.sub_plot.variable.name == "cloud_fraction":
             self._data[self._data == 0] = ma.masked
@@ -335,6 +379,25 @@ class Plot2D(Plot):
         if figure_data.options.mark_data_gaps:
             self._fill_between_data_gaps(figure_data)
 
+        if figure_data.is_mwrpy_product():
+            self._fill_flagged_data(figure_data)
+
+    def _fill_flagged_data(self, figure_data: FigureData) -> None:
+        flags = self._read_flagged_data(figure_data)
+        batches = find_batches_of_ones(flags)
+        for batch in batches:
+            if batch[0] == batch[1]:
+                continue
+            time_batch = figure_data.time[batch[0]], figure_data.time[batch[1]]
+            self._ax.fill_between(
+                time_batch,
+                *self._get_y_limits(),
+                facecolor="whitesmoke",
+                alpha=0.7,
+                edgecolor="grey",
+                label="_nolegend_",
+            )
+
     def _plot_segment_data(self, figure_data: FigureData) -> None:
         def _hide_segments(
             data_in: ma.MaskedArray,
@@ -403,22 +466,35 @@ class Plot2D(Plot):
 
 
 class Plot1D(Plot):
-    def plot_tb(self, figure_data: FigureData, ind: int):
-        flagged_data = self._pointing_filter(figure_data, ind)
+    def plot_tb(self, figure_data: FigureData, freq_ind: int):
+        self._data = self._data[:, freq_ind]
+        self._data_orig = self._data_orig[:, freq_ind]
+        is_bad_zenith = self._get_bad_zenith_profiles(figure_data)
+        self._data[is_bad_zenith] = ma.masked
+        self._data_orig[is_bad_zenith] = ma.masked
+        flags = self._read_flagged_data(figure_data)[:, freq_ind]
+        flags[is_bad_zenith] = False
+        if np.any(flags):
+            self.plot_flag_data(figure_data.time[flags], self._data_orig[flags])
+            self.add_legend()
+        self.plot(figure_data)
+
+    def plot_flag_data(self, time: np.ndarray, values: np.ndarray) -> None:
         self._ax.plot(
-            figure_data.time,
-            flagged_data,
+            time,
+            values,
             color="salmon",
             marker=".",
             lw=0,
             markersize=3,
+            zorder=10,
         )
-        self.plot(figure_data)
+
+    def add_legend(self):
         self._ax.legend(
-            ["Flagged data", "Valid data"],
+            ["Flagged data"],
             markerscale=3,
             numpoints=1,
-            reverse=True,
             frameon=False,
         )
 
@@ -428,6 +504,7 @@ class Plot1D(Plot):
         self._ax.plot(
             figure_data.time_including_gaps,
             self._data,
+            label="_nolegend_",
             **self._get_plot_options(),
         )
         if self._plot_meta.moving_average:
@@ -436,6 +513,11 @@ class Plot1D(Plot):
         self.sub_plot.set_yax(ylabel=units, y_limits=self._get_y_limits())
         pos = self._ax.get_position()
         self._ax.set_position((pos.x0, pos.y0, pos.width * 0.965, pos.height))
+        if figure_data.is_mwrpy_product():
+            flags = self._read_flagged_data(figure_data)
+            if np.any(flags):
+                self.plot_flag_data(figure_data.time[flags], self._data_orig[flags])
+                self.add_legend()
 
     def _get_y_limits(self) -> tuple[float, float]:
         percent_gap = 0.05
@@ -452,26 +534,6 @@ class Plot1D(Plot):
             return fallback
         return min_y, max_y
 
-    def _convert_units(self) -> str | None:
-        multiply, add = "multiply", "add"
-        units_conversion = {
-            "rainfall_rate": (multiply, 360000, "mm h$^{-1}$"),
-            "air_pressure": (multiply, 0.01, "hPa"),
-            "relative_humidity": (multiply, 100, "%"),
-            "rainfall_amount": (multiply, 1000, "mm"),
-            "air_temperature": (add, -273.15, "\u00B0C"),
-        }
-        conversion_method, conversion, units = units_conversion.get(
-            self.sub_plot.variable.name, (multiply, 1, None)
-        )
-        if conversion_method == multiply:
-            self._data *= conversion
-        elif conversion_method == add:
-            self._data += conversion
-        if units is not None:
-            return units
-        return _reformat_units(self.sub_plot.variable.units)
-
     def _get_plot_options(self) -> dict:
         default_options = {
             "color": "lightblue",
@@ -497,13 +559,14 @@ class Plot1D(Plot):
         return min(max(line_width, 0.25), 0.9)
 
     def _plot_moving_average(self, figure_data: FigureData):
-        time = figure_data.time_including_gaps.copy()
-        data, time = self._get_unmasked_values(self._data, time)
+        time = figure_data.time.copy()
+        data = self._data_orig.copy()
+        data, time = self._get_unmasked_values(data, time)
         sma = self._calculate_moving_average(data, time, window=5)
         gap_time = _get_max_gap_in_minutes(figure_data)
         gaps = self._find_time_gap_indices(time, max_gap_min=gap_time)
         sma[gaps] = np.nan
-        self._ax.plot(time, sma, color="slateblue", lw=2)
+        self._ax.plot(time, sma, color="slateblue", lw=2, label="_nolegend_")
 
     @staticmethod
     def _get_unmasked_values(
@@ -515,24 +578,17 @@ class Plot1D(Plot):
         good_values = ~data.mask
         return data[good_values], time[good_values]
 
-    def _pointing_filter(self, figure_data: FigureData, ind: int) -> ndarray:
+    @staticmethod
+    def _get_bad_zenith_profiles(figure_data: FigureData) -> np.ndarray:
         zenith_limit = 5
-        status = 0
-        self._data = self._data[:, ind]
-        flagged_data = ma.masked_all_like(figure_data.time)
+        valid_pointing_status = 0
         if "pointing_flag" in figure_data.file.variables:
             pointing_flag = figure_data.file.variables["pointing_flag"][:]
             zenith_angle = figure_data.file.variables["zenith_angle"][:]
-            quality_flag = figure_data.file.variables["quality_flag"][:, ind]
-            # First mask bad zenith angle points
-            self._data[np.abs(zenith_angle) > zenith_limit] = ma.masked
-            self._data[pointing_flag != status] = ma.masked
-            # Store flagged data points for visualization
-            valid_ind = np.where(quality_flag != status)[0]
-            if len(valid_ind) > 0:
-                flagged_data[valid_ind] = self._data[valid_ind]
-            self._data[quality_flag != status] = ma.masked
-        return flagged_data
+            is_bad_zenith = np.abs(zenith_angle) > zenith_limit
+            is_bad_pointing = pointing_flag != valid_pointing_status
+            return is_bad_zenith | is_bad_pointing
+        return np.zeros_like(figure_data.time, dtype=bool)
 
     @staticmethod
     def _find_time_gap_indices(time: ndarray, max_gap_min: float) -> ndarray:
@@ -633,6 +689,8 @@ def _reformat_units(unit: str) -> str:
         "sr-1 m-1": "sr$^{-1}$ m$^{-1}$",
         "kg m-2": "kg m$^{-2}$",
         "kg m-3": "kg m$^{-3}$",
+        "g m-3": "g m$^{-3}$",
+        "g m-2": "g m$^{-2}$",
         "kg m-2 s-1": "kg m$^{-2}$ s$^{-1}$",
         "dB km-1": "dB km$^{-1}$",
         "rad km-1": "rad km$^{-1}$",
@@ -682,3 +740,22 @@ def plot_2d(
     if xlim is not None:
         plt.xlim(xlim)
     plt.show()
+
+
+def find_batches_of_ones(array: np.ndarray) -> list[tuple[int, int]]:
+    """Find batches of ones in a binary array."""
+    starts = np.where(np.diff(np.hstack(([0], array))) == 1)[0]
+    stops = np.where(np.diff(np.hstack((array, [0]))) == -1)[0]
+    return list(zip(starts, stops, strict=True))
+
+
+def screen_completely_masked_profiles(time: np.ndarray, data: ma.MaskedArray) -> tuple:
+    if not ma.is_masked(data):
+        return time, data
+    good_ind = np.where(np.any(~data.mask, axis=1))[0]
+    if len(good_ind) == 0:
+        msg = "All values masked in the file."
+        raise PlottingError(msg)
+    good_ind = np.append(good_ind, good_ind[-1] + 1)
+    good_ind = np.clip(good_ind, 0, len(time) - 1)
+    return time[good_ind], data[good_ind, :]

cloudnetpy/products/__init__.py

@@ -4,3 +4,4 @@ from .drizzle import generate_drizzle
 from .ier import generate_ier
 from .iwc import generate_iwc
 from .lwc import generate_lwc
+from .mwr_tools import generate_mwr_multi, generate_mwr_single

cloudnetpy/products/mwr_tools.py

@@ -0,0 +1,127 @@
+import tempfile
+from typing import Literal
+
+import netCDF4
+from mwrpy.level2.lev2_collocated import generate_lev2_multi as gen_multi
+from mwrpy.level2.lev2_collocated import generate_lev2_single as gen_single
+from mwrpy.version import __version__ as mwrpy_version
+
+from cloudnetpy import output, utils
+from cloudnetpy.products import product_tools
+
+
+def generate_mwr_single(
+    mwr_l1c_file: str, output_file: str, uuid: str | None = None
+) -> str:
+    """
+    Generates MWR single-pointing product including liquid water path, integrated
+    water vapor, etc. from zenith measurements.
+
+    Args:
+        mwr_l1c_file: The Level 1C MWR file to be processed.
+        output_file: The file path where the output file should be saved.
+        uuid: The UUID, if any, associated with the output file. Defaults to None.
+
+    Returns:
+        UUID of generated file.
+
+    Example:
+        >>> generate_mwr_single('input_mwr_l1c_file', 'output_file', 'abcdefg1234567')
+    """
+    return _generate_product(mwr_l1c_file, output_file, uuid, "single")
+
+
+def generate_mwr_multi(
+    mwr_l1c_file: str, output_file: str, uuid: str | None = None
+) -> str:
+    """
+    Generates MWR multiple-pointing product, including relative humidity profiles,
+    etc. from scanning measurements.
+
+    Args:
+        mwr_l1c_file: The input file in MWR L1C format.
+        output_file: The location where the output file should be generated.
+        uuid: The UUID for the MWR multi product, defaults to None if
+            not provided.
+
+    Returns:
+        UUID of generated file.
+    """
+    return _generate_product(mwr_l1c_file, output_file, uuid, "multi")
+
+
+def _generate_product(
+    mwr_l1c_file: str,
+    output_file: str,
+    uuid: str | None,
+    product: Literal["multi", "single"],
+) -> str:
+    fun = gen_multi if product == "multi" else gen_single
+    with tempfile.TemporaryDirectory() as temp_dir:
+        coeffs = product_tools.get_read_mwrpy_coeffs(mwr_l1c_file, temp_dir)
+        fun(None, mwr_l1c_file, output_file, coeff_files=coeffs)
+    with (
+        netCDF4.Dataset(mwr_l1c_file, "r") as nc_input,
+        netCDF4.Dataset(output_file, "r+") as nc_output,
+    ):
+        mwr = Mwr(nc_input, nc_output, uuid)
+        return mwr.harmonize(product)
+
+
+class Mwr:
+    def __init__(
+        self, nc_l1c: netCDF4.Dataset, nc_l2: netCDF4.Dataset, uuid: str | None
+    ):
+        self.nc_l1c = nc_l1c
+        self.nc_l2 = nc_l2
+        self.uuid = uuid if uuid is not None else utils.get_uuid()
+
+    def harmonize(self, product: Literal["multi", "single"]) -> str:
+        self._truncate_global_attributes()
+        self._copy_variable_values()
+        self._copy_global_attributes()
+        self._fix_variable_attributes()
+        self._write_missing_global_attributes(product)
+        return self.uuid
+
+    def _truncate_global_attributes(self):
+        for attr in self.nc_l2.ncattrs():
+            delattr(self.nc_l2, attr)
+
+    def _copy_variable_values(self):
+        keys = ("latitude", "longitude", "altitude")
+        for var in keys:
+            if var in self.nc_l2.variables:
+                self.nc_l2.variables[var][:] = self.nc_l1c.variables[var][:]
+
+    def _copy_global_attributes(self):
+        keys = ("year", "month", "day", "location", "source")
+        output.copy_global(self.nc_l1c, self.nc_l2, keys)
+
+    def _fix_variable_attributes(self):
+        output.replace_attribute_with_standard_value(
+            self.nc_l2,
+            (
+                "lwp",
+                "iwv",
+                "temperature",
+                "azimuth_angle",
+                "latitude",
+                "longitude",
+                "altitude",
+            ),
+            ("units", "long_name", "standard_name"),
+        )
+
+    def _write_missing_global_attributes(self, product: Literal["multi", "single"]):
+        output.add_standard_global_attributes(self.nc_l2, self.uuid)
+        product_type = "multiple-pointing" if product == "multi" else "single-pointing"
+        self.nc_l2.title = f"MWR {product_type} from {self.nc_l1c.location}"
+        self.nc_l2.cloudnet_file_type = f"mwr-{product}"
+        output.fix_time_attributes(self.nc_l2)
+        self.nc_l2.history = (
+            f"{utils.get_time()} - MWR {product_type} file created \n"
+            f"{self.nc_l1c.history}"
+        )
+        self.nc_l2.source_file_uuids = self.nc_l1c.file_uuid
+        self.nc_l2.mwrpy_version = mwrpy_version

cloudnetpy/version.py

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

{cloudnetpy-1.56.4.dist-info → cloudnetpy-1.56.6.dist-info}/METADATA

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

{cloudnetpy-1.56.4.dist-info → cloudnetpy-1.56.6.dist-info}/RECORD

@@ -3,12 +3,12 @@ cloudnetpy/cloudnetarray.py,sha256=vSI6hqozhS1ntNIgY2kqTt7N6BF_xJtUii_vsuyxTno,6
 cloudnetpy/concat_lib.py,sha256=YK5ho5msqwNxpPtPT8f2OewIJ8hTrbhCkaxHaBKLTI0,9809
 cloudnetpy/constants.py,sha256=OMp3pKHCZmdKyRvfO35E7vE3FrS_DHIs_GJuexJLCQk,600
 cloudnetpy/datasource.py,sha256=-6oLC5bsn9sIoaN0glV88owFyTeGRsW1ZVJSV8rM5rE,7813
-cloudnetpy/exceptions.py,sha256=NsuB5gTA8NvpmxykIJjHOWObTPpAerzpofs8xrFA1ow,1272
+cloudnetpy/exceptions.py,sha256=nA6YieylwKSp5KQOh3DhhcTmUBsd0tBZnedgmlWck-w,1415
 cloudnetpy/metadata.py,sha256=Bcu1a9UyUq61jomuZ0_6hYIOzf61e5qCXeiwLm46ikw,5040
 cloudnetpy/output.py,sha256=jD1pfBb4OQhVOrlhPEk-8FAi4bUW7zjAL468r6BPkJg,14586
 cloudnetpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/utils.py,sha256=yY5a5HLuAks2uzA4XbbqsGFEmXoyqECn_TjD3sMa0lI,27193
-cloudnetpy/version.py,sha256=lnEVFXHSKtSjA3iEu1JkOORO-IrhXQfth6GZQDdyhv4,72
+cloudnetpy/version.py,sha256=KcLO5w70O8aXSbgK5nqMVq2YM5wAvubh8Uf9D1Q4FNc,72
 cloudnetpy/categorize/__init__.py,sha256=gP5q3Vis1y9u9OWgA_idlbjfWXYN_S0IBSWdwBhL_uU,69
 cloudnetpy/categorize/atmos.py,sha256=cax3iRmvr7S-VkUZqz0JCfAN3WEsUVbGfH4zSHy1APo,12384
 cloudnetpy/categorize/atmos_utils.py,sha256=wndpwJxc2-QnNTkV8tc8I11Vs_WkNz9sVMX1fuGgUC4,3777
@@ -33,7 +33,7 @@ cloudnetpy/instruments/cl61d.py,sha256=ycJGvUqNU2KHhECbrSehtWRnvg1vKFHhvMeQpjpdC
 cloudnetpy/instruments/cloudnet_instrument.py,sha256=RG5HJxGM6p0F-IGyr85fvOizcMmgx48OeD_XeIsrgSU,3367
 cloudnetpy/instruments/copernicus.py,sha256=AT0AtMhGSKzPWEqXsfAda6zeaw4g0Jr5dqIyfeu4FP0,6327
 cloudnetpy/instruments/galileo.py,sha256=FyFYh1JhWed1d6yvpsv3rdBzHUTjkfOPw5HEQz4Wssw,4545
-cloudnetpy/instruments/hatpro.py,sha256=TK-7KcpI7E1ErEq9XmQzJPEqoenjOePfkieD0ybEPW4,8099
+cloudnetpy/instruments/hatpro.py,sha256=TEwPyUsT8J17uDPwcB5B8nPDo0f6UAvg5bDjG8tKLdA,8119
 cloudnetpy/instruments/instruments.py,sha256=GcUEbQFPHUhRTnp300AZ2PK0O2d2EPIGtHqCX6dy99M,3133
 cloudnetpy/instruments/lufft.py,sha256=nozeiMRMz7I6q_FwmlxDGhWeJlqTuNh6ru39-M4K3BI,3629
 cloudnetpy/instruments/mira.py,sha256=TfozpYivQAThZ_rV3gLzZpz2QyJFWOF0RXdzA4521rM,9332
@@ -91,9 +91,9 @@ cloudnetpy/model_evaluation/tests/unit/test_plotting.py,sha256=h9V8JKmrO4v9bOvv-
 cloudnetpy/model_evaluation/tests/unit/test_statistical_methods.py,sha256=Ra3r4V0qbqkpDuaTYvEIbaasl0nZ5gmTLR4eGC0glBQ,9724
 cloudnetpy/model_evaluation/tests/unit/test_tools.py,sha256=Ia_VrLdV2NstX5gbx_3AZTOAlrgLAy_xFZ8fHYVX0xI,3817
 cloudnetpy/plotting/__init__.py,sha256=2-8x8d1AfAhfU15RwWhusD0Wot_g6Ob_jJoywbrTC7A,95
-cloudnetpy/plotting/plot_meta.py,sha256=WNTeSEpACN5vV1omoZfXtRdIxrohYHJU3v2lHjspQRM,12823
-cloudnetpy/plotting/plotting.py,sha256=Br5rBWZtP14moM81LdMs0mb-NhDFVAcRizOYlg8edb8,23933
-cloudnetpy/products/__init__.py,sha256=hGkngQT-YAC5cmDiHkSkQw2ZBrg0hN2z40Fizz0QU5Y,210
+cloudnetpy/plotting/plot_meta.py,sha256=xbiEU9Okx5L_WG7KtVnljxjpCYcgqyOLywBc49gibSQ,13033
+cloudnetpy/plotting/plotting.py,sha256=NjeWF5u7fSvNVCwvOu8RyxQ7bApm7K74CF4I2sDCR40,26868
+cloudnetpy/products/__init__.py,sha256=2hRb5HG9hNrxH1if5laJkLeFeaZCd5W1q3hh4ewsX0E,273
 cloudnetpy/products/classification.py,sha256=J_FOMUSyxvFaT-hvdKVVcKPtuQ0u3V9PsV5xaIKzMjg,7843
 cloudnetpy/products/der.py,sha256=HAdPvbJySEqkIwDrdZDPnli_wnN2qwm72_D1a82ZWIs,12398
 cloudnetpy/products/drizzle.py,sha256=BY2HvJeWt_ps6KKCGXwUUNRTy78q0cQM8bOCCoj8TWA,10803
@@ -103,12 +103,11 @@ cloudnetpy/products/ier.py,sha256=IcGPlQahbwJjp3vOOrxWSYW2FPzbSV0KQL5eYECc4kU,77
 cloudnetpy/products/iwc.py,sha256=MUPuVKWgqOuuLRCGk3QY74uBZB_7P1qlinlP8nEvz9o,10124
 cloudnetpy/products/lwc.py,sha256=TbIR6kMwjbm63ed5orB1pkqx9ZBm8C5TF2JmT8WKdKI,18794
 cloudnetpy/products/mie_lu_tables.nc,sha256=It4fYpqJXlqOgL8jeZ-PxGzP08PMrELIDVe55y9ob58,16637951
-cloudnetpy/products/mwr_multi.py,sha256=mRMzdDhTddhPLBcDiG_2kw_BSRL_01hA9-o4-cmaVaQ,3301
-cloudnetpy/products/mwr_single.py,sha256=4KyxeFg7AphEJg5P7ey8SXacyNAG3PGDOvnksvZj3R8,3168
+cloudnetpy/products/mwr_tools.py,sha256=TsVEqNwzoDv90TgzUSnJjMuc3C1KQ-hwsIZ8t0IdDJ4,4407
 cloudnetpy/products/product_tools.py,sha256=E8CSijBY8cr70BH2JFa0lGQ-RzI9EcHQ0Fzt8CQ8rY4,10442
 docs/source/conf.py,sha256=IKiFWw6xhUd8NrCg0q7l596Ck1d61XWeVjIFHVSG9Og,1490
-cloudnetpy-1.56.4.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
-cloudnetpy-1.56.4.dist-info/METADATA,sha256=R6YZSD8wmlEcw9Oz2cnyWjGz5YAltO9g3OT0ZQblaH0,5733
-cloudnetpy-1.56.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-cloudnetpy-1.56.4.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
-cloudnetpy-1.56.4.dist-info/RECORD,,
+cloudnetpy-1.56.6.dist-info/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
+cloudnetpy-1.56.6.dist-info/METADATA,sha256=kr-kst-d8xZSZA6N5IpUhsoRdab_rPEEXAmWlPS1pXo,5733
+cloudnetpy-1.56.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+cloudnetpy-1.56.6.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
+cloudnetpy-1.56.6.dist-info/RECORD,,

cloudnetpy/products/mwr_multi.py

@@ -1,82 +0,0 @@
-import tempfile
-from tempfile import NamedTemporaryFile
-
-import netCDF4
-from mwrpy.level2.write_lev2_nc import MissingInputData, lev2_to_nc
-from mwrpy.version import __version__ as mwrpy_version
-
-from cloudnetpy import output, utils
-from cloudnetpy.exceptions import MissingInputFileError
-from cloudnetpy.products import product_tools
-
-
-def generate_mwr_multi(
-    mwr_l1c_file: str,
-    output_file: str,
-    uuid: str | None = None,
-) -> str:
-    file_uuid = uuid if uuid is not None else utils.get_uuid()
-
-    with (
-        NamedTemporaryFile() as temp_file,
-        NamedTemporaryFile() as abs_hum_file,
-        NamedTemporaryFile() as rel_hum_file,
-        NamedTemporaryFile() as t_pot_file,
-        NamedTemporaryFile() as eq_temp_file,
-        tempfile.TemporaryDirectory() as temp_dir,
-    ):
-        coeffs = product_tools.get_read_mwrpy_coeffs(mwr_l1c_file, temp_dir)
-
-        for prod, file in zip(
-            ("2P02", "2P03", "2P04", "2P07", "2P08"),
-            (temp_file, abs_hum_file, rel_hum_file, t_pot_file, eq_temp_file),
-            strict=True,
-        ):
-            try:
-                lev2_to_nc(
-                    prod,
-                    mwr_l1c_file,
-                    file.name,
-                    coeff_files=coeffs,
-                    temp_file=temp_file.name if prod not in ("2P02", "2P03") else None,
-                    hum_file=abs_hum_file.name
-                    if prod not in ("2P02", "2P03")
-                    else None,
-                )
-            except MissingInputData as err:
-                raise MissingInputFileError from err
-
-        with (
-            netCDF4.Dataset(output_file, "w", format="NETCDF4_CLASSIC") as nc_output,
-            netCDF4.Dataset(mwr_l1c_file, "r") as nc_l1c,
-            netCDF4.Dataset(temp_file.name, "r") as nc_temp,
-            netCDF4.Dataset(rel_hum_file.name, "r") as nc_rel_hum,
-            netCDF4.Dataset(t_pot_file.name, "r") as nc_t_pot,
-            netCDF4.Dataset(eq_temp_file.name, "r") as nc_eq_temp,
-        ):
-            nc_output.createDimension("time", len(nc_temp.variables["time"][:]))
-            nc_output.createDimension("height", len(nc_temp.variables["height"][:]))
-
-            for source, variables in (
-                (nc_l1c, ("latitude", "longitude", "altitude")),
-                (nc_temp, ("time", "height", "temperature")),
-                (nc_rel_hum, ("relative_humidity",)),
-                (nc_t_pot, ("potential_temperature",)),
-                (nc_eq_temp, ("equivalent_potential_temperature",)),
-            ):
-                output.copy_variables(source, nc_output, variables)
-
-            output.add_standard_global_attributes(nc_output, file_uuid)
-            output.copy_global(nc_l1c, nc_output, ("year", "month", "day", "location"))
-            nc_output.title = f"MWR multiple-pointing from {nc_l1c.location}"
-            nc_output.cloudnet_file_type = "mwr-multi"
-            nc_output.mwrpy_version = mwrpy_version
-            output.fix_time_attributes(nc_output)
-            nc_output.history = (
-                f"{utils.get_time()} - MWR multiple-pointing product created \n"
-                f"{nc_l1c.history}"
-            )
-            nc_output.source_file_uuids = nc_l1c.file_uuid
-            nc_output.source = nc_l1c.source
-
-    return file_uuid

cloudnetpy/products/mwr_single.py

@@ -1,83 +0,0 @@
-import tempfile
-from tempfile import NamedTemporaryFile
-
-import netCDF4
-from mwrpy.level2.write_lev2_nc import lev2_to_nc
-from mwrpy.version import __version__ as mwrpy_version
-
-from cloudnetpy import output, utils
-from cloudnetpy.products import product_tools
-
-
-def generate_mwr_single(
-    mwr_l1c_file: str,
-    output_file: str,
-    uuid: str | None = None,
-) -> str:
-    file_uuid = uuid if uuid is not None else utils.get_uuid()
-
-    with (
-        NamedTemporaryFile() as lwp_file,
-        NamedTemporaryFile() as iwv_file,
-        NamedTemporaryFile() as t_prof_file,
-        NamedTemporaryFile() as abs_hum_file,
-        tempfile.TemporaryDirectory() as temp_dir,
-    ):
-        coeffs = product_tools.get_read_mwrpy_coeffs(mwr_l1c_file, temp_dir)
-
-        for prod, file in zip(
-            ("2I01", "2I02", "2P01", "2P03"),
-            (lwp_file, iwv_file, t_prof_file, abs_hum_file),
-            strict=True,
-        ):
-            lev2_to_nc(prod, mwr_l1c_file, file.name, coeff_files=coeffs)
-
-        with (
-            netCDF4.Dataset(output_file, "w", format="NETCDF4_CLASSIC") as nc_output,
-            netCDF4.Dataset(lwp_file.name, "r") as nc_lwp,
-            netCDF4.Dataset(iwv_file.name, "r") as nc_iwv,
-            netCDF4.Dataset(abs_hum_file.name, "r") as nc_hum,
-            netCDF4.Dataset(t_prof_file.name, "r") as nc_t_prof,
-            netCDF4.Dataset(mwr_l1c_file, "r") as nc_l1c,
-        ):
-            nc_output.createDimension("height", len(nc_t_prof.variables["height"][:]))
-            nc_output.createDimension("time", len(nc_lwp.variables["time"][:]))
-
-            for source, variables in (
-                (nc_iwv, ("iwv",)),
-                (nc_hum, ("absolute_humidity",)),
-                (nc_t_prof, ("temperature", "height")),
-                (nc_l1c, ("latitude", "longitude", "altitude")),
-                (
-                    nc_lwp,
-                    (
-                        "time",
-                        "lwp",
-                        "lwp_random_error",
-                        "lwp_offset",
-                        "lwp_systematic_error",
-                        "azimuth_angle",
-                    ),
-                ),
-            ):
-                output.copy_variables(source, nc_output, variables)
-
-            output.add_standard_global_attributes(nc_output, file_uuid)
-            output.copy_global(nc_l1c, nc_output, ("year", "month", "day", "location"))
-            nc_output.title = f"MWR single-pointing from {nc_l1c.location}"
-            nc_output.cloudnet_file_type = "mwr-single"
-            nc_output.mwrpy_version = mwrpy_version
-            output.fix_time_attributes(nc_output)
-            output.replace_attribute_with_standard_value(
-                nc_output,
-                ("lwp", "iwv", "temperature", "azimuth_angle"),
-                ("units", "long_name", "standard_name"),
-            )
-            nc_output.history = (
-                f"{utils.get_time()} - MWR single-pointing product created \n"
-                f"{nc_l1c.history}"
-            )
-            nc_output.source_file_uuids = nc_l1c.file_uuid
-            nc_output.source = nc_l1c.source
-
-    return file_uuid