Day 1 AM/2 - BW structure and first LCAs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "hidden"
   },
   "source": [
    "# Brightway2 seminar\n",
    "Chris Mutel ([PSI](https://www.psi.ch/)), Pascal Lesage ([CIRAIG](http://www.ciraig.org/en/))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Day 1, morning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Learning objectives  \n",
    "  - Learn about the general structure of Brightway and its most importand abstractions: projects, databases, activities and exchanges  \n",
    "  - Learn how to find objects (notably activities and exchanges), assign them to variables and work with them using their associated methods  \n",
    "  - Learn about how simple LCA calculations are done (one product, one impact category), and specifically how the different matrices are built and used  \n",
    "  - Learn how to extract information from the matrices (inputs or results) and translate them into nice, human-readable objects  \n",
    "  - Learn different ways to carry out comparative LCAs  \n",
    "  - Learn different ways to carry out LCAs with multiple impact categories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Content  \n",
    "\n",
    "#### 1) Getting started  \n",
    "##### 1.1) Downloading, installing and accessing Brightway2  \n",
    "  - Downloading and installing Brightway  \n",
    "  - Accessing Brightway2 libraries  \n",
    "  \n",
    "##### 1.2) Projects  \n",
    "  - Concept  \n",
    "  - Creating a new project, or switching to an existing project  \n",
    "  - Contents of a project  \n",
    "\n",
    "  \n",
    "##### 1.3) bw2_setup(), biosphere3 database and LCIA methods  \n",
    "  - bw2_setup()  \n",
    "  - biosphere3 database and a first look at database objects  \n",
    "  - Getting activities from codes or keys  \n",
    "  - Methods  \n",
    "  - Looking up elementary flows (list comprehensions, search)  \n",
    "  - Searching for methods  \n",
    "  - Nice display of data in methods \n",
    "\n",
    "##### 1.4) LCI databases  \n",
    "  - Importing (succinct)  \n",
    "  - LCI activities  \n",
    "  - Looking up activities  \n",
    "  - LCI exchanges\n",
    "  - Loaded LCI databases\n",
    "  \n",
    "#### 2) My first LCA - simplest case:  \n",
    "##### 2.1) General syntax of LCA calculations  \n",
    "\n",
    "##### 2.2) The `demand` attribute  \n",
    "\n",
    "##### 2.3) Reminder of the system that needs to be solved in calculating an LCI  \n",
    "\n",
    "##### 2.4) Building the matrices  \n",
    "\n",
    "  - $A$ matrix  \n",
    "  - $B$ matrix  \n",
    "  - $f$ (demand array)  \n",
    "  \n",
    "##### 2.5) Solution to the inventory calculation  \n",
    "\n",
    "  - Supply array  \n",
    "  - Inventory matrix  \n",
    "  \n",
    "##### 2.6) Life Cycle Impact Assessment  \n",
    "\n",
    "  - `.lcia()` method  \n",
    "  - Simple contribution analysis  \n",
    "  \n",
    "#### 3) My second LCA - comparative LCA:\n",
    "    \n",
    "#### 4) My third LCA - Multiple impact categories\n",
    "  \n",
    "#### 5) My first and third LCAs revisited with MultiLCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1) Getting started"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### 1.1) Downloading, installing and accessing Brightway2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Downloading and installing Brightway"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Please [install miniconda](https://conda.io/docs/install/quick.html).\n",
    "\n",
    "Then, in a command prompt or a terminal window (see [Brightway2 docs](https://docs.brightwaylca.org/installation.html#launching-and-using-a-command-shell) if this is something new), enter the following:\n",
    "\n",
    "conda create -n bw2 python=3.6\n",
    "Then activate the bw2 environment using something like one of the following:\n",
    "\n",
    "source activate bw2\n",
    "activate bw2\n",
    "Finally, instead the needed libraries:\n",
    "\n",
    "conda install -q -y -c haasad -c conda-forge brightway2 jupyter jupyter_contrib_nbextensions jupyter_nbextensions_configurator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Accessing Brightway2 libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The different modules in Brightway2 are Python libraries. This means that, to use them, you can use any environment from which you normally use Python (Idle, command prompt, Spyder or, as is the case today, Jupyter Notebooks).  \n",
    "\n",
    "We will favour Jupyter Notebooks in this seminar because it allows us to integrate code and text. It will also allow us to provide code snippets for you to complete.  \n",
    "\n",
    "Note that the [Brightway2 installation package](https://docs.brightwaylca.org/installation.html) installs Brightway2 in a separate [Conda environment](https://conda.io/docs/using/using.html). This isolates Brightway2 from your other Python installations. It however requires you to activate the bw2 environment. You can do this the same way you [normally activate Conda environments](https://conda.io/docs/using/envs.html#change-environments-activate-deactivate), or by executing the bw2-env.bat batch file installed in your `bw2-python` directory (located at `C:\\bw2-python`in Windows).  \n",
    "\n",
    "The `bw2-python` directory also offers two other ways to run Brightway2: via IPython (run the `bw2-ipython.bat` file) or via Jupyter Notebooks (`bw2-notebook.bat`).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "For this course, you should run `bw2-notebook.bat` and open the Notebooks (such as this one), allowing you to directly run the code and get some hands-on experience. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Like all other Python packages, you need to `import` Brightway2 modules. We will here import it as `bw`. This means that, to access a method or function from the brightway2 modules, the prefix `bw.` needs to be added. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import brightway2 as bw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We're also going to be using the following libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import os               # to use \"operating system dependent functionality\"\n",
    "import numpy as np      # \"the fundamental package for scientific computing with Python\"\n",
    "import pandas as pd     # \"high-performance, easy-to-use data structures and data analysis tools\" for Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### 1.2) Projects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Concept"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The top-level containent in Brightway2 is the project (see [here](https://docs.brightwaylca.org/intro.html#projects) for a description and [here](https://docs.brightwaylca.org/technical/bw2data.html#projects) for the docs). A project contains LCI databases, LCIA methods and other less often used objects. Objects from one project do not interract with objects within other projects. By analogy, projects are like databases in openLCA and SimePro.  \n",
    "When you first launch Brightway2, you will be in the `default` project. You can check this using the `current` property of the `projects` object: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.projects.current"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Creating a new project, or switching to an existing project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's create a new project for this seminar, unsurprisingly called \"bw2_seminar_2017\". There are two ways of doing this:  \n",
    "* `projects.create_project('bw2_seminar_2017')` will create the project, but you will remain in your current project.\n",
    "* `projects.set_current('bw2_seminar_2017')` will switch you to the project passed as argument, and create it first if it doesn't exist.  Let's do the latter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution": "hidden"
   },
   "outputs": [],
   "source": [
    "# The name of the project is entered as string; \n",
    "# it doesn't really have any restrictions, so can include spaces, \n",
    "# special characters, other languages, or even emoji.\n",
    "\n",
    "bw.projects.set_current('bw2_seminar_2017') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can always see what projects you have on your computer by running `list(bw.projects)`. Unless you have worked with Brightway2 before on your computer, your list should contain two projects: 'default' and 'bw2_seminar_2017'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "shown",
    "solution2": "shown",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "_**Exercise**_: list the projects on your computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": true,
    "solution": "shown",
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "list(bw.projects)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Like in all Python modules, you can get additionnal information on the `projects` object and associated properties and methods by typing `help(projects)`. The [docs](https://docs.brightwaylca.org/technical/bw2data.html#projects) are of course more verbose."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Contents of a project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "One property of `projects` is its location, given by `projects.dir`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.projects.dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Looking at what is inside:  \n",
    "<img src=\"images/project_folder_before_setup.JPG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "First things first: **do not panic**! You can use Brightway2 for years without ever opening this directory, but we will discuss some of these files later.\n",
    "\n",
    "It is simply interesting to note that, for now, all the directories are empty except the `lci` directory, which contains an empty database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "All in all, the project takes up 4KB.  \n",
    "Its now time to start populating the project."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### 1.3) bw2setup(), biosphere3 database and LCIA methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### bw2setup()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The first thing you should do is add flow and LCIA methods. This is done by running the `bw2setup` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.bw2setup()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The output tells us that bw2_setup created some very useful things:  \n",
    "  - Created a database called \"biosphere3\": this database contains elementary flows (called biosphere exchanges in Brightway2)  \n",
    "  - 718 impact assessment methods  \n",
    "  \n",
    "It also created some a `mapping` between the imported exchanges and some integer: more on this later.  \n",
    "The whole directory now takes up 125MB."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### biosphere3 database and a first look at database objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Looking at the contents of the `databases.db` database, we see we have imported 4029 exchanges:  \n",
    "<img src=\"images\\database_after_setup_data.JPG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It also states that all the records are associated with the same database: `biosphere3`  \n",
    "\n",
    "Trivia question: why \"3\"?\n",
    "\n",
    "Note: You can always list the databases inside a project by simply typing 'bw.databases'. This accesses the 'database.json' file in your 'project.dir' (I learned the latter by typing `databases?`, you should try it too.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.databases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "While not impossible to interact with the data at this level, you probably never will unless you are developping some funky program. Instead, it is strongly recommended to learn to work with `abstractions`.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To access a database in Brightway, you use the `Database` initialization method (again, you can type `Database?` for more information - this is the last I'll mention this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.Database('biosphere3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It doesn't actually return anything other than information about the Backend.  \n",
    "However, there are many properties and functions associated with this database object.  These are found [here](https://docs.brightwaylca.org/technical/bw2data.html). We can also have a look through the autocomplete. Let's assign the database to a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "my_bio = bw.Database('biosphere3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's check the my_bio `type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(my_bio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's check its length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "len(my_bio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This is exactly the number of items we saw had been added to databases.db  \n",
    "Given this, what do you think is going on?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "If you type `my_bio.` and click on tab, you should get a list of properties and methods associated with database objects. Try this now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "my_bio.        #Type my_bio. and click tab. Have a look at the different properties and objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Some of the more basic ones we will be using now are :  \n",
    "  - `random()` - returns a random activity in the database\n",
    "  - `get(*valid_exchange_tuple*)` - returns an activity, but you must know the activity key\n",
    "  - `load()` - loads the whole database as a dictionary.\n",
    "  - `make_searchable` - allows searching of the database (by default, it is already searchable)\n",
    "  - `search` - search the database  \n",
    "  \n",
    "Lets start with `random`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "my_bio.random()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This returns a biosphere activity, but without assigning it to a variable, there is not much we can do with it directly.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Note: It may seem counter-intuitive for elementary *flows* to be considered *activities* in Brightway, but it is no mistake. \n",
    "LCA models are made up of **nodes** (activities) that are linked by **edges** (exchanges). The biosphere activities are the nodes *outside* the technosphere. Emissions and resource extractions are modelled as exchanges between activities in the technosphere (part of the product system) and these biosphere activities.  \n",
    "\n",
    "More on this later. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "For now, let's assign another random activity to a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_biosphere = my_bio.random()\n",
    "random_biosphere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can get the type of the object that was returned from the database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(random_biosphere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The type is an **activity proxy**. Activity proxies allow us to interact with the content of the database. In the journey to and from the database, several translation layers are used:  \n",
    "<img src=\"images/data_transition_layers.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In Brightway, we *almost* always work with `Activity` or `Exchange` objects. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To see what the activity contains, we can convert it to a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_biosphere.as_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Getting activities from codes or keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can see that the activities in the biosphere3 database have unique **codes**, which we can use with the `get` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "my_bio.get(random_biosphere['code'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Activities can also be \"gotten\" via `get_activity`, but the argument is the activity **key**, consisting of a tuple with two elements: the database name, and the activity code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Use `bw.get_activity()` to retrieve the random biosphere activity. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "database_name = 'biosphere3'\n",
    "code = random_biosphere['code']\n",
    "random_biosphere_key = (database_name, code)\n",
    "random_biosphere_key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "bw.get_activity(random_biosphere_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can always find (or return) the key to an activity using the `.key` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_biosphere.key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Searching for activities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's say we are looking for a specific elementary flow, we can use the `search` method of the database (see [here](https://docs.brightwaylca.org/technical/bw2data.html#default-backend-databases-stored-in-a-sqlite-database) for more details on using search):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.Database('biosphere3').search('carbon dioxide')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It is also possible to use \"filters\" to narrow searches, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.Database('biosphere3').search('carbon dioxide', filter={'categories':'urban', 'name':'fossil'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The database object is also iterable, allowing \"home-made\" searches through list comprehensions. This approach is better because one can add as many criteria as wanted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "[act for act in my_bio if 'Carbon dioxide' in act['name'] \n",
    "                                            and 'fossil' in act['name']\n",
    "                                            and 'non' not in act['name']\n",
    "                                            and 'urban air close to ground' in str(act['categories'])\n",
    "         ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Activities returned by searches or list comprehensions can be assigned to variables, but to do so, one needs to identify the activity by index. Based on the above, I can refine my filters to ensure the list comprehension only returns one activity, and then choose it without fear of choosing the wrong one.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[act for act in my_bio if 'Carbon dioxide' in act['name'] \n",
    "                                            and 'fossil' in act['name']\n",
    "                                            and 'non' not in act['name']\n",
    "                                            and 'urban air close to ground' in str(act['categories'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "activity_I_want = [act for act in my_bio if 'Carbon dioxide' in act['name'] \n",
    "                                            and 'fossil' in act['name']\n",
    "                                            and 'non' not in act['name']\n",
    "                                            and 'urban air close to ground' in str(act['categories'])\n",
    "         ][0]\n",
    "activity_I_want"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**Exercise**: look for and assign to a variable an emission of nitrous oxide emitted to air in the \"urban air\" subcompartment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# First inquiry:\n",
    "[act for act in my_bio if 'nitrogen' in act['name']\n",
    "                       and 'urban air' in str(act['categories'])\n",
    "         ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Found what I need:\n",
    "[act for act in my_bio if 'Dinitrogen monoxide' in act['name']\n",
    "                       and 'urban air close to ground' in str(act['categories'])\n",
    "         ][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's leave the biosphere database here for now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "bw2_setup() also installed LCIA methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "One can load a random method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.methods.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(bw.methods.random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here, the random method returns the tuple by which the method is identified. To get to an actual method, the following syntax is used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.Method(bw.methods.random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Of course, a random method is probably not useful except to play around. To find an actual method, one can again use list comprehensions. Let's say I am interested in using the IPCC2013 100 years method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "[m for m in bw.methods if 'IPCC' in str(m) and ('2013') in str(m) and '100' in str(m)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "I am interested in the second of these, and will assign it to a variable. I can will refine my search until there is one element in my list and then choose it by subscripting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[m for m in bw.methods if 'IPCC' in m[0]\n",
    "                        and ('2013') in str(m)\n",
    "                        and 'GWP 100' in str(m)\n",
    "                        and 'no LT' not in str(m)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Good, now let's choose it:\n",
    "ipcc2013 = [m for m in bw.methods if 'IPCC' in m[0]\n",
    "                    and ('2013') in str(m)\n",
    "                    and 'GWP 100' in str(m)\n",
    "                    and 'no LT' not in str(m)][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Of course, if I know exactly the method I want, and I know the syntax, I can simply type it out: `('IPCC 2013', 'climate change', 'GWP 100a')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(ipcc2013)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ipcc_2013_method = bw.Method(ipcc2013)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(ipcc_2013_method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Again, there are a bunch of methods associated with a method object. You can access these by typing ipcc_2013_method. and clicking tab.  \n",
    "For example, metadata:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ipcc_2013_method.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ipcc_2013_method.metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ipcc_2013_method.metadata['unit']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Question: where is this metadata?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's use the `load` method to see what is in the object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ipcc_2013_method.load()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This contains tuples with (elementary flow, characterization factors)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Nice display of data in methods "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Create a dictionary with keys = elementary flow names and values = characterization factors for the ILCD \"respiratory effects, inorganics\" method (including long-term emissions).  \n",
    "Bonus (optional): Generate a Pandas Series with the resulting dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# First exploration\n",
    "[m for m in bw.methods if 'ILCD' in str(m) \n",
    "                        and 'inorganics' in str(m)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Refine search and assign to a variable\n",
    "ILCD_resp_effects_tuple = [m for m in bw.methods if 'ILCD' in str(m) \n",
    "                        and 'inorganics' in str(m)\n",
    "                        and 'no LT' not in str(m)][0]\n",
    "ILCD_resp_effects = bw.Method(ILCD_resp_effects_tuple)\n",
    "ILCD_resp_effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Generate the dictionary using a comprehension:\n",
    "ILCD_resp_effects_dict = {bw.get_activity(ef[0])['name']:ef[1] for ef in ILCD_resp_effects.load()}\n",
    "ILCD_resp_effects_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Bonus: put the whole thing in a neat Pandas series\n",
    "pd.Series(ILCD_resp_effects_dict,\n",
    "          name=\"{}, {}\".format(ILCD_resp_effects.name, ILCD_resp_effects.metadata['unit']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Enough said for now about methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### 1.4) LCI datases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "There is much information on the structure of LCI databases in Brightway2 [here](https://docs.brightwaylca.org/intro.html#inventory-databases), [here](http://nbviewer.jupyter.org/urls/bitbucket.org/cmutel/brightway2/raw/default/notebooks/Databases.ipynb) and [here](https://docs.brightwaylca.org/technical/bw2data.html#databases).  Probably the easiest way to learn about them, however, is to import one and have a look.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here is the code to import the ecoinvent v3.3 database. Don't do it though, not now: it takes too long, we're better off working with a smaller database and getting more done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "fpei33 = \"enter your path to the datasets e.g. r'C:\\FolderWith\\LotsOf\\ecoSpold2\\Files'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Next, execute the following code. It will import the ecoinvent database. We will look in detail in another Notebook at what this code actually does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "if 'ecoinvent 3.3 cutoff' in bw.databases:\n",
    "    print(\"Database has already been imported\")\n",
    "else:\n",
    "    ei33 = bw.SingleOutputEcospold2Importer(fpei33, 'ecoinvent 3.3 cutoff')\n",
    "    ei33.apply_strategies()\n",
    "    ei33.statistics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The database needs to be written to disk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ei33.write_database()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's instead import **ecoinvent v2.2**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "fpei22 =  \"enter your path to the datasets e.g. r'C:\\FolderWith\\LotsOf\\ecoSpold1\\Files'\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "if 'ecoinvent 2.2' in bw.databases:\n",
    "    print(\"Database has already been imported\")\n",
    "else:\n",
    "    ei22 = bw.SingleOutputEcospold1Importer(fpei22, 'ecoinvent 2.2')\n",
    "    ei22.apply_strategies()\n",
    "    ei22.statistics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "if 'ecoinvent 2.2' in bw.databases:\n",
    "    print(\"Database has already been imported\")\n",
    "else:\n",
    "    ei22.write_database()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Other code to import LCI databases in other formats are found [here](https://bitbucket.org/cmutel/brightway2-io/src/211f748e7b9987aef452a1ead1f483cc0b4bc25c/bw2io/importers/?at=default). We'll explore this later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "If you check that the database has actually been added to your project: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "eidb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.databases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Note: the ei22 (or ei33) object created above is not the actual database, but actually an object used strictly for importing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Only execute this code if you've just imported ecoinvent v2.2\n",
    "type(ei22)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To access the actual database, you need to use the Database method: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.Database('ecoinvent 2.2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This is a more advanced topic, but note that there are alternative backends. See [here](https://docs.brightwaylca.org/technical/bw2data.html#inventory-data-backends)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's assign the database to a variable and see what we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "eidb = bw.Database('ecoinvent 2.2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Check the length of the database:\n",
    "len(eidb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Again, we can get an idea of useful methods and attributes by typing eidb. and Tab. Do this now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "eidb. #Press tab!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### LCI activities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In the context of LCI databases, activities are the nodes \"within the technosphere\". They are therefore the columns in the technosphere matrix $A$.  \n",
    "There are different ways to get access to an activity. Let's use the `random()` method for now to explore a random activity in the ecoinvent database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_act = eidb.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_act"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(random_act)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To see what is stored in an activity object, let's convert our random act in a dictionary: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_act.as_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice one important thing: **no exchanges**!  \n",
    "Indeed, the exchanges and the activities are stored in two different tables of the `databases.db` database.  \n",
    "It is possible, however, to iterate through the exchanges of the activities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "##### Searching and getting LCI activities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Searching and getting LCI activities is done exactly the same way as for activities in the biosphere3 database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_act.as_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Using search\n",
    "eidb.search('transport', filter={'name':'lorry'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_act['location']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Using list comprehensions:\n",
    "[act for act in eidb if 'lorry' in act['name']\n",
    "                    and 'RER' in act['location']\n",
    "                    and '>32t' in act['name']\n",
    "                    and 'operation' not in act['name']\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Return an activity for electricity production, coal-fired power plants in Germany"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "[act for act in eidb if 'electricity' in act['name']\n",
    "                        and 'coal' in act['name']\n",
    "                        and act['location']=='DE'\n",
    "              ][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### LCI exchanges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**`Exchanges`** are the edges between nodes.\n",
    "\n",
    "These can be:  \n",
    "  - an edge between two activities within the technosphere (an element $a_{ij}$ of matrix $A$)  \n",
    "  - edges between an activity in the technosphere and an activity in the \"biosphere\" (an element $b_{kj}$ of the biosphere matrix $B$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "One can iterate through **all** exchanges that have a given activity as `output`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "for exc in random_act.exchanges():\n",
    "    print(exc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "One can also iterate through subsets of the exchanges:  \n",
    "  - Technosphere exchanges: exchanges linking to other activities in the technosphere, `activity.technosphere()`  \n",
    "  - Biosphere exchanges: AKA elementary flows, linking to activities in the biosphere database `activity.biosphere()`  \n",
    "  - Production exchange: the reference flow of the activity `activity.production`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's assign a **technosphere exchange** to a variable to learn more about it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "random_techno_exchange = [exc for exc in random_act.technosphere()][0]\n",
    "random_techno_exchange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(random_techno_exchange)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Again, the type is a proxy (refer to the diagram above about the different translation layers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Amount, or weight of the edge\n",
    "random_techno_exchange.amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Activity the exchange stems from\n",
    "random_techno_exchange.input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Activity the exchange terminates in\n",
    "random_techno_exchange.output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Exchange as a dictionary\n",
    "random_techno_exchange.as_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's now look at a production exchange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Assign a biosphere flow to a variable, and check the following:  \n",
    "  - Is the output the same as for the technosphere exchange?  \n",
    "  - From what database does the biosphere exchange come from?  \n",
    "  - What is the amount of the exchange (i.e. the weight of the edge connecting the two activities)?\n",
    "  \n",
    "NOTE: If you get a ` list index out of range` error when trying to subscript your list comprehension, it means your list comprehension is empty, i.e. that there are no biosphere flows associated with the activity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Assign the exchange to a variable:\n",
    "random_bio_exchange = [exc for exc in random_act.biosphere()][0]\n",
    "random_bio_exchange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Output of biosphere exchange\n",
    "random_bio_exchange.output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Is it the same as the output of the technosphere exchange? It should be!\n",
    "random_bio_exchange.output == random_techno_exchange.output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Database of the random biosphere exchange input - `.input`directly returns the activity proxy!\n",
    "random_bio_exchange.input.key[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Amount of exchange\n",
    "random_bio_exchange['amount']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Loaded LCI databases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It is possible to load the entire database into a dictionary.  \n",
    "This greatly speeds up work if you need to iterate over all activities or exchanges. The resulting object is quite big, so you should do this only if the gain in efficiency is worth it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Let's not do this in the seminar, ok?\n",
    "eidb_loaded = eidb.load()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "eidb_loaded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 2) My first LCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Brightway has a so-called LCA object.  \n",
    "It is instantiated using `LCA(args)`.  \n",
    "The only required argument is a functional unit, described by a dictionary with keys = activities and values = amounts (more [here](https://docs.brightwaylca.org/lca.html#specifying-a-functional-unit)).  \n",
    "A second argument that is often passed is an LCIA method, passed using the method tuple.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 2.1) General syntax of LCA calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's create our first LCA object using our random activity and our IPCC method.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA_quick = bw.LCA({random_act:1}, ('IPCC 2013', 'climate change', 'GWP 100a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The steps to get to the impact score are as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA_quick.lci()    # Builds matrices, solves the system, generates an LCI matrix.\n",
    "myFirstLCA_quick.lcia()   # Characterization, i.e. the multiplication of the elements \n",
    "                          # of the LCI matrix with characterization factors from the chosen method\n",
    "myFirstLCA_quick.score    # Returns the score, i.e. the sum of the characterized inventory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's not take a closer look at the LCA object and its methods/attributes. We'll do this by creating a new LCA object: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA = bw.LCA({random_act:1}, ('IPCC 2013', 'climate change', 'GWP 100a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 2.2) the `demand` attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.demand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To access the actual activity from the demand, you would do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "demanded_act = list(myFirstLCA.demand.keys())[0]\n",
    "demanded_act"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "demanded_act == random_act"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "There are also other attributes that have simply not been built yet, such as the `demand_array` and the `score`. To generate them, we first need to actually build the matrices. This will be done when calling the `.lci()` method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 2.3) Reminder of the system that needs to be solved in calculating an LCI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Before actually running the `.lci()` method, here's a quick refresher of the actual calculation that Brightway will need to do to calculate the inventory:  \n",
    "\n",
    "$g=BA^{-1}f$  \n",
    "\n",
    "where:  \n",
    "\n",
    "  - $A$ = the technosphere matrix  \n",
    "  - $B$ = the biosphere matrix (matrix with elementary flows)  \n",
    "  - $f$ = the final demand vector  \n",
    "  - $g$ = the inventory  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "hidden",
    "solution_first": true
   },
   "source": [
    "**Discussion:** Knowing what you do about the structure of Brightway (notably, activities and exchanges), what needs to happen to generate these matrices?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "hidden"
   },
   "source": [
    "To consider:  \n",
    "  - how should the order of the rows and columns be determined?  \n",
    "  - how should we keep track of what is in each row and column?  \n",
    "  - The parameters in the matrices are sometimes actually probability distribution functions - how should we consider this uncertainty information?  \n",
    "  - The matrices are *sparse*, i.e. they are mostly made up of zeros. Should we consider this? Why? How?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 2.4) Building the matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Structured arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "LCI data imported in Brightway is stored in the `databases.db` database, discussed above.  \n",
    "It is also stored in [numpy *structured arrays*](https://docs.scipy.org/doc/numpy/user/basics.rec.html). Here is a look at the  structured array for my ecoinvent 2.2 import (put in a pandas DataFrame because it looks nicer):  \n",
    "<img src=\"images\\structured_array_ecoinvent22.JPG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise**(not core): Load the structured array of the ecoinvent database you are working with now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "eidb.filepath_processed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "your_structured_array = np.load(eidb.filepath_processed())\n",
    "pd.DataFrame(your_structured_array).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In this array:  \n",
    "  - `input` and `output` columns are integers that map to an activity. This mapping is found in the `mapping.pickle` file in the `project` directory and it looks something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pd.Series(bw.mapping).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "  - `row` and `col`store *dummy* placeholder information about the location of the parameter in the matrices. \n",
    "  - the `type` indicates whether the exchange is a reference flow (`type`=0), technosphere exchange (`type`=1) or elementary flow (`type`=2).  \n",
    "  - the other columns deal with uncertainty data. We'll cover that later, but one can always read about these columns in the [`stats_arrays` documentation](http://stats-arrays.readthedocs.io/en/latest/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "When the `.lci()` method is called, the structured arrayas are used to build matrices. The code responsible to do this is in the [`MatrixBuilder` class methods](https://bitbucket.org/cmutel/brightway2-calc/src/105e24e2d803c96773651ed73c43d850f9c23548/bw2calc/matrices.py?at=default&fileviewer=file-view-default). \n",
    "\n",
    "The method `MatrixBuilder.build_dictionary` is used to take input and output values, respectively, and figure out which rows and columns they correspond to. The actual code is succinct - only one line - but what it does is:\n",
    "  - Get all unique values, as each value will appear multiple times\n",
    "  - Sort these values\n",
    "  - Give them integer indices, starting with zero\n",
    "This information on row and column indices is sufficient to build matrices. These matrices are build in a [COOrdinate sparse matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.coo_matrix.html) format, where, for each exchange, three values are required: row position, column position, and amount (the actual value). The sparse matrices are actually stored in [CSR format](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html#scipy.sparse.csr_matrix), but this is a detail.  \n",
    "\n",
    "Some more details are are found [here](https://docs.brightwaylca.org/lca.html#building-matrices).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's now finally run the `.lci()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.lci()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here's what the structured arrays *now* look like:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(myFirstLCA.bio_params).head(5) # Technosphere parameters are at myFirstLCA.tech_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We see that the row and col numbers are no longer dummy variables, but that they actually have real matrix indices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Dictionaries that map between incides and activities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "One of the useful things that the `MatrixBuilder` produces are `dictionaries` that map row and column numbers to the keys of activities.  There are three such dictionaries, all directly accessible as attributes of the LCA object:\n",
    " - `activity_dict`: Columns in the technosphere matrix $A$ or biosphere matrix $B$\n",
    " - `product_dict` : Rows in the technosphere matrix $A$  \n",
    " - `biosphere_dict`: Rows in the biosphere matrix $B$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here what this dictionary looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.activity_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So, if I know the key to my activity (which, again,  is a `tuple` consisting of the database name and the activity code), I can read the column index (from `activity_dict`) or row index (from `product_dict` or `biosphere_dict` for the $A$ or $B$ matrices, respectively). \n",
    "\n",
    "Let's find out what column is associated with the activity that is producing our final demand as reference flow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Getting the key from the `demand`attribute:\n",
    "act_key = list(myFirstLCA.demand)[0].key\n",
    "# Getting the column number from the activity_dict:\n",
    "col_index = myFirstLCA.activity_dict[act_key]\n",
    "print(\"The column index for activity {} is {}\".format(act_key, col_index))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "While this is useful, it is often more useful to determine what a row or column in the matrices actually refers to. In these cases, we need a dictionary that maps row or column indices to activity keys, and not the opposite.  \n",
    "We can do this by reversing our dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA_rev_activity_dict = {value:key for key, value in myFirstLCA.activity_dict.items()}\n",
    "myFirstLCA_rev_activity_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "As a convenience, Brightway offers a method that will generate the three reverse dictionaries simultaneously.  \n",
    "`.reverse_dict()` returns three reverse dicts (reverse activity dict,  reverse product dict,  reverse biosphere dict) *in that order*. The syntax for creating and assigning these reverse dicts is therefore: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA_rev_act_dict, myFirstLCA_rev_product_dict, myFirstLCA_rev_bio_dict = myFirstLCA.reverse_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### $A$ and $B$ Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can also access the matrices that were constructed. Let's look at the technosphere matrix ($A$).  \n",
    "The ** $A$ matrix**, with each element $a_{ij}$ provides information on the amount of input or output of product $i$ from activity $j$. When $i=j$, the element $a_{ij}$ is the *reference flow* for the activity described in the column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.technosphere_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "I am told that the dimensions of the matrix is $n*n$ where $n$ is the number of activities in my product system, and that the amount of actually stored elements is much less than $n^2$ (because the matrix is *sparse* and zero values are not stored).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can have an idea of what it stores by printing it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "print(myFirstLCA.technosphere_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It therefore stores both the coordinates and the values (as expected).\n",
    "We can slice this matrix using coordinates. For example, let's say we wanted a view of the exchanges associated with the unit process providing our functional unit.  \n",
    "We already know found the column number for that activity: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "print(\"As a reminder, the column index for  {} is  {}\".format(act_key, col_index))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To return the whole column from the $A$ matrix, we therefore slice the $A$ matrix.  \n",
    "Python notes:  \n",
    "  - In Python, slicing is done using []\n",
    "  - We specify rows first, then columns  \n",
    "  - `:` refers to \"the whole row\" or \"the whole column\" (depending if it is passed first or second in the []) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myColumn = myFirstLCA.technosphere_matrix[:, col_index]\n",
    "myColumn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Printing this out gives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "print(myColumn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Not too useful: it would be better to get the *names* to these exchanges.  \n",
    "We need to do two things:  \n",
    "  - Get the indices from the CSR matrix (we can do this by converting it to a sparse matrix in `COOrdinate` format first)  \n",
    "  - Get the activity code for the each index (we can do this using the reverse of the `activity_dict`)  \n",
    "  - Use `get_activity` to access the actual names of the activities.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "1) Converting the CSR matrix to a COO matrix:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myColumnCOO = myColumn.tocoo()\n",
    "myColumnCOO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It is still a sparse matrix with the same number of elements, and it looks quite like the CSR version when we print it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "print(myColumnCOO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "However, we can directly access the rows and column indices using `row` and `col`:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myColumnCOO.row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "2) Get the activity code for each element using the **reverse** product dictionary we produced above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Using a list comprehension:\n",
    "[myFirstLCA_rev_product_dict[i] for i in myColumnCOO.row]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "It would be even nicer to get the names for these:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "names_of_my_inputs = [bw.get_activity(myFirstLCA_rev_product_dict[i])['name'] for i in myColumnCOO.row]\n",
    "names_of_my_inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can put these in a neat Pandas Series, with actual names and amounts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# First create a dict with the information I want:\n",
    "myColumnAsDict = dict(zip(names_of_my_inputs,myColumnCOO.data))\n",
    "# Create Pandas Series from dict\n",
    "pd.Series(myColumnAsDict, name=\"Nice series with information on exchanges in my foreground process\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "shown",
    "solution_first": true
   },
   "source": [
    "Alternative way to generate similar information without even looking at the matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution": "shown"
   },
   "outputs": [],
   "source": [
    "pd.Series({bw.get_activity(exc.input)['name']:exc.amount for exc in random_act.technosphere()}, \n",
    "          name=\"alternative way to generate exchanges\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "shown"
   },
   "source": [
    "Note the differences:  \n",
    "  - The reference flow is not there (activity.technosphere() only returns technoshere exchanges where the input is not equal to the output)  \n",
    "  - The values are positive, not negative (because the $A$ matrix is $I-Z$ where $Z$ contains the information on these inputs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution": "shown",
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise**: Create a Pandas Series with the elementary flows of the activity supplying the reference flow for myFirstLCA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "myBioColumn = myFirstLCA.biosphere_matrix[:, col_index]\n",
    "myBioValues = myBioColumn.tocoo().data\n",
    "myBioNames = [bw.get_activity(myFirstLCA_rev_bio_dict[row])['name'] for row in myBioColumn.tocoo().row]\n",
    "pd.Series(dict(zip(myBioNames, myBioValues)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Demand array $f$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The demand array is the $f$ in $As=f$. \n",
    "It is an attribute of the LCA object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.demand_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Looks like it is all zeros, but not so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.demand_array.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So where is the one? We can know this by using our `activity_dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "demand_database = list(myFirstLCA.demand.keys())[0]['database']\n",
    "demand_code = list(myFirstLCA.demand.keys())[0]['code']\n",
    "(demand_database, demand_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "row_of_demand = myFirstLCA.activity_dict[(demand_database, demand_code)]\n",
    "row_of_demand # Row number of our demand vector containing the functional unit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.demand_array[row_of_demand]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 2.5) Solution to the inventory calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We saw above how `.lci()` produced the $A$ and $B$ matrices.  \n",
    "`.lci()` also *solves* the equation $As=f$ and calculated the inventory by multiplying the solution to this equation by the biosphere matrix.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Supply array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Vector containing the amount each activity will need to provide to meet the functional demand, i.e. $s=A^{-1}f$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.supply_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.supply_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Inventory matrix**  \n",
    "Contains the inventory *by activity* (i.e. not summed). In other words, we do not have $g=BA^{-1}f$, but rather $G=B \\cdot diag(A^{-1}f)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.inventory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can aggregate the LCI results along the columns (i.e. calculate the cradle-to-gate inventory):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "LCI_cradle_to_gate = myFirstLCA.inventory.sum(axis=1)\n",
    "LCI_cradle_to_gate.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Get the total (cradle-to-gate) emissions of nitrous oxide emitted to air in the \"urban air\" subcompartment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "NOx_act = [act for act in my_bio if 'Dinitrogen monoxide' in act['name']\n",
    "                       and 'urban air close to ground' in str(act['categories'])\n",
    "         ][0]\n",
    "NOx_act.key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "NOx_row = myFirstLCA.biosphere_dict[NOx_act]\n",
    "NOx_row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "myFirstLCA.inventory[NOx_row, :].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 2.7) LCIA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The LCIA calculation is done via the `.lcia()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.lcia()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "A number of other matrices are now available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Matrix of characterization factors:\n",
    "myFirstLCA.characterization_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.characterization_matrix.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Matrix of characterized inventory flows\n",
    "myFirstLCA.characterized_inventory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Question: would there be more, less or just as many elements in the inventory matrix as there are in the characterized inventory matrix?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The overall score is now an attribute of the LCA object: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We also could have determined what this score was by summing the elements of our `characterized_inventory` matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA.characterized_inventory.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We could also have calculated it by multiplying the inventory and characterization factors ourselves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "(myFirstLCA.characterization_matrix * myFirstLCA.inventory).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We could also calculate the score by elementary flow (summing columns for each rows), irrespective of the unit process that produced it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "elementary_flow_contribution = myFirstLCA.characterized_inventory.sum(axis=1) #Axis is the dimension I want to sum over:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "elementary_flow_contribution.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice that is has **two** dimensions. The result is in fact a one-dimensional matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "type(elementary_flow_contribution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To convert it to an array (probably more useful for many purposes), you can use any of the following approaches:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "elementary_flow_contribution.A1 \n",
    "#np.squeeze(np.asarray(elementary_flow_contribution))\n",
    "#np.asarray(elementary_flow_contribution).reshape(-1)\n",
    "#np.array(elementary_flow_contribution).flatten()\n",
    "#np.array(elementary_flow_contribution).ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Create a Pandas series that has the scores per unit process, sorted by value (contribution analysis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create array with the results per column (i.e. per activity)\n",
    "results_by_activity = (myFirstLCA.characterized_inventory.sum(axis=0)).A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Create a list of names in columns\n",
    "list_of_names_in_columns = [bw.get_activity(myFirstLCA_rev_act_dict[col])['name'] \n",
    "                            for col in range(myFirstLCA.characterized_inventory.shape[1])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pd.Series(index=list_of_names_in_columns, data=results_by_activity).sort_values(ascending=False).head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 3) My second LCA: Comparative LCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's choose two activities to compare, say Swiss electricity produced from respectively a run-of-river hydropower plant and a wind turbine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise**: assign the two activities to variables `hydro` and `wind` respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "[act for act in eidb if \"wind\" in act['name'] and \"electricity\" in act['name'] and \"CH\" in act['location']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "wind = [act for act in eidb if \"wind\" in act['name']\n",
    "        and \"600kW\" in act['name'] \n",
    "        and \"kilowatt hour\" in act['unit']][0]\n",
    "wind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "[act for act in eidb if \"hydro\" in act['name'] and \"river\" in act['name'] and \"CH\" in act['location']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "hydro = [act for act in eidb if \"hydro\" in act['name'] \n",
    "                     and \"river\" in act['name'] \n",
    "                     and \"CH\" in act['location']\n",
    "                     and \"kilowatt hour\" in act['unit']\n",
    "                     ][0]\n",
    "hydro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's also compare these according to their carbon footprint as measured with the IPCC method we already selected above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ipcc_2013_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### One at a time approach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "hydroLCA = bw.LCA({hydro:1}, ipcc_2013_method.name)\n",
    "hydroLCA.lci()\n",
    "hydroLCA.lcia()\n",
    "hydroLCA.score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "solution2": "shown",
    "solution2_first": true
   },
   "source": [
    "**Exercise:** Do the LCA for `wind`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "solution2": "shown"
   },
   "outputs": [],
   "source": [
    "windLCA = bw.LCA({wind:1}, ipcc_2013_method.name)\n",
    "windLCA.lci()\n",
    "windLCA.lcia()\n",
    "windLCA.score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "#Compare results:\n",
    "if windLCA.score>hydroLCA.score:\n",
    "    print(\"Hydro is preferable\")\n",
    "elif windLCA.score<hydroLCA.score:\n",
    "    print(\"Wind is preferable\")\n",
    "else:\n",
    "    print(\"Both options have the same climate change indicator result\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Do one \"delta\" LCA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "deltaLCA = bw.LCA({wind:1, hydro:-1}, ipcc_2013_method.name)\n",
    "deltaLCA.lci()\n",
    "deltaLCA.lcia()\n",
    "deltaLCA.score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "if deltaLCA.score>0:\n",
    "    print(\"Hydro is preferable\")\n",
    "elif deltaLCA.score<0:\n",
    "    print(\"Wind is preferable\")\n",
    "else:\n",
    "    print(\"Both options have the same climate change indicator result\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 4) My third LCA - Multiple impact categories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Say we want to evaluate the indicator results for our randomAct for all ILCD midpoint categories (with long-term emissions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Make a list of all impact method names (tuples):\n",
    "ILCD = [method for method in bw.methods if \"ILCD\" in str(method) and \"no LT\" not in str(method)]\n",
    "ILCD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Simplest way: for loop, using `switch method`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myThirdLCA = bw.LCA({random_act:1}, ILCD[0]) # Do LCA with one impact category\n",
    "myThirdLCA.lci()\n",
    "myThirdLCA.lcia()\n",
    "for category in ILCD:\n",
    "    myThirdLCA.switch_method(category)\n",
    "    myThirdLCA.lcia()\n",
    "    print(\"Score is {:f} {} for category {}\".format(myThirdLCA.score, \n",
    "                                                 bw.Method(category).metadata['unit'],\n",
    "                                                 bw.Method(category).name)\n",
    "          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myFirstLCA_unitProcessContribution = myFirstLCA.characterized_inventory.sum(axis=0).A1\n",
    "myFirstLCA_unitProcessRelativeContribution = myFirstLCA_unitProcessContribution/myFirstLCA.score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Revising my second and third LCA with `MultiLCA`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The `MultiLCA` allows thecalculation of LCA results for multiple functional units and impact categories.  \n",
    "One simply needs to create a `calculation setup`, i.e. a named set of functional units and LCIA methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Calculation setups: dictionary with lists of functional units and methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "list_functional_units = [{wind.key:1}, {hydro.key:1}]\n",
    "list_methods = ILCD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.calculation_setups['wind_vs_hydro'] = {'inv':list_functional_units, 'ia':list_methods}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bw.calculation_setups['wind_vs_hydro']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myMultiLCA = bw.MultiLCA('wind_vs_hydro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myMultiLCA.results.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "myMultiLCA.results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(index=ILCD, columns=[wind['name'], hydro['name']], data=myMultiLCA.results.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can also create \"fuller\" DataFrames. Here is with code from [here](http://stackoverflow.com/questions/42984831/create-a-dataframe-from-multilca-results-in-brightway2): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "scores = pd.DataFrame(myMultiLCA.results, columns=myMultiLCA.methods)\n",
    "as_activities = [\n",
    "    (bw.get_activity(key), amount) \n",
    "    for dct in myMultiLCA.func_units \n",
    "    for key, amount in dct.items()\n",
    "]\n",
    "nicer_fu = pd.DataFrame(\n",
    "    [\n",
    "        (x['database'], x['code'], x['name'], x['location'], x['unit'], y) \n",
    "        for x, y in as_activities\n",
    "    ], \n",
    "    columns=('Database', 'Code', 'Name', 'Location', 'Unit', 'Amount')\n",
    ")\n",
    "pd.concat([nicer_fu, scores], axis=1).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can even generate beautiful heatmaps like this in a relatively easy way, see example notebook [here](http://nbviewer.jupyter.org/urls/bitbucket.org/cmutel/brightway2/raw/default/notebooks/Using%20calculation%20setups.ipynb).\n",
    "\n",
    "<img src=\"images/multiLCA_heatmap.JPG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Done with deterministic LCA using only existing database items!"
   ]
  }
 ],
 "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.5.2"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}