diff --git a/.github/workflows/generate_notebook_matrix.py b/.github/workflows/generate_notebook_matrix.py
index 02f81a00a..966f921e6 100644
--- a/.github/workflows/generate_notebook_matrix.py
+++ b/.github/workflows/generate_notebook_matrix.py
@@ -14,14 +14,14 @@
     "cdip_example.ipynb": 420,
     "Delft3D_example.ipynb": 180,
     "directional_waves.ipynb": 180,
-    "environmental_contours_example.ipynb": 360,
-    "extreme_response_contour_example.ipynb": 360,
-    "extreme_response_full_sea_state_example.ipynb": 360,
-    "extreme_response_MLER_example.ipynb": 360,
+    "environmental_contours_example.ipynb": 240,
+    "extreme_response_contour_example.ipynb": 240,
+    "extreme_response_full_sea_state_example.ipynb": 240,
+    "extreme_response_MLER_example.ipynb": 240,
     "loads_example.ipynb": 180,
     "metocean_example.ipynb": 180,
     "mooring_example.ipynb": 240,
-    "PacWave_resource_characterization_example.ipynb": 780,
+    "PacWave_resource_characterization_example.ipynb": 240,
     "power_example.ipynb": 180,
     "qc_example.ipynb": 180,
     "river_example.ipynb": 180,
diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml
index 08458f95d..77eb4637e 100644
--- a/.github/workflows/pylint.yml
+++ b/.github/workflows/pylint.yml
@@ -1,4 +1,4 @@
-name: Pylint Loads
+name: Pylint
 
 on: [push, pull_request]
 
@@ -28,3 +28,7 @@ jobs:
       - name: Run Pylint on mhkit/power/
         run: |
           pylint mhkit/power/
+
+      - name: Run Pylint on mhkit/acoustics/
+        run: |
+          pylint mhkit/acoustics/
diff --git a/examples/PacWave_resource_characterization_example.ipynb b/examples/PacWave_resource_characterization_example.ipynb
index 9f46be4b9..32bcc49fa 100644
--- a/examples/PacWave_resource_characterization_example.ipynb
+++ b/examples/PacWave_resource_characterization_example.ipynb
@@ -1119,12 +1119,19 @@
     "\n",
     "    Tz_list.append(resource.average_zero_crossing_period(year_data.T))\n",
     "\n",
-    "# Concatenate list of Series into a single DataFrame\n",
+    "# Concatenate each list of Series into a single Series\n",
     "Te = pd.concat(Te_list, axis=0)\n",
     "Tp = pd.concat(Tp_list, axis=0)\n",
     "Hm0 = pd.concat(Hm0_list, axis=0)\n",
     "J = pd.concat(J_list, axis=0)\n",
     "Tz = pd.concat(Tz_list, axis=0)\n",
+    "\n",
+    "# Name each Series and concat into a dataFrame\n",
+    "Te.name = 'Te'\n",
+    "Tp.name = 'Tp'\n",
+    "Hm0.name = 'Hm0'\n",
+    "J.name = 'J'\n",
+    "Tz.name = 'Tz'\n",
     "data = pd.concat([Hm0, Te, Tp, J, Tz], axis=1)\n",
     "\n",
     "# Calculate wave steepness\n",
@@ -1590,7 +1597,7 @@
     "    J = []\n",
     "    for i in range(len(result)):\n",
     "        b = resource.jonswap_spectrum(f, result.Tp[i], result.Hm0[i])\n",
-    "        J.extend([resource.energy_flux(b, h=399.0).values[0][0]])\n",
+    "        J.extend([resource.energy_flux(b, h=399.0).item()])\n",
     "\n",
     "    result[\"J\"] = J\n",
     "    results[N] = result\n",
@@ -1622,7 +1629,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.12.7"
   }
  },
  "nbformat": 4,
diff --git a/examples/acoustics_example.ipynb b/examples/acoustics_example.ipynb
new file mode 100644
index 000000000..41104f234
--- /dev/null
+++ b/examples/acoustics_example.ipynb
@@ -0,0 +1,1040 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Analyzing Passive Acoustic Data with MHKiT\n",
+    "\n",
+    "The following example illustrates how to read and analyze some basic parameters for passive acoustics data. Functionality to analyze .wav files recorded using hydrophones has been integrated into MHKiT to support analysis based on the IEC-TS 62600-40 standard.\n",
+    "\n",
+    "The standard workflow for passive acoustics analysis is as follows:\n",
+    "\n",
+    "1. Import .wav file\n",
+    "2. Calibrate data\n",
+    "3. Calculate spectral density\n",
+    "4. Calculate other parameters\n",
+    "\n",
+    "We'll import a couple plotting tools and the acoustics module:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.dates as mdates\n",
+    "\n",
+    "from mhkit import acoustics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Read in Hydrophone Measurements\n",
+    "\n",
+    "All hydrophone .wav files can be read in MHKiT using a base function called `read_hydrophone` from the acoustics.io submodule. Because the sampling frequency is so fast, measurements are stored in the lowest memory format possible and need to be scaled and transformed to return the measurements in units of voltage or pressure.\n",
+    "\n",
+    "The `read_hydrophone` function scales and transforms raw measurements given a few input parameters. Most parameters needed to convert the raw data are stored in the native .wav format header blocks, but two, the peak voltage (\"peak_voltage\") of the sensor's analog-to-digital converter (ADC) and file \"start_time\" (usually stored in the filename) are required. \n",
+    "\n",
+    "Two other inputs, the hydrophone \"sensitivity\" and an amplifier \"gain\" (typically for custom hydrophone builds) can also be input. If a sensitivity value is provided, the function will convert voltage to pressure; otherwise the sensitivity(ies) can be provided later using a calibration curve. Gain should be provided if the instrument utilizes an amplifier gain, which is then added to the sensitivity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.DataArray (time: 30720000)> Size: 246MB\n",
+      "array([0.31546374, 0.30229832, 0.32229963, ..., 0.08506887, 0.07291618,\n",
+      "       0.06278893])\n",
+      "Coordinates:\n",
+      "  * time     (time) datetime64[ns] 246MB 2024-06-01T05:31:14 ... 2024-06-01T0...\n",
+      "Attributes:\n",
+      "    units:        Pa\n",
+      "    sensitivity:  1.413e-09\n",
+      "    resolution:   9.89e-07\n",
+      "    valid_min:    -2123.837353\n",
+      "    valid_max:    2123.837353\n",
+      "    fs:           512000\n",
+      "    filename:     RBW_6661_20240601_053114\n"
+     ]
+    }
+   ],
+   "source": [
+    "P = acoustics.io.read_hydrophone(\n",
+    "    \"data/acoustics/RBW_6661_20240601_053114.wav\", \n",
+    "    peak_voltage=3, \n",
+    "    sensitivity=-177, \n",
+    "    gain=0, \n",
+    "    start_time=\"2024-06-01T05:31:14\"\n",
+    ")\n",
+    "# `P` is returned as an xarray DataArray, which allows easy handling of labeled multi-dimensional arrays. \n",
+    "# In this case, the array represents sound pressure in Pascals (Pa) over time because the calibrated sensitivity was passed.\n",
+    "print(P)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\"Smart\" hydrophones are those where the hydrophone element, pre-amplifier board, ADC, motherboard and memory card are sold in a single package. Companies that sell these often store metadata in the .wav file header, and MHKiT has a couple of wrapper functions for these hydrophones.\n",
+    "\n",
+    "OceanSonics icListens and OceanInstruments Soundtraps are two common smart hydrophones datafiles with examples as follows.\n",
+    "\n",
+    "For icListen datafiles, only the filename is necessary to provide to return file contents in units of pressure. The stored sensitivity calibration value can be overridden by setting the \"sensitivity\" input, and to return measurements in units of voltage, set `sensitivity` to None and `use_metadata` to False."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "P = acoustics.io.read_iclisten(\"data/acoustics/RBW_6661_20240601_053114.wav\")\n",
+    "V = acoustics.io.read_iclisten(\n",
+    "    \"data/acoustics/RBW_6661_20240601_053114.wav\", \n",
+    "    sensitivity=None, \n",
+    "    use_metadata=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For Ocean Instruments Soundtrap datafiles, the filename and sensitivity should be provided to return the measurements in units of pressure. If the hydrophone has been calibrated, set the sensitivity to None to return the measurements in units of voltage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "P = acoustics.io.read_soundtrap(\"data/acoustics/6247.230204150508.wav\", sensitivity=-177)\n",
+    "V = acoustics.io.read_soundtrap(\"data/acoustics/6247.230204150508.wav\", sensitivity=None)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Mean Square Sound Pressure Spectral Density\n",
+    "\n",
+    "After the .wav file is read in, either in units of pressure or voltage, we calculate the mean square sound pressure spectral density (SPSD) of the timeseries using `sound_pressure_spectral_density`. This splits the timeseries into windows and uses fast Fourier transforms to convert the raw measurements into the frequency domain, with units of $Pa^2/Hz$ or $V^2/Hz$, depending on the input. The function takes the original datafile, the hydrophone's sampling rate, which is stored as an attribute of the measurement timeseries, and a window size in seconds as input.\n",
+    "\n",
+    "The IEC-40 considers an acoustic sample to have a length of 1 second, so we'll set the window size as such here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create mean square spectral densities using 1 s bins.\n",
+    "spsd = acoustics.sound_pressure_spectral_density(V, V.fs, bin_length=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Applying Calibration Curves\n",
+    "\n",
+    "For conducting scientific-grade analysis, it is critical to use calibration curves to correct the SPSD calculations. Hydrophones should be calibrated (i.e., a sensitivity calibration curve should be generated for a hydrophone) every few years. The IEC-40 asks that a hydrophone be calibrated both before and after the test deployment.\n",
+    "\n",
+    "A calibration curve consists of the hydrophone's sensitivity (in units of dB rel $1 V^2/uPa^2$) vs frequency and should be applied to the spectral density we just calculated.\n",
+    "\n",
+    "The easiest way to apply a sensitivity calibration curve in MHKiT is to first copy the calibration data into a CSV file, where the left column contains the calibrated frequencies and the right column contains the sensitivity values. Here we use the function in the following codeblock to read in a CSV file created with the column headers \"Frequency\" and \"Analog Sensitivity\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<xarray.DataArray 'Analog Sensitivity' (Frequency: 40)> Size: 320B\n",
+      "array([-223.49, -220.8 , -218.13, -215.41, -212.68, -209.91, -207.12,\n",
+      "       -204.29, -201.45, -198.58, -195.69, -192.79, -189.85, -186.9 ,\n",
+      "       -183.93, -180.93, -177.92, -174.97, -172.16, -169.61, -167.69,\n",
+      "       -166.52, -165.96, -165.81, -165.85, -165.95, -166.05, -166.13,\n",
+      "       -166.2 , -166.25, -166.28, -166.29, -166.29, -166.27, -166.24,\n",
+      "       -166.17, -166.03, -165.79, -165.47, -164.87])\n",
+      "Coordinates:\n",
+      "  * Frequency  (Frequency) float64 320B 1.0 1.183 1.399 ... 500.3 591.8 700.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "def read_calibration_file(filename):\n",
+    "    calibration = pd.read_csv(filename, sep=\",\")\n",
+    "    calibration.index = calibration[\"Frequency\"]\n",
+    "    calibration = calibration.to_xarray()\n",
+    "    return calibration[\"Analog Sensitivity\"]\n",
+    "\n",
+    "sensitivity_curve = read_calibration_file(\"data/acoustics/6247_calibration.csv\")\n",
+    "print(sensitivity_curve)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once we have the calibration data in an xarray DataArray, we can apply that to the SPSD using the `apply_calibration` function. Calibration curves typically do not cover the entire range of the hydrophone, so this function will linearly interpolate the missing values. A fill_value can be provided to extrapolate outside of the calibrated frequencies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
+       "<defs>\n",
+       "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
+       "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
+       "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
+       "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
+       "</symbol>\n",
+       "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
+       "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
+       "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
+       "</symbol>\n",
+       "</defs>\n",
+       "</svg>\n",
+       "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n",
+       " *\n",
+       " */\n",
+       "\n",
+       ":root {\n",
+       "  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n",
+       "  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n",
+       "  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n",
+       "  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n",
+       "  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n",
+       "  --xr-background-color: var(--jp-layout-color0, white);\n",
+       "  --xr-background-color-row-even: var(--jp-layout-color1, white);\n",
+       "  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
+       "}\n",
+       "\n",
+       "html[theme=dark],\n",
+       "html[data-theme=dark],\n",
+       "body[data-theme=dark],\n",
+       "body.vscode-dark {\n",
+       "  --xr-font-color0: rgba(255, 255, 255, 1);\n",
+       "  --xr-font-color2: rgba(255, 255, 255, 0.54);\n",
+       "  --xr-font-color3: rgba(255, 255, 255, 0.38);\n",
+       "  --xr-border-color: #1F1F1F;\n",
+       "  --xr-disabled-color: #515151;\n",
+       "  --xr-background-color: #111111;\n",
+       "  --xr-background-color-row-even: #111111;\n",
+       "  --xr-background-color-row-odd: #313131;\n",
+       "}\n",
+       "\n",
+       ".xr-wrap {\n",
+       "  display: block !important;\n",
+       "  min-width: 300px;\n",
+       "  max-width: 700px;\n",
+       "}\n",
+       "\n",
+       ".xr-text-repr-fallback {\n",
+       "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-header {\n",
+       "  padding-top: 6px;\n",
+       "  padding-bottom: 6px;\n",
+       "  margin-bottom: 4px;\n",
+       "  border-bottom: solid 1px var(--xr-border-color);\n",
+       "}\n",
+       "\n",
+       ".xr-header > div,\n",
+       ".xr-header > ul {\n",
+       "  display: inline;\n",
+       "  margin-top: 0;\n",
+       "  margin-bottom: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-obj-type,\n",
+       ".xr-array-name {\n",
+       "  margin-left: 2px;\n",
+       "  margin-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-obj-type {\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-sections {\n",
+       "  padding-left: 0 !important;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 150px auto auto 1fr 20px 20px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input + label {\n",
+       "  color: var(--xr-disabled-color);\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input:enabled + label {\n",
+       "  cursor: pointer;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-section-item input:enabled + label:hover {\n",
+       "  color: var(--xr-font-color0);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary {\n",
+       "  grid-column: 1;\n",
+       "  color: var(--xr-font-color2);\n",
+       "  font-weight: 500;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary > span {\n",
+       "  display: inline-block;\n",
+       "  padding-left: 0.5em;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:disabled + label {\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in + label:before {\n",
+       "  display: inline-block;\n",
+       "  content: '►';\n",
+       "  font-size: 11px;\n",
+       "  width: 15px;\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:disabled + label:before {\n",
+       "  color: var(--xr-disabled-color);\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked + label:before {\n",
+       "  content: '▼';\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked + label > span {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary,\n",
+       ".xr-section-inline-details {\n",
+       "  padding-top: 4px;\n",
+       "  padding-bottom: 4px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-inline-details {\n",
+       "  grid-column: 2 / -1;\n",
+       "}\n",
+       "\n",
+       ".xr-section-details {\n",
+       "  display: none;\n",
+       "  grid-column: 1 / -1;\n",
+       "  margin-bottom: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-section-summary-in:checked ~ .xr-section-details {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-array-wrap {\n",
+       "  grid-column: 1 / -1;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 20px auto;\n",
+       "}\n",
+       "\n",
+       ".xr-array-wrap > label {\n",
+       "  grid-column: 1;\n",
+       "  vertical-align: top;\n",
+       "}\n",
+       "\n",
+       ".xr-preview {\n",
+       "  color: var(--xr-font-color3);\n",
+       "}\n",
+       "\n",
+       ".xr-array-preview,\n",
+       ".xr-array-data {\n",
+       "  padding: 0 5px !important;\n",
+       "  grid-column: 2;\n",
+       "}\n",
+       "\n",
+       ".xr-array-data,\n",
+       ".xr-array-in:checked ~ .xr-array-preview {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       ".xr-array-in:checked ~ .xr-array-data,\n",
+       ".xr-array-preview {\n",
+       "  display: inline-block;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list {\n",
+       "  display: inline-block !important;\n",
+       "  list-style: none;\n",
+       "  padding: 0 !important;\n",
+       "  margin: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list li {\n",
+       "  display: inline-block;\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list:before {\n",
+       "  content: '(';\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list:after {\n",
+       "  content: ')';\n",
+       "}\n",
+       "\n",
+       ".xr-dim-list li:not(:last-child):after {\n",
+       "  content: ',';\n",
+       "  padding-right: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-has-index {\n",
+       "  font-weight: bold;\n",
+       "}\n",
+       "\n",
+       ".xr-var-list,\n",
+       ".xr-var-item {\n",
+       "  display: contents;\n",
+       "}\n",
+       "\n",
+       ".xr-var-item > div,\n",
+       ".xr-var-item label,\n",
+       ".xr-var-item > .xr-var-name span {\n",
+       "  background-color: var(--xr-background-color-row-even);\n",
+       "  margin-bottom: 0;\n",
+       "}\n",
+       "\n",
+       ".xr-var-item > .xr-var-name:hover span {\n",
+       "  padding-right: 5px;\n",
+       "}\n",
+       "\n",
+       ".xr-var-list > li:nth-child(odd) > div,\n",
+       ".xr-var-list > li:nth-child(odd) > label,\n",
+       ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
+       "  background-color: var(--xr-background-color-row-odd);\n",
+       "}\n",
+       "\n",
+       ".xr-var-name {\n",
+       "  grid-column: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-var-dims {\n",
+       "  grid-column: 2;\n",
+       "}\n",
+       "\n",
+       ".xr-var-dtype {\n",
+       "  grid-column: 3;\n",
+       "  text-align: right;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-var-preview {\n",
+       "  grid-column: 4;\n",
+       "}\n",
+       "\n",
+       ".xr-index-preview {\n",
+       "  grid-column: 2 / 5;\n",
+       "  color: var(--xr-font-color2);\n",
+       "}\n",
+       "\n",
+       ".xr-var-name,\n",
+       ".xr-var-dims,\n",
+       ".xr-var-dtype,\n",
+       ".xr-preview,\n",
+       ".xr-attrs dt {\n",
+       "  white-space: nowrap;\n",
+       "  overflow: hidden;\n",
+       "  text-overflow: ellipsis;\n",
+       "  padding-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-var-name:hover,\n",
+       ".xr-var-dims:hover,\n",
+       ".xr-var-dtype:hover,\n",
+       ".xr-attrs dt:hover {\n",
+       "  overflow: visible;\n",
+       "  width: auto;\n",
+       "  z-index: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-data,\n",
+       ".xr-index-data {\n",
+       "  display: none;\n",
+       "  background-color: var(--xr-background-color) !important;\n",
+       "  padding-bottom: 5px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
+       ".xr-var-data-in:checked ~ .xr-var-data,\n",
+       ".xr-index-data-in:checked ~ .xr-index-data {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       ".xr-var-data > table {\n",
+       "  float: right;\n",
+       "}\n",
+       "\n",
+       ".xr-var-name span,\n",
+       ".xr-var-data,\n",
+       ".xr-index-name div,\n",
+       ".xr-index-data,\n",
+       ".xr-attrs {\n",
+       "  padding-left: 25px !important;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs,\n",
+       ".xr-var-attrs,\n",
+       ".xr-var-data,\n",
+       ".xr-index-data {\n",
+       "  grid-column: 1 / -1;\n",
+       "}\n",
+       "\n",
+       "dl.xr-attrs {\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "  display: grid;\n",
+       "  grid-template-columns: 125px auto;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt,\n",
+       ".xr-attrs dd {\n",
+       "  padding: 0;\n",
+       "  margin: 0;\n",
+       "  float: left;\n",
+       "  padding-right: 10px;\n",
+       "  width: auto;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt {\n",
+       "  font-weight: normal;\n",
+       "  grid-column: 1;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dt:hover span {\n",
+       "  display: inline-block;\n",
+       "  background: var(--xr-background-color);\n",
+       "  padding-right: 10px;\n",
+       "}\n",
+       "\n",
+       ".xr-attrs dd {\n",
+       "  grid-column: 2;\n",
+       "  white-space: pre-wrap;\n",
+       "  word-break: break-all;\n",
+       "}\n",
+       "\n",
+       ".xr-icon-database,\n",
+       ".xr-icon-file-text2,\n",
+       ".xr-no-icon {\n",
+       "  display: inline-block;\n",
+       "  vertical-align: middle;\n",
+       "  width: 1em;\n",
+       "  height: 1.5em !important;\n",
+       "  stroke-width: 0;\n",
+       "  stroke: currentColor;\n",
+       "  fill: currentColor;\n",
+       "}\n",
+       "</style><pre class='xr-text-repr-fallback'>&lt;xarray.DataArray &#x27;Analog Sensitivity&#x27; (Frequency: 40)&gt; Size: 320B\n",
+       "array([-223.49, -220.8 , -218.13, -215.41, -212.68, -209.91, -207.12,\n",
+       "       -204.29, -201.45, -198.58, -195.69, -192.79, -189.85, -186.9 ,\n",
+       "       -183.93, -180.93, -177.92, -174.97, -172.16, -169.61, -167.69,\n",
+       "       -166.52, -165.96, -165.81, -165.85, -165.95, -166.05, -166.13,\n",
+       "       -166.2 , -166.25, -166.28, -166.29, -166.29, -166.27, -166.24,\n",
+       "       -166.17, -166.03, -165.79, -165.47, -164.87])\n",
+       "Coordinates:\n",
+       "  * Frequency  (Frequency) float64 320B 1.0 1.183 1.399 ... 500.3 591.8 700.0</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.DataArray</div><div class='xr-array-name'>'Analog Sensitivity'</div><ul class='xr-dim-list'><li><span class='xr-has-index'>Frequency</span>: 40</li></ul></div><ul class='xr-sections'><li class='xr-section-item'><div class='xr-array-wrap'><input id='section-c6d0953b-3ea8-4759-9328-aacec4fb79a4' class='xr-array-in' type='checkbox' checked><label for='section-c6d0953b-3ea8-4759-9328-aacec4fb79a4' title='Show/hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-array-preview xr-preview'><span>-223.5 -220.8 -218.1 -215.4 -212.7 ... -166.0 -165.8 -165.5 -164.9</span></div><div class='xr-array-data'><pre>array([-223.49, -220.8 , -218.13, -215.41, -212.68, -209.91, -207.12,\n",
+       "       -204.29, -201.45, -198.58, -195.69, -192.79, -189.85, -186.9 ,\n",
+       "       -183.93, -180.93, -177.92, -174.97, -172.16, -169.61, -167.69,\n",
+       "       -166.52, -165.96, -165.81, -165.85, -165.95, -166.05, -166.13,\n",
+       "       -166.2 , -166.25, -166.28, -166.29, -166.29, -166.27, -166.24,\n",
+       "       -166.17, -166.03, -165.79, -165.47, -164.87])</pre></div></div></li><li class='xr-section-item'><input id='section-f55018de-a33d-4ce1-acda-863155b5db51' class='xr-section-summary-in' type='checkbox'  checked><label for='section-f55018de-a33d-4ce1-acda-863155b5db51' class='xr-section-summary' >Coordinates: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>Frequency</span></div><div class='xr-var-dims'>(Frequency)</div><div class='xr-var-dtype'>float64</div><div class='xr-var-preview xr-preview'>1.0 1.183 1.399 ... 591.8 700.0</div><input id='attrs-58dad91a-42f8-4179-85d4-557b10be10a0' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-58dad91a-42f8-4179-85d4-557b10be10a0' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-5d899ad6-a9d6-43b9-9e8c-f4f438bad70b' class='xr-var-data-in' type='checkbox'><label for='data-5d899ad6-a9d6-43b9-9e8c-f4f438bad70b' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([  1.   ,   1.183,   1.399,   1.655,   1.958,   2.316,   2.74 ,   3.241,\n",
+       "         3.834,   4.535,   5.364,   6.345,   7.506,   8.879,  10.5  ,  12.42 ,\n",
+       "        14.7  ,  17.38 ,  20.56 ,  24.33 ,  28.78 ,  34.04 ,  40.26 ,  47.63 ,\n",
+       "        56.34 ,  66.65 ,  78.84 ,  93.26 , 110.3  , 130.5  , 154.4  , 182.6  ,\n",
+       "       216.   , 255.5  , 302.2  , 357.5  , 422.9  , 500.3  , 591.8  , 700.   ])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-00cf03c4-8049-45d9-b63e-bc60a4abcca3' class='xr-section-summary-in' type='checkbox'  ><label for='section-00cf03c4-8049-45d9-b63e-bc60a4abcca3' class='xr-section-summary' >Indexes: <span>(1)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>Frequency</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-b6f7256f-a7b9-47f8-bab7-db407ab5e7f4' class='xr-index-data-in' type='checkbox'/><label for='index-b6f7256f-a7b9-47f8-bab7-db407ab5e7f4' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([  1.0, 1.183, 1.399, 1.655, 1.958, 2.316,  2.74, 3.241, 3.834, 4.535,\n",
+       "       5.364, 6.345, 7.506, 8.879,  10.5, 12.42,  14.7, 17.38, 20.56, 24.33,\n",
+       "       28.78, 34.04, 40.26, 47.63, 56.34, 66.65, 78.84, 93.26, 110.3, 130.5,\n",
+       "       154.4, 182.6, 216.0, 255.5, 302.2, 357.5, 422.9, 500.3, 591.8, 700.0],\n",
+       "      dtype=&#x27;float64&#x27;, name=&#x27;Frequency&#x27;))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-b8c69746-039a-4427-80ab-f7c8f293429a' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-b8c69746-039a-4427-80ab-f7c8f293429a' class='xr-section-summary'  title='Expand/collapse section'>Attributes: <span>(0)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'></dl></div></li></ul></div></div>"
+      ],
+      "text/plain": [
+       "<xarray.DataArray 'Analog Sensitivity' (Frequency: 40)> Size: 320B\n",
+       "array([-223.49, -220.8 , -218.13, -215.41, -212.68, -209.91, -207.12,\n",
+       "       -204.29, -201.45, -198.58, -195.69, -192.79, -189.85, -186.9 ,\n",
+       "       -183.93, -180.93, -177.92, -174.97, -172.16, -169.61, -167.69,\n",
+       "       -166.52, -165.96, -165.81, -165.85, -165.95, -166.05, -166.13,\n",
+       "       -166.2 , -166.25, -166.28, -166.29, -166.29, -166.27, -166.24,\n",
+       "       -166.17, -166.03, -165.79, -165.47, -164.87])\n",
+       "Coordinates:\n",
+       "  * Frequency  (Frequency) float64 320B 1.0 1.183 1.399 ... 500.3 591.8 700.0"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sensitivity_curve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Use last value in calibration curve for higher frequencies\n",
+    "fill_Sf = sensitivity_curve[-1].values.item()\n",
+    "spsd = acoustics.apply_calibration(spsd, sensitivity_curve, fill_value=fill_Sf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Mean Square Sound Pressure Spectral Density Level\n",
+    "\n",
+    "We can use the function `sound_pressure_spectral_density_level` to calculate the mean square sound pressure spectral density levels (SPSDLs) from the calibrated SPSD. This function converts absolute pressure into relative pressure in log-space, the traditional means with which we measure sound, in units of decibels relative to 1 uPa (dB rel 1 uPa), the standard for underwater sound. \n",
+    "    \n",
+    "Sidenote: Sound in air is measured in decibels relative to 20 uPa, the minimum pressure level humans can hear. To convert between dB rel 1 uPa and dB rel 20 uPa, one simply needs to subtract 26 dB from the dB rel 1 uPa value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "spsdl = acoustics.sound_pressure_spectral_density_level(spsd)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that the SPSDL is calculated, we can create spectrograms, or waterfall plots, using the `plot_spectrogram` function in the graphics submodule. While spectrograms aren't required by the IEC-40, they are useful to do quality control so we can avoid using contaminated soundbytes in further analysis (like the boat noise shown in this one).\n",
+    "\n",
+    "To do this, we'll give the function the minimum and maximum frequencies to plot, as well as keyword arguments supplied to the matplotlib pcolormesh function. For these measurements, we're setting fmin = 10 Hz, the minimum specified by the IEC-40, and fmax = 48,000 Hz, the Nyquist frequency for these data. \n",
+    "\n",
+    "Note, the IEC-40 requires a maximum frequency of 100,000 Hz, so a hydrophone capable of sampling faster than 200,000 Hz should be used for IEC testing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "48000.0"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Show Nyquist frequency (maximum in frequency vector)\n",
+    "spsdl[\"freq\"].max().item()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fmin = 10\n",
+    "fmax = 48000\n",
+    "\n",
+    "# Create high resolution spectrogram\n",
+    "kwargs={\"cmap\": \"inferno\", \"vmin\": 0, \"vmax\": 100}\n",
+    "fig, ax = acoustics.graphics.plot_spectrogram(\n",
+    "    spsdl, fmin, fmax, **kwargs\n",
+    ")\n",
+    "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%H:%M:%S\"))\n",
+    "ax.xaxis.set_major_locator(mdates.MinuteLocator(interval=2))\n",
+    "ax.xaxis.set_minor_locator(mdates.MinuteLocator())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you see something interesting in the spectrogram, the next step you should do is listen to the .wav file. This can tell you a lot about what you're looking at. If you listen to this file, you'll hear the boat cruising by around 3 minutes in.\n",
+    "\n",
+    "Some audio players aren't able to play some hydrophone recodings (i.e. icListens), so be sure to try multiple if you can't hear anything in one particular player. Higher-end hydrophones tend to user higher ADC peak voltages, which will translate to quieter audio tracks. You can use the `export_audio` file in the io submodule to rescale these audio tracks and increase the gain if need be."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uncomment to save new file\n",
+    "filename = \"sound1.wav\"\n",
+    "#acoustics.io.export_audio(filename, P, gain=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Window Averaging\n",
+    "\n",
+    "The IEC-40 requires a few aggregate statistics for characterizing the sound of marine energy devices. For the first, the IEC-40 asks for plots showing the 25%, 50%, and 75% quantiles of the SPSDL during specific marine energy device states. For current energy devices, the IEC-40 requires 10 SPSDL samples at a series of turbine states (braked, freewheel, 25% power, 50% power, 75% power, 100% power). For wave energy devices, the spec requires 30 SPSDL samples in each wave height and period bin observed.\n",
+    "\n",
+    "In the following code block, we'll take our 5 minutes of measurements, `time_aggregate` them into 30 second intervals, and find the median, 25% and 75% quantiles of each interval. For the IEC-40, the sets 10 or 30 samples can either be continuous timeseries or pieced together from individual 1 s measurements. For this example notebook we'll keep it simple and just use the first 30 s interval."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Time average into 30 s windows\n",
+    "window = 30\n",
+    "spsdl_50 = acoustics.time_aggregate(spsdl, window, method=\"median\")\n",
+    "spsdl_25 = acoustics.time_aggregate(spsdl, window, method={\"quantile\":0.25})\n",
+    "spsdl_75 = acoustics.time_aggregate(spsdl, window, method={\"quantile\":0.75})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can then using the `plot_spectra` function in the graphics submodule to plot the median and quantiles of the first 30 s window."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Median and Quantile Sound Pressure Spectral Density Level')"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot medians and quantiles\n",
+    "fig, ax = acoustics.graphics.plot_spectra(spsdl_50[0], fmin, fmax)\n",
+    "ax.fill_between(\n",
+    "    spsdl_50[\"freq\"],\n",
+    "    spsdl_25[0],\n",
+    "    spsdl_75[0],\n",
+    "    alpha=0.5,\n",
+    "    facecolor=\"C0\",\n",
+    "    edgecolor=None\n",
+    ")\n",
+    "ax.set_ylim(20, 80)\n",
+    "ax.set_title(\"Median and Quantile Sound Pressure Spectral Density Level\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sound Pressure Level\n",
+    "\n",
+    "The next two requirements from the IEC-40 are calculations of sound pressure level (SPL). We'll first calculate the SPL over the full frequency range of the turbine and/or hydrophone. The IEC-40 asks that the range be set from 10 to 100,000 Hz, though the lower limit can be increased due to flow noise or low frequency signal loss due to shallow water. \n",
+    "\n",
+    "#### Shallow water cutoff frequency\n",
+    "Low frequency sound is absorbed into the seabed in shallow water depths. We can use the function `minimum_frequency` to get an approximation of what our minimum frequency should be. This approximation uses the water depth, estimates of the in-water sound speed and sea/riverbed sound speed to determine what the cutoff frequency will be. The difficult part with this approximation is figuring out the speed of sound in the bed material, which generally ranges from 1450-1800 m/s. \n",
+    "\n",
+    "This function should only be used as a rough approximation and sanity check if significant attenuation is seen at various low frequencies and harmonics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Depth [m], Freq [Hz]\n",
+      "1, 796.9\n",
+      "5, 159.4\n",
+      "10, 79.7\n",
+      "20, 39.8\n",
+      "40, 19.9\n",
+      "80, 10.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "depths = np.array([1, 5, 10, 20, 40, 80])\n",
+    "fmin = acoustics.minimum_frequency(water_depth=depths, c=1500, c_seabed=1700)\n",
+    "\n",
+    "print(\"Depth [m], Freq [Hz]\")\n",
+    "for d, f in zip(depths, fmin):\n",
+    "    print(f\"{d}, {f:0.1f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Though the IEC-40 says we should default to a minimum frequency of 10 Hz, as you can see above, unless we're measuring from a depth of around 80 +/- 10 m, our minimum frequency should be higher. One can play around with the bed soundspeed to see how these change with varying bed densities/compositions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Flow Noise\n",
+    "Flow noise, or psuedo-sound, is the other reason to increase the minimum frequency of our SPL measurements. Flow noise is caused by one of three things: turbulence advected past the hydrophone element, turbulence caused by the hydrophone element, and the sensitivity of the hydrophone element to temperature inhomogeneities in the advected flow. Flow noise is most noticeably apparent when flow speeds increase above 0.5 m/s, seen in spectrograms as a logarithmic increase in pressure with decreasing frequency.\n",
+    "\n",
+    "The particular data shown here was measured in around 8-10 m of water, and a mix of mild flow noise below 20 Hz and low frequency attenutation below ~50 Hz can be seen in the spectrogram. We'll again use the Nyquist frequency of 48,000 Hz."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "spl_median: 86.02\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Sound pressure level\n",
+    "fmin = 50\n",
+    "fmax = 48000\n",
+    "\n",
+    "spl = acoustics.sound_pressure_level(spsd, fmin, fmax)\n",
+    "spl_q50 = acoustics.time_aggregate(spl, window, method=\"median\")\n",
+    "print(f\"spl_median: {spl_q50[0].values:0.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So our median SPL for this overall frequency band is 98.5 dB rel 1 uPa."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Decidecade Sound Pressure Levels\n",
+    "\n",
+    "The last stat that IEC-40 requests are the decidecade SPLs. Note that the IEC-40 incorrectly labels these as synonymous with the third-octave SPLs, following the relevant (and also incorrect) ANSI specifications. \n",
+    "\n",
+    "To explain, an octave is a frequency band where the upper frequency is double (2^1) that of the lower frequency. The one-third octave is a frequency band where the upper frequency is 2^(1/3) times the lower frequency. The decidecade is a frequency band with a bandwidth of 2^(1/10), which means it's the tenth octave, not the third. Wherever the IEC-40 says third octave they actually mean the decidecade band.\n",
+    "\n",
+    "We can calculate the SPL in each decidecade band using the function `decidecade_sound_pressure_level`. This function uses the same calculation as `sound_pressure_level` above and run it on each tenth octave band. Note that the SPL in smaller frequency bands will be smaller than the SPL in larger ones."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Decidecade SPL')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Decidecade octave sound pressure level (also interquartile)\n",
+    "spl10 = acoustics.decidecade_sound_pressure_level(spsd, fmin, fmax)\n",
+    "\n",
+    "# Time average into 30 s windows\n",
+    "window = 30\n",
+    "spl10_q50 = acoustics.time_aggregate(spl10, window, method=\"median\")\n",
+    "spl10_q25 = acoustics.time_aggregate(spl10, window, method={\"quantile\":0.25})\n",
+    "spl10_q75 = acoustics.time_aggregate(spl10, window, method={\"quantile\":0.75})\n",
+    "\n",
+    "# Plot medians and quantiles\n",
+    "fig, ax = acoustics.graphics.plot_spectra(spl10_q50[0], fmin, fmax)\n",
+    "ax.fill_between(\n",
+    "    spl10_q50[\"freq_bins\"],\n",
+    "    spl10_q25[0],\n",
+    "    spl10_q75[0],\n",
+    "    alpha=0.5,\n",
+    "    facecolor=\"C0\",\n",
+    "    edgecolor=None\n",
+    ")\n",
+    "ax.set_title(\"Decidecade SPL\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Third Octave Sound Pressure Level\n",
+    "\n",
+    "Since you're now curious, you can also calculate the 1/3 octave SPLs using `third_octave_sound_pressure_level`. Third octaves are often measured because the human ear appears to have evolved to filter sound at this bandwidth. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Third Octave SPL')"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Median third octave sound pressure level\n",
+    "spl3 = acoustics.third_octave_sound_pressure_level(spsd, fmin, fmax)\n",
+    "\n",
+    "# Time average into 30 s windows\n",
+    "window = 30\n",
+    "spl3_q50 = acoustics.time_aggregate(spl3, window, method=\"median\")\n",
+    "spl3_q25 = acoustics.time_aggregate(spl3, window,  method={\"quantile\":0.25})\n",
+    "spl3_q75 = acoustics.time_aggregate(spl3, window,  method={\"quantile\":0.25})\n",
+    "\n",
+    "# Plot medians and quantiles\n",
+    "fig, ax = acoustics.graphics.plot_spectra(spl3_q50[0], fmin, fmax)\n",
+    "ax.fill_between(\n",
+    "    spl3_q50[\"freq_bins\"],\n",
+    "    spl3_q25[0],\n",
+    "    spl3_q75[0],\n",
+    "    alpha=0.5,\n",
+    "    facecolor=\"C0\",\n",
+    "    edgecolor=None\n",
+    ")\n",
+    "ax.set_title(\"Third Octave SPL\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "work",
+   "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.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/cdip_example.ipynb b/examples/cdip_example.ipynb
index 0f5028af2..698d794bd 100644
--- a/examples/cdip_example.ipynb
+++ b/examples/cdip_example.ipynb
@@ -576,7 +576,7 @@
     "Hs = buoy_data[\"data\"][\"wave\"][\"waveHs\"]\n",
     "Tp = buoy_data[\"data\"][\"wave\"][\"waveTp\"]\n",
     "Dp = buoy_data[\"data\"][\"wave\"][\"waveDp\"]\n",
-    "buoy_name = buoy_data[\"data\"][\"wave\"].name\n",
+    "buoy_name = buoy_data[\"metadata\"][\"name\"]\n",
     "ax = graphics.plot_compendium(Hs, Tp, Dp, buoy_name)"
    ]
   },
@@ -590,7 +590,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -604,7 +604,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.12.7"
   }
  },
  "nbformat": 4,
