diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution.ipynb index fcb9221..0dad97f 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution.ipynb @@ -115,6 +115,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution_solution.ipynb index 18f9165..b61bb94 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicCh_steady_solution_solution.ipynb @@ -115,6 +115,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution.ipynb index d54a90d..4b1b474 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution.ipynb @@ -94,6 +94,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", @@ -130,6 +132,7 @@ "# initialize the model by passing the correct arguments and\n", "# keyword arguments.\n", "\n", + "\n", "model = BasicRt(\n", " clock,\n", " grid,\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution_solution.ipynb index 111922e..00d786b 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicRt_steady_solution_solution.ipynb @@ -93,6 +93,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", @@ -129,6 +131,7 @@ "# initialize the model by passing the correct arguments and\n", "# keyword arguments.\n", "\n", + "\n", "model = BasicRt(\n", " clock,\n", " grid,\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution.ipynb index fa70564..85b36e1 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution.ipynb @@ -125,6 +125,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution_solution.ipynb index 53cbfc2..dee6b48 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basicVs_steady_solution_solution.ipynb @@ -125,6 +125,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution.ipynb index d6591f9..f3793a5 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution.ipynb @@ -114,6 +114,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution_solution.ipynb index b196191..b0c79a3 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_steady_solution_solution.ipynb @@ -116,6 +116,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution.ipynb index fc3f1eb..2b34992 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution.ipynb @@ -112,6 +112,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution_solution.ipynb b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution_solution.ipynb index 0e7ce9a..bf78aec 100644 --- a/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution_solution.ipynb +++ b/lessons/landlab/landlab-terrainbento/coupled_process_elements/model_basic_var_m_steady_solution_solution.ipynb @@ -112,6 +112,8 @@ "outputs": [], "source": [ "# we can use an output writer to run until the model reaches steady state.\n", + "\n", + "\n", "class run_to_steady:\n", " def __init__(self, model):\n", " self.model = model\n", diff --git a/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb b/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb index c61b8df..fb8cd9e 100644 --- a/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb +++ b/lessons/landlab/landlab/bedrock_landslides_on_dems.ipynb @@ -250,6 +250,8 @@ "outputs": [], "source": [ "# These are plotting functions\n", + "\n", + "\n", "def plotting(\n", " grid, topo=True, DA=True, hill_DA=False, flow_metric=\"D8\", hill_flow_metric=\"Quinn\"\n", "):\n", diff --git a/lessons/landlab/landlab/create_a_component.a.ipynb b/lessons/landlab/landlab/create_a_component.a.ipynb index e31eb43..11b1317 100644 --- a/lessons/landlab/landlab/create_a_component.a.ipynb +++ b/lessons/landlab/landlab/create_a_component.a.ipynb @@ -197,6 +197,7 @@ "source": [ "# Type your code here: calculate time step\n", "\n", + "\n", "for _ in trange(1000):\n", " ... # Type your code here: calculate diffusion and update *z*\n", "\n", diff --git a/lessons/landlab/landlab/create_a_component.ipynb b/lessons/landlab/landlab/create_a_component.ipynb index 2aa232b..80db8e8 100644 --- a/lessons/landlab/landlab/create_a_component.ipynb +++ b/lessons/landlab/landlab/create_a_component.ipynb @@ -205,6 +205,7 @@ "source": [ "# Type your code here: calculate time step\n", "\n", + "\n", "for _ in trange(1000):\n", " ... # Type your code here: calculate diffusion and update *z*\n", "\n", diff --git a/lessons/python/rainfall_runoff.ipynb b/lessons/python/rainfall_runoff.ipynb index d2d12c6..8193014 100644 --- a/lessons/python/rainfall_runoff.ipynb +++ b/lessons/python/rainfall_runoff.ipynb @@ -132,6 +132,8 @@ "outputs": [], "source": [ "# calculate time to peak\n", + "\n", + "\n", "def calculate_time_to_peak(length, slope, t_rain):\n", " \"\"\"\n", " Calculate the time to peak of a hydrograph using the SCS-CN method.\n", @@ -165,6 +167,8 @@ "outputs": [], "source": [ "# calculate peak discharge\n", + "\n", + "\n", "def calculate_peak_discharge(area, w_eff, t_peak):\n", " \"\"\"\n", " Calculate the peak discharge of a hydrograph using the SCS-CN method.\n", @@ -245,6 +249,8 @@ "outputs": [], "source": [ "# calculate the runoff hydrograph\n", + "\n", + "\n", "def calculate_runoff_hydrograph(q_peak, t_peak, unit_hydrograph):\n", " \"\"\"\n", " Calculate the runoff hydrograph using the SCS-CN method.\n", @@ -289,6 +295,8 @@ "outputs": [], "source": [ "# create a model function\n", + "\n", + "\n", "def scs_curve_number_model(cn, area, length, slope, t_rain, w, unit_hydrograph):\n", " \"\"\"\n", " Model the runoff hydrograph using the SCS-CN method.\n", diff --git a/lessons/python/yet_another_oop.ipynb b/lessons/python/yet_another_oop.ipynb index 0e028ca..470ef49 100644 --- a/lessons/python/yet_another_oop.ipynb +++ b/lessons/python/yet_another_oop.ipynb @@ -10,14 +10,14 @@ }, { "cell_type": "code", - "execution_count": 295, + "execution_count": null, "id": "16b65d76-7454-42ab-81cb-ada3dc221ba1", "metadata": {}, "outputs": [], "source": [ "# Best practice: import everything at the top\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "import numpy as np" ] }, { @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 372, + "execution_count": null, "id": "4176e609-72bf-4670-b429-1a9d4476294a", "metadata": {}, "outputs": [], @@ -66,25 +66,32 @@ "baseline_temperature = -10.0\n", "temperature_amplitude = 25.0\n", "time_steps = np.arange(3650)\n", - "air_temperature = baseline_temperature + temperature_amplitude * np.sin(2 * np.pi / 365 * time_steps)\n", + "air_temperature = baseline_temperature + temperature_amplitude * np.sin(\n", + " 2 * np.pi / 365 * time_steps\n", + ")\n", + "\n", "\n", "# Step 2) make some functions\n", "def calc_derivative(temperature):\n", " # does something cool\n", " pass\n", "\n", + "\n", "def calc_flux(derivative):\n", " # does something also very cool\n", " pass\n", "\n", + "\n", "def calc_divergence(flux):\n", " # maybe we're not entirely sure why this works, but it does\n", " pass\n", "\n", + "\n", "def plot_results(temperature):\n", " # hopefully our array has the right shape, otherwise this might break\n", " pass\n", "\n", + "\n", "# Step 3) run the actual model\n", "for t in time_steps:\n", " dT = calc_derivative(air_temperature)\n", @@ -140,17 +147,19 @@ }, { "cell_type": "code", - "execution_count": 318, + "execution_count": null, "id": "fa2dfe7d-1459-4f95-b74d-51a2f1404475", "metadata": {}, "outputs": [], "source": [ "# \"def\" means we are defining a function\n", - "def my_function(arg_1, arg_2): # the function gets a name, \"my_function\"\n", + "\n", + "\n", + "def my_function(arg_1, arg_2): # the function gets a name, \"my_function\"\n", " # and it takes two arguments, \"arg_1\" and \"arg_2\"\n", - " result = arg_1 * arg_2 # we can make new variables inside the function\n", - " \n", - " return result # and at the end we should return something" + " result = arg_1 * arg_2 # we can make new variables inside the function\n", + "\n", + " return result # and at the end we should return something" ] }, { @@ -163,18 +172,10 @@ }, { "cell_type": "code", - "execution_count": 319, + "execution_count": null, "id": "e8160be4-5760-4136-bd19-ce6d9aa1b2e0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "200\n" - ] - } - ], + "outputs": [], "source": [ "# use the function\n", "answer = my_function(100, 2)\n", @@ -193,19 +194,10 @@ }, { "cell_type": "code", - "execution_count": 311, + "execution_count": null, "id": "b005bf79-8e9a-422f-8155-35b6d74fc733", "metadata": {}, - "outputs": [ - { - "ename": "SyntaxError", - "evalue": "incomplete input (546207509.py, line 1)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m Cell \u001b[0;32mIn[311], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m class MyModel:\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m incomplete input\n" - ] - } - ], + "outputs": [], "source": [ "class MyModel:" ] @@ -222,13 +214,12 @@ }, { "cell_type": "code", - "execution_count": 326, + "execution_count": null, "id": "d0b74872-ef9e-42f0-a8a0-b3376012c137", "metadata": {}, "outputs": [], "source": [ "class MyModel:\n", - "\n", " def __init__(self, a):\n", " self.a = a" ] @@ -251,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 327, + "execution_count": null, "id": "0cb8522a-72f5-459e-940c-463b3f0f1c79", "metadata": {}, "outputs": [], @@ -275,21 +266,10 @@ }, { "cell_type": "code", - "execution_count": 328, + "execution_count": null, "id": "e30f7525-7dc2-4970-bb56-d3ddd4918fb1", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "100" - ] - }, - "execution_count": 328, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model.a" ] @@ -304,13 +284,12 @@ }, { "cell_type": "code", - "execution_count": 332, + "execution_count": null, "id": "42d7ac94-966e-4c8b-b1d1-7651ccddff6d", "metadata": {}, "outputs": [], "source": [ "class MyModel:\n", - "\n", " def __init__(self, a):\n", " self.a = a\n", "\n", @@ -323,18 +302,10 @@ }, { "cell_type": "code", - "execution_count": 334, + "execution_count": null, "id": "0220389b-771e-4e52-b0e8-980908b9cc35", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4\n" - ] - } - ], + "outputs": [], "source": [ "model = MyModel(2)\n", "model.add(2)\n", @@ -343,18 +314,10 @@ }, { "cell_type": "code", - "execution_count": 335, + "execution_count": null, "id": "ca1e24c7-fb41-48c6-9fe7-4a77a68f5af8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4\n" - ] - } - ], + "outputs": [], "source": [ "print(model.add_and_return(2))" ] @@ -415,15 +378,15 @@ }, { "cell_type": "code", - "execution_count": 379, + "execution_count": null, "id": "e5e42cab-583e-424e-ac5b-6ce0fe372d6b", "metadata": {}, "outputs": [], "source": [ "class SimpleGlacier:\n", " \"\"\"Models the temperature profile with a glacier.\n", - " \n", - " This model is based off of: \n", + "\n", + " This model is based off of:\n", " The Physics of Glaciers (Cuffey and Paterson, 2010).\n", " Lecture notes from Andy Aschwanden (McCarthy school, summer 2012).\n", "\n", @@ -453,70 +416,20 @@ }, { "cell_type": "code", - "execution_count": 363, + "execution_count": null, "id": "bc5b6258-ea43-4a08-b1a4-6c8c06ae9f87", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class SimpleGlacier in module __main__:\n", - "\n", - "class SimpleGlacier(builtins.object)\n", - " | SimpleGlacier(z: numpy.ndarray, ice_density: float = 917.0)\n", - " | \n", - " | Models the temperature profile with a glacier.\n", - " | \n", - " | This model is based off of: \n", - " | The Physics of Glaciers (Cuffey and Paterson, 2010).\n", - " | Lecture notes from Andy Aschwanden (McCarthy school, summer 2012).\n", - " | \n", - " | Attributes:\n", - " | z: an array of z-coordinates\n", - " | \n", - " | Methods defined here:\n", - " | \n", - " | __init__(self, z: numpy.ndarray, ice_density: float = 917.0)\n", - " | Initialize the model with an array of z-coordinates.\n", - " | \n", - " | run_one_step(self, dt: float) -> numpy.ndarray\n", - " | Advance the model by one step of size dt.\n", - " | \n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors defined here:\n", - " | \n", - " | __dict__\n", - " | dictionary for instance variables\n", - " | \n", - " | __weakref__\n", - " | list of weak references to the object\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "help(SimpleGlacier)" ] }, { "cell_type": "code", - "execution_count": 364, + "execution_count": null, "id": "56c97ced-a05d-4423-955f-c12e85e24b2d", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on function run_one_step in module __main__:\n", - "\n", - "run_one_step(self, dt: float) -> numpy.ndarray\n", - " Advance the model by one step of size dt.\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "help(SimpleGlacier.run_one_step)" ] @@ -531,18 +444,10 @@ }, { "cell_type": "code", - "execution_count": 369, + "execution_count": null, "id": "3e62dcb7-d12f-4f5f-a720-46e17e4e17ca", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10000000000\n" - ] - } - ], + "outputs": [], "source": [ "model = SimpleGlacier(np.arange(10), 10000000000)\n", "print(model.ice_density)" @@ -558,18 +463,10 @@ }, { "cell_type": "code", - "execution_count": 370, + "execution_count": null, "id": "4639ce75-4725-4db7-8e86-116a74e80a51", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "917.0\n" - ] - } - ], + "outputs": [], "source": [ "model = SimpleGlacier(np.arange(10))\n", "print(model.ice_density)" @@ -589,14 +486,6 @@ "(It's up to you if you want to store that value as an attribute or return it directly.)" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "20dc1ec1-3e83-45d3-89ee-2c4a9ace143a", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "id": "2ef7596d-bb6f-4484-9c85-d435282d6d32", @@ -623,15 +512,15 @@ }, { "cell_type": "code", - "execution_count": 541, + "execution_count": null, "id": "0fe24f77-be64-4235-88b6-b7f766d72be7", "metadata": {}, "outputs": [], "source": [ "class SimpleGlacier:\n", " \"\"\"Models the temperature profile with a glacier.\n", - " \n", - " This model is based off of: \n", + "\n", + " This model is based off of:\n", " The Physics of Glaciers (Cuffey and Paterson, 2010).\n", " Lecture notes from Andy Aschwanden (McCarthy school, summer 2012).\n", "\n", @@ -649,9 +538,9 @@ "\n", " # We'll need attributes for rho, c, and k\n", " # You could also store info about boundary conditions at this point, if you want\n", - " \n", + "\n", " # Maybe we should go ahead and calculate diffusivity right away?\n", - " \n", + "\n", " # Let's keep track of the elapsed time\n", "\n", " def calc_diffusivity(self):\n", @@ -660,19 +549,19 @@ "\n", " def calc_heat_flux(self):\n", " \"\"\"The heat flux is -kappa * dT / dz.\"\"\"\n", - " \n", + "\n", " # How should we calculate the difference in temperature with depth? (hint: see dz, above)\n", "\n", " # Are dT and dz the same size? Are they the same size as z?\n", "\n", " # Don't forget to apply boundary conditions! The heat flux at the bed should be zero, for now.\n", - " \n", + "\n", " pass\n", "\n", " def calc_divergence(self):\n", " \"\"\"In 1D, divergence is just the derivative. yay!\"\"\"\n", " pass\n", - " \n", + "\n", " def run_one_step(self, dt: float) -> np.ndarray:\n", " \"\"\"Advance the model by one step of size dt.\"\"\"\n", "\n", @@ -693,21 +582,10 @@ }, { "cell_type": "code", - "execution_count": 539, + "execution_count": null, "id": "d74164bf-7cbe-47cf-a825-9bc249684fff", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# The Greenland ice sheet is 3,053 m thick at the summit!\n", "z = np.arange(3053)\n", @@ -718,9 +596,9 @@ "\n", "# Tip: maybe you wnat to include this plotting function into your class?\n", "plt.plot(T0, z)\n", - "plt.xlabel('Temperature ($^\\circ$ C)')\n", - "plt.ylabel('Depth (m)')\n", - "plt.gca().invert_yaxis() # This forces matplotlib to invert the y-axis\n", + "plt.xlabel(r\"Temperature ($^\\circ$ C)\")\n", + "plt.ylabel(\"Depth (m)\")\n", + "plt.gca().invert_yaxis() # This forces matplotlib to invert the y-axis\n", "plt.show()" ] }, @@ -737,30 +615,18 @@ }, { "cell_type": "code", - "execution_count": 528, + "execution_count": null, "id": "d216e3d2-986e-4d3f-82c1-e6ed2fbfbc43", "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'SimpleGlacier' object has no attribute 'time_elapsed'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[528], line 7\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m365\u001b[39m): \n\u001b[1;32m 6\u001b[0m model\u001b[38;5;241m.\u001b[39mrun_one_step(dt)\n\u001b[0;32m----> 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_elapsed\u001b[49m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m31556926\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m years.\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 9\u001b[0m model\u001b[38;5;241m.\u001b[39mplot()\n", - "\u001b[0;31mAttributeError\u001b[0m: 'SimpleGlacier' object has no attribute 'time_elapsed'" - ] - } - ], + "outputs": [], "source": [ "model = SimpleGlacier(z, T0)\n", "\n", "dt = 60 * 60 * 24\n", "\n", - "for i in range(365): \n", + "for i in range(365):\n", " model.run_one_step(dt)\n", - " print(f'{model.time_elapsed / 31556926} years.')\n", + " print(f\"{model.time_elapsed / 31556926} years.\")\n", "\n", "model.plot()" ] @@ -775,7 +641,7 @@ }, { "cell_type": "code", - "execution_count": 538, + "execution_count": null, "id": "2ebbb16c-f568-4358-992f-4bfe38817afc", "metadata": {}, "outputs": [], @@ -811,26 +677,15 @@ }, { "cell_type": "code", - "execution_count": 542, + "execution_count": null, "id": "7de68364-01b1-4c34-8c43-4392411f5a4a", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Replace test_array with your results\n", "test_array = np.random.random((10, 10))\n", "\n", - "plt.imshow(test_array, cmap = 'coolwarm')\n", + "plt.imshow(test_array, cmap=\"coolwarm\")\n", "plt.colorbar()\n", "plt.show()" ] @@ -867,13 +722,12 @@ }, { "cell_type": "code", - "execution_count": 373, + "execution_count": null, "id": "d54d9620-8be3-44d5-846f-cf58b616030b", "metadata": {}, "outputs": [], "source": [ "class DiffusionModel1D:\n", - "\n", " def __init__(self):\n", " pass\n", "\n", @@ -892,14 +746,15 @@ }, { "cell_type": "code", - "execution_count": 548, + "execution_count": null, "id": "9bdc456b-4425-48ef-8b5f-aa9a42a33abe", "metadata": {}, "outputs": [], "source": [ "# Example of a child class\n", - "class DiffusionChild(DiffusionModel1D):\n", "\n", + "\n", + "class DiffusionChild(DiffusionModel1D):\n", " def __init__(self):\n", " pass\n", "\n", @@ -909,21 +764,10 @@ }, { "cell_type": "code", - "execution_count": 547, + "execution_count": null, "id": "df9ab5b5-a885-4219-b49f-32cbf7dfee25", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on function run_one_step in module __main__:\n", - "\n", - "run_one_step(self)\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "help(DiffusionChild.run_one_step)" ] @@ -938,22 +782,10 @@ }, { "cell_type": "code", - "execution_count": 549, + "execution_count": null, "id": "1474651c-a28b-4c5a-92ed-271be7b98b9a", "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "type object 'DiffusionModel1D' has no attribute 'no_parents_allowed'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[549], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m help(\u001b[43mDiffusionModel1D\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mno_parents_allowed\u001b[49m)\n", - "\u001b[0;31mAttributeError\u001b[0m: type object 'DiffusionModel1D' has no attribute 'no_parents_allowed'" - ] - } - ], + "outputs": [], "source": [ "help(DiffusionModel1D.no_parents_allowed)" ] diff --git a/pytest.ini b/pytest.ini index a9afe8f..005a26a 100644 --- a/pytest.ini +++ b/pytest.ini @@ -7,11 +7,7 @@ addopts = --strict-markers --doctest-modules -vvv - --ignore-glob=*/Landlab_grids.ipynb --ignore-glob=*/practice-your-skills.ipynb - --ignore-glob=*/PracticeYourSkills-landlab.ipynb - --ignore-glob=*/PracticeYourSkills-Solution\ (DO\ not\ Remove).ipynb - --ignore-glob=*/PracticeYourSkills-Solution2\ (do\ NOT\ remove).ipynb --ignore-glob=*/Welcome_to_TerrainBento.ipynb --ignore-glob=*/bedrockLandslides_on_DEMs.ipynb --ignore-glob=*/ku-eml-paleomip.ipynb @@ -21,3 +17,4 @@ addopts = --ignore-glob=*/landlab-fault-scarp-for-espin.ipynb --ignore-glob=*/intro-to-grids.ipynb --ignore-glob=*/pymt/*.ipynb + --ignore-glob=*/python/yet_another_oop.ipynb