pyadps 0.1.0__tar.gz → 0.1.1__tar.gz

{pyadps-0.1.0 → pyadps-0.1.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: pyadps
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Python package for ADCP data processing
-Home-page: https://example.com
+Home-page: https://pyadps.readthedocs.io/en/latest/index.html
 License: MIT
 Keywords: adcp,data-processing,oceanography
 Author: P. Amol
@@ -25,7 +25,7 @@ Requires-Dist: plotly-resampler (>=0.10.0)
 Requires-Dist: pygeomag (>=1.1.0,<2.0.0)
 Requires-Dist: scipy (>=1.14.0)
 Requires-Dist: streamlit (>=1.36.0)
-Project-URL: Documentation, https://example.com/docs
+Project-URL: Documentation, https://pyadps.readthedocs.io/en/latest/index.html
 Project-URL: Repository, https://github.com/p-amol/pyadps
 Description-Content-Type: text/markdown
 

{pyadps-0.1.0 → pyadps-0.1.1}/pyproject.toml

@@ -1,13 +1,13 @@
 [tool.poetry]
 name = "pyadps"
-version = "0.1.0"
+version = "0.1.1"
 description = "A Python package for ADCP data processing"
 authors = ["P. Amol <prakashamol@gmail.com>"]
 readme = "README.md"
 license = "MIT"
-homepage = "https://example.com" # You can add your homepage URL or GitHub URL here
+homepage = "https://pyadps.readthedocs.io/en/latest/index.html" # You can add your homepage URL or GitHub URL here
 repository = "https://github.com/p-amol/pyadps" # Replace with your repository link
-documentation = "https://example.com/docs" # Optional documentation link
+documentation = "https://pyadps.readthedocs.io/en/latest/index.html" # Optional documentation link
 keywords = ["adcp", "data-processing", "oceanography"]
 include = ["utils/metadata/*.json"]
 classifiers = [

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/01_Read_File.py

@@ -182,6 +182,7 @@ date_df = pd.DataFrame(
 st.session_state.date = pd.to_datetime(date_df)
 st.session_state.date1 = pd.to_datetime(date_df)
 st.session_state.date2 = pd.to_datetime(date_df)
+st.session_state.date3 = pd.to_datetime(date_df)
 st.session_state.ensemble_axis = np.arange(0, st.session_state.head.ensembles, 1)
 st.session_state.axis_option = "time"
 
@@ -312,12 +313,12 @@ st.session_state.maxwvel_VT = 15
 
 # Tab3: Despike
 st.session_state.isDespikeCheck_VT = False
-st.session_state.despike_kernal_VT = 5
+st.session_state.despike_kernel_VT = 5
 st.session_state.despike_cutoff_VT = 3
 
 # Tab4: Flatline
 st.session_state.isFlatlineCheck_VT = False
-st.session_state.flatline_kernal_VT = 5
+st.session_state.flatline_kernel_VT = 5
 st.session_state.flatline_cutoff_VT = 3
 
 # ------------------

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/03_Download_Raw_File.py

@@ -20,6 +20,9 @@ if "fname" not in st.session_state:
 if "rawfilename" not in st.session_state:
     st.session_state.rawfilename = "rawfile.nc"
 
+if "fleadfilename" not in st.session_state:
+    st.session_state.fleadfilename = "flead.nc"
+
 if "vleadfilename" not in st.session_state:
     st.session_state.vleadfilename = "vlead.nc"
 
@@ -66,6 +69,23 @@ def file_write(path, axis_option, add_attributes=True):
             path, st.session_state.rawfilename, st.session_state.date1, axis_option
         )
 
+@st.cache_data
+def file_write_flead(path, axis_option, add_attributes=True):
+    tempvardirname = tempfile.TemporaryDirectory(delete=False)
+    st.session_state.fleadfilename = tempvardirname.name + "/flead.nc"
+
+    if add_attributes:
+        wr.flead_nc(
+            path,
+            st.session_state.fleadfilename,
+            st.session_state.date2,
+            axis_option,
+            attributes=st.session_state.attributes,
+        )
+    else:
+        wr.flead_nc(
+            path, st.session_state.fleadfilename, st.session_state.date2, axis_option
+        )
 
 @st.cache_data
 def file_write_vlead(path, axis_option, add_attributes=True):
@@ -76,13 +96,13 @@ def file_write_vlead(path, axis_option, add_attributes=True):
         wr.vlead_nc(
             path,
             st.session_state.vleadfilename,
-            st.session_state.date2,
+            st.session_state.date3,
             axis_option,
             attributes=st.session_state.attributes,
         )
     else:
         wr.vlead_nc(
-            path, st.session_state.vleadfilename, st.session_state.date2, axis_option
+            path, st.session_state.vleadfilename, st.session_state.date3, axis_option
         )
 
 
@@ -141,6 +161,9 @@ st.session_state.axis_option_DRW = st.selectbox(
 
 # Buttons to generate files
 st.session_state.rawnc_download_DRW = st.button("Generate Raw NetCDF File")
+st.session_state.fleadnc_download_DRW = st.button(
+    "Generate Raw Fixed Leader NetCDF File"
+)
 st.session_state.vleadnc_download_DRW = st.button(
     "Generate Raw Variable Leader NetCDF File"
 )
@@ -159,6 +182,20 @@ if st.session_state.rawnc_download_DRW:
             file_name="rawfile.nc",
         )
 
+if st.session_state.fleadnc_download_DRW:
+    file_write_flead(
+        st.session_state.fpath,
+        st.session_state.axis_option,
+        st.session_state.add_attributes_DRW == "Yes",
+    )
+    st.write(st.session_state.fleadfilename)
+    with open(st.session_state.fleadfilename, "rb") as file:
+        st.download_button(
+            label="Download Fixed Leader",
+            data=file,
+            file_name="flead.nc",
+        )
+
 if st.session_state.vleadnc_download_DRW:
     file_write_vlead(
         st.session_state.fpath,

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/06_Profile_Test.py

@@ -135,7 +135,7 @@ beam_angle = int(flobj.system_configuration()["Beam Angle"])
 x = np.arange(0, ensembles, 1)
 y = np.arange(0, cells, 1)
 
-# Regrided data
+# Regridded data
 # if "velocity_regrid" not in st.session_state:
 #     st.session_state.echo_regrid = np.copy(echo)
 #     st.session_state.velocity_regrid = np.copy(velocity)
@@ -472,7 +472,7 @@ tab1, tab2, tab3, tab4, tab5 = st.tabs(
         "Trim Ends",
         "Cut Bins - Sidelobe",
         "Cut Bins - Manual",
-        "Regriding",
+        "Regridding",
         "Save & Reset",
     ]
 )
@@ -731,7 +731,7 @@ with tab4:
         """
     When the ADCP buoy has vertical oscillations (greater than depth cell size), 
     the depth bins has to be regridded based on the pressure sensor data. The data
-    can be regrided either till the surface or till the last bin. 
+    can be regridded either till the surface or till the last bin. 
     If the `Cell` option is selected, ensure that the end data are trimmed.
     Manual option permits choosing the end cell depth.
     """
@@ -803,7 +803,7 @@ with tab4:
                 beams=beams,
             )
             grid_bar.progress(20, text=progress_text)
-            st.write(":grey[Regrided velocity ...]")
+            st.write(":grey[Regridded velocity ...]")
             z, st.session_state.echo_regrid = regrid3d(
                 transdepth,
                 echo,
@@ -819,7 +819,7 @@ with tab4:
                 beams=beams,
             )
             grid_bar.progress(40, text=progress_text)
-            st.write(":grey[Regrided echo intensity ...]")
+            st.write(":grey[Regridded echo intensity ...]")
             z, st.session_state.correlation_regrid = regrid3d(
                 transdepth,
                 correlation,
@@ -835,7 +835,7 @@ with tab4:
                 beams=beams,
             )
             grid_bar.progress(60, text=progress_text)
-            st.write(":grey[Regrided correlation...]")
+            st.write(":grey[Regridded correlation...]")
             z, st.session_state.pgood_regrid = regrid3d(
                 transdepth,
                 pgood,
@@ -851,7 +851,7 @@ with tab4:
                 beams=beams,
             )
             grid_bar.progress(80, text=progress_text)
-            st.write(":grey[Regrided percent good...]")
+            st.write(":grey[Regridded percent good...]")
 
             z, st.session_state.profile_mask_regrid = regrid2d(
                 transdepth,
@@ -868,13 +868,13 @@ with tab4:
             )
 
             grid_bar.progress(99, text=progress_text)
-            st.write(":grey[Regrided mask...]")
+            st.write(":grey[Regridded mask...]")
 
             st.session_state.depth_axis = z
             st.write(":grey[New depth axis created...]")
 
             grid_bar.progress(100, text="Completed")
-            st.write(":green[All data regrided!]")
+            st.write(":green[All data regridded!]")
 
             st.write(
                 "No. of grid depth bins before regridding: ", np.shape(velocity)[1]

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/07_Velocity_Test.py

@@ -379,15 +379,15 @@ with tab3:
     ############## DESPIKE DATA #################
     st.header("Despike Data", divider="blue")
     st.write("""A rolling median filter is applied to remove spikes from the data.
-    The kernal size determines the number of ensembles (time interval) for the filter window.
+    The kernel size determines the number of ensembles (time interval) for the filter window.
     The standard deviation specifies the maximum allowable deviation to remove the spike.""")
 
     # time_interval = pd.Timedelta(st.session_state.date[-1] - st.session_state.date[0]).seconds/(3600*st.session_state.head.ensembles)
 
     st.write("Time interval: ", st.session_state.date[1] - st.session_state.date[0])
 
-    despike_kernal = st.number_input(
-        "Enter Despike Kernal Size for Median Filter",
+    despike_kernel = st.number_input(
+        "Enter Despike kernel Size for Median Filter",
         0,
         st.session_state.head.ensembles,
         5,
@@ -399,19 +399,19 @@ with tab3:
     )
     despike_button = st.button("Despike")
     if despike_button:
-        st.session_state.despike_kernal_VT = despike_kernal
+        st.session_state.despike_kernel_VT = despike_kernel
         st.session_state.despike_cutoff_VT = despike_cutoff
 
         st.session_state.velocity_mask_despike = despike(
             velocity[0, :, :],
             st.session_state.velocity_mask_temp,
-            kernal_size=despike_kernal,
+            kernel_size=despike_kernel,
             cutoff=despike_cutoff,
         )
         st.session_state.velocity_mask_despike = despike(
             velocity[1, :, :],
             st.session_state.velocity_mask_temp,
-            kernal_size=despike_kernal,
+            kernel_size=despike_kernel,
             cutoff=despike_cutoff,
         )
 
@@ -424,7 +424,7 @@ with tab3:
     if st.session_state.isDespikeCheck_VT:
         st.success("Data Despiked")
         b = {
-            "Kernal Size": despike_kernal,
+            "kernel Size": despike_kernel,
             "Despike Cutoff": despike_cutoff,
         }
         st.write(b)
@@ -462,31 +462,31 @@ with tab4:
 
     st.write("Time interval: ", st.session_state.date[1] - st.session_state.date[0])
 
-    flatline_kernal = st.number_input("Enter Flatline Kernal Size", 0, 100, 13, 1)
+    flatline_kernel = st.number_input("Enter Flatline kernel Size", 0, 100, 13, 1)
     flatline_cutoff = st.number_input("Enter Flatline deviation (mm/s)", 0, 100, 1, 1)
 
     flatline_button = st.button("Remove Flatline")
 
     if flatline_button:
-        st.session_state.flatline_kernal_VT = flatline_kernal
+        st.session_state.flatline_kernel_VT = flatline_kernel
         st.session_state.flatline_cutoff_VT = flatline_cutoff
 
         st.session_state.velocity_mask_flatline = flatline(
             velocity[0, :, :],
             st.session_state.velocity_mask_temp,
-            kernal_size=flatline_kernal,
+            kernel_size=flatline_kernel,
             cutoff=flatline_cutoff,
         )
         st.session_state.velocity_mask_flatline = flatline(
             velocity[1, :, :],
             st.session_state.velocity_mask_temp,
-            kernal_size=flatline_kernal,
+            kernel_size=flatline_kernel,
             cutoff=flatline_cutoff,
         )
         st.session_state.velocity_mask_flatline = flatline(
             velocity[2, :, :],
             st.session_state.velocity_mask_temp,
-            kernal_size=flatline_kernal,
+            kernel_size=flatline_kernel,
             cutoff=flatline_cutoff,
         )
         # Modify the temporary mask file
@@ -498,7 +498,7 @@ with tab4:
     if st.session_state.isFlatlineCheck:
         st.success("Flatline Removed")
         b = {
-            "Kernal Size": flatline_kernal,
+            "kernel Size": flatline_kernel,
             "Flatline Cutoff": flatline_cutoff,
         }
         st.write(b)

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/08_Write_File.py

@@ -198,12 +198,12 @@ st.session_state.mask_data_WF = st.radio(
 
 if st.session_state.mask_data_WF == "Yes":
     mask = st.session_state.final_mask
-    st.session_state.write_velocity = np.copy(st.session_state.final_velocity)
+    st.session_state.write_velocity = np.copy(st.session_state.final_velocity).astype(np.int16)
     st.session_state.write_velocity[:, mask == 1] = -32768
+    
 else:
     st.session_state.write_velocity = np.copy(st.session_state.final_velocity)
 
-
 st.session_state.file_type_WF = st.radio(
     "Select output file format:", ("NetCDF", "CSV")
 )
@@ -262,6 +262,9 @@ if download_button:
     #    st.write(st.session_state.processed_filename)
     depth_axis = np.trunc(st.session_state.final_depth_axis)
     final_mask = st.session_state.final_mask
+    st.session_state.write_echo = np.copy(st.session_state.final_echo)
+    st.session_state.write_correlation = np.copy(st.session_state.final_correlation)
+    st.session_state.write_pgood = np.copy(st.session_state.final_pgood)
 
     if st.session_state.file_type_WF == "NetCDF":
         if add_attr_button and st.session_state.attributes:
@@ -270,6 +273,9 @@ if download_button:
                 st.session_state.processed_filename,
                 depth_axis,
                 final_mask,
+                st.session_state.write_echo,
+                st.session_state.write_correlation,
+                st.session_state.write_pgood,
                 st.session_state.date,
                 st.session_state.write_velocity,
                 attributes=st.session_state.attributes,  # Pass edited attributes
@@ -280,6 +286,9 @@ if download_button:
                 st.session_state.processed_filename,
                 depth_axis,
                 final_mask,
+                st.session_state.write_echo,
+                st.session_state.write_correlation,
+                st.session_state.write_pgood,
                 st.session_state.date,
                 st.session_state.write_velocity,
             )
@@ -370,6 +379,7 @@ if generate_config_radio == "Yes":
     config["FileSettings"]["input_file_name"] = st.session_state.fname
     config["FileSettings"]["output_file_path"] = ""
     config["FileSettings"]["output_file_name_raw_netcdf"] = ""
+    config["FileSettings"]["output_file_name_flead_netcdf"] = ""
     config["FileSettings"]["output_file_name_vlead_netcdf"] = ""
     config["FileSettings"]["output_file_name_raw_csv"] = ""
     config["FileSettings"]["output_file_name_processed_netcdf"] = ""
@@ -386,6 +396,9 @@ if generate_config_radio == "Yes":
     config["DownloadOptions"]["download_raw_netcdf"] = str(
         st.session_state.rawnc_download_DRW
     )
+    config["DownloadOptions"]["download_flead_netcdf"] = str(
+        st.session_state.fleadnc_download_DRW
+    )
     config["DownloadOptions"]["download_vlead_netcdf"] = str(
         st.session_state.vleadnc_download_DRW
     )
@@ -534,15 +547,15 @@ if generate_config_radio == "Yes":
 
     # Tab 3
     config["VelocityTest"]["despike"] = str(st.session_state.isDespikeCheck_VT)
-    config["VelocityTest"]["despike_kernal_size"] = str(
-        st.session_state.despike_kernal_VT
+    config["VelocityTest"]["despike_kernel_size"] = str(
+        st.session_state.despike_kernel_VT
     )
     config["VelocityTest"]["despike_cutoff"] = str(st.session_state.despike_cutoff_VT)
 
     # Tab 4
     config["VelocityTest"]["flatline"] = str(st.session_state.isFlatlineCheck_VT)
-    config["VelocityTest"]["flatline_kernal_size"] = str(
-        st.session_state.flatline_kernal_VT
+    config["VelocityTest"]["flatline_kernel_size"] = str(
+        st.session_state.flatline_kernel_VT
     )
     config["VelocityTest"]["flatline_cutoff"] = str(st.session_state.flatline_cutoff_VT)
 

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/09_Auto_process.py

@@ -6,6 +6,8 @@ import json
 import streamlit as st
 from utils.autoprocess import autoprocess
 
+# To make the page wider if the user presses the reload button.
+st.set_page_config(layout="wide")
 
 @st.cache_data
 def file_access(uploaded_file):

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/utils/autoprocess.py

@@ -378,44 +378,44 @@ def autoprocess(config_file, binary_file_path=None):
 
         isDespike = config.getboolean("VelocityTest", "despike")
         if isDespike:
-            despike_kernal = config.getint("VelocityTest", "despike_kernal_size")
-            despike_cutoff = config.getint("VelocityTest", "despike_cutoff")
+            despike_kernel = config.getint("VelocityTest", "despike_kernel_size")
+            despike_cutoff = config.getfloat("VelocityTest", "despike_cutoff")
 
             mask = despike(
                 velocity[0, :, :],
                 mask,
-                kernal_size=despike_kernal,
+                kernel_size=despike_kernel,
                 cutoff=despike_cutoff,
             )
             mask = despike(
                 velocity[1, :, :],
                 mask,
-                kernal_size=despike_kernal,
+                kernel_size=despike_kernel,
                 cutoff=despike_cutoff,
             )
             print("Velocity data despiked.")
 
         isFlatline = config.getboolean("VelocityTest", "flatline")
         if isFlatline:
-            despike_kernal = config.getint("VelocityTest", "flatline_kernal_size")
+            despike_kernel = config.getint("VelocityTest", "flatline_kernel_size")
             despike_cutoff = config.getint("VelocityTest", "flatline_deviation")
 
             mask = flatline(
                 velocity[0, :, :],
                 mask,
-                kernal_size=despike_kernal,
+                kernel_size=despike_kernel,
                 cutoff=despike_cutoff,
             )
             mask = flatline(
                 velocity[1, :, :],
                 mask,
-                kernal_size=despike_kernal,
+                kernel_size=despike_kernel,
                 cutoff=despike_cutoff,
             )
             mask = flatline(
                 velocity[2, :, :],
                 mask,
-                kernal_size=despike_kernal,
+                kernel_size=despike_kernel,
                 cutoff=despike_cutoff,
             )
 
@@ -463,6 +463,7 @@ def autoprocess(config_file, binary_file_path=None):
     )
 
     date_raw = pd.to_datetime(date_df)
+    date_flead = pd.to_datetime(date_df)
     date_vlead = pd.to_datetime(date_df)
     date_final = pd.to_datetime(date_df)
 
@@ -477,6 +478,7 @@ def autoprocess(config_file, binary_file_path=None):
         attributes = None
 
     isWriteRawNC = config.getboolean("DownloadOptions", "download_raw_netcdf")
+    isWritefleadNc = config.getboolean("DownloadOptions", "download_flead_netcdf")
     isWriteVleadNC = config.getboolean("DownloadOptions", "download_vlead_netcdf")
     isWriteProcNC = config.getboolean("DownloadOptions", "download_processed_netcdf")
     filepath = config.get("FileSettings", "output_file_path")
@@ -496,6 +498,19 @@ def autoprocess(config_file, binary_file_path=None):
 
         print("Raw file written.")
 
+    if isWritefleadNc:
+        filename = config.get("FileSettings", "output_file_name_flead_netcdf")
+        output_file_path = os.path.join(filepath, filename)
+        wr.flead_nc(
+            full_input_file_path,
+            output_file_path,
+            date_flead,
+            axis_option=axis_option,
+            attributes=attributes,
+        )
+
+        print("Flead File written")
+
     if isWriteVleadNC:
         filename = config.get("FileSettings", "output_file_name_vlead_netcdf")
         output_file_path = os.path.join(filepath, filename)
@@ -519,6 +534,9 @@ def autoprocess(config_file, binary_file_path=None):
             output_file_path,
             depth1,
             mask,
+            echo,
+            correlation,
+            pgood,
             date_final,
             velocity,
             attributes=attributes,  # Pass edited attributes

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/utils/pyreadrdi.py

@@ -890,7 +890,7 @@ def datatype(
 
     # These arguments are outputs of fixedleader function.
     # Makes the code faster if the fixedheader function is already executed.
-    if cell == 0 or beam == 0:
+    if isinstance(cell, (np.integer, int)) or isinstance(beam, (np.integer, int)):
         flead, ensemble, fl_error_code = fixedleader(
             filename,
             byteskip=byteskip,
@@ -898,22 +898,23 @@ def datatype(
             idarray=idarray,
             ensemble=ensemble,
         )
-        cell = int(flead[7][0])
-        beam = int(flead[6][0])
+        cell = []
+        beam = []
+        cell = flead[7][:]
+        beam = flead[6][:]
         if fl_error_code != 0:
             error_code = fl_error_code
     else:
-        cell = int(cell)
-        beam = int(beam)
-
+        cell = cell
+        beam = beam
     # Velocity is 16 bits and all others are 8 bits.
     # Create empty array for the chosen variable name.
     if var_name == "velocity":
-        var_array = np.zeros((beam, cell, ensemble), dtype="int16")
+        var_array = np.full((int(max(beam)), int(max(cell)), ensemble), -32768, dtype="int16")
         bitstr = "<h"
         bitint = 2
     else:  # inserted
-        var_array = np.zeros((beam, cell, ensemble), dtype="uint8")
+        var_array = np.zeros((int(max(beam)), int(max(cell)), ensemble), dtype="uint8")
         bitstr = "<B"
         bitint = 1
     # -----------------------------
@@ -942,7 +943,9 @@ def datatype(
     fbyteskip = None
     for count, item in enumerate(idarray[0][:]):
         if item in vid:
-            fbyteskip = offset[0][count]
+            fbyteskip = []
+            for i in range(ensemble):
+                fbyteskip.append(int(offset[i][count]))
             break
     if fbyteskip is None:
         print(
@@ -955,10 +958,10 @@ def datatype(
 
     # READ DATA
     for i in range(ensemble):
-        bfile.seek(fbyteskip, 1)
+        bfile.seek(fbyteskip[i], 1)
         bdata = bfile.read(2)
-        for cno in range(cell):
-            for bno in range(beam):
+        for cno in range(int(cell[i])):
+            for bno in range(int(beam[i])):
                 bdata = bfile.read(bitint)
                 varunpack = unpack(bitstr, bdata)
                 var_array[bno][cno][i] = varunpack[0]

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/utils/script.py

@@ -160,33 +160,33 @@ def run_script(filename):
 
     affirm = input("Despike the data? [y/n]: ")
     if affirm.lower() == "y":
-        despike_kernal = input("Enter despike kernal size:")
-        despike_kernal = int(despike_kernal)
+        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, kernal_size=despike_kernal, cutoff=despike_cutoff
+            vel[0, :, :], mask, kernel_size=despike_kernel, cutoff=despike_cutoff
         )
         mask = despike(
-            vel[1, :, :], mask, kernal_size=despike_kernal, cutoff=despike_cutoff
+            vel[1, :, :], mask, kernel_size=despike_kernel, 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_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, kernal_size=flatline_kernal, cutoff=flatline_cutoff
+            vel[0, :, :], mask, kernel_size=flatline_kernel, cutoff=flatline_cutoff
         )
         mask = flatline(
-            vel[1, :, :], mask, kernal_size=flatline_kernal, cutoff=flatline_cutoff
+            vel[1, :, :], mask, kernel_size=flatline_kernel, cutoff=flatline_cutoff
         )
         mask = flatline(
-            vel[2, :, :], mask, kernal_size=flatline_kernal, cutoff=flatline_cutoff
+            vel[2, :, :], mask, kernel_size=flatline_kernel, cutoff=flatline_cutoff
         )
     apply_mask = input("Apply mask? [y/n]: ")
     if apply_mask.lower() == "y":

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/utils/velocity_test.py

@@ -132,7 +132,7 @@ def velocity_cutoff(velocity, mask, cutoff=250):
     return mask
 
 
-def despike(velocity, mask, kernal_size=13, cutoff=3):
+def despike(velocity, mask, kernel_size=13, cutoff=3):
     """
     Function to remove anomalous spikes in the data over a period of time.
     A median filter is used to despike the data.
@@ -140,7 +140,7 @@ def despike(velocity, mask, kernal_size=13, cutoff=3):
     Args:
         velocity (numpy array, integer): Velocity(depth, time) in mm/s
         mask (numpy array, integer): Mask file
-        kernal_size (paramater, integer): Window size for rolling median filter
+        kernel_size (paramater, integer): Window size for rolling median filter
         cutoff (parameter, integer): Number of standard deviations to identify spikes
 
     Returns:
@@ -150,7 +150,7 @@ def despike(velocity, mask, kernal_size=13, cutoff=3):
     shape = np.shape(velocity)
     for j in range(shape[0]):
         # Apply median filter
-        filt = sp.signal.medfilt(velocity[j, :], kernal_size)
+        filt = sp.signal.medfilt(velocity[j, :], kernel_size)
         # Calculate absolute deviation from the rolling median
         diff = np.abs(velocity[j, :] - filt)
         # Calculate threshold for spikes based on standard deviation
@@ -164,7 +164,7 @@ def despike(velocity, mask, kernal_size=13, cutoff=3):
 def flatline(
     velocity,
     mask,
-    kernal_size=4,
+    kernel_size=4,
     cutoff=1,
 ):
     """
@@ -174,7 +174,7 @@ def flatline(
     Args:
         velocity (numpy arrray, integer): Velocity (depth, time)
         mask (numpy  array, integer): Mask file
-        kernal_size (parameter, integer): No. of ensembles over which flatline has to be detected
+        kernel_size (parameter, integer): No. of ensembles over which flatline has to be detected
         cutoff (parameter, integer): Permitted deviation in velocity
 
     Returns:
@@ -191,7 +191,7 @@ def flatline(
         for k, g in groupby(dummymask):
             # subset_size = sum(1 for i in g)
             subset_size = len(list(g))
-            if k == 1 and subset_size >= kernal_size:
+            if k == 1 and subset_size >= kernel_size:
                 mask[j, index : index + subset_size] = 1
             index = index + subset_size
         dummymask = np.zeros(shape[1])

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/utils/writenc.py

@@ -179,6 +179,74 @@ def rawnc(
 
     outnc.close()
 
+def flead_nc(
+    infile,
+    outfile,
+    time,
+    axis_option=None,
+    attributes=None,
+    t0="hours since 2000-01-01",
+):
+    """
+    Function to create ncfile containing Variable Leader.
+
+    Args:
+        infile (string): Input file path including filename
+        outfile (string): Output file path including filename
+    """
+    outnc = nc4.Dataset(outfile, "w", format="NETCDF4")
+
+    # Dimensions
+    # Define the primary axis based on axis_option
+    if axis_option == "ensemble":
+        outnc.createDimension("ensemble", None)
+        primary_axis = "ensemble"
+        ensemble = outnc.createVariable("ensemble", "i4", ("ensemble",))
+        ensemble.axis = "T"
+    elif axis_option == "time":
+        tsize = len(time)
+        outnc.createDimension("time", tsize)
+        primary_axis = "time"
+        time_var = outnc.createVariable("time", "i4", ("time",))
+        time_var.axis = "T"
+        time_var.units = t0
+        time_var.long_name = "time"
+
+        # Convert time_data to numerical format
+        nctime = pd2nctime(time, t0)
+        time_var[:] = nctime
+
+    else:
+        raise ValueError(f"Invalid axis_option: {axis_option}.")
+
+    # Variables
+
+    flead = rd.FixedLeader(infile)
+    fdict = flead.fleader
+    varid = [0] * len(fdict)
+
+    i = 0
+
+    for key, values in fdict.items():
+        format_item = key.replace(" ", "_")
+        varid[i] = outnc.createVariable(
+            format_item, "i4", primary_axis, fill_value=-32768
+        )
+        var = values
+        vshape = var.shape
+        if i == 0:
+            if primary_axis == "ensemble":
+                ensemble[:] = np.arange(1, vshape[0] + 1, 1)
+
+        varid[i][0 : vshape[0]] = var
+        i += 1
+
+    # Add global attributes if provided
+    if attributes:
+        for key, value in attributes.items():
+            setattr(outnc, key, str(value))  # Store attributes as strings
+
+    outnc.close()
 
 def vlead_nc(
     infile,
@@ -251,7 +319,7 @@ def vlead_nc(
 
 
 def finalnc(
-    outfile, depth, final_mask, time, data, t0="hours since 2000-01-01", attributes=None
+    outfile, depth, final_mask, final_echo, final_corr , final_pgood, time, data, t0="hours since 2000-01-01", attributes=None
 ):
     """
     Function to create the processed NetCDF file.
@@ -277,6 +345,9 @@ def finalnc(
         depth = depth[::-1]
         data = data[:, ::-1, :]
         final_mask = final_mask[::-1, :]
+        final_echo = final_echo[:,::-1, :]
+        final_corr = final_corr[:,::-1, :]
+        final_pgood = final_pgood[:,::-1, :]
 
     ncfile = nc4.Dataset(outfile, mode="w", format="NETCDF4")
     # Check if depth is scalar or array
@@ -319,6 +390,42 @@ def finalnc(
     mvel = ncfile.createVariable("mask", np.float32, ("time", "depth"), fill_value=fill)
     mvel.long_name = "Velocity Mask (1: bad value, 0: good value)"
 
+    echo1 = ncfile.createVariable("echo1", np.float32, ("time", "depth"), fill_value=-32768)
+    echo1.long_name = "Echo intensity Beam 1"
+
+    echo2 = ncfile.createVariable("echo2", np.float32, ("time", "depth"), fill_value=-32768)
+    echo2.long_name = "Echo intensity Beam 2"
+
+    echo3 = ncfile.createVariable("echo3", np.float32, ("time", "depth"), fill_value=-32768)
+    echo3.long_name = "Echo intensity Beam 3"
+
+    echo4 = ncfile.createVariable("echo4", np.float32, ("time", "depth"), fill_value=-32768)
+    echo4.long_name = "Echo intensity Beam 4"
+
+    corr1 = ncfile.createVariable("corr1", np.float32, ("time", "depth"), fill_value=-32768)
+    corr1.long_name = "Beam 1 correlation"
+
+    corr2 = ncfile.createVariable("corr2", np.float32, ("time", "depth"), fill_value=-32768)
+    corr2.long_name = "Beam 2 correlation"
+
+    corr3 = ncfile.createVariable("corr3", np.float32, ("time", "depth"), fill_value=-32768)
+    corr3.long_name = "Beam 3 correlation"
+
+    corr4 = ncfile.createVariable("corr4", np.float32, ("time", "depth"), fill_value=-32768)
+    corr4.long_name = "Beam 4 correlation"  
+
+    pgd1 = ncfile.createVariable("pgd1", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd1.long_name = "Percent Good Beam 1"
+
+    pgd2 = ncfile.createVariable("pgd2", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd2.long_name = "Percent Good Beam 2"
+
+    pgd3 = ncfile.createVariable("pgd3", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd3.long_name = "Percent Good Beam 3"
+
+    pgd4 = ncfile.createVariable("pgd4", np.float32, ("time", "depth"), fill_value=-32768)
+    pgd4.long_name = "Percent Good Beam 4"   
+
     nctime = pd2nctime(time, t0)
     # write data
     z[:] = depth
@@ -328,6 +435,18 @@ def finalnc(
     wvel[:, :] = data[2, :, :].T
     evel[:, :] = data[3, :, :].T
     mvel[:, :] = final_mask.T
+    echo1[:, :] = final_echo[0, :, :].T
+    echo2[:, :] = final_echo[1, :, :].T
+    echo3[:, :] = final_echo[2, :, :].T
+    echo4[:, :] = final_echo[3, :, :].T
+    corr1[:, :] = final_corr[0, :, :].T
+    corr2[:, :] = final_corr[1, :, :].T
+    corr3[:, :] = final_corr[2, :, :].T
+    corr4[:, :] = final_corr[3, :, :].T
+    pgd1[:, :] = final_pgood[0, :, :].T
+    pgd2[:, :] = final_pgood[1, :, :].T
+    pgd3[:, :] = final_pgood[2, :, :].T
+    pgd4[:, :] = final_pgood[3, :, :].T
 
     # Add global attributes if provided
     if attributes:

{pyadps-0.1.0 → pyadps-0.1.1}/src/pyadps/pages/04_Sensor_Health.py

@@ -289,8 +289,8 @@ tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8 = st.tabs(
         "Salinity",
         "Temperature",
         "Heading",
-        "Roll",
         "Pitch",
+        "Roll",
         "Corrections",
         "Save/Reset",
     ]