pyadps 0.2.0b0__py3-none-any.whl → 0.3.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 (readbytes, ErrorCode.FILE_CORRUPTED)
+            return (None, ErrorCode.FILE_CORRUPTED)
         else:
             return (readbytes, ErrorCode.SUCCESS)
 
@@ -427,6 +427,7 @@ 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:
@@ -442,8 +443,14 @@ def fileheader(rdi_file):
                 print(f"Ensembles reset to {i}" + bcolors.ENDC)
                 break
 
-        data = unpack("H" * datatype[i], dbyte)
-        address_offset.append(data)
+        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]):
@@ -553,7 +560,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[1][count]
+                fbyteskip = offset[0][count]
         if fbyteskip == None:
             error = ErrorCode.ID_NOT_FOUND
             ensemble = i
@@ -703,7 +710,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[1][count]
+                fbyteskip = offset[0][count]
         if fbyteskip == None:
             error = ErrorCode.ID_NOT_FOUND
             ensemble = i
@@ -935,7 +942,7 @@ def datatype(
     fbyteskip = None
     for count, item in enumerate(idarray[0][:]):
         if item in vid:
-            fbyteskip = offset[1][count]
+            fbyteskip = offset[0][count]
             break
     if fbyteskip is None:
         print(

pyadps/utils/readrdi.py

@@ -435,7 +435,7 @@ def flead_dict(fid, dim=2):
         "False Target Thresh": "int64",
         "Spare 1": "int64",
         "Transmit Lag Dist": "int64",
-        "CPU Serial No": "int64",
+        "CPU Serial No": "int128",
         "System Bandwidth": "int64",
         "System Power": "int64",
         "Spare 2": "int64",
@@ -447,9 +447,15 @@ def flead_dict(fid, dim=2):
     counter = 1
     for key, value in fname.items():
         if dim == 2:
-            flead[key] = getattr(np, value)(fid[:][counter])
+            if key == "CPU Serial No":
+                flead[key] = np.uint64(fid[:][counter])
+            else:
+                flead[key] = np.int64(fid[:][counter])
         elif dim == 1:
-            flead[key] = getattr(np, value)(fid[counter])
+            if key == "CPU Serial No":
+                flead[key] = np.uint64(fid[counter])
+            else:
+                flead[key] = np.int64(fid[counter])
         else:
             print("ERROR: Higher dimensions not allowed")
             sys.exit()
@@ -505,6 +511,7 @@ 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"))
 
@@ -878,7 +885,7 @@ class VariableLeader:
             setattr(getattr(self, key), "data", self.data[i])
             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.
@@ -957,8 +964,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 +980,73 @@ 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:
     """

pyadps/utils/script.py

@@ -1,22 +1,19 @@
-import sys
-
 import matplotlib.pyplot as plt
 import numpy as np
 import pyadps.utils.readrdi as rd
-from pyadps.utils.cutbin import CutBins
-from pyadps.utils.plotgen import plotmask, plotvar
+from pyadps.utils.plotgen import CutBins
 from pyadps.utils.profile_test import side_lobe_beam_angle, trim_ends
-from pyadps.utils.regrid import regrid2d, regrid3d
+from pyadps.utils.profile_test import regrid2d, regrid3d
 from pyadps.utils.signal_quality import (default_mask, ev_check, false_target,
-                                         pg_check, qc_check, qc_prompt)
-from pyadps.utils.velocity_test import (despike, flatline,
-                                        magnetic_declination, velocity_cutoff)
+                                         pg_check, correlation_check, echo_check, qc_prompt)
+from pyadps.utils.velocity_test import (despike, flatline, velocity_modifier,
+                                        wmm2020api, velocity_cutoff)
 
 plt.style.use("seaborn-v0_8-darkgrid")
 
 
 # Read data
-filename = "/home/amol/Desktop/BGS11000.000"
+filename = "./src/pyadps/utils/metadata/demo.000"
 ds = rd.ReadFile(filename)
 fl = ds.fixedleader
 vl = ds.variableleader
@@ -34,7 +31,7 @@ cells = fl.field()["Cells"]
 # sys.exit()
 
 # Original mask created from velocity
-mask = default_mask(fl, vel)
+mask = default_mask(ds)
 orig_mask = np.copy(mask)
 
 # Default threshold
@@ -56,22 +53,22 @@ ft = qc_prompt(fl, "False Target Thresh")
 # Apply threshold
 values, counts = np.unique(mask, return_counts=True)
 print(values, counts, np.round(counts * 100 / np.sum(counts)))
-mask = pg_check(pgood, mask, pgt)
-mask = qc_check(cor, mask, ct)
-mask = qc_check(echo, mask, et)
-mask = ev_check(vel[3, :, :], mask, evt)
-mask = false_target(echo, mask, ft, threebeam=True)
+mask = pg_check(ds, mask, pgt)
+mask = correlation_check(ds, mask, ct)
+mask = echo_check(ds, mask, et)
+mask = ev_check(ds, mask, evt)
+mask = false_target(ds, mask, ft, threebeam=True)
 
 
 ########## PROFILE TEST #########
 
 affirm = input("Would you like to trim the ends? [y/n]: ")
 if affirm.lower() == "y":
-    mask = trim_ends(vl, mask)
+    mask = trim_ends(ds, mask)
 
 affirm = input("Would you remove the surface backscatter bins? [y/n]: ")
 if affirm.lower() == "y":
-    mask = side_lobe_beam_angle(fl, vl, mask)
+    mask = side_lobe_beam_angle(ds, mask)
 
 affirm = input("Would you like to manually select and mask data?")
 if affirm.lower() == "y":
@@ -81,11 +78,11 @@ if affirm.lower() == "y":
 
 affirm = input("Regrid the data based on pressure sensor? [y/n]:")
 if affirm.lower() == "y":
-    z, vel = regrid3d(fl, vl, vel, -32768)
-    z, echo_reg = regrid3d(fl, vl, echo, -32768)
-    z, correlation_reg = regrid3d(fl, vl, cor, -32768)
-    z, percentgood_reg = regrid3d(fl, vl, pgood, -32768)
-    z, mask = regrid2d(fl, vl, mask, -32768)
+    z, vel = regrid3d(ds, vel, -32768)
+    z, echo_reg = regrid3d(ds, echo, -32768)
+    z, correlation_reg = regrid3d(ds, cor, -32768)
+    z, percentgood_reg = regrid3d(ds, pgood, -32768)
+    z, mask = regrid2d(ds, mask, -32768)
 
 # affirm = input("Display original and revised mask files? [y/n]:")
 # if affirm.lower() == "y":
@@ -107,7 +104,8 @@ if affirm.lower() == "y":
     year = input("Year: ")
     year = int(year)
 
-    velocity = magnetic_declination(vel, lat, lon, depth, year)
+    mag = wmm2020api(lat, lon, year)
+    vel = velocity_modifier(vel, mag)
 
 affirm = input("Apply velocity thresholds [y/n]: ")
 if affirm.lower() == "y":

pyadps/utils/sensor_health.py

@@ -0,0 +1,120 @@
+import numpy as np
+
+
+def sound_speed_correction(
+    velocity: np.ndarray,
+    sound_speed: np.ndarray,
+    temperature: np.ndarray,
+    salinity: np.ndarray,
+    depth: np.ndarray,
+    horizontal: bool = True,
+) -> np.ndarray:
+    """
+    Corrects velocity measurements for variations in sound speed.
+
+    The function calculates the corrected sound speed based on temperature,
+    salinity, and depth using empirical equations. It then adjusts the velocity
+    measurements for the u and v components using the ratio of the original
+    and corrected sound speeds, while leaving the w component unchanged by default.
+
+    Parameter:
+    ----------
+        velocity (numpy.ndarray): 4D array of velocity measurements in m/s with
+            components (u, v, w, error) along depth and time axes. Missing values
+            should be represented by -32768.
+        sound_speed (numpy.ndarray): 1D array of measured sound speed in m/s as a function of time.
+        temperature (numpy.ndarray): 1D array of temperature in degrees Celsius as a function of time.
+        salinity (numpy.ndarray): 1D array of salinity in PSU (Practical Salinity Units) as a function of time.
+        depth (numpy.ndarray): 1D array of transducer depth in meters as a function of time.
+        horizontal (bool): By default only horizontal velocities are corrected.
+
+    Returns:
+    --------
+        numpy.ndarray: 3D array of corrected velocity measurements as 32-bit integers.
+        The w component remains unchanged. Missing values (-32768) remain unchanged.
+
+    Notes:
+    ------
+        The sound speed correction formula is derived empirically using the
+        equation (Urick, 1983).
+    """
+    # Calculate corrected sound speed
+    sound_speed_corrected = (
+        1449.2
+        + 4.6 * temperature
+        - 0.055 * temperature**2
+        + 0.00029 * temperature**3
+        + (1.34 - 0.01 * temperature) * (salinity - 35)
+        + 0.016 * depth
+    )
+
+    sound_speed = sound_speed
+    sound_speed_corrected = sound_speed_corrected
+    # Separate u, v, and w components
+    u = velocity[0, :, :]
+    v = velocity[1, :, :]
+    w = velocity[2, :, :]
+    e = velocity[3, :, :]
+
+    # Correct u and v components
+    u_corrected = np.where(
+        u == -32768,
+        -32768.0,
+        u * sound_speed[np.newaxis, :] / sound_speed_corrected[np.newaxis, :],
+    )
+
+    v_corrected = np.where(
+        v == -32768,
+        -32768.0,
+        v * sound_speed[np.newaxis, :] / sound_speed_corrected[np.newaxis, :],
+    )
+
+    if not horizontal:
+        w_corrected = np.where(
+            w == -32768,
+            -32768.0,
+            w * sound_speed[np.newaxis, :] / sound_speed_corrected[np.newaxis, :],
+        )
+    else:
+        w_corrected = w
+
+    # Combine corrected components back into a 4D array
+    velocity_corrected = np.stack(
+        [
+            u_corrected.astype(np.int32),
+            v_corrected.astype(np.int32),
+            w_corrected.astype(np.int32),
+            e.astype(np.int32),
+        ],
+        axis=0,
+    )
+
+    return velocity_corrected
+
+
+def tilt_sensor_check(
+    tilt: np.ndarray, mask: np.ndarray, cutoff: int = 15
+) -> np.ndarray:
+    """
+    Updates the given 2D mask array based on the tilt sensor readings. If the tilt value in
+    the 1D tilt array exceeds the specified cutoff, the corresponding values in the mask are
+    set to 1.
+
+    Parameters
+    ----------
+    tilt : np.ndarray
+        A 1D array of tilt sensor readings.
+    mask : np.ndarray
+        A 2D array where the tilt values are checked against the cutoff.
+    cutoff : int, optional
+        The tilt value threshold. Default is 15. If a tilt value exceeds this threshold,
+        the corresponding mask value is updated to 1.
+
+    Returns
+    -------
+    np.ndarray
+        A 2D array with updated mask values where tilt exceeds the cutoff.
+    """
+    tilt = tilt * 0.01
+    updated_mask = np.where(tilt[:, np.newaxis] > cutoff, 1, mask.T)
+    return updated_mask.T