diff --git a/examples/data/acoustics/6247.230204150508.wav b/examples/data/acoustics/6247.230204150508.wav
new file mode 100644
index 000000000..5341f49d0
Binary files /dev/null and b/examples/data/acoustics/6247.230204150508.wav differ
diff --git a/examples/data/acoustics/6247_calibration.csv b/examples/data/acoustics/6247_calibration.csv
new file mode 100644
index 000000000..0bcda8f62
--- /dev/null
+++ b/examples/data/acoustics/6247_calibration.csv
@@ -0,0 +1,41 @@
+Frequency,Analog Sensitivity,
+1,-223.49,
+1.183,-220.8,
+1.399,-218.13,
+1.655,-215.41,
+1.958,-212.68,
+2.316,-209.91,
+2.74,-207.12,
+3.241,-204.29,
+3.834,-201.45,
+4.535,-198.58,
+5.364,-195.69,
+6.345,-192.79,
+7.506,-189.85,
+8.879,-186.9,
+10.5,-183.93,
+12.42,-180.93,
+14.7,-177.92,
+17.38,-174.97,
+20.56,-172.16,
+24.33,-169.61,
+28.78,-167.69,
+34.04,-166.52,
+40.26,-165.96,
+47.63,-165.81,
+56.34,-165.85,
+66.65,-165.95,
+78.84,-166.05,
+93.26,-166.13,
+110.3,-166.2,
+130.5,-166.25,
+154.4,-166.28,
+182.6,-166.29,
+216,-166.29,
+255.5,-166.27,
+302.2,-166.24,
+357.5,-166.17,
+422.9,-166.03,
+500.3,-165.79,
+591.8,-165.47,
+700,-164.87,
diff --git a/examples/data/acoustics/RBW_6661_20240601_053114.wav b/examples/data/acoustics/RBW_6661_20240601_053114.wav
new file mode 100644
index 000000000..08fdb27e6
Binary files /dev/null and b/examples/data/acoustics/RBW_6661_20240601_053114.wav differ
diff --git a/examples/environmental_contours_example.ipynb b/examples/environmental_contours_example.ipynb
index 9f5e72da8..c97f2a634 100644
--- a/examples/environmental_contours_example.ipynb
+++ b/examples/environmental_contours_example.ipynb
@@ -647,9 +647,13 @@
     "    Hm0_list.append(resource.significant_wave_height(year_data.T))\n",
     "    Te_list.append(resource.energy_period(year_data.T))\n",
     "\n",
-    "# Concatenate list of Series into a single DataFrame\n",
+    "# Concatenate each list of Series into a single Series\n",
     "Te = pd.concat(Te_list, axis=0)\n",
     "Hm0 = pd.concat(Hm0_list, axis=0)\n",
+    "\n",
+    "# Name each Series and concat into a dataFrame\n",
+    "Te.name = 'Te'\n",
+    "Hm0.name = 'Hm0'\n",
     "Hm0_Te = pd.concat([Hm0, Te], axis=1)\n",
     "\n",
     "# Drop any NaNs created from the calculation of Hm0 or Te\n",
@@ -800,7 +804,7 @@
    "source": [
     "## Resource Clusters\n",
     "\n",
-    "Often in resource characterization we want to pick a few representative sea state to run an alaysis. To do this with the resource data in python we reccomend using a Gaussian Mixture Model (a more generalized k-means clustering method). Using sckitlearn this is very straigth forward. We combine our Hm0 and Te data into an N x 2 numpy array. We specify our number of components (number of representative sea states) and then call the fit method on the data. Fianlly, using the methods `means_` and `weights` we can organize the results into an easily digestable table."
+    "Often in resource characterization we want to pick a few representative sea state to run an alaysis. To do this with the resource data in python we reccomend using a Gaussian Mixture Model (a more generalized k-means clustering method). Using sckitlearn this is very straight forward. We combine our Hm0 and Te data into an N x 2 numpy array. We specify our number of components (number of representative sea states) and then call the fit method on the data. Fianlly, using the methods `means_` and `weights` we can organize the results into an easily digestable table."
    ]
   },
   {
@@ -933,9 +937,13 @@
     "    Hm0_list.append(resource.significant_wave_height(year_data.T))\n",
     "    Tp_list.append(resource.peak_period(year_data.T))\n",
     "\n",
-    "# Concatenate list of Series into a single DataFrame\n",
+    "# Concatenate each list of Series into a single Series\n",
     "Tp = pd.concat(Tp_list, axis=0)\n",
     "Hm0 = pd.concat(Hm0_list, axis=0)\n",
+    "\n",
+    "# Name each Series and concat into a dataFrame\n",
+    "Tp.name = 'Tp'\n",
+    "Hm0.name = 'Hm0'\n",
     "Hm0_Tp = pd.concat([Hm0, Tp], axis=1)\n",
     "\n",
     "# Drop any NaNs created from the calculation of Hm0 or Te\n",
@@ -1116,7 +1124,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.13 ('.venv': venv)",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1130,7 +1138,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.12.4"
   },
   "vscode": {
    "interpreter": {
diff --git a/examples/extreme_response_MLER_example.ipynb b/examples/extreme_response_MLER_example.ipynb
index 2860c6ef2..be95fb280 100644
--- a/examples/extreme_response_MLER_example.ipynb
+++ b/examples/extreme_response_MLER_example.ipynb
@@ -197,11 +197,11 @@
     "\n",
     "# generate wave number k\n",
     "k = resource.wave_number(wave_freq, 70)\n",
-    "k = k.fillna(0)\n",
+    "np.nan_to_num(k, 0)\n",
     "\n",
     "peakHeightDesired = Hs / 2 * 1.9\n",
     "mler_norm = extreme.mler_wave_amp_normalize(\n",
-    "    peakHeightDesired, mler_data, sim, k.k.values\n",
+    "    peakHeightDesired, mler_data, sim, k\n",
     ")"
    ]
   },
