cloudnetpy 1.77.2__tar.gz → 1.78.1__tar.gz

{cloudnetpy-1.77.2/cloudnetpy.egg-info → cloudnetpy-1.78.1}/PKG-INFO

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

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/categorize/insects.py

@@ -83,7 +83,7 @@ def _get_smoothed_v(
     obs: ClassData,
     sigma: tuple[float, float] = (5, 5),
 ) -> ma.MaskedArray:
-    smoothed_v = gaussian_filter(obs.v, sigma)
+    smoothed_v = gaussian_filter(obs.v.filled(0), sigma)
     return ma.masked_where(obs.v.mask, smoothed_v)
 
 

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/categorize/radar.py

@@ -24,8 +24,6 @@ class Radar(DataSource):
         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.
         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
@@ -39,21 +37,17 @@ class Radar(DataSource):
     def __init__(self, full_path: str):
         super().__init__(full_path, radar=True)
         self.radar_frequency = float(self.getvar("radar_frequency"))
-        self.folding_velocity = self._get_folding_velocity()
-        self.sequence_indices = self._get_sequence_indices()
         self.location = getattr(self.dataset, "location", "")
         self.source_type = getattr(self.dataset, "source", "")
         self.height: np.ndarray
         self.altitude: float
         self._init_data()
-        self._init_sigma_v()
-        self._get_folding_velocity_full()
 
     def rebin_to_grid(self, time_new: np.ndarray) -> list:
-        """Rebins radar data in time using mean.
+        """Rebins radar data in time.
 
         Args:
-            time_new: Target time array as fraction hour. Updates *time* attribute.
+            time_new: Target time array as fraction hour.
 
         """
         bad_time_indices = []
@@ -64,21 +58,25 @@ class Radar(DataSource):
                     bad_time_indices = array.rebin_data(self.time, time_new)
                     array.lin2db()
                 case "v":
-                    array.rebin_velocity(
-                        self.time,
+                    array.data = self._rebin_velocity(
+                        array.data,
                         time_new,
-                        self.folding_velocity,
-                        self.sequence_indices,
                     )
                 case "v_sigma":
-                    array.calc_linear_std(self.time, time_new)
+                    array.data, _ = utils.rebin_2d(
+                        self.time,
+                        array.data,
+                        time_new,
+                        "std",
+                        mask_zeros=True,
+                    )
                 case "width":
                     array.rebin_data(self.time, time_new)
                 case "rainfall_rate":
-                    array.rebin_data(self.time, time_new, mask_zeros=False)
+                    array.rebin_data(self.time, time_new)
                 case _:
                     continue
-        return bad_time_indices
+        return list(bad_time_indices)
 
     def remove_incomplete_pixels(self) -> None:
         """Mask radar pixels where one or more required quantities are missing.
@@ -337,63 +335,88 @@ class Radar(DataSource):
 
     def _init_data(self) -> None:
         self.append_data(self.getvar("Zh"), "Z", units="dBZ")
-        for key in ("v", "ldr", "width", "sldr", "rainfall_rate"):
-            try:
-                self._variables_to_cloudnet_arrays((key,))
-            except KeyError:
-                continue
-
-    def _init_sigma_v(self) -> None:
-        """Initializes std of the velocity field. The std will be calculated
-        later when re-binning the data.
-        """
         self.append_data(self.getvar("v"), "v_sigma")
+        for key in ("v", "ldr", "width", "sldr", "rainfall_rate", "nyquist_velocity"):
+            if key in self.dataset.variables:
+                data = self.dataset.variables[key]
+                self.append_data(data, key)
 
