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

pyadps/utils/profile_test.py

@@ -2,8 +2,8 @@ import matplotlib.pyplot as plt
 import numpy as np
 import streamlit as st
 from matplotlib.widgets import Button, Slider, TextBox
-
 from pyadps.utils import readrdi as rd
+
 from .plotgen import plotmask, plotvar
 
 
@@ -127,7 +127,7 @@ def trim_ends(vlobj, mask, method="Manual"):
     return mask
 
 
-def side_lobe_beam_angle(flobj, vlobj, mask, extra_cells=2):
+def side_lobe_beam_angle(flobj, vlobj, mask, orientation='default', water_column_depth=0, extra_cells=2):
     beam_angle = int(flobj.system_configuration()["Beam Angle"])
     cell_size = flobj.field()["Depth Cell Len"]
     bin1dist = flobj.field()["Bin 1 Dist"]
@@ -135,11 +135,19 @@ def side_lobe_beam_angle(flobj, vlobj, mask, extra_cells=2):
     ensembles = flobj.ensembles
     transducer_depth = vlobj.vleader["Depth of Transducer"]
 
+    if orientation.lower() == "default":
+        orientation = flobj.system_configuration()['Beam Direction']
+
+    if orientation.lower() == "up":
+        sgn = -1
+        water_column_depth = 0
+    else:
+        sgn = 1
+
     beam_angle = np.deg2rad(beam_angle)
     depth = transducer_depth / 10
-    valid_depth = depth * np.cos(beam_angle) - bin1dist / 100
+    valid_depth = (water_column_depth - sgn*depth) * np.cos(beam_angle) + sgn*bin1dist / 100
     valid_cells = np.trunc(valid_depth * 100 / cell_size) - extra_cells
-    st.write(cells, valid_cells[100], extra_cells)
 
     for i in range(ensembles):
         c = int(valid_cells[i])
@@ -153,23 +161,27 @@ def side_lobe_rssi_bump(echo, mask):
     pass
 
 
-# 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")
-#
-# beam_angle = int(fl.system_configuration()["Beam Angle"])
-# cell_size = fl.field()["Depth Cell Len"]
-# bin1dist = fl.field()["Bin 1 Dist"]
-# cells = fl.field()["Cells"]
-#
-# shape = np.shape(vel[0, :, :])
-# mask = np.zeros(shape)
-# orig_mask = np.copy(mask)
-#
-# mask = trim_ends(vl, mask)
-# mask = side_lobe_beam_angle(fl, vl, mask)
-# plotmask(orig_mask, mask)
-# plotvar(echo, "Echo Intensity", mask)
+def manual_cut_bins(mask, min_cell, max_cell, min_ensemble, max_ensemble):
+    """
+    Apply manual bin cutting by selecting a specific range of cells and ensembles.
+
+    Parameters:
+        mask (numpy array): The mask array to modify.
+        min_cell (int): The minimum cell index to mask.
+        max_cell (int): The maximum cell index to mask.
+        min_ensemble (int): The minimum ensemble index to mask.
+        max_ensemble (int): The maximum ensemble index to mask.
+
+    Returns:
+        numpy array: The updated mask with selected areas masked.
+    """
+    # Ensure the indices are within valid range
+    min_cell = max(0, min_cell)
+    max_cell = min(mask.shape[0], max_cell)
+    min_ensemble = max(0, min_ensemble)
+    max_ensemble = min(mask.shape[1], max_ensemble)
+
+    # Apply mask on the selected range
+    mask[min_cell:max_cell, min_ensemble:max_ensemble] = 1
+
+    return mask

pyadps/utils/readrdi.py