@@ -239,7 +239,7 @@
     }
    ],
    "source": [
-    "mler_ts = extreme.mler_export_time_series(RAO.values, mler_norm, sim, k.k.values)\n",
+    "mler_ts = extreme.mler_export_time_series(RAO.values, mler_norm, sim, k)\n",
     "mler_ts.plot(xlabel=\"Time (s)\", ylabel=\"[m] / [*]\", xlim=[-100, 100], grid=True)"
    ]
   },
@@ -256,7 +256,7 @@
    "hash": "6acc4428af86beefd6565514d05fe9ce8e024621fafadd3627cdac7b7bd68bc4"
   },
   "kernelspec": {
-   "display_name": "Python 3.8.10 64-bit ('MHKdev': conda)",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -270,10 +270,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
-  },
-  "orig_nbformat": 4
+   "version": "3.12.4"
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/examples/extreme_response_contour_example.ipynb b/examples/extreme_response_contour_example.ipynb
index ae22dd57e..0ee20f4c9 100644
--- a/examples/extreme_response_contour_example.ipynb
+++ b/examples/extreme_response_contour_example.ipynb
@@ -72,9 +72,13 @@
     "    Hm0_list.append(resource.significant_wave_height(year_data.T))\n",
     "    Te_list.append(resource.energy_period(year_data.T))\n",
     "\n",
-    "# Concatenate list of Series into a single DataFrame\n",
+    "# Concatenate each list of Series into a single Series\n",
     "Te = pd.concat(Te_list, axis=0)\n",
     "Hm0 = pd.concat(Hm0_list, axis=0)\n",
+    "\n",
+    "# Name each Series and concat into a dataFrame\n",
+    "Te.name = 'Te'\n",
+    "Hm0.name = 'Hm0'\n",
     "Hm0_Te = pd.concat([Hm0, Te], axis=1)\n",
     "\n",
     "# Drop any NaNs created from the calculation of Hm0 or Te\n",
@@ -323,7 +327,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
diff --git a/examples/extreme_response_full_sea_state_example.ipynb b/examples/extreme_response_full_sea_state_example.ipynb
index 4181e1bc3..76266e05e 100644
--- a/examples/extreme_response_full_sea_state_example.ipynb
+++ b/examples/extreme_response_full_sea_state_example.ipynb
@@ -75,9 +75,13 @@
     "    Hm0_list.append(resource.significant_wave_height(year_data.T))\n",
     "    Te_list.append(resource.energy_period(year_data.T))\n",
     "\n",
-    "# Concatenate list of Series into a single DataFrame\n",
+    "# Concatenate each list of Series into a single Series\n",
     "Te = pd.concat(Te_list, axis=0)\n",
     "Hm0 = pd.concat(Hm0_list, axis=0)\n",
+    "\n",
+    "# Name each Series and concat into a dataFrame\n",
+    "Te.name = 'Te'\n",
+    "Hm0.name = 'Hm0'\n",
     "Hm0_Te = pd.concat([Hm0, Te], axis=1)\n",
     "\n",
     "# Drop any NaNs created from the calculation of Hm0 or Te\n",
@@ -573,7 +577,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
diff --git a/examples/wave_example.ipynb b/examples/wave_example.ipynb
index e03f81feb..4adf42b5b 100644
--- a/examples/wave_example.ipynb
+++ b/examples/wave_example.ipynb
@@ -514,65 +514,14 @@
       "outputs": [
         {
           "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>Te</th>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>index</th>\n",
-              "      <th></th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 00:40:00</th>\n",
-              "      <td>7.458731</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 01:40:00</th>\n",
-              "      <td>7.682413</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 02:40:00</th>\n",
-              "      <td>7.498263</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 03:40:00</th>\n",
-              "      <td>7.676198</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 04:40:00</th>\n",
-              "      <td>7.669476</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "</div>"
-            ],
             "text/plain": [
-              "                           Te\n",
-              "index                        \n",
-              "2018-01-01 00:40:00  7.458731\n",
-              "2018-01-01 01:40:00  7.682413\n",
-              "2018-01-01 02:40:00  7.498263\n",
-              "2018-01-01 03:40:00  7.676198\n",
-              "2018-01-01 04:40:00  7.669476"
+              "variable\n",
+              "2018-01-01 00:40:00    7.458731\n",
+              "2018-01-01 01:40:00    7.682413\n",
+              "2018-01-01 02:40:00    7.498263\n",
+              "2018-01-01 03:40:00    7.676198\n",
+              "2018-01-01 04:40:00    7.669476\n",
+              "Name: Te, dtype: float64"
             ]
           },
           "execution_count": 4,
@@ -593,65 +542,14 @@
       "outputs": [
         {
           "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>Hm0</th>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>index</th>\n",
-              "      <th></th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 00:40:00</th>\n",
-              "      <td>0.939574</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 01:40:00</th>\n",
-              "      <td>1.001399</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 02:40:00</th>\n",
-              "      <td>0.924770</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 03:40:00</th>\n",
-              "      <td>0.962497</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 04:40:00</th>\n",
-              "      <td>0.989949</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "</div>"
-            ],
             "text/plain": [
-              "                          Hm0\n",
-              "index                        \n",
-              "2018-01-01 00:40:00  0.939574\n",
-              "2018-01-01 01:40:00  1.001399\n",
-              "2018-01-01 02:40:00  0.924770\n",
-              "2018-01-01 03:40:00  0.962497\n",
-              "2018-01-01 04:40:00  0.989949"
+              "variable\n",
+              "2018-01-01 00:40:00    0.939574\n",
+              "2018-01-01 01:40:00    1.001399\n",
+              "2018-01-01 02:40:00    0.924770\n",
+              "2018-01-01 03:40:00    0.962497\n",
+              "2018-01-01 04:40:00    0.989949\n",
+              "Name: Hm0, dtype: float64"
             ]
           },
           "execution_count": 5,
@@ -672,65 +570,14 @@
       "outputs": [
         {
           "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>J</th>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>index</th>\n",
-              "      <th></th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 00:40:00</th>\n",
-              "      <td>3354.825613</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 01:40:00</th>\n",
-              "      <td>3916.541523</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 02:40:00</th>\n",
-              "      <td>3278.298930</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 03:40:00</th>\n",
-              "      <td>3664.246679</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2018-01-01 04:40:00</th>\n",
-              "      <td>3867.014933</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "</div>"
-            ],
             "text/plain": [
-              "                               J\n",
-              "index                           \n",
-              "2018-01-01 00:40:00  3354.825613\n",
-              "2018-01-01 01:40:00  3916.541523\n",
-              "2018-01-01 02:40:00  3278.298930\n",
-              "2018-01-01 03:40:00  3664.246679\n",
-              "2018-01-01 04:40:00  3867.014933"
+              "variable\n",
+              "2018-01-01 00:40:00    3354.825613\n",
+              "2018-01-01 01:40:00    3916.541523\n",
+              "2018-01-01 02:40:00    3278.298930\n",
+              "2018-01-01 03:40:00    3664.246679\n",
+              "2018-01-01 04:40:00    3867.014933\n",
+              "Name: J, dtype: float64"
             ]
           },
           "execution_count": 6,
@@ -751,85 +598,10 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Conversion from DataFrames to Series\n",
-        "MHKiT functions typically take in Pandas Series so that the function knows exactly which column to use. Pandas Series are one-dimensional ndarrays with axis labels which are most commonly encountered when a single column is requested from a DataFrame (e.g. `ndbc_data['2018-01-01 01:40:00']` returns a Pandas Series from the Pandas DataFrame of all frequencies at the specified time). \n",
+        "### Note on data types\n",
+        "MHKiT functions typically allow Pandas Series, Pandas DataFrame, or xarray DataArray input. Multidimensional data (DataFrames and DataArrays) typically require an index or dimension name to specify the frequency or time dimension in question. If not supplied, the first dimension is assumed to be the relevant dimension.\n",
         "\n",
-        "To the above results (energy Period, energy flux, and significant wave height) were returned as DataFrames. For DataFrames which only have one column the conversion from DataFrame to Series can accomplished using the `squeeze` method. Alternatively we can call on the column header. Both methods are demonstrated below:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 7,
-      "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "index\n",
-              "2018-01-01 00:40:00    7.458731\n",
-              "2018-01-01 01:40:00    7.682413\n",
-              "2018-01-01 02:40:00    7.498263\n",
-              "2018-01-01 03:40:00    7.676198\n",
-              "2018-01-01 04:40:00    7.669476\n",
-              "Name: Te, dtype: float64"
-            ]
-          },
-          "execution_count": 7,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "# Convert the energy period DataFrame to a Series.\n",
-        "Te = Te.squeeze()\n",
-        "Te.head()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 8,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "index\n",
-            "2018-01-01 00:40:00    0.939574\n",
-            "2018-01-01 01:40:00    1.001399\n",
-            "2018-01-01 02:40:00    0.924770\n",
-            "2018-01-01 03:40:00    0.962497\n",
-            "2018-01-01 04:40:00    0.989949\n",
-            "                         ...   \n",
-            "2018-01-31 19:40:00    2.650811\n",
-            "2018-01-31 20:40:00    3.086746\n",
-            "2018-01-31 21:40:00    2.650358\n",
-            "2018-01-31 22:40:00    2.941428\n",
-            "2018-01-31 23:40:00    2.895928\n",
-            "Name: Hm0, Length: 743, dtype: float64\n",
-            "index\n",
-            "2018-01-01 00:40:00     3354.825613\n",
-            "2018-01-01 01:40:00     3916.541523\n",
-            "2018-01-01 02:40:00     3278.298930\n",
-            "2018-01-01 03:40:00     3664.246679\n",
-            "2018-01-01 04:40:00     3867.014933\n",
-            "                           ...     \n",
-            "2018-01-31 19:40:00    37596.750775\n",
-            "2018-01-31 20:40:00    52532.427635\n",
-            "2018-01-31 21:40:00    38153.227517\n",
-            "2018-01-31 22:40:00    50501.872907\n",
-            "2018-01-31 23:40:00    47070.874952\n",
-            "Name: J, Length: 743, dtype: float64\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Alternatively, convert to Series by calling a specific column in the DataFrame\n",
-        "Hm0 = Hm0[\"Hm0\"]\n",
-        "print(Hm0)\n",
-        "\n",
-        "J = J[\"J\"]\n",
-        "print(J)"
+        "The above results (energy period, energy flux, and significant wave height) were returned as Pandas Series. 2D wave spectral data (frequency x time) was input and the frequency dimension was reduced leaving 1D, columnar data as the output. In Pandas, this is represented as a Series. If a DataArray with 3 or more dimensions was input, the output would be a DataArray with one fewer dimensions."
       ]
     },
     {
@@ -843,7 +615,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": 7,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -864,7 +636,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 10,
+      "execution_count": 8,
       "metadata": {},
       "outputs": [
         {
@@ -1449,7 +1221,7 @@
               "10.5       0.000204  0.000225  "
             ]
           },
-          "execution_count": 10,
+          "execution_count": 8,
           "metadata": {},
           "output_type": "execute_result"
         }
@@ -1484,7 +1256,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": 9,
       "metadata": {},
       "outputs": [
         {
@@ -2069,7 +1841,7 @@
               "10.5       0.001346  0.001346  "
             ]
           },
-          "execution_count": 11,
+          "execution_count": 9,
           "metadata": {},
           "output_type": "execute_result"
         }
@@ -2093,7 +1865,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": 10,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -2112,7 +1884,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 13,
+      "execution_count": 11,
       "metadata": {
         "scrolled": true
       },
@@ -2134,7 +1906,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 14,
+      "execution_count": 12,
       "metadata": {},
       "outputs": [
         {
@@ -2719,7 +2491,7 @@
               "10.5       212.411  "
             ]
           },
-          "execution_count": 14,
+          "execution_count": 12,
           "metadata": {},
           "output_type": "execute_result"
         }
@@ -2748,15 +2520,15 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 15,
+      "execution_count": 13,
       "metadata": {},
       "outputs": [
         {
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "MAEP from timeseries =  1767087.5275863332\n",
-            "MAEP from matrices =  1781210.865283919\n"
+            "MAEP from timeseries =  1767087.527586333\n",
+            "MAEP from matrices =  1781210.8652839188\n"
           ]
         }
       ],
@@ -2787,7 +2559,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 16,
+      "execution_count": 14,
       "metadata": {},
       "outputs": [
         {
@@ -2816,7 +2588,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 17,
+      "execution_count": 15,
       "metadata": {
         "scrolled": true
       },
@@ -2827,7 +2599,7 @@
               "<Axes: xlabel='Te (s)', ylabel='Hm0 (m)'>"
             ]
           },
-          "execution_count": 17,
+          "execution_count": 15,
           "metadata": {},
           "output_type": "execute_result"
         },
