AWBM_Final_Optimised.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------\n",
      "Importing python modules\n",
      "\n",
      "...Python Modules imported...\n",
      " \n",
      "...input data loaded...\n",
      "     fun: 0.25876096269267146\n",
      "     jac: array([ 1.58986449e-03, -6.48468733e-04,  0.00000000e+00,  3.14784050e-03,\n",
      "       -8.43405724e-06,  0.00000000e+00,  2.11438537e-03, -4.24504280e-03,\n",
      "        1.07020140e-03,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
      "        5.28916717e-04,  4.84240055e-03])\n",
      " message: 'Optimization terminated successfully.'\n",
      "    nfev: 1443\n",
      "     nit: 88\n",
      "    njev: 88\n",
      "  status: 0\n",
      " success: True\n",
      "       x: array([1.18545290e-01, 7.12914941e-01, 4.33000000e-01, 2.78993889e+01,\n",
      "       1.02816786e+02, 1.50000000e+02, 5.96990068e-01, 9.65605506e-01,\n",
      "       1.30170798e-01, 2.09292492e-03, 0.00000000e+00, 0.00000000e+00,\n",
      "       2.95524822e+00, 1.43261721e-18])\n"
     ]
    }
   ],
   "source": [
    "print('-'*20)\n",
    "print('Importing python modules')\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "import matplotlib.font_manager as font_manager\n",
    "import datetime\n",
    "import csv\n",
    "%matplotlib inline\n",
    "from scipy.optimize import minimize\n",
    "print('')\n",
    "print('...Python Modules imported...')\n",
    "\n",
    "#========== model parameters ==========\n",
    "\n",
    "A = float(177);       # Catchment area [k^2]\n",
    "A1 = float(0.134)       # [0-1]\n",
    "A2 = float(0.433)       # [0-1]\n",
    "A3 = 1- A1 - A2       # [0-1]\n",
    "C1 = float(7)         # [mm]\n",
    "C2 = float(70)       # [mm]\n",
    "C3 = float(150)       # [mm]  \n",
    "BFI = float(0.35)      # Base flow index [0-1]\n",
    "Kbase = float(0.95)   # Baseflow recession constant [0-1]\n",
    "Ksurf = float(0.35)    # Surface flow recession constant [0-1]\n",
    "\n",
    "# Setting initial storage capacities\n",
    "S1_0 = float(0)        # Initial storage capacity storage 1 [mm]\n",
    "S2_0 = float(0)      # Initial storage capacity storage 2 [mm]\n",
    "S3_0 = float(0)     # Initial storage capacity storage 3 [mm]\n",
    "BS_0 = float(0)     # Initial storage capacity baseflow store [mm]\n",
    "SS_0 = float(0)     # Initial storage capacity surface flow store [mm]\n",
    "\n",
    "# Parameters needed to be calibrate\n",
    "parameters = [A1,A2,A3,C1,\n",
    "             C2,C3,BFI,Kbase,Ksurf,\n",
    "             S1_0,S2_0,S3_0,BS_0,SS_0]\n",
    "\n",
    "# establishing variables\n",
    "Date_in = []\n",
    "Day_in = []\n",
    "P_in = []\n",
    "E_in = []\n",
    "observed_temp = [] #in order to change unit\n",
    "predcted = []\n",
    "#date = []\n",
    "observed = []\n",
    "result = []\n",
    "\n",
    "# reading data\n",
    "infile_name = 'averaged silo data for task 5.csv'\n",
    "infile_name2 = 'Gauge row data 99-00.csv'\n",
    "\n",
    "with open(infile_name) as csvDataFile:\n",
    "    csvReader = csv.reader(csvDataFile)\n",
    "    next(csvReader)         # skips the 1st row (header information)\n",
    "    next(csvReader)         # skips the 2nd row (header information)\n",
    "    for row in csvReader:\n",
    "        Day_in.append(row[1])\n",
    "        Date_in.append(row[0])\n",
    "        P_in.append(row[10])\n",
    "        E_in.append(row[11])        \n",
    "del row\n",
    "\n",
    "#read observed data\n",
    "with open(infile_name2) as csvDataFile:\n",
    "    csvReader = csv.reader(csvDataFile)\n",
    "    next(csvReader)\n",
    "    next(csvReader)\n",
    "    next(csvReader)\n",
    "    next(csvReader) #skip headers\n",
    "    for row in csvReader:\n",
    "        observed.append(row[7]) #==========mean value==========!!!\n",
    "del row\n",
    "\n",
    "observed =[float(x) for x in observed]\n",
    "\n",
    "#Converting dates from string to datetime for plotting\n",
    "dims = np.shape(Date_in)\n",
    "Date = []\n",
    "for i in range(0,dims[0]):\n",
    "    temp_str = Date_in[i]\n",
    "    if \"-\" in temp_str:\n",
    "        temp_PD = datetime.datetime.strptime(temp_str, '%d-%m-%Y')\n",
    "    else:\n",
    "        temp_PD = datetime.datetime.strptime(temp_str, '%d/%m/%y %H:%S')\n",
    "    Date.append(temp_PD)\n",
    "del temp_str\n",
    "del temp_PD    \n",
    "del i\n",
    "del dims\n",
    "\n",
    "# Converting missing data to zero values \n",
    "Day = np.array(Day_in)\n",
    "Day[Day==''] = 0\n",
    "Day=[float(x) for x in Day]\n",
    "\n",
    "P = np.array(P_in)\n",
    "P[P==''] = 0               \n",
    "P=[float(x) for x in P]\n",
    "\n",
    "E = np.array(E_in)\n",
    "E[E==''] = 0               \n",
    "E=[float(x) for x in E]\n",
    "\n",
    "del Date_in, Day_in, P_in, E_in\n",
    "print(' ')\n",
    "print('...input data loaded...')\n",
    "\n",
    "def AWBM (parameters):\n",
    "    dims = np.shape(Date)\n",
    "    dS = []\n",
    "    S1 = []; S2 = []; S3 = []\n",
    "    S1_Excess =[]; S2_Excess =[]; S3_Excess =[]\n",
    "    Total_Excess = []\n",
    "    BaseFlowRecharge = []\n",
    "    SurfaceFlowRecharge = []\n",
    "    BS = []\n",
    "    SS = []\n",
    "    Qbase = []\n",
    "    Qsurf = []\n",
    "    Qtotal = []\n",
    "    Q = []\n",
    "    dS  = P[0]-E[0] # change in storage\n",
    "\n",
    "    S1_temp = max(parameters[9]+dS,0)\n",
    "    S1_Excess = max(S1_temp-parameters[3],0)\n",
    "    S1.append(min(S1_temp,parameters[3]))\n",
    "\n",
    "    S2_temp = max(parameters[10]+dS,0)\n",
    "    S2_Excess = max(S2_temp-parameters[4],0)\n",
    "    S2.append(min(S2_temp,parameters[4]))\n",
    "\n",
    "    S3_temp = max(parameters[11]+dS,0)\n",
    "    S3_Excess = max(S3_temp-parameters[5],0)\n",
    "    S3.append(min(S3_temp,parameters[5]))\n",
    "\n",
    "    Total_Excess.append((S1_Excess*parameters[0])+(S2_Excess*parameters[1])+(S3_Excess*parameters[2]))\n",
    "\n",
    "    BaseFlowRecharge = Total_Excess[0] * parameters[6]\n",
    "    SurfaceFlowRecharge = Total_Excess[0] * (1-parameters[6])\n",
    "\n",
    "    #BS_temp = (BaseFlowRecharge/2)+BS_0\n",
    "    BS_temp = BaseFlowRecharge + parameters[12]\n",
    "    Qbase.append((1-parameters[7])*BS_temp)\n",
    "    BS.append(max((parameters[12] + BaseFlowRecharge - Qbase[0]),0))\n",
    "\n",
    "    #SS_temp = (SurfaceFlowRecharge/2)+SS_0\n",
    "    SS_temp = SurfaceFlowRecharge + parameters[13]\n",
    "    Qsurf.append((1-parameters[8])*SS_temp)\n",
    "    SS.append(max((parameters[13] + SurfaceFlowRecharge - Qsurf[0]),0))\n",
    "\n",
    "    Qtotal.append(Qbase[0] + Qsurf[0])\n",
    "    Q.append(((Qtotal[0]/1000)*(A*1000*1000))/24/60/60)\n",
    "\n",
    "    for i in range(1,dims[0]):\n",
    "        dS = P[i]-E[i] \n",
    "\n",
    "        S1_temp = max(S1[i-1]+dS,0)\n",
    "        S1_Excess = max(S1_temp-parameters[3],0)\n",
    "        S1.append(min(S1_temp,parameters[3]))\n",
    "\n",
    "        S2_temp = max(S2[i-1]+dS,0)\n",
    "        S2_Excess = max(S2_temp-parameters[4],0)\n",
    "        S2.append(min(S2_temp,parameters[4]))\n",
    "\n",
    "        S3_temp = max(S3[i-1]+dS,0)\n",
    "        S3_Excess = max(S3_temp-parameters[5],0)\n",
    "        S3.append(min(S3_temp,parameters[5]))\n",
    "\n",
    "        Total_Excess.append((S1_Excess*parameters[0])+(S2_Excess*parameters[1])+(S3_Excess*parameters[2]))\n",
    "\n",
    "        BaseFlowRecharge = Total_Excess[i] * parameters[6]\n",
    "        SurfaceFlowRecharge = Total_Excess[i] * (1-parameters[6])\n",
    "\n",
    "    #   BS_temp = (BaseFlowRecharge/2)+BS[i-1] \n",
    "        BS_temp = BaseFlowRecharge + BS[i-1]\n",
    "        Qbase.append((1-parameters[7])*BS_temp)\n",
    "        BS.append(max((BS[i-1] + BaseFlowRecharge - Qbase[i]),0))\n",
    "\n",
    "    #   SS_temp = (SurfaceFlowRecharge/2)+SS[i-1]\n",
    "        SS_temp = SurfaceFlowRecharge + SS[i-1]\n",
    "        Qsurf.append((1-parameters[8])*SS_temp)\n",
    "        SS.append(max((SS[i-1] + SurfaceFlowRecharge - Qsurf[i]),0))\n",
    "\n",
    "        Qtotal.append(Qbase[i] + Qsurf[i])\n",
    "        Q.append(((Qtotal[i]/1000)*(A*1000*1000))/24/60/60)\n",
    "    del dims\n",
    "    \n",
    "    # Q = AWBM_List[13]\n",
    "    AWBM_List = [S1,S2,S3,S1_Excess,S2_Excess,\n",
    "                        S3_Excess,Total_Excess,BaseFlowRecharge,\n",
    "                        BS,SS,Qbase,Qsurf,Qtotal,Q]\n",
    "\n",
    "    predcted = AWBM_List[13]\n",
    "    predcted = [float(x) for x in predcted]\n",
    "    dims = np.shape(Date)\n",
    "    #====================================#\n",
    "    #======NSE and R^2 to calibrate======#\n",
    "    #====================================#\n",
    "\n",
    "    #set parameters\n",
    "    pmean = (sum(predcted[0:]))/len(predcted)\n",
    "    omean = (sum(observed[0:]))/len(observed)\n",
    "\n",
    "    #initialising variables for calculate\n",
    "\n",
    "    o_minus_omean = []\n",
    "    p_minus_pmean = []\n",
    "    o_minus_omean_and_p = [] #o-omean*p-pmean\n",
    "    o_minus_omean_square = []\n",
    "    p_minus_pmean_square = []\n",
    "    o_minus_p = []\n",
    "    o_minus_p_square = []\n",
    "    sum_o_minus_omean = float(0)  #sum all value up later\n",
    "    sum_p_minus_pmean = float(0)\n",
    "    sum_o_minus_omean_and_p = float(0)\n",
    "    sum_o_minus_omean_square = float(0)\n",
    "    sum_p_minus_pmean_square = float(0)\n",
    "    sum_o_minus_p = float(0)\n",
    "    sum_o_minus_p_square = float(0)\n",
    "    sum_d = float(0)\n",
    "    R_square = float(0)\n",
    "    NSE = float(0)\n",
    "    critical = float(0)\n",
    "\n",
    "    #===================for cycle to get every value=======================\n",
    "    for i in range(0,dims[0]):\n",
    "      #0-0mean \n",
    "        o_minus_omean_temp = observed[i]-omean\n",
    "        o_minus_omean.append(o_minus_omean_temp)\n",
    "\n",
    "      #p-pmean\n",
    "        p_minus_pmean_temp = predcted[i]-pmean\n",
    "        p_minus_pmean.append(p_minus_pmean_temp)\n",
    "\n",
    "      #(o-omean)*(p-pmean)\n",
    "        o_minus_omean_and_p.append((observed[i]-omean)*(predcted[i]-pmean))\n",
    "\n",
    "      #(o-omean)2\n",
    "        o_minus_omean_square.append((observed[i]-omean)**2)\n",
    "      #(p-pmean)2\n",
    "        p_minus_pmean_square.append((predcted[i]-pmean)**2)\n",
    "      #o-p & (o-p)2\n",
    "        o_minus_p.append(observed[i]-predcted[i])\n",
    "        o_minus_p_square.append((observed[i]-predcted[i])**2)\n",
    "\n",
    "      #sum\n",
    "        sum_o_minus_omean+= observed[i]-omean\n",
    "        sum_p_minus_pmean+= predcted[i]-pmean\n",
    "        sum_o_minus_omean_and_p+= (observed[i]-omean)*(predcted[i]-pmean)\n",
    "        sum_o_minus_omean_square+= (observed[i]-omean)**2\n",
    "        sum_p_minus_pmean_square+= (predcted[i]-pmean)*(predcted[i]-pmean)\n",
    "        sum_o_minus_p+= observed[i]-predcted[i]\n",
    "        sum_o_minus_p_square+= ((observed[i]-predcted[i])**2)\n",
    "        sum_d +=(abs(predcted[i]-omean)+abs(o_minus_omean[i]))**2\n",
    "        \n",
    "    #====testing=========\n",
    "    #R^2&NSE&d\n",
    "    R_square = (sum_o_minus_omean_and_p/(np.sqrt(sum_o_minus_omean_square)*np.sqrt(sum_p_minus_pmean_square)))**2\n",
    "    NSE = 1-(sum_o_minus_p_square/sum_o_minus_omean_square)\n",
    "    d = 1-((sum_o_minus_p_square)/(sum_d))\n",
    "    critical = 2 - (R_square + NSE)\n",
    "    \n",
    "    return critical\n",
    "\n",
    "AWBM(parameters)\n",
    "\n",
    "#set boundary\n",
    "#A1-3 [0-1] C1[0-50] C2[0-200] C3[0-500]\n",
    "b1 = [0.0,1.0]\n",
    "b2 = [0.0,50.0]\n",
    "b3 = [0.0,200.0]\n",
    "b4 = [0.0,500.0]\n",
    "b5 = [0.0,999999.0]\n",
    "#boundary for all parameters\n",
    "bnbs = [b1,b1,b1,b2,b3,b4,b1,b1,b1,b5,b5,b5,b5,b5]\n",
    "\n",
    "res = minimize(AWBM,parameters,\n",
    "              method = 'SLSQP',\n",
    "              bounds = bnbs)\n",
    "print(res)\n",
    "\n",
    "Calibrated_P = res.x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "...plotting data...\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def AWBM (x):\n",
    "    dims = np.shape(Date)\n",
    "    dS = []\n",
    "    S1 = []; S2 = []; S3 = []\n",
    "    S1_Excess =[]; S2_Excess =[]; S3_Excess =[]\n",
    "    Total_Excess = []\n",
    "    BaseFlowRecharge = []\n",
    "    SurfaceFlowRecharge = []\n",
    "    BS = []\n",
    "    SS = []\n",
    "    Qbase = []\n",
    "    Qsurf = []\n",
    "    Qtotal = []\n",
    "    Q = []\n",
    "    dS  = P[0]-E[0] # change in storage\n",
    "\n",
    "    S1_temp = max(x[9]+dS,0)\n",
    "    S1_Excess = max(S1_temp-x[3],0)\n",
    "    S1.append(min(S1_temp,x[3]))\n",
    "\n",
    "    S2_temp = max(x[10]+dS,0)\n",
    "    S2_Excess = max(S2_temp-x[4],0)\n",
    "    S2.append(min(S2_temp,x[4]))\n",
    "\n",
    "    S3_temp = max(x[11]+dS,0)\n",
    "    S3_Excess = max(S3_temp-x[5],0)\n",
    "    S3.append(min(S3_temp,x[5]))\n",
    "\n",
    "    Total_Excess.append((S1_Excess*x[0])+(S2_Excess*x[1])+(S3_Excess*x[2]))\n",
    "\n",
    "    BaseFlowRecharge = Total_Excess[0] * x[6]\n",
    "    SurfaceFlowRecharge = Total_Excess[0] * (1-x[6])\n",
    "\n",
    "    #BS_temp = (BaseFlowRecharge/2)+BS_0\n",
    "    BS_temp = BaseFlowRecharge + x[12]\n",
    "    Qbase.append((1-x[7])*BS_temp)\n",
    "    BS.append(max((x[12] + BaseFlowRecharge - Qbase[0]),0))\n",
    "\n",
    "    #SS_temp = (SurfaceFlowRecharge/2)+SS_0\n",
    "    SS_temp = SurfaceFlowRecharge + x[13]\n",
    "    Qsurf.append((1-x[8])*SS_temp)\n",
    "    SS.append(max((x[13] + SurfaceFlowRecharge - Qsurf[0]),0))\n",
    "\n",
    "    Qtotal.append(Qbase[0] + Qsurf[0])\n",
    "    Q.append(((Qtotal[0]/1000)*(A*1000*1000))/24/60/60)\n",
    "\n",
    "    for i in range(1,dims[0]):\n",
    "        dS = P[i]-E[i] \n",
    "\n",
    "        S1_temp = max(S1[i-1]+dS,0)\n",
    "        S1_Excess = max(S1_temp-x[3],0)\n",
    "        S1.append(min(S1_temp,x[3]))\n",
    "\n",
    "        S2_temp = max(S2[i-1]+dS,0)\n",
    "        S2_Excess = max(S2_temp-x[4],0)\n",
    "        S2.append(min(S2_temp,x[4]))\n",
    "\n",
    "        S3_temp = max(S3[i-1]+dS,0)\n",
    "        S3_Excess = max(S3_temp-x[5],0)\n",
    "        S3.append(min(S3_temp,x[5]))\n",
    "\n",
    "        Total_Excess.append((S1_Excess*x[0])+(S2_Excess*x[1])+(S3_Excess*x[2]))\n",
    "\n",
    "        BaseFlowRecharge = Total_Excess[i] * x[6]\n",
    "        SurfaceFlowRecharge = Total_Excess[i] * (1-x[6])\n",
    "\n",
    "    #   BS_temp = (BaseFlowRecharge/2)+BS[i-1] \n",
    "        BS_temp = BaseFlowRecharge + BS[i-1]\n",
    "        Qbase.append((1-x[7])*BS_temp)\n",
    "        BS.append(max((BS[i-1] + BaseFlowRecharge - Qbase[i]),0))\n",
    "\n",
    "    #   SS_temp = (SurfaceFlowRecharge/2)+SS[i-1]\n",
    "        SS_temp = SurfaceFlowRecharge + SS[i-1]\n",
    "        Qsurf.append((1-x[8])*SS_temp)\n",
    "        SS.append(max((SS[i-1] + SurfaceFlowRecharge - Qsurf[i]),0))\n",
    "\n",
    "        Qtotal.append(Qbase[i] + Qsurf[i])\n",
    "        Q.append(((Qtotal[i]/1000)*(A*1000*1000))/24/60/60)\n",
    "    del dims\n",
    "    \n",
    "    # Q = AWBM_List[13]\n",
    "    AWBM_List = [S1,S2,S3,S1_Excess,S2_Excess,\n",
    "                        S3_Excess,Total_Excess,BaseFlowRecharge,\n",
    "                        BS,SS,Qbase,Qsurf,Qtotal,Q]\n",
    "\n",
    "    predcted = AWBM_List[13]\n",
    "    predcted = [float(x) for x in predcted]\n",
    "    return predcted\n",
    "\n",
    "Q = AWBM(Calibrated_P)\n",
    "\n",
    "#==========plottttt==========\n",
    "print('')\n",
    "print('...plotting data...')\n",
    "# ========== Setting plot formatting (global settings)==========\n",
    "mS = 10 # set marker size\n",
    "lW = 3 # set linewidth\n",
    "fS = 20 # set font size\n",
    "plt.rcParams['font.family'] = 'Times New Roman' # Globally sets the font type\n",
    "plt.rc('font',size=fS)\n",
    "plt.rc('axes',titlesize=fS)\n",
    "plt.rc('axes',labelsize=fS)\n",
    "plt.rc('xtick',labelsize=fS)\n",
    "plt.rc('ytick',labelsize=fS)\n",
    "plt.rc('legend',fontsize=fS)\n",
    "plt.rc('figure',titlesize=fS)\n",
    "\n",
    "months = mdates.MonthLocator()\n",
    "monthsFmt = mdates.DateFormatter('%m')\n",
    "days = mdates.DayLocator()\n",
    "\n",
    "stDate = datetime.datetime.strptime('1999-11-1', '%Y-%m-%d')\n",
    "enDate = datetime.datetime.strptime('2000-3-1', '%Y-%m-%d')\n",
    "\n",
    "# ===== Single plot example =====\n",
    "fig, ax1 = plt.subplots() #Establishes figure handle\n",
    "ax2 = ax1.twinx()\n",
    "\n",
    "\n",
    "tle = 'AWBM - Model Output'\n",
    "\n",
    "ax1.plot(Date,Q, '-o', c='b',label='Simulated flow',\n",
    "         markersize=mS,linewidth=lW)\n",
    "ax2.plot(Date,observed,color='k',label='Observed flow')\n",
    "ax1.set_xlim(stDate, enDate)\n",
    "ax1.xaxis.set_major_locator(months)\n",
    "ax1.xaxis.set_major_formatter(monthsFmt)\n",
    "ax1.xaxis.set_minor_locator(days)\n",
    "\n",
    "ax1.set_xlabel('Date [Month in 1999-2000]')\n",
    "ax1.set_ylabel('Avg Daily Flow [m$^3$ $s^{-1}$]')\n",
    "ax2.set_ylabel('Rainfall [mm]')\n",
    "ax1.set_title(tle)\n",
    "ax1.legend(loc='upper left')\n",
    "ax2.legend(loc='upper right')\n",
    "\n",
    "#set size\n",
    "fig.set_figheight(8)\n",
    "fig.set_figwidth(16)\n",
    "\n",
    "fig.tight_layout() \n",
    "\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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "557px",
    "left": "890px",
    "right": "20px",
    "top": "129px",
    "width": "350px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}