@@ -326,7 +326,7 @@ class FileHeader:
         """
         file_stats = os.stat(self.filename)
         sys_file_size = file_stats.st_size
-        cal_file_size = sum(self.bytes) + 2 * len(self.bytes)
+        cal_file_size = sum((self.bytes).astype(int)) + 2 * len(self.bytes)
 
         check = dict()
 
@@ -800,7 +800,8 @@ def vlead_dict(vid):
 
     counter = 1
     for key, value in vname.items():
-        vlead[key] = getattr(np, value)(vid[:][counter])
+        # vlead[key] = getattr(np, value)(vid[:][counter])
+        vlead[key] = vid[:][counter]
         counter += 1
 
     return vlead

pyadps/utils/regrid.py

@@ -9,49 +9,148 @@ def regrid2d(
     vlobj,
     data,
     fill_value,
-    minimum_depth="cell",
+    end_bin_option="cell",
     trimends=None,
     method="nearest",
+    orientation="default",
+    boundary_limit=0,
 ):
-    depth = vlobj.vleader["Depth of Transducer"] / 10
+    """
+    Regrids 2D data onto a new grid based on specified parameters.
+
+    Parameters:
+    -----------
+    flobj : object
+        The fixed leader object that contains information 
+        about the fixed leader data.
+        
+    vlobj : object
+        The variable leader object that contains information 
+        about the variable leader data.
+        
+    data : array-like
+        The 2D data array to be regridded.
+        
+    fill_value : scalar
+        The value used to fill missing or undefined grid points.
+        
+    end_bin_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.
+        
+    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_bin_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.
+    """
+   
+    # Get values and convert to 'm'
+    bin1dist = flobj.field()["Bin 1 Dist"] / 100
+    transdepth = vlobj.vleader["Depth of Transducer"] / 10
     depth_interval = flobj.field()["Depth Cell Len"] / 100
     bins = flobj.field()["Cells"]
     ensembles = flobj.ensembles
 
+    if orientation.lower() == "default":
+        orientation = flobj.system_configuration()['Beam Direction']
+
+    if orientation.lower() == "up":
+        sgn = -1 
+    else:
+        sgn = 1
+
     # 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
+
+    # Find depth of first cell
+    depth = transdepth + sgn*bin1dist
+
+    # 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:
-        mindepth = depth_interval
+        max_depth = abs(np.min(sgn*depth))
+        min_depth = abs(np.max(sgn*depth))
 
-    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
+    # FIRST CELL
+    # Convert the first cell depth to the first regular grid depth 
+    depthfirstcell = max_depth - max_depth % depth_interval
 
-    maxdepth = maxbins * depth_interval
-    z = np.arange(-1 * maxdepth, -1 * mindepth, depth_interval)
+    # LAST CELL
+    # Convert the last cell depth to last regular grid depth 
+    if end_bin_option.lower() == "surface":
+        # Added one additional negative cell to accomodate 0 m.
+        depthlastcell = sgn * depth_interval
+    elif end_bin_option.lower() == "cell":
+        min_depth_regrid = min_depth - sgn*min_depth % depth_interval
+        depthlastcell = min_depth_regrid  + sgn* (bins+1) * depth_interval
+        # Check if this is required. Use 'surface' option
+        if depthlastcell < 0:
+            depthlastcell = sgn*depth_interval 
+    elif end_bin_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_bin_option` not recognized.")
+        return
+  
+    # Negative used for upward and positive for downward.
+    z = np.arange(sgn * depthfirstcell, sgn * depthlastcell, depth_interval)
     regbins = len(z)
 
-    # print(maxbins, bins, ensemble)
-    data_regrid = np.zeros((regbins, ensembles))
+    regridded_data = 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)
+        n = d + sgn*depth_interval * bins
+        # 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, depth_interval)
+        depth_bins = np.linspace(sgn*d, sgn*n, bins)
         f = sp.interpolate.interp1d(
             depth_bins,
             data[:, i],
@@ -61,9 +160,9 @@ def regrid2d(
         )
         gridz = f(z)
 
-        data_regrid[:, i] = gridz
+        regridded_data[:, i] = gridz
 
-    return z, data_regrid
+    return abs(z), regridded_data
 
 
 def regrid3d(
@@ -71,24 +170,96 @@ def regrid3d(
     vlobj,
     data,
     fill_value,
-    minimum_depth="cell",
+    end_bin_option="cell",
     trimends=None,
     method="nearest",
+    orientation="up",
+    boundary_limit=0,
 ):
+    """
+    Regrids 3D data onto a new grid based on specified parameters.
+
+    Parameters:
+    -----------
+    flobj : object
+        The fixed leader object that contains information 
+        about the fixed leader data.
+        
+    vlobj : object
+        The variable leader object that contains information 
+        about the variable leader data.
+        
+    data : array-like
+        The 3D data array to be regridded, with dimensions 
+        typically representing time, depth, and another axis (e.g., ensembles).
+        
+    fill_value : scalar
+        The value used to fill missing or undefined grid points.
+        
+    end_bin_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.
+        
+    Returns:
+    --------
+    z : array-like
+        The regridded depth array.
+    regridded_data : array-like
+        The regridded 3D data array, based on the specified method, 
+        orientation, and other parameters.
+    
+    Notes:
+    ------
+    - If `end_bin_option == boundary`, then `boundary_limit` is used to regrid the data.
+    - This function allows for flexible regridding of 3D 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.
+    - This function is an extension of 2D regridding to handle the time dimension or other additional axes in the data.
+    """
+
     beams = flobj.field()["Beams"]
     z, data_dummy = regrid2d(
         flobj,
         vlobj,
         data[0, :, :],
         fill_value,
-        minimum_depth=minimum_depth,
+        end_bin_option=end_bin_option,
         trimends=trimends,
         method=method,
+        orientation=orientation,
+        boundary_limit=boundary_limit,
     )
 
     newshape = np.shape(data_dummy)
-    data_regrid = np.zeros((beams, newshape[0], newshape[1]))
-    data_regrid[0, :, :] = data_dummy
+    regridded_data = np.zeros((beams, newshape[0], newshape[1]))
+    regridded_data[0, :, :] = data_dummy
 
     for i in range(beams - 1):
         z, data_dummy = regrid2d(
@@ -96,27 +267,13 @@ def regrid3d(
             vlobj,
             data[i + 1, :, :],
             fill_value,
-            minimum_depth=minimum_depth,
+            end_bin_option=end_bin_option,
             trimends=trimends,
             method=method,
+            orientation=orientation,
+            boundary_limit=boundary_limit,
         )
-        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)
+        regridded_data[i + 1, :, :] = data_dummy
+
+    return z, regridded_data
+

pyadps/utils/velocity_test.py

@@ -1,39 +1,74 @@
 from itertools import groupby
 
+import requests
 import numpy as np
 import scipy as sp
-import wmm2020
 
+def wmm2020api(lat1, lon1, year):
+    """
+    This function uses the WMM2020 API to retrieve the magnetic field values at a given location
+    The API need latitude, longitude and year to perform the calculation. The key in the function
+    must be updated time to time since the API is subjected to timely updates and the key may change.
+
+    Args:
+        Latitude (float)
+        Longitude (float)
+        startYear (int)
 
