diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d2ab2d7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +# PyCharm +/.idea \ No newline at end of file diff --git a/Software/Analysis/Python/OpenCTD_single_profile_example.ipynb b/Software/Analysis/Python/OpenCTD_single_profile_example.ipynb new file mode 100644 index 0000000..cb2974a --- /dev/null +++ b/Software/Analysis/Python/OpenCTD_single_profile_example.ipynb @@ -0,0 +1,475 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## Download Required Packages" + ], + "metadata": { + "collapsed": false + }, + "id": "2694084beb1973aa" + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "# Uncomment the following lines to install.\n", + "\n", + "# !pip install gsw\n", + "# !pip install matplotlib\n", + "# !pip install numpy\n", + "# !pip install pandas\n", + "# !pip install xarray" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:09.768920100Z", + "start_time": "2024-01-01T22:00:09.749905200Z" + } + }, + "id": "initial_id" + }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "collapsed": false + }, + "id": "76cce3c313c2b3cf" + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Ian\\AppData\\Roaming\\Python\\Python310\\site-packages\\scipy\\__init__.py:146: UserWarning: A NumPy version >=1.17.3 and <1.25.0 is required for this version of SciPy (detected version 1.26.2\n", + " warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n" + ] + } + ], + "source": [ + "import gsw #Used to compute advanced data products.\n", + "import matplotlib.pyplot as plt # Used for plotting.\n", + "import numpy as np\n", + "import os\n", + "import pandas as pd\n", + "import xarray as xr" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:13.648236700Z", + "start_time": "2024-01-01T22:00:09.761429Z" + } + }, + "id": "37282d761383d7ae" + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "filepath = \"C:/Users/Ian/Desktop/BWW_060122.csv\"\n", + "\n", + "file_has_header = False\n", + "atmospheric_pressure = 'infer'\n", + "latitude = 44.12306\n", + "longitude = -67.20528" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:13.664875200Z", + "start_time": "2024-01-01T22:00:13.650225Z" + } + }, + "id": "59914081769baaaa" + }, + { + "cell_type": "markdown", + "source": [ + "## Helper Functions" + ], + "metadata": { + "collapsed": false + }, + "id": "caf5896050f7b225" + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "def import_file(filepath: os.path.abspath, file_has_header = True) -> xr.Dataset:\n", + " \"\"\"\n", + " Import an OpenCTD csv file and convert to an Xarray Dataset object. \n", + " Add attributes where necessary.\n", + " \n", + " :param filepath: The filepath of the data file.\n", + " :param file_has_header: Set to True if the file has a header (e.g. date, time, pressure...)\n", + " If set to False, default headers are used. \n", + " :return: An xarray Dataset of data from within the file.\n", + " \"\"\"\n", + " \n", + " if file_has_header is True:\n", + " df = pd.read_csv(filepath)\n", + " for column in df.columns:\n", + " new_column = column.lower().lstrip().replace(' ','_')\n", + " df = df.rename(columns = {column:new_column})\n", + " else:\n", + " columns = ['date','time', 'pressure', 'temp_a','temp_b','temp_c', 'conductivity']\n", + " df = pd.read_csv(os.path.normpath(filepath), names = columns)\n", + " \n", + " \n", + " ds = xr.Dataset()\n", + " ds = ds.assign_coords({'time':np.array(pd.to_datetime(df['date'] + ' ' + df['time']))})\n", + " ds['time'].attrs['units'] = 'nanoseconds since 1900-01-01'\n", + " ds['time'].attrs['description'] = 'Sample time computed from a combination of the sensor date and sensor time.'\n", + " \n", + " \n", + " ds['sensor_date'] = (['time'], np.array(df.date).astype(str))\n", + " ds['sensor_date'].attrs['units'] = 'mm/dd/yyyy'\n", + " ds['sensor_date'].attrs['description'] = 'The date measured by the OpenCTD RTC.'\n", + " \n", + " \n", + " ds['sensor_time'] = (['time'], np.array(df.time).astype(str))\n", + " ds['sensor_time'].attrs['units'] = 'hh:mm:ss'\n", + " ds['sensor_time'].attrs['description'] = 'The time measured by the OpenCTD RTC.'\n", + " \n", + " \n", + " ds['pressure'] = (['time'], np.array(df.pressure))\n", + " ds['pressure'].attrs['units'] = 'millibar'\n", + " ds['pressure'].attrs['units_tex'] = 'mbar'\n", + " ds['pressure'].attrs['description'] = 'The absolute pressure (atmosphere + water) measured by the OpenCTD pressure sensor.'\n", + " ds['pressure'].attrs['fill_value'] = 'NaN'\n", + "\n", + "\n", + " ds['temp_a'] = (['time'], np.array(df.temp_a))\n", + " ds['temp_a'].attrs['units'] = 'degrees_celsius'\n", + " ds['temp_a'].attrs['units_tex'] = r'$^{\\circ}C$'\n", + " ds['temp_a'].attrs['description'] = 'The temperature measured by thermistor A.'\n", + " ds['temp_a'].attrs['fill_value'] = 'NaN'\n", + "\n", + "\n", + " ds['temp_b'] = (['time'], np.array(df.temp_b))\n", + " ds['temp_b'].attrs['units'] = 'degrees_celsius'\n", + " ds['temp_b'].attrs['units_tex'] = r'$^{\\circ}C$'\n", + " ds['temp_b'].attrs['description'] = 'The temperature measured by thermistor B.'\n", + " ds['temp_b'].attrs['fill_value'] = 'NaN'\n", + "\n", + "\n", + " ds['temp_c'] = (['time'], np.array(df.temp_c))\n", + " ds['temp_c'].attrs['units'] = 'degrees_celsius'\n", + " ds['temp_c'].attrs['units_tex'] = r'$^{\\circ}C$'\n", + " ds['temp_c'].attrs['description'] = 'The temperature measured by thermistor B.'\n", + " ds['temp_c'].attrs['fill_value'] = 'NaN'\n", + "\n", + "\n", + " ds['conductivity'] = (['time'], np.array(df.conductivity))\n", + " ds['conductivity'].attrs['units'] = 'micro siemens per centimeter'\n", + " ds['conductivity'].attrs['units_tex'] = r'$\\frac{{\\mu}S}{cm}$'\n", + " ds['conductivity'].attrs['description'] = 'The uncorrected electrical conductivity measured by the Atlas Scientific K 1.0 probe.'\n", + " ds['conductivity'].attrs['fill_value'] = 'NaN'\n", + "\n", + " return ds\n", + " \n", + "\n", + "\n", + "def process_data(ds: xr.Dataset, atmospheric_pressure: str or float = 'infer', latitude: float = 45.000, longitude: float = -125.000) -> xr.Dataset:\n", + " \"\"\"\n", + " Process data to get more advanced data products. \n", + " \n", + " TODO:\n", + " Seek out bad data.\n", + " Apply gross range test.\n", + " Apply global range test\n", + " \n", + " :param ds: The xarray dataset generated from the import_file funcrtion.\n", + " :param atmospheric_pressure: If 'infer', the minimum pressure value is used as a reference. \n", + " Otherwise, a float value can be supplied in millibars. Typical would be 1013.25 millibars.\n", + " :param latitude: The latitude where the profile was taken.\n", + " :param longitude: The longitude the profile was taken.\n", + " :return: An xarray dataset containing more advanced products.\n", + " \"\"\"\n", + " if atmospheric_pressure == 'infer':\n", + " atmospheric_pressure = np.nanmin(ds.pressure)\n", + " ds['sea_water_pressure'] = (ds.pressure - atmospheric_pressure)/100\n", + " ds['sea_water_pressure'].attrs['units'] = 'decibar'\n", + " ds['sea_water_pressure'].attrs['units_tex'] = 'dbar'\n", + " ds['sea_water_pressure'].attrs['description'] = 'The pressure of sea water (seawater = absolute - atmospheric).'\n", + " ds['sea_water_pressure'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_pressure'].attrs['ancillary_variables'] = 'pressure'\n", + "\n", + " \n", + " ds['depth'] = (['time'], gsw.z_from_p(np.array(ds['sea_water_pressure']), latitude) * -1)\n", + " ds['depth'].attrs['units'] = 'meters'\n", + " ds['depth'].attrs['units_tex'] = 'm'\n", + " ds['depth'].attrs['description'] = 'The depth of the sample.'\n", + " ds['depth'].attrs['fill_value'] = 'NaN'\n", + " ds['depth'].attrs['ancillary_variables'] = 'sea_water_pressure, latitude'\n", + "\n", + "\n", + " ds['sea_water_electrical_conductivity'] = ds.conductivity/1000\n", + " ds['sea_water_electrical_conductivity'].attrs['units'] = 'milli siemens per centimeter'\n", + " ds['sea_water_electrical_conductivity'].attrs['units_tex'] = r'$\\frac{mS}{cm}$'\n", + " ds['sea_water_electrical_conductivity'].attrs['description'] = 'The uncorrected electrical conductivity of seawater.'\n", + " ds['sea_water_electrical_conductivity'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_electrical_conductivity'].attrs['ancillary_variables'] = 'conductivity'\n", + " \n", + " \n", + " ds['sea_water_temperature'] = (['time'], np.nanmean([ds.temp_a,ds.temp_b, ds.temp_c], axis = 0))\n", + " ds['sea_water_temperature'].attrs['units'] = 'degrees_celsius'\n", + " ds['sea_water_temperature'].attrs['units_tex'] = r'$^{\\circ}C$'\n", + " ds['sea_water_temperature'].attrs['description'] = 'The average temperature between the three OpenCTD thermistors.'\n", + " ds['sea_water_temperature'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_temperature'].attrs['ancillary_variables'] = 'temp_a, temp_b, temp_c'\n", + "\n", + "\n", + " ds['sea_water_practical_salinity'] = (['time'],np.array(gsw.SP_from_C(ds.sea_water_electrical_conductivity,\n", + " ds.sea_water_temperature,\n", + " ds.sea_water_pressure)))\n", + " ds['sea_water_practical_salinity'].attrs['units'] = 'practical salinity units'\n", + " ds['sea_water_practical_salinity'].attrs['units_tex'] = r'$PSU$'\n", + " ds['sea_water_practical_salinity'].attrs['description'] = 'Practical salinity is the measurement of salinity based on the PSS-78 scale.'\n", + " ds['sea_water_practical_salinity'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_practical_salinity'].attrs['ancillary_variables'] = 'sea_water_electrical_conductivity, sea_water_temperature, sea_water_pressure'\n", + "\n", + " \n", + " ds['sea_water_absolute_salinity'] = (['time'],np.array(gsw.SA_from_SP(ds.sea_water_practical_salinity,\n", + " ds.sea_water_pressure, longitude, latitude)))\n", + " ds['sea_water_absolute_salinity'].attrs['units'] = 'absolute salinity units'\n", + " ds['sea_water_absolute_salinity'].attrs['units_tex'] = r'$\\frac{g}{kg}$'\n", + " ds['sea_water_absolute_salinity'].attrs['description'] = 'Absolute salinity is the measurement of salinity based on the TEOS-10 scale.'\n", + " ds['sea_water_absolute_salinity'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_absolute_salinity'].attrs['ancillary_variables'] = 'sea_water_practical_salinity, sea_water_pressure, longitude, latitude'\n", + "\n", + " \n", + " ds['sea_water_conservative_temperature'] = (['time'],np.array(gsw.CT_from_t(ds.sea_water_absolute_salinity, \n", + " ds.sea_water_temperature,\n", + " ds.sea_water_pressure)))\n", + " ds['sea_water_conservative_temperature'].attrs['units'] = 'degrees_celsius'\n", + " ds['sea_water_conservative_temperature'].attrs['units_tex'] = r'$^{\\circ}C$'\n", + " ds['sea_water_conservative_temperature'].attrs['description'] = 'Conservative temperature is computed via TEOS-10 and is a representation of the heat content of the sea water sample.'\n", + " ds['sea_water_conservative_temperature'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_conservative_temperature'].attrs['ancillary_variables'] = 'sea_water_absolute_salinity, sea_water_temperature, sea_water_temperature'\n", + "\n", + " \n", + " ds['sea_water_density'] = (['time'],np.array(gsw.rho(ds.sea_water_absolute_salinity, \n", + " ds.sea_water_conservative_temperature, \n", + " ds.sea_water_pressure)))\n", + " ds['sea_water_density'].attrs['units'] = 'kilograms per cubic meter'\n", + " ds['sea_water_density'].attrs['units_tex'] = r'$\\frac{kg}{m^3}$'\n", + " ds['sea_water_density'].attrs['description'] = 'Sea water density is mass per volume of seawater.'\n", + " ds['sea_water_density'].attrs['fill_value'] = 'NaN'\n", + " ds['sea_water_density'].attrs['ancillary_variables'] = 'sea_water_absolute_salinity, sea_water_conservative_temperature, sea_water_pressure'\n", + "\n", + " return ds\n", + "\n", + "\n", + "\n", + "\n", + "def split_cast(ds: xr.Dataset) -> tuple:\n", + " \"\"\"\n", + " A hacked method for splitting a single profile into the up and down cast.\n", + " The maximum depth is used to separate the up and down casts by time.\n", + " \n", + " :param ds: A dataset created through the process_data function.\n", + " :return: A tuple of two xarray datasets.\n", + " \"\"\"\n", + " max_depth = ds.where(ds.depth == ds.depth.max(), drop = True)\n", + " downcast = ds.sel(time = slice(ds.time.min(),max_depth.time.values[0]))\n", + " upcast = ds.sel(time = slice(max_depth.time.values[0],ds.time.max()))\n", + " return (downcast, upcast)\n" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:13.696626600Z", + "start_time": "2024-01-01T22:00:13.676835Z" + } + }, + "id": "48464dabba95a854" + }, + { + "cell_type": "markdown", + "source": [ + "## Import and Process Data" + ], + "metadata": { + "collapsed": false + }, + "id": "bdf50e88fec06de7" + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [ + "ds = import_file(filepath, file_has_header = file_has_header)\n", + "ds = process_data(ds, atmospheric_pressure = atmospheric_pressure, \n", + " latitude = latitude, \n", + " longitude = longitude)\n", + "ds = ds.where(ds.depth >= 1, drop = True) # Remove upper meter of data.\n", + "down, up = split_cast(ds)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:13.728834Z", + "start_time": "2024-01-01T22:00:13.698134400Z" + } + }, + "id": "57987fbecd25069a" + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "\nDimensions: (time: 111)\nCoordinates:\n * time (time) datetime64[ns] 2022-06-01T17:0...\nData variables: (12/15)\n sensor_date (time) object '6/1/2022' ... '6/1/2022'\n sensor_time (time) object '17:01:48' ... '17:03:36'\n pressure (time) float64 1.132e+03 ... 6.464e+03\n temp_a (time) float64 11.63 11.63 ... 8.94 9.0\n temp_b (time) float64 10.69 10.69 ... 7.87 7.87\n temp_c (time) float64 10.56 10.56 ... 7.81 7.81\n ... ...\n sea_water_electrical_conductivity (time) float64 34.94 34.95 ... 33.33\n sea_water_temperature (time) float64 10.96 10.96 ... 8.227\n sea_water_practical_salinity (time) float64 30.97 30.98 ... 31.69\n sea_water_absolute_salinity (time) float64 31.12 31.13 ... 31.84\n sea_water_conservative_temperature (time) float64 11.03 11.03 ... 8.265\n sea_water_density (time) float64 1.024e+03 ... 1.025e+03", + "text/html": "
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
<xarray.Dataset>\nDimensions:                             (time: 111)\nCoordinates:\n  * time                                (time) datetime64[ns] 2022-06-01T17:0...\nData variables: (12/15)\n    sensor_date                         (time) object '6/1/2022' ... '6/1/2022'\n    sensor_time                         (time) object '17:01:48' ... '17:03:36'\n    pressure                            (time) float64 1.132e+03 ... 6.464e+03\n    temp_a                              (time) float64 11.63 11.63 ... 8.94 9.0\n    temp_b                              (time) float64 10.69 10.69 ... 7.87 7.87\n    temp_c                              (time) float64 10.56 10.56 ... 7.81 7.81\n    ...                                  ...\n    sea_water_electrical_conductivity   (time) float64 34.94 34.95 ... 33.33\n    sea_water_temperature               (time) float64 10.96 10.96 ... 8.227\n    sea_water_practical_salinity        (time) float64 30.97 30.98 ... 31.69\n    sea_water_absolute_salinity         (time) float64 31.12 31.13 ... 31.84\n    sea_water_conservative_temperature  (time) float64 11.03 11.03 ... 8.265\n    sea_water_density                   (time) float64 1.024e+03 ... 1.025e+03
" + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "down" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:13.785100200Z", + "start_time": "2024-01-01T22:00:13.729798800Z" + } + }, + "id": "fd4676d0828bd78a" + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [ + { + "data": { + "text/plain": "\nDimensions: (time: 89)\nCoordinates:\n * time (time) datetime64[ns] 2022-06-01T17:0...\nData variables: (12/15)\n sensor_date (time) object '6/1/2022' ... '6/1/2022'\n sensor_time (time) object '17:03:36' ... '17:05:02'\n pressure (time) float64 6.464e+03 ... 1.13e+03\n temp_a (time) float64 9.0 9.0 ... 11.25 11.31\n temp_b (time) float64 7.87 7.87 ... 10.38 10.38\n temp_c (time) float64 7.81 7.81 ... 10.13 10.19\n ... ...\n sea_water_electrical_conductivity (time) float64 33.33 33.33 ... 34.9\n sea_water_temperature (time) float64 8.227 8.227 ... 10.63\n sea_water_practical_salinity (time) float64 31.69 31.69 ... 31.21\n sea_water_absolute_salinity (time) float64 31.84 31.84 ... 31.36\n sea_water_conservative_temperature (time) float64 8.265 8.265 ... 10.69\n sea_water_density (time) float64 1.025e+03 ... 1.024e+03", + "text/html": "
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
<xarray.Dataset>\nDimensions:                             (time: 89)\nCoordinates:\n  * time                                (time) datetime64[ns] 2022-06-01T17:0...\nData variables: (12/15)\n    sensor_date                         (time) object '6/1/2022' ... '6/1/2022'\n    sensor_time                         (time) object '17:03:36' ... '17:05:02'\n    pressure                            (time) float64 6.464e+03 ... 1.13e+03\n    temp_a                              (time) float64 9.0 9.0 ... 11.25 11.31\n    temp_b                              (time) float64 7.87 7.87 ... 10.38 10.38\n    temp_c                              (time) float64 7.81 7.81 ... 10.13 10.19\n    ...                                  ...\n    sea_water_electrical_conductivity   (time) float64 33.33 33.33 ... 34.9\n    sea_water_temperature               (time) float64 8.227 8.227 ... 10.63\n    sea_water_practical_salinity        (time) float64 31.69 31.69 ... 31.21\n    sea_water_absolute_salinity         (time) float64 31.84 31.84 ... 31.36\n    sea_water_conservative_temperature  (time) float64 8.265 8.265 ... 10.69\n    sea_water_density                   (time) float64 1.025e+03 ... 1.024e+03
" + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "up" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:13.833673900Z", + "start_time": "2024-01-01T22:00:13.794648Z" + } + }, + "id": "f18b2b7269103bb" + }, + { + "cell_type": "markdown", + "source": [ + "## Plot Data" + ], + "metadata": { + "collapsed": false + }, + "id": "dee6f6b0083184f0" + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,3, figsize = (11,8.5), sharey = True)\n", + "ax[0].plot(down.sea_water_temperature, down.depth,label = 'Downcast', color = 'blue')\n", + "ax[0].plot(up.sea_water_temperature, up.depth,label = 'Upcast', color = 'red')\n", + "ax[0].legend(loc = 'upper left')\n", + "ax[0].set_title('Sea Water Temperature')\n", + "ax[0].set_xlabel(ds.sea_water_temperature.attrs['units_tex'])\n", + "\n", + "ax[1].plot(down.conductivity, down.depth,label = 'Downcast', color = 'blue')\n", + "ax[1].plot(up.conductivity, up.depth,label = 'Upcast', color = 'red')\n", + "ax[1].legend(loc = 'upper left')\n", + "ax[1].set_title('Raw Conductivity')\n", + "ax[1].set_xlabel(ds.conductivity.attrs['units_tex'])\n", + "\n", + "ax[2].plot(down.sea_water_practical_salinity, down.depth,label = 'Downcast', color = 'blue')\n", + "ax[2].plot(up.sea_water_practical_salinity, up.depth,label = 'Upcast', color = 'red')\n", + "ax[2].legend(loc = 'upper left')\n", + "ax[2].set_title('Sea Water Practical Salinity')\n", + "ax[2].set_xlabel(ds.sea_water_practical_salinity.attrs['units_tex'])\n", + "\n", + "\n", + "ax[-1].invert_yaxis()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:14.259675300Z", + "start_time": "2024-01-01T22:00:13.807220Z" + } + }, + "id": "c41bb674267bd816" + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-01-01T22:00:14.346701200Z", + "start_time": "2024-01-01T22:00:14.260617300Z" + } + }, + "id": "71c15899ff1b9023" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}