@@ -2861,7 +2633,7 @@
   ],
   "metadata": {
     "kernelspec": {
-      "display_name": "Python 3",
+      "display_name": "base",
       "language": "python",
       "name": "python3"
     },
diff --git a/mhkit/__init__.py b/mhkit/__init__.py
index 116453146..919634a7a 100644
--- a/mhkit/__init__.py
+++ b/mhkit/__init__.py
@@ -8,6 +8,7 @@
 from mhkit import loads
 from mhkit import dolfyn
 from mhkit import mooring
+from mhkit import acoustics
 
 # Register datetime converter for a matplotlib plotting methods
 from pandas.plotting import register_matplotlib_converters as _rmc
diff --git a/mhkit/acoustics/__init__.py b/mhkit/acoustics/__init__.py
new file mode 100644
index 000000000..f91eec6f9
--- /dev/null
+++ b/mhkit/acoustics/__init__.py
@@ -0,0 +1,9 @@
+"""
+The `acoustics` package of the MHKiT (Marine and Hydrokinetic Toolkit) library
+provides tools and functionalities for analyzing and visualizing passive
+acoustic monitoring data deployed in water bodies. This package reads in raw
+wav files and conducts basic acoustics analysis and visualization.
+"""
+
+from mhkit.acoustics import io, graphics
+from .analysis import *
diff --git a/mhkit/acoustics/analysis.py b/mhkit/acoustics/analysis.py
new file mode 100644
index 000000000..89d93b5b8
--- /dev/null
+++ b/mhkit/acoustics/analysis.py
@@ -0,0 +1,862 @@
+"""
+This module contains key functions for passive acoustics analysis, designed to process
+and analyze sound pressure data from .wav files in the frequency and time domains.
+The functions herein build on each other, with a structured flow that facilitates the
+calculation of sound pressure levels, spectral densities, and banded averages, based on 
+input audio data.
+
+The following functionality is provided:
+
+1. **Frequency Validation and Warning**:
+   - `_fmax_warning`: Ensures specified maximum frequency does not exceed the Nyquist frequency, 
+     adjusting if necessary to avoid aliasing.
+
+2. **Shallow Water Cutoff Frequency**:
+   - `minimum_frequency`: Calculates the minimum frequency cutoff based on water depth and the
+     speed of sound in water and seabed materials.
+
+3. **Spectral Density Calculations**:
+   - `sound_pressure_spectral_density`: Computes the mean square sound pressure spectral density
+     using FFT binning with Hanning windowing and 50% overlap.
+
+4. **Calibration**:
+   - `apply_calibration`: Applies calibration adjustments to the spectral density data using 
+     a sensitivity curve, filling missing values as specified.
+
+5. **Spectral Density Level Calculation**:
+   - `sound_pressure_spectral_density_level`: Converts mean square spectral density values to 
+     sound pressure spectral density levels in dB.
+
+6. **Spectral Density Aggregation**:
+   - `band_aggregate`: Aggregates spectral density data into fractional octave bands using
+     specified statistical methods (e.g., median, mean).
+
+   - `time_aggregate`: Aggregates spectral density data into specified time windows using
+     similar statistical methods.
+
+7. **Sound Pressure Level Calculation**:
+   - `sound_pressure_level`: Computes the overall sound pressure level within a frequency band
+     from mean square spectral density.
+
+8. **Frequency-Banded Sound Pressure Level**:
+   - `_band_sound_pressure_level`: Helper function for calculating sound pressure levels
+     over specified frequency bandwidths.
+     
+   - `third_octave_sound_pressure_level` and `decidecade_sound_pressure_level`: 
+     Compute sound pressure levels across third-octave and decidecade bands, respectively.
+
+"""
+
+from typing import Union, Dict, Tuple, Optional
+import warnings
+import numpy as np
+import xarray as xr
+
+from mhkit.dolfyn import VelBinner
+from mhkit.dolfyn.time import epoch2dt64, dt642epoch
+
+
+def _fmax_warning(
+    fn: Union[int, float, np.ndarray], fmax: Union[int, float, np.ndarray]
+) -> Union[int, float, np.ndarray]:
+    """
+    Checks that the maximum frequency limit isn't greater than the Nyquist frequency.
+
+    Parameters
+    ----------
+    fn: int, float, or numpy.ndarray
+        The Nyquist frequency in Hz.
+    fmax: float
+        The maximum frequency limit in Hz.
+
+    Returns
+    -------
+    fmax: float
+        The adjusted maximum frequency limit, ensuring it does not exceed the Nyquist frequency.
+    """
+
+    if not isinstance(fn, (int, float, np.ndarray)):
+        raise TypeError("'fn' must be a numeric type (int or float).")
+    if not isinstance(fmax, (int, float, np.ndarray)):
+        raise TypeError("'fmax' must be a numeric type (int or float).")
+
+    if fmax > fn:
+        warnings.warn(
+            f"`fmax` = {fmax} is greater than the Nyquist frequency. Setting"
+            f"fmax = {fn}"
+        )
+        fmax = fn
+
+    return fmax
+
+
+def minimum_frequency(
+    water_depth: Union[int, float, np.ndarray, list],
+    c: Union[int, float] = 1500,
+    c_seabed: Union[int, float] = 1700,
+) -> Union[float, np.ndarray]:
+    """
+    Estimate the shallow water cutoff frequency based on the speed of
+    sound in the water column and the speed of sound in the seabed
+    material (generally ranges from 1450 - 1800 m/s)
+
+    Parameters
+    ----------
+    water_depth: int, float or array-like
+        Depth of the water column in meters.
+    c: float, optional
+        Speed of sound in the water column in meters per second. Default is 1500 m/s.
+    c_seabed: float, optional
+        Speed of sound in the seabed material in meters per second. Default is 1700 m/s.
+
+    Returns
+    -------
+    f_min: float or numpy.ndarray
+        The minimum cutoff frequency in Hz.
+
+    Reference
+    ---------
+    Jennings 2011 - Computational Ocean Acoustics, 2nd ed.
+    """
+
+    # Convert water_depth to a NumPy array for vectorized operations
+    water_depth = np.asarray(water_depth)
+
+    # Validate water_depth
+    if not np.issubdtype(water_depth.dtype, np.number):
+        raise TypeError("'water_depth' must be a numeric type or array of numerics.")
+
+    if not isinstance(c, (int, float)):
+        raise TypeError("'c' must be a numeric type (int or float).")
+    if not isinstance(c_seabed, (int, float)):
+        raise TypeError("'c_seabed' must be a numeric type (int or float).")
+
+    if np.any(water_depth <= 0):
+        raise ValueError("All elements of 'water_depth' must be positive numbers.")
+    if c <= 0:
+        raise ValueError("'c' must be a positive number.")
+    if c_seabed <= 0:
+        raise ValueError("'c_seabed' must be a positive number.")
+    if c_seabed <= c:
+        raise ValueError("'c_seabed' must be greater than 'c'.")
+
+    fmin = c / (4 * water_depth * np.sqrt(1 - (c / c_seabed) ** 2))
+
+    return fmin
+
+
+def sound_pressure_spectral_density(
+    pressure: xr.DataArray, fs: Union[int, float], bin_length: Union[int, float] = 1
+) -> xr.DataArray:
+    """
+    Calculates the mean square sound pressure spectral density from audio
+    samples split into FFTs with a specified bin length in seconds, using Hanning
+    windowing with 50% overlap. The amplitude of the PSD is adjusted
+    according to Parseval's theorem.
+
+    Parameters
+    ----------
+    pressure: xarray.DataArray (time)
+        Sound pressure in [Pa] or voltage [V]
+    fs: int or float
+        Data collection sampling rate [Hz]
+    bin_length: int or float
+        Length of time in seconds to create FFTs. Default: 1.
+
+    Returns
+    -------
+    spsd: xarray.DataArray (time, freq)
+        Spectral density [Pa^2/Hz] indexed by time and frequency
+    """
+
+    # Type checks
+    if not isinstance(pressure, xr.DataArray):
+        raise TypeError("'pressure' must be an xarray.DataArray.")
+    if not isinstance(fs, (int, float)):
+        raise TypeError("'fs' must be a numeric type (int or float).")
+    if not isinstance(bin_length, (int, float)):
+        raise TypeError("'bin_length' must be a numeric type (int or float).")
+
+    # Ensure that 'pressure' has a 'time' coordinate
+    if "time" not in pressure.dims:
+        raise ValueError("'pressure' must be indexed by 'time' dimension.")
+
+    # window length of each time series
+    nbin = bin_length * fs
+
+    # Use dolfyn PSD
+    binner = VelBinner(n_bin=nbin, fs=fs, n_fft=nbin)
+    # Always 50% overlap if numbers reshape perfectly
+    # Mean square sound pressure
+    psd = binner.power_spectral_density(pressure, freq_units="Hz")
+    samples = binner.reshape(pressure.values) - binner.mean(pressure.values)[:, None]
+    # Power in time domain
+    t_power = np.sum(samples**2, axis=1) / nbin
+    # Power in frequency domain
+    f_power = psd.sum("freq") * (fs / nbin)
+    # Adjust the amplitude of PSD according to Parseval's theorem
+    psd_adj = psd * t_power[:, None] / f_power
+
+    out = xr.DataArray(
+        psd_adj,
+        coords={"time": psd_adj["time"], "freq": psd_adj["freq"]},
+        attrs={
+            "units": pressure.units + "^2/Hz",
+            "long_name": "Mean Square Sound Pressure Spectral Density",
+            "fs": fs,
+            "nbin": str(bin_length) + " s",
+            "overlap": "50%",
+            "nfft": nbin,
+        },
+    )
+
+    return out
+
+
+def apply_calibration(
+    spsd: xr.DataArray,
+    sensitivity_curve: xr.DataArray,
+    fill_value: Union[float, int, np.ndarray],
+) -> xr.DataArray:
+    """
+    Applies custom calibration to spectral density values.
+
+    Parameters
+    ----------
+    spsd: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density in V^2/Hz.
+    sensitivity_curve: xarray.DataArray (freq)
+        Calibrated sensitivity curve in units of dB rel 1 V^2/uPa^2.
+        First column should be frequency, second column should be calibration values.
+    fill_value: float or int
+        Value with which to fill missing values from the calibration curve,
+        in units of dB rel 1 V^2/uPa^2.
+
+    Returns
+    -------
+    spsd_calibrated: xarray.DataArray (time, freq)
+        Spectral density in Pa^2/Hz, indexed by time and frequency.
+    """
+
+    if not isinstance(spsd, xr.DataArray):
+        raise TypeError("'spsd' must be an xarray.DataArray.")
+    if not isinstance(sensitivity_curve, xr.DataArray):
+        raise TypeError("'sensitivity_curve' must be an xarray.DataArray.")
+    if not isinstance(fill_value, (int, float, np.ndarray)):
+        raise TypeError("'fill_value' must be a numeric type (int or float).")
+
+    # Ensure 'freq' dimension exists in 'spsd'
+    if "freq" not in spsd.dims:
+        if len(spsd.dims) > 1:
+            # Issue a warning and assign the 2nd dimension as 'freq'
+            warnings.warn(
+                f"'spsd' does not have 'freq' as a dimension and has multiple dimensions. "
+                f"Using the second dimension '{spsd.dims[1]}' as 'freq'."
+            )
+        # Assign the 2nd dimension as 'freq'
+        spsd = spsd.rename({spsd.dims[1]: "freq"})
+
+    # Ensure 'freq' dimension exists in 'sensitivity_curve'
+    if "freq" not in sensitivity_curve.dims:
+        if len(sensitivity_curve.dims) > 1:
+            # Issue a warning and assign the 1st dimension as 'freq'
+            warnings.warn(
+                f"'sensitivity_curve' does not have 'freq' as a dimension \
+                      and has multiple dimensions. "
+                f"Using the first dimension '{sensitivity_curve.dims[0]}' as 'freq'."
+            )
+        # Assign the 0th dimension as 'freq'
+        sensitivity_curve = sensitivity_curve.rename(
+            {sensitivity_curve.dims[0]: "freq"}
+        )
+
+    # Create a copy of spsd to avoid in-place modification
+    spsd_calibrated = spsd.copy(deep=True)
+    attrs = spsd.attrs  # recover attrs
+
+    # Read calibration curve
+    freq = sensitivity_curve.dims[0]
+    # Interpolate calibration curve to desired value
+    calibration = sensitivity_curve.interp(
+        {freq: spsd_calibrated["freq"]}, method="linear"
+    )
+    # Fill missing with provided value
+    calibration = calibration.fillna(fill_value)
+
+    # Subtract from sound pressure spectral density
+    sensitivity_ratio = 10 ** (calibration / 10)  # V^2/uPa^2
+    spsd_calibrated = spsd_calibrated / sensitivity_ratio / 1e12  # Pa^2/Hz
+    attrs.update(
+        {"long_name": "Calibrated Sound Pressure Spectral Density", "units": "Pa^2/Hz"}
+    )
+    spsd_calibrated.attrs = attrs
+
+    return spsd_calibrated
+
+
+def sound_pressure_spectral_density_level(spsd: xr.DataArray) -> xr.DataArray:
+    """
+    Calculates the sound pressure spectral density level from
+    the mean square sound pressure spectral density.
+
+    Parameters
+    ----------
+    spsd: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density in Pa^2/Hz
+
+    Returns
+    -------
+    spsdl: xarray.DataArray (time, freq)
+        Sound pressure spectral density level [dB re 1 uPa^2/Hz]
+        indexed by time and frequency
+    """
+
+    # Reference value of sound pressure
+    reference = 1e-12  # Pa^2 to 1 uPa^2
+
+    # Sound pressure spectral density level from mean square values
+    lpf = 10 * np.log10(spsd.values / reference)
+
+    spsdl = xr.DataArray(
+        lpf.astype(np.float32),
+        coords={"time": spsd["time"], "freq": spsd["freq"]},
+        attrs={
+            "units": "dB re 1 uPa^2/Hz",
+            "long_name": "Sound Pressure Spectral Density Level",
+        },
+    )
+
+    return spsdl
+
+
+def _validate_method(
+    method: Union[str, Dict[str, Union[float, int]]]
+) -> Tuple[str, Optional[Union[float, int]]]:
+    """
+    Validates the 'method' parameter and returns the method name and its argument (if any).
+
+    Parameters
+    ----------
+    method : str or dict
+        The aggregation method to validate. It can be either:
+          - A string representing one of the supported methods without additional arguments,
+            e.g., 'mean', 'sum'.
+          - A dictionary with a single key-value pair where the key is the method name and
+            the value is its argument, e.g., {'quantile': 0.25}.
+
+        Supported methods are:
+          - 'median'
+          - 'mean'
+          - 'min'
+          - 'max'
+          - 'sum'
+          - 'quantile' (requires an argument between 0 and 1)
+          - 'std'
+          - 'var'
+          - 'count'
+
+    Returns
+    -------
+    method_name : str
+        The validated method name in lowercase.
+    method_arg : float, int, or None
+        The argument associated with the method, if applicable; otherwise, None.
+
+    Raises
+    ------
+    ValueError
+        - If the method name is not supported.
+        - If the 'quantile' method is provided without an argument or with an invalid argument.
+        - If the 'method' dictionary does not contain exactly one key-value pair.
+        - If 'method' is of an unsupported type.
+    TypeError
+        - If the key in the 'method' dictionary is not a string.
+
+    Examples
+    --------
+    >>> _validate_method('mean')
+    ('mean', None)
+
+    >>> _validate_method({'quantile': 0.75})
+    ('quantile', 0.75)
+
+    >>> _validate_method('quantile')
+    ValueError: The 'quantile' method must be provided as a dictionary with the quantile value,
+        e.g., {'quantile': 0.25}.
+
+    >>> _validate_method({'quantile': 1.5})
+    ValueError: The 'quantile' method must have a float between 0 and 1 as an argument.
+
+    >>> _validate_method({'unsupported_method': None})
+    ValueError: Method 'unsupported_method' is not supported.
+        Supported methods are:
+        ['median', 'mean', 'min', 'max', 'sum', 'quantile', 'std', 'var', 'count']
+    """
+
+    allowed_methods = [
+        "median",
+        "mean",
+        "min",
+        "max",
+        "sum",
+        "quantile",
+        "std",
+        "var",
+        "count",
+    ]
+
+    if isinstance(method, str):
+        method_name = method.lower()
+        if method_name not in allowed_methods:
+            raise ValueError(
+                f"Method '{method}' is not supported. Supported methods are: {allowed_methods}"
+            )
+        if method_name == "quantile":
+            raise ValueError(
+                "The 'quantile' method must be provided as a dictionary with "
+                "the quantile value, e.g., {'quantile': 0.25}."
+            )
+        method_arg = None
+    elif isinstance(method, dict):
+        if len(method) != 1:
+            raise ValueError(
+                "'method' dictionary must contain exactly one key-value pair."
+            )
+        method_name, method_arg = list(method.items())[0]
+        if not isinstance(method_name, str):
+            raise TypeError("Key in 'method' dictionary must be a string.")
+        method_name = method_name.lower()
+        if method_name not in allowed_methods:
+            raise ValueError(
+                f"Method '{method_name}' is not supported. Supported methods are: {allowed_methods}"
+            )
+        if method_name == "quantile":
+            if not isinstance(method_arg, (float, int)) or not 0 <= method_arg <= 1:
+                raise ValueError(
+                    "The 'quantile' method must have a float between 0 and 1 as an argument."
+                )
+    else:
+        raise ValueError(
+            f"Unsupported method type: {type(method)}. Must be a string or dictionary."
+        )
+    return method_name, method_arg
+
+
+def band_aggregate(
+    spsdl: xr.DataArray,
+    octave: int = 3,
+    fmin: int = 10,
+    fmax: int = 100000,
+    method: Union[str, Dict[str, Union[float, int]]] = "median",
+) -> xr.DataArray:
+    """
+    Reorganizes spectral density level frequency tensor into
+    fractional octave bands and applies a function to them.
+
+    Parameters
+    ----------
+    spsdl: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density level in dB rel 1 uPa^2/Hz
+    octave: int
+        Octave to subdivide spectral density level by. Default = 3 (third octave)
+    fmin: int
+        Lower frequency band limit (lower limit of the hydrophone). Default: 10 Hz
+    fmax: int
+        Upper frequency band limit (Nyquist frequency). Default: 100000 Hz
+    method: str or dict
+        Method to run on the binned data. Can be a string (e.g., "median") or a dict
+        where the key is the method and the value is its argument (e.g., {"quantile": 0.25}).
+        Options: [median, mean, min, max, sum, quantile, std, var, count]
+
+    Returns
+    -------
+    out: xarray.DataArray (time, freq_bins)
+        Frequency band-averaged sound pressure spectral density level [dB re 1 uPa^2/Hz]
+        indexed by time and frequency
+    """
+
+    # Type checks
+    if not isinstance(spsdl, xr.DataArray):
+        raise TypeError("'spsdl' must be an xarray.DataArray.")
+    if not isinstance(octave, int):
+        raise TypeError("'octave' must be an integer.")
+    if not isinstance(fmin, int):
+        raise TypeError("'fmin' must be an integer.")
+    if not isinstance(fmax, int):
+        raise TypeError("'fmax' must be an integer.")
+    if not isinstance(method, (str, dict)):
+        raise TypeError("'method' must be a string or a dictionary.")
+
+    # Value checks
+    if "freq" not in spsdl.dims or "time" not in spsdl.dims:
+        raise ValueError("'spsdl' must have 'time' and 'freq' as dimensions.")
+    if octave <= 0:
+        raise ValueError("'octave' must be a positive integer.")
+    if fmin <= 0:
+        raise ValueError("'fmin' must be a positive integer.")
+    if fmax <= fmin:
+        raise ValueError("'fmax' must be greater than 'fmin'.")
+
+    # Validate method and get method_name and method_arg
+    method_name, method_arg = _validate_method(method)
+
+    # Check fmax
+    fn = spsdl["freq"].max().values
+    fmax = _fmax_warning(fn, fmax)
+
+    bandwidth = 2 ** (1 / octave)
+    half_bandwidth = 2 ** (1 / (octave * 2))
+
+    band = {}
+    band["center_freq"] = 10 ** np.arange(
+        np.log10(fmin),
+        np.log10(fmax * bandwidth),
+        step=np.log10(bandwidth),
+    )
+    band["lower_limit"] = band["center_freq"] / half_bandwidth
+    band["upper_limit"] = band["center_freq"] * half_bandwidth
+    octave_bins = np.append(band["lower_limit"], band["upper_limit"][-1])
+
+    # Use xarray binning methods
+    spsdl_group = spsdl.groupby_bins("freq", octave_bins, labels=band["center_freq"])
+
+    # Handle method being a string or a dict
+    if isinstance(method, str):
+        func = getattr(spsdl_group, method.lower())
+        out = func()
+    elif isinstance(method, dict):
+        method_name, method_arg = list(method.items())[0]
+        func = getattr(spsdl_group, method_name.lower())
+        out = func(method_arg)
+    else:
+        raise ValueError(
+            f"Unsupported method type: {type(method)}. "
+            "Must be a string or dictionary."
+        )
+
+    out.attrs.update(
+        {"units": spsdl.units, "comment": f"Third octave frequency band {method}"}
+    )
+
+    return out
+
+
+def time_aggregate(
+    spsdl: xr.DataArray,
+    window: int = 60,
+    method: Union[str, Dict[str, Union[float, int]]] = "median",
+) -> xr.DataArray:
+    """
+    Reorganizes spectral density level frequency tensor into
+    time windows and applies a function to them.
+
+    If the window length is equivalent to the size of spsdl["time"],
+    this function is equivalent to spsdl.<method>("time")
+
+    Parameters
+    ----------
+    spsdl: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density level in dB rel 1 uPa^2/Hz
+    window: int
+        Time in seconds to subdivide spectral density level into. Default: 60 s.
+    method: str or dict
+        Method to run on the binned data. Can be a string (e.g., "median") or a dict
+        where the key is the method and the value is its argument (e.g., {"quantile": 0.25}).
+        Options: [median, mean, min, max, sum, quantile, std, var, count]
+
+    Returns
+    -------
+    out: xarray.DataArray (time_bins, freq)
+        Time-averaged sound pressure spectral density level [dB re 1 uPa^2/Hz]
+        indexed by time and frequency
+    """
+
+    # Type checks
+    if not isinstance(spsdl, xr.DataArray):
+        raise TypeError("'spsdl' must be an xarray.DataArray.")
+    if not isinstance(window, int):
+        raise TypeError("'window' must be an integer.")
+    if not isinstance(method, (str, dict)):
+        raise TypeError("'method' must be a string or dictionary.")
+    if "time" not in spsdl.dims:
+        raise ValueError("'spsdl' must have 'time' dimension.")
+
+    # Value checks
+    if window <= 0:
+        raise ValueError("'window' must be a positive integer.")
+
+    # Ensure 'time' coordinate is of datetime64 dtype
+    if not np.issubdtype(spsdl["time"].dtype, np.datetime64):
+        raise TypeError("'spsdl['time']' must be of dtype 'datetime64'.")
+
+    # Validate method and get method_name and method_arg
+    method_name, method_arg = _validate_method(method)
+
+    window = np.timedelta64(window, "s")
+    time_bins_lower = np.arange(
+        spsdl["time"][0].values, spsdl["time"][-1].values, window
+    )
+    time_bins_upper = time_bins_lower + window
+    time_bins = np.append(time_bins_lower, time_bins_upper[-1])
+    center_time = epoch2dt64(
+        0.5 * (dt642epoch(time_bins_lower) + dt642epoch(time_bins_upper))
+    )
+
+    # Use xarray binning methods
+    spsdl_group = spsdl.groupby_bins("time", time_bins, labels=center_time)
+
+    # Apply the aggregation method
+    func = getattr(spsdl_group, method_name)
+    if method_arg is not None:
+        out = func(method_arg)
+    else:
+        out = func()
+
+    # Update attributes
+    out.attrs["units"] = spsdl.units
+    out.attrs["comment"] = f"Time average {method}"
+
+    # Remove 'quantile' coordinate if present
+    if method == "quantile":
+        out = out.drop_vars("quantile")
+
+    return out
+
+
+def sound_pressure_level(
+    spsd: xr.DataArray, fmin: int = 10, fmax: int = 100000
+) -> xr.DataArray:
+    """
+    Calculates the sound pressure level in a specified frequency band
+    from the mean square sound pressure spectral density.
+
+    Parameters
+    ----------
+    spsd: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density in [Pa^2/Hz]
+    fmin: int
+        Lower frequency band limit (lower limit of the hydrophone). Default: 10 Hz
+    fmax: int
+        Upper frequency band limit (Nyquist frequency). Default: 100000 Hz
+
+    Returns
+    -------
+    spl: xarray.DataArray (time)
+        Sound pressure level [dB re 1 uPa] indexed by time
+    """
+
+    # Type checks
+    if not isinstance(spsd, xr.DataArray):
+        raise TypeError("'spsd' must be an xarray.DataArray.")
+    if not isinstance(fmin, int):
+        raise TypeError("'fmin' must be an integer.")
+    if not isinstance(fmax, int):
+        raise TypeError("'fmax' must be an integer.")
+
+    # Ensure 'freq' and 'time' dimensions are present
+    if "freq" not in spsd.dims or "time" not in spsd.dims:
+        raise ValueError("'spsd' must have 'time' and 'freq' as dimensions.")
+
+    # Check that 'fs' (sampling frequency) is available in attributes
+    if "fs" not in spsd.attrs:
+        raise ValueError(
+            "'spsd' must have 'fs' (sampling frequency) in its attributes."
+        )
+
+    # Value checks
+    if fmin <= 0:
+        raise ValueError("'fmin' must be a positive integer.")
+    if fmax <= fmin:
+        raise ValueError("'fmax' must be greater than 'fmin'.")
+
+    # Check fmax
+    fn = spsd.attrs["fs"] // 2
+    fmax = _fmax_warning(fn, fmax)
+
+    # Reference value of sound pressure
+    reference = 1e-12  # Pa^2, = 1 uPa^2
+
+    # Mean square sound pressure in a specified frequency band from mean square values
+    pressure_squared = np.trapz(
+        spsd.sel(freq=slice(fmin, fmax)), spsd["freq"].sel(freq=slice(fmin, fmax))
+    )
+
+    # Mean square sound pressure level
+    mspl = 10 * np.log10(pressure_squared / reference)
+
+    out = xr.DataArray(
+        mspl.astype(np.float32),
+        coords={"time": spsd["time"]},
+        attrs={
+            "units": "dB re 1 uPa",
+            "long_name": "Sound Pressure Level",
+            "freq_band_min": fmin,
+            "freq_band_max": fmax,
+        },
+    )
+
+    return out
+
+
+def _band_sound_pressure_level(
+    spsd: xr.DataArray,
+    bandwidth: int,
+    half_bandwidth: int,
+    fmin: int = 10,
+    fmax: int = 100000,
+) -> xr.DataArray:
+    """
+    Calculates band-averaged sound pressure levels
+
+    Parameters
+    ----------
+    spsd: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density.
+    bandwidth : int or float
+        Bandwidth to average over.
+    half_bandwidth : int or float
+        Half-bandwidth, used to set upper and lower bandwidth limits.
+    fmin : int, optional
+        Lower frequency band limit (lower limit of the hydrophone). Default is 10 Hz.
+    fmax : int, optional
+        Upper frequency band limit (Nyquist frequency). Default is 100,000 Hz.
+
+
+    Returns
+    -------
+    out: xarray.DataArray (time, freq_bins)
+        Sound pressure level [dB re 1 uPa] indexed by time and frequency of specified bandwidth
+    """
+
+    # Type checks
+    if not isinstance(spsd, xr.DataArray):
+        raise TypeError("'spsd' must be an xarray.DataArray.")
+    if not isinstance(bandwidth, (int, float)):
+        raise TypeError("'bandwidth' must be a numeric type (int or float).")
+    if not isinstance(half_bandwidth, (int, float)):
+        raise TypeError("'half_bandwidth' must be a numeric type (int or float).")
+    if not isinstance(fmin, int):
+        raise TypeError("'fmin' must be an integer.")
+    if not isinstance(fmax, int):
+        raise TypeError("'fmax' must be an integer.")
+
+    # Ensure 'freq' and 'time' dimensions are present
+    if "freq" not in spsd.dims or "time" not in spsd.dims:
+        raise ValueError("'spsd' must have 'time' and 'freq' as dimensions.")
+
+    # Check that 'fs' (sampling frequency) is available in attributes
+    if "fs" not in spsd.attrs:
+        raise ValueError(
+            "'spsd' must have 'fs' (sampling frequency) in its attributes."
+        )
+
+    # Value checks
+    if fmin <= 0:
+        raise ValueError("'fmin' must be a positive integer.")
+    if fmax <= fmin:
+        raise ValueError("'fmax' must be greater than 'fmin'.")
+
+    # Check fmax
+    fn = spsd.attrs["fs"] // 2
+    fmax = _fmax_warning(fn, fmax)
+
+    # Reference value of sound pressure
+    reference = 1e-12  # Pa^2, = 1 uPa^2
+
+    band = {}
+    band["center_freq"] = 10 ** np.arange(
+        np.log10(fmin),
+        np.log10(fmax * bandwidth),
+        step=np.log10(bandwidth),
+    )
+    band["lower_limit"] = band["center_freq"] / half_bandwidth
+    band["upper_limit"] = band["center_freq"] * half_bandwidth
+    octave_bins = np.append(band["lower_limit"], band["upper_limit"][-1])
+
+    # Manual trapezoidal rule to get Pa^2
+    pressure_squared = xr.DataArray(
+        coords={"time": spsd["time"], "freq_bins": band["center_freq"]},
+        dims=["time", "freq_bins"],
+    )
+    for i, key in enumerate(band["center_freq"]):
+        band_min = octave_bins[i]
+        band_max = octave_bins[i + 1]
+        pressure_squared.loc[{"freq_bins": key}] = np.trapz(
+            spsd.sel(freq=slice(band_min, band_max)),
+            spsd["freq"].sel(freq=slice(band_min, band_max)),
+        )
+
+    # Mean square sound pressure level in dB rel 1 uPa
+    mspl = 10 * np.log10(pressure_squared / reference)
+
+    return mspl
+
+
+def third_octave_sound_pressure_level(
+    spsd: xr.DataArray, fmin: int = 10, fmax: int = 100000
+) -> xr.DataArray:
+    """
+    Calculates the sound pressure level in third octave bands directly
+    from the mean square sound pressure spectral density.
+
+    Parameters
+    ----------
+    spsd: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density.
+    fmin: int
+        Lower frequency band limit (lower limit of the hydrophone). Default: 10 Hz
+    fmax: int
+        Upper frequency band limit (Nyquist frequency). Default: 100000 Hz
+
+    Returns
+    -------
+    mspl: xarray.DataArray (time, freq_bins)
+        Sound pressure level [dB re 1 uPa] indexed by time and third octave bands
+    """
+
+    # Third octave bin frequencies
+    bandwidth = 2 ** (1 / 3)
+    half_bandwidth = 2 ** (1 / 6)
+
+    mspl = _band_sound_pressure_level(spsd, bandwidth, half_bandwidth, fmin, fmax)
+    mspl.attrs = {
+        "units": "dB re 1 uPa",
+        "long_name": "Third Octave Sound Pressure Level",
+    }
+
+    return mspl.astype(np.float32)
+
+
+def decidecade_sound_pressure_level(
+    spsd: xr.DataArray, fmin: int = 10, fmax: int = 100000
+) -> xr.DataArray:
+    """
+    Calculates the sound pressure level in decidecade bands directly
+    from the mean square sound pressure spectral density.
+
+    Parameters
+    ----------
+    spsd: xarray.DataArray (time, freq)
+        Mean square sound pressure spectral density.
+    fmin: int
+        Lower frequency band limit (lower limit of the hydrophone). Default: 10 Hz
+    fmax: int
+        Upper frequency band limit (Nyquist frequency). Default: 100000 Hz
+
+    Returns
+    -------
+    mspl : xarray.DataArray (time, freq_bins)
+        Sound pressure level [dB re 1 uPa] indexed by time and decidecade bands
+    """
+
+    # Decidecade bin frequencies
+    bandwidth = 2 ** (1 / 10)
+    half_bandwidth = 2 ** (1 / 20)
+
+    mspl = _band_sound_pressure_level(spsd, bandwidth, half_bandwidth, fmin, fmax)
+    mspl.attrs = {
+        "units": "dB re 1 uPa",
+        "long_name": "Decidecade Sound Pressure Level",
+    }
+
+    return mspl.astype(np.float32)
diff --git a/mhkit/acoustics/graphics.py b/mhkit/acoustics/graphics.py
new file mode 100644
index 000000000..1f9aa0526
--- /dev/null
+++ b/mhkit/acoustics/graphics.py
@@ -0,0 +1,152 @@
+"""
+This submodule provides essential plotting functions for visualizing passive acoustics 
+data. The functions allow for customizable plotting of sound pressure spectral density 
+levels across time and frequency dimensions.
+
+Each plotting function leverages the flexibility of Matplotlib, allowing for passthrough
+of Matplotlib keyword arguments via **kwargs, making it easy to modify plot aspects such as
+color, scale, and label formatting.
+
+Key Functions
+-------------
+1. **plot_spectrogram**:
+   - Generates a spectrogram plot from sound pressure spectral density level data, 
+     with a logarithmic frequency scale by default for improved readability of acoustic data.
+
+2. **plot_spectra**:
+   - Produces a spectral density plot with a log-transformed x-axis, allowing for clear 
+     visualization of spectral density across frequency bands.
+"""
+
+from typing import Tuple
+import xarray as xr
+import matplotlib.pyplot as plt
+
+from .analysis import _fmax_warning
+
+
+def plot_spectrogram(
+    spsdl: xr.DataArray,
+    fmin: int = 10,
+    fmax: int = 100000,
+    fig: plt.figure = None,
+    ax: plt.Axes = None,
+    **kwargs
+) -> Tuple[plt.figure, plt.Axes]:
+    """
+    Plots the spectrogram of the sound pressure spectral density level.
+
+    Parameters
+    ----------
+    spsdl: xarray DataArray (time, freq)
+        Mean square sound pressure spectral density level in dB rel 1 uPa^2/Hz
+    fmin: int
+        Lower frequency band limit (lower limit of the hydrophone). Default: 10 Hz
+    fmax: int
+        Upper frequency band limit (Nyquist frequency). Default: 100000 Hz
+    fig: matplotlib.pyplot.figure
+        Figure handle to plot on
+    ax: matplotlib.pyplot.axis
+        Figure axis containing plot objects
+    kwargs: dict
+        Dictionary of matplotlib function keyword arguments
+
+    Returns
+    -------
+    fig: matplotlib.pyplot.figure
+        Figure handle of plot
+    ax: matplotlib.pyplot.Axes
+        Figure plot axis
+    """
+
+    if not isinstance(fmin, (int, float)) or not isinstance(fmax, (int, float)):
+        raise TypeError("fmin and fmax must be numeric types.")
+    if fmin >= fmax:
+        raise ValueError("fmin must be less than fmax.")
+
+    # Set dimension names
+    # "time" or "time_bins" is always first
+    time = spsdl.dims[0]
+    # "freq" or "freq_bins" is always second
+    freq = spsdl.dims[-1]
+
+    # Check fmax
+    fn = spsdl[freq].max().item()
+    fmax = _fmax_warning(fn, fmax)
+    # select frequency range
+    spsdl = spsdl.sel({freq: slice(fmin, fmax)})
+
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(6, 5), subplot_kw={"yscale": "log"})
+        fig.subplots_adjust(left=0.1, right=0.95, top=0.97, bottom=0.11)
+    h = ax.pcolormesh(
+        spsdl[time].values,
+        spsdl[freq].values,
+        spsdl.transpose(freq, time),
+        shading="nearest",
+        **kwargs
+    )
+    fig.colorbar(h, ax=ax, label=spsdl.units)
+    ax.set(xlabel="Time", ylabel="Frequency [Hz]")
+
+    return fig, ax
+
+
+def plot_spectra(
+    spsdl: xr.DataArray,
+    fmin: int = 10,
+    fmax: int = 100000,
+    fig: plt.figure = None,
+    ax: plt.Axes = None,
+    **kwargs
+) -> Tuple[plt.figure, plt.Axes]:
+    """
+    Plots spectral density. X axis is log-transformed.
+
+    Parameters
+    ----------
+    spsdl: xarray DataArray (time, freq)
+        Mean square sound pressure spectral density level in dB rel 1 uPa^2/Hz
+    fmin: int
+        Lower frequency band limit (lower limit of the hydrophone). Default: 10 Hz
+    fmax: int
+        Upper frequency band limit (Nyquist frequency). Default: 100000 Hz
+    fig: matplotlib.pyplot.figure
+        Figure handle to plot on
+    ax: matplotlib.pyplot.Axes
+        Figure axis containing plot objects
+    kwargs: dict
+        Dictionary of matplotlib function keyword arguments
+
+    Returns
+    -------
+    fig: matplotlib.pyplot.figure
+        Figure handle of plot
+    ax: matplotlib.pyplot.Axes
+        Figure plot axis
+    """
+
+    if not isinstance(fmin, (int, float)) or not isinstance(fmax, (int, float)):
+        raise TypeError("fmin and fmax must be numeric types.")
+    if fmin >= fmax:
+        raise ValueError("fmin must be less than fmax.")
+
+    # Set dimension names.
+    # "freq" or "freq_bins" is always second
+    freq = spsdl.dims[-1]
+
+    # Check fmax
+    fn = spsdl[freq].max().item()
+    fmax = _fmax_warning(fn, fmax)
+    # select frequency range
+    spsdl = spsdl.sel({freq: slice(fmin, fmax)})
+
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(6, 5), subplot_kw={"xscale": "log"})
+        fig.subplots_adjust(
+            left=0.1, right=0.95, top=0.85, bottom=0.2, hspace=0.3, wspace=0.15
+        )
+    ax.plot(spsdl[freq], spsdl.T, **kwargs)
+    ax.set(xlim=(fmin, fmax), xlabel="Frequency [Hz]", ylabel=spsdl.units)
+
+    return fig, ax
diff --git a/mhkit/acoustics/io.py b/mhkit/acoustics/io.py
new file mode 100644
index 000000000..94acc2048
--- /dev/null
+++ b/mhkit/acoustics/io.py
@@ -0,0 +1,545 @@
+"""
+This submodule provides input/output functions for passive acoustics data,
+focusing on hydrophone recordings stored in WAV files. The main functionality
+includes reading and processing hydrophone data from various manufacturers 
+and exporting audio files for easy playback and analysis.
+
+Supported Hydrophone Models
+---------------------------
+- **SoundTrap** (Ocean Instruments)
+- **icListen** (Ocean Sonics)
+
+Functions Overview
+------------------
+
+1. **Data Reading**:
+   - `read_hydrophone`: Main function to read a WAV file from a hydrophone and 
+     convert it to either a voltage or pressure time series, depending on the 
+     availability of sensitivity data.
+
+   - `read_soundtrap`: Wrapper for reading Ocean Instruments SoundTrap hydrophone 
+     files, automatically using appropriate metadata.
+
+   - `read_iclisten`: Wrapper for reading Ocean Sonics icListen hydrophone files, 
+     including metadata processing to apply hydrophone sensitivity for direct 
+     sound pressure calculation.
+
+2. **Audio Export**:
+   - `export_audio`: Converts processed sound pressure data back into a WAV file 
+     format, with optional gain adjustment to improve playback quality.
+
+3. **Data Extraction**:
+   - `_read_wav_metadata`: Extracts metadata from a WAV file, including bit depth 
+     and other header information.
+
+   - `_calculate_voltage_and_time`: Converts raw WAV data into voltage values and 
+     generates a time index based on the sampling frequency.
+"""
+
+from typing import BinaryIO, Tuple, Dict, Union, Optional, Any
+import io
+import struct
+import wave
+from pathlib import Path
+import numpy as np
+import pandas as pd
+import xarray as xr
+from scipy.io import wavfile
+
+
+def _read_wav_metadata(f: BinaryIO) -> dict:
+    """
+    Extracts the bit depth from a WAV file and skips over any metadata blocks
+    that might be present (e.g., 'LIST' chunks).
+
+    Parameters
+    ----------
+    f : BinaryIO
+        An open WAV file in binary mode.
+
+    Returns
+    -------
+    header : dict
+        Dictionary containing .wav file's header data
+    """
+
+    header = {}
+    f.read(4)  # riff_key
+    header["filesize"] = struct.unpack("<I", f.read(4))[0]
+    f.read(4)  # wave_key
+    list_key = f.read(4)
+
+    # Skip metadata if it exists
+    if "LIST" in list_key.decode():
+        list_size = struct.unpack("<I", f.read(4))[0]
+        f.seek(f.tell() + list_size)
+    else:
+        f.seek(f.tell() - 4)
+
+    f.read(4)  # fmt_key
+    fmt_size = struct.unpack("<I", f.read(4))[0]
+    header["compression_code"] = struct.unpack("<H", f.read(2))[0]
+    header["n_channels"] = struct.unpack("<H", f.read(2))[0]
+    header["sample_rate"] = struct.unpack("<I", f.read(4))[0]
+    header["bytes_per_sec"] = struct.unpack("<I", f.read(4))[0]
+    header["block_align"] = struct.unpack("<H", f.read(2))[0]
+    header["bits_per_sample"] = struct.unpack("<H", f.read(2))[0]
+    f.seek(f.tell() + fmt_size - 16)
+
+    return header
+
+
+def _calculate_voltage_and_time(
+    fs: int,
+    raw: np.ndarray,
+    bits_per_sample: int,
+    peak_voltage: Union[int, float],
+    start_time: str,
+) -> Tuple[np.ndarray, pd.DatetimeIndex, int]:
+    """
+    Normalizes the raw data from the WAV file to the appropriate voltage and
+    calculates the time array based on the sampling frequency.
+
+    Parameters
+    ----------
+    fs : int
+        Sampling frequency of the audio data in Hertz.
+    raw : numpy.ndarray
+        Raw audio data extracted from the WAV file.
+    bits_per_sample : int
+        Number of bits per sample in the WAV file.
+    peak_voltage : int or float
+        Peak voltage supplied to the analog-to-digital converter (ADC) in volts.
+    start_time : str, np.datetime64
+        Start time of the recording in ISO 8601 format (e.g., '2024-06-06T00:00:00').
+
+    Returns
+    -------
+    raw_voltage : numpy.ndarray
+        Normalized voltage values corresponding to the raw audio data.
+    time : pandas.DatetimeIndex
+        Time index for the audio data based on the sample rate and start time.
+    max_count : int
+        Maximum possible count value for the given bit depth, used for normalization.
+    """
+
+    if not isinstance(fs, int):
+        raise TypeError("Sampling frequency 'fs' must be an integer.")
+    if not isinstance(raw, np.ndarray):
+        raise TypeError("Raw audio data 'raw' must be a numpy.ndarray.")
+    if not isinstance(bits_per_sample, int):
+        raise TypeError("'bits_per_sample' must be an integer.")
+    if not isinstance(peak_voltage, (int, float)):
+        raise TypeError("'peak_voltage' must be numeric (int or float).")
+    if not isinstance(start_time, (str, np.datetime64)):
+        raise TypeError("'start_time' must be a string or np.datetime64.")
+
+    length = raw.shape[0] // fs  # length of recording in seconds
+
+    if bits_per_sample in [16, 32]:
+        max_count = 2 ** (bits_per_sample - 1)
+    elif bits_per_sample == 12:
+        max_count = 2 ** (16 - 1) - 2**4  # 12 bit read in as 16 bit
+    elif bits_per_sample == 24:
+        max_count = 2 ** (32 - 1) - 2**8  # 24 bit read in as 32 bit
+    else:
+        raise IOError(
+            f"Unknown how to read {bits_per_sample} bit ADC."
+            "Please notify MHKiT team."
+        )
+
+    # Normalize and then scale to peak voltage
+    # Use 64 bit float for decimal accuracy
+    raw_voltage = raw.astype(float) / max_count * peak_voltage
+
+    # Get time
+    end_time = np.datetime64(start_time) + np.timedelta64(length * 1000, "ms")
+    time = pd.date_range(start_time, end_time, raw.size + 1)
+
+    return raw_voltage, time, max_count
+
+
+def read_hydrophone(
+    filename: Union[str, Path],
+    peak_voltage: Union[int, float],
+    sensitivity: Optional[Union[int, float]] = None,
+    gain: Union[int, float] = 0,
+    start_time: str = "2024-01-01T00:00:00",
+) -> xr.DataArray:
+    """
+    Read .wav file from a hydrophone. Returns voltage timeseries if sensitivity not
+    provided, returns pressure timeseries if it is provided.
+
+    Parameters
+    ----------
+    filename: str or pathlib.Path
+        Input filename
+    peak_voltage: int or float
+        Peak voltage supplied to the analog to digital converter (ADC) in V.
+        (Or 1/2 of the peak to peak voltage).
+    sensitivity: int or float
+        Hydrophone calibration sensitivity in dB re 1 V/uPa.
+        Should be negative. Default: None.
+    gain: int or float
+        Amplifier gain in dB re 1 V/uPa. Default 0.
+    start_time: str
+        Start time in the format yyyy-mm-ddTHH:MM:SS
+
+    Returns
+    -------
+    out: numpy.array
+        Sound pressure [Pa] or Voltage [V] indexed by time[s]
+    """
+
+    if not isinstance(filename, (str, Path)):
+        raise TypeError("Filename must be a string or a pathlib.Path object.")
+    if not isinstance(peak_voltage, (int, float)):
+        raise TypeError("'peak_voltage' must be numeric (int or float).")
+    if sensitivity is not None and not isinstance(sensitivity, (int, float)):
+        raise TypeError("'sensitivity' must be numeric (int, float) or None.")
+    if not isinstance(gain, (int, float)):
+        raise TypeError("'gain' must be numeric (int or float).")
+    if not isinstance(start_time, (str, np.datetime64)):
+        raise TypeError("'start_time' must be a string or np.datetime64")
+
+    if (sensitivity is not None) and (sensitivity > 0):
+        raise ValueError(
+            "Hydrophone calibrated sensitivity should be entered as a negative number."
+        )
+
+    # Read metadata from WAV file
+    with open(filename, "rb") as f:
+        header = _read_wav_metadata(f)
+
+    # Read data using scipy (will auto drop as int16 or int32)
+    fs, raw = wavfile.read(filename)
+
+    # Calculate raw voltage and time array
+    raw_voltage, time, max_count = _calculate_voltage_and_time(
+        fs, raw, header["bits_per_sample"], peak_voltage, start_time
+    )
+
+    # If sensitivity is provided, convert to sound pressure
+    if sensitivity is not None:
+        # Subtract gain
+        # Hydrophone with sensitivity of -177 dB and gain of -3 dB = sensitivity of -174 dB
+        if gain:
+            sensitivity -= gain
+        # Convert calibration from dB rel 1 V/uPa into ratio
+        sensitivity = 10 ** (sensitivity / 20)  # V/uPa
+
+        # Sound pressure
+        pressure = raw_voltage / sensitivity  # uPa
+        pressure = pressure / 1e6  # Pa
+
+        out = xr.DataArray(
+            pressure,
+            coords={"time": time[:-1]},
+            attrs={
+                "units": "Pa",
+                "sensitivity": np.round(sensitivity, 12),
+                # Pressure min resolution
+                "resolution": np.round(peak_voltage / max_count / sensitivity / 1e6, 9),
+                # Minimum pressure sensor can read
+                "valid_min": np.round(-peak_voltage / sensitivity / 1e6, 6),
+                # Pressure at which sensor is saturated
+                "valid_max": np.round(peak_voltage / sensitivity / 1e6, 6),
+                "fs": fs,
+                "filename": Path(filename).stem,
+            },
+        )
+    else:
+        out = xr.DataArray(
+            raw_voltage,
+            coords={"time": time[:-1]},
+            attrs={
+                "units": "V",
+                # Voltage min resolution
+                "resolution": np.round(peak_voltage / max_count, 6),
+                # Minimum voltage sensor can read
+                "valid_min": -peak_voltage,
+                # Voltage at which sensor is saturated
+                "valid_max": peak_voltage,
+                "fs": fs,
+                "filename": Path(filename).stem,
+            },
+        )
+
+    return out
+
+
+def read_soundtrap(
+    filename: str,
+    sensitivity: Optional[Union[int, float]] = None,
+    gain: Union[int, float] = 0,
+) -> xr.DataArray:
+    """
+    Read .wav file from an Ocean Instruments SoundTrap hydrophone.
+    Returns voltage timeseries if sensitivity not provided, returns pressure
+    timeseries if it is provided.
+
+    Parameters
+    ----------
+    filename : str
+        Input filename.
+    sensitivity : int or float, optional
+        Hydrophone calibration sensitivity in dB re 1 V/μPa.
+        Should be negative. Default is None.
+    gain : int or float
+        Amplifier gain in dB re 1 V/μPa. Default is 0.
+
+    Returns
+    -------
+    out : xarray.DataArray
+        Sound pressure [Pa] or Voltage [V] indexed by time[s].
+    """
+
+    # Get time from filename
+    st = filename.split(".")[-2]
+    start_time = (
+        "20"
+        + st[:2]
+        + "-"
+        + st[2:4]
+        + "-"
+        + st[4:6]
+        + "T"
+        + st[6:8]
+        + ":"
+        + st[8:10]
+        + ":"
+        + st[10:12]
+    )
+
+    # Soundtrap uses a peak voltage of 1 V
+    out = read_hydrophone(
+        filename,
+        peak_voltage=1,
+        sensitivity=sensitivity,
+        gain=gain,
+        start_time=start_time,
+    )
+    out.attrs["make"] = "SoundTrap"
+
+    return out
+
+
+def _read_iclisten_metadata(f: io.BufferedIOBase) -> Dict[str, Any]:
+    """
+    Reads the metadata from the icListen .wav file and
+    returns the metadata in a dictionary.
+
+    Parameters
+    ----------
+    f: io.BufferedIOBase
+        Opened .wav file for reading metadata.
+
+    Returns
+    -------
+    metadata: dict
+        A dictionary containing metadata such as peak_voltage,
+        stored_sensitivity, humidity, temperature, etc.
+    """
+
+    def read_string(f: io.BufferedIOBase) -> dict:
+        """Reads a string from the file based on its size."""
+        key = f.read(4).decode().lower()  # skip 4 bytes to bypass key name
+        item = struct.unpack("<I", f.read(4))[0]
+        return {key: f.read(item).decode().rstrip("\x00")}
+
+    metadata: Dict[str, Any] = {}
+
+    # Read header keys
+    riff_key = f.read(4)
+    metadata["filesize"] = struct.unpack("<I", f.read(4))[0]
+    wave_key = f.read(4)
+    # Check if headers are as expected
+    if riff_key != b"RIFF" or wave_key != b"WAVE":
+        raise IOError("Invalid file format or file corrupted.")
+
+    # Read metadata keys
+    list_key = f.read(4)
+    if list_key != b"LIST":
+        raise KeyError("Missing LIST chunk in WAV file.")
+    list_size_bytes = f.read(4)
+    if len(list_size_bytes) < 4:
+        raise EOFError("Unexpected end of file when reading list size.")
+    info_key = f.read(4)
+    if info_key != b"INFO":
+        raise KeyError("Expected INFO key in metadata but got different key.")
+
+    # Read metadata and store in the dictionary
+    metadata.update(read_string(f))  # Hydrophone make and SN
+    metadata.update(read_string(f))  # Hydrophone model
+    metadata.update(read_string(f))  # File creation date
+    metadata.update(read_string(f))  # Hydrophone software version
+    metadata.update(read_string(f))  # Original filename
+
+    # Additional comments
+    icmt_key = f.read(4)
+    if icmt_key != b"ICMT":
+        raise KeyError("Expected ICMT key in metadata but got different key.")
+    icmt_size_bytes = f.read(4)
+    if len(icmt_size_bytes) < 4:
+        raise EOFError("Unexpected end of file when reading ICMT size.")
+    icmt_size = struct.unpack("<I", icmt_size_bytes)[0]
+    icmt_bytes = f.read(icmt_size)
+    if len(icmt_bytes) < icmt_size:
+        raise EOFError("Unexpected end of file when reading ICMT data.")
+    icmt = icmt_bytes.decode().rstrip("\x00")
+
+    # Parse the fields from comments and update the metadata dictionary
+    fields = icmt.split(",")
+    try:
+        metadata["peak_voltage"] = float(fields[0].split(" ")[0])
+        metadata["stored_sensitivity"] = int(fields[1].strip().split(" ")[0])
+        metadata["humidity"] = fields[2].strip()
+        metadata["temperature"] = fields[3].strip()
+        metadata["accelerometer"] = (
+            ",".join(fields[4:7]).strip() if len(fields) > 6 else None
+        )
+        metadata["magnetometer"] = (
+            ",".join(fields[7:10]).strip() if len(fields) > 9 else None
+        )
+        metadata["count_at_peak_voltage"] = fields[-2].strip()
+        metadata["sequence_num"] = fields[-1].strip()
+    except (IndexError, ValueError) as e:
+        raise ValueError(f"Error parsing metadata comments: {e}") from e
+
+    # Return a dictionary with metadata
+    return metadata
+
+
+def read_iclisten(
+    filename: str,
+    sensitivity: Optional[Union[int, float]] = None,
+    use_metadata: bool = True,
+) -> xr.DataArray:
+    """
+    Read .wav file from an Ocean Sonics icListen "Smart" hydrophone.
+    Returns voltage timeseries if sensitivity not provided, returns pressure
+    timeseries if it is provided.
+
+    Parameters
+    ----------
+    filename : str
+        Input filename.
+    sensitivity : int or float, optional
+        Hydrophone calibration sensitivity in dB re 1 V/μPa.
+        Should be negative. Default is None.
+    use_metadata : bool
+        If True and `sensitivity` is None, applies sensitivity value stored
+        in the .wav file's LIST block. If False and `sensitivity` is None,
+        a sensitivity value isn't applied.
+
+    Returns
+    -------
+    out : xarray.DataArray
+        Sound pressure [Pa] or Voltage [V] indexed by time[s].
+    """
+
+    if not isinstance(use_metadata, bool):
+        raise TypeError("'use_metadata' must be a boolean value.")
+
+    # Read icListen metadata from file header
+    with open(filename, "rb") as f:
+        metadata = _read_iclisten_metadata(f)
+
+    # Use stored sensitivity
+    if use_metadata and sensitivity is None:
+        sensitivity = metadata["stored_sensitivity"]
+        if sensitivity is None:
+            raise ValueError("Stored sensitivity not found in metadata.")
+
+    # Convert metadata creation date to datetime64
+    try:
+        start_time = np.datetime64(metadata["icrd"])
+    except ValueError as e:
+        raise ValueError(f"Invalid creation date format in metadata: {e}") from e
+
+    out = read_hydrophone(
+        filename,
+        peak_voltage=metadata["peak_voltage"],
+        sensitivity=sensitivity,
+        gain=0,
+        start_time=start_time,
+    )
+
+    # Update attributes with metadata
+    out.attrs.update(
+        {
+            "serial_num": metadata["iart"],
+            "model": metadata["iprd"],
+            "software_ver": metadata["isft"],
+            "filename": metadata["inam"] + ".wav",
+            "peak_voltage": metadata["peak_voltage"],
+            "sensitivity": sensitivity,
+            "humidity": metadata["humidity"],
+            "temperature": metadata["temperature"],
+            "accelerometer": metadata["accelerometer"],
+            "magnetometer": metadata["magnetometer"],
+            "count_at_peak_voltage": metadata["count_at_peak_voltage"],
+            "sequence_num": metadata["sequence_num"],
+        }
+    )
+
+    return out
+
+
+def export_audio(
+    filename: str, pressure: xr.DataArray, gain: Union[int, float] = 1
+) -> None:
+    """
+    Creates human-scaled audio file from underwater recording.
+
+    Parameters
+    ----------
+    filename : str
+        Output filename for the WAV file (without extension).
+    pressure : xarray.DataArray
+        Sound pressure data with attributes:
+            - 'values' (numpy.ndarray): Pressure data array.
+            - 'sensitivity' (int or float): Sensitivity of the hydrophone in dB.
+            - 'fs' (int or float): Sampling frequency in Hz.
+    gain : int or float, optional
+        Gain to multiply the original time series by. Default is 1.
+
+    Returns
+    -------
+    None
+    """
+    if not isinstance(filename, str):
+        raise TypeError("'filename' must be a string.")
+
+    if not isinstance(pressure, xr.DataArray):
+        raise TypeError("'pressure' must be an xarray.DataArray.")
+
+    if not hasattr(pressure, "values") or not isinstance(pressure.values, np.ndarray):
+        raise TypeError("'pressure.values' must be a numpy.ndarray.")
+
+    if not hasattr(pressure, "sensitivity") or not isinstance(
+        pressure.sensitivity, (int, float)
+    ):
+        raise TypeError("'pressure.sensitivity' must be a numeric type (int or float).")
+
+    if not hasattr(pressure, "fs") or not isinstance(pressure.fs, (int, float)):
+        raise TypeError("'pressure.fs' must be a numeric type (int or float).")
+
+    if not isinstance(gain, (int, float)):
+        raise TypeError("'gain' must be a numeric type (int or float).")
+
+    # Convert from Pascals to UPa
+    upa = pressure.values.T * 1e6
+    # Change to voltage waveform
+    v = upa * 10 ** (pressure.sensitivity / 20)  # in V
+    # Normalize
+    v = v / max(abs(v)) * gain
+    # Convert to (little-endian) 16 bit integers.
+    audio = (v * (2**16 - 1)).astype("<h")
+
+    # pylint incorrectly thinks this is opening in read mode
+    with wave.open(f"{filename}.wav", mode="w") as f:
+        f.setnchannels(1)  # pylint: disable=no-member
+        f.setsampwidth(2)  # pylint: disable=no-member
+        f.setframerate(pressure.fs)  # pylint: disable=no-member
+        f.writeframes(audio.tobytes())  # pylint: disable=no-member
diff --git a/mhkit/dolfyn/adv/clean.py b/mhkit/dolfyn/adv/clean.py
index bf91efacf..69a03587b 100644
--- a/mhkit/dolfyn/adv/clean.py
+++ b/mhkit/dolfyn/adv/clean.py
@@ -6,7 +6,6 @@
 from ..velocity import VelBinner
 from ..tools.misc import group, slice1d_along_axis
 
