pyadps 0.2.1b0__py3-none-any.whl → 0.3.0__py3-none-any.whl

pyadps/utils/readrdi.py

@@ -3,9 +3,9 @@
 """
 RDI ADCP Binary File Reader
 ===========================
-This module provides classes and functions to read and extract data from RDI Acoustic Doppler 
-Current Profiler (ADCP) binary files. The module supports Workhorse, Ocean Surveyor, and DVS ADCPs. 
-It allows for parsing of various data types such as Fixed Leader, Variable Leader, Velocity, Correlation, 
+This module provides classes and functions to read and extract data from RDI Acoustic Doppler
+Current Profiler (ADCP) binary files. The module supports Workhorse, Ocean Surveyor, and DVS ADCPs.
+It allows for parsing of various data types such as Fixed Leader, Variable Leader, Velocity, Correlation,
 Echo Intensity, Percent Good, and Status data.
 
 Classes
@@ -28,7 +28,7 @@ Status
     Parses the status data from the ADCP.
 ReadFile
     Manages the entire data extraction process and unifies all data types.
-    
+
 Functions
 ---------
 check_equal(array)
@@ -42,11 +42,11 @@ Creation Date
 
 Last Modified Date
 --------------
-2024-09-05
+2025-08-14
 
 Version
 -------
-0.3.0
+0.4.0
 
 Author
 ------
@@ -101,7 +101,10 @@ import os
 import sys
 
 import numpy as np
+import pandas as pd
+from collections import Counter
 from pyadps.utils import pyreadrdi
+from pyadps.utils.pyreadrdi import bcolors
 
 
 class DotDict:
@@ -129,9 +132,7 @@ class DotDict:
             #     with open(json_file_path, "r") as file:
             #         dictionary = json.load(file)
             else:
-                dictionary = (
-                    {}
-                )  # Initialize an empty dictionary if no JSON file is found
+                dictionary = {}  # Initialize an empty dictionary if no JSON file is found
         self._initialize_from_dict(dictionary)
 
     def _initialize_from_dict(self, dictionary):
@@ -386,79 +387,6 @@ class FileHeader:
 
 
 # FIXED LEADER CODES #
-
-
-def flead_dict(fid, dim=2):
-    """
-    Extracts Fixed Leader data from a file and assigns it a identifiable name.
-
-    Parameters
-    ----------
-    fid : file object or array-like
-        The data source to extract Fixed Leader information from.
-    dim : int, optional
-        The dimension of the data, by default 2.
-
-    Returns
-    -------
-    dict
-        A dictionary containing Fixed Leader field and data.
-    """
-
-    fname = {
-        "CPU Version": "int64",
-        "CPU Revision": "int64",
-        "System Config Code": "int64",
-        "Real Flag": "int64",
-        "Lag Length": "int64",
-        "Beams": "int64",
-        "Cells": "int64",
-        "Pings": "int64",
-        "Depth Cell Len": "int64",
-        "Blank Transmit": "int64",
-        "Signal Mode": "int64",
-        "Correlation Thresh": "int64",
-        "Code Reps": "int64",
-        "Percent Good Min": "int64",
-        "Error Velocity Thresh": "int64",
-        "TP Minute": "int64",
-        "TP Second": "int64",
-        "TP Hundredth": "int64",
-        "Coord Transform Code": "int64",
-        "Head Alignment": "int64",
-        "Head Bias": "int64",
-        "Sensor Source Code": "int64",
-        "Sensor Avail Code": "int64",
-        "Bin 1 Dist": "int64",
-        "Xmit Pulse Len": "int64",
-        "Ref Layer Avg": "int64",
-        "False Target Thresh": "int64",
-        "Spare 1": "int64",
-        "Transmit Lag Dist": "int64",
-        "CPU Serial No": "int64",
-        "System Bandwidth": "int64",
-        "System Power": "int64",
-        "Spare 2": "int64",
-        "Instrument No": "int64",
-        "Beam Angle": "int64",
-    }
-
-    flead = dict()
-    counter = 1
-    for key, value in fname.items():
-        if dim == 2:
-            flead[key] = getattr(np, value)(fid[:][counter])
-        elif dim == 1:
-            flead[key] = getattr(np, value)(fid[counter])
-        else:
-            print("ERROR: Higher dimensions not allowed")
-            sys.exit()
-
-        counter += 1
-
-    return flead
-
-
 class FixedLeader:
     """
     The class extracts Fixed Leader data from RDI File.
