{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C.D. Cooper. Partly based on content  by David Ketcheson, also under CC-BY."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Phugoid model: bonus!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_The phugoid model of glider flight_ has been such a fun problem to showcase the power of numerical solution of differential equations, we thought you'd enjoy a bonus notebook. The previous lessons were:\n",
    "\n",
    "* [Phugoid motion](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_01_Phugoid_Theory.ipynb) —Lays the groundwork for our fun problem, with some context, a little history and a description of the physics of phugoids: curves representing the trajectory of a glider exchanging potential and kinetic energy, with no drag.\n",
    "* [Phugoid oscillation](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb) —Develops the simple harmonic motion of an aircraft experiencing a small perturbation from the horizontal trajectory: our opportunity to introduce Euler's method, and study its convergence via an exact solution.\n",
    "* [Full phugoid motion](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb) —The full model takes into account the force of drag and results in a system of two nonlinear equations. We obtain the trajectories using Euler's method in vectorized form, introduce grid-convergence analysis and finish with the paper-airplane challenge!\n",
    "\n",
    "That is a fantastic foundation for numerical methods. It's a good time to complement it with some theory: the first screencast of the course uses Taylor series to show that _Euler's method is a first-order method_, and we also show you graphical interpretations. Many problems require a more accurate method, though: second order or higher. Among the most popular higher-order methods that we can mention are the _Runge-Kutta methods_, developed around 1900: more than 100 years after Euler published his book containing the method now named after him!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Euler's method is a first-order method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this screencast, we use a Taylor series expansion to analyze Euler's method and show that it incurs a truncation error of first order. We also use a graphical interpretation to motivate the _modified_ Euler method, which achieves second order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAUDBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChALCAgOCggIDRUNDhERExMTCAsWGBYSGBASExIBBQUFCAcIDwkJDxQPDw8UFBQUFBQUFBQVFRUUFBQVFBQUFBQUFBUUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAWgB4AMBIgACEQEDEQH/xAAdAAEAAgIDAQEAAAAAAAAAAAAABQYEBwECAwgJ/8QAWBAAAgIBAwMBBgEGBwoJCQkAAQIDBAAFERIGEyExBxQiQVFhMggVI0JxgRYkUmJykbUlMzU2U3R1obG0Q1V2gpKUwdHSFzREY4S20/DxRXOFk6Oys8LF/8QAFwEBAQEBAAAAAAAAAAAAAAAAAAECA//EACwRAQEBAAEDAwIFBAMBAAAAAAABEQISITFBUWEDgSJxscHwE5Gh0TLh8UL/2gAMAwEAAhEDEQA/APsrGMYAY3xjAYxjJQxjGAxjGNDGMYDGMZQxjGAxjGAGBjOMDnGMYDGMYDGMYDBxjJoYxjGhjGMoYxjAYxjAYxjADOd84xkoYxjAYxjKGMYwGMYyaGMYxoYxjEDGMZQxjGAxjGAwMYGAxjGQMYxgMYxlDGMYDGMZAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGAxjGKGMYwGMYwGMYyhjGMgYxjAYxjGBjGMoYxjIGMYwGBjAyhjGMBjOkoJVgp4kggNsDxJHg7Hwdvpms3i18aumm/n5eDabJd7n5pqc+aWY4OG3PbiQ5P18ZZx1LcbPxlN/g/ro9OoV3+XLR6hX94WQHb9hGd+kNfue+zaTqq1xeiri5WsVO4lbUKRkELzJDKS9eeKUokkXJwO9CwY89ldPtdNW/GMZlTGMYDGMYDGM4wOcZVoNcsN1DY008PdY9Fp3lHH9J7xPevV5CX38pwrx7Db13+uWnLeOJpjKnrnVNuvrWm6ZHpNuzVuwzyT6pH/5rSaEErHN42BbYepB+Ndg3xbWzF42fc0xnGc5FMYxgMZ5WUZkdUftuysEfiG4MQQr8T4bY7HY+u2UrpO3qcWtW9Nu3kvRJplS7E4pxVZEkmtXIJFJiYh04wIRuNwd/XLOOpbi9YxmHrNeeWB0rWPdZm24T9pJ+3sQT+ikPF9xuPP1yRWZjNPdJ9capU16/pmsTw2tNGoV9Ko6ilda0kepS6ZR1JK9tEJjCTrdMcbj1evxPmRc3DmuXC8Ul0xmterTrkOq6bVg1lI6+p2L44tplaRq0derJaiSNy47m3EISw3I8+ubA0qGWOGNJ5veJlXaSftrD3G/ldpDxT9g+mLxyeSVlYxnGZVzjGMBjGMBjGMBjGMBjGMgYzg5U+kuqrd3UtXozaTcowadJEla9Pt2NRWQNyev422HEHwW8Ou/E7rmpxt+yWrbjbGc5FcYxjAYxkfr9WzNCUq2/c5uSkTdiOx8I/EvbkIXz9flgSGMqXsv1K5YrWhenSzPV1PUaXfSFa4kjq2XjiYxISqvxA32Pk/TLbmr2uJLpjGMimMYyYGMYwGBjAyhjGMBlMl/xpi/0BP8A2jBlzzWvVekS3Opqyxahc08poVhmen7tykB1CuAr+8wyDiPXwAfOb+n3v2rPLx/ZsrKHqDiXq2gsWzNS0DVGtODuYRfvaUtONwPQymlacf5q2ZP8CrZ8N1HrhHzAbTEP7mWhuP3ZMdJ9L09MSVayyGSxJ3rVmxNLZt2piAvcsWJmMkhCgKoJ4qoCqFAAxM4+pda56i6r1Hp7WKFW5qNnWo9Vo6m1OglCnDam1GrY0xateu9ZFGzR27BZ5SERYS7MApOWUaB1DdCzW9cfSWYb+5aNVoTpDy2+CW7qtWZ7TrsfjSOAHc/D6Z16gjU9XaCSoJTQupGQkAlWNzpxeSk/hPFmG4+TH65fRmuXLJMk8fukii9Fahq9np6lNE8FnVJECPPf/QRnjZaKSzLHUiHJxEpcRoEDsAOSA8hwej9bb45OrNQSU+eFbTdDjpqdh8KQ2KUs5j+zTFv52THWXUEtRqlSnAlnUNQkkSrFLI0NeOKBRJat2ZERmWCJWTwqku8sSDjz5LFLovU7bl9f01CTuEh6ffgo/k8pdUZnI/leN/oMT37Tfeb+1GZ0LrtySe5pmpiH84UBBIZ6ytHXvU7IcV7kULszV2LwzxtEWbi0R2Yhhnr1z1FPWerR0+OKfVNQMgrJMzCCvXg7Ztaha4fG1eESxDiuxd5oU3XnyWtdEU78PVGpLqF6K9KdC0opJFSFJUj9/wBVHbMYmk5nkGPLcfiA28eZmL/Gqfn6jQK3u+/8k6hZ964/fdau+30Tf5Y5cZOX20l7ffGMek9eA7q9VWmseW7Uml6QdNLedkNdK62xDv8ASzz/AJxzF6Q6n1ezrF/SdQrrRkqaVBMJoAs1WxPPZtRLdpSyDm0XCNN4ZV3R1ZTyHxNscZiDTYBZa2I195aFazS+eRgSR5Vj9duId2P78zee+ZP7LjTlXpvWf4VWYv4SWe6vT1F2sfmzSuTo2paiqxGPscAqsjNuBuTIdzsAM2h0rpF+qZTd1aXUg4TtiWpTq9kjlyINSNefLcfi324+MgKn+ONz/kzp39q6p/35fc19Tnbnjx7ROMa+DapS1zToJtWe7U1AakWrSUqcPYNeOOaHtzV0V22Dlfi33Gxyx9b9RDTayyLE1mzPNFUpVEPFrVuc8Yo+Wx7cY2Z3k2ISOORjvxyI6t/w/wBO/wBHWP8AdYc69Zbfn3prnt2+ermPf0NsUAItv53YN3+o5MnKz8r/AI0tzXivS2vzDvT9TWKs7fF7tp2naV+b4ifPbHv1WWzOo9C5lQttuAm+wj6HUuuwa1pmj6lDCyTx35TqdSLjUvRQV1MaNFI7SUbqyEs0QLoy8Srn4lXZmYtrToJZoLEkYaar3exId94+8nbl22Ox5L485JznrJ/ZbEN1TV1ixKkNC1V0+r2+U1xoTbumQsw7VetIBXiAXi3dkMnk7dvxuYOfpvqGorT1OobGpTIpYUdWqaUlWyRsTEJ9NpwTVHYDiJN5FXluUfbbMnU9b1O/bt0dGapVSg6QXNTvQTW0W28MNj3WrRilh94Kwzxs0zTKqlwoVyG4hoXUnjfqGjv89tAAH7gdRJA/fmuPaeZ95/1SrD0jrcepUat6NHjWzEsnak27kT/hkhfiduaOHQ7fNTkDU/xqt/8AJ/T/AO0dSzz9hiuuhU1kcSSLJeWSQJ2xI41C0HcICQgZtzx3O2+25z0p/wCNVz/QGn/2jqWZvHOVntv7puyVdM4znOM5xtrDRtBr6nZ63o2Q3asazTQsjFJInHTegtFPC48xzxyKjq48hkU/LJ32YdQTzpY03UWX876SyQXCBxFuFwxp6pCpA/Q2Y0LHj4WRJ03PbOY3s4/wt1f/AKcp/wDu1oOc+03S7EMlfXtPjeS9piutitGdjqWlSFWuU9vRp0C9+Hcb9yLiCBK2drd7X4/SM/L062/w50x/nGq/2VPnf2q1tTWnau6fq0mnmnRtTdlaVK0k0sUbyoztZjLqPhA2UjxkfrGq172pdIXKsqzVrTalPBKh3V4pdImdGH08H0+WWX2jj+42rf6Mvf7rLk8Wfz1PdI6DZaapVmfbnLXgkfYbDlJErtsPkNycp3tgOqVadvVKOrPVSlVMvuXuVOeKZ4mLMXlmjMq8l2X4WG22485a+kj/AHPo/wCZ1f8A+CPIH23f4u6z/mE3+zJP+X3PRYtXrzz1njr2WpzOq8LKRRTNEd1JIinUxtuNx8QPrmrunupNek1HVen4bIuWqduFpNZt0ooq9GhPSrzIOxVCR3LzzGdUj3QBVLudlVX27D+Ef0R/symez7/CfVHj/wC1q39j6biXNS+iO1iLWdDgk1J9Ys63UrL3b9O7T06KcVU3NiehLplWEieNN5O1IsgcRlQVJ3z0p3NU6g3s0NQk0fR9yKdmtWqz6hqiqSvvaG/DJBVoMd+3+jZ5F4vyRWANr65AOl6l9Pzfc/3eTOvQI/uVpn+j6fj/ANnjy9Xbc7/z0PXEBoN/UtO1KDS9TtfnKC9HPJp2pNDBWsiasFeejeirKsLyGNmljliRAVhlDKCoZ7B1p1DHplN7TxvO5eKCtWh2M1q3YkWGtWi38BnkdRyPhRyY7BSchfaF/hLpg/P872B+46Pqe/8AsGR3th98NzpoVDXDnWJj/GxMa3cXSNRMXcEPxct+XH+dxxk5WL417QdN9Q2lE1zqGbTpXHL3LR6WmPVrk7kRmxqdOea2y77GT9EG47hFzvputalpl2tp+sSx3K15jDp+rxQis5trG8vuOo103ijmeON2SaMqjsrJwRuAfI49U/ytA/6Go/8AiyP17p/qHUVrw2p9GhhivUbjSVorrWB7laitcYu64UM3aKbn0Eh9fTNbva5n8+E7/J7ZZ9SoU7Wr1dYapBShikkqNSpzQOqTKJmkmljMygox34nxx3GetPUdX1xTNQmGjaU4/i1x6yWNTvIf/SYK9oGCjXPqhlSVpAQxRARvke3aNX6d1RHUMrwIrKwBVlaeIMrA+CCCRtl0iUBVAAAAAAHgAD0AHyGZ6pOM7d9/0f8A1nw1x0xBqyaprelS61etoml6RZp3bVTTO7VsXJ9YisdtatOKGVeNOueLq2378k/Z3a1Bb2sUL19tQFN6JgmetXrOFtVjK6MtZVVgGXwSN/OXbbKX0l/h/qP/APCP9yfHVsv+vyL5j36w6htC1DpOliE6lYha1LNYVpK+m0g5iFueJGVpnklDRxxcl5mOU8gI2zAbpXX4h3YOqLNiceexqGm6U1CQ/wAgpRrQ2Yl+QYTEj1IbPfpkL/CLXy23e920ZU3/AB+6CK4Y9vn2/eDb+2/P575dsl5dPafovlQfZn1XqN/UNZq6hU9yk04abH7vuJI+7PDO801a0ADapycYyjsqsNmBVSCBmarpGu3Zpf7rJo9RXK1006tWt3ZYx4EtizqUDwxFvXtJCeP+UbLJHQrQS2bgRI5Z0i95m87ulZXEXPc7AIrv6fU5S9Ov69rMSXaFmhpGnzfpKnvNGXU7tyq2xhtSKLUEdFZF+NY9pW4upYqd1FlluzJ/59zu8tTn1fp9Y7dnUpNb0vvQxXve61OC/SjnkSBbkEunwxQ2II3dGkjeMMELsHPDg2xs057YtG19NC1R59cqTwLVZpoU0VYXljDKXjWb31u0WG45cW239M3HjnJ0y9vXx9vySXvim+yb+9ar/p/Wf98fLmcpvsm/vWq/6f1n/fHy5HOfLy1DGMZFMYxgMYxgMDGBlDGMZMHSViFYhSxAJCjYFiB4UFiACfTyQM1Q2ta4dYTUf4I6v2l0ySkU/OHTfc7j2o5wwH5148OKEb777n0+ebaxmuPLp+Us14afM8kMUkkL13eNHeCVomkhZlBaKRoHeNnUkqSjMu4OxI857ZzjM1WodV1TXZNd0/U16T1YwU9O1ai6nUOnBI737GlSxPGPzrtwC6fJvuQf0iePXbaek2ZJoIpZa8lSSRFZ60zwvLAxHmOR68jxMw9N0dh98y84zV5bJPZMVHr/AEi60+n6ppqRT3NNNlDUmk7KXaV1I1s10nIIgsB4a8qMwKkwlTxDllw26y1WReFfpjU1snxtes6XWqRNt+Ka1BbmZo9/nCkjefT6XvGWcvjTGmdH0bXNG1u7qUlC91DJqun0ltT0rOmVq9W1XsXN6tWtqd6J4aaQyQcQC25MjE8mbL11z0/ZsPU1HTnii1TT+6IRPuILdWx2/e9OsvHu0cUhihYSKG7ckET8XAKtbMZb9S26k4yKMvWupKvF+l9Z94G47cU2jywsR847bX1Ttn5F+Dbeqj0yU6QbWJZJrOprVqRSKi1tNgb3iWvxLl5bV7wsszgoO3GvBOB2Z998suMl5TPC4pHWen3a2pVtb0+ob7pUk0+/RjlghsT1XlWxDNVksukTTQyiT9G7oGWxJsdwA3vpPUOrXbUSR6PNp9FDys2tUkrCWUcSBBTqVJ5H58ipMsxRQAdg5Pw3DGOr3Map6l1XWpNW021F0rqrw6e2oo7C/wBPL31sxJDFJCr6oDxPDls/EgEeN/GWzqXRpdX0+BuMml6jE8N2m0vYnloXogeKzCvK0U8ZVnikSOTZ45ZAGG4ItWMdfj4MUSDrHVoR2rvTeoPOmymXTZ9PtUrBA8vA89qKaJCd/hmRCPTc+pzunLWt27S2LVaLSdPSN1FGSSG5qNiVtuEties7V6kaDl+jjaUsSCXUDibbjHVPaGNfWU1PRr16erp02r6dqdhbjx1ZqsV7T7Xu8FebjDbkjjtU5BXST4X7iu7/AAuGBVqWo65qytUqafa0KvKOFjVL0tT3tYW8SrptOrPKy2ipYCacosZKsFl22zYOMdfwnS1f7H11PS6MWjzaFqKx0VurFee7o80VpUnnkrAcL3f7sqMg3kjUBieRUecxK+s64usz6kektX7MumVaSp+cOm+6JILVqdmI/O3HtlbCgHlvup8ZtvG2X+ptts8/mdPo6xkkAkFSQCVO26kj0OxI3H2zD125LXryTQVJr0qAcKtd60c0u7AEI9uWOFSASfidfwn57DM7Gc2mq/Z5b1iLVNYktdN6lWr6vqde0lh7uhSJVhi0nTtPY2Ug1FpCe5Sdto1fw6/PcZtMYznNcuWpjSusdL6tpGuUp9L0yXVNESzqOoe7VrNCvY065erSQWIIEv2YY2pSyyd8KrfAzzjbYqM21SY3Ki+9VJKxsRMs9Ow0EkkYcFXikerI8TEqT5R2Hn1yQxl5c+rNJMa26bu6xokEemWdLuavXqIIKeqafJTeSerGAtdb9WzPFJFcVAFZ4w8bmPlunLgsN7TNH6g6i022nuk2l1ooXlraZ71UOparciIetHcnjlarTpcl37XcYuSnNowrIdxYy/1O+53TpVPTOotRepYlk6e1KCeARCGnJb0Vp7nLw5gkh1BoE4ep7zx7/LfK10Be1iPU9Tez01qVWDVL8NhLEl3QpErRpQq1WNhK+ovITzrsdo1fwy/fNo4ydfnt5XFT9pt68lOWvS0i5qj261qEmrY02Ba7PEUQzfnC3CWVi5/vYbbgd9vG/X2XXbzU4a17SLmltTq1YQ1mxps6WGSIRuYfcLcxUKU3/SBd+a7b+drdnGOqZmGNYe0G/rEmpaY1bprUrUGl6hJYaxHd0KNLMT6fbqg147GopKDzsqdpFTwjfbLNrGlya1piLPDZ0m33I7VfuPWls0LlWbuVpi1SaSGQckXkiuQ6SOjfiYZasY6u35GKHX6s1iuOzf6euzTJ8PvOlTUbFK0R47kS2LUdivvtuUlT4d9uT7cjmaDc1y7ajmnqR6Pp0Xc5VZ5ILmpXGKlY+41WRq9GFSQ+yvK7FQDwG4Nvxk6p7RM+WufbXPqlilb02hoV7UPeIYuNuG3pEFdX7yu0bLcuxzcgI/UIR8Q2PrtaektZuWxL73pF3SjHw4C5Ppk/f5cuRj/N1ubjx4rvz478xtv52nsY6u2Yud9Ymr2ZIYJZYa8luRELJWheCOWZh6RxvZkSJWP1d1H3zWfTOq63Fq2pWpeldVjg1F9OVHN/p5jAteEwSyTKmpk8Ry5bJyJAPjfxm184xOWFin9Y6DcFyHWNKELX4YDUs1Z3aKHU6HNpUrNOoPu9iKZmkilKuF7sykbSlhj/AMN9RKgL0trff/yTTaKsan6m1+cTEU+e6knb5E+MvOcZZy95qWK70zX1OaK02rmqnvXwxUanJ0pwFCjRvccK1udySxfgir4UA7FmrPTuoatokEOlz6Ld1KvSijrU9S02Wi6z1oR24FtVrNmKavaWNUVtg8ZILBhvxGycYnP4Mab9qOia/wBR6ZaT3SXTK8URmraX71UOo6pchZZKyXZ45TUqUwyhu0JGLtwLPGFKm7wdT6k1WWdum9USeOSNEpNc0Izzow+KaORdSNdUT0IeRWO/gHLbjLfqbMJx761l7Lb2rwy2K9vpzUacdzVNQue9SXNDlhrxWpXnjEyVtReYv6KQiN5I+W5Gzc4znMcrqyYYxjMqYxjKGMYwGBjAyhjGMBjOk0iorOzBUUFmZiFVVUblmY+AoAJ3OYWk61Tt8vdbdazw25+72IpuHLfjy7THjvsdt/ocYJDGQem9X6RZsvTrapp1i5HuJKsF6tLZQr+IPBHIZF2+e4yQ1bU61OF7FuxBVgjG8k9mWOCFB9XllYKo/acXjTWZjI3p/X6GoxmbT7tS9CDxMtOzDaiDfyS8DsoP23yRxZnkc4yD6i6v0nTWVdR1TTqDP5Rbt2tVZx9VE8ilh+zJLS9Rr2olnqzw2YH8pNXlSaJx9VkjJVv3HLZZN9E17ySqo5MwVRtuWIUDc7Dcnx6kD9+d8137dtcow6TagluVIp+dB+zLYhSXj+cKrcu27BuOysd9vRTlph6t0p2VE1PT3d2VERbtZmZmICqqiTdmJIAA9d8vRc03vjOsarVjkEUlmvHKdtonmjWQ8vw7Izcjv8szc137c9EpSaXYtPUqvaSbTStlq8TTqU1Gpw4zFeY2+Xnxlu6i6k07TVWTUb9KhG54o921BVRj9Fad1DH9mTp2Sw3ulsZg6Lq9S9EJ6Vqtcgb8M1WeKxE37JImKn+vM3JmK5xkL1H1ZpWm8fzjqWn0Of4Pfblerz/o9915fuzM0XV6l2JZ6dqvbgb8M1WeKxE39GSJip/rx03NNZ2MZh6jqlasN7FiCAH0M00cQP7DIwxB1XV6hl7Is1zNyKdoTxGXkPVe3y5cvHptmdmofaJNoUtzQZaT6RJefqTT2MlVqb235Ja7jF4j3G3G+5/bvm3RmuXHJKkuucZXdb660SjL2L2s6VTn/wAja1GnXl//AC5ZQ3+rJmG9A8ccqTRPFLxEUiyI0cpf8AjcHZyflt65LxuausnGMw9V1StUVXtWIKyM3BWsTRwqzbFuKtIwBbYE7D6HMwZmMjNM6goWnMVa7TsSBS5jgswzOEBALFI3J4gsvn7jM+WZEKh3VS7cEDMFLvsW4oCfibZWOw+hy4a9MZ4XbcUEbSzyxwxIAXlldY40BIALO5CqNyB5PzGR1XqnTJXSOLUaEskhCxxx3K7u7H0VEVyWP2GMpqXziR1UFmIVVBLMxAVQPUknwBlDvwNe1/T7dLqSNK9KGzHb0SvJXmFxzuvdk4yc0KFl33U7dtduO7b+ft/1inD09rdea3Vinl0m524ZbEUcsnOGRV4RuwZtzuBsPJzXR4nunU2DmJc1WrCwSazBE5AISWaONiCSAQrsCRuCP3ZF1OsNIKxgarppJVAAL1UkkgbAbSed/GVr8oLRac3T+s2ZalaWxHps/bnkgieaPgCycJWUsuzEkbHwScTh3ypb21sXGReva/Q06ITX7tSjCSFEtyzDWjLfQPO6qT9t876DrtLUIu/QuVbsO+3eqWIbMW49R3IWZd/tvk6b5WVI4xjMqjZdeoozK92orIxV1azCrKynZlYFt1IPjY51HUWn/K9TP/tUH/jyg+03pnTW1fpZm0+izWNdu+8Malcmfl09rkzd4lP0u8qI/wAW/wASg+oy5/wL0b/inTP+oVf/AIebvHjJPLO3U5DKrqHRldWG6spDKR9QR4IzvmttU0WDQdS0y1pkYqVNSvDTdSowkR0mM9eeWrfjrfgitJNBHEWjC80sty5cE2th6x0j/jXTfHr/AB6r4/8A1MXh7dzq907gZ0WRSvMMpQjkGBHErtvy5enHbzvkL/DHSP8AjXTf+vVf/iZmS1rU08igqCQCx4qCQCx2LbKD6nZSdh8gc7DNX+03qXTfzr0qPzhR3g120Zh73XBhH8H9biJlBf8ARjuSRpudvikUepAy96d1Lp1mQRV79KeVgSscNuCWQhRuSEjcsQB5zV4XNTqjJh1Wq8phSzXaYEgxLNG0oK78gYw3LcbHfx8szc151lotOHWenLENStFPLqlzuTRQRRyyctJ1Bm7kiKGfdgCdz5Iyy9QdZ6Pp0iw39W0yjM43SK5fq1pGHgbqk0isw8j0Hzx0eM76m+6exnjUsxzIksMiSxuoZJI3V0dT6MrqSGU/UZ7ZmtGMruuddaHRl7F7WdKpz/5G1qNSvL9v0csob/Vk7WsRyoskTpJG43SSNldGH1VlJDD9mW8bmpr1xkbqGvUa0ghsXakErBSsU1mGKRgxKqQjsGIJBA8fLOOoOoKGnRibUL1OjETxEtyzDVjLfQPO6qT9sk42qk8ZH6FrlK/F36Nyrdh3271SxFZi3+nchYrv+/JDJZnkMYxgMDGBlDGMZB0ljV1ZHUMrAqysAysrDYqwPgggkbHNM6j0Ytjq6xTrdmhpTaDpk2qV6cQqy3uOo6t7rX7tfiYoCyuZdvLqip+FmzdOUTTv8b9S/wCTujf2lredfp2y2/FZ5TUvrfQ+l2qXuLU4IYUXau1aNK0tN1G0c1OWEK1aZDsVZCCNspnsk0efWYK2s9Qdi5cj7lenXCcqdM1JGqT20hf4GvzzQzSGXbeNJVjXwGZ9rZS/Yf8A4Fr/AOc6p/at3HHlem/z3SybEf7StOh02xp2t040gtDVNL024YVWNb1HVL0GnNFaCjaUxPZjnRmBZTCQCA7bz3tL1mxTofxPj79csVtOpMy81jsXZkgFl0JHNIUaScrv5EBHzyM9uP8Ag2r/AMoOl/8A3i0zPH270o5NMhnniaatQ1OhduRqzoRSjnEVublGwfaGGaSchTuRAQPXLO8m+/8ApfdN9JdFafp0ZEcKzWJPitXrKrNduzH8c1mw4LOzHc8dwq77KFAAys9f6PDom/UGmIlM15Ym1etCBFV1Cg8ix2ZZ4V/R++Qq/eWcDmewUJKt4lIfZpoLqrrULKwDKy3bxVlYbhlIn8gg775xY9mfTwAE1JCrsqBJ7Vt45GJBWNo5Zyku5H4CDvt6YnKb5v8Ab/tO7E9uuiU5dJtTy1Ksk4k09e9JXieXj+caq8e4yluOzMNt/Rjlph6V0xGV002grIwZWWlWVlZSGVlYJurAgEEfTIT24OF0G/Ix2SH3WeRj4CQ17taaZ2PyVY43Y/ZTl0U7gbed/TM7en739lnlRfb73f4PXxAUE5NPsGTcxib3+r2jIB5MfPjvt8t8zej+h69Pe1b46hq06hrmpWIw0skhHxR1lct7lSU7hK8ZCqNt+TbsfH22f4Es/wD32n/2lTy546rOGfN/Yya171lpEGm39N1ejGlWWfUK2naikK9qK/VvsYENiNNkexFO0EiykFwqyJvs5ye9pWtT0qDNU4e+2Z61CiZF5xpbvTpWhmkTcc4ozIZWXcbiIjcb75g+1z/zbT/9O6H/AGjBnHthUpRr3gCyaVqVDUpwoLH3WvMBcfiPLcK8k0mw3P6Px5xO+aeGd0p0TQ09CViFi3L8VrULSrPeuSk7tJPYcFttydo12RBsqqqgAQXtD6dj0+ObXtKhSrqFGNrNlK6iOLVacO0lqpchQhJpWhR+1MwLxvxIOxdWv9eVXRXRldHUMjqQysrDdWUjwVIIO/3yte1bVBV0e+23KaeB6dSL9axduKa1SBB82eWRB9hyJ8AnJOV0yYxuu+o5Vp0V02RFt61Yr1KE0i80iE8L257Zj9JGipwWZQh8M0agkAk56aR7NtGgHOSlDest5lvaki37szk7sz2LIZgCfIROKL6KqgAZA9a0BptbpWzK36DQ9Qpx2n8kLFZ0y1ofeYj8May3oWZvQKCTsASNlnLe07fKTy1p7S+nqFaTQJK9GnBIOo9NAkhqwROAVsggOiA7HLD7Wp7MWjXXrGZXVI+89YO1mOmZoxfkrCMF/eFqmdl4jlyUbedsr3tl1yrHe6Y09pR73a1+nPFAoJbsV0n7sz7fgjDOi7n1LAD0O1n9o/VSaLp7ahKEMUdmjFM0j9tIoLV2vWmnZ9jssccryfft/L1zV29PqetOjdK0X3SNtLhoPUkUMstZYZVm5eskkw3M0hO+7OSxO+/nKj1f7PUr3dJtaSslWAazTm1HTq0YNGdVMxFzsD4Kc6O/JpYgvMHZ+WylbJb9nuhWHaylGCGWxtI1vT3koTTFh4laxQeNpGI22ckn75X+pqNjpyKC9T1LULNX3/TqljTdTtSaissWo36+nhqtuzytw2I2spIA0jowiK8Ry5BL37W/cs7NnZiappla0qparwWUVuarPDHMqtsV5KsikBtiRv8Ac5l5znFtrD2N6RT027rekx1K8EtC61ipKkMSzS6XrBN6ICRVDmKO0blcKSdhVT0HHIX211JtS1H+KvL3Ok6C6+kURI941KafelAx/W3qafqMZT5i8p8eN7T10407WtG1XfhBaZ9BvHcBP44wm0yWT7pbiMKn66gfr49fY+vvNe9qzqOWtahYtR7+eVCEilpvr6BqleKTj8jO37c7zlZ+P+a53L+FY5NQo29NFyXszafNUS4xlVJYGrGIWVkYMCrJw2b9wymew/pOomnRanLp9WG9qc8usNvVgWar763crV1ITeMw1uxH8O3lGPqSTU3djpn8Dtykz69JoShVI20GP+6+4+QT8zbVuXoHbYfIZvWNAoCqAqqAFUDYADwAAPQAZOX4Zk9b/j+fos71Qdb0epX6g0GSvVrQSSLrHckhgiid960LHmyKC3nz5+edfygNIqS9Pa5PLVrSzx6Td7c0kETypxhkZeEjKWTYncbHwckOrP8ADvT39HWP91hzr7dAT0x1BsCxGj6i2yjckJVlZth8zsp8ZJfH89T3StPpLSgkbDTNPBCoQRSrAggAgg9vwchvb3y/gxrvHYt+bLXHf05ds7b/AG32y4adKrwxOhDK0UbKw8gqyAggj1BBGVH27/4s65/o2z/+w5JfxT81vh26M6GjrkXtSMepazMoNi/NGGERYDetp8T7ilRTbYRpty2LMWZiTHe0jSIdOkqa7RjStbhvUa9wwIsQ1ChdtRU5q9tVAExT3hZkdviV4RsQGYHYi+gyme2n/BD/AOfaR/a9HE5W8/zqZ+Fc85xjObbXHti1KvTv9J2bc8VavFrtnuTzOscUfPp3W4k5uxAXd3RRv82AyZ/8pvTv/Hmlf9er/wDjyP8AacgbVOkFYBgddt7ggEeOm9dI8HLv7pF/ko/+gv8A3Z1vT0zdZ7617b1VOoNR0uPT+7Jp2mXDqV3UOy61J5oq08FShVklC+9OZLInaSLkiCoFJ3fbMT2p9LaZQalry6ZQ7emytFqSe6VwjaRdaNLc7KU4lqzpBZ5EEhIJ1G3M77TAzyvVY54pIZkWSKaN4pY2AKvHIpR0YHwVKkjb75J9TLM8Q6XaIIUAULwKgKABw4EbAADxx2zV/s86X0u/qGsasdNo9g2PzRp6+6QcPdtJkmjsWETt8d5b0lscx+JK8J3I2zCo9TWNK0fU9IMhk1bSZoNJ04vyZ7MWqSdjp6ywJJccHCSPvtyoWSdgDtsvpDRI9NoU6ERJjqVooFdju8hjQK0rsfLSO3JiT5JYn55f+MvynlRfad05p/516VJo0iZ9dtLOTVg3mH8Htcl2lPD9IO4iN538op9QMvlDp3T68glgo04JV3CyQ1YI5ACNiA6ICNx4yr+08baj0lIfwJ1BKHb5KZen9chj5H5cpHRR93UfPL3kvK5O65Na09t9S9YsdOQadZWlYl1aeM22jWVq8LaVqAsSwxuOLWRHz4ct1DcSQQCDa+mujNN0+ExV6sZL+Z55h7xatSbbNLbszby2ZT53ZyfX5DxkX19/hPpn/Slr+x9Ry6DLy5WcZEk71r7TdOi0fqCGrSQQUdZpXrMlOMBK0F+hLV5Wa8QG0LTR3CHVdgxgRttyxOf7RrViabT9HqTPWfUnne3aiYpPX02mitaNZgPgsSSS1oA/goJ3ceUGdOpv8ZOn/wDMdf8A/wDKzjrOQVNa0S/L4ryJe0iSQj4YZr5q2KjSN+ojyUTCG9Oc8Q/WGXzZfj/ae6d0TpTTaUPu9SjVgi/WVYUJkJ9WldgWmc/NnJJ+ZOVLWdNh6eu0r1BRW0+/erabqVCIcane1CZa9G/XgUcK9gW5Io34BRItgs25jU5sYZRfa4wsDSdLjINm5rOmWQg8stTSb1bU7tgj9WNUrpHy+T2Yh6kZnhbb3bsmMf8AKA0ivL0/rFj3WrJbj06bsTzQxtIjqCYtpWUuihzv4Pjc5ndDdCx1wt3UjHqWszKGtXpowwjLKN6unxvuKVFPwrGm3LjycszMT39tv+Lusf5jN/sGW+H0H7B/sxOVnHPlM2te+0nSa+myVNdpxpVsw3tPq3TAqxLfo3rkVGSC2qjabg1lJkY/EjReCAzA7Eyk+3P/AAM/+kdC/t3Tcu2Tld4z7kmVzjGMw0YGMDKGMYyaPK3EXjdFkeJnRlWWPgZIyykCRBIrIXUncclI3A3BHjNfVfZjZjutf/hRr7WpIIK0rtHoO0levLLNFCyrpIAAeeY7rs36Q+fTbY2M1x52eEs1FdT6XNbhEUGoXNMcSK5sUlpPKygMDERerTR8CWBOy7/API87wPs86Fk0bZF1rVb1YLMEqXV0zspJPP7xJOHqUYpjJzaTwXK7St48Da54x13MMUn2g9AvrDrz1vVqUCS1J1qU10sQrYo2EtV5+VmhLMXE0UTbc+J7Y8bbgz/Tmjy1YGgs37eqF2Yma8lJZODADtcaVaGIx+vqpPxHzkvjHXcwxRa3QEtPePSNYvabU/U08x1LtKsN9+NNLUJlqx+dhEshjUABUUeuVo/QUSWo71+5d1i5AxerJfaDsUnZShalTqwxwQycSw7pVpdnYc9vGXDGXrpkeF6pFPFJBMiywzRvFLG4DJJHIpR0dT4KlSQR98pEPQFuOIU4eotXioKAiRAUWtxQA+K8eovXM4jC/AHO8oUD49xyy/YyTnYWa1/1L7MhbgSnFrWr0KCRV41pVfza8e9eRZUlae7RlsvKZEVmLSHcj7nLV0xpU1OExz6hc1JzIXE91aaSqpCgRgUa0MfAbE+V3+I+T4yWxl/qWzDFJ646Cl1WVXOu6vShjlrTx1aa6T2Y56riSKZWs6fJMW5qGILlTt6beMsPTelS1YDDPftak5ZmNi6tNZSrbfo+NKvDFwHn9TfydyclcZLzuYYo8fQMlQkaRq13S6x8rp6x1LenwEkk+6w2oTJVUk/3tJBGPki+d8vROiEjtJevXber3YSxqy3fd1ho81KSGlVqxRxQuykqZCGkIYjnsdstuMddOl4X6kViKSCeNJoZo2ilikUPHJG4Kujq3hlIJBB+uUyv0NcrL2aHUGp1qg8R15o6N81k22EdazbgaYRjYbCVpSPrtsBesZJysMa+u+yupJCAt3UY7/vdW6+s9ytNqc09PuCASPYrPAIFEsgEKxLGvNuKjc7y93o1bOnpp1+/dvqtqraazOKSWJWqXYbsUMi1qqQGAtCqECMEoWG+53y1Yy/1KdMUleg5KxP5o1a7pcB32oKlW5p8RJ3JrwW4mkqr67RxSLGN/CDPTTOhD71Fc1LUr2rTV37lWKz7tBRqzcWXvQ06kKK8wDHZ5jIV3+Er5y5Yy/1KnTHGc4xmNaQPtB6Xg1rTLemWGkjjtRcO7FsJYJFYPFPEWBAkSRUcH6rkppGnxVa8FWFeENaGKCJf5McKLGi/uVRmVjLt8GKuvRFMa63UG8nvjaeun8Nx2QglMhmC7b98rxjJ/kxqPlloxjFtqY15qns1s2LUVxup9eSWu1g1gkehcIFsgLIiBtKPJeIVRzLHZfXfzl20+kY60deeaS4ViEcs9lYe5Y8cWaZYI0i3YE7hUUefTM3GW87exJIoMHs9s14vdKOv6nS08fDDWji0+WWnD42rUrdis0kUCjwofuFR4VgAu3n1H7Llt0/zdFrOsUtPaqas1WB6E/vPN3eaxYtahTmtSWZS55P3BvtvsCSTsLGWfV5Q6Yhuk9GnpRPHY1O7qjM/JZbyUUkjXiF7ae4VYVKbgn4gTuT5+WQntB6El1g8W1vVqNf9ATUpLpfZMteYTxzF7VGWbn3FjO3Pj+jHj13umMk53dM9EP0rpE9OJ47GpXdTdpC4mvJRSSNeKr2kFCrCnDcFviUndj522AmMYyW7dVr3qP2az3bcNt+pNciarbmuUook0QRU5JobFYrFz0tnkjWC1NEO6znZtyS3xZcentPlq10hmu2dQkUsTatrVWd+TFgGFOCKLZQQo2QeAN9z5yRxlvO2YkgMZwMpV/oSVZ7E+m6xqOlC27y2K8C0rVU2JNudmGG/Xl91mYgkiMhGZizKSSTOMl8lqI1PRK+o9YVbKg76FpztcI5COW3ff+5kUn6kkleFb8oB3Ke/RHxzG+zchekOnINMgaGFppWllexZs2JDLZt2Zdu5YsSEDk52UAABVVVVQqqAJrNc+W9vZJEV1VoFfU6r1LQftuY3V4nMU0E0LrLDYryr8UU8ciqysPQrlZk6CtWAkWoa9qd2mhBaqEpUvewvol6elAkk8Z9WSMxK3owI3U3vGZnKxca+1/2b2LlqK03UmuQmvYls1IYU0TtVWljlhKRdzS2d0EUzoO4znY77k+cu+kVXggihksS2njQK1mcQiaYj1kkFeNIg5/mIo+2ZW2Mt52zKSSNe6v7N7Nm8l/8AhLrsUsJtCssceh9utFcZDLBGH0ti8e0USgyF2AjHnfcm2y6HFNR9wvE6jE8AgsNcSFmtDYBnnSGNIubEb/AigH0A8ZK4xedv2JFHg6Kv1x26nUeqJXHhIrUVC/JEu2wSO3Yg77qAPWZpW8ncn5SvSfSEGnvLYM1q9enVUn1C/IktqSNDukK9tEhr1wfPahRE3JYgsSTY8YvO0yKZ7QehpdYWSJta1WjUmg7E1Okul9mQbsWcvaoyzq7AgHi4GyDYDzvNdJ6NPSjeOfU7upsz8llvLRWSNeIXtoKNWFCnjfdgTux87eMmcY6rmGKX7Qeg5NYPF9a1WlW3rOalNdL7Jlq2FsxTF7VCWbn3Y4jtz4/ox49d5zpXSZ6cTx2NSu6m7SFxPeSikiKVVe0ooVYU7YKlviUtu587bATGMddzDO+mMYzKmBjAyhjGMgYxjAYxjIGMYwGMYyhjGMBjGMBjGMBjNB9Ze3W7otu3JP07qVvSJLLGrqkUm1cwRRQwFo1MJREMsU7gySJyDchuCDk50Z+Uf0rqPFHutp0x2/R6jGYE3bwALS8q58/zwftgbgxmPp92GxGsteaKeJgCskMiSxsD5BV0JBGZGQMYxgMYxlDGMYDGMYDGMYDGMYDGMYDGMYoYxjAYxjAYxjAYxnGBzjGMoYxjGBjGMgYxjAYxjAYxjAYxjAYGMDKGMYzIYxjAYxjKGMYwGMYwGMYwGMYwGeN2DuxyR8nTuIyF4zxdQwKko36rbHwflntjA8Yq0axrCqKIlQRrHxHARqoUJx9OIUAbZq3r/wDJ76Y1fnIaC6dZYs3vOmBKjF29XlhVexMxPklkJO58+c2xjA+NeofydOqtBd7PTWqS2lDF1iqWX0u6R9JEMwr2jt67sN9j8PoMjtL/ACiusNCnFPW6iWWTwYtRqyUrjbfrJYhASRfB+LtuD9c+2xkb1JoNHUYWrX6le5Aw+KGzDHNGfvxkB2P3HnKNIdH/AJVvT9niuow3NKkJALNE12vufmJaitIF+7xr/wBubn6X6r0zVIxLp1+pdTbfevPHIR8viVTyQ/YgZo72gfko6RbLzaRan0qcglYH/jdAn5fo5CJox/Rk2H8nPn7rf2JdT6DIbLUZJ4od2XUtIkeRkA2+LaPjZgPz/AB4/FgfoXnOfnt0X7f+qNPAWDVkvxrsog1WP3sDj4KiZXSf7eZflm6ekvytoNkTWtIsVidg1mg62IPT8ZhmZZAp+imQ+fn64H1BjKN0V7XOnNY4rR1aq8xAPu0zGrZ8/wDqLAVz+0AjLzkwMYxjAxjGAxjGMDGMYDGMYDGMYDGMYDGMYDGMYDGMYDGMYDGMZQxjGTAxjGUMYxkgYxjAYGMDKGMYyBjGMBjGMBjGMoYxjJoYxjAYxjAYxjGhjGMoYxjIGMYyCie0L2R9P67ya/p8RnYH+Nwb17YP1M0Wxk/Y/IfbPnvrj8lLUavKTQdSW3H5Pul8iGbjv+FJo0MMren4lj9PXPr/ADq43BAOxIIBHqD9RvlH5b69VaOWWpbqxJYryyQzoCpKzRMUdW7bNE5DAjdd/TLN0V171DpDxQaXqlyEKR/FGkWxWA8bJ2LIeONdv5HHb65Zfab7N4dE6kOnC9Jd/ikOoSzWkSKV5bc9oMvGLcSH9CGLADcynx4zXt3TZVWzdR+SQXY6kqqWEqtPFYlicqPSB1rTLyJ8MAPmMo3N01+VL1LWmBvV6OoV1fjKixGtKByAJjnhLIG239UIP29c+gOifyieltTCK18abYfiPd9TAqnm36izljXkO/j4XPqM+MI9IFadopGXty14p+JJCBZIY51+YP4ZF+XzyBrGmJZUnSR42I4vGQDH5O5AJ2dT/wBmB+odWxHKiyROkkbDdXjZXRh9VZSQR+zPXPzj6V9+onvdP63Yqn5xRzNEvp/wldt4ZD/TQ5tHpr8pHqnTAqavQg1aIEcrAX3KwV8bt3K8bQO32Eag/X54wfZeM0l0V+U50xqGyWZptJmI8rqEYWAH0/8AO4S0Kjz+uV+ebh0jVK1yJZ6liC1A43SavNHNEw+qyRMVI/fgZmMYyQMYxlDGMZAxjGKGMYwGMYyhjGMBjGeckyL+J1X+kwH+04HpjMdb0J9Joj+yRP8Avz1jlVvwsrf0SD/swO+MYwGMYwGMYyaGMYyhgYwMBjGMgYxjAYxjGhjGMoYxjGBjGMgYxjIGMYwGMZxlHOMYwGMYwGMYwNA/lReyW5qk9fXdIj79+tAKtmnzCPbqo8ksTQs5Cd+N5ZfhO3JZPXdQD8l9YUJe7IZa1qlMzD3mrcgsVTIy7+SHVfi8/wCvcEeufpjnWSJW/Eqt/SAP+3KPzr0vpTqHqnUpJammSqZyilxHJX02pCirEi+8yDj20REHFSzkL6HPq3o/8m/QKulpTuwi5ecc7OoqXilaYjysClisddfRYyCDtu25JObpAA8AbAfIemc40fI3tF/JetVhJZ0awtlVDOIWK1bCqPO3Jn7Mx23O+8f7M0Hp3V92sWiZkmRSQVfZ1O3w/iG4YePln6Ie0/p2xq2kXtNrXTp8tyHsi0sfdMaM6mVeAdSVeMPGSGBAkJB3AzQvRn5JFeJ1bVtVNuNSD7vRq+5K4A24vPJLI/E/zAh++NGhKWp6LqJWO5XFOZvAmQ/oyx22+IAFf35IVulrunSifQ9XnrycgdoZZYGLeNhI0LhZFPjw4YHxm++u/wAmOkVL6UEKrvtUn4q+38mOyBs/2Eg3O/mTPnvqLTLPT9s17yajWA/AoQKCN/1TIeE0f3RmG/zwNg9OflEdW6T+j1SrBq0SAfFIPdZyAdifeqyFD4/lQk/U5uPon8pzpu+ES40+kzN4Itxl63LbcgXIAY1H0MgTf6fLPmW/rgmRYYzJYmniB+MjaNHHws7KPA+ij1+22+V3qnSlpxRRFWexN+BP1E3232jB25D0wP0e0fVatyJZ6lmC1Cw3WWvLHNGf2PGSMzM/MbpqneTnLRtz03UhnerPPWl3/lcq7K2429d/nm3Oj/ylOo9KdK2pCtqsKKBynV4bbefB96h8MeO/4omP1P1YPt7GaT6K/KX6dvBFttPpcrHb+MxtNWDfe3WDJEv86YR5uDSNVrXIlmqWIbMLDdZa8qTRn/nRkjAzMZH6hrVSueM1mCJj6I8ihz+xN+R/cMh7vW9VSVhjs2WH8iIxL/07BQEfcb4FozjKBP1vcckRVa8AO4V5pXnPp4JSJVG2+3jl9cwLWp3Zd+9elA+aVwtZfO/o8Y7njx+tgbMmmWMFnZUUerMwUD958ZDz9V0V3Czd4jcbV0efyPUcowVB/ac1+kcOxYjusPVpGaaRhvsOTyknf6E/T75m1357KuyAAEbL9/n9R9vt/UwWKx1dISVgoyN/OnlWIepHpGJCPQHY7eozHj1W/N5aWGAHyBDGpb7DnOzBh533AB8ZixpyO3qBt68m323/AJI2+noPrknAAB89h58M2xUAMwOzEEFTy8D1UbjcAMGM8DSD9JNLKPo0u4O381XKj9w+vyGdPzbEP+CUH6so3/b8YQfL7+n2IEmdj4J323A37YO25/VkTyQARsT6x+p5EnsqEegK/XiCB+7tybH8J+XnZP5R3CMNKM/qIf8AmB/9QAX6f1j7E9PcI99xGoYDfcKOf9Sefkf/AK7jJR08eQfn6rIQPxb+SrEjw/n5gH5vnk/p9B+7YHbb9UBQfG3opHH0YcVIYiSTx+Ip5UP0L90f1PyB9N/HyO+ZlTqCeM7WUWVP8pCCrr8jyiJIfb5lSPoFOeTH/u9GPgkAennbc/zR53+rGO1sOIJDAE7oUsndXmgbbcAxgr8IHAgBvPxD4d9sC8U7UcyCSJw6H5j6/MEeqsPofIz2zROk9fWabiR64mmUr7zFATC8sQP6Q+7WCGeRVLMpDMSRt6Mc3Xo+owXK8FqtIs1ezFHPDKnlZIpVDow/aCMgy8YxgMYxgMDGBlDGMZAxjGAxjGAxjGAxjGUMYxkwMYxjAxjGMDBxjAYxjAYxjIGMYyhjGMoYxjIGMYyhnz3+VB7Meo+pL1IUjSbS6kRKQyWnhc25TtLNMnaIYBFRVKncBpPHnPoTGQfnz09oA0vUb+n2zGtunYMEu3JowUUMrRtxBKFGBG4G4ZT485G+2J3W5UkQeREpjdfUtuPPrsfQf1nPrL26+xiHV5zrFO5HpmpRQhZ5ZxvStRxD9Gbe3xROigqJV32UjkG4rt8m9dWZOLVrZrWUhfil7Tpms0zId/Edl0TmP3AeRlE5pXusV6xw87IORCKo5spDqRud9if9X7swacUVzX9LgWNWSNu5YJ8gRRo7Pvv42IAHnf8AEv1yk6XQvyd0VVmnjQcpXiQvwHoGldARGnp5YgeDkzU6O1arKkqq0MysCHVix3/FsSvgg7Dx5B++WjcfUPsooT7vErQSEgq0PwkePoPUemUaz0Hq2mtJLSnkXkPjkrTSVp3CnwHeAr3B59G39c2V0Lrdpokiv795Qq8/O0n0+X4ttvGXiqVfxsrDY/CxOxHp+0eD/wDO2+QaO6c9qmtaYwimiqToDs4tQe72n+/vlYqpbfby8bE7fXzl/wBG9tdCbZbMU+nuT5aRO/AxPqRLBu233ZVy0670fWtKQYxufk4HjkYxtv8AtY/95zWXVHsoeMM9Rig/F223KEH58dvHjbC43Dp2sQ3EEtWeCdAAd4ZFkCn7lSSrefn5zOksfLxsR8THzv8AXbz58b58rT6RapyB3hkidfwzwFjt9w67OvjJjTuuNWr8SJ1tINhwsAs3H5qJFKyDfxvuTmkfSkciB99wN/p9Adth/VtnvXtjcBTv/R8nf7Df9gz51s+0ZivJ680EnkkxssqL4PkE7Nt59CGyV9n/AF5NO67BXj347blSu2+wJ+g+v3yK+jaj7+T/AFE+P2b/ADA/+mx8iVqnf7n1AI5MdiATsCCdzI25Hpz+uwWm9P6ssygAjZQD8vn6/c/L+rLfRfbYk/yfBYr5DAg/COW+2/p48+vyERnKQDsH+hA7hHzXj8Eo+vZPr8zgIvjwPtuINvPHh5+f/Af1HO8RY+nIgbbcWSRfHIbAt8W/6Ef152Knx8LjyB4WEeN4tvLH+av9eBjNwGw2Qk/h37BIAAYMQCPAVYifI+f1zhgfXZhsP53ID1ADHz6Aj8frCM93cgbbn03Ckx7kKIWICxoSRsP9eeDR7fIAjfztxO45bH4ol/Wi39f1jgeXAHzsGIPnjxPjxv6SFtvA+v44/wCTmFOGdgPkd/rt9WJ3JPqWOw9NyPuc6cgjYHfbf5hvhUHxtycj4JPlt+AZjSrvv8x6HwfTbwTv9sCJ1PSIZ0Mc0ccsbAgrIoYDf18EfCfPqNtv6ie3s+Mek8KEY46fLM/Y3Y/xWeZuXbG/pA8hOw/VeT6N8ORO+wI+YB8bfQf1bgf7fofMD1NMRVmcHbaNm32O4ZUcgqP5Qbgd/lgbcxnnASUUt4YqpYfQkDf/AF56YDGMZAwMYGUMYxgMYxkDGMZQxjGAxjGAxjGAxjGNDGMYDGMZAxjGAxjGQMYxgMYxlDGMYDGMYDGMYHzD+Vbdv2tboaU7T19IFP3gciY6mpXDKxeIkeJ3gSOI9snx3t9vQ5IezzQIYlChFO/6uwcEbeRx9CPXxm+equnqeqVnqXoFngfY7NuHRx+GWKRSHilX5OpBGal1LovU9FcyVg+q0ASfgRTqFdP1Q0IG1ziP1owGP8j5mies8K0QEYVEA8qihUAG+w4hdlO49Nvn9xtqTXJYFklEYjMIJL1yygB99v4sfSOQ7+IvwncbcPO+xLuqRW6xkicP6gruAUceO2yHYxsNiOJA2+mfO2iaxz10QWSI1Dsyq3hDIWCofOw/Bt/0jhV8qz1R8KyIGY+I5Ascy+h4mN/iVvHoR8xli028GPEkK48Hf0I/f65UPaB0zLqGp6eyOscVeMsZIxtLKOQPAyD9XwfX08/fNhxaHUZEDKSVULy5vy5AAevL18DCJOja+HwRsBtx9V/1nwczoJEZNn28ehJ3/qPqfGw+vj9+QEWnpHuEssFP6sgDfsG6kH5D5HM+ABf+EjPz8H5eNvG37MsGLqemxyk9yCPiCCHiJ2Pw7bFNvgI8+PIP2+da1roqq+57YK/iHwgMAQCfH18ft8ZdxJHt8Tgjf5D/ALd88bLxHfiCxHnf1PL7fQ+nn9mRWius+mVhikNZXd91VUDFj8QHkqQdh8szPZX0vJUWZ7ICyTNz4geEUbgDb93n0+X79qjShIxcqAoPqwG2++43O/rnaxQ33biQB8J9Ax3HE/hG/wA/nlRWujtSMWoyQmQlH2aLfz8XlW2+o25E7+mbp0yXdeJPkj0BIG532O3LZhv8vHqPI9Rqr8zQLKsyeJI/Hk7bk+GGxPqQAP3ZedEveByBHjbc7geNvJPy8gf/ACMguccoB8jcgggbsGO43COR8XDaR/LDwSv4t89AB8lUnxsRC5BI4AfEx8glIjv/AOsGYFS6ANuW2wUr8XHYAALsOQ8Dip28fhH1Yj0acE/Ijf5/H4O/gcpPTYkenp+zdQyZW4qfUKF+awqOPHbchvP4RGf+Y/0w23I7FFO7frIPPKTb8Mo/yqf15jCwB6Hb7/Cp87nf+9D6777/ADJ+ZU9Htj6nb08l9iADt5Dn5N/V48+AA92b6Enf6Fj4PEeNpj54hRt9XGYkkjEHdtjv9Qw2H4fUclB+4+Y9dxvi2NRjH4nT9jMpO/n5+p9W/wBf1JPmFtT/AN4rTPv6M47KftLzbEjck7qG9TgeOovtv8yR8vr8vC+oH2+n3OYXT2mPqdiM7D3GtKGmfztYlhblHWT6qrqrOfQcePqx42Kl0c0mzXpuQ9TXgJSNv5ss3h5B9lCA/PcZbK8KRoscaKiIAqIihVVR4Cqo8AfbA9MYxkDGMYDAxgZQxjGQMYxgMYxgMYxlDGMZAxjGAxjGAxjGUMYxjAxjGTAxjGAxjAyBjAxlDGMYwMYxlDGMZkMYxgV/qLo+heJeWLtzkbGzXPZsED0DuviVR8lkDD7ZoX2pfk63rLtYoWq1px6JYBpWNh6D3iENG7+ux4x59NYyj4mfpTq+jxitabqViNG2UHjYkUfWK7QeUEHf9YKfrnU6neg4+8JqOnFj8K34bEEZIPnhJKgD7bH0J/fvn21vnWZFdSrqGVhsVYBlI+hB8EZR8c0dRsybEOk3P1bnsvz32Prufqfnt+zJujcdCSreo22cltj8xt6EZvvWfZdoNos7afFBIx3MtMtTkJ/lE1ioY/0gcqWr+wus55VtSuRsPI76xzAfYmHtMw/pFj98CgVNQKj5kk78fPH7gA+mSMWrnl8/TwCQRv48jfbMyz7FNYjY+73acsZ32EslmJ9z8/ETgeR9TnvU9jmtPsJ7unxAbgNGLVh9t/mGEY38n0IwMGXUWOzA7Db18j57+APB9P8AZnKagOPIsXA+FgPT4v1didwcsaexJlhlL6tclmEbmKOBYKsLTcG4K3cWU8C23zH7c+e5ukurEPZu0NUMvgPwhkmgJBPhDUDJIu/z3P1y2q2D1DqVSHeWTUTUB8FWaFjuPQDuRF9vI9Nx4yk3vaTOXWKhevW2YhU414EQ/wDPeJdx9/tlG9oXSGo0BXk1HTWp++NIlZ7LIsrmIIzERLKZIx8Y8OFJ3P03yHj0jtxFzasQ7DyfgEZP9EkH0+/ywVtMdWdTx+WvrGp32Vew3HkNhuxTZj+4ZC2fat1DVmjkkud5I5FZoiIjDMgPxRye7hZY1I+aMCPv6HX+iLbk3WMxsnghpZFgR9iPG7njv5387D75Ya3TmrS7KlWEA/re9VZEO+/E/Aznb1+WMR9aexTrjQOpIQsIkg1CNAbGnz27LyL48yV3ZwLMG5/EAGHw8lU7DNnJoFIf+iwN93jWQ/P5vv8AU/15+ds3SWq0LCWFfsWoGEsM9ZnjaOTdhzWUKvFgOQ3XbcMfUHPoj2cflL+7V46/UkRksJ8LXaYhBZQBxazXeUfpT82i8En8C5B9MQ1o0/BGif0UVf8AYM9co3Rntb6d1Zu3T1ODv7bmtYJq2APHpFYClx5Hldx5y8DA5xjGA2xjGQMYxgMDGBlDGMYHSeJXVkYbqylWG5G4I2I3HkZUulunqckEpeNmIu6igJnsEhItQsxxqD3NwFRFA+gUZbycqHTGkCWOd/fLi8tR1Q8IrPFF/ulb8KAN1H784/UkvKdt8rHtFqR09b6lLNuvSeN1CMks0ML1hNJGzzyqZFTiW8szbTIPO2ZNjqyIDuRV7VisHRGtwrAKwLyLFyVppkaZAz+WiVx8LbbkbZ06koQ1dJ1FIxxDVLjuzu0kkkjV3BeSSQlpHIAG5J8KB6ADJurEnaRFVOAVVCADiAoHEBR4AGw8fbM/ilnGdu1/VWDd1wJK8MNezcki4iYVhAFhLKHVJJLE0adwqytwBLAMpIAYE96msrLHKyQzmaAhZahWNLKOQCEKvII/KncMH4kehOYfSDhPe6zkCzHdtyyKfDPFZsST15l38vGYZI05DwDE6+qEBp8iyanaliIMcdWvWlkHlHnWaxJ2+foXiSTyPl7wB8iMTnb3+cz+f3TEL0eovBLM9LUYp5ZJZ/e5JoUVAJmMcCCC0zLEECpw4cSFPLckk3rIPoVgdPr7EH4X9Dv/AMK+SOmalXtK7Vp4Z1jlkgkaGRJQk0R4yxOUJ4yKfBU+Rl+jk4z5/wAl8oj2gVI5KZLht0lr8SskkZHOzDG3mNgdirEfvOTdGskMaxxrxRQQq7k7bkk+WJJ8k5FdcsBSfcgfpqnr/nkGSGpajFXgmnc7pBFJM4UqWKxIzsFBI3bZTl7T6lvxP1p6Ma/rSxytBFBYtyoFMqVhD+hDjdO688saKzDyFDFttjtsQc7UdZWZJSsM6zwAdyo6xpZBYEoAC/bZW2YB1coSrDl8J2wulplWW9C2yzm3JZIbw0sE6q0Eqg/iQIBFuPAMDD5ZzDKsuqO8RDJXpmGy6ndO9JMskURYeO5GiSsV9VFhP5WScr53z6DpV6sjnUe7VbdmQFlmhiWANWdHaNo55ZZlgWUFT8ActsQdtiCfUdSwtDVkiisTyXIFsQ1oljM/ZZVYvIXkEUSjmo5M4G5ABJzr0IqCoeAUcreoO3HbyzX7BZjt6sfXfMCzBImqSKtoVBPTqrWHZhdZfd3s92GMyDYMvdRuA+Um/wAjtic+fTOXuuJjTdbWVnieCxXsIhk92sLEJHjB25xNFI0Uq7lQeLniXXlx3GYNTq6OZpIoal2WzA5js1UWt3ax2DL3pGsCBSysrKBIWIO+2dq9Le7CZtQ789eOV1gEcEbBJgsbPIIxy7fgbA7AlQfPHPXpPjy1HbjudRmJ228/ooACdvXwAP3DNdXK2T5+PY7JDStSSwjMqyRvG5jmhlULLDIFDcHVSQTxZWBUkEMCCQcj5epAgMklK9HWX4mtPFCsaIPWR4e97wiD1JMfgbk7AE5jWb3u8+rzRp3Xhq15hEp8yOkU/jxudzwUenyyP6o5x6fYsy6xYKvWlKrVgoMkzNE3GOrEa0kspbf4VDOx3Hk5L9Syflvt6fmYuoO/pnjftJBFLNKeMcMbyyN9EjUu5/cAcx+n2BqViCD/ABeHyDv/AMGvzyL6y3sGvp0cvaezKJZWAR2WrUaOWX4HBDB5DBEQR6TN9M3Pqbw6veJndh9IGxBY4WmctqUJvqjsz9iyrAWqyk+EjWOaoFUeD2pT9ct+VHqXTbUMcd03ZJzp8ot9s16y84kVksopjQNyNeSYAb+W45Py6vURqyPZgR7jFaiNLGr2WWMyssCk7ysIwWIXfwN8z9L8Pa9vXv8A5/ytZzKCCD6EEH9h9cp3T2g0W975of0d2dF5WJ90ReHFRvJ4A3/15cd8qehaVQme9JNWqSyNqFgF5YYXcgCMDdnBJGwAzX1Jtnj7pEh0rOe3ZAd5a8Fh0qzMWleSBY43YB/LTBJmniDeSRCPLHck3UYUc5aV6GvuN7MscAjRSdhJJGsxnij8jctGOI3LcQDtFxWkpfnU0gprVa8DrEh3rQWuM3eROPiONYhWkeNdgvLfbdycxeukeHTLcs2r2WElSwEiigoFZ2eB9o4IxWaV1PnwGJCgkt4Jzl19PH8t9v39FzVn13W46XbadHEDuqPZ3iEEBdlRDOzyBlUswG6q23z2zCbXIrDxV5KdxYLjNDFPKkcMchWKSfbgZhZQFIXIJjHoPrnn1QI3p1A/B1N3STs3FlJS7WcHY+pDKDv8iBli4g8TsDsdwfB2O224+h2JH7znSXlzva+kp4VLpXWZI6kaGhqEiRtNGJl93lUpHPKilQbJmccVG2677beMsCavC9f3mLuTRncBYonaUuHMZjMW3JJA4KsG24kHltsdor2f6lDLU4K45wS2UljbdJEIszbMUbz22A5K/oykEZgQ6g4axJXlSODUNVSGK0QHjRUoxxSTRg/CzPPVeFSfhLMp+LcBuf0+fTw43d/bst8pyprm8kcU1W1UaYlYWsCuUlcKXMYevNIEk4qxAfjuAdt9jtL5SOo94J9Pjl1O1YkkvQMK7RUuPBeW8kpr1VeKIHYBiwBZkXzy2N3GdPpfUvK3j7Z7ev5JXOMYzsyYxjAYxjIGMYyhjGMox79KGxGYp4o5om/FHKiyI37VcEHNb9fewvQNVjjCVU0yaGQypY06GvC7MV4lZlMRWVPsfI+RGbQxkHzjd/JiiSKQx6rNIVR2WP3OJZJGXdkjEhnCqxPjc+PI3zTui1uodJD17mn6nFD5PaNWZ+2TuzJHJHH2XiJVdyp23BI33z7wxlHwZGLerSstiSVKqn4YATH8Kkqol2HIsQPKk7DLVV6SqVkDCCPZF5kcR4P7frt/tzN9pel2+ntbuPYSUabfnnsVr4VzWAszvN7vNNtxhmSSVlCuQWHFhv529JdZjnglQMpLxng2w4knYgBht5Hn0OWjTidPya7LbZQsdWsxhjUKCHlUAkN4I/AR5/Zls9mnXGr9G2a/csPNobTxw26crkxQQyOoksVlcfoJUHJgEIVvIYbnkuB7KOpIaaWqVn4JFtSSAEiPmjoo3Unbk24PqSfIzy9pOsjUTX06l+lnmlBbiVkCJsw+JhuCAp5H6bHItfoDG4YAqdwQCD9QRuDnbPi+h7eupdAdK9uarracVCV5YhXsIiqBstmrEBt93jc+PXN1+yD8oTSdfsR0JYptM1GXxFXssrw2HClmjr2V2DSbBiEdUYhTsDsdojcuMYyBjGMoYGMDKGMYwOk0SurI6q6OpV0YBlZWGxVlPggj5HMTTNIqVeXu1avX5/j7EMcXPYkjl21HLyzHz9T9czsZMgxtRoQWU7diGKePfftzRpKm43APBwRvsT/XnNGnDAgjgijhjG5EcSLGgJO5IVAACTmRjGTdGFqWlVbPH3ivDPx34mWNHK7+oUsNwDsPTPT3CDte79mLscePZ7adrj/J7e3Hj9tsycZM9Rh6ZpdaqCtavBXViCywRRxBiPQkRgAnPSlShgDLDFHCryPK4ijWMPLId3kYIBydj5LHycyMYnGDD1PTK1oKtmvBYVTuqzxRyqp+oEgIBzE/gvpn/F1H/qlf/wAGS+MXjL5gw9R0utZCixXhmCb8O7Gj8N/XjyHw77D0zsmnwLD7usMSwEFTCI0ERVvxKYwOJB+m2ZWMdM3cNYOmaTVq8hWrV64fbmIIY4Q22+3LtqN/U+v1Oet+hDYTtzxRzR7g8JUWRNx6Hi4I3H1zJxlyeDWJQ02vAjRwQQwo34kjjRFbxtuwUfEdvHnOmmaRUqlzWq165k25mCGOIvt6czGo5bffM7GOmDAraNTilaxHVrRzuWLzJBEkrFySxaRV5MSSd9z53zitolOJzLHUrRyHfd0gjVjy/F5C7+dzv9d/OSGMnTPY1j6fRhrxiKvDFBEPIjhjSJAT67IgAGeDaNTM/vJq1jZ3B94MERn3AAB7vHnvsAPX5Zn4x0zwPC9UinQxTRxzRttyjlRZEbYgjkjgg+QD+7MWvodKPs9upVT3d2kgCV4lEDunbd4eK/o2KEqSu248ZI4y9MHVlBBBAIIIII3BB8EEfMZEL0rpY9NNoD9lOuP/AOmTOMnTL5HjWrRxII4o0jjXcBI1VEG/k7Ko2GYdbQqUbM0dSsjOrIxSCJSyP+NTsv4T8x6HJLGOmGoqXp3T3SON6NNo4tzEjVYWSPkeTdtSmybkA+PnklDEqKqIqoigKqqAqqoGwVVHgAD5DO+MdMngR9/RKdjj36labgCF7kEb8QTuQOS+FJ87emZMtSJ4zC8cbxFeBiZFaMoPRShHEr4HjPfGXpgjU0CiI3hFOqIpCrSR9iIo5Q8kLqV2YqRuN/TJCNAoCqAqqAqqBsAANgAB6ADO2MkkniBjGMtDGMYDGMZAzjOcYDGMZoMYxkDGMZR52IUkVkkRXRhsyOoZWB9Qyt4I/bmvte9ifTVwlm04VnJJ5UJ7NAbn1PbqyLGT+1c2LjA+Mvyg/ZTpWj36Cot01bkbAzTWjJvPG5DRGRo9wQjxMAW3PxbbbE526W0XSqag04VjcgBnblJK/oWRpHJbgD42HrsPGfWfV3TNDVqzU9RqxWq7ENwkHlJACFlicbPDKAx2dCCNz585p3V/yeTExfR9Ymrrvv7vfhF1Nh6KJ43jkA+78z+31wPn3oxIJdZ1aWyQXjREiBXfj3GcP67bfgUePkxzF9oNKvVFaeqTHcW1C9V4VPMTo4MfEctyeYT+sbZszV/yaOomttagvaWkjjZ3ElpQ4J33aMwn7Hbf5ZdfZX+To9S/X1LXtQj1KSm6zVKcMLJUjnX8E8zSHedkbZlHFQGVSeWwwPoGAtwQv4cqpYfRtviH9e+emMYDGMZAwMYGUMYxkDGMZQxjGAxjOMDnGMZAxjGUMYxgMYxkwMYxlDGMZKGMYwGMYxoYxjGhjGMoYxjIGMYxoYxjAYxjAYxjAYxjIGMYywMYxlDGMYDGMYDGMYDGMYHGc4xkDGMZQxjGQMDGMoYxjIGYHUM0kdWZ4iVdV/Gq82RSQHkVSCGZULMAQfK+h9Mz8YFC6XnAau0VmxJameIWK8ncMQVkc2OEkikTIgAcS8nJ4p8e0oB69dtBJfr161mcauTVlAS/PHXoUlsDuWrVUSiBlkCzRojozTNuAOEcjR3arRgiLNFDFGz/AI2jjRGfyT8RUAt5JPn65jXdBozyiealUmmUqVmlrQySgp5QiR1LDj8vPjKNdU7EjSx2zZsJq8uv3NNlqi5I0a0EuWYY0/Nzs1ePhpsda4H7YYkByxErcoXW9cvRaR2RJqjR1repyS6hEs881hqmvWa9Wm88Kkou0XOTfhuqRxgFZHC7mXTq4nNoQQiyydtrAiQTtGCCIzNtzKbgfDvt4z192j4lOCcCSxTivElmLsSu2xJYk7/U74FW67sBpNMgnmmq0Lc8qWZUlkqs8ogLU6ctiPjJVSSTkd1dCzwRx7nulWhbSUhbp6at+b81u14vtqs7OdTi9ylh0t7om94QdiWzYFcyAsEPjtrxzYdutHMjRyoksbji8ciK6OD8mRgQw+xzG/M1P3f3P3St7oBx917EXu/Hflx7HHhtv522wKR1tqUdPQNUi057k8cOlas0WoJcFtak1evZ/RPdksGz3o5I9hvzZSACRt4jun9OsvauUorBpSGjWuVexrF7WoktRWX4T2Gt8JIYyyojVx8Eyd34t1PHaEVOFYRXWGJYAnbEKxoIRHtx7YjA48NvHHbbPHStJq1FZatavWVjyZa8McKs2227CJQCdvG+BXvZ5antVG1ewXMuoRxypVikeWGrXhDiGvXUhVeVuUkjycQzNKFJ4xxha97NuoLM+s6mLvv0LS6bpNoVrUM0FeiZrmrwpWi7n6MycEgRpF/vrxyEfCFA2ZFGqKFRVVQNgqgKoH0AHgDPOapE5JeKNye3uWRWJ7L9yLfceeD/ABL9D5HnA1n03bYWdIsJZsSX9Q1DUINWrvZmlSOCCtfd09xeQx00r2IKMQdEX++KCSZiW2nmLBp1dJpLCQQpYmCrLOsSLNKqfgWSUDk4HyBJ2zKwGMYwGMYyBjGMBjGMBjGMBjGMBjGMgYxjKGMYwGMYwGMYyBjGNsoYxjIGMYyhjGMQMYxlDGMYDGMYDGMZAxjGAxjGAzkZxgHKGMYyQMYxgMYxgcbZzjGUMYxkoYxjIOM5xjKGMYyhjGMBjGMgYxjFHGM5xkDGMZQxjGMDGMYwMYxkDGMZQxjGKGMYyBjGNsBjOBnOAxjGUMYxiBjGMoYxjAYxjJgYxjAYxjAYxjIGMYzQYxjJoYyt+1HUpqeiatbrO0ditp1ueGRVR2SSKB3RlSQFGYEDwwIOUvqr2j6nXoytHphiuw6h09C8TWa038T1jUatdWkLFESy6vLCVUuscjq3JlBbA2xjNf8AUXV+qQahpFeLSZnW7BelsQ+80A4kgVCsQkacKCgIckHYiRQCSCM4q+0hm1CKq+mzR1ZtZt6DHdM8TGS9WrWbgeOuoLGoY6k6mRirK4UcWG7gNg4yIl1jsQXbV+MUq1Np37zypIslSCMSG2eH96BHP4D5HD75ALr16tpht2UL6hqNgLpumuFTsyWvho0nKLyPCNe9O558ONoj4EUBgu2M12/XEtA9ixG12vp9nS9K1TVWkigmbUtSanFE8NCKLhJD3L1YuQ0fATfCr8TmEPa+kcD3bmmWKtEVNXtRTd6Gaab8yy8LI93T8EcgKmNi25IYMqfCWo2jjNYVvatK6wxrpMr3LGrppMUUc5FWR5dMtamllLliCMtAiVZI5No+SMj8RIAnPGk9tMPGv26MskvCxJegWR2kgFXUrWlTR1BFA/vs5s0rRVW7QZIt+QLBTBtjGa213ra5LepRafAoprrb6ZYsyTojW54dPuzS1ooDC5ECzRojTFkYNCwCsNyZv2b9bpraWZIa0kC05jSsiZ0Lx6nDuL1IKhIdYG4L3geLljx3A3IW7GVD2ldZNo6Vn7ETpO8iyWrdl6Wn1BEgfe3dWvKK5fchC6qhKkF18bx2r+0uKHVV02Oq9jjNQr2pYmkd4pdR4GExRRwss0MaSRySu0kfFHBAfY7BsDGa1p+1JpSJE0qzLWs6Tq+saYYJFnu6hX0mSpGVSkifo5LPvsLQrzZmDDkEY8RZvZ71P+darWCKiskrRPHUuNcEbBVbtz9yvDJXsAMOUToCPuCDgWTGUXr/ANoB017ccFM3H07T01XUC1gVkr05ZLEcARjG5nsyGpa2QAACE8mXku8L/wCWiqbM9MVJTYg7ylTLGFeepNbW9WRtvM0EEEFhl9eFyPx4JwNqYyuaD1Slu2KghZGOk0NV5l1I4XpbUSw7Ab8lNViW9DyGRntK6/TR5K1dIPebdqK1ZjhMjwr7tRNcWCJI4ZSZy1qFEQqAzP8AEyAFgF2xmquqvaFamWqdMglgrrq3TdW7bs8YZk/OlvTpJKMdOWF2kk91uRpKxMZjM54lmRgtk0bryGdtMDRGFdR069qRkklQJWioPUSRZWO3g+9g8vAAjbfAuOMrvQd21cilvzlkguyCXT6rRdt69AIqwNMGUSe8zfFOyv8AgE0cewMbFrFjAxjGAxjGAxjGKGMYwGMYyBjGMoYxjAYxmDq1iSPsmPj8UwVwylt07cjEKQw4Nuq/Ed/n4xgzsZBVeoeXAvWliRkryM7tFsi2uXZ5cXO53Rg234fB8g+PL+FcWx5JwbkQqySJErr21lVo3l4iQsrAADcEg+dviyixYyF0rqBZ5RF2ZUbdkbcAmORF5OsgX8K+oDH5jbxuN+ZNcYcStSeSN5O2kitDsT3hB8QZwV+Ilv6CsfUcSEzjIFOpU5MjQyBl3RlUoxEwC7xHY8VUs4QOSByHyBBOPLrtpTKOxGWSSVQnLbwjUeIaQEjlxtOT4/UHp8ws2M8a0jty5xmPZtl3ZWDjip5jifA5Fl2Ox+AnbYjIj+Ei85EWCWQo8IXtlSsiTzvXV0dyEIDoSdidlO+5O64E7jIilrYksCs0To5jduQIkRXi7XdiZ1HEOO8vjff4W3A8bhrTEpxryETMyQOXjCuy8+Qfzyi+GN29D4H1+HAl8ZHJqgYRlUb9JHO/kqOLQFVaNiCRvuWG43Hw/cZh6Rr/AH7L1wnIgLLuCFMUL160qCQFj3JC8xHw+gAJ23XkE7jGMmhjGMBnIzjGUMYxgYetabDcrT1LKdyvZikgmTkyc4pVKOvJCGXdSfIIORur9I6fbS0k8BdbqVUnImmjc+4v3KbxSRuHrzRSbOskZV1ZVYHdQRPYwK5qfRdKzBXgla8fdWlaCwmp6jFeQzK6TD3+KwthlZXIKl9vCbAcF2j+lvZ7Vp3bOoSPLZtS3b1uAvYtmtVF1/PYoyTtWisiPdDOiK7B5POzsDc84GBCT9LVHWSNxNJHLeTUZEks2JEaxE8cka8XkPGuHhjbsrtHun4fJBzbWkQS2q9yRWaepHPHXJd+3H7z2xM4i34GYrEFEhBZVeRQQHcHPxgVzUuidNs3BemhkabuV5nQWrSVJ56h3qT2aKSitZniIQq8iMQYoTvvGnGH6Q9mGn068sVlTqEliG5Wna1LZngNW7ZlsTVoKtmaSKpC/cUOsIQP2k3/AAqBe8ZBWtN6IoQGsd7thqlsXaz3dS1G9JFYFOegGR7lhzw93tTrw/CTIWILfFmP/wCTvSx2+1HZrGN7b8qmoahUeT325LqFmOeStYVp4TZnmkCOSqdxgoUEg23GUVGb2b6Q9t7xrze8NO9pWW9eWOG1LXkqzWasCz9qpPJFIwZ4lUsdmJLAHJDSekNPqc/dYPdxJThouIZZo1avXV0h3VX276q7KJv75tsCx2G09jArWr9E0rVWvTle+IK9c1FEOq6nXeWBo1hZLUsFlXtkog+KUs2+533JJ7v0ZQ94htRrYryQpXjC1L12pBKlTb3ZbNetMsVpUA4gSq3w/Cd18ZYsZBTNL9mGjVWd4ILETtXtVEddR1EPWqXGieatSf3jlQgDwxsiQFBGRunEk5m0+h9PirXKyC3xvuslydtQvPdmdI4okY3mmNhSscMaDi42C7fM72bAwNZ+1T2YHXLBfu14IpqsVOw3G/32himll+OOG6lS8V70hh95ifsSO0g5k8csiez/AEcTd/3GEy++X7/M82Jt6nXNS9MQW2JlgJQr6bbbAbZaMYFT6e9nml0BYFaKyr2qcdCaaTUNQsWWqRd7sxCzYsNLH2+/KFZWBUEAEBRtl6x0dStx1El96VqSGKtYr371W4kbRrFJG12tOs8iOscZYM5DNHGx+JFYWHGBULHs20eSytt68zzJNSsjlevmL3rT+z7rbaDv9p7gWCJDMyl3ReLFlJBxo/ZToau7itMWdJoTzvXpVWrYsQWp6UUcs7JDReSvHvXQLHxaRQoDsDeMYAYxjKGMYyBjGMBjGMBjGMgYxjAYxjKGMYwGeFunHNw7iK/B+achvxfiy8h9DxZh/wA4574wI8aLU2293i2CwLtwG3Gty93XY/qpzbYfLkcwrnStN2VkijhZd/KwwSctwF3KzRsOQAADbbgbj0O2TuMoxKemwxEMiDmEVO4SWdgqqu7sfLNsq7sfJ2zo+k1ixYwRljIspPEf3xG5q/2YN8W/185nYyDFl06BmdmijZpVKSEqDzUqFIYHwd1AH7ABmOmhU1341oRyEqt8A+ITqiTcv5RdYowSfXgv0ySxgY9OnFCCsSKgYhmCjbdgiICfqeKIN/5ozG/MVPkX92h5kq3IIA26P3U8/RX3YD0BJPzOSOMDAsaLUkdnevCzurqzlByKyrxkG/rswAB+uw39BnL6TWPPeCP9IQz/AA+rAluX2PIk7j5k5m5zgYDaNUZSprwlSVJXtjYlIxEvj6dsBNvp4xW0apEyNHXiRo25RlUAKEQrXBX6foURP2KB8szxjAYxjAYxjAYxjKGMYwGMYwGMYwGMYwGMYwGMYwGMYwGMYwGMYwGMYyBjGMoYxjAYxjAYxjIGMYyhjGMkDGMYDGMZAxjGAxjGWBjGMQMYxlDGMZIGMYyhjGMBjGMBjGMBjGMkDGMZQzkYxgf/2Q==\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/6i6qhqDCViA\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x7f263020f6d8>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('6i6qhqDCViA')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second-order methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The notebook on phugoid oscillation (lesson 2) included a study of the accuracy obtained with Euler's method, using the exact solution for the simple harmonic motion. We made a _convergence plot_ and saw that as $\\Delta t$ gets smaller, the error also gets smaller. \n",
    "\n",
    "We could have drawn a line with a slope equal to 1 on that log-log plot, and you would have seen that it was parallel to the convergence line. A slope equal to 1 on a log-log convergence plot is an indication that we have a first-order method: the error scales as ${\\mathcal O}(\\Delta t)$. \n",
    "\n",
    "In lesson 3, using the full phugoid model (which is nonlinear and does not have an exact solution), we did a _grid-convergence study_ with three different grids, and obtained the _observed_ order of convergence—it was very close to 1, indicating a slope of 1 on a log-log plot.\n",
    "\n",
    "Another way to look at an ${\\mathcal O}(\\Delta t)$ method is to say that the error scales _linearly_ with the step size, or that they are proportional:\n",
    "\n",
    "$$\n",
    "e \\propto \\Delta t\n",
    "$$\n",
    "\n",
    "where $e$ stands for the error. To get more accuracy, we could use a _second-order_ method, in which the error is ${\\mathcal O}(\\Delta t^2)$. In general, we say that a method is of order $p$ when the error is proportional to $(\\Delta t)^p$.\n",
    "\n",
    "In the screencast titled \"Euler's method is a first-order method,\" we used a graphical interpretation to get an idea for improving it: by estimating an intermediate point, like the **midpoint**, we can get a better approximation of the area under the curve of $u^\\prime$. The scheme has two steps and is written as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "u_{n+1/2}   & = u_n + \\frac{\\Delta t}{2} f(u_n) \\\\\n",
    "u_{n+1} & = u_n + \\Delta t \\,\\, f(u_{n+1/2})\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "This method is known as the *explicit midpoint method* or the *modified Euler method*, and it is a second-order method. Notice that we had to apply the right-hand side, $~f(u)$, twice. This idea can be extended: we could imagine estimating additional points between $u_{n}$ and $u_{n+1}$ and evaluating $~f(u)$ at the intermediate points to get higher accuracy—that's the idea behind Runge-Kutta methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Runge-Kutta methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the modified Euler method, we improve the accuracy over Euler's method by evaluating the right-hand side of the differential equation at an intermediate point: the midpoint. The same idea can be applied again, and the function $f(u)$ can be evaluated at more intermediate points, improving the accuracy even more. This is the basis of the famous *Runge-Kutta (RK) methods*, going back to Carl Runge and Martin Kutta. The modified Euler method corresponds to _second-order_ Runge-Kutta.\n",
    "\n",
    "Here's a bit of historical coincidence that will blow your mind: Carl Runge's daughter Iris—an accomplished applied mathematician in her own right—worked assiduously over the summer of 1909 to translate Lanchester's _\"Aerodonetics.\"_ She also reproduced his graphical method to draw the phugoid curves (Tobies, 2012)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Phugoid model with 2nd-order RK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute the motion of a glider under the full phugoid model using the second-order Runge-Kutta method. We'll build on the _paper airplane challenge_ of lesson 3 now, and look for the horizontal distance that the plane travels until the moment it touches the ground. \n",
    "\n",
    "As usual, let's start by importing the libraries and modules that we need, and setting up the model parameters. We also set some default plotting formats by modifying entries of the `rcParams` dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy\n",
    "from matplotlib import pyplot\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the font family and size to use for Matplotlib figures.\n",
    "pyplot.rcParams['font.family'] = 'serif'\n",
    "pyplot.rcParams['font.size'] = 16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the paper-airplane challenge of lesson 3, we suggested an $L/D=5.0$ as a realistic value for paper airplanes, according to experiments, and a trim velocity of 4.9 m/s. Let's start with those values, but you could experiment changing these a bit. _What do you think will happen if you make $L/D$ higher?_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set parameters.\n",
    "g = 9.81  # gravitational acceleration (m.s^{-2})\n",
    "vt = 4.9  # trim velocity (m.s)\n",
    "CD = 1.0 / 5.0  # drag coefficient\n",
    "CL = 1.0  # lift coefficient\n",
    "\n",
    "# Set initial conditions.\n",
    "v0 = 6.5  # start at the trim velocity\n",
    "theta0 = -0.1  # trajectory angle\n",
    "x0 = 0.0  # horizontal position\n",
    "y0 = 2.0  # vertical position (altitude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Among the initial parameters that we suggest for your first experiment, we are starting with a velocity a little higher than the trim velocity, launch the paper airplane with a negative initial angle, and take the initial height to be 2 meters—all sound like reasonable choices.\n",
    "\n",
    "Now, we can define a few functions to carry out the computation:\n",
    "* The right-hand side of the phugoid model from [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb),\n",
    "* One step of the Euler's method that we learned in [Lesson 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_02_Phugoid_Oscillation.ipynb), and\n",
    "* Differences with respect to a fine grid, as in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rhs_phugoid(u, CL, CD, g, vt):\n",
    "    \"\"\"\n",
    "    Returns the right-hand side of the phugoid system of equations.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    u : list or numpy.ndarray\n",
    "        Solution at the previous time step\n",
    "        as a list or 1D array of four floats.\n",
    "    CL : float\n",
    "        Lift coefficient.\n",
    "    CD : float\n",
    "        Drag coefficient.\n",
    "    g : float\n",
    "        Gravitational acceleration.\n",
    "    vt : float\n",
    "        Trim velocity.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    rhs : numpy.ndarray\n",
    "        The right-hand side of the system\n",
    "        as a 1D array of four floats.\n",
    "    \"\"\"\n",
    "    v, theta, x, y = u\n",
    "    rhs = numpy.array([-g * math.sin(theta) - CD / CL * g / vt**2 * v**2,\n",
    "                       -g * math.cos(theta) / v + g / vt**2 * v,\n",
    "                       v * math.cos(theta),\n",
    "                       v * math.sin(theta)])\n",
    "    return rhs\n",
    "\n",
    "\n",
    "def euler_step(u, f, dt, *args):\n",
    "    \"\"\"\n",
    "    Returns the solution at the next time step using Euler's method.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    u : numpy.ndarray\n",
    "        Solution at the previous time step\n",
    "        as a 1D array of floats.\n",
    "    f : function\n",
    "        Function to compute the right-hand side of the system.\n",
    "    dt : float\n",
    "        Time-step size.\n",
    "    args : tuple, optional\n",
    "        Positional arguments to pass to the function f.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    u_new : numpy.ndarray\n",
    "        The solution at the next time step\n",
    "        as a 1D array of floats.\n",
    "    \"\"\"\n",
    "    u_new = u + dt * f(u, *args)\n",
    "    return u_new\n",
    "\n",
    "\n",
    "def l1_diff(u_coarse, u_fine, dt):\n",
    "    \"\"\"\n",
    "    Returns the difference in the L1-norm between the solution on\n",
    "    a coarse grid and the solution on a fine grid.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    u_coarse : numpy.ndarray\n",
    "        Solution on the coarse grid as a 1D array of floats.\n",
    "    u_fine : numpy.ndarray\n",
    "        Solution on the fine grid as a 1D array of floats.\n",
    "    dt : float\n",
    "        Time-step size.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    diff : float\n",
    "        The difference between the two solution in the L1-norm\n",
    "        scaled by the time-step size.\n",
    "    \"\"\"\n",
    "    N_coarse = u_coarse.shape[0]\n",
    "    N_fine = u_fine.shape[0]\n",
    "    ratio = math.ceil(N_fine / N_coarse)\n",
    "    diff = dt * numpy.sum(numpy.abs(u_coarse - u_fine[::ratio]))\n",
    "    return diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we also need to define the function `rk2_step()` that computes the next time step using the *modified Euler* method of equations $(1)$ and $(2)$, above, otherwise known as 2nd-order Runge-Kutta or RK2. This function will be called over and over again within the time loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rk2_step(u, f, dt, *args):\n",
    "    \"\"\"\n",
    "    Returns the solution at the next time step using 2nd-order\n",
    "    Runge-Kutta method.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    u : numpy.ndarray\n",
    "        Solution at the previous time step\n",
    "        as a 1D array of floats.\n",
    "    f : function\n",
    "        Function to compute the right-hand side of the system.\n",
    "    dt : float\n",
    "        Time-step size.\n",
    "    args : tuple, optional\n",
    "        Positional arguments to pass to the function f.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    u_new : numpy.ndarray\n",
    "        The solution at the next time step\n",
    "        as a 1D array of floats.\n",
    "    \"\"\"\n",
    "    u_star = u + 0.5 * dt * f(u, *args)\n",
    "    u_new = u + dt * f(u_star, *args)\n",
    "    return u_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), we first need to set up the time discretization, then initialize arrays to save the solution and we are set to go! The only difference this time is that we are using _both_ Euler's method and 2nd-order Runge-Kutta to get a solution, to compare the two. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = 15.0  # length of the time interval\n",
    "dt = 0.01  # time-step size\n",
    "N = int(T / dt) + 1  # number of time steps\n",
    "\n",
    "# Create arrays to store the solution at each time step.\n",
    "u_euler = numpy.empty((N, 4))\n",
    "u_rk2 = numpy.empty((N, 4))\n",
    "\n",
    "# Set the initial conditions.\n",
    "u_euler[0] = numpy.array([v0, theta0, x0, y0])\n",
    "u_rk2[0] = numpy.array([v0, theta0, x0, y0])\n",
    "\n",
    "# Time integration with both method.\n",
    "for n in range(N - 1):\n",
    "    u_euler[n + 1] = euler_step(u_euler[n], rhs_phugoid, dt,\n",
    "                                CL, CD, g, vt)\n",
    "    u_rk2[n + 1] = rk2_step(u_rk2[n], rhs_phugoid, dt,\n",
    "                            CL, CD, g, vt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can get the position of the glider in time, according to both Euler's method and the 2nd-order Runge-Kutta method, by extracting the appropriate portions of the solution arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the glider's position over the time.\n",
    "x_euler = u_euler[:, 2]\n",
    "y_euler = u_euler[:, 3]\n",
    "x_rk2 = u_rk2[:, 2]\n",
    "y_rk2 = u_rk2[:, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### How far will it fly before touching the ground?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the $y$-axis measures the vertical coordinate with respect to the ground, negative values of $y$ don't have any physical meaning: the glider would have hit the ground by then! To find out if there are any negative $y$ values we can use the handy function [`numpy.where`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html). This function returns the **indices** of the elements in an array that match a given condition. For example, `numpy.where(y_euler<0)[0]` gives an array of the indices `i` where `y_euler[i]<0` (the `[0]` is necessary as `numpy.where` returns an array, which in this case contains a single line). If no elements of the array match the condition, the array of indices comes out empty. \n",
    "\n",
    "From the physical problem, we know that once there is one negative value, the glider has hit the ground and all the remaining time-steps are unphysical. Therefore, we are interested in finding the _first_ index where the condition applies, given by `numpy.where(y_euler<0)[0][0]`—do read the  documentation of the function if you need to! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the index of the first negative element of y_euler.\n",
    "idx_negative_euler = numpy.where(y_euler < 0.0)[0]\n",
    "if len(idx_negative_euler) == 0:\n",
    "    idx_ground_euler = N - 1\n",
    "    print('[Euler] Glider has not touched ground yet!')\n",
    "else:\n",
    "    idx_ground_euler = idx_negative_euler[0]\n",
    "# Get the index of the first negative element of y_rk2.\n",
    "idx_negative_rk2 = numpy.where(y_rk2 < 0.0)[0]\n",
    "if len(idx_negative_rk2) == 0:\n",
    "    idx_ground_rk2 = N - 1\n",
    "    print('[RK2] Glider has not touched ground yet!')\n",
    "else:\n",
    "    idx_ground_rk2 = idx_negative_rk2[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Do Euler and RK2 produce the same solution?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An easy way to compare the numerical results obtained with the Euler and 2nd-order Runge-Kutta methods is using [`numpy.allclose`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html). This function compares each element of two arrays and returns `True` if each comparison is within some relative tolerance. Here, we use the default tolerance: $10^{-5}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are the x-values close? False\n",
      "Are the y-values close? False\n"
     ]
    }
   ],
   "source": [
    "# Check if to two scheme leads to the same numerical solution.\n",
    "print('Are the x-values close? {}'.format(numpy.allclose(x_euler, x_rk2)))\n",
    "print('Are the y-values close? {}'.format(numpy.allclose(y_euler, y_rk2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmmm, they do differ. Maybe $10^{-5}$ is too tight a tolerance, considering we're using a somewhat coarse grid with first- and second-order methods. Perhaps we can assess this visually, by plotting the glider's path? Study the code below, where we are plotting the path twice, taking a closer look in the second plot by \"zooming in\" to the beginning of the flight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance traveled: 14.516\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Distance traveled: {:.3f}'.format(x_rk2[idx_ground_rk2 - 1]))\n",
    "\n",
    "# Plot the glider's path for both schemes.\n",
    "pyplot.figure(figsize=(9.0, 6.0))\n",
    "pyplot.subplot(121)\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x')\n",
    "pyplot.ylabel('y')\n",
    "pyplot.plot(x_euler[:idx_ground_euler], y_euler[:idx_ground_euler],\n",
    "            label='Euler')\n",
    "pyplot.plot(x_rk2[:idx_ground_rk2], y_rk2[:idx_ground_rk2],\n",
    "            label='RK2')\n",
    "pyplot.legend();\n",
    "# Let's take a closer look!\n",
    "pyplot.subplot(122)\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x')\n",
    "pyplot.ylabel('y')\n",
    "pyplot.plot(x_euler, y_euler, label='Euler')\n",
    "pyplot.plot(x_rk2, y_rk2, label='RK2')\n",
    "pyplot.xlim(0.0, 5.0)\n",
    "pyplot.ylim(1.8, 2.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From far away, the Euler and RK2 methods seem to be producing similar answers. However, if we take a closer look, small differences become evident. Keep in mind that we are solving the same equation and both methods will converge to the same solution as we refine the grid. However, they converge to that solution at different rates: RK2 gets more accurate faster, as you make $\\Delta t$ smaller."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grid-convergence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), we want to do a grid-convergence study with RK2, to see if we indeed observe the expected rate of convergence. It is always an important step in a numerical solution to investigate whether the method is behaving the way we expect it to: this needs to be confirmed experimentally for every new problem we solve and for every new method we apply!\n",
    "\n",
    "In the code below, a `for`-loop computes the solution on different time grids, with the coarsest and finest grid differing by 100x. We can use the difference between solutions to investigate convergence, as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the list of time-step sizes to investigate.\n",
    "dt_values = [0.1, 0.05, 0.01, 0.005, 0.001]\n",
    "\n",
    "# Create an empty list to store the solution for each time-step size.\n",
    "u_values = []\n",
    "\n",
    "for dt in dt_values:\n",
    "    N = int(T / dt) + 1  # number of time steps\n",
    "    # Set initial conditions.\n",
    "    u = numpy.empty((N, 4))\n",
    "    u[0] = numpy.array([v0, theta0, x0, y0])\n",
    "    # Time integration using RK2 method.\n",
    "    for n in range(N - 1):\n",
    "        u[n + 1] = rk2_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)\n",
    "    u_values.append(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once those runs are done, we compute the difference between each numerical solution and the fine-grid solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the differences in the x-position for all grids.\n",
    "diff_values = []\n",
    "for u, dt in zip(u_values, dt_values):\n",
    "    diff = l1_diff(u[:, 2], u_values[-1][:, 2], dt)\n",
    "    diff_values.append(diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we plot!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot difference versus the time-step size.\n",
    "pyplot.figure(figsize=(6.0, 6.0))\n",
    "pyplot.title('L1-norm of the difference vs. time-step size')\n",
    "pyplot.xlabel('$\\Delta t$')\n",
    "pyplot.ylabel('Difference')\n",
    "pyplot.grid()\n",
    "pyplot.loglog(dt_values[:-1], diff_values[:-1],\n",
    "              color='C0', linestyle='--', marker='o')\n",
    "pyplot.axis('equal');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is looking good! The difference relative to our fine-grid solution is decreasing with the mesh size at a faster rate than in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), but *how much faster?* When we computed the observed order of convergence with Euler's method, we got a value close to 1—it's a first-order method. Can you guess what we'll get now with RK2?\n",
    "\n",
    "To compute the observed order of convergence, we use three grid resolutions that are refined at a constant rate, in this case $r=2$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observed order of convergence: p = 1.996\n"
     ]
    }
   ],
   "source": [
    "r = 2  # time-step size refinement ratio\n",
    "h = 0.001  # finest time-step size\n",
    "\n",
    "dt_values = [h, r * h, r**2 * h]\n",
    "u_values = []\n",
    "\n",
    "for dt in dt_values:\n",
    "    N = int(T / dt) + 1  # number of time steps\n",
    "    # Set initial conditions.\n",
    "    u = numpy.empty((N, 4))\n",
    "    u[0] = numpy.array([v0, theta0, x0, y0])\n",
    "    # Time integration using RK2.\n",
    "    for n in range(N - 1):\n",
    "        u[n + 1] = rk2_step(u[n], rhs_phugoid, dt, CL, CD, g, vt)\n",
    "    # Store the solution for the present time grid.\n",
    "    u_values.append(u)\n",
    "\n",
    "# Compute the observed order of convergence.\n",
    "p = (math.log(l1_diff(u_values[2], u_values[1], dt_values[2]) /\n",
    "              l1_diff(u_values[1], u_values[0], dt_values[1])) /\n",
    "     math.log(r))\n",
    "\n",
    "print('Observed order of convergence: p = {:.3f}'.format(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probably you're not too surprised to see that the observed order of convergence is close to $2$. Because we used a second-order method! This means that the numerical solution is converging with the grid resolution twice as fast compared with Euler's method in [Lesson 3](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/01_phugoid/01_03_PhugoidFullModel.ipynb), or in other words, the error scales as ${\\mathcal O}(\\Delta t^2)$. That is a lot faster! However, we are paying a price here: second-order Runge-Kutta requires more computations per iteration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Challenge task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How much longer does it take to get the solution with RK2, compared to Euler's method? Run the same solution (same time grid, same parameters), but find a way to *time* the calculation with Python, and compare the runtimes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-step methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The screencast *\"Euler's method is a first-order method\"* motivated graphically an idea to get increased accuracy: using intermediate points between $u_{n}$ and $u_{n+1}$ and evaluating the right-hand side of the differential equation at those intermediate points. The idea is to somehow get a better approximation using more data from the function $f(u)$.\n",
    "\n",
    "Another way to bring more information about $f(u)$ into the numerical solution is to look at time data $t\\lt t_{n}$. For example, we can involve in the calculation of the solution $u_{n+1}$ the known solution at $u_{n-1}$, in addition to $u_{n}$. Schemes that use this idea are called _multi-step methods_.\n",
    "\n",
    "\n",
    "A classical multi-step method achieves second order by applying a _centered difference_ approximation of the derivative $u'$:\n",
    "\n",
    "$$\n",
    "u'(t) \\approx \\frac{u_{n+1} - u_{n-1}}{2\\Delta t}\n",
    "$$\n",
    "\n",
    "Isolate the future value of the solution $u_{n+1}$ and apply the differential equation $u'=f(u)$, to get the following formula for this method:\n",
    "\n",
    "$$\n",
    "u_{n+1} = u_{n-1} + 2\\Delta t \\, f(u_n)\n",
    "$$\n",
    "\n",
    "This scheme is known as the **leapfrog method**. Notice that it is using the right-hand side of the differential equation, $f(u)$, evaluated at the _midpoint_ between $u_{n-1}$ and $u_{n+1}$, where the time interval between these two solutions is $2\\Delta t$. Why is it called \"leapfrog\"? If you imagine for a moment all of the _even_ indices $n$ of the numerical solution, you notice that these solution values are computed using the slope estimated from _odd_ values $n$, and vice-versa.\n",
    "\n",
    "Let's define a function that computes the numerical solution using the leapfrog method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def leapfrog_step(u_prev, u, f, dt, *args):\n",
    "    \"\"\"\n",
    "    Returns the solution at the next time step using \n",
    "    the leapfrog method.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    u_prev : numpy.ndarray\n",
    "        Solution at the time step n-1\n",
    "        as a 1D array of floats.\n",
    "    u : numpy.ndarray\n",
    "        Solution at the previous time step\n",
    "        as a 1D array of floats.\n",
    "    f : function\n",
    "        Function to compute the right-hand side of the system.\n",
    "    dt : float\n",
    "        Time-step size.\n",
    "    args : tuple, optional\n",
    "        Positional arguments to pass to the function f.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    u_new : numpy.ndarray\n",
    "        The solution at the next time step\n",
    "        as a 1D array of floats.\n",
    "    \"\"\"\n",
    "    u_new = u_prev + 2.0 * dt * f(u, *args)\n",
    "    return u_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But wait ... what will we do at the _initial_ time step, when we don't have information for $u_{n-1}$? This is an issue with all multi-step methods: we say that they are _not self-starting_. In the first time step, we need to use another method to get the first \"kick\"—either Euler's method or 2nd-order Runge Kutta could do: let's use RK2, since it's also second order.\n",
    "\n",
    "For this calculation, we are going to re-enter the model parameters in the code cell below, so that later on we can experiment here using the leapfrog method and different starting values. At the end of this notebook, we'll give you some other model parameters to try that will create a very interesting situation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set parameters.\n",
    "g = 9.81  # gravitational acceleration (m.s^{-2})\n",
    "vt = 4.9  # trim velocity (m.s)\n",
    "CD = 1.0 / 5.0  # drag coefficient\n",
    "CL = 1.0  # lift coefficient\n",
    "\n",
    "# Set initial conditions.\n",
    "v0 = 6.5  # start at the trim velocity\n",
    "theta0 = -0.1  # trajectory angle\n",
    "x0 = 0.0  # horizontal position\n",
    "y0 = 2.0  # vertical position (altitude)\n",
    "\n",
    "T = 15.0  # length of the time interval\n",
    "dt = 0.01  # time-step size\n",
    "N = int(T / dt) + 1  # number of time steps\n",
    "\n",
    "# Create arrays to store the solution at each time step.\n",
    "u_leapfrog = numpy.empty((N, 4))\n",
    "# Set the initial conditions.\n",
    "u_leapfrog[0] = numpy.array([v0, theta0, x0, y0])\n",
    "# Use the RK2 method for the first time step.\n",
    "u_leapfrog[1] = rk2_step(u_leapfrog[0], rhs_phugoid, dt, CL, CD, g, vt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have all the required information to loop in time using the leapfrog method. The code cell below calls the leapfrog function for each time step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Time integration using the leapfrog method.\n",
    "for n in range(1, N - 1):\n",
    "    u_leapfrog[n + 1] = leapfrog_step(u_leapfrog[n - 1], u_leapfrog[n],\n",
    "                                      rhs_phugoid, dt, CL, CD, g, vt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like before, we extract from the solution array the information about the glider's position in time and find where it reaches the ground."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the glider's position over the time.\n",
    "x_leapfrog = u_leapfrog[:, 2]\n",
    "y_leapfrog = u_leapfrog[:, 3]\n",
    "\n",
    "# Get the index of the first negative element of y_leapfrog.\n",
    "idx_negative_leapfrog = numpy.where(y_leapfrog < 0.0)[0]\n",
    "if len(idx_negative_leapfrog) == 0:\n",
    "    idx_ground_leapfrog = N - 1\n",
    "    print('[leapfrog] Glider has not touched ground yet!')\n",
    "else:\n",
    "    idx_ground_leapfrog = idx_negative_leapfrog[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the glider's trajectory with both the leapfrog and RK2 methods, we find that the solutions are very close to each other now: we don't see the differences that were apparent when we compared Euler's method and RK2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance traveled: 14.516\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Distance traveled: {:.3f}'.format(x_leapfrog[idx_ground_leapfrog - 1]))\n",
    "\n",
    "# Plot the glider's path for the leapfrog scheme.\n",
    "pyplot.figure(figsize=(9.0, 6.0))\n",
    "pyplot.subplot(121)\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x')\n",
    "pyplot.ylabel('y')\n",
    "pyplot.plot(x_leapfrog[:idx_ground_leapfrog],\n",
    "            y_leapfrog[:idx_ground_leapfrog])\n",
    "# Let's take a closer look!\n",
    "pyplot.subplot(122)\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x')\n",
    "pyplot.ylabel('y')\n",
    "pyplot.plot(x_leapfrog, y_leapfrog)\n",
    "pyplot.xlim(0.0, 5.0)\n",
    "pyplot.ylim(1.8, 2.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about the observed order of convergence? We'll repeat the process we have used before, with a grid-refinement ratio $r=2$ ... here we go:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observed order of convergence: p = 2.187\n"
     ]
    }
   ],
   "source": [
    "r = 2  # time-step size refinement ratio\n",
    "h = 0.001  # finest time-step size\n",
    "\n",
    "dt_values = [h, r * h, r**2 * h]\n",
    "u_values = []\n",
    "\n",
    "for dt in dt_values:\n",
    "    N = int(T / dt) + 1  # number of time steps\n",
    "    # Set initial conditions.\n",
    "    u = numpy.empty((N, 4))\n",
    "    u[0] = numpy.array([v0, theta0, x0, y0])\n",
    "    # Use RK2 for the first time step.\n",
    "    u[1] = rk2_step(u[0], rhs_phugoid, dt, CL, CD, g, vt)\n",
    "    # Time integration using the leapfrog scheme.\n",
    "    for n in range(1, N - 1):\n",
    "        u[n + 1] = leapfrog_step(u[n - 1], u[n], rhs_phugoid, dt,\n",
    "                                 CL, CD, g, vt)\n",
    "    # Store the solution for the present time grid.\n",
    "    u_values.append(u)\n",
    "\n",
    "# Compute the observed order of convergence.\n",
    "p = (math.log(l1_diff(u_values[2][:, 2], u_values[1][:, 2],\n",
    "                      dt_values[2]) /\n",
    "              l1_diff(u_values[1][:, 2], u_values[0][:, 2],\n",
    "                      dt_values[1])) /\n",
    "     math.log(r))\n",
    "\n",
    "print('Observed order of convergence: p = {:.3f}'.format(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have numerical evidence that our calculation with the leapfrog method indeed exhibits second-order convergence, i.e., the method is ${\\mathcal O}(\\Delta t^2)$. _The leapfrog method is a second-order method_. Good job!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### But chew on this ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go back to the cell that re-enters the model parameters, just above the leapfrog-method time loop, and change the following: the initial height `y0` to 25, and the final time `T` to 36. Now re-run the leapfrog calculation and the two code cells below that, which extract the glider's position and plot it.\n",
    "\n",
    "_What is going on?_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tobies, R. \"Iris Runge: A life at the crossroads of mathematics, science and industry,\" Springer Basel, 1st ed. (2012). [Read on Google books, page 73](http://books.google.com/books?id=EDm0eQqFUQ4C&lpg=PA73&dq=%22I%20have%20been%20making%20good%20progress%20with%20Lanchester.%20The%20second%20chapter%20is%20already%20on%20your%20desk%22&pg=PA73#v=onepage&q=%22I%20have%20been%20making%20good%20progress%20with%20Lanchester.%20The%20second%20chapter%20is%20already%20on%20your%20desk%22&f=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "###### The cell below loads the style of the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Nixie+One' rel='stylesheet' type='text/css'>\n",
       "<link href='https://fonts.googleapis.com/css?family=Source+Code+Pro' rel='stylesheet' type='text/css'>\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: rgb(245,245,245);\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width */\n",
       "    width: 750px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 1000px;\n",
       "    margin: auto;\n",
       "    padding-left: 0em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "    margin-top:0.8em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    background-color: rgb(256,256,256); \n",
       "    border-radius: 0px; \n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Alegreya Sans' sans-serif;\n",
       "    line-height: 140%;\n",
       "    font-size: 125%;\n",
       "    font-weight: 400;\n",
       "    width:600px;\n",
       "    margin-left:auto;\n",
       "    margin-right:auto;\n",
       "}\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Nixie One', serif;\n",
       "    font-style:regular;\n",
       "    font-weight: 400;    \n",
       "    font-size: 45pt;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0,51,102);\n",
       "    margin-bottom: 0.5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Nixie One', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 30pt;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0,51,102);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Nixie One', serif;\n",
       "    margin-top:16px;\n",
       "    font-size: 22pt;\n",
       "    font-weight: 600;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: regular;\n",
       "    color: rgb(102,102,0);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Use this for captions*/\n",
       "    font-family: 'Nixie One', serif;\n",
       "    font-size: 14pt;\n",
       "    text-align: center;\n",
       "    margin-top: 0em;\n",
       "    margin-bottom: 2em;\n",
       "    font-style: regular;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {  /*Use this for small titles*/\n",
       "    font-family: 'Nixie One', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 16pt;\n",
       "    color: rgb(163,0,0);\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.8em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 { /*use this for copyright note*/\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 9pt;\n",
       "    line-height: 100%;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "    font-family: \"Source Code Pro\";\n",
       "    font-size: 90%;\n",
       "}\n",
       "\n",
       ".alert-box {\n",
       "    padding:10px 10px 10px 36px;\n",
       "    margin:5px;\n",
       "}\n",
       "\n",
       ".success {\n",
       "    color:#666600;\n",
       "    background:rgb(240,242,229);\n",
       "}\n",
       "</style>\n",
       "\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                            extensions: [\"AMSmath.js\"],\n",
       "                            equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                            },\n",
       "                        tex2jax: {\n",
       "                            inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                            displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                            },\n",
       "                        displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                        \"HTML-CSS\": {\n",
       "                            styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                            }\n",
       "                        });\n",
       "    MathJax.Hub.Queue(\n",
       "                      [\"resetEquationNumbers\", MathJax.InputJax.TeX],\n",
       "                      [\"PreProcess\", MathJax.Hub],\n",
       "                      [\"Reprocess\", MathJax.Hub]\n",
       "                     );\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "css_file = '../../styles/numericalmoocstyle.css'\n",
    "HTML(open(css_file, 'r').read())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (MOOC)",
   "language": "python",
   "name": "py36-mooc"
  },
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}