-warnings.simplefilter("ignore", np.exceptions.RankWarning)
 
 sin = np.sin
 cos = np.cos
diff --git a/mhkit/loads/extreme/mler.py b/mhkit/loads/extreme/mler.py
index 5aa174d26..f77f7d883 100644
--- a/mhkit/loads/extreme/mler.py
+++ b/mhkit/loads/extreme/mler.py
@@ -61,9 +61,9 @@ def _calculate_spectral_values(
     spectrum_r = np.abs(rao_array) ** 2 * (2 * wave_spectrum)
 
     # Calculate spectral moments
-    m_0 = frequency_moment(pd.Series(spectrum_r, index=freq_hz), 0).iloc[0, 0]
-    m_1 = frequency_moment(pd.Series(spectrum_r, index=freq_hz), 1).iloc[0, 0]
-    m_2 = frequency_moment(pd.Series(spectrum_r, index=freq_hz), 2).iloc[0, 0]
+    m_0 = frequency_moment(pd.Series(spectrum_r, index=freq_hz), 0).item()
+    m_1 = frequency_moment(pd.Series(spectrum_r, index=freq_hz), 1).item()
+    m_2 = frequency_moment(pd.Series(spectrum_r, index=freq_hz), 2).item()
 
     # Calculate coefficient A_{R,n}
     coeff_a_rn = (
diff --git a/mhkit/tests/acoustics/__init__.py b/mhkit/tests/acoustics/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/mhkit/tests/acoustics/test_analysis.py b/mhkit/tests/acoustics/test_analysis.py
new file mode 100644
index 000000000..b33eb4748
--- /dev/null
+++ b/mhkit/tests/acoustics/test_analysis.py
@@ -0,0 +1,291 @@
+import os
+from os.path import abspath, dirname, join, normpath
+import numpy as np
+import xarray as xr
+import unittest
+
+import mhkit.acoustics as acoustics
+
+
+testdir = dirname(abspath(__file__))
+plotdir = join(testdir, "plots")
+isdir = os.path.isdir(plotdir)
+if not isdir:
+    os.mkdir(plotdir)
+datadir = normpath(join(testdir, "..", "..", "..", "examples", "data", "acoustics"))
+
+
+class TestAnalysis(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        file_name = join(datadir, "6247.230204150508.wav")
+        P = acoustics.io.read_soundtrap(file_name, sensitivity=-177)
+        self.spsd = acoustics.sound_pressure_spectral_density(P, P.fs, bin_length=1)
+
+    @classmethod
+    def tearDownClass(self):
+        pass
+
+    def test_spsdl(self):
+        td_spsdl = acoustics.sound_pressure_spectral_density_level(self.spsd)
+
+        cc = np.array(
+            [
+                "2023-02-04T15:05:08.499983310",
+                "2023-02-04T15:05:09.499959707",
+                "2023-02-04T15:05:10.499936580",
+                "2023-02-04T15:05:11.499913454",
+                "2023-02-04T15:05:12.499890089",
+            ],
+            dtype="datetime64[ns]",
+        )
+        cd_spsdl = np.array(
+            [
+                [61.72558153, 60.45878138, 61.02543806, 62.10487326, 53.69452342],
+                [64.73788935, 63.7154788, 56.60306848, 55.59145693, 65.14298631],
+                [54.88840931, 64.81213715, 68.5464288, 66.96210531, 57.26933701],
+                [47.83166387, 46.34269439, 55.26689475, 59.97537222, 62.87564412],
+                [51.84125861, 58.33037915, 56.42519674, 55.83574275, 55.48694318],
+            ]
+        )
+
+        np.testing.assert_allclose(td_spsdl.head().values, cd_spsdl, atol=1e-6)
+        np.testing.assert_equal(td_spsdl["time"].head().values, cc)
+
+    def test_averaging(self):
+        td_spsdl = acoustics.sound_pressure_spectral_density_level(self.spsd)
+
+        # Frequency average into # octave bands
+        octave = 3
+        td_spsdl_mean = acoustics.band_aggregate(td_spsdl, octave, fmin=50)
+
+        # Time average into 30 s bins
+        lbin = 30
+        td_spsdl_50 = acoustics.time_aggregate(td_spsdl_mean, lbin, method="median")
+        td_spsdl_25 = acoustics.time_aggregate(
+            td_spsdl_mean, lbin, method={"quantile": 0.25}
+        )
+        td_spsdl_75 = acoustics.time_aggregate(
+            td_spsdl_mean, lbin, method={"quantile": 0.75}
+        )
+
+        cc = np.array(
+            [
+                "2023-02-04T15:05:23.499983310",
+                "2023-02-04T15:05:53.499983310",
+                "2023-02-04T15:06:23.499983310",
+                "2023-02-04T15:06:53.499983310",
+                "2023-02-04T15:07:23.499983310",
+            ],
+            dtype="datetime64[ns]",
+        )
+        cd_spsdl_50 = np.array(
+            [
+                [73.71803613, 70.97557445, 69.79906778, 69.04934313, 67.56449352],
+                [73.72245955, 71.53327285, 70.55206775, 68.69638127, 67.75243522],
+                [73.64022645, 72.24548986, 70.09995522, 69.00394292, 68.22919418],
+                [73.1301846, 71.99940268, 70.56372046, 69.01366589, 67.19515351],
+                [74.67880072, 71.27235403, 70.23024477, 67.4915765, 66.73024553],
+            ]
+        )
+        cd_spsdl_25 = np.array(
+            [
+                [72.42136105, 70.37422873, 68.60783404, 67.56108417, 66.4751517],
+                [71.95173902, 71.03281659, 69.59019407, 67.79615712, 66.73980611],
+                [71.12756436, 70.68228634, 69.53891917, 68.126758, 67.48463198],
+                [71.71909635, 70.1849931, 69.22647784, 68.14102709, 66.18740693],
+                [72.25521793, 70.18087912, 68.97354823, 66.71295946, 65.35302077],
+            ]
+        )
+        cd_spsdl_75 = np.array(
+            [
+                [75.29614796, 71.86901413, 71.08418954, 69.6835928, 68.26993291],
+                [74.51608597, 72.82376854, 71.31219865, 70.38580566, 69.01731822],
+                [75.17013043, 73.45962974, 71.30593827, 71.50687178, 69.49805535],
+                [74.38176106, 73.13456376, 72.13861655, 70.45825381, 67.93458589],
+                [75.52387419, 72.99604074, 71.26831962, 68.90629303, 67.79114848],
+            ]
+        )
+
+        np.testing.assert_allclose(td_spsdl_50.head().values, cd_spsdl_50, atol=1e-6)
+        np.testing.assert_allclose(td_spsdl_25.head().values, cd_spsdl_25, atol=1e-6)
+        np.testing.assert_allclose(td_spsdl_75.head().values, cd_spsdl_75, atol=1e-6)
+        np.testing.assert_equal(td_spsdl_50["time_bins"].head().values, cc)
+
+    def test_freq_loss(self):
+        # Test min frequency
+        fmin = acoustics.minimum_frequency(water_depth=20, c=1500, c_seabed=1700)
+        self.assertEqual(fmin, 39.84375)
+
+    def test_spl(self):
+        td_spl = acoustics.sound_pressure_level(self.spsd, fmin=50)
+
+        # Decidecade octave sound pressure level
+        td_spl10 = acoustics.decidecade_sound_pressure_level(self.spsd, fmin=50)
+
+        # Median third octave sound pressure level
+        td_spl3 = acoustics.third_octave_sound_pressure_level(self.spsd, fmin=50)
+
+        cc = np.array(
+            [
+                "2023-02-04T15:05:08.499983310",
+                "2023-02-04T15:05:09.499959707",
+                "2023-02-04T15:05:10.499936580",
+                "2023-02-04T15:05:11.499913454",
+                "2023-02-04T15:05:12.499890089",
+            ],
+            dtype="datetime64[ns]",
+        )
+        cd_spl = np.array(
+            [97.48727775, 98.21888437, 96.99586637, 97.43571891, 96.60915502]
+        )
+        cd_spl10 = np.array(
+            [
+                [82.06503071, 78.20349846, 79.78088446, 75.31281183, 82.1194826],
+                [82.66175023, 79.77804574, 82.86005403, 77.57078269, 76.7598224],
+                [77.48975416, 82.72580274, 83.88251531, 74.71242694, 74.01377947],
+                [79.11312683, 76.56114947, 82.18953494, 75.40888015, 74.80285354],
+                [81.26751434, 82.29074565, 80.08831394, 75.75364773, 73.52176641],
+            ]
+        )
+        cd_spl3 = np.array(
+            [
+                [86.5847236, 84.98068691, 85.61056131, 83.55067796, 84.41810962],
+                [87.5449842, 84.48841036, 84.09406069, 85.81895309, 86.71437852],
+                [86.37334939, 84.08914125, 86.01614536, 83.36059983, 84.54635288],
+                [84.21413445, 84.63996392, 82.52906024, 84.54731095, 83.45652422],
+                [86.90033232, 84.8217658, 83.85297355, 82.92231618, 81.39163217],
+            ]
+        )
+
+        np.testing.assert_allclose(td_spl.head().values, cd_spl, atol=1e-6)
+        np.testing.assert_allclose(td_spl10.head().values, cd_spl10, atol=1e-6)
+        np.testing.assert_allclose(td_spl3.head().values, cd_spl3, atol=1e-6)
+        np.testing.assert_equal(td_spl["time"].head().values, cc)
+
+    def test_sound_pressure_spectral_density(self):
+        """
+        Test sound pressure spectral density calculation.
+        """
+        # Create some sample pressure data
+        time = np.arange(0, 10, 0.1)
+        data = np.sin(time)
+        pressure = xr.DataArray(
+            data, coords=[time], dims=["time"], attrs={"units": "Pa", "fs": 100}
+        )
+
+        # Adjust bin size to get multiple segments
+        fs = 100
+        bin_length = 0.1  # seconds
+        win_samples = int(bin_length * fs)
+
+        # Run the spectral density function
+        spsd = acoustics.sound_pressure_spectral_density(
+            pressure, fs=fs, bin_length=bin_length
+        )
+
+        # Assert that output is an xarray DataArray with expected dimensions
+        self.assertIsInstance(spsd, xr.DataArray)
+        self.assertIn("freq", spsd.dims)
+        self.assertIn("time", spsd.dims)
+        self.assertEqual(spsd.attrs["units"], "Pa^2/Hz")
+        self.assertEqual(spsd.attrs["nbin"], f"{bin_length} s")
+
+        # Calculate expected number of segments
+        overlap = 0.0
+        step = int(win_samples * (1 - overlap))
+        expected_segments = (len(pressure) - win_samples) // step + 1
+
+        # Calculate expected number of segments without overlap
+        expected_segments = len(pressure) // win_samples
+        self.assertEqual(spsd.shape[0], expected_segments)
+
+    def test_apply_calibration(self):
+        """
+        Test the application of calibration curves to spectral density.
+        """
+        # Create a sample SPSD (Spectral Pressure Spectral Density) and calibration curve
+        time = np.arange(0, 10, 0.1)
+        freq = np.linspace(10, 1000, len(time))
+        spsd_data = np.random.random((len(time), len(freq)))
+        spsd = xr.DataArray(
+            spsd_data,
+            coords=[time, freq],
+            dims=["time", "freq"],
+            attrs={"units": "V^2/Hz"},
+        )
+
+        sensitivity_curve = xr.DataArray(
+            np.random.random(len(freq)), coords=[freq], dims=["freq"]
+        )
+        fill_value = 0.0
+
+        # Apply calibration
+        calibrated_spsd = acoustics.apply_calibration(
+            spsd, sensitivity_curve, fill_value
+        )
+
+        # Assert that the calibration returns the correct data format and values
+        self.assertIsInstance(calibrated_spsd, xr.DataArray)
+        self.assertEqual(calibrated_spsd.attrs["units"], "Pa^2/Hz")
+        self.assertEqual(
+            calibrated_spsd.shape, spsd.shape
+        )  # Ensure shape remains the same
+        np.testing.assert_array_less(
+            calibrated_spsd.values, spsd.values
+        )  # Calibration should reduce values
+
+    def test_fmax_warning(self):
+        """
+        Test that fmax warning adjusts the maximum frequency if necessary.
+        """
+        from mhkit.acoustics.analysis import _fmax_warning
+
+        # Test case where fmax is greater than Nyquist frequency
+        fn = 1000
+        fmax = 1500  # Greater than Nyquist frequency
+        adjusted_fmax = _fmax_warning(fn, fmax)
+        self.assertEqual(adjusted_fmax, fn)  # Should return the Nyquist frequency
+
+        # Test case where fmax is within limits
+        fmax = 500
+        adjusted_fmax = _fmax_warning(fn, fmax)
+        self.assertEqual(adjusted_fmax, fmax)  # Should return the original fmax
+
+        # Test with incorrect types
+        with self.assertRaises(TypeError):
+            _fmax_warning("not a number", fmax)
+        with self.assertRaises(TypeError):
+            _fmax_warning(fn, "not a number")
+
+    def test_validate_method(self):
+        """
+        Test the validation of the 'method' parameter in band_aggregate or time_aggregate.
+        """
+        from mhkit.acoustics.analysis import _validate_method
+
+        # Valid method string
+        method_name, method_arg = _validate_method("median")
+        self.assertEqual(method_name, "median")
+        self.assertIsNone(method_arg)
+
+        # Valid method dictionary
+        method_name, method_arg = _validate_method({"quantile": 0.25})
+        self.assertEqual(method_name, "quantile")
+        self.assertEqual(method_arg, 0.25)
+
+        # Invalid method string
+        with self.assertRaises(ValueError):
+            _validate_method("unsupported_method")
+
+        # Invalid method dictionary
+        with self.assertRaises(ValueError):
+            _validate_method({"unsupported_method": None})
+
+        # Invalid quantile value in dictionary
+        with self.assertRaises(ValueError):
+            _validate_method({"quantile": 1.5})  # Out of valid range (0,1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mhkit/tests/acoustics/test_io.py b/mhkit/tests/acoustics/test_io.py
new file mode 100644
index 000000000..24cf4d624
--- /dev/null
+++ b/mhkit/tests/acoustics/test_io.py
@@ -0,0 +1,266 @@
+import os
+from os.path import abspath, dirname, join, normpath, isfile
+import numpy as np
+import pandas as pd
+import unittest
+
+import mhkit.acoustics as acoustics
+
+
+testdir = dirname(abspath(__file__))
+plotdir = join(testdir, "plots")
+isdir = os.path.isdir(plotdir)
+if not isdir:
+    os.mkdir(plotdir)
+datadir = normpath(join(testdir, "..", "..", "..", "examples", "data", "acoustics"))
+
+
+class TestIO(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        pass
+
+    @classmethod
+    def tearDownClass(self):
+        pass
+
+    def test_read_wav_metadata(self):
+        # Test read_wav_metadata function
+        file_name = join(datadir, "RBW_6661_20240601_053114.wav")
+        with open(file_name, "rb") as f:
+            header = acoustics.io._read_wav_metadata(f)
+        expected_bits_per_sample = 24
+        self.assertEqual(header["bits_per_sample"], expected_bits_per_sample)
+
+    def test_calculate_voltage_and_time(self):
+        # Test calculate_voltage_and_time function
+        fs = 1
+        raw = np.array([0, 32767, -32768, 16384, -16384], dtype=np.int16)
+        bits_per_sample = 16
+        peak_voltage = 2.5
+        start_time = "2024-06-06T00:00:00"
+
+        raw_voltage, time, max_count = acoustics.io._calculate_voltage_and_time(
+            fs, raw, bits_per_sample, peak_voltage, start_time
+        )
+
+        # Expected max_count
+        expected_max_count = 2 ** (bits_per_sample - 1)
+        self.assertEqual(max_count, expected_max_count)
+
+        # Expected raw_voltage
+        expected_raw_voltage = raw.astype(float) / expected_max_count * peak_voltage
+        np.testing.assert_allclose(raw_voltage, expected_raw_voltage, atol=1e-6)
+
+        # Expected time array
+        time_interval = pd.Timedelta(seconds=1 / fs)
+        expected_time = pd.date_range(
+            start=start_time, periods=len(raw) + 1, freq=time_interval
+        )
+        pd.testing.assert_index_equal(time, expected_time)
+
+    def test_read_iclisten_metadata(self):
+        from mhkit.acoustics.io import _read_iclisten_metadata
+
+        file_name = join(datadir, "RBW_6661_20240601_053114.wav")
+
+        with open(file_name, "rb") as f:
+            metadata = _read_iclisten_metadata(f)
+
+        expected_metadata = {
+            "iart": "icListen HF #6661",
+            "iprd": "RB9-ETH R8",
+            "icrd": "2024-06-01T05:31:14+00",
+            "isft": "icListen HF R40.0",
+            "inam": "RBW6661_20240601_053114",
+            "peak_voltage": 3.0,
+            "stored_sensitivity": -177,
+            "humidity": "24.0 % RH",
+            "temperature": "8.6 deg C",
+            "accelerometer": "Acc(-980,-18,141)",
+            "magnetometer": "Mag(3603,3223,-598)",
+            "count_at_peak_voltage": "8388608 = Max Count",
+            "sequence_num": "2589798400000 = Seq #",
+        }
+
+        # Assertions to check if metadata matches expected values
+        for key, expected_value in expected_metadata.items():
+            self.assertIn(key, metadata)
+            if isinstance(expected_value, float):
+                self.assertAlmostEqual(metadata[key], expected_value, places=6)
+            else:
+                self.assertEqual(metadata[key], expected_value)
+
+    def test_read_iclisten(self):
+        file_name = join(datadir, "RBW_6661_20240601_053114.wav")
+        td_orig = acoustics.io.read_iclisten(file_name)
+        td_wrap = acoustics.io.read_hydrophone(
+            file_name,
+            peak_voltage=3,
+            sensitivity=-177,
+            start_time="2024-06-01T05:31:14",
+        )
+        td_volt = acoustics.io.read_iclisten(
+            file_name, sensitivity=None, use_metadata=False
+        )
+        td_ovrrd = acoustics.io.read_iclisten(
+            file_name, sensitivity=-180, use_metadata=False
+        )
+        td_ovrrd2 = acoustics.io.read_iclisten(
+            file_name, sensitivity=-180, use_metadata=True
+        )
+
+        # Check time coordinate
+        cc = np.array(
+            [
+                "2024-06-01T05:31:14.000000000",
+                "2024-06-01T05:31:14.000001953",
+                "2024-06-01T05:31:14.000003906",
+                "2024-06-01T05:31:14.000005859",
+                "2024-06-01T05:31:14.000007812",
+            ],
+            dtype="datetime64[ns]",
+        )
+        # Check data
+        cd_orig = np.array([0.31546374, 0.30229832, 0.32229963, 0.3159701, 0.30356423])
+        cd_volt = np.array([0.0004456, 0.00042701, 0.00045526, 0.00044632, 0.0004288])
+        cd_ovrrd = np.array(
+            [0.44560438, 0.42700773, 0.45526033, 0.44631963, 0.42879587]
+        )
+
+        np.testing.assert_allclose(td_orig.head().values, cd_orig, atol=1e-6)
+        np.testing.assert_equal(td_orig["time"].head().values, cc)
+
+        np.testing.assert_allclose(td_wrap.head().values, cd_orig, atol=1e-6)
+        np.testing.assert_equal(td_wrap["time"].head().values, cc)
+
+        np.testing.assert_allclose(td_volt.head().values, cd_volt, atol=1e-6)
+        np.testing.assert_equal(td_volt["time"].head().values, cc)
+
+        np.testing.assert_allclose(td_ovrrd.head().values, cd_ovrrd, atol=1e-6)
+        np.testing.assert_equal(td_ovrrd["time"].head().values, cc)
+
+        np.testing.assert_allclose(
+            td_ovrrd.head().values, td_ovrrd2.head().values, atol=1e-6
+        )
+
+    def test_read_soundtrap(self):
+        file_name = join(datadir, "6247.230204150508.wav")
+        td_orig = acoustics.io.read_soundtrap(file_name, sensitivity=-177)
+        td_wrap = acoustics.io.read_hydrophone(
+            file_name,
+            peak_voltage=1,
+            sensitivity=-177,
+            start_time="2023-02-04T15:05:08",
+        )
+        td_volt = acoustics.io.read_soundtrap(file_name, sensitivity=None)
+
+        # Check time coordinate
+        cc = np.array(
+            [
+                "2023-02-04T15:05:08.000000000",
+                "2023-02-04T15:05:08.000010416",
+                "2023-02-04T15:05:08.000020832",
+                "2023-02-04T15:05:08.000031249",
+                "2023-02-04T15:05:08.000041665",
+            ],
+            dtype="datetime64[ns]",
+        )
+        # Check data
+        cd_orig = np.array([0.929006, 0.929006, 0.929006, 0.929006, 1.01542517])
+        cd_volt = np.array([0.00131226, 0.00131226, 0.00131226, 0.00131226, 0.00143433])
+
+        np.testing.assert_allclose(td_orig.head().values, cd_orig, atol=1e-6)
+        np.testing.assert_equal(td_orig["time"].head().values, cc)
+
+        np.testing.assert_allclose(td_wrap.head().values, cd_orig, atol=1e-6)
+        np.testing.assert_equal(td_wrap["time"].head().values, cc)
+
+        np.testing.assert_allclose(td_volt.head().values, cd_volt, atol=1e-6)
+        np.testing.assert_equal(td_volt["time"].head().values, cc)
+
+    def test_calibration(self):
+        file_name = join(datadir, "6247.230204150508.wav")
+        td_volt = acoustics.io.read_soundtrap(file_name, sensitivity=None)
+        td_spsd = acoustics.sound_pressure_spectral_density(
+            td_volt, td_volt.fs, bin_length=1
+        )
+
+        # Run calibration
+        cal_name = join(datadir, "6247_calibration.csv")
+        calibration = pd.read_csv(cal_name, sep=",")
+        calibration.index = calibration["Frequency"]
+        calibration = calibration.to_xarray()
+        fill_Sf = calibration["Analog Sensitivity"][-1].values
+
+        # Apply calibration
+        td_spsd = acoustics.apply_calibration(
+            td_spsd, calibration["Analog Sensitivity"], fill_value=fill_Sf
+        )
+
+        # Check time coordinate
+        cc = np.array(
+            [
+                "2023-02-04T15:05:08.499983310",
+                "2023-02-04T15:05:09.499959707",
+                "2023-02-04T15:05:10.499936580",
+                "2023-02-04T15:05:11.499913454",
+                "2023-02-04T15:05:12.499890089",
+            ],
+            dtype="datetime64[ns]",
+        )
+
+        cd_spsd = np.array(
+            [
+                [
+                    6.63068204e-02,
+                    3.81400273e-03,
+                    9.28277032e-04,
+                    3.86833846e-04,
+                    2.31924928e-05,
+                ],
+                [
+                    1.32674948e-01,
+                    8.07329208e-03,
+                    3.35305424e-04,
+                    8.63341841e-05,
+                    3.23737989e-04,
+                ],
+                [
+                    1.37353862e-02,
+                    1.03924150e-02,
+                    5.24537532e-03,
+                    1.18371618e-03,
+                    5.28236923e-05,
+                ],
+                [
+                    2.70499444e-03,
+                    1.47833274e-04,
+                    2.46503548e-04,
+                    2.36905027e-04,
+                    1.92069973e-04,
+                ],
+                [
+                    6.80966653e-03,
+                    2.33636493e-03,
+                    3.21849897e-04,
+                    9.13295549e-05,
+                    3.50420384e-05,
+                ],
+            ]
+        )
+
+        np.testing.assert_allclose(td_spsd.head().values, cd_spsd, atol=1e-6)
+        np.testing.assert_equal(td_spsd["time"].head().values, cc)
+
+    def test_audio_export(self):
+        file_name = join(datadir, "RBW_6661_20240601_053114.wav")
+        P = acoustics.io.read_iclisten(file_name)
+        acoustics.io.export_audio("sound1", P, gain=1)
+
+        self.assertEqual(isfile("sound1.wav"), True)
+        os.remove("sound1.wav")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mhkit/tests/loads/test_loads.py b/mhkit/tests/loads/test_loads.py
index 8c119a38e..633763f83 100644
--- a/mhkit/tests/loads/test_loads.py
+++ b/mhkit/tests/loads/test_loads.py
@@ -422,10 +422,8 @@ def test_mler_wave_amp_normalize(self):
         mler["WaveSpectrum"] = self.mler["Res_Spec"].values
         mler["Phase"] = self.mler["phase"].values
         k = resource.wave_number(wave_freq, 70)
-        k = k.fillna(0)
-        mler_norm = loads.extreme.mler_wave_amp_normalize(
-            4.5 * 1.9, mler, self.sim, k.k.values
-        )
+        k = np.nan_to_num(k, nan=0)
+        mler_norm = loads.extreme.mler_wave_amp_normalize(4.5 * 1.9, mler, self.sim, k)
         mler_norm.reset_index(drop=True, inplace=True)
 
         assert_series_equal(
@@ -442,11 +440,9 @@ def test_mler_export_time_series(self):
         mler["WaveSpectrum"] = self.mler["Norm_Spec"].values
         mler["Phase"] = self.mler["phase"].values
         k = resource.wave_number(wave_freq, 70)
-        k = k.fillna(0)
+        np.nan_to_num(k, 0)
         RAO = self.mler["RAO"].astype(complex)
-        mler_ts = loads.extreme.mler_export_time_series(
-            RAO.values, mler, self.sim, k.k.values
-        )
+        mler_ts = loads.extreme.mler_export_time_series(RAO.values, mler, self.sim, k)
         mler_ts.index.name = None  # compatibility with old data
 
         assert_frame_equal(self.mler_ts, mler_ts, atol=0.0001)
diff --git a/mhkit/tests/wave/test_performance.py b/mhkit/tests/wave/test_performance.py
index b8fce7cb8..a12c8050c 100644
--- a/mhkit/tests/wave/test_performance.py
+++ b/mhkit/tests/wave/test_performance.py
@@ -126,6 +126,7 @@ def test_powerperformance_workflow(self):
         if isfile(filename):
             os.remove(filename)
         P = pd.Series(np.random.normal(200, 40, 743), index=self.S.columns)
+        P.index.name = "variable"
         statistic = ["mean"]
         savepath = plotdir
         show_values = True
diff --git a/mhkit/tests/wave/test_resource_metrics.py b/mhkit/tests/wave/test_resource_metrics.py
index 9cdf589fc..3df52fcd1 100644
--- a/mhkit/tests/wave/test_resource_metrics.py
+++ b/mhkit/tests/wave/test_resource_metrics.py
@@ -95,10 +95,11 @@ def test_kfromw(self):
 
             expected = self.valdata1[i]["k"]
             k = wave.resource.wave_number(f, h, rho)
-            calculated = k.loc[:, "k"].values
+            calculated = k
             error = ((expected - calculated) ** 2).sum()  # SSE
 
             self.assertLess(error, 1e-6)
+            self.assertIsInstance(calculated, type(f))
 
     def test_kfromw_one_freq(self):
         g = 9.81
@@ -106,21 +107,26 @@ def test_kfromw_one_freq(self):
         h = 1e9
         w = np.pi * 2 * f  # deep water dispersion
         expected = w**2 / g
-        calculated = wave.resource.wave_number(f=f, h=h, g=g).values[0][0]
+        calculated = wave.resource.wave_number(f=f, h=h, g=g).item()
         error = np.abs(expected - calculated)
         self.assertLess(error, 1e-6)
+        self.assertIsInstance(calculated, type(f))
 
     def test_wave_length(self):
         k_array = np.asarray([1.0, 2.0, 10.0, 3.0])
-
         k_int = int(k_array[0])
         k_float = k_array[0]
         k_df = pd.DataFrame(k_array, index=[1, 2, 3, 4])
         k_series = k_df[0]
 
-        for l in [k_array, k_int, k_float, k_df, k_series]:
-            l_calculated = wave.resource.wave_length(l)
-            self.assertTrue(np.all(2.0 * np.pi / l == l_calculated))
+        for k in [k_int]:
+            l_calculated = wave.resource.wave_length(k)
+            self.assertTrue(np.all(2.0 * np.pi / k == l_calculated))
+
+        for k in [k_array, k_float, k_df, k_series]:
+            l_calculated = wave.resource.wave_length(k)
+            self.assertTrue(np.all(2.0 * np.pi / k == l_calculated))
+            self.assertIsInstance(l_calculated, type(k))
 
     def test_depth_regime(self):
         h = 10
@@ -144,11 +150,13 @@ def test_depth_regime(self):
         for l in [l_array, l_series, l_da, l_ds]:
             calculated = wave.resource.depth_regime(l, h)
             self.assertTrue(np.all(expected == calculated))
+            self.assertIsInstance(calculated, type(l))
 
         # special formatting for pd.DataFrame
         for l in [l_df]:
             calculated = wave.resource.depth_regime(l, h)
             self.assertTrue(np.all(expected == calculated[0]))
+            self.assertIsInstance(calculated, type(l))
 
     def test_wave_celerity(self):
         # Depth regime ratio
@@ -218,7 +226,7 @@ def test_moments(self):
 
                     calculated = wave.resource.frequency_moment(
                         S, int(m), frequency_bins=f_bins
-                    ).iloc[0, 0]
+                    ).item()
                     error = np.abs(expected - calculated) / expected
 
                     self.assertLess(error, 0.01)
@@ -234,11 +242,11 @@ def test_energy_period_to_peak_period(self):
         for g in gamma:
             for T in Te:
                 Tp = wave.resource.energy_period_to_peak_period(T, g)
+                self.assertIsInstance(Tp, type(T))
 
                 f = np.linspace(1 / (10 * Tp), 3 / Tp, 100)
                 S = wave.resource.jonswap_spectrum(f, Tp, Hs, g)
-
-                Te_calc = wave.resource.energy_period(S).values[0][0]
+                Te_calc = wave.resource.energy_period(S).item()
 
                 error = np.abs(T - Te_calc) / Te_calc
                 self.assertLess(error, 0.01)
@@ -259,16 +267,16 @@ def test_metrics(self):
                 expected = data["metrics"]["Hm0"]
                 calculated = wave.resource.significant_wave_height(
                     S, frequency_bins=f_bins
-                ).iloc[0, 0]
+                )
                 error = np.abs(expected - calculated) / expected
                 # print('Hm0', expected, calculated, error)
                 self.assertLess(error, 0.01)
 
                 # Te
                 expected = data["metrics"]["Te"]
-                calculated = wave.resource.energy_period(S, frequency_bins=f_bins).iloc[
-                    0, 0
-                ]
+                calculated = wave.resource.energy_period(
+                    S, frequency_bins=f_bins
+                ).item()
                 error = np.abs(expected - calculated) / expected
                 # print('Te', expected, calculated, error)
                 self.assertLess(error, 0.01)
@@ -277,7 +285,7 @@ def test_metrics(self):
                 expected = data["metrics"]["T0"]
                 calculated = wave.resource.average_zero_crossing_period(
                     S, frequency_bins=f_bins
-                ).iloc[0, 0]
+                ).item()
                 error = np.abs(expected - calculated) / expected
                 # print('T0', expected, calculated, error)
                 self.assertLess(error, 0.01)
@@ -289,7 +297,7 @@ def test_metrics(self):
                         S,
                         # Tc = Tavg**2
                         frequency_bins=f_bins,
-                    ).iloc[0, 0]
+                    ).item()
                     ** 2
                 )
                 error = np.abs(expected - calculated) / expected
