diff --git a/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb b/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb index 487567e..5e5d16d 100644 --- a/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb +++ b/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb @@ -35,26 +35,12 @@ "metadata": {}, "outputs": [], "source": [ - "import sys, time, os\n", - "from pathlib import Path\n", - "import copy\n", - "import numpy as np\n", - "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", - "\n", - "from landlab.components import (\n", - " FlowAccumulator,\n", - " PriorityFloodFlowRouter,\n", - " ChannelProfiler,\n", - " BedrockLandslider,\n", - ")\n", - "from landlab.io.netcdf import read_netcdf\n", - "from landlab.utils import get_watershed_mask\n", - "from landlab import imshowhs_grid, imshow_grid\n", - "from landlab.io import read_esri_ascii, write_esri_ascii\n", - "from landlab import RasterModelGrid\n", - "\n", - "from bmi_topography import Topography" + "import numpy as np\n", + "from bmi_topography import Topography\n", + "from landlab import RasterModelGrid, imshow_grid, imshowhs_grid\n", + "from landlab.components import BedrockLandslider, PriorityFloodFlowRouter\n", + "from landlab.io import read_esri_ascii" ] }, { @@ -194,19 +180,15 @@ "metadata": {}, "outputs": [], "source": [ - "# Read DEM as Lanlab grid\n", + "# Read DEM as Landlab grid\n", "grid_geog, elev = read_esri_ascii(fname, name=\"topographic__elevation\")\n", - "# Show dem\n", - "plt.figure()\n", - "cmap = copy.copy(mpl.cm.get_cmap(\"terrain\"))\n", - "imshow_grid(\n", - " grid_geog,\n", + "\n", + "grid_geog.imshow(\n", " \"topographic__elevation\",\n", - " cmap=cmap,\n", + " cmap=\"terrain\",\n", " grid_units=(\"deg\", \"deg\"),\n", " colorbar_label=\"Elevation (m)\",\n", - ")\n", - "plt.show()" + ")" ] }, { @@ -245,9 +227,8 @@ "outputs": [], "source": [ "# make a new grid with RasterModelGrid, use the dimensions of grid_geog\n", - "\n", - "# grid =\n", - "# grid.add_field(..." + "grid = RasterModelGrid(grid_geog.shape, xy_spacing=30.0)\n", + "grid.at_node[\"topographic__elevation\"] = grid_geog.at_node[\"topographic__elevation\"]" ] }, { @@ -257,7 +238,8 @@ "metadata": {}, "outputs": [], "source": [ - "# Plot this one with imshowhs_grid" + "# Plot this one with imshowhs_grid\n", + "imshowhs_grid(grid, \"topographic__elevation\")" ] }, { @@ -272,7 +254,6 @@ " grid, topo=True, DA=True, hill_DA=False, flow_metric=\"D8\", hill_flow_metric=\"Quinn\"\n", "):\n", " if topo:\n", - " cmap = copy.copy(mpl.cm.get_cmap(\"terrain\"))\n", " azdeg = 200\n", " altdeg = 20\n", " ve = 1\n", @@ -283,7 +264,7 @@ " \"topographic__elevation\",\n", " grid_units=(\"deg\", \"deg\"),\n", " var_name=\"Topo, m\",\n", - " cmap=cmap,\n", + " cmap=\"terrain\",\n", " plot_type=plot_type,\n", " vertical_exa=ve,\n", " azdeg=azdeg,\n", @@ -309,13 +290,11 @@ " drape1 = plot_DA\n", " thres_drape1 = None\n", " alpha = 0.5\n", - " myfile1 = \"temperature.cpt\"\n", - " cmap1 = copy.copy(mpl.cm.get_cmap(\"terrain\"))\n", " ax = imshowhs_grid(\n", " grid,\n", " \"topographic__elevation\",\n", " grid_units=(\"deg\", \"deg\"),\n", - " cmap=cmap1,\n", + " cmap=\"terrain\",\n", " plot_type=plot_type,\n", " drape1=drape1,\n", " vertical_exa=ve,\n", @@ -351,7 +330,7 @@ " grid.at_node[\"hill_drainage_area\"][grid.at_node[\"hill_drainage_area\"] == 0] = (\n", " grid.dx * grid.dx\n", " )\n", - " plotDA = np.log10(grid.at_node[\"hill_drainage_area\"] * 111e3 * 111e3)\n", + " # plotDA = np.log10(grid.at_node[\"hill_drainage_area\"] * 111e3 * 111e3)\n", " # plt.figure()\n", " # imshow_grid(grid, plotDA,grid_units=(\"m\", \"m\"), var_name=\"Elevation (m)\", cmap='terrain')\n", "\n", @@ -361,13 +340,11 @@ " drape1 = np.log10(grid.at_node[\"hill_drainage_area\"])\n", " thres_drape1 = None\n", " alpha = 0.5\n", - " myfile1 = \"temperature.cpt\"\n", - " cmap1 = copy.copy(mpl.cm.get_cmap(\"terrain\"))\n", " ax = imshowhs_grid(\n", " grid,\n", " \"topographic__elevation\",\n", " grid_units=(\"deg\", \"deg\"),\n", - " cmap=cmap1,\n", + " cmap=\"terrain\",\n", " plot_type=plot_type,\n", " drape1=drape1,\n", " vertical_exa=ve,\n", @@ -460,7 +437,7 @@ "metadata": {}, "outputs": [], "source": [ - "_ = grid.add_zeros(\"soil__depth\", at=\"node\")" + "grid.add_zeros(\"soil__depth\", at=\"node\")" ] }, { @@ -495,7 +472,6 @@ "metadata": {}, "outputs": [], "source": [ - "plt.figure()\n", "LS_size = np.array(ls.landslides_size) * grid.dx**2\n", "counts, bins = np.histogram(np.log10(LS_size), 8)\n", "plt.hist(np.log10(LS_size), log=True, bins=bins, density=True)\n", @@ -524,29 +500,33 @@ { "cell_type": "code", "execution_count": null, - "id": "e6d6b71c", + "id": "9d7a51ac", "metadata": {}, "outputs": [], "source": [ "# Landslide Erosion\n", - "cmap = copy.copy(mpl.cm.get_cmap(\"hot_r\"))\n", "imshow_grid(\n", " grid,\n", " np.sqrt(grid.at_node[\"landslide__erosion\"]),\n", " colorbar_label=\"SQRT( Landslide erosion, m) \",\n", - " cmap=cmap,\n", - ")\n", - "plt.show()\n", - "\n", + " cmap=\"hot_r\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6d6b71c", + "metadata": {}, + "outputs": [], + "source": [ "# Landslide Deposition\n", - "cmap = copy.copy(mpl.cm.get_cmap(\"winter_r\"))\n", "imshow_grid(\n", " grid,\n", " np.sqrt(grid.at_node[\"landslide__deposition\"]),\n", " colorbar_label=\"SQRT( Landslide deposition, m) \",\n", - " cmap=cmap,\n", - ")\n", - "plt.show()" + " cmap=\"winter_r\",\n", + ")" ] }, { @@ -557,7 +537,6 @@ "outputs": [], "source": [ "# Show Landslide Erosion draped over the shaded topographic relief\n", - "cmap1 = copy.copy(mpl.cm.get_cmap(\"hot_r\"))\n", "imshowhs_grid(\n", " grid,\n", " \"topographic__elevation\",\n", @@ -566,7 +545,7 @@ " var_name=\"LS \\n erosion\",\n", " var_units=r\"m\",\n", " grid_units=(\"m\", \"m\"),\n", - " cmap=cmap1,\n", + " cmap=\"hot_r\",\n", " ticks_km=False,\n", " colorbar_label_y=-55,\n", " add_label_bbox=True,\n", @@ -574,7 +553,6 @@ ")\n", "plt.show()\n", "# Show Landslide deposition draped over the shaded topographic relief\n", - "cmap1 = copy.copy(mpl.cm.get_cmap(\"winter_r\"))\n", "imshowhs_grid(\n", " grid,\n", " \"topographic__elevation\",\n", @@ -583,7 +561,7 @@ " var_name=\"LS \\n deposition\",\n", " var_units=r\"m\",\n", " grid_units=(\"m\", \"m\"),\n", - " cmap=cmap1,\n", + " cmap=\"winter_r\",\n", " ticks_km=False,\n", " colorbar_label_y=-55,\n", " add_label_bbox=True,\n", @@ -600,26 +578,24 @@ "outputs": [], "source": [ "# Show Landslide erosion and deposition draped over the shaded topographic relief\n", - "cmap1 = copy.copy(mpl.cm.get_cmap(\"Blues\"))\n", "thres_drape1 = 0.01\n", "thres_drape2 = 0.01\n", "alpha = 0.8\n", "alpha2 = 0.8\n", "drape1 = np.sqrt(grid.at_node[\"landslide__erosion\"])\n", "drape2 = np.sqrt(grid.at_node[\"landslide__deposition\"])\n", - "cmap1 = copy.copy(mpl.cm.get_cmap(\"hot_r\"))\n", - "cmap2 = copy.copy(mpl.cm.get_cmap(\"winter_r\"))\n", "plt.figure(figsize=(15, 15))\n", + "\n", "imshowhs_grid(\n", " grid,\n", " \"topographic__elevation\",\n", " plot_type=\"Drape2\",\n", " drape1=drape1,\n", - " cmap=cmap1,\n", + " cmap=\"hot_r\",\n", " thres_drape1=thres_drape1,\n", " alpha=alpha,\n", " drape2=drape2,\n", - " cmap2=cmap2,\n", + " cmap2=\"winter_r\",\n", " thres_drape2=thres_drape2,\n", " alpha2=alpha2,\n", " add_double_colorbar=True,\n", @@ -627,9 +603,7 @@ " cbar_label_color=\"red\",\n", " cbar_label_fontweight=\"normal\",\n", " add_label_bbox=True,\n", - ")\n", - "\n", - "plt.show()" + ")" ] }, { @@ -668,7 +642,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.11.0" } }, "nbformat": 4, diff --git a/lessons/landlab/landlab/fault-scarp.ipynb b/lessons/landlab/landlab/fault-scarp.ipynb index b567b28..391da04 100644 --- a/lessons/landlab/landlab/fault-scarp.ipynb +++ b/lessons/landlab/landlab/fault-scarp.ipynb @@ -39,9 +39,7 @@ "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "%matplotlib inline" + "import numpy as np" ] }, { @@ -156,8 +154,13 @@ "\n", "In Part 3 we will use the HexagonalModelGrid. \n", "\n", - "In Part 4 we will use the LinearDiffuser component. \n", - "\n", + "In Part 4 we will use the LinearDiffuser component. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "## Part 2: 2D version using Landlab's Model Grids\n", "\n", "The Landlab model grids are data structures that represent the model domain (the variable `x` in our prior example). Here we will use `RasterModelGrid` which creates a grid with regularly spaced square grid elements. The RasterModelGrid knows how the elements are connected and how far apart they are.\n", @@ -251,7 +254,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### *Exercises for section 2a*\n", + "#### Exercises for section 2a\n", "\n", "(2a.1) Create an instance of a `RasterModelGrid` with 5 rows and 7 columns, with a spacing between nodes of 10 units. Plot the node layout, and identify the ID number of the center-most node." ] @@ -560,7 +563,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### *Exercises for section 2b*\n", + "#### Exercises for section 2b\n", "\n", "(2b .1) Create an instance of a `RasterModelGrid` called `mygrid`, with 16 rows and 25 columns, with a spacing between nodes of 5 meters. Use the `plot` function in the `matplotlib` library to make a plot that shows the position of each node marked with a dot (hint: see the plt.plot() example above)." ] @@ -752,7 +755,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### *Exercises for section 2c*\n", + "#### Exercises for section 2c\n", "\n", "(2c.1) Make a 3x3 `RasterModelGrid` called `tinygrid`, with a cell spacing of 2 m. Use the `plot_graph` function to display the nodes and their ID numbers." ] @@ -937,7 +940,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### *Exercises for section 3*\n", + "#### Exercises for section 3\n", "\n", "(3.1-6) Repeat the exercises from section 2c, but this time using a hexagonal tiny grid called `tinyhex`. Your grid should have 7 nodes: one core node and 6 perimeter nodes. (Hints: use `node_layout = 'hex'`, and make a grid with 3 rows and 2 base-row columns.)" ] @@ -1085,7 +1088,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### *Exercises for section 4*\n", + "### Exercises for section 4\n", "\n", "(4.1) Repeat the steps above that instantiate and run a `LinearDiffuser` component, but this time give it a `RasterModelGrid`. Use `imshow_grid` to display the topography below." ] @@ -1167,7 +1170,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### *SOLUTION (derivation)*\n", + "#### SOLUTION (derivation)\n", "\n", "##### Derivation of the original governing equation\n", "\n", @@ -1302,8 +1305,15 @@ "source": [ "Congratulations on making it to the end of this tutorial!\n", "\n", - "### Click here for more Landlab tutorials" + "**Click here for more** Landlab tutorials" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1323,7 +1333,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.11.0" } }, "nbformat": 4, diff --git a/lessons/landlab/landlab/intro-to-grids.ipynb b/lessons/landlab/landlab/intro-to-grids.ipynb index df471e0..6d98817 100644 --- a/lessons/landlab/landlab/intro-to-grids.ipynb +++ b/lessons/landlab/landlab/intro-to-grids.ipynb @@ -7,6 +7,25 @@ "" ] }, + { + "cell_type": "markdown", + "metadata": { + "tags": [ + "toc" + ] + }, + "source": [ + "# Table of Contents\n", + "* [Introduction to Landlab: Grids and simple 2D models](#Introduction-to-Landlab:-Grids-and-simple-2D-models)\n", + " * [What types of problems can Landlab solve?](#What-types-of-problems-can-Landlab-solve?)\n", + " * [What you need to know about Landlab grids](#What-you-need-to-know-about-Landlab-grids)\n", + " * [Explore the Landlab grids](#Explore-the-Landlab-grids)\n", + " * [Add fields and manipulate boundaries](#Add-fields-and-manipulate-boundaries)\n", + " * [Gradients](#Gradients)\n", + " * [Sediment diffusion](#Sediment-diffusion)\n", + " * [Sediment diffusion with a Landlab component](#Sediment-diffusion-with-a-Landlab-component)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -72,21 +91,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### (a) Explore the Landlab grids\n", + "### Explore the Landlab grids\n", "\n", "First let's visualize the types of grids that Landlab supports. The most common is the `RasterModelGrid`, but different grid types are useful for different applications. We'll start by importing a couple different grid libraries, plus some tools that will help us visualize the grids." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# import libraries\n", - "from landlab import RasterModelGrid, HexModelGrid\n", - "from landlab.plot.graph import plot_graph\n", - "from landlab import imshow_grid" + "from landlab import HexModelGrid, RasterModelGrid, imshow_grid\n", + "from landlab.plot.graph import plot_graph" ] }, { @@ -98,19 +115,19 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "tags": [] }, "outputs": [], "source": [ "# get info on RasterModelGrid\n", - "?RasterModelGrid" + "RasterModelGrid?" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -127,30 +144,9 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# visualize nodes\n", "plot_graph(rmg, at=\"node\")" @@ -165,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -173,42 +169,25 @@ ] }, { - "cell_type": "code", - "execution_count": 6, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_graph(rmg, at=\"link\")" + "source": [ + "
\n", + " 👉 click to see solution\n", + "\n", + "```python\n", + "plot_graph(rmg, at=\"link\")\n", + "```\n", + "
" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -216,37 +195,20 @@ ] }, { - "cell_type": "code", - "execution_count": 8, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "plot_graph(rmg, at=\"cell\")" + "
\n", + " 👉 click to see solution\n", + "\n", + "```python\n", + "plot_graph(rmg, at=\"cell\")\n", + "```\n", + "
" ] }, { @@ -258,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -268,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -276,38 +238,25 @@ ] }, { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_graph(hmg, at=\"node\")" + "cell_type": "markdown", + "metadata": { + "tags": [ + "solution" + ] + }, + "source": [ + "
\n", + " 👉 click to see solution\n", + "\n", + "```python\n", + "plot_graph(hmg, at=\"node\")\n", + "```\n", + "
" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -315,93 +264,45 @@ ] }, { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_graph(hmg, at=\"link\")" + "cell_type": "markdown", + "metadata": { + "tags": [ + "solution" + ] + }, + "source": [ + "
\n", + " 👉 click to see solution\n", + "\n", + "```python\n", + "plot_graph(hmg, at=\"link\")\n", + "```\n", + "
" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# plot cells" ] }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_graph(hmg, at=\"cell,face\")" - ] - }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "tags": [ + "solution" + ] + }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# plot nodes\n", - "plot_graph(hmg, at=\"node\")\n", - "\n", - "# plot links\n", - "plot_graph(hmg, at=\"link\")\n", - "\n", - "# plot cells\n", - "plot_graph(hmg, at=\"cell, face\")\n", + "plot_graph(hmg, at=\"cell,face\")\n", "```\n", - " \n", "
" ] }, @@ -414,20 +315,9 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "12" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# find number of nodes\n", "rmg.number_of_nodes" @@ -442,20 +332,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# find number of core nodes here\n", "rmg.number_of_core_nodes" @@ -470,20 +349,9 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([5, 6])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# get index values of core nodes\n", "rmg.core_nodes" @@ -493,7 +361,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### (b) Add fields and manipulate boundaries (but first, a quick interlude about boundary and core nodes)\n", + "### Add fields and manipulate boundaries\n", + "\n", + "**(but first, a quick interlude about boundary and core nodes)**\n", "\n", "At this point, we've alluded to there being more than one type of grid node. Indeed, there are two types: \"boundary\" and \"core\" nodes. What's up with these? Very simply, boundary nodes form the perimeter of the grid. They can be given boundary conditions, such as constant sediment flux, or constant base-level lowering. They can also be set to be \"open\" or \"closed.\" This will make more sense as we move through this next section, in which we start to attach values to grid elements. \n", "\n", @@ -502,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -519,20 +389,9 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "numpy.ndarray" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# print the data type of \"z\"\n", "type(z)" @@ -540,20 +399,9 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "12" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# print the length of \"z\"\n", "len(z)" @@ -568,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -579,44 +427,22 @@ "# print array" ] }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0. 0. 0. 0. 5. 3.6 0. 0. 0. 0. 0. ]\n" - ] - } - ], - "source": [ - "z[rmg.core_nodes[0]] = 5.0\n", - "z[rmg.core_nodes[1]] = 3.6\n", - "print(z)" - ] - }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "tags": [ + "solution" + ] + }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# set elevation of first core node\n", "z[rmg.core_nodes[0]] = 5.0\n", - "\n", - "# set elevation for next core node\n", "z[rmg.core_nodes[1]] = 3.6\n", - "\n", - "# print array\n", "print(z)\n", "```\n", - "\n", "
" ] }, @@ -624,28 +450,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In addition to printing the array, we can also use the `imshow_grid` library that we imported at the top of this notebook to visulize these grid values. `imshow_grid` takes two arguments: first, the name of the grid that we're working with, and second, the name of the field that we're trying to visualize." + "In addition to printing the array, we can also use the `grid.imshow` method to visulize these grid values. `imshow` takes one arguments: the name of the grid that we're working with." ] }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# visualize topographic elevation field\n", - "imshow_grid(rmg, \"topographic__elevation\")" + "rmg.imshow(\"topographic__elevation\")" ] }, { @@ -657,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -665,61 +480,27 @@ ] }, { - "cell_type": "code", - "execution_count": 26, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rmg.add_zeros(\"soil__depth\", at=\"node\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# add soil depth field here\n", "rmg.add_zeros(\"soil__depth\", at=\"node\")\n", "```\n", - "\n", - "
\n" + "" ] }, { "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['topographic__elevation', 'soil__depth']" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# see all fields associated with grid\n", "rmg.at_node.keys()" @@ -734,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -746,7 +527,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### (c) Gradients\n", + "### Gradients\n", "\n", "Many earth science problems depend on spatial gradients on the landscape. Let's say we want to find the topographic gradient between each pair of adjacent nodes on `rmg`. This is information that is associated not with the grid nodes, but instead with grid links that connect nodes. Let's take a closer look at links." ] @@ -755,7 +536,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "##### What are links?\n", + "**What are links?**\n", "\n", "For each pair of adjacent nodes in a Landlab grid, there is a corresponding **link**. Links are directed line segments whose endpoints are the coordinates of the nodes. A link can be illustrated like this:\n", "\n", @@ -804,30 +585,9 @@ }, { "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# check out the nodes and links\n", "plot_graph(rmg, at=\"node, link\")" @@ -842,18 +602,9 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0. 0. 0. 0. 0.5 0.36 0. 0.5 -0.14 -0.36 0. -0.5\n", - " -0.36 0. 0. 0. 0. ]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# create a gradient array\n", "dzdx = rmg.calc_grad_at_link(z)\n", @@ -897,20 +648,9 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0., 0., 0.])" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# check out values associated with first three horizontal links\n", "dzdx[0:3]" @@ -925,20 +665,9 @@ }, { "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0. , 0.5 , 0.36, 0. ])" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# now check out values associated with first four vertical links\n", "dzdx[3:7]" @@ -953,20 +682,9 @@ }, { "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0. , 0. , 0. , 0.5 , -0.14, -0.36, 0. , 0. , 0. ])" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# get all of the values of horizontal links\n", "dzdx[rmg.horizontal_links]" @@ -974,7 +692,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -982,50 +700,27 @@ ] }, { - "cell_type": "code", - "execution_count": 35, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0. , 0.5 , 0.36, 0. , 0. , -0.5 , -0.36, 0. ])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dzdx[rmg.vertical_links]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# get all of the values of vertical links\n", "dzdx[rmg.vertical_links]\n", "```\n", - "\n", - "
\n" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### (d) Sediment diffusion\n", + "### Sediment diffusion\n", "\n", "Finally, we can put together the basics of Landlab with some geomorphic soil transport laws to write a quick-n-easy diffusion model! First, we'll need to tackle a tiny bit of math.\n", "\n", @@ -1055,7 +750,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1063,31 +758,19 @@ ] }, { - "cell_type": "code", - "execution_count": 37, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "mg = RasterModelGrid((25, 25), 10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# create your grid here\n", "mg = RasterModelGrid((25, 25), 10)\n", "```\n", - "\n", "
" ] }, @@ -1104,17 +787,9 @@ }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2000.0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# transport coefficient, aka hillslope diffusivity\n", "D = 0.01\n", @@ -1135,7 +810,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1143,31 +818,19 @@ ] }, { - "cell_type": "code", - "execution_count": 40, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "elev = mg.add_zeros(\"topographic__elevation\", at=\"node\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# create elevation field here\n", "elev = mg.add_zeros(\"topographic__elevation\", at=\"node\")\n", "```\n", - "\n", "
" ] }, @@ -1180,7 +843,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1197,7 +860,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1205,43 +868,20 @@ ] }, { - "cell_type": "code", - "execution_count": 43, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "imshow_grid(mg, \"topographic__elevation\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# display landscape\n", - "imshow_grid(mg, \"topographic__elevation\")\n", + "mg.imshow(\"topographic__elevation\")\n", "```\n", - "\n", - "
\n" + "" ] }, { @@ -1253,7 +893,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1261,32 +901,20 @@ ] }, { - "cell_type": "code", - "execution_count": 45, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "qs = mg.add_zeros(\"sediment__flux\", at=\"link\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# create sediment flux field here\n", "qs = mg.add_zeros(\"sediment__flux\", at=\"link\")\n", "```\n", - "\n", - "
\n" + "" ] }, { @@ -1298,7 +926,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1306,32 +934,20 @@ ] }, { - "cell_type": "code", - "execution_count": 47, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "mg.set_closed_boundaries_at_grid_edges(True, False, True, False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# close left and right boundaries\n", "mg.set_closed_boundaries_at_grid_edges(True, False, True, False)\n", "```\n", - "\n", - "
\n" + "" ] }, { @@ -1349,7 +965,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1357,40 +973,24 @@ ] }, { - "cell_type": "code", - "execution_count": 49, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "for i in range(25):\n", - " g = mg.calc_grad_at_link(elev)\n", - " qs[mg.active_links] = -D * g[mg.active_links]\n", - " dzdt = -mg.calc_flux_div_at_node(qs)\n", - " elev[mg.core_nodes] += dzdt[mg.core_nodes] * dt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# write for loop to evolve landscape\n", - "for i in range(25):\n", + "for _ in range(25):\n", " g = mg.calc_grad_at_link(elev)\n", " qs[mg.active_links] = -D * g[mg.active_links]\n", " dzdt = -mg.calc_flux_div_at_node(qs)\n", " elev[mg.core_nodes] += dzdt[mg.core_nodes] * dt\n", "```\n", - "\n", - "
\n" + "" ] }, { @@ -1402,23 +1002,12 @@ }, { "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# display your final landscape\n", - "imshow_grid(mg, \"topographic__elevation\")" + "mg.imshow(\"topographic__elevation\")" ] }, { @@ -1432,7 +1021,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### (e) Sediment diffusion with a Landlab component\n", + "### Sediment diffusion with a Landlab component\n", "\n", "Finally, we'll take a look at how Landlab components can simplify model creation even further.\n", "\n", @@ -1452,7 +1041,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1468,20 +1057,9 @@ }, { "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "('topographic__elevation',)" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# check out input variable names\n", "LinearDiffuser.input_var_names" @@ -1498,23 +1076,9 @@ }, { "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "name: topographic__elevation\n", - "description:\n", - " Land surface topographic elevation\n", - "units: m\n", - "unit agnostic: True\n", - "at: node\n", - "intent: inout\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# ask for info related to the input variable 'topographic__elevation'\n", "LinearDiffuser.var_help(\"topographic__elevation\")" @@ -1524,19 +1088,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "If we want to see the complete documentation, we can also access this information using `?`, similar to how we accessed information from `RasterModelGrid` in part (a) (Explore the Landlab grids)." + "If we want to see the complete documentation, we can also access this information using `?`, similar to how we accessed information from `RasterModelGrid` in part [Explore the Landlab grids](#Explore-the-Landlab-grids)." ] }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "metadata": { "tags": [] }, "outputs": [], "source": [ "# recall the question mark notation used to access documentation in Landlab\n", - "?LinearDiffuser" + "LinearDiffuser?" ] }, { @@ -1545,7 +1109,7 @@ "source": [ "Note we haven't needed to instantiate the component in order to access any of this information. Instantiation occurs when we create a unique instance of the component with specific variables and parameter values (just like how we created instances of `RasterModelGrid` above with unique names, dimensions, and grid spacing.) Don't worry if this is confusing right now - it will make sense momentarily. \n", "\n", - "Since we know `LinearDiffuser` requires a topographic elevation field in order to be instantiated, we need to create that field. Recall that `topographic__elevation` is tied to grid nodes, so we actually need to create a grid instance, and add the `topographic__elevation` field onto the grid. This is just like the steps we took in part (d) (Sediment diffusion) of this tutorial." + "Since we know `LinearDiffuser` requires a topographic elevation field in order to be instantiated, we need to create that field. Recall that `topographic__elevation` is tied to grid nodes, so we actually need to create a grid instance, and add the `topographic__elevation` field onto the grid. This is just like the steps we took in part [Sediment diffusion](#Sediment-diffusion) of this tutorial." ] }, { @@ -1557,7 +1121,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1565,32 +1129,20 @@ ] }, { - "cell_type": "code", - "execution_count": 56, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "new_grid = RasterModelGrid((25, 25), 10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# create a new grid here\n", "new_grid = RasterModelGrid((25, 25), 10)\n", "```\n", - "\n", - "
\n" + "" ] }, { @@ -1599,16 +1151,16 @@ "source": [ "Great, we now have a grid on which we can implement our diffusion component. Recall, however, our diffusion equation from above:\n", "\n", - "$$\\frac{\\partial z}{\\partial t} = D \\nabla^2 z$$.\n", + "$$\\frac{\\partial z}{\\partial t} = D \\nabla^2 z$$\n", "\n", - "As before, we need some topographic variation in order to drive diffusion. We'll still need to add our `topographic__elevation` field manually, and we'll need to create a \"fault\" on the grid by elevating half of the nodes. Let's do this now, following the format we used in (d) (Sediment diffusion).\n", + "As before, we need some topographic variation in order to drive diffusion. We'll still need to add our `topographic__elevation` field manually, and we'll need to create a \"fault\" on the grid by elevating half of the nodes. Let's do this now, following the format we used in [Sediment diffusion](#Sediment-diffusion).\n", "\n", - "Hint: in (d) (Sediment diffusion), we saved our elevation data to an array named `elev`. Be sure to give your elevation array a different name here - perhaps `new_elev`." + "Hint: in [Sediment diffusion](#Sediment-diffusion), we saved our elevation data to an array named `elev`. Be sure to give your elevation array a different name here - perhaps `new_elev`." ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1617,38 +1169,25 @@ ] }, { - "cell_type": "code", - "execution_count": 58, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "new_elev = new_grid.add_zeros(\"topographic__elevation\", at=\"node\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# add a field of zeros called \"topographic__elevation\" and attach it to the grid nodes\n", - "# save the field to an array with a new name\n", "new_elev = new_grid.add_zeros(\"topographic__elevation\", at=\"node\")\n", "```\n", - "\n", - "
\n" + "" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1656,65 +1195,42 @@ ] }, { - "cell_type": "code", - "execution_count": 60, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "new_elev[new_grid.y_of_node > 120] += 10" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# now elevate the upper half of the landscape, following the `node_of_y` method used in part (d)\n", "new_elev[new_grid.y_of_node > 120] += 10\n", "```\n", - "\n", - "
\n" + "" ] }, { "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# now display the landscape\n", - "imshow_grid(new_grid, \"topographic__elevation\")" + "new_grid.imshow(\"topographic__elevation\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As in part (d) (Sediment diffusion), let's close the left and right grid boundaries." + "As in part [Sediment diffusion](#Sediment-diffusion), let's close the left and right grid boundaries." ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1731,7 +1247,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1743,12 +1259,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Great, we now have an instance of our model. Next, use the `run_one_step` method with a timestep `dt` on `diffusion_model` in a `for` loop in order to evolve our faulted landscape. As in part (d) (Sediment diffusion), run the loop for 25 steps. Use the same timestep, `dt`, as defined above. " + "Great, we now have an instance of our model. Next, use the `run_one_step` method with a timestep `dt` on `diffusion_model` in a `for` loop in order to evolve our faulted landscape. As in part [Sediment diffusion](#Sediment-diffusion), run the loop for 25 steps. Use the same timestep, `dt`, as defined above. " ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1757,84 +1273,59 @@ ] }, { - "cell_type": "code", - "execution_count": 65, + "cell_type": "markdown", "metadata": { "tags": [ "solution" ] }, - "outputs": [], - "source": [ - "for _ in range(25):\n", - " diffusion_model.run_one_step(dt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", - "# create your for loop here\n", - "# hint: you only need two lines of code in this cell to run the model\n", "for _ in range(25):\n", " diffusion_model.run_one_step(dt)\n", "```\n", - "\n", - "
\n" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Great, now visualize your landscape to see if it looks similar to the 5-line model you created in part (d) (Sediment diffusion)." + "Great, now visualize your landscape to see if it looks similar to the 5-line model you created in part [Sediment diffusion](#Sediment-diffusion)." ] }, { "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# visualize landscape\n", - "imshow_grid(new_grid, \"topographic__elevation\")" + "new_grid.imshow(\"topographic__elevation\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Fantastic! Your final output should look very simialr to the diffusion model you created in part (d) (Sediment diffusion), but here you can see that using a Landlab component to simulate the diffusion process has simplified your `for` loop even further. You can appreciate how valuable this simplicity is, especially if you wanted to couple several components together (for example, flow routing, fluvial erosion, and hillslope diffusion) in order to evolve a more complex landscape.\n", + "Fantastic! Your final output should look very simialr to the diffusion model you created in part [Sediment diffusion](#Sediment-diffusion), but here you can see that using a Landlab component to simulate the diffusion process has simplified your `for` loop even further. You can appreciate how valuable this simplicity is, especially if you wanted to couple several components together (for example, flow routing, fluvial erosion, and hillslope diffusion) in order to evolve a more complex landscape.\n", "\n", "As a final, fun exercise, check out the `LinearDiffuser` documentation using `?` once again. See if you can find the list of input parameters. These are listed in the order of the arguments taken by the component; the first one will always be `grid`. " ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": null, "metadata": { "tags": [] }, "outputs": [], "source": [ "# check out the optional variables\n", - "?LinearDiffuser" + "LinearDiffuser?" ] }, { @@ -1854,8 +1345,15 @@ "source": [ "Congratulations on making it to the end of this tutorial!\n", "\n", - "### Click here for more Landlab tutorials" + "**Click here for more** Landlab tutorials" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/lessons/landlab/landlab/overland_flow.ipynb b/lessons/landlab/landlab/overland_flow.ipynb index f98a307..ba94c99 100644 --- a/lessons/landlab/landlab/overland_flow.ipynb +++ b/lessons/landlab/landlab/overland_flow.ipynb @@ -39,10 +39,9 @@ "outputs": [], "source": [ "import numpy as np\n", - "from matplotlib.pyplot import figure\n", - "\n", "from landlab.components.overland_flow import OverlandFlow\n", - "from landlab.io.esri_ascii import read_esri_ascii" + "from landlab.io.esri_ascii import read_esri_ascii\n", + "from matplotlib.pyplot import figure" ] }, { diff --git a/lessons/landlab/landlab/practice-your-skills.ipynb b/lessons/landlab/landlab/practice-your-skills.ipynb index c21e15a..05d019d 100644 --- a/lessons/landlab/landlab/practice-your-skills.ipynb +++ b/lessons/landlab/landlab/practice-your-skills.ipynb @@ -7,6 +7,21 @@ "" ] }, + { + "cell_type": "markdown", + "metadata": { + "tags": [ + "toc" + ] + }, + "source": [ + "# Table of Contents\n", + "* [Introduction to Landlab: Grids, Landlab as a solver for advection-diffusion problems, some demos](#Introduction-to-Landlab:-Grids,-Landlab-as-a-solver-for-advection-diffusion-problems,-some-demos)\n", + " * [Use Landlab to solve the problem Eyjafjallajökull problem](#Use-Landlab-to-solve-the-problem-Eyjafjallajökull-problem)\n", + " * [Preparation](#Preparation)\n", + " * [Advection diffusion](#Advection-diffusion)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -20,11 +35,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### *Use Landlab to solve the eyjafjallajökull problem*\n", + "## Use Landlab to solve the problem Eyjafjallajökull problem\n", "\n", - "#### Preparation: \n", + "### Preparation\n", "\n", - "load the map of Europe, plot the location of the eyjafjallajökull and Brussels" + "Load the map of Europe, plot the location of the Eyjafjallajökull and Brussels\n" ] }, { @@ -72,10 +87,9 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "from landlab import RasterModelGrid\n", "\n", "rows, cols = 100, 140\n", @@ -88,7 +102,8 @@ "\n", "volcano_node = europe.find_nearest_node((volcano_x, volcano_y))\n", "brussels_node = europe.find_nearest_node((brussels_x, brussels_y))\n", - "```\n" + "```\n", + "
" ] }, { @@ -116,13 +131,13 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "print(f\"number of nodes = {europe.number_of_nodes}\")\n", "print(f\"number of core nodes = {europe.number_of_core_nodes}\")\n", - "```\n" + "```\n", + "
" ] }, { @@ -150,12 +165,12 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "europe.add_zeros(\"Aerosol\", at=\"node\", clobber=True)\n", - "```\n" + "```\n", + "
" ] }, { @@ -183,14 +198,14 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "C_ini = 10.0\n", "europe.at_node[\"Aerosol\"][volcano_node] = C_ini\n", "europe.imshow(\"Aerosol\", at=\"node\")\n", - "```\n" + "```\n", + "
" ] }, { @@ -208,7 +223,7 @@ "metadata": {}, "outputs": [], "source": [ - "def plot_aerosol(grid, a):\n", + "def plot_aerosol(grid, a): \n", " plt.plot(volcano_x, volcano_y, marker=\"^\", markersize=10)\n", " plt.plot(brussels_x, brussels_y, marker=\"*\", markersize=10)\n", " plt.scatter(europe_coast[:, 0], europe_coast[:, 1], s=0.5, c=\"r\")\n", @@ -219,10 +234,10 @@ " grid.imshow(\n", " a_plt, cmap=\"inferno_r\", color_for_background=None, color_for_closed=None\n", " )\n", - "\n", + " \n", " # plt.plot(volcano_x, volcano_y, s=5, c=\"k\")\n", " # plt.plot(brussels_x, brussels_y, s=5, c=\"g\")\n", - "\n", + " \n", " plt.show()\n", "\n", "\n", @@ -273,14 +288,14 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "qa = europe.add_zeros(\"aerosol_flux\", at=\"link\")\n", "print(europe.number_of_links)\n", "print(len(qa))\n", - "```\n" + "```\n", + "
" ] }, { @@ -299,17 +314,17 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "# europe.set_closed_boundaries_at_grid_edges(True, True, True, True)\n", "\n", "europe.status_at_node[europe.nodes_at_right_edge] = europe.BC_NODE_IS_CLOSED\n", "europe.status_at_node[europe.nodes_at_top_edge] = europe.BC_NODE_IS_CLOSED\n", "europe.status_at_node[europe.nodes_at_left_edge] = europe.BC_NODE_IS_CLOSED\n", "europe.status_at_node[europe.nodes_at_bottom_edge] = europe.BC_NODE_IS_CLOSED\n", - "```\n" + "```\n", + "
" ] }, { @@ -380,10 +395,9 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "for step in range(n_steps):\n", " g = europe.calc_grad_at_link(\"Aerosol\")\n", " qa[europe.active_links] = -D * g[europe.active_links]\n", @@ -394,7 +408,8 @@ " if step % 100 == 0:\n", " print(f\"Time is: {step * dt} days\")\n", " plot_aerosol(europe, europe.at_node[\"Aerosol\"])\n", - "```\n" + "```\n", + "
" ] }, { @@ -418,7 +433,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Advection diffusion: \n", + "## Advection diffusion\n", + "\n", "We have solved the diffusion part of the volcanic ash problem imposed by the eyjafjallajökull volcano. However, most of the ash transport was induced by wind fields advection the ash towards Europe (yup, west winds). Can you come up with a landlab implementation of the advection equation? Copy paste your solution from exercise () and add some lines to solve the 2D advection equation:\n", "\n", "$$\\frac{\\partial C}{\\partial t} +v \\frac{\\partial C}{\\partial x} +u \\frac{\\partial C}{\\partial y}=0\n", @@ -513,10 +529,9 @@ }, "source": [ "
\n", - " Click for a solution\n", + " 👉 click to see solution\n", "\n", "```python\n", - "\n", "v = 1.5\n", "u = -.5\n", "C_n = 200\n", @@ -581,7 +596,8 @@ " \n", "plt.figure()\n", "plt.plot(range(n_steps) * dt,aerosol_at_brussels)\n", - "```\n" + "```\n", + "
" ] }, { @@ -592,7 +608,7 @@ "\n", "Congratulations on making it to the end of this tutorial!\n", "\n", - "### Click here for more Landlab tutorials" + "**Click here for more** Landlab tutorials" ] } ], diff --git a/lessons/landlab/landlab/tidal_flow_calculator.ipynb b/lessons/landlab/landlab/tidal_flow_calculator.ipynb index 04704aa..ccbe175 100644 --- a/lessons/landlab/landlab/tidal_flow_calculator.ipynb +++ b/lessons/landlab/landlab/tidal_flow_calculator.ipynb @@ -106,7 +106,6 @@ "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "\n", "from landlab import RasterModelGrid, imshow_grid\n", "from landlab.components import TidalFlowCalculator\n", "from landlab.grid.mappers import map_link_vector_components_to_node"