Worked_Example_FEWS-GoldSim-Adapter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Jupyter Notebook Delft FEWS User Day 2019\n",
    "\n",
    "### by Lindsay Millard, Hydrologist Seqwater\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "Jupyter Notebooks are fast way to develop and trial code for Delft FEWS adapters\n",
    "visit: <br>\n",
    "https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks\n",
    "to learn more about Jupyter Notebooks.\n",
    "<br> I'd like to bring the following example in the gallery to your attention: \n",
    "####  Pandas for Data Analysis \n",
    "Example notebooks - such as Timeseries Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "Let start off by calling the following Python modules to run the code in this example. Most are standard libraries within a Python installation. <br> If your Anaconda Distribution (or vanilla Python) does not have it then you can use either conda or pip to install them.\n",
    "\n",
    "Command Line >>> Pip install 'missing module'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from xml.etree.ElementTree import *  # Import everything \n",
    "\n",
    "import time\n",
    "from datetime import datetime\n",
    "import csv\n",
    "import os\n",
    "\n",
    "## from xlsxwriter.workbook import Workbook\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd  ## Abbreviate it using the convention\n",
    "pd.options.display.date_dayfirst=True  # Important to some assumptions below\n",
    "\n",
    "# Check what version of the module you are running, lets check Pandas.\n",
    "pd.__version__\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You can set up functions for checking the currency of the file found in the system path.  \n",
    "This needs to be run before the main part of the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "## Worker Function for checking currency\n",
    "def newest(path):\n",
    "    files = os.listdir(path)\n",
    "    paths = [os.path.join(path, basename) for basename in files]\n",
    "    return max(paths, key=os.path.getctime)\n",
    "\n",
    "# It is a good idea to put your variables up front\n",
    "fewsNamespace=\"http://www.wldelft.nl/fews/PI\"\n",
    "\n",
    "# The working folder root path can be defined here and then built on later when looking for files or output paths\n",
    "regionHome = r'W:\\500_Reference\\530_Presentations\\04_FEWS User Conference - Australia\\2019\\Python_LinguaFrancaofFEWS\\GoldSim/'\n",
    "\n",
    "regionHome = r'C:\\Users\\Lindsay\\Documents\\GitHub\\DFUDA_2019_Adapter/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Using For and If loops are a great way to pull data into the Python interpreter. It is probably a little confusing at first but the commentary along the way should make aspects a little clearer. If it doesn't make sense it can be unwrapped into a simple example. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part 1 _ Pre-Adapter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importState\n"
     ]
    }
   ],
   "source": [
    "# This is a list of the names of the XML files to go look for. I.e. look in regionHome for import.xml\n",
    "XMLs = ['importState','import']\n",
    "\n",
    "for xml in XMLs:\n",
    "    fin = os.path.join(regionHome,'1_Input',xml+'.xml')    \n",
    "    FEWS_Export = fin   #  regionHome+'1_Input/importState.xml'\n",
    "\n",
    "    parameterNames = ['HNPD_OUT','Reservoir.inflow.forecast', 'Reservoir.outflow.forecast', 'Gate.setting.forecast',]\n",
    "    spreadsheetNames = {'Reservoir.inflow.forecast':'LakeInflows', 'Reservoir.outflow.forecast':'RegulatorFlows', 'Gate.setting.forecast':'Gates', 'HNPD_OUT':'LakeLevels'}\n",
    "\n",
    "XMLs = ['importState']#,'import']\n",
    "## This will only work one by one in a Jupyter Notebook with many cells spilting the loop\n",
    "\n",
    "for xml in XMLs:\n",
    "    print(xml)\n",
    "    fin = os.path.join(regionHome,'1_Input',xml+'.xml')    \n",
    "    FEWS_Export = fin   #  regionHome+'1_Input/importState.xml'\n",
    "\n",
    "    parameterNames = ['HNPD_OUT','Reservoir.inflow.forecast', 'Reservoir.outflow.forecast', 'Gate.setting.forecast',]\n",
    "    spreadsheetNames = {'Reservoir.inflow.forecast':'LakeInflows', 'Reservoir.outflow.forecast':'RegulatorFlows', 'Gate.setting.forecast':'Gates', 'HNPD_OUT':'LakeLevels'}\n",
    "\n",
    "    for parametername in parameterNames:                   \n",
    "        ParList=[]\n",
    "        par =[]\n",
    "        locId=[]\n",
    "        i = 0    \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Here is reminder of what an XML looks like (using Grid display in XML spy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"assets/XML_timeseries.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Here is some code the will scrape timeseries data out of an XML file exported from FEWS.  \n",
    "The header information can be dealt with first. You can retrieve the number of Series (7), ParameterId (Reservoir.inflow.forecast) and MissingValue (-999.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have opended the following file:\n",
      "C:\\Users\\Lindsay\\Documents\\GitHub\\DFUDA_2019_Adapter/1_Input\\importState.xml\n"
     ]
    }
   ],
   "source": [
    "        with open(FEWS_Export, \"r\") as file:\n",
    "            print('We have opended the following file:\\n'+FEWS_Export)\n",
    "            \n",
    "            tree = parse(file)\n",
    "            PItimeSeries = tree.getroot()\n",
    "            \n",
    "            series = PItimeSeries.findall('.//{' + fewsNamespace + '}series')\n",
    "            ## Search for all the Parameters defined in the XML\n",
    "            Parameters=PItimeSeries.findall('.//{' + fewsNamespace + '}parameterId')\n",
    "            for param in Parameters:\n",
    "                ParList.append(param.text)\n",
    "            \n",
    "            parCount=0  # Initialise a counter of parameters found                \n",
    "            \n",
    "            missingvalue = PItimeSeries.findall('.//{' + fewsNamespace + '}missVal')\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The code does not know how many timeseries are in the XML. The following code will loop through all of the parameters of interest and then count the length.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Timestep rows:     481\n",
      "Number of Parameter columns: 0\n"
     ]
    }
   ],
   "source": [
    "            for S in series:\n",
    "                events = S.findall('.//{' + fewsNamespace + '}event')\n",
    "                \n",
    "                # When working with Date Time we will need to define it is a DateTime not a string or float\n",
    "                ArrayDates = np.zeros((len(events)),dtype='datetime64[ns]')\n",
    "                \n",
    "                par = S.find('.//{' + fewsNamespace + '}parameterId').text\n",
    "                if par==parametername:\n",
    "                    parCount = parCount + 1\n",
    "            \n",
    "            ## Once you loop through the file you are able to set up empty array of appropriate size            \n",
    "            ArrayValues = np.zeros((len(events), parCount))\n",
    "            print('Number of Timestep rows:     '+ str(ArrayValues.shape[0]))\n",
    "            print('Number of Parameter columns: '+ str(ArrayValues.shape[1]))\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "            j = 0\n",
    "\n",
    "            DateList = []\n",
    "            for S in series:\n",
    "                par = S.find('.//{' + fewsNamespace + '}parameterId').text\n",
    "                \n",
    "                if par!=parametername:\n",
    "                    pass\n",
    "                \n",
    "                else:            \n",
    "                    events = S.findall('.//{' + fewsNamespace + '}event')\n",
    "                    locs = S.findall('.//{' + fewsNamespace + '}locationId')\n",
    "                    \n",
    "                    i=0\n",
    "                    for l in locs:\n",
    "                        locId.append(l.text)        \n",
    "                \n",
    "                    for ev in events:\n",
    "                        if ev.attrib['value'] == S.find('.//{' + fewsNamespace + '}missVal').text:\n",
    "                            ArrayValues[i,j] = float(0)\n",
    "                        else:\n",
    "                            ArrayValues[i,j] = float(ev.attrib['value'])\n",
    "                        \n",
    "                        strucTime_Tuple = datetime.strptime(ev.attrib['date'] + \" \" + ev.attrib['time'],\"%Y-%m-%d %H:%M:%S\")\n",
    "                        ArrayDates[i] = strucTime_Tuple\n",
    "\n",
    "                        i += 1\n",
    "                    j += 1\n",
    "            row = i\n",
    "            col = j\n",
    "            print(row,col)\n",
    "\n",
    "            DFd = pd.DataFrame(ArrayDates) \n",
    "            # Rename the columns\n",
    "            DFd.columns = ['DateTime']\n",
    "            \n",
    "            DFv = pd.DataFrame(ArrayValues) \n",
    "            # Rename the columns\n",
    "            DFv.columns = locId\n",
    "            \n",
    "            # Concatenate both columns together, do this column-wise (axis=1)\n",
    "            DF = pd.concat([DFd,DFv],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gate.setting.forecast\n",
      "Gate.setting.forecast\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Outflow_m3/s</th>\n",
       "      <th>North_m</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DateTime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2011-01-08 23:00:00</th>\n",
       "      <td>30.0</td>\n",
       "      <td>38.60000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-01-08 23:30:00</th>\n",
       "      <td>30.0</td>\n",
       "      <td>38.59776</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-01-09 00:00:00</th>\n",
       "      <td>30.0</td>\n",
       "      <td>38.59553</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-01-09 00:30:00</th>\n",
       "      <td>30.0</td>\n",
       "      <td>38.59335</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2011-01-09 01:00:00</th>\n",
       "      <td>30.0</td>\n",
       "      <td>38.59138</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Outflow_m3/s   North_m\n",
       "DateTime                                   \n",
       "2011-01-08 23:00:00          30.0  38.60000\n",
       "2011-01-08 23:30:00          30.0  38.59776\n",
       "2011-01-09 00:00:00          30.0  38.59553\n",
       "2011-01-09 00:30:00          30.0  38.59335\n",
       "2011-01-09 01:00:00          30.0  38.59138"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "        ## Because the list of files and parameters contradict, we need to stop it overwriting the previous loop\n",
    "        if xml == 'importState' and parametername == 'HNPD_OUT':\n",
    "            GoldSIMSpreadSheet = regionHome+'2_Model/'+spreadsheetNames[parametername]+'.xlsx'\n",
    "\n",
    "            #Let us use Pandas to write the file to a spreadsheet, this can be done in one line\n",
    "            DF.to_excel(GoldSIMSpreadSheet,sheet_name='FEWS_Export')\n",
    "            print(parametername)\n",
    "\n",
    "        elif parametername != 'HNPD_OUT':\n",
    "            GoldSIMSpreadSheet = regionHome+'2_Model/'+spreadsheetNames[parametername]+'.xlsx'\n",
    "            DF.to_excel(GoldSIMSpreadSheet,sheet_name='FEWS_Export')\n",
    "            print(parametername)\n",
    "\n",
    "print(parametername)\n",
    "DF.head()           "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part 1 - Run the Pre- Adapter\n",
    "\n",
    "## Run the Master For loop from the top\n",
    "\n",
    "This will allow the file to iterate over all of the parameters and files of interest.  \n",
    "This will produce the XLSX files that GoldSim requires to run\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "XMLs = ['importState','import']\n",
    "\n",
    "for xml in XMLs:\n",
    "    fin = os.path.join(regionHome,'1_Input',xml+'.xml')    \n",
    "    FEWS_Export = fin   #  regionHome+'1_Input/importState.xml'\n",
    "\n",
    "    parameterNames = ['HNPD_OUT','Reservoir.inflow.forecast', 'Reservoir.outflow.forecast', 'Gate.setting.forecast',]\n",
    "    spreadsheetNames = {'Reservoir.inflow.forecast':'LakeInflows', 'Reservoir.outflow.forecast':'RegulatorFlows', 'Gate.setting.forecast':'Gates', 'HNPD_OUT':'LakeLevels'}\n",
    "\n",
    "    for parametername in parameterNames:                   \n",
    "        ParList=[]\n",
    "        par =[]\n",
    "        locId=[]\n",
    "        i = 0    \n",
    "        \n",
    "        with open(FEWS_Export, \"r\") as file:\n",
    "            tree = parse(file)\n",
    "            PItimeSeries = tree.getroot()\n",
    "            Parameters=PItimeSeries.findall('.//{' + fewsNamespace + '}parameterId')\n",
    "            for param in Parameters:\n",
    "                ParList.append(param.text)\n",
    "                \n",
    "            missingvalue = PItimeSeries.findall('.//{' + fewsNamespace + '}missVal')\n",
    "            series = PItimeSeries.findall('.//{' + fewsNamespace + '}series')\n",
    "\n",
    "            # determine size of aray needed. all series MUST be the same length\n",
    "            parCount=0\n",
    "            for S in series:\n",
    "                events = S.findall('.//{' + fewsNamespace + '}event')\n",
    "                ArrayDates = np.zeros((len(events)),dtype='datetime64[ns]')\n",
    "                \n",
    "                par = S.find('.//{' + fewsNamespace + '}parameterId').text\n",
    "                if par==parametername:\n",
    "                    parCount = parCount + 1\n",
    "            \n",
    "            ArrayValues = np.zeros((len(events), parCount))\n",
    "            j = 0\n",
    "\n",
    "            DateList = []\n",
    "            for S in series:\n",
    "                par = S.find('.//{' + fewsNamespace + '}parameterId').text\n",
    "                \n",
    "                if par!=parametername:\n",
    "                    pass\n",
    "                \n",
    "                else:            \n",
    "                    events = S.findall('.//{' + fewsNamespace + '}event')\n",
    "                    locs = S.findall('.//{' + fewsNamespace + '}locationId')\n",
    "                    i=0\n",
    "                    for l in locs:\n",
    "                        locId.append(l.text)        \n",
    "                \n",
    "                    for ev in events:\n",
    "                        if ev.attrib['value'] == S.find('.//{' + fewsNamespace + '}missVal').text:\n",
    "                            ArrayValues[i,j] = float(0)\n",
    "                        else:\n",
    "                            ArrayValues[i,j] = float(ev.attrib['value'])\n",
    "                        \n",
    "                        strucTime_Tuple = datetime.strptime(ev.attrib['date'] + \" \" + ev.attrib['time'],\"%Y-%m-%d %H:%M:%S\")\n",
    "                        ArrayDates[i] = strucTime_Tuple\n",
    "\n",
    "                        i += 1\n",
    "                    j +=  1\n",
    "            row = i\n",
    "            col = j\n",
    "\n",
    "            DFd = pd.DataFrame(ArrayDates) \n",
    "            DFd.columns = ['DateTime']\n",
    "            DFv = pd.DataFrame(ArrayValues) \n",
    "            DFv.columns = locId\n",
    "\n",
    "            DF = pd.concat([DFd,DFv],axis=1)\n",
    "                \n",
    "            \n",
    "        if xml == 'importState' and parametername == 'HNPD_OUT':\n",
    "            GoldSIMSpreadSheet = regionHome+'2_Model/'+spreadsheetNames[parametername]+'.xlsx'\n",
    "            DF.to_excel(GoldSIMSpreadSheet,sheet_name='FEWS_Export')\n",
    "        \n",
    "        elif parametername != 'HNPD_OUT':\n",
    "            GoldSIMSpreadSheet = regionHome+'2_Model/'+spreadsheetNames[parametername]+'.xlsx'\n",
    "            DF.to_excel(GoldSIMSpreadSheet,sheet_name='FEWS_Export')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part 2 - Run GoldSim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The Excel spreadsheet files for the:\n",
    "    Gates, LakeInflows, LakeLevels and RegulatorFlows have all been produced by Part 1.\n",
    "    \n",
    "Running the GoldSim Player file produces RoutedFlows.txt and RoutedLevels.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"assets/GoldSim_RunTheTimeseries.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Part 3 - Run the Post-Adapter\n",
    "\n",
    "Using the RoutedFlows.txt and RoutedLevel.txt we can now turn them back into XML timeseries for FEWS to read"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# populate the xml file\n",
    "def xml(parameter, location, eventValues, dT64, unit):\n",
    "    #sd = str(dateTime[0])\n",
    "    sd = dateTime[0].strftime(\"%Y-%m-%d\")\n",
    "    st = dateTime[0].strftime(\"%H:%M:%S\")\n",
    "    ed = dateTime[-1].strftime(\"%Y-%m-%d\")\n",
    "    et = dateTime[-1].strftime(\"%H:%M:%S\")\n",
    "    DTtimeStep = dateTime[1]-dateTime[0]\n",
    "    timeStep = int(DTtimeStep.total_seconds())\n",
    "    \n",
    "    # write XML output timeseries\n",
    "    with open(regionHome+ExportXML,'a') as xf:    # 'a+b'\n",
    "        \n",
    "        ## Write Header for each Series \n",
    "        \n",
    "        xf.write('    <series>\\n')\n",
    "        xf.write('        <header>\\n')\n",
    "        xf.write('            <type>instantaneous</type>\\n')        \n",
    "        \n",
    "        loc_text = str('            <locationId>%s</locationId>\\n') % (location)\n",
    "        xf.write(loc_text)        \n",
    "        \n",
    "        par_text = str('            <parameterId>%s</parameterId>\\n') % (parameter)\n",
    "        xf.write(par_text)\n",
    "        \n",
    "        timestep_text = str('            <timeStep unit=\"second\" multiplier=\"%s\"/>\\n') %(timeStep)\n",
    "        xf.write(timestep_text)   \n",
    "        \n",
    "        sd_text = str('            <startDate date=\"%s\" time=\"%s\"/>\\n') % (sd, st)\n",
    "        xf.write(sd_text)\n",
    "        \n",
    "        ed_text = str('            <endDate date=\"%s\" time=\"%s\"/>\\n') % (ed, et)\n",
    "        xf.write(ed_text)\n",
    "        \n",
    "        xf.write('            <missVal>-999.0</missVal>\\n')\n",
    "        xf.write('            <stationName>Hydro Gauge 1</stationName>\\n')        \n",
    "        \n",
    "        unit_text = str('            <units>%s</units>\\n') %(unit)\n",
    "        xf.write(unit_text) \n",
    "        \n",
    "        xf.write('        </header>\\n')\n",
    "        \n",
    "        \n",
    "        ## Write all the event values for each  timestamp in the series\n",
    "        for i in range(len(eventValues)):\n",
    "            event_date = str('        <event date=\"%s\"') % (dateTime[i].strftime(\"%Y-%m-%d\"))\n",
    "            event_time = str(' time=\"%s\"') % (dateTime[i].strftime(\"%H:%M:%S\"))\n",
    "            event_value = str(' value=\"%s\"') % eventValues[i][0].round(2)\n",
    "            event_flag = str(' flag=\"0\"/>\\n')\n",
    "            \n",
    "            event = str(event_date+event_time+event_value+event_flag)\n",
    "            xf.write(event)\n",
    "            \n",
    "        xf.write('    </series>\\n')\n",
    "        \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 03 _ Main Post-Adapter code\n",
    "\n",
    "Go get the GoldSim model results and then translate the output files\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "regionHome = r'C:\\Users\\Lindsay\\Documents\\GitHub\\DFUDA_2019_Adapter/'\n",
    "\n",
    "ExportXML = '3_Output/Export_fromGoldSim.xml'\n",
    "GoldSimOutputs = ['RoutedFlows.txt','RoutedLevels.txt']\n",
    "\n",
    "DF = pd.DataFrame()\n",
    "\n",
    "# write XML output header, once\n",
    "with open(ExportXML,'w') as xf:\n",
    "    xf.write('<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n')\n",
    "    xf.write('<TimeSeries xmlns=\"http://www.wldelft.nl/fews/PI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.wldelft.nl/fews/PI http://fews.wldelft.nl/schemas/version1.0/pi-schemas/pi_timeseries.xsd\" version=\"1.2\">\\n')\n",
    "    xf.write('    <timeZone>10.0</timeZone>\\n')\n",
    "\n",
    "for GS in GoldSimOutputs:\n",
    "    fin = os.path.join(regionHome,'2_Model',GS)\n",
    "\n",
    "    with open(fin,'r') as f:\n",
    "        lines = f.readlines()\n",
    "        parameter = lines[11].split()[1]\n",
    "        unit = lines[12].split()[1]\n",
    "\n",
    "    df = pd.read_table(fin,skiprows=14,header=None,names=['DateTime',parameter+'_'+unit,'Blank'],index_col=0,\n",
    "                       parse_dates=True,dayfirst=True)\n",
    "\n",
    "    df = df.drop(['Blank'],axis=1)   \n",
    "    DF = pd.concat([DF,df],axis=1)\n",
    "    \n",
    "    locn = 'NPD'\n",
    "    dateTime = df.index.to_pydatetime()\n",
    "    xml(parameter,locn,df.values,dateTime,unit)\n",
    "\n",
    "with open(ExportXML,'a') as xf:\n",
    "    xf.write('</TimeSeries>\\n') \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Have a quick plot of the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax=DF.iloc[:,0].plot(legend=True)\n",
    "DF.iloc[:,1].plot(secondary_y=True,\n",
    "                  ax=ax,legend=True)\n",
    "ax.set_ylabel(DF.columns[0])\n",
    "ax.set_xlim('09-01-2011','13-01-2011')\n",
    "ax.grid(which='both')"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}