-    def _get_sequence_indices(self) -> list:
-        """Mira has only one sequence and one folding velocity. RPG has
-        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")
-            return np.split(all_indices, starting_indices[1:])
-        return [all_indices]
-
-    def _get_folding_velocity(self) -> np.ndarray | float:
+    def _rebin_velocity(
+        self,
+        data: np.ndarray,
+        time_new: np.ndarray,
+    ) -> np.ndarray:
+        """Rebins Doppler velocity in polar coordinates."""
+        folding_velocity = self._get_expanded_folding_velocity()
+        # with the new shape (maximum value in every bin)
+        max_folding_binned, _ = utils.rebin_2d(
+            self.time,
+            folding_velocity,
+            time_new,
+            "max",
+        )
+        # store this in the file
+        self.append_data(max_folding_binned, "nyquist_velocity")
+        # with original shape (repeat maximum value for each point in every bin)
+        max_folding_full, _ = utils.rebin_2d(
+            self.time,
+            folding_velocity,
+            time_new,
+            "max",
+            keepdim=True,
+        )
+        data_scaled = data * (np.pi / max_folding_full)
+        vel_x = ma.cos(data_scaled)
+        vel_y = ma.sin(data_scaled)
+        vel_x_mean, _ = utils.rebin_2d(self.time, vel_x, time_new)
+        vel_y_mean, _ = utils.rebin_2d(self.time, vel_y, time_new)
+        vel_scaled = ma.arctan2(vel_y_mean, vel_x_mean)
+        return vel_scaled / (np.pi / max_folding_binned)
+
+    def _get_expanded_folding_velocity(self) -> np.ndarray:
         if "nyquist_velocity" in self.dataset.variables:
-            return self.getvar("nyquist_velocity")
-        if "prf" in self.dataset.variables:
+            fvel = self.getvar("nyquist_velocity")
+        elif "prf" in self.dataset.variables:
             prf = self.getvar("prf")
-            return _prf_to_folding_velocity(prf, self.radar_frequency)
-        msg = "Unable to determine folding velocity"
-        raise RuntimeError(msg)
-
-    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]),
-            )
+            fvel = _prf_to_folding_velocity(prf, self.radar_frequency)
         else:
-            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")
-
-
-def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> float:
+            msg = "Unable to determine folding velocity"
+            raise RuntimeError(msg)
+
+        n_time = self.getvar("time").size
+        n_height = self.height.size
+
+        if fvel.shape == (n_time, n_height):
+            # Folding velocity is already expanded in radar file
+            # Not yet in current files
+            return fvel
+        if utils.isscalar(fvel):
+            # e.g. MIRA
+            return np.broadcast_to(fvel, (n_time, n_height))
+
+        # RPG radars have chirp segments
+        starts = self.getvar("chirp_start_indices")
+        n_seg = starts.size if starts.ndim == 1 else starts.shape[1]
+
+        starts = np.broadcast_to(starts, (n_time, n_seg))
+        fvel = np.broadcast_to(fvel, (n_time, n_seg))
+
+        # Indices should start from zero (first range gate)
+        # In pre-processed RV Meteor files the first index is 1, so normalize:
+        # Normalize starts so indices begin from zero
+        first_values = starts[:, [0]]
+        if not np.all(np.isin(first_values, [0, 1])):
+            msg = "First value of chirp_start_indices must be 0 or 1"
+            raise ValueError(msg)
+        starts = starts - first_values
+
+        chirp_size = np.diff(starts, append=n_height)
+        return np.repeat(fvel.ravel(), chirp_size.ravel()).reshape((n_time, n_height))
+
+
+def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> np.ndarray:
     ghz_to_hz = 1e9
     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))
+    return prf[0] * constants.c / (4 * radar_frequency * ghz_to_hz)

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/cloudnetarray.py

@@ -1,6 +1,5 @@
 """CloudnetArray class."""
 
-import math
 from collections.abc import Sequence
 
 import netCDF4
@@ -58,29 +57,22 @@ class CloudnetArray:
         """Masks data from given indices."""
         self.data[ind] = ma.masked
 
-    def rebin_data(
-        self, time: np.ndarray, time_new: np.ndarray, *, mask_zeros: bool = True
-    ) -> list:
+    def rebin_data(self, time: np.ndarray, time_new: np.ndarray) -> np.ndarray:
         """Rebins `data` in time.
 
         Args:
             time: 1D time array.
             time_new: 1D new time array.