@@ -505,7 +433,8 @@ class FixedLeader:
         )
         self.warning = pyreadrdi.ErrorCode.get_message(self.error)
 
-        self.fleader = flead_dict(self.data)
+        # self.data = self.data.astype(np.uint64)
+        self.fleader = dict()
         self._initialize_from_dict(DotDict(json_file_path="flmeta.json"))
 
     def _initialize_from_dict(self, dotdict):
@@ -520,7 +449,9 @@ class FixedLeader:
         i = 1
         for key, value in dotdict.__dict__.items():
             setattr(self, key, value)
-            setattr(getattr(self, key), "data", self.data[i])
+            data_slice = self.data[i]
+            setattr(getattr(self, key), "data", data_slice)
+            self.fleader[value.long_name] = data_slice
             i = i + 1
 
     def field(self, ens=0):
@@ -538,8 +469,7 @@ class FixedLeader:
             A dictionary of Fixed Leader data for the specified ensemble.
         """
 
-        f1 = np.array(self.data)
-        return flead_dict(f1[:, ens], dim=1)
+        return {key: value[ens] for key, value in self.fleader.items()}
 
     def is_uniform(self):
         """
@@ -555,14 +485,15 @@ class FixedLeader:
             output[key] = check_equal(value)
         return output
 
-    def system_configuration(self, ens=0):
+    def system_configuration(self, ens=-1):
         """
         Extracts and interprets the system configuration from the Fixed Leader data.
 
         Parameters
         ----------
         ens : int, optional
-            Ensemble number to extract system configuration for, by default 0.
+            Ensemble number to extract system configuration for.
+            Use -1 to extract the most common configuration (default).
 
         Returns
         -------
@@ -586,7 +517,19 @@ class FixedLeader:
                                           "5 Beam CFIG 2 DEMOD"]
         """
 
-        binary_bits = format(self.fleader["System Config Code"][ens], "016b")
+        if ens == -1:
+            syscode = self.fleader["System Config Code"]
+            most_common_syscode = Counter(syscode).most_common()[0][0]
+            binary_bits = format(int(most_common_syscode), "016b")
+        elif ens > -1:
+            binary_bits = format(int(self.fleader["System Config Code"][ens]), "016b")
+        else:
+            raise ValueError(
+                bcolors.FAIL
+                + "Ensemble number should be greater than or equal to -1"
+                + bcolors.ENDC
+            )
+
         # convert integer to binary format
         # In '016b': 0 adds extra zeros to the binary string
         #          : 16 is the total number of binary bits
@@ -672,7 +615,7 @@ class FixedLeader:
             A dictionary of coordinate transformation details.
         """
 
-        bit_group = format(self.fleader["Coord Transform Code"][ens], "08b")
+        bit_group = format(int(self.fleader["Coord Transform Code"][ens]), "08b")
         transform = dict()
 
         trans_code = {
@@ -709,9 +652,9 @@ class FixedLeader:
 
         """
         if field == "source":
-            bit_group = format(self.fleader["Sensor Source Code"][ens], "08b")
+            bit_group = format(int(self.fleader["Sensor Source Code"][ens]), "08b")
         elif field == "avail":
-            bit_group = format(self.fleader["Sensor Avail Code"][ens], "08b")
+            bit_group = format(int(self.fleader["Sensor Avail Code"][ens]), "08b")
         else:
             sys.exit("ERROR (function ez_sensor): Enter valid argument.")
 
