StoDyM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('Dam_Characteristics',   DID  SIN  ISC(m^3)     IDA(%)  LE(yr)\n",
       "              0  D0    9   43000.0  15.492391      28\n",
       "              1  D1   11   52000.0  11.570980      25\n",
       "              2  D2   22   59000.0  29.116676      24\n",
       "              3  D3   27   58000.0  15.274982      22\n",
       "              4  D4   34   28000.0  17.336339      22),\n",
       "             ('Storage_Variation',\n",
       "                  Year        D0        D1        D2        D3        D4\n",
       "              0      0  1.000000  1.000000  1.000000  1.000000  1.000000\n",
       "              1      1  0.955023  0.952350  0.952711  0.956837  0.959683\n",
       "              2      2  0.910211  0.904818  0.905466  0.913532  0.919346\n",
       "              3      3  0.865580  0.857417  0.858269  0.870070  0.878984\n",
       "              4      4  0.821145  0.810160  0.811131  0.826436  0.838591\n",
       "              5      5  0.776924  0.763061  0.764058  0.782612  0.798158\n",
       "              6      6  0.732939  0.716140  0.717064  0.738577  0.757673\n",
       "              7      7  0.689213  0.669416  0.670163  0.694308  0.717125\n",
       "              8      8  0.645774  0.622914  0.623371  0.649776  0.676494\n",
       "              9      9  0.602654  0.576663  0.576712  0.604950  0.635758\n",
       "              10    10  0.559891  0.530700  0.530214  0.559790  0.594888\n",
       "              11    11  0.517529  0.485068  0.483914  0.514252  0.553843\n",
       "              12    12  0.475620  0.439819  0.437862  0.468283  0.512570\n",
       "              13    13  0.434227  0.395022  0.392121  0.421823  0.470995\n",
       "              14    14  0.393425  0.350762  0.346780  0.374800  0.429012\n",
       "              15    15  0.353306  0.307148  0.301960  0.327138  0.386472\n",
       "              16    16  0.313981  0.264328  0.257834  0.278761  0.343153\n",
       "              17    17  0.275591  0.222499  0.214646  0.229617  0.298717\n",
       "              18    18  0.238310  0.181936  0.172761  0.179741  0.252630\n",
       "              19    19  0.202357  0.143033  0.132722  0.129423  0.204028\n",
       "              20    20  0.168012  0.106368  0.095352  0.079690  0.151497\n",
       "              21    21  0.135629  0.072814  0.061898  0.033724  0.092981\n",
       "              22    22  0.105654  0.043701  0.034150  0.000896  0.028415\n",
       "              23    23  0.078637  0.020948  0.014269       NaN       NaN\n",
       "              24    24  0.055213  0.006669  0.003603       NaN       NaN\n",
       "              25    25  0.036024  0.001029       NaN       NaN       NaN\n",
       "              26    26  0.021522       NaN       NaN       NaN       NaN\n",
       "              27    27  0.011681       NaN       NaN       NaN       NaN\n",
       "              28    28  0.005798       NaN       NaN       NaN       NaN),\n",
       "             ('SDR_Variation',     Year       SDR\n",
       "              0      1  0.131146\n",
       "              1      2  0.131709\n",
       "              2      3  0.132325\n",
       "              3      4  0.133000\n",
       "              4      5  0.133743\n",
       "              5      6  0.134567\n",
       "              6      7  0.135487\n",
       "              7      8  0.136520\n",
       "              8      9  0.137690\n",
       "              9     10  0.139028\n",
       "              10    11  0.140577\n",
       "              11    12  0.142394\n",
       "              12    13  0.144562\n",
       "              13    14  0.147201\n",
       "              14    15  0.150497\n",
       "              15    16  0.154749\n",
       "              16    17  0.160474\n",
       "              17    18  0.168626\n",
       "              18    19  0.181157\n",
       "              19    20  0.202563\n",
       "              20    21  0.244916\n",
       "              21    22  0.346261\n",
       "              22    23  0.620395\n",
       "              23    24  0.809212\n",
       "              24    25  0.910305\n",
       "              25    26  0.949992\n",
       "              26    27  0.966065\n",
       "              27    28  0.979711),\n",
       "             ('Summary',                        0\n",
       "              ITSC(m^3)  240000.000000\n",
       "              ITDA(%)        88.791368\n",
       "              LE_A(yr)       24.200000\n",
       "              O-LE            0.806667\n",
       "              O-SD            0.036787\n",
       "              O-SDR,ST        0.131146\n",
       "              O-SDR,LT        0.202563)])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pandas import DataFrame, ExcelWriter, read_excel\n",
    "from collections import OrderedDict\n",
    "\n",
    "def dam_storage_sdr_annual(dtl_a, dsc_a, dda_a, dste_a, dnuc_a):\n",
    "     \n",
    "    \"\"\"\n",
    "    This function calculates the annual variations of \n",
    "    (a) dams' sediment input, Sediment Trapping Efficiency (STE), and storage capacity;\n",
    "    (b) catchment's Sediment Delivery Ratio\n",
    "    \"\"\"\n",
    "    \n",
    "    ssi_tv = np.sum(ssi_a)  # stream sediment input total value (ton)\n",
    "    ssi_ca = np.copy(ssi_a)  # copied array of stream sediment input\n",
    "    \n",
    "    # store the connected order of dams' location\n",
    "    dlco_a = np.empty(len(dtl_a), dtype=int)\n",
    "    for i_v1, v1 in enumerate(dtl_a):\n",
    "        dlco_a[i_v1] = np.array([i_v2 for i_v2, v2 in enumerate(slco_a) if v1 in v2])\n",
    "    \n",
    "    # argument sort of dams' stream ID connected order and sorting other data \n",
    "    dlco_as = np.argsort(dlco_a) \n",
    "    dtl_sa = dtl_a[dlco_as] \n",
    "    dsc_sa = dsc_a[dlco_as] \n",
    "    dste_sa = dste_a[dlco_as] \n",
    "    dnuc_sa = dnuc_a[dlco_as]\n",
    "    \n",
    "    dsd_v = 0  # initial value of cumulative sediment deposition in dams\n",
    "    \n",
    "    # Store dams' sediment input, storage capacity and STE, and catchmnet's SDR value\n",
    "    dsi_sa = np.empty(len(dtl_a))\n",
    "    for i_v1, v1 in enumerate(dtl_sa): \n",
    "        v1_suc = sluc_a[v1 - 1]  \n",
    "        if len(v1_suc) == 0:  # if dam's upstream connection is not found\n",
    "            v1_dsi = ssi_ca[v1-1]\n",
    "            dsi_sa[i_v1] = v1_dsi  \n",
    "            v1_dsd = v1_dsi * dste_sa[i_v1]  \n",
    "            dsd_v += v1_dsd \n",
    "            dsc_sa[i_v1] -= (v1_dsd*csw_kg) / s_sg \n",
    "            ssi_ca[v1-1] -= v1_dsd\n",
    "        else:  # if dam's upstream connection is found\n",
    "            v1_udc = np.array([v2 for v2 in dtl_sa if v2 in v1_suc and v2 != v1])  \n",
    "            if len(v1_udc) == 0:  # if upstream dam's upstream segments are not found\n",
    "                v1_dsi = np.sum(ssi_ca[sluc_a[v1-1] - 1])\n",
    "                dsi_sa[i_v1] = v1_dsi  \n",
    "                v1_dsd = v1_dsi * dste_sa[i_v1]  \n",
    "                dsd_v += v1_dsd  \n",
    "                dsc_sa[i_v1] -= (v1_dsd*csw_kg) / s_sg \n",
    "                ssi_ca[v1-1] = v1_dsi - v1_dsd  \n",
    "            else:  # if upstream dam's upstream segments are found\n",
    "                v1_rus = np.concatenate([sluc_a[v3-1] if len(sluc_a[v3-1]) != 0 else np.array([v3]) \n",
    "                                         for v3 in v1_udc])  # remove upstream segments\n",
    "                v1_urus = np.unique(v1_rus) \n",
    "                v1_auc = np.setdiff1d(v1_suc, v1_urus)  \n",
    "                v1_dsi = np.sum(ssi_ca[v1_auc-1]) + np.sum(ssi_ca[dtl_a[dnuc_sa[i_v1]] - 1]) \n",
    "                dsi_sa[i_v1] = v1_dsi  \n",
    "                v1_dsd = v1_dsi * dste_sa[i_v1]\n",
    "                dsd_v += v1_dsd  \n",
    "                dsc_sa[i_v1] -= (v1_dsd*csw_kg) / s_sg \n",
    "                ssi_ca[v1-1] = v1_dsi - v1_dsd  \n",
    "    \n",
    "    # argument sort of dams' stream ID and corresponding sort of other data\n",
    "    dtl_2as = np.argsort(dtl_sa)\n",
    "    dsi_a = dsi_sa[dtl_2as] \n",
    "    dsc_a = dsc_sa[dtl_2as]  \n",
    "    dste_a = dam_ste(dsc_a, dda_a) \n",
    "    \n",
    "    # Sediment Delivery Ratio\n",
    "    sdr_v = (ssi_tv-dsd_v) / ssi_tv\n",
    "    \n",
    "    return dsi_a, dsc_a, dste_a, sdr_v  # return the outputs\n",
    "\n",
    "\n",
    "def dam_next_upstream_connection(dtl_a):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function calculates the next upstream connection of dams\n",
    "    \"\"\"\n",
    "    \n",
    "    # store the dams' all upstream connection\n",
    "    duc_a = np.empty(len(dtl_a), dtype=object) \n",
    "    for i_v1, v1 in enumerate(dtl_a): \n",
    "        v1_sluc = sluc_a[v1-1]\n",
    "        if len(v1_sluc) != 0: \n",
    "            duc_a[i_v1] = np.array([np.asscalar(np.where(dtl_a == v2)[0]) \n",
    "                                    for v2 in dtl_a \n",
    "                                    if v2 in v1_sluc and v2 != v1])\n",
    "        else: \n",
    "            duc_a[i_v1] = v1_sluc\n",
    "    \n",
    "    # store the dams' next upstream connection only\n",
    "    dnuc_a = np.empty(len(dtl_a), dtype=object) \n",
    "    for i_v1, v1 in enumerate(duc_a):  \n",
    "        if len(v1) == 0:  \n",
    "            dnuc_a[i_v1] = v1 \n",
    "        else:  \n",
    "            v1_uuc = [duc_a[v2] for v2 in v1 if len(duc_a[v2]) != 0]\n",
    "            if len(v1_uuc) != 0:  \n",
    "                v1_ucd = np.unique(np.concatenate(v1_uuc)) \n",
    "                dnuc_a[i_v1] = np.setdiff1d(v1, v1_ucd) \n",
    "            else:      \n",
    "                dnuc_a[i_v1] = v1 \n",
    "    \n",
    "    return dnuc_a  # return the output\n",
    "\n",
    "\n",
    "def dam_ste(dsc_a, dda_a):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function calculates the dams' Sediment Trapping Efficiency (STE) \n",
    "    \"\"\"\n",
    "    \n",
    "    dste_a = 1 - (1 / (1 + ((0.0021*0.1*dsc_a) / dda_a))) \n",
    "    \n",
    "    return dste_a  # return the output\n",
    "\n",
    "\n",
    "def dam_output_data(dtl_a, dda_a, dsc_a):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function calculates:\n",
    "    (a) the arrays of dams' annual storage capacity variation\n",
    "    (b) life expectancy of each dam, \n",
    "    (c) array of Sediment Delivery Ratio (SDR) up to the maximum life expectancy of all dams \n",
    "    \"\"\"\n",
    "    \n",
    "    did_a = np.array(np.arange(len(dtl_a)), dtype=int)  # array of dams' ID\n",
    "    dste_a = dam_ste(dsc_a, dda_a)  # array of dams's initial STE\n",
    "    dnuc_a = dam_next_upstream_connection(dtl_a)  # array of dams' initial next upstream connection\n",
    "    dfo_a = np.empty(0, dtype=int)  # an empty array to store the order of inactive dam(s)\n",
    "    \n",
    "    dscv_l = []  # an empty list to store dams' storage capacity variation\n",
    "    sdr_a = np.empty(0)  # an empty array to store annual SDR variation\n",
    "    dsv_m = np.array([dsc_a])  # dams' storage capacity variation matrix with first row as initial value  \n",
    "    \n",
    "    # store annual variaton of dams' storage capacity and catchment's SDR\n",
    "    yr_i = 0  # initial year\n",
    "    while True:\n",
    "        yr_i += 1 \n",
    "        dsi_a, dsc_a, dste_a, sdr_v = dam_storage_sdr_annual(dtl_a, dsc_a, dda_a, dste_a, dnuc_a)\n",
    "        dsv_m = np.vstack((dsv_m, dsc_a))\n",
    "        sdr_a = np.append(sdr_a, sdr_v) \n",
    "        if yr_i >= dle_max:\n",
    "            fdi_a = np.where(dtl_a > 0)[0]\n",
    "        elif np.any((dsc_a <= 0) | (dste_a < ste_tv)):\n",
    "            fdi_a = np.where((dsc_a <= 0) | (dste_a < ste_tv))[0]\n",
    "        else:\n",
    "            continue\n",
    "        dfo_a = np.append(dfo_a, did_a[fdi_a])\n",
    "        [dscv_l.append(dsv_m[:, v1]) for v1 in fdi_a]  \n",
    "        dsv_m = np.delete(dsv_m, fdi_a, axis=1) \n",
    "        did_a = np.delete(did_a, fdi_a)\n",
    "        dtl_a = np.delete(dtl_a, fdi_a) \n",
    "        dsc_a = np.delete(dsc_a, fdi_a) \n",
    "        dste_a = np.delete(dste_a, fdi_a)\n",
    "        dnuc_a = dam_next_upstream_connection(dtl_a)  \n",
    "        dda_a = dam_drainage_area(dtl_a)\n",
    "        if len(did_a) == 0:\n",
    "            break\n",
    "        else:\n",
    "            continue\n",
    "    \n",
    "    # sorted dams' annual storage variation and life expectancy\n",
    "    dsv_a = (dscv_l[v1] for v1 in np.argsort(dfo_a)) \n",
    "    dpvsv_a = (np.delete(v1, np.where(v1 < 0)[0]) for v1 in dsv_a)  \n",
    "    dnsv_a = np.array([v1/v1[0] for v1 in dpvsv_a])  \n",
    "    dle_a = np.array([(len(v1)-1) for v1 in dnsv_a])  \n",
    "\n",
    "    return dnsv_a, dle_a, sdr_a  # return the outputs\n",
    "\n",
    "\n",
    "def dam_drainage_area(dtl_a):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function calculates the dams' initial drainage area \n",
    "    based on their locations in the stream path\n",
    "    \"\"\"\n",
    "    \n",
    "    # store the connected order of dams' location\n",
    "    dlco_a = np.empty(len(dtl_a), dtype=int)  \n",
    "    for i_v1, v1 in enumerate(dtl_a):\n",
    "        dlco_a[i_v1] = np.array([i_v2 for i_v2, v2 in enumerate(slco_a) if v1 in v2])\n",
    "    \n",
    "    # argument sort of dams' connected order and sorting other data\n",
    "    dlco_as = np.argsort(dlco_a)\n",
    "    dlco_sa = dtl_a[dlco_as]  \n",
    "    \n",
    "    # store dams' flow accumulation by dams' stream ID connected order\n",
    "    dtlfa_sa = np.empty(len(dtl_a))\n",
    "    for i_v1, v1 in enumerate(dlco_sa): \n",
    "        v1_sluc = sluc_a[v1-1]  \n",
    "        v1_udc = [v2 for v2 in dlco_sa if v2 in v1_sluc and v2 != v1] \n",
    "        if len(v1_udc) == 0:   \n",
    "            dtlfa_sa[i_v1] = fa_a[v1-1] + 1 \n",
    "        else:  \n",
    "            v1_udci = [np.asscalar(np.where(dlco_sa == v3)[0]) for v3 in v1_udc]  \n",
    "            v1_udfa = np.sum([dtlfa_sa[v4] for v4 in v1_udci])   \n",
    "            dtlfa_sa[i_v1] = (fa_a[v1-1]-v1_udfa) + 1  \n",
    "    \n",
    "    # dams drainage area (km^2) according to dams' targeted location \n",
    "    dtlfa_a = dtlfa_sa[np.argsort(dlco_sa)]\n",
    "    dda_a = dtlfa_a * pa_v \n",
    "    \n",
    "    return dda_a  # return the output\n",
    "\n",
    "\n",
    "def stream_connection_structure():\n",
    "    \n",
    "    \"\"\"\n",
    "    This function calculates: \n",
    "    (a) all the connnected upstream segments for each stream segment,\n",
    "    (b) connected order of stream segments from downstream to upstream\n",
    "    \"\"\"\n",
    "    \n",
    "    # an empty array to store stream link upstream connection\n",
    "    sluc_a = np.empty(len(sid_a), dtype=object)\n",
    "    \n",
    "    # an empty list to store connected order of stream segments from downstream to upstream\n",
    "    slco_l = []  \n",
    "    \n",
    "    # end segment\n",
    "    sl_mds = sid_a[np.where(nsid_a == (len(nsid_a) + 1))[0]]\n",
    "    sl_mdsi = np.asscalar(np.where(sid_a == sl_mds)[0])\n",
    "    sluc_a[sl_mdsi] = sl_mds\n",
    "    slco_l.append(sl_mds)\n",
    "    \n",
    "    while True:  \n",
    "        if len(sl_mds) == 1:  # detemine next downstream segments of end segment and store the values\n",
    "            sl_nuci = np.where(nsid_a == sl_mds)[0]\n",
    "            sl_mds = sid_a[sl_nuci]\n",
    "            sluc_a[sl_mdsi] = np.append(sluc_a[sl_mdsi], sl_mds)\n",
    "            slco_l.append(sl_mds) \n",
    "        else:  # update next donwstream segments and store the values\n",
    "            sl_nuci = np.array([np.where(nsid_a == v1)[0] for v1 in sl_mds])\n",
    "            sl_nuc = [sid_a[v2] if len(v2) != 0 else v2 for v2 in sl_nuci] \n",
    "            for v3, v4 in zip(sl_mds, sl_nuc):\n",
    "                if len(v4) != 0:\n",
    "                    sluc_a[v3-1] = np.append(sid_a[v3-1], v4)\n",
    "                else:\n",
    "                    sluc_a[v3-1] = v4\n",
    "            for v5 in sl_mds:  # iterate updated next downstream segments and store the values\n",
    "                sl_uci = np.array([i_v6 for i_v6, v6 in enumerate(sluc_a) \n",
    "                                   if v6 is not None and v5 in v6 and i_v6 != v5 - 1])\n",
    "                for v7 in sl_uci:\n",
    "                    v7_uuc = np.append(sluc_a[v7], sluc_a[v5-1])\n",
    "                    v7_usp = np.unique(v7_uuc, return_index=True)\n",
    "                    sluc_a[v7] = v7_uuc[np.sort(v7_usp[1])] \n",
    "            sl_nenuc = [sid_a[v8] for v8 in sl_nuci if len(v8) != 0]\n",
    "            if len(sl_nenuc) != 0:  # continue if non-empty next upstream connection is found\n",
    "                sl_mds = np.concatenate(sl_nenuc)\n",
    "                slco_l.append(sl_mds)\n",
    "            else:  # otherwise break the loop \n",
    "                break \n",
    "    \n",
    "    # connected order of stream segments from downstream to upstream\n",
    "    slco_a = np.array(slco_l)[::-1]  \n",
    "    \n",
    "    return sluc_a, slco_a  # return the outputs\n",
    "\n",
    "\n",
    "def stodym_output_write(excel_file=False, stodym_fp=\"StoDyM_Output.xlsx\"):\n",
    "    \n",
    "    \"\"\"\n",
    "    This function gives the output of StoDyM and write the output data in excel file if option is given\n",
    "    \"\"\"\n",
    "    \n",
    "    didcn_l = [\"D\"+str(v3) for v3 in range(len(dtl_a))]  # Dams' ID coulmn list\n",
    "    \n",
    "    # Dams' locations, storage capacity, drainage area and life expectancy  \n",
    "    dccn_l = [\"DID\", \"SIN\", \"ISC(m^3)\", \"IDA(%)\", \"LE(yr)\"]\n",
    "    dc_df = DataFrame.from_records(zip(didcn_l, dtl_a, dsc_a, ddap_a, dle_a), columns=dccn_l)\n",
    "    \n",
    "    # Dams' normalized storage capacity variation\n",
    "    nsv_od = OrderedDict([(v1, v2) for v1, v2 in zip(didcn_l, dnsv_a)]) \n",
    "    nsv_df = DataFrame.from_dict(nsv_od, orient=\"index\").T\n",
    "    nsv_df.insert(0, \"Year\", range(1+np.amax(dle_a)))\n",
    "\n",
    "    # SDR variation\n",
    "    sdr_od = OrderedDict([(v1, v2) for v1, v2 in zip([\"Year\", \"SDR\"], [1+np.arange(len(sdr_a)), sdr_a])])\n",
    "    sdr_df = DataFrame.from_dict(sdr_od)\n",
    "    \n",
    "    # Dam deployment summary with objective values\n",
    "    dsscn_l = [\"ITSC(m^3)\", \"ITDA(%)\", \"LE_A(yr)\"] + ocn_l \n",
    "    if len(np.where(dle_a >= dle_min)[0]) >= 2:\n",
    "        sd_m = np.array([v1[:dle_min] for v1, v2 in zip(dnsv_a, dle_a) \n",
    "                            if v2 >= dle_min]) \n",
    "        sdm_a = np.mean(sd_m, axis=0)\n",
    "        sdd_max = np.amax([np.mean(np.power(v1-sdm_a, 2))**0.5 for v1 in sd_m])\n",
    "        dds_l = [np.sum(dsc_a), np.sum(ddap_a), np.mean(dle_a), \n",
    "                 np.mean(dle_a)/dle_max, sdd_max, sdr_a[0], sdr_a[dle_min-1]]\n",
    "    else:\n",
    "        sdd_max = \"NA\" \n",
    "        dds_l = [np.sum(dsc_a), np.sum(ddap_a), np.mean(dle_a), \n",
    "                 np.mean(dle_a)/dle_max, sdd_max, sdr_a[0], sdr_a[-1]]\n",
    "    dds_df = DataFrame.from_records([dds_l], columns=dsscn_l).T\n",
    "    \n",
    "    # StoDyM output ordered dictionary\n",
    "    stodym_od = OrderedDict([(v1, v2) for v1, v2 in zip(stodym_sn, [dc_df, nsv_df, sdr_df, dds_df])])\n",
    "    \n",
    "    # if the data need to be saved in excel file\n",
    "    if excel_file == True:       \n",
    "        stodymxl_wo = ExcelWriter(stodym_fp, engine=\"xlsxwriter\") \n",
    "        dc_df.to_excel(stodymxl_wo, sheet_name=stodym_sn[0], index=False)\n",
    "        nsv_df.to_excel(stodymxl_wo, sheet_name=stodym_sn[1], index=False)\n",
    "        sdr_df.to_excel(stodymxl_wo, sheet_name=stodym_sn[2], index=False) \n",
    "        dds_df.to_excel(stodymxl_wo, sheet_name=stodym_sn[3], index=True, header=False)\n",
    "        stodymxl_wo.save()\n",
    "\n",
    "    return stodym_od\n",
    "\n",
    "c_pn, pa_v = (12419, 20**2/10**6)  # number of pixel in catchment area and pixel area in km^2\n",
    "ste_tv = 0.1  # dam Sediment Trapping Efficiency (STE) threshold value\n",
    "ca_km2 = c_pn * pa_v  # catchment area (km^2)\n",
    "dle_min, dle_max = (20, 30)  # dam life expectancy minimum and maxiumum values\n",
    "csw_kg, s_sg = (907.185, 2650)  # connversion of sediment unit to Kg and sediment specific graity \n",
    "\n",
    "sc_fn = \"Shejiagou_Stream_Characteristics.xlsx\"  # stream characteristics file name\n",
    "sc_df = read_excel(sc_fn, sheet_name=\"SC_Data\")  # stream characteristics dataframe\n",
    "sid_a = np.array(sc_df[\"SID\"], dtype=int)  # stream ID array\n",
    "nsid_a = np.array(sc_df[\"NSID\"], dtype=int)  # next stream ID array\n",
    "fa_a = np.array(sc_df[\"DFA\"], dtype=int)  # flow accumulation array\n",
    "ssi_a = np.array(sc_df[\"SSI\"], dtype=float)  # stream sediment input array\n",
    "\n",
    "sluc_a, slco_a = stream_connection_structure()  # stream link upstream connection and connected order\n",
    "\n",
    "dtl_a = np.array([9, 11, 22, 27, 34])  # dam targeted location stream ID\n",
    "dsc_a = 10**3*np.array([43, 52, 59, 58, 28], dtype=float)  # dams' initial storage capacity array\n",
    "dda_a = dam_drainage_area(dtl_a)  # dam drainage area array\n",
    "ddap_a = 100 * (dda_a/ca_km2)  # dam initial drainage area percentage array\n",
    "dnsv_a, dle_a, sdr_a = dam_output_data(dtl_a, dda_a, dsc_a)  # dam output data\n",
    "\n",
    "ocn_l = [\"O-LE\", \"O-SD\", \"O-SDR,ST\", \"O-SDR,LT\"]  # objective column name list\n",
    "stodym_sn = [\"Dam_Characteristics\", \"Storage_Variation\", \"SDR_Variation\", \"Summary\"]  # sheet name\n",
    "stodym_od = stodym_output_write(excel_file=False, stodym_fp=\"StoDyM_Output.xlsx\")  # StoDyM ordered dictionary\n",
    "stodym_od\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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}