@@ -300,14 +308,14 @@ def test_metrics(self):
                 expected = np.sqrt(data["metrics"]["Tm"])
                 calculated = wave.resource.average_wave_period(
                     S, frequency_bins=f_bins
-                ).iloc[0, 0]
+                ).item()
                 error = np.abs(expected - calculated) / expected
                 # print('Tm', expected, calculated, error)
                 self.assertLess(error, 0.01)
 
                 # Tp
                 expected = data["metrics"]["Tp"]
-                calculated = wave.resource.peak_period(S).iloc[0, 0]
+                calculated = wave.resource.peak_period(S)
                 error = np.abs(expected - calculated) / expected
                 # print('Tp', expected, calculated, error)
                 self.assertLess(error, 0.001)
@@ -316,7 +324,7 @@ def test_metrics(self):
                 expected = data["metrics"]["e"]
                 calculated = wave.resource.spectral_bandwidth(
                     S, frequency_bins=f_bins
-                ).iloc[0, 0]
+                ).item()
                 error = np.abs(expected - calculated) / expected
                 # print('e', expected, calculated, error)
                 self.assertLess(error, 0.001)
@@ -325,8 +333,8 @@ def test_metrics(self):
                 if file_i != "CDiP":
                     for i, j in zip(data["h"], data["J"]):
                         expected = data["J"][j]
