pyadps 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

pyadps/utils/plotgen.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 from matplotlib.widgets import Button, RadioButtons, Slider, TextBox
 from matplotlib.widgets import RectangleSelector
 
-mpl.use("TkAgg")
+# mpl.use("TkAgg")
 
 
 class CutBins:

pyadps/utils/profile_test.py

@@ -1,6 +1,6 @@
 import numpy as np
 import scipy as sp
-from pyadps.utils.readrdi import ReadFile
+from pyadps.utils.readrdi import ReadFile, check_equal
 from .plotgen import PlotEnds
 
 
@@ -214,6 +214,217 @@ def manual_cut_bins(mask, min_cell, max_cell, min_ensemble, max_ensemble):
     return mask
 
 
+def modifiedRegrid2d(
+    ds,
+    data,
+    fill_value,
+    end_cell_option="cell",
+    trimends=None,
+    method="nearest",
+    orientation="default",
+    boundary_limit=0,
+    cells=None,
+    cell_size=None,
+    bin1dist=None,
+):
+    """
+    Modified Regrids 2D data onto a new grid based on specified parameters.
+    The function is capable of handling data with non-uniform number of cells
+    and Depth cell length.
+
+    Parameters:
+    -----------
+    ds : pyadps.dataset or numpy.ndarray
+        If pyadps dataframe is loaded, the data from the fixed and variable leader
+        is automatically obtained. This includes the depth of the transducer and other relevant information
+        for trimming the data.
+
+        If numpy.ndarray is loaded, the value should contain the transducer_depth.
+        In such cases provide cells, cell_size, and bin 1 distance.
+        Orientiation should be either 'up' or 'down' and not 'default'.
+
+
+    data : array-like
+        The 2D data array to be regridded.
+
+    fill_value : scalar
+        The value used to fill missing or undefined grid points.
+
+    end_cell_option : str or float, optional, default="cell"
+        The depth of the last bin or boundary for the grid.
+        Options include:
+        - "cell" : Calculates the depth of the default last bin for the grid.
+                   Truncates to surface for upward ADCP.
+        - "surface": The data is gridded till the surface
+        - "manual": User-defined depth for the grid.
+                      Use boundary_limit option to provide the value.
+        otherwise, a specific numerical depth value can be provided.
+
+    trimends : tuple of floats, optional, default=None
+        If provided, defines the ensemble range (start, end) for
+        calculating the maximum/minimum transducer depth.
+        Helps avoiding the deployment or retrieval data.
+        E.g. (10, 3000)
+
+    method : str, optional, default="nearest"
+        The interpolation method to use for regridding based
+        on scipy.interpolate.interp1d.
+        Options include:
+        - "nearest" : Nearest neighbor interpolation.
+        - "linear" : Linear interpolation.
+        - "cubic" : Cubic interpolation.
+
+    orientation : str, optional, default="up"
+        Defines the direction of the regridding for an upward/downward looking ADCP. Options include:
+        - "up" : Regrid upwards (for upward-looking ADCP).
+        - "down" : Regrid downwards (for downward-looking ADCP).
+
+    boundary_limit : float, optional, default=0
+        The limit for the boundary depth. This restricts the grid regridding to depths beyond the specified limit.
+
+    cells: int, optional
+        Number of cells
+
+    cell_size: int, optional
+        Cell size or depth cell length in cm
+
+    bin1dist: int, optional
+        Distance from the first bin in cm
+
+
+    Returns:
+    --------
+    z: regridded depth
+    regridded_data : array-like
+        The regridded 2D data array, based on the specified method,
+        orientation, and other parameters.
+
+    Notes:
+    ------
+    - If `end_cell_option == boundary`, then `boundary_limit` is used to regrid the data.
+    - This function allows for flexible regridding of 2D data to fit a new grid, supporting different interpolation methods.
+    - The `boundary_limit` parameter helps restrict regridding to depths above or below a certain threshold.
+    """
+
+    if isinstance(ds, ReadFile) or ds.__class__.__name__ == "ReadFile":
+        flobj = ds.fixedleader
+        vlobj = ds.variableleader
+        # Get values and convert to 'm'
+        bin1dist = flobj.field()["Bin 1 Dist"] / 100
+        transdepth = vlobj.vleader["Depth of Transducer"] / 10
+        cell_size = flobj.field()["Depth Cell Len"] / 100
+        cells = flobj.field()["Cells"]
+        ensembles = flobj.ensembles
+        if orientation.lower() == "default":
+            orientation = flobj.system_configuration()["Beam Direction"]
+
+    elif isinstance(ds, np.ndarray) and np.squeeze(ds).ndim == 1:
+        transdepth = ds / 10
+        ensembles = np.size(ds)
+
+        if cells is None:
+            raise ValueError("Input must include number of cells.")
+
+        if cell_size is None:
+            raise ValueError("Input must include cell size.")
+        else:
+            cell_size = cell_size / 100
+
+        if bin1dist is None:
+            raise ValueError("Input must include bin 1 distance.")
+        else:
+            bin1dist = bin1dist / 100
+
+        if orientation.lower() != "up" and orientation.lower() != "down":
+            raise ValueError("Orientation must be `up` or `down`.")
+    else:
+        raise ValueError("Input must be a 1-D numpy array or a PyADPS instance")
+
+    if orientation.lower() == "up":
+        sgn = -1
+    else:
+        sgn = 1
+
+    # Create a regular grid
+
+    # Find depth of first cell
+    depth = transdepth + sgn * bin1dist
+    # print("depth: ", depth)
+
+    # Find the maximum and minimum depth for first cell for upward
+    # looking ADCP (minimum and maximum for downward looking)
+    if trimends is not None:
+        max_depth = abs(np.min(sgn * depth[trimends[0] : trimends[1]]))
+        min_depth = abs(np.max(sgn * depth[trimends[0] : trimends[1]]))
+    else:
+        max_depth = abs(np.min(sgn * depth))
+        min_depth = abs(np.max(sgn * depth))
+
+    # FIRST CELL
+    # Convert the first cell depth to the first regular grid depth
+    depthfirstcell = max_depth - max_depth % min(cell_size)
+    # print("depthfirstcell: ", depthfirstcell)
+
+    # LAST CELL
+    # Convert the last cell depth to last regular grid depth
+    if end_cell_option.lower() == "surface":
+        # Added one additional negative cell to accomodate 0 m.
+        depthlastcell = sgn * min(cell_size)
+        # print("depthlastcell: ", depthlastcell)
+    elif end_cell_option.lower() == "cell":
+        min_depth_regrid = min_depth - sgn * min_depth % min(cell_size)
+        depthlastcell = min_depth_regrid + sgn * (max(cells) + 1) * min(cell_size)
+        # print("depthlastcell: ", depthlastcell)
+        # Check if this is required. Use 'surface' option
+        if depthlastcell < 0:
+            depthlastcell = sgn * min(cell_size)
+    elif end_cell_option.lower() == "manual":
+        if sgn < 0 and boundary_limit > depthfirstcell:
+            print(
+                "ERROR: For upward looking ADCP, boundary limit should be less than transducer depth"
+            )
+            return
+        if sgn > 0 and boundary_limit < depthfirstcell:
+            print(
+                "ERROR: For downward looking ADCP, boundary limit should be greater than transducer depth"
+            )
+            return
+        # Set the last grid cell depth
+        depthlastcell = boundary_limit
+    else:
+        print("ERROR: `end_cell_option` not recognized.")
+        return
+
+    # Negative used for upward and positive for downward.
+    z = np.arange(sgn * depthfirstcell, sgn * depthlastcell, min(cell_size))
+    regbins = len(z)
+
+    regridded_data = np.zeros((regbins, ensembles))
+
+    # Create original depth array
+    for i, d in enumerate(depth):
+        n = d + sgn * cell_size[i] * cells[i]
+        # np.arange may include unexpected elements due to floating-point
+        # precision issues at the stopping point. Changed to np.linspace.
+        #
+        # depth_bins = np.arange(sgn*d, sgn*n, cell_size)
+        depth_bins = np.linspace(sgn * d, sgn * n, max(cells))
+        # print("depth_bins: ", depth_bins, "len: ", len(depth_bins))
+        # print("data:", data, "len:", len(data))
+        # print("i: ", i)
+        f = sp.interpolate.interp1d(
+            depth_bins,
+            data[:, i],
+            kind=method,
+            fill_value=fill_value,
+            bounds_error=False,
+        )
+        gridz = f(z)
+
+        regridded_data[:, i] = gridz
+
+    return abs(z), regridded_data
+
 def regrid2d(
     ds,
     data,
@@ -305,6 +516,11 @@ def regrid2d(
     """
 
     if isinstance(ds, ReadFile) or ds.__class__.__name__ == "ReadFile":
+        if not (check_equal(ds.fleader['Cells']) or check_equal(ds.fleader['Depth Cell Len'])):
+            print("\033[93m Warning: The number of cells or depth cell length are not equal. Using the modifiedRegrid2d function, which may take some time.\033[0m")
+            return modifiedRegrid2d(ds, data, fill_value, end_cell_option, trimends, method, orientation,
+            boundary_limit, cells, cell_size, bin1dist)
+
         flobj = ds.fixedleader
         vlobj = ds.variableleader
         # Get values and convert to 'm'
@@ -322,11 +538,21 @@ def regrid2d(
 
         if cells is None:
             raise ValueError("Input must include number of cells.")
+        else:
+            if not check_equal(cells):
+                print("\033[93m Warning: The number of cells or depth cell length are not equal. Using the modifiedRegrid2d function, which may take some time.\033[0m")
+                return modifiedRegrid2d(ds, data, fill_value, end_cell_option, trimends, method, orientation,
+                boundary_limit, cells, cell_size, bin1dist)
+            cells = cells[0]
 
         if cell_size is None:
             raise ValueError("Input must include cell size.")
         else:
-            cell_size = cell_size / 100
+            if not check_equal(cell_size):
+                # print("\033[93m Warning: The number of cells or depth cell length are not equal. Using the modifiedRegrid2d function, which may take some time.\033[0m")
+                return modifiedRegrid2d(ds, data, fill_value, end_cell_option, trimends, method, orientation,
+                boundary_limit, cells, cell_size, bin1dist)
+            cell_size = cell_size[0] / 100
 
         if bin1dist is None:
             raise ValueError("Input must include bin 1 distance.")

pyadps/utils/pyreadrdi.py

@@ -3,17 +3,17 @@ pyreadrdi.py
 
 Module Overview
 ---------------
-This module provides functionalities to read and parse RDI ADCP files. 
-It includes functions for reading file headers, fixed and variable leaders, 
+This module provides functionalities to read and parse RDI ADCP files.
+It includes functions for reading file headers, fixed and variable leaders,
 and data types like velocity, correlation, echo intensity, and percent good.
-Currently reads only PD0 format. 
+Currently reads only PD0 format.
 
 Modules
 -------------------
 - fileheader: Function to read and parse the file header information.
 - fixedleader: Function to read and parse the fixed leader section of an RDI file.
 - variableleader: Function to read and parse the variable leader section of an RDI file.
-- datatype: Function to read and parse 3D data types. 
+- datatype: Function to read and parse 3D data types.
 - ErrorCode: Enum class to define and manage error codes for file operations.
 
 Creation Date
@@ -57,7 +57,7 @@ Examples
 >>> vel_data = datatype('example.rdi', "velocity")
 >>> vel_data = datatype('example.rdi', "echo", beam=4, cell=20)
 
-Other add-on functions and classes inlcude bcolors, safe_open, and ErrorCode. 
+Other add-on functions and classes inlcude bcolors, safe_open, and ErrorCode.
 Examples (add-on)
 -------------------
 >>> error = ErrorCode.FILE_NOT_FOUND
@@ -403,72 +403,85 @@ def fileheader(rdi_file):
     bfile.seek(0, 0)
     bskip = i = 0
     hid = [None] * 5
-    while byt := bfile.read(6):
-        hid[0], hid[1], hid[2], hid[3], hid[4] = unpack("<BBHBB", byt)
-        headerid = np.append(headerid, np.int8(hid[0]))
-        sourceid = np.append(sourceid, np.int16(hid[1]))
-        byte = np.append(byte, np.int16(hid[2]))
-        spare = np.append(spare, np.int16(hid[3]))
-        datatype = np.append(datatype, np.int16(hid[4]))
-
-        # dbyte = bfile.read(2 * datatype[i])
-        dbyte, error = safe_read(bfile, 2 * datatype[i])
-        if dbyte is None:
+    try:
+        while byt := bfile.read(6):
+            hid[0], hid[1], hid[2], hid[3], hid[4] = unpack("<BBHBB", byt)
+            headerid = np.append(headerid, np.int8(hid[0]))
+            sourceid = np.append(sourceid, np.int16(hid[1]))
+            byte = np.append(byte, np.int16(hid[2]))
+            spare = np.append(spare, np.int16(hid[3]))
+            datatype = np.append(datatype, np.int16(hid[4]))
+
+            # dbyte = bfile.read(2 * datatype[i])
+            dbyte, error = safe_read(bfile, 2 * datatype[i])
+            if dbyte is None:
+                if i == 0:
+                    error_code = error.code
+                    dummytuple = ([], [], [], [], [], ensemble, error_code)
+                    return dummytuple
+                else:
+                    break
+
+            # Check for id and datatype errors
             if i == 0:
-                error_code = error.code
-                dummytuple = ([], [], [], [], [], ensemble, error_code)
-                return dummytuple
+                if headerid[0] != 127 or sourceid[0] != 127:
+                    error = ErrorCode.WRONG_RDIFILE_TYPE
+                    print(bcolors.FAIL + error.message + bcolors.ENDC)
+                    error_code = error.code
+                    dummytuple = ([], [], [], [], [], ensemble, error_code)
+                    return dummytuple
             else:
-                break
+                if headerid[i] != 127 or sourceid[i] != 127:
+                    error = ErrorCode.ID_NOT_FOUND
+                    print(bcolors.FAIL + error.message)
+                    print(f"Ensembles reset to {i}" + bcolors.ENDC)
+                    break
+
+                if datatype[i] != datatype[i - 1]:
+                    error = ErrorCode.DATATYPE_MISMATCH
+                    print(bcolors.FAIL + error.message)
+                    print(f"Data Types for ensemble {i} is {datatype[i - 1]}.")
+                    print(f"Data Types for ensemble {i + 1} is {datatype[i]}.")
+                    print(f"Ensembles reset to {i}" + bcolors.ENDC)
+                    break
 
-        # Check for id and datatype errors
-        if i == 0:
-            if headerid[0] != 127 or sourceid[0] != 127:
-                error = ErrorCode.WRONG_RDIFILE_TYPE
-                print(bcolors.FAIL + error.message + bcolors.ENDC)
+            try:
+                data = unpack("H" * datatype[i], dbyte)
+                address_offset.append(data)
+            except:
+                error = ErrorCode.FILE_CORRUPTED
                 error_code = error.code
                 dummytuple = ([], [], [], [], [], ensemble, error_code)
                 return dummytuple
-        else:
-            if headerid[i] != 127 or sourceid[i] != 127:
-                error = ErrorCode.ID_NOT_FOUND
-                print(bcolors.FAIL + error.message + bcolors.ENDC)
-                break
-
-            if datatype[i] != datatype[i - 1]:
-                error = ErrorCode.DATATYPE_MISMATCH
-                print(bcolors.FAIL + error.message)
-                print(f"Data Types for ensemble {i} is {datatype[i - 1]}.")
-                print(f"Data Types for ensemble {i + 1} is {datatype[i]}.")
-                print(f"Ensembles reset to {i}" + bcolors.ENDC)
-                break
-
-        try:
-            data = unpack("H" * datatype[i], dbyte)
-            address_offset.append(data)
-        except:
-            error = ErrorCode.FILE_CORRUPTED
-            error_code = error.code
-            dummytuple = ([], [], [], [], [], ensemble, error_code)
-            return dummytuple
-
-        skip_array = [None] * datatype[i]
-        for dtype in range(datatype[i]):
-            bseek = int(bskip) + int(address_offset[i][dtype])
-            bfile.seek(bseek, 0)
-            readbyte = bfile.read(2)
-            skip_array[dtype] = int.from_bytes(
-                readbyte, byteorder="little", signed=False
-            )
-
-        dataid.append(skip_array)
-        # bytekip is the number of bytes to skip to reach
-        # an ensemble from beginning of file.
-        # ?? Should byteskip be from current position ??
-        bskip = int(bskip) + int(byte[i]) + 2
-        bfile.seek(bskip, 0)
-        byteskip = np.append(byteskip, np.int32(bskip))
-        i += 1
+
+            skip_array = [None] * datatype[i]
+            for dtype in range(datatype[i]):
+                bseek = int(bskip) + int(address_offset[i][dtype])
+                bfile.seek(bseek, 0)
+                readbyte = bfile.read(2)
+                skip_array[dtype] = int.from_bytes(
+                    readbyte, byteorder="little", signed=False
+                )
+
+            dataid.append(skip_array)
+            # bytekip is the number of bytes to skip to reach
+            # an ensemble from beginning of file.
+            # ?? Should byteskip be from current position ??
+            bskip = int(bskip) + int(byte[i]) + 2
+            bfile.seek(bskip, 0)
+            byteskip = np.append(byteskip, np.int32(bskip))
+            i += 1
+    except (ValueError, StructError, OverflowError) as e:
+        # except:
+        print(bcolors.WARNING + "WARNING: The file is broken.")
+        print(
+            f"Function `fileheader` unable to extract data for ensemble {i + 1}. Total ensembles reset to {i}."
+        )
+        print(bcolors.UNDERLINE + "Details from struct function" + bcolors.ENDC)
+        print(f"  Error Type: {type(e).__name__}")
+        print(f"  Error Details: {e}")
+        error = ErrorCode.FILE_CORRUPTED
+        ensemble = i
 
     ensemble = i
     bfile.close()
@@ -612,13 +625,14 @@ def fixedleader(rdi_file, byteskip=None, offset=None, idarray=None, ensemble=0):
 
                 bfile.seek(byteskip[i], 0)
 
-            except (ValueError, StructError) as e:
+            except (ValueError, StructError, OverflowError) as e:
                 print(bcolors.WARNING + "WARNING: The file is broken.")
                 print(
                     f"Function `fixedleader` unable to extract data for ensemble {i + 1}. Total ensembles reset to {i}."
                 )
-                print("Details from struct function:")
-                print(f"An error occurred: {e}" + bcolors.ENDC)
+                print(bcolors.UNDERLINE + "Details from struct function" + bcolors.ENDC)
+                print(f"  Error Type: {type(e).__name__}")
+                print(f"  Error Details: {e}")
                 error = ErrorCode.FILE_CORRUPTED
                 ensemble = i
 
@@ -794,13 +808,14 @@ def variableleader(rdi_file, byteskip=None, offset=None, idarray=None, ensemble=
 
                 bfile.seek(byteskip[i], 0)
 
-            except (ValueError, StructError) as e:
+            except (ValueError, StructError, OverflowError) as e:
                 print(bcolors.WARNING + "WARNING: The file is broken.")
                 print(
                     f"Function `variableleader` unable to extract data for ensemble {i + 1}. Total ensembles reset to {i}."
                 )
-                print("Details from struct function:")
-                print(f"An error occurred: {e}" + bcolors.ENDC)
+                print(bcolors.UNDERLINE + "Details from struct function" + bcolors.ENDC)
+                print(f"  Error Type: {type(e).__name__}")
+                print(f"  Error Details: {e}")
                 error = ErrorCode.FILE_CORRUPTED
                 ensemble = i
 
@@ -910,7 +925,9 @@ def datatype(
     # Velocity is 16 bits and all others are 8 bits.
     # Create empty array for the chosen variable name.
     if var_name == "velocity":
-        var_array = np.full((int(max(beam)), int(max(cell)), ensemble), -32768, dtype="int16")
+        var_array = np.full(
+            (int(max(beam)), int(max(cell)), ensemble), -32768, dtype="int16"
+        )
         bitstr = "<h"
         bitint = 2
     else:  # inserted
@@ -957,16 +974,28 @@ def datatype(
         return (var_array, error.code)
 
     # READ DATA
-    for i in range(ensemble):
-        bfile.seek(fbyteskip[i], 1)
-        bdata = bfile.read(2)
-        for cno in range(int(cell[i])):
-            for bno in range(int(beam[i])):
-                bdata = bfile.read(bitint)
-                varunpack = unpack(bitstr, bdata)
-                var_array[bno][cno][i] = varunpack[0]
-        bfile.seek(byteskip[i], 0)
-    bfile.close()
+    i = 0
+    try:
+        for i in range(ensemble):
+            bfile.seek(fbyteskip[i], 1)
+            bdata = bfile.read(2)
+            for cno in range(int(cell[i])):
+                for bno in range(int(beam[i])):
+                    bdata = bfile.read(bitint)
+                    varunpack = unpack(bitstr, bdata)
+                    var_array[bno][cno][i] = varunpack[0]
+            bfile.seek(byteskip[i], 0)
+        bfile.close()
+    except (ValueError, StructError, OverflowError) as e:
+        print(bcolors.WARNING + "WARNING: The file is broken.")
+        print(
+            f"Function `datatype` unable to extract {var_name} for ensemble {i + 1}. Total ensembles reset to {i}."
+        )
+        print(bcolors.UNDERLINE + "Details from struct function" + bcolors.ENDC)
+        print(f"  Error Type: {type(e).__name__}")
+        print(f"  Error Details: {e}")
+        error = ErrorCode.FILE_CORRUPTED
+        ensemble = i
 
-    data = var_array
+    data = var_array[:, :, :ensemble]
     return (data, ensemble, cell, beam, error_code)

pyadps/utils/readrdi.py

@@ -103,6 +103,7 @@ import sys
 import numpy as np
 import pandas as pd
 from pyadps.utils import pyreadrdi
+from pyadps.utils.pyreadrdi import bcolors
 
 
 class DotDict:
@@ -773,7 +774,7 @@ def vlead_dict(vid):
         "MPT Minute": "int16",
         "MPT Second": "int16",
         "MPT Hundredth": "int16",
-        "Hdg Std Dev": "int16",
+        "Head Std Dev": "int16",
         "Pitch Std Dev": "int16",
         "Roll Std Dev": "int16",
         "ADC Channel 0": "int16",
@@ -1358,7 +1359,7 @@ class ReadFile:
         The RDI ADCP binary file to be read.
     """
 
-    def __init__(self, filename):
+    def __init__(self, filename, is_fix_ensemble=True):
         """
         Initializes the ReadFile object and extracts data from the RDI ADCP binary file.
         """
@@ -1534,6 +1535,10 @@ class ReadFile:
         # Add attribute that lists all variables/functions
         self.list_vars = list(vars(self).keys())
 
+        # By default fix ensemble
+        if is_fix_ensemble and not self.isEnsembleEqual:
+            self.fixensemble()
+
     def _copy_attributes_from_var(self):
         for attr_name, attr_value in self.variableleader.__dict__.items():
             # Copy each attribute of var into self
@@ -1552,6 +1557,18 @@ class ReadFile:
             f"'{self.__class__.__name__}' object has no attribute '{name}'"
         )
 
+    def resize_fixedleader(self, newshape):
+        for key in self.fixedleader.fleader:
+            attr_name = key.lower().replace(" ", "_")
+            attr_obj = getattr(self.fixedleader, attr_name)
+            attr_obj.data = attr_obj.data[:newshape]
+
+    def resize_variableleader(self, newshape):
+        for key in self.variableleader.vleader:
+            attr_name = key.lower().replace(" ", "_")
+            attr_obj = getattr(self.variableleader, attr_name)
+            attr_obj.data = attr_obj.data[:newshape]
+
     def fixensemble(self, min_cutoff=0):
         """
         Fixes the ensemble size across all data types in the file if they differ.
@@ -1582,10 +1599,18 @@ class ReadFile:
             self.fileheader.dataid = self.fileheader.dataid[:minens, :]
             if "Fixed Leader" in datatype_array:
                 self.fixedleader.data = self.fixedleader.data[:, :minens]
+                self.fixedleader.fleader = {
+                    k: v[:minens] for k, v in self.fixedleader.fleader.items()
+                }
                 self.fixedleader.ensembles = minens
+                self.resize_fixedleader(minens)
             if "Variable Leader" in datatype_array:
                 self.variableleader.data = self.variableleader.data[:, :minens]
+                self.variableleader.vleader = {
+                    k: v[:minens] for k, v in self.variableleader.vleader.items()
+                }
                 self.variableleader.ensembles = minens
+                self.resize_variableleader(minens)
             if "Velocity" in datatype_array:
                 self.velocity.data = self.velocity.data[:, :, :minens]
                 self.velocity.ensembles = minens
@@ -1601,7 +1626,13 @@ class ReadFile:
             if "Status" in datatype_array:
                 self.status.data = self.status.data[:, :, :minens]
                 self.status.ensembles = minens
-            print(f"Ensembles fixed to {minens}. All data types have same ensembles.")
+
+            self.time = self.time[:minens]
+            print(
+                bcolors.OKBLUE
+                + f"Ensembles fixed to {minens}. All data types have same ensembles."
+                + bcolors.ENDC
+            )
         else:
             print(
                 "WARNING: No response was initiated. All data types have same ensemble."