-            mask_zeros: Whether to mask 0 values in the returned array. Default is True.
 
         Returns:
             Time indices without data.
 
         """
         if self.data.ndim == 1:
-            self.data = utils.rebin_1d(time, self.data, time_new, mask_zeros=mask_zeros)
-            bad_indices = list(np.where(self.data == ma.masked)[0])
+            self.data = utils.rebin_1d(time, self.data, time_new)
+            bad_indices = np.nonzero(self.data.mask)[0]
         else:
-            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, mask_zeros=mask_zeros
-            )
+            self.data, bad_indices = utils.rebin_2d(time, self.data, time_new)
         return bad_indices
 
     def fetch_attributes(self) -> list:
@@ -108,6 +100,21 @@ class CloudnetArray:
             if data:
                 setattr(self, key, data)
 
+    def filter_isolated_pixels(self) -> None:
+        """Filters hot pixels from radar data."""
+        self._filter(utils.filter_isolated_pixels)
+
+    def filter_vertical_stripes(self) -> None:
+        """Filters vertical artifacts from radar data."""
+        self._filter(utils.filter_x_pixels)
+
+    def _filter(self, fun) -> None:
+        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
+
     def _init_data(self) -> np.ndarray:
         if isinstance(self.variable, netCDF4.Variable):
             return self.variable[:]
@@ -139,73 +146,3 @@ class CloudnetArray:
 
     def __getitem__(self, ind: tuple) -> np.ndarray:
         return self.data[ind]
-
-    def filter_isolated_pixels(self) -> None:
-        """Filters hot pixels from radar data."""
-        self._filter(utils.filter_isolated_pixels)
-
-    def filter_vertical_stripes(self) -> None:
-        """Filters vertical artifacts from radar data."""
-        self._filter(utils.filter_x_pixels)
-
-    def _filter(self, fun) -> None:
-        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
-
-    def calc_linear_std(self, time: np.ndarray, time_new: np.ndarray) -> None:
-        """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)
-        data_as_float = ma.masked_array(data_as_float)
-        self.data, _ = utils.rebin_2d(time, data_as_float, time_new, "std")
-
-    def rebin_velocity(
-        self,
-        time: np.ndarray,
-        time_new: np.ndarray,
-        folding_velocity: float | np.ndarray,
-        sequence_indices: list,
-    ) -> None:
-        """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
-                it's the same for all altitudes, or np.ndarray when it
-                matches difference altitude regions (defined in `sequence_indices`).
-            sequence_indices: List containing indices of different folding regions,
-                e.g. [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10]].
-
-        """
-
-        def _get_scaled_vfold() -> np.ndarray:
-            vfold_scaled = math.pi / folding_velocity
-            if isinstance(vfold_scaled, float):
-                vfold_scaled = np.array([float(vfold_scaled)])
-            return vfold_scaled
-
-        def _scale_by_vfold(data_in: np.ndarray, fun) -> np.ndarray:
-            data_out = ma.copy(data_in)
-            for i, ind in enumerate(sequence_indices):
-                data_out[:, ind] = fun(data_in[:, ind], folding_velocity_scaled[i])
-            return data_out
-
-        folding_velocity_scaled = _get_scaled_vfold()
-        data_scaled = _scale_by_vfold(self.data, np.multiply)
-        vel_x = ma.cos(data_scaled)
-        vel_y = ma.sin(data_scaled)
-        vel_x_mean, _ = utils.rebin_2d(time, vel_x, time_new)
-        vel_y_mean, _ = utils.rebin_2d(time, vel_y, time_new)
-        mean_vel_scaled = np.arctan2(vel_y_mean, vel_x_mean)
-        self.data = _scale_by_vfold(mean_vel_scaled, np.divide)

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/concat_lib.py

@@ -9,9 +9,9 @@ from typing import Literal
 
 import netCDF4
 import numpy as np
+from numpy import ma
 
 from cloudnetpy import utils
-from cloudnetpy.exceptions import InconsistentDataError
 
 
 def truncate_netcdf_file(
@@ -89,7 +89,7 @@ def concatenate_files(
     variables: list | None = None,
     new_attributes: dict | None = None,
     ignore: list | None = None,
-    allow_difference: list | None = None,
+    interp_dimension: str = "range",
 ) -> list:
     """Concatenate netCDF files in one dimension.
 
@@ -101,22 +101,21 @@ def concatenate_files(
             Default is None when all variables with 'concat_dimension' will be saved.
         new_attributes: Optional new global attributes as {'attribute_name': value}.
         ignore: List of variables to be ignored.
-        allow_difference: Names of scalar variables that can differ from one file to
-            another (value from the first file is saved).
+        interp_dimension: Dimension name for interpolation if the dimensions
+            are not the same.
 
     Returns:
         List of filenames that were successfully concatenated.
 
     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.
+        Arrays without 'concat_dimension' and scalars are expanded to the
+        concat_dimension. Global attributes are taken from the first file.
+        Groups, possibly present in a NETCDF4 formatted file, are ignored.
 
     """
-    with _Concat(filenames, output_file, concat_dimension) as concat:
-        concat.get_common_variables()
+    with _Concat(filenames, output_file, concat_dimension, interp_dimension) as concat:
         concat.create_global_attributes(new_attributes)
-        return concat.concat_data(variables, ignore, allow_difference)
+        return concat.concat_data(variables, ignore)
 
 
 class _Concat:
@@ -127,19 +126,14 @@ class _Concat:
         filenames: Iterable[PathLike | str],
         output_file: str,
         concat_dimension: str = "time",
+        interp_dim: str = "range",
     ):
         self.filenames = sorted(map(Path, filenames), key=lambda f: f.name)
         self.concat_dimension = concat_dimension
