pyadps 0.1.0__py3-none-any.whl → 0.1.0b0__py3-none-any.whl

pyadps/utils/pyreadrdi.py

@@ -320,7 +320,7 @@ def safe_read(bfile, num_bytes):
 
         if len(readbytes) != num_bytes:
             print(f"Unexpected end of file: fewer than {num_bytes} bytes were read.")
-            return (None, ErrorCode.FILE_CORRUPTED)
+            return (readbytes, ErrorCode.FILE_CORRUPTED)
         else:
             return (readbytes, ErrorCode.SUCCESS)
 
@@ -427,7 +427,6 @@ def fileheader(rdi_file):
                 error = ErrorCode.WRONG_RDIFILE_TYPE
                 print(bcolors.FAIL + error.message + bcolors.ENDC)
                 error_code = error.code
-                dummytuple = ([], [], [], [], [], ensemble, error_code)
                 return dummytuple
         else:
             if headerid[i] != 127 or sourceid[i] != 127:
@@ -443,14 +442,8 @@ def fileheader(rdi_file):
                 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
+        data = unpack("H" * datatype[i], dbyte)
+        address_offset.append(data)
 
         skip_array = [None] * datatype[i]
         for dtype in range(datatype[i]):
@@ -560,7 +553,7 @@ def fixedleader(rdi_file, byteskip=None, offset=None, idarray=None, ensemble=0):
         fbyteskip = None
         for count, item in enumerate(idarray[i]):
             if item in (0, 1):
-                fbyteskip = offset[0][count]
+                fbyteskip = offset[1][count]
         if fbyteskip == None:
             error = ErrorCode.ID_NOT_FOUND
             ensemble = i
@@ -710,7 +703,7 @@ def variableleader(rdi_file, byteskip=None, offset=None, idarray=None, ensemble=
         fbyteskip = None
         for count, item in enumerate(idarray[i]):
             if item in (128, 129):
-                fbyteskip = offset[0][count]
+                fbyteskip = offset[1][count]
         if fbyteskip == None:
             error = ErrorCode.ID_NOT_FOUND
             ensemble = i
@@ -942,7 +935,7 @@ def datatype(
     fbyteskip = None
     for count, item in enumerate(idarray[0][:]):
         if item in vid:
-            fbyteskip = offset[0][count]
+            fbyteskip = offset[1][count]
             break
     if fbyteskip is None:
         print(

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)
@@ -101,7 +101,6 @@ import os
 import sys
 
 import numpy as np
-import pandas as pd
 from pyadps.utils import pyreadrdi
 
 
@@ -130,7 +129,9 @@ 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):
@@ -325,7 +326,7 @@ class FileHeader:
         """
         file_stats = os.stat(self.filename)
         sys_file_size = file_stats.st_size
-        cal_file_size = sum((self.bytes).astype(int)) + 2 * len(self.bytes)
+        cal_file_size = sum(self.bytes) + 2 * len(self.bytes)
 
         check = dict()
 
@@ -434,7 +435,7 @@ def flead_dict(fid, dim=2):
         "False Target Thresh": "int64",
         "Spare 1": "int64",
         "Transmit Lag Dist": "int64",
-        "CPU Serial No": "int128",
+        "CPU Serial No": "int64",
         "System Bandwidth": "int64",
         "System Power": "int64",
         "Spare 2": "int64",
@@ -446,15 +447,9 @@ def flead_dict(fid, dim=2):
     counter = 1
     for key, value in fname.items():
         if dim == 2:
-            if key == "CPU Serial No":
-                flead[key] = np.uint64(fid[:][counter])
-            else:
-                flead[key] = np.int64(fid[:][counter])
+            flead[key] = getattr(np, value)(fid[:][counter])
         elif dim == 1:
-            if key == "CPU Serial No":
-                flead[key] = np.uint64(fid[counter])
-            else:
-                flead[key] = np.int64(fid[counter])
+            flead[key] = getattr(np, value)(fid[counter])
         else:
             print("ERROR: Higher dimensions not allowed")
             sys.exit()
@@ -510,7 +505,6 @@ class FixedLeader:
         )
         self.warning = pyreadrdi.ErrorCode.get_message(self.error)
 
-        self.data = np.uint64(self.data)
         self.fleader = flead_dict(self.data)
         self._initialize_from_dict(DotDict(json_file_path="flmeta.json"))
 
@@ -806,8 +800,7 @@ def vlead_dict(vid):
 
     counter = 1
     for key, value in vname.items():
-        # vlead[key] = getattr(np, value)(vid[:][counter])
-        vlead[key] = vid[:][counter]
+        vlead[key] = getattr(np, value)(vid[:][counter])
         counter += 1
 
     return vlead
@@ -884,7 +877,7 @@ class VariableLeader:
             setattr(getattr(self, key), "data", self.data[i])
             i = i + 1
 
-    def bitresult(self):
+    def bit_result(self):
         """
         Extracts Bit Results from Variable Leader (Byte 13 & 14)
         This field is part of the WorkHorse ADCP’s Built-in Test function.
@@ -963,6 +956,8 @@ 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)
@@ -979,80 +974,6 @@ 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:
-            byte_split = format(data, "08b")
-            bitposition = 0
-            for item in bitset:
-                errorstatus[item] = np.append(
-                    errorstatus[item], byte_split[bitposition]
-                )
-                bitposition += 1
-
-        return errorstatus
-
 
 class Velocity:
     """
@@ -1106,7 +1027,7 @@ class Velocity:
         self.cells = cell
         self.beams = beam
 
-        self.unit = "mm/s"
+        self.units = "mm/s"
         self.missing_value = "-32768"
         self.scale_factor = 1
         self.valid_min = -32768
@@ -1165,7 +1086,7 @@ class Correlation:
         self.cells = cell
         self.beams = beam
 
-        self.unit = ""
+        self.units = ""
         self.scale_factor = 1
         self.valid_min = 0
         self.valid_max = 255
@@ -1224,7 +1145,7 @@ class Echo:
         self.cells = cell
         self.beams = beam
 
-        self.unit = "counts"
+        self.units = "counts"
         self.scale_factor = "0.45"
         self.valid_min = 0
         self.valid_max = 255
@@ -1283,7 +1204,7 @@ class PercentGood:
         self.cells = cell
         self.beams = beam
 
-        self.unit = "percent"
+        self.units = "percent"
         self.valid_min = 0
         self.valid_max = 100
         self.long_name = "Percent Good"
@@ -1341,7 +1262,7 @@ class Status:
         self.cells = cell
         self.beams = beam
 
-        self.unit = ""
+        self.units = ""
         self.valid_min = 0
         self.valid_max = 1
         self.long_name = "Status Data Format"
@@ -1469,47 +1390,6 @@ 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)
-
-        # 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
@@ -1525,33 +1405,6 @@ 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())
-
-    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}'"
-        )
-
     def fixensemble(self, min_cutoff=0):
         """
         Fixes the ensemble size across all data types in the file if they differ.

