fmda_kf.ipynb

   1 {
   2   "nbformat": 4,
   3   "nbformat_minor": 0,
   4   "metadata": {
   5     "colab": {
   6       "name": "fmda_kf.ipynb",
   7       "provenance": [],
   8       "collapsed_sections": [
   9         "jivOYEhiXMi5"
  10       ]
  11     },
  12     "kernelspec": {
  13       "display_name": "Python 3",
  14       "language": "python",
  15       "name": "python3"
  16     },
  17     "language_info": {
  18       "codemirror_mode": {
  19         "name": "ipython",
  20         "version": 3
  21       },
  22       "file_extension": ".py",
  23       "mimetype": "text/x-python",
  24       "name": "python",
  25       "nbconvert_exporter": "python",
  26       "pygments_lexer": "ipython3",
  27       "version": "3.8.5"
  28     }
  29   },
  30   "cells": [
  31     {
  32       "cell_type": "markdown",
  33       "metadata": {
  34         "id": "khOTxJsYc91W"
  35       },
  36       "source": [
  37         "# Kalman Filtering for Fuel Moisture\n",
  38         "## Jan Mandel, University of Colorado Denver\n",
  39         "### Instructor for MATH 4779 - Math Clinic\n",
  40         "### December 2021"
  41       ]
  42     },
  43     {
  44       "cell_type": "markdown",
  45       "metadata": {
  46         "id": "sXaqfI-EdCEk"
  47       },
  48       "source": [
  49         "## Abstract"
  50       ]
  51     },
  52     {
  53       "cell_type": "markdown",
  54       "metadata": {
  55         "id": "ZbtSiYm4dF7B"
  56       },
  57       "source": [
  58         "''Fuel moisture is an important factor of the spread of wildland fires. Some weather stations have fuel moisture sensors and data are available online. We review a simple model of fuel moisture from atmospheric conditions, and show how to adjust the model using the weather station data."
  59       ]
  60     },
  61     {
  62       "cell_type": "markdown",
  63       "metadata": {
  64         "id": "eZ6dfHlZ63j1"
  65       },
  66       "source": [
  67         "## Table of contents"
  68       ]
  69     },
  70     {
  71       "cell_type": "markdown",
  72       "metadata": {
  73         "id": "WHIgN2uZ689b"
  74       },
  75       "source": [
  76         "A table of contents is not generated automatically in this medium. We'll write when we are done, after we know what the sections are."
  77       ]
  78     },
  79     {
  80       "cell_type": "markdown",
  81       "metadata": {
  82         "id": "ZFafUPCTO1N1"
  83       },
  84       "source": [
  85         "## 1. Introduction"
  86       ]
  87     },
  88     {
  89       "cell_type": "markdown",
  90       "metadata": {
  91         "id": "4_RcdWybPFks"
  92       },
  93       "source": [
  94         "The Kalman filter is at the foundation of many technologies in daily use, from GPS to weather forecasting. No model is completely accurate. Think space navigation: the movement of a Apollo 13 between the moon and the earth, subject to gravitational forces and propulsion, with the position ascertained by visual measurements. No matter how accurate the model of spacecraft motion is, the measurements are always burdened with noise. The idea of Kalman filter is to evolve a quantification of the of the state (here, positin and velocity of the spacecraft) in the form of a covariance matrix, and, using an estimate of the uncertainty of the data, adjust the state to split the difference every time measurements are taken. \n",
  95         "\n",
  96         "Here, we use the Kalman filter to estimate the evolution of fuel (dead wood) moisture content from a simple theoretical model, adjusting the state of the model hourly for measurements from fuel moisture a sensor in a wood stick exposed to the elements. This is needed for forecasting of wildfire progress; for this purpose, we also want to have the filter adjust the model from the data, so that it gives more accurate data for future when we only have hourly weather forecast but no actual data - because the future has not happened yet. "
  97       ]
  98     },
  99     {
 100       "cell_type": "markdown",
 101       "metadata": {
 102         "id": "M2kbwDPBTB7A"
 103       },
 104       "source": [
 105         "## 2. Background"
 106       ]
 107     },
 108     {
 109       "cell_type": "markdown",
 110       "metadata": {
 111         "id": "ar1BbXac49hO"
 112       },
 113       "source": [
 114         "In this section, we provide some technical details about the Kalman filter."
 115       ]
 116     },
 117     {
 118       "cell_type": "markdown",
 119       "metadata": {
 120         "id": "_5F5CuRqc91X"
 121       },
 122       "source": [
 123         "### 2.1 Imports"
 124       ]
 125     },
 126     {
 127       "cell_type": "markdown",
 128       "metadata": {
 129         "id": "K6sWUMf0c91Y"
 130       },
 131       "source": [
 132         "First we import some packages we will need. We will need to use upgrade numpy to the current version; google colab is using an older numpy version for compatibility with tensorflow."
 133       ]
 134     },
 135     {
 136       "cell_type": "code",
 137       "metadata": {
 138         "id": "WzwJ619dAlA5",
 139         "colab": {
 140           "base_uri": "https://localhost:8080/"
 141         },
 142         "outputId": "f8bcdc7f-c1be-45bd-f450-6085c0ac5676"
 143       },
 144       "source": [
 145         "import numpy as np, os\n",
 146         "if not [int(i) for i in np.__version__.split('.')] >= [1,20,1]: # check numpy version\n",
 147         "    print('Upgrading numpy and stopping RUNTIME! When the notebook completes, please run again.')\n",
 148         "    ! pip install --upgrade numpy    # suggested by Efosa, see also https://github.com/jswhit/pygrib/issues/192\n",
 149         "    os.kill(os.getpid(), 9)          # kill the runtime, need to run again from the beginning! pip install pygrib\n",
 150         "! pip install pygrib   \n",
 151         "! wget --no-clobber https://raw.githubusercontent.com/openwfm/wrfxpy/master/src/ingest/grib_file.py\n",
 152         "from grib_file import GribFile     # Martin's utility layer on top of  pygrib,from wrfxpy"
 153       ],
 154       "execution_count": 6,
 155       "outputs": [
 156         {
 157           "output_type": "stream",
 158           "name": "stdout",
 159           "text": [
 160             "Collecting pygrib\n",
 161             "  Downloading pygrib-2.1.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.5 MB)\n",
 162             "\u001b[K     |████████████████████████████████| 16.5 MB 5.5 MB/s \n",
 163             "\u001b[?25hCollecting pyproj\n",
 164             "  Downloading pyproj-3.2.1-cp37-cp37m-manylinux2010_x86_64.whl (6.3 MB)\n",
 165             "\u001b[K     |████████████████████████████████| 6.3 MB 29.8 MB/s \n",
 166             "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pygrib) (1.21.4)\n",
 167             "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from pyproj->pygrib) (2021.10.8)\n",
 168             "Installing collected packages: pyproj, pygrib\n",
 169             "Successfully installed pygrib-2.1.4 pyproj-3.2.1\n",
 170             "--2021-12-03 06:04:31--  https://raw.githubusercontent.com/openwfm/wrfxpy/master/src/ingest/grib_file.py\n",
 171             "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
 172             "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
 173             "HTTP request sent, awaiting response... 200 OK\n",
 174             "Length: 6208 (6.1K) [text/plain]\n",
 175             "Saving to: ‘grib_file.py’\n",
 176             "\n",
 177             "grib_file.py        100%[===================>]   6.06K  --.-KB/s    in 0s      \n",
 178             "\n",
 179             "2021-12-03 06:04:31 (62.2 MB/s) - ‘grib_file.py’ saved [6208/6208]\n",
 180             "\n"
 181           ]
 182         }
 183       ]
 184     },
 185     {
 186       "cell_type": "markdown",
 187       "metadata": {
 188         "id": "X9rvlymMZdJg"
 189       },
 190       "source": [
 191         "### 2.2 Kalman filter"
 192       ]
 193     },
 194     {
 195       "cell_type": "markdown",
 196       "metadata": {
 197         "id": "x5E2UE3F5gf2"
 198       },
 199       "source": [
 200         "#### 2.2.1 Overview"
 201       ]
 202     },
 203     {
 204       "cell_type": "markdown",
 205       "metadata": {
 206         "id": "NPgTHlCLAlA-"
 207       },
 208       "source": [
 209         "The Kalman filter provides an estimate $u$ of the time evolution of some unknown process, called \"nature\" or \"truth\". We do not know with certainty what the nature is, but we can observe it at regular intervals (steps) with some error. In each step, model $F$ advances the model state $u$ in time, $ u \\leftarrow F(u)$, and attempts to reconcile the state with an observation $d$ of the true state, so $u \\approx d$. The filter modifies the model state $u$ to balance the uncertainty in the model and the data (this is called *analysis*) and the cycle continues. For that purpose, the filter evolves also an estimate of the uncertainly of the model.\n",
 210         "\n",
 211         "More generally, instead of $u \\approx d$, only a part of the state is observed, and $Hu \\approx d$ where $H$ is a matrix, or observation function. Basically, $Hu$ is what the data would be if the model was completely accurate. \n",
 212         "\n",
 213         "See Kalman (1960) for the original publication, and Kalnay (2003) for a gentle introduction."
 214       ]
 215     },
 216     {
 217       "cell_type": "markdown",
 218       "metadata": {
 219         "id": "y6j34L5s5pEL"
 220       },
 221       "source": [
 222         "#### 2.2.2 Formulation\n",
 223         "\n",
 224         "---\n",
 225         "\n"
 226       ]
 227     },
 228     {
 229       "cell_type": "markdown",
 230       "metadata": {
 231         "id": "b3GZW5vP5_o8"
 232       },
 233       "source": [
 234         "Text with the math is coming soon."
 235       ]
 236     },
 237     {
 238       "cell_type": "code",
 239       "metadata": {
 240         "id": "-bvUtJ_OLwQA"
 241       },
 242       "source": [
 243         "import numpy as np\n",
 244         "def ext_kf(u,P,F,Q=0,d=None,H=None,R=None):\n",
 245         "  \"\"\"\n",
 246         "  One step of the extended Kalman filter. \n",
 247         "  If there is no data, only advance in time.\n",
 248         "  :param u:   the state vector, shape n\n",
 249         "  :param P:   the state covariance, shape (n,n)\n",
 250         "  :param F:   the model function, args vector u, returns F(u) and Jacobian J(u)\n",
 251         "  :param Q:   the process model noise covariance, shape (n,n)\n",
 252         "  :param d:   data vector, shape (m). If none, only advance in time\n",
 253         "  :param H:   observation matrix, shape (m,n)\n",
 254         "  :param R:   data error covariance, shape (n,n)\n",
 255         "  :return ua: the analysis state vector, shape (n)\n",
 256         "  :return Pa: the analysis covariance matrix, shape (n,n)\n",
 257         "  \"\"\"\n",
 258         "  def d2(a):\n",
 259         "    return np.atleast_2d(a) # convert to at least 2d array\n",
 260         "\n",
 261         "  def d1(a):\n",
 262         "    return np.atleast_1d(a) # convert to at least 1d array\n",
 263         "\n",
 264         "  # forecast\n",
 265         "  uf, J  = F(u)          # advance the model state in time and get the Jacobian\n",
 266         "  uf = d1(uf)            # if scalar, make state a 1D array\n",
 267         "  J = d2(J)              # if scalar, make jacobian a 2D array\n",
 268         "  P = d2(P)              # if scalar, make Jacobian as 2D array\n",
 269         "  Pf  = d2(J.T @ P) @ J + Q  # advance the state covariance Pf = J' * P * J + Q\n",
 270         "  # analysis\n",
 271         "  if d is None or not d.size :  # no data, no analysis\n",
 272         "    return uf, Pf\n",
 273         "  # K = P H' * inverse(H * P * H' + R) = (inverse(H * P * H' + R)*(H P))'\n",
 274         "  H = d2(H)\n",
 275         "  HP  = d2(H @ P)            # precompute a part used twice  \n",
 276         "  K   = d2(np.linalg.solve( d2(HP @ H.T) + R, HP)).T  # Kalman gain\n",
 277         "  # print('H',H)\n",
 278         "  # print('K',K)\n",
 279         "  res = d1(H @ d1(uf) - d)          # res = H*uf - d\n",
 280         "  ua = uf - K @ res # analysis mean uf - K*res\n",
 281         "  Pa = Pf - K @ d2(H @ P)        # analysis covariance\n",
 282         "  return ua, d2(Pa)\n"
 283       ],
 284       "execution_count": 9,
 285       "outputs": []
 286     },
 287     {
 288       "cell_type": "markdown",
 289       "metadata": {
 290         "id": "Uvsbbv2XZ2Hd"
 291       },
 292       "source": [
 293         "#### 2.2.3 A Kalman filter tester"
 294       ]
 295     },
 296     {
 297       "cell_type": "markdown",
 298       "metadata": {
 299         "id": "gcmGBqPOU1e5"
 300       },
 301       "source": [
 302         "It is a very good idea to make write a simple tester for every piece of code. How else would we know it actually works, and that something basic did not get broken inadvertently, perhaps as a side effect of changing something else? A simple tester may save a great deal of time trying to debug cryptic errors later. And, what better place for a tester that right after the code it is testing so that it gets run every time?"
 303       ]
 304     },
 305     {
 306       "cell_type": "code",
 307       "metadata": {
 308         "id": "OsOqvQk6ZXZV",
 309         "colab": {
 310           "base_uri": "https://localhost:8080/"
 311         },
 312         "outputId": "1af18dca-62ac-4ed5-fd68-a9ed4146be82"
 313       },
 314       "source": [
 315         "# a basic ext_kf test\n",
 316         "import numpy as np\n",
 317         "u = [1,\n",
 318         "     2]\n",
 319         "P = [[2 , -1],\n",
 320         "    [-1 , 2]]\n",
 321         "A = [ [1 ,2],\n",
 322         "      [3 ,4]]\n",
 323         "u = np.array(u)      \n",
 324         "Q = np.array([[1,0],[0,1]])\n",
 325         "A = np.array(A)\n",
 326         "def fun(u):\n",
 327         "  return A @ u, A\n",
 328         "F = lambda u: fun(u)\n",
 329         "H = [[1, 0],\n",
 330         "     [0, 1]]\n",
 331         "d = [2,\n",
 332         "    3]\n",
 333         "R = [[2, 0],\n",
 334         "    [0, 2]]\n",
 335         "H = np.array(H)      \n",
 336         "d = np.array(d)\n",
 337         "R = np.array(R)\n",
 338         "ua,Pa = ext_kf(u,P,F,Q)\n",
 339         "print('ua=',ua)\n",
 340         "print('Pa=',Pa)\n",
 341         "ua,Pa = ext_kf(u,P,F,Q,d,H,R)\n",
 342         "print('ua=',ua)\n",
 343         "print('Pa=',Pa)\n"
 344       ],
 345       "execution_count": 10,
 346       "outputs": [
 347         {
 348           "output_type": "stream",
 349           "name": "stdout",
 350           "text": [
 351             "ua= [ 5 11]\n",
 352             "Pa= [[15 18]\n",
 353             " [18 25]]\n",
 354             "ua= [4.66666667 7.66666667]\n",
 355             "Pa= [[13.93333333 18.73333333]\n",
 356             " [18.73333333 23.93333333]]\n"
 357           ]
 358         }
 359       ]
 360     },
 361     {
 362       "cell_type": "markdown",
 363       "metadata": {
 364         "id": "JDLU3B_jV42l"
 365       },
 366       "source": [
 367         "## 3. Methods"
 368       ]
 369     },
 370     {
 371       "cell_type": "markdown",
 372       "metadata": {
 373         "id": "K9pD9grsAJMq"
 374       },
 375       "source": [
 376         "### 3.1  A basic exponential decay model of fuel moisture\n",
 377         "\n",
 378         "\n"
 379       ]
 380     },
 381     {
 382       "cell_type": "markdown",
 383       "metadata": {
 384         "id": "EHGMoaVWao89"
 385       },
 386       "source": [
 387         "Consider a simplified fuel moisture model following Mandel et al. (2004). \n",
 388         "The evolution of fuel moisture content $m(t)$ is modeled by the differential equation on interval $\\left[\n",
 389         "t_{0},t_{1}\\right]  $,\n",
 390         "$$\n",
 391         "\\frac{dm}{dt}=\\frac{E-m(t)}{T},\\quad m(t_{0})=m_{0}.\n",
 392         "$$\n",
 393         "where the initial fuel moisture content $m_{0}=m\\left(  t_{0}\\right)  $ is the\n",
 394         "input, and $m_{1}=m(t_{1})$ is the output. Tnus, $m_1=F(m_0)$. The parameters of the model are the\n",
 395         "fuel moisture equilibrium $E$, assumed to be constant over the interval $\\left[\n",
 396         "t_{0},t_{1}\\right]  $, NS the characteristic decay time $T$. \n",
 397         "\n",
 398         "We can build the general model later by calling this simple model with different\n",
 399         "equilibria and time constants (drying, wetting, rain).\n",
 400         "\n",
 401         "Since $E$ is constant in time, the solution can be found\n",
 402         "analytically,\n",
 403         "$$\n",
 404         "m\\left(  t\\right)  =E+\\left(  m_{0}-E\\right)  e^{-t/T}%\n",
 405         "$$\n",
 406         "For convenience, we use $T_{1}=1/T$ instead of $T$, and the model becomes\n",
 407         "$$\n",
 408         "m_{1}=E+\\left(  m_{0}-E\\right)  e^{-\\left(  t_{1}-t_{0}\\right)  T_{1}}%\n",
 409         "$$\n",
 410         "In the extended Kalman filter, we will need the partial derivatives of $m_{1}$\n",
 411         "with respect to the input and the parameters. Compute\n",
 412         "$$\n",
 413         "\\frac{dm_{1}}{d_{m0}}=e^{-\\left(  t_{1}-t_{0}\\right)  T_{1}}\n",
 414         "$$\n",
 415         "$$\n",
 416         "\\frac{dm_{1}}{dE}=1-e^{-\\left(  t_{1}-t_{0}\\right)  T_{1}}\n",
 417         "$$\n",
 418         "$$\n",
 419         "\\frac{dm_{1}}{dT_{1}}=-\\left(  m_{0}-E\\right)  \\left(  t_{1}-t_{0}\\right)\n",
 420         "e^{-\\left(  t_{1}-t_{0}\\right)  T_{1}}\n",
 421         "$$\n",
 422         "At the moment, we need only ${dm_{1}}/{dm_{0}}$ but we put in the code all partials for possible use in future.\n"
 423       ]
 424     },
 425     {
 426       "cell_type": "code",
 427       "metadata": {
 428         "id": "eqcs0zEiAn0j"
 429       },
 430       "source": [
 431         "import numpy as np\n",
 432         "def model_decay(m0,E,partials=0,T1=0.1,tlen=1):  \n",
 433         "  # Arguments: \n",
 434         "  #   m0          fuel moisture content at start dimensionless, unit (1)\n",
 435         "  #   E           fuel moisture eqilibrium (1)\n",
 436         "  #   partials=0: return m1 = fuel moisture contents after time tlen (1)\n",
 437         "  #           =1: return m1, dm0/dm0 \n",
 438         "  #           =2: return m1, dm1/dm0, dm1/dE\n",
 439         "  #           =3: return m1, dm1/dm0, dm1/dE dm1/dT1   \n",
 440         "  #   T1          1/T, where T is the time constant approaching the equilibrium\n",
 441         "  #               default 0.1/hour\n",
 442         "  #   tlen        the time interval length, default 1 hour\n",
 443         "\n",
 444         "  exp_t = np.exp(-tlen*T1)                  # compute this subexpression only once\n",
 445         "  m1 = E + (m0 - E)*exp_t                   # the solution at end\n",
 446         "  if partials==0:\n",
 447         "    return m1\n",
 448         "  dm1_dm0 = exp_t\n",
 449         "  if partials==1:\n",
 450         "    return m1, dm1_dm0          # return value and Jacobian\n",
 451         "  dm1_dE = 1 - exp_t      \n",
 452         "  if partials==2:\n",
 453         "     return m1, dm1_dm0, dm1_dE \n",
 454         "  dm1_dT1 = -(m0 - E)*tlen*exp_t            # partial derivative dm1 / dT1\n",
 455         "  if partials==3:\n",
 456         "    return m1, dm1_dm0, dm1_dE, dm1_dT1       # return value and all partial derivatives wrt m1 and parameters\n",
 457         "  raise('Bad arg partials')\n",
 458         "  "
 459       ],
 460       "execution_count": 11,
 461       "outputs": []
 462     },
 463     {
 464       "cell_type": "markdown",
 465       "metadata": {
 466         "id": "hLPJT3FcA2a7"
 467       },
 468       "source": [
 469         "### 3.2 Kalman filter demonstration for the simple model"
 470       ]
 471     },
 472     {
 473       "cell_type": "markdown",
 474       "metadata": {
 475         "id": "kIA3X8vluFdd"
 476       },
 477       "source": [
 478         "We demonstrate the Kalman filter for this model on a simple artificial example. The model is solving the differential equation for one hour. The equilibrium $E$ is constant during the hour, but it changes over the day so that it is higher at night and lower during the day, with a 24-hour period.  First, we create the \"truth\" by choosing the equilibrium $E$ and solving the differential aquation every hour, with a small additive noise. The synthetic data is obtained as the values of the \"truth\", with random noise to simulate observation error."
 479       ]
 480     },
 481     {
 482       "cell_type": "markdown",
 483       "metadata": {
 484         "id": "bBv10PTiChhm"
 485       },
 486       "source": [
 487         "#### 3.2.1 Create synthetic data"
 488       ]
 489     },
 490     {
 491       "cell_type": "code",
 492       "metadata": {
 493         "id": "-_pz-wXnCMnP",
 494         "colab": {
 495           "base_uri": "https://localhost:8080/",
 496           "height": 261
 497         },
 498         "outputId": "867546dc-45d6-464c-c11d-8a1f5d643b58"
 499       },
 500       "source": [
 501         "import numpy as np, random\n",
 502         "days = 20       \n",
 503         "hours = days*24\n",
 504         "h2 = int(hours/2)\n",
 505         "hour = range(hours)\n",
 506         "day = np.array(range(hours))/24.\n",
 507         "\n",
 508         "# artificial equilibrium data\n",
 509         "E = np.power(np.sin(np.pi*day),4) # diurnal curve\n",
 510         "E = 0.05+0.25*E\n",
 511         "# FMC free run\n",
 512         "m_f = np.zeros(hours)\n",
 513         "m_f[0] = 0.1         # initial FMC\n",
 514         "for t in range(hours-1):\n",
 515         "  m_f[t+1] = max(0.,model_decay(m_f[t],E[t])  + random.gauss(0,0.005) )\n",
 516         "data = m_f + np.random.normal(loc=0,scale=0.02,size=hours)    \n",
 517         "\n",
 518         "%matplotlib inline\n",
 519         "import matplotlib.pyplot as plt \n",
 520         "# fig1, ax1 = plt.subplots()\n",
 521         "\n",
 522         "plt.figure(figsize=(16,4))\n",
 523         "plt.plot(hour,E,linestyle='--',c='r',label='Equilibrium')\n",
 524         "plt.plot(hour,m_f,linestyle='-',c='k',label='10-h fuel truth')\n",
 525         "plt.scatter(hour[:h2],data[:h2],c='b',label='10-h fuel data')\n",
 526         "plt.title('Kalman filter example on artificial data')\n",
 527         "plt.xlabel('Time (hours)')\n",
 528         "plt.ylabel('Fuel moisture content (%)')\n",
 529         "plt.legend()\n",
 530         " "
 531       ],
 532       "execution_count": 12,
 533       "outputs": [
 534         {
 535           "output_type": "execute_result",
 536           "data": {
 537             "text/plain": [
 538               "<matplotlib.legend.Legend at 0x7f72edaffe90>"
 539             ]
 540           },
 541           "metadata": {},
 542           "execution_count": 12
 543         },
 544         {
 545           "output_type": "display_data",
 546           "data": {
 547             "image/png": "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\n",
 548             "text/plain": [
 549               "<Figure size 1152x288 with 1 Axes>"
 550             ]
 551           },
 552           "metadata": {
 553             "needs_background": "light"
 554           }
 555         }
 556       ]
 557     },
 558     {
 559       "cell_type": "code",
 560       "metadata": {
 561         "id": "ECsvw2KJ7tAX"
 562       },
 563       "source": [
 564         ""
 565       ],
 566       "execution_count": null,
 567       "outputs": []
 568     },
 569     {
 570       "cell_type": "markdown",
 571       "metadata": {
 572         "id": "z-3WLAEpD2yJ"
 573       },
 574       "source": [
 575         "#### 3.2.2 Run Kalman filter"
 576       ]
 577     },
 578     {
 579       "cell_type": "markdown",
 580       "metadata": {
 581         "id": "T4g-RrrYAlBD"
 582       },
 583       "source": [
 584         "We have used the same code for model and for the truth, and run the Kalman filter for 10 days. The graph below shows that the model state was remarkably close to the truth, even if the model is fed only noisy observations. This is because the dynamics of the model and of the truth are the same. After 10 days, we let the model continue without any new data to simulate forecasting the future, and the agreement with the truth was still very good."
 585       ]
 586     },
 587     {
 588       "cell_type": "code",
 589       "metadata": {
 590         "id": "_-CjONZkD18n"
 591       },
 592       "source": [
 593         "import numpy as np\n",
 594         "import matplotlib.pyplot as plt \n",
 595         "\n",
 596         "def kf_example(DeltaE):\n",
 597         "  h2 = int(hours/2)\n",
 598         "  m = np.zeros(hours)\n",
 599         "  m[0]=0.1             # background state  \n",
 600         "  P = np.zeros(hours)\n",
 601         "  P[0] = 0.03 # background state variance\n",
 602         "  Q = np.array([0.02]) # process noise variance\n",
 603         "  H = np.array([1.])   # all observed\n",
 604         "  R = np.array([0.02]) # data variance\n",
 605         "\n",
 606         "  for t in range(h2):\n",
 607         "    # use lambda construction to pass additional arguments to the model \n",
 608         "    m[t+1],P[t+1] = ext_kf(m[t],P[t],lambda u: model_decay(u,E[t]+DeltaE,partials=1),Q,\n",
 609         "                    d=data[t],H=H,R=R)\n",
 610         "  for t in range(h2,hours - 1):\n",
 611         "    m[t+1],P[t+1] = ext_kf(m[t],P[t],lambda u: model_decay(u,E[t]+DeltaE,partials=1))\n",
 612         "  \n",
 613         "  %matplotlib inline\n",
 614         "  plt.figure(figsize=(16,4))\n",
 615         "  plt.plot(hour,E,linestyle='--',c='r',label='Equilibrium')\n",
 616         "  # print(len(hour),len(m_f))\n",
 617         "  plt.plot(hour,m_f,linestyle='-',c='b',label='10-h fuel truth')\n",
 618         "  plt.scatter(hour[:h2],data[:h2],c='b',label='10-h fuel data')\n",
 619         "  plt.plot(hour[:h2],m[:h2],linestyle='-',c='k',label='filtered')\n",
 620         "  plt.plot(hour[h2:hours],m[h2:hours],linestyle='-',c='r',label='forecast')\n",
 621         "  plt.title('Kalman filtering and forecast on artificial data')\n",
 622         "  plt.xlabel('Time (hours)') \n",
 623         "  plt.ylabel('Fuel moisture content (%)')\n",
 624         "  plt.legend()\n",
 625         " \n",
 626         "  return E, P"
 627       ],
 628       "execution_count": 13,
 629       "outputs": []
 630     },
 631     {
 632       "cell_type": "code",
 633       "metadata": {
 634         "id": "d0EFhTPZAlBD",
 635         "scrolled": true,
 636         "colab": {
 637           "base_uri": "https://localhost:8080/",
 638           "height": 244
 639         },
 640         "outputId": "574f9925-46e5-46fc-c1e0-c7b6e33a805e"
 641       },
 642       "source": [
 643         "DeltaE = 0.0          # bias\n",
 644         "E, P = kf_example(DeltaE)"
 645       ],
 646       "execution_count": 14,
 647       "outputs": [
 648         {
 649           "output_type": "display_data",
 650           "data": {
 651             "image/png": "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\n",
 652             "text/plain": [
 653               "<Figure size 1152x288 with 1 Axes>"
 654             ]
 655           },
 656           "metadata": {
 657             "needs_background": "light"
 658           }
 659         }
 660       ]
 661     },
 662     {
 663       "cell_type": "markdown",
 664       "metadata": {
 665         "id": "vqyB2Yz3uCsD"
 666       },
 667       "source": [
 668         "We have recovered the fuel moisture from data with random noise - we **filtered** the noise out. "
 669       ]
 670     },
 671     {
 672       "cell_type": "markdown",
 673       "metadata": {
 674         "id": "Dl7pBZ9B3Nox"
 675       },
 676       "source": [
 677         "Let's have a look at the evolution of the filter's estimate of the variance $P$. A common problem with the Kalman filter is when the variance converges to zero over time, then, since the filter trusts the model too much, it ignores the observations. Of course, once we switch to forecasting mode, the variance is not of interest. We could keep evolving the variance to bridge over periods when there are no observations, but not in this simplified version."
 678       ]
 679     },
 680     {
 681       "cell_type": "code",
 682       "metadata": {
 683         "id": "wRJgbmGLc91g",
 684         "colab": {
 685           "base_uri": "https://localhost:8080/",
 686           "height": 232
 687         },
 688         "outputId": "03edc378-62be-40b1-f5e6-5eb37a55b853"
 689       },
 690       "source": [
 691         "import matplotlib as plt\n",
 692         "%matplotlib inline\n",
 693         "plt.figure(figsize=(16,4))\n",
 694         "plt.plot(P,linestyle='-',c='b',label='Estimated state variance P')\n",
 695         "plt.title('Kalman filtering and forecast on artificial data')\n",
 696         "plt.xlabel('Time (hours)') \n",
 697         "plt.ylabel('Estimated variance of fuel moisture (%^2)')\n",
 698         "plt.legend()"
 699       ],
 700       "execution_count": 15,
 701       "outputs": [
 702         {
 703           "output_type": "error",
 704           "ename": "TypeError",
 705           "evalue": "ignored",
 706           "traceback": [
 707             "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
 708             "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
 709             "\u001b[0;32m<ipython-input-15-80767a8ea737>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmagic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'matplotlib inline'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mP\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlinestyle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'-'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Estimated state variance P'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Kalman filtering and forecast on artificial data'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
 710             "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable"
 711           ]
 712         }
 713       ]
 714     },
 715     {
 716       "cell_type": "markdown",
 717       "metadata": {
 718         "id": "Ccr-uKbmAlBE"
 719       },
 720       "source": [
 721         "Now what if the model is wrong - different from nature? That is always so in reality. Now suppose that the model and the truth are not the same. That is always the case in reality.  Consider a simple case when the model thinks that the equilibrium $E$ is too high."
 722       ]
 723     },
 724     {
 725       "cell_type": "code",
 726       "metadata": {
 727         "id": "spMdGW8oAlBE"
 728       },
 729       "source": [
 730         "DeltaE = -0.05\n",
 731         "E, P = kf_example(DeltaE)  "
 732       ],
 733       "execution_count": null,
 734       "outputs": []
 735     },
 736     {
 737       "cell_type": "markdown",
 738       "metadata": {
 739         "id": "DQeF7J8T4j2i"
 740       },
 741       "source": [
 742         "We have found a good estimate of the state $m$, while data is available. Also, the estimated state variance $P$ converges with time - we have *learned* the variance that balances the noise. But for forecasting fuel moisture, we need to continue the fuel moisture model into the future, and we can't have any measurements from future. We only have the equilibrium from weather forecast. And the forecast and the truth disagree - as soon as there is no data to attract the simulation, the model is doing its own thing."
 743       ]
 744     },
 745     {
 746       "cell_type": "markdown",
 747       "metadata": {
 748         "id": "6uXVJj9koGF2"
 749       },
 750       "source": [
 751         "### Real data"
 752       ]
 753     },
 754     {
 755       "cell_type": "markdown",
 756       "metadata": {
 757         "id": "q3BpOBuzc91i"
 758       },
 759       "source": [
 760         "Data assimilation for fuel moisture from Remote Automated Weather Stations (RAWS) was developed in Vejmelka et al. (2016). First, they use regression from all RAWS in a given area to extend the data spatially from RAWS to a grid in the whole area, then they run the extended Kalman filter at each grid node. Here, we are interested in a simplified problem: estimate future fuel moisture at a single RAWS location from weather forecast. In lieu of weather forecast, we use the Real-Time Mesoscale Analysis ([RTMA](https://www.nco.ncep.noaa.gov/pmb/products/rtma/)) interpolated to the RAWS location. RTMA is a real-time product, posted hourly, and available only for few days in the past. We have our own collection of selected RAWS data over past few years, obtained as a side effecto of running the fuel moisture modeling software [WRFXPY](https://github.com/openwfm/wrfxpy).  "
 761       ]
 762     },
 763     {
 764       "cell_type": "markdown",
 765       "metadata": {
 766         "id": "c8Y6bL1Yc91i"
 767       },
 768       "source": [
 769         "### Fuel moisture RAWS data"
 770       ]
 771     },
 772     {
 773       "cell_type": "markdown",
 774       "metadata": {
 775         "id": "0CuXyWBFc91i"
 776       },
 777       "source": [
 778         "Try to load the data from a saved file first. If that fails, retrieve the fuel moisture data from sensors on weather stations in the Mesowest network. Get all stations with fuel moisture data in a spatial box within one hour, then pick one station and retrieve the whole time series."
 779       ]
 780     },
 781     {
 782       "cell_type": "code",
 783       "metadata": {
 784         "id": "LFrlbbMmc91i"
 785       },
 786       "source": [
 787         "import json\n",
 788         "jfile = 'raws.json'\n",
 789         "try:\n",
 790         "    ! wget --no-clobber https://demo.openwfm.org/web/data/raws.json\n",
 791         "    j = json.load(open(jfile,'r'))\n",
 792         "    print('loaded from ',jfile)\n",
 793         "    # Take the first station in the boulding box that has data between time_start and time_s2.\n",
 794         "    # Then retrieve data for that station between time_start and time_end\n",
 795         "    time_start = j['time_start']      # start of data time series\n",
 796         "    # time_s2    = j['time_s2']         # end of segment to read coordinates\n",
 797         "    time_end  = j['time_end']         # end of data time series\n",
 798         "    meso_ts  = j['meso_ts']           # get meso observations time series\n",
 799         "    obs_lon =   j['obs_lon']          # where we retrieved observations\n",
 800         "    obs_lat =   j['obs_lat']\n",
 801         "except:\n",
 802         "    print(\"can't read\",jfile,', creating')\n",
 803         "    # set up bounds\n",
 804         "    time_start = \"201806010800\"  # June 1 2018 08:00 in format yyyymmddHHMM\n",
 805         "    time_s2    = \"201806010900\"  # June 1 2018 09:00 in format yyyymmddHHMM \n",
 806         "    time_end   = \"201906200900\"  # Nov 1 2018 09:00 in format yyyymmddHHMM \n",
 807         "    #time_start=  \"201810230100\"\n",
 808         "    #time_s2=  \"201810230300\"\n",
 809         "    #time_end  =  \"201806022300\"\n",
 810         "    !pip install MesoPy\n",
 811         "    from MesoPy import Meso\n",
 812         "    bounding_box = \"-115, 38, -110, 40\"  # min longtitude, latitude\n",
 813         "    meso_token=\"b40cb52cbdef43ef81329b84e8fd874f\"       # you should get your own if you do more of this\n",
 814         "    m = Meso(meso_token)# create a Meso object\n",
 815         "    print('reading MesoWest fuel moisture data from',)\n",
 816         "    meso_obss = m.timeseries(time_start, time_s2, bbox=bounding_box, \n",
 817         "                             showemptystations = '0', vars='fuel_moisture')   # ask the object for data\n",
 818         "    # pick one station and retrieve the whole time series.\n",
 819         "    station=meso_obss['STATION'][0]\n",
 820         "    #print(json.dumps(station, indent=4))\n",
 821         "    lon,lat = (float(station['LONGITUDE']),float(station['LATITUDE']))\n",
 822         "    print(station['NAME'],'station',station['STID'],'at',lon,lat)\n",
 823         "    e = 0.01   # tolerance\n",
 824         "    bb = '%s, %s, %s, %s' % (lon - e, lat - e, lon + e, lat + e)\n",
 825         "    print('bounding box',bb)\n",
 826         "    meso_ts = m.timeseries(time_start, time_end, bbox=bb, showemptystations = '0', vars='fuel_moisture')   # ask the object for data\n",
 827         "    obs_lon, obs_lat = (lon, lat)   # remember station coordinates for later\n",
 828         "    j={'time_start':time_start,'time_s2':time_s2,'time_end':time_end,\n",
 829         "       'meso_ts':meso_ts,'obs_lon':obs_lon,'obs_lat':obs_lat}\n",
 830         "    json.dump(j,open(jfile,'w'),indent=4)\n",
 831         "    print('done')"
 832       ],
 833       "execution_count": null,
 834       "outputs": []
 835     },
 836     {
 837       "cell_type": "code",
 838       "metadata": {
 839         "id": "3bXopS3btyz0",
 840         "scrolled": true
 841       },
 842       "source": [
 843         "# process the data retrieved for this station\n",
 844         "# print(json.dumps(meso_ts['STATION'][0], indent=4))\n",
 845         "from datetime import datetime, timedelta, time\n",
 846         "import numpy as np\n",
 847         "import matplotlib.pyplot as plt\n",
 848         "import pytz\n",
 849         "station = meso_ts['STATION'][0]\n",
 850         "time_str  = station['OBSERVATIONS']['date_time']\n",
 851         "obs_time = [datetime.strptime(t, '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=pytz.UTC) for t in time_str]\n",
 852         "start_time = obs_time[0].replace(minute=0)     # remember obs_time and start_time for later\n",
 853         "end_time = obs_time[-1]\n",
 854         "obs_data = np.array(station['OBSERVATIONS'][\"fuel_moisture_set_1\"])\n",
 855         "# display the data retrieved\n",
 856         "#for o_time,o_data in zip (obs_time,obs_data):\n",
 857         "#    print(o_time,o_data)\n",
 858         "%matplotlib inline\n",
 859         "plt.figure(figsize=(16,4))\n",
 860         "plt.plot(obs_data,linestyle='-',c='k',label='10-h fuel data')\n",
 861         "plt.title(station['STID'] + ' 10 h fuel moisture data')\n",
 862         "plt.xlabel('Time (hours)') \n",
 863         "plt.ylabel('Fuel moisture content (%)')\n",
 864         "plt.legend()\n",
 865         " "
 866       ],
 867       "execution_count": null,
 868       "outputs": []
 869     },
 870     {
 871       "cell_type": "markdown",
 872       "metadata": {
 873         "id": "pY4hPeATK9wZ"
 874       },
 875       "source": [
 876         "## Retrieve weather analysis for the duration of the station data, from our RTMA stash."
 877       ]
 878     },
 879     {
 880       "cell_type": "markdown",
 881       "metadata": {
 882         "id": "dQ-uJI2sy6I3"
 883       },
 884       "source": [
 885         "Create a function to transfer RTMA files in GRIB2 format from the stash. The function returns zero if the file transfer succeeded. If the file is not available, it returns a nonzero value. Note: if needed, maybe in future add more sophisticated checks, check the return code of wget and if the file size is correct."
 886       ]
 887     },
 888     {
 889       "cell_type": "code",
 890       "metadata": {
 891         "id": "mxZABVDxt0gd"
 892       },
 893       "source": [
 894         "import subprocess,os\n",
 895         "def load_rtma(path,file,reload=0):\n",
 896         "  url='http://math.ucdenver.edu/~jmandel/rtma/' + path \n",
 897         "  if os.path.exists(file):\n",
 898         "    if reload:\n",
 899         "      print(file + ' already exists, removing')\n",
 900         "      os.remove(file)\n",
 901         "    else:\n",
 902         "      print(file + ' already exists, exiting')\n",
 903         "      # add checking size here\n",
 904         "      return 0\n",
 905         "  try:\n",
 906         "    ret = subprocess.check_output(['wget','--no-clobber','--output-document='+ file, url,],stderr=subprocess.STDOUT).decode() # execute command from python strings\n",
 907         "    if os.path.exists(file):\n",
 908         "      print('loaded ' + url + ' as ' + file)\n",
 909         "      return 0\n",
 910         "    else: \n",
 911         "      print('file transfer completed, but the file is missing? ' + url)  \n",
 912         "      return 1\n",
 913         "  except:\n",
 914         "    print('file transfer failed: ' + url)\n",
 915         "    return 2\n"
 916       ],
 917       "execution_count": 1,
 918       "outputs": []
 919     },
 920     {
 921       "cell_type": "markdown",
 922       "metadata": {
 923         "id": "THI6gElyHOOc"
 924       },
 925       "source": [
 926         "Next, functions to get the files, open as grib, and interpolate to the station coordinates"
 927       ]
 928     },
 929     {
 930       "cell_type": "code",
 931       "metadata": {
 932         "id": "PL3gxK67AlBI"
 933       },
 934       "source": [
 935         "def rtma_grib(t,var):\n",
 936         "    tpath = '%4i%02i%02i/%02i' % (t.year, t.month, t.day, t.hour)  # remote path on server\n",
 937         "    tstr  = '%4i%02i%02i%02i_' % (t.year, t.month, t.day, t.hour)  # time string for local path\n",
 938         "    gribfile = os.path.join('data',tstr + var + '.grib')\n",
 939         "    remote = tpath + '/' + var + '.grib'\n",
 940         "    if load_rtma(remote,gribfile):\n",
 941         "        print('cannot load remote file',remote,'as',gribfile)\n",
 942         "        return []\n",
 943         "    else:\n",
 944         "        try:\n",
 945         "            gf=GribFile(gribfile)\n",
 946         "            v = np.array(gf[1].values())\n",
 947         "        except:\n",
 948         "            print('cannot read grib file',gribfile)\n",
 949         "            return []\n",
 950         "        print('loaded ',gribfile,' containing array shape ',v.shape)\n",
 951         "        return gf[1]   # grib message\n"
 952       ],
 953       "execution_count": 2,
 954       "outputs": []
 955     },
 956     {
 957       "cell_type": "code",
 958       "metadata": {
 959         "id": "ccp10kurAlBI"
 960       },
 961       "source": [
 962         "from scipy.interpolate import LinearNDInterpolator, interpn\n",
 963         "from scipy.optimize import root\n",
 964         "def interp_to_lat_lon_slow(lats,lons,v,lat,lon): \n",
 965         "    # on mesh with coordinates lats and lons interpolate v to given lat lon\n",
 966         "    interp=LinearNDInterpolator(list(zip(lats.flatten(),lons.flatten())),v.flatten())\n",
 967         "    return interp(lat,lon)\n",
 968         "def interp_to_lat_lon(lats,lons,v,lat,lon):\n",
 969         "    # on mesh with coordinates lats and lons interpolate v to given lat lon\n",
 970         "    points=(np.array(range(lats.shape[0]),float),np.array(range(lats.shape[1]),float))  # uniform mesh\n",
 971         "    def res(ij):  # interpolation of lons lats on the uniform mesh, to noninteger coordinates   \n",
 972         "       return np.hstack((interpn(points,lats,ij)-lat, interpn(points,lons,ij)-lon))\n",
 973         "    # solve for xi,xj such that lats(xi,xj)=lat lons(xi,xj)=lon, then interpolate to (xi, xj) on uniform grid \n",
 974         "    result = root(res,(0,0)) # solve res(ij) = 0\n",
 975         "    if not result.success:\n",
 976         "        print(result.message)\n",
 977         "        exit(1)\n",
 978         "    return interpn(points,v,result.x) \n"
 979       ],
 980       "execution_count": 3,
 981       "outputs": []
 982     },
 983     {
 984       "cell_type": "markdown",
 985       "metadata": {
 986         "id": "jvnpq6S5AlBI"
 987       },
 988       "source": [
 989         "The interpolation function needs to  be tested."
 990       ]
 991     },
 992     {
 993       "cell_type": "code",
 994       "metadata": {
 995         "id": "NVMJBYI7AlBI"
 996       },
 997       "source": [
 998         "def interp_to_lat_lon_test(lats,lons):\n",
 999         "    print('testing interp_to_lat_lon')\n",
1000         "    vx, vy = np.meshgrid(range(lats.shape[0]),range(lats.shape[1]),indexing='ij')\n",
1001         "    i, j = (1,2)\n",
1002         "    lat,lon = ((lats[i,j]+lats[i+1,j+1])/2,(lons[i,j]+lons[i+1,j+1])/2)\n",
1003         "    vi = interp_to_lat_lon(lats,lons,vx,lat,lon)\n",
1004         "    vj = interp_to_lat_lon(lats,lons,vy,lat,lon)\n",
1005         "    print(vi,vj,'should be about',i+0.5,j+0.5)\n",
1006         "    test_slow = 0\n",
1007         "    if test_slow:\n",
1008         "        print('Testing against the standard slow method scipy.interpolate.LinearNDInterpolator. Please wait...')\n",
1009         "        vi_slow = interp_to_lat_lon_slow(lats,lons,vx,lat,lon)\n",
1010         "        print(vi_slow)\n",
1011         "        vj_slow = interp_to_lat_lon_slow(lats,lons,vy,lat,lon)\n",
1012         "        print(vj_slow)\n",
1013         "        \n",
1014         "#gf = rtma_grib(start_time,'temp')      #  read the first grib file and use it to test interpolation\n",
1015         "#lats, lons = gf.latlons()\n",
1016         "#interp_to_lat_lon_test(lats,lons)\n"
1017       ],
1018       "execution_count": 4,
1019       "outputs": []
1020     },
1021     {
1022       "cell_type": "code",
1023       "metadata": {
1024         "id": "vt-Mk8fIc91m"
1025       },
1026       "source": [
1027         "#%debug\n"
1028       ],
1029       "execution_count": null,
1030       "outputs": []
1031     },
1032     {
1033       "cell_type": "markdown",
1034       "metadata": {
1035         "id": "LQbWB_3GAlBI"
1036       },
1037       "source": [
1038         "Now we are ready for a function to read the RTMA files and interpolate to the station coordinates"
1039       ]
1040     },
1041     {
1042       "cell_type": "code",
1043       "metadata": {
1044         "id": "b3JJH3XPAlBI"
1045       },
1046       "source": [
1047         "import pandas as pd, json\n",
1048         "def read_interp_rtma(varnames,times,lat,lon):\n",
1049         "    # read RTMA from start_time to end_time and interpolate to obs_lat obs_lon\n",
1050         "    ntimes = len(times)\n",
1051         "    time_str = 'time_str'\n",
1052         "    j={time_str:times.strftime('%Y-%m-%d %H:%M').tolist()}\n",
1053         "    for varname in varnames:\n",
1054         "        j[varname]=np.full(ntimes,np.nan)  # initialize array of nans as list\n",
1055         "    n=0\n",
1056         "    for t in times:\n",
1057         "        tim=t.strftime('%Y-%m-%d %H:%M')\n",
1058         "        should_be = j[time_str][n]\n",
1059         "        if tim != should_be:\n",
1060         "            print('n=',n,'time',tim,'expected',should_be)\n",
1061         "            raise 'Invalid time' \n",
1062         "        for varname in varnames:\n",
1063         "            gf = rtma_grib(t,varname)   # read and create grib object, download if needed\n",
1064         "            if gf:\n",
1065         "                lats,lons = gf.latlons()    # coordinates\n",
1066         "                v = gf.values()\n",
1067         "                vi=interp_to_lat_lon(lats,lons,v,lat,lon) # append to array\n",
1068         "                print(varname,'at',t,'interpolated to',lat,lon,' value ',vi)\n",
1069         "                j[varname][n] = vi\n",
1070         "            else:\n",
1071         "                print(varname,'at',t,' could not be loaded')\n",
1072         "        n = n+1\n",
1073         "    return j"
1074       ],
1075       "execution_count": 5,
1076       "outputs": []
1077     },
1078     {
1079       "cell_type": "code",
1080       "metadata": {
1081         "id": "WlqJRP8Vc91o"
1082       },
1083       "source": [
1084         "import json\n",
1085         "jfile = 'rtma.json'\n",
1086         "try:\n",
1087         "    ! wget --no-clobber https://demo.openwfm.org/web/data/rtma.json\n",
1088         "    j = json.load(open(jfile,'r'))\n",
1089         "    print('loaded from ',jfile)\n",
1090         "    if j['obs_lat']!=obs_lat or j['obs_lon']!=obs_lon:\n",
1091         "        raise 'Wrong lon lat'\n",
1092         "except:\n",
1093         "    print(\"can't read\",jfile,', creating')\n",
1094         "    # Set up environment to read RTMA gribs\n",
1095         "    # we will need current numpy for pygrib - needed on Colab, tensorflow is using numpy 1.19\\\n",
1096         "    times = pd.date_range(start=time_start,end=time_end,freq='1H')\n",
1097         "    varnames=['temp','td','precipa']\n",
1098         "    j =    read_interp_rtma(varnames,times,obs_lat,obs_lon)      # temperature\n",
1099         "    for varname in varnames:\n",
1100         "        j[varname]=j[varname].tolist() \n",
1101         "    j['obs_lat']=obs_lat\n",
1102         "    j['obs_lon']=obs_lon\n",
1103         "    json.dump(j,open('rtma.json','w'),indent=4)\n",
1104         "    print('done')"
1105       ],
1106       "execution_count": null,
1107       "outputs": []
1108     },
1109     {
1110       "cell_type": "code",
1111       "metadata": {
1112         "id": "bMpYIZT6c91o"
1113       },
1114       "source": [
1115         "# %debug\n"
1116       ],
1117       "execution_count": null,
1118       "outputs": []
1119     },
1120     {
1121       "cell_type": "code",
1122       "metadata": {
1123         "id": "fNA3Vbo1c91o"
1124       },
1125       "source": [
1126         "rtma = j\n",
1127         "td = np.array(rtma['td'])\n",
1128         "t2 = np.array(rtma['temp'])\n",
1129         "rain=np.array(rtma['precipa'])\n",
1130         "# compute relative humidity\n",
1131         "rh = 100*np.exp(17.625*243.04*(td - t2) / (243.04 + t2 - 273.15) / (243.0 + td - 273.15))\n",
1132         "Ed = 0.924*rh**0.679 + 0.000499*np.exp(0.1*rh) + 0.18*(21.1 + 273.15 - t2)*(1 - np.exp(-0.115*rh))\n",
1133         "Ew = 0.618*rh**0.753 + 0.000454*np.exp(0.1*rh) + 0.18*(21.1 + 273.15 - t2)*(1 - np.exp(-0.115*rh))"
1134       ],
1135       "execution_count": null,
1136       "outputs": []
1137     },
1138     {
1139       "cell_type": "code",
1140       "metadata": {
1141         "id": "tZIK59bJAlBJ"
1142       },
1143       "source": [
1144         "%matplotlib inline\n",
1145         "plt.figure(figsize=(16,4))\n",
1146         "plt.plot(t2,linestyle='-',c='k',label='Temperature')\n",
1147         "plt.title(station['STID'] + ' Temperature')\n",
1148         "plt.xlabel('Time (hours)') \n",
1149         "plt.ylabel('Temperature (K)')\n",
1150         "plt.legend()"
1151       ],
1152       "execution_count": null,
1153       "outputs": []
1154     },
1155     {
1156       "cell_type": "code",
1157       "metadata": {
1158         "id": "LbyqcuXYAlBJ"
1159       },
1160       "source": [
1161         "%matplotlib inline\n",
1162         "plt.figure(figsize=(16,4))\n",
1163         "plt.plot(td,linestyle='-',c='k',label='Dew point')\n",
1164         "plt.title(station['STID'] + ' Dew point (K)')\n",
1165         "plt.xlabel('Time (hours)') \n",
1166         "plt.ylabel('Dew point (K)')\n",
1167         "plt.legend()"
1168       ],
1169       "execution_count": null,
1170       "outputs": []
1171     },
1172     {
1173       "cell_type": "code",
1174       "metadata": {
1175         "id": "dfoOK2kSc91p"
1176       },
1177       "source": [
1178         "%matplotlib inline\n",
1179         "plt.figure(figsize=(16,4))\n",
1180         "plt.plot(rh,linestyle='-',c='k',label='Dew point')\n",
1181         "plt.title(station['STID'] + ' relative humidity')\n",
1182         "plt.xlabel('Time (hours)') \n",
1183         "plt.ylabel('Relative humidity (%)')\n",
1184         "plt.legend()"
1185       ],
1186       "execution_count": null,
1187       "outputs": []
1188     },
1189     {
1190       "cell_type": "code",
1191       "metadata": {
1192         "id": "MWTJ5b2kc91p"
1193       },
1194       "source": [
1195         "%matplotlib inline\n",
1196         "plt.figure(figsize=(16,4))\n",
1197         "plt.plot(Ed,linestyle='-',c='r',label='drying equilibrium')\n",
1198         "plt.plot(Ew,linestyle=':',c='b',label='wetting equilibrium')\n",
1199         "plt.title(station['STID'] + ' drying and wetting equilibria')\n",
1200         "plt.xlabel('Time (hours)') \n",
1201         "plt.ylabel('Fuel moisture contents (%)')\n",
1202         "plt.legend()"
1203       ],
1204       "execution_count": null,
1205       "outputs": []
1206     },
1207     {
1208       "cell_type": "markdown",
1209       "metadata": {
1210         "id": "jY3_eeBRc91p"
1211       },
1212       "source": [
1213         " "
1214       ]
1215     },
1216     {
1217       "cell_type": "code",
1218       "metadata": {
1219         "id": "PQKSRvRSAlBJ"
1220       },
1221       "source": [
1222         "%matplotlib inline\n",
1223         "plt.figure(figsize=(16,4))\n",
1224         "plt.plot(rain,linestyle='-',c='k',label='Precipitation')\n",
1225         "plt.title(station['STID'] + ' Precipitation' )\n",
1226         "plt.xlabel('Time (hours)') \n",
1227         "plt.ylabel('Precipitation (mm/hour)')\n",
1228         "plt.legend()"
1229       ],
1230       "execution_count": null,
1231       "outputs": []
1232     },
1233     {
1234       "cell_type": "code",
1235       "metadata": {
1236         "id": "Dwbt4UXfro5x"
1237       },
1238       "source": [
1239         "print(rain[1900:2000])"
1240       ],
1241       "execution_count": null,
1242       "outputs": []
1243     },
1244     {
1245       "cell_type": "markdown",
1246       "metadata": {
1247         "id": "_yRu_7WvHc6P"
1248       },
1249       "source": [
1250         "Precipitation from RTMA is in kg/m${}^2$. 1m water depth over 1m${}^2$ is 1m${}^3$ with mass 1000 kg thus 1 kg/m${}^2$ is the same as 1 mm of precipitation. RTMA values are accumulations over 1 h so these are values in mm/h. So 9999 mm/h = 10m/h makes no sense. Replace anything over 1m/h by nan and try again."
1251       ]
1252     },
1253     {
1254       "cell_type": "code",
1255       "metadata": {
1256         "id": "XPYO_Iuvc91q"
1257       },
1258       "source": [
1259         "rain[rain > 1000] = np.NaN"
1260       ],
1261       "execution_count": null,
1262       "outputs": []
1263     },
1264     {
1265       "cell_type": "code",
1266       "metadata": {
1267         "scrolled": true,
1268         "id": "GYWTfbBBc91q"
1269       },
1270       "source": [
1271         "%matplotlib inline\n",
1272         "plt.figure(figsize=(16,4))\n",
1273         "plt.plot(rain,linestyle='-',c='k',label='Precipitation')\n",
1274         "plt.title(station['STID'] + ' Precipitation' )\n",
1275         "plt.xlabel('Time (hours)') \n",
1276         "plt.ylabel('Precipitation (mm/hour)')\n",
1277         "plt.legend()"
1278       ],
1279       "execution_count": null,
1280       "outputs": []
1281     },
1282     {
1283       "cell_type": "markdown",
1284       "metadata": {
1285         "id": "Q_L0R2Njc91q"
1286       },
1287       "source": [
1288         "Fix some missing data, then we can use the data for up to 1942 hours until a biger gap."
1289       ]
1290     },
1291     {
1292       "cell_type": "code",
1293       "metadata": {
1294         "id": "_tkU7UJic91q"
1295       },
1296       "source": [
1297         "# fix isolated nans\n",
1298         "def fixnan(a,n):\n",
1299         "    for c in range(n):\n",
1300         "        for i in np.where(np.isnan(a)):\n",
1301         "            a[i]=0.5*(a[i-1]+a[i+1])\n",
1302         "        if not any(np.isnan(a)):\n",
1303         "            break\n",
1304         "    return a\n",
1305         "\n",
1306         "rain=fixnan(rain,2)\n",
1307         "t2=fixnan(t2,2)\n",
1308         "rh=fixnan(rh,2)\n",
1309         "obs_data=fixnan(obs_data,2)\n",
1310         "Ed=fixnan(Ed,2)\n",
1311         "Ew=fixnan(Ew,2)\n",
1312         "\n",
1313         "print(np.where(np.isnan(rain)))\n",
1314         "print(np.where(np.isnan(t2)))\n",
1315         "print(np.where(np.isnan(rh)))\n",
1316         "print(np.where(np.isnan(obs_data)))"
1317       ],
1318       "execution_count": null,
1319       "outputs": []
1320     },
1321     {
1322       "cell_type": "code",
1323       "metadata": {
1324         "id": "0SSWIbGCAlBK"
1325       },
1326       "source": [
1327         "### Define model function with drying, wetting, and rain equilibria\n",
1328         "\n",
1329         "# Parameters\n",
1330         "r0 = 0.05                                   # threshold rainfall [mm/h]\n",
1331         "rk = 8.0                                    # saturation rain intensity [mm/h]\n",
1332         "Trk = 14.0                                  # time constant for rain wetting model [h]\n",
1333         "S = 2.5                                     # saturation intensity [dimensionless]\n",
1334         "T = 10.0                                    # time constant for wetting/drying\n",
1335         "\n",
1336         "def model_moisture(m0,Eqd,Eqw,r,partials=0,T=10,tlen=1):\n",
1337         "    # arguments:\n",
1338         "    # m0         starting fuel moistureb (%)\n",
1339         "    # Eqd        drying equilibrium      (%) \n",
1340         "    # Eqw        wetting equilibrium     (%)\n",
1341         "    # r          rain intensity          (mm/h)\n",
1342         "    # partials = 0, 1, 2\n",
1343         "    # returns: same as model_decay\n",
1344         "    #   if partials==0: m1 = fuel moisture contents after time 1 hour\n",
1345         "    #              ==1: m1, dm1/dm0 \n",
1346         "    #              ==2: m1, dm1/dm0, dm1/dE  \n",
1347         "    \n",
1348         "    if r > r0:\n",
1349         "        # print('raining')\n",
1350         "        E = S\n",
1351         "        T1 = 1.0 / (Trk * (1.0 - np.exp(- (r - r0) / rk)))\n",
1352         "        exp_t = np.exp(-tlen*T1)\n",
1353         "        m1 = E + (m0 - E)*exp_t  \n",
1354         "        dm1_dm0 = exp_t\n",
1355         "        dm1_dE = 0\n",
1356         "    elif m0 <= Eqw: \n",
1357         "        # print('wetting')\n",
1358         "        T1 = 1.0/T\n",
1359         "        exp_t = np.exp(-tlen*T1)\n",
1360         "        m1 = Eqw + (m0 - Eqw)*exp_t  \n",
1361         "        dm1_dm0 = exp_t\n",
1362         "        dm1_dE = 1- exp_t\n",
1363         "    elif m0 >= Eqd:\n",
1364         "        # print('drying')\n",
1365         "        T1 = 1.0/T\n",
1366         "        exp_t = np.exp(-tlen*T1)\n",
1367         "        m1 = Eqd + (m0 - Eqd)*exp_t  \n",
1368         "        dm1_dm0 = exp_t\n",
1369         "        dm1_dE = 1- exp_t\n",
1370         "    else:\n",
1371         "        # print('no change')\n",
1372         "        m1 = m0\n",
1373         "        dm1_dm0 = 1.0\n",
1374         "        dm1_dE = 0.0  \n",
1375         "        \n",
1376         "    if partials==0: \n",
1377         "        return m1\n",
1378         "    if partials==1:\n",
1379         "        return m1, dm1_dm0\n",
1380         "    if partials==2:\n",
1381         "        return m1, dm1_dm0, dm1_dE\n",
1382         "    raise('bad partials')"
1383       ],
1384       "execution_count": null,
1385       "outputs": []
1386     },
1387     {
1388       "cell_type": "markdown",
1389       "metadata": {
1390         "id": "2tIC_Tqnc91r"
1391       },
1392       "source": [
1393         "# Kalman filter with RAWS observations, followed by forecasting\n",
1394         "We run the model first with Kalman filter for 150 hours. The observations are the RAWS data\n",
1395         "After 150 hours, we run in forecast mode - the RAWS data are no longer used, and we run the model from the weather data without the Kalman filter. The weather data are taken to be RTMA interpolated to one RAWS location.\n",
1396         "In a real forecasting application, the model would be run from weather forecast rather than data."
1397       ]
1398     },
1399     {
1400       "cell_type": "code",
1401       "metadata": {
1402         "id": "aXnSQM7wc91r"
1403       },
1404       "source": [
1405         "# run KF on an initial data seqment\n",
1406         "import numpy as np\n",
1407         "import matplotlib.pyplot as plt \n",
1408         "\n",
1409         "hours=300\n",
1410         "h2 = round(hours/2)\n",
1411         "m = np.zeros(hours) # preallocate\n",
1412         "m[0]= obs_data[0]             # initial state  \n",
1413         "P = np.zeros(hours)\n",
1414         "P[0] = 1e-3 # background state variance\n",
1415         "H = np.array([1.])   # all oQ = np.array([0.02]) # process noise variancebserved\n",
1416         "Q = np.array([1e-3]) # process noise variance\n",
1417         "R = np.array([1e-3]) # data variance\n",
1418         "for t in range(hours-1):\n",
1419         "    # using lambda construction to pass additional arguments to the model \n",
1420         "    if t < h2 and not np.isnan(obs_data[t]) and not np.isnan(Ew[t]) and not np.isnan(rain[t]): # advance model and run KF\n",
1421         "        m[t+1],P[t+1] = ext_kf(m[t],P[t],lambda u: model_moisture(u,Ed[t],Ew[t],rain[t],partials=1),Q,\n",
1422         "                    d=obs_data[t],H=H,R=R)\n",
1423         "    else:  # just advance to next hour, no process noise\n",
1424         "        m[t+1],P[t+1] = ext_kf(m[t],P[t],lambda u: model_moisture(u,Ed[t],Ew[t],rain[t],partials=1),Q*0.0)"
1425       ],
1426       "execution_count": null,
1427       "outputs": []
1428     },
1429     {
1430       "cell_type": "code",
1431       "metadata": {
1432         "scrolled": true,
1433         "id": "peMi-OF3c91r"
1434       },
1435       "source": [
1436         "%matplotlib inline\n",
1437         "plt.figure(figsize=(16,4))\n",
1438         "plt.plot(Ed[:hours],linestyle='--',c='r',label='Drying Equilibrium')\n",
1439         "plt.plot(Ew[:hours],linestyle='--',c='b',label='Wetting Equilibrium')\n",
1440         "plt.plot(obs_data[:hours],linestyle=':',c='k',label='RAWS data')\n",
1441         "plt.plot(m[:h2],linestyle='-',c='k',label='filtered')\n",
1442         "plt.plot(range(h2,hours),m[h2:hours],linestyle='-',c='r',label='forecast')\n",
1443         "plt.title('Kalman filtering and forecast with real data')\n",
1444         "plt.xlabel('Time (hours)') \n",
1445         "plt.ylabel('Fuel moisture content (%)')\n",
1446         "plt.legend()"
1447       ],
1448       "execution_count": null,
1449       "outputs": []
1450     },
1451     {
1452       "cell_type": "markdown",
1453       "metadata": {
1454         "id": "3TnwXYcLc91r"
1455       },
1456       "source": [
1457         "Clearly, there is a problem - the forecast fuel moisture is too high. We need to assimilate also some parameters of the model, not just its output state. "
1458       ]
1459     },
1460     {
1461       "cell_type": "markdown",
1462       "metadata": {
1463         "id": "jivOYEhiXMi5"
1464       },
1465       "source": [
1466         "## Model with an augmented state\n",
1467         "In reality, the equilibrium moisture $E$ computed from atmospheric conditions\n",
1468         "generally does not agree with the data. We want to add a correction $\\Delta\n",
1469         "E$ to $E$ constant in time, and identify the new parameter $\\Delta E$ from data. \n",
1470         "Because the Kalman filter identifies state, add the parameter to the state.\n",
1471         "Define augmented state $u=\\left[\n",
1472         "\\begin{array}\n",
1473         "[c]{c}\n",
1474         "m\\\\\n",
1475         "\\Delta E\n",
1476         "\\end{array}\n",
1477         "\\right]  .$ Since $\\Delta E$ is constant in time, it satisfies the\n",
1478         "differential equation $\\frac{d\\Delta E}{dt}=0.$ So, we want to estimate the\n",
1479         "state $u$ governed by the\n",
1480         "$$\n",
1481         "\\frac{d}{dt}\\left[\n",
1482         "\\begin{array}\n",
1483         "[c]{c}\n",
1484         "m\\\\\n",
1485         "\\Delta E\n",
1486         "\\end{array}\n",
1487         "\\right]  =\\left[\n",
1488         "\\begin{array}\n",
1489         "[c]{c}\n",
1490         "\\frac{E+\\Delta E-m(t)}{T}\\\\\n",
1491         "0\n",
1492         "\\end{array}\n",
1493         "\\right]  ,\n",
1494         "$$\n",
1495         "which we write as $\\frac{du}{dt}=F(u),$ where\n",
1496         "$$\n",
1497         "F(u)=\\left[\n",
1498         "\\begin{array}\n",
1499         "[c]{c}\n",
1500         "F_{1}\\left(  u\\right)  \\\\\n",
1501         "F_{2}\\left(  u\\right)\n",
1502         "\\end{array}\n",
1503         "\\right]  =F\\left(  \\left[\n",
1504         "\\begin{array}\n",
1505         "[c]{c}\n",
1506         "m\\\\\n",
1507         "\\Delta E\n",
1508         "\\end{array}\n",
1509         "\\right]  \\right)  =\\left[\n",
1510         "\\begin{array}\n",
1511         "[c]{c}\n",
1512         "\\left(  E+\\Delta E-m(t)\\right)  T_{1}\\\\\n",
1513         "0\n",
1514         "\\end{array}\n",
1515         "\\right]  ,\\quad T_{1}=\\frac{1}{T}.\n",
1516         "$$\n",
1517         "The Jacobian of $F$ is\n",
1518         "$$\n",
1519         "\\left[\n",
1520         "\\begin{array}\n",
1521         "[c]{cc}\n",
1522         "\\frac{\\partial F_{1}}{\\partial u_{1}} & \\frac{\\partial F_{1}}{\\partial u_{2}\n",
1523         "}\\\\\n",
1524         "\\frac{\\partial F_{2}}{\\partial u_{1}} & \\frac{\\partial F_{2}}{\\partial u_{2}}\n",
1525         "\\end{array}\n",
1526         "\\right]  =\\left[\n",
1527         "\\begin{array}\n",
1528         "[c]{cc}\n",
1529         "\\frac{\\partial m_{1}}{\\partial m_{0}} & \\frac{\\partial m_{1}}{\\partial E}\\\\\n",
1530         "\\frac{\\partial\\Delta E}{\\partial m_{0}} & \\frac{\\partial\\Delta E}\n",
1531         "{\\partial\\Delta E}\n",
1532         "\\end{array}\n",
1533         "\\right]  =\\left[\n",
1534         "\\begin{array}\n",
1535         "[c]{cc}\n",
1536         "\\frac{\\partial m_{1}}{\\partial m_{0}} & \\frac{\\partial m_{1}}{\\partial E}\\\\\n",
1537         "0 & 1\n",
1538         "\\end{array}\n",
1539         "\\right]\n",
1540         "$$\n",
1541         "Here is a function that implements the augmented model $F$. The input is\n",
1542         "$u_{0}$. The output is $u_{1}$ and the Jacobian $du_{1}/du_{0}$."
1543       ]
1544     },
1545     {
1546       "cell_type": "markdown",
1547       "metadata": {
1548         "id": "MJ1C_1Omc91s"
1549       },
1550       "source": [
1551         "### Define augmented model function with drying, wetting, and rain equilibria"
1552       ]
1553     },
1554     {
1555       "cell_type": "code",
1556       "metadata": {
1557         "id": "GHtAaGp9WSHT"
1558       },
1559       "source": [
1560         "def model_augmented(u0,Ed,Ew,r):\n",
1561         "    # state u is the vector [m,dE] with dE correction to equilibria Ed and Ew\n",
1562         "    # \n",
1563         "    m0, Ec = u0  # decompose state u0\n",
1564         "    # reuse model_moisture(m0,Eqd,Eqw,r,partials=0):\n",
1565         "    # arguments:\n",
1566         "    # m0         starting fuel moistureb (1)\n",
1567         "    # Ed         drying equilibrium      (1) \n",
1568         "    # Ew         wetting equilibrium     (1)\n",
1569         "    # r          rain intensity          (mm/h)\n",
1570         "    # partials = 0, 1, 2\n",
1571         "    # returns: same as model_decay\n",
1572         "    #   if partials==0: m1 = fuel moisture contents after time 1 hour\n",
1573         "    #              ==1: m1, dm0/dm0 \n",
1574         "    #              ==2: m1, dm1/dm0, dm1/dE \n",
1575         "    m1, dm1_dm0, dm1_dE  = model_moisture(m0,Ed + Ec, Ew + Ec, r, partials=2)\n",
1576         "    u1 = np.array([m1,Ec])   # dE is just copied\n",
1577         "    J =  np.array([[dm1_dm0, dm1_dE],\n",
1578         "                   [0.     ,     1.]])\n",
1579         "    return u1, J"
1580       ],
1581       "execution_count": null,
1582       "outputs": []
1583     },
1584     {
1585       "cell_type": "markdown",
1586       "metadata": {
1587         "id": "8SuVNg8TsW4d"
1588       },
1589       "source": [
1590         "### Run the extended Kalman filter on the augmented model"
1591       ]
1592     },
1593     {
1594       "cell_type": "code",
1595       "metadata": {
1596         "id": "1No3g6HyAEh_"
1597       },
1598       "source": [
1599         "u = np.zeros((2,hours))\n",
1600         "u[:,0]=[0.1,0.1]       # initialize,background state  \n",
1601         "P = np.zeros((2,2,hours))\n",
1602         "P[:,:,0] = np.array([[1e-3, 0.],\n",
1603         "                    [0.,  1e-3]]) # background state covariance\n",
1604         "Q = np.array([[1e-3, 0.],\n",
1605         "              [0,  1e-3]]) # process noise covariance\n",
1606         "H = np.array([[1., 0.]])  # first component observed\n",
1607         "R = np.array([1e-3]) # data variance\n",
1608         "\n",
1609         "# ext_kf(u,P,F,Q=0,d=None,H=None,R=None) returns ua, Pa\n",
1610         "\n",
1611         "# print('initial u=',u,'P=',P)\n",
1612         "# print('Q=',Q,'H=',H,'R=',R)\n",
1613         "for t in range(1,h2):\n",
1614         "    # use lambda construction to pass additional arguments to the model \n",
1615         "    u[:,t],P[:,:,t] = ext_kf(u[:,t-1],P[:,:,t-1],\n",
1616         "                                 lambda uu: model_augmented(uu,Ed[t],Ew[t],rain[t]),\n",
1617         "                                 Q,obs_data[t],H=H,R=R)\n",
1618         "    print('time',t,'data',obs_data[t],'filtered',u[0,t],'Ec',u[1,t])\n",
1619         "for t in range(h2,hours):\n",
1620         "    u[:,t],P[:,:,t] = ext_kf(u[:,t-1],P[:,:,t-1],\n",
1621         "                                 lambda uu: model_augmented(uu,Ed[t],Ew[t],rain[t]),\n",
1622         "                                 Q*0.0)\n",
1623         "    # print('time',t,'data',obs_data[t],'forecast',u[0,t],'Ec',u[1,t])"
1624       ],
1625       "execution_count": null,
1626       "outputs": []
1627     },
1628     {
1629       "cell_type": "code",
1630       "metadata": {
1631         "id": "wa-eMw4Qc91s"
1632       },
1633       "source": [
1634         "m,Ec = u  # extract from state"
1635       ],
1636       "execution_count": null,
1637       "outputs": []
1638     },
1639     {
1640       "cell_type": "code",
1641       "metadata": {
1642         "id": "B7sXGUotc91s"
1643       },
1644       "source": [
1645         "%matplotlib inline\n",
1646         "plt.figure(figsize=(16,4))\n",
1647         "plt.plot(Ed[:hours],linestyle='--',c='r',label='Drying Equilibrium')\n",
1648         "plt.plot(Ew[:hours],linestyle='--',c='b',label='Wetting Equilibrium')\n",
1649         "plt.plot(Ec[:hours],linestyle='--',c='g',label='Equilibrium Correction')\n",
1650         "plt.plot(obs_data[:hours],linestyle=':',c='k',label='RAWS data')\n",
1651         "plt.plot(m[:h2],linestyle='-',c='k',label='Filtered')\n",
1652         "plt.plot(range(h2,hours),m[h2:hours],linestyle='-',c='r',label='Forecast')\n",
1653         "plt.title('Kalman filtering and forecast with augmented state, real data')\n",
1654         "plt.xlabel('Time (hours)') \n",
1655         "plt.ylabel('Fuel moisture content (%)')\n",
1656         "plt.legend()\n"
1657       ],
1658       "execution_count": null,
1659       "outputs": []
1660     },
1661     {
1662       "cell_type": "markdown",
1663       "metadata": {
1664         "id": "7W03QTo3c91t"
1665       },
1666       "source": [
1667         "Filtering by extended Kalman filter using RAWS data until 150 hours, then forecasting mode - running the model from interpolated RTMA only. For the first 60 hours the forecast is good, the equilibium correction made the model quite close to data. But then the big spike in equilibrium moisture around 230 hours attracted the solution, and it took a while for it to get back. The spike in the RAWS measurement is there but much smaller. \n",
1668         "\n",
1669         "Possible reasons include: 1. There was something in the data we do not know about - maybe it rained but RTMA did not tell us. Try comparing with data from the RAWS itself? 2. The model is too simple, assumes the whole depth of the wood stick is wetting and drying at the same time. Perhaps the moisture got stored in the inside layers of the measurement stick. Try a two-layer model - make the state larger? "
1670       ]
1671     },
1672     {
1673       "cell_type": "markdown",
1674       "metadata": {
1675         "id": "gVQxv9Blc91t"
1676       },
1677       "source": [
1678         "## Information flow in the Kalman filter and neural networks"
1679       ]
1680     },
1681     {
1682       "cell_type": "markdown",
1683       "metadata": {
1684         "id": "CZmR4HPAc91t"
1685       },
1686       "source": [
1687         "At each time step $k$,\n",
1688         "\n",
1689         "* input state $u_{k-1}$ size $n$ and its covariance matrix $P_{k-1}$ size $n \\times n$.\n",
1690         "* the model is applied to external data $e_k$ and the input $u_{k-1},P_{k-1}$ produce the forecast $u_k^f$ and its covariance $P^f_k$\n",
1691         "* the new state $u_k$ is found by minimizing $|| u^f_k - u_k||^2_{P^f_k} + ||H u_k - d_k||^2_{R}$   \n",
1692         "* the new state covariance is $P_k = ( (P^f_k)^{-1} + H^\\top R^{-1} H)^{-1}$.\n",
1693         "\n",
1694         "Here, the state consists of \n",
1695         "* the fuel moisture and the adjustment to the equilibrium, dimension 2\n",
1696         "* the covariance matrix of vector of dimension 2, which is symmetric $2 \\times 2$ matrix, given by 3 numbers because it is symmetric\n",
1697         "Thus, the dimension of the state is 2 + 3 = 5. The first component of the state, the fuel moisture, is the quantity of interest, the rest are auxiliary.\n",
1698         "\n",
1699         "\n",
1700         "This can be understood as:\n",
1701         "\n",
1702         "* a mapping $M$ of the 5-dimensional hidden and external data state to a new hidden state:\n",
1703         "$$M:(u_{k-1},P_{k-1},e_k) \\mapsto (u_{k},P_{k})$$\n",
1704         "* taking the output (the quantity of interest) as the first component of the hiddent state\n",
1705         "* feeding the hiddent state back to the mapping $M$ for the next step $k+1$\n",
1706         "* training consists of fitting the hidden state to minimize a loss function\n",
1707         "$$\\ell(u_{k},P_{k},d_k,R_k) \\to \\min$$\n",
1708         "\n",
1709         "Note that in the augmented Kalman filter above, the mapping $M$ is fixed and it has a one component of the hidden state as a parameter. To get a better fit, we could increase the number of parameters, e.g., by modeling the moisture in multiple layers, as in van der Kamp et al. (2017) two-layer model.\n",
1710         "\n",
1711         "A recurrent neural network (RNN) has a similar information flow but it can be more flexible and look for the best $M$ automatically, i.e., build the model from data. \n"
1712       ]
1713     },
1714     {
1715       "cell_type": "markdown",
1716       "metadata": {
1717         "id": "_g_OTEg6ePb9"
1718       },
1719       "source": [
1720         "## Conclusion"
1721       ]
1722     },
1723     {
1724       "cell_type": "markdown",
1725       "metadata": {
1726         "id": "ylDXUrCKeSOr"
1727       },
1728       "source": [
1729         "We have shown how to combine a model and data for improved forecasting of fuel moisture from weather forecast using the Kalman filter. Augmenting the filter state by a model parameter and joint estimation of augmented state let to an improvement of the forecast."
1730       ]
1731     },
1732     {
1733       "cell_type": "markdown",
1734       "metadata": {
1735         "id": "ZsNZxOv7c91t"
1736       },
1737       "source": [
1738         "## References"
1739       ]
1740     },
1741     {
1742       "cell_type": "markdown",
1743       "metadata": {
1744         "id": "vFY-iS1Wc91t"
1745       },
1746       "source": [
1747         "J. Mandel, S. Amram, J. D. Beezley, G. Kelman, A. K. Kochanski, V. Y. Kondratenko, B. H. Lynn, B. Regev, and M. Vejmelka. Recent advances and applications of WRF-SFIRE. Natural Hazards and Earth System Science, 14(10):2829–2845, 2014. [doi:10.5194/nhessd-2-1759-2014](https://doi.org/10.5194/nhessd-2-1759-2014)\n",
1748         "\n",
1749         "R. E. Kalman. A new approach to linear filtering and prediction problems. Transactions of the ASME – Journal of Basic Engineering, Series D, 82:35–45, 1960. [doi:10.1115/1.3662552](https://doi.org/10.1115/1.3662552)\n",
1750         "\n",
1751         "E. Kalnay. Atmospheric Modeling, Data Assimilation and Predictability. Cambridge University Press, 2003. [doi:10.1017/CBO9780511802270](https://doi.org/10.1017/CBO9780511802270)\n",
1752         "\n",
1753         "D.W. Van der Kamp, R.D. Moore, and I.G. McKendry. A model for simulating the moisture content of standardized fuel sticks of various sizes. Agricultural and Forest Meteorology, 236:123–134, 2017. [doi:10.1016/j.agrformet.2017.01.013](https://doi.org/10.1016/j.agrformet.2017.01.013)\n",
1754         "\n",
1755         "M. Vejmelka, A. K. Kochanski, and J. Mandel. Data assimilation of dead fuel moisture observations from remote automatic weather stations. International Journal of Wildland Fire, 25:558– 568, 2016. [doi:10.1071/WF14085](https://doi.org/10.1071/WF14085)\n"
1756       ]
1757     }
1758   ]
1759 }