{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Surface Water-Mass Transformation\n", "\n", "In this recipe, we compute surface water-mass transformation rates (both in the net and partitioned into contributions from heat and salt fluxes) for the southern ocean, south of 60S.\n", "\n", "This recipe is set up to run with MOM6 simulations. You should read the diagnostics in the `get_variables` function and add/remove according to your needs. Notice that a different set of diagnostics has to be used when adapting this code to run with MOM5 simulations. Directions on how to change the diagnostic fields to run the code with MOM5 simulations are under the *requirements section*.\n", "\n", "This code runs smoothly for *panant-01-zstar-ACCESSyr2* experiment, under the normal queue, with X-large memory settings. Finer resolutions might require more memory." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Defining surface water-mass transformation\n", "\n", "The surface water-mass transformation framework described here follows [Newsom *et al* (2016)](https://journals.ametsoc.org/doi/full/10.1175/JCLI-D-15-0513.1) and [Abernathey *et al* (2016)](https://www.nature.com/articles/ngeo2749). Surface water-mass transformation may be defined as the volume flux into a given density class ($\\sigma$) from lighter density classes ($\\sigma'<\\sigma$) due to surface buoyancy forcing. Integrated over a region of the ocean surface, this volume flux can be expressed as,\n", "\n", "$$\n", "\\begin{equation}\n", "\\Omega(\\sigma, t) = \\frac{\\partial}{\\partial\\sigma} \\iint_{\\sigma'<\\sigma} \\Big(\\frac{\\partial\\sigma}{\\partial\\theta} \\dot\\theta + \\frac{\\partial\\sigma}{\\partial S}\\dot S\\Big) \\, \\mathrm{d}x \\, \\mathrm{d}y\n", "\\end{equation}\n", "$$\n", "\n", "where $t$ is time, and the terms in the integrand are the potential temperature ($\\dot \\theta$) flux and salinity ($\\dot S$) flux components of the surface buoyancy flux. The linearity of this expression means we can extract the relative contributions of heat ($\\Omega_\\text{heat}$) and salinity ($\\Omega_\\text{fw}$) fluxes to surface water-mass transformation, highlighting driving mechanisms." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Requirements\n", "\n", "**Analysis environment:** The conda/analysis3-25.05 (or later) module on NCI. This is available via the `xp65` project.\n", "\n", "**Model diagnostics:** This notebook is set up to work with MOM6 simulations, and uses the folowing monthly diagnostics: \n", "\n", "\n", "| Variable| Diagnostic field | \n", "| --- | --- | \n", "| Temperature | `thetao` | \n", "| Salinity| `so` | \n", "| Water flux into ocean | `wfo` | \n", "| Salt flux| `salt_flux` | \n", "| Surface heat flux | `hfds` | \n", "| Surface area| `areacello` | \n", "| Ocean depth| `deptho` | \n", "\n", "The code code also integrates the surface fluxes zonally (i.e., along `xh` in MOM6) and meridionally (along `yh`).\n", "_______\n", "**Warning**: A different set monthly diagnostics is required to run this code with ACCESS-OM2 (MOM5) outputs. They are:\n", "\n", "\n", "| Variable| Diagnostic field | \n", "| --- | --- | \n", "| Temperature | `temp` | \n", "| Salinity| `salt` | \n", "| Water flux into ocean | `pme_river` | \n", "| Salt flux| `sfc_salt_flux_ice` + `sfc_salt_flux_restore` | \n", "| Surface heat flux | `sfc_hflux_coupler`+`sfc_hflux_from_runoff`+`frazil_3d_int_z`+ `sfc_hflux_pme` | \n", "| Surface Area| `area_t` | \n", "| Ocean depth| `ht` | \n", "\n", "Notice that for MOM5 you will have to import the diagnostic fields for each variable and sum them into the target variable, e.g.,\n", "\n", "\n", "`salt_flux = sfc_salt_flux_ice + sfc_salt_flux_restore` \n", "\n", "\n", "Finally, zonal integration should be done along `xt_ocean` and meridional integration along `yt_ocean`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import cartopy.crs as ccrs\n", "import cmocean as cm\n", "import dask.distributed\n", "import gsw\n", "import matplotlib.pyplot as plt\n", "from matplotlib import gridspec \n", "import matplotlib.colors as mcolors\n", "import numpy as np\n", "import xarray as xr\n", "import os\n", "import pathlib\n", "import shutil\n", "\n", "import intake\n", "cat = intake.cat.access_nri\n", "\n", "# Set temp_dir to a directory to store ~8GB of temporary output files\n", "temp_dir = os.path.expandvars(\"/scratch/$PROJECT/$USER/temp/swmt\")\n", "temp_path = pathlib.Path(temp_dir)\n", "\n", "# Ensure a fresh start\n", "if temp_path.exists():\n", " shutil.rmtree(temp_path) # Delete the directory and all its contents\n", "temp_path.mkdir(parents=True, exist_ok=True) # Create it again" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "scrolled": true }, "outputs": [], "source": [ "from dask.distributed import Client\n", "client = Client(threads_per_worker = 1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Computing surface water mass transformation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will do this by defining three functions. The first one loads the diagnostics needed. The second one **actually calculates the transformations**, and a third one does the density binning." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def get_variables(expt, freq, start_time, end_time, lon_slice, lat_slice):\n", " # Load variables required for the Surface Water Mass Transformation\n", " ds = {}\n", " #Setting the time slice\n", " time_slice=slice(start_time,end_time)\n", " # Getting surface fluxes\n", " #Importing water flux into ocean\n", " wfo = cat[expt].search(variable=\"wfo\",frequency=freq)\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"wfo\"].sel(xh = lon_slice, yh = lat_slice,time = time_slice).compute()\n", " #Importing salt flux into ocean - includes salt flux from sea ice and restoring\n", " salt_flux = cat[expt].search(variable=\"salt_flux\",frequency=freq)\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"salt_flux\"].sel(xh = lon_slice, yh = lat_slice,time = time_slice).compute()\n", " # importing heat fluxes \"hfds\"\n", " heat_flux = cat[expt].search(variable=\"hfds\",frequency=freq)\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"hfds\"].sel(xh = lon_slice, yh = lat_slice,time = time_slice).compute()\n", "\n", " # # Get temperature and salinity to calculate few other things we'll need later on\n", " #Importing practical salinity\n", " SP = cat[expt].search(variable=\"so\",frequency=freq)\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"so\"].sel(xh = lon_slice, yh = lat_slice,time = time_slice).isel(z_l=0)\n", " #importing conservative temperature\n", " CT = cat[expt].search(variable=\"thetao\",frequency=freq)\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"thetao\"].sel(xh = lon_slice, yh = lat_slice,time = time_slice).isel(z_l=0).compute()\n", " Temp_type= CT.attrs['long_name']\n", " if Temp_type == 'Sea Water Potential Temperature':\n", " print('Sea Water Potential Temperature will be converted to Conservative Temperature' )\n", " #importing area\n", " area = cat[expt].search(variable=\"areacello\")\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"areacello\"].sel(xh = lon_slice, yh = lat_slice).compute()\n", " #importing maximum depth\n", " maximum_depth = cat[expt].search(variable=\"deptho\")\\\n", " .to_dask(xarray_open_kwargs={\"decode_timedelta\": False})[\"deptho\"].sel(xh = lon_slice, yh = lat_slice).compute()\n", " #creating a depth array for each latitude\n", " surface_z = SP.z_l.values\n", " # # Calculate pressure\n", " pressure = gsw.p_from_z(-surface_z, SP.yh).rename('pressure').compute()\n", "\n", " # # Calculate absolute salinity\n", " SA = gsw.SA_from_SP(SP, pressure, SP.xh, SP.yh).rename('SA').compute()\n", "\n", " # # Ensure we have conservative temperature; Convert MOM6's potential temperature to conservative\n", " #Conversion is wrapped within a \"if\" statement to make sure we only convert the temperature when necessary, i.e., conversion not performed with MOM5 output\n", " #\n", " if Temp_type == 'Sea Water Potential Temperature': \n", " naming = CT.name\n", " CT = gsw.CT_from_pt(SA, CT).compute(); CT.name = naming; del naming\n", " # ds['temperature'][model_vars[model]['temperature'][0]].data = CT.values\n", "\n", " # Calculate potential density\n", " pot_rho_1 = gsw.sigma1(SA, CT).compute()\n", "\n", " # # Save everything to our dictionary\n", " ds['pressure'] = pressure\n", " ds['SA'] = SA\n", " ds['pot_rho_1'] = pot_rho_1\n", " ds['CT'] = CT\n", " ds['wfo'] = wfo\n", " ds[\"salt_flux\"] = salt_flux\n", " ds[\"heat_flux\"] = heat_flux\n", " ds[\"area\"] = area\n", " ds[\"maximum_depth\"] = maximum_depth\n", " \n", " # Calculate days per month accounting for leap years\n", " months_standard_noleap = np.array([31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31])\n", " months_standard_leap = np.array([31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31])\n", " if 'ryf' or 'panan' in expt:\n", " nyears = len(np.unique(CT['time.year']))\n", " days_per_month = np.tile(months_standard_noleap, nyears)\n", " elif 'iaf' in expt:\n", " nyears = len(np.unique(CT['time.year']))\n", " if CT['time.year'][0] % 4 == 0:\n", " days_per_month = months_standard_leap\n", " else: \n", " days_per_month = months_standard_noleap\n", " for yr in CT['time.year'][::12][1:]:\n", " if yr % 4 == 0:\n", " days_per_month = np.concatenate([days_per_month, months_standard_leap])\n", " else:\n", " days_per_month = np.concatenate([days_per_month, months_standard_noleap])\n", " days_per_month = xr.DataArray(days_per_month, dims = ['time'], coords = {'time': CT['time']}, name = 'days_per_month')\n", " ds['days_per_month'] = days_per_month\n", "\n", " return ds" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the function below to compute the salt transformation, note that the salt fluxes have units of (kg of salt)/m²/s, while β has units of kg / (g of salt), so we need to multiply the salt fluxes by 1000. The fresh water flux `pme_river` has units of (kg of water)/(m²/s) and needs to be multiplied by SSS to convert to (g of salt)/m²/s. This gives units of (kg of water)/m² for the salt_transformation but it will later be divided by time and density and be in m/s." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def compute_salt_transformation(ds):\n", " # Multiply the water flux by absolute salinity to get it in the correct units\n", " water_flux_into_ocean = ds['wfo']\n", " water_flux_into_ocean = ds['SA'] * water_flux_into_ocean\n", "\n", " # Caculate the haline contraction coefficient\n", " haline_contraction = gsw.beta(ds['SA'], ds['CT'], ds['pressure']).rename('beta')\n", "\n", " # Calculate the net salt flux and multiply by 1000 to convert units\n", " net_salt_flux = ds['salt_flux'] * 1000\n", "\n", " # Note that we also multiply pme_river by absolute salinity to have the correct units\n", " salt_transformation = haline_contraction * (water_flux_into_ocean - net_salt_flux) * ds['days_per_month']\n", " salt_transformation = salt_transformation.load()\n", "\n", " return salt_transformation\n", "\n", "def compute_heat_transformation(ds):\n", " # Calculate the thermal expansion coefficient \n", " thermal_expansion = gsw.alpha(ds['SA'], ds['CT'], ds['pressure']).rename('alpha')\n", " \n", " # Calculate the net surface heating\n", " net_surface_heating = ds['heat_flux']\n", " \n", " # Calculate the heat transformation\n", " heat_transformation = thermal_expansion * net_surface_heating * ds['days_per_month']\n", " heat_transformation = heat_transformation.load()\n", "\n", " return heat_transformation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need to define the isopycnal re-binning function" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def isopycnal_bins(ds, salt_transformation, heat_transformation):\n", "\n", " # Next section does a few things. It cycles through isopycnal bins, determines which cells are \n", " # within the given bin for each month, finds the transformation values for those cells for each month, \n", " # and sums these through time. You are left with an array of shape (isopyncal bins * lats * lons) \n", " # where the array associated with a given isopycnal bin is NaN everywhere except where pot_rho_1 \n", " # was within the bin, there it has a time summed transformation value.\n", " \n", " # Choose appropriate bin range\n", " isopycnal_bins = np.arange(31, 33.5, 0.02) # 125 bins - 31, 33.5, 0.02 (sigma1)\n", " #isopycnal_bins = np.concatenate([np.arange(25.0, 26.5, 0.05), np.arange(26.5, 28.5, 0.02)]) # 130 bins (sigma0)\n", " bin_bottoms = isopycnal_bins[:-1]\n", " isopycnal_bin_mid = (isopycnal_bins[1:] + bin_bottoms) / 2\n", " isopycnal_bin_diff = np.diff(isopycnal_bins)\n", "\n", " pot_rho_1 = ds['pot_rho_1']\n", "\n", " results_salt = []\n", " results_heat = []\n", "\n", " for i in range(len(bin_bottoms)):\n", " # Create binary mask for each bin\n", " bin_mask = xr.where((pot_rho_1 > bin_bottoms[i]) & (pot_rho_1 <= isopycnal_bins[i + 1]), 1, np.nan)\n", "\n", " # Multiply and sum over time\n", " salt_sum = (salt_transformation * bin_mask).sum(dim='time')\n", " heat_sum = (heat_transformation * bin_mask).sum(dim='time')\n", "\n", " results_salt.append(salt_sum.expand_dims({'isopycnal_bins': [isopycnal_bin_mid[i]]}))\n", " results_heat.append(heat_sum.expand_dims({'isopycnal_bins': [isopycnal_bin_mid[i]]}))\n", "\n", " # Concatenate results along isopycnal dimension\n", " salt_transformation = xr.concat(results_salt, dim='isopycnal_bins')\n", " heat_transformation = xr.concat(results_heat, dim='isopycnal_bins')\n", "\n", " # Normalise by number of days and bin thickness\n", " ndays = ds['days_per_month'].sum()\n", " c_p = 3992.1 # J kg-1 degC-1\n", "\n", " salt_transformation /= ndays\n", " heat_transformation /= (c_p * ndays)\n", "\n", " salt_transformation /= isopycnal_bin_diff[:, np.newaxis, np.newaxis]\n", " heat_transformation /= isopycnal_bin_diff[:, np.newaxis, np.newaxis]\n", "\n", " # Overwrite zeros with NANs \n", " # (Note: the code within the for-loop should provide nans but lazy computing with dask can sometimes give unpredictable results)\n", " salt_transformation = salt_transformation.where(salt_transformation != 0)\n", " heat_transformation = heat_transformation.where(heat_transformation != 0)\n", "\n", " # Change the sign so that positive means conversion into denser water masses\n", " salt_transformation *= -1\n", " heat_transformation *= -1\n", "\n", " # Renaming\n", " salt_transformation.name = \"salt_transformation\"\n", " heat_transformation.name = \"heat_transformation\"\n", "\n", " return salt_transformation.load(), heat_transformation.load()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Change to your experiment of interest\n", "expt = 'panant-01-zstar-ACCESSyr2'\n", "freq = '1mon'\n", "\n", "# Select time period and region\n", "start_time = '2004-01-01'\n", "end_time = '2004-12-31'\n", "lon_slice = slice(None, None)\n", "lat_slice = slice(None, -59)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Sea Water Potential Temperature will be converted to Conservative Temperature\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/source.py:308: ConcatenationWarning: Attempting to concatenate datasets without valid dimension coordinates: retaining only first dataset. Request valid dimension coordinate to silence this warning.\n", " warnings.warn(\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/core.py:321: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n", " records = grouped.get_group(internal_key).to_dict(orient='records')\n", "/g/data/xp65/public/apps/med_conda/envs/analysis3-25.09/lib/python3.11/site-packages/intake_esm/source.py:308: ConcatenationWarning: Attempting to concatenate datasets without valid dimension coordinates: retaining only first dataset. Request valid dimension coordinate to silence this warning.\n", " warnings.warn(\n" ] } ], "source": [ "ds = get_variables(expt, freq, start_time, end_time, lon_slice, lat_slice)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "salt_transformation = compute_salt_transformation(ds)\n", "heat_transformation = compute_heat_transformation(ds)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "🚨 ⏰ **Note**: the `isopycnal_bins` method below might take ~1 minute on an X-Large ARE instance, for a $0.1^o$ degree model resolution" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1min 17s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" ] } ], "source": [ "%%timeit -n 1 -r 1\n", "salt_transformation_binned, heat_transformation_binned = isopycnal_bins(ds, salt_transformation, heat_transformation)\n", "salt_transformation_binned.to_netcdf(pathlib.Path(temp_dir, \"binned_salt_transformation_mom6.nc\"), mode=\"w\")\n", "heat_transformation_binned.to_netcdf(pathlib.Path(temp_dir, \"binned_heat_transformation_mom6.nc\"), mode=\"w\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Re-loading saved transformation" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": true }, "outputs": [], "source": [ "salt_tr = xr.open_dataarray(pathlib.Path(temp_dir, \"binned_salt_transformation_mom6.nc\"), chunks = {'isopycnal_bins': 1})\n", "heat_tr = xr.open_dataarray(pathlib.Path(temp_dir, \"binned_heat_transformation_mom6.nc\"), chunks = {'isopycnal_bins': 1})\n", "net_tr = salt_tr + heat_tr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting\n", "\n", "### Entire Southern Ocean south of 59S" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [], "source": [ "#multiplying transformation rates by area and integrating it horizontally to get transformation rates in Sverdrups\n", "swmt = (ds['area'] * net_tr / 1e6).sum(['xh','yh'])\n", "swmt_heat = (ds['area'] * heat_tr / 1e6).sum(['xh','yh'])\n", "swmt_salt = (ds['area'] * salt_tr / 1e6).sum(['xh','yh'])\n", "\n", "for da in [swmt, swmt_heat, swmt_salt]:\n", " da.attrs[\"units\"] = \"Sv\"" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure = plt.figure(figsize = (7, 7))\n", "\n", "plt.plot(swmt, swmt['isopycnal_bins'], color = 'k', label='net')\n", "plt.plot(swmt_heat, swmt['isopycnal_bins'], color = 'r', label='heat')\n", "plt.plot(swmt_salt, swmt['isopycnal_bins'], color = 'b', label='salt')\n", "plt.plot([0, 0], [31, 33.2], 'k', linewidth = 0.5)\n", "plt.ylim((33.2, 31))\n", "plt.ylabel(r'$\\sigma_1$ (kg m$^{-3}$)', fontsize = 14)\n", "plt.xlabel('Surface water-mass transformation (Sv)', fontsize = 14)\n", "plt.legend(loc = 3, fontsize = 14);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are two key things to understand in order to interpret the figure above. First, positive values correspond to water masses that are becoming denser, and negative values waters that are becoming lighter. Second, the derivative of the transformation with respect to density ($\\partial_{\\sigma} \\Omega$) indicates convergence or divergence of mass in density space. \n", "\n", "Therefore, in the figure above, waters on the denser side of the positive peak ($\\sigma > 32.4$) are experiencing (i) densification and (ii) convergence of mass which results in subduction. The waters \"feeding\" the subduction are those that are experiencing (i) densification and (ii) divergence, i.e. those with densities between 32.1 and 32.4 (approximately). Therefore this peak is representing the abyssal part of the overturning circulation, with a strength of around 15Sv." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Antarctic shelf dense water formation\n", "\n", "You might be interested in dense water formation on the Anarctic continental shelf. Below we've outlined a procedure whereby you can identify the density of subducting waters on the continental shelf, and map the locations where this sudbuction occurs.\n", "\n", "You will need a way of masking for the continental shelf. You might just use a simple depth criterion, but here we define the shelf region using a mask that selects cells poleward of a continuous approximation of the 1000 m isobath surrounding Antarctica.\n", "\n", "**Warning**: Shelf masking is model-specific, and is currently set up for the Pan-Antarctic simulation at 1/10th degree resolution. A mask for ACCESS-OM2-01 simulations is also available as a `.npz` file at `/g/data/ik11/grids/Antarctic_slope_contour_1000m.npz`. When altering this code to run with ACCESS-OM2-01 first load the the above listed file using `np.load` and extract the `contour_masked_above` variable from it. If you are using a different MOM6 simulation, or a different MOM5-based model you will have to calculate your own mask. " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def shelf_mask_isobath(var):\n", " '''\n", " Masks Pan-Antarctic variables by the region polewards of the 1000m isobath as computed using \n", " a script contributed by Christina Schmidt\"\n", " Only to be used with ACCESS-OM2-0.1 and Pan-Antarctic output!\n", " '''\n", "\n", " path = \"/g/data/ik11/grids/Antarctic_slope_contour_1000m_MOM6_01deg.nc\"\n", "\n", " var = var.sel(yh=slice(-90, -59))\n", "\n", " shelf_mask = xr.open_dataset(path)['contour_masked_above']\n", "\n", " \n", " shelf_mask = xr.where(shelf_mask == 0, 1, 0)\n", " masked_var = var * shelf_mask\n", " \n", " return masked_var, shelf_mask" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "depth = ds['maximum_depth']\n", "land_mask = (depth*0).fillna(1)\n", "depth_shelf, shelf_mask = shelf_mask_isobath(depth)\n", "shelf_mask_plot = shelf_mask.where((shelf_mask == 1) & (land_mask == 0))" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(7, 7))\n", "ax = plt.subplot(projection = ccrs.SouthPolarStereo())\n", "\n", "ax.contourf(shelf_mask_plot.xh, shelf_mask_plot.yh, shelf_mask_plot,\n", " colors = 'red', alpha = 0.5, transform = ccrs.PlateCarree())\n", "ax.contour(land_mask.xh, land_mask.yh, land_mask,\n", " levels = [0, 1], colors = 'dimgrey', transform = ccrs.PlateCarree())\n", "ax.contour(shelf_mask.xh, shelf_mask.yh, shelf_mask,\n", " levels = [0, 1], colors = 'r', transform = ccrs.PlateCarree())\n", "ax.set_extent([-180, 180, -90, -59], ccrs.PlateCarree())" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "land_mask = (0 * ds['maximum_depth']).fillna(1)\n", "depth_shelf, shelf_mask = shelf_mask_isobath(ds['maximum_depth'])" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": true }, "outputs": [], "source": [ "swmt_shelf = (net_tr * ds['area'] / 1e6).where(shelf_mask == 1)\n", "heat_shelf = (heat_tr * ds['area'] / 1e6).where(shelf_mask == 1)\n", "salt_shelf = (salt_tr * ds['area']/ 1e6).where(shelf_mask == 1)\n", "swmt_shelf_sum = swmt_shelf.sum(['xh','yh'])\n", "heat_shelf_sum = heat_shelf.sum(['xh','yh'])\n", "salt_shelf_sum = salt_shelf.sum(['xh','yh'])\n", "\n", "for da in [swmt_shelf_sum, heat_shelf_sum, salt_shelf_sum]:\n", " da.attrs[\"units\"] = \"Sv\"" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "figure = plt.figure(figsize = (7, 7))\n", "\n", "plt.plot(swmt_shelf_sum, swmt_shelf_sum['isopycnal_bins'], color = 'k', label='net')\n", "plt.plot(heat_shelf_sum, heat_shelf_sum['isopycnal_bins'], color = 'r', label='heat')\n", "plt.plot(salt_shelf_sum, salt_shelf_sum['isopycnal_bins'], color = 'b', label='salt')\n", "plt.plot([0, 0], [31.0, 33.2], 'k', linewidth = 0.5)\n", "\n", "plt.ylim((33.2, 31.0))\n", "plt.ylabel(r'$\\sigma_1$ (kg m$^{-3}$)', fontsize = 14)\n", "plt.xlabel('Surface water-mass transformation (Sv)', fontsize = 14)\n", "plt.legend(loc = 1, fontsize = 14);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This shows us that continental shelf surface waters are made denser (almost entirely by sea-ice freshwater fluxes) and subduct away from the surface at a rate of over 8 Sv! Where does this happen? If we map the surface water-mass transformation rate across a chosen density class, we will be able to see where waters are subducting. We know from experience that the dense waters that overflow are best correlated with the transformation on the denser side of the peak, so let's choose $\\sigma_1$ = 32.6 kg/m^3." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "transformation_density = 32.6\n", "shelf_subduction_plot = net_tr.sel(isopycnal_bins = transformation_density, method = 'nearest') * 1e5\n", "swmt_xt = ds['area'].xh\n", "swmt_yt = ds['area'].yh" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure(1, figsize = (15, 8))\n", "gs = gridspec.GridSpec(1, 2, width_ratios = [3, 2], wspace = 0.05)\n", "\n", "ax, ax1 = plt.subplot(gs[0], projection = ccrs.SouthPolarStereo()), plt.subplot(gs[1])\n", "ax.set_extent([-180, 180, -90, -59], ccrs.PlateCarree())\n", "\n", "ax.contour(land_mask.xh, land_mask.yh, land_mask,\n", " levels = [0, 1], colors = 'dimgrey', transform = ccrs.PlateCarree())\n", "ax.contour(shelf_mask.xh, shelf_mask.yh, shelf_mask,\n", " levels = [0, 1], colors = 'r', transform = ccrs.PlateCarree())\n", "\n", "norm = mcolors.Normalize(vmin = 0, vmax = 2.5)\n", "plot_swmt = ax.pcolormesh(swmt_xt, swmt_yt, shelf_subduction_plot,\n", " vmin = 0, vmax = 2.5,\n", " cmap = cm.cm.matter,\n", " transform = ccrs.PlateCarree())\n", "\n", "cax = fig.add_axes([0.27, 0.03, 0.2, 0.04])\n", "cbar = plt.colorbar(plot_swmt, cax=cax, orientation='horizontal', shrink = 0.5, ticks = [0, 0.5, 1, 1.5, 2, 2.5, 3])\n", "cbar.set_label(r'Surface water-mass transformation ($\\times 10^{-5}$m s$^{-1}$)')\n", "\n", "ax1.plot(swmt_shelf_sum, swmt_shelf_sum['isopycnal_bins'], color = 'k', label='net')\n", "ax1.plot(heat_shelf_sum, swmt_shelf_sum['isopycnal_bins'], color = 'r', label='heat')\n", "ax1.plot(salt_shelf_sum, swmt_shelf_sum['isopycnal_bins'], color = 'b', label='salt')\n", "ax1.plot([0, 0], [31, 33.2], 'k', linewidth=0.5)\n", "ax1.plot([-5, 15], [transformation_density, transformation_density], 'k--', linewidth=1)\n", "ax1.set_ylim((33.2, 31))\n", "ax1.set_xlim((-1.5, 10))\n", "ax1.yaxis.set_label_position(\"right\")\n", "ax1.yaxis.tick_right()\n", "ax1.set_ylabel(r'$\\sigma_1$ (kg m$^{-3}$)')\n", "ax1.set_xlabel('Surface water-mass transformation (Sv)')\n", "ax1.legend();" ] } ], "metadata": { "kernelspec": { "display_name": "Python [conda env:analysis3-25.09]", "language": "python", "name": "conda-env-analysis3-25.09-py" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.13" } }, "nbformat": 4, "nbformat_minor": 4 }