+        self.interp_dim = interp_dim
         self.first_filename = self.filenames[0]
         self.first_file = netCDF4.Dataset(self.first_filename)
         self.concatenated_file = self._init_output_file(output_file)
-        self.common_variables = set()
-
-    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:
-                self.common_variables.add(key)
 
     def create_global_attributes(self, new_attributes: dict | None) -> None:
         """Copies global attributes from one of the source files."""
@@ -150,17 +144,16 @@ class _Concat:
 
     def concat_data(
         self,
-        variables: list | None,
-        ignore: list | None,
-        allow_vary: list | None,
+        keep: list | None = None,
+        ignore: list | None = None,
     ) -> list:
         """Concatenates data arrays."""
-        self._write_initial_data(variables, ignore)
+        self._write_initial_data(keep, ignore)
         output = [self.first_filename]
         if len(self.filenames) > 1:
             for filename in self.filenames[1:]:
                 try:
-                    self._append_data(filename, allow_vary)
+                    self._append_data(filename)
                 except RuntimeError as e:
                     if "NetCDF: HDF error" in str(e):
                         msg = f"Caught a NetCDF HDF error. Skipping file '{filename}'."
@@ -170,24 +163,28 @@ class _Concat:
                 output.append(filename)
         return output
 
-    def _write_initial_data(self, variables: list | None, ignore: list | None) -> None:
-        for key in self.first_file.variables:
+    def _write_initial_data(self, keep: list | None, ignore: list | None) -> None:
+        len_concat_dim = self.first_file[self.concat_dimension].size
+        auto_scale = False
+
+        for key, var in self.first_file.variables.items():
             if (
-                variables is not None
-                and key not in variables
-                and key not in self.common_variables
+                # This filtering only affects variables having the concat_dimension
+                keep is not None
+                and key not in keep
                 and key != self.concat_dimension
+                and self.concat_dimension in var.dimensions
             ):
                 continue
             if ignore and key in ignore:
                 continue
 
-            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)
-            var = self.concatenated_file.createVariable(
+            var.set_auto_scale(auto_scale)
+            array, dimensions = self._expand_array(var, len_concat_dim)
+
+            fill_value = var.get_fill_value()
+
+            var_new = self.concatenated_file.createVariable(
                 key,
                 array.dtype,
                 dimensions,
@@ -196,37 +193,49 @@ class _Concat:
                 shuffle=False,
                 fill_value=fill_value,
             )
-            auto_scale = False
-            var.set_auto_scale(auto_scale)
-            var[:] = array
-            _copy_attributes(self.first_file[key], var)
-
-    def _append_data(self, filename: str | PathLike, allow_vary: list | None) -> None:
+            var_new.set_auto_scale(auto_scale)
+            var_new[:] = array
+            _copy_attributes(var, var_new)
+
+    def _expand_array(
+        self, var: netCDF4.Variable, n_data: int
+    ) -> tuple[ma.MaskedArray, tuple[str, ...]]:
+        dimensions = var.dimensions
+        arr = var[:]
+        if self.concat_dimension not in dimensions and var.name != self.interp_dim:
+            dimensions = (self.concat_dimension, *dimensions)
+            arr = np.repeat(arr[np.newaxis, ...], n_data, axis=0)
+
+        return arr, dimensions
+
+    def _append_data(self, filename: str | PathLike) -> None:
         with netCDF4.Dataset(filename) as file:
             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])
+            n_points = ind1 - ind0
+
             for key in self.concatenated_file.variables:
-                if key not in file.variables:
-                    continue
-                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):
-                        msg = (
-                            f"Inconsistent values in variable '{key}' between "
-                            f"files '{self.first_filename}' and '{filename}'"
-                        )
-                        raise InconsistentDataError(msg)
+                if key not in file.variables or key == self.interp_dim:
                     continue