@@ -731,82 +674,6 @@ class FixedLeader:
 
 
 # VARIABLE LEADER CODES #
-def vlead_dict(vid):
-    """
-    Extracts Variable Leader data from a file and assigns it a identifiable name.
-
-    Parameters
-    ----------
-    fid : file object or array-like
-        The data source to extract Fixed Leader information from.
-
-    Returns
-    -------
-    dict
-        A dictionary containing Variable Leader field and data.
-    """
-
-    vname = {
-        "RDI Ensemble": "int16",
-        "RTC Year": "int16",
-        "RTC Month": "int16",
-        "RTC Day": "int16",
-        "RTC Hour": "int16",
-        "RTC Minute": "int16",
-        "RTC Second": "int16",
-        "RTC Hundredth": "int16",
-        "Ensemble MSB": "int16",
-        "Bit Result": "int16",
-        "Speed of Sound": "int16",
-        "Depth of Transducer": "int16",
-        "Heading": "int32",
-        "Pitch": "int16",
-        "Roll": "int16",
-        "Salinity": "int16",
-        "Temperature": "int16",
-        "MPT Minute": "int16",
-        "MPT Second": "int16",
-        "MPT Hundredth": "int16",
-        "Hdg Std Dev": "int16",
-        "Pitch Std Dev": "int16",
-        "Roll Std Dev": "int16",
-        "ADC Channel 0": "int16",
-        "ADC Channel 1": "int16",
-        "ADC Channel 2": "int16",
-        "ADC Channel 3": "int16",
-        "ADC Channel 4": "int16",
-        "ADC Channel 5": "int16",
-        "ADC Channel 6": "int16",
-        "ADC Channel 7": "int16",
-        "Error Status Word 1": "int16",
-        "Error Status Word 2": "int16",
-        "Error Status Word 3": "int16",
-        "Error Status Word 4": "int16",
-        "Reserved": "int16",
-        "Pressure": "int32",
-        "Pressure Variance": "int32",
-        "Spare": "int16",
-        "Y2K Century": "int16",
-        "Y2K Year": "int16",
-        "Y2K Month": "int16",
-        "Y2K Day": "int16",
-        "Y2K Hour": "int16",
-        "Y2K Minute": "int16",
-        "Y2K Second": "int16",
-        "Y2K Hundredth": "int16",
-    }
-
-    vlead = dict()
-
-    counter = 1
-    for key, value in vname.items():
-        # vlead[key] = getattr(np, value)(vid[:][counter])
-        vlead[key] = vid[:][counter]
-        counter += 1
-
-    return vlead
-
-
 class VariableLeader:
     """
     The class extracts Variable Leader Data.
@@ -859,8 +726,7 @@ class VariableLeader:
         )
         self.warning = pyreadrdi.ErrorCode.get_message(self.error)
 
-        # self.vdict = DotDict()
-        self.vleader = vlead_dict(self.data)
+        self.vleader = dict()
         self._initialize_from_dict(DotDict(json_file_path="vlmeta.json"))
 
     def _initialize_from_dict(self, dotdict):
@@ -875,10 +741,12 @@ class VariableLeader:
         i = 1
         for key, value in dotdict.__dict__.items():
             setattr(self, key, value)
-            setattr(getattr(self, key), "data", self.data[i])
+            data_slice = self.data[i]
+            setattr(getattr(self, key), "data", data_slice)
+            self.vleader[value.long_name] = data_slice
             i = i + 1
 
-    def bit_result(self):
+    def bitresult(self):
         """
         Extracts Bit Results from Variable Leader (Byte 13 & 14)
         This field is part of the WorkHorse ADCP’s Built-in Test function.
@@ -914,7 +782,7 @@ class VariableLeader:
             test_field[key] = np.array([], dtype=value)
 
         for item in bit_array:
-            bit_group = format(item, "016b")
+            bit_group = format(int(item), "016b")
             bitpos = 8
             for key, value in tfname.items():
                 bitappend = getattr(np, value)(bit_group[bitpos])
