Lectures/Lecture04 -- Intro to CLIMLAB.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# [ATM 623: Climate Modeling](../index.ipynb)\n",
    "\n",
    "[Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany\n",
    "\n",
    "# Lecture 4: Building simple climate models using `climlab`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Warning: content out of date and not maintained\n",
    "\n",
    "You really should be looking at [The Climate Laboratory book](https://brian-rose.github.io/ClimateLaboratoryBook) by Brian Rose, where all the same content (and more!) is kept up to date.\n",
    "\n",
    "***Here you are likely to find broken links and broken code.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### About these notes:\n",
    "\n",
    "This document uses the interactive [`Jupyter notebook`](https://jupyter.org) format. The notes can be accessed in several different ways:\n",
    "\n",
    "- The interactive notebooks are hosted on `github` at https://github.com/brian-rose/ClimateModeling_courseware\n",
    "- The latest versions can be viewed as static web pages [rendered on nbviewer](http://nbviewer.ipython.org/github/brian-rose/ClimateModeling_courseware/blob/master/index.ipynb)\n",
    "- A complete snapshot of the notes as of May 2017 (end of spring semester) are [available on Brian's website](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2017/Notes/index.html).\n",
    "\n",
    "[Also here is a legacy version from 2015](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/Notes/index.html).\n",
    "\n",
    "Many of these notes make use of the `climlab` package, available at https://github.com/brian-rose/climlab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Ensure compatibility with Python 2 and 3\n",
    "from __future__ import print_function, division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Contents\n",
    "\n",
    "1. [Introducing `climlab`](#section1)\n",
    "2. [Using `climlab` to implement the zero-dimensional energy balance model](#section2)\n",
    "3. [Run the zero-dimensional EBM out to equilibrium](#section3)\n",
    "4. [A climate change scenario in the EBM](#section4)\n",
    "5. [Further `climlab` resources](#section5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________\n",
    "<a id='section1'></a>\n",
    "\n",
    "## 1. Introducing `climlab`\n",
    "____________\n",
    "\n",
    "`climlab` is a python package for process-oriented climate modeling.\n",
    "\n",
    "It is based on a very general concept of a model as a collection of individual, \n",
    "interacting processes. `climlab` defines a base class called `Process`, which\n",
    "can contain an arbitrarily complex tree of sub-processes (each also some \n",
    "sub-class of `Process`). Every climate process (radiative, dynamical, \n",
    "physical, turbulent, convective, chemical, etc.) can be simulated as a stand-alone\n",
    "process model given appropriate input, or as a sub-process of a more complex model. \n",
    "New classes of model can easily be defined and run interactively by putting together an\n",
    "appropriate collection of sub-processes.\n",
    "\n",
    "`climlab` is an open-source community project. The latest code can always be found on `github`:\n",
    "\n",
    "https://github.com/brian-rose/climlab\n",
    "\n",
    "You can install `climlab` by doing\n",
    "\n",
    "```\n",
    "conda install -c conda-forge climlab\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import climlab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________\n",
    "<a id='section2'></a>\n",
    "\n",
    "## 2. Using `climlab` to implement the zero-dimensional energy balance model\n",
    "____________\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that we have worked with a zero-dimensional Energy Balance Model\n",
    "\n",
    "$$ C \\frac{dT_s}{dt} = (1-\\alpha) Q - \\tau \\sigma T_s^4 $$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are going to implement this exact model using `climlab`.\n",
    "\n",
    "Yes, we have already written code to implement this model, but we are going to repeat this effort here as a way of learning how to use `climlab`.\n",
    "\n",
    "There are tools within `climlab` to implement much more complicated models, but the basic interface will be the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AttrDict({'Ts': Field([[32.]])})"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a zero-dimensional domain with a single surface temperature\n",
    "state = climlab.surface_state(num_lat=1,  # a single point\n",
    "                              water_depth = 100.,  # 100 meters slab of water (sets the heat capacity)\n",
    "                             )\n",
    "state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have created a dictionary called `state` with a single item called `Ts`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[32.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state['Ts']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This dictionary holds the state variables for our model -- which is this case is a single number!  It is a **temperature in degrees Celsius**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, we can access the same data as an attribute (which lets us use tab-autocomplete when doing interactive work):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[32.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state.Ts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to see this `state` dictionary as an `xarray.Dataset` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<xarray.Dataset>\n",
       "Dimensions:       (depth: 1, depth_bounds: 2, lat: 1, lat_bounds: 2)\n",
       "Coordinates:\n",
       "  * depth         (depth) float64 50.0\n",
       "  * lat           (lat) float64 0.0\n",
       "  * depth_bounds  (depth_bounds) float64 0.0 100.0\n",
       "  * lat_bounds    (lat_bounds) float64 -90.0 90.0\n",
       "Data variables:\n",
       "    Ts            (depth, lat) float64 32.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "climlab.to_xarray(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "climlab Process of type <class 'climlab.radiation.boltzmann.Boltzmann'>. \n",
      "State variables and domain shapes: \n",
      "  Ts: (1, 1) \n",
      "The subprocess tree: \n",
      "OutgoingLongwave: <class 'climlab.radiation.boltzmann.Boltzmann'>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#  create the longwave radiation process\n",
    "olr = climlab.radiation.Boltzmann(name='OutgoingLongwave',\n",
    "                                  state=state, \n",
    "                                  tau = 0.612,\n",
    "                                  eps = 1.,\n",
    "                                  timestep = 60*60*24*30.)\n",
    "#  Look at what we just created\n",
    "print(olr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "climlab Process of type <class 'climlab.radiation.absorbed_shorwave.SimpleAbsorbedShortwave'>. \n",
      "State variables and domain shapes: \n",
      "  Ts: (1, 1) \n",
      "The subprocess tree: \n",
      "AbsorbedShortwave: <class 'climlab.radiation.absorbed_shorwave.SimpleAbsorbedShortwave'>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#  create the shortwave radiation process\n",
    "asr = climlab.radiation.SimpleAbsorbedShortwave(name='AbsorbedShortwave',\n",
    "                                                state=state, \n",
    "                                                insolation=341.3, \n",
    "                                                albedo=0.299,\n",
    "                                                timestep = 60*60*24*30.)\n",
    "#  Look at what we just created\n",
    "print(asr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "climlab Process of type <class 'climlab.process.time_dependent_process.TimeDependentProcess'>. \n",
      "State variables and domain shapes: \n",
      "  Ts: (1, 1) \n",
      "The subprocess tree: \n",
      "EnergyBalanceModel: <class 'climlab.process.time_dependent_process.TimeDependentProcess'>\n",
      "   OutgoingLongwave: <class 'climlab.radiation.boltzmann.Boltzmann'>\n",
      "   AbsorbedShortwave: <class 'climlab.radiation.absorbed_shorwave.SimpleAbsorbedShortwave'>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#  couple them together into a single model\n",
    "ebm = olr + asr\n",
    "#  Give the parent process name\n",
    "ebm.name = 'EnergyBalanceModel'\n",
    "#  Examine the model object\n",
    "print(ebm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object called `ebm` here is the entire model -- including its current state (the temperature `Ts`) as well as all the methods needed to integrated forward in time!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The current model state, accessed two ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AttrDict({'Ts': Field([[32.]])})"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[32.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.Ts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is some internal information about the timestep of the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2592000.0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(ebm.time['timestep'])\n",
    "print(ebm.time['steps'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This says the timestep is 2592000 seconds (30 days!), and the model has taken 0 steps forward so far."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To take a single step forward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "ebm.step_forward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[31.61786227]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.Ts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model got colder!\n",
    "\n",
    "To see why, let's look at some useful diagnostics computed by this model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'OLR': Field([[300.896072]]), 'ASR': 239.25130000000004}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.diagnostics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is another dictionary, now with two items. They should make sense to you.\n",
    "\n",
    "Just like the `state` variables, we can access these `diagnostics` variables as attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[300.896072]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.OLR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "239.25130000000004"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.ASR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So why did the model get colder in the first timestep?\n",
    "\n",
    "What do you think will happen next?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________\n",
    "<a id='section3'></a>\n",
    "\n",
    "## 3. Run the zero-dimensional EBM out to equilibrium\n",
    "____________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at how the model adjusts toward its equilibrium temperature.\n",
    "\n",
    "Exercise:\n",
    "\n",
    "- Using a `for` loop, take 500 steps forward with this model\n",
    "- Store the current temperature at each step in an array\n",
    "- Make a graph of the temperature as a function of time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________\n",
    "<a id='section4'></a>\n",
    "\n",
    "## 4. A climate change scenario \n",
    "____________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to investigate the effects of a small decrease in the transmissitivity of the atmosphere `tau`. \n",
    "\n",
    "Previously we used the zero-dimensional model to investigate a **hypothetical climate change scenario** in which:\n",
    "- the transmissitivity of the atmosphere `tau` decreases to 0.57\n",
    "- the planetary albedo increases to 0.32\n",
    "\n",
    "How would we do that using `climlab`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that the model is comprised of two sub-components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OutgoingLongwave\n",
      "climlab Process of type <class 'climlab.radiation.boltzmann.Boltzmann'>. \n",
      "State variables and domain shapes: \n",
      "  Ts: (1, 1) \n",
      "The subprocess tree: \n",
      "OutgoingLongwave: <class 'climlab.radiation.boltzmann.Boltzmann'>\n",
      "\n",
      "AbsorbedShortwave\n",
      "climlab Process of type <class 'climlab.radiation.absorbed_shorwave.SimpleAbsorbedShortwave'>. \n",
      "State variables and domain shapes: \n",
      "  Ts: (1, 1) \n",
      "The subprocess tree: \n",
      "AbsorbedShortwave: <class 'climlab.radiation.absorbed_shorwave.SimpleAbsorbedShortwave'>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for name, process in ebm.subprocess.items():\n",
    "    print(name)\n",
    "    print(process)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parameter `tau` is a property of the `OutgoingLongwave` subprocess:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.612"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.subprocess['OutgoingLongwave'].tau"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and the parameter `albedo` is a property of the `AbsorbedShortwave` subprocess:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.299"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm.subprocess['AbsorbedShortwave'].albedo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make an exact clone of our model and then change these two parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "climlab Process of type <class 'climlab.process.time_dependent_process.TimeDependentProcess'>. \n",
      "State variables and domain shapes: \n",
      "  Ts: (1, 1) \n",
      "The subprocess tree: \n",
      "EnergyBalanceModel: <class 'climlab.process.time_dependent_process.TimeDependentProcess'>\n",
      "   OutgoingLongwave: <class 'climlab.radiation.boltzmann.Boltzmann'>\n",
      "   AbsorbedShortwave: <class 'climlab.radiation.absorbed_shorwave.SimpleAbsorbedShortwave'>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ebm2 = climlab.process_like(ebm)\n",
    "print(ebm2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "ebm2.subprocess['OutgoingLongwave'].tau = 0.57\n",
    "ebm2.subprocess['AbsorbedShortwave'].albedo = 0.32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now our model is out of equilibrium and the climate will change!\n",
    "\n",
    "To see this without actually taking a step forward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[-46.76117229]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  Computes diagnostics based on current state but does not change the state\n",
    "ebm2.compute_diagnostics()\n",
    "ebm2.ASR - ebm2.OLR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shoud the model warm up or cool down?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, we can find out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[31.61786227]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm2.Ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "ebm2.step_forward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[31.32798841]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm2.Ts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatic timestepping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often we want to integrate a model forward in time to equilibrium without needing to store information about the transient state.\n",
    "\n",
    "`climlab` offers convenience methods to do this easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "ebm3 = climlab.process_like(ebm2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integrating for 608 steps, 18262.11 days, or 50 years.\n",
      "Total elapsed time is 50.10373938170343 years.\n"
     ]
    }
   ],
   "source": [
    "ebm3.integrate_years(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[17.94837835]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  What is the current temperature?\n",
    "ebm3.Ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[-0.00021699]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  How close are we to energy balance?\n",
    "ebm3.ASR - ebm3.OLR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  We should be able to accomplish the exact same thing with explicit timestepping\n",
    "for n in range(608):\n",
    "    ebm2.step_forward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[17.94837835]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm2.Ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Field([[-0.00021699]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ebm2.ASR - ebm2.OLR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____________\n",
    "<a id='section5'></a>\n",
    "\n",
    "## 5. Further `climlab` resources\n",
    "____________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will be using `climlab` extensively throughout this course. Lots of examples of more advanced usage are found here in the course notes. Here are some links to other resources:\n",
    "\n",
    "- The documentation is hosted at <https://climlab.readthedocs.io/en/latest/>\n",
    "- Source code (for both software and docs) are at <https://github.com/brian-rose/climlab>\n",
    "- [A video of a talk I gave about `climlab` at the 2018 AMS Python symposium](https://ams.confex.com/ams/98Annual/videogateway.cgi/id/44948?recordingid=44948) (January 2018)\n",
    "- [Slides from a talk and demonstration that I gave in Febrary 2018](https://livealbany-my.sharepoint.com/:f:/g/personal/brose_albany_edu/EuA2afxy5-hNkzNhHgkp_HYBYcJumR3l6ukRVIEl4W3MmA?e=sbXN0d) (The Apple Keynote version contains some animations that will not show up in the pdf version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "____________\n",
    "## Version information\n",
    "____________\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading extensions from ~/.ipython/extensions is deprecated. We recommend managing extensions like any other Python packages, in site-packages.\n"
     ]
    },
    {
     "data": {
      "application/json": {
       "Software versions": [
        {
         "module": "Python",
         "version": "3.7.3 64bit [Clang 4.0.1 (tags/RELEASE_401/final)]"
        },
        {
         "module": "IPython",
         "version": "7.6.0"
        },
        {
         "module": "OS",
         "version": "Darwin 17.7.0 x86_64 i386 64bit"
        },
        {
         "module": "numpy",
         "version": "1.16.4"
        },
        {
         "module": "matplotlib",
         "version": "3.1.1"
        },
        {
         "module": "climlab",
         "version": "0.7.5"
        }
       ]
      },
      "text/html": [
       "<table><tr><th>Software</th><th>Version</th></tr><tr><td>Python</td><td>3.7.3 64bit [Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>IPython</td><td>7.6.0</td></tr><tr><td>OS</td><td>Darwin 17.7.0 x86_64 i386 64bit</td></tr><tr><td>numpy</td><td>1.16.4</td></tr><tr><td>matplotlib</td><td>3.1.1</td></tr><tr><td>climlab</td><td>0.7.5</td></tr><tr><td colspan='2'>Wed Jul 03 14:49:48 2019 EDT</td></tr></table>"
      ],
      "text/latex": [
       "\\begin{tabular}{|l|l|}\\hline\n",
       "{\\bf Software} & {\\bf Version} \\\\ \\hline\\hline\n",
       "Python & 3.7.3 64bit [Clang 4.0.1 (tags/RELEASE\\_401/final)] \\\\ \\hline\n",
       "IPython & 7.6.0 \\\\ \\hline\n",
       "OS & Darwin 17.7.0 x86\\_64 i386 64bit \\\\ \\hline\n",
       "numpy & 1.16.4 \\\\ \\hline\n",
       "matplotlib & 3.1.1 \\\\ \\hline\n",
       "climlab & 0.7.5 \\\\ \\hline\n",
       "\\hline \\multicolumn{2}{|l|}{Wed Jul 03 14:49:48 2019 EDT} \\\\ \\hline\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "Software versions\n",
       "Python 3.7.3 64bit [Clang 4.0.1 (tags/RELEASE_401/final)]\n",
       "IPython 7.6.0\n",
       "OS Darwin 17.7.0 x86_64 i386 64bit\n",
       "numpy 1.16.4\n",
       "matplotlib 3.1.1\n",
       "climlab 0.7.5\n",
       "Wed Jul 03 14:49:48 2019 EDT"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%load_ext version_information\n",
    "%version_information numpy, matplotlib, climlab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "____________\n",
    "\n",
    "## Credits\n",
    "\n",
    "The author of this notebook is [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n",
    "\n",
    "It was developed in support of [ATM 623: Climate Modeling](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/), a graduate-level course in the [Department of Atmospheric and Envionmental Sciences](http://www.albany.edu/atmos/index.php)\n",
    "\n",
    "Development of these notes and the [climlab software](https://github.com/brian-rose/climlab) is partially supported by the National Science Foundation under award AGS-1455071 to Brian Rose. Any opinions, findings, conclusions or recommendations expressed here are mine and do not necessarily reflect the views of the National Science Foundation.\n",
    "____________"
   ]
  }
 ],
 "metadata": {
  "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.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}