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

cloudnetpy/categorize/model.py

@@ -14,11 +14,13 @@ class Model(DataSource):
     """Model class, child of DataSource.
 
     Args:
+    ----
         model_file: File name of the NWP model file.
         alt_site: Altitude of the site above mean sea level (m).
 
     Attributes:
-        type (str): Model type, e.g. 'gdas1' or 'ecwmf'.
+    ----------
+        source_type (str): Model type, e.g. 'gdas1' or 'ecwmf'.
         model_heights (ndarray): 2-D array of model heights (one for each time
             step).
         mean_height (ndarray): Mean of *model_heights*.
@@ -38,11 +40,11 @@ class Model(DataSource):
         "specific_saturated_gas_atten",
         "specific_liquid_atten",
     )
-    fields_sparse = fields_dense + ("q", "uwind", "vwind")
+    fields_sparse = (*fields_dense, "q", "uwind", "vwind")
 
     def __init__(self, model_file: str, alt_site: float):
         super().__init__(model_file)
-        self.type = _find_model_type(model_file)
+        self.source_type = _find_model_type(model_file)
         self.model_heights = self._get_model_heights(alt_site)
         self.mean_height = _calc_mean_height(self.model_heights)
         self.height: np.ndarray
@@ -54,6 +56,7 @@ class Model(DataSource):
         """Interpolates model variables to common height grid.
 
         Args:
+        ----
             wl_band: Integer denoting the approximate wavelength band of the
                 cloud radar (0 = ~35.5 GHz, 1 = ~94 GHz).
 
@@ -61,7 +64,9 @@ class Model(DataSource):
 
         def _interpolate_variable(data_in: ma.MaskedArray) -> CloudnetArray:
             datai = ma.zeros((len(self.time), len(self.mean_height)))
-            for ind, (alt, prof) in enumerate(zip(self.model_heights, data_in)):
+            for ind, (alt, prof) in enumerate(
+                zip(self.model_heights, data_in, strict=True),
+            ):
                 if prof.mask.all():
                     datai[ind, :] = ma.masked
                 else:
@@ -78,14 +83,21 @@ class Model(DataSource):
             self.data_sparse[key] = _interpolate_variable(data)
 
     def interpolate_to_grid(
-        self, time_grid: np.ndarray, height_grid: np.ndarray
-    ) -> None:
+        self,
+        time_grid: np.ndarray,
+        height_grid: np.ndarray,
+    ) -> list:
         """Interpolates model variables to Cloudnet's dense time / height grid.
 
         Args:
+        ----
             time_grid: The target time array (fraction hour).
             height_grid: The target height array (m).
 
+        Returns:
+        -------
+            Indices fully masked profiles.
+
         """
         for key in self.fields_dense:
             array = self.data_sparse[key][:]
@@ -93,9 +105,14 @@ class Model(DataSource):
             if valid_profiles < 2:
                 raise ModelDataError
             self.data_dense[key] = utils.interpolate_2d_mask(
-                self.time, self.mean_height, array, time_grid, height_grid
+                self.time,
+                self.mean_height,
+                array,
+                time_grid,
+                height_grid,
             )
         self.height = height_grid
+        return utils.find_masked_profiles_indices(self.data_dense["temperature"])
 
     def calc_wet_bulb(self) -> None:
         """Calculates wet-bulb temperature in dense grid."""
@@ -116,7 +133,8 @@ class Model(DataSource):
         try:
             model_heights = self.dataset.variables["height"]
         except KeyError as err:
-            raise ModelDataError("No 'height' variable in the model file.") from err
+            msg = "No 'height' variable in the model file."
+            raise ModelDataError(msg) from err
         return self.to_m(model_heights) + alt_site
 
 
@@ -131,7 +149,8 @@ def _find_model_type(file_name: str) -> str:
     for key in possible_keys:
         if key in file_name:
             return key
-    raise ValueError("Unknown model type")
+    msg = "Unknown model type"
+    raise ValueError(msg)
 
 
 def _find_number_of_valid_profiles(array: np.ndarray) -> int:

cloudnetpy/categorize/mwr.py

@@ -2,6 +2,7 @@
 import numpy as np
 
 from cloudnetpy import utils