-def magnetic_declination(velocity, lat, lon, depth, year):
+    Returns:
+        mag -> magnetic declination at the given location in degree.
     """
-    The function uses magnetic declination from wmm2020 to correct
-    the horizontal velocities
+    baseurl = "https://www.ngdc.noaa.gov/geomag-web/calculators/calculateDeclination?"
+    key = "zNEw7"
+    resultFormat="json"
+    url = "{}lat1={}&lon1={}&key={}&startYear{}&resultFormat={}".format(baseurl, lat1, lon1, key, year, resultFormat)
+    response = requests.get(url)
+    data = response.json()
+    results = data["result"][0]
+    mag = [[results["declination"]]]
+    
+    return mag
+
+def magnetic_declination(lat, lon, depth, year):
+    """
+    The function  calculates the magnetic declination at a given location and depth.
+    using a local installation of wmm2020 model.
+
 
     Args:
-        velocity (numpy array): velocity(beam, depth, time)
         lat (parameter, float): Latitude in decimals
         lon (parameter, float): Longitude in decimals
         depth (parameter, float): depth in m
         year (parameter, integer): Year
 
     Returns:
-        velocity (numpy array): Rotated velocity using magnetic declination
         mag: Magnetic declination (degrees)
     """
+    import wmm2020
     mag = wmm2020.wmm(lat, lon, depth, year)
-    mag = np.deg2rad(mag.decl.data)
+    mag = mag.decl.data
+
+    return  mag
+
+def velocity_modifier(velocity, mag):
+    """
+    The function uses magnetic declination from wmm2020 to correct
+    the horizontal velocities
+
+    Args:
+    velocity (numpy array): velocity array
+    mag: magnetic declination  (degrees)
+
+    Returns:
+        velocity (numpy array): Rotated velocity using magnetic declination
+    """
+    mag = np.deg2rad(mag[0][0])
     velocity = np.where(velocity == -32768, np.nan, velocity)
-    velocity[0, :, :] = velocity[0, :, :] * np.cos(mag) + velocity[1, :, :] * np.sin(
-        mag
-    )
-    velocity[1, :, :] = -1 * velocity[0, :, :] * np.sin(mag) + velocity[
-        1, :, :
-    ] * np.cos(mag)
+    velocity[0, :, :] = velocity[0, :, :] * np.cos(mag) + velocity[1, :, :] * np.sin(mag)
+    velocity[1, :, :] = -1 * velocity[0, :, :] * np.sin(mag) + velocity[1, :, :] * np.cos(mag)
     velocity = np.where(velocity == np.nan, -32768, velocity)
 
-    return velocity, np.rad2deg(mag)
-
+    return velocity
 
 def velocity_cutoff(velocity, mask, cutoff=250):
     """