-                        calculated = wave.resource.energy_flux(S, i)
-                        error = np.abs(expected - calculated.values) / expected
+                        calculated = wave.resource.energy_flux(S, i).item()
+                        error = np.abs(expected - calculated) / expected
                         self.assertLess(error, 0.1)
 
                 # v
@@ -335,14 +343,14 @@ def test_metrics(self):
                     expected = data["metrics"]["v"]
                     calculated = wave.resource.spectral_width(
                         S, frequency_bins=f_bins
-                    ).iloc[0, 0]
+                    ).item()
                     error = np.abs(expected - calculated) / expected
                     self.assertLess(error, 0.01)
 
                 if file_i == "MC":
                     expected = data["metrics"]["v"]
                     # testing that default uniform frequency bin widths works
-                    calculated = wave.resource.spectral_width(S).iloc[0, 0]
+                    calculated = wave.resource.spectral_width(S).item()
                     error = np.abs(expected - calculated) / expected
                     self.assertLess(error, 0.01)
 
diff --git a/mhkit/tests/wave/test_resource_spectrum.py b/mhkit/tests/wave/test_resource_spectrum.py
index 5ac06cb29..e52f53bf7 100644
--- a/mhkit/tests/wave/test_resource_spectrum.py
+++ b/mhkit/tests/wave/test_resource_spectrum.py
@@ -36,8 +36,8 @@ def tearDownClass(self):
 
     def test_pierson_moskowitz_spectrum(self):
         S = wave.resource.pierson_moskowitz_spectrum(self.f, self.Tp, self.Hs)
-        Hm0 = wave.resource.significant_wave_height(S).iloc[0, 0]
-        Tp0 = wave.resource.peak_period(S).iloc[0, 0]
+        Hm0 = wave.resource.significant_wave_height(S).item()
+        Tp0 = wave.resource.peak_period(S).item()
 
         errorHm0 = np.abs(self.Tp - Tp0) / self.Tp
         errorTp0 = np.abs(self.Hs - Hm0) / self.Hs
@@ -60,8 +60,8 @@ def test_pierson_moskowitz_spectrum_zero_freq(self):
 
     def test_jonswap_spectrum(self):
         S = wave.resource.jonswap_spectrum(self.f, self.Tp, self.Hs)
-        Hm0 = wave.resource.significant_wave_height(S).iloc[0, 0]
-        Tp0 = wave.resource.peak_period(S).iloc[0, 0]
+        Hm0 = wave.resource.significant_wave_height(S).item()
+        Tp0 = wave.resource.peak_period(S).item()
 
         errorHm0 = np.abs(self.Tp - Tp0) / self.Tp
         errorTp0 = np.abs(self.Hs - Hm0) / self.Hs
@@ -122,14 +122,14 @@ def test_surface_elevation_moments(self):
             eta, 1 / dt, len(eta.values), detrend=False, window="boxcar", noverlap=0
         )
 
-        m0 = wave.resource.frequency_moment(S, 0).m0.values[0]
-        m0n = wave.resource.frequency_moment(Sn, 0).m0.values[0]
+        m0 = wave.resource.frequency_moment(S, 0).item()
+        m0n = wave.resource.frequency_moment(Sn, 0).item()
         errorm0 = np.abs((m0 - m0n) / m0)
 
         self.assertLess(errorm0, 0.01)
 
-        m1 = wave.resource.frequency_moment(S, 1).m1.values[0]
-        m1n = wave.resource.frequency_moment(Sn, 1).m1.values[0]
+        m1 = wave.resource.frequency_moment(S, 1).item()
+        m1n = wave.resource.frequency_moment(Sn, 1).item()
         errorm1 = np.abs((m1 - m1n) / m1)
 
         self.assertLess(errorm1, 0.01)
@@ -149,6 +149,39 @@ def test_surface_elevation_rmse(self):
 
         self.assertLess(rmse_sum, 0.02)
 
+    def test_elevation_spectrum_multiple_variables(self):
+        time = np.linspace(0, 100, 1000)
+        eta1 = np.sin(2 * np.pi * 0.1 * time)
+        eta2 = np.sin(2 * np.pi * 0.2 * time)
+        eta3 = np.sin(2 * np.pi * 0.3 * time)
+
+        eta_dataset = xr.Dataset(
+            {
+                "eta1": (["time"], eta1),
+                "eta2": (["time"], eta2),
+                "eta3": (["time"], eta3),
+            },
+            coords={"time": time},
+        )
+
+        sample_rate = 10
+        nnft = 256
+
+        spectra = wave.resource.elevation_spectrum(eta_dataset, sample_rate, nnft)
+
+        # For each variable, find the frequency at which the spectrum has its maximum value
+        for var_name, expected_peak_freq in [
+            ("eta1", 0.117),
+            ("eta2", 0.2),
+            ("eta3", 0.3125),
+        ]:
+            spec_values = spectra[var_name].values
+            peak_index = np.argmax(spec_values)
+            peak_freq = spectra.index[peak_index]
+
+            # Assert that the peak frequency is close to the expected frequency
+            self.assertAlmostEqual(peak_freq, expected_peak_freq, places=2)
+
     def test_mhkit_spectrum_without_frequency_index_name_defined(self):
         S = wave.resource.jonswap_spectrum(self.f, self.Tp, self.Hs)
         S.index.name = None
@@ -168,7 +201,7 @@ def test_user_spectrum_without_frequency_index_name_defined(self):
 
         expected_magnitude = [-0.983917, 1.274248, -2.129812]
 
-        assert_allclose(result["magnitude"], expected_magnitude, atol=1e-6)
+        assert_allclose(result.values[:, 0], expected_magnitude, atol=1e-6)
 
     def test_ifft_sum_of_sines(self):
         S = wave.resource.jonswap_spectrum(self.f, self.Tp, self.Hs)
diff --git a/mhkit/utils/type_handling.py b/mhkit/utils/type_handling.py
index 1b06c7d12..634bebeaf 100644
--- a/mhkit/utils/type_handling.py
+++ b/mhkit/utils/type_handling.py
@@ -160,27 +160,25 @@ def convert_to_dataarray(data, name="data"):
             # iloc returns a Series with one value as expected.
             data = data.iloc[:, 0]
         else:
-            index = data.index.values
-            columns = data.columns.values
-            data = xr.DataArray(
-                data=data.T,
-                dims=("variable", "index"),
-                coords={"variable": columns, "index": index},
-            )
+            # With this conversion, dataframe columns always become "dim_1".
+            # Rename to "variable" to match how multiple Dataset variables get converted into a DataArray dimension
+            data = xr.DataArray(data)
+            if data.dims[1] == "dim_1":
+                # Slight chance there is already a name for the columns
+                data = data.rename({"dim_1": "variable"})
 
     # Checks xr.Dataset input and converts to xr.DataArray if possible
     if isinstance(data, xr.Dataset):
         keys = list(data.keys())
         if len(keys) == 1:
-            # if only one variable, remove the "variable" dimension and rename the DataArray to simplify
-            data = data.to_array()
-            data = data.sel(variable=keys[0])
-            data.name = keys[0]
-            data.drop_vars("variable")
+            # if only one variable, select that variable so reduce the Dataset to a DataArray
+            data = data[keys[0]]
         else:
             # Allow multiple variables if they have the same dimensions
             if all([data[keys[0]].dims == data[key].dims for key in keys]):