@@ -957,8 +825,6 @@ class VariableLeader:
 
         scale_factor = scale_list.get(fixclass["Frequency"])
 
-        print(fixclass["Frequency"])
-
         channel["Xmit Voltage"] = adc1 * (scale_factor[0] / 1000000)
 
         channel["Xmit Current"] = adc0 * (scale_factor[1] / 1000000)
@@ -975,6 +841,84 @@ class VariableLeader:
 
         return channel
 
+    def error_status_word(self, esw=1):
+        bitset1 = (
+            "Bus Error exception",
+            "Address Error exception",
+            "Zero Divide exception",
+            "Emulator exception",
+            "Unassigned exception",
+            "Watchdog restart occurred",
+            "Batter Saver Power",
+        )
+
+        bitset2 = (
+            "Pinging",
+            "Not Used 1",
+            "Not Used 2",
+            "Not Used 3",
+            "Not Used 4",
+            "Not Used 5",
+            "Cold Wakeup occured",
+            "Unknown Wakeup occured",
+        )
+
+        bitset3 = (
+            "Clock Read error occured",
+            "Unexpected alarm",
+            "Clock jump forward",
+            "Clock jump backward",
+            "Not Used 6",
+            "Not Used 7",
+            "Not Used 8",
+            "Not Used 9",
+        )
+
+        bitset4 = (
+            "Not Used 10",
+            "Not Used 11",
+            "Not Used 12",
+            "Power Fail Unrecorded",
+            "Spurious level 4 intr DSP",
+            "Spurious level 5 intr UART",
+            "Spurious level 6 intr CLOCK",
+            "Level 7 interrup occured",
+        )
+
+        if esw == 1:
+            bitset = bitset1
+            errorarray = self.vleader["Error Status Word 1"]
+        elif esw == 2:
+            bitset = bitset2
+            errorarray = self.vleader["Error Status Word 2"]
+        elif esw == 3:
+            bitset = bitset3
+            errorarray = self.vleader["Error Status Word 3"]
+        else:
+            bitset = bitset4
+            errorarray = self.vleader["Error Status Word 4"]
+
+        errorstatus = dict()
+        # bitarray = np.zeros(32, dtype='str')
+
+        for item in bitset:
+            errorstatus[item] = np.array([])
+
+        for data in errorarray:
+            if data != -32768:
+                byte_split = format(int(data), "08b")
+                bitposition = 0
+                for item in bitset:
+                    errorstatus[item] = np.append(
+                        errorstatus[item], int(byte_split[bitposition])
+                    )
+                    bitposition += 1
+            else:
+                for item in bitset:
+                    errorstatus[item] = np.append(errorstatus[item], 0)
+
+        return errorstatus
+
 
 class Velocity:
     """
@@ -1028,7 +972,7 @@ class Velocity:
         self.cells = cell
         self.beams = beam
 
-        self.units = "mm/s"
+        self.unit = "mm/s"
         self.missing_value = "-32768"
         self.scale_factor = 1
         self.valid_min = -32768
@@ -1087,7 +1031,7 @@ class Correlation:
         self.cells = cell
         self.beams = beam
 
-        self.units = ""
+        self.unit = ""
         self.scale_factor = 1
         self.valid_min = 0
         self.valid_max = 255
@@ -1146,7 +1090,7 @@ class Echo:
         self.cells = cell
         self.beams = beam
 
-        self.units = "counts"
+        self.unit = "counts"
         self.scale_factor = "0.45"
         self.valid_min = 0
         self.valid_max = 255
@@ -1205,7 +1149,7 @@ class PercentGood:
         self.cells = cell
         self.beams = beam
 
-        self.units = "percent"
+        self.unit = "percent"
         self.valid_min = 0
         self.valid_max = 100
         self.long_name = "Percent Good"
@@ -1263,7 +1207,7 @@ class Status:
         self.cells = cell
         self.beams = beam
 
-        self.units = ""
+        self.unit = ""
         self.valid_min = 0
         self.valid_max = 1
         self.long_name = "Status Data Format"
@@ -1280,7 +1224,7 @@ class ReadFile:
         The RDI ADCP binary file to be read.
     """
 
