From bbad9ff0ca65a55c78f6f6ad4d62ff95a4aea489 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Thu, 31 Oct 2024 10:52:11 +0100 Subject: [PATCH 01/15] Added a function to compute vertical velocity using centered first difference derivative --- glidertest/tools.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/glidertest/tools.py b/glidertest/tools.py index fcc8ab6..7092e83 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -15,6 +15,33 @@ import cartopy.crs as ccrs import cartopy.feature as cfeature +def calculate_vertical_velocity(pressure, time): + """ + Calculate the vertical velocity of a glider using changes in pressure with time. + + Parameters: + pressure (array-like): Array of pressure measurements. + time (array-like): Array of time measurements corresponding to the pressure measurements. + + Returns: + vertical_velocity (array-like): Array of calculated vertical velocities. + """ + # Ensure inputs are numpy arrays + pressure = np.array(pressure) + time = np.array(time).astype('datetime64[s]').astype('float64') + + # Calculate the centered differences in pressure and time + delta_pressure = (pressure[2:] - pressure[:-2]) / 2 + delta_time = (time[2:] - time[:-2]) / 2 + + # Calculate vertical velocity (rate of change of pressure with time) + vertical_velocity = delta_pressure / delta_time + + # Pad the result to match the original array length + vertical_velocity = - np.pad(vertical_velocity, (1, 1), 'edge') + + return vertical_velocity + def grid2d(x, y, v, xi=1, yi=1): """ Function to grid data From 5d8729dbd46e97d72304629edde89a0c87139b9c Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 06:48:05 +0100 Subject: [PATCH 02/15] Added functions to calculate seawater velocity (calc_seawater_w) and to calculate glider vertical speed from dzdt. Created a diagnostic plot (plot_vertical_speeds_with_histograms) --- glidertest/tools.py | 195 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 167 insertions(+), 28 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index 7092e83..bdbfb0f 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -15,33 +15,6 @@ import cartopy.crs as ccrs import cartopy.feature as cfeature -def calculate_vertical_velocity(pressure, time): - """ - Calculate the vertical velocity of a glider using changes in pressure with time. - - Parameters: - pressure (array-like): Array of pressure measurements. - time (array-like): Array of time measurements corresponding to the pressure measurements. - - Returns: - vertical_velocity (array-like): Array of calculated vertical velocities. - """ - # Ensure inputs are numpy arrays - pressure = np.array(pressure) - time = np.array(time).astype('datetime64[s]').astype('float64') - - # Calculate the centered differences in pressure and time - delta_pressure = (pressure[2:] - pressure[:-2]) / 2 - delta_time = (time[2:] - time[:-2]) / 2 - - # Calculate vertical velocity (rate of change of pressure with time) - vertical_velocity = delta_pressure / delta_time - - # Pad the result to match the original array length - vertical_velocity = - np.pad(vertical_velocity, (1, 1), 'edge') - - return vertical_velocity - def grid2d(x, y, v, xi=1, yi=1): """ Function to grid data @@ -844,4 +817,170 @@ def plot_ts_histograms(ds: xr.Dataset, ax: plt.Axes = None, **kw: dict) -> tuple ax[2].contour(xi, yi, zi, colors='black', alpha=0.5, linewidths=0.5) ax[2].clabel(ax[2].contour(xi, yi, zi, colors='black', alpha=0.5, linewidths=0.5), inline=True, fontsize=10) - return fig, ax \ No newline at end of file + return fig, ax + + +def calc_glider_w_from_depth(ds): + """ + Calculate the vertical velocity of a glider using changes in pressure with time. + + Parameters: + pressure (array-like): Array of pressure measurements. + time (array-like): Array of time measurements corresponding to the pressure measurements. + + Returns: + vertical_velocity (array-like): Array of calculated vertical velocities. + """ + # Ensure inputs are numpy arrays + depth = ds.DEPTH.values + time = ds.TIME.values + + # Calculate the centered differences in pressure and time, i.e. instead of using neighboring points, + # use the points two steps away. This has a couple of advantages: one being a slight smoothing of the + # differences, and the other that the calculated speed will be the speed at the midpoint of the two + # points. + # For data which are evenly spaced in time, this will be equivalent to a centered difference. + # For data which are not evenly spaced in time, i.e. when a Seaglider sample rate changes from 5 + # seconds to 10 seconds, there may be some uneven weighting of the differences. + delta_z_meters = (depth[2:] - depth[:-2]) + delta_time_datetime64ns = (time[2:] - time[:-2]) + delta_time_sec = delta_time_datetime64ns / np.timedelta64(1, 's') # Convert to seconds + + # Calculate vertical velocity (rate of change of pressure with time) + vertical_velocity = delta_z_meters / delta_time_sec + + # Pad the result to match the original array length + vertical_velocity = - np.pad(vertical_velocity, (1, 1), 'edge') + + # Convert vertical velocity from m/s to cm/s + vertical_velocity = vertical_velocity * 100 + + # Add vertical velocity to the dataset + ds = ds.assign(VERT_SPEED_DZDT=(('N_MEASUREMENTS'), vertical_velocity)) + + return ds + +def calc_seawater_w(ds): + """ + Calculate the vertical seawater velocity and add it to the dataset. + + Parameters: + ds (xarray.Dataset): Dataset containing 'VERT_GLIDER_SPEED' and 'VERT_SPEED_DZDT'. + + Returns: + ds (xarray.Dataset): Dataset with the new variable 'VERT_SW_SPEED'. + + Eleanor's note: This could be bundled with calculate_glider_w_from_pressure, but keeping them separate allows for some extra testing/flexibility for the user. + """ + # Check if 'VERT_GLIDER_SPEED' is in the dataset + if 'VERT_GLIDER_SPEED' not in ds: + print("Error: 'VERT_GLIDER_SPEED' is not in the dataset.") + return ds + + # Calculate the vertical seawater velocity + vert_sw_speed = ds['VERT_SPEED_DZDT'].values - ds['VERT_GLIDER_SPEED'].values + + # Add vertical seawater velocity to the dataset as a data variable + ds = ds.assign(VERT_SW_SPEED=(('N_MEASUREMENTS'), vert_sw_speed)) + return ds + + +def plot_vertical_speeds_with_histograms(ds, start_prof=0, end_prof=-1): + """ + Plot vertical speeds with histograms for diagnostic purposes. + This function generates a diagnostic plot for the calculation of vertical seawater velocity. + It plots the modelled and computed (from dz/dt) vertical velocities as line plots, where these + should be similar. The difference between these velocities is the implied seawater velocity, + which should be closer to zero than the vehicle velocities. The histogram provides a visual + representation to identify any biases. The final calculation of the median should be close to + zero if a large enough sample of dives is input and if the glider flight model is well-tuned. + Parameters: + ds (xarray.Dataset): The dataset containing the vertical speed data where + - VERT_GLIDER_SPEED is the modelled glider speed + - VERT_SPEED_DZDT is the computed glider speed from the pressure sensor + - VERT_SW_SPEED is the implied seawater velocity. + start_prof (int, optional): The starting profile number for subsetting the dataset. Defaults to 0. + end_prof (int, optional): The ending profile number for subsetting the dataset. Defaults to -1. + Returns: + None + """ + required_vars = ['VERT_GLIDER_SPEED', 'VERT_SPEED_DZDT', 'VERT_SW_SPEED'] + for var in required_vars: + if var not in ds: + print(f"Dataset must contain '{var}' to create this plot.") + return + + if start_prof is not None and end_prof is not None: + # Subset the dataset for the given profile range + ds = ds.where((ds['PROFILE_NUMBER'] >= start_prof) & (ds['PROFILE_NUMBER'] <= end_prof), drop=True) + + fig, axs = plt.subplots(2, 2, figsize=(14, 12), gridspec_kw={'width_ratios': [3, 1]}) + + # Upper left subplot for vertical velocity and glider speed + ax1 = axs[0, 0] + ax1.plot(ds['TIME'], ds['VERT_SPEED_DZDT'], label='Vertical Velocity (from dz/dt)') + ax1.set_xlabel('Time') + ax1.set_ylabel('Vertical Velocity (cm/s)') + ax1.legend(loc='upper left') + + ax1_twin = ax1.twinx() + ax1_twin.plot(ds['TIME'], ds['VERT_GLIDER_SPEED'], color='r', label='Vertical Glider Speed (model)') + ax1_twin.set_ylabel('Vertical Glider Speed (cm/s)') + ax1_twin.legend(loc='upper right') + + ax1_twin.plot(ds['TIME'], ds['VERT_SW_SPEED'], color='k', label='Vertical Water Speed (calculated)') + ax1_twin.legend(loc='lower right') + + # Upper right subplot for histogram of vertical velocity + ax1_hist = axs[0, 1] + ax1_hist.hist(ds['VERT_SPEED_DZDT'], bins=50, orientation='horizontal', alpha=0.5, color='blue', label='Vertical Velocity (from dz/dt)') + ax1_hist.hist(ds['VERT_GLIDER_SPEED'], bins=50, orientation='horizontal', alpha=0.5, color='red', label='Vertical Glider Speed (model)') + ax1_hist.hist(ds['VERT_SW_SPEED'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') + ax1_hist.set_xlabel('Frequency') + ax1_hist.set_yticklabels([]) + + # Determine the best location for the legend based on the y-axis limits and zero + y_upper_limit = ax1_hist.get_ylim()[1] + y_lower_limit = ax1_hist.get_ylim()[0] + + if abs(y_upper_limit) > abs(y_lower_limit): + legend_loc = 'upper right' + else: + legend_loc = 'lower right' + + ax1_hist.legend(loc=legend_loc) + + # Lower left subplot for vertical water speed + ax2 = axs[1, 0] + ax2.axhline(0, color='darkgray', linestyle='-', linewidth=0.5) # Add zero horizontal line + ax2.plot(ds['TIME'], ds['VERT_SW_SPEED'], label='Vertical Water Speed') + ax2.set_xlabel('Time') + ax2.set_ylabel('Vertical Water Speed (cm/s)') + ax2.legend(loc='upper left') + + # Lower right subplot for histogram of vertical water speed + ax2_hist = axs[1, 1] + ax2_hist.hist(ds['VERT_SW_SPEED'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') + ax2_hist.set_xlabel('Frequency') + ax2_hist.set_yticklabels([]) + + # Calculate and plot the median line + median_vert_sw_speed = np.nanmedian(ds['VERT_SW_SPEED']) + ax2_hist.axhline(median_vert_sw_speed, color='red', linestyle='dashed', linewidth=1, label=f'Median: {median_vert_sw_speed:.2f} cm/s') + + # Determine the best location for the legend based on the y-axis limits and median + y_upper_limit = ax2_hist.get_ylim()[1] + y_lower_limit = ax2_hist.get_ylim()[0] + median_vert_sw_speed = np.nanmedian(ds['VERT_SW_SPEED']) + + if abs(y_upper_limit - median_vert_sw_speed) > abs(y_lower_limit - median_vert_sw_speed): + legend_loc = 'upper right' + else: + legend_loc = 'lower right' + + ax2_hist.legend(loc=legend_loc) + + plt.tight_layout() + plt.show() + + return fig, axs \ No newline at end of file From 049d3b440e2395a505a1acb630db966a0b58fb95 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 06:48:23 +0100 Subject: [PATCH 03/15] New cell to check vertical velocity --- notebooks/demo.ipynb | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb index 427032a..3d2ff53 100644 --- a/notebooks/demo.ipynb +++ b/notebooks/demo.ipynb @@ -21,7 +21,7 @@ { "cell_type": "code", "execution_count": null, - "id": "fc10d805", + "id": "51929278", "metadata": {}, "outputs": [], "source": [ @@ -50,7 +50,7 @@ "metadata": {}, "outputs": [], "source": [ - "ds = fetchers.load_sample_dataset()" + "ds = fetchers.load_sample_dataset()\n" ] }, { @@ -67,6 +67,32 @@ "cell_type": "markdown", "id": "6b93a2ef", "metadata": {}, + "source": [ + "### Vertical velocity" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02264a97", + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate vertical seawater velocity \n", + "\n", + "# First, calculate the vertical speed of the glider from the depth data\n", + "ds = tools.calc_glider_w_from_depth(ds)\n", + "\n", + "# Next, calculate the vertical seawater speed by differencing the DZDT data and the modelled vertical glider speed\n", + "ds = tools.calc_seawater_w(ds)\n", + "\n", + "tools.plot_vertical_speeds_with_histograms(ds,3,10)" + ] + }, + { + "cell_type": "markdown", + "id": "d22b9ca5", + "metadata": {}, "source": [ "# Basic statistics of dataset" ] From 249de5d5b2fb831107b757fff9a5599758d8158b Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 08:55:33 +0100 Subject: [PATCH 04/15] Updated default values for start_prof and end_prof --- glidertest/tools.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index bdbfb0f..a49fdaf 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -885,7 +885,7 @@ def calc_seawater_w(ds): return ds -def plot_vertical_speeds_with_histograms(ds, start_prof=0, end_prof=-1): +def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): """ Plot vertical speeds with histograms for diagnostic purposes. This function generates a diagnostic plot for the calculation of vertical seawater velocity. @@ -914,6 +914,12 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=0, end_prof=-1): # Subset the dataset for the given profile range ds = ds.where((ds['PROFILE_NUMBER'] >= start_prof) & (ds['PROFILE_NUMBER'] <= end_prof), drop=True) + if start_prof is None: + start_prof = ds['PROFILE_NUMBER'].values.min() + + if end_prof is None: + end_prof = ds['PROFILE_NUMBER'].values.max() + fig, axs = plt.subplots(2, 2, figsize=(14, 12), gridspec_kw={'width_ratios': [3, 1]}) # Upper left subplot for vertical velocity and glider speed @@ -983,4 +989,6 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=0, end_prof=-1): plt.tight_layout() plt.show() - return fig, axs \ No newline at end of file + return fig, axs + + From 942687b4e0284963ca6973236891c7aa7477b7c7 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 08:56:13 +0100 Subject: [PATCH 05/15] Updated inputs for plot_vertical_speeds_with_histograms --- glidertest/tools.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index a49fdaf..e00b37f 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -918,7 +918,7 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): start_prof = ds['PROFILE_NUMBER'].values.min() if end_prof is None: - end_prof = ds['PROFILE_NUMBER'].values.max() + end_prof = ds['PROFILE_NUMBER'].values.max() fig, axs = plt.subplots(2, 2, figsize=(14, 12), gridspec_kw={'width_ratios': [3, 1]}) From 17be5c22afa182ed622ac4fd449bdddce12ebb8d Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 09:09:18 +0100 Subject: [PATCH 06/15] Fixed docstring on calc_glider_w_from_depth and calc_seawater_w, and formatting on plot_vertical_speeds_with_histograms docstring --- glidertest/tools.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index e00b37f..638782e 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -825,9 +825,10 @@ def calc_glider_w_from_depth(ds): Calculate the vertical velocity of a glider using changes in pressure with time. Parameters: - pressure (array-like): Array of pressure measurements. - time (array-like): Array of time measurements corresponding to the pressure measurements. - + ds (xarray.Dataset): Dataset containing 'DEPTH' and 'TIME'. + - DEPTH (array-like): Array of depth measurements + - TIME (array-like): Array of time stamps + Returns: vertical_velocity (array-like): Array of calculated vertical velocities. """ From a1e55979dc5214573bc732a2f57df3f8f760419b Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 09:10:26 +0100 Subject: [PATCH 07/15] Might have failed to save before committing --- glidertest/tools.py | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index 638782e..b042abd 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -824,13 +824,16 @@ def calc_glider_w_from_depth(ds): """ Calculate the vertical velocity of a glider using changes in pressure with time. - Parameters: + Parameters + ---------- ds (xarray.Dataset): Dataset containing 'DEPTH' and 'TIME'. - DEPTH (array-like): Array of depth measurements - TIME (array-like): Array of time stamps - Returns: - vertical_velocity (array-like): Array of calculated vertical velocities. + Returns + ------- + ds (xarray.Dataset): Containing the new variable + - VERT_SPEED_DZDT (array-like): with vertical velocities calculated from dz/dt """ # Ensure inputs are numpy arrays depth = ds.DEPTH.values @@ -865,13 +868,15 @@ def calc_seawater_w(ds): """ Calculate the vertical seawater velocity and add it to the dataset. - Parameters: + Parameters + ---------- ds (xarray.Dataset): Dataset containing 'VERT_GLIDER_SPEED' and 'VERT_SPEED_DZDT'. - Returns: - ds (xarray.Dataset): Dataset with the new variable 'VERT_SW_SPEED'. + Returns + ------- + ds (xarray.Dataset): Dataset with the new variable 'VERT_SW_SPEED', which is the inferred vertical seawater velocity. - Eleanor's note: This could be bundled with calculate_glider_w_from_pressure, but keeping them separate allows for some extra testing/flexibility for the user. + Eleanor's note: This could be bundled with calc_glider_w_from_depth, but keeping them separate allows for some extra testing/flexibility for the user. """ # Check if 'VERT_GLIDER_SPEED' is in the dataset if 'VERT_GLIDER_SPEED' not in ds: @@ -895,15 +900,19 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): which should be closer to zero than the vehicle velocities. The histogram provides a visual representation to identify any biases. The final calculation of the median should be close to zero if a large enough sample of dives is input and if the glider flight model is well-tuned. - Parameters: + + Parameters + ---------- ds (xarray.Dataset): The dataset containing the vertical speed data where - VERT_GLIDER_SPEED is the modelled glider speed - VERT_SPEED_DZDT is the computed glider speed from the pressure sensor - VERT_SW_SPEED is the implied seawater velocity. - start_prof (int, optional): The starting profile number for subsetting the dataset. Defaults to 0. - end_prof (int, optional): The ending profile number for subsetting the dataset. Defaults to -1. - Returns: - None + start_prof (int, optional): The starting profile number for subsetting the dataset. Defaults to first profile number. + end_prof (int, optional): The ending profile number for subsetting the dataset. Defaults to last profile number. + + Returns + ------- + fig, axs (tuple): The figure and axes objects for the plot. """ required_vars = ['VERT_GLIDER_SPEED', 'VERT_SPEED_DZDT', 'VERT_SW_SPEED'] for var in required_vars: From 4d254d1bb92c0a4323944a7435fff39eca58535c Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 09:11:37 +0100 Subject: [PATCH 08/15] Shouldn't be any changes in demo.ipynb --- notebooks/demo.ipynb | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb index 3d2ff53..9e2a6da 100644 --- a/notebooks/demo.ipynb +++ b/notebooks/demo.ipynb @@ -21,10 +21,11 @@ { "cell_type": "code", "execution_count": null, - "id": "51929278", + "id": "23dfc3fb", "metadata": {}, "outputs": [], "source": [ + "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from glidertest import fetchers\n", @@ -50,7 +51,7 @@ "metadata": {}, "outputs": [], "source": [ - "ds = fetchers.load_sample_dataset()\n" + "ds = fetchers.load_sample_dataset()" ] }, { @@ -79,14 +80,14 @@ "outputs": [], "source": [ "# Calculate vertical seawater velocity \n", - "\n", "# First, calculate the vertical speed of the glider from the depth data\n", "ds = tools.calc_glider_w_from_depth(ds)\n", "\n", "# Next, calculate the vertical seawater speed by differencing the DZDT data and the modelled vertical glider speed\n", "ds = tools.calc_seawater_w(ds)\n", "\n", - "tools.plot_vertical_speeds_with_histograms(ds,3,10)" + "tools.plot_vertical_speeds_with_histograms(ds)\n", + "\n" ] }, { From d6148f50a6490fbd561aaef564211de4df156f2d Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 15:16:23 +0100 Subject: [PATCH 09/15] Assign long_name to GLIDER_VERT_VELO_DZDT and VERT_CURR --- glidertest/tools.py | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index b042abd..0ef1666 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -833,10 +833,10 @@ def calc_glider_w_from_depth(ds): Returns ------- ds (xarray.Dataset): Containing the new variable - - VERT_SPEED_DZDT (array-like): with vertical velocities calculated from dz/dt + - GLIDER_VERT_VELO_DZDT (array-like): with vertical velocities calculated from dz/dt """ # Ensure inputs are numpy arrays - depth = ds.DEPTH.values + depth = ds.DEPTH_Z.values time = ds.TIME.values # Calculate the centered differences in pressure and time, i.e. instead of using neighboring points, @@ -854,13 +854,13 @@ def calc_glider_w_from_depth(ds): vertical_velocity = delta_z_meters / delta_time_sec # Pad the result to match the original array length - vertical_velocity = - np.pad(vertical_velocity, (1, 1), 'edge') + vertical_velocity = np.pad(vertical_velocity, (1, 1), 'edge') - # Convert vertical velocity from m/s to cm/s - vertical_velocity = vertical_velocity * 100 + # No - Convert vertical velocity from m/s to cm/s + vertical_velocity = vertical_velocity # Add vertical velocity to the dataset - ds = ds.assign(VERT_SPEED_DZDT=(('N_MEASUREMENTS'), vertical_velocity)) + ds = ds.assign(GLIDER_VERT_VELO_DZDT=(('N_MEASUREMENTS'), vertical_velocity, {'long_name': 'glider_vertical_speed_from_pressure', 'units': 'm s-1'})) return ds @@ -879,15 +879,15 @@ def calc_seawater_w(ds): Eleanor's note: This could be bundled with calc_glider_w_from_depth, but keeping them separate allows for some extra testing/flexibility for the user. """ # Check if 'VERT_GLIDER_SPEED' is in the dataset - if 'VERT_GLIDER_SPEED' not in ds: - print("Error: 'VERT_GLIDER_SPEED' is not in the dataset.") + if 'GLIDER_VERT_VELO_MODEL' not in ds: + print("Error: 'GLIDER_VERT_VELO_MODEL' is not in the dataset.") return ds # Calculate the vertical seawater velocity - vert_sw_speed = ds['VERT_SPEED_DZDT'].values - ds['VERT_GLIDER_SPEED'].values + vert_sw_speed = ds['GLIDER_VERT_VELO_DZDT'].values - ds['GLIDER_VERT_VELO_MODEL'].values # Add vertical seawater velocity to the dataset as a data variable - ds = ds.assign(VERT_SW_SPEED=(('N_MEASUREMENTS'), vert_sw_speed)) + ds = ds.assign(VERT_CURR=(('N_MEASUREMENTS'), vert_sw_speed), {'long_name': 'vertical_currents_from_glider_flight_model', 'units': 'm s-1'}) return ds @@ -914,7 +914,7 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): ------- fig, axs (tuple): The figure and axes objects for the plot. """ - required_vars = ['VERT_GLIDER_SPEED', 'VERT_SPEED_DZDT', 'VERT_SW_SPEED'] + required_vars = ['GLIDER_VERT_VELO_MODEL', 'GLIDER_VERT_VELO_DZDT', 'VERT_CURR'] for var in required_vars: if var not in ds: print(f"Dataset must contain '{var}' to create this plot.") @@ -934,24 +934,24 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): # Upper left subplot for vertical velocity and glider speed ax1 = axs[0, 0] - ax1.plot(ds['TIME'], ds['VERT_SPEED_DZDT'], label='Vertical Velocity (from dz/dt)') + ax1.plot(ds['TIME'], ds['GLIDER_VERT_VELO_DZDT'], label='Vertical Velocity (from dz/dt)') ax1.set_xlabel('Time') ax1.set_ylabel('Vertical Velocity (cm/s)') ax1.legend(loc='upper left') ax1_twin = ax1.twinx() - ax1_twin.plot(ds['TIME'], ds['VERT_GLIDER_SPEED'], color='r', label='Vertical Glider Speed (model)') + ax1_twin.plot(ds['TIME'], ds['GLIDER_VERT_VELO_MODEL'], color='r', label='Vertical Glider Speed (model)') ax1_twin.set_ylabel('Vertical Glider Speed (cm/s)') ax1_twin.legend(loc='upper right') - ax1_twin.plot(ds['TIME'], ds['VERT_SW_SPEED'], color='k', label='Vertical Water Speed (calculated)') + ax1_twin.plot(ds['TIME'], ds['VERT_CURR'], color='k', label='Vertical Water Speed (calculated)') ax1_twin.legend(loc='lower right') # Upper right subplot for histogram of vertical velocity ax1_hist = axs[0, 1] - ax1_hist.hist(ds['VERT_SPEED_DZDT'], bins=50, orientation='horizontal', alpha=0.5, color='blue', label='Vertical Velocity (from dz/dt)') - ax1_hist.hist(ds['VERT_GLIDER_SPEED'], bins=50, orientation='horizontal', alpha=0.5, color='red', label='Vertical Glider Speed (model)') - ax1_hist.hist(ds['VERT_SW_SPEED'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') + ax1_hist.hist(ds['GLIDER_VERT_VELO_DZDT'], bins=50, orientation='horizontal', alpha=0.5, color='blue', label='Vertical Velocity (from dz/dt)') + ax1_hist.hist(ds['GLIDER_VERT_VELO_MODEL'], bins=50, orientation='horizontal', alpha=0.5, color='red', label='Vertical Glider Speed (model)') + ax1_hist.hist(ds['VERT_CURR'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') ax1_hist.set_xlabel('Frequency') ax1_hist.set_yticklabels([]) @@ -969,25 +969,25 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): # Lower left subplot for vertical water speed ax2 = axs[1, 0] ax2.axhline(0, color='darkgray', linestyle='-', linewidth=0.5) # Add zero horizontal line - ax2.plot(ds['TIME'], ds['VERT_SW_SPEED'], label='Vertical Water Speed') + ax2.plot(ds['TIME'], ds['VERT_CURR'], label='Vertical Water Speed') ax2.set_xlabel('Time') ax2.set_ylabel('Vertical Water Speed (cm/s)') ax2.legend(loc='upper left') # Lower right subplot for histogram of vertical water speed ax2_hist = axs[1, 1] - ax2_hist.hist(ds['VERT_SW_SPEED'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') + ax2_hist.hist(ds['VERT_CURR'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') ax2_hist.set_xlabel('Frequency') ax2_hist.set_yticklabels([]) # Calculate and plot the median line - median_vert_sw_speed = np.nanmedian(ds['VERT_SW_SPEED']) + median_vert_sw_speed = np.nanmedian(ds['VERT_CURR']) ax2_hist.axhline(median_vert_sw_speed, color='red', linestyle='dashed', linewidth=1, label=f'Median: {median_vert_sw_speed:.2f} cm/s') # Determine the best location for the legend based on the y-axis limits and median y_upper_limit = ax2_hist.get_ylim()[1] y_lower_limit = ax2_hist.get_ylim()[0] - median_vert_sw_speed = np.nanmedian(ds['VERT_SW_SPEED']) + median_vert_sw_speed = np.nanmedian(ds['VERT_CURR']) if abs(y_upper_limit - median_vert_sw_speed) > abs(y_lower_limit - median_vert_sw_speed): legend_loc = 'upper right' From a1a3cfc9a25e5e7e958322bbeba41d4855b0584f Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 15:23:46 +0100 Subject: [PATCH 10/15] Correction in plot_ts_histograms (sal -> SA and temp->CT in *_filtered) --- glidertest/tools.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index 0ef1666..5fbe4a6 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -782,8 +782,8 @@ def plot_ts_histograms(ds: xr.Dataset, ax: plt.Axes = None, **kw: dict) -> tuple CT = gsw.CT_from_t(SA, temp, depth) # Reduce to middle 95% of values - temp_filtered = CT[(CT >= np.nanpercentile(temp, 2.5)) & (CT <= np.nanpercentile(CT, 97.5))] - sal_filtered = SA[(SA >= np.nanpercentile(sal, 2.5)) & (SA <= np.nanpercentile(sal, 97.5))] + temp_filtered = CT[(CT >= np.nanpercentile(CT, 2.5)) & (CT <= np.nanpercentile(CT, 97.5))] + sal_filtered = SA[(SA >= np.nanpercentile(SA, 2.5)) & (SA <= np.nanpercentile(SA, 97.5))] ax[0].hist(temp_filtered, bins=50, **kw) ax[0].set_xlabel('Conservative Temperature (°C)') @@ -887,7 +887,7 @@ def calc_seawater_w(ds): vert_sw_speed = ds['GLIDER_VERT_VELO_DZDT'].values - ds['GLIDER_VERT_VELO_MODEL'].values # Add vertical seawater velocity to the dataset as a data variable - ds = ds.assign(VERT_CURR=(('N_MEASUREMENTS'), vert_sw_speed), {'long_name': 'vertical_currents_from_glider_flight_model', 'units': 'm s-1'}) + ds = ds.assign(VERT_CURR=(('N_MEASUREMENTS'), vert_sw_speed, {'long_name': 'vertical_currents_from_glider_flight_model', 'units': 'm s-1'})) return ds From 7cc3a2975d1f0d3d4c310f7604f09967adaefba9 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 15:24:40 +0100 Subject: [PATCH 11/15] Shouldn't be changed --- notebooks/demo.ipynb | 596 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 586 insertions(+), 10 deletions(-) diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb index 9e2a6da..d1a210b 100644 --- a/notebooks/demo.ipynb +++ b/notebooks/demo.ipynb @@ -25,7 +25,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from glidertest import fetchers\n", @@ -56,10 +55,483 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "8ca89b5a-37aa-43db-97a4-d25a8a140a30", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                 (N_MEASUREMENTS: 2446)\n",
+       "Coordinates:\n",
+       "    dive_num                (N_MEASUREMENTS) float64 ...\n",
+       "    LONGITUDE               (N_MEASUREMENTS) float64 ...\n",
+       "    LATITUDE                (N_MEASUREMENTS) float64 ...\n",
+       "    TIME                    (N_MEASUREMENTS) datetime64[ns] ...\n",
+       "    DEPTH                   (N_MEASUREMENTS) float64 ...\n",
+       "Dimensions without coordinates: N_MEASUREMENTS\n",
+       "Data variables: (12/20)\n",
+       "    POTDENS0                (N_MEASUREMENTS) float64 ...\n",
+       "    HEADING                 (N_MEASUREMENTS) float64 ...\n",
+       "    ROLL                    (N_MEASUREMENTS) float64 ...\n",
+       "    PITCH                   (N_MEASUREMENTS) float64 ...\n",
+       "    GLIDER_VERT_VELO_MODEL  (N_MEASUREMENTS) float64 ...\n",
+       "    GLIDE_ANGLE             (N_MEASUREMENTS) float64 ...\n",
+       "    ...                      ...\n",
+       "    TEMP                    (N_MEASUREMENTS) float64 ...\n",
+       "    dive_num_cast           (N_MEASUREMENTS) float64 ...\n",
+       "    PROFILE_NUMBER          (N_MEASUREMENTS) float64 ...\n",
+       "    PHASE                   (N_MEASUREMENTS) float64 ...\n",
+       "    PHASE_QC                (N_MEASUREMENTS) int64 ...\n",
+       "    DEPTH_Z                 (N_MEASUREMENTS) float64 ...\n",
+       "Attributes: (12/44)\n",
+       "    title:                                      OceanGliders trajectory file\n",
+       "    platform:                                   sub-surface gliders\n",
+       "    platform_vocabulary:                        https://vocab.nerc.ac.uk/coll...\n",
+       "    id:                                         SG015_20050213T230253_delayed\n",
+       "    naming_authority:                           edu.washington.apl\n",
+       "    institution:                                School of Oceanography\\nUnive...\n",
+       "    ...                                         ...\n",
+       "    contributing_institutions_vocabulary:       https://edmo.seadatanet.org/r...\n",
+       "    contributing_institutions_role:             Operator, Data scientist\n",
+       "    contributing_institutions_role_vocabulary:  http://vocab.nerc.ac.uk/colle...\n",
+       "    uri_comment:                                UUID\n",
+       "    landstation_version:                        3707.7999999523163\n",
+       "    glider_firmware_version:                    66.05
" + ], + "text/plain": [ + "\n", + "Dimensions: (N_MEASUREMENTS: 2446)\n", + "Coordinates:\n", + " dive_num (N_MEASUREMENTS) float64 ...\n", + " LONGITUDE (N_MEASUREMENTS) float64 ...\n", + " LATITUDE (N_MEASUREMENTS) float64 ...\n", + " TIME (N_MEASUREMENTS) datetime64[ns] ...\n", + " DEPTH (N_MEASUREMENTS) float64 ...\n", + "Dimensions without coordinates: N_MEASUREMENTS\n", + "Data variables: (12/20)\n", + " POTDENS0 (N_MEASUREMENTS) float64 ...\n", + " HEADING (N_MEASUREMENTS) float64 ...\n", + " ROLL (N_MEASUREMENTS) float64 ...\n", + " PITCH (N_MEASUREMENTS) float64 ...\n", + " GLIDER_VERT_VELO_MODEL (N_MEASUREMENTS) float64 ...\n", + " GLIDE_ANGLE (N_MEASUREMENTS) float64 ...\n", + " ... ...\n", + " TEMP (N_MEASUREMENTS) float64 ...\n", + " dive_num_cast (N_MEASUREMENTS) float64 ...\n", + " PROFILE_NUMBER (N_MEASUREMENTS) float64 ...\n", + " PHASE (N_MEASUREMENTS) float64 ...\n", + " PHASE_QC (N_MEASUREMENTS) int64 ...\n", + " DEPTH_Z (N_MEASUREMENTS) float64 ...\n", + "Attributes: (12/44)\n", + " title: OceanGliders trajectory file\n", + " platform: sub-surface gliders\n", + " platform_vocabulary: https://vocab.nerc.ac.uk/coll...\n", + " id: SG015_20050213T230253_delayed\n", + " naming_authority: edu.washington.apl\n", + " institution: School of Oceanography\\nUnive...\n", + " ... ...\n", + " contributing_institutions_vocabulary: https://edmo.seadatanet.org/r...\n", + " contributing_institutions_role: Operator, Data scientist\n", + " contributing_institutions_role_vocabulary: http://vocab.nerc.ac.uk/colle...\n", + " uri_comment: UUID\n", + " landstation_version: 3707.7999999523163\n", + " glider_firmware_version: 66.05" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds" ] @@ -77,7 +549,32 @@ "execution_count": null, "id": "02264a97", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
,\n", + " array([[,\n", + " ],\n", + " [,\n", + " ]], dtype=object))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Calculate vertical seawater velocity \n", "# First, calculate the vertical speed of the glider from the depth data\n", @@ -100,10 +597,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "c6fd094f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eddifying/Cloudfree/gitlab-cloudfree/glidertest/glidertest/tools.py:655: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", + " cbar.ax.set_yticklabels([pd.to_datetime(t).strftime('%Y-%b-%d') for t in cbar.get_ticks()])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Basic plot of the location of the dataset in space/time\n", "tools.plot_glider_track(ds)" @@ -111,10 +638,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "620e5523", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ],\n", + " dtype=object))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Basic diagnostics of the gridding in the dataset\n", "tools.plot_grid_spacing_histograms(ds)" @@ -125,10 +676,35 @@ "execution_count": null, "id": "6bf7fb8d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " array([,\n", + " ,\n", + " ],\n", + " dtype=object))" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Basic diagnostics of the watermass properties\n", - "tools.plot_ts_histograms(ds)" + "tools.plot_ts_histograms(ds)\n" ] }, { From a609a27a080cbc18ba2b6714009e6ef95807feb2 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 15:30:10 +0100 Subject: [PATCH 12/15] Removed outputs --- glidertest/tools.py | 2 +- notebooks/demo.ipynb | 593 +------------------------------------------ 2 files changed, 9 insertions(+), 586 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index 5fbe4a6..e5f64b2 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -887,7 +887,7 @@ def calc_seawater_w(ds): vert_sw_speed = ds['GLIDER_VERT_VELO_DZDT'].values - ds['GLIDER_VERT_VELO_MODEL'].values # Add vertical seawater velocity to the dataset as a data variable - ds = ds.assign(VERT_CURR=(('N_MEASUREMENTS'), vert_sw_speed, {'long_name': 'vertical_currents_from_glider_flight_model', 'units': 'm s-1'})) + ds = ds.assign(VERT_CURR_FLIGHTMODEL=(('N_MEASUREMENTS'), vert_sw_speed, {'long_name': 'vertical_current_of_seawater_derived_from_glider_flight_model', 'units': 'm s-1'})) return ds diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb index d1a210b..68b074d 100644 --- a/notebooks/demo.ipynb +++ b/notebooks/demo.ipynb @@ -55,483 +55,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "8ca89b5a-37aa-43db-97a4-d25a8a140a30", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:                 (N_MEASUREMENTS: 2446)\n",
-       "Coordinates:\n",
-       "    dive_num                (N_MEASUREMENTS) float64 ...\n",
-       "    LONGITUDE               (N_MEASUREMENTS) float64 ...\n",
-       "    LATITUDE                (N_MEASUREMENTS) float64 ...\n",
-       "    TIME                    (N_MEASUREMENTS) datetime64[ns] ...\n",
-       "    DEPTH                   (N_MEASUREMENTS) float64 ...\n",
-       "Dimensions without coordinates: N_MEASUREMENTS\n",
-       "Data variables: (12/20)\n",
-       "    POTDENS0                (N_MEASUREMENTS) float64 ...\n",
-       "    HEADING                 (N_MEASUREMENTS) float64 ...\n",
-       "    ROLL                    (N_MEASUREMENTS) float64 ...\n",
-       "    PITCH                   (N_MEASUREMENTS) float64 ...\n",
-       "    GLIDER_VERT_VELO_MODEL  (N_MEASUREMENTS) float64 ...\n",
-       "    GLIDE_ANGLE             (N_MEASUREMENTS) float64 ...\n",
-       "    ...                      ...\n",
-       "    TEMP                    (N_MEASUREMENTS) float64 ...\n",
-       "    dive_num_cast           (N_MEASUREMENTS) float64 ...\n",
-       "    PROFILE_NUMBER          (N_MEASUREMENTS) float64 ...\n",
-       "    PHASE                   (N_MEASUREMENTS) float64 ...\n",
-       "    PHASE_QC                (N_MEASUREMENTS) int64 ...\n",
-       "    DEPTH_Z                 (N_MEASUREMENTS) float64 ...\n",
-       "Attributes: (12/44)\n",
-       "    title:                                      OceanGliders trajectory file\n",
-       "    platform:                                   sub-surface gliders\n",
-       "    platform_vocabulary:                        https://vocab.nerc.ac.uk/coll...\n",
-       "    id:                                         SG015_20050213T230253_delayed\n",
-       "    naming_authority:                           edu.washington.apl\n",
-       "    institution:                                School of Oceanography\\nUnive...\n",
-       "    ...                                         ...\n",
-       "    contributing_institutions_vocabulary:       https://edmo.seadatanet.org/r...\n",
-       "    contributing_institutions_role:             Operator, Data scientist\n",
-       "    contributing_institutions_role_vocabulary:  http://vocab.nerc.ac.uk/colle...\n",
-       "    uri_comment:                                UUID\n",
-       "    landstation_version:                        3707.7999999523163\n",
-       "    glider_firmware_version:                    66.05
" - ], - "text/plain": [ - "\n", - "Dimensions: (N_MEASUREMENTS: 2446)\n", - "Coordinates:\n", - " dive_num (N_MEASUREMENTS) float64 ...\n", - " LONGITUDE (N_MEASUREMENTS) float64 ...\n", - " LATITUDE (N_MEASUREMENTS) float64 ...\n", - " TIME (N_MEASUREMENTS) datetime64[ns] ...\n", - " DEPTH (N_MEASUREMENTS) float64 ...\n", - "Dimensions without coordinates: N_MEASUREMENTS\n", - "Data variables: (12/20)\n", - " POTDENS0 (N_MEASUREMENTS) float64 ...\n", - " HEADING (N_MEASUREMENTS) float64 ...\n", - " ROLL (N_MEASUREMENTS) float64 ...\n", - " PITCH (N_MEASUREMENTS) float64 ...\n", - " GLIDER_VERT_VELO_MODEL (N_MEASUREMENTS) float64 ...\n", - " GLIDE_ANGLE (N_MEASUREMENTS) float64 ...\n", - " ... ...\n", - " TEMP (N_MEASUREMENTS) float64 ...\n", - " dive_num_cast (N_MEASUREMENTS) float64 ...\n", - " PROFILE_NUMBER (N_MEASUREMENTS) float64 ...\n", - " PHASE (N_MEASUREMENTS) float64 ...\n", - " PHASE_QC (N_MEASUREMENTS) int64 ...\n", - " DEPTH_Z (N_MEASUREMENTS) float64 ...\n", - "Attributes: (12/44)\n", - " title: OceanGliders trajectory file\n", - " platform: sub-surface gliders\n", - " platform_vocabulary: https://vocab.nerc.ac.uk/coll...\n", - " id: SG015_20050213T230253_delayed\n", - " naming_authority: edu.washington.apl\n", - " institution: School of Oceanography\\nUnive...\n", - " ... ...\n", - " contributing_institutions_vocabulary: https://edmo.seadatanet.org/r...\n", - " contributing_institutions_role: Operator, Data scientist\n", - " contributing_institutions_role_vocabulary: http://vocab.nerc.ac.uk/colle...\n", - " uri_comment: UUID\n", - " landstation_version: 3707.7999999523163\n", - " glider_firmware_version: 66.05" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds" ] @@ -549,32 +76,7 @@ "execution_count": null, "id": "02264a97", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(
,\n", - " array([[,\n", - " ],\n", - " [,\n", - " ]], dtype=object))" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Calculate vertical seawater velocity \n", "# First, calculate the vertical speed of the glider from the depth data\n", @@ -597,40 +99,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "c6fd094f", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/eddifying/Cloudfree/gitlab-cloudfree/glidertest/glidertest/tools.py:655: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n", - " cbar.ax.set_yticklabels([pd.to_datetime(t).strftime('%Y-%b-%d') for t in cbar.get_ticks()])\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "(
,\n", - " )" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Basic plot of the location of the dataset in space/time\n", "tools.plot_glider_track(ds)" @@ -638,34 +110,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "620e5523", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " array([,\n", - " ],\n", - " dtype=object))" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Basic diagnostics of the gridding in the dataset\n", "tools.plot_grid_spacing_histograms(ds)" @@ -676,32 +124,7 @@ "execution_count": null, "id": "6bf7fb8d", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
,\n", - " array([,\n", - " ,\n", - " ],\n", - " dtype=object))" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Basic diagnostics of the watermass properties\n", "tools.plot_ts_histograms(ds)\n" From 49dd71112ce9e13fac19b7a3c060607b3c0ace68 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 16:44:04 +0100 Subject: [PATCH 13/15] Updated for new velocity variable names --- glidertest/tools.py | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index e5f64b2..b9cd97e 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -887,7 +887,7 @@ def calc_seawater_w(ds): vert_sw_speed = ds['GLIDER_VERT_VELO_DZDT'].values - ds['GLIDER_VERT_VELO_MODEL'].values # Add vertical seawater velocity to the dataset as a data variable - ds = ds.assign(VERT_CURR_FLIGHTMODEL=(('N_MEASUREMENTS'), vert_sw_speed, {'long_name': 'vertical_current_of_seawater_derived_from_glider_flight_model', 'units': 'm s-1'})) + ds = ds.assign(VERT_CURR_MODEL=(('N_MEASUREMENTS'), vert_sw_speed, {'long_name': 'vertical_current_of_seawater_derived_from_glider_flight_model', 'units': 'm s-1'})) return ds @@ -914,7 +914,7 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): ------- fig, axs (tuple): The figure and axes objects for the plot. """ - required_vars = ['GLIDER_VERT_VELO_MODEL', 'GLIDER_VERT_VELO_DZDT', 'VERT_CURR'] + required_vars = ['GLIDER_VERT_VELO_MODEL', 'GLIDER_VERT_VELO_DZDT', 'VERT_CURR_MODEL'] for var in required_vars: if var not in ds: print(f"Dataset must contain '{var}' to create this plot.") @@ -930,30 +930,35 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): if end_prof is None: end_prof = ds['PROFILE_NUMBER'].values.max() + vert_curr = ds.VERT_CURR_MODEL.values * 100 # Convert to cm/s + vert_dzdt = ds.GLIDER_VERT_VELO_DZDT.values * 100 # Convert to cm/s + vert_model = ds.GLIDER_VERT_VELO_MODEL.values * 100 # Convert to cm/s + + fig, axs = plt.subplots(2, 2, figsize=(14, 12), gridspec_kw={'width_ratios': [3, 1]}) # Upper left subplot for vertical velocity and glider speed ax1 = axs[0, 0] - ax1.plot(ds['TIME'], ds['GLIDER_VERT_VELO_DZDT'], label='Vertical Velocity (from dz/dt)') + ax1.plot(ds['TIME'], vert_dzdt, label='Vertical Velocity (from dz/dt)') ax1.set_xlabel('Time') ax1.set_ylabel('Vertical Velocity (cm/s)') - ax1.legend(loc='upper left') + ax1.legend(loc='lower left') ax1_twin = ax1.twinx() - ax1_twin.plot(ds['TIME'], ds['GLIDER_VERT_VELO_MODEL'], color='r', label='Vertical Glider Speed (model)') - ax1_twin.set_ylabel('Vertical Glider Speed (cm/s)') - ax1_twin.legend(loc='upper right') + ax1_twin.plot(ds['TIME'], vert_model, color='r', label='Vertical Glider Speed (model)') + ax1_twin.legend(loc='lower left') - ax1_twin.plot(ds['TIME'], ds['VERT_CURR'], color='k', label='Vertical Water Speed (calculated)') + ax1_twin.plot(ds['TIME'], vert_curr, color='g', label='Vertical Water Speed (calculated)') ax1_twin.legend(loc='lower right') + # Remove y-axis labels on the right + ax1_twin.set_yticklabels([]) # Upper right subplot for histogram of vertical velocity ax1_hist = axs[0, 1] - ax1_hist.hist(ds['GLIDER_VERT_VELO_DZDT'], bins=50, orientation='horizontal', alpha=0.5, color='blue', label='Vertical Velocity (from dz/dt)') - ax1_hist.hist(ds['GLIDER_VERT_VELO_MODEL'], bins=50, orientation='horizontal', alpha=0.5, color='red', label='Vertical Glider Speed (model)') - ax1_hist.hist(ds['VERT_CURR'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') + ax1_hist.hist(vert_dzdt, bins=50, orientation='horizontal', alpha=0.5, color='blue', label='Vertical Velocity (from dz/dt)') + ax1_hist.hist(vert_model, bins=50, orientation='horizontal', alpha=0.5, color='red', label='Vertical Glider Speed (model)') + ax1_hist.hist(vert_curr, bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') ax1_hist.set_xlabel('Frequency') - ax1_hist.set_yticklabels([]) # Determine the best location for the legend based on the y-axis limits and zero y_upper_limit = ax1_hist.get_ylim()[1] @@ -969,25 +974,24 @@ def plot_vertical_speeds_with_histograms(ds, start_prof=None, end_prof=None): # Lower left subplot for vertical water speed ax2 = axs[1, 0] ax2.axhline(0, color='darkgray', linestyle='-', linewidth=0.5) # Add zero horizontal line - ax2.plot(ds['TIME'], ds['VERT_CURR'], label='Vertical Water Speed') + ax2.plot(ds['TIME'], vert_curr, 'g', label='Vertical Water Speed') ax2.set_xlabel('Time') ax2.set_ylabel('Vertical Water Speed (cm/s)') ax2.legend(loc='upper left') # Lower right subplot for histogram of vertical water speed ax2_hist = axs[1, 1] - ax2_hist.hist(ds['VERT_CURR'], bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') + ax2_hist.hist(vert_curr, bins=50, orientation='horizontal', alpha=0.5, color='green', label='Vertical Water Speed (calculated)') ax2_hist.set_xlabel('Frequency') - ax2_hist.set_yticklabels([]) # Calculate and plot the median line - median_vert_sw_speed = np.nanmedian(ds['VERT_CURR']) + median_vert_sw_speed = np.nanmedian(vert_curr) ax2_hist.axhline(median_vert_sw_speed, color='red', linestyle='dashed', linewidth=1, label=f'Median: {median_vert_sw_speed:.2f} cm/s') # Determine the best location for the legend based on the y-axis limits and median y_upper_limit = ax2_hist.get_ylim()[1] y_lower_limit = ax2_hist.get_ylim()[0] - median_vert_sw_speed = np.nanmedian(ds['VERT_CURR']) + median_vert_sw_speed = np.nanmedian(vert_curr) if abs(y_upper_limit - median_vert_sw_speed) > abs(y_lower_limit - median_vert_sw_speed): legend_loc = 'upper right' From 6154c71f9af29b7e69e4fd98c5b7399230cd4f23 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 16:47:05 +0100 Subject: [PATCH 14/15] Added a function calc_DEPTH_Z if it's missing --- glidertest/tools.py | 36 +++++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index b9cd97e..05ad1af 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -819,6 +819,38 @@ def plot_ts_histograms(ds: xr.Dataset, ax: plt.Axes = None, **kw: dict) -> tuple return fig, ax +def calc_Z(ds): + """ + Calculate the depth (Z position) of the glider using the gsw library to convert pressure to depth. + + Parameters + ---------- + ds (xarray.Dataset): The input dataset containing 'PRES', 'LATITUDE', and 'LONGITUDE' variables. + + Returns + ------- + xarray.Dataset: The dataset with an additional 'DEPTH' variable. + """ + # Ensure the required variables are present + if 'PRES' not in ds.variables or 'LATITUDE' not in ds.variables or 'LONGITUDE' not in ds.variables: + raise ValueError("Dataset must contain 'PRES', 'LATITUDE', and 'LONGITUDE' variables.") + + # Initialize the new variable with the same dimensions as dive_num + ds['DEPTH_Z'] = (['N_MEASUREMENTS'], np.full(ds.dims['N_MEASUREMENTS'], np.nan)) + + # Calculate depth using gsw + depth = gsw.z_from_p(ds['PRES'], ds['LATITUDE']) + ds['DEPTH_Z'] = depth + + # Assign the calculated depth to a new variable in the dataset + ds['DEPTH_Z'].attrs = { + "units": "meters", + "positive": "up", + "standard_name": "depth", + "comment": "Depth calculated from pressure using gsw library, positive up.", + } + + return ds def calc_glider_w_from_depth(ds): """ @@ -836,8 +868,10 @@ def calc_glider_w_from_depth(ds): - GLIDER_VERT_VELO_DZDT (array-like): with vertical velocities calculated from dz/dt """ # Ensure inputs are numpy arrays - depth = ds.DEPTH_Z.values time = ds.TIME.values + if 'DEPTH_Z' not in ds.variables and all(var in ds.variables for var in ['PRES', 'LATITUDE', 'LONGITUDE']): + ds = calc_Z(ds) + depth = ds.DEPTH_Z.values # Calculate the centered differences in pressure and time, i.e. instead of using neighboring points, # use the points two steps away. This has a couple of advantages: one being a slight smoothing of the From 1490362abd9cf4c6b17d2590e4322807e0dd73c2 Mon Sep 17 00:00:00 2001 From: Eleanor Frajka-Williams Date: Fri, 1 Nov 2024 16:47:25 +0100 Subject: [PATCH 15/15] Named it calc_DEPTH_Z --- glidertest/tools.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/glidertest/tools.py b/glidertest/tools.py index 05ad1af..83c5040 100644 --- a/glidertest/tools.py +++ b/glidertest/tools.py @@ -819,7 +819,7 @@ def plot_ts_histograms(ds: xr.Dataset, ax: plt.Axes = None, **kw: dict) -> tuple return fig, ax -def calc_Z(ds): +def calc_DEPTH_Z(ds): """ Calculate the depth (Z position) of the glider using the gsw library to convert pressure to depth. @@ -829,7 +829,7 @@ def calc_Z(ds): Returns ------- - xarray.Dataset: The dataset with an additional 'DEPTH' variable. + xarray.Dataset: The dataset with an additional 'DEPTH_Z' variable. """ # Ensure the required variables are present if 'PRES' not in ds.variables or 'LATITUDE' not in ds.variables or 'LONGITUDE' not in ds.variables: @@ -870,7 +870,7 @@ def calc_glider_w_from_depth(ds): # Ensure inputs are numpy arrays time = ds.TIME.values if 'DEPTH_Z' not in ds.variables and all(var in ds.variables for var in ['PRES', 'LATITUDE', 'LONGITUDE']): - ds = calc_Z(ds) + ds = calc_DEPTH_Z(ds) depth = ds.DEPTH_Z.values # Calculate the centered differences in pressure and time, i.e. instead of using neighboring points,