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

pyadps/utils/script.py

@@ -1,155 +1,205 @@
-import sys
-
+import os
 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.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)
+from pyadps.utils.profile_test import regrid2d, regrid3d
+from pyadps.utils.signal_quality import (
+    default_mask,
+    ev_check,
+    false_target,
+    pg_check,
+    correlation_check,
+    echo_check,
+    qc_prompt,
+)
+from pyadps.utils.velocity_test import (
+    despike,
+    flatline,
+    velocity_modifier,
+    wmm2020api,
+    velocity_cutoff,
+)
+
+import pyadps.utils.writenc as wr
 
 plt.style.use("seaborn-v0_8-darkgrid")
 
 
-# Read data
-filename = "/home/amol/Desktop/BGS11000.000"
-ds = rd.ReadFile(filename)
-fl = ds.fixedleader
-vl = ds.variableleader
-vel = ds.velocity.data
-echo = ds.echo.data
-cor = ds.correlation.data
-pgood = ds.percentgood.data
-
-# Data pressure = vl.vleader["Pressure"]
-beam_angle = int(fl.system_configuration()["Beam Angle"])
-cell_size = fl.field()["Depth Cell Len"]
-blank_size = fl.field()["Blank Transmit"]
-cells = fl.field()["Cells"]
-
-# sys.exit()
-
-# Original mask created from velocity
-mask = default_mask(fl, vel)
-orig_mask = np.copy(mask)
-
-# Default threshold
-ct = fl.field()["Correlation Thresh"]
-et = 0
-pgt = fl.field()["Percent Good Min"]
-evt = fl.field()["Error Velocity Thresh"]
-ft = fl.field()["False Target Thresh"]
-
-print(ct, et, pgt, evt, ft)
-
-# Get the threshold values
-ct = qc_prompt(fl, "Correlation Thresh")
-evt = qc_prompt(fl, "Error Velocity Thresh")
-pgt = qc_prompt(fl, "Percent Good Min")
-et = qc_prompt(fl, "Echo Intensity Thresh", echo)
-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)
-
-
-########## PROFILE TEST #########
-
-affirm = input("Would you like to trim the ends? [y/n]: ")
-if affirm.lower() == "y":
-    mask = trim_ends(vl, mask)
-
-affirm = input("Would you remove the surface backscatter bins? [y/n]: ")
-if affirm.lower() == "y":
-    mask = side_lobe_beam_angle(fl, vl, mask)
-
-affirm = input("Would you like to manually select and mask data?")
-if affirm.lower() == "y":
-    manual = CutBins(echo[0, :, :], mask)
-    plt.show()
-    mask = manual.mask()
-
-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)
-
-# affirm = input("Display original and revised mask files? [y/n]:")
-# if affirm.lower() == "y":
-#     plotmask(orig_mask, mask)
-
-
-########## VELOCITY TEST ##########
-affirm = input("Apply correction for magnetic declination? [y/n]:")
-if affirm.lower() == "y":
-    lat = input("Enter Latitude: ")
-    lat = float(lat)
-
-    lon = input("Enter Longitude: ")
-    lon = float(lon)
-
-    depth = input("Enter Depth (m): ")
-    depth = float(depth)
-
-    year = input("Year: ")
-    year = int(year)
-
-    velocity = magnetic_declination(vel, lat, lon, depth, year)
-
-affirm = input("Apply velocity thresholds [y/n]: ")
-if affirm.lower() == "y":
-    maxuvel = input("Enter maximum zonal velocity: ")
-    maxuvel = float(maxuvel)
-
-    maxvvel = input("Enter maximum meridional velocity: ")
-    maxvvel = float(maxvvel)
-
-    maxwvel = input("Enter maximum vertical velocity: ")
-    maxwvel = float(maxwvel)
-    mask = velocity_cutoff(vel[0, :, :], mask, cutoff=maxuvel)
-    mask = velocity_cutoff(vel[1, :, :], mask, cutoff=maxvvel)
-    mask = velocity_cutoff(vel[2, :, :], mask, cutoff=maxwvel)
-
-affirm = input("Despike the data? [y/n]: ")
-if affirm.lower() == "y":
-    despike_kernal = input("Enter despike kernal size:")
-    despike_kernal = int(despike_kernal)
-
-    despike_cutoff = input("Enter despike cutoff (mm/s): ")
-    despike_cutoff = float(despike_cutoff)
-
-    mask = despike(
-        vel[0, :, :], mask, kernal_size=despike_kernal, cutoff=despike_cutoff
-    )
-    mask = despike(
-        vel[1, :, :], mask, kernal_size=despike_kernal, cutoff=despike_cutoff
-    )
-
-affirm = input("Remove flatlines? [y/n]: ")
-if affirm.lower() == "y":
-    flatline_kernal = input("Enter despike kernal size:")
-    flatline_kernal = int(flatline_kernal)
-    flatline_cutoff = input("Enter Flatline deviation: [y/n]")
-    flatlineL_cutoff = int(flatline_cutoff)
-    mask = flatline(
-        velocity[0, :, :], mask, kernal_size=flatline_kernal, cutoff=flatline_cutoff
-    )
-    mask = flatline(
-        velocity[1, :, :], mask, kernal_size=flatline_kernal, cutoff=flatline_cutoff
-    )
-    mask = flatline(
-        velocity[2, :, :], mask, kernal_size=flatline_kernal, cutoff=flatline_cutoff
-    )
+def main():
+    # Get the config file
+    try:
+        filepath = input("Enter file name: ")
+        if os.path.exists(filepath):
+            run_script(filepath)
+        else:
+            print("File not found!")
+    except Exception as e:
+        import traceback
+
+        print("Error: Unable to process the data.")
+        traceback.print_exc()
+
+
+# filename = "./metadata/demo.000"
+
+
+def run_script(filename):
+    ds = rd.ReadFile(filename)
+    fl = ds.fixedleader
+    vl = ds.variableleader
+    vel = ds.velocity.data
+    echo = ds.echo.data
+    cor = ds.correlation.data
+    pgood = ds.percentgood.data
+    time = ds.time
+    beamdir = ds.fixedleader.system_configuration()["Beam Direction"]
+
+    # Data pressure = vl.vleader["Pressure"]
+    # beam_angle = int(fl.system_configuration()["Beam Angle"])
+    # blank_size = fl.field()["Blank Transmit"]
+    cell_size = fl.field()["Depth Cell Len"] / 100
+    cells = fl.field()["Cells"]
+    bin1dist = fl.field()["Bin 1 Dist"] / 100
+
+    mean_depth = np.mean(ds.variableleader.depth_of_transducer.data) / 10
+    mean_depth = np.trunc(mean_depth)
+    if beamdir.lower() == "up":
+        sgn = -1
+    else:
+        sgn = 1
+
+    first_depth = mean_depth + sgn * bin1dist
+    last_depth = first_depth + sgn * cells * cell_size
+    z = np.arange(first_depth, last_depth, sgn * cell_size)
+
+    # Original mask created from velocity
+    mask = default_mask(ds)
+    orig_mask = np.copy(mask)
+
+    # Default threshold
+    ct = fl.field()["Correlation Thresh"]
+    et = 0
+    pgt = fl.field()["Percent Good Min"]
+    evt = fl.field()["Error Velocity Thresh"]
+    ft = fl.field()["False Target Thresh"]
+
+    # Get the threshold values
+    ct = qc_prompt(ds, "Correlation Thresh")
+    evt = qc_prompt(ds, "Error Velocity Thresh")
+    pgt = qc_prompt(ds, "Percent Good Min")
+    et = qc_prompt(ds, "Echo Intensity Thresh", echo)
+    ft = qc_prompt(ds, "False Target Thresh")
+
+    # Apply threshold
+    # values, counts = np.unique(mask, return_counts=True)
+    # print(values, counts, np.round(counts * 100 / np.sum(counts)))
+    print("Applying Thresholds")
+    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(ds, mask)
+
+    affirm = input("Would you remove the surface backscatter bins? [y/n]: ")
+    if affirm.lower() == "y":
+        mask = side_lobe_beam_angle(ds, mask)
+
+    affirm = input("Would you like to manually select and mask data? [y/n]: ")
+    if affirm.lower() == "y":
+        manual = CutBins(echo[0, :, :], mask)
+        plt.show()
+        mask = manual.mask()
+
+    affirm = input("Regrid the data based on pressure sensor? [y/n]:")
+    if affirm.lower() == "y":
+        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)
+
+    ########## VELOCITY TEST ##########
+    affirm = input("Apply correction for magnetic declination? [y/n]:")
+    if affirm.lower() == "y":
+        lat = input("Enter Latitude: ")
+        lat = float(lat)
+
+        lon = input("Enter Longitude: ")
+        lon = float(lon)
+
+        depth = input("Enter Depth (m): ")
+        depth = float(depth)
+
+        year = input("Year: ")
+        year = int(year)
+
+        mag = wmm2020api(lat, lon, year)
+        vel = velocity_modifier(vel, mag)
+
+    affirm = input("Apply velocity thresholds [y/n]: ")
+    if affirm.lower() == "y":
+        maxuvel = input("Enter maximum zonal velocity: ")
+        maxuvel = float(maxuvel)
+
+        maxvvel = input("Enter maximum meridional velocity: ")
+        maxvvel = float(maxvvel)
+
+        maxwvel = input("Enter maximum vertical velocity: ")
+        maxwvel = float(maxwvel)
+        mask = velocity_cutoff(vel[0, :, :], mask, cutoff=maxuvel)
+        mask = velocity_cutoff(vel[1, :, :], mask, cutoff=maxvvel)
+        mask = velocity_cutoff(vel[2, :, :], mask, cutoff=maxwvel)
+
+    affirm = input("Despike the data? [y/n]: ")
+    if affirm.lower() == "y":
+        despike_kernel = input("Enter despike kernel size:")
+        despike_kernel = int(despike_kernel)
+
+        despike_cutoff = input("Enter despike cutoff (mm/s): ")
+        despike_cutoff = float(despike_cutoff)
+
+        mask = despike(
+            vel[0, :, :], mask, kernel_size=despike_kernel, cutoff=despike_cutoff
+        )
+        mask = despike(
+            vel[1, :, :], mask, kernel_size=despike_kernel, cutoff=despike_cutoff
+        )
+
+    affirm = input("Remove flatlines? [y/n]: ")
+    if affirm.lower() == "y":
+        flatline_kernel = input("Enter despike kernel size:")
+        flatline_kernel = int(flatline_kernel)
+        flatline_cutoff = input("Enter Flatline deviation: [y/n]")
+        flatlineL_cutoff = int(flatline_cutoff)
+        mask = flatline(
+            vel[0, :, :], mask, kernel_size=flatline_kernel, cutoff=flatline_cutoff
+        )
+        mask = flatline(
+            vel[1, :, :], mask, kernel_size=flatline_kernel, cutoff=flatline_cutoff
+        )
+        mask = flatline(
+            vel[2, :, :], mask, kernel_size=flatline_kernel, cutoff=flatline_cutoff
+        )
+    apply_mask = input("Apply mask? [y/n]: ")
+    if apply_mask.lower() == "y":
+        for i in range(4):
+            vel[i, :, :] = np.where(mask == 0, vel[i, :, :], -32768)
+
+    outfilepath = input("Enter output file name (*nc): ")
+    if os.path.exists(outfilepath):
+        if os.path.isfile(outfilepath):
+            print(f"The file already exists: {outfilepath}")
+    else:
+        wr.finalnc(outfilepath, z, mask, time, vel)
+
+
+if __name__ == "__main__":
+    main()

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