cloudnetpy 1.55.20__py3-none-any.whl → 1.55.22__py3-none-any.whl

cloudnetpy/instruments/ceilometer.py

@@ -1,5 +1,5 @@
 import logging
-from typing import NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 
 import numpy as np
 from numpy import ma
@@ -8,9 +8,11 @@ from scipy.ndimage import gaussian_filter
 from cloudnetpy import utils
 from cloudnetpy.cloudnetarray import CloudnetArray
 from cloudnetpy.exceptions import ValidTimeStampError
-from cloudnetpy.instruments.instruments import Instrument
 from cloudnetpy.utils import Epoch
 
+if TYPE_CHECKING:
+    from cloudnetpy.instruments.instruments import Instrument
+
 
 class NoiseParam(NamedTuple):
     """Noise parameters. Values are weakly instrument-dependent."""
@@ -22,8 +24,8 @@ class NoiseParam(NamedTuple):
 class Ceilometer:
     """Base class for all types of ceilometers and pollyxt."""
 
-    def __init__(self, noise_param: NoiseParam = NoiseParam()):
-        self.noise_param = noise_param
+    def __init__(self, noise_param: NoiseParam | None = None):
+        self.noise_param = noise_param or NoiseParam()
         self.data: dict = {}  # Need to contain 'beta_raw', 'range' and 'time'
         self.metadata: dict = {}  # Need to contain 'date' as ('yyyy', 'mm', 'dd')
         self.expected_date: str | None = None
@@ -36,10 +38,15 @@ class Ceilometer:
         self,
         array: np.ndarray,
         snr_limit: int = 5,
+        *,
         range_corrected: bool = True,
     ) -> np.ndarray:
         """Screens noise from lidar variable."""
