diff --git a/examples/adcp_example.ipynb b/examples/adcp_example.ipynb index f83d007f..5982e7f4 100644 --- a/examples/adcp_example.ipynb +++ b/examples/adcp_example.ipynb @@ -3970,7 +3970,7 @@ "#### Quick 5-beam ADCP lesson before we dive in:\n", "\n", "There are a couple caveats to calculating Reynolds stress tensor components:\n", - " 1. Because this instrument only has 5 beams, we can only find 5 of the 6 components (6 unkowns, 5 knowns)\n", + " 1. Because this instrument only has 5 beams, we can only find 5 of the 6 components (6 unknowns, 5 knowns)\n", " 2. Because the ADCP's instrument (XYZ) axes weren't aligned with the flow during deployment, we don't know what direction these components are aligned to (i.e. the 'u' direction is not necessarily the streamwise direction)\n", " 3. It is possible to rotate the tensor, but we'd need to know all 6 components to do so properly (\"coupled ADCPs\")\n", " 4. Measurements close to the seafloor can be suspect due to increased vertical flow. ADCPs operate under the \"assumption of homogeneity\", which means that they can only accurate measure consistent horizontal currents with relatively little vertical motion.\n" @@ -4131,11 +4131,8 @@ } ], "metadata": { - "interpreter": { - "hash": "5cfd453a1a1cce2f32ea80f99ff7da863344217116d39185ac62b248c2577445" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "work", "language": "python", "name": "python3" }, diff --git a/examples/adv_example.ipynb b/examples/adv_example.ipynb index 7ea0582d..b497a863 100644 --- a/examples/adv_example.ipynb +++ b/examples/adv_example.ipynb @@ -1,943 +1,1325 @@ { - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Reading ADV Data with MHKiT\n", - "\n", - "This example presents a simplified workflow for analyzing Acoustic Doppler Velocimetry (ADV) data using MHKiT. MHKiT incorporates the DOLfYN codebase as a module to handle ADV and Acoustic Doppler Current Profiler (ADCP) data.\n", - "\n", - "A standard ADV data analysis workflow can be segmented into the following steps:\n", - "\n", - "1. **Raw Data Review**: Evaluate the original data by verifying timestamps and assessing the quality of velocity data, specifically looking for any data spikes.\n", - "\n", - "2. **Data Cleaning**: Identify and eliminate any spurious data points. If needed, bad data points can be replaced with interpolated values.\n", - "\n", - "3. **Data Rotation**: Transform the data into the principal flow coordinates, which are the streamwise, cross-stream, and vertical directions.\n", - "\n", - "4. **Data Averaging**: Aggregate the data into bins or ensembles, each of which spans a predefined time length, typically between 5 and 10 minutes.\n", - "\n", - "5. **Statistical Analysis**: Compute turbulence statistics such as turbulence intensity, Turbulent Kinetic Energy (TKE), and Reynolds stresses for the observed flow field.\n", - "\n", - "Start your analysis by importing the necessary tools:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from mhkit import dolfyn\n", - "from mhkit.dolfyn.adv import api" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read Raw Instrument Data" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "DOLfYN currently only carries support for the Nortek Vector ADV. The example loaded here is a short clip of data from a test deployment to show DOLfYN's capabilities.\n", - "\n", - "Start by reading in the raw datafile downloaded from the instrument. The `dolfyn.read` function reads the raw file and dumps the information into an xarray Dataset, which contains three groups of variables:\n", - "\n", - "1. Velocity, amplitude, and correlation of the Doppler velocimetry\n", - "2. Measurements of the instrument's bearing and environment\n", - "3. Orientation matrices DOLfYN uses for rotating through coordinate frames." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Reading file data/dolfyn/vector_data01.VEC ...\n" - ] - } - ], - "source": [ - "ds = dolfyn.read(\"data/dolfyn/vector_data01.VEC\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There are two ways to see what's in a Dataset. The first is to simply type the dataset's name to see the standard xarray output. To access a particular variable in a dataset, use dict-style (`ds['vel']`) or attribute-style syntax (`ds.vel`). See the [xarray docs](http://xarray.pydata.org/en/stable/getting-started-guide/quick-overview.html) for more details on how to use the xarray format." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 11MB\n",
-              "Dimensions:              (time: 122912, beam: 3, dir: 3, x1: 3, x2: 3,\n",
-              "                          earth: 3, inst: 3)\n",
-              "Coordinates:\n",
-              "  * time                 (time) datetime64[ns] 983kB 2012-06-12T12:00:02.9687...\n",
-              "  * beam                 (beam) int32 12B 1 2 3\n",
-              "  * dir                  (dir) <U1 12B 'X' 'Y' 'Z'\n",
-              "  * x1                   (x1) int32 12B 1 2 3\n",
-              "  * x2                   (x2) int32 12B 1 2 3\n",
-              "  * earth                (earth) <U1 12B 'E' 'N' 'U'\n",
-              "  * inst                 (inst) <U1 12B 'X' 'Y' 'Z'\n",
-              "Data variables: (12/15)\n",
-              "    beam2inst_orientmat  (x1, x2) float64 72B 2.709 -1.34 ... -0.3438 -0.3499\n",
-              "    batt                 (time) float32 492kB 13.2 13.2 13.2 ... nan nan nan\n",
-              "    c_sound              (time) float32 492kB 1.493e+03 1.493e+03 ... nan nan\n",
-              "    heading              (time) float32 492kB 5.6 10.5 10.51 ... nan nan nan\n",
-              "    pitch                (time) float32 492kB -31.5 -31.7 -31.69 ... nan nan nan\n",
-              "    roll                 (time) float32 492kB 0.4 4.2 4.253 ... nan nan nan\n",
-              "    ...                   ...\n",
-              "    orientation_down     (time) bool 123kB True True True ... True True True\n",
-              "    vel                  (dir, time) float32 1MB -1.002 -1.008 ... nan nan\n",
-              "    amp                  (beam, time) uint8 369kB 104 110 111 113 ... 0 0 0 0\n",
-              "    corr                 (beam, time) uint8 369kB 97 91 97 98 90 ... 0 0 0 0 0\n",
-              "    pressure             (time) float32 492kB 5.448 5.436 5.484 ... 0.0 0.0 0.0\n",
-              "    orientmat            (earth, inst, time) float32 4MB 0.0832 ... -0.7065\n",
-              "Attributes: (12/39)\n",
-              "    inst_make:                   Nortek\n",
-              "    inst_model:                  Vector\n",
-              "    inst_type:                   ADV\n",
-              "    rotate_vars:                 ['vel']\n",
-              "    n_beams:                     3\n",
-              "    profile_mode:                continuous\n",
-              "    ...                          ...\n",
-              "    recorder_size_bytes:         4074766336\n",
-              "    vel_range:                   normal\n",
-              "    firmware_version:            3.34\n",
-              "    fs:                          32.0\n",
-              "    coord_sys:                   inst\n",
-              "    has_imu:                     0
" - ], - "text/plain": [ - " Size: 11MB\n", - "Dimensions: (time: 122912, beam: 3, dir: 3, x1: 3, x2: 3,\n", - " earth: 3, inst: 3)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 983kB 2012-06-12T12:00:02.9687...\n", - " * beam (beam) int32 12B 1 2 3\n", - " * dir (dir) : Nortek Vector\n", - " . 1.07 hours (started: Jun 12, 2012 12:00)\n", - " . inst-frame\n", - " . (122912 pings @ 32.0Hz)\n", - " Variables:\n", - " - time ('time',)\n", - " - vel ('dir', 'time')\n", - " - orientmat ('earth', 'inst', 'time')\n", - " - heading ('time',)\n", - " - pitch ('time',)\n", - " - roll ('time',)\n", - " - temp ('time',)\n", - " - pressure ('time',)\n", - " - amp ('beam', 'time')\n", - " - corr ('beam', 'time')\n", - " ... and others (see `.variables`)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds_dolfyn = ds.velds\n", - "ds_dolfyn" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quality Control" - ] - }, + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reading ADV Data with MHKiT\n", + "\n", + "This example presents a simplified workflow for analyzing Acoustic Doppler Velocimetry (ADV) data using MHKiT. MHKiT incorporates the DOLfYN codebase as a module to handle ADV and Acoustic Doppler Current Profiler (ADCP) data.\n", + "\n", + "This particular dataset is an excerpt from a cabled ADV mounted to a Sea Spider tripod, where the ADV was sampling on a duty cycle where 5 minutes of data was recorded every 20 minutes. All of the steps for a non-cabled ADV still apply, excepting the probe-inst rotation step.\n", + "\n", + "A standard ADV data analysis workflow can be segmented into the following steps:\n", + "\n", + "1. **Raw Data Review**: Evaluate the original data by verifying timestamps and assessing the quality of velocity data, specifically looking for any data spikes.\n", + "\n", + "2. **Data Cleaning**: Identify and eliminate any spurious data points. If needed, bad data points can be replaced with interpolated values.\n", + "\n", + "3. **Data Rotation**: Transform the data into the principal flow coordinates, which are the streamwise, cross-stream, and vertical directions.\n", + "\n", + "4. **Data Averaging**: Aggregate the data into bins or ensembles, each of which spans a predefined time length, typically between 5 and 10 minutes.\n", + "\n", + "5. **Statistical Analysis**: Compute turbulence statistics such as turbulence intensity, Turbulent Kinetic Energy (TKE), and Reynolds stresses for the observed flow field.\n", + "\n", + "Start your analysis by importing the necessary tools:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from mhkit import dolfyn\n", + "from mhkit.dolfyn.adv import api" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read Raw Instrument Data" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "DOLfYN currently only carries support for the Nortek Vector ADV. The example loaded here is a short clip of data from a test deployment to show DOLfYN's capabilities.\n", + "\n", + "Start by reading in the raw datafile downloaded from the instrument. The `dolfyn.read` function reads the raw file and dumps the information into an xarray Dataset, which contains three groups of variables:\n", + "\n", + "1. Velocity, amplitude, and correlation of the Doppler velocimetry\n", + "2. Measurements of the instrument's bearing and environment\n", + "3. Orientation matrices DOLfYN uses for rotating through coordinate frames." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": true + }, + "outputs": [ { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "ADV velocity data tends to have spikes due to Doppler noise, and the common way to \"despike\" the data is by using the phase-space algorithm by Goring and Nikora (2002). DOLfYN integrates this function using a 2-step approach: create a logical mask where True corresponds to a spike detection, and then utilize an interpolation function to replace the spikes." - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading file data/dolfyn/vector_cabled_imu01.VEC ...\n" + ] + } + ], + "source": [ + "ds = dolfyn.read(\"data/dolfyn/vector_cabled_imu01.VEC\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are two ways to see what's in a Dataset. The first is to simply type the dataset's name to see the standard xarray output. To access a particular variable in a dataset, use dict-style (`ds['vel']`) or attribute-style syntax (`ds.vel`). See the [xarray docs](http://xarray.pydata.org/en/stable/getting-started-guide/quick-overview.html) for more details on how to use the xarray format." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Percent of data containing spikes: 0.73%\n" - ] - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 25MB\n",
+       "Dimensions:              (time: 216039, beam: 3, dir: 3, x1: 3, x2: 3,\n",
+       "                          earth: 3, inst: 3)\n",
+       "Coordinates:\n",
+       "  * time                 (time) datetime64[ns] 2MB 2025-02-25T10:00:03.587208...\n",
+       "  * beam                 (beam) int32 12B 1 2 3\n",
+       "  * dir                  (dir) <U1 12B 'X' 'Y' 'Z'\n",
+       "  * x1                   (x1) int32 12B 1 2 3\n",
+       "  * x2                   (x2) int32 12B 1 2 3\n",
+       "  * earth                (earth) <U1 12B 'E' 'N' 'U'\n",
+       "  * inst                 (inst) <U1 12B 'X' 'Y' 'Z'\n",
+       "Data variables: (12/17)\n",
+       "    beam2inst_orientmat  (x1, x2) float64 72B 2.575 -1.305 ... 0.3582 0.3455\n",
+       "    batt                 (time) float32 864kB 13.4 13.4 13.4 ... nan nan nan\n",
+       "    c_sound              (time) float32 864kB 1.477e+03 1.477e+03 ... nan nan\n",
+       "    heading              (time) float32 864kB 0.0 0.0 0.0 0.0 ... nan nan nan\n",
+       "    pitch                (time) float32 864kB 0.0 0.0 0.0 0.0 ... nan nan nan\n",
+       "    roll                 (time) float32 864kB 0.0 0.0 0.0 0.0 ... nan nan nan\n",
+       "    ...                   ...\n",
+       "    amp                  (beam, time) uint8 648kB 84 93 104 103 ... 106 106 95\n",
+       "    corr                 (beam, time) uint8 648kB 94 98 98 97 99 ... 95 97 97 92\n",
+       "    accel                (dir, time) float32 3MB 9.53 9.536 ... -1.229 -1.219\n",
+       "    angrt                (dir, time) float32 3MB 0.000111 ... -0.0005012\n",
+       "    orientmat            (earth, inst, time) float32 8MB 0.1533 ... -0.1279\n",
+       "    pressure             (time) float32 864kB 8.865 8.869 8.86 ... 7.073 7.073\n",
+       "Attributes: (12/42)\n",
+       "    inst_make:                   Nortek\n",
+       "    inst_model:                  Vector\n",
+       "    inst_type:                   ADV\n",
+       "    rotate_vars:                 ['vel', 'accel', 'angrt']\n",
+       "    n_beams:                     3\n",
+       "    profile_mode:                continuous\n",
+       "    ...                          ...\n",
+       "    duty_cycle_n_burst:          9600\n",
+       "    duty_cycle_interval:         1200\n",
+       "    duty_cycle_description:      300.0 second bursts collected at 32.0 Hz, wi...\n",
+       "    fs:                          32.0\n",
+       "    coord_sys:                   inst\n",
+       "    has_imu:                     1
" ], - "source": [ - "# Clean the file using the Goring+Nikora method:\n", - "mask = api.clean.GN2002(ds.vel, npt=5000)\n", - "# Replace bad datapoints via cubic spline interpolation\n", - "ds[\"vel\"] = api.clean.clean_fill(ds[\"vel\"], mask, npt=12, method=\"cubic\", maxgap=None)\n", - "\n", - "print(\"Percent of data containing spikes: {0:.2f}%\".format(100 * mask.mean()))\n", - "\n", - "# If interpolation isn't desired:\n", - "ds_nan = ds.copy(deep=True)\n", - "ds_nan.coords[\"mask\"] = ((\"dir\", \"time\"), ~mask)\n", - "ds_nan[\"vel\"] = ds_nan[\"vel\"].where(ds_nan[\"mask\"])" + "text/plain": [ + " Size: 25MB\n", + "Dimensions: (time: 216039, beam: 3, dir: 3, x1: 3, x2: 3,\n", + " earth: 3, inst: 3)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2MB 2025-02-25T10:00:03.587208...\n", + " * beam (beam) int32 12B 1 2 3\n", + " * dir (dir) \"inst\"<->\"earth\"<->\"principal\"), done through the `rotate2` function. If the \"earth\" (ENU) coordinate system is specified, DOLfYN will automatically rotate the dataset through the necessary coordinate systems to get there. The `inplace` set as true will alter the input dataset \"in place\", a.k.a. it not create a new dataset." + "data": { + "text/plain": [ + ": Nortek Vector\n", + " . 7.37 hours (started: Feb 25, 2025 10:00)\n", + " . inst-frame\n", + " . (216039 pings @ 32.0Hz)\n", + " Variables:\n", + " - time ('time',)\n", + " - vel ('dir', 'time')\n", + " - orientmat ('earth', 'inst', 'time')\n", + " - heading ('time',)\n", + " - pitch ('time',)\n", + " - roll ('time',)\n", + " - temp ('time',)\n", + " - pressure ('time',)\n", + " - amp ('beam', 'time')\n", + " - corr ('beam', 'time')\n", + " - accel ('dir', 'time')\n", + " - angrt ('dir', 'time')\n", + " ... and others (see `.variables`)" ] - }, + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_dolfyn = ds.velds\n", + "ds_dolfyn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set rotation for cabled ADV head\n", + "For cable-head ADVs, be sure to record the position and orientation of the ADV head relative to the ADV pressure case ‘inst’ coordinate system. This ADV was set up in the same orientation as the one shown in Figure 1 [here](https://dolfyn.readthedocs.io/en/stable/motion-correction.html); the rotation matrix for this setup is written below. Per the Nortek documentation, in this orientation, the probe \"X\" direction is the IMU's \"-Z\" direction.\n", + "\n", + "If utilizing a non-cabled ADV (the standard version), skip this step." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# This is the rotation matrix per Figure 1: https://dolfyn.readthedocs.io/en/stable/motion-correction.html\n", + "dolfyn.set_inst2head_rotmat(ds, [[0, 0, -1], [0, -1, 0], [-1, 0, 0]])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quality Control" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ADV velocity data tends to have spikes due to Doppler noise. There are multiple approaches to removing bad values, including trimming beyond a maximum range, removing values with low acoustic correlation values, and finally another is to \"despike\" the data is by using the phase-space algorithm by Goring and Nikora (2002). DOLfYN integrates QC functions using a 2-step approach: create a logical mask where True corresponds to a spike detection, and then remove and/or interpolate those values." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# First set the magnetic declination\n", - "dolfyn.set_declination(\n", - " ds, declin=10, inplace=True\n", - ") # declination points 10 degrees East\n", - "\n", - "# Rotate that data from the instrument to earth frame (ENU):\n", - "dolfyn.rotate2(ds, \"earth\", inplace=True)" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Percent of data containing spikes: 0.12%\n" + ] + } + ], + "source": [ + "# Remove low correlation values and noisy beam measurements\n", + "ds.velds.rotate2(\"beam\")\n", + "# Start a mask by copying the velocity data-array\n", + "mask = ds[\"vel\"].copy() * 0\n", + "# Now we'll remove values with correlation < 80% and velocity outside of +/- 0.7 m/s\n", + "# We decide this +/- 0.7 m/s threshold by looking at plots of the along-beam velocity\n", + "mask = mask + (ds[\"corr\"].values < 80) + (ds[\"vel\"] > 0.7) + (ds[\"vel\"] < -0.7)\n", + "# Set the mask to boolean\n", + "mask = mask.astype(bool)\n", + "# Replace bad datapoints using the ensemble mean over a 5-minute window\n", + "ds[\"vel\"] = dolfyn.adv.clean.fill_nan_ensemble_mean(\n", + " ds[\"vel\"], mask, int(ds.fs), window=300\n", + ")\n", + "print(\"Percent of data containing spikes: {0:.2f}%\".format(100 * mask.mean()))\n", + "\n", + "# How to use the Goring+Nikora method to clean spikes in ADV data:\n", + "ds_ex = ds.copy(deep=True)\n", + "# Clean the file using the Goring+Nikora method:\n", + "mask_ex = api.clean.GN2002(ds.vel, npt=5000)\n", + "# Replace bad datapoints via cubic spline interpolation\n", + "ds_ex[\"vel\"] = api.clean.clean_fill(ds_ex[\"vel\"], mask, npt=12, method=\"cubic\", maxgap=None)\n", + "\n", + "# If interpolation isn't desired:\n", + "ds_nan = ds.copy(deep=True)\n", + "ds_nan.coords[\"mask\"] = ((\"dir\", \"time\"), ~mask_ex)\n", + "ds_nan[\"vel\"] = ds_nan[\"vel\"].where(ds_nan[\"mask\"])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coordinate Rotations" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the data has been cleaned, the next step is to rotate the velocity data into true East, North, Up (ENU) coordinates.\n", + "\n", + "ADVs use an internal compass or magnetometer to determine magnetic ENU directions. The `set_declination` function takes the user supplied magnetic declination (which can be looked up online for specific coordinates) and adjusts the orientation matrix saved within the dataset.\n", + "\n", + "Instruments save vector data in the coordinate system specified in the deployment configuration file. To make the data useful, it must be rotated through coordinate systems (\"beam\"<->\"inst\"<->\"earth\"<->\"principal\"), done through the `rotate2` function. If the \"earth\" (ENU) coordinate system is specified, DOLfYN will automatically rotate the dataset through the necessary coordinate systems to get there. The `inplace` set as true will alter the input dataset \"in place\", i.e., it not create a new dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# First set the magnetic declination\n", + "dolfyn.set_declination(\n", + " ds, declin=15.3, inplace=True\n", + ") # declination points 15.3 degrees East\n", + "\n", + "# Rotate that data from the instrument to earth frame (ENU):\n", + "dolfyn.rotate2(ds, \"earth\", inplace=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once in the true ENU frame of reference, we can calculate the principal flow direction for the velocity data and rotate it into the principal frame of reference (streamwise, cross-stream, vertical). Principal flow directions are aligned with and orthogonal to the flow streamlines at the measurement location. \n", + "\n", + "First, the principal flow direction must be calculated through `calc_principal_heading`. As a standard for DOLfYN functions, those that begin with \"calc_*\" require the velocity data for input. This function is different from others in DOLfYN in that it requires placing the output in an attribute called \"principal_heading\", as shown below.\n", + "\n", + "Again we use `rotate2` to change coordinate systems." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "ds.attrs[\"principal_heading\"] = dolfyn.calc_principal_heading(ds[\"vel\"])\n", + "dolfyn.rotate2(ds, \"principal\", inplace=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once we've done quality control and coordinate rotations (not necessarily in that order), we can plot the velocity vector to see how it looks:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once in the true ENU frame of reference, we can calculate the principal flow direction for the velocity data and rotate it into the principal frame of reference (streamwise, cross-stream, vertical). Principal flow directions are aligned with and orthogonal to the flow streamlines at the measurement location. \n", - "\n", - "First, the principal flow direction must be calculated through `calc_principal_heading`. As a standard for DOLfYN functions, those that begin with \"calc_*\" require the velocity data for input. This function is different from others in DOLfYN in that it requires place the output in an attribute called \"principal_heading\", as shown below.\n", - "\n", - "Again we use `rotate2` to change coordinate systems." + "data": { + "text/plain": [ + "Text(0.5, 1.0, '')" ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" }, { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "ds.attrs[\"principal_heading\"] = dolfyn.calc_principal_heading(ds[\"vel\"])\n", - "dolfyn.rotate2(ds, \"principal\", inplace=True)" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "plt.figure()\n", + "ds[\"vel\"][0].plot(label=\"streamwise\")\n", + "ds[\"vel\"][1].plot(label=\"cross-stream\")\n", + "ds[\"vel\"][2].plot(label=\"vertical\")\n", + "plt.legend()\n", + "plt.title(\"\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Averaging Data\n", + "The next step in ADV analysis is to average the velocity data into time bins (ensembles) and calculate turbulence statistics. These averaged values are then used to calculate turbulence statistics. There are two distinct methods for performing this operation, both of which utilize the same variable inputs and produce identical datasets.\n", + "\n", + "1. **Object-Oriented Approach** (standard): Define an 'averaging object', create a dataset binned in time, and calculate basic turbulence statistics. This is accomplished by initiating an object from the ADVBinner class and then feeding that object with our dataset.\n", + "\n", + "2. **Functional Approach** (simple): The same operations can be performed using the functional counterpart of ADVBinner, turbulence_statistics.\n", + "\n", + "Function inputs shown here are the dataset itself: \n", + " - `n_bin`: the number of elements in each bin; \n", + " - `fs`: the ADV's sampling frequency in Hz; \n", + " - `n_fft`: optional, the number of elements per FFT for spectral analysis; \n", + " - `freq_units`: optional, either in Hz or rad/s, of the calculated spectral frequency vector.\n", + "\n", + "All of the variables in the returned dataset have been bin-averaged, where each average is computed using the number of elements specified in `n_bins`. Additional variables in this dataset include the turbulent kinetic energy (TKE) vector (\"ds_binned.tke_vec\"), the Reynold's stresses (\"ds_binned.stress\"), and the power spectral densities (\"ds_binned.psd\"), calculated for each bin." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Option 1 (standard)\n", + "binner = api.ADVBinner(n_bin=ds.fs * 600, fs=ds.fs, n_fft=ds.fs * 600)\n", + "ds_binned = binner.bin_average(ds)\n", + "\n", + "# Option 2 (simple)\n", + "# ds_binned = api.calc_turbulence(ds, n_bin=ds.fs*600, fs=ds.fs, n_fft=ds.fs*600, freq_units=\"Hz\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The benefit to using `ADVBinner` is that one has access to all of the velocity and turbulence analysis functions that DOLfYN contains. If basic analysis will suffice, the `turbulence_statistics` function is the most convienent. Either option can still utilize DOLfYN's shortcuts.\n", + "\n", + "See the [DOLfYN API](https://dolfyn.readthedocs.io/en/latest/apidoc/dolfyn.binners.html) for the full list of functions and shortcuts. A few examples are shown below.\n", + "\n", + "Some things to know:\n", + "- All functions operate bin-by-bin.\n", + "- Some functions will fail if there are NaN's in the data stream (Notably the PSD functions)\n", + "- \"Shortcuts\", as referred to in DOLfYN, are functions accessible by the xarray accessor `velds`, as shown below. The list of \"shortcuts\" available through `velds` are listed [here](https://dolfyn.readthedocs.io/en/latest/apidoc/dolfyn.shortcuts.html). Some shortcut variables require the raw dataset, some an averaged dataset.\n", + "\n", + "For instance, \n", + "- `bin_variance` calculates the binned-variance of each variable in the raw dataset, the complementary to `bin_average`. Variables returned by this function contain a \"_var\" suffix to their name.\n", + "- `power_spectral_density` calculates the power spectral density (velocity spectra) of the velocity vector\n", + "- `cross_spectral_density` calculates the cross spectral density between each direction of the supplied DataArray. Note that inputs specified in creating the `ADVBinner` object can be overridden or additionally specified for a particular function call.\n", + "- `turbulence_intensity` is calculated from the ratio of the standard deviation of the horizontal velocity magnitude (equivalent to the RMS of turbulent velocity fluctuations) to the mean of the horizontal velocity magnitude\n", + "- `integral_length_scales` estimates the integral length scale in the streamwise, transverse, and vertical directions from the first crossing of the autocorrelation function\n", + "- `turbulent_kinetic_energy` calculates the TKE (Reynolds normal stress) components\n", + "- `reynolds_stress` calculates the Reynolds shear stress components\n", + "- `dissipation_rate_LT83` uses the Lumley and Terray 1983 algorithm to estimate the TKE dissipation rate from the isoropic turbulence cascade seen in the spectral. This requires the frequency range of the cascade as input.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Calculate the variance of each variable in the dataset and add to the averaged dataset\n", + "ds_binned = binner.bin_variance(ds, out_ds=ds_binned)\n", + "\n", + "# Calculate the power spectral density\n", + "ds_binned[\"auto_spectra\"] = binner.power_spectral_density(ds[\"vel\"], freq_units=\"Hz\")\n", + "\n", + "# Calculate the cross power spectral densities\n", + "ds_binned[\"cross_spectra\"] = binner.cross_spectral_density(\n", + " ds[\"vel\"], freq_units=\"Hz\", n_fft_coh=ds.fs * 200\n", + ")\n", + "\n", + "# Water speed and direction\n", + "ds_binned[\"U_mag\"] = ds_binned.velds.U_mag\n", + "ds_binned[\"U_dir\"] = ds_binned.velds.U_dir\n", + "\n", + "# Calculate the Doppler noise level from the white noise floor of the auto-spectra\n", + "ds_binned[\"noise\"] = binner.doppler_noise_level(ds_binned[\"auto_spectra\"], pct_fN=0.8)\n", + "\n", + "# Calculate the turbulence intensity and subtract the average horizontal velocity noise level\n", + "ds_binned[\"TI\"] = binner.turbulence_intensity(\n", + " ds.velds.U_mag, noise=ds_binned[\"noise\"][:2].mean(\"S\")\n", + ")\n", + "\n", + "# Calculate the auto-covariance to find the integral length scales\n", + "autocov = binner.autocovariance(ds[\"vel\"])\n", + "ds_binned[\"length_scale\"] = binner.integral_length_scales(autocov, ds_binned[\"U_mag\"])\n", + "\n", + "# Calculate the TKE components and Reynolds shear stresses\n", + "ds_binned['tke_vec'] = binner.turbulent_kinetic_energy(ds[\"vel\"])\n", + "ds_binned['stress_vec'] = binner.reynolds_stress(ds[\"vel\"])\n", + "\n", + "# Calculate dissipation rate from isotropic turbulence cascade\n", + "ds_binned[\"dissipation_rate\"] = binner.dissipation_rate_LT83(\n", + " ds_binned[\"auto_spectra\"], ds_binned[\"U_mag\"], noise=ds_binned[\"noise\"], freq_range=[0.8, 2]\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving and Loading DOLfYN datasets\n", + "Datasets can be saved and reloaded using the `save` and `load` functions. Xarray is saved natively in netCDF format, hence the \".nc\" extension.\n", + "\n", + "Note: DOLfYN datasets cannot be saved using xarray's native `ds.to_netcdf`; however, DOLfYN datasets can be opened using `xarray.open_dataset`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment these lines to save and load to your current working directory\n", + "# dolfyn.save(ds, 'your_data.nc')\n", + "# ds_saved = dolfyn.load('your_data.nc')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization\n", + "Plotting can be performed using matplotlib. As an example, the mean spectrum in the streamwise direction is plotted here. This spectrum shows the mean energy density in the flow at a particular flow frequency." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Averaging Data\n", - "The next step in ADV analysis is to average the velocity data into time bins (ensembles) and calculate turbulence statistics. These averaged values are then used to calculate turbulence statistics. There are two distinct methods for performing this operation, both of which utilize the same variable inputs and produce identical datasets.\n", - "\n", - "1. **Object-Oriented Approach** (standard): Define an 'averaging object', create a dataset binned in time, and calculate basic turbulence statistics. This is accomplished by initiating an object from the ADVBinner class and then feeding that object with our dataset.\n", - "\n", - "2. **Functional Approach** (simple): The same operations can be performed using the functional counterpart of ADVBinner, turbulence_statistics.\n", - "\n", - "Function inputs shown here are the dataset itself: \n", - " - `n_bin`: the number of elements in each bin; \n", - " - `fs`: the ADV's sampling frequency in Hz; \n", - " - `n_fft`: optional, the number of elements per FFT for spectral analysis; \n", - " - `freq_units`: optional, either in Hz or rad/s, of the calculated spectral frequency vector.\n", - "\n", - "All of the variables in the returned dataset have been bin-averaged, where each average is computed using the number of elements specified in `n_bins`. Additional variables in this dataset include the turbulent kinetic energy (TKE) vector (\"ds_binned.tke_vec\"), the Reynold's stresses (\"ds_binned.stress\"), and the power spectral densities (\"ds_binned.psd\"), calculated for each bin." + "data": { + "text/plain": [ + "" ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" }, { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# Option 1 (standard)\n", - "binner = api.ADVBinner(n_bin=ds.fs * 600, fs=ds.fs, n_fft=1024)\n", - "ds_binned = binner.bin_average(ds)\n", - "\n", - "# Option 2 (simple)\n", - "# ds_binned = api.calc_turbulence(ds, n_bin=ds.fs*600, fs=ds.fs, n_fft=1024, freq_units=\"Hz\")" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(5, 4), constrained_layout=True)\n", + "for spec in ds_binned[\"S\"]:\n", + " ax.loglog(\n", + " ds_binned[\"freq\"],\n", + " ds_binned[\"auto_spectra\"].sel(S=spec).mean(dim=\"time\"),\n", + " label=spec.values,\n", + " )\n", + "ax.plot(\n", + " ds_binned[\"freq\"], 4e-5 * ds_binned[\"freq\"] ** (-5 / 3), \"k--\", label=\"f$^{-5/3}$ slope\"\n", + ")\n", + "ax.set(ylim=(1e-5, 1), xlabel=\"Frequency [Hz]\", ylabel=\"Spectra [m$^2$/s$^2$/Hz]\")\n", + "ax.grid()\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The benefit to using `ADVBinner` is that one has access to all of the velocity and turbulence analysis functions that DOLfYN contains. If basic analysis will suffice, the `turbulence_statistics` function is the most convienent. Either option can still utilize DOLfYN's shortcuts.\n", - "\n", - "See the [DOLfYN API](https://dolfyn.readthedocs.io/en/latest/apidoc/dolfyn.binners.html) for the full list of functions and shortcuts. A few examples are shown below.\n", - "\n", - "Some things to know:\n", - "- All functions operate bin-by-bin.\n", - "- Some functions will fail if there are NaN's in the data stream (Notably the PSD functions)\n", - "- \"Shorcuts\", as referred to in DOLfYN, are functions accessible by the xarray accessor `velds`, as shown below. The list of \"shorcuts\" available through `velds` are listed [here](https://dolfyn.readthedocs.io/en/latest/apidoc/dolfyn.shortcuts.html). Some shorcut variables require the raw dataset, some an averaged dataset.\n", - "\n", - "For instance, \n", - "- `bin_variance` calculates the binned-variance of each variable in the raw dataset, the complementary to `bin_average`. Variables returned by this function contain a \"_var\" suffix to their name.\n", - "- `turbulence_intensity` is calculated from the ratio of the standard deviation of the horizontal velocity magnitude (equivalent to the RMS of turbulent velocity fluctuations) to the mean of the horizontal velocity magnitude\n", - "- `power_spectral_density` calculates the power spectral density (velocity spectra) of the velocity vector\n", - "- `cross_spectral_density` calculates the cross spectral density between each direction of the supplied DataArray. Note that inputs specified in creating the `ADVBinner` object can be overridden or additionally specified for a particular function call.\n", - "- `dissipation_rate_LT83` uses the Lumley and Terray 1983 algorithm to estimate the TKE dissipation rate from the isoropic turbulence cascade seen in the spectral. This requires the frequency range of the cascade as input.\n", - "- `turbulent_kinetic_energy` calculates the TKE (Reynolds normal stress) components\n", - "- `reynolds_stress` calculates the Reynolds shear stress components\n", - "\n" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Turbulence intensity\n", + "fig, ax = plt.subplots(figsize=(5, 4), constrained_layout=True)\n", + "ax.scatter(\n", + " abs(ds_binned[\"U_mag\"]),\n", + " ds_binned[\"TI\"] * 100,\n", + ")\n", + "ax.set(xlabel=\"Velocity [m/s]\", ylabel=\"Turbulence Intensity [%]\", xlim=[0, 2], ylim=[0, 35])\n", + "ax.set_axisbelow(True) # set grid below data\n", + "ax.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "# Calculate the variance of each variable in the dataset and add to the averaged dataset\n", - "ds_binned = binner.bin_variance(ds, out_ds=ds_binned)\n", - "\n", - "# Calculate the turbulence intensity\n", - "ds_binned[\"TI\"] = binner.turbulence_intensity(ds.velds.U_mag)\n", - "\n", - "# Calculate the power spectral density\n", - "ds_binned[\"auto_spectra\"] = binner.power_spectral_density(ds[\"vel\"], freq_units=\"Hz\")\n", - "\n", - "# Calculate the cross power spectral density\n", - "ds_binned[\"cross_spectra\"] = binner.cross_spectral_density(\n", - " ds[\"vel\"], freq_units=\"Hz\", n_fft_coh=512\n", - ")\n", - "\n", - "# Calculate dissipation rate from isotropic turbulence cascade\n", - "ds_binned[\"dissipation\"] = binner.dissipation_rate_LT83(\n", - " ds_binned[\"auto_spectra\"], ds_binned.velds.U_mag, freq_range=[0.5, 1]\n", - ")\n", - "\n", - "# Calculate the Reynolds stresses\n", - "ds_binned['tke_vec'] = binner.turbulent_kinetic_energy(ds[\"vel\"])\n", - "ds_binned['stress_vec'] = binner.reynolds_stress(ds[\"vel\"])\n" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TKE Dissipation rate\n", + "import numpy as np\n", + "\n", + "x_ticks = [0.1, 0.5, 1, 2]\n", + "y_ticks = [0.00001, 0.0001, 0.001, 0.01]\n", + "y_labels = [r\"10$^{-5}$\", r\"10$^{-4}$\", r\"10$^{-3}$\", r\"10$^{-2}$\"]\n", + "U = np.arange(0, 2, 0.1)\n", + "\n", + "fig, ax = plt.subplots(\n", + " figsize=(5, 4),\n", + " subplot_kw={\"xscale\": \"log\", \"yscale\": \"log\"},\n", + " constrained_layout=True,\n", + ")\n", + "ax.scatter(\n", + " abs(ds_binned[\"U_mag\"]),\n", + " ds_binned[\"dissipation_rate\"][0]\n", + ")\n", + "ax.plot(U, U**3 * 10 ** (-3), \"--\", color=\"black\", label=\"U$^3$ slope\")\n", + "\n", + "# Set axis labels\n", + "ax.set(\n", + " xlabel=\"Velocity [m/s]\",\n", + " ylabel=\"Dissipation Rate [m$^2$/s$^3$]\",\n", + " ylim=(y_ticks[0], y_ticks[-1]),\n", + " yticks=y_ticks,\n", + " yticklabels=y_labels,\n", + " xlim=(x_ticks[0], x_ticks[-1]),\n", + " xticks=x_ticks,\n", + " xticklabels=x_ticks,\n", + ")\n", + "ax.set_axisbelow(True) # set grid below data\n", + "ax.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plotting can be performed using matplotlib. As an example, the mean spectrum in the streamwise direction is plotted here. This spectrum shows the mean energy density in the flow at a particular flow frequency." + "data": { + "text/plain": [ + "" ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" }, { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Streamwise Direction')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "%matplotlib inline\n", - "\n", - "plt.figure()\n", - "plt.loglog(ds_binned[\"freq\"], ds_binned[\"auto_spectra\"].sel(S=\"Sxx\").mean(dim=\"time\"))\n", - "plt.xlabel(\"Frequency [Hz]\")\n", - "plt.ylabel(\"Energy Density $\\mathrm{[m^2/s^s/Hz]}$\")\n", - "plt.title(\"Streamwise Direction\")" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Length scales\n", + "fig, ax = plt.subplots(\n", + " figsize=(7, 3), subplot_kw={\"yscale\": \"log\"}, constrained_layout=True\n", + ")\n", + "ax.plot(ds_binned[\"time\"].values, ds_binned[\"length_scale\"][0], \"o\")\n", + "ax.plot(ds_binned[\"time\"].values, ds_binned[\"length_scale\"][1], \"D\")\n", + "ax.plot(ds_binned[\"time\"].values, ds_binned[\"length_scale\"][2], \"s\")\n", + "\n", + "ax.set(xlabel=\"Time\", ylabel=\"Length Scale [m]\", ylim=(0.05, 50))\n", + "ax.legend(\n", + " (\"Streamwise\", \"Transverse\", \"Vertical\"),\n", + " bbox_to_anchor=(-0.05, 1.02, 1, 0.102),\n", + " loc=\"lower center\",\n", + " ncol=3,\n", + " handlelength=1,\n", + " columnspacing=0.5,\n", + " handletextpad=0.3,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Saving and Loading DOLfYN datasets\n", - "Datasets can be saved and reloaded using the `save` and `load` functions. Xarray is saved natively in netCDF format, hence the \".nc\" extension.\n", - "\n", - "Note: DOLfYN datasets cannot be saved using xarray's native `ds.to_netcdf`; however, DOLfYN datasets can be opened using `xarray.open_dataset`." + "data": { + "text/plain": [ + "" ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" }, { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# Uncomment these lines to save and load to your current working directory\n", - "# dolfyn.save(ds, 'your_data.nc')\n", - "# ds_saved = dolfyn.load('your_data.nc')" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.12 ('base')", - "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.7" - }, - "vscode": { - "interpreter": { - "hash": "357206ab7e4935423e95e994af80e27e7e6c0672abcebb9d86ab743298213348" - } - } + ], + "source": [ + "# Reynolds stresses\n", + "fig, ax = plt.subplots(figsize=(7, 3), constrained_layout=True)\n", + "# u'w' bar\n", + "ax.plot(\n", + " ds_binned[\"time\"].values,\n", + " np.log10(abs(ds_binned[\"stress_vec\"][1])),\n", + " \"o-\"\n", + ")\n", + "# v'w' bar\n", + "ax.plot(\n", + " ds_binned[\"time\"].values,\n", + " np.log10(abs(ds_binned[\"stress_vec\"][2])),\n", + " \"s-\"\n", + ")\n", + "\n", + "y_labels = [r\"10$^{-5}$\", r\"10$^{-4}$\", r\"10$^{-3}$\", r\"10$^{-2}$\", r\"10$^{-1}$\"]\n", + "ax.set(\n", + " xlabel=\"Time\",\n", + " ylabel=r\"$\\overline{u_iu_j}$ \" + \"[m$^2$/s$^2$]\",\n", + " ylim=(-5, -1),\n", + " yticks=[-5, -4, -3, -2, -1],\n", + " yticklabels=y_labels,\n", + ")\n", + "ax.legend(\n", + " (r\"$\\overline{u'w'}$\", r\"$\\overline{v'w'}$\"),\n", + " # (r\"$\\overline{u'v'}$\", r\"$\\overline{u'w'}$\", r\"$\\overline{v'w'}$\"),\n", + " bbox_to_anchor=(-0.05, 1.02, 1, 0.102),\n", + " loc=\"lower center\",\n", + " ncol=3,\n", + " handlelength=1,\n", + " columnspacing=0.5,\n", + " handletextpad=0.3,\n", + " fontsize=12,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 4 + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/data/dolfyn/vector_cabled_imu01.VEC b/examples/data/dolfyn/vector_cabled_imu01.VEC new file mode 100644 index 00000000..f39de44a Binary files /dev/null and b/examples/data/dolfyn/vector_cabled_imu01.VEC differ diff --git a/mhkit/dolfyn/adp/turbulence.py b/mhkit/dolfyn/adp/turbulence.py index 41e00cea..5002523a 100644 --- a/mhkit/dolfyn/adp/turbulence.py +++ b/mhkit/dolfyn/adp/turbulence.py @@ -96,32 +96,32 @@ def __init__( diff_style="centered_extended", ): """ - A class for calculating turbulence statistics from ADCP data + A class for calculating turbulence statistics from ADCP measurements. Parameters ---------- n_bin : int - Number of data points to include in a 'bin' (ensemble), not the - number of bins + Number of data points to include in a 'bin' (ensemble) fs : int Instrument sampling frequency in Hz n_fft : int Number of data points to use for fft (`n_fft`<=`n_bin`). - Default: `n_fft`=`n_bin` + Default = `n_fft`=`n_bin` n_fft_coh : int - Number of data points to use for coherence and cross-spectra ffts - Default: `n_fft_coh`=`n_fft` + Number of data points to use for coherence and cross-spectra ffts. + Default = `n_fft_coh`=`n_fft` noise : float or array-like Instrument noise level in same units as velocity. Typically found from `adp.turbulence.doppler_noise_level`. - Default: None. - orientation : str, default='up' - Instrument's orientation, either 'up' or 'down' - diff_style : str, default='centered_extended' + Default = None + orientation : str + Instrument's orientation, either 'up' or 'down'. Default = 'up' + diff_style : str Style of numerical differentiation using Newton's Method. Either 'first' (first difference), 'centered' (centered difference), or 'centered_extended' (centered difference with first and last points extended using a first difference). + Default = 'centered_extended' """ VelBinner.__init__(self, n_bin, fs, n_fft, n_fft_coh, noise) @@ -169,14 +169,15 @@ def _diff_func(self, vel, u, orientation): def dudz(self, vel, orientation=None): """ - The shear in the first velocity component. + The shear in the first velocity component (:math:`du/dz`). Parameters ---------- vel : xarray.DataArray ADCP raw velocity - orientation : str, default=ADPBinner.orientation - Direction ADCP is facing ('up' or 'down') + orientation : str + Direction ADCP is facing ('up' or 'down'). + Default = ADPBinner.orientation Returns ------- @@ -185,8 +186,8 @@ def dudz(self, vel, orientation=None): Notes ----- - The derivative direction is along the profiler's 'z' - coordinate ('dz' is actually diff(self['range'])), not necessarily the + The derivative direction is along the profiler's :math:`z` + coordinate (:math:`dz` is actually `diff(self['range'])`), not necessarily the 'true vertical' direction. """ @@ -200,14 +201,15 @@ def dudz(self, vel, orientation=None): def dvdz(self, vel, orientation=None): """ - The shear in the second velocity component. + The shear in the second velocity component (:math:`dv/dz`). Parameters ---------- vel : xarray.DataArray ADCP raw velocity - orientation : str, default=ADPBinner.orientation - Direction ADCP is facing ('up' or 'down') + orientation : str + Direction ADCP is facing ('up' or 'down'). + Default = ADPBinner.orientation Returns ------- @@ -216,8 +218,8 @@ def dvdz(self, vel, orientation=None): Notes ----- - The derivative direction is along the profiler's 'z' - coordinate ('dz' is actually diff(self['range'])), not necessarily the + The derivative direction is along the profiler's :math:`z` + coordinate (:math:`dz` is actually `diff(self['range'])`), not necessarily the 'true vertical' direction. """ @@ -231,14 +233,15 @@ def dvdz(self, vel, orientation=None): def dwdz(self, vel, orientation=None): """ - The shear in the third velocity component. + The shear in the third velocity component (:math:`dw/dz`). Parameters ---------- vel : xarray.DataArray ADCP raw velocity - orientation : str, default=ADPBinner.orientation - Direction ADCP is facing ('up' or 'down') + orientation : str + Direction ADCP is facing ('up' or 'down'). + Default = ADPBinner.orientation Returns ------- @@ -247,8 +250,8 @@ def dwdz(self, vel, orientation=None): Notes ----- - The derivative direction is along the profiler's 'z' - coordinate ('dz' is actually diff(self['range'])), not necessarily the + The derivative direction is along the profiler's :math:`z` + coordinate (:math:`dz` is actually `diff(self['range'])`), not necessarily the 'true vertical' direction. """ @@ -276,13 +279,9 @@ def shear_squared(self, vel): Notes ----- - This is actually (dudz)^2 + (dvdz)^2. So, if those variables + This is actually :math:`(du/dz)^{2} + (dv/dz)^{2}`. So, if those variables are not actually vertical derivatives of the horizontal velocity, then this is not the 'horizontal shear squared'. - - See Also - -------- - :math:`dudz`, :math:`dvdz` """ shear2 = self.dudz(vel) ** 2 + self.dvdz(vel) ** 2 @@ -293,12 +292,12 @@ def shear_squared(self, vel): def doppler_noise_level(self, psd, pct_fN=0.8): """ - Calculate bias due to Doppler noise using the noise floor - of the velocity spectra. + Calculate bias (in units of velocity) due to Doppler noise + using the noise floor of the velocity spectra. Parameters ---------- - psd : xarray.DataArray (time, f) + psd : xarray.DataArray (time, freq) The velocity spectra from a single depth bin (range), typically in the mid-water range pct_fN : float @@ -313,17 +312,17 @@ def doppler_noise_level(self, psd, pct_fN=0.8): ----- Approximates bias from - .. :math: \\sigma^{2}_{noise} = N x f_{c} + .. math:: \\sigma^{2}_{noise} = N * f_{c} - where :math: `\\sigma_{noise}` is the bias due to Doppler noise, - `N` is the constant variance or spectral density, and `f_{c}` + where :math:`\\sigma_{noise}` is the bias due to Doppler noise, + :math:`N` is the constant variance or spectral density, and :math:`f_{c}` is the characteristic frequency. The characteristic frequency is then found as - .. :math: f_{c} = pct_fN * (f_{s}/2) + .. math:: f_{c} = pct_fN * (f_{s}/2) - where `f_{s}/2` is the Nyquist frequency. + where :math:`f_{s}/2` is the Nyquist frequency. Richard, Jean-Baptiste, et al. "Method for identification of Doppler noise @@ -381,8 +380,9 @@ def _stress_func_warnings(self, ds, beam_angle, noise, tilt_thresh): ---------- ds : xarray.Dataset Raw dataset in beam coordinates - beam_angle : int, default=ds.attrs['beam_angle'] - ADCP beam angle in units of degrees + beam_angle : int + ADCP beam angle in units of degrees. + Default = ``ds.attrs['beam_angle']`` noise : int or xarray.DataArray (time) Doppler noise level in units of m/s tilt_thresh: numeric @@ -459,9 +459,10 @@ def _check_orientation(self, ds, orientation, beam5=False): The orientation of the instrument, either 'up' or 'down'. If None, the orientation will be retrieved from the dataset or the instance's default orientation. - beam5 : bool, default=False + beam5 : bool A flag indicating whether a fifth beam is present. If True, the number 4 will be appended to the beam order. + Default = False Returns ------- @@ -472,6 +473,10 @@ def _check_orientation(self, ds, orientation, beam5=False): phi3 : float, optional The mean of the pitch values in radians, negated for Nortek instruments. Only returned if 'beam5' is True. + + Stacey, Mark T., Stephen G. Monismith, and Jon R. Burau. "Measurements + of Reynolds stress profiles in unstratified tidal flow." Journal of + Geophysical Research: Oceans 104.C5 (1999): 10933-10949. """ if orientation is None: @@ -548,7 +553,7 @@ def _beam_variance(self, ds, time, noise, beam_order, n_beams): bp2_[i] = np.nanvar(self.reshape(beam_vel[beam]), axis=-1) # Remove doppler_noise - if type(noise) == type(ds.vel): + if type(noise) == type(ds["vel"]): noise = noise.values bp2_ -= noise**2 @@ -556,8 +561,8 @@ def _beam_variance(self, ds, time, noise, beam_order, n_beams): def reynolds_stress_4beam(self, ds, noise=None, orientation=None, beam_angle=None): """ - Calculate the stresses from the covariance of along-beam - velocity measurements + Calculate the specific Reynolds shear stresses from the covariance of along-beam + velocity measurements (:math:`\\overline{u'w'}`, :math:`\\overline{v'w'}`). Parameters ---------- @@ -565,15 +570,17 @@ def reynolds_stress_4beam(self, ds, noise=None, orientation=None, beam_angle=Non Raw dataset in beam coordinates noise : int or xarray.DataArray (time) Doppler noise level in units of m/s - orientation : str, default=ds.attrs['orientation'] + orientation : str Direction ADCP is facing ('up' or 'down') - beam_angle : int, default=ds.attrs['beam_angle'] + Default = ``ds.attrs['orientation']`` + beam_angle : int ADCP beam angle in units of degrees + Default = ``ds.attrs['beam_angle']`` Returns ------- stress_vec : xarray.DataArray(s) - Stress vector with u'w'_ and v'w'_ components + Stress vector with :math:`\\overline{u'w'}` and :math:`\\overline{v'w'}` components Notes ----- @@ -581,10 +588,6 @@ def reynolds_stress_4beam(self, ds, noise=None, orientation=None, beam_angle=Non Assumes ADCP instrument coordinate system is aligned with principal flow directions. - - Stacey, Mark T., Stephen G. Monismith, and Jon R. Burau. "Measurements - of Reynolds stress profiles in unstratified tidal flow." Journal of - Geophysical Research: Oceans 104.C5 (1999): 10933-10949. """ # Run through warnings @@ -618,26 +621,31 @@ def stress_tensor_5beam( self, ds, noise=None, orientation=None, beam_angle=None, tke_only=False ): """ - Calculate the stresses from the covariance of along-beam - velocity measurements + Calculate the specific Reynolds stresses from the covariance of along-beam + velocity measurements (:math:`\\overline{u'u'}`, :math:`\\overline{v'v'}`, + :math:`\\overline{w'w'}`, :math:`\\overline{u'w'}`, :math:`\\overline{v'w'}`). Parameters ---------- ds : xarray.Dataset Raw dataset in beam coordinates - noise : int or xarray.DataArray with dim 'time', default=0 - Doppler noise level in units of m/s - orientation : str, default=ds.attrs['orientation'] - Direction ADCP is facing ('up' or 'down') - beam_angle : int, default=ds.attrs['beam_angle'] - ADCP beam angle in units of degrees - tke_only : bool, default=False - If true, only calculates tke components + noise : int or xarray.DataArray ('time') + Doppler noise level in units of m/s. + Default = 0 + orientation : str + Direction ADCP is facing ('up' or 'down'). + Default = ``ds.attrs['orientation']`` + beam_angle : int + ADCP beam angle in units of degrees. + Default = ``ds.attrs['beam_angle']`` + tke_only : bool + If true, only calculates TKE components. + Default = False Returns ------- tke_vec(, stress_vec) : xarray.DataArray or tuple[xarray.DataArray] - If tke_only is set to False, function returns `tke_vec` and `stress_vec`. + If `tke_only` is set to False, function returns `tke_vec` and `stress_vec`. Otherwise only `tke_vec` is returned Notes @@ -645,14 +653,14 @@ def stress_tensor_5beam( Assumes small-angle approximation is applicable. Assumes ADCP instrument coordinate system is aligned with principal flow - directions, i.e. u', v' and w' are aligned to the instrument's (XYZ) - frame of reference. + directions, i.e., :math:`u'`, :math:`v'` and :math:`w'` are aligned to the + instrument's (XYZ) frame of reference. - The stress equations here utilize u'v'_ to account for small variations - in pitch and roll. u'v'_ cannot be directly calculated by a 5-beam ADCP, - so it is approximated by the covariance of `u` and `v`. The uncertainty - introduced by using this approximation is small if deviations from pitch - and roll are small (<= 5 degrees). + The stress equations here utilize :math:`\\overline{u'v'}` to account for small + variations in pitch and roll. :math:`\\overline{u'v'}` cannot be directly calculated + by a 5-beam ADCP, (there are only 5 beams so only 5 unknowns can be found) so it is + approximated by the covariance of :math:`u` and :math:`v`. This approximation assumes + :math:`\\overline{u'v'}` is similar in magnitude to the other stress components. Dewey, R., and S. Stringer. "Reynolds stresses and turbulent kinetic energy estimates from various ADCP beam configurations: Theory." J. of @@ -780,9 +788,10 @@ def check_turbulence_cascade_slope(self, psd, freq_range=[0.2, 0.4]): ---------- psd : xarray.DataArray ([[range,] time,] freq) The power spectral density (1D, 2D or 3D) - freq_range : iterable(2) (default: [6.28, 12.57]) + freq_range : iterable(2) The range over which the isotropic turbulence cascade occurs, in - units of the psd frequency vector (Hz or rad/s) + units of the psd frequency vector (Hz or rad/s). + Default = [6.28, 12.57] Returns ------- @@ -809,7 +818,7 @@ def check_turbulence_cascade_slope(self, psd, freq_range=[0.2, 0.4]): Where :math:`y` is S(k) or S(f), :math:`x` is k or f, :math:`m` is the slope (ideally -5/3), and :math:`10^{b}` is the intercept of - y at x^m=1. + :math:`y` at :math:`x^{m}=1'. """ if not isinstance(psd, xr.DataArray): @@ -843,12 +852,12 @@ def dissipation_rate_LT83( Parameters ---------- - psd : xarray.DataArray (time,f) - The power spectral density from the vertical beam and depth - bin (range) + psd : xarray.DataArray (time, freq) + The power spectral density from the vertical beam and depth bin (range) U_mag : xarray.DataArray (time) The bin-averaged horizontal velocity (a.k.a. speed) from a single - depth bin (range) + depth bin (range) (i.e., computed using + :func:`mhkit.dolfyn.velocity.Velocity.U_mag`) f_range : iterable(2) The range over which to integrate/average the spectrum, in units of the psd frequency vector (Hz or rad/s) @@ -856,9 +865,9 @@ def dissipation_rate_LT83( Kolmogorov Constant (\\alpha in Notes section below) to use. Default \\alpha is 0.67. noise : float or array-like - Instrument noise level in same units as velocity. Typically - found from `adp.turbulence.doppler_noise_level`. - Default: None. + Instrument noise level in same units as velocity. Typically found from + :func:`doppler_noise_level ` + Default = None Returns ------- @@ -871,7 +880,7 @@ def dissipation_rate_LT83( .. math:: S(k) = \\alpha \\epsilon^{2/3} k^{-5/3} + N - where :math:`\\alpha is the Kolmogorov constant (0.67 for vertical direction), + where :math:`\\alpha` is the Kolmogorov constant (0.67 for vertical direction), `k` is wavenumber, `S(k)` is the turbulent kinetic energy spectrum, and `N' is the doppler noise level associated with the TKE spectrum. @@ -948,10 +957,11 @@ def dissipation_rate_SF(self, vel_raw, r_range=[1, 5]): vel_raw : xarray.DataArray The raw beam velocity data (one beam, last dimension time) upon which to perform the SF technique. - r_range : numeric, default=[1,5] + r_range : numeric, Range of r in [m] to calc dissipation across. Low end of range should be bin size, upper end of range is limited to the length of largest eddies in the inertial subrange. + Default = [1, 5] Returns ------- @@ -976,7 +986,7 @@ def dissipation_rate_SF(self, vel_raw, r_range=[1, 5]): where `u'` is the velocity fluctuation `z` is the depth bin, `r` is the separation between depth bins, and [] denotes a time average - (size 'ADPBinner.n_bin'). + (size 'self.n_bin'). The stucture function can then be used to estimate the dissipation rate: @@ -1094,12 +1104,12 @@ def friction_velocity(self, ds_avg, upwp_, z_inds=slice(1, 5), H=None): ds_avg : xarray.Dataset Bin-averaged dataset containing `stress_vec` upwp_ : xarray.DataArray - First component of Reynolds shear stress vector, "u-prime v-prime bar" + Second component of Reynolds shear stress vector, :math:`\\overline{u'w'}` Ex `ds_avg['stress_vec'].sel(tau='upwp_')` - z_inds : slice(int,int) + z_inds : slice(int, int) Depth indices to use for profile. Default = slice(1, 5) - H : numeric (default=`ds_avg.depth`) - Total water depth + H : numeric + Total water depth. Default = `ds_avg["depth"]` Returns ------- diff --git a/mhkit/dolfyn/adv/motion.py b/mhkit/dolfyn/adv/motion.py index f4a9e756..fcefa4e5 100644 --- a/mhkit/dolfyn/adv/motion.py +++ b/mhkit/dolfyn/adv/motion.py @@ -171,8 +171,8 @@ def calc_velacc( Returns ------- - velacc : numpy.ndarray (3 x n_time) - The acceleration-induced velocity array (3, n_time). + velacc : numpy.ndarray (dir, time) + The acceleration-induced velocity array """ samp_freq = self.ds.fs @@ -235,15 +235,15 @@ def calc_velrot(self, vec, to_earth=None): Parameters ---------- - vec : numpy.ndarray (len(3) or 3 x M) + vec : numpy.ndarray (dir[, time]) The vector in meters (or vectors) from the body-origin (center of head end-cap) to the point of interest (in the body coord-sys). Returns ------- - velrot : numpy.ndarray (3 x M x N_time) - The rotation-induced velocity array (3, n_time). + velrot : numpy.ndarray (dir[, time]) + The rotation-induced velocity array """ if to_earth is None: diff --git a/mhkit/dolfyn/adv/turbulence.py b/mhkit/dolfyn/adv/turbulence.py index d0d6bb90..4fe24a80 100644 --- a/mhkit/dolfyn/adv/turbulence.py +++ b/mhkit/dolfyn/adv/turbulence.py @@ -9,37 +9,36 @@ class ADVBinner(VelBinner): """ A class that builds upon `VelBinner` for calculating turbulence - statistics and velocity spectra from ADV data + statistics and velocity spectra from ADV data. Parameters ---------- n_bin : int - The length of each `bin`, in number of points, for this averaging + The length of each bin, in number of points, for this averaging operator. fs : int Instrument sampling frequency in Hz n_fft : int - The length of the FFT for computing spectra (must be <= n_bin). + The length of the FFT for computing spectra (must be <= `n_bin`). Optional, default `n_fft` = `n_bin` n_fft_coh : int - Number of data points to use for coherence and cross-spectra fft's. + Number of data points to use for coherence and cross-spectra FFT's. Optional, default `n_fft_coh` = `n_fft` - noise : float or array-like - Instrument noise level in same units as velocity. Typically - found from `adv.turbulence.doppler_noise_level`. - Default: None. + noise : float or array-like + Instrument noise level in same units as velocity. Typically found from + :func:`doppler_noise_level `. + Default: None. """ def __call__(self, ds, freq_units="rad/s", window="hann"): out = type(ds)() out = self.bin_average(ds, out) - noise = ds.get("doppler_noise", [0, 0, 0]) - out["tke_vec"] = self.turbulent_kinetic_energy(ds["vel"], noise=noise) + out["tke_vec"] = self.turbulent_kinetic_energy(ds["vel"]) out["stress_vec"] = self.reynolds_stress(ds["vel"]) out["psd"] = self.power_spectral_density( - ds["vel"], window=window, freq_units=freq_units, noise=noise + ds["vel"], window=window, freq_units=freq_units ) for key in list(ds.attrs.keys()): if "config" in key: @@ -53,19 +52,18 @@ def __call__(self, ds, freq_units="rad/s", window="hann"): def reynolds_stress(self, veldat, detrend=True): """ - Calculate the specific Reynolds stresses - (covariances of u,v,w in m^2/s^2) + Calculate the specific Reynolds shear stresses (:math:`\\overline{u'v'}`, + :math:`\\overline{u'w'}`, :math:`\\overline{v'w'}`). Parameters ---------- veldat : xr.DataArray - A velocity data array. The last dimension is assumed - to be time. + A velocity data array. The last dimension is assumed to be time. detrend : bool Detrend the velocity data (True), or simply de-mean it (False), prior to computing stress. Note: the psd routines use detrend, so if you want to have the same amount of - variance here as there use ``detrend=True``. + variance here as there use `detrend=True`. Default = True Returns @@ -121,20 +119,20 @@ def cross_spectral_density( Frequency units of the returned spectra in either Hz or rad/s (`f` or :math:`\\omega`) fs : float (optional) - The sample rate. Default = `binner.fs` + The sample rate. Default = `self.fs` window : string or array Specify the window function. Options: 1, None, 'hann', 'hamm' n_bin : int (optional) - The bin-size. Default = `binner.n_bin` + The bin-size. Default = `self.n_bin` n_fft_coh : int (optional) - The fft size. Default = `binner.n_fft_coh` + The fft size. Default = `self.n_fft_coh` Returns ------- csd : xarray.DataArray (3, M, N_FFT) The first-dimension of the cross-spectrum is the three - different cross-spectra: 'uv', 'uw', 'vw'. + different cross-spectra: :math:`uv`, :math:`uw`, :math:`vw`. """ if not isinstance(veldat, xr.DataArray): @@ -208,10 +206,11 @@ def doppler_noise_level(self, psd, pct_fN=0.8): Parameters ---------- - psd : xarray.DataArray (dir, time, f) + psd : xarray.DataArray (dir, time, freq) The ADV power spectral density of velocity (auto-spectra) pct_fN : float - Percent of Nyquist frequency to calculate characeristic frequency + Percent of Nyquist frequency to calculate characeristic frequency. + Default = 0.8 (80%) Returns ------- @@ -222,17 +221,17 @@ def doppler_noise_level(self, psd, pct_fN=0.8): ----- Approximates bias from - .. :math: \\sigma^{2}_{noise} = N x f_{c} + .. math:: \\sigma^{2}_{noise} = N * f_{c} - where :math: `\\sigma_{noise}` is the bias due to Doppler noise, - `N` is the constant variance or spectral density, and `f_{c}` + where :math:`\\sigma_{noise}` is the bias due to Doppler noise, + :math:`N` is the constant variance or spectral density, and :math:`f_{c}` is the characteristic frequency. The characteristic frequency is then found as - .. :math: f_{c} = pct_fN * (f_{s}/2) + .. math:: f_{c} = pct_fN * (f_{s}/2) - where `f_{s}/2` is the Nyquist frequency. + where :math:`f_{s}/2` is the Nyquist frequency. Richard, Jean-Baptiste, et al. "Method for identification of Doppler noise @@ -284,9 +283,10 @@ def check_turbulence_cascade_slope(self, psd, freq_range=[6.28, 12.57]): ---------- psd : xarray.DataArray ([time,] freq) The power spectral density (1D or 2D) - freq_range : iterable(2) (default: [6.28, 12.57]) + freq_range : iterable(2) The range over which the isotropic turbulence cascade occurs, in - units of the psd frequency vector (Hz or rad/s) + units of the psd frequency vector (Hz or rad/s). + Default = [6.28, 12.57] rad/s Returns ------- @@ -313,7 +313,7 @@ def check_turbulence_cascade_slope(self, psd, freq_range=[6.28, 12.57]): Where :math:`y` is S(k) or S(f), :math:`x` is k or f, :math:`m` is the slope (ideally -5/3), and :math:`10^{b}` is the intercept of - y at x^m=1. + :math:`y` at :math:`x^{m}=1'. """ if not isinstance(psd, xr.DataArray): @@ -352,10 +352,11 @@ def dissipation_rate_LT83( Parameters ---------- - psd : xarray.DataArray (...,time,f) + psd : xarray.DataArray ([dir,] time, freq) The power spectral density - U_mag : xarray.DataArray (...,time) - The bin-averaged horizontal velocity [m/s] (from dataset shortcut) + U_mag : xarray.DataArray (time) + The bin-averaged horizontal velocity [m/s] (i.e., computed using + :func:`U_mag `) freq_range : iterable(2) The range over which to integrate/average the spectrum, in units of the psd frequency vector (Hz or rad/s). @@ -373,7 +374,7 @@ def dissipation_rate_LT83( Returns ------- - epsilon : xarray.DataArray (...,n_time) + epsilon : xarray.DataArray ([dir,] time) dataArray of the dissipation rate Notes @@ -466,11 +467,12 @@ def dissipation_rate_SF(self, vel_raw, U_mag, fs=None, freq_range=[2.0, 4.0]): vel_raw : xarray.DataArray (time) The raw velocity data upon which to perform the SF technique. U_mag : xarray.DataArray - The bin-averaged horizontal velocity (from dataset shortcut) + The bin-averaged horizontal velocity (i.e., computed using + :func:`U_mag `) fs : float - The sample rate of `vel_raw` [Hz] + The sample rate of `vel_raw` in Hz freq_range : iterable(2) - The frequency range over which to compute the SF [Hz] + The frequency range over which to compute the SF in Hz (i.e. the frequency range within which the isotropic turbulence cascade falls). Default = [2., 4.] Hz @@ -575,9 +577,9 @@ def dissipation_rate_TE01(self, dat_raw, dat_avg, freq_range=[6.28, 12.57]): dat_raw : xarray.Dataset The raw (off the instrument) adv dataset dat_avg : xarray.Dataset - The bin-averaged adv dataset (calc'd from 'calc_turbulence' or - 'do_avg'). The spectra (psd) and basic turbulence statistics - ('tke_vec' and 'stress_vec') must already be computed. + The bin-averaged adv dataset (calculated from `ADVBinner.calc_turbulence` or + `VelBinner.bin_average`). The spectra (PSD) and Reynolds stresses + (`tke_vec` and `stress_vec`) must already be computed. freq_range : iterable(2) The range over which to integrate/average the spectrum, in units of the psd frequency vector (Hz or rad/s). @@ -602,7 +604,7 @@ def dissipation_rate_TE01(self, dat_raw, dat_avg, freq_range=[6.28, 12.57]): theta = np.angle(dat_avg.velds.U.values) - self._up_angle( dat_raw.velds.U.values ) - freq = dat_avg["psd"].freq.values + freq = dat_avg["freq"].values # Calculate constants alpha = 1.5 @@ -630,7 +632,7 @@ def dissipation_rate_TE01(self, dat_raw, dat_avg, freq_range=[6.28, 12.57]): return xr.DataArray( out.astype("float32"), - coords={"time": dat_avg["psd"]["time"]}, + coords={"time": dat_avg["time"]}, dims="time", attrs={ "units": "m2 s-3", @@ -647,25 +649,29 @@ def integral_length_scales(self, a_cov, U_mag, fs=None): Parameters ---------- - a_cov : xarray.DataArray (..., time, lag) - The autocovariance or autocorrelation array (i.e. computed using `autocovariance`). - U_mag : xarray.DataArray (..., time) - The bin-averaged horizontal velocity (from dataset shortcut) + a_cov : xarray.DataArray ([dir,] time, lag) + The autocovariance or autocorrelation array + (i.e., computed using + :func:`autocovariance `) + U_mag : xarray.DataArray (time) + The bin-averaged horizontal velocity (i.e., computed using + :func:`U_mag `) fs : numeric The raw sample rate Returns ------- - L_int : numpy.ndarray (..., n_time) - The integral length scale (T_int*U_mag). + L_int : numpy.ndarray ([dir,] time) + The integral length scale. Notes ---- - The integral time scale (T_int) is integral of the normalized autocorrelation - function, which theoretically decays to zero over time. Practically, - T_int is the integral from zero to the first zero-crossing lag-time - of the autocorrelation function. The integral length scale (L_int) - then is the integral time scale multiplied by the bin speed. + The integral time scale (:math:`T_{int}`) is integral of the normalized + autocovariance (autocorrelation) function, which theoretically decays to + zero over time. Practically, :math:`T_{int}` is the integral from zero to + the first zero-crossing lag-time of the autocorrelation function. The + integral length scale (:math:`L_{int}`) then is the integral time scale + multiplied by the bin speed. """ if not isinstance(a_cov, xr.DataArray): @@ -709,20 +715,19 @@ def turbulence_statistics( Parameters ---------- ds_raw : xarray.Dataset - The raw adv datset to `bin`, average and compute - turbulence statistics of. + The raw adv datset to bin, average, and compute turbulence statistics + from. freq_units : string Frequency units of the returned spectra in either Hz or rad/s - (`f` or :math:`\\omega`). Default is 'rad/s' + (`f` or :math:`\\omega`). Default = 'rad/s' window : string or array The window to use for calculating spectra. - Returns ------- ds : xarray.Dataset Returns an 'binned' (i.e. 'averaged') data object. All - fields (variables) of the input data object are averaged in n_bin + fields (variables) of the input data object are averaged in `n_bin` chunks. This object also computes the following items over those chunks: diff --git a/mhkit/dolfyn/binned.py b/mhkit/dolfyn/binned.py index 0bdb00f7..ef999e99 100644 --- a/mhkit/dolfyn/binned.py +++ b/mhkit/dolfyn/binned.py @@ -188,7 +188,7 @@ def reshape(self, arr, n_pad=0, n_bin=None): corners of the matrix (beginning/end of timeseries). In this case, the array shape will be (...,`n`,`n_pad`+`n_bin`) n_bin : int - Override this binner's n_bin. Default is `binner.n_bin` + Override this binner's n_bin. Default is `self.n_bin` Returns ------- @@ -256,7 +256,7 @@ def detrend(self, arr, axis=-1, n_pad=0, n_bin=None): this case, the array shape will be (...,`n`,`n_pad`+`n_bin`). Default = 0 n_bin : int - Override this binner's n_bin. Default is `binner.n_bin` + Override this binner's n_bin. Default is `self.n_bin` Returns ------- @@ -284,7 +284,7 @@ def demean(self, arr, axis=-1, n_pad=0, n_bin=None): this case, the array shape will be (...,`n`,`n_pad`+`n_bin`). Default = 0 n_bin : int - Override this binner's n_bin. Default is `binner.n_bin` + Override this binner's n_bin. Default is `self.n_bin` Returns ------- @@ -305,7 +305,7 @@ def mean(self, arr, axis=-1, n_bin=None): axis : int Axis along which to take mean. Default = -1 n_bin : int - Override this binner's n_bin. Default is `binner.n_bin` + Override this binner's n_bin. Default is `self.n_bin` Returns ------- @@ -332,7 +332,7 @@ def variance(self, arr, axis=-1, n_bin=None): axis : int Axis along which to take variance. Default = -1 n_bin : int - Override this binner's n_bin. Default is `binner.n_bin` + Override this binner's n_bin. Default is `self.n_bin` Returns ------- @@ -353,7 +353,7 @@ def standard_deviation(self, arr, axis=-1, n_bin=None): axis : int Axis along which to take std dev. Default = -1 n_bin : int - Override this binner's n_bin. Default is `binner.n_bin` + Override this binner's n_bin. Default is `self.n_bin` Returns ------- diff --git a/mhkit/dolfyn/velocity.py b/mhkit/dolfyn/velocity.py index 7a0f7e9d..bb95c40c 100644 --- a/mhkit/dolfyn/velocity.py +++ b/mhkit/dolfyn/velocity.py @@ -18,10 +18,6 @@ class Velocity: :class:`VelBinner` tool, but the method for calculating these variables can depend on the details of the measurement (instrument, it's configuration, orientation, etc.). - - See Also - ======== - :class:`VelBinner` """ ######## @@ -43,7 +39,7 @@ def rotate2(self, out_frame="earth", inplace=True): Returns ------- ds : xarray.Dataset or None - Returns the rotated dataset **when ``inplace=False``**, otherwise + Returns the rotated dataset **when `inplace=False`**, otherwise returns None. Notes @@ -128,7 +124,7 @@ def set_inst2head_rotmat(self, rotmat, inplace=True): Returns ------- ds : xarray.Dataset or None - Returns the rotated dataset **when ``inplace=False``**, otherwise + Returns the rotated dataset **when `inplace=False`**, otherwise returns None. Notes @@ -155,7 +151,7 @@ def save(self, filename, **kwargs): Notes ----- - See DOLfYN's :func:`save ` function for + See DOLfYN's :func:`save ` function for additional details. """ @@ -299,9 +295,9 @@ def u( """ The first velocity component. - This is simply a shortcut to self['vel'][0]. Therefore, + This is simply a shortcut to ``self['vel'][0]``. Therefore, depending on the coordinate system of the data object - (self.attrs['coord_sys']), it is: + (``self.attrs['coord_sys']``), it is: - beam: beam1 - inst: x @@ -317,9 +313,9 @@ def v( """ The second velocity component. - This is simply a shortcut to self['vel'][1]. Therefore, + This is simply a shortcut to ``self['vel'][1]``. Therefore, depending on the coordinate system of the data object - (self.attrs['coord_sys']), it is: + (``self.attrs['coord_sys']``), it is: - beam: beam2 - inst: y @@ -335,9 +331,9 @@ def w( """ The third velocity component. - This is simply a shortcut to self['vel'][2]. Therefore, + This is simply a shortcut to ``self['vel'][2]``. Therefore, depending on the coordinate system of the data object - (self.attrs['coord_sys']), it is: + (``self.attrs['coord_sys']``), it is: - beam: beam3 - inst: z @@ -361,7 +357,7 @@ def U( def U_mag( self, ): - """Horizontal velocity magnitude""" + """Horizontal velocity magnitude, i.e., speed""" return xr.DataArray( np.abs(self.U).astype("float32"), @@ -377,7 +373,7 @@ def U_dir( self, ): """ - Angle of horizontal velocity vector. Direction is 'to', + Angle of horizontal velocity vector, i.e., direction. Direction is 'to', as opposed to 'from'. This function calculates angle as "degrees CCW from X/East/streamwise" and then converts it to "degrees CW from X/North/streamwise". @@ -416,8 +412,8 @@ def E_coh( """ Coherent turbulent energy - Niel Kelley's 'coherent turbulence energy', which is the RMS - of the Reynold's stresses. + Niel Kelley's 'coherent turbulence energy', which is the + root-mean-square of the Reynold's stresses. See: NREL Technical Report TP-500-52353 """ @@ -438,7 +434,7 @@ def I_tke(self, thresh=0): """ Turbulent kinetic energy intensity. - Ratio of sqrt(tke) to horizontal velocity magnitude. + Ratio of sqrt(TKE) to horizontal velocity magnitude. """ I_tke = np.ma.masked_where( self.U_mag < thresh, np.sqrt(2 * self.tke) / self.U_mag @@ -482,7 +478,7 @@ def tke( def upvp_( self, ): - """u'v'bar Reynolds stress""" + """:math:`\\overline{u'v'}` Reynolds stress""" return self.ds["stress_vec"].sel(tau="upvp_").drop_vars("tau") @@ -490,7 +486,7 @@ def upvp_( def upwp_( self, ): - """u'w'bar Reynolds stress""" + """:math:`\\overline{u'w'}` Reynolds stress""" return self.ds["stress_vec"].sel(tau="upwp_").drop_vars("tau") @@ -498,7 +494,7 @@ def upwp_( def vpwp_( self, ): - """v'w'bar Reynolds stress""" + """:math:`\\overline{v'w'}` Reynolds stress""" return self.ds["stress_vec"].sel(tau="vpwp_").drop_vars("tau") @@ -506,7 +502,7 @@ def vpwp_( def upup_( self, ): - """u'u'bar component of the tke""" + """:math:`\\overline{u'u'}` component of the TKE vector""" return self.ds["tke_vec"].sel(tke="upup_").drop_vars("tke") @@ -514,7 +510,7 @@ def upup_( def vpvp_( self, ): - """v'v'bar component of the tke""" + """:math:`\\overline{v'v'}` component of the TKE vector""" return self.ds["tke_vec"].sel(tke="vpvp_").drop_vars("tke") @@ -522,7 +518,7 @@ def vpvp_( def wpwp_( self, ): - """w'w'bar component of the tke""" + """:math:`\\overline{w'w'}` component of the TKE vector""" return self.ds["tke_vec"].sel(tke="wpwp_").drop_vars("tke") @@ -603,30 +599,30 @@ def bin_average(self, raw_ds, out_ds=None, names=None): Parameters ---------- raw_ds : xarray.Dataset - The raw data structure to be binned + The raw data structure to be binned out_ds : xarray.Dataset - The bin'd (output) data object to which averaged data is added. + The binned (output) data object to which averaged data is added. names : list of strings - The names of variables to be averaged. If `names` is None, - all data in `raw_ds` will be binned. + The names of variables to be averaged. If `names` is None, + all data in `raw_ds` will be binned. Returns ------- out_ds : xarray.Dataset - The new (or updated when out_ds is not None) dataset - with the averages of all the variables in raw_ds. + The new (or updated when `out_ds` is not None) dataset + with the averages of all the variables in `raw_ds`. Raises ------ - AttributeError : when out_ds is supplied as input (not None) - and the values in out_ds.attrs are inconsistent with - raw_ds.attrs or the properties of this VelBinner (n_bin, - n_fft, fs, etc.) + AttributeError : when `out_ds` is supplied as input (not None) + and the values in ``out_ds.attrs`` are inconsistent with + ``raw_ds.attrs`` or the properties of this VelBinner (`n_bin`, + `n_fft`, `fs`, etc.) Notes ----- - raw_ds.attrs are copied to out_ds.attrs. Inconsistencies - between the two (when out_ds is specified as input) raise an + ``raw_ds.attrs`` are copied to ``out_ds.attrs``. Inconsistencies + between the two (when `out_ds` is specified as input) raise an AttributeError. """ @@ -675,36 +671,37 @@ def bin_average(self, raw_ds, out_ds=None, names=None): def bin_variance(self, raw_ds, out_ds=None, names=None, suffix="_var"): """ Bin the dataset and calculate the ensemble variances of each - variable. Complementary to `bin_average()`. + variable. Complementary to :func:`bin_average `. Parameters ---------- raw_ds : xarray.Dataset - The raw data structure to be binned. + The raw data structure to be binned. out_ds : xarray.Dataset - The binned (output) dataset to which variance data is added, - nominally dataset output from `bin_average()` + The binned (output) dataset to which variance data is added, + nominally the dataset output from + :func:`bin_average `. names : list of strings - The names of variables of which to calculate variance. If - `names` is None, all data in `raw_ds` will be binned. + The names of variables of which to calculate variance. If + `names` is None, all data in `raw_ds` will be binned. Returns ------- out_ds : xarray.Dataset - The new (or updated when out_ds is not None) dataset - with the variance of all the variables in raw_ds. + The new (or updated when `out_ds` is not None) dataset + with the variance of all the variables in `raw_ds`. Raises ------ - AttributeError : when out_ds is supplied as input (not None) - and the values in out_ds.attrs are inconsistent with - raw_ds.attrs or the properties of this VelBinner (n_bin, - n_fft, fs, etc.) + AttributeError : when `out_ds` is supplied as input (not None) + and the values in ``out_ds.attrs`` are inconsistent with + ``raw_ds.attrs`` or the properties of this VelBinner (`n_bin`, + `n_fft`, `fs`, etc.) Notes ----- - raw_ds.attrs are copied to out_ds.attrs. Inconsistencies - between the two (when out_ds is specified as input) raise an + ``raw_ds.attrs`` are copied to ``out_ds.attrs``. Inconsistencies + between the two (when `out_ds` is specified as input) raise an AttributeError. """ @@ -807,21 +804,26 @@ def autocovariance(self, veldat, n_bin=None): def turbulence_intensity(self, U_mag, noise=0, thresh=0, detrend=False): """ - Calculate noise-corrected turbulence intensity. + Calculate noise-corrected turbulence intensity (TI). Parameters ---------- U_mag : xarray.DataArray - Raw horizontal velocity magnitude + Raw horizontal velocity magnitude (i.e., computed using + :func:`U_mag `) noise : numeric Instrument noise level in same units as velocity. Typically - found from `.turbulence.doppler_noise_level`. - Default: None. + found from the ADV's + :func:`doppler_noise_level `. + or ADCP's + :func:`doppler_noise_level `. + Default = None thresh : numeric Theshold below which TI will not be calculated - detrend : bool (default: False) + detrend : bool Detrend the velocity data (True), or simply de-mean it (False), prior to computing TI. + Default = False """ if "xarray" in type(U_mag).__module__: @@ -861,8 +863,8 @@ def turbulence_intensity(self, U_mag, noise=0, thresh=0, detrend=False): def turbulent_kinetic_energy(self, veldat, noise=None, detrend=True): """ - Calculate the turbulent kinetic energy (TKE) (variances - of u,v,w). + Calculate the turbulent kinetic energy (TKE) (:math:`\\overline{u'u'}`, + :math:`\\overline{v'v'}`, :math:`\\overline{w'w'}`). Parameters ---------- @@ -871,18 +873,22 @@ def turbulent_kinetic_energy(self, veldat, noise=None, detrend=True): The last dimension is assumed to be time. noise : float or array-like Instrument noise level in same units as velocity. Typically - found from `.turbulence.doppler_noise_level`. - Default: None. - detrend : bool (default: False) - Detrend the velocity data (True), or simply de-mean it - (False), prior to computing TKE. Note: the PSD routines - use detrend, so if you want to have the same amount of - variance here as there use ``detrend=True``. + found from the ADV's + :func:`doppler_noise_level `. + or ADCP's + :func:`doppler_noise_level `. + Default = None + detrend : bool + Detrend the velocity data (True), or simply de-mean it (False), + prior to computing TKE. Default = False + + Note: the PSD routines use detrend, so if you want to have the same + amount of variance here as there use ``detrend=True``. Returns ------- tke_vec : xarray.DataArray - dataArray containing u'u'_, v'v'_ and w'w'_ + dataArray containing ``u'u'_``, ``v'v'_`` and ``w'w'_`` """ if "xarray" in type(veldat).__module__: @@ -960,25 +966,24 @@ def power_spectral_density( Parameters ---------- - veldat : xr.DataArray - The raw velocity data (of dims 'dir' and 'time'). + veldat : xr.DataArray (dir, time) + The raw velocity data freq_units : string Frequency units of the returned spectra in either Hz or rad/s - (`f` or :math:`\\omega`) fs : float (optional) The sample rate. Default is `binner.fs` window : string or array Specify the window function. - Options: 1, None, 'hann', 'hamm' + Options = 1, None, 'hann', 'hamm'. Default = 'hann' noise : numeric or array Instrument noise level in same units as velocity. - Default: 0 (ADCP) or [0, 0, 0] (ADV). + Default = 0 (ADCP) or [0, 0, 0] (ADV) n_bin : int (optional) - The bin-size. Default: from the binner. + The bin-size. Default = `self.n_bin` n_fft : int (optional) - The fft size. Default: from the binner. + The fft size. Default = `self.n_fft` n_pad : int (optional) - The number of values to pad with zero. Default = 0. + The number of values to pad with zero. Default = 0 step : int (optional) Controls amount of overlap in fft. Default: the step size is chosen to maximize data use, minimize nens, and have a @@ -986,7 +991,7 @@ def power_spectral_density( Returns ------- - psd : xarray.DataArray (3, M, N_FFT) + psd : xarray.DataArray (dir, time, freq) The spectra in the 'u', 'v', and 'w' directions. """