cloudnetpy 1.65.7__py3-none-any.whl → 1.66.0__py3-none-any.whl

cloudnetpy/output.py

@@ -2,6 +2,7 @@
 
 import datetime
 import logging
+from dataclasses import fields
 from os import PathLike
 from uuid import UUID
 
@@ -10,6 +11,9 @@ import numpy as np
 from numpy import ma
 
 from cloudnetpy import utils, version
+from cloudnetpy.categorize.containers import Observations
+from cloudnetpy.categorize.model import Model
+from cloudnetpy.datasource import DataSource
 from cloudnetpy.instruments.instruments import Instrument
 from cloudnetpy.metadata import COMMON_ATTRIBUTES, MetaData
 
@@ -69,7 +73,7 @@ def _get_netcdf_dimensions(obj) -> dict:
 
 def save_product_file(
     short_id: str,
-    obj,
+    obj: DataSource,
     file_name: str,
     uuid: str | None = None,
     copy_from_cat: tuple = (),
@@ -105,13 +109,13 @@ def save_product_file(
             f"{human_readable_file_type.capitalize()} products from"
             f" {obj.dataset.location}"
         )
-        nc.source_file_uuids = get_source_uuids(nc, obj)
+        nc.source_file_uuids = get_source_uuids([nc, obj])
         copy_global(
             obj.dataset,
             nc,
             ("location", "day", "month", "year", "source", "voodoonet_version"),
         )
-        merge_history(nc, human_readable_file_type, {"categorize": obj})
+        merge_history(nc, human_readable_file_type, obj)
         nc.references = get_references(short_id)
     return file_uuid
 
@@ -172,26 +176,32 @@ def get_references(identifier: str | None = None, extra: list | None = None) ->
     return references
 
 
-def get_source_uuids(*sources) -> str:
+def get_source_uuids(data: Observations | list[netCDF4.Dataset | DataSource]) -> str:
     """Returns file_uuid attributes of objects.
 
     Args:
-        *sources: Objects whose file_uuid attributes are read (if exist).
+        data: Observations instance.
 
     Returns:
         str: UUIDs separated by comma.
 
     """
+    if isinstance(data, Observations):
+        obs = [getattr(data, field.name) for field in fields(data)]
+    elif isinstance(data, list):
+        obs = data
     uuids = [
-        source.dataset.file_uuid
-        for source in sources
-        if hasattr(source, "dataset") and hasattr(source.dataset, "file_uuid")
+        obj.dataset.file_uuid
+        for obj in obs
+        if hasattr(obj, "dataset") and hasattr(obj.dataset, "file_uuid")
     ]
-    unique_uuids = list(set(uuids))
+    unique_uuids = sorted(set(uuids))
     return ", ".join(unique_uuids)
 
 
-def merge_history(nc: netCDF4.Dataset, file_type: str, data: dict) -> None:
+def merge_history(
+    nc: netCDF4.Dataset, file_type: str, data: Observations | DataSource
+) -> None:
     """Merges history fields from one or several files and creates a new record.
 
     Args:
@@ -202,26 +212,36 @@ def merge_history(nc: netCDF4.Dataset, file_type: str, data: dict) -> None:
     """
     new_record = f"{utils.get_time()} - {file_type} file created"
     histories = []
-    for key, obj in data.items():
-        if (
-            not isinstance(obj, str | list)
-            and obj is not None
-            and hasattr(obj.dataset, "history")
-        ):
-            history = obj.dataset.history
-            history = history.split("\n")[-1] if key == "model" else history
-            histories.append(history)
+    if (
+        isinstance(data, DataSource)
+        and hasattr(data, "dataset")
+        and hasattr(data.dataset, "history")
+    ):
+        history = data.dataset.history
+        histories.append(history)
+    if isinstance(data, Observations):
+        for field in fields(data):
+            obj = getattr(data, field.name)
+            if hasattr(obj, "dataset") and hasattr(obj.dataset, "history"):
+                history = obj.dataset.history
+                history = history.split("\n")[-1] if isinstance(obj, Model) else history
+                histories.append(history)
     histories.sort(reverse=True)
     old_history = [f"\n{history}" for history in histories]
     old_history_str = "".join(old_history)
     nc.history = f"{new_record}{old_history_str}"
 
 
-def add_source_instruments(nc: netCDF4.Dataset, data: dict) -> None:
+def add_source_instruments(nc: netCDF4.Dataset, data: Observations) -> None:
     """Adds source attribute to categorize file."""
-    sources = [obj.source for obj in data.values() if hasattr(obj, "source")]
-    sources = [sources[0]] + [f"\n{source}" for source in sources[1:]]
-    nc.source = "".join(sources)
+    sources = []
+    for field in fields(data):
+        obj = getattr(data, field.name)
+        if hasattr(obj, "source"):
+            sources.append(obj.source)
+    if sources:
+        formatted_sources = [sources[0]] + [f"\n{source}" for source in sources[1:]]
+        nc.source = "".join(formatted_sources)
 
 
 def init_file(
@@ -319,7 +339,7 @@ def add_time_attribute(
     return attributes
 
 
-def add_source_attribute(attributes: dict, data: dict) -> dict:
+def add_source_attribute(attributes: dict, data: Observations) -> dict:
     """Adds source attribute to variables."""
     variables = {
         "radar": (
@@ -340,9 +360,9 @@ def add_source_attribute(attributes: dict, data: dict) -> dict:
         "disdrometer": ("rainfall_rate",),
     }
     for instrument, keys in variables.items():
-        if data[instrument] is None:
+        if getattr(data, instrument) is None:
             continue
-        source = data[instrument].dataset.source
+        source = getattr(data, instrument).dataset.source
         for key in keys:
             if key in attributes:
                 attributes[key] = attributes[key]._replace(source=source)

cloudnetpy/plotting/plot_meta.py

@@ -96,7 +96,7 @@ _CLABEL = {
         ("Uncorrected", _COLORS["orange"]),
         ("Corrected", _COLORS["lightgreen"]),
         ("Ice from lidar", _COLORS["yellow"]),
-        ("Ice above rain", _COLORS["darksky"]),
+        ("_Ice above rain", _COLORS["darksky"]),
         ("Clear above rain", _COLORS["skyblue"]),
         ("Positive temp.", _COLORS["seaweed"]),
     ),
@@ -497,7 +497,13 @@ ATTRIBUTES = {
             plot_range=(0, 5),
         ),
         "radar_gas_atten": PlotMeta(
-            plot_range=(0, 1),
+            plot_range=(0, 5),
+        ),
+        "radar_rain_atten": PlotMeta(
+            plot_range=(0, 5),
+        ),
+        "radar_melting_atten": PlotMeta(
+            plot_range=(0, 5),
         ),
         "iwv": PlotMeta(
             cmap="Blues",

cloudnetpy/plotting/plotting.py

@@ -21,6 +21,7 @@ from mpl_toolkits.axes_grid1 import make_axes_locatable
 from numpy import ma, ndarray
 from scipy.ndimage import uniform_filter
 
+from cloudnetpy.categorize.freezing import find_t0_alt
 from cloudnetpy.exceptions import PlottingError
 from cloudnetpy.instruments.ceilometer import calc_sigma_units
 from cloudnetpy.plotting.plot_meta import ATTRIBUTES, PlotMeta
@@ -399,8 +400,9 @@ class Plot:
         flag_names = [
             f"{self.sub_plot.variable.name}_quality_flag",
             "temperature_quality_flag",
-            "quality_flag",
         ]
+        if self.sub_plot.variable.name != "irt":
+            flag_names.append("quality_flag")
         for flag_name in flag_names:
             if flag_name in figure_data.file.variables:
                 return figure_data.file.variables[flag_name][:] > 0
@@ -426,6 +428,22 @@ class Plot2D(Plot):
         if figure_data.is_mwrpy_product():
             self._fill_flagged_data(figure_data)
 
+        if self.sub_plot.variable.name == "Tw":
+            tw = figure_data.file["Tw"][:]
+            height = figure_data.height
+            if height is None:
+                msg = "No height information in the file."
+                raise ValueError(msg)
+            t0_alt = find_t0_alt(tw, height)
+            t0_alt = ma.masked_where(t0_alt <= height[0], t0_alt)
+            self._ax.plot(
+                figure_data.time,
+                t0_alt,
+                color="gray",
+                linestyle="dashed",
+                zorder=_get_zorder("t0"),
+            )
+
     def _fill_flagged_data(self, figure_data: FigureData) -> None:
         flags = self._read_flagged_data(figure_data)
         batches = find_batches_of_ones(flags)
@@ -490,6 +508,10 @@ class Plot2D(Plot):
             smoothed_data = uniform_filter(self._data[valid_time_ind, :], sigma_units)
             self._data[valid_time_ind, :] = smoothed_data
 
+        if self._data.mask.all():
+            msg = "All data is masked"
+            raise PlottingError(msg)
+
         pcolor_kwargs = {
             "cmap": plt.get_cmap(str(self._plot_meta.cmap)),
             "vmin": vmin,
@@ -584,10 +606,10 @@ class Plot1D(Plot):
             msg = "All data is masked"
             raise PlottingError(msg)
         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
         if self.sub_plot.variable.name == "tb":
+            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):
@@ -602,7 +624,7 @@ class Plot1D(Plot):
             value = figure_data.file.variables["frequency"][freq_ind]
             unit = "GHz"
         else:
-            label = "Wavel"
+            label = "WL"
             variable = figure_data.file.variables["ir_wavelength"]
             # `ir_wavelength` is scalar in old files
             value = variable[:] if len(variable.shape) == 0 else variable[freq_ind]
@@ -681,7 +703,7 @@ class Plot1D(Plot):
         time = figure_data.time.copy()
         data = self._data_orig.copy()
         flags = self._read_flagged_data(figure_data)
-        if hacky_freq_ind is not None:
+        if hacky_freq_ind is not None and np.any(flags):
             flags = flags[:, hacky_freq_ind]
         is_invalid = ma.getmaskarray(data)
         if np.any(flags):
@@ -689,7 +711,8 @@ class Plot1D(Plot):
 
         is_wind_direction = self.sub_plot.variable.name == "wind_direction"
         if is_wind_direction:
-            data = np.stack([figure_data.file["wind_speed"], data])
+            wind_speed = figure_data.file["wind_speed"]
+            data = np.stack([wind_speed, data], axis=1)
 
         block_ind = np.where(np.diff(is_invalid))[0] + 1
         valid_time_blocks = np.split(time, block_ind)[is_invalid[0] :: 2]
@@ -698,7 +721,7 @@ class Plot1D(Plot):
         for time1, data1 in zip(valid_time_blocks, valid_data_blocks, strict=False):
             if is_wind_direction:
                 sma = self._calculate_average_wind_direction(
-                    data1[0], data1[1], time1, window=15
+                    data1[:, 0], data1[:, 1], time1, window=15
                 )
             else:
                 sma = self._calculate_moving_average(data1, time1, window=5)

cloudnetpy/products/classification.py

@@ -4,7 +4,7 @@ import numpy as np
 from numpy import ma
 
 from cloudnetpy import output, utils
-from cloudnetpy.categorize import atmos
+from cloudnetpy.categorize import atmos_utils
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.metadata import MetaData
 from cloudnetpy.products.product_tools import CategorizeBits
@@ -67,40 +67,45 @@ def _get_target_classification(
     categorize_bits: CategorizeBits,
 ) -> ma.MaskedArray:
     bits = categorize_bits.category_bits
-    clutter = categorize_bits.quality_bits["clutter"]
-    classification = ma.zeros(bits["cold"].shape, dtype=int)
-    classification[bits["droplet"] & ~bits["falling"]] = 1  # Cloud droplets
-    classification[~bits["droplet"] & bits["falling"]] = 2  # Drizzle or rain
-    classification[bits["droplet"] & bits["falling"]] = (
-        3  # Drizzle or rain and droplets
-    )
-    classification[~bits["droplet"] & bits["falling"] & bits["cold"]] = 4  # ice
-    classification[bits["droplet"] & bits["falling"] & bits["cold"]] = (
-        5  # ice + supercooled
-    )
-    classification[bits["melting"]] = 6  # melting layer
-    classification[bits["melting"] & bits["droplet"]] = 7  # melting + droplets
-    classification[bits["aerosol"]] = 8  # aerosols
-    classification[bits["insect"] & ~clutter] = 9  # insects
-    classification[bits["aerosol"] & bits["insect"] & ~clutter] = (
-        10  # insects + aerosols
-    )
-    classification[clutter & ~bits["aerosol"]] = 0
+    clutter = categorize_bits.quality_bits.clutter
+    classification = ma.zeros(bits.freezing.shape, dtype=int)
+    classification[bits.droplet & ~bits.falling] = 1  # Cloud droplets
+    classification[~bits.droplet & bits.falling] = 2  # Drizzle or rain
+    classification[bits.droplet & bits.falling] = 3  # Drizzle or rain and droplets
+    classification[~bits.droplet & bits.falling & bits.freezing] = 4  # ice
+    classification[bits.droplet & bits.falling & bits.freezing] = 5  # ice + supercooled
+    classification[bits.melting] = 6  # melting layer
+    classification[bits.melting & bits.droplet] = 7  # melting + droplets
+    classification[bits.aerosol] = 8  # aerosols
+    classification[bits.insect & ~clutter] = 9  # insects
+    classification[bits.aerosol & bits.insect & ~clutter] = 10  # insects + aerosols
+    classification[clutter & ~bits.aerosol] = 0
     return classification
 
 
 def _get_detection_status(categorize_bits: CategorizeBits) -> np.ndarray:
     bits = categorize_bits.quality_bits
-    status = np.zeros(bits["radar"].shape, dtype=int)
-    status[bits["lidar"] & ~bits["radar"]] = 1
-    status[bits["radar"] & bits["lidar"]] = 3
-    status[~bits["radar"] & bits["attenuated"] & ~bits["corrected"]] = 4
-    status[bits["radar"] & ~bits["lidar"] & ~bits["attenuated"]] = 5
-    status[~bits["radar"] & bits["attenuated"] & bits["corrected"]] = 6
-    status[bits["radar"] & bits["corrected"]] = 7
-    status[bits["radar"] & bits["attenuated"] & ~bits["corrected"]] = 2
-    status[bits["clutter"]] = 8
-    status[bits["molecular"] & ~bits["radar"]] = 9
+
+    is_attenuated = (
+        bits.attenuated_liquid | bits.attenuated_rain | bits.attenuated_melting
+    )
+    is_corrected = (
+        is_attenuated
+        & (~bits.attenuated_liquid | bits.corrected_liquid)
+        & (~bits.attenuated_rain | bits.corrected_rain)
+        & (~bits.attenuated_melting | bits.corrected_melting)
+    )
+
+    status = np.zeros(bits.radar.shape, dtype=int)
+    status[bits.lidar & ~bits.radar] = 1
+    status[bits.radar & bits.lidar] = 3
+    status[~bits.radar & is_attenuated & ~is_corrected] = 4
+    status[bits.radar & ~bits.lidar & ~is_attenuated] = 5
+    status[~bits.radar & is_attenuated & is_corrected] = 6
+    status[bits.radar & is_corrected] = 7
+    status[bits.radar & is_attenuated & ~is_corrected] = 2
+    status[bits.clutter] = 8
+    status[bits.molecular & ~bits.radar] = 9
     return status
 
 
@@ -112,8 +117,8 @@ def _get_cloud_base_and_top_heights(
     cloud_mask = _find_cloud_mask(classification)
     if not cloud_mask.any():
         return ma.masked_all(cloud_mask.shape[0]), ma.masked_all(cloud_mask.shape[0])
-    lowest_bases = atmos.find_lowest_cloud_bases(cloud_mask, height)
-    highest_tops = atmos.find_highest_cloud_tops(cloud_mask, height)
+    lowest_bases = atmos_utils.find_lowest_cloud_bases(cloud_mask, height)
+    highest_tops = atmos_utils.find_highest_cloud_tops(cloud_mask, height)
     if not (highest_tops - lowest_bases >= 0).all():
         msg = "Cloud base higher than cloud top!"
         raise ValueError(msg)
@@ -168,8 +173,8 @@ DEFINITIONS = {
                   attenuation that would be experienced is unknown.""",
             5: """Good radar echo only.""",
             6: """No radar echo but known attenuation.""",
-            7: """Radar echo corrected for liquid attenuation using microwave
-                  radiometer data.""",
+            7: """Radar echo corrected for liquid, rain or melting
+                  attenuation.""",
             8: """Radar ground clutter.""",
             9: """Lidar clear-air molecular scattering.""",
         }

cloudnetpy/products/der.py

@@ -8,7 +8,7 @@ import numpy as np
 from numpy import ma
 
 from cloudnetpy import output, utils
-from cloudnetpy.categorize import atmos
+from cloudnetpy.categorize import atmos_utils
 from cloudnetpy.datasource import DataSource
 from cloudnetpy.exceptions import InvalidSourceFileError
 from cloudnetpy.metadata import MetaData
@@ -94,18 +94,18 @@ class DropletClassification(ProductClassification):
         self.is_ice = self._find_ice()
 
     def _find_droplet(self) -> np.ndarray:
-        return self.category_bits["droplet"]
+        return self.category_bits.droplet
 
     def _find_mixed(self) -> np.ndarray:
-        return self.category_bits["falling"] & self.category_bits["droplet"]
+        return self.category_bits.falling & self.category_bits.droplet
 
     def _find_ice(self) -> np.ndarray:
         return (
-            self.category_bits["falling"]
-            & self.category_bits["cold"]
-            & ~self.category_bits["melting"]
-            & ~self.category_bits["droplet"]
-            & ~self.category_bits["insect"]
+            self.category_bits.falling
+            & self.category_bits.freezing
+            & ~self.category_bits.melting
+            & ~self.category_bits.droplet
+            & ~self.category_bits.insect
         )
 
 
@@ -131,7 +131,6 @@ class DerSource(DataSource):
         rho_l = 1000  # density of liquid water(kg m-3)
 
         var_x = params.sigma_x * params.sigma_x
-        dheight = utils.mdiff(self.getvar("height"))
 
         Z = self.getvar("Z")
         Z = utils.db2lin(Z)
@@ -146,9 +145,12 @@ class DerSource(DataSource):
         der_scaled_error = np.zeros(Z.shape)
         N_scaled = np.zeros(Z.shape)
 
-        is_droplet = self.categorize_bits.category_bits["droplet"]
-        liquid_bases = atmos.find_cloud_bases(is_droplet)
-        liquid_tops = atmos.find_cloud_tops(is_droplet)
+        is_droplet = self.categorize_bits.category_bits.droplet
+        liquid_bases = atmos_utils.find_cloud_bases(is_droplet)
+        liquid_tops = atmos_utils.find_cloud_tops(is_droplet)
+
+        height = self.getvar("height")
+        path_lengths = utils.path_lengths_from_ground(height)
 
         for base, top in zip(
             zip(*np.where(liquid_bases), strict=True),
@@ -162,7 +164,7 @@ class DerSource(DataSource):
             if Z[ind_t, idx_layer].mask.all():
                 continue
 
-            integral = ma.sum(ma.sqrt(Z[ind_t, idx_layer])) * dheight
+            integral = ma.sum(ma.sqrt(Z[ind_t, idx_layer])) * path_lengths[idx_layer]
 
             # der formula (5)
             A = (Z[ind_t, idx_layer] / params.N) ** (1 / 6)

cloudnetpy/products/drizzle_tools.py

@@ -21,7 +21,6 @@ class DrizzleSource(DataSource):
 
     Attributes:
         mie (dict): Mie look-up table data.
-        dheight (float): Median difference of height array.
         z (ndarray): 2D radar echo (linear units).
         beta (ndarray): 2D lidar backscatter.
         v (ndarray): 2D doppler velocity.
@@ -31,7 +30,7 @@ class DrizzleSource(DataSource):
     def __init__(self, categorize_file: str):
         super().__init__(categorize_file)
         self.mie = self._read_mie_lut()
-        self.dheight = utils.mdiff(self.getvar("height"))
+        self.height_vector = self.getvar("height")
         self.z = self._convert_z_units()
         self.beta = self.getvar("beta")
         self.v = self.getvar("v")
@@ -106,21 +105,22 @@ class DrizzleClassification(ProductClassification):
         return np.isfinite(v_sigma)
 
     def _find_warm_liquid(self) -> np.ndarray:
-        return self.category_bits["droplet"] & ~self.category_bits["cold"]
+        return self.category_bits.droplet & ~self.category_bits.freezing
 
     def _find_drizzle(self) -> np.ndarray:
         return (
             ~utils.transpose(self.is_rain)
-            & self.category_bits["falling"]
-            & ~self.category_bits["droplet"]
-            & ~self.category_bits["cold"]
-            & ~self.category_bits["melting"]
-            & ~self.category_bits["insect"]
-            & self.quality_bits["radar"]
-            & self.quality_bits["lidar"]
-            & ~self.quality_bits["clutter"]
-            & ~self.quality_bits["molecular"]
-            & ~self.quality_bits["attenuated"]
+            & self.category_bits.falling
+            & ~self.category_bits.droplet
+            & ~self.category_bits.freezing
+            & ~self.category_bits.melting
+            & ~self.category_bits.insect
+            & self.quality_bits.radar
+            & self.quality_bits.lidar
+            & ~self.quality_bits.clutter
+            & ~self.quality_bits.molecular
+            & ~self.quality_bits.attenuated_liquid
+            & ~self.quality_bits.attenuated_rain
             & self.is_v_sigma
         )
 
@@ -128,16 +128,16 @@ class DrizzleClassification(ProductClassification):
         return (
             ~utils.transpose(self.is_rain)
             & self.warm_liquid
-            & self.category_bits["falling"]
-            & ~self.category_bits["melting"]
-            & ~self.category_bits["insect"]
-            & self.quality_bits["radar"]
-            & ~self.quality_bits["clutter"]
-            & ~self.quality_bits["molecular"]
+            & self.category_bits.falling
+            & ~self.category_bits.melting
+            & ~self.category_bits.insect
+            & self.quality_bits.radar
+            & ~self.quality_bits.clutter
+            & ~self.quality_bits.molecular
         )
 
     def _find_cold_rain(self) -> np.ndarray:
-        return np.any(self.category_bits["melting"], axis=1)
+        return np.any(self.category_bits.melting, axis=1)
 
 
 class SpectralWidth:
@@ -250,6 +250,7 @@ class DrizzleSolver:
         dia_init[drizzle_ind] = self._calc_dia(self._beta_z_ratio[drizzle_ind], k=18.8)
         n_widths, n_dia = self._width_lut.shape[0], len(self._data.mie["Do"])
         max_ite = 10
+        path_lengths = utils.path_lengths_from_ground(self._data.height_vector)
         for ind in zip(*drizzle_ind, strict=True):
             for _ in range(max_ite):
                 lut_ind = self._find_lut_indices(ind, dia_init, n_dia, n_widths)
@@ -264,7 +265,7 @@ class DrizzleSolver:
                     break
                 self._dia_init[ind] = dia
             beta_factor = np.exp(
-                2 * self.params["S"][ind] * self._data.beta[ind] * self._data.dheight,
+                2 * self.params["S"][ind] * self._data.beta[ind] * path_lengths[ind[-1]]
             )
             self.params["beta_corr"][ind[0], (ind[-1] + 1) :] *= beta_factor
 

cloudnetpy/products/ier.py

@@ -5,6 +5,7 @@ from numpy import ma
 
 from cloudnetpy import constants, output, utils
 from cloudnetpy.metadata import MetaData
+from cloudnetpy.products.iwc import DEFINITIONS as IWC_DEFINITION
 from cloudnetpy.products.product_tools import IceClassification, IceSource
 
 
@@ -57,11 +58,10 @@ def generate_ier(
     product = "ier"
     with IerSource(categorize_file, product) as ier_source:
         ice_classification = IceClassification(categorize_file)
-        ier_source.append_main_variable_including_rain(ice_classification)
-        ier_source.append_main_variable(ice_classification)
+        ier_source.append_icy_data(ice_classification)
         ier_source.convert_units()
         ier_source.append_status(ice_classification)
-        ier_source.append_ier_error(ice_classification)
+        ier_source.append_ier_error()
         date = ier_source.get_date()
         attributes = output.add_time_attribute(IER_ATTRIBUTES, date)
         attributes = _add_ier_comment(attributes, ier_source)
@@ -74,12 +74,10 @@ class IerSource(IceSource):
 
     def convert_units(self) -> None:
         """Convert um to m."""
-        for prod in ("ier", "ier_inc_rain"):
-            self.data[prod].data[:] /= 1e6
+        self.data["ier"].data[:] /= 1e6
 
-    def append_ier_error(self, ice_classification: IceClassification) -> None:
-        error = ma.copy(self.data[f"{self.product}_inc_rain"][:])
-        error[ice_classification.ice_above_rain] = ma.masked
+    def append_ier_error(self) -> None:
+        error = ma.copy(self.data[f"{self.product}"][:])
         error = error * np.sqrt(0.4**2 + 0.4**2)
         self.append_data(error, f"{self.product}_error")
 
@@ -105,9 +103,7 @@ def _add_ier_comment(attributes: dict, ier: IerSource) -> dict:
         "data has diagnosed that the radar echo is due to ice, but note\n"
         "that in some cases supercooled drizzle will erroneously be identified\n"
         "as ice. Missing data indicates either that ice cloud was present but it was\n"
-        "only detected by the lidar so its ice water content could not be estimated,\n"
-        "or than there was rain below the ice associated with uncertain attenuation\n"
-        "of the reflectivities in the ice.\n",
+        "only detected by the lidar so its ice water content could not be estimated."
     )
     return attributes
 
@@ -122,37 +118,9 @@ COMMENTS = {
         "This variable describes whether a retrieval was performed\n"
         "for each pixel, and its associated quality."
     ),
-    "ier_inc_rain": (
-        "This variable is the same as ier but it also contains ier values\n"
-        "above rain. The ier values above rain have been severely affected\n"
-        "by attenuation and should be used when the effect of attenuation\n"
-        "is being studied."
-    ),
 }
 
-DEFINITIONS = {
-    "ier_retrieval_status": utils.status_field_definition(
-        {
-            0: """No ice present.""",
-            1: """Reliable retrieval.""",
-            2: """Unreliable retrieval due to uncorrected attenuation from
-                  liquid water below the ice (no liquid water path measurement
-                  available).""",
-            3: """Retrieval performed but radar corrected for liquid attenuation
-                  using radiometer liquid water path which is not always
-                  accurate.""",
-            4: """Ice detected only by the lidar.""",
-            5: """Ice detected by radar but rain below so no retrieval performed
-                  due to very uncertain attenuation.""",
-            6: """Clear sky above rain wet-bulb temperature less than 0degC: if
-                  rain attenuation were strong then ice could be present but
-                  undetected.""",
-            7: """Drizzle or rain that would have been classified as ice if the
-                  wet-bulb temperature were less than 0degC: may be ice if
-                  temperature is in error.""",
-        }
-    ),
-}
+DEFINITIONS = {"ier_retrieval_status": IWC_DEFINITION["iwc_retrieval_status"]}
 
 IER_ATTRIBUTES = {
     "ier": MetaData(
@@ -160,11 +128,6 @@ IER_ATTRIBUTES = {
         units="m",
         ancillary_variables="ier_error",
     ),
-    "ier_inc_rain": MetaData(
-        long_name="Ice effective radius including rain",
-        units="m",
-        comment=COMMENTS["ier_inc_rain"],
-    ),
     "ier_error": MetaData(
         long_name="Random error in ice effective radius",
         units="m",