From c36c71e62e486b6c8656739de41430ce622437be Mon Sep 17 00:00:00 2001 From: Anouk Vlug Date: Wed, 3 May 2023 16:27:02 +0200 Subject: [PATCH 1/2] adds changes to distribute_thickness_per_altitude so it can be used with different topo data --- oggm/core/inversion.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/oggm/core/inversion.py b/oggm/core/inversion.py index b8cded36e..410a65771 100644 --- a/oggm/core/inversion.py +++ b/oggm/core/inversion.py @@ -723,7 +723,7 @@ def compute_inversion_velocities(gdir, glen_a=None, fs=None, filesuffix='', @entity_task(log, writes=['gridded_data']) -def distribute_thickness_per_altitude(gdir, add_slope=True, +def distribute_thickness_per_altitude(gdir, add_slope=True, topo='topo_smoothed', smooth_radius=None, dis_from_border_exp=0.25, varname_suffix=''): @@ -757,7 +757,7 @@ def distribute_thickness_per_altitude(gdir, add_slope=True, gridded_attributes(gdir) with utils.ncDataset(grids_file) as nc: - topo_smoothed = nc.variables['topo_smoothed'][:] + topo_smoothed = nc.variables[topo][:] glacier_mask = nc.variables['glacier_mask'][:] dis_from_border = nc.variables['dis_from_border'][:] if add_slope: From 85dab797b06808f15de89ab4859f4eafb8c9e5ae Mon Sep 17 00:00:00 2001 From: Anouk Vlug Date: Wed, 3 May 2023 16:36:13 +0200 Subject: [PATCH 2/2] adds notebook to discuss changes --- ...tribute_ice_to_grid_after_simulation.ipynb | 58951 ++++++++++++++++ 1 file changed, 58951 insertions(+) create mode 100644 oggm/sandbox/Redistribute_ice_to_grid_after_simulation.ipynb diff --git a/oggm/sandbox/Redistribute_ice_to_grid_after_simulation.ipynb b/oggm/sandbox/Redistribute_ice_to_grid_after_simulation.ipynb new file mode 100644 index 000000000..66989b04d --- /dev/null +++ b/oggm/sandbox/Redistribute_ice_to_grid_after_simulation.ipynb @@ -0,0 +1,58951 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "eb728ce4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import oggm.cfg as cfg\n", + "from oggm import tasks, graphics, utils, workflow\n", + "from oggm.core import flowline\n", + "import numpy as np\n", + "import geopandas as gpd\n", + "import pandas as pd\n", + "import xarray as xr\n", + "import scipy\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "import salem\n", + "from scipy.stats.mstats import rankdata\n", + "# This is needed to display graphics calculated outside of jupyter notebook\n", + "from IPython.display import HTML, display\n", + "from oggm.core.gis import gaussian_blur\n", + "from oggm import global_tasks\n", + "from oggm.core import massbalance\n", + "from oggm import graphics\n", + "import warnings\n", + "\n", + "\n", + "import shapely.geometry as shpg\n", + "from scipy.ndimage import binary_erosion,distance_transform_edt\n", + "from oggm.utils import ncDataset" + ] + }, + { + "cell_type": "markdown", + "id": "729da606", + "metadata": {}, + "source": [ + "This notebook is a proposal on how to redistribute the glacier ice that has been simulated allong the flowline after a simulation where the glacier has been retreating. Extrapolating the glacier ice onto a map comes with some assumptions and trade-offs. Depending on the purpose one might like to make different choices. e.g. for visualisation, one might like to use a higher resolution, than when using the output to put in for instance a hydrological model. It would offcourse be possible to add different option to the final function, so one can select the option that is best for their needs, however that hasn't been included yet. \n", + "\n", + "This notebook uses one glacier to show how this redistribution can be done. It has as purpose to discuss it further, before it enters the OGGM code base. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "504b03c3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-05-03 16:27:38: oggm.cfg: Reading default parameters from the OGGM `params.cfg` configuration file.\n", + "2023-05-03 16:27:38: oggm.cfg: Multiprocessing switched OFF according to the parameter file.\n", + "2023-05-03 16:27:38: oggm.cfg: Multiprocessing: using all available processors (N=16)\n" + ] + } + ], + "source": [ + "# Initialize OGGM and set up the default run parameters\n", + "cfg.initialize(logging_level='WARNING')\n", + "rgi_region = '11' # Region Central Europe\n", + "\n", + "# Local working directory (where OGGM will write its output)\n", + "# WORKING_DIR = utils.gettempdir('OGGM_distr4')\n", + "cfg.PATHS['working_dir'] = utils.mkdir('/home/anouk/Workspace/OGGM_distributed2', reset=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4c86bebf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-05-03 16:27:39: oggm.workflow: init_glacier_directories from prepro level 3 on 2 glaciers.\n", + "2023-05-03 16:27:39: oggm.workflow: Execute entity tasks [gdir_from_prepro] on 2 glaciers\n" + ] + } + ], + "source": [ + "# RGI file\n", + "path = utils.get_rgi_region_file(rgi_region)\n", + "rgidf = gpd.read_file(path)\n", + "\n", + "# Select a glacier\n", + "# rgidf = rgidf.loc[rgidf[rgidf.columns[0]] == 'RGI60-11.01450']\n", + "rgidf = rgidf.loc[rgidf[rgidf.columns[0]] == 'RGI60-11.00897']\n", + "\n", + "rgi_ids = ['RGI60-11.01450', 'RGI60-11.00897'] \n", + "# rgi_ids = ['RGI60-03.00841', 'RGI60-03.00840']\n", + "base_url = 'https://cluster.klima.uni-bremen.de/~oggm/gdirs/oggm_v1.6/L3-L5_files/2023.1/elev_bands/W5E5'\n", + "\n", + "gdirs = workflow.init_glacier_directories(rgi_ids, prepro_base_url=base_url, from_prepro_level=3, prepro_border=80, reset=True, force=True)" + ] + }, + { + "cell_type": "markdown", + "id": "34c0c417", + "metadata": {}, + "source": [ + "### Functions " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f4a19b75", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# This smooting function is used by the smooth_glacier_topo function to only smooth the topo of the glacier, and excludes \n", + "# the surrounding in the process.\n", + "\n", + "def filter_nan_gaussian_conserving(arr, sigma):\n", + " \"\"\"Apply a gaussian filter to an array with nans.\n", + "\n", + " Intensity is only shifted between not-nan pixels and is hence conserved.\n", + " The intensity redistribution with respect to each single point\n", + " is done by the weights of available pixels according\n", + " to a gaussian distribution.\n", + " All nans in arr, stay nans in gauss.\n", + " \"\"\"\n", + " nan_msk = np.isnan(arr)\n", + "\n", + " loss = np.zeros(arr.shape)\n", + " loss[nan_msk] = 1\n", + " loss = scipy.ndimage.gaussian_filter(\n", + " loss, sigma=sigma, mode='constant', cval=1)\n", + "\n", + " gauss = arr.copy()\n", + " gauss[nan_msk] = 0\n", + " gauss = scipy.ndimage.gaussian_filter(\n", + " gauss, sigma=sigma, mode='constant', cval=0)\n", + " gauss[nan_msk] = np.nan\n", + "\n", + " gauss += loss * arr\n", + "\n", + " return gauss" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3209458c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def smooth_glacier_topo(gdir, topo_correction=None):\n", + "\n", + " \"\"\"This smooting function is used smooth the topo of the glacier, and excludes the surrounding in the process.\n", + " It is therefore different that the smoothing that occurs in the 'process_dem' function, that generates 'topo_smoothed'\n", + " in the gridded_data.nc file. This is of importance when extrapolation to the 2D grid, because the sides on a glacier \n", + " tongue can other wise be higher that the middle, resulting in an odd shape once the glacier retreats (e.g. with the \n", + " middle of the tongue retreating faster that the edges). \"\"\"\n", + " \n", + " with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load()\n", + " topo_smooth_glacier = filter_nan_gaussian_conserving(topo_correction.values, 1)\n", + "\n", + " ds[\"topo_smoothed_glacier\"] = xr.full_like(ds.topo, fill_value=np.nan)\n", + " \n", + " for ki in np.arange(len(ds.x)):\n", + " for kj in np.arange(len(ds.y)):\n", + " ds[\"topo_smoothed_glacier\"].loc[dict(y=ds.y[kj], x=ds.x[ki])] = topo_smooth_glacier[kj, ki]\n", + "\n", + " topo_smoothed_glacier = xr.where(ds.glacier_mask==1, ds[\"topo_smoothed_glacier\"], ds['topo_smoothed'])\n", + "\n", + " with ncDataset(gdir.get_filepath('gridded_data'), 'a') as nc:\n", + " vn = 'topo_smoothed_glacier'\n", + " if vn in nc.variables:\n", + " v = nc.variables[vn]\n", + " else:\n", + " v = nc.createVariable(vn, 'f4', ('y', 'x',))\n", + " v.units = 'm'\n", + " v.long_name = 'Glacier topo smoothed'\n", + " v.description = ('DEM smoothed just on the glacier. \\\n", + " (The DEM outside the glacier doesn\\'t impact the smoothing.)')\n", + " v[:] = topo_smoothed_glacier\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b1ffbd3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def assign_points_to_section(gdir, filesuffix_diagnostics='', option=1):\n", + "\n", + " \"\"\"This function assigns the points on the grid to the different elevation bands along the flowline, creating the \n", + " variable points_by_section in the gridded data.\n", + " \n", + " Option 1 (default) uses the topo that create with smooth_glacier_topo. This is smoothed over the glacier, \n", + " without taking into account its surroundings. \n", + " Option 2 uses the regular smoothed_topo.\"\"\" \n", + " \n", + " \n", + " with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load()\n", + "\n", + " f = gdir.get_filepath('fl_diagnostics' + filesuffix_diagnostics)\n", + "\n", + " with xr.open_dataset(f) as di:\n", + " fl_ids = di.flowlines.data\n", + "\n", + " # For now we pick the last flowline (the main one)\n", + " with xr.open_dataset(f, group=f'fl_{fl_ids[-1]}') as dg:\n", + " dg = dg.load()\n", + " dg2 = dg[dict(time=0)]\n", + "\n", + " # number of pixels in section along flowline\n", + " npix1 = dg2.area_m2 / (gdir.grid.dx ** 2)\n", + " npix_rcumsum = np.around(npix1.values[::-1].cumsum()[::-1])\n", + " npix = npix_rcumsum[0:-2] - npix_rcumsum[1:-1]\n", + "\n", + " if option == 1:\n", + " rank_hl1 = rankdata(ds.where(ds.glacier_mask == 1).topo_smoothed_glacier)\n", + " elif option == 2:\n", + " rank_hl1 = rankdata(ds.where(ds.glacier_mask == 1).topo_smoothed)\n", + "\n", + " ds['rank_hl1'] = (('y', 'x'), rank_hl1)\n", + " ds['rank_hl1'] = ds.where(ds.glacier_mask == 1).rank_hl1\n", + "\n", + " ds[\"fl_att\"] = xr.full_like(ds.rank_hl1, fill_value=np.nan)\n", + "\n", + " for ki in ds.x:\n", + " for kj in ds.y:\n", + " check = ds.sel(y=kj, x=ki).rank_hl1.values\n", + " if not np.isnan(check):\n", + " kn = np.sum(npix_rcumsum >= check)\n", + " ds[\"fl_att\"].loc[dict(y=kj, x=ki)] = kn\n", + "\n", + " fl_att = ds['fl_att']\n", + "\n", + " with ncDataset(gdir.get_filepath('gridded_data'), 'a') as nc:\n", + " vn = 'points_by_section'\n", + " if vn in nc.variables:\n", + " v = nc.variables[vn]\n", + " else:\n", + " v = nc.createVariable(vn, 'f4', ('y', 'x',))\n", + " v.units = '-'\n", + " v.long_name = 'points grouped by section along the flowline'\n", + " v.description = ('Points grouped by section along the follow line. Here the lowest number corresponds to the '\n", + " 'lowest elevation band containing glacier ice at the time of initialization.')\n", + " v[:] = fl_att" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2c30ec21", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def assign_points_within_section(gdir, filesuffix_diagnostics='', option=2):\n", + " \n", + " \"\"\"This function ranks the points within the different elevation bands along the flowline in order they will disappear \n", + " and stores this information as the variable points_ranked_within_section in gridded_data.\n", + " \n", + " Option 1 ranks by distributed_thickness\n", + " Option 2 (default) ranks based on the thickness combined with elevation, thereby trying to take into mimic the\n", + " mass balance gradient.\"\"\" \n", + " \n", + " with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load()\n", + " \n", + " f = gdir.get_filepath('fl_diagnostics' + filesuffix_diagnostics)\n", + "\n", + " with xr.open_dataset(f) as di:\n", + " fl_ids = di.flowlines.data\n", + "\n", + " # For now we pick the last flowline (the main one)\n", + " with xr.open_dataset(f, group=f'fl_{fl_ids[-1]}') as dg:\n", + " dg = dg.load()\n", + " dg2 = dg[dict(time=0)]\n", + " min_alt = ds.topo_smoothed_glacier.min().values\n", + " \n", + " \n", + " npix1 = dg2.area_m2/(gdir.grid.dx**2)\n", + " npix_rcumsum = np.around(npix1.values[::-1].cumsum()[::-1])\n", + " npix = npix_rcumsum[0:-2] - npix_rcumsum[1:-1]\n", + " \n", + " ds[\"fl_att_sub\"] = xr.full_like(ds.points_by_section, fill_value=np.nan)\n", + " ds[\"rank_hl2\"] = xr.full_like(ds.points_by_section, fill_value=0)\n", + "\n", + " for ki in np.arange(len(npix)):\n", + " ds[\"rank_hl2_\" + str(ki)] = xr.full_like(ds.points_by_section, fill_value=0)\n", + " \n", + " if option==1:\n", + " rank_hl2 = rankdata(ds.distributed_thickness.where(ds.points_by_section==ki))\n", + " elif option==2:\n", + " ds[\"corrected_thick\"] = ((ds.topo_smoothed_glacier - min_alt + 1) * 1.003) * ds.distributed_thickness\n", + " rank_hl2 = rankdata(ds.corrected_thick.where(ds.points_by_section==ki))\n", + " ds[\"rank_hl2_\" + str(ki)] = (('y', 'x'), rank_hl2)\n", + " ds[\"rank_hl2_\" + str(ki)] = ds[\"rank_hl2_\" + str(ki)].where(ds.points_by_section==ki, 0)\n", + "\n", + " rank_hl3 = ds.rank_hl2_0.values\n", + "\n", + " for ki in np.arange(1,np.max(ds.points_by_section)):\n", + " rank_hl3 = rank_hl3 + (ds['rank_hl2_' + str(int(ki))]).values\n", + "\n", + " ds[\"rank_hl3\"] = xr.full_like(ds.points_by_section, fill_value=np.nan)\n", + " ds[\"rank_hl3\"] = (('y', 'x'), rank_hl3)\n", + " ds['fl_att_sub']=ds.where(ds.glacier_mask==1).rank_hl3\n", + "\n", + " fl_att_sub = ds['fl_att_sub']\n", + "\n", + " with ncDataset(gdir.get_filepath('gridded_data'), 'a') as nc:\n", + " vn = 'points_ranked_within_section'\n", + " if vn in nc.variables:\n", + " v = nc.variables[vn]\n", + " else:\n", + " v = nc.createVariable(vn, 'f4', ('y', 'x',))\n", + " v.units = '-'\n", + " v.long_name = 'points ranked within each section along the flowline'\n", + " v.description = ('...')\n", + " v[:] = fl_att_sub\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cdd2ed1d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def redistribute_thicknesses(gdir, ys=0, ye=10, filesuffix_diagnostics='', smooth_radius=None):\n", + "\n", + " \"\"\"This function redistributes the simulated glacier area and volume allong the elevation band flowline back onto\n", + " a 2D grid. In order for this to work, the glacier can not advance beyond its initial state, the glacier diagnostics\n", + " during the simulation have to be stored, the gridded_data file needs to contain both the points_by_section and \n", + " points_ranked_within_section variables.\n", + " \n", + " ys: the first year to be redistributed\n", + " ye: the last year to be redistributed \"\"\"\n", + " \n", + " f = gdir.get_filepath('fl_diagnostics' + filesuffix_diagnostics)\n", + " with xr.open_dataset(f) as di:\n", + " fl_ids = di.flowlines.data\n", + "\n", + " # For now we pick the last flowline (the main one)\n", + " with xr.open_dataset(f, group=f'fl_{fl_ids[-1]}') as dg:\n", + " dg = dg.load()\n", + "\n", + " dg2 = dg[dict(time=0)]\n", + "\n", + " # number of pixels in section along flowline\n", + " npix1 = dg2.area_m2 / (gdir.grid.dx ** 2)\n", + " npix_rcumsum = np.around(npix1.values[::-1].cumsum()[::-1])\n", + " npix = npix_rcumsum[0:-2] - npix_rcumsum[1:-1]\n", + " \n", + " for yr in np.arange(ys, ye, 1):\n", + " redistribute_thickness(gdir, yr=yr, dg=dg.sel(dict(time=yr)), npix=npix, smooth_radius=smooth_radius)\n", + " \n", + "def redistribute_thickness(gdir, yr=0, dg=None, npix=None, smooth_radius=None, min_thick=1):\n", + "\n", + " with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load() \n", + " ds['thickness_' + str(yr)] = xr.full_like(ds.points_by_section, fill_value=np.nan)\n", + " if smooth_radius != 0:\n", + " ds['thickness_' + str(yr) + \"_smooth\"] = xr.full_like(ds.points_by_section, fill_value=np.nan)\n", + " \n", + " residual_area = 0\n", + " residual_pix = 0\n", + "\n", + " Area2 = 0\n", + " for ki in np.arange(len(npix),-1,-1):\n", + " if dg.area_m2[ki].values != 0: \n", + " pix_cov = ((dg.area_m2[ki].values)/(gdir.grid.dx**2)) + residual_pix\n", + " mask = ((ds.points_by_section==(ki+1)) & (ds.points_ranked_within_section>= (npix[ki]-pix_cov)))\n", + " residual_pix = pix_cov - mask.sum().sum().values\n", + " vol_sim = dg.volume_m3[ki].values\n", + " vol_dis = xr.where(mask, ds.distributed_thickness, 0).sum().sum() * (gdir.grid.dx**2)\n", + " area = mask.sum().sum() * (gdir.grid.dx**2)\n", + " vol_cor = (vol_dis - vol_sim)/ area\n", + " Area2 = Area2 + area.values \n", + " ds[\"thickness_\" + str(yr)] = xr.where(mask, ds.distributed_thickness - vol_cor, ds[\"thickness_\" + str(yr)]) \n", + " \n", + " # here I added a final smoothing of the total thickness distribution (copied from distribute_thickness_per_altitude)\n", + " thick = ds[\"thickness_\" + str(yr)]\n", + " \n", + " # Make sure all glacier covered cells have the miniumum thickness\n", + " thick = xr.where(thick<=min_thick, min_thick, thick)\n", + " # set all nans to 0 for smoothing\n", + " thick = xr.where(np.isnan(thick), 0, thick)\n", + " glacier_mask = thick > 0\n", + " init_vol = dg.volume_m3.sum().values\n", + " # Smooth\n", + " dx = gdir.grid.dx\n", + " if smooth_radius != 0:\n", + " if smooth_radius is None:\n", + " smooth_radius = np.rint(cfg.PARAMS['smooth_window'] / dx)\n", + " thick = gaussian_blur(thick, int(smooth_radius))\n", + " thick = np.where(glacier_mask, thick, min_thick)\n", + "\n", + " # Re-mask\n", + " utils.clip_min(thick, min_thick, out=thick)\n", + " thick[glacier_mask == 0] = np.NaN\n", + " assert np.all(np.isfinite(thick[glacier_mask == 1]))\n", + "\n", + " # Conserve volume\n", + " tmp_vol = np.nansum(thick * dx**2)\n", + " thick *= init_vol / tmp_vol\n", + "\n", + " ds[\"thickness_\" + str(yr)] = xr.where(glacier_mask, thick, np.nan)\n", + " \n", + " conservation = ((ds[\"thickness_\" + str(yr)].sum().sum() * (gdir.grid.dx**2)) / dg.volume_m3.sum()) * 100\n", + " print(\"volume conservation: \" + str(float(conservation)) + ' %')\n", + " area_conservation = (((ds[\"thickness_\" + str(yr)] > 0).sum() * (gdir.grid.dx**2)) / dg.area_m2.sum()) * 100\n", + " print(f\"area conservation: {float(area_conservation.values)} %\")\n", + " \n", + " thickness = ds[\"thickness_\" + str(yr)]\n", + " #ds.close()\n", + "\n", + " with ncDataset(gdir.get_filepath('gridded_data'), 'a') as nc:\n", + " vn = \"thickness_\" + str(yr)\n", + " if vn in nc.variables:\n", + " v = nc.variables[vn]\n", + " else:\n", + " v = nc.createVariable(vn, 'f4', ('y', 'x',))\n", + " v.units = '-'\n", + " v.long_name = '...'\n", + " v.description = ('...')\n", + " v[:] = thickness\n" + ] + }, + { + "cell_type": "markdown", + "id": "51adee20", + "metadata": { + "tags": [] + }, + "source": [ + "### Start experiment - to redistribute the ice after the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0587e522-2e98-4098-aff0-7c346e8107be", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "gdir = gdirs[0]\n", + "### Do a random run\n", + "tasks.run_constant_climate(gdir, nyears=100, y0=2000, temperature_bias=0.25, store_fl_diagnostics=True);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "00993b9b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Create an array with only the topo on the glacier and substract X meter from the elevation of glaciers on the outline. \n", + "# This value is arbritary, but seems to result in a more realistic retreat of the glacier tongue than \n", + "# that without this correction. A physical explanation for this might be that there is an influence of steep valley walls \n", + "# along the tongue on the glacier DEM, causing the sides of the glacier to be higher than the center. \n", + "border_correction = 40 \n", + "with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load()\n", + "topo_correction = xr.where(ds.glacier_mask==1, ds.topo, np.nan) - (xr.where(ds.glacier_mask==1, ds.glacier_ext, np.nan) * border_correction)\n", + "\n", + "smooth_glacier_topo(gdir, topo_correction=topo_correction)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ef949161", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "tasks.distribute_thickness_per_altitude(gdir, topo='topo_smoothed_glacier');" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e8ddabcb", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "assign_points_to_section(gdir, filesuffix_diagnostics='', option=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7894c3fa", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "assign_points_within_section(gdir, filesuffix_diagnostics='', option=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9582d84b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load()\n", + "ds.points_by_section.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1f126bc5-1d5a-4b32-8de0-bea1262f336f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ds.points_ranked_within_section.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "35e1e48a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "volume conservation: 100.0 %\n", + "area conservation: 99.97986886601952 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.98521256062833 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98722848060734 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99149741838357 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.99972494403522 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99775987850556 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99365558246271 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99551534136326 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.9805656782379 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.9948157576679 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.99240181204955 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.99632986808467 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98358524519955 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.97715655916633 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97697762644539 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.98240460846802 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98327322773488 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98949183843652 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.97768929379306 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99408304629692 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99528833069301 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.98691381036764 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98289554021468 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98622009111104 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98026680161578 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.97837162938553 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98048522871196 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.9865398185478 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97691419865 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.97980417279732 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98616992389559 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98069229511236 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98280941040117 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98594445210658 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.98302939524747 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99651362076223 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97767945604834 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98817571010356 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.9874248881047 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98842166522854 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98245698157159 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99627915522517 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99038827159838 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99609977068283 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98154705513471 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99298041798744 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.98080524663358 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98931815007552 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99589644798868 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99412018949701 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.97895184531231 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99563855736352 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98789367920705 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98746365493804 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.99820904912646 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98428754002381 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.9766178596895 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98126253554797 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98660346759468 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99264721431217 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99232684973053 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.9912992035192 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99085210617201 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99098418720003 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98746289938771 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98022719134097 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.9873836211803 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99878467193537 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.9845362894206 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.99675406077344 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.98654948517145 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99141401904112 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99660313949542 %\n", + "volume conservation: 99.99999999999997 %\n", + "area conservation: 99.97589645503966 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98174033411053 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98020492553442 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.9786379654326 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97727721923097 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97613917676878 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97523558042558 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97457436424313 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.97416146198789 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.98254454202905 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.97476614220311 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99359056906805 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98597788922339 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97848317599639 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.99767593847191 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99046860147736 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98341889673327 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.97653596212336 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.9964021101229 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98988231172743 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.99140484977961 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.97730254398914 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.98989827058436 %\n", + "volume conservation: 100.0 %\n", + "area conservation: 99.97579412630618 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.98844216104102 %\n", + "volume conservation: 100.00000000000003 %\n", + "area conservation: 99.97442144556462 %\n", + "volume conservation: 99.99999999999999 %\n", + "area conservation: 99.98718940261165 %\n" + ] + } + ], + "source": [ + "redistribute_thicknesses(gdir, ys=0, ye=100, filesuffix_diagnostics='', smooth_radius=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fe26d813", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "with xr.open_dataset(gdir.get_filepath('gridded_data')) as ds:\n", + " ds = ds.load()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ec1b7f05", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import animation\n", + "\n", + "# Get a handle on the figure and the axes\n", + "fig, ax = plt.subplots(figsize=(gdir.grid.nx/20,gdir.grid.ny/25))\n", + "\n", + "# Plot the initial frame. \n", + "cax = ds.thickness_0.plot(\n", + " add_colorbar=True,\n", + " cmap='viridis',\n", + " vmin=0, vmax=350,\n", + " cbar_kwargs={\n", + " 'extend':'neither'\n", + " }\n", + ")\n", + "\n", + "def animate(frame):\n", + " cax.set_array(ds['thickness_' + str(int(frame))].values.flatten())\n", + "\n", + "ani = animation.FuncAnimation(\n", + " fig, \n", + " animate, \n", + " frames=99, \n", + " interval=200, \n", + " save_count=1500\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "92b7f318", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "HTML(ani.to_jshtml())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}