rda_intensity_diff.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#corresponding script to rda_freq_diff, except for rainband intensity based on the mean and standard deviation\n",
    "#those were calculated in RDA_intensity_climo.ipynb.\n",
    "\n",
    "#2 methods used:\n",
    "#1) Analytic estimate pretending intensity is Gaussian (first guess);\n",
    "#2) Bootstrapping method using actual values of intensity (cf RDA_intensity_bootstrap.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import time\n",
    "import os\n",
    "import netCDF4 as nc\n",
    "import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "#import masked arrays - important because intensity shows up as a NaN at some points\n",
    "%matplotlib notebook\n",
    "import numpy.ma as ma\n",
    "import scipy.stats as st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5179\n",
      "8007\n",
      "8093\n",
      "9407\n"
     ]
    }
   ],
   "source": [
    "## LOAD FROM NETCDF FILE ##\n",
    "loadfile = \"RDA_int_climo\"\n",
    "ferretpath = \"/Users/Siwen/Desktop/Ferret/bin/\"\n",
    "\n",
    "#netCDF output file formatting formatting\n",
    "hovname = ferretpath + loadfile + \".nc\"\n",
    "hovnc = nc.Dataset(hovname, \"r\")\n",
    "\n",
    "#in this case, we're just going to load the smoothed plots of hovmoller frequency\n",
    "ints_1_mean_p1 = []\n",
    "ints_mean_p1 = []\n",
    "ints_1_std_p1 = []\n",
    "ints_std_p1 = []\n",
    "ints_1_stdofmean_p1 = []\n",
    "ints_stdofmean_p1 = []\n",
    "\n",
    "ints_1_mean_p2 = []\n",
    "ints_mean_p2 = []\n",
    "ints_1_std_p2 = []\n",
    "ints_std_p2 = []\n",
    "ints_1_stdofmean_p2 = []\n",
    "ints_stdofmean_p2 = []\n",
    "\n",
    "\n",
    "for p1_b, p1_e, p2_b, p2_e in zip(p1_beg, p1_end, p2_beg, p2_end):\n",
    "\n",
    "    years_p1= str(p1_b-1900) + str(\"{0:0=2d}\".format((p1_e-1900)%100))\n",
    "    print(years_p1)\n",
    "    years_p2= str(p2_b-1900) + str(\"{0:0=2d}\".format((p2_e-1900)%100))\n",
    "    print(years_p2)\n",
    "    \n",
    "    ints_1_mean_p1.append(hovnc['int_1_mean_' + years_p1][:])\n",
    "    ints_mean_p1.append(hovnc['int_mean_' + years_p1][:])\n",
    "    ints_1_std_p1.append(hovnc['int_1_std_' + years_p1][:])\n",
    "    ints_std_p1.append(hovnc['int_std_' + years_p1][:])\n",
    "    ints_1_stdofmean_p1.append(hovnc['int_1_stdofmean_' + years_p1][:])\n",
    "    ints_stdofmean_p1.append(hovnc['int_stdofmean_' + years_p1][:])\n",
    "    \n",
    "    ints_1_mean_p2.append(hovnc['int_1_mean_' + years_p2][:])\n",
    "    ints_mean_p2.append(hovnc['int_mean_' + years_p2][:])\n",
    "    ints_1_std_p2.append(hovnc['int_1_std_' + years_p2][:])\n",
    "    ints_std_p2.append(hovnc['int_std_' + years_p2][:])\n",
    "    ints_1_stdofmean_p2.append(hovnc['int_1_stdofmean_' + years_p2][:])\n",
    "    ints_stdofmean_p2.append(hovnc['int_stdofmean_' + years_p2][:])\n",
    "    \n",
    "hovnc.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        this.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width);\n",
       "        canvas.attr('height', height);\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x;\n",
       "    var y = canvas_pos.y;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x1194633c8>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(311)\n",
    "plt.pcolormesh(ints_mean_p1[0][:,3:16].T, vmin=0, vmax=40)\n",
    "plt.colorbar()\n",
    "\n",
    "ax1 = fig.add_subplot(312)\n",
    "plt.pcolormesh(ints_mean_p2[0][:,3:16].T, vmin=0, vmax=40)\n",
    "plt.colorbar()\n",
    "\n",
    "ax1 = fig.add_subplot(313)\n",
    "plt.pcolormesh(ints_mean_p2[0][:,3:16].T-ints_mean_p1[0][:,3:16].T, vmin=-10, vmax=10)\n",
    "plt.colorbar()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## CALCULATE CHANGES IN INTENSITY BETWEEN TIME PERIODS\n",
    "ints_1_diff = []\n",
    "ints_diff = []\n",
    "\n",
    "ints_1_Z = []\n",
    "ints_Z = []\n",
    "\n",
    "ints_1_pval = []\n",
    "ints_pval = []\n",
    "\n",
    "for int_p1, int_p1_stdofmean, int_p2, int_p2_stdofmean in zip(ints_1_mean_p1, ints_1_stdofmean_p1, ints_1_mean_p2, ints_1_stdofmean_p2):\n",
    "    \n",
    "    ints_1_diff.append(int_p2-int_p1)\n",
    "    Zscore = (int_p2-int_p1)/((int_p1_stdofmean**2+int_p2_stdofmean**2)**.5)\n",
    "    ints_1_Z.append(ma.array(Zscore, mask = np.isnan(Zscore)))\n",
    "    ints_1_pval.append(ma.array(st.norm.cdf(Zscore), mask = np.isnan(Zscore).mask))\n",
    "    \n",
    "for int_p1, int_p1_stdofmean, int_p2, int_p2_stdofmean in zip(ints_mean_p1, ints_stdofmean_p1, ints_mean_p2, ints_stdofmean_p2):\n",
    "    \n",
    "    ints_diff.append(int_p2-int_p1)\n",
    "    Zscore = (int_p2-int_p1)/((int_p1_stdofmean**2+int_p2_stdofmean**2)**.5)\n",
    "    ints_Z.append(ma.array(Zscore, mask = np.isnan(Zscore)))\n",
    "    pval = st.norm.cdf(Zscore)\n",
    "    ints_pval.append(ma.array((pval), mask = np.isnan(Zscore).mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8007_5179\n",
      "9407_8093\n"
     ]
    }
   ],
   "source": [
    "## SAVE INTENSITY DIFFERENCES AND P-VALUES AS NETCDF\n",
    "outfilename = \"RDA_int_diff.nc\"\n",
    "ferretpath = \"/Users/Siwen/Desktop/Ferret/bin/\"\n",
    "\n",
    "#netCDF output file formatting formatting\n",
    "fullname = ferretpath + outfilename\n",
    "\n",
    "##the following is only to make sure that we don't exceed the bounds of the number of rows of actual data.\n",
    "if os.path.isfile(fullname):\n",
    "    os.remove(fullname)\n",
    "    \n",
    "outfile = nc.Dataset(fullname, 'w')\n",
    "\n",
    "#use same years as chosen above:\n",
    "#p1_beg = [1951,1980]\n",
    "#p1_end = [1979,1993]\n",
    "#p2_beg = [1980,1994]\n",
    "#p2_end = [2007,2007]\n",
    "\n",
    "#create dimensions in NetCDF file\n",
    "days_dim = outfile.createDimension('time', None)\n",
    "lat_dim = outfile.createDimension('lat', 22)\n",
    "dim_tuple = (\"time\",\"lat\")\n",
    "\n",
    "#run through loop and save all differences of interest, as well as p-values\n",
    "for p1_b, p1_e, p2_b, p2_e, int_1_diff, int_diff, int_1_Z,int_Z, int_1_pval, int_pval in \\\n",
    "                            zip(p1_beg, p1_end, p2_beg, p2_end, ints_1_diff, \\\n",
    "                            ints_diff, ints_1_Z, ints_Z, ints_1_pval, ints_pval):\n",
    "    \n",
    "    #convoluted line of code below guarantees that 2007 will become '07' and not '7'\n",
    "    yrs_p1 = str(p1_b-1900) + str(\"{0:0=2d}\".format((p1_e-1900)%100))\n",
    "    yrs_p2 = str(p2_b-1900) + str(\"{0:0=2d}\".format((p2_e-1900)%100))\n",
    "    years = yrs_p2 + '_' + yrs_p1\n",
    "    print(years)\n",
    "\n",
    "    #create variables inside netCDF file\n",
    "    ints_1_diff_out = outfile.createVariable(\"int_1_diff_\" + years, 'f8', dim_tuple)\n",
    "    ints_diff_out = outfile.createVariable(\"int_diff_\" + years, 'f8', dim_tuple)\n",
    "    \n",
    "    ints_1_Z_out = outfile.createVariable(\"int_1_Z_\" + years, 'f8', dim_tuple)\n",
    "    ints_Z_out = outfile.createVariable(\"int_Z_\" + years, 'f8', dim_tuple)\n",
    "    \n",
    "    ints_1_pval_out = outfile.createVariable(\"int_1_pval_\" + years, 'f8', dim_tuple)\n",
    "    ints_pval_out = outfile.createVariable(\"int_pval_\" + years, 'f8', dim_tuple)\n",
    "    \n",
    "    \n",
    "    #fill with actual values\n",
    "    ints_1_diff_out[:] = int_1_diff\n",
    "    ints_diff_out[:] = int_diff\n",
    "    \n",
    "    ints_1_Z_out[:] = int_1_Z\n",
    "    ints_Z_out[:] = int_Z\n",
    "    \n",
    "    ints_1_pval_out[:] = int_1_pval\n",
    "    ints_pval_out[:] = int_pval\n",
    "\n",
    "\n",
    "outfile.close()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}