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

pyadps/pages/01_Read_File.py

@@ -110,6 +110,7 @@ if uploaded_file is not None:
     correlation = ds.correlation.data
     echo = ds.echo.data
     pgood = ds.percentgood.data
+    beamdir = ds.fixedleader.system_configuration()['Beam Direction']
 
     st.session_state.fname = uploaded_file.name
     st.session_state.head = ds.fileheader
@@ -119,6 +120,7 @@ if uploaded_file is not None:
     st.session_state.echo = ds.echo.data
     st.session_state.correlation = ds.correlation.data
     st.session_state.pgood = ds.percentgood.data
+    st.session_state.beam_direction = beamdir
 
     # st.session_state.flead = flead
     # st.session_state.vlead = vlead

pyadps/pages/03_Download_Raw_File.py

@@ -46,24 +46,27 @@ def read_file(filepath):
     st.session_state.ds = ds
 
 @st.cache_data
-def file_write(path, add_attributes=True):
+def file_write(path, axis_option, add_attributes=True):
     tempdirname = tempfile.TemporaryDirectory(delete=False)
     st.session_state.rawfilename = tempdirname.name + "/rawfile.nc"
     
     if add_attributes:
-        wr.main(path, st.session_state.rawfilename, attributes=st.session_state.attributes)
+        wr.rawnc(path, st.session_state.rawfilename, st.session_state.date, axis_option, attributes=st.session_state.attributes)
     else:
-        wr.main(path, st.session_state.rawfilename)
+        wr.rawnc(path, st.session_state.rawfilename, st.session_state.date,axis_option)
 
 @st.cache_data
-def file_write_vlead(path, add_attributes=True):
+def file_write_vlead(path, axis_option, add_attributes=True):
     tempvardirname = tempfile.TemporaryDirectory(delete=False)
     st.session_state.vleadfilename = tempvardirname.name + "/vlead.nc"
     
     if add_attributes:
-        wr.vlead_nc(path, st.session_state.vleadfilename, attributes=st.session_state.attributes)
+        wr.vlead_nc(path, st.session_state.vleadfilename, st.session_state.date, axis_option, attributes=st.session_state.attributes)
     else:
-        wr.vlead_nc(path, st.session_state.vleadfilename)
+        wr.vlead_nc(path, st.session_state.vleadfilename, st.session_state.date, axis_option)
+
+if "axis_option" not in st.session_state:
+    st.session_state.axis_option = "ensemble"  # Default value
 
 # UI for attribute selection
 st.header("NetCDF File", divider="blue")
@@ -97,13 +100,23 @@ if add_attributes == "Yes":
         st.session_state.attributes['Comments'] = st.text_area("Comments")
 
     st.write("Attributes will be added to the NetCDF file once you submit.")
-    
+
+# Dropdown for axis_option
+axis_option = st.selectbox(
+    "Select x-axis option:",
+    options=["ensemble", "time"],
+    index=0  # Default to "ensemble"
+)
+
+# Ensure it is passed correctly
+st.session_state.axis_option = axis_option
+
 # Buttons to generate files
 download_button = st.button("Generate Raw NetCDF File")
 download_var_button = st.button("Generate Raw Variable Leader NetCDF File")
 
 if download_button:
-    file_write(st.session_state.fpath, add_attributes == "Yes")
+    file_write(st.session_state.fpath,   st.session_state.axis_option , add_attributes == "Yes")
     st.write(st.session_state.rawfilename)
     with open(st.session_state.rawfilename, "rb") as file:
         st.download_button(
@@ -113,7 +126,7 @@ if download_button:
         )
 
 if download_var_button:
-    file_write_vlead(st.session_state.fpath, add_attributes == "Yes")
+    file_write_vlead(st.session_state.fpath,  st.session_state.axis_option, add_attributes == "Yes")
     st.write(st.session_state.vleadfilename)
     with open(st.session_state.vleadfilename, "rb") as file:
         st.download_button(

pyadps/pages/04_QC_Test.py

@@ -5,6 +5,7 @@ import plotly.graph_objects as go
 import streamlit as st
 from plotly.subplots import make_subplots
 from plotly_resampler import FigureResampler
+from streamlit.runtime.state import session_state
 from utils.signal_quality import ev_check, false_target, pg_check, qc_check
 
 if "flead" not in st.session_state:
@@ -134,11 +135,25 @@ plot_noise(dep=dn, rec=rn)
 ################## QC Test ###################
 
 st.header("Quality Control Tests", divider="blue")
+st.write("")
 
 left, right = st.columns([1, 1])
 with left:
-    st.write("Thresholds used during deployment")
+    st.write(""" Teledyne RDI recommends these quality control tests, 
+                 some of which can be configured before deployment. 
+                 The pre-deployment values configured for the ADCP are listed 
+                 in the table below. The noise-floor identification graph above 
+                 can assist in determining the echo intensity threshold. 
+                 For more information about these tests, 
+                 refer to *Acoustic Doppler Current Profiler Principles of 
+                 Operation: A Practical Primer* by Teledyne RDI.""")
     fdata = st.session_state.flead.field()
+    st.divider()
+    st.write(":blue-background[Additional Information:]")
+    st.write(f"Number of Pings per Ensemble: `{fdata["Pings"]}`")
+    st.write(f"Number of Beams: `{fdata["Beams"]}`")
+    st.divider()
+    st.write(":red-background[Thresholds used during deployment:]")
     thresh = pd.DataFrame(
         [
             ["Correlation", fdata["Correlation Thresh"]],
@@ -222,7 +237,7 @@ with left:
         st.session_state.mask = mask
 
     if st.session_state.isThresh:
-        st.write("Current Thresholds")
+        st.write(":green-background[Current Thresholds]")
         st.write(st.session_state.newthresh)
 
 
@@ -237,7 +252,7 @@ Ensure to save any necessary changes or apply additional thresholds if needed.
 
 
 if st.button("Display mask file"):
-    st.header("Default Mask File", divider="blue")
+    st.subheader("Default Mask File")
     st.write(
     """
 ADCP assigns missing values based on thresholds set before deployment.
@@ -247,7 +262,7 @@ These values cannot be recovered and the default
     fillplot_plotly(st.session_state.orig_mask, colorscale="greys")
 
 
-    st.header("Update Mask File", divider="blue")
+    st.subheader("Update Mask File")
     st.write(
     """
 Update, display and save the updated mask file after applying threshold.
@@ -257,8 +272,36 @@ If thresholds are not saved, default mask file is used.
 # values, counts = np.unique(mask, return_counts=True)
     fillplot_plotly(st.session_state.mask, colorscale="greys")
 
-col1, col2 = st.columns([1, 1])
+############## SENSOR HEALTH ######################
+st.header("Sensor Health", divider="blue")
+st.write("The following details can be used to determine whether the additional sensors are functioning properly.")
+# ################## Pressure Sensor Check ###################
+# st.subheader("Pressure Sensor Check", divider="orange")
+#
+# st.subheader("Temperature Sensor Check", divider="orange")
+#
+# st.subheader("Tilt Sensor Check", divider="orange")
+################## Fix Orientation ###################
+st.subheader("Fix Orientation", divider="orange")
+
+
+if st.session_state.beam_direction == 'Up':
+    beamalt = 'Down' 
+else:
+    beamalt = 'Up'
+st.write(f"The current orientation of ADCP is `{st.session_state.beam_direction}`. Use the below option to correct the orientation.")
+
+beamdir_select = st.radio(f'Change orientation to {beamalt}', ['No', 'Yes'])
+if beamdir_select == 'Yes':
+    st.session_state.beam_direction = beamalt
+    st.write(f"The orientation changed to `{st.session_state.beam_direction}`")
+
 
+
+
+################## Save Button #############
+st.header("Save Data", divider="blue")
+col1, col2 = st.columns([1, 1])
 with col1:
     save_mask_button = st.button(label="Save Mask Data")
 
@@ -281,3 +324,11 @@ with col2:
         st.session_state.isProfileMask = False
         st.session_state.isVelocityMask = False
         st.write(":green[Mask data is reset to default]")
+
+
+
+
+
+
+
+

pyadps/pages/05_Profile_Test.py

@@ -5,7 +5,7 @@ import plotly.graph_objects as go
 import streamlit as st
 from plotly.subplots import make_subplots
 from plotly_resampler import FigureResampler
-from utils.profile_test import side_lobe_beam_angle
+from utils.profile_test import side_lobe_beam_angle, manual_cut_bins
 from utils.regrid import regrid2d, regrid3d
 from utils.signal_quality import default_mask
 
@@ -79,6 +79,7 @@ def fillplot_plotly(
     data, title="data", maskdata=None, missing=-32768, colorscale="balance"
 ):
     fig = FigureResampler(go.Figure())
+    data = np.int32(data)
     data1 = np.where(data == missing, np.nan, data)
     fig.add_trace(
         go.Heatmap(
@@ -98,7 +99,7 @@ def fillplot_plotly(
                 colorscale="gray",
                 hoverongaps=False,
                 showscale=False,
-                opacity=0.5,
+                opacity=0.7,
             )
         )
     fig.update_layout(
@@ -113,6 +114,7 @@ def fillplot_plotly(
 
 def fillselect_plotly(data, title="data", colorscale="balance"):
     fig = FigureResampler(go.Figure())
+    data = np.int32(data)
     data1 = np.where(data == -32768, None, data)
     fig.add_trace(
         go.Heatmap(
@@ -215,8 +217,10 @@ m = 20
 if "update_mask" not in st.session_state:
     st.session_state.update_mask = False
     st.session_state.endpoints = None
+    st.session_state.isTrimEnds = False
 if "update_mask_cutbin" not in st.session_state:
     st.session_state.update_mask_cutbin = False
+    st.session_state.isCutBins = False
 
 ens_range = st.number_input("Change range", x[0], x[-1], 20)
 start_ens = st.slider("Deployment Ensembles", 0, ens_range, 0)
@@ -226,7 +230,7 @@ n = int(ens_range)
 
 if start_ens or end_ens:
     trim_ends(start_ens=start_ens, end_ens=end_ens, ens_range=n)
-    st.session_state.update_mask = False
+    # st.session_state.update_mask = False
 
 update_mask = st.button("Update mask data")
 if update_mask:
@@ -246,6 +250,7 @@ if update_mask:
     )
     st.write(st.session_state.endpoints)
     st.session_state.update_mask = True
+    st.session_state.isTrimEnds = True
 
 if not st.session_state.update_mask:
     st.write(":red[mask data not updated]")
@@ -268,13 +273,22 @@ beam = beam - 1
 st.session_state.beam = beam
 fillplot_plotly(echo[beam, :, :], title="Echo Intensity")
 
+orientation = st.session_state.beam_direction
+st.write(f"The orientation is `{orientation}`.")
+water_column_depth = 0
 with st.form(key="cutbin_form"):
     extra_cells = st.number_input("Additional Cells to Delete", 0, 10, 0)
+    if orientation.lower() == 'down':
+        water_column_depth = st.number_input("Enter water column depth (m): ", 0, 15000, 0) 
+
     cut_bins_mask = st.form_submit_button(label="Cut bins")
 
     if cut_bins_mask:
         st.session_state.extra_cells = extra_cells
-        mask = side_lobe_beam_angle(flobj, vlobj, mask, extra_cells=extra_cells)
+        mask = side_lobe_beam_angle(flobj, vlobj, mask, 
+                                    orientation=orientation,
+                                    water_column_depth=water_column_depth,
+                                    extra_cells=extra_cells)
         fillplot_plotly(
             echo[beam, :, :],
             title="Echo Intensity (Masked)",
@@ -287,14 +301,140 @@ if update_mask_cutbin:
     st.session_state.maskp = mask
     st.write(":green[mask file updated]")
     st.session_state.update_mask_cutbin = True
+    st.session_state.isCutBins = True
 
 if not st.session_state.update_mask_cutbin:
     st.write(":red[mask file not updated]")
 
 
-############ CUT BINS: Manual #################
+########### CUT BINS: Manual #################
 st.header("Cut Bins: Manual", divider="blue")
+# Reset mask
+# Selection of variable (Velocity, Echo Intensity, etc.)
+variable = st.selectbox(
+    "Select Variable to Display",
+    ("Velocity", "Echo Intensity", "Correlation", "Percentage Good")
+)
+
+# Map variable selection to corresponding data
+data_dict = {
+    "Velocity": velocity,
+    "Echo Intensity": echo,
+    "Correlation": correlation,
+    "Percentage Good": pgood,
+}
+
+# User selects beam (1-4)
+beam = st.radio("Select beam", (1, 2, 3, 4), horizontal=True,  key="beam_selection")
+beam_index = beam - 1
+
+# Display the selected variable and beam
+selected_data = data_dict[variable][beam_index, :, :]
+fillplot_plotly(selected_data, title=f"{variable}")
+
+
+st.subheader("Mask Selected Regions")
+with st.form(key="manual_cutbin_form"):
+    st.write("Select the specific range of cells and ensembles to delete")
+
+    # Input for selecting minimum and maximum cells
+    min_cell = st.number_input("Min Cell", 0, int(flobj.field()["Cells"]), 0)
+    max_cell = st.number_input("Max Cell", 0, int(flobj.field()["Cells"]), 10)
+
+    # Input for selecting minimum and maximum ensembles
+    min_ensemble = st.number_input("Min Ensemble", 0, int(flobj.ensembles), 0)
+    max_ensemble = st.number_input("Max Ensemble", 0, int(flobj.ensembles), int(flobj.ensembles))
+
+    # Submit button to apply the mask
+    cut_bins_mask_manual = st.form_submit_button(label="Apply Manual Cut Bins")
 
+    if cut_bins_mask_manual:
+        mask = manual_cut_bins(mask, min_cell, max_cell, min_ensemble, max_ensemble)
+        st.session_state.maskp = mask
+        fillplot_plotly(
+            echo[beam, :, :],
+            title="Echo Intensity (Masked Manually)",
+            maskdata=mask,
+        )
+        fillplot_plotly(mask, colorscale="greys", title="Mask Data")
+
+# Adding the new feature: Delete Single Cell or Ensemble
+st.subheader("Delete Specific Cell or Ensemble")
+
+# Step 1: User chooses between deleting a cell or an ensemble
+delete_option = st.radio("Select option to delete", ("Cell", "Ensemble"), horizontal=True)
+
+# Step 2: Display options based on user's choice
+if delete_option == "Cell":
+    # Option to delete a specific cell across all ensembles
+    with st.form(key="delete_cell_form"):
+        st.write("Select a specific cell to delete across all ensembles")
+        
+        # Input for selecting a single cell
+        cell = st.number_input("Cell", 0, int(flobj.field()["Cells"]), 0, key="single_cell")
+        
+        # Submit button to apply the mask for cell deletion
+        delete_cell = st.form_submit_button(label="Delete Cell")
+
+        if delete_cell:
+            mask[cell, :] = 1  # Mask the entire row for the selected cell
+            st.session_state.maskp = mask
+            fillplot_plotly(
+                echo[beam, :, :],
+                title=f"Echo Intensity (Cell {cell} Deleted Across Ensembles)",
+                maskdata=mask,
+            )
+            fillplot_plotly(mask, colorscale="greys", title="Mask Data")
+
+elif delete_option == "Ensemble":
+    # Option to delete a specific ensemble across all cells
+    with st.form(key="delete_ensemble_form"):
+        st.write("Select a specific ensemble to delete across all cells")
+        
+        # Input for selecting a specific ensemble
+        ensemble = st.number_input("Ensemble", 0, int(flobj.ensembles), 0, key="single_ensemble")
+        
+        # Submit button to apply the mask for ensemble deletion
+        delete_ensemble = st.form_submit_button(label="Delete Ensemble")
+
+        if delete_ensemble:
+            mask[:, ensemble-1] = 1  # Mask the entire column for the selected ensemble
+            st.session_state.maskp = mask
+            fillplot_plotly(
+                echo[beam, :, :],
+                title=f"Echo Intensity (Ensemble {ensemble} Deleted Across Cells)",
+                maskdata=mask,
+            )
+            fillplot_plotly(mask, colorscale="greys", title="Mask Data")
+
+           
+# Layout with two columns
+col1, col2 = st.columns([2, 1])
+
+with col1:
+            
+    # Button to save mask data after manual cut bins, with unique key
+    update_mask_cutbin = st.button("Update mask file after cutbin Manual", key="update_cutbin_button")
+    if update_mask_cutbin:
+        st.session_state.maskp = mask
+        st.write(":green[mask file updated]")
+        st.session_state.update_mask_cutbin = True
+        st.session_state.isCutBins = True
+
+    if not st.session_state.update_mask_cutbin:
+        st.write(":red[mask file not updated]")
+
+with col2:
+    # Button to reset the mask data, with unique key
+    reset_mask_button = st.button("Reset mask data", key="reset_mask_button")
+    if reset_mask_button:
+        st.session_state.maskp = np.copy(st.session_state.orig_mask)
+        st.write(":green[Mask data is reset to default]")
+        st.session_state.isQCMask = False
+        st.session_state.isProfileMask = False
+        st.session_state.isGrid = False
+        st.session_state.isGridSave = False
+        st.session_state.isVelocityMask = False
 
 ############ REGRID ###########################################
 st.header("Regrid Depth Cells", divider="blue")
@@ -304,38 +444,84 @@ st.write(
 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. 
-If the `bin` option is selected, ensure that the end data are trimmed.
+If the `Cell` option is selected, ensure that the end data are trimmed.
+Manual option permits choosing the end cell depth.
 """
 )
 
-last_cell = st.radio(
-    "Select the depth of last bin for regridding", ("Bin", "Surface"), horizontal=True
-)
-st.session_state.last_cell = last_cell
-st.write(last_cell)
-regrid_button = st.button(label="Regrid Data")
+if st.session_state.beam_direction.lower() == "up":
+    end_bin_option = st.radio(
+        "Select the depth of last bin for regridding", ("Cell", "Surface", "Manual"), horizontal=True
+    )
+else:
+    end_bin_option = st.radio(
+        "Select the depth of last bin for regridding", ("Cell", "Manual"), horizontal=True
+    )
+
+st.session_state.end_bin_option = end_bin_option 
+st.write(f"You have selected: `{end_bin_option}`")
+
+if end_bin_option == "Manual":
+    mean_depth = np.mean(st.session_state.vlead.vleader["Depth of Transducer"]) / 10
+    mean_depth = round(mean_depth, 2)
 
+    st.write(f"The transducer depth is {mean_depth} m. The value should not exceed the transducer depth")
+    if st.session_state.beam_direction.lower() == "up":
+        boundary = st.number_input("Enter the depth (m):", max_value=int(mean_depth), min_value=0)
+    else:
+        boundary = st.number_input("Enter the depth (m):", min_value=int(mean_depth))
+else:
+    boundary = 0
+
+interpolate = st.radio("Choose interpolation method:", ("nearest", "linear", "cubic"))
+
+regrid_button = st.button(label="Regrid Data")
 
 if regrid_button:
     st.write(st.session_state.endpoints)
     z, st.session_state.velocity_regrid = regrid3d(
-        flobj, vlobj, velocity, -32768, trimends=st.session_state.endpoints
+        flobj, vlobj, velocity, -32768, 
+        trimends=st.session_state.endpoints, 
+        end_bin_option=st.session_state.end_bin_option, 
+        orientation=st.session_state.beam_direction,
+        method=interpolate,
+        boundary_limit=boundary
     )
     st.write(":grey[Regrided velocity ...]")
     z, st.session_state.echo_regrid = regrid3d(
-        flobj, vlobj, echo, -32768, trimends=st.session_state.endpoints
+        flobj, vlobj, echo, -32768, 
+        trimends=st.session_state.endpoints, 
+        end_bin_option=st.session_state.end_bin_option, 
+        orientation=st.session_state.beam_direction,
+        method=interpolate,
+        boundary_limit=boundary
     )
     st.write(":grey[Regrided echo intensity ...]")
     z, st.session_state.correlation_regrid = regrid3d(
-        flobj, vlobj, correlation, -32768, trimends=st.session_state.endpoints
+        flobj, vlobj, correlation, -32768,
+        trimends=st.session_state.endpoints, 
+        end_bin_option=st.session_state.end_bin_option, 
+        orientation=st.session_state.beam_direction,
+        method=interpolate,
+        boundary_limit=boundary
     )
     st.write(":grey[Regrided correlation...]")
     z, st.session_state.pgood_regrid = regrid3d(
-        flobj, vlobj, pgood, -32768, trimends=st.session_state.endpoints
+        flobj, vlobj, pgood, -32768,
+        trimends=st.session_state.endpoints, 
+        end_bin_option=st.session_state.end_bin_option, 
+        orientation=st.session_state.beam_direction,
+        method=interpolate,
+        boundary_limit=boundary
     )
     st.write(":grey[Regrided percent good...]")
     z, st.session_state.mask_regrid = regrid2d(
-        flobj, vlobj, mask, 1, trimends=st.session_state.endpoints
+        flobj, vlobj, mask, 1,
+        trimends=st.session_state.endpoints, 
+        end_bin_option=st.session_state.end_bin_option, 
+        orientation=st.session_state.beam_direction,
+        method="nearest",
+        boundary_limit=boundary
     )
 
     st.session_state.depth = z

pyadps/pages/06_Velocity_Test.py

@@ -9,7 +9,7 @@ from streamlit.runtime.state import session_state
 from utils.profile_test import side_lobe_beam_angle
 from utils.signal_quality import default_mask
 from utils.velocity_test import (despike, flatline, magnetic_declination,
-                                 velocity_cutoff)
+                                 velocity_cutoff, wmm2020api, velocity_modifier)
 
 if "flead" not in st.session_state:
     st.write(":red[Please Select Data!]")
@@ -104,12 +104,24 @@ The processing in this page apply only to the velocity data.
 st.header("Magnetic Declination", divider="blue")
 st.write(
     """
-The magnetic declination is obtained from World Magnetic Model 2020 (WMM2020).
+* The magnetic declination is obtained from World Magnetic Model 2020 (WMM2020).
 The python wrapper module `wmm2020` is available from this [Link](https://github.com/space-physics/wmm2020). 
+
+* The API method utilizes the online magnetic declination service provided by the National Geophysical Data Center (NGDC)
+of the National Oceanic and Atmospheric Administration (NOAA) to calculate the magnetic declination. The service is available at this [link](https://www.ngdc.noaa.gov/geomag/calculators/magcalc.shtml#declination).
+Internet connection is necessary for this method to work.
+
+* In the manual method, the user can directly enter the magnetic declination.
+
 If the magnetic declination is reset, re-run the remaining tests again.
 """
 )
 
+# Selecting the method to calculate magnetic declination.
+method = st.radio("Select a method", ("WMM2020", "API", "Manual"), horizontal=True)
+# method = method - 1
+st.session_state.method = method
+
 if "isMagnetButton" not in st.session_state:
     st.session_state.isMagnetButton = False
 
@@ -119,23 +131,60 @@ def toggle_btns():
 
 
 with st.form(key="magnet_form"):
-    lat = st.number_input("Latitude", -90.0, 90.0, 0.0, step=1.0)
-    lon = st.number_input("Longitude", 0.0, 360.0, 0.1, step=1.0, format="%.4f")
-    depth = st.number_input("Depth", 0, 1000, 0, step=1)
-    year = st.number_input("Year", 1950, 2100, 2024, 1)
+    if st.session_state.method == "WMM2020":
+        st.session_state.isMagnet = False
+        lat = st.number_input("Latitude", -90.0, 90.0, 0.0, step=1.0)
+        lon = st.number_input("Longitude", 0.0, 360.0, 0.1, step=1.0, format="%.4f")
+        depth = st.number_input("Depth", 0, 1000, 0, step=1)
+        year = st.number_input("Year", 1950, 2100, 2024, 1)
+    elif  st.session_state.method == "API":
+        st.session_state.isMagnet = False
+        lat = st.number_input("Latitude", -90.0, 90.0, 0.0, step=1.0)
+        lon = st.number_input("Longitude", 0.0, 360.0, 0.1, step=1.0, format="%.4f")
+        year = st.number_input("Year", 1950, 2100, 2024, 1)
+    else:
+        st.session_state.isMagnet = False
+        mag = [[st.number_input("Declination", -180.0, 180.0, 0.0, 0.1)]]
+    
+    if st.session_state.method == "Manual":
+        button_name = "Accept"
+    else:
+        button_name = "Compute"
+
 
     if st.form_submit_button(
-        "Compute", on_click=toggle_btns, disabled=st.session_state.isMagnetButton
+        button_name, on_click=toggle_btns, disabled=st.session_state.isMagnetButton
     ):
-        st.session_state.dummyvelocity, mag = magnetic_declination(
-            velocity, lat, lon, depth, year
-        )
-        st.session_state.lat = lat
-        st.session_state.lon = lon
-        st.session_state.magnetic_dec_depth = depth
-        st.session_state.year = year
-        st.session_state.angle = np.trunc(mag[0][0])
-        st.session_state.isMagnet = True
+        if st.session_state.method == "WMM2020":
+            try:
+                mag = magnetic_declination(lat, lon, depth, year)
+                st.session_state.dummyvelocity = velocity_modifier(velocity, mag)
+                st.session_state.lat = lat
+                st.session_state.lon = lon
+                st.session_state.magnetic_dec_depth = depth
+                st.session_state.year = year
+                st.session_state.angle = np.trunc(mag[0][0])
+                st.session_state.isMagnet = True
+            except:
+                st.write(":red[Process failed! please use other methods: API or  Manual]")
+
+        elif  st.session_state.method == "API":
+            try:
+                mag = wmm2020api(lat, lon, year)
+                st.session_state.dummyvelocity = velocity_modifier(velocity, mag)
+                st.session_state.lat = lat
+                st.session_state.lon = lon
+                st.session_state.year = year
+                st.session_state.angle = np.trunc(mag[0][0])
+                st.session_state.isMagnet = True
+            except:
+                st.write(":red[Connection error! please check the internet or use other methods: WMM2020 or  Manual]")
+
+        else:
+            st.session_state.dummyvelocity = velocity_modifier(velocity, mag)
+            st.session_state.angle = np.trunc(mag[0][0])
+            st.session_state.isMagnet = True
+
 
 if st.session_state.isMagnet:
     st.write(f"Magnetic declination: {st.session_state.angle}\u00b0")
@@ -170,7 +219,6 @@ if submit_cutoff:
     st.session_state.maxvvel = maxvvel
     st.session_state.maxwvel = maxwvel
 
-
     st.session_state.maskd = velocity_cutoff(
         velocity[0, :, :], st.session_state.maskd, cutoff=maxuvel
     )
@@ -184,7 +232,7 @@ if submit_cutoff:
 
 
 if st.session_state.isCutoff:
-    st.write("Cutoff Applied")
+    st.write(":green[Cutoff Applied]")
     a = {
         "Max. Zonal Velocity": maxuvel,
         "Max. Meridional Velocity": maxvvel,
@@ -220,7 +268,7 @@ if despike_button:
     st.session_state.isDespike = True
 
 if st.session_state.isDespike:
-    st.write("Data Despiked")
+    st.write(":green[Data Despiked]")
     b = {
         "Kernal Size": despike_kernal,
         "Despike Cutoff": despike_cutoff,