-                data = data.to_array()
+                data = (
+                    data.to_array().T
+                )  # transpose so that the new "variable dimension" is the last dimension (matches DataFrame to DataArray behavior)
             else:
                 raise ValueError(
                     "Multivariate Datasets can only be input if all variables have the same dimensions."
diff --git a/mhkit/wave/performance.py b/mhkit/wave/performance.py
index 4d137dd48..160918cc0 100644
--- a/mhkit/wave/performance.py
+++ b/mhkit/wave/performance.py
@@ -6,7 +6,7 @@
 from mhkit import wave
 import matplotlib.pylab as plt
 from os.path import join
-from mhkit.utils import convert_to_dataarray, convert_to_dataset
+from mhkit.utils import convert_to_dataarray
 
 
 def capture_length(P, J, to_pandas=True):
@@ -246,22 +246,22 @@ def power_matrix(LM, JM):
 
     Parameters
     ------------
-    LM: pandas DataFrame or xarray Dataset
+    LM: pandas DataFrame, xarray DataArray, or xarray Dataset
         Capture length matrix
-    JM: pandas DataFrame or xarray Dataset
+    JM: pandas DataFrame, xarray DataArray, or xarray Dataset
         Wave energy flux matrix
 
     Returns
     ---------
-    PM: pandas DataFrame or xarray Dataset
+    PM: pandas DataFrame, xarray DataArray, or xarray Dataset
         Power matrix
 
     """
-    if not isinstance(LM, (pd.DataFrame, xr.Dataset)):
+    if not isinstance(LM, (pd.DataFrame, xr.DataArray, xr.Dataset)):
         raise TypeError(
             f"LM must be of type pd.DataFrame or xr.Dataset. Got: {type(LM)}"
         )
-    if not isinstance(JM, (pd.DataFrame, xr.Dataset)):
+    if not isinstance(JM, (pd.DataFrame, xr.DataArray, xr.Dataset)):
         raise TypeError(
             f"JM must be of type pd.DataFrame or xr.Dataset. Got: {type(JM)}"
         )
@@ -306,11 +306,11 @@ def mean_annual_energy_production_matrix(LM, JM, frequency):
 
     Parameters
     ------------
-    LM: pandas DataFrame or xarray Dataset
+    LM: pandas DataFrame, xarray DataArray, or xarray Dataset
         Capture length
-    JM: pandas DataFrame or xarray Dataset
+    JM: pandas DataFrame, xarray DataArray, or xarray Dataset
         Wave energy flux
-    frequency: pandas DataFrame or xarray Dataset
+    frequency: pandas DataFrame, xarray DataArray, or xarray Dataset
         Data frequency for each bin
 
     Returns
@@ -393,7 +393,7 @@ def power_performance_workflow(
     maep_matrix: float
         Mean annual energy production
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(h, (int, float)):
         raise TypeError(f"h must be of type int or float. Got: {type(h)}")
     P = convert_to_dataarray(P)
@@ -408,19 +408,16 @@ def power_performance_workflow(
 
     # Compute the enegy periods from the spectra data
     Te = wave.resource.energy_period(S, frequency_bins=frequency_bins, to_pandas=False)
-    Te = Te["Te"]
 
     # Compute the significant wave height from the NDBC spectra data
     Hm0 = wave.resource.significant_wave_height(
         S, frequency_bins=frequency_bins, to_pandas=False
     )
-    Hm0 = Hm0["Hm0"]
 
     # Compute the energy flux from spectra data and water depth
     J = wave.resource.energy_flux(
         S, h, deep=deep, rho=rho, g=g, ratio=ratio, to_pandas=False
     )
-    J = J["J"]
 
     # Calculate capture length from power and energy flux
     L = wave.performance.capture_length(P, J, to_pandas=False)
diff --git a/mhkit/wave/resource.py b/mhkit/wave/resource.py
index 0cfe28e06..488df50c2 100644
--- a/mhkit/wave/resource.py
+++ b/mhkit/wave/resource.py
@@ -1,5 +1,4 @@
 import warnings
-
 from scipy.optimize import fsolve as _fsolve
 from scipy import signal as _signal
 import pandas as pd
@@ -47,14 +46,14 @@ def elevation_spectrum(
 
     Returns
     ---------
-    S: pandas DataFrame or xr.Dataset
-        Spectral density [m^2/Hz] indexed by frequency [Hz]
+    S: pandas DataFrame, pandas Series, xarray DataArray, or xarray Dataset
+        Spectral density [m^2/Hz] indexed by frequency [Hz].
     """
 
     # TODO: Add confidence intervals, equal energy frequency spacing, and NDBC
     #       frequency spacing
     # TODO: may need to raise an error for the length of nnft- signal.welch breaks when nfft is too short
-    eta = convert_to_dataset(eta)
+    eta = convert_to_dataset(eta, "eta")
     if not isinstance(sample_rate, (float, int)):
         raise TypeError(
             f"sample_rate must be of type int or float. Got: {type(sample_rate)}"
@@ -84,18 +83,18 @@ def elevation_spectrum(
     if not np.allclose(time.diff(dim=time_dimension)[1:], delta_t):
         raise ValueError(
             "Time bins are not evenly spaced. Create a constant "
-            + "temporal spacing for eta."
+            + f"temporal spacing for eta."
         )
 
     S = xr.Dataset()
     for var in eta.data_vars:
-        data = eta[var]
+        eta_subset = eta[var]
         if detrend:
-            data = _signal.detrend(
-                data.dropna(dim=time_dimension), axis=-1, type="linear", bp=0
+            eta_subset = _signal.detrend(
+                eta_subset.dropna(dim=time_dimension), axis=-1, type="linear", bp=0
             )
         [f, wave_spec_measured] = _signal.welch(
-            data,
+            eta_subset,
             fs=sample_rate,
             window=window,
             nperseg=nnft,
@@ -106,7 +105,7 @@ def elevation_spectrum(
     S = S.assign_coords({"Frequency": f})
 
     if to_pandas:
-        S = S.to_dataframe()
+        S = S.to_pandas()
 
     return S
 
@@ -275,24 +274,24 @@ def surface_elevation(
     method: str (optional)
         Method used to calculate the surface elevation. 'ifft'
         (Inverse Fast Fourier Transform) used by default if the
-        given frequency_bins==None.
+        given frequency_bins==None or is evenly spaced.
         'sum_of_sines' explicitly sums each frequency component
-        and used by default if frequency_bins are provided.
+        and used by default if uneven frequency_bins are provided.
         The 'ifft' method is significantly faster.
     frequency_dimension: string (optional)
         Name of the xarray dimension corresponding to frequency. If not supplied,
-        defaults to the first dimension. Does not affect pandas input.
+        defaults to the first dimension (the index for pandas input).
     to_pandas: bool (optional)
         Flag to output pandas instead of xarray. Default = True.
 
     Returns
     ---------
     eta: pandas DataFrame or xarray Dataset
-        Wave surface elevation [m] indexed by time [s]
+        Wave surface elevation [m] indexed by time [s].
 
     """
+    S = convert_to_dataset(S, "S")
     time_index = to_numeric_array(time_index, "time_index")
-    S = convert_to_dataset(S)
     if not isinstance(seed, (type(None), int)):
         raise TypeError(f"If specified, seed must be of type int. Got: {type(seed)}")
     if not isinstance(phases, type(None)):
@@ -304,11 +303,18 @@ def surface_elevation(
 
     if frequency_dimension == "":
         frequency_dimension = list(S.coords)[0]
-
     elif frequency_dimension not in list(S.dims):
+        # frequency_dimension given, but not in list of possible dimensions
         raise ValueError(
             f"frequency_dimension is not a dimension of S ({list(S.dims)}). Got: {frequency_dimension}."
         )
+    frequency_axis = list(S.dims).index(frequency_dimension)
+
+    # Create dimensions and coordinates for the new dataset (frequency becomes time)
+    new_dims = list(S.dims)
+    new_dims[frequency_axis] = "Time"
+    new_coords = S.sum(dim=frequency_dimension).coords
+    new_coords = new_coords.assign({"Time": time_index})
     f = S[frequency_dimension]
 
     if not isinstance(frequency_bins, (type(None), np.ndarray)):
@@ -322,40 +328,39 @@ def surface_elevation(
     if frequency_bins is not None:
         if not frequency_bins.squeeze().shape == f.shape:
             raise ValueError(
-                "shape of frequency_bins must match shape of the frequency dimension of S"
+                "shape of frequency_bins must only contain 1 column and match the shape of the frequency dimension of S"
             )
+        delta_f = frequency_bins
+        delta_f_even = np.allclose(frequency_bins, frequency_bins[0])
+        if delta_f_even:
+            # reduce delta_f to a scalar if it is uniform
+            delta_f = delta_f[0].item()
+    else:
+        delta_f = f.values[1] - f.values[0]
+        delta_f_even = np.allclose(f.diff(dim=frequency_dimension)[1:], delta_f)
     if phases is not None:
-        if not list(phases.data_vars) == list(S.data_vars):
-            raise ValueError("phases must have the same variable names as S")
         for var in phases.data_vars:
             if not phases[var].shape == S[var].shape:
                 raise ValueError(
                     "shape of variables in phases must match shape of variables in S"
                 )
-    if method is not None:
-        if not (method == "ifft" or method == "sum_of_sines"):
-            raise ValueError(f"Method must be 'ifft' or 'sum_of_sines'. Got: {method}")
-
     if method == "ifft":
+        # ifft method must have a zero frequency and evenly spaced frequency bins
         if not f[0] == 0:
             warnings.warn(
                 f"ifft method must have zero frequency defined. Lowest frequency is: {f[0].values}. Setting method to less efficient `sum_of_sines` method."
             )
             method = "sum_of_sines"
-
-    if frequency_bins is None:
-        delta_f = f.values[1] - f.values[0]
-        if not np.allclose(f.diff(dim=frequency_dimension)[1:], delta_f):
-            raise ValueError(
-                "Frequency bins are not evenly spaced. "
-                + "Define 'frequency_bins' or create a constant "
-                + "frequency spacing for S."
+        if not delta_f_even:
+            warnings.warn(
+                f"ifft method must have evenly spaced frequency bins. Setting method to less efficient `sum_of_sines` method."
             )
+            method = "sum_of_sines"
+    elif method == "sum_of_sines":
+        # For sum of sines, does not matter if there is a zero frequency or if frequency bins are evenly spaced
+        pass
     else:
-        if not len(frequency_bins.squeeze().shape) == 1:
-            raise ValueError("frequency_bins must only contain 1 column")
-        delta_f = frequency_bins
-        method = "sum_of_sines"
+        raise ValueError(f"Method must be 'ifft' or 'sum_of_sines'. Got: {method}")
 
     omega = xr.DataArray(
         data=2 * np.pi * f, dims=frequency_dimension, coords={frequency_dimension: f}
@@ -363,10 +368,13 @@ def surface_elevation(
 
     eta = xr.Dataset()
     for var in S.data_vars:
+        S_subset = S[var]
         if phases is None:
             np.random.seed(seed)
             phase = xr.DataArray(
-                data=2 * np.pi * np.random.rand(S[var].size),
+                data=2
+                * np.pi
+                * np.random.random_sample(S_subset[frequency_dimension].shape),
                 dims=frequency_dimension,
                 coords={frequency_dimension: f},
             )
@@ -374,18 +382,16 @@ def surface_elevation(
             phase = phases[var]
 
         # Wave amplitude times delta f
-        A = 2 * S[var]
-        A = A * delta_f
-        A = np.sqrt(A)
+        A = np.sqrt(2 * S_subset * delta_f)
 
         if method == "ifft":
             A_cmplx = A * (np.cos(phase) + 1j * np.sin(phase))
-            eta_tmp = np.fft.irfft(
-                0.5 * A_cmplx.values * time_index.size, time_index.size
-            )
-            eta[var] = xr.DataArray(
-                data=eta_tmp, dims="Time", coords={"Time": time_index}
+            eta_tmp = np.fft.irfftn(
+                0.5 * A_cmplx * time_index.size,
+                list(time_index.shape),
+                axes=[frequency_axis],
             )
+            eta[var] = xr.DataArray(data=eta_tmp, dims=new_dims, coords=new_coords)
 
         elif method == "sum_of_sines":
             # Product of omega and time
@@ -402,7 +408,9 @@ def surface_elevation(
             eta[var] = (C * A).sum(dim=frequency_dimension)
 
     if to_pandas:
-        eta = eta.to_dataframe()
+        eta = eta.to_pandas()
+    if isinstance(eta, (pd.Series, pd.DataFrame, xr.DataArray)):
+        eta.name = "eta"
 
     return eta
 
@@ -430,7 +438,7 @@ def frequency_moment(S, N, frequency_bins=None, frequency_dimension="", to_panda
     m: pandas DataFrame or xarray Dataset
         Nth Frequency Moment indexed by S.columns
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(N, int):
         raise TypeError(f"N must be of type int. Got: {type(N)}")
     if not isinstance(to_pandas, bool):
@@ -464,10 +472,10 @@ def frequency_moment(S, N, frequency_bins=None, frequency_dimension="", to_panda
     m = S * fn * delta_f
     m = m.sum(dim=frequency_dimension)
 
-    m = _transform_dataset(m, "m" + str(N))
-
     if to_pandas:
-        m = m.to_dataframe()
+        m = m.to_pandas()
+    if isinstance(m, (pd.Series, pd.DataFrame, xr.DataArray)):
+        m.name = "m" + str(N)
 
     return m
 
@@ -495,7 +503,7 @@ def significant_wave_height(
     Hm0: pandas DataFrame or xarray Dataset
         Significant wave height [m] index by S.columns
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -506,11 +514,13 @@ def significant_wave_height(
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m0": "Hm0"})
+    )
     Hm0 = 4 * np.sqrt(m0)
 
     if to_pandas:
-        Hm0 = Hm0.to_dataframe()
+        Hm0 = Hm0.to_pandas()
+    if isinstance(Hm0, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Hm0.name = "Hm0"
 
     return Hm0
 
@@ -538,7 +548,6 @@ def average_zero_crossing_period(
     Tz: pandas DataFrame or xarray Dataset
         Average zero crossing period [s] indexed by S.columns
     """
-    S = convert_to_dataset(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -549,19 +558,20 @@ def average_zero_crossing_period(
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m0": "Tz"})
+    )
     m2 = frequency_moment(
         S,
         2,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m2": "Tz"})
-
+    )
     Tz = np.sqrt(m0 / m2)
 
     if to_pandas:
-        Tz = Tz.to_dataframe()
+        Tz = Tz.to_pandas()
+    if isinstance(Tz, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Tz.name = "Tz"
 
     return Tz
 
@@ -590,7 +600,6 @@ def average_crest_period(
         Average wave period [s] indexed by S.columns
 
     """
-    S = convert_to_dataset(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -600,19 +609,21 @@ def average_crest_period(
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m2": "Tavg"})
+    )
     m4 = frequency_moment(
         S,
         4,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m4": "Tavg"})
+    )
 
     Tavg = np.sqrt(m2 / m4)
 
     if to_pandas:
-        Tavg = Tavg.to_dataframe()
+        Tavg = Tavg.to_pandas()
+    if isinstance(Tavg, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Tavg.name = "Tavg"
 
     return Tavg
 
@@ -638,7 +649,6 @@ def average_wave_period(S, frequency_dimension="", frequency_bins=None, to_panda
     Tm: pandas DataFrame or xarray Dataset
         Mean wave period [s] indexed by S.columns
     """
-    S = convert_to_dataset(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -648,19 +658,21 @@ def average_wave_period(S, frequency_dimension="", frequency_bins=None, to_panda
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m0": "Tm"})
+    )
     m1 = frequency_moment(
         S,
         1,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m1": "Tm"})
+    )
 
     Tm = np.sqrt(m0 / m1)
 
     if to_pandas:
-        Tm = Tm.to_dataframe()
+        Tm = Tm.to_pandas()
+    if isinstance(Tm, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Tm.name = "Tm"
 
     return Tm
 
@@ -684,7 +696,7 @@ def peak_period(S, frequency_dimension="", to_pandas=True):
     Tp: pandas DataFrame or xarray Dataset
         Wave peak period [s] indexed by S.columns
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -699,10 +711,10 @@ def peak_period(S, frequency_dimension="", to_pandas=True):
     fp = S.idxmax(dim=frequency_dimension)  # Hz
     Tp = 1 / fp
 
-    Tp = _transform_dataset(Tp, "Tp")
-
     if to_pandas:
-        Tp = Tp.to_dataframe()
+        Tp = Tp.to_pandas()
+    if isinstance(Tp, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Tp.name = "Tp"
 
     return Tp
 
@@ -728,7 +740,7 @@ def energy_period(S, frequency_dimension="", frequency_bins=None, to_pandas=True
     Te: pandas DataFrame or xarray Dataset
         Wave energy period [s] indexed by S.columns
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -738,20 +750,22 @@ def energy_period(S, frequency_dimension="", frequency_bins=None, to_pandas=True
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m-1": "Te"})
+    )
     m0 = frequency_moment(
         S,
         0,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m0": "Te"})
+    )
 
     # Eq 13 in IEC 62600-101
     Te = mn1 / m0
 
     if to_pandas:
-        Te = Te.to_dataframe()
+        Te = Te.to_pandas()
+    if isinstance(Te, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Te.name = "Te"
 
     return Te
 
@@ -777,7 +791,7 @@ def spectral_bandwidth(S, frequency_dimension="", frequency_bins=None, to_pandas
     e: pandas DataFrame or xarray Dataset
         Spectral bandwidth [s] indexed by S.columns
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -787,26 +801,28 @@ def spectral_bandwidth(S, frequency_dimension="", frequency_bins=None, to_pandas
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m2": "e"})
+    )
     m0 = frequency_moment(
         S,
         0,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m0": "e"})
+    )
     m4 = frequency_moment(
         S,
         4,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m4": "e"})
+    )
 
     e = np.sqrt(1 - (m2**2) / (m0 / m4))
 
     if to_pandas:
-        e = e.to_dataframe()
+        e = e.to_pandas()
+    if isinstance(e, (pd.Series, pd.DataFrame, xr.DataArray)):
+        e.name = "e"
 
     return e
 
@@ -832,7 +848,6 @@ def spectral_width(S, frequency_dimension="", frequency_bins=None, to_pandas=Tru
     v: pandas DataFrame or xarray Dataset
         Spectral width [m] indexed by S.columns
     """
-    S = convert_to_dataset(S)
     if not isinstance(to_pandas, bool):
         raise TypeError(f"to_pandas must be of type bool. Got: {type(to_pandas)}")
 
@@ -842,27 +857,29 @@ def spectral_width(S, frequency_dimension="", frequency_bins=None, to_pandas=Tru
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m-2": "v"})
+    )
     m0 = frequency_moment(
         S,
         0,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m0": "v"})
+    )
     mn1 = frequency_moment(
         S,
         -1,
         frequency_bins=frequency_bins,
         frequency_dimension=frequency_dimension,
         to_pandas=False,
-    ).rename({"m-1": "v"})
+    )
 
     # Eq 16 in IEC 62600-101
     v = np.sqrt((m0 * mn2 / np.power(mn1, 2)) - 1)
 
     if to_pandas:
-        v = v.to_dataframe()
+        v = v.to_pandas()
+    if isinstance(v, (pd.Series, pd.DataFrame, xr.DataArray)):
+        v.name = "v"
 
     return v
 
@@ -909,7 +926,7 @@ def energy_flux(
     J: pandas DataFrame or xarray Dataset
         Omni-directional wave energy flux [W/m] indexed by S.columns
     """
-    S = convert_to_dataset(S)
+    S = convert_to_dataarray(S)
     if not isinstance(h, (int, float)):
         raise TypeError(f"h must be of type int or float. Got: {type(h)}")
     if not isinstance(deep, bool):
@@ -933,8 +950,8 @@ def energy_flux(
 
     if deep:
         # Eq 8 in IEC 62600-100, deep water simplification
-        Te = energy_period(S, to_pandas=False).rename({"Te": "J"})
-        Hm0 = significant_wave_height(S, to_pandas=False).rename({"Hm0": "J"})
+        Te = energy_period(S, to_pandas=False)
+        Hm0 = significant_wave_height(S, to_pandas=False)
 
         coeff = rho * (g**2) / (64 * np.pi)
 
@@ -945,9 +962,7 @@ def energy_flux(
         k = wave_number(f, h, rho, g, to_pandas=False)
 
         # wave celerity (group velocity)
-        Cg = wave_celerity(k, h, g, depth_check=True, ratio=ratio, to_pandas=False)[
-            "Cg"
-        ]
+        Cg = wave_celerity(k, h, g, depth_check=True, ratio=ratio, to_pandas=False)
 
         # Calculating the wave energy flux, Eq 9 in IEC 62600-101
         delta_f = f.diff(dim=frequency_dimension)
@@ -958,10 +973,11 @@ def energy_flux(
         CgSdelF = S * delta_f * Cg
 
         J = rho * g * CgSdelF.sum(dim=frequency_dimension)
-        J = _transform_dataset(J, "J")
 
     if to_pandas:
-        J = J.to_dataframe()
+        J = J.to_pandas()
+    if isinstance(J, (pd.Series, pd.DataFrame, xr.DataArray)):
+        J.name = "J"
 
     return J
 
@@ -997,8 +1013,8 @@ def energy_period_to_peak_period(Te, gamma):
     factor = 0.8255 + 0.03852 * gamma - 0.005537 * gamma**2 + 0.0003154 * gamma**3
 
     Tp = Te / factor
-    if isinstance(Tp, xr.Dataset):
-        Tp.rename({"Te": "Tp"})
+    if isinstance(Tp, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Tp.name = "Tp"
 
     return Tp
 
@@ -1091,10 +1107,10 @@ def wave_celerity(
         )
         Cg.name = "Cg"
 
-    Cg = Cg.to_dataset()
-
     if to_pandas:
-        Cg = Cg.to_dataframe()
+        Cg = Cg.to_pandas()
+    if isinstance(Cg, (pd.Series, pd.DataFrame, xr.DataArray)):
+        Cg.name = "Cg"
 
     return Cg
 
@@ -1122,6 +1138,8 @@ def wave_length(k):
         )
 
     l = 2 * np.pi / k
+    if isinstance(l, (pd.Series, pd.DataFrame, xr.DataArray)):
+        l.name = "l"
 
     return l
 
@@ -1135,7 +1153,7 @@ def wave_number(f, h, rho=1025, g=9.80665, to_pandas=True):
 
     Parameters
     -----------
-    f: int, float, numpy ndarray, pandas DataFrame, pandas Series, xarray DataArray, or xarray Dataset
+    f: int, float, numpy ndarray, pandas DataFrame, pandas Series, xarray DataArray
         Frequency [Hz]
     h: float
         Water depth [m]
@@ -1153,7 +1171,6 @@ def wave_number(f, h, rho=1025, g=9.80665, to_pandas=True):
     """
     if isinstance(f, (int, float)):
         f = np.asarray([f])
-    f = convert_to_dataarray(f)
     if not isinstance(h, (int, float)):
         raise TypeError(f"h must be of type int or float. Got: {type(h)}")
     if not isinstance(rho, (int, float)):
@@ -1182,12 +1199,10 @@ def func(kk):
         if not ier == 1:
             raise ValueError("Wave number not found. " + mesg)
         k0[mask] = k
+    k = k0
 
-    k0.name = "k"
-    k = k0.to_dataset()
-
-    if to_pandas:
-        k = k.to_dataframe()
+    if isinstance(k, (pd.Series, pd.DataFrame, xr.DataArray)):
+        k.name = "k"
 
     return k
 
@@ -1228,16 +1243,7 @@ def depth_regime(l, h, ratio=2):
         raise TypeError(f"h must be of type int or float. Got: {type(h)}")
 
     depth_reg = h / l > ratio
+    if isinstance(depth_reg, (pd.Series, pd.DataFrame, xr.DataArray)):
+        depth_reg.name = "depth_reg"
 
     return depth_reg
-
-
-def _transform_dataset(data, name):
-    # Converting data from a Dataset into a DataArray will turn the variables
-    # columns into a 'variable' dimension.
-    # Converting it back to a dataset will keep this concise variable dimension
-    # but in the expected xr.Dataset/pd.DataFrame format
-    data = data.to_array()
-    data = convert_to_dataset(data, name=name)
-    data = data.rename({"variable": "index"})
-    return data