docs/ODYM Example and Tutorial No. 1. System with two processes, two parameters, one material.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ODYM Example no. 1.  System with two processes, two parameters, one material.\n",
    "\n",
    "A simple MFA system with one material (represented by the indicator element carbon 'C'), a time horizon of 30 years [1980-2010], two processes, and a time-dependent parameter is analysed.\n",
    "\n",
    "<img src=\"Images/MFAExample1.png\" width=\"404\" height=\"490\" alt=\"Simple MFA system\">\n",
    "\n",
    "\n",
    "The model equations are as follows:\n",
    "+ $a(t) = D(t)$ (exogenous input flow)\n",
    "+ $d(t) = \\alpha (t)\\cdot b(t)$ (recovery efficiency parameter)\n",
    "+ $a(t) +d(t) = b(t) $ (mass balance process 1)\n",
    "+ $b(t) = c(t) + d(t) $ (mass balance process 2)\n",
    "\n",
    "From these equations the system solution follows:\n",
    "+ $c(t) = a(t) = D(t)$\n",
    "+ $b(t) = \\frac{1}{1-\\alpha (t)}\\cdot D(t)$\n",
    "+ $c(t) = \\frac{\\alpha}{1-\\alpha (t)}\\cdot D(t)$\n",
    "\n",
    "We will now programm this solution into ODYM. That is overkill, as ODYM was developed for handling much more complex MFA systems, but instructive.\n",
    "\n",
    "\n",
    "### 1) Load ODYM\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load a local copy of the current ODYM branch:\n",
    "import sys, os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "\n",
    "# For Ipython Notebook only\n",
    "%matplotlib inline\n",
    "\n",
    "sys.path.insert(0, os.path.join('..', 'odym', 'modules')) # add ODYM module directory to system path, relative\n",
    "sys.path.insert(0, os.path.join(os.getcwd(),'..', 'odym', 'modules')) # add ODYM module directory to system path, absolute\n",
    "import ODYM_Classes as msc # import the ODYM class file\n",
    "import ODYM_Functions as msf # import the ODYM function file\n",
    "import dynamic_stock_model as dsm # import the dynamic stock model library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Define MFA system \n",
    "With the model imported, we cannow set up the system definition. The 'classical' elements of the system definition in MFA include: The processes, flows, and stocks, the material, the region, and the time frame studied. Next to these elements, ODYM features/requires the following elements to be specified:\n",
    "+ The list of chemical elements considered\n",
    "+ The classification(s) of the system variables (stocks and flows): Which materials, products, regions, or waste groups are considered?\n",
    "+ An index letter to quickly/directly access a model aspect.\n",
    "+ A dictionary of model parameters\n",
    "\n",
    "For all these items ODYM has a specific structure, which is used below.\n",
    "\n",
    "First, we define a classification of all objects flowing. In this example we conduct a 'classical' dynamic MFA with just one material/chemical element/indicator element considered, and our classification can therefore be as simple as possible: it contains only one chemical element, in this case, we choose carbon ('C'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelClassification  = {} # Create dictionary of model classifications\n",
    "\n",
    "ModelClassification['Time'] = msc.Classification(Name = 'Time', Dimension = 'Time', ID = 1, \n",
    "                                                 Items = list(np.arange(1980,2011)))\n",
    "\n",
    "# Classification for time labelled 'Time' must always be present, \n",
    "# with Items containing a list of odered integers representing years, months, or other discrete time intervals\n",
    "\n",
    "ModelClassification['Element'] = msc.Classification(Name = 'Elements', Dimension = 'Element', ID = 2, \n",
    "                                                    Items = ['C'])\n",
    "\n",
    "# Classification for elements labelled 'Element' must always be present, \n",
    "# with Items containing a list of the symbols of the elements covered.\n",
    "\n",
    "# Get model time start, end, and duration:\n",
    "Model_Time_Start = int(min(ModelClassification['Time'].Items))\n",
    "Model_Time_End = int(max(ModelClassification['Time'].Items))\n",
    "Model_Duration = Model_Time_End - Model_Time_Start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That dictionary of classifications enteres the index table defined for the system. The indext table lists all aspects needed and assigns a classification and index letter to each aspect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "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>Description</th>\n",
       "      <th>Dimension</th>\n",
       "      <th>Classification</th>\n",
       "      <th>IndexLetter</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aspect</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Time</th>\n",
       "      <td>Model aspect \"time\"</td>\n",
       "      <td>Time</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>t</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Element</th>\n",
       "      <td>Model aspect \"Element\"</td>\n",
       "      <td>Element</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Description Dimension  \\\n",
       "Aspect                                      \n",
       "Time        Model aspect \"time\"      Time   \n",
       "Element  Model aspect \"Element\"   Element   \n",
       "\n",
       "                                            Classification IndexLetter  \n",
       "Aspect                                                                  \n",
       "Time     <ODYM_Classes.Classification object at 0x00000...           t  \n",
       "Element  <ODYM_Classes.Classification object at 0x00000...           e  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IndexTable = pd.DataFrame({'Aspect'        : ['Time','Element'], # 'Time' and 'Element' must be present!\n",
    "                           'Description'   : ['Model aspect \"time\"', 'Model aspect \"Element\"'],\n",
    "                           'Dimension'     : ['Time','Element'], # 'Time' and 'Element' are also dimensions\n",
    "                           'Classification': [ModelClassification[Aspect] for Aspect in ['Time','Element']],\n",
    "                           'IndexLetter'   : ['t','e']}) # Unique one letter (upper or lower case) indices to be used later for calculations.\n",
    "\n",
    "# Default indexing of IndexTable, other indices are produced on the fly\n",
    "IndexTable.set_index('Aspect', inplace = True) \n",
    "\n",
    "IndexTable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now define our MFA system: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Dyn_MFA_System = msc.MFAsystem(Name = 'TestSystem', \n",
    "                      Geogr_Scope = 'TestRegion', \n",
    "                      Unit = 'Mt', \n",
    "                      ProcessList = [], \n",
    "                      FlowDict = {}, \n",
    "                      StockDict = {},\n",
    "                      ParameterDict = {}, \n",
    "                      Time_Start = Model_Time_Start, \n",
    "                      Time_End = Model_Time_End, \n",
    "                      IndexTable = IndexTable, \n",
    "                      Elements = IndexTable.loc['Element'].Classification.Items) # Initialize MFA system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This system has a name, a geographical scope, a system-wide unit, a time frame, an index table with all aspects defined, and a list of chemical elements considered.\n",
    "\n",
    "### 3) Inserting data into the MFA system\n",
    "\n",
    "It is lacking a list of processes, stocks, flows, and parameters, and these are now defined and inserted into the system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<ODYM_Classes.Process at 0x278048fb8e0>,\n",
       " <ODYM_Classes.Process at 0x278048fbbe0>,\n",
       " <ODYM_Classes.Process at 0x278048fb070>]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dyn_MFA_System.ProcessList = [] # Start with empty process list, only process numbers (IDs) and names are needed.\n",
    "Dyn_MFA_System.ProcessList.append(msc.Process(Name = 'Environment', ID   = 0))\n",
    "Dyn_MFA_System.ProcessList.append(msc.Process(Name = 'Process 1'  , ID   = 1))\n",
    "Dyn_MFA_System.ProcessList.append(msc.Process(Name = 'Process 2'  , ID   = 2))\n",
    "\n",
    "# Print list of processes:\n",
    "Dyn_MFA_System.ProcessList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ParameterDict = {}\n",
    "\n",
    "# Define parameter Inflow (D) with indices 'te' (years x element) and matching time series Values (array with size 31 x 1).\n",
    "# In a more advanced setup the parameters are defined in a data template and then read into the software.\n",
    "ParameterDict['D']  = msc.Parameter(Name = 'Inflow',        ID = 1, P_Res = 1, MetaData = None, Indices = 'te', Values= np.arange(0,31).reshape(31,1), Unit = 'Mt/yr')\n",
    "\n",
    "# Define parameter Recovery rate (alpha) with indices 'te' (years x element) and matching time series Values(array with size 31 x 1).\n",
    "# In a more advanced setup the parameters are defined in a data template and then read into the software.\n",
    "ParameterDict['alpha'] = msc.Parameter(Name = 'Recovery rate', ID = 2, P_Res = 2, MetaData = None, Indices = 'te', Values= np.arange(2,33).reshape(31,1)/34, Unit = '1')\n",
    "\n",
    "# Assign parameter dictionary to MFA system:\n",
    "Dyn_MFA_System.ParameterDict = ParameterDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the four flows a,b,c,d of the system, and initialise their values:\n",
    "Dyn_MFA_System.FlowDict['a'] = msc.Flow(Name = 'Input'              , P_Start = 0, P_End = 1, Indices = 't,e', Values=None)\n",
    "Dyn_MFA_System.FlowDict['b'] = msc.Flow(Name = 'Consumption'        , P_Start = 1, P_End = 2, Indices = 't,e', Values=None)\n",
    "Dyn_MFA_System.FlowDict['c'] = msc.Flow(Name = 'Output'             , P_Start = 2, P_End = 0, Indices = 't,e', Values=None)\n",
    "Dyn_MFA_System.FlowDict['d'] = msc.Flow(Name = 'Recovered material' , P_Start = 2, P_End = 1, Indices = 't,e', Values=None)\n",
    "\n",
    "# Assign empty arrays to flows according to dimensions.\n",
    "Dyn_MFA_System.Initialize_FlowValues() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, True)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check whether flow value arrays match their indices, etc. See method documentation.\n",
    "Dyn_MFA_System.Consistency_Check() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4) Programming a solution of the MFA system\n",
    "Now the system definition is complete, and we can program the model solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "Dyn_MFA_System.FlowDict['a'].Values = Dyn_MFA_System.ParameterDict['D'].Values\n",
    "Dyn_MFA_System.FlowDict['b'].Values = 1 / (1 - Dyn_MFA_System.ParameterDict['alpha'].Values) * \\\n",
    "    Dyn_MFA_System.ParameterDict['D'].Values\n",
    "Dyn_MFA_System.FlowDict['c'].Values = Dyn_MFA_System.ParameterDict['D'].Values\n",
    "Dyn_MFA_System.FlowDict['d'].Values = Dyn_MFA_System.ParameterDict['alpha'].Values / \\\n",
    "    (1 - Dyn_MFA_System.ParameterDict['alpha'].Values) * Dyn_MFA_System.ParameterDict['D'].Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5) Mass-balance-check, analyse, and store the model solution\n",
    "One major advantage of the ODYM system structure is that mass balance checks can be performed automatically using unit-tested routines without further programming need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(31, 3, 1)\n",
      "1.0044742815296104e-13\n"
     ]
    }
   ],
   "source": [
    "Bal = Dyn_MFA_System.MassBalance()\n",
    "print(Bal.shape) # dimensions of balance are: time step x process x chemical element\n",
    "print(np.abs(Bal).sum()) # reports the sum of all absolute balancing errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ODYM mass balance array reports the balance for each chemical element, each year, and each process, including the system balance (process 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Flow a in Mt/yr')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.set_loglevel(\"info\") \n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(Dyn_MFA_System.IndexTable['Classification']['Time'].Items, Dyn_MFA_System.FlowDict['a'].Values)\n",
    "ax.set_ylabel('Flow a in Mt/yr', fontsize =16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Flow b in Mt/yr')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmRklEQVR4nO3deXxc1Xn/8c+jffUiWfIqecELmB0cQwLBGEogCSk0BALNQgItpSHN8kvSmKZJm1Ja8kubhJSQ1K+ExEmhhiz8cMhCwLExEAg2hM3Gu+RVWItlSxrt0vP7417hwZbGY1uzSd/363Vfc+fMnZnnzrXvo3vOueeYuyMiIjKUrFQHICIi6U2JQkREYlKiEBGRmJQoREQkJiUKERGJKSfVAQy3CRMm+IwZM1IdhohIRnnhhRca3b1isNdGXKKYMWMG69atS3UYIiIZxcx2DPWaqp5ERCQmJQoREYlJiUJERGJSohARkZiUKEREJCYlChERiUmJQkREYlKiEBEZAe57uoZfv1qXkM9WohARGQGWrtnOE6/vS8hnJz1RmFmtmb1qZi+Z2bqwrMzMHjezLeHj+KjtbzezrWa2ycwuT3a8IiLprqO7jzdaOplZXpyQz0/VFcVidz/L3ReEz5cAK919DrAyfI6ZzQeuB04FrgDuNbPsVAQsIpKuapsiAMyYMLISxeGuApaF68uAq6PKl7t7l7vXAFuBhckPT0QkfdU2Boli5ghKFA78zsxeMLNbwrKJ7l4HED5WhuVTgV1R790dlr2Fmd1iZuvMbF1DQ0MCQxcRST81Cb6iSMXosRe4+14zqwQeN7ONMba1Qcr8iAL3pcBSgAULFhzxuojISFbbGGFCST4l+Yk5pSf9isLd94aP9cDDBFVJ+8xsMkD4WB9uvhuoinr7NGBv8qIVEUl/tY3tzJxQlLDPT2qiMLNiMysdWAfeBbwGrABuDDe7EXgkXF8BXG9m+WY2E5gDPJ/MmEVE0l1NU4QZCerxBMmvepoIPGxmA9/9gLv/1szWAg+Z2c3ATuBaAHdfb2YPARuAXuA2d+9LcswiImkr0tVLQ2tXwtonIMmJwt23A2cOUt4EXDrEe+4E7kxwaCIiGWmga2yiejxB+nSPFRGR41Db2A6Q0KonJQoRkQw2cEUxvXyENGaLiMjwqmmMUFmaT3GCusaCEoWISEarbYwktCEblChERDJabVMkYYMBDlCiEBHJUK2dPTS2deuKQkREBjfQ4ymRd2WDEoWISMZK9GCAA5QoREQy1MDw4tPLlChERGQQtY0RJo8toDAvsfO5KVGIiGSoRA8GOECJQkQkQyXjHgpQohARyUgH23tobu9JeI8nUKIQEclIb/Z4UtWTiIgMZqDHUyKHFx+gRCEikoFqGiOYQVWZqp5ERGQQtU0RpowtpCA3sV1jQYlCRCQj1TZGklLtBEoUIiIZx92paYwwIwk9nkCJQkQk4zS399DS2ZuUHk+gRCEiknFqktjjCZQoREQyzkDX2GTclQ1KFCIiGWdHU4Qsg6rxaqMQEZFB1DS1M218EXk5yTmFK1GIiGSYZA0GOECJQkQkg7h7cA9FeXKqnUCJQkQkozRFumnt6mV6krrGghKFiEhGSeZggAOUKEREMkhNkrvGghKFiEhGqW2KkJ1lTBtfmLTvTEmiMLNsM/uTmT0aPi8zs8fNbEv4OD5q29vNbKuZbTKzy1MRr4hIuqhtbKdqfCG52ck7fR/1m8wsz8weNrOLhvF7Pw28HvV8CbDS3ecAK8PnmNl84HrgVOAK4F4zS/yYuiIiaaomyV1jIY5E4e7dwJ/Fs208zGwa8F7g+1HFVwHLwvVlwNVR5cvdvcvda4CtwMLhiENEJNO4O7VNkaQNBjgg3pP/M8D5w/Sd3wL+HuiPKpvo7nUA4WNlWD4V2BW13e6w7C3M7BYzW2dm6xoaGoYpTBGR9NLQ2kV7d19SezxB/Inic8DNZvZJM5sWtjFkRS/xfIiZXQnUu/sLcX6vDVLmRxS4L3X3Be6+oKKiIs6PFhHJLKno8QSQE+d2r4aPd4fL4TzOz7oA+HMzew9QAIwxs/8B9pnZZHevM7PJQH24/W6gKur904C9ccYsIjKi1DaF91Akueop3kTxLwzyl/yxcvfbgdsBzOxi4PPu/mEz+zpwI3BX+PhI+JYVwANm9g1gCjAHeP5E4xARyUQ1je3kZhtTxhUk9XvjShTu/s8JjuMu4CEzuxnYCVwbfu96M3sI2AD0Are5e1+CYxERSUu1jRGqyorISWLXWIgzUZjZZe7++HB+sbuvBlaH603ApUNsdydw53B+t4hIJqptiiS92gnib8x+LLzp7QtmptZiEZEk6+8Pu8YmuSEb4k8UlwBrgTuAXWb2gJktSlxYIiISbV9rJ509/embKNx9tbvfQHAPw5eBBcAqM3vdzD4dPeSGiIgMv4Guselc9QQEbQnu/nV3nwtcBjQC3wD2mNmPzOz0RAQpIjLa1Ta2AzBjQvImLBpwXE3n4X0QnyK4W7se+DGwCHjRzP52+MITEREIGrLzcrKYMjZ5o8YOiDtRmNkkM/uSmdUAjwLjgA8DVe5+KzAb+G/gK4kIVERkNKtpjDC9rIisrMEGrEiseLvH/hy4EugE/ge4193XR2/j7n1m9gDwiWGPUkRklKtNwaixA+K9M3sO8BngJ+7eFmO7V4HFJxqUiIgc0t/v7NjfzuKTK4++cQIMmSjM7AbgV+7e4u5nxPNh7t4KPDlcwYmICNS1dNLd25/04cUHxGqj+C5Qb2aPmdmtZjYlWUGJiMghtW+OGpv8Hk8QO1FUAH8B1BDcO7HLzP4YTk16SlKiExGRQ/dQpKiNYshE4e497v4bd7/V3acCFwKrgI8Cr4VzWH/NzIZrQiMRERlEbWOEgtwsJpYmd9TYAXF3j3X3Z919ibufQjCH9Y8I7p14xszqzOx7CYpRRGRUq22KML2sOCVdY+E4b7hz943u/u/ufj7BsB5fBaYPa2QiIgIEVU+pap+AOBOFmf3ezE4e4uUxwHXu/u7hC0tERAD6+p1d+ztSdg8FxH9FcTFBQhhMKUEVlIiIDLO9Bzro7utPyWCAA46l6mmoqVBPAmLdhCciIsep5s2usalLFLFuuPs48PHwqQNLzaz1sM0KgdOAlYkJT0RkdKttSm3XWIh9RdEP9IWLHfZ8YGkiuDHv5sSGKSIyOtU0RijKy6ayND9lMQx5ReHuy4BlAGa2Cvhbd9+YrMBERCS4h2J6eTFmqekaC3EOCujuGuhPRCQFapvaOWVyaUpjiNVGccmxfJC7//7EwxERkQHt3b3s2t/Oe0+fnNI4Yl1RPMGhnk5DXfN4+JoD2cMYl4jIqPeHrU309jvvOKk8pXEcreqpFfh5uEQSH46IiAxYtame4rxsFswoS2kcsRLFYoIBAK8BrgUeBpapiklEJPHcndWbGrhwzgTyco5rtKVhE2v02Cfd/WZgEnArUAk8ZmY7zezfNdS4iEjibKlvY8+BDhbPS82sdtGOmqbcvdPdHwjHcqoG7gbeQzDU+D2JDlBEZDRatbEegIszIVEcpgmoDRcHxg9zPCIiQtA+cfKkUiaNTc0cFNHiHT32gnC+iTqCm/DagPcCH0lgbCIio1JLZw/raptZfHLqryYgRqIws9lm9lUz2wasAeYBnwcmufuH3P0xd+8/li8zswIze97MXjaz9Wb21bC8zMweN7Mt4eP4qPfcbmZbwxn1Lj++3RQRyRzPbGmkt9/Ton0CYvd62gy0AL8A/grYEZZXmtkR0bv79ji+rwu4xN3bzCwXeNrMfgO8H1jp7neZ2RJgCfBFM5sPXE8wo94U4Akzm+vufXHun4hIxlm9qYHSghzOqR6X6lCAo99HMQb4GHBjHJ911Bvu3N05NCR5brg4cBXBnBcQVG2tBr4Yli939y6gxsy2AguBZ+OIR0Qk47g7qzbVc9HcCnKyU9stdkCsRPHxGK8dNzPLBl4AZgPfcfc/mtlEd68DcPe6qCuWqcBzUW/fHZaJiIxIG+paqG/tSptqJzj66LHDLqw2OsvMxgEPm9lpMTYfbOiQIyZQMrNbgFsAqqurhyNMEZGUWL2pAYBFcytSHMkhKbuucfcDBFVMVwD7zGwyQPhYH262G6iKets0YO8gn7XU3Re4+4KKivT5cUVEjtWqjfWcMW0sFSmcf+JwSU0UZlYRXklgZoXAnwEbgRUcage5EXgkXF8BXG9m+WY2E5gDPJ/MmEVEkuVAezcv7mxOi5vsosU1H8UwmgwsC9spsoCH3P1RM3sWeMjMbgZ2EowthbuvN7OHgA1AL3CbejyJyEi1Zksj/Q6L56VXzUhSE4W7vwKcPUh5E3DpEO+5E7gzwaGJiKTc6o31jC/K5Yxp41IdylukR98rEZFRrr/fWb25gUVzK8jOSt20p4NRohARSQOv7DnI/kh32gzbES3uqiczG0Mwamw1cPgoVe7udwxnYCIio8nqTfWYwUVz0qt9AuJMFGZ2AfBLYNwQmzigRCEicpxWbWrg7KpxjC/OS3UoR4i36ulbBEOLvw0ocPeswxbNly0icpwa27p4ZfeBtLobO1q8VU+nANe5+wuJDEZEZDRas7kBd9KyfQLiv6LYCaTPbYIiIiPIqk0NVJTmM3/ymFSHMqh4E8VXgSVhg7aIiAyT3r5+1mxu4OK5FWSlWbfYAfFWPV0JTCQY6vtZYP9hr7u7xzMUuYiIRHlp1wEOdvSk3bAd0eJNFBcS9GxqIZhE6HBHjOgqIiJHt2pTPdlZxoVzJqQ6lCHFlSjcfWaiAxERGY1WbWzg3OnjGVuYm+pQhqQ7s0VEUmRfSycb6lrStlvsgCGvKMysGqhz955wPSZ33zmskYmIjHBPhpMULT45/e7Gjhar6qkGeDvB/A+1HL0dQjfdiYgcg1Wb6pk8toB5E0tTHUpMsRLFTcC2qHU1WIuIDJOevn6e2tLI+86cgll6dosdENec2e7+o6REIyIySqyrbaatqzftJikajBqzRURSYPWmenKzjQtmp2+32AFKFCIiKbBqUz3nzSynOD/ZM1IfOyUKEZEk29bQxuZ9bVycAdVOoEQhIpJ031u9jfycLK46a2qqQ4mLEoWISBLtbm7n4T/t4YaF1VSUZsag3MeVKMwsM66XRETSzH8/uR0zuOWiWakOJW5xJwozW2RmT5pZB/CGmXWY2WozuyiB8YmIjBj1LZ08uG4X15wzjSnjClMdTtziShRmdi3we6AS+DrwKeA/CIYe/72ZfSBhEYqIjBDff7qG3r5+bl10UqpDOSbx9sv6F+BXwNXu3j9QaGb/BKwA7gB+NvzhiYiMDM2Rbv7nuR2878wpzJhQnOpwjkm8VU8zge9GJwmA8Pm9wIxhjktEZET54R9qae/u47bFs1MdyjGLN1FsAYZqwK4Atg5POCIiI09rZw8/eqaGy0+dyNw0HwBwMPEmii8BXzWzt0UXmtl5wD8Dtw9zXCIiI8ZPnttBS2cvn1w8J9WhHJdY81GsOayoAHjOzHYB+wgasquAeuALwKOJClJEJFN1dPfxg6dquGhuBadPG5vqcI5LrMbsft46tPjGcBlQEy4iIjKE5Wt30hTp5u8uyby2iQGxhhm/eLi/zMyqgB8DkwgS0VJ3v9vMyoAHCRrFa4Hr3L05fM/twM1AH/Apd39suOMSEUmErt4+lq7ZzsKZZbxtRlmqwzluyR7Coxf4nLufApwP3GZm84ElwEp3nwOsDJ8TvnY9cCpwBXCvmWkmPRHJCL94cQ91Bzv5ZAb2dIqW1ETh7nXu/mK43gq8DkwFrgIGJkpaBlwdrl8FLHf3LnevIehdtTCZMYuIHI/evn6+u3obZ0wbyzvnpP+cE7GkbFBAM5sBnA38EZjo7nUQJBOCO8AhSCK7ot62Oyw7/LNuMbN1ZrauoaEhoXGLiMTj0Vfq2Lm/ndsWz077qU6PJiWJwsxKgJ8Dn3H3llibDlJ2xNzd7r7U3Re4+4KKCo1XKCKp1d/vfGfVVuZNLOWyUyamOpwTlvREYWa5BEnifnf/RVi8z8wmh69PJuhyC8EVRFXU26cBe5MVq4jI8fjdhn1sqW/jE4tPIisrs68mIMmJwoLrrx8Ar7v7N6JeWgHcGK7fCDwSVX69meWb2UxgDvB8suIVETlW7s49q7Ywo7yIK8+YkupwhkVcgwKa2XMEo8euBp5y947j/L4LgI8Ar5rZS2HZPwB3AQ+Z2c3ATuBaAHdfb2YPARsIekzd5u59x/ndIiIJ9+TmBl7b08LXrjmd7BFwNQHxjx67jeAv/SVAt5mtBVYRJI9n3b0rng9x96cZvN0B4NIh3nMncGeccYqIpNR3Vm1lytgC/uLsaakOZdjEVfXk7h9y96nAfOD/AHXArQT3PDSb2crEhSgikhlWbaxnbW0zf7PoJPJyRs5M08e0J+6+0d3vBW4Kl98TjAF18fCHJiKSORpau/jCz15m3sRSPvi2qqO/IYPE20ZRAFwILAYuAc4FIsDTwOcJEoaIyKjU3+98/qcv09rZywN/fT4FuSNrAIl42yiaCe5feIqgR9JngLWHT2QkIjIa3fdMDU9ubuCOq0/LyPkmjibeqqc2IJ9gaPHKcMmsufxERBLgtT0H+dpvN3LZ/Il8+LzqVIeTEHFdUbh7hZmdwaGqp48DJWb2ImHvJ3f/XeLCFBFJP+3dvXxq+Z8oK87ja9eckfFDdQwl7sZsd3/F3e9296uAcoLurC3A3wO/SVB8IiJp619+uYGaxgjf/OBZlBXnpTqchIm3jWJg6I3zCa4oFgPnEVRH1RPciCciMmr8+tU6lq/dxScuPol3nJTZo8MeTby9nh4H3g4UAfuBJwmmP13l7usTF56ISPrZc6CDJT9/hTOrxvHZy+amOpyEi/eKohP4MkF7xMvufsQIriIio0Ffv/OZ5X+i3+Hb159FbvbIubFuKPE2Zr8v0YGIiGSCe36/lbW1zXzzg2cyvXx0dP6Mu40CwMyuBBYBZUATsNrdf52IwERE0s262v3cvXIzV581ZUSN5XQ08bZRlAKPAu8kGMW1iaDn0+fM7CngSndvS1iUIiIpdrCjh08vf4lp44u44+rTUh1OUsVbufZvwDkEQ4QXuvtkoBD4aFj+b4kJT0Qk9dydf3j4Vfa1dHL39WdRWpCb6pCSKt5EcQ3wj+5+/8B8EO7e5+73EzRyX5OoAEVEUu0HT9fwq1fq+Oxlczm7enyqw0m6eBNFOcHkQYPZEL4uIjLifP+p7fzrr17n3adN4tZFJ6U6nJSIN1HUAFcO8dp7wtdFREaUpWu28a+/ep33nj6Zb99w9oiZse5Yxdvr6b+B/zSzEuB+gomLJgHXA39FMJmRiMiI8d3V2/jabzdy5RmT+dYHzyJnFNwvMZR476P4pplVAJ8FPhYWG9AF3OXudycmPBGR5PvOqq18/bFN/PmZU/jGdWeO6iQBx3Afhbv/g5l9nWC8pzKCoTyec/fmRAUnIpJs/7VyC//5eHCvxH9cqyQBx3jDXZgUNFKsiIxI33piM996YgvvP2cqX//AmaO2TeJwQyYKM7voWD7I3deceDgiIsnn7nzziS18e+UWPnDuNL52zRlKElFiXVGsJpj+9Ggs3G5kTRIrIqOCu/ONxzfzX7/fynULpnHX+88gS0niLWIlisVJi0JEJAXcna8/tol7V2/jhoVV3Hn16UoSgxgyUbj7k8kMREQkmTp7+rjj0Q3c/8ed/OV51fzrVacpSQwhVhvFJcDzGuxPREaa7Q1tfPKBP7GhroVbF53E318+T0kihlj9vh4H5g88MbMsM1tjZnMSH5aISGI88tIe3vdfT1N3sIP7PraAJe8+WUniKGK1URz+yxlwIVCauHBERBKjo7uPf16xngfX7WLhjDLuvuEsJo8tTHVYGeGY7qMQEclEm/e1ctv9L7K1oY2/u2Q2n750jm6kOwZKFCIyYrk7P123m6+seI2S/Fx+ctN5XDhnQqrDyjhHSxRTzWxWuJ4dVXbg8A3dffvRvszM7iMYhbbe3U8Ly8qAB4EZQC1w3cCwIGZ2O3Az0Ad8yt0fO9p3iIgAtHX18qWHX+WRl/ZywexyvvnBs6gsLUh1WBnpaIniZ4OU/b8hto3nhrsfAfcAP44qWwKsdPe7zGxJ+PyLZjafYHTaU4EpwBNmNndg4iQRkaG8svsAn17+EjuaInz+XXP524tn607rExArUXx8uL/M3deY2YzDiq8CLg7XlxHcEf7FsHy5u3cBNWa2FVgIPDvccYnIyNDY1sV//m4Ty9fuorI0n//96/M5b5bmVTtRsW64W5akGCa6e134nXVmVhmWTwWei9pud1h2BDO7BbgFoLq6OoGhikg66u7tZ9kfavn2yi109PRx0wUz+dSlcxhbOLrmtk6UdG7MHuw6cdCxp9x9KbAUYMGCBfGMTyUiI4C7s2pTPXc8+jo1jREWz6vgS++dz+zKklSHNqKkQ6LYZ2aTw6uJyUB9WL4bqIrabhqwN+nRiUha2lrfyh2Pvs6TmxuYVVHMDz/2NhafXHn0N8oxS4dEsQK4EbgrfHwkqvwBM/sGQWP2HOD5lEQoImnjYHsP31q5mR8/u4OivGy+fOV8Pvr26eTqvoiESWqiMLP/JWi4nmBmu4F/IkgQD5nZzcBO4FoAd19vZg8BG4Be4Db1eBIZvTq6+3hw7U7uXrmFgx09XL+wms9dNpfykvxUhzbiJTVRuPsNQ7x06RDb3wncmbiIRCTdNUe6+clzO/jRH2rZH+nm/FllfOXKU5k/ZUyqQxs10qHqSUTkCLub2/n+UzU8uHYXHT19XHJyJX9z0SwWzizDTPdEJJMShYiklQ17W1i6Zhu/fKUOA646ayq3XDSLeZM0HmmqKFGISMq5O89ua+J7a7azZnMDxXnZfPwdM7jpwplMGacRXlNNiUJEUuZgew8rXt7Dg+t28dqeFiaU5PGFy+fx4fOmM7ZIN8ulCyUKEUmqvn7n6a2N/HTdLn63YR/dvf2cPKmUO//iNK45ZxoFufEMGyfJpEQhIkmxvaGNn72wm1+8uIc3WjoZV5TLDW+r4toFVZw6ZYwaqNOYEoWIJExbVy+/emUvP123m3U7mskyWDS3gq+8bz6XnlJJfo6uHjKBEoWIDKvmSDcrN9bzu/VvsGZLA509/cyqKOaLV5zM+8+ZysQxmhMi0yhRiMgJ23Ogg8fXv8Fj6/fxfO1++vqdyWMLuG5BFVefPZWzq8apaimDKVGIyDFzd7bUt/HYa2/wuw37eHXPQQDmVJZw66JZXH7qJE6fOlbJYYRQohCRuLR09vDctiae2drIk5sbqG1qB+Ds6nEseffJvGv+RGZVaHjvkUiJQkQG1d3bz592NvPM1kae3trIy7sP0tfvFOZmc96sMv7qnbN41/yJVKrNYcRTohARAPr7g+qkp7Y08MzWRv5Ys5/27j6yDM6sGscnLj6JC2ZP4OzqceqtNMooUYiMUh3dfby8+wAv7GjmhR3NvLizmQPtPQDMqijmA+dO44LZEzh/VrmmFB3llChERok3Dnaybsf+ICnsaGb93hZ6+4OZg2dXlnDFqZM4d/p43jF7AlM1vpJEUaIQGYGaI928tvcgr+45yPo9Lby06wB7DnQAUJCbxZnTxvE3i2Zx7vTxnFM9nnFFeSmOWNKZEoVIhmtq6woSwt4WXt0dJIeBpABQVVbIWVXjuOnCmSyYPp75U8Zo2lA5JkoUIhmiu7ef7Y1tbHqjlU1vtLJ5Xysb9raw92Dnm9vMKC/irOpxfOTt0zl96lhOnTJGVwtywpQoRNJMf7+zq7n9zYSwaV+QFLY3RN5sU8jJMmZVFHPujDI+NnUMp00dy6lTxqrRWRJCiUIkRdq6etne0Ma2hja2N0TY3hBhW0MbtU0ROnv639yuqqyQeRNL+bNTJjJvUinzJpUyc0KxuqhK0ihRiCRQR3cfu5rb2dHUzo6mCNsbI2wPE0N9a9eb22UZVJUVcVJFCRfOnsCciSXMnVjKnImllOTrv6mklv4FipwAd6cp0s3O/e3sbAoSws797ezcH2FHU/tbkgHA2MJcZlUUc9HcCmZVFDNrQgknVRRTXV6kKwRJW0oUIjH09Tv1rZ3sae5gz4EOdjcHy54DHexpbmfPgY63VBMBTBpTQHV5EYvmVlBdVkR1eRHTy4upLitifFGuBsqTjKNEIaNWX7/T1NZF3cFO6g528sbBDupaOnkjfF53sIO6A51vNiAPKCvOY+q4QuZUlnLxvEqmjitkenkR08uLmDa+SFN5yoijRCEjjrvT3N5DfWsn9S1d7GvppL61i4bWYH1fmAzqW7uOSAJ52VlMGlvApLEFnF01nvedUcjU8YVMHVfItPGFTBlXSFGe/tvI6KJ/8ZIR3J22rl4a27ppbOuisbWLxrbg5N8QljW0Hlq6+/qP+IzSghwqS/OZOKaA808qZ/LYAiaNLWTymCAxTB5bQFlxnqqGRA6jRCEp4e5EuvvY39ZNU6SL/ZFumiLd7A+XprZu9oflA8mhq/fIk78ZlBXlMaEknwmlecyaUEbFmHwmlhZQOSZICpWl+VSWFlCYpyohkeOhRCEnrLevn5bOXg529HCgvZsD7T3sj3TTPLDe3s2B9m6aIz00t3eHSw/dg5z4AfJzsigvzqOsJI+y4nxOqihhQmk+E0rChDCwlOZRVpRHjoajEEkoJQoBoKevn9bOXlo6ejjY0UNLZw8tHb1vrh8Myw+2B48HOoIkcLCjh9bO3iE/N8tgfFEe44pyGV+UR1VZEWdMG8v4ojzGF+dRXpxHeZgQyovzKCvOoygvW9U/ImlEiWIE6OnrJ9LVS2tnL21dwdLaGZzAW8KTf2vnobLWzh5aop63dPQQ6e6L+R3ZWca4wlzGFuUyrjCXipJ85lSWMrYwl3FFuYc9Bn/pjy/Ko7Qgh6wsnfRFMllGJAozuwK4G8gGvu/ud6U4pBPi7nT1Bif39u4+It29RLp6aevqCx7DE36kq5e28LVIV9+hsjApBImh54h+/IPJzTZKC3IpLcgJlvxcZk4oprQglzEFwQl+TGFO1HrwfGxh8Lr+yhcZvdI+UZhZNvAd4DJgN7DWzFa4+4ZEf3d/v9PR0xcs3X20dwfr7d29dHT3Eenuo6M7OIl39PS9eeLvCE/+A4/t3cFJvr3r0PO+w7plDiUvJ4uS/ByK87MpzsuhJD+H8uI8ppcXU5IfnPRL8sOlIIfS8DF4LZcxBcFjQW6WTvQiclzSPlEAC4Gt7r4dwMyWA1cBw5ooNuxt4VPL/0RHVDKI5y/1aNlZRlFecEIvysumMC+b4vDEXl1WFJSHJ/yi/GxK8nMoysuhOC+bovxDJ/zi8LXi/BzNGyAiKZcJiWIqsCvq+W7gvOgNzOwW4BaA6urq4/qSkvwc5k4soTD30Em+MDf7sPUcCvOy3tymOD+bwvBEX5iXTV62/moXkZEnExLFYGfet9TbuPtSYCnAggUL4qvTOUx1eRH3fujc43mriMiIlgn1GruBqqjn04C9KYpFRGTUyYREsRaYY2YzzSwPuB5YkeKYRERGjbSvenL3XjP7JPAYQffY+9x9fYrDEhEZNdI+UQC4+6+BX6c6DhGR0SgTqp5ERCSFlChERCQmJQoREYlJiUJERGIy9+O6Py1tmVkDsOMEPmIC0DhM4aTSSNkP0L6ko5GyH6B9GTDd3SsGe2HEJYoTZWbr3H1BquM4USNlP0D7ko5Gyn6A9iUeqnoSEZGYlChERCQmJYojLU11AMNkpOwHaF/S0UjZD9C+HJXaKEREJCZdUYiISExKFCIiEtOITxRmdp+Z1ZvZa1FlZ5rZs2b2qpn90szGhOW5ZrYsLH/dzG6Pes+5YflWM/u2pWAqu2Hcl9VmtsnMXgqXyjTejzwz+2FY/rKZXRz1nkw7JrH2JdXHpMrMVoX/Vtab2afD8jIze9zMtoSP46Pec3v4228ys8ujylN6XIZ5XzLquJhZebh9m5ndc9hnHf9xcfcRvQAXAecAr0WVrQUWhes3AXeE638JLA/Xi4BaYEb4/Hng7QQz7v0GeHcG78tqYEGGHJPbgB+G65XAC0BWhh6TWPuS6mMyGTgnXC8FNgPzgf8LLAnLlwBfC9fnAy8D+cBMYBuQnQ7HZZj3JdOOSzFwIXArcM9hn3Xcx2XEX1G4+xpg/2HF84A14frjwDUDmwPFZpYDFALdQIuZTQbGuPuzHvziPwauTnTshxuOfUlGnEdzjPsxH1gZvq8eOAAsyNBjMui+JD7Ko3P3Ond/MVxvBV4nmK/+KmBZuNkyDv3GVxH8IdLl7jXAVmBhOhyX4dqXZMY8lGPdF3ePuPvTQGf055zocRnxiWIIrwF/Hq5fy6GpVn8GRIA6YCfwH+6+n+DA7I56/+6wLB0c674M+GF4Kf3lVFTZDGKo/XgZuMrMcsxsJnBu+FomHpOh9mVAWhwTM5sBnA38EZjo7nUQnLQIroQg+K13Rb1t4PdPq+NygvsyIJOOy1BO6LiM1kRxE3Cbmb1AcDnXHZYvBPqAKQSXoJ8zs1kEl2qHS5d+xce6LwAfcvfTgXeGy0eSG/KghtqP+wj+Ua8DvgX8AeglM4/JUPsCaXJMzKwE+DnwGXePdQU61O+fNsdlGPYFMu+4DPkRg5TFfVwyYoa74ebuG4F3AZjZXOC94Ut/CfzW3XuAejN7hqBq4ClgWtRHTAP2Ji/ioR3Hvmx39z3he1vN7AGCpPLjpAcfZaj9cPde4LMD25nZH4AtQDMZdkxi7AvpcEzMLJfgZHS/u/8iLN5nZpPdvS6svqgPy3fz1quhgd9/N2lwXIZpXzLxuAzlhI7LqLyiGOi5YGZZwD8C3wtf2glcYoFi4HxgY3hp12pm54eXnh8FHklB6Ec41n0Jqz0mhO/JBa4kqCpJqaH2w8yKwvgxs8uAXnffkInHZKh9SYdjEv6GPwBed/dvRL20ArgxXL+RQ7/xCuB6M8sPq9HmAM+nw3EZrn3J0OMyqBM+LqlqzU/WAvwvQT19D0FWvRn4NEHvgc3AXRy6Q70E+CmwHtgAfCHqcxYQ/CPZBtwz8J5M2xeCXhEvAK+Er91N2MMjTfdjBrCJoBHvCYKhkDP1mAy6L2lyTC4kqIp4BXgpXN4DlBM0wG8JH8ui3vOl8LffRFQPmlQfl+Halww+LrUEHSzawn+T80/0uGgIDxERiWlUVj2JiEj8lChERCQmJQoREYlJiUJERGJSohARkZiUKEREJCYlChERien/A1I1Xp8xayUQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.set_loglevel(\"info\") \n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(Dyn_MFA_System.IndexTable['Classification']['Time'].Items, Dyn_MFA_System.FlowDict['b'].Values)\n",
    "ax.set_ylabel('Flow b in Mt/yr', fontsize =16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save entire system: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump({'MFATestSystem': Dyn_MFA_System}, open(\"Tutorial1_MFATestSystem.p\", \"wb\") )"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}