docs/ODYM Example and Tutorial No. 4. ODYM_Database.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ODYM Example no. 4.  ODYM classification and database\n",
    "\n",
    "This tutorial shows how to use the ODYM data structure, including the classification file, the configuration file, and formatted parameter datasets.\n",
    "\n",
    "### 1) Load ODYM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load a local copy of the current ODYM branch:\n",
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import openpyxl\n",
    "import pylab\n",
    "from copy import deepcopy\n",
    "import logging as log\n",
    "\n",
    "# For Ipython Notebook only\n",
    "%matplotlib inline\n",
    "\n",
    "# add ODYM module directory to system path, relative\n",
    "MainPath = os.path.join('..', 'odym', 'modules')\n",
    "sys.path.insert(0, MainPath)\n",
    "\n",
    "# add ODYM module directory to system path, absolute\n",
    "sys.path.insert(0, os.path.join(os.getcwd(),'..', 'odym', 'modules'))\n",
    "\n",
    "# Specify path to dynamic stock model and to datafile, relative\n",
    "DataPath = os.path.join('..', 'docs', 'files')\n",
    "\n",
    "# Specify path to dynamic stock model and to datafile, absolute\n",
    "DataPath = os.path.join(os.getcwd(),'..', 'docs', 'files')\n",
    "\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\n",
    "\n",
    "# Initialize loggin routine\n",
    "log_verbosity = eval(\"log.DEBUG\")\n",
    "log_filename = 'LogFileTest.md'\n",
    "[Mylog, console_log, file_log] = msf.function_logger(log_filename, os.getcwd(),\n",
    "                                                     log_verbosity, log_verbosity)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Load Config file and read model control parameters\n",
    "__Note__ The functionalities below are shown so that one can see how the model works. For practical applications of ODYM, they have been built into the ODYM functions\n",
    "\n",
    "msf.ParseModelControl, msf.ParseConfigFile, and msf.ParseClassificationFile_Main'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ODYM_Tutorial\n",
      "{'Model Setting': 'Tutorial', 'Name of model setting': 'ODYM_Tutorial', 'Description': 'A tutorial on the classification, configuration, and data formats of ODYM', 'Name of model script used': 'ODYM_Tutorial_1', 'Version of master classification': 'ODYM_Classifications_Master_Tutorial', 'Version of ODYM Classes': 'V01', 'Version of ODYM Functions': 'V01'}\n"
     ]
    }
   ],
   "source": [
    "#Read main script parameters\n",
    "#Load project-specific config file\n",
    "ProjectSpecs_Name_ConFile = 'ODYM_Config_Tutorial.xlsx'\n",
    "Model_Configfile = openpyxl.load_workbook(os.path.join(DataPath, ProjectSpecs_Name_ConFile), data_only=True)\n",
    "ScriptConfig = {'Model Setting': Model_Configfile['Config'].cell(4,4).value}\n",
    "Model_Configsheet = Model_Configfile['Setting_' + ScriptConfig['Model Setting']]\n",
    "\n",
    "Name_Scenario            = Model_Configsheet.cell(4,4).value\n",
    "print(Name_Scenario)\n",
    "\n",
    "### 1.2) Read model control parameters\n",
    "#Read control and selection parameters into dictionary\n",
    "SCix = 0\n",
    "# search for script config list entry\n",
    "while Model_Configsheet.cell(SCix+1, 2).value != 'General Info':\n",
    "    SCix += 1\n",
    "\n",
    "\n",
    "SCix += 2  # start on first data row\n",
    "while Model_Configsheet.cell(SCix+1, 4).value is not None:\n",
    "    ScriptConfig[Model_Configsheet.cell(SCix+1, 3).value] = Model_Configsheet.cell(SCix+1,4).value\n",
    "    SCix += 1\n",
    "\n",
    "SCix = 0\n",
    "# search for script config list entry\n",
    "while Model_Configsheet.cell(SCix+1, 2).value != 'Software version selection':\n",
    "    SCix += 1\n",
    "        \n",
    "SCix += 2 # start on first data row\n",
    "while Model_Configsheet.cell(SCix+1, 4).value is not None:\n",
    "    ScriptConfig[Model_Configsheet.cell(SCix+1, 3).value] = Model_Configsheet.cell(SCix+1,4).value\n",
    "    SCix += 1 \n",
    "\n",
    "print(ScriptConfig)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Read classification and data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of file or formatting error while reading the classification file in column 11.\n",
      "Read index table from model config sheet.\n",
      "Read parameter list from model config sheet.\n",
      "Read process list from model config sheet.\n",
      "Read model run control from model config sheet.\n"
     ]
    }
   ],
   "source": [
    "# Read model run config data\n",
    "Classfile  = openpyxl.load_workbook(os.path.join(DataPath, \n",
    "                                             str(ScriptConfig['Version of master classification']) \\\n",
    "                                             + '.xlsx'), data_only=True)\n",
    "Classsheet = Classfile['MAIN_Table']\n",
    "ci = 1 # column index to start with\n",
    "MasterClassification = {} # Dict of master classifications\n",
    "while True:\n",
    "    TheseItems = []\n",
    "    ri = 10 # row index to start with    \n",
    "    if Classsheet.cell(1,ci+1).value is not None: \n",
    "        ThisName = Classsheet.cell(1,ci+1).value\n",
    "        ThisDim  = Classsheet.cell(2,ci+1).value\n",
    "        ThisID   = Classsheet.cell(4,ci+1).value\n",
    "        ThisUUID = Classsheet.cell(5,ci+1).value\n",
    "        TheseItems.append(Classsheet.cell(ri+1,ci+1).value) # read the first classification item\n",
    "    else:\n",
    "        print('End of file or formatting error while reading the classification file in column '+ str(ci) +'.')\n",
    "        break\n",
    "    while True:\n",
    "        ri +=1\n",
    "        if Classsheet.cell(ri+1,ci+1).value is not None:\n",
    "            ThisItem = Classsheet.cell(ri+1,ci+1).value\n",
    "        else:\n",
    "            break\n",
    "        if ThisItem is not None:\n",
    "            TheseItems.append(ThisItem)\n",
    "    MasterClassification[ThisName] = msc.Classification(Name = ThisName, Dimension = ThisDim, \n",
    "                                                        ID = ThisID, UUID = ThisUUID, Items = TheseItems)\n",
    "    ci +=1 \n",
    "    \n",
    "print('Read index table from model config sheet.')\n",
    "ITix = 0\n",
    "while True: # search for index table entry\n",
    "    if Model_Configsheet.cell(ITix+1,2).value == 'Index Table':\n",
    "        break\n",
    "    else:\n",
    "        ITix += 1\n",
    "        \n",
    "IT_Aspects        = []\n",
    "IT_Description    = []\n",
    "IT_Dimension      = []\n",
    "IT_Classification = []\n",
    "IT_Selector       = []\n",
    "IT_IndexLetter    = []\n",
    "ITix += 2 # start on first data row\n",
    "while True:\n",
    "    if Model_Configsheet.cell(ITix+1,3).value is not None:\n",
    "        IT_Aspects.append(Model_Configsheet.cell(ITix+1,3).value)\n",
    "        IT_Description.append(Model_Configsheet.cell(ITix+1,4).value)\n",
    "        IT_Dimension.append(Model_Configsheet.cell(ITix+1,5).value)\n",
    "        IT_Classification.append(Model_Configsheet.cell(ITix+1,6).value)\n",
    "        IT_Selector.append(Model_Configsheet.cell(ITix+1,7).value)\n",
    "        IT_IndexLetter.append(Model_Configsheet.cell(ITix+1,8).value)        \n",
    "        ITix += 1\n",
    "    else:\n",
    "        break\n",
    "\n",
    "print('Read parameter list from model config sheet.')\n",
    "PLix = 0\n",
    "while True: # search for parameter list entry\n",
    "    if Model_Configsheet.cell(PLix+1,2).value == 'Model Parameters':\n",
    "        break\n",
    "    else:\n",
    "        PLix += 1\n",
    "        \n",
    "PL_Names          = []\n",
    "PL_Description    = []\n",
    "PL_Version        = []\n",
    "PL_IndexStructure = []\n",
    "PL_IndexMatch     = []\n",
    "PL_IndexLayer     = []\n",
    "PLix += 2 # start on first data row\n",
    "\n",
    "while True:\n",
    "    if Model_Configsheet.cell(PLix+1,3).value is not None:\n",
    "        PL_Names.append(Model_Configsheet.cell(PLix+1,3).value)\n",
    "        PL_Description.append(Model_Configsheet.cell(PLix+1,4).value)\n",
    "        PL_Version.append(Model_Configsheet.cell(PLix+1,5).value)\n",
    "        PL_IndexStructure.append(Model_Configsheet.cell(PLix+1,6).value)\n",
    "        PL_IndexMatch.append(Model_Configsheet.cell(PLix+1,7).value)\n",
    "        # strip numbers out of list string\n",
    "        PL_IndexLayer.append(msf.ListStringToListNumbers(Model_Configsheet.cell(PLix+1,8).value)) \n",
    "        PLix += 1\n",
    "    else:\n",
    "        break\n",
    " \n",
    "print('Read process list from model config sheet.')\n",
    "PrLix = 0\n",
    "while True: # search for process list entry\n",
    "    if Model_Configsheet.cell(PrLix+1,2).value == 'Process Group List':\n",
    "        break\n",
    "    else:\n",
    "        PrLix += 1\n",
    "        \n",
    "PrL_Number         = []\n",
    "PrL_Name           = []\n",
    "PrL_Code           = []\n",
    "PrL_Type           = []\n",
    "PrLix += 2 # start on first data row\n",
    "while True:\n",
    "    if Model_Configsheet.cell(PrLix+1,3).value is not None:\n",
    "        try:\n",
    "            PrL_Number.append(int(Model_Configsheet.cell(PrLix+1,3).value))\n",
    "        except:\n",
    "            PrL_Number.append(Model_Configsheet.cell(PrLix+1,3).value)\n",
    "        PrL_Name.append(Model_Configsheet.cell(PrLix+1,4).value)\n",
    "        PrL_Code.append(Model_Configsheet.cell(PrLix+1,5).value)\n",
    "        PrL_Type.append(Model_Configsheet.cell(PrLix+1,6).value)\n",
    "        PrLix += 1\n",
    "    else:\n",
    "        break    \n",
    "\n",
    "print('Read model run control from model config sheet.')\n",
    "PrLix = 0\n",
    "while True: # search for model flow control entry\n",
    "    if Model_Configsheet.cell(PrLix+1,2).value == 'Model flow control':\n",
    "        break\n",
    "    else:\n",
    "        PrLix += 1\n",
    "        \n",
    "PrLix += 2 # start on first data row\n",
    "while True:\n",
    "    if Model_Configsheet.cell(PrLix+1,3).value is not None:\n",
    "        try:\n",
    "            ScriptConfig[Model_Configsheet.cell(PrLix+1,3).value] = Model_Configsheet.cell(PrLix+1,4).value\n",
    "        except:\n",
    "            None\n",
    "        PrLix += 1\n",
    "    else:\n",
    "        break  \n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Define model classifications and select items for model classifications according to information provided by config file.\n"
     ]
    }
   ],
   "source": [
    "print('Define model classifications and select items for model classifications according to information provided by config file.')\n",
    "ModelClassification  = {} # Dict of model classifications\n",
    "for m in range(0,len(IT_Aspects)):\n",
    "    ModelClassification[IT_Aspects[m]] = deepcopy(MasterClassification[IT_Classification[m]])\n",
    "    EvalString = msf.EvalItemSelectString(IT_Selector[m],len(ModelClassification[IT_Aspects[m]].Items))\n",
    "    if EvalString.find(':') > -1: # range of items is taken\n",
    "        RangeStart = int(EvalString[0:EvalString.find(':')])\n",
    "        RangeStop  = int(EvalString[EvalString.find(':')+1::])\n",
    "        ModelClassification[IT_Aspects[m]].Items = ModelClassification[IT_Aspects[m]].Items[RangeStart:RangeStop]           \n",
    "    elif EvalString.find('[') > -1: # selected items are taken\n",
    "        ModelClassification[IT_Aspects[m]].Items = \\\n",
    "            [ModelClassification[IT_Aspects[m]].Items[i] for i in eval(EvalString)]\n",
    "    elif EvalString == 'all':\n",
    "        None\n",
    "    else:\n",
    "        Mylog.info('ITEM SELECT ERROR for aspect ' + IT_Aspects[m] + ' were found in datafile.</br>')\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block creates the index table for the MFA system and parses all parameter files specified into the parameter dictionary ParameterDict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Define index table dataframe.\n",
      "Read model data and parameters.\n",
      "Reading parameter Par_ManufacturingYield\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\spauliuk.AD\\Anaconda3\\lib\\site-packages\\openpyxl\\worksheet\\header_footer.py:48: UserWarning: Cannot parse header or footer so it will be ignored\n",
      "  warn(\"\"\"Cannot parse header or footer so it will be ignored\"\"\")\n",
      "INFO (ODYM_Functions.py <ReadParameterXLSX>): A total of 800 values was read from file for parameter Par_ManufacturingYield.\n",
      "INFO (ODYM_Functions.py <ReadParameterXLSX>): 800.0 of 23698 values for parameter Par_ManufacturingYield were assigned.\n",
      "INFO (ODYM_Functions.py <ReadParameterXLSX>): A total of 32 values was read from file for parameter Par_ElementContent_Materials.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TABLE\n",
      "Reading parameter Par_ElementContent_Materials\n",
      "LIST\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO (ODYM_Functions.py <ReadParameterXLSX>): 16.0 of 123 values for parameter Par_ElementContent_Materials were assigned.\n"
     ]
    }
   ],
   "source": [
    "# Define model index table and parameter dictionary\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\n",
    "\n",
    "print('Define index table dataframe.')\n",
    "IndexTable = pd.DataFrame({'Aspect'        : IT_Aspects, # 'Time' and 'Element' must be present!\n",
    "                           'Description'   : IT_Description,\n",
    "                           'Dimension'     : IT_Dimension,\n",
    "                           'Classification': [ModelClassification[Aspect] for Aspect in IT_Aspects],\n",
    "                           # Unique one letter (upper or lower case) indices to be used later for calculations.\n",
    "                           'IndexLetter'   : IT_IndexLetter}) \n",
    "\n",
    "# Default indexing of IndexTable, other indices are produced on the fly\n",
    "IndexTable.set_index('Aspect', inplace = True) \n",
    "\n",
    "# Add indexSize to IndexTable:\n",
    "IndexTable['IndexSize'] = \\\n",
    "    pd.Series([len(IndexTable.Classification[i].Items) for i in range(0,len(IndexTable.IndexLetter))], index=IndexTable.index)\n",
    "\n",
    "# list of the classifications used for each indexletter\n",
    "IndexTable_ClassificationNames = [IndexTable.Classification[i].Name for i in range(0,len(IndexTable.IndexLetter))] \n",
    "\n",
    "#Define shortcuts for the most important index sizes:\n",
    "Nt = len(IndexTable.Classification[IndexTable.index.get_loc('Time')].Items)\n",
    "NG = len(IndexTable.Classification[IndexTable.set_index('IndexLetter').index.get_loc('g')].Items)\n",
    "print('Read model data and parameters.')\n",
    "\n",
    "ParameterDict = {}\n",
    "for mo in range(0,len(PL_Names)):\n",
    "    ParPath = os.path.join(DataPath,PL_Version[mo])\n",
    "    print('Reading parameter ' + PL_Names[mo])\n",
    "    # Do not change order of parameters handed over to function!\n",
    "    MetaData, Values = msf.ReadParameterXLSX(ParPath, PL_Names[mo], PL_IndexStructure[mo], \n",
    "                                         PL_IndexMatch[mo], PL_IndexLayer[mo],\n",
    "                                         MasterClassification, IndexTable,\n",
    "                                         IndexTable_ClassificationNames, ScriptConfig,Mylog, False) \n",
    "\n",
    "    ParameterDict[PL_Names[mo]] = msc.Parameter(Name = MetaData['Dataset_Name'], \n",
    "                                                ID = MetaData['Dataset_ID'], \n",
    "                                                UUID = MetaData['Dataset_UUID'],\n",
    "                                                P_Res = None,\n",
    "                                                MetaData = MetaData,\n",
    "                                                Indices = PL_IndexStructure[mo], \n",
    "                                                Values=Values, \n",
    "                                                Uncert=None,\n",
    "                                                Unit = MetaData['Dataset_Unit'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4) Define MFA system \n",
    "With the index table and parameter dictionary defined, we can now define the MFA system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Define MFA system and processes.\n"
     ]
    }
   ],
   "source": [
    "print('Define MFA system and processes.')\n",
    "\n",
    "Tutorial_MFA_System = msc.MFAsystem(Name = 'TestSystem_Tutorial', \n",
    "                      Geogr_Scope = 'World', \n",
    "                      Unit = 'Mt', \n",
    "                      ProcessList = [], \n",
    "                      FlowDict = {}, \n",
    "                      StockDict = {},\n",
    "                      ParameterDict = ParameterDict, \n",
    "                      Time_Start = Model_Time_Start, \n",
    "                      Time_End = Model_Time_End, \n",
    "                      IndexTable = IndexTable, \n",
    "                      Elements = IndexTable.loc['Element'].Classification.Items, \n",
    "                      Graphical = None) # Initialize MFA system\n",
    "                      \n",
    "# Check Validity of index tables:\n",
    "# returns true if dimensions are OK and time index is present and element list is not empty\n",
    "Tutorial_MFA_System.IndexTableCheck() \n",
    "\n",
    "# Add processes to system\n",
    "for m in range(0, len(PrL_Number)):\n",
    "    Tutorial_MFA_System.ProcessList.append(msc.Process(Name = PrL_Name[m], ID   = PrL_Number[m]))\n",
    "    \n",
    "# Define system variables: Flows.     \n",
    "Tutorial_MFA_System.FlowDict['F_m3_4'] = msc.Flow(Name = 'Final consumption', P_Start = 'm3',\n",
    "                                                  P_End = 4, Indices = 't,g,e',\n",
    "                                                  Values=None, Uncert=None, Color = None,\n",
    "                                                  ID = None, UUID = None)\n",
    "Tutorial_MFA_System.FlowDict['F_4_m5'] = msc.Flow(Name = 'EoL products', P_Start = 4, \n",
    "                                                  P_End = 5, Indices = 't,g,e', \n",
    "                                                  Values=None, Uncert=None, Color = None, \n",
    "                                                  ID = None, UUID = None)\n",
    "# Define system variables: Stocks.\n",
    "Tutorial_MFA_System.StockDict['S_4']  = msc.Stock(Name = 'In-use stock', P_Res = 4, Type = 1,\n",
    "                                                  Indices = 't,g,e', Values=None, Uncert=None,\n",
    "                                                  ID = None, UUID = None)\n",
    "\n",
    "Tutorial_MFA_System.Initialize_StockValues() # Assign empty arrays to stocks according to dimensions.\n",
    "Tutorial_MFA_System.Initialize_FlowValues() # Assign empty arrays to flows according to dimensions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
       "      <th>IndexSize</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aspect</th>\n",
       "      <th></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 time</td>\n",
       "      <td>Time</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>t</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Element</th>\n",
       "      <td>chemical elements</td>\n",
       "      <td>Element</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>e</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Unity</th>\n",
       "      <td>trivial classification, 1 entry only</td>\n",
       "      <td>Unity</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ManufacturingProcess</th>\n",
       "      <td>Manufacturing processes</td>\n",
       "      <td>Process</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>F</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>UsePhase</th>\n",
       "      <td>Use phase sectors</td>\n",
       "      <td>Process</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>U</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>WasteManagementIndustries</th>\n",
       "      <td>Waste management industries</td>\n",
       "      <td>Process</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>W</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Engineering materials</th>\n",
       "      <td>Engineering materials considered</td>\n",
       "      <td>Material</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>m</td>\n",
       "      <td>41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Good</th>\n",
       "      <td>Goods and products considered</td>\n",
       "      <td>Material</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>g</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Waste_Scrap</th>\n",
       "      <td>waste and scrap types considered</td>\n",
       "      <td>Material</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>w</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                    Description Dimension  \\\n",
       "Aspect                                                                      \n",
       "Time                                                 Model time      Time   \n",
       "Element                                       chemical elements   Element   \n",
       "Unity                      trivial classification, 1 entry only     Unity   \n",
       "ManufacturingProcess                    Manufacturing processes   Process   \n",
       "UsePhase                                      Use phase sectors   Process   \n",
       "WasteManagementIndustries           Waste management industries   Process   \n",
       "Engineering materials          Engineering materials considered  Material   \n",
       "Good                              Goods and products considered  Material   \n",
       "Waste_Scrap                    waste and scrap types considered  Material   \n",
       "\n",
       "                                                              Classification  \\\n",
       "Aspect                                                                         \n",
       "Time                       <ODYM_Classes.Classification object at 0x00000...   \n",
       "Element                    <ODYM_Classes.Classification object at 0x00000...   \n",
       "Unity                      <ODYM_Classes.Classification object at 0x00000...   \n",
       "ManufacturingProcess       <ODYM_Classes.Classification object at 0x00000...   \n",
       "UsePhase                   <ODYM_Classes.Classification object at 0x00000...   \n",
       "WasteManagementIndustries  <ODYM_Classes.Classification object at 0x00000...   \n",
       "Engineering materials      <ODYM_Classes.Classification object at 0x00000...   \n",
       "Good                       <ODYM_Classes.Classification object at 0x00000...   \n",
       "Waste_Scrap                <ODYM_Classes.Classification object at 0x00000...   \n",
       "\n",
       "                          IndexLetter  IndexSize  \n",
       "Aspect                                            \n",
       "Time                                t         36  \n",
       "Element                             e          3  \n",
       "Unity                               1          1  \n",
       "ManufacturingProcess                F         17  \n",
       "UsePhase                            U         13  \n",
       "WasteManagementIndustries           W         19  \n",
       "Engineering materials               m         41  \n",
       "Good                                g         13  \n",
       "Waste_Scrap                         w         34  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Tutorial_MFA_System.IndexTable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Par_ManufacturingYield': <ODYM_Classes.Parameter at 0x237678a1280>,\n",
       " 'Par_ElementContent_Materials': <ODYM_Classes.Parameter at 0x23767bf1fd0>}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Tutorial_MFA_System.ParameterDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<ODYM_Classes.Process object at 0x0000023767BEB880>, <ODYM_Classes.Process object at 0x0000023767BEBD00>, <ODYM_Classes.Process object at 0x0000023767BEB940>, <ODYM_Classes.Process object at 0x0000023767BEB7C0>, <ODYM_Classes.Process object at 0x0000023767BEB5E0>, <ODYM_Classes.Process object at 0x0000023767BEBA60>, <ODYM_Classes.Process object at 0x0000023767BEBCA0>]\n",
      "['Material production', 'Manufacturing_Construction', 'Use phase', 'Waste mgt. industries', 'Material markets', 'Product markets', 'Waste_Scrap markets']\n",
      "[2, 3, 4, 5, 'm2', 'm3', 'm5']\n"
     ]
    }
   ],
   "source": [
    "print(Tutorial_MFA_System.ProcessList)\n",
    "print([i.Name for i in Tutorial_MFA_System.ProcessList])\n",
    "print([i.ID for i in Tutorial_MFA_System.ProcessList])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 5) Building the MFA model.\n",
    "\n",
    "With the parameter loaded into the MFA system structure the system model can now be built as shown in the previous tutorials."
   ]
  }
 ],
 "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
}