-                if array.ndim == 0:
-                    continue
-                if array.ndim == 1:
-                    self.concatenated_file.variables[key][ind0:ind1] = array
-                else:
-                    self.concatenated_file.variables[key][ind0:ind1, :] = array
+
+                array, dimensions = self._expand_array(file[key], n_points)
+
+                # Nearest neighbour interpolation in the interp_dim dimension
+                # if the dimensions are not the same between the files
+                if self.interp_dim in dimensions and (
+                    self.first_file[self.interp_dim].size != file[self.interp_dim].size
+                ):
+                    x = file.variables[self.interp_dim][:]
+                    x_target = self.first_file.variables[self.interp_dim][:]
+                    idx = np.abs(x[:, None] - x_target[None, :]).argmin(axis=0)
+                    array = array[:, idx]
+                    out_of_bounds = (x_target < x.min()) | (x_target > x.max())
+                    fill_value = self.first_file.variables[key].get_fill_value()
+                    array[:, out_of_bounds] = fill_value
+
+                self.concatenated_file.variables[key][ind0:ind1, ...] = array
 
     def _init_output_file(self, output_file: str) -> netCDF4.Dataset:
         data_model: Literal["NETCDF4", "NETCDF4_CLASSIC"] = (

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/datasource.py

@@ -182,53 +182,6 @@ class DataSource:
             return np.array(range_instrument + self.altitude)
         return None
 
-    def _variables_to_cloudnet_arrays(self, keys: tuple) -> None:
-        """Transforms netCDF4-variables into CloudnetArrays.
-
-        Args:
-            keys: netCDF4-variables to be converted. The results
-                are saved in *self.data* dictionary with *fields*
-                strings as keys.
-
-        Notes:
-            The attributes of the variables are not copied. Just the data.
-
-        """
-        for key in keys:
-            self.append_data(self.dataset.variables[key], key)
-
-    def _unknown_variable_to_cloudnet_array(
-        self,
-        possible_names: tuple,
-        key: str,
-        units: str | None = None,
-        *,
-        ignore_mask: bool = False,
-    ) -> None:
-        """Transforms single netCDF4 variable into CloudnetArray.
-
-        Args:
-            possible_names: Tuple of strings containing the possible
-                names of the variable in the input NetCDF file.
-            key: Key for self.data dictionary and name-attribute
-                for the saved CloudnetArray object.
-            units: Units attribute for the CloudnetArray object.
-            ignore_mask: If true, always writes an ordinary numpy array.
-
-        Raises:
-            RuntimeError: No variable found.
-
-        """
-        for name in possible_names:
-            if name in self.dataset.variables:
-                array: netCDF4.Variable | np.ndarray = self.dataset.variables[name]
-                if ignore_mask is True:
-                    array = np.array(array)
-                self.append_data(array, key, units=units)
-                return
-        msg = f"Missing variable {possible_names[0]} in the input file."
-        raise RuntimeError(msg)
-
     def __enter__(self):
         return self
 

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/instruments/bowtie.py

@@ -80,8 +80,8 @@ class Bowtie(NcRadar):
         self.data["relative_humidity"].data /= 100
 
     def fix_chirp_start_indices(self) -> None:
-        ind = self.data["chirp_start_indices"].data
-        self.data["chirp_start_indices"].data = np.array([int(i) for i in ind])
+        array = self.data["chirp_start_indices"].data
+        self.data["chirp_start_indices"].data = np.array(array, dtype=np.int32)
         self.data["chirp_start_indices"].data_type = "int32"
 
     def check_date(self, date: str):

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/instruments/copernicus.py

@@ -69,7 +69,6 @@ def copernicus2nc(
                 valid_filenames = utils.get_files_with_variables(
                     valid_filenames, ["time", "ZED_HC"]
                 )
-                valid_filenames = utils.get_files_with_common_range(valid_filenames)
                 variables = list(keymap.keys())
                 concat_lib.concatenate_files(
                     valid_filenames,

{cloudnetpy-1.77.2 → cloudnetpy-1.78.1}/cloudnetpy/instruments/galileo.py

@@ -68,7 +68,6 @@ def galileo2nc(
                 valid_filenames = utils.get_files_with_variables(
                     valid_filenames, ["time", "ZED_HC"]
                 )
-                valid_filenames = utils.get_files_with_common_range(valid_filenames)
                 variables = list(keymap.keys())
                 concat_lib.concatenate_files(
                     valid_filenames,