-        noisy_data = NoisyData(self.data, self.noise_param, range_corrected)
+        noisy_data = NoisyData(
+            self.data,
+            self.noise_param,
+            range_corrected=range_corrected,
+        )
         if (
             self.instrument is not None
             and getattr(self.instrument, "model", "").lower() == "ct25k"
@@ -47,40 +54,48 @@ class Ceilometer:
             n_negatives = 20
         else:
             n_negatives = 5
-        array_screened = noisy_data.screen_data(
-            array, snr_limit=snr_limit, n_negatives=n_negatives
+        return noisy_data.screen_data(
+            array,
+            snr_limit=snr_limit,
+            n_negatives=n_negatives,
         )
-        return array_screened
 
     def calc_beta_smooth(
         self,
         beta: np.ndarray,
         snr_limit: int = 5,
+        *,
         range_corrected: bool = True,
     ) -> np.ndarray:
-        noisy_data = NoisyData(self.data, self.noise_param, range_corrected)
+        noisy_data = NoisyData(
+            self.data,
+            self.noise_param,
+            range_corrected=range_corrected,
+        )
         beta_raw = ma.copy(self.data["beta_raw"])
         cloud_ind, cloud_values, cloud_limit = _estimate_clouds_from_beta(beta)
         beta_raw[cloud_ind] = cloud_limit
         sigma = calc_sigma_units(self.data["time"], self.data["range"])
         beta_raw_smooth = gaussian_filter(beta_raw, sigma)
         beta_raw_smooth[cloud_ind] = cloud_values
-        beta_smooth = noisy_data.screen_data(
-            beta_raw_smooth, is_smoothed=True, snr_limit=snr_limit
+        return noisy_data.screen_data(
+            beta_raw_smooth,
+            is_smoothed=True,
+            snr_limit=snr_limit,
         )
-        return beta_smooth
 
-    def prepare_data(self):
+    def prepare_data(self) -> None:
         """Add common additional data / metadata and convert into CloudnetArrays."""
         zenith_angle = self.data["zenith_angle"]
         self.data["height"] = np.array(
             self.site_meta["altitude"]
-            + utils.range_to_height(self.data["range"], zenith_angle)
+            + utils.range_to_height(self.data["range"], zenith_angle),
         )
         for key in ("time", "range"):
             self.data[key] = np.array(self.data[key])
-        assert self.instrument is not None
-        assert self.instrument.wavelength is not None
+        if self.instrument is None or self.instrument.wavelength is None:
+            msg = "Instrument wavelength not defined"
+            raise RuntimeError(msg)
         self.data["wavelength"] = float(self.instrument.wavelength)
         for key in ("latitude", "longitude", "altitude"):
             if key in self.site_meta:
@@ -92,37 +107,42 @@ class Ceilometer:
         self.date = utils.seconds2date(self.data["time"][0], epoch=epoch)[:3]
         self.data["time"] = utils.seconds2hours(self.data["time"])
 
-    def data_to_cloudnet_arrays(self):
+    def data_to_cloudnet_arrays(self) -> None:
         for key, array in self.data.items():
             self.data[key] = CloudnetArray(array, key)
 
-    def screen_depol(self):
+    def screen_depol(self) -> None:
         key = "depolarisation"
         if key in self.data:
             self.data[key][self.data[key] <= 0] = ma.masked
             self.data[key][self.data[key] > 1] = ma.masked
 
-    def screen_invalid_values(self):
-        for key in self.data.keys():
+    def screen_invalid_values(self) -> None:
+        for key in self.data:
             try:
                 if self.data[key][:].ndim == 2:
                     self.data[key] = ma.masked_invalid(self.data[key])
             except (IndexError, TypeError):
                 continue
 
-    def add_snr_info(self, key: str, snr_limit: float):
+    def add_snr_info(self, key: str, snr_limit: float) -> None:
         if key in self.data:
             self.data[key].comment += f" SNR threshold applied: {snr_limit}."
 
-    def check_beta_raw_shape(self):
+    def check_beta_raw_shape(self) -> None:
         beta_raw = self.data["beta_raw"]
         if beta_raw.ndim != 2 or (beta_raw.shape[0] == 1 or beta_raw.shape[1] == 1):
-            raise ValidTimeStampError(f"Invalid beta_raw shape: {beta_raw.shape}")
+            msg = f"Invalid beta_raw shape: {beta_raw.shape}"
+            raise ValidTimeStampError(msg)
 
 
 class NoisyData:
     def __init__(
-        self, data: dict, noise_param: NoiseParam, range_corrected: bool = True
+        self,
+        data: dict,
+        noise_param: NoiseParam,
+        *,
+        range_corrected: bool = True,
     ):
         self.data = data
         self.noise_param = noise_param
@@ -132,20 +152,22 @@ class NoisyData:
         self,
         data_in: np.ndarray,
         snr_limit: float = 5,
+        n_negatives: int = 5,
+        *,
         is_smoothed: bool = False,
         keep_negative: bool = False,
         filter_fog: bool = True,
         filter_negatives: bool = True,
         filter_snr: bool = True,
-        n_negatives: int = 5,
     ) -> np.ndarray:
         data = ma.copy(data_in)
         self._calc_range_uncorrected(data)
         noise = _estimate_background_noise(data)
-        noise = self._adjust_noise(noise, is_smoothed)
+        noise = self._adjust_noise(noise, is_smoothed=is_smoothed)
         if filter_negatives is True:
             is_negative = self._mask_low_values_above_consequent_negatives(
-                data, n_negatives=n_negatives
+                data,
+                n_negatives=n_negatives,
             )
             noise[is_negative] = 1e-12
         if filter_fog is True:
@@ -153,18 +175,26 @@ class NoisyData:
             self._clean_fog_profiles(data, is_fog)
             noise[is_fog] = 1e-12
         if filter_snr is True:
-            data = self._remove_noise(data, noise, keep_negative, snr_limit)
+            data = self._remove_noise(
+                data,
+                noise,
+                keep_negative=keep_negative,
+                snr_limit=snr_limit,
+            )
         self._calc_range_corrected(data)
         return data
 
-    def _adjust_noise(self, noise: np.ndarray, is_smoothed: bool) -> np.ndarray:
+    def _adjust_noise(self, noise: np.ndarray, *, is_smoothed: bool) -> np.ndarray:
         noise_min = (
             self.noise_param.noise_smooth_min
             if is_smoothed is True
             else self.noise_param.noise_min
         )
         noise_below_threshold = noise < noise_min
-        logging.debug(f"Adjusted noise of {sum(noise_below_threshold)} profiles")
+        logging.debug(
+            "Adjusted noise of %s profiles",
+            sum(np.array(noise_below_threshold)),
+        )
         noise[noise_below_threshold] = noise_min
         return noise
 
@@ -180,12 +210,13 @@ class NoisyData:
         n_consequent_negatives = utils.cumsumr(negative_data, axis=1)
         time_indices, alt_indices = np.where(n_consequent_negatives > n_negatives)
         alt_indices += n_skip_lowest
-        for time_ind, alt_ind in zip(time_indices, alt_indices):
+        for time_ind, alt_ind in zip(time_indices, alt_indices, strict=True):
             profile = data[time_ind, alt_ind:]
             profile[profile < threshold] = ma.masked
         cleaned_time_indices = np.unique(time_indices)
         logging.debug(
-            f"Cleaned {len(cleaned_time_indices)} profiles with negative filter"
+            "Cleaned %s profiles with negative filter",
+            len(cleaned_time_indices),
         )
         return cleaned_time_indices
 
@@ -197,17 +228,19 @@ class NoisyData:
     ) -> np.ndarray:
         """Finds saturated (usually fog) profiles from beta_raw."""
         signal_sum = ma.sum(
-            ma.abs(self.data["beta_raw"][:, :n_gates_for_signal_sum]), axis=1
+            ma.abs(self.data["beta_raw"][:, :n_gates_for_signal_sum]),
+            axis=1,
         )
         variance = _calc_var_from_top_gates(self.data["beta_raw"])
         is_fog = (signal_sum > signal_sum_threshold) | (variance < variance_threshold)
-        logging.debug(f"Cleaned {sum(is_fog)} profiles with fog filter")
+        logging.debug("Cleaned %s profiles with fog filter", sum(is_fog))
         return is_fog
 
     def _remove_noise(
         self,
         array: np.ndarray,
         noise: np.ndarray,
+        *,
         keep_negative: bool,
         snr_limit: float,
     ) -> np.ndarray:
@@ -236,7 +269,8 @@ class NoisyData:
         if self.range_corrected is False:
             alt_limit = 2400.0
             logging.warning(
-                f"Raw data not range-corrected, correcting below {alt_limit} m"
+                "Raw data not range-corrected, correcting below %s m",
+                alt_limit,
             )
         else:
             alt_limit = 1e12
@@ -249,7 +283,9 @@ class NoisyData:
 
     @staticmethod
     def _clean_fog_profiles(
-        data: np.ndarray, is_fog: np.ndarray, threshold: float = 2e-6
+        data: np.ndarray,
+        is_fog: np.ndarray,
+        threshold: float = 2e-6,
     ) -> None:
         """Removes values in saturated (e.g. fog) profiles above peak."""
         for time_ind in np.where(is_fog)[0]:
@@ -281,18 +317,21 @@ def calc_sigma_units(
     how many steps in time and height corresponds to this smoothing.
 
     Args:
+    ----
         time_vector: 1D vector (fraction hour).
         range_los: 1D vector (m).
         sigma_minutes: Smoothing in minutes.
         sigma_metres: Smoothing in metres.
 
     Returns:
+    -------
         tuple: Two element tuple containing number of steps in time and height to
             achieve wanted smoothing.
 
     """
     if len(time_vector) == 0 or np.max(time_vector) > 24:
-        raise ValueError("Invalid time vector")
+        msg = "Invalid time vector"
+        raise ValueError(msg)
     minutes_in_hour = 60
     time_step = utils.mdiff(time_vector) * minutes_in_hour
     alt_step = utils.mdiff(range_los)

cloudnetpy/instruments/cl61d.py

@@ -11,7 +11,10 @@ class Cl61d(NcLidar):
     """Class for Vaisala CL61d ceilometer."""
 
     def __init__(
-        self, file_name: str, site_meta: dict, expected_date: str | None = None
+        self,
+        file_name: str,
+        site_meta: dict,
+        expected_date: str | None = None,
     ):
         super().__init__()
         self.file_name = file_name
@@ -31,7 +34,9 @@ class Cl61d(NcLidar):
             self.dataset = None
 
     def _fetch_lidar_variables(self, calibration_factor: float | None = None) -> None:
-        assert self.dataset is not None
+        if self.dataset is None:
+            msg = "No dataset found"
+            raise RuntimeError(msg)
         beta_raw = self.dataset.variables["beta_att"][:]
         if calibration_factor is None:
             logging.warning("Using default calibration factor")
@@ -44,5 +49,5 @@ class Cl61d(NcLidar):
         )
         self.data["depolarisation_raw"] = self.data["depolarisation"].copy()
 
-    def _fetch_attributes(self):
+    def _fetch_attributes(self) -> None:
         self.serial_number = getattr(self.dataset, "instrument_serial_number", None)

cloudnetpy/instruments/cloudnet_instrument.py

@@ -24,7 +24,8 @@ class CloudnetInstrument:
                 value = self.site_meta[key]
             # From source global attributes (MIRA):
             elif isinstance(self.dataset, netCDF4.Dataset) and hasattr(
-                self.dataset, key.capitalize()
+                self.dataset,
+                key.capitalize(),
             ):
                 value = self.parse_global_attribute_numeral(key.capitalize())
             # From source data (BASTA / RPG):

cloudnetpy/instruments/copernicus.py

@@ -1,5 +1,6 @@
 """Module for reading raw cloud radar data."""
 import os
+import tempfile
 from tempfile import TemporaryDirectory
 
 import numpy as np
@@ -20,6 +21,7 @@ def copernicus2nc(
     """Converts 'Copernicus' cloud radar data into Cloudnet Level 1b netCDF file.
 
     Args:
+    ----
         raw_files: Input file name or folder containing multiple input files.
         output_file: Output filename.
         site_meta: Dictionary containing information about the site. Required key
@@ -29,12 +31,15 @@ def copernicus2nc(
         date: Expected date as YYYY-MM-DD of all profiles in the file.
 
     Returns:
+    -------
         UUID of the generated file.
 
     Raises:
+    ------
         ValidTimeStampError: No valid timestamps found.
 
     Examples:
+    --------
           >>> from cloudnetpy.instruments import copernicus2nc
           >>> site_meta = {'name': 'Chilbolton'}
           >>> copernicus2nc('raw_radar.nc', 'radar.nc', site_meta)
@@ -57,13 +62,20 @@ def copernicus2nc(
 
     with TemporaryDirectory() as temp_dir:
         if os.path.isdir(raw_files):
-            nc_filename = f"{temp_dir}/tmp.nc"
-            valid_filenames = utils.get_sorted_filenames(raw_files, ".nc")
-            valid_filenames = utils.get_files_with_common_range(valid_filenames)
-            variables = list(keymap.keys())
-            concat_lib.concatenate_files(
-                valid_filenames, nc_filename, variables=variables
-            )
+            with tempfile.NamedTemporaryFile(
+                dir=temp_dir,
+                suffix=".nc",
+                delete=False,
+            ) as temp_file:
+                nc_filename = temp_file.name
+                valid_filenames = utils.get_sorted_filenames(raw_files, ".nc")
+                valid_filenames = utils.get_files_with_common_range(valid_filenames)
+                variables = list(keymap.keys())
+                concat_lib.concatenate_files(
+                    valid_filenames,
+                    nc_filename,
+                    variables=variables,
+                )
         else:
             nc_filename = raw_files
 
@@ -90,14 +102,14 @@ def copernicus2nc(
             copernicus.add_height()
         attributes = output.add_time_attribute(ATTRIBUTES, copernicus.date)
         output.update_attributes(copernicus.data, attributes)
-        uuid = output.save_level1b(copernicus, output_file, uuid)
-        return uuid
+        return output.save_level1b(copernicus, output_file, uuid)
 
 
 class Copernicus(ChilboltonRadar):
     """Class for Copernicus raw radar data. Child of ChilboltonRadar().
 
     Args:
+    ----
         full_path: Filename of a daily Copernicus .nc NetCDF file.
         site_meta: Site properties in a dictionary. Required keys are: `name`.
 
@@ -107,16 +119,17 @@ class Copernicus(ChilboltonRadar):
         super().__init__(full_path, site_meta)
         self.instrument = COPERNICUS
 
-    def calibrate_reflectivity(self):
+    def calibrate_reflectivity(self) -> None:
         default_offset = -146.8  # TODO: check this value
         calibration_factor = self.site_meta.get("calibration_offset", default_offset)
         self.data["Zh"].data[:] += calibration_factor
         self.append_data(np.array(calibration_factor), "calibration_offset")
 
-    def mask_corrupted_values(self):
+    def mask_corrupted_values(self) -> None:
         """Experimental masking of corrupted Copernicus data.
 
-        Notes:
+        Notes
+        -----
             This method is based on a few days of test data only. Should be improved
             and tested more carefully in the future.
         """
@@ -125,13 +138,13 @@ class Copernicus(ChilboltonRadar):
             ind = np.where(np.abs(self.data[key][:]) > value)
             self.data["v"].mask_indices(ind)
 
-    def fix_range_offset(self, site_meta: dict):
+    def fix_range_offset(self, site_meta: dict) -> None:
         """Fixes range offset."""
         range_offset = site_meta.get("range_offset", 0)
         self.data["range"].data[:] += range_offset
         self.append_data(np.array(range_offset, dtype=float), "range_offset")
 
-    def screen_negative_ranges(self):
+    def screen_negative_ranges(self) -> None:
         """Screens negative range values."""
         valid_ind = np.where(self.data["range"][:] >= 0)[0]
         for key, cloudnet_array in self.data.items():

cloudnetpy/instruments/disdrometer/common.py

@@ -6,6 +6,7 @@ from numpy import ma
 
 from cloudnetpy import utils
 from cloudnetpy.cloudnetarray import CloudnetArray
+from cloudnetpy.constants import MM_TO_M, SEC_IN_HOUR, SEC_IN_MINUTE
 from cloudnetpy.exceptions import DisdrometerDataError, ValidTimeStampError
 from cloudnetpy.instruments.cloudnet_instrument import CloudnetInstrument
 from cloudnetpy.instruments.vaisala import values_to_dict
@@ -27,14 +28,13 @@ class Disdrometer(CloudnetInstrument):
         self.n_velocity: int = 0
         self._file_data = self._read_file()
 
-    def convert_units(self):
-        mm_to_m = 1e3
-        mmh_to_ms = 3600 * mm_to_m
+    def convert_units(self) -> None:
+        mmh_to_ms = SEC_IN_HOUR / MM_TO_M
         c_to_k = 273.15
         self._convert_data(("rainfall_rate_1min_total",), mmh_to_ms)
         self._convert_data(("rainfall_rate",), mmh_to_ms)
         self._convert_data(("rainfall_rate_1min_solid",), mmh_to_ms)
-        self._convert_data(("diameter", "diameter_spread", "diameter_bnds"), mm_to_m)
+        self._convert_data(("diameter", "diameter_spread", "diameter_bnds"), 1e3)
         self._convert_data(("V_sensor_supply",), 10)
         self._convert_data(("I_mean_laser",), 100)
         self._convert_data(("T_sensor",), c_to_k, method="add")
@@ -42,12 +42,12 @@ class Disdrometer(CloudnetInstrument):
         self._convert_data(("T_ambient",), c_to_k, method="add")
         self._convert_data(("T_laser_driver",), c_to_k, method="add")
 
-    def add_meta(self):
-        valid_keys = ("latitude", "longitude", "altitude")
+    def add_meta(self) -> None:
+        valid_names = ("latitude", "longitude", "altitude")
         for key, value in self.site_meta.items():
-            key = key.lower()
-            if key in valid_keys:
-                self.data[key] = CloudnetArray(float(value), key)
+            name = key.lower()
+            if name in valid_names:
+                self.data[name] = CloudnetArray(float(value), name)
 
     def validate_date(self, expected_date: str) -> None:
         valid_ind = []
@@ -95,7 +95,7 @@ class Disdrometer(CloudnetInstrument):
         return data
 
     def _append_data(self, column_and_key: list) -> None:
-        indices, keys = zip(*column_and_key)
+        indices, keys = zip(*column_and_key, strict=True)
         data = self._parse_useful_data(indices)
         data_dict = values_to_dict(keys, data)
         for key in keys:
@@ -108,7 +108,8 @@ class Disdrometer(CloudnetInstrument):
                     float_array = ma.append(float_array, float(value_str))
                 except ValueError:
                     logging.warning(
-                        f"Invalid character: {value_str}, masking a data point"
+                        "Invalid character: %s, masking a data point",
+                        value_str,
                     )
                     float_array = ma.append(float_array, invalid_value)
             float_array[float_array == invalid_value] = ma.masked
@@ -131,12 +132,12 @@ class Disdrometer(CloudnetInstrument):
             first_id = data_dict["_serial_number"][0]
             for sensor_id in data_dict["_serial_number"]:
                 if sensor_id != first_id:
-                    raise DisdrometerDataError(
-                        "Multiple serial numbers are not supported"
-                    )
+                    msg = "Multiple serial numbers are not supported"
+                    raise DisdrometerDataError(msg)
+
             self.serial_number = first_id
 
-    def _parse_useful_data(self, indices: list) -> list:
+    def _parse_useful_data(self, indices: tuple) -> list:
         data = []
         for row in self._file_data["scalars"]:
             useful_data = [row[ind] for ind in indices]
@@ -149,10 +150,12 @@ class Disdrometer(CloudnetInstrument):
             if self.source == PARSIVEL:
                 raise NotImplementedError
             hour, minute, sec = timestamp.split(":")
-            seconds.append(int(hour) * 3600 + int(minute) * 60 + int(sec))
+            seconds.append(
+                int(hour) * SEC_IN_HOUR + int(minute) * SEC_IN_MINUTE + int(sec)
+            )
         return CloudnetArray(utils.seconds2hours(np.array(seconds)), "time")
 
-    def _convert_data(self, keys: tuple, value: float, method: str = "divide"):
+    def _convert_data(self, keys: tuple, value: float, method: str = "divide") -> None:
         for key in keys:
             if key in self.data:
                 if method == "divide":
@@ -162,14 +165,15 @@ class Disdrometer(CloudnetInstrument):
                 else:
                     raise ValueError
 
-    def _append_spectra(self):
+    def _append_spectra(self) -> None:
         array = ma.masked_all(
-            (len(self._file_data["scalars"]), self.n_diameter, self.n_velocity)
+            (len(self._file_data["scalars"]), self.n_diameter, self.n_velocity),
         )
         for time_ind, row in enumerate(self._file_data["spectra"]):
             values = _parse_int(row)
             array[time_ind, :, :] = np.reshape(
-                values, (self.n_diameter, self.n_velocity)
+                values,
+                (self.n_diameter, self.n_velocity),
             )
         self.data["data_raw"] = CloudnetArray(
             array,
@@ -180,7 +184,12 @@ class Disdrometer(CloudnetInstrument):
 
     @classmethod
     def store_vectors(
-        cls, data, n_values: list, spreads: list, name: str, start: float = 0.0
+        cls,
+        data,
+        n_values: list,
+        spreads: list,
+        name: str,
+        start: float = 0.0,
     ):
         mid, bounds, spread = cls._create_vectors(n_values, spreads, start)
         data[name] = CloudnetArray(mid, name, dimensions=(name,))
@@ -191,12 +200,14 @@ class Disdrometer(CloudnetInstrument):
 
     @staticmethod
     def _create_vectors(
-        n_values: list[int], spreads: list[float], start: float
+        n_values: list[int],
+        spreads: list[float],
+        start: float,
     ) -> tuple:
         mid_value: np.ndarray = np.array([])
         lower_limit: np.ndarray = np.array([])
         upper_limit: np.ndarray = np.array([])
-        for spread, n in zip(spreads, n_values):
+        for spread, n in zip(spreads, n_values, strict=True):
             lower = np.linspace(start, start + (n - 1) * spread, n)
             upper = lower + spread
             lower_limit = np.append(lower_limit, lower)
@@ -208,7 +219,7 @@ class Disdrometer(CloudnetInstrument):
         return mid_value, bounds, spread
 
 
-def _format_thies_date(date: str):
+def _format_thies_date(date: str) -> str:
     day, month, year = date.split(".")
     year = f"20{year}"
     return f"{year}-{month.zfill(2)}-{day.zfill(2)}"
@@ -218,9 +229,9 @@ def _parse_int(row: np.ndarray) -> np.ndarray:
     values = ma.masked_all((len(row),))
     for ind, value in enumerate(row):
         try:
-            value = int(value)
-            if value != 0:
-                values[ind] = value
+            value_int = int(value)
+            if value_int != 0:
+                values[ind] = value_int
         except ValueError:
             pass
     return values
@@ -262,7 +273,9 @@ ATTRIBUTES = {
         units="m s-1",
     ),
     "rainfall_rate": MetaData(
-        long_name="Rainfall rate", units="m s-1", standard_name="rainfall_rate"
+        long_name="Rainfall rate",
+        units="m s-1",
+        standard_name="rainfall_rate",
     ),
     "rainfall_rate_1min_solid": MetaData(
         long_name="Solid precipitation rate",
@@ -288,7 +301,8 @@ ATTRIBUTES = {
     "interval": MetaData(long_name="Length of measurement interval", units="s"),
     "sig_laser": MetaData(long_name="Signal amplitude of the laser strip", units="1"),
     "n_particles": MetaData(
-        long_name="Number of particles in time interval", units="1"
+        long_name="Number of particles in time interval",
+        units="1",
     ),
     "T_sensor": MetaData(
         long_name="Temperature in the sensor housing",
@@ -326,7 +340,8 @@ ATTRIBUTES = {
         units="1",
     ),
     "kinetic_energy": MetaData(
-        long_name="Kinetic energy of the hydrometeors", units="J m-2 h-1"
+        long_name="Kinetic energy of the hydrometeors",
+        units="J m-2 h-1",
     ),
     # Thies-specific:
     "T_ambient": MetaData(long_name="Ambient temperature", units="K"),
@@ -397,12 +412,16 @@ ATTRIBUTES = {
         units="1",
     ),
     "status_laser": MetaData(
-        long_name="Status of laser", comment="0 = OK/on , 1 = Off", units="1"
+        long_name="Status of laser",
+        comment="0 = OK/on , 1 = Off",
+        units="1",
     ),
     "measurement_quality": MetaData(long_name="Measurement quality", units="%"),
     "maximum_hail_diameter": MetaData(long_name="Maximum hail diameter", units="mm"),
     "static_signal": MetaData(
-        long_name="Static signal", comment="0 = OK, 1 = ERROR", units="1"
+        long_name="Static signal",
+        comment="0 = OK, 1 = ERROR",
+        units="1",
     ),
     "T_laser_driver": MetaData(long_name="Temperature of laser driver", units="K"),
     "I_mean_laser": MetaData(long_name="Mean value of laser current", units="mA"),