{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Lab 5: Daisyworld" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## List of Problems\n", "\n", "\n", "[Problem Constant](#prob_constant): Daisyworld with a constant growth rate\n", "\n", "[Problem Coupling](#prob_coupling): Daisyworld of neutral daisies coupled to\n", "the temperature\n", "\n", "[Problem Conduction](#prob_conduction): Daisyworld steady states and the effect\n", "of the conduction parameter R\n", "\n", "[Problem Initial](#prob_initial): Daisyworld steady states and initial\n", "conditions\n", "\n", "[Problem Temperature](#prob_temperature): Add temperature retrieval code\n", "\n", "[Problem Estimate](#prob_estimate): Compare the error estimate to the true\n", "error\n", "\n", "[Problem tolerances](#prob_tolerances) User specified error tolerances in\n", "stepsize control\n", "\n", "[Problem Adaptive](#prob_adaptive): Adaptive Timestep Code\n", "\n", "[Problem Predators](#prob_predator): Adding predators to Daisyworld\n" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 0 }, "source": [ "## Assignment\n", "\n", "Upload a jupyter notebook that solves the following problems -- if you\n", "want to import your own module code, include that with the notebook\n", "in a zipfile\n", "\n", "\n", "Undergrads: Upload a notebook (and, if you modify library files, include that)\n", "* A409: do Problems 1 (constant), 2 (coupling), 4 (initial), 5 (temperature), 6 (estimate)\n", "* E511: do Problems 1 (constant), 2 (coupling), 4 (initial), 5 (temperature), 6 (estimate), 8 (adaptive), 9 (predators)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Objectives\n", "\n", "In this lab, you will explore a simple environmental model,\n", "*Daisyworld*, with the help of a Runge-Kutta method with\n", "adaptive stepsize control.\n", "\n", "The goal is for you to gain some experience using a Runge-Kutta\n", "integrator and to see the advantages of applying error control to the\n", "algorithm. As well, you will discover the the possible insights one can\n", "garner from the study of numerical solutions of a physical model.\n", "\n", "In particular you will be able to:\n", "\n", "- explain how the daisies affect the climate in the daisy world model\n", "\n", "- define adaptive step-size model\n", "\n", "- explain for what reasons an adaptive step-size model maybe faster\n", " for given accuracy\n", "\n", "- explain why white daisies (alone) can survive at a higher solar\n", " constant than black daisies\n", "\n", "- define hysteresis" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Readings\n", "\n", "There is no required reading for this lab, beyond the contents of the\n", "lab itself. However, if you would like additional background on any of\n", "the following topics, then refer to the sections indicated below:\n", "\n", "- **Daisy World:**\n", "\n", " - The original article by [Watson and Lovelock, 1983](http://ezproxy.library.ubc.ca/login?url=http://onlinelibrary.wiley.com/enhanced/doi/10.1111/j.1600-0889.1983.tb00031.x) which derive the equations used here.\n", "\n", " - A 2008 Reviews of Geophysics article by [Wood et al.](http://ezproxy.library.ubc.ca/login?url=http://doi.wiley.com/10.1029/2006RG000217) with more recent developments (species competition, etc.)\n", "\n", "- **Runge-Kutta Methods with Adaptive Stepsize Control:**\n", "\n", " - Newman, Section 8.4\n", "\n", " - Press, et al. Section 16.2: these are equations we implemented in Python,\n", " [scanned pdf here](pdfs/adapt_ode.pdf)\n", "\n", " - Burden & Faires Section 5.5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Introduction\n", "\n", "It is obvious that life on earth is highly sensitive to the planet’s\n", "atmospheric and climatic conditions. What is less obvious, but of great\n", "interest, is the role biology plays in the sensitivity of the climate.\n", "This is dramatically illustrated by the concern over the possible\n", "contribution to global warming by the loss of the rain forests in\n", "Brazil.\n", "\n", "The fact that each may affect the other implies that the climate and\n", "life on earth are interlocked in a complex series of feedbacks, i.e. the\n", "climate affects the biosphere which, when altered, then changes the\n", "climate and so on. A fascinating question arises as to whether or not\n", "this would eventually lead to a stable climate. This scenerio is\n", "exploited to its fullest in the *Gaia* hypothesis which\n", "postulates that the biosphere, atmosphere, ocean and land are all part\n", "of some totality, dubbed *Gaia*, which is essentially an\n", "elaborate feedback system which optimizes the conditions of life here on\n", "earth.\n", "\n", "It would be hopeless to attempt to mathematically model such a large,\n", "complex system. What can be done instead is to construct a ’toy model’\n", "of the system in which much of the complexity has been stripped away and\n", "only some of the relevant characteristics retained. The resulting system\n", "will then be tractable but, unfortunately, may bear little connection\n", "with the original physical system.\n", "\n", "Daisyworld is such a model. Life on Daisyworld has been reduced to just\n", "two species of daisies of different colors. The only environmental\n", "condition that affects the daisy growth rate is temperature. The\n", "temperature in turn is modified by the varying amounts of radiation\n", "absorbed by the daisies.\n", "\n", "Daisyworld is obviously a gross simplification of the real earth.\n", "However, it does retain the central feature of interest: a feedback loop\n", "between the climate and life on the planet. Since the equations\n", "governing the system will be correspondingly simplified, it will allow\n", "us to investigate under what conditions, if any, that equilibrium is\n", "reached. The hope is that this will then gain us some insight into how\n", "life on the real earth may lead to a stable climate." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## The Daisyworld Model\n", "\n", "Daisyworld is populated by two types of daisies, one darker and the\n", "other lighter than the bare ground. As with life on earth, the daisies\n", "will not grow at extreme temperatures and will have optimum growth at\n", "moderate temperatures.\n", "\n", "The darker, ’black’ daisies absorb more radiation than the lighter,\n", "’white’ daisies. If the black daisy population grows and spreads over\n", "more area, an increased amount of solar energy will be absorbed, which\n", "will ultimately raise the temperature of the planet. Conversely, an\n", "increase in the white daisy population will result in more radiation\n", "being reflected away, lowering the planet’s temperature.\n", "\n", "The question to be answered is:\n", "\n", "**Under what conditions, if any, will the daisy population and\n", " temperature reach equilibrium?**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "\n", "### The Daisy Population\n", "\n", "The daisy population will be modeled along the lines of standard\n", "population ecology models where the net growth depends upon the current\n", "population. For example, the simplest model assumes the rate of growth\n", "is proportional to the population, i.e.\n", "\n", "\n", "\n", "$$\n", "\\frac{dA_w}{dt} = k_w A_w\n", "$$\n", "\n", "$$\n", "\\frac{dA_b}{dt} = k_b A_b\n", "$$\n", "\n", "where $A_w$\n", "and $A_b$ are fractions of the total planetary area covered by the white\n", "and black daisies, respectively, and $k_i$, $i=w,b$, are the white and\n", "black daisy growth rates per unit time, respectively. If assume the the\n", "growth rates $k_i$ are (positive) constants we would have exponential\n", "growth like the bunny rabbits of lore.\n", "\n", "We can make the model more realistic by letting the daisy birthrate\n", "depend on the amount of available land, i.e. $$k_i = \\beta_i x$$ where\n", "$\\beta_i$ are the white and black daisy growth rates per unit time and\n", "area, respectively, and $x$ is the fractional area of free fertile\n", "ground not colonized by either species. We can also add a daisy death\n", "rate per unit time, $\\chi$, to get\n", "\n", "\n", "\\textbf{eq: constantgrowth}\n", "$$\n", "\\frac{dA_w}{dt} = A_w ( \\beta_w x - \\chi)\n", "$$\n", "\n", "\n", "$$\n", "\\frac{dA_b}{dt} = A_b ( \\beta_b x - \\chi)\n", "$$\n", "\n", "However, even these small modifications are non-trivial mathematically\n", "as the available fertile land is given by,\n", "$$\n", " x = 1 - A_w - A_b\n", "$$\n", "\n", "(assuming all the land mass is fertile) which\n", "makes the equations non-linear." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
** Problem constant growth**
\n", "\n", "\n", "\n", "\n", "Note that though the daisy growth rate per unit\n", "time depends on the amount of available fertile land, it is not\n", "otherwise coupled to the environment (i.e. $\\beta_i$ is note a function\n", "of temperature. Making the growth a function of bare ground, however,\n", "keeps the daisy population bounded and the daisy population will\n", "eventually reach some steady state. The next python cell has a script\n", "that runs a fixed timestep Runge Kutte routine that calculates area\n", "coverage of white and black daisies for fixed growth rates $\\beta_w$ and $\\beta_b$.\n", "Try changing these growth rates (specified in the derivs5 routine) and\n", "the initial white and black concentrations (specified in the fixed_growth.yaml file\n", "discussed next).\n", "\n", "1. For a given set of growth rates try various (non-zero) initial daisy\n", " populations.\n", "\n", "2. For a given set of initial conditions try various growth rates. In\n", " particular, try rates that are both greater than and less than the\n", " death rate.\n", "\n", "3. Can you determine when non-zero steady states are achieved? Explain.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### Running the constant growth rate demo\n", "\n", "In the appendix we discuss the design of the integrator class and the adaptive Runge-Kutta\n", "routine. For this demo, we need to be able to change variables in the configuration\n", "file. For this demonstration you are asked to\n", "\n", "1. Change the inital white and black daisy concentrations by changing these lines in the\n", " [fixed_growth.yaml](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/notebooks/lab5/fixed_growth.yaml#L13-L15) input file:\n", "\n", " ```yaml\n", "\n", " initvars:\n", " whiteconc: 0.2\n", " blackconc: 0.7\n", " ```\n", "\n", "2. Change the white and black daisy growth rates by editing the variables\n", " beta_w and beta_b in the derivs5 routine in the next cell\n", "\n", "The Integrator class contains two different timeloops, both of which use embedded Runge Kutta Cash Carp\n", "code given in Lab 4 and code here as [rkckODE5](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L70). The simplest way to loop through the timesteps is just to call the\n", "integrator with a specified set of times. This is done in [timeloop5fixed](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L244). Below we will describe how to use the error extimates returned\n", "by rkckODE5 to tune the size of the timesteps,\n", "which is done in [timeloop5Err](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L244)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "******************************\n", "context imported. Front of path:\n", "/Users/phil/repos/numeric\n", "back of path: /Users/phil/.ipython\n", "******************************\n", "\n", "through /Users/phil/repos/numeric/notebooks/lab5/context.py\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#\n", "# 4.1 integrate constant growth rates with fixed timesteps\n", "#\n", "import context\n", "from numlabs.lab5.lab5_funs import Integrator\n", "from collections import namedtuple\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "class Integ51(Integrator):\n", " def set_yinit(self):\n", " #\n", " # read in 'albedo_white chi S0 L albedo_black R albedo_ground'\n", " #\n", " uservars = namedtuple('uservars', self.config['uservars'].keys())\n", " self.uservars = uservars(**self.config['uservars'])\n", " #\n", " # read in 'whiteconc blackconc'\n", " #\n", " initvars = namedtuple('initvars', self.config['initvars'].keys())\n", " self.initvars = initvars(**self.config['initvars'])\n", " self.yinit = np.array(\n", " [self.initvars.whiteconc, self.initvars.blackconc])\n", " self.nvars = len(self.yinit)\n", " return None\n", "\n", " #\n", " # Construct an Integ51 class by inheriting first intializing\n", " # the parent Integrator class (called super). Then do the extra\n", " # initialization in the set_yint function\n", " #\n", " def __init__(self, coeffFileName):\n", " super().__init__(coeffFileName)\n", " self.set_yinit()\n", "\n", " def derivs5(self, y, t):\n", " \"\"\"y[0]=fraction white daisies\n", " y[1]=fraction black daisies\n", " \n", " Constant growty rates for white\n", " and black daisies beta_w and beta_b\n", " \n", " returns dy/dt\n", " \"\"\"\n", " user = self.uservars\n", " #\n", " # bare ground\n", " #\n", " x = 1.0 - y[0] - y[1]\n", "\n", " # growth rates don't depend on temperature\n", " beta_b = 0.7 # growth rate for black daisies\n", " beta_w = 0.7 # growth rate for white daisies\n", "\n", " # create a 1 x 2 element vector to hold the derivitive\n", " f = np.empty([self.nvars], 'float')\n", " f[0] = y[0] * (beta_w * x - user.chi)\n", " f[1] = y[1] * (beta_b * x - user.chi)\n", " return f\n", "\n", "\n", "theSolver = Integ51('fixed_growth.yaml')\n", "timeVals, yVals, errorList = theSolver.timeloop5fixed()\n", "\n", "plt.close('all')\n", "thefig, theAx = plt.subplots(1, 1)\n", "theLines = theAx.plot(timeVals, yVals)\n", "theLines[0].set_marker('+')\n", "theLines[1].set_linestyle('--')\n", "theLines[1].set_color('k')\n", "theLines[1].set_marker('*')\n", "theAx.set_title('lab 5 interactive 1 constant growth rate')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('fractional coverage')\n", "theAx.legend(theLines, ('white daisies', 'black daisies'), loc='best')\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "theLines = theAx.plot(timeVals, errorList)\n", "theLines[0].set_marker('+')\n", "theLines[1].set_linestyle('--')\n", "theLines[1].set_color('k')\n", "theLines[1].set_marker('*')\n", "theAx.set_title('lab 5 interactive 1 errors')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('error')\n", "out = theAx.legend(theLines, ('white errors', 'black errors'), loc='best')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### The Daisy Growth Rate - Coupling to the Environment\n", "\n", "We now want to couple the Daisy growth rate to the climate, which we do\n", "by making the growth rate a function of the local temperature $T_i$,\n", "$$\\beta_i = \\beta_i(T_i)$$ The growth rate should drop to zero at\n", "extreme temperatures and be optimal at moderate temperatures. In\n", "Daisyworld this means the daisy population ceases to grow if the\n", "temperature drops below $5^o$C or goes above $40^o $C. The simplest\n", "model for the growth rate would then be parabolic function of\n", "temperature, lpeaking at $22.5^o$C:\n", "\n", "\n", "$$\n", "\\beta_i = 1.0 - 0.003265(295.5 K - T_i)^2\n", "$$\n", "where the $i$ subscript denotes the type of daisy: grey (i=y), whithe (i=w) or black (i=b).\n", "(We're reserving $\\alpha_g$ for the bare ground albedo)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before specifying the local temperature, and its dependence on the daisy\n", "population, first consider the emission temperature $T_e$, which is the\n", "mean temperature of the planet,\n", "\n", "\n", "\n", "$$ T^4_e = L \\frac{S_0}{4\\sigma}(1-\\alpha_p)$$\n", "\n", "where $S_0$ is a solar\n", "flux density constant, $L$ is the fraction of $S_0$ received at\n", "Daisyworld, and $\\alpha_p$ is the planetary albedo. The greater the\n", "planetary albedo $\\alpha_p$, i.e. the more solar radiation the planet\n", "reflects, the lower the emission temperature.\n", "\n", "**Mathematical note**: The emission temperature is derived on the assumption that the planet is\n", "in global energy balance and is behaving as a blackbody radiator. See\n", "the appendix for more information." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
**Problem Coupling**
\n", "\n", "Consider daisies with the same albedo as the\n", "planet, i.e. ’grey’ or neutral daisies, as specified in derivs5 routine\n", "below.\n", "\n", "1. For the current value of L (0.2) in the file coupling.yaml,\n", " the final daisy steady state is zero.\n", " Why is it zero?\n", "\n", "2. Find a value of L which leads to a non-zero steady state.\n", "\n", "3. What happens to the emission temperature as L is varied? Make a plot of\n", " $L$ vs. $T_E$ for 10-15 values of $L$. To do this, I overrode\n", " the value of L from the init file by passing a new value into\n", " the IntegCoupling constructor (see [Appendix A](#sec_override)).\n", " This allowed me to put\n", "\n", " ```\n", " theSolver = IntegCoupling(\"coupling.yaml\",newL)\n", " timeVals, yVals, errorList = theSolver.timeloop5fixed()\n", " ```\n", "\n", " inside a loop that varied the L value and saved the steady state concentration\n", " for plotting\n", "\n", "After reading the the next section on the local\n", "temperature,\n", "\n", "4. Do you see any difference between the daisy temperature and emission\n", " temperature? Plot both and explain. (Hint: I modified derivs5 to save\n", " these variables to self so I could compare their values at the end\n", " of the simulation. You could also override timeloop5fixed to do the same\n", " thing at each timestep.)\n", "\n", "5. How (i.e. thorugh what mechanism) does the makeup of the global daisy population\n", " affect the local temperature?\n", "\n", "Hand in -- notebook cells with the code, plots and your answers." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "\n", "class IntegCoupling(Integrator):\n", " \"\"\"rewrite the init and derivs5 methods to\n", " work with a single (grey) daisy\n", " \"\"\"\n", " def set_yinit(self):\n", " #\n", " # read in 'albedo_grey chi S0 L R albedo_ground'\n", " #\n", " uservars = namedtuple('uservars', self.config['uservars'].keys())\n", " self.uservars = uservars(**self.config['uservars'])\n", " #\n", " # read in 'greyconc'\n", " #\n", " initvars = namedtuple('initvars', self.config['initvars'].keys())\n", " self.initvars = initvars(**self.config['initvars'])\n", " self.yinit = np.array([self.initvars.greyconc])\n", " self.nvars = len(self.yinit)\n", " return None\n", "\n", " def __init__(self, coeffFileName):\n", " super().__init__(coeffFileName)\n", " self.set_yinit()\n", "\n", " def derivs5(self, y, t):\n", " \"\"\"\n", " Make the growth rate depend on the ground temperature\n", " using the quadratic function of temperature\n", "\n", " y[0]=fraction grey daisies\n", " t = time\n", " returns f[0] = dy/dt\n", " \"\"\"\n", " sigma = 5.67e-8 # Stefan Boltzman constant W/m^2/K^4\n", " user = self.uservars\n", " x = 1.0 - y[0]\n", " albedo_p = x * user.albedo_ground + y[0] * user.albedo_grey\n", " Te_4 = user.S0 / 4.0 * user.L * (1.0 - albedo_p) / sigma\n", " eta = user.R * user.L * user.S0 / (4.0 * sigma)\n", " temp_y = (eta * (albedo_p - user.albedo_grey) + Te_4)**0.25\n", " if (temp_y >= 277.5 and temp_y <= 312.5):\n", " beta_y = 1.0 - 0.003265 * (295.0 - temp_y)**2.0\n", " else:\n", " beta_y = 0.0\n", "\n", " # create a 1 x 1 element vector to hold the derivative\n", " f = np.empty([self.nvars], np.float64)\n", " f[0] = y[0] * (beta_y * x - user.chi)\n", " return f" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "theSolver = IntegCoupling('coupling.yaml')\n", "timeVals, yVals, errorList = theSolver.timeloop5fixed()\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "theLines = theAx.plot(timeVals, yVals)\n", "theAx.set_title('lab 5: interactive 2 Coupling with grey daisies')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('fractional coverage')\n", "out = theAx.legend(theLines, ('grey daisies', ), loc='best')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## The Local Temperature - Dependence on Surface Heat Conductivity\n", "\n", "If we now allow for black and white daisies, the local temperature will\n", "differ according to the albedo of the region. The regions with white\n", "daisies will tend to be cooler than the ground and the regions with\n", "black daisies will tend to be hotter. To determine what the temperature\n", "is locally, we need to decide how readily the planet surface\n", "thermalises, i.e. how easily large-scale weather patterns redistributes\n", "the surface heat.\n", "\n", "- If there is perfect heat ‘conduction’ between the different regions\n", " of the planet then the local temperature will equal the mean\n", " temperature given by the emission temperature $T_e$.\n", "\n", " \n", " $$\n", " T^4_i \\equiv T^4_e = L \\frac{S_0}{4\\sigma}(1-\\alpha_p)\n", " $$\n", "\n", "- If there is no conduction, or perfect ‘insulation’, between regions\n", " then the temperature will be the emission temperature due to the\n", " albedo of the local region.\n", "\n", " \n", " $$\n", " T^4_i= L \\frac{S_0}{4\\sigma}(1-\\alpha_i)\n", " $$\n", "where $\\alpha_i$ indicates either $\\alpha_g$, $\\alpha_w$ or $\\alpha_b$.\n", "\n", "The local temperature can be chosen to lie between these two values,\n", "\n", "\n", "\n", "$$\n", " T^4_i = R L \\frac{S_0}{4\\sigma}(\\alpha_p-\\alpha_i) + T^4_e\n", "$$\n", "\n", "where $R$\n", "is a parameter that interpolates between the two extreme cases i.e.\n", "$R=0$ means perfect conduction and $R=1$ implies perfect insulation\n", "between regions.\n", "\n", "
**Problem Conduction**\n", "\n", "The conduction parameter R will determine the\n", "temperature differential between the bare ground and the regions with\n", "black or white daisies. The code in the next cell specifies the derivatives\n", "for this situation, removing the feedback between the daisies and the\n", "planetary albedo but introducint conduction. Use it to investigate these two questions:\n", "\n", "1. Change the value of R and observe the effects on the daisy and\n", " emission temperature.\n", "\n", "2. What are the effects on the daisy growth rate and the final steady\n", " states?" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "#\n", "# 5.2 keep the albedo constant at alpha_p and vary the conductivity R\n", "#\n", "from numlabs.lab5.lab5_funs import Integrator\n", "\n", "\n", "class Integ53(Integrator):\n", " def set_yinit(self):\n", " #\n", " # read in 'albedo_white chi S0 L albedo_black R albedo_ground'\n", " #\n", " uservars = namedtuple('uservars', self.config['uservars'].keys())\n", " self.uservars = uservars(**self.config['uservars'])\n", " #\n", " # read in 'whiteconc blackconc'\n", " #\n", " initvars = namedtuple('initvars', self.config['initvars'].keys())\n", " self.initvars = initvars(**self.config['initvars'])\n", " self.yinit = np.array(\n", " [self.initvars.whiteconc, self.initvars.blackconc])\n", " self.nvars = len(self.yinit)\n", " return None\n", "\n", " def __init__(self, coeffFileName):\n", " super().__init__(coeffFileName)\n", " self.set_yinit()\n", "\n", " def derivs5(self, y, t):\n", " \"\"\"y[0]=fraction white daisies\n", " y[1]=fraction black daisies\n", " no feedback between daisies and\n", " albedo_p (set to ground albedo)\n", " \"\"\"\n", " sigma = 5.67e-8 # Stefan Boltzman constant W/m^2/K^4\n", " user = self.uservars\n", " x = 1.0 - y[0] - y[1]\n", " #\n", " # hard wire the albedo to that of the ground -- no daisy feedback\n", " #\n", " albedo_p = user.albedo_ground\n", " Te_4 = user.S0 / 4.0 * user.L * (1.0 - albedo_p) / sigma\n", " eta = user.R * user.L * user.S0 / (4.0 * sigma)\n", " temp_b = (eta * (albedo_p - user.albedo_black) + Te_4)**0.25\n", " temp_w = (eta * (albedo_p - user.albedo_white) + Te_4)**0.25\n", "\n", " if (temp_b >= 277.5 and temp_b <= 312.5):\n", " beta_b = 1.0 - 0.003265 * (295.0 - temp_b)**2.0\n", " else:\n", " beta_b = 0.0\n", "\n", " if (temp_w >= 277.5 and temp_w <= 312.5):\n", " beta_w = 1.0 - 0.003265 * (295.0 - temp_w)**2.0\n", " else:\n", " beta_w = 0.0\n", "\n", " # create a 1 x 2 element vector to hold the derivitive\n", " f = np.empty([self.nvars], 'float')\n", " f[0] = y[0] * (beta_w * x - user.chi)\n", " f[1] = y[1] * (beta_b * x - user.chi)\n", " return f" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "theSolver = Integ53('conduction.yaml')\n", "timeVals, yVals, errorList = theSolver.timeloop5fixed()\n", "\n", "plt.close('all')\n", "thefig, theAx = plt.subplots(1, 1)\n", "theLines = theAx.plot(timeVals, yVals)\n", "theLines[1].set_linestyle('--')\n", "theLines[1].set_color('k')\n", "theAx.set_title('lab 5 interactive 3 -- conduction problem')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('fractional coverage')\n", "out = theAx.legend(theLines, ('white daisies', 'black daisies'),\n", " loc='center right')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## The Feedback Loop - Feedback Through the Planetary Albedo\n", "\n", "The amount of solar radiation the planet reflects will depend on the\n", "daisy population since the white daisies will reflect more radiation\n", "than the bare ground and the black daisies will reflect less. So a\n", "reasonable estimate of the planetary albedo $\\alpha_p$ is an average of\n", "the albedo’s of the white and black daisies and the bare ground,\n", "weighted by the amount of area covered by each, i.e.\n", "\n", "\n", "\n", "$$\n", " \\alpha_p = A_w\\alpha_w + A_b\\alpha_b + A_g\\alpha_g\n", "$$\n", "\n", "A greater\n", "population of white daisies will tend to increase planetary albedo and\n", "decrease the emission temperature, as is apparent from equation\n", "([lab5:eq:tempe]), while the reverse is true for the black daisies.\n", "\n", "To summarize: The daisy population is controlled by its growth rate\n", "$\\beta_i$ which is a function of the local\n", "temperature $T_i$ $$\\beta_i = 1.0 - 0.003265(295.5 K -T_i)^2$$ If the\n", "conductivity $R$ is nonzero, the local temperature is a function of\n", "planetary albedo $\\alpha_p$\n", "\n", "$$T_i = \\left[ R L \\frac{S_0}{4\\sigma}(\\alpha_p-\\alpha_i)\n", " + T^4_e \\right]^{\\frac{1}{4}}$$\n", "\n", "which is determined by the daisy\n", "population.\n", "\n", "- Physically, this provides the feedback from the daisy population\n", " back to the temperature, completing the loop between the daisies and\n", " temperature.\n", "\n", "- Mathematically, this introduces a rather nasty non-linearity into\n", " the equations which, as pointed out in the lab 1, usually makes it\n", " difficult, if not impossible, to obtain exact analytic solutions." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
**Problem initial**
\n", "\n", "The feedback means a stable daisy population (a\n", "steady state) and the environmental conditions are in a delicate\n", "balance. The code below produces a steady state which arises from a given initial daisy\n", "population,\n", "\n", "1. Add a small initial fraction of black daisies (say, 0.01) to the\n", " value in initial.yaml and see\n", " what effect this has on the temperature and final daisy populations.\n", " Do you still have a final non-zero daisy population?\n", "\n", "2. Attempt to adjust the initial white daisy population to obtain a\n", " non-zero steady state. Do you have to increase or decrease the\n", " initial fraction? What is your explanation for this behavior?\n", "\n", "3. Experiment with other initial fractions of daisies and look for\n", " non-zero steady states." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from numlabs.lab5.lab5_funs import Integrator\n", "\n", "\n", "class Integ54(Integrator):\n", " def set_yinit(self):\n", " #\n", " # read in 'albedo_white chi S0 L albedo_black R albedo_ground'\n", " #\n", " uservars = namedtuple('uservars', self.config['uservars'].keys())\n", " self.uservars = uservars(**self.config['uservars'])\n", " #\n", " # read in 'whiteconc blackconc'\n", " #\n", " initvars = namedtuple('initvars', self.config['initvars'].keys())\n", " self.initvars = initvars(**self.config['initvars'])\n", " self.yinit = np.array(\n", " [self.initvars.whiteconc, self.initvars.blackconc])\n", " self.nvars = len(self.yinit)\n", " return None\n", "\n", " def __init__(self, coeff_file_name):\n", " super().__init__(coeff_file_name)\n", " self.set_yinit()\n", "\n", " def find_temp(self, yvals):\n", " \"\"\"\n", " Calculate the temperatures over the white and black daisies\n", " and the planetary equilibrium temperature given the daisy fractions\n", " \n", " input: yvals -- array of dimension [2] with the white [0] and black [1]\n", " daisy fractiion\n", " output: white temperature (K), black temperature (K), equilibrium temperature (K)\n", " \"\"\"\n", " sigma = 5.67e-8 # Stefan Boltzman constant W/m^2/K^4\n", " user = self.uservars\n", " bare = 1.0 - yvals[0] - yvals[1]\n", " albedo_p = bare * user.albedo_ground + \\\n", " yvals[0] * user.albedo_white + yvals[1] * user.albedo_black\n", " Te_4 = user.S0 / 4.0 * user.L * (1.0 - albedo_p) / sigma\n", " temp_e = Te_4**0.25\n", " eta = user.R * user.L * user.S0 / (4.0 * sigma)\n", " temp_b = (eta * (albedo_p - user.albedo_black) + Te_4)**0.25\n", " temp_w = (eta * (albedo_p - user.albedo_white) + Te_4)**0.25\n", " return (temp_w, temp_b, temp_e)\n", "\n", " def derivs5(self, y, t):\n", " \"\"\"y[0]=fraction white daisies\n", " y[1]=fraction black daisies\n", " no feedback between daisies and\n", " albedo_p (set to ground albedo)\n", " \"\"\"\n", " temp_w, temp_b, temp_e = self.find_temp(y)\n", "\n", " if (temp_b >= 277.5 and temp_b <= 312.5):\n", " beta_b = 1.0 - 0.003265 * (295.0 - temp_b)**2.0\n", " else:\n", " beta_b = 0.0\n", "\n", " if (temp_w >= 277.5 and temp_w <= 312.5):\n", " beta_w = 1.0 - 0.003265 * (295.0 - temp_w)**2.0\n", " else:\n", " beta_w = 0.0\n", " user = self.uservars\n", " bare = 1.0 - y[0] - y[1]\n", " # create a 1 x 2 element vector to hold the derivitive\n", " f = np.empty_like(y)\n", " f[0] = y[0] * (beta_w * bare - user.chi)\n", " f[1] = y[1] * (beta_b * bare - user.chi)\n", " return f" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", "theSolver = Integ54('initial.yaml')\n", "timevals, yvals, errorlist = theSolver.timeloop5fixed()\n", "daisies = pd.DataFrame(yvals, columns=['white', 'black'])\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "line1, = theAx.plot(timevals, daisies['white'])\n", "line2, = theAx.plot(timevals, daisies['black'])\n", "line1.set(linestyle='--', color='r', label='white')\n", "line2.set(linestyle='--', color='k', label='black')\n", "theAx.set_title('lab 5 interactive 4, initial conditions')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('fractional coverage')\n", "out = theAx.legend(loc='center right')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
**Problem Temperature**
\n", "\n", "The code above adds a new method, ```find_temp``` that takes the white/black daisy fractions and calculates local and planetary temperatures.\n", "\n", "1. override ```timeloop5fixed``` so that it saves these three temperatures, plus the daisy growth rates\n", " to new variables in the Integ54 instance\n", "\n", "2. Make plots of (temp_w, temp_b) and (beta_w, beta_b) vs. time for a case with non-zero equilibrium\n", " concentrations of both black and white daisies" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Adaptive Stepsize in Runge-Kutta\n", "\n", "\n", "\n", "### Why Adaptive Stepsize?\n", "\n", "As a rule of thumb, accuracy increases in Runge-Kutta methods as\n", "stepsize decreases. At the same time, the number of function evaluations\n", "performed increases. This tradeoff between accuracy of the solution and\n", "computational cost always exists, but in the ODE solution algorithms\n", "presented earlier it often appears to be unnecessarily large. To see\n", "this, consider the solution to a problem in two different time\n", "intervals. In the first one, the solution is close to steady, whereas in\n", "the second one it changes quickly. For acceptable accuracy with a\n", "non-adaptive method the step size will have to be adjusted so that the\n", "approximate solution is close to the actual solution in the second\n", "interval. The stepsize will be fairly small, so that the approximate\n", "solution is able to follow the changes in the solution here. However, as\n", "there is no change in stepsize throughout the solution process, the same\n", "step size will be applied to approximate the solution in the first time\n", "interval, where clearly a much larger stepsize would suffice to achieve\n", "the same accuracy. Thus, in a region where the solution behaves nicely a\n", "lot of function evaluations are wasted because the stepsize is chosen in\n", "accordance with the most quickly changing part of the solution.\n", "\n", "The way to address this problem is the use of adaptive stepsize control.\n", "This class of algorithms adjusts the stepsize taken in a time interval\n", "according to the properties of the solution in that interval, making it\n", "useful for producing a solution that has a given accuracy in the minimum\n", "number of steps.\n", "\n", "\n", "\n", "### Designing Adaptive Stepsize Control\n", "\n", "Now that the goal is clear, the question remains of how to close in on\n", "it. As mentioned above, an adaptive algorithm is usually asked to solve\n", "a problem to a desired accuracy. To be able to adjust the stepsize in\n", "Runge-Kutta the algorithm must therefore calculate some estimate of how\n", "far its solution deviates from the actual solution. If with its initial\n", "stepsize this estimate is already well within the desired accuracy, the\n", "algorithm can proceed with a larger stepsize. If the error estimate is\n", "larger than the desired accuracy, the algorithm decreases the stepsize\n", "at this point and attempts to take a smaller step. Calculating this\n", "error estimate will always increase the amount of work done at a step\n", "compared to non-adaptive methods. Thus, the remaining problem is to\n", "devise a method of calculating this error estimate that is both\n", "inexpensive and accurate.\n", "\n", "\n", "\n", "### Error Estimate by Step Doubling\n", "\n", "The first and simple approach to arriving at an error estimate is to\n", "simply take every step twice. The second time the step is divided up\n", "into two steps, producing a different estimate of the solution. The\n", "difference in the two solutions can be used to produce an estimate of\n", "the truncation error for this step.\n", "\n", "How expensive is this method to estimate the error? A single step of\n", "fourth order Runge-Kutta always takes four function evaluations. As the\n", "second time the step is taken in half-steps, it will take 8 evaluations.\n", "However, the first function evaluation in taking a step twice is\n", "identical to both steps, and thus the overall cost for one step with\n", "step doubling is $12 - 1 = 11$ function evaluations. This should be\n", "compared to taking two normal half-steps as this corresponds to the\n", "overall accuracy achieved. So we are looking at 3 function evaluations\n", "more per step, or an increase of computational cost by a factor of\n", "$1.375$.\n", "\n", "Step doubling works in practice, but the next section presents a slicker\n", "way of arriving at an error estimate that is less computationally\n", "expensive. It is the commmonly used one today.\n", "\n", "\n", "\n", "### Error Estimate using Embedded Runge-Kutta\n", "\n", "Another way of estimating the truncation error of a step is due to the\n", "existence of the special fifth-order Runge-Kutta methods discussed\n", "earlier. These methods use six function evaluations which can be\n", "recombined to produce a fourth-order method . Again, the difference\n", "between the fifth and the fourth order solution is used to calculate an\n", "estimate of the truncation error. Obviously this method requires fewer\n", "function evaluations than step doubling, as the two estimates use the\n", "same evaluation points. Originally this method was found by Fehlberg,\n", "and later Cash and Karp produced the set of constants presented earlier\n", "that produce an efficient and accurate error estimate." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
**Problem Estimate**
\n", "\n", "In the demo below, compare the error estimate to\n", "the true error, on the initial value problem from ,\n", "\n", "$$\\frac{dy}{dt} = -y +t +1, \\;\\;\\;\\; y(0) =1$$\n", "\n", "which has the exact\n", "solution\n", "\n", "$$y(t) = t + e^{-t}$$\n", "\n", "1. Play with the time step and final time, attempting small changes at\n", " first. How reasonable is the error estimate?\n", "\n", "2. Keep decreasing the time step. Does the error estimate diverge from\n", " the computed error? Why?\n", "\n", "3. Keep increasing the time step. Does the error estimate diverge? What\n", " is happening with the numerical solution?" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "from numlabs.lab5.lab5_funs import Integrator\n", "\n", "\n", "class Integ55(Integrator):\n", " def set_yinit(self):\n", " #\n", " # read in 'c1 c2 c3'\n", " #\n", " uservars = namedtuple('uservars', self.config['uservars'].keys())\n", " self.uservars = uservars(**self.config['uservars'])\n", " #\n", " # read in initial yinit\n", " #\n", " initvars = namedtuple('initvars', self.config['initvars'].keys())\n", " self.initvars = initvars(**self.config['initvars'])\n", " self.yinit = np.array([self.initvars.yinit])\n", " self.nvars = len(self.yinit)\n", " return None\n", "\n", " def __init__(self, coeff_file_name):\n", " super().__init__(coeff_file_name)\n", " self.set_yinit()\n", "\n", " def derivs5(self, y, theTime):\n", " \"\"\"\n", " y[0]=fraction white daisies\n", " \"\"\"\n", " user = self.uservars\n", " f = np.empty_like(self.yinit)\n", " f[0] = user.c1 * y[0] + user.c2 * theTime + user.c3\n", " return f" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'lab 5 interactive 5 -- fixed errors')" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "theSolver = Integ55('expon.yaml')\n", "\n", "timeVals, yVals, yErrors = theSolver.timeloop5Err()\n", "timeVals = np.array(timeVals)\n", "exact = timeVals + np.exp(-timeVals)\n", "yVals = np.array(yVals)\n", "yVals = yVals.squeeze()\n", "yErrors = np.array(yErrors)\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "line1 = theAx.plot(timeVals, yVals, label='adapt')\n", "line2 = theAx.plot(timeVals, exact, 'r+', label='exact')\n", "theAx.set_title('lab 5 interactive 5')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('y value')\n", "theAx.legend(loc='center right')\n", "\n", "#\n", "# we need to unpack yvals (a list of arrays of length 1\n", "# into an array of numbers using a list comprehension\n", "#\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "realestError = yVals - exact\n", "actualErrorLine = theAx.plot(timeVals, realestError, label='actual error')\n", "estimatedErrorLine = theAx.plot(timeVals, yErrors, label='estimated error')\n", "theAx.legend(loc='best')\n", "\n", "timeVals, yVals, yErrors = theSolver.timeloop5fixed()\n", "\n", "np_yVals = np.array(yVals).squeeze()\n", "yErrors = np.array(yErrors)\n", "np_exact = timeVals + np.exp(-timeVals)\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "line1 = theAx.plot(timeVals, np_yVals, label='fixed')\n", "line2 = theAx.plot(timeVals, np_exact, 'r+', label='exact')\n", "theAx.set_title('lab 5 interactive 5 -- fixed')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('y value')\n", "theAx.legend(loc='center right')\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "realestError = np_yVals - np_exact\n", "actualErrorLine = theAx.plot(timeVals, realestError, label='actual error')\n", "estimatedErrorLine = theAx.plot(timeVals, yErrors, label='estimated error')\n", "theAx.legend(loc='best')\n", "theAx.set_title('lab 5 interactive 5 -- fixed errors')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### Using Error to Adjust the Stepsize\n", "\n", "Both step doubling and embedded methods leave us with the difference\n", "between two different order solutions to the same step. Provided is a\n", "desired accuracy, $\\Delta_{des}$. The way this accuracy is specified\n", "depends on the problem. It can be relative to the solution at step $i$,\n", "\n", "$$\\Delta_{des}(i) = RTOL\\cdot |y(i)|$$\n", "\n", "where $RTOL$ is the relative\n", "tolerance desired. An absolute part should be added to this so that the\n", "desired accuracy does not become zero. There are more ways to adjust the\n", "error specification to the problem, but the overall goal of the\n", "algorithm always is to make $\\Delta_{est}(i)$, the estimated error for a\n", "step, satisfy\n", "\n", "$$|\\Delta_{est}(i)|\\leq\\Delta_{des}(i)|$$\n", "\n", "Note also that\n", "for a system of ODEs $\\Delta_{des}$ is of course a vector, and it is\n", "wise to replace the componentwise comparison by a vector norm.\n", "\n", "Note now that the calculated error term is $O(h^{5})$ as it was found as\n", "an error estimate to fourth-order Runge-Kutta methods. This makes it\n", "possible to scale the stepsize as\n", "\n", "\n", "\n", "$$h_{new} = h_{old}[{\\Delta_{des}\\over \\Delta_{est}}]^{1/5}$$\n", "\n", "or,\n", "to give an example of the suggested use of vector norms above, the new\n", "stepsize is given by\n", "\n", "\n", "\n", "\\begin{equation}\n", "\\label{eq:hnewnorm}\n", "h_{new} = S h_{old}\\{[{1\\over N}\\sum_{i=1}^{N}({\\Delta_{est}(i)\\over\n", "\\Delta_{des}(i)})^{2}]^{1/2}\\}^{-1/5}\\}\n", "\\end{equation}\n", "\n", "using the\n", "root-mean-square norm. $S$ appears as a safety factor ($0" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", "theSolver = Integ54('adapt.yaml')\n", "timeVals, yVals, errorList = theSolver.timeloop5Err()\n", "\n", "yvals = pd.DataFrame.from_records(yVals, columns=['white', 'black'])\n", "\n", "thefig, theAx = plt.subplots(1, 1)\n", "\n", "points, = theAx.plot(timeVals, yvals['white'], '-b+', label='white daisies')\n", "points.set_markersize(12)\n", "theLine1, = theAx.plot(timeVals, yvals['black'], '--ko', label='black daisies')\n", "theAx.set_title('lab 5 interactive 6')\n", "theAx.set_xlabel('time')\n", "theAx.set_ylabel('fractional coverage')\n", "out = theAx.legend(loc='best')\n", "\n", "# timeVals,yVals,errorList=theSolver.timeloop5fixed()\n", "# whiteDaisies=[frac[0] for frac in yVals]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
**Problem Tolerances**
\n", "\n", "The Runge-Kutta algorithm with adaptive time\n", "steps will, in general, be more efficient and accurate than same\n", "algorithm with fixed time steps. In other words, greater accuracy can\n", "usually be achieved in fewer time steps. For the given set of Daisyworld\n", "parameters and initial conditions,\n", "\n", "1. Decrease the error tolerances and compare the plots. You will note\n", " that as the error tolerances are decreased, the plots approach the\n", " one created by the algorithm with fixed time steps. What does this\n", " imply?\n", "\n", "2. Compare the Daisyworld plot to a plot of the stepsizes. Do you see a\n", " correlation between stepsize and the shape of the curve?\n", "\n", "3. Play with the tolerances and see if you can re-create (roughly) the\n", " same plot but in fewer time steps." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Coding Runge-Kutta Adaptive Stepsize Control\n", "\n", "The Runge-Kutta code developed in Lab 4 solves the given ODE system in\n", "fixed timesteps. It is now necessary to exert adaptive timestep control\n", "over the solution. The python code for this is at given in\n", "[these lines](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L145-L197)\n", "\n", "\n", "\n", "In principle, this is pretty simple:\n", "\n", "1. As before, take a step specified by the Runge-Kutta algorithm.\n", "\n", "2. Determine whether the estimated error lies within the user specified\n", " tolerance\n", "\n", "3. If the error is too large, calculate the new stepsize with\n", " (\\ref{eq:hnewnorm}) and retake the step.\n", "\n", "This can be accomplished by writing a new [timeloop5Err](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L115-L117)\n", "method which evaluates each Runge-Kutta step. This routine\n", "must now also return\n", "the estimate of the truncation error.\n", "\n", "In practice, it is prudent to take a number of safeguards. This involves\n", "defining a number of variables that place limits on the change in\n", "stepsize:\n", "\n", "- A safety factor ($0**Problem adaptive**
\n", "\n", "The demos in the previous section, solved the\n", "Daisyworld equations using the embedded Runge-Kutta methods with\n", "adaptive timestep control.\n", "\n", "1. Run the code and find solutions of Daisyworld with the default\n", " settings found in adapt.yaml using the timeloop5Err adaptive\n", " code\n", "\n", "2. Find the solutions again but this time with fixed stepsizes and\n", " compare the size of the timesteps and number of the timesteps.\n", "\n", "3. How much faster does the fixed timeloop need to be to give the\n", " same performance as the adaptive timeloop for this case?\n", "\n", "\n", "\n", "### Daisyworld Steady States\n", "\n", "We can now use the Runge-Kutta code with adaptive timestep control to\n", "find some steady states of Daisyworld by varying the luminosity $LS_0$ in the\n", "uservars section of adapt.yaml and recording the daisy fractions at the\n", "end of the integration. The code was used in the earlier\n", "sections to find some adhoc steady state solutions and the effect of\n", "altering some of the model parameters. What is of interest now is the\n", "effect of the daisy feedback on the range of parameter values for which\n", "non-zero steady states exist. That the feedback does have an effect on\n", "the steady states was readily seen in a [Problem initial](#prob_initial)\n", "\n", "If we fix all other Daisyworld parameters, we find that non-zero steady\n", "states will exist for a range of solar luminosities which we\n", "characterize by the parameter L. Recall, that L is the multiple of the\n", "solar constant $S_0$ that Daisyworld receives. What we will investigate\n", "in the next few sections is the effect of the daisy feedback on the\n", "range of L for which non-zero steady states can exist.\n", "\n", "We accomplish this by fixing the Daisyworld parameters and finding the\n", "resulting steady state daisy population for a given value of L. A plot\n", "is then made of the steady-state daisy populations versus various values\n", "of L.\n", "\n", "\n", "\n", "### Neutral Daisies\n", "\n", "The first case we consider is the case investigated in a previous demo\n", "where the albedo of the daisies and the ground are set to the same\n", "value. This means the daisy population has no effect on the planetary\n", "temperature, i.e. there is no feedback ([lab5:demo:coupling]).\n", "\n", "$~$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Daisy fraction -- daisies have ground albedo\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Emission temperature\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### Black Daisies\n", "\n", "Now consider a population of black daisies. Note the sharp jump in the\n", "graph when the first non-zero daisy steady states appear and the\n", "corresponding rise in the planetary temperature. The appearance of the\n", "black daisies results in a strong positive feedback on the temperature.\n", "Note as well that the graph drops back to zero at a lower value of L\n", "than in the case of neutral daisies." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Daisies darker than ground\n", "" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Temperature\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### White Daisies\n", "\n", "Consider now a population of purely white daisies. In this case there is\n", "an abrupt drop in the daisy steady state when it approaches zero with a\n", "corresponding jump in the emission temperature. Another interesting\n", "feature is the appearance of hysteresis. This arises since the plot of\n", "steady states is different when solar luminosity is lowered as opposed\n", "to being raised incrementally." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Daisies brighter than ground\n", "" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Temperature\n", "" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "\n", "\n", "### Black and White Daisies\n", "\n", "Finally, consider a population of both black and white daisies. This\n", "blends in features from the cases where the daisy population was purely\n", "white or black. Note how the appearance of a white daisy population\n", "initially causes the planetary temperature to actually drop even though\n", "the solar luminosity has been increased." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "fraction of black and white daisies\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "note extended temperature range with stabilizing feedbacks\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Conclusion\n", "\n", "Black daisies can survive at lower mean temperatures than the white\n", "daisies and the reverse is true for white daisies. The end result is\n", "that the range of L for which the non-zero daisy steady states exist is\n", "greater than the case of neutral (or no) daisies . In other words, the\n", "feedback from the daisies provide a stabilizing effect that extends the\n", "set of environmental conditions in which life on Daisyworld can exist.\n", "\n", "\n", "\n", "**Problem Predator**: To make life a little more interesting on\n", "Daisyworld, add a population of rabbits that feed upon the daisies. The\n", "rabbit birth rate will be proportional to the area covered by the\n", "daisies while, conversely, the daisy *death rate* will be\n", "proportional to the rabbit population.\n", "\n", "Add another equation to the Daisyworld model which governs the rabbit\n", "population and make the appropriate modifications to the existing daisy\n", "equations. Modify the set of equations and solve it with the Runge-Kutta\n", "method with adaptive timesteps. Use it to look for steady states and to\n", "determine their dependence on the initial conditions and model\n", "parameters.\n", "\n", "Hand in notebook cells that:\n", "\n", "1. Show your modified Daisyworld equations and your new integrator class.\n", "\n", "2. At least one set of parameter values and initial conditions that\n", " leads to the steady state and a plot of the timeseries for the daisies and rabbits.\n", "\n", "3. A discussion of the steady state’s dependence on these values, i.e.\n", " what happens when they are altered. Include a few plots for\n", " illustration.\n", "\n", "4. Does adding this feedback extend the range of habital L values for which\n", " non-zero populations exist?\n", "\n", "**Bonus:**: Now consider foxes that prey on rabbits but\n", "leave the daisies alone." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Appendix: Note on Global Energy Balance\n", "\n", "The statement that the earth is in energy balance follows from the First\n", "Law of Thermodynamics, i.e.\n", "\n", "**The energy absorbed by an isolated system is equal to the\n", " change in the internal energy minus the work extracted**\n", "\n", "which itself is an expression of the conservation of energy.\n", "\n", "For the earth, the primary source of energy is radiation from the sun.\n", "The power emitted by the sun, known as the solar luminosity, is\n", "$L_0=3.9 \\times 10^{26}W$ while the energy flux received at the\n", "mean distance of the earth from the sun ($1.5\\times 10^{11}m$) is called\n", "the solar constant, $S_0=1367\\ W m^{-2}$. For Daisy World the solar\n", "constant is taken to be $S_0=3668\\ W m^{-2}$.\n", "\n", "The emission temperature of a planet is the temperature the planet would\n", "be at if it emitted energy like a blackbody. A blackbody, so-called\n", "because it is a perfect absorber of radiation, obeys the\n", "Stefan-Boltzmann Law:\n", "\n", "\n", "\n", "\\textbf{eq: Stefan-Boltzman}\n", "$$ F_B\\ (Wm^{-2}) = \\sigma T^4_e$$\n", "\n", " where $\\epsilon$ is the energy density and\n", "$\\sigma = 5.67\\times 10^{-8}Wm^{-2}K^{-4}$. Given the energy absorbed,\n", "it is easy to calculate the emission temperature $T_e$ with\n", "Stefan-Boltzman equation.\n", "\n", "In general, a planet will reflect some of the radiation it receives,\n", "with the fraction reflected known as the albedo $\\alpha_p$. So the total\n", "energy absorbed by the planet is actually flux density received times\n", "the fraction absorbed times the perpendicular area to the sun ( the\n", "’shadow area’), i.e.\n", "\n", "\n", "\n", "$$\n", " E_{\\rm absorbed}=S_0(1-\\alpha_p)\\pi r_p^2$$\n", "\n", "where $r^2_p$ is the\n", "planet’s radius.\n", "\n", "If we still assume the planet emits like a blackbody, we can calculate\n", "the corresponding blackbody emission temperature. The total power\n", "emitted would be the flux $F_B$ of the blackbody times its\n", "surface area, i.e.\n", "\n", "\n", "\n", "$$\n", " E_{\\rm blackbody} = \\sigma T^4_e 4\\pi r_p^2$$\n", "\n", "Equating the energy absorbed with the energy emitted by a blackbody we\n", "can calculate the emission temperature,\n", "\n", "\n", "\n", "$$\n", " T^4_e = L \\frac{S_0}{4\\sigma}(1-\\alpha_p)$$\n", "\n", "\n", "\n", "## Summary: Daisy World Equations\n", "\n", "$$\\frac{dA_w}{dt} = A_w ( \\beta_w x - \\chi)$$\n", "\n", "$$\\frac{dA_b}{dt} = A_b ( \\beta_b x - \\chi)$$\n", "\n", "$$x = 1 - A_w - A_b$$\n", "\n", "$$\\beta_i = 1.0 - 0.003265(295.5 K -T_i)^2$$\n", "\n", "$$T^4_i = R L \\frac{S_0}{4\\sigma}(\\alpha_p-\\alpha_i) + T^4_e$$\n", "\n", "$$\\alpha_p = A_w\\alpha_w + A_b\\alpha_b + A_g\\alpha_g$$\n", "\n", "$$T^4_e = L \\frac{S_0}{4\\sigma}(1-\\alpha_p)$$" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 0 }, "source": [ "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Appendix: Organization of the adaptive Runge Kutta routines\n", "\n", "* The coding follows [Press et al.](pdfs/adapt_ode.pdf), with the adaptive Runge Kutta defined\n", " in the Integrator base class [here](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L43-L59)\n", "\n", "* The step size choice is made in [timeloop5err](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L115-L118)\n", "\n", "* To set up a specific problem, you need to overide two methods as demonstrated in the example code:\n", "the member function that initalizes the concentrations: [yinit](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L115-L118) and the derivatives routine [derivs5](https://github.com/phaustin/numeric/blob/10117233dc7c440b15c549c8086d76a03b9dcdd0/numlabs/lab5/lab5_funs.py#L66-L68)\n", "\n", "* In [Problem Initial](#prob_initial) we define a new member function:\n", "\n", "```python\n", "\n", "def find_temp(self, yvals):\n", " \"\"\"\n", " Calculate the temperatures over the white and black daisies\n", " and the planetary equilibrium temperature given the daisy fractions\n", "\n", " input: yvals -- array of dimension [2] with the white [0] and black [1]\n", " daisy fraction\n", " output: white temperature (K), black temperature (K), equilibrium temperature (K)\n", " \"\"\"\n", "```\n", "which give an example of how to use the instance variable data (self.uservars) in additional calculations." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Appendix: 2 minute intro to object oriented programming\n", "\n", "For a very brief introduction to python classes take a look at [these scipy lecture notes](http://www.scipy-lectures.org/intro/language/oop.html)\n", "that define some of the basic concepts. For perhaps more detail than you want/need to know, see this 2 part\n", "series on [object oriented programming](https://realpython.com/python3-object-oriented-programming) and inheritence ([supercharge your classes with super()](https://realpython.com/python-super/))\n", "Briefly, we need a way to store a lot of information, for\n", "example the Runge-Kutta coefficients, in an organized way that is accessible to multiple functions,\n", "without having to pass all that information through the function arguments. Python solves this problem\n", "by putting both the data and the functions together into an class, as in the Integrator class below.\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "### Classes and constructors" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "class Integrator:\n", " def __init__(self, first, second, third):\n", " print('Constructing Integrator')\n", " self.a = first\n", " self.b = second\n", " self.c = third\n", "\n", " def dumpit(self, the_name):\n", " printlist = [self.a, self.b, self.c]\n", " print(f'dumping arguments for {the_name}: {printlist}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* ```__init__()``` is called the class constructor\n", "\n", "* a,b,c are called class attributes\n", "\n", "* ```dumpit()``` is called a member function or method\n", "\n", "* We construct and instance of the class by passing the required arguments to ```__init__```" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Constructing Integrator\n", "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'c', 'dumpit']\n" ] } ], "source": [ "the_integ = Integrator(1, 2, 3)\n", "print(dir(the_integ))\n", "#note that the_integ now has a, b, c, and dumpit" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* and we call the member function like this:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dumping arguments for Demo object: [1, 2, 3]\n" ] } ], "source": [ "the_integ.dumpit('Demo object')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What does this buy us? Member functions only need arguments specific to them, and can use any\n", "attribute or other member function attached to the self variable, which doesn't need to be\n", "part of the function call." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### finding the attributes and methods of a class instance\n", "\n", "Python has a couple of functions that allow you to see the methods and\n", "attributes of objects\n", "\n", "To get a complete listing of builtin and user-defined methods and attributes use\n", "\n", "```\n", " dir\n", "```" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['__class__',\n", " '__delattr__',\n", " '__dict__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__gt__',\n", " '__hash__',\n", " '__init__',\n", " '__init_subclass__',\n", " '__le__',\n", " '__lt__',\n", " '__module__',\n", " '__ne__',\n", " '__new__',\n", " '__reduce__',\n", " '__reduce_ex__',\n", " '__repr__',\n", " '__setattr__',\n", " '__sizeof__',\n", " '__str__',\n", " '__subclasshook__',\n", " '__weakref__',\n", " 'a',\n", " 'b',\n", " 'c',\n", " 'dumpit']" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dir(the_integ)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To see just the attributes, use\n", "\n", "```\n", " vars\n", "```" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'a': 1, 'b': 2, 'c': 3}" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vars(the_integ)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The inspect.getmembers function gives you everything as a list of (name,object) tuples\n", "so you can filter the items you're interested in. See:\n", "\n", "https://docs.python.org/3/library/inspect.html" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "methods for the_integ: ['__init__', 'dumpit']\n" ] } ], "source": [ "import inspect\n", "all_info_the_integ = inspect.getmembers(the_integ)\n", "only_methods = [\n", " item[0] for item in all_info_the_integ if inspect.ismethod(item[1])\n", "]\n", "print('methods for the_integ: ', only_methods)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inheritance" ] }, { "cell_type": "markdown", "metadata": { "lines_to_next_cell": 2 }, "source": [ "We can also specialize a class by driving from a base and then adding more data or members,\n", "or overriding existing values. For example:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "class Trig(Integrator):\n", " \n", " def __init__(self, one, two, three, four):\n", " print('constructing Trig')\n", " #\n", " # first construct the base class\n", " #\n", " super().__init__(one, two, three)\n", " self.d = four\n", "\n", " def calc_trig(self):\n", " self.trigval = np.sin(self.c * self.d)\n", "\n", " def print_trig(self, the_date):\n", " print(f'on {the_date} the value of sin(a*b)=: {self.trigval:5.3f}')\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "constructing Trig\n", "Constructing Integrator\n", "on July 5 the value of sin(a*b)=: -0.537\n" ] } ], "source": [ "sample = Trig(1, 2, 3, 4)\n", "sample.calc_trig()\n", "sample.print_trig('July 5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initializing using yaml\n", "\n", "To specify the intial values for the class, we use a plain text\n", "format called [yaml](http://www.yaml.org/spec/1.2/spec.html). To write a yaml\n", "file, start with a dictionary that contains entries that are themselves dictionaries:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "import yaml\n", "out_dict = dict()\n", "out_dict['vegetables'] = dict(carrots=5, eggplant=7, corn=2)\n", "out_dict['fruit'] = dict(apples='Out of season', strawberries=8)\n", "with open('groceries.yaml', 'w') as f:\n", " yaml.dump(out_dict, f)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fruit:\n", " apples: Out of season\n", " strawberries: 8\n", "vegetables:\n", " carrots: 5\n", " corn: 2\n", " eggplant: 7\n" ] } ], "source": [ "#what's in the yaml file?\n", "#each toplevel dictionary key became a category\n", "import sys #output to sys.stdout because print adds blank lines\n", "with open('groceries.yaml', 'r') as f:\n", " for line in f.readlines():\n", " sys.stdout.write(line)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'fruit': {'apples': 'Out of season', 'strawberries': 8}, 'vegetables': {'carrots': 5, 'corn': 2, 'eggplant': 7}}\n" ] } ], "source": [ "#read into a dictionary\n", "with open('groceries.yaml', 'r') as f:\n", " init_dict = yaml.load(f, Loader=yaml.FullLoader)\n", "print(init_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "### Overriding initial values in a derived class" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Suppose we want to change a value like the strength of the sun, $L$, after it's been\n", "read in from the initail yaml file? Since a derived class can override the yinit function\n", "in the Integrator class, we are free to change it to overwrite any variable by reassigning\n", "the new value to self in the child constructor.\n", "\n", "Here's a simple example showing this kind of reinitialization:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "\n", "class Base:\n", " #\n", " # this constructor is called first\n", " #\n", " def __init__(self, basevar):\n", " self.L = basevar\n", "\n", "\n", "class Child(Base):\n", " #\n", " # this class changes the initialization\n", " # to add a new variable\n", " #\n", " def __init__(self, a, L):\n", " super().__init__(a)\n", " #\n", " # change the L in the child class\n", " #\n", " self.L = L" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can use Child(a,Lval) to construct instances with any value of L we want:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "set L value in child class to 0\n", "set L value in child class to 10\n", "set L value in child class to 20\n", "set L value in child class to 30\n", "set L value in child class to 40\n", "set L value in child class to 50\n", "set L value in child class to 60\n", "set L value in child class to 70\n", "set L value in child class to 80\n", "set L value in child class to 90\n", "set L value in child class to 100\n" ] } ], "source": [ "Lvals = np.linspace(0, 100, 11)\n", "\n", "#\n", "# now make 10 children, each with a different value of L\n", "#\n", "a = 5\n", "for theL in Lvals:\n", " newItem = Child(a, theL)\n", " print(f'set L value in child class to {newItem.L:3.0f}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To change L in the IntegCoupling class in [Problem Conduction](#prob_conduction) look at\n", "changing the value above these lines:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```python\n", "initvars = namedtuple('initvars', self.config['initvars'].keys())\n", "self.initvars = initvars(**self.config['initvars'])\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Specific example\n", "\n", "So to use this technique for [Problem Conduction](#prob_conduction), override `set_yinit` so that\n", "it will take a new luminosity value newL, and add it to uservars, like this:\n", "\n", "```\n", "class IntegCoupling(Integrator):\n", " \"\"\"rewrite the set_yinit method\n", " to work with luminosity\n", " \"\"\"\n", "\n", " def set_yinit(self, newL):\n", " #\n", " # change the luminocity\n", " #\n", " self.config[\"uservars\"][\"L\"] = newL # change solar incidence fraction\n", " #\n", " # make a new namedtuple factory called uservars that includes newL \n", " #\n", " uservars_fac = namedtuple('uservars', self.config['uservars'].keys())\n", " #\n", " # use the factory to make the augmented uservars named tuple\n", " #\n", " self.uservars = uservars_fac(**self.config['uservars'])\n", " #\n", "\n", "\n", " def __init__(self, coeffFileName, newL):\n", " super().__init__(coeffFileName)\n", " self.set_yinit(newL)\n", " \n", " ...\n", "```\n", "\n", "then construct a new instance with a value of newL like this:\n", "\n", "```\n", "theSolver = IntegCoupling(\"coupling.yaml\", newL)\n", "```\n", "\n", "The IntegCoupling constructor first constructs an instance of the Integrator\n", "class by calling `super()` and passing it the name of the yaml file. Once this\n", "is done then it\n", "calls the `IntegCoupling.set_yinit` method which takes the Integrator class instance\n", "(called \"self\" by convention) and modifies it by adding newL to the usersvars\n", "attribute.\n", "\n", "Try executing\n", "\n", "```\n", "newL = 50\n", "theSolver = IntegCoupling(\"coupling.yaml\", newL)\n", "```\n", "\n", "and verify that:\n", "\n", "`theSolver.uservars.L` is indeed 50\n", "\n", "#### Check your understanding\n", "\n", "To see if you're really getting the zeitgeist, try an alternative design where\n", "you leave the constructor as is, and instead add a new method called:\n", "\n", "```\n", "def reset_L(self,newL)\n", "```\n", "\n", "so that you could do this:\n", "\n", "```\n", "newL = 50\n", "theSolver = IntegCoupling(\"coupling.yaml\")\n", "theSolver.reset_L(newL)\n", "```\n", "\n", "and get `theSolver.uservars.L` set to 50." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Why bother?\n", "\n", "What does object oriented programming buy us? The dream was that companies/coders could ship\n", "standard base classes, thoroughly tested and documented, and then users could adapt those\n", "classes to their special needs using inheritence. This turned out to be too ambitous,\n", "but a dialed-back version of this is definitely now part of many major programming languages." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "jupytext": { "cell_metadata_filter": "all", "encoding": "# -*- coding: utf-8 -*-", "formats": "ipynb,py:percent", "notebook_metadata_filter": "all,-language_info,-toc,-latex_envs" }, "kernelspec": { "display_name": "Python 3", "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.7.6" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": false, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "meta-9" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": false, "user_envs_cfg": false }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": false, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": { "height": "679.091px", "left": "0px", "top": "66.2926px", "width": "207.145px" }, "toc_section_display": "block", "toc_window_display": true } }, "nbformat": 4, "nbformat_minor": 2 }