2_spectra_pro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 - Process spectral data\n",
    "\n",
    "Loads adjusted data and formats for spectral analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports\n",
    "\n",
    "Necessary modules for analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# import modules\n",
    "\n",
    "import xarray as xr\n",
    "import numpy as np\n",
    "import scipy.signal as sig\n",
    "for i in range(2):\n",
    "    %matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# import data\n",
    "\n",
    "adcp = 'Shoulder'     # Slope(2013,2014,2017,2018), Axis75(2013,2014), Axis55(2017,2018), Shoulder\n",
    "year = 2013\n",
    "if adcp == 'Shoulder':\n",
    "    adcp2 = 'Axis75'\n",
    "    ds_in = xr.open_dataset(f'../Data/data/adj/adj_{adcp2}_1min_{year}_0.nc')\n",
    "    n_seg = ds_in.n_seg\n",
    "    if n_seg > 1:\n",
    "        ds = [ds_in]\n",
    "        for i in range(n_seg):\n",
    "            if i > 0:\n",
    "                ds_temp = xr.open_dataset(f'../Data/data/adj/adj_{adcp2}_1min_{year}_{i}.nc')\n",
    "                ds.append(ds_temp)\n",
    "    elif n_seg == 1:\n",
    "        ds = [ds_in]\n",
    "else:\n",
    "    ds_in = xr.open_dataset(f'../Data/data/adj/adj_{adcp}_{year}_0.nc')\n",
    "    n_seg = ds_in.n_seg\n",
    "    if n_seg > 1:\n",
    "        ds = [ds_in]\n",
    "        for i in range(n_seg):\n",
    "            if i > 0:\n",
    "                ds_temp = xr.open_dataset(f'../Data/data/adj/adj_{adcp}_{year}_{i}.nc')\n",
    "                ds.append(ds_temp)\n",
    "    elif n_seg == 1:\n",
    "        ds = [ds_in]\n",
    "    \n",
    "print(ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# extract variables\n",
    "\n",
    "t_stamp = ds[0].t_stamp\n",
    "depth = ds[0].depth.values\n",
    "d = ds[0].d\n",
    "start_date = ds[0].start_date\n",
    "end_date = ds[0].end_date\n",
    "\n",
    "# get WKB scale for site specific depth range\n",
    "\n",
    "scaling_array = np.load('../project/archive/N2/scaling_array.npy')\n",
    "GM_depths = scaling_array[0]                                 # depths range from -4 to -924 metres\n",
    "GM_scale = scaling_array[1]\n",
    "int_scale = np.interp(depth,-GM_depths,GM_scale)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format spectrogram data\n",
    "Removes the mean from each depth. Performs spectrogram process with optimised parameters for visual analysis of spectra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     23
    ]
   },
   "outputs": [],
   "source": [
    "# spectra data adjustments & Welch parameters\n",
    "\n",
    "time_total = 0\n",
    "for i in range(n_seg):\n",
    "    time_total += len(ds[i].t_seg)\n",
    "print('Total time length:',time_total)\n",
    "\n",
    "if adcp == 'Shoulder':\n",
    "    # set Welch parameters for PSD\n",
    "    fs = 1.6667e-2                # 60 samples per HOUR, 1.67e-2 per SECOND\n",
    "    win = 'hann'                  # optimal window for averaging\n",
    "    nps = 2**14                    # find optimal window for nperseg (1024 ~10 days)\n",
    "    overlap = 0.5*nps             # 50% overlap, default   \n",
    "    # set Welch parameters for spectrograms and depth-band plots\n",
    "    nps_s = 2**13                   # find optimal window for nperseg (512 ~5 days)\n",
    "    overlap_s = 0.5*nps_s            # 50% overlap, default   \n",
    "    # set Welch parameters for continuum analysis\n",
    "    nps_c = 2**10                   # find optimal window for nperseg (256 ~2.5 days)\n",
    "    overlap_c = 0.5*nps_c         # 50% overlap, default   \n",
    "    # set Welch parameters for tidal analysis\n",
    "    nps_SN = 2**13                    # find optimal window for nperseg (2048 ~20 days)\n",
    "    overlap_SN = 0.8*nps_SN         # 50% overlap, default  \n",
    "    \n",
    "else:\n",
    "    # set Welch parameters for PSD\n",
    "\n",
    "    fs = 1.1111e-3                # 4 samples per HOUR, 1.11e-3 per SECOND\n",
    "    win = 'hann'                  # optimal window for averaging\n",
    "    nps = 1024                    # find optimal window for nperseg (1024 ~10 days)\n",
    "    #nps = 4096                   # fine spectra\n",
    "    overlap = nps / 2             # 50% overlap, default   \n",
    "\n",
    "    # set Welch parameters for spectrograms and depth-band plots\n",
    "\n",
    "    nps_s = 512                   # find optimal window for nperseg (512 ~5 days)\n",
    "    overlap_s = 0.5*nps_s            # 50% overlap, default   \n",
    "\n",
    "    # set Welch parameters for continuum analysis\n",
    "\n",
    "    nps_c = 256                   # find optimal window for nperseg (256 ~2.5 days)\n",
    "    overlap_c = 0.5*nps_c         # 50% overlap, default   \n",
    "\n",
    "    # set Welch parameters for tidal analysis\n",
    "\n",
    "    nps_SN = 512                    # find optimal window for nperseg (2048 ~20 days)\n",
    "    overlap_SN = 0.8*nps_SN         # 50% overlap, default   \n",
    "\n",
    "# remove short segments\n",
    "\n",
    "t_short = []\n",
    "for i in range(n_seg):\n",
    "    if len(ds[i].t_seg) < nps:\n",
    "        t_short.append(i)\n",
    "for i in sorted(t_short, reverse=True):\n",
    "    del ds[i]\n",
    "n_seg = n_seg - len(t_short)\n",
    "\n",
    "time_total = 0\n",
    "for i in range(n_seg):\n",
    "    time_total += len(ds[i].t_seg)\n",
    "print(len(t_short),'segment(s) too short, new total time length:',time_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# remove mean at each depth\n",
    "\n",
    "um,vm,uh,vh = [],[],[],[]\n",
    "for i in range(n_seg):\n",
    "    um_seg,vm_seg,uh_seg,vh_seg = [],[],[],[]\n",
    "    uorig_temp = ds[i].uorig.values\n",
    "    vorig_temp = ds[i].vorig.values\n",
    "    uh_temp = ds[i].uorig.values - ds[i].ulp.values   # high pass for tidal analysis\n",
    "    vh_temp = ds[i].vorig.values - ds[i].vlp.values\n",
    "    for j in range(d):\n",
    "        umtemp = np.copy(uorig_temp[:,j]) - np.nanmean(uorig_temp[:,j])\n",
    "        vmtemp = np.copy(vorig_temp[:,j]) - np.nanmean(vorig_temp[:,j])\n",
    "        um_seg.append(umtemp)\n",
    "        vm_seg.append(vmtemp)\n",
    "        uhtemp = np.copy(uh_temp[:,j]) - np.nanmean(uh_temp[:,j])\n",
    "        vhtemp = np.copy(vh_temp[:,j]) - np.nanmean(vh_temp[:,j])\n",
    "        uh_seg.append(uhtemp)\n",
    "        vh_seg.append(vhtemp)\n",
    "    um.append(um_seg)     # list[segment][depth][time]\n",
    "    vm.append(vm_seg)     # 0 is upper depth index\n",
    "    uh.append(uh_seg)     # list[segment][depth][time]\n",
    "    vh.append(vh_seg)     # 0 is upper depth index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# define cross-spectra function using spectrograms\n",
    "\n",
    "def spectrocross(u,v,fs,window,nperseg,noverlap,nfft,detrend,return_onesided,scaling,axis,mode):\n",
    "    freqs, time, Sxy = sig._spectral_helper(u, v, fs, window, nperseg,\n",
    "                                            noverlap, nfft, detrend,\n",
    "                                            return_onesided, scaling, axis,\n",
    "                                            mode='psd')        # get this from scipy spectral.py in pkgs (add name to import list)\n",
    "    return freqs, time, Sxy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "# spectrograms at each depth (PSD at each depth in time-steps of nps)\n",
    "\n",
    "Sduh,Sdvh,spect_SN,specf_SN,cw_SN,ccw_SN = [],[],[],[],[],[]\n",
    "spect,specf,spect_s,specf_s,Sxu,Sxv,cw,ccw,Sdu,Sdv = [],[],[],[],[],[],[],[],[],[]\n",
    "cw_s, ccw_s = [],[]\n",
    "spect_c,specf_c,Scu,Scv,cw_c,ccw_c = [],[],[],[],[],[]\n",
    "\n",
    "for i in range(n_seg): \n",
    "    specf_SN_temp,spect_SN_temp,Sdvh_temp,Sduh_temp,cw_SN_temp,ccw_SN_temp = [],[],[],[],[],[]\n",
    "    spect_temp,specf_temp,cw_temp,ccw_temp,spect_s_temp,specf_s_temp,Sxu_temp,Sxv_temp,Sdu_temp,Sdv_temp=[],[],[],[],[],[],[],[],[],[]\n",
    "    cw_s_temp,ccw_s_temp = [],[]\n",
    "    spect_c_temp,specf_c_temp,Scu_temp,Scv_temp,cw_c_temp,ccw_c_temp = [],[],[],[],[],[]\n",
    "    for z in range(d):\n",
    "        # get spectrogram for PSD and rotary   \n",
    "        u_f, u_t, u_Sxx = sig.spectrogram(um[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps, noverlap = overlap, return_onesided=True)\n",
    "        v_f, v_t, v_Sxx = sig.spectrogram(vm[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps, noverlap = overlap, return_onesided=True)\n",
    "        \n",
    "        # get quadrature spectrogram and rotary\n",
    "        uv_f,uv_t,uv_Cxy = spectrocross(vm[i][z],um[i][z],fs=fs,window=win,nperseg=nps,noverlap=overlap,nfft=None,detrend='constant',\n",
    "                    return_onesided=True,scaling='density',axis=-1,mode='psd')     # cross spectrogram\n",
    "        Sxyuv = uv_Cxy.imag                             # quadrature spectra is imag part of cross spectra\n",
    "        Scw = ((u_Sxx + v_Sxx) - (2*Sxyuv)) / 2         # rotatory components\n",
    "        Sccw = ((u_Sxx + v_Sxx) + (2*Sxyuv)) / 2 \n",
    "        \n",
    "        # get high-res for spectrogram and depth-band plots (finer resolution)\n",
    "        u_f_s, u_t_s, u_Sxx_s = sig.spectrogram(um[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps_s, noverlap = overlap_s, return_onesided=True)\n",
    "        v_f_s, v_t_s, v_Sxx_s = sig.spectrogram(vm[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps_s, noverlap = overlap_s, return_onesided=True)\n",
    "        \n",
    "        # get high-res quadrature spectrogram and rotary\n",
    "        uv_f_s,uv_t_s,uv_Cxy_s = spectrocross(vm[i][z],um[i][z],fs=fs,window=win,nperseg=nps_s,noverlap=overlap_s,nfft=None,\n",
    "                                              detrend='constant',return_onesided=True,scaling='density',\n",
    "                                              axis=-1,mode='psd')     # cross spectrogram\n",
    "        Sxyuv_s = uv_Cxy_s.imag                                 # quadrature spectra is imag part of cross spectra\n",
    "        Scw_s = ((u_Sxx_s + v_Sxx_s) - (2*Sxyuv_s)) / 2         # rotatory components\n",
    "        Sccw_s = ((u_Sxx_s + v_Sxx_s) + (2*Sxyuv_s)) / 2 \n",
    "        \n",
    "        # get high freq res for spectrogram and depth-band plots (finer freq resolution)\n",
    "        u_f_c, u_t_c, u_Sxx_c = sig.spectrogram(um[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps_c, noverlap = overlap_c, return_onesided=True)\n",
    "        v_f_c, v_t_c, v_Sxx_c = sig.spectrogram(vm[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps_c, noverlap = overlap_c, return_onesided=True)\n",
    "        \n",
    "        # get high freq quadrature spectrogram and rotary\n",
    "        uv_f_c,uv_t_c,uv_Cxy_c = spectrocross(vm[i][z],um[i][z],fs=fs,window=win,nperseg=nps_c,noverlap=overlap_c,nfft=None,\n",
    "                                              detrend='constant',return_onesided=True,scaling='density',\n",
    "                                              axis=-1,mode='psd')     # cross spectrogram\n",
    "        Sxyuv_c = uv_Cxy_c.imag                                 # quadrature spectra is imag part of cross spectra\n",
    "        Scw_c = ((u_Sxx_c + v_Sxx_c) - (2*Sxyuv_c)) / 2         # rotatory components\n",
    "        Sccw_c = ((u_Sxx_c + v_Sxx_c) + (2*Sxyuv_c)) / 2 \n",
    "        \n",
    "        # get smooth highpass data for tidal analysis\n",
    "        u_f_SN, u_t_SN, u_Sxx_SN = sig.spectrogram(uh[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps_SN, noverlap = overlap_SN, return_onesided=True)\n",
    "        v_f_SN, v_t_SN, v_Sxx_SN = sig.spectrogram(vh[i][z], fs=fs, window=win, \\\n",
    "                                                            nperseg = nps_SN, noverlap = overlap_SN, return_onesided=True)\n",
    "        \n",
    "        # get tidal quadrature spectrogram and rotary\n",
    "        uv_f_SN,uv_t_SN,uv_Cxy_SN = spectrocross(vh[i][z],uh[i][z],fs=fs,window=win,nperseg=nps_SN,noverlap=overlap_SN,nfft=None,\n",
    "                                              detrend='constant',return_onesided=True,scaling='density',\n",
    "                                              axis=-1,mode='psd')     # cross spectrogram\n",
    "        Sxyuv_SN = uv_Cxy_SN.imag                                 # quadrature spectra is imag part of cross spectra\n",
    "        Scw_SN = ((u_Sxx_SN + v_Sxx_SN) - (2*Sxyuv_SN)) / 2         # rotatory components\n",
    "        Sccw_SN = ((u_Sxx_SN + v_Sxx_SN) + (2*Sxyuv_SN)) / 2 \n",
    "\n",
    "        # convert spectro_t to datetime for x-axis on plots for PSD\n",
    "        spectro_t4 = u_t*fs\n",
    "        spectro_time_len = len(spectro_t4)\n",
    "        spectro_time_axis = np.zeros([spectro_time_len],dtype='datetime64[s]')\n",
    "        for k in range(spectro_time_len):\n",
    "            j = int(spectro_t4[k])\n",
    "            spectro_time_axis[k] = ds[i].t_seg[j].values    \n",
    "            \n",
    "        # convert spectro_t to datetime for x-axis on plots for spectro/depth-band\n",
    "        spectro_t4_s = u_t_s*fs\n",
    "        spectro_time_len_s = len(spectro_t4_s)\n",
    "        spectro_time_axis_s = np.zeros([spectro_time_len_s],dtype='datetime64[s]')\n",
    "        for k in range(spectro_time_len_s):\n",
    "            j = int(spectro_t4_s[k])\n",
    "            spectro_time_axis_s[k] = ds[i].t_seg[j].values\n",
    "            \n",
    "        # convert spectro_t to datetime for x-axis on plots for high-freq resolution (continuum)\n",
    "        spectro_t4_c = u_t_c*fs\n",
    "        spectro_time_len_c = len(spectro_t4_c)\n",
    "        spectro_time_axis_c = np.zeros([spectro_time_len_c],dtype='datetime64[s]')\n",
    "        for k in range(spectro_time_len_c):\n",
    "            j = int(spectro_t4_c[k])\n",
    "            spectro_time_axis_c[k] = ds[i].t_seg[j].values\n",
    "            \n",
    "        # convert spectro_t to datetime for x-axis on plots for tidal analysis\n",
    "        spectro_t4_SN = u_t_SN*fs\n",
    "        spectro_time_len_SN = len(spectro_t4_SN)\n",
    "        spectro_time_axis_SN = np.zeros([spectro_time_len_SN],dtype='datetime64[s]')\n",
    "        for k in range(spectro_time_len_SN):\n",
    "            j = int(spectro_t4_SN[k])\n",
    "            spectro_time_axis_SN[k] = ds[i].t_seg[j].values\n",
    "        \n",
    "        spect_SN_temp.append(spectro_time_axis_SN)\n",
    "        specf_SN_temp.append(u_f_SN)\n",
    "        cw_SN_temp.append(Scw_SN)\n",
    "        ccw_SN_temp.append(Sccw_SN)\n",
    "        Sduh_temp.append(u_Sxx_SN)\n",
    "        Sdvh_temp.append(v_Sxx_SN)\n",
    "        ###\n",
    "        spect_temp.append(spectro_time_axis)\n",
    "        specf_temp.append(u_f)\n",
    "        cw_temp.append(Scw)\n",
    "        ccw_temp.append(Sccw)\n",
    "        cw_s_temp.append(Scw_s)\n",
    "        ccw_s_temp.append(Sccw_s)\n",
    "        spect_s_temp.append(spectro_time_axis_s)\n",
    "        specf_s_temp.append(u_f_s)\n",
    "        cw_c_temp.append(Scw_c)\n",
    "        ccw_c_temp.append(Sccw_c)\n",
    "        spect_c_temp.append(spectro_time_axis_c)\n",
    "        specf_c_temp.append(u_f_c)\n",
    "        Sxu_temp.append(u_Sxx)         # non-whitened\n",
    "        Sxv_temp.append(v_Sxx)\n",
    "        Sdu_temp.append(u_Sxx_s)\n",
    "        Sdv_temp.append(v_Sxx_s)\n",
    "        Scu_temp.append(u_Sxx_c)\n",
    "        Scv_temp.append(v_Sxx_c)\n",
    "        \n",
    "    spect_SN.append(spect_SN_temp[0]) \n",
    "    specf_SN.append(specf_SN_temp[0])\n",
    "    cw_SN.append(cw_SN_temp)\n",
    "    ccw_SN.append(ccw_SN_temp)\n",
    "    Sduh.append(Sduh_temp)          # non-whitened spectro/depth-band\n",
    "    Sdvh.append(Sdvh_temp)          # list[array_segment][depth][frequency][time_segment]\n",
    "    \n",
    "    spect.append(spect_temp[0])   # append arrays to lists (same times and frequencies at each depth)\n",
    "    specf.append(specf_temp[0])\n",
    "    spect_s.append(spect_s_temp[0])\n",
    "    specf_s.append(specf_s_temp[0])\n",
    "    spect_c.append(spect_c_temp[0])\n",
    "    specf_c.append(specf_c_temp[0])\n",
    "    Sxu.append(Sxu_temp)          # PSD\n",
    "    Sxv.append(Sxv_temp)\n",
    "    cw.append(cw_temp)            # rotary spectra\n",
    "    ccw.append(ccw_temp)\n",
    "    cw_s.append(cw_s_temp)\n",
    "    ccw_s.append(ccw_s_temp)\n",
    "    cw_c.append(cw_c_temp)\n",
    "    ccw_c.append(ccw_c_temp)\n",
    "    Sdu.append(Sdu_temp)          # non-whitened spectro/depth-band\n",
    "    Sdv.append(Sdv_temp)          # list[array_segment][depth][frequency][time_segment]\n",
    "    Scu.append(Scu_temp)          # non-whitened spectro/depth-band\n",
    "    Scv.append(Scv_temp)          # list[array_segment][depth][frequency][time_segment]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save\n",
    "Save key values and arrays to NetCDF format using xarray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# save to .nc files\n",
    "\n",
    "for i in range(n_seg):\n",
    "    ds_out = xr.Dataset( \n",
    "        data_vars=dict(\n",
    "            Sxxu=(['depth','specf','spect'], Sxu[i]),                   # depth-freq-time data for PSD at each depth\n",
    "            Sxxv=(['depth','specf','spect'], Sxv[i]),\n",
    "            cw=(['depth','specf','spect'], cw[i]),                      # depth-freq-time data for rotary at each depth\n",
    "            ccw=(['depth','specf','spect'], ccw[i]),\n",
    "            Sxxu_d=(['depth','specf_s','spect_s'], Sdu[i]),             # depth-freq-time data for depth-band/spectro at each depth\n",
    "            Sxxv_d=(['depth','specf_s','spect_s'], Sdv[i]),\n",
    "            cw_d=(['depth','specf_s','spect_s'], cw_s[i]),              # depth-freq-time data for rotary for depth-band/spectro\n",
    "            ccw_d=(['depth','specf_s','spect_s'], ccw_s[i]),\n",
    "            Sxxu_c=(['depth','specf_c','spect_c'], Scu[i]),             # depth-freq-time data for depth-band/spectro at each depth\n",
    "            Sxxv_c=(['depth','specf_c','spect_c'], Scv[i]),\n",
    "            cw_c=(['depth','specf_c','spect_c'], cw_c[i]),              # depth-freq-time data for rotary for depth-band/spectro\n",
    "            ccw_c=(['depth','specf_c','spect_c'], ccw_c[i]),\n",
    "            Sxxu_SN=(['depth','specf_SN','spect_SN'], Sduh[i]),             # depth-freq-time data for tidal analysis\n",
    "            Sxxv_SN=(['depth','specf_SN','spect_SN'], Sdvh[i]),\n",
    "            cw_SN=(['depth','specf_SN','spect_SN'], cw_SN[i]),              # depth-freq-time data for rotary for tidal analysis\n",
    "            ccw_SN=(['depth','specf_SN','spect_SN'], ccw_SN[i]),\n",
    "            WKB_scale=(['depth'],int_scale),                            # WKB multiplier\n",
    "        ),\n",
    "        coords=dict(\n",
    "            depth=depth,                               # depth values\n",
    "            specf=specf[i],                            # PSD frequency bins\n",
    "            specf_s=specf_s[i],                        # spectrogram frequency bins\n",
    "            specf_c=specf_c[i],                        # continuum frequency bins\n",
    "            specf_SN=specf_SN[i],                      # tidal freq bins\n",
    "            spect=spect[i],                            # PSD time bins\n",
    "            spect_s=spect_s[i],                        # spectrogram time bins\n",
    "            spect_c=spect_c[i],                        # continuum time bins\n",
    "            spect_SN=spect_SN[i],                      # tidal time bins\n",
    "        ),\n",
    "        attrs=dict(\n",
    "            description=f'Depth-freq-time data for {adcp} {t_stamp} segment {i} (from 0 to {n_seg - 1}).',\n",
    "            n_seg=n_seg,                               # n_seg for major datagaps each year\n",
    "            adcp=adcp,                                 # adcp\n",
    "            t_stamp=t_stamp,                           # time stamp\n",
    "            t=time_total,                              # length of initial time series\n",
    "            d=d,                                       # depth range\n",
    "            start_date=str(ds[i].t_seg[0].values),     # start date of initial time series segment\n",
    "            end_date=str(ds[i].t_seg[-1].values),      # end date of initial time series segment\n",
    "            fs=fs,                                     # sampling frequency\n",
    "            window=win,                                # fft window\n",
    "            nps=nps,                                   # fft segment length\n",
    "            overlap=overlap,                           # fft window overlap\n",
    "            nps_s=nps_s,                               # fft segment length for depth-band and spectro\n",
    "            overlap_s=overlap_s,                       # fft window overlap for depth-band and spectro\n",
    "            nps_c=nps_c,                               # fft segment length for continuum\n",
    "            overlap_c=overlap_c,                       # fft window overlap for continuum\n",
    "            nps_SN=nps_SN,                             # fft segment length for tidal\n",
    "            overlap_SN=overlap_SN,                     # fft window length for tidal\n",
    "        ),\n",
    "    ) \n",
    "    if adcp == 'Shoulder':\n",
    "        ds_out.to_netcdf(f'../Data/data/spectra/spectra_{adcp2}_1min_{t_stamp}_{i}.nc')\n",
    "    else:\n",
    "        ds_out.to_netcdf(f'../Data/data/spectra/spectra_{adcp}_{t_stamp}_{i}.nc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": "16",
    "lenType": "16",
    "lenVar": "200"
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}