pyadps/utils/regrid.py

@@ -0,0 +1,122 @@
+import numpy as np
+import scipy as sp
+
+# import readrdi as rd
+
+
+def regrid2d(
+    flobj,
+    vlobj,
+    data,
+    fill_value,
+    minimum_depth="cell",
+    trimends=None,
+    method="nearest",
+):
+    depth = vlobj.vleader["Depth of Transducer"] / 10
+    depth_interval = flobj.field()["Depth Cell Len"] / 100
+    bins = flobj.field()["Cells"]
+    ensembles = flobj.ensembles
+
+    # Create a regular grid
+    # Find the minimum depth.
+    if minimum_depth == "surface":
+        mindepth = depth_interval
+    elif minimum_depth == "cell":
+        if trimends is not None:
+            dm = np.min(depth[trimends[0] : trimends[1]])
+        else:
+            dm = np.min(depth)
+        mintransdepth = dm - bins * depth_interval
+        mindepth = mintransdepth - mintransdepth % depth_interval
+        mindepth = mindepth - depth_interval
+        # If mindepth is above surface choose surface
+        if mindepth < 0:
+            mindepth = depth_interval
+    else:
+        mindepth = depth_interval
+
+    maxbins = np.max(depth) // depth_interval + 1
+    # print(np.max(depth), np.max(depth) % depth_interval)
+    # if np.max(depth) % depth_interval > depth_interval / 2:
+    #     maxbins = maxbins + 1
+
+    maxdepth = maxbins * depth_interval
+    z = np.arange(-1 * maxdepth, -1 * mindepth, depth_interval)
+    regbins = len(z)
+
+    # print(maxbins, bins, ensemble)
+    data_regrid = np.zeros((regbins, ensembles))
+
+    # Create original depth array
+    for i, d in enumerate(depth):
+        n = -1 * d + depth_interval * bins
+        depth_bins = np.arange(-1 * d, n, depth_interval)
+        f = sp.interpolate.interp1d(
+            depth_bins,
+            data[:, i],
+            kind=method,
+            fill_value=fill_value,
+            bounds_error=False,
+        )
+        gridz = f(z)
+
+        data_regrid[:, i] = gridz
+
+    return z, data_regrid
+
+
+def regrid3d(
+    flobj,
+    vlobj,
+    data,
+    fill_value,
+    minimum_depth="cell",
+    trimends=None,
+    method="nearest",
+):
+    beams = flobj.field()["Beams"]
+    z, data_dummy = regrid2d(
+        flobj,
+        vlobj,
+        data[0, :, :],
+        fill_value,
+        minimum_depth=minimum_depth,
+        trimends=trimends,
+        method=method,
+    )
+
+    newshape = np.shape(data_dummy)
+    data_regrid = np.zeros((beams, newshape[0], newshape[1]))
+    data_regrid[0, :, :] = data_dummy
+
+    for i in range(beams - 1):
+        z, data_dummy = regrid2d(
+            flobj,
+            vlobj,
+            data[i + 1, :, :],
+            fill_value,
+            minimum_depth=minimum_depth,
+            trimends=trimends,
+            method=method,
+        )
+        data_regrid[i + 1, :, :] = data_dummy
+
+    return z, data_regrid
+
+
+# # read data
+# filename = "BGS11000.000"
+# fl = rd.FixedLeader(filename, run="fortran")
+# vl = rd.VariableLeader(filename, run="fortran")
+# # echo = rd.echo(filename, run="fortran")
+# vel = rd.velocity(filename, run="fortran")
+# pressure = vl.vleader["Pressure"]
+#
+# shape = np.shape(vel[0, :, :])
+# mask = np.zeros(shape)
+# orig_mask = np.copy(mask)
+#
+# z, newvel = regrid2d(fl, vl, vel[0, :, :], fill_value=-32768)
+# z, newmask = regrid(mask[:, :], pressure, depth_interval=4, fill_value=1)
+# z, newvel3d = regrid3d(vel, pressure, depth_interval=4, fill_value=-32768)