+from cloudnetpy.constants import G_TO_KG
 from cloudnetpy.datasource import DataSource
 
 
@@ -9,6 +10,7 @@ class Mwr(DataSource):
     """Microwave radiometer class, child of DataSource.
 
     Args:
+    ----
          full_path: Cloudnet Level 1b mwr file.
 
     """
@@ -22,6 +24,7 @@ class Mwr(DataSource):
         """Approximates lwp and its error in a grid using mean.
 
         Args:
+        ----
             time_grid: 1D target time grid.
 
         """
@@ -34,8 +37,7 @@ class Mwr(DataSource):
 
     def _init_lwp_error(self) -> None:
         random_error, bias = 0.25, 20
-        g2kg = 1e-3
-        lwp_error = utils.l2norm(self.data["lwp"][:] * random_error, bias * g2kg)
+        lwp_error = utils.l2norm(self.data["lwp"][:] * random_error, bias * G_TO_KG)
         self.append_data(lwp_error, "lwp_error", units="kg m-2")
         self.data["lwp_error"].comment = (
             "This variable is a rough estimate of the one-standard-deviation\n"

cloudnetpy/categorize/radar.py

@@ -8,6 +8,7 @@ from scipy import constants
 
 from cloudnetpy import utils
 from cloudnetpy.categorize.classify import ClassificationResult
+from cloudnetpy.constants import SEC_IN_HOUR
 from cloudnetpy.datasource import DataSource
 
 
@@ -15,21 +16,24 @@ class Radar(DataSource):
     """Radar class, child of DataSource.
 
     Args:
+    ----
         full_path: Cloudnet Level 1 radar netCDF file.
 
     Attributes:
+    ----------
         radar_frequency (float): Radar frequency (GHz).
         folding_velocity (float): Radar's folding velocity (m/s).
         location (str): Location of the radar, copied from the global attribute
             `location` of the input file.
         sequence_indices (list): Indices denoting the different altitude
             regimes of the radar.
-        type (str): Type of the radar, copied from the global attribute
+        source_type (str): Type of the radar, copied from the global attribute
             `source` of the *radar_file*. Can be free form string but must
             include either 'rpg' or 'mira' denoting one of the two supported
             radars.
 
     See Also:
+    --------
         :func:`instruments.rpg2nc()`, :func:`instruments.mira2nc()`
 
     """
@@ -40,7 +44,7 @@ class Radar(DataSource):
         self.folding_velocity = self._get_folding_velocity()
         self.sequence_indices = self._get_sequence_indices()
         self.location = getattr(self.dataset, "location", "")
-        self.type = getattr(self.dataset, "source", "")
+        self.source_type = getattr(self.dataset, "source", "")
         self._init_data()
         self._init_sigma_v()
         self._get_folding_velocity_full()
@@ -49,6 +53,7 @@ class Radar(DataSource):
         """Rebins radar data in time using mean.
 
         Args:
+        ----
             time_new: Target time array as fraction hour. Updates *time* attribute.
 
         """
@@ -83,7 +88,7 @@ class Radar(DataSource):
 
         """
         good_ind = ~ma.getmaskarray(self.data["Z"][:]) & ~ma.getmaskarray(
-            self.data["v"][:]
+            self.data["v"][:],
         )
 
         if "width" in self.data:
@@ -121,15 +126,28 @@ class Radar(DataSource):
         if n_profiles_with_data < 300:
             return
         n_vertical = self._filter(
-            data, 1, min_coverage=0.5, z_limit=10, distance=4, n_blocks=100
+            data,
+            1,
+            min_coverage=0.5,
+            z_limit=10,
+            distance=4,
+            n_blocks=100,
         )
         n_horizontal = self._filter(
-            data, 0, min_coverage=0.3, z_limit=-30, distance=3, n_blocks=20
+            data,
+            0,
+            min_coverage=0.3,
+            z_limit=-30,
+            distance=3,
+            n_blocks=20,
         )
         if n_vertical > 0 or n_horizontal > 0:
             logging.debug(
-                f"Filtered {n_vertical} vertical and {n_horizontal} horizontal stripes "
-                f"from radar data using {variable}"
+                "Filtered %s vertical and %s horizontal stripes "
+                "from radar data using %s",
+                n_vertical,
+                n_horizontal,
+                variable,
             )
 
     def _filter(
@@ -162,7 +180,7 @@ class Radar(DataSource):
             threshold = distance * (q3 - q1) + q3
 
             indices = np.where(
-                (n_values > threshold) & (n_values > (min_coverage * data.shape[1]))
+                (n_values > threshold) & (n_values > (min_coverage * data.shape[1])),
             )[0]
             true_ind = [int(x) for x in (block_number * len_block + indices)]
             n_removed = len(indices)
@@ -184,10 +202,12 @@ class Radar(DataSource):
         """Corrects radar echo for liquid and gas attenuation.
 
         Args:
+        ----
             attenuations: 2-D attenuations due to atmospheric gases and liquid:
                 `radar_gas_atten`, `radar_liquid_atten`.
 
         References:
+        ----------
             The method is based on Hogan R. and O'Connor E., 2004,
             https://bit.ly/2Yjz9DZ and the original Cloudnet Matlab implementation.
 
@@ -198,7 +218,9 @@ class Radar(DataSource):
         self.append_data(z_corrected, "Z")
 
     def calc_errors(
-        self, attenuations: dict, classification: ClassificationResult
+        self,
+        attenuations: dict,
+        classification: ClassificationResult,
     ) -> None:
         """Calculates uncertainties of radar echo.
 
@@ -206,10 +228,12 @@ class Radar(DataSource):
         :class:`CloudnetArray` instances to `data` attribute.
 
         Args:
+        ----
             attenuations: 2-D attenuations due to atmospheric gases.
             classification: The :class:`ClassificationResult` instance.
 
         References:
+        ----------
             The method is based on Hogan R. and O'Connor E., 2004,
             https://bit.ly/2Yjz9DZ and the original Cloudnet Matlab implementation.
 
@@ -238,8 +262,7 @@ class Radar(DataSource):
             return z_error
 
         def _number_of_independent_pulses() -> float:
-            seconds_in_hour = 3600
-            dwell_time = utils.mdiff(self.time) * seconds_in_hour
+            dwell_time = utils.mdiff(self.time) * SEC_IN_HOUR
             return (
                 dwell_time
                 * self.radar_frequency
@@ -271,7 +294,7 @@ class Radar(DataSource):
         for key in ("time", "height", "radar_frequency"):
             self.append_data(np.array(getattr(self, key)), key)
 
-    def _init_data(self):
+    def _init_data(self) -> None:
         self.append_data(self.getvar("Zh"), "Z", units="dBZ")
         for key in ("v", "ldr", "width", "sldr", "rainfall_rate"):
             try:
@@ -281,13 +304,17 @@ class Radar(DataSource):
 
     def _init_sigma_v(self) -> None:
         """Initializes std of the velocity field. The std will be calculated
-        later when re-binning the data."""
+        later when re-binning the data.
+        """
         self.append_data(self.getvar("v"), "v_sigma")
 
     def _get_sequence_indices(self) -> list:
         """Mira has only one sequence and one folding velocity. RPG has
-        several sequences with different folding velocities."""
-        assert self.height is not None
+        several sequences with different folding velocities.
+        """
+        if self.height is None:
+            msg = "Height not found in the input file"
+            raise RuntimeError(msg)
         all_indices = np.arange(len(self.height))
         if not utils.isscalar(self.folding_velocity):
             starting_indices = self.getvar("chirp_start_indices")
@@ -300,18 +327,24 @@ class Radar(DataSource):
         if "prf" in self.dataset.variables:
             prf = self.getvar("prf")
             return _prf_to_folding_velocity(prf, self.radar_frequency)
-        raise RuntimeError("Unable to determine folding velocity")
+        msg = "Unable to determine folding velocity"
+        raise RuntimeError(msg)
 
-    def _get_folding_velocity_full(self):
+    def _get_folding_velocity_full(self) -> None:
         folding_velocity: list | np.ndarray = []
         if utils.isscalar(self.folding_velocity):
             folding_velocity = np.repeat(
-                self.folding_velocity, len(self.sequence_indices[0])
+                self.folding_velocity,
+                len(self.sequence_indices[0]),
             )
         else:
-            assert isinstance(folding_velocity, list)
-            assert isinstance(self.folding_velocity, np.ndarray)
-            for indices, velocity in zip(self.sequence_indices, self.folding_velocity):
+            folding_velocity = list(folding_velocity)
+            self.folding_velocity = np.array(self.folding_velocity)
+            for indices, velocity in zip(
+                self.sequence_indices,
+                self.folding_velocity,
+                strict=True,
+            ):
                 folding_velocity.append(np.repeat(velocity, len(indices)))
             folding_velocity = np.hstack(folding_velocity)
         self.append_data(folding_velocity, "nyquist_velocity")
@@ -319,4 +352,7 @@ class Radar(DataSource):
 
 def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> float:
     ghz_to_hz = 1e9
-    return float(prf * constants.c / (4 * radar_frequency * ghz_to_hz))
+    if len(prf) != 1:
+        msg = "Unable to determine folding velocity"
+        raise RuntimeError(msg)
+    return float(prf[0] * constants.c / (4 * radar_frequency * ghz_to_hz))

cloudnetpy/cloudnetarray.py

@@ -14,6 +14,7 @@ class CloudnetArray:
     """Stores netCDF4 variables, numpy arrays and scalars as CloudnetArrays.
 
     Args:
+    ----
         variable: The netCDF4 :class:`Variable` instance,
             numpy array (masked or regular), or scalar (float, int).
         name: Name of the variable.
@@ -25,7 +26,7 @@ class CloudnetArray:
 
     def __init__(
         self,
-        variable: netCDF4.Variable | np.ndarray | float | int,
+        variable: netCDF4.Variable | np.ndarray | float,
         name: str,
         units_from_user: str | None = None,
         dimensions: Sequence[str] | None = None,
@@ -58,10 +59,12 @@ class CloudnetArray:
         """Rebins `data` in time.
 
         Args:
+        ----
             time: 1D time array.
             time_new: 1D new time array.
 
         Returns:
+        -------
             Time indices without data.
 
         """
@@ -69,7 +72,8 @@ class CloudnetArray:
             self.data = utils.rebin_1d(time, self.data, time_new)
             bad_indices = list(np.where(self.data == ma.masked)[0])
         else:
-            assert isinstance(self.data, ma.MaskedArray)
+            if not isinstance(self.data, ma.MaskedArray):
+                self.data = ma.masked_array(self.data)
             self.data, bad_indices = utils.rebin_2d(time, self.data, time_new)
         return bad_indices
 
@@ -101,7 +105,7 @@ class CloudnetArray:
             return self.variable
         if isinstance(
             self.variable,
-            (int, float, np.float32, np.int8, np.float64, np.int32, np.uint16),
+            int | float | np.float32 | np.int8 | np.float64 | np.int32 | np.uint16,
         ):
             return np.array(self.variable)
         if isinstance(self.variable, str):
@@ -110,7 +114,8 @@ class CloudnetArray:
                 return np.array(numeric_value)
             except ValueError:
                 pass
-        raise ValueError(f"Incorrect CloudnetArray input: {self.variable}")
+        msg = f"Incorrect CloudnetArray input: {self.variable}"
+        raise ValueError(msg)
 
     def _init_units(self) -> str:
         return getattr(self.variable, "units", "")
@@ -134,7 +139,8 @@ class CloudnetArray:
         self._filter(utils.filter_x_pixels)
 
     def _filter(self, fun) -> None:
-        assert isinstance(self.data, ma.MaskedArray)
+        if not isinstance(self.data, ma.MaskedArray):
+            self.data = ma.masked_array(self.data)
         is_data = (~self.data.mask).astype(int)
         is_data_filtered = fun(is_data)
         self.data[is_data_filtered == 0] = ma.masked
@@ -143,14 +149,16 @@ class CloudnetArray:
         """Calculates std of radar velocity.
 
         Args:
+        ----
             time: 1D time array.
             time_new: 1D new time array.
 
         Notes:
+        -----
             The result is masked if the bin contains masked values.
         """
         data_as_float = self.data.astype(float)
-        assert isinstance(data_as_float, ma.MaskedArray)
+        data_as_float = ma.masked_array(data_as_float)
         self.data, _ = utils.rebin_2d(time, data_as_float, time_new, "std")
 
     def rebin_velocity(
@@ -163,6 +171,7 @@ class CloudnetArray:
         """Rebins Doppler velocity in polar coordinates.
 
         Args:
+        ----
             time: 1D time array.
             time_new: 1D new time array.
             folding_velocity: Folding velocity (m/s). Can be a float when

cloudnetpy/concat_lib.py

@@ -5,7 +5,7 @@ import numpy as np
 from cloudnetpy.exceptions import InconsistentDataError
 
 
-def truncate_netcdf_file(filename: str, output_file: str, n_profiles: int):
+def truncate_netcdf_file(filename: str, output_file: str, n_profiles: int) -> None:
     """Truncates netcdf file in 'time' dimension taking only n_profiles.
     Useful for creating small files for tests.
     """
@@ -13,7 +13,7 @@ def truncate_netcdf_file(filename: str, output_file: str, n_profiles: int):
         netCDF4.Dataset(filename, "r") as nc,
         netCDF4.Dataset(output_file, "w", format=nc.data_model) as nc_new,
     ):
-        for dim in nc.dimensions.keys():
+        for dim in nc.dimensions:
             dim_len = None if dim == "time" else nc.dimensions[dim].size
             nc_new.createDimension(dim, dim_len)
         for attr in nc.ncattrs():
@@ -24,7 +24,11 @@ def truncate_netcdf_file(filename: str, output_file: str, n_profiles: int):
             dimensions = nc.variables[key].dimensions
             fill_value = getattr(nc.variables[key], "_FillValue", None)
             var = nc_new.createVariable(
-                key, array.dtype, dimensions, zlib=True, fill_value=fill_value
+                key,
+                array.dtype,
+                dimensions,
+                zlib=True,
+                fill_value=fill_value,
             )
             if dimensions and "time" in dimensions[0]:
                 if array.ndim == 1:
@@ -43,13 +47,16 @@ def update_nc(old_file: str, new_file: str) -> int:
     """Appends data to existing netCDF file.
 
     Args:
+    ----
         old_file: Filename of an existing netCDF file.
         new_file: Filename of a new file whose data will be appended to the end.
 
     Returns:
+    -------
         1 = success, 0 = failed to add new data.
 
     Notes:
+    -----
         Requires 'time' variable with unlimited dimension.
 
     """
@@ -79,6 +86,7 @@ def concatenate_files(
     """Concatenate netCDF files in one dimension.
 
     Args:
+    ----
         filenames: List of files to be concatenated.
         output_file: Output file name.
         concat_dimension: Dimension name for concatenation. Default is 'time'.
@@ -90,6 +98,7 @@ def concatenate_files(
             another (value from the first file is saved).
 
     Notes:
+    -----
         Arrays without 'concat_dimension', scalars, and global attributes will be taken
         from the first file. Groups, possibly present in a NETCDF4 formatted file,
         are ignored.
@@ -105,7 +114,10 @@ class _Concat:
     common_variables: set[str]
 
     def __init__(
-        self, filenames: list, output_file: str, concat_dimension: str = "time"
+        self,
+        filenames: list,
+        output_file: str,
+        concat_dimension: str = "time",
     ):
         self.filenames = sorted(filenames)
         self.concat_dimension = concat_dimension
@@ -114,7 +126,7 @@ class _Concat:
         self.concatenated_file = self._init_output_file(output_file)
         self.common_variables = set()
 
-    def get_common_variables(self):
+    def get_common_variables(self) -> None:
         """Finds variables which should have the same values in all files."""
         for key, value in self.first_file.variables.items():
             if self.concat_dimension not in value.dimensions:
@@ -132,7 +144,7 @@ class _Concat:
         variables: list | None,
         ignore: list | None,
         allow_vary: list | None,
-    ):
+    ) -> None:
         """Concatenates data arrays."""
         self._write_initial_data(variables, ignore)
         if len(self.filenames) > 1:
@@ -140,7 +152,7 @@ class _Concat:
                 self._append_data(filename, allow_vary)
 
     def _write_initial_data(self, variables: list | None, ignore: list | None) -> None:
-        for key in self.first_file.variables.keys():
+        for key in self.first_file.variables:
             if (
                 variables is not None
                 and key not in variables
@@ -151,7 +163,8 @@ class _Concat:
             if ignore and key in ignore:
                 continue
 
-            self.first_file[key].set_auto_scale(False)
+            auto_scale = False
+            self.first_file[key].set_auto_scale(auto_scale)
             array = self.first_file[key][:]
             dimensions = self.first_file[key].dimensions
             fill_value = getattr(self.first_file[key], "_FillValue", None)
@@ -164,25 +177,28 @@ class _Concat:
                 shuffle=False,
                 fill_value=fill_value,
             )
-            var.set_auto_scale(False)
+            auto_scale = False
+            var.set_auto_scale(auto_scale)
             var[:] = array
             _copy_attributes(self.first_file[key], var)
 
     def _append_data(self, filename: str, allow_vary: list | None) -> None:
         with netCDF4.Dataset(filename) as file:
-            file.set_auto_scale(False)
+            auto_scale = False
+            file.set_auto_scale(auto_scale)
             ind0 = len(self.concatenated_file.variables[self.concat_dimension])
             ind1 = ind0 + len(file.variables[self.concat_dimension])
-            for key in self.concatenated_file.variables.keys():
+            for key in self.concatenated_file.variables:
                 array = file[key][:]
                 if key in self.common_variables:
                     if allow_vary is not None and key in allow_vary:
                         continue
                     if not np.array_equal(self.first_file[key][:], array):
-                        raise InconsistentDataError(
+                        msg = (
                             f"Inconsistent values in variable '{key}' between "
                             f"files '{self.first_filename}' and '{filename}'"
                         )
+                        raise InconsistentDataError(msg)
                     continue
                 if array.ndim == 0:
                     continue
@@ -196,7 +212,7 @@ class _Concat:
             "NETCDF4" if self.first_file.data_model == "NETCDF4" else "NETCDF4_CLASSIC"
         )
         nc = netCDF4.Dataset(output_file, "w", format=data_model)
-        for dim in self.first_file.dimensions.keys():
+        for dim in self.first_file.dimensions:
             dim_len = (
                 None
                 if dim == self.concat_dimension
@@ -205,7 +221,7 @@ class _Concat:
             nc.createDimension(dim, dim_len)
         return nc
 
-    def _close(self):
+    def _close(self) -> None:
         self.first_file.close()
         self.concatenated_file.close()
 
@@ -223,11 +239,18 @@ def _copy_attributes(source: netCDF4.Dataset, target: netCDF4.Dataset) -> None:
             setattr(target, attr, value)
 
 
-def _find_valid_time_indices(nc_old: netCDF4.Dataset, nc_new: netCDF4.Dataset):
+def _find_valid_time_indices(
+    nc_old: netCDF4.Dataset,
+    nc_new: netCDF4.Dataset,
+) -> np.ndarray:
     return np.where(nc_new.variables["time"][:] > nc_old.variables["time"][-1])[0]
 
 
-def _update_fields(nc_old: netCDF4.Dataset, nc_new: netCDF4.Dataset, valid_ind: list):
+def _update_fields(
+    nc_old: netCDF4.Dataset,
+    nc_new: netCDF4.Dataset,
+    valid_ind: np.ndarray,
+) -> None:
     ind0 = len(nc_old.variables["time"])
     idx = [ind0 + x for x in valid_ind]
     concat_dimension = nc_old.variables["time"].dimensions[0]

cloudnetpy/constants.py

@@ -18,3 +18,10 @@ RS: Final = 287.058
 
 # ice density kg m-3
 RHO_ICE: Final = 917
+
+# other
+SEC_IN_MINUTE: Final = 60
+SEC_IN_HOUR: Final = 3600
+SEC_IN_DAY: Final = 86400
+MM_TO_M: Final = 1e-3
+G_TO_KG: Final = 1e-3