From 11136bc27d2042d47fcf997190a3e7773ea2ba01 Mon Sep 17 00:00:00 2001 From: Selwyn Heminway Date: Thu, 19 Jun 2025 10:05:48 -0700 Subject: [PATCH 1/2] linear_SCR - no beach lateral growth, only growing vertically --- aeolis/bed.py | 34 ++++++++++++++++++++++++++++++++++ aeolis/constants.py | 3 +++ aeolis/model.py | 3 +++ 3 files changed, 40 insertions(+) diff --git a/aeolis/bed.py b/aeolis/bed.py index 23b37a51..a21f7828 100644 --- a/aeolis/bed.py +++ b/aeolis/bed.py @@ -32,6 +32,7 @@ import aeolis.gridparams from matplotlib import pyplot as plt from numba import njit +import math # package modules from aeolis.utils import * @@ -230,6 +231,39 @@ def wet_bed_reset(s, p): return s +def linear_scr(s, p): + ''' Increase elevation of beach topography. + + Parameters + ---------- + s : dict + Spatial grids + p : dict + Model configuration parameters + + Returns + ------- + dict + Spatial grids + + ''' + + if p['process_linear_scr']: + xi = (s['zb']) < p['dune_toe_elevation'] + beach_z = s['zb'][xi] + beach_inc = p['sed_inc']*math.cos((math.pi/2)-math.atan(p['beach_slope'])) + vrate = (beach_inc*(1/365.25/24/3600))*p['dt'] #(m/timestep) + # print(scr) + # sed_inc = p['sed_inc'] + b = beach_z[0] + vrate + x = s['x'][xi] #print what xi looks like ==> add additional + slope = p['beach_slope'] + new_beach = slope*x + b #ADD (x+h) + s['zb'][xi] =new_beach + + # exit() + return s + def update(s, p): '''Update bathymetry and bed composition diff --git a/aeolis/constants.py b/aeolis/constants.py index 7575223e..527ac9e8 100644 --- a/aeolis/constants.py +++ b/aeolis/constants.py @@ -175,6 +175,7 @@ 'process_moist' : False, # Enable the process of moist 'process_mixtoplayer' : False, # Enable the process of mixing 'process_wet_bed_reset' : False, # Enable the process of bed-reset in the intertidal zone + 'process_linear_scr' : False, # Enable the process of linear shoreline change rate 'process_meteo' : False, # Enable the process of meteo 'process_salt' : False, # Enable the process of salt 'process_humidity' : False, # Enable the process of humidity @@ -342,6 +343,8 @@ 'rhoveg_max' : 0.5, #maximum vegetation density, only used in duran and moore 14 formulation 't_veg' : 3, #time scale of vegetation growth (days), only used in duran and moore 14 formulation 'v_gam' : 1, # only used in duran and moore 14 formulation + 'inc_sed' : 0, # Elevation added to beach during process sed supply (shoreline change rate rate m/hr) + } REQUIRED_CONFIG = ['nx', 'ny'] diff --git a/aeolis/model.py b/aeolis/model.py index cf8acd12..cd92343f 100644 --- a/aeolis/model.py +++ b/aeolis/model.py @@ -356,6 +356,9 @@ def update(self, dt:float=-1) -> None: # reset original bed in marine zone (wet) self.s = aeolis.bed.wet_bed_reset(self.s, self.p) + # beach growth + self.s = aeolis.bed.linear_scr(self.s, self.p) + # calculate average bed level change over time self.s = aeolis.bed.average_change(self.l, self.s, self.p) From a4e93824eb59bbcb71920bfb156f97b957416803 Mon Sep 17 00:00:00 2001 From: Selwyn Heminway Date: Tue, 22 Jul 2025 15:04:46 -0700 Subject: [PATCH 2/2] created function sediment_supply with methods 'wet_bed_reset', 'vertical_beach_growth', 'constant_SCR_constant_tanB', and 'constant_SCR_variable_tanB' with ability to track shoreline, dune toe elevation and beach slope --- aeolis/bed.py | 161 ++++++-- aeolis/constants.py | 13 +- aeolis/examples/README.md | 2 + aeolis/model.py | 8 +- run_aeolis.ipynb | 772 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 911 insertions(+), 45 deletions(-) create mode 100644 run_aeolis.ipynb diff --git a/aeolis/bed.py b/aeolis/bed.py index a21f7828..141f48a3 100644 --- a/aeolis/bed.py +++ b/aeolis/bed.py @@ -74,6 +74,12 @@ def initialize(s, p): s['zb0'][:,:] = p['bed_file'] s['zne'][:,:] = p['ne_file'] + #initialize variable shoreline, beach slope, dune toe elevation + s['zshore'][:,:] = p['zshoreline'] + s['xshore'][:,:] = p['xshoreline'] + s['beachslope'][:,:] = p['beach_slope'] + s['dte'][:,:] = p['dune_toe_elevation'] + #initialize thickness of erodable or dry top layer s['zdry'][:,:] = 0.05 @@ -126,7 +132,7 @@ def initialize(s, p): # initialize threshold if p['threshold_file'] is not None: s['uth'] = p['threshold_file'][:,:,np.newaxis].repeat(nf, axis=-1) - + return s @@ -198,40 +204,39 @@ def mixtoplayer(s, p): s['mass'][ix] = mass[ix] - return s -def wet_bed_reset(s, p): - ''' Reset wet bed to initial bed level if the total water level is above the bed level. +# def wet_bed_reset(s, p): **** Now part of def sediment_supply **** +# ''' Reset wet bed to initial bed level if the total water level is above the bed level. - Parameters - ---------- - s : dict - Spatial grids - p : dict - Model configuration parameters +# Parameters +# ---------- +# s : dict +# Spatial grids +# p : dict +# Model configuration parameters - Returns - ------- - dict - Spatial grids +# Returns +# ------- +# dict +# Spatial grids - ''' +# ''' - if p['process_wet_bed_reset']: +# if p['process_wet_bed_reset']: - Tbedreset = p['dt_opt'] / p['Tbedreset'] +# Tbedreset = p['dt_opt'] / p['Tbedreset'] - ix = s['TWL'] > (s['zb']) - s['zb'][ix] += (s['zb0'][ix] - s['zb'][ix]) * Tbedreset +# ix = s['TWL'] > (s['zb']) +# s['zb'][ix] += (s['zb0'][ix] - s['zb'][ix]) * Tbedreset - return s +# return s -def linear_scr(s, p): +def sediment_supply(s, p): ''' Increase elevation of beach topography. Parameters @@ -248,24 +253,105 @@ def linear_scr(s, p): ''' - if p['process_linear_scr']: - xi = (s['zb']) < p['dune_toe_elevation'] - beach_z = s['zb'][xi] - beach_inc = p['sed_inc']*math.cos((math.pi/2)-math.atan(p['beach_slope'])) - vrate = (beach_inc*(1/365.25/24/3600))*p['dt'] #(m/timestep) - # print(scr) - # sed_inc = p['sed_inc'] - b = beach_z[0] + vrate - x = s['x'][xi] #print what xi looks like ==> add additional - slope = p['beach_slope'] - new_beach = slope*x + b #ADD (x+h) - s['zb'][xi] =new_beach - - # exit() + if p['process_sediment_supply']: + + if p['method_sed_supply'] == 'wet_bed_reset': + Tbedreset = p['dt_opt'] / p['Tbedreset'] + + ix = s['TWL'] > (s['zb']) + s['zb'][ix] += (s['zb0'][ix] - s['zb'][ix]) * Tbedreset + + if p['method_sed_supply'] == 'vertical_beach_growth': + beach_inc = p['shoreline_change_rate']*math.cos((math.pi/2)-math.atan(p['beach_slope'])) + vrate = (beach_inc*(1/365.25/24/3600))*p['dt'] #(m/timestep) + s['zshore'] = s['zshore'] + vrate + + ny, nx = s['zb'].shape + + for iy in range(ny): + x_all = s['x'][iy,:] + zb_all = s['zb'][iy,:] + xi = (zb_all < p['dune_toe_elevation']) + beach_z = zb_all[xi] + b = beach_z[0] + vrate + x = x_all[xi] + slope = p['beach_slope'] + new_beach = slope*x + b + s['zb'][iy,xi] = new_beach + + if p['method_sed_supply'] == 'constant_SCR_constant_tanB': + + beach_inc = p['shoreline_change_rate']*math.cos((math.pi/2)-math.atan(p['beach_slope'])) + vrate = (beach_inc/(365.25*24*3600))*p['dt'] #(m/timestep) + ny, nx = s['zb'].shape + + for iy in range(ny): + + x_all = s['x'][iy,:] + zb_all = s['zb'][iy,:] + + xi = zb_all < p['dune_toe_elevation'] + beach_z = zb_all[xi] + s['dte'] = beach_z[-1] + + x = x_all[xi] + + xi3 = np.where(beach_z > p['zshoreline']) + xi3 = xi3[0][0] + b = beach_z[xi3] + vrate + + new_temp_beach = p['beach_slope']*(x-x[xi3]) + b + + xi2 = new_temp_beach <= np.min(zb_all) + new_temp_beach[xi2] = np.min(zb_all) + + s['zb'][iy,xi]= new_temp_beach + + if p['method_sed_supply'] == 'constant_SCR_variable_tanB': + beach_inc = p['shoreline_change_rate']*math.cos((math.pi/2)-math.atan(p['beach_slope'])) + vrate = (beach_inc/(365.25*24*3600))*p['dt'] #(m/timestep) + hrate = (p['shoreline_change_rate']/(365.25*24*3600))*p['dt'] #(m/timestep) + ny, nx = s['zb'].shape + + for iy in range(ny): + x_all = s['x'][iy,:] + zb_all = s['zb'][iy,:] + + xi = zb_all <= p['dune_toe_elevation'] + beach_z = zb_all[xi] + + s['dte'][iy,:] = beach_z[-1] + + x = x_all[xi] + + xi3 = np.where(beach_z > p['zshoreline']) + xi3 = xi3[0][0] + beach_x = x-x[xi3] + + xy1 = ((np.min(x[xi3])),np.min(beach_z[xi3])) + xy2 = (np.max(x), np.max(beach_z)) + + new_slope = (xy2[1]-xy1[1])/(xy2[0]-(xy1[0])) + s['beachslope'][iy,:] = new_slope + + b = np.min(beach_z[xi3]) + vrate + new_temp_beach = new_slope*(beach_x) + b + + xi2 = new_temp_beach <= np.min(zb_all) + new_temp_beach[xi2] = np.min(zb_all) + + xi4 = new_temp_beach > p['dune_toe_elevation'] + new_temp_beach[xi4] = p['dune_toe_elevation'] + + s['xshore'][iy,:] = s['xshore'][0][0] - hrate + s['zshore'][iy,:] = s['zshore'][0][0] + vrate + + s['zb'][iy,xi]= new_temp_beach return s def update(s, p): + '''Update bathymetry and bed composition Update bed composition by moving sediment fractions between bed @@ -380,7 +466,7 @@ def update(s, p): s['zb'] += dz if p['process_tide']: s['zs'] += dz #??? - + return s @@ -530,7 +616,6 @@ def average_change(l, s, p): if p['_time'] < p['avg_time']: s['dzbveg'] *= 0. - return s @njit @@ -569,5 +654,5 @@ def arrange_layers(m,dm,d,nl,ix_ero,ix_dep): m[ix_dep,-1,:] -= dm[ix_dep,:] * d[ix_dep,-1,:] return m - + diff --git a/aeolis/constants.py b/aeolis/constants.py index 527ac9e8..68002ee1 100644 --- a/aeolis/constants.py +++ b/aeolis/constants.py @@ -142,6 +142,10 @@ 'unST', # [NEW] [m/s] Component of the saltation velocity in y-direction for SedTRAILS 'u0', 'masstop', # [kg/m^2] Sediment mass in bed toplayer, only stored for output + 'zshore', + 'xshore', + 'dte', + 'beachslope', ), ('ny','nx','nlayers') : ( 'thlyr', # [m] Bed composition layer thickness @@ -174,8 +178,8 @@ 'process_runup' : False, # Enable the process of wave runup 'process_moist' : False, # Enable the process of moist 'process_mixtoplayer' : False, # Enable the process of mixing - 'process_wet_bed_reset' : False, # Enable the process of bed-reset in the intertidal zone - 'process_linear_scr' : False, # Enable the process of linear shoreline change rate + # 'process_wet_bed_reset' : False, # Enable the process of bed-reset in the intertidal zone + 'process_sediment_supply' : False, # Enable the process of linear shoreline change rate 'process_meteo' : False, # Enable the process of meteo 'process_salt' : False, # Enable the process of salt 'process_humidity' : False, # Enable the process of humidity @@ -343,7 +347,10 @@ 'rhoveg_max' : 0.5, #maximum vegetation density, only used in duran and moore 14 formulation 't_veg' : 3, #time scale of vegetation growth (days), only used in duran and moore 14 formulation 'v_gam' : 1, # only used in duran and moore 14 formulation - 'inc_sed' : 0, # Elevation added to beach during process sed supply (shoreline change rate rate m/hr) + 'method_sed_supply' :'pos_shoreline_change', # Name of method to comput sediment supply (pos_shoreline_change, wet_bed_reset) + 'shoreline_change_rate' : 0, # Elevation added to beach during process sed supply (shoreline change rate m/year) + 'zshoreline' :0, + 'xshoreline' :0 } diff --git a/aeolis/examples/README.md b/aeolis/examples/README.md index 58b5e422..d3d20324 100644 --- a/aeolis/examples/README.md +++ b/aeolis/examples/README.md @@ -69,7 +69,9 @@ vanWesten2024/parabolic +longterm_dune_growth - 1D 27-year simulation from Long Beach Penninsula, Washington, USA (LBP) +The beach-dune system on LBP has been rapidly prograding over the past three decades. This example uses the newly process_sediment_supply function in AeoLiS to hindcast almost 3 decades of dune evolution. diff --git a/aeolis/model.py b/aeolis/model.py index cd92343f..17a2bfa2 100644 --- a/aeolis/model.py +++ b/aeolis/model.py @@ -353,11 +353,11 @@ def update(self, dt:float=-1) -> None: self.s = aeolis.avalanching.angele_of_repose(self.s, self.p) self.s = aeolis.avalanching.avalanche(self.s, self.p) - # reset original bed in marine zone (wet) - self.s = aeolis.bed.wet_bed_reset(self.s, self.p) + # # reset original bed in marine zone (wet) + # self.s = aeolis.bed.wet_bed_reset(self.s, self.p) - # beach growth - self.s = aeolis.bed.linear_scr(self.s, self.p) + # either wet bed reset or positive shoreline change + self.s = aeolis.bed.sediment_supply(self.s, self.p) # calculate average bed level change over time self.s = aeolis.bed.average_change(self.l, self.s, self.p) diff --git a/run_aeolis.ipynb b/run_aeolis.ipynb new file mode 100644 index 00000000..db6aba3a --- /dev/null +++ b/run_aeolis.ipynb @@ -0,0 +1,772 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 64, + "id": "802fa541", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/server/pi/homes/heminwas/update_aeolis/prof38_moisture_on.txt\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "\n", + "sys.path.append(os.getcwd())\n", + "\n", + "aeolis_directory = r'/home/server/pi/homes/heminwas/update_aeolis/aeolis-python/aeolis'\n", + "\n", + "model_directory = r'/home/server/pi/homes/heminwas/update_aeolis'\n", + "\n", + "sys.path.append(aeolis_directory)\n", + "from console_debug import *\n", + "\n", + "scenario = 'prof38_moisture_on'\n", + "run = os.path.join(model_directory, scenario +str('.txt'))\n", + "print(run)\n", + "\n", + "# aeolis_debug(run)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "45c71c84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0003274013232945471\n", + "0.00032741925179567217\n" + ] + } + ], + "source": [ + "print(2.87/(365.25*24*3600) *3600)\n", + "print(2.87*(1/365.23/24/3600) *3600)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "e64c2ec5", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd \n", + "import numpy as np\n", + "import netCDF4 as nc\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "from datetime import datetime, timedelta\n", + "import mat4py as mt" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "b346be7b", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_netcdf(file, fig_folder):\n", + " \n", + " run = nc.Dataset(file, 'r')\n", + " # qs = run['qs'][:]\n", + " # q = run['q'][:]\n", + " # rhoveg = run['rhoveg'][:]\n", + " # hveg = run['hveg'][:]\n", + " # dhveg = run['hveg'][:]\n", + " # dzbveg = run['dzbveg'][:]\n", + " # pickup = run['pickup'][:]\n", + " time = run['time'][:]\n", + "\n", + " # TWL = run['TWL'][:]\n", + " try:\n", + " dte = run['dte'][:]\n", + " dte_clean =[]\n", + " for i in range(0, len(time)):\n", + " dte_clean.append(np.array(dte[i,0,0])[0])\n", + " except: \n", + " dte_clean = np.nan\n", + " try:\n", + " beach_slope = run['beachslope'][:]\n", + " bs_clean = []\n", + " for i in range(0, len(time)):\n", + " bs_clean.append(np.array(beach_slope[i,0,0])[0])\n", + " except:\n", + " bs_clean = np.nan\n", + " \n", + " try:\n", + " zshore = run['zshore'][:]\n", + " zshore_clean = []\n", + " for i in range(0, len(time)):\n", + " zshore_clean.append(np.array(zshore[i,0,0])[0])\n", + " except:\n", + " zshore_clean = np.nan\n", + " \n", + " try:\n", + " xshore = run['xshore'][:]\n", + " xshore_clean = []\n", + " for i in range(0, len(time)):\n", + " xshore_clean.append(np.array(xshore[i,0,0])[0])\n", + " except:\n", + " xshore_clean = np.nan\n", + " \n", + " x = run['x'][0,:] #baselineb['x'][1,:].values\n", + " zbi = run['zb'][0,0,:] # baselineb['zb'][0,1,:].values \n", + " zbf = run['zb'][-1,0,:]\n", + " zb_all = run['zb'][:,0,:]\n", + " \n", + " run.close()\n", + " \n", + " #dhveg_fig = plt.figure()\n", + " #for i in range(0,len(time)):\n", + " # plt.plot(x,dhveg[i,:])\n", + " \n", + " # prof_fig = plt.figure(figsize = (7,4))\n", + " # plt.plot(x, zbi, color = 'black', linestyle = '--', label = 'Initial Profile')\n", + " \n", + " # colors_arr = plt.cm.viridis(np.linspace(0, 1, len(time)))\n", + " \n", + " # offset = 186\n", + " # for i in range(0, len(time)):\n", + " # zb = run['zb'][i,0,:] #baselineb['zb'][i,1,:].values\n", + " # if time[i] == time[-1] or time[i] == time[0]:\n", + " # plt.plot(x, zb, color = colors_arr[i], label = time[i])\n", + " # else:\n", + " # plt.plot(x, zb, color = colors_arr[i])\n", + " start_time = datetime(1997, 9, 17, 0, 0)\n", + " dates = [start_time + timedelta(seconds = sec) for sec in time]\n", + " # aeolis_times_J = time\n", + " # aeolis_times = []\n", + " # for i in range(0, len(aeolis_times_J)):\n", + " # time = aeolis_times_J[i]\n", + " # standard_datetime = datetime(\n", + " # time.year, time.month, time.day,\n", + " # time.hour, time.minute, time.second)\n", + " # aeolis_times.append(standard_datetime)\n", + " \n", + " # plt.plot((field_zf.index-offset), field_zf[::-1], color = 'black', label = 'Final Field Profile')\n", + " # plt.legend()\n", + " # plt.ylim([0,10])\n", + " # plt.xlim([0, 435])\n", + " # plt.xlabel('Cross-shore Distance (m)')\n", + " # plt.ylabel('Elevation (m)')\n", + " # # os.chdir(fig_folder)\n", + " # plot_name = os.path.join(fig_folder,file[24:-3] + str('_fig.png'))\n", + " # plt.savefig(plot_name)\n", + " # plt.close()\n", + " \n", + " # final_plot = plt.figure(figsize = (7,4))\n", + " # plt.plot(x, zbi, color = 'black', linestyle = '--', label = 'Initial Profile')\n", + " # plt.plot(x, zbf, color = 'goldenrod', label = 'Final Modeled Profile')\n", + " # plt.plot((field_zf.index-offset), field_zf[::-1], color = 'black', label = 'Final Field Profile')\n", + " # plt.legend()\n", + " # plt.ylim([0,10])\n", + " # plt.xlim([0, 435])\n", + " # plt.xlabel('Cross-shore Distance (m)')\n", + " # plt.ylabel('Elevation (m)')\n", + " # # os.chdir(fig_folder)\n", + " # plot_name = os.path.join(fig_folder,file[24:-3] + str('_final_fig.png'))\n", + " # plt.savefig(plot_name)\n", + " # plt.close(\n", + " return x, zbi, zbf, zb_all, time, dates, dte_clean, bs_clean, xshore_clean, zshore_clean #qs, q, rhoveg, hveg, dhveg, dzbveg, pickup, TWL" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "9a4dc01e", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_aeolis(x, zb_all, time, field_zf, fig_folder, figname ):\n", + " colors_arr = plt.cm.viridis(np.linspace(0, 1, len(time)))\n", + "\n", + " fig = plt.figure(figsize = (8,5))\n", + " plt.plot(x,zb_all[0,:], color = 'k', linestyle = '--', label = 'Initial Profile')\n", + " for i in range(0, len(time)):\n", + " if i==0 or i == len(time)-1:\n", + " plt.plot(x, zb_all[i,:], color = colors_arr[i], label = dates[i])\n", + " else:\n", + " plt.plot(x, zb_all[i,:], color = colors_arr[i])\n", + " offset = 186\n", + " plt.plot(field_zf.index[::-1] - offset, field_zf, color = 'k', label = 'Final Field Profile')\n", + " # plt.plot(x, zbf, label = 'Final Profile')\n", + " plt.ylabel('Elevation (m)', fontsize = 14)\n", + " plt.xlabel('Cross-shore Distance (m)', fontsize = 14)\n", + " plt.legend(loc = 'upper left')\n", + " os.chdir(fig_folder)\n", + " plt.savefig(figname)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "960885f7", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "file = '/home/server/pi/homes/heminwas/Final_runs/Profile_38.mat'\n", + "line = mt.loadmat(file) \n", + "start_time = datetime.fromtimestamp(np.array(line['Dates_unix'])[0])\n", + "# field_xi = line['Morph_Data'][0].index()\n", + "field_zi = pd.Series(line['Morph_Data'][0])\n", + "field_zf = pd.Series(line['Morph_Data'][-1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84f658c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/server/pi/homes/heminwas/update_aeolis/figures\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# scenario = 'prof38_pos_SCR_ck'\n", + "\n", + "file = scenario +'.nc'\n", + "path = os.path.join(model_directory, file)\n", + "fig_folder = os.path.join(model_directory,'figures')\n", + "print(os.getcwd())\n", + "\n", + "x, zbi, zbf, zb_all, time, dates, dte, beach_slope = extract_netcdf(path,fig_folder) \n", + "fig1 = plot_aeolis(x, zb_all,time, field_zf, fig_folder, 'moisture_off_SCR_off.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "40868d7c", + "metadata": {}, + "outputs": [], + "source": [ + "def get_volume(elevation, seaward_x, landward_x):\n", + " \"\"\"\n", + " Determine volume under coastal profile between two points\n", + "\n", + " The volume of the coastal profile between a landward and seaward boundary \n", + " is determined by integrating over the surface beneath the coastal profile \n", + " between those two points. \n", + "\n", + " Parameters\n", + " ----------\n", + " elevation : np.array\n", + " np.array containing the elevation of the coastal profile in meters\n", + " seaward_x : float or int\n", + " Cross-shore seaward boundary\n", + " landward_x : float or int\n", + " Cross-shore landward boundary\n", + "\n", + " Returns\n", + " -------\n", + " float\n", + " volume: surface under the graph in m^2. Can be interpreted as m^3 by \n", + " assuming the profile is 1 m wide.\n", + "\n", + " Author: Christa van Ijzendorn\n", + " \"\"\"\n", + " # print(landward_x)\n", + " from scipy import integrate\n", + " if pd.isna(landward_x) == True: \n", + " # print('no landward_x value')\n", + " if pd.isnull(seaward_x) == True: # or pd.isnull(landward_x) == True:\n", + " volume = np.nan\n", + " raise ValueError('Seaward or Landward = null')\n", + " \n", + " else:\n", + " if elevation.iloc[1][0] > elevation.iloc[-1][0]:\n", + " # raise ValueError('1')\n", + " # Remove all elevation outside of boundaries\n", + " # drop everything seaward of seaward boundary\n", + " elevation = elevation.drop(\n", + " elevation.index[elevation.index > seaward_x]).interpolate()\n", + " # elevation2 = elevation.drop(elevation.index[elevation.index < landward_x]).interpolate() # drop everything landward of landward boundary and interpolate remaining data\n", + " elif elevation.iloc[0][0] < elevation.iloc[-1][0]:\n", + " # raise ValueError('2')\n", + " # drop everything seaward of seaward boundary\n", + " elevation = elevation.drop(\n", + " elevation.index[elevation.index < seaward_x]).interpolate()\n", + " # elevation2 = elevation.drop(elevation.index[elevation.index > landward_x]).interpolate()\n", + " if elevation.empty == False:\n", + " # raise ValueError('3')\n", + " volume_y = elevation - elevation.min()\n", + " volume_simps = integrate.simpson(\n", + " volume_y.values.transpose(), x=volume_y.index)\n", + " volume = volume_simps\n", + " else:\n", + " volume = np.nan\n", + " raise ValueError('Elevation is empty')\n", + " else:\n", + "\n", + " if pd.isnull(seaward_x) == True: # or pd.isnull(landward_x) == True:\n", + " volume = np.nan\n", + " raise ValueError('Seaward or Landward = null')\n", + " \n", + " else:\n", + " if elevation.iloc[1][0] > elevation.iloc[-1][0]:\n", + " # raise ValueError('1')\n", + " # Remove all elevation outside of boundaries\n", + " # drop everything seaward of seaward boundary\n", + " elevation = elevation.drop(\n", + " elevation.index[elevation.index > seaward_x]).interpolate()\n", + " elevation2 = elevation.drop(elevation.index[elevation.index < landward_x]).interpolate() # drop everything landward of landward boundary and interpolate remaining data\n", + " elif elevation.iloc[0][0] < elevation.iloc[-1][0]:\n", + " # raise ValueError('2')\n", + " # drop everything seaward of seaward boundary\n", + " elevation = elevation.drop(\n", + " elevation.index[elevation.index < seaward_x]).interpolate()\n", + " elevation2 = elevation.drop(elevation.index[elevation.index > landward_x]).interpolate()\n", + " if elevation.empty == False:\n", + " # raise ValueError('3')\n", + " volume_y = elevation2 - elevation2.min()\n", + " volume_simps = integrate.simpson(\n", + " volume_y.values.transpose(), x=volume_y.index)\n", + " volume = volume_simps\n", + " else:\n", + " volume = np.nan\n", + " raise ValueError('Elevation is empty')\n", + " # print(volume *0.1)\n", + " return volume\n", + "\n", + "vol_lim = 4\n", + "vol_overtime = []\n", + "\n", + "for i in range(0,len(dates)):\n", + " z = pd.DataFrame(zb_all[i,:])\n", + " seaward_x = np.where(abs(zb_all[i,:]-vol_lim) == min(abs(zb_all[i,:]-vol_lim)))[0][0]\n", + " vol = get_volume(z, seaward_x, np.nan)[0]\n", + " vol_overtime.append(vol)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "b83af235", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Time')" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.plot(dates, vol_overtime)\n", + "plt.ylabel('$\\Delta V_{\\t{dune}}$ ($m^3$/m/yr)')\n", + "plt.xlabel('Time')" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "9807dd60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/server/pi/homes/heminwas/update_aeolis/figures\n", + "-0.14466187357902527\n", + "/home/server/pi/homes/heminwas/update_aeolis/figures\n", + "/home/server/pi/homes/heminwas/update_aeolis/figures\n", + "/home/server/pi/homes/heminwas/update_aeolis/figures\n" + ] + } + ], + "source": [ + "#load wetbedreset \n", + "scen1 = 'prof38_wetbedreset_final'\n", + "file = scen1 +'.nc'\n", + "path = os.path.join(model_directory, file)\n", + "fig_folder = os.path.join(model_directory,'figures')\n", + "print(os.getcwd())\n", + "\n", + "x_wetbed, zbi, zbf, zb_all_wetbed, time, dates_wetbed, dte_wetbed, beach_slope_wetbed, xshore_wetbed, zshore_wetbed = extract_netcdf(path,fig_folder) \n", + "\n", + "vol_lim = 3\n", + "vol_wetbed = []\n", + "\n", + "for i in range(0,len(dates_wetbed)):\n", + " z = pd.DataFrame(zb_all_wetbed[i,:])\n", + " seaward_x = np.where(abs(zb_all_wetbed[i,:]-vol_lim) == min(abs(zb_all_wetbed[i,:]-vol_lim)))[0][0]\n", + " vol = get_volume(z, seaward_x, np.nan)[0]\n", + " vol_wetbed.append(vol)\n", + "print(np.min(zb_all_wetbed))\n", + "#load beach growth \n", + "scen2 = 'prof38_beach_growth'\n", + "file = scen2 +'.nc'\n", + "path = os.path.join(model_directory, file)\n", + "fig_folder = os.path.join(model_directory,'figures')\n", + "print(os.getcwd())\n", + "\n", + "x_bg, zbi, zbf, zb_all_bg, time, dates_bg, dte_bg, beach_slope_wetbed, xshore_bs, zshore_bs = extract_netcdf(path,fig_folder) \n", + "\n", + "vol_bg = []\n", + "\n", + "for i in range(0,len(dates_bg)):\n", + " z = pd.DataFrame(zb_all_bg[i,:])\n", + " seaward_x = np.where(abs(zb_all_bg[i,:]-vol_lim) == min(abs(zb_all_bg[i,:]-vol_lim)))[0][0]\n", + " vol = get_volume(z, seaward_x, np.nan)[0]\n", + " vol_bg.append(vol)\n", + "\n", + "#load shoreline change rate \n", + "scen3 = 'prof38_moisture_on_nooffshore'\n", + "file = scen3 +'.nc'\n", + "path = os.path.join(model_directory, file)\n", + "fig_folder = os.path.join(model_directory,'figures')\n", + "print(os.getcwd())\n", + "\n", + "x_scr, zbi, zbf, zb_all_scr, time, dates_scr, dte_scr, beach_slope_scr, xshore_scr, zshore_scr= extract_netcdf(path,fig_folder) \n", + "\n", + "vol_scr = []\n", + "\n", + "for i in range(0,len(dates_scr)):\n", + " z = pd.DataFrame(zb_all_scr[i,:])\n", + " seaward_x = np.where(abs(zb_all_scr[i,:]-vol_lim) == min(abs(zb_all_scr[i,:]-vol_lim)))[0][0]\n", + " vol = get_volume(z, seaward_x, np.nan)[0]\n", + " vol_scr.append(vol)\n", + "\n", + "#load time varying tanB \n", + "scen4 = 'prof38_constant_SCR_variable_tanB'\n", + "file = scen4 +'.nc'\n", + "path = os.path.join(model_directory, file)\n", + "fig_folder = os.path.join(model_directory,'figures')\n", + "print(os.getcwd())\n", + "\n", + "x_tanb, zbi, zbf, zb_all_tanb, time, dates_tanb, dte_tanb, beach_slope_tanb, xshore_tanb, zshore_tanb = extract_netcdf(path,fig_folder) \n", + "\n", + "vol_tanb = []\n", + "\n", + "for i in range(0,len(dates_tanb)):\n", + " z = pd.DataFrame(zb_all_tanb[i,:])\n", + " seaward_x = np.where(abs(zb_all_tanb[i,:]-vol_lim) == min(abs(zb_all_tanb[i,:]-vol_lim)))[0][0]\n", + " vol = get_volume(z, seaward_x, np.nan)[0]\n", + " vol_tanb.append(vol)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fca2ca9d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "nan" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "zshore_tanb" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "984babdd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#make schematic \n", + "fig, (ax1, ax2) = plt.subplots(1,2, figsize = (9,5),gridspec_kw={'width_ratios': [2, 1]})\n", + "ax1.plot(x, zb_all[0,:], linewidth = 2, linestyle = '--', color = 'k', label = '1997 Initial Profile')\n", + "ax1.plot(x_wetbed, zb_all_wetbed[-1,:], linewidth = 2, color = 'goldenrod', label = '2023 WetBedReset Profile')\n", + "ax1.plot(x_bg, zb_all_bg[-1,:], linewidth = 2, color = 'firebrick', label = '2023 VerticalBeachGrowth Profile')\n", + "ax1.plot(x_scr, zb_all_scr[-1,:], linewidth = 2, color = 'blue', label = '2023 PosShorelineChange Profile')\n", + "ax1.plot(x_tanb, zb_all_tanb[-1,:], linewidth = 2, color = 'green', label = '2023 Time Varying Beach Slope Profile')\n", + "\n", + "offset = 186\n", + "ax1.plot(field_zf.index[::-1] - offset, field_zf, color = 'k', label = '2023 Measured Profile')\n", + " # plt.plot(x, zbf, label = 'Final Profile')\n", + "ax1.set_ylabel('Elevation (m)', fontsize = 14)\n", + "ax1.set_xlabel('Cross-shore Distance (m)', fontsize = 14)\n", + "ax1.legend(loc = 'upper left')\n", + "\n", + "ax2.plot(dates_wetbed, vol_wetbed, linewidth = 2)\n", + "ax2.plot(dates_bg, vol_bg, linewidth = 2)\n", + "ax2.plot(dates_scr, vol_scr, linewidth = 2)\n", + "ax2.plot(dates_tanb, vol_tanb, linewidth = 2)\n", + "ax2.set_ylabel('$\\Delta V_{\\t{dune}}$ ($m^3$/m/yr)')\n", + "ax2.set_xlabel('Time')\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "id": "51c22fff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 9496. 10957. 12418. 13879. 15340. 16801. 18262. 19723.]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot(ax, x, zb_all, time, xticks, yticks,title):\n", + " colors_arr = plt.cm.viridis(np.linspace(0, 1, len(time)))\n", + " ax.grid()\n", + " ax.set_title(title, fontsize = 13, fontweight = 'bold')\n", + " ax.plot(x,zb_all[0,:], color = 'k', linestyle = '--', label = 'Initial Profile')\n", + " for i in range(0, len(time)):\n", + " if i==0 or i == len(time)-1:\n", + " ax.plot(x, zb_all[i,:], color = colors_arr[i], label = dates[i])\n", + " else:\n", + " ax.plot(x, zb_all[i,:], color = colors_arr[i])\n", + " offset = 186\n", + " ax.plot(field_zf.index[::-1] - offset, field_zf, color = 'k', label = 'Final Field Profile')\n", + " if xticks == 0:\n", + " ax.set_xticks(ax.get_xticks(),[])\n", + " else:\n", + " ax.set_xlabel('Cross-shore Distance (m)')\n", + " if yticks == 0:\n", + " ax.set_yticks(ax.get_yticks(),[])\n", + " else:\n", + " ax.set_ylabel('Elevation (m)')\n", + " ax.set_ylim([-1,9])\n", + " ax.set_xlim([-100,450])\n", + "\n", + "cmap = plt.cm.tab20c\n", + "\n", + "layout = '''\n", + "aabb\n", + "ccdd\n", + "efgh\n", + "iiii'''\n", + "\n", + "font_size = 13\n", + "\n", + "schem_fig, axes= plt.subplot_mosaic(layout, figsize = (12,10))\n", + "\n", + "for i, (key, ax) in enumerate(axes.items()):\n", + " # Tick size\n", + " ax.tick_params(axis='both', labelsize=font_size)\n", + "\n", + " # Axis label size\n", + " if key not in ['a','b']:\n", + " ax.set_xlabel(\"X Label\", fontsize=font_size)\n", + " if key not in ['b','d']:\n", + " ax.set_ylabel(\"Y Label\", fontsize=font_size)\n", + "\n", + " # Add (a), (b), ... in top-left corner of each subplot\n", + " ax.text(\n", + " 0.02, 0.95, str(key),\n", + " transform=ax.transAxes,\n", + " fontsize=font_size,\n", + " fontweight='bold',\n", + " va='top',\n", + " ha='left'\n", + " )\n", + "\n", + "plot(axes['a'], x_wetbed, zb_all_wetbed, time, 0,1, 'wet_bed_reset')\n", + "plot(axes['b'], x_scr, zb_all_scr,time, 0,0, 'constant_SCR_constant_tanB')\n", + "plot(axes['c'], x_bg, zb_all_bg, time, 1,1, 'vertical_beach_growth')\n", + "plot(axes['d'], x_tanb, zb_all_tanb, time, 1,0, 'constant_SCR_variable_tanB')\n", + "\n", + "axes['e'].plot(dates, np.zeros(len(dates)), color = cmap(0), linewidth = 3, label = 'wet_bed_reset')\n", + "axes['e'].plot(dates, np.zeros(len(dates)), color = cmap(4), linewidth = 1, label = 'vertical_beach_growth')\n", + "axes['e'].plot(dates, xshore_tanb, color = cmap(8), linewidth = 3, label = 'constant_SCR_constant_tanB')\n", + "axes['e'].plot(dates, xshore_tanb, color = cmap(12), linewidth = 1, label = 'constant_SCR_variable_tanB')\n", + "axes['e'].set_ylabel('Shoreline Cross-shore \\n Location (m)')\n", + "axes['e'].set_xlabel('Time')\n", + "print(axes['e'].get_xticks())\n", + "axes['e'].set_xticks(axes['e'].get_xticks(),['','2000', '', '2008', '', '2016', '' , '2024']) \n", + "\n", + "axes['f'].plot(dates, np.zeros(len(dates)), color = cmap(0), linewidth = 2, label = 'wet_bed_reset')\n", + "axes['f'].plot(dates, zshore_tanb, color = cmap(4), linewidth = 3, label = 'vertical_beach_growth')\n", + "axes['f'].plot(dates, zshore_tanb, color = cmap(8), linewidth = 2, label = 'constant_SCR_constant_tanB')\n", + "axes['f'].plot(dates, zshore_tanb, color = cmap(12), linewidth = 1, label = 'constant_SCR_variable_tanB')\n", + "axes['f'].set_ylabel('Shoreline \\nElevation (m)')\n", + "axes['f'].set_xlabel('Time')\n", + "axes['f'].set_xticks(axes['f'].get_xticks(),['','2000', '', '2008', '', '2016', '' , '2024']) \n", + "\n", + "dune_toe_elevation = 4.4\n", + "axes['g'].plot(dates, np.ones(len(dates))*dune_toe_elevation, color = cmap(4), linewidth = 3, label = 'vertical_beach_growth')\n", + "axes['g'].plot(dates, np.ones(len(dates))*dune_toe_elevation, color = cmap(8), linewidth = 1, label = 'constant_SCR_constant_tanB')\n", + "axes['g'].plot(dates, dte_tanb, color = cmap(12), linewidth = 2, label = 'constant_SCR_variable_tanB')\n", + "axes['g'].set_ylabel('Dune Toe Elevation (m)')\n", + "axes['g'].set_xlabel('Time')\n", + "axes['g'].set_xticks(axes['g'].get_xticks(),['','2000', '', '2008', '', '2016', '' , '2024']) \n", + "\n", + "beach_slope = 0.0156\n", + "axes['h'].plot(dates, np.ones(len(dates))*beach_slope, color = cmap(4), linewidth = 3, label = 'vertical_beach_growth')\n", + "axes['h'].plot(dates, np.ones(len(dates))*beach_slope, color = cmap(8), linewidth = 1, label = 'constant_SCR_constant_tanB')\n", + "axes['h'].plot(dates, beach_slope_tanb, color = cmap(12), linewidth = 2, label = 'constant_SCR_variable_tanB')\n", + "axes['h'].set_ylabel('Beach Slope (m/m)')\n", + "axes['h'].set_xlabel('Time')\n", + "axes['h'].set_xticks(axes['h'].get_xticks(),['','2000', '', '2008', '', '2016', '' , '2024'])\n", + "\n", + "axes['i'].grid()\n", + "axes['i'].plot(dates, vol_wetbed, color = cmap(0), linewidth=2, label = 'wet_bed_reset')\n", + "axes['i'].plot(dates, vol_bg, color = cmap(4), linewidth =2, label = 'vertical_beach_growth')\n", + "axes['i'].plot(dates, vol_scr, color = cmap(8), linewidth = 2, label = 'constant_SCR_constant_tanB')\n", + "axes['i'].plot(dates, vol_tanb, color = cmap(12), linewidth = 2, label = 'constant_SCR_variable_tanB')\n", + "axes['i'].set_ylabel('$\\Delta V_{\\t{dune}}$ ($m^3$/m/yr)')\n", + "axes['i'].set_xlabel('Time')\n", + "axes['i'].set_ylim([425,825])\n", + "axes['i'].legend(loc = 'lower right',ncol = 2, fontsize = 13)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.savefig('aeolis_sed_supply.png', dpi = 600)" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "id": "6caf380e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import matplotlib.colors as mcolors\n", + "\n", + "# Create a dummy scalar mappable to generate the colorbar\n", + "cmap = plt.cm.viridis\n", + "norm = mcolors.Normalize(vmin=1997, vmax=2023)\n", + "\n", + "fig, ax = plt.subplots(figsize=(1, 6)) # Tall narrow figure for vertical bar\n", + "# fig.subplots_adjust(right=0.5) # Shrink to leave space for colorbar\n", + "\n", + "# Hide the main axes (not needed)\n", + "ax.axis('off')\n", + "\n", + "# Add vertical colorbar\n", + "cbar = fig.colorbar(\n", + " plt.cm.ScalarMappable(norm=norm, cmap=cmap),\n", + " ax=ax,\n", + " orientation='vertical',\n", + " shrink=1\n", + ")\n", + "\n", + "# Format tick labels as integers (years)\n", + "cbar.set_ticks(np.linspace(1997, 2023, 6)) # e.g., 1997, 2002, 2008, ...\n", + "cbar.ax.set_yticklabels([f\"{int(year)}\" for year in np.linspace(1997, 2023, 6)])\n", + "\n", + "# Add label\n", + "cbar.set_label('Date', rotation=270, labelpad=15)\n", + "\n", + "plt.show()\n", + "\n", + "plt.savefig('colorbar.png', dpi = 600)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aeolis_py310", + "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.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}