-    def __init__(self, filename):
+    def __init__(self, filename, is_fix_ensemble=True, fix_time=False):
         """
         Initializes the ReadFile object and extracts data from the RDI ADCP binary file.
         """
@@ -1305,8 +1249,8 @@ class ReadFile:
         error_array["Fixed Leader"] = self.fixedleader.error
         warning_array["Fixed Leader"] = self.fixedleader.warning
         ensemble_array["Fixed Leader"] = self.fixedleader.ensembles
-        cells = self.fixedleader.fleader["Cells"][0]
-        beams = self.fixedleader.fleader["Beams"][0]
+        cells = int(self.fixedleader.fleader["Cells"][0])
+        beams = int(self.fixedleader.fleader["Beams"][0])
         ensemble = self.fixedleader.ensembles
 
         self.variableleader = VariableLeader(
@@ -1324,8 +1268,8 @@ class ReadFile:
         if "Velocity" in datatype_array:
             self.velocity = Velocity(
                 filename,
-                cell=cells,
-                beam=beams,
+                cell=int(cells),
+                beam=int(beams),
                 byteskip=byteskip,
                 offset=offset,
                 idarray=idarray,
@@ -1391,6 +1335,48 @@ class ReadFile:
             warning_array["Status"] = self.status.warning
             ensemble_array["Status"] = self.status.ensembles
 
+        # Add Time Axis
+        year = self.variableleader.vleader["RTC Year"]
+        month = self.variableleader.vleader["RTC Month"]
+        day = self.variableleader.vleader["RTC Day"]
+        hour = self.variableleader.vleader["RTC Hour"]
+        minute = self.variableleader.vleader["RTC Minute"]
+        second = self.variableleader.vleader["RTC Second"]
+        year = year + 2000
+        date_df = pd.DataFrame(
+            {
+                "year": year,
+                "month": month,
+                "day": day,
+                "hour": hour,
+                "minute": minute,
+                "second": second,
+            }
+        )
+        self.time = pd.to_datetime(date_df)
+        self.isTimeRegular = self.is_time_regular()
+
+        # Depth
+        # Create a depth axis with mean depth in 'm'
+        cell1 = self.fixedleader.field()["Cells"]
+        bin1dist1 = self.fixedleader.field()["Bin 1 Dist"] / 100
+        depth_cell_len1 = self.fixedleader.field()["Depth Cell Len"] / 100
+        beam_direction1 = self.fixedleader.system_configuration()["Beam Direction"]
+        mean_depth = np.mean(self.variableleader.vleader["Depth of Transducer"]) / 10
+        mean_depth = np.trunc(mean_depth)
+        if beam_direction1.lower() == "up":
+            sgn = -1
+        else:
+            sgn = 1
+        first_depth = mean_depth + sgn * bin1dist1
+        last_depth = first_depth + sgn * cell1 * depth_cell_len1
+        z = np.arange(first_depth, last_depth, sgn * depth_cell_len1)
+        self.depth = z
+
+        # Add all attributes/method/data from FixedLeader and VariableLeader
+        self._copy_attributes_from_var()
+
+        # Error Codes and Warnings
         self.error_codes = error_array
         self.warnings = warning_array
         self.ensemble_array = ensemble_array
@@ -1406,6 +1392,256 @@ class ReadFile:
         else:
             self.isWarning = True
 
+        # Add additional attributes
+        # Ensemble
+        dtens = self.ensemble_value_array
+        minens = np.min(dtens)
+        self.ensembles = minens
+
+        # Add attribute that lists all variables/functions
+        self.list_vars = list(vars(self).keys())
+
+        # By default, fix the time axis if requested
+        if fix_time:
+            self.fix_time_axis()
+
+        # 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
+            setattr(self, attr_name, attr_value)
+        for attr_name, attr_value in self.fixedleader.__dict__.items():
+            # Copy each attribute of var into self
+            setattr(self, attr_name, attr_value)
+
+    def __getattr__(self, name):
+        # Delegate attribute/method access to self.var if not found in self
+        if hasattr(self.variableleader, name):
+            return getattr(self.variableleader, name)
+        if hasattr(self.fixedleader, name):
+            return getattr(self.fixedleader, name)
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )
+
+    # Add this method inside your ReadFile class
+
+    def get_time_component_frequency(self, component="minute"):
+        """
+        Calculates the frequency of a specific time component (hour, minute, or second).
+
+        This is a diagnostic tool to help identify irregularities in the time axis.
+        For example, for ideal hourly data, the minute and second frequencies
+        should show a single entry (0) with a count equal to the number of ensembles.
+
+        Parameters
+        ----------
+        component : str, optional
+            The time component to analyze. Must be one of 'hour', 'minute',
+            or 'second', by default "minute".
+
+        Returns
+        -------
+        pandas.Series
+            A pandas Series with the time component values as the index and
+            their frequency (count) as the values, sorted in descending order.
+        """
+        if component not in ["hour", "minute", "second"]:
+            print(
+                bcolors.FAIL
+                + "Error: Component must be 'hour', 'minute', or 'second'."
+                + bcolors.ENDC
+            )
+            return
+
+        if component == "hour":
+            return self.time.dt.hour.value_counts()
+        elif component == "minute":
+            return self.time.dt.minute.value_counts()
+        else:  # second
+            return self.time.dt.second.value_counts()
+
+    # In readrdi.py, replace the snap_time_axis method inside the ReadFile class
+
+    def snap_time_axis(self, freq="h", tolerance="5min", target_minute=None):
+        """
+        Rounds the time axis, returning a status and message for the UI.
+        """
+        if target_minute is not None:
+            action_msg = f"snapping to nearest minute '{target_minute}'"
+            try:
+                offset = pd.to_timedelta(target_minute, unit="m")
+                snapped_time = (self.time - offset).dt.round("h") + offset
+            except Exception as e:
+                return False, f"Error during rounding: {e}"
+        else:
+            action_msg = f"snapping to nearest frequency '{freq}'"
+            try:
+                snapped_time = self.time.dt.round(freq)
+            except Exception as e:
+                return False, f"Error during rounding: {e}"
+
+        tolerance_delta = pd.to_timedelta(tolerance)
+
+        # Safety Check 1: Tolerance
+        max_diff = (self.time - snapped_time).abs().max()
+        if max_diff > tolerance_delta:
+            message = f"Operation Aborted: Maximum required correction is {max_diff}, which exceeds the tolerance of {tolerance}."
+            return False, message
+
+        # Safety Check 2: Duplicates
+        if snapped_time.duplicated().any():
+            message = "Operation Aborted: Snapping would create duplicate timestamps. The data may be too irregular or have large gaps."
+            return False, message
+
+        # Success Case
+        self.time = snapped_time
+        self.isTimeRegular = self.is_time_regular()
+        success_message = f"Successfully snapped time axis. Maximum correction applied was {max_diff}."
+        return True, success_message
+
+    def is_time_regular(self, tolerance_s=1):
+        """
+        Checks if the time axis has a regular, equal interval.
+
+        Args:
+            tolerance_ns (int): Tolerance in nanoseconds to consider intervals equal.
+                                Defaults to 1 second.
+
+        Returns:
+            bool: True if the time axis is regular, False otherwise.
+        """
+        if len(self.time) < 2:
+            return False  # Not enough data to determine regularity
+
+        diffs = pd.Series(self.time).diff().dropna()
+        if diffs.empty:
+            return False
+
+        # Get the most common difference (mode)
+        common_interval = diffs.mode()[0]
+
+        # Check if all differences are approximately equal to the common_interval
+        max_deviation_ns = (diffs - common_interval).abs().max().total_seconds()
+
+        return max_deviation_ns <= tolerance_s
+
+    def get_time_interval(self):
+        """
+        Calculates the most common time interval (frequency) in the data.
+
+        Returns:
+            pd.Timedelta or None: The detected modal interval, or None if insufficient data.
+        """
+        if len(self.time) < 2:
+            return None
+
+        diffs = pd.Series(self.time).diff().dropna()
+        if diffs.empty:
+            return None
+
+        # Find the most common interval (mode)
+        return diffs.mode()[0]
+
+    def get_time_interval_frequency(self):
+        if len(self.time) < 2:
+            return None
+
+        diffs = pd.Series(self.time).diff().dropna()
+        if diffs.empty:
+            return None
+        all_diffs = diffs.tolist()
+        frequency = Counter(all_diffs)
+        # return dict(frequency)
+        return {str(td): count for td, count in frequency.items()}
+
+    def fill_time_axis(self):
+        """
+        Resamples all data to a regular time axis, filling gaps with missing values.
+        Returns a status and message for the UI.
+        """
+        # 1. Determine the expected frequency
+        frequency = self.get_time_interval()
+        if frequency is None:
+            return (
+                False,
+                "Operation Aborted: Could not determine a regular time interval from the data.",
+            )
+
+        # 2. Create the new, complete time index
+        full_time_index = pd.date_range(
+            start=self.time.min(), end=self.time.max(), freq=frequency
+        )
+
+        if len(full_time_index) == len(self.time) and self.isTimeRegular:
+            return (
+                False,
+                "No action taken: The time axis is already regular and has no gaps.",
+            )
+
+        # --- Handle Fixed Leader Data ---
+        fleader_df = pd.DataFrame(self.fixedleader.fleader, index=self.time)
+        fleader_df_resampled = fleader_df.reindex(full_time_index)
+        for key in fleader_df_resampled.columns:
+            mode_value = fleader_df[key].mode().iloc[0]
+            original_dtype = fleader_df[key].dtype
+            fleader_df_resampled[key] = (
+                fleader_df_resampled[key].fillna(mode_value).astype(original_dtype)
+            )
+        for key in self.fixedleader.fleader:
+            self.fixedleader.fleader[key] = fleader_df_resampled[key].values
+
+        # --- Handle Variable Leader Data ---
+        vleader_df = pd.DataFrame(self.variableleader.vleader, index=self.time)
+        vleader_df_resampled = vleader_df.reindex(full_time_index)
+        for key, attrs in self.variableleader.vleader.items():
+            missing_val = getattr(attrs, "missing_value", -32768)
+            self.variableleader.vleader[key] = (
+                vleader_df_resampled[key].fillna(missing_val).values.astype(np.int64)
+            )
+
+        # --- Handle 3D/4D data types ---
+        missing_indices = np.where(full_time_index.isin(self.time) == False)[0]
+        data_to_resize = {
+            "velocity": -32768,
+            "correlation": 255,
+            "echo": 255,
+            "percentgood": 255,
+            "status": 0,
+        }
+        for name, missing_val in data_to_resize.items():
+            if hasattr(self, name):
+                obj = getattr(self, name)
+                if np.issubdtype(obj.data.dtype, np.integer):
+                    new_data = np.insert(
+                        obj.data, missing_indices, missing_val, axis=-1
+                    )
+                    obj.data = new_data
+                    obj.ensembles = new_data.shape[-1]
+
+        # --- Update the main object's state ---
+        self.time = pd.Series(full_time_index)
+        self.ensembles = len(full_time_index)
+        self.isTimeRegular = True
+
+        message = f"Successfully filled time axis gaps. Total ensembles are now {self.ensembles}."
+        return True, message
+
+    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.
@@ -1436,10 +1672,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
@@ -1455,7 +1699,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."