1 - The supply chain graph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f72ca9c0-623b-4358-afc9-e9a7c606d102",
   "metadata": {},
   "source": [
    "# 1 - The supply chain graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73ad8843-58b9-4975-bd89-d2508ac992ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import bw2data as bd\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43798d94-b985-4c61-9c89-56f5b330c64f",
   "metadata": {},
   "source": [
    "The first thing to learn about `bw2data` is the concept of projects. Each project is self-contained, and independent of other projects. Each has its own subdirectory. This can lead to data duplication, but helps keep each project safe from the changes in the others.\n",
    "\n",
    "We start in the `default` project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "501f40ae-0f41-4cc2-9aad-c2317f9642a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.current"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0636bf15-5339-4816-9c34-a120dfc34b3d",
   "metadata": {},
   "source": [
    "It has its own directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "295ae718-fced-4833-b997-f7433352ef40",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.dir"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5e29301-038c-4cc5-a38b-3787763cdeba",
   "metadata": {},
   "source": [
    "Make it easy to reset this project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2a0c34b-f4e0-4a66-8528-a35766c792c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    bd.projects.delete_project(\"supply chain graph\", True)\n",
    "except ValueError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67681db-d546-4f1a-90c9-2f0659c768ab",
   "metadata": {},
   "source": [
    "Let's create a new project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd63cc67-aa35-424f-a671-d5ac9cc8b5f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"supply chain graph\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ed963be-9865-4f44-96c5-84b64fbe662f",
   "metadata": {},
   "source": [
    "A graph can have nodes of any type, but for the purposes of LCA it is convenient to separate activity nodes, product nodes, elementary flow nodes, and characterization nodes. We will also use a shortcut (for now) and assume that each activity produces exactly one product, so we can collapse activity and products nodes into a single node.\n",
    "\n",
    "Let's think about a simple product system - a bike. Here is a graph:\n",
    "\n",
    "<img src='images/simple-graph.png' width='400'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dd40bbf-cf56-41f4-9142-78dcee0bdab1",
   "metadata": {},
   "source": [
    "To enter this data into BW, we need to create the nodes, and then the edges. We will create these nodes in a `Database`. A database in BW is just a collection of nodes - it can be large or small, there aren't any general rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dec2934-818c-479e-ad85-1c99a88c7512",
   "metadata": {},
   "outputs": [],
   "source": [
    "db = bd.Database(\"bike\")\n",
    "# Let the metadata system know this database exists. Not necessary if using a `bw2io` importer.\n",
    "db.register()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f17ff766-fb54-4534-9d69-4d8ad51c90b9",
   "metadata": {},
   "source": [
    "Our first node. We specify some additional data to make it easier to find or use this node later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c887c7f5-c83a-40c3-9e85-430e93b837f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    'code': 'bike',\n",
    "    'name': 'bike production',\n",
    "    'location': 'DK',\n",
    "    'unit': 'bike'\n",
    "}\n",
    "\n",
    "bike = db.new_node(**data)\n",
    "bike.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c67bf17-7a15-455d-a4ca-dd477c2ebc40",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    'code': 'ng',\n",
    "    'name': 'natural gas production',\n",
    "    'location': 'NO',\n",
    "    'unit': 'MJ'\n",
    "}\n",
    "\n",
    "ng = db.new_node(**data)\n",
    "ng.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "789d250d-3a39-44f5-93ca-91e1403d1dd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    'code': 'cf',\n",
    "    'name': 'carbon fibre production',\n",
    "    'location': 'DE',\n",
    "    'unit': 'kg'\n",
    "}\n",
    "\n",
    "cf = db.new_node(**data)\n",
    "cf.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68c0bbc0-4453-49c6-94fe-2802ec1bbe3b",
   "metadata": {},
   "source": [
    "We can also define nodes like this. Note that this node has a `type`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "487752b1-1106-44fd-9a96-096059856bf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "co2 = db.new_node(\n",
    "    code='co2', \n",
    "    name=\"Carbon Dioxide\", \n",
    "    categories=('air',),\n",
    "    type='emission',\n",
    "    unit='kg'\n",
    ")\n",
    "\n",
    "co2.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c92505-3e0c-4c99-aa1f-18c681c32205",
   "metadata": {},
   "source": [
    "We also need to create edges between the nodes. We can do this in many ways, here is one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6950d13b-516f-44a5-9419-8c5bd7989ddf",
   "metadata": {},
   "outputs": [],
   "source": [
    "bike.new_edge(\n",
    "    amount=2.5, \n",
    "    type='technosphere',\n",
    "    input=cf\n",
    ").save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466d440a-9467-4f00-b2ae-bb18f567325d",
   "metadata": {},
   "source": [
    "What about some uncertainty? We use [stats_arrays](https://stats-arrays.readthedocs.io/en/latest/) to model probability distribution functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "402901ff-9553-46fb-ac89-230bd0de99c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "cf.new_edge(\n",
    "    amount=237.3,  # plus 58 kWh of electricity, in ecoinvent 3.8 \n",
    "    uncertainty_type=5, \n",
    "    minimum=200, \n",
    "    maximum=300, \n",
    "    type='technosphere',\n",
    "    input=ng,\n",
    ").save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbdf759e-20c7-4ad2-a88b-de2517bfbd67",
   "metadata": {},
   "outputs": [],
   "source": [
    "cf.new_edge(\n",
    "    amount=26.6, \n",
    "    uncertainty_type=5, \n",
    "    minimum=26,\n",
    "    maximum=27.2, \n",
    "    type='biosphere',\n",
    "    input=co2,\n",
    ").save()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "794e1092-5fca-4f13-b7fe-0bfb440e70f5",
   "metadata": {},
   "source": [
    "Brightway will assume that the a `production` exchange of amount 1 in each node unless you tell it otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547326d4-e179-429b-9b45-95c6e7fa2298",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "\n",
    "Create a new bicycle made of steel. You will need some coal and some iron ore mining for the steel, and some steel for the bicycle.\n",
    "\n",
    "Your use of steel consumed some iron ore, a natural resource. In a **new database**, create a biosphere flow for this iron ore, and add the iron ore flow. You might not be sure about the numbers - you can reflect that in the uncertainty you assign to the exchanges."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b14df34b-b85e-4dee-b685-454fdb5135aa",
   "metadata": {},
   "source": [
    "## LCIA\n",
    "\n",
    "To define characterization nodes and edges, we use a different data structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "413baa19-fdc7-4f93-a84a-3037d3278c8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ipcc = bd.Method(('IPCC',))\n",
    "ipcc.write([\n",
    "    (co2.key, {'amount': 1, 'uncertainty_type': 3, 'loc': 1, 'scale': 0.05}),\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a2edb6b-1695-43af-a3f9-5292c9006cd3",
   "metadata": {},
   "source": [
    "This is already enough to do an LCA. Let's check what our answer should be. Without uncertainty, to make one bike we need 2.5 kg of CF, and carbon fibre produces 26.6 kg CO2 per kg of carbon fibre, so we are looking for around 60 kg CO2-eq."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68e7940f-cbb1-418d-819f-aeafabf5cd0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import bw2calc as bc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8a87a8f-3386-4c4a-9077-63e0dbfa4953",
   "metadata": {},
   "outputs": [],
   "source": [
    "lca = bc.LCA(demand={bike: 1}, method=('IPCC',))\n",
    "lca.lci()\n",
    "lca.lcia()\n",
    "lca.score"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d33cba8-306c-4286-ab04-6353b81b0fc9",
   "metadata": {},
   "source": [
    "To use uncertainty, we tell the `LCA` object to use the probability distributions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d087957-f85b-4006-b110-bd3c336ca483",
   "metadata": {},
   "outputs": [],
   "source": [
    "lca = bc.LCA(demand={bike: 1}, method=('IPCC',), use_distributions=True)\n",
    "lca.lci()\n",
    "lca.lcia()\n",
    "\n",
    "df = pd.DataFrame([{'score': lca.score} for _ in zip(lca, range(10))])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "185b0a8b-b94e-4da8-b9c8-14be227f0bb7",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Create a new LCIA method for your iron ore consumption. Calculate the LCIA result you should get, and then verify that you have the correct value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97edfa43-2b13-4ffd-a5c4-7683acc78ad5",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Open a new notebook, and calculate an LCIA score for you steel bike using everything you have learned already. You are not allowed to duplicate this notebook :) But you can copy and paste individual cells."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddb5a306-2020-4cf2-a822-28eedeebf687",
   "metadata": {},
   "source": [
    "## Searching through the database\n",
    "\n",
    "In addition to storing and using nodes and edges, our graph database can be searched in different ways. Let's show this with a larger database."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "521e2ad1-4f0e-4d2b-9488-592147a4ad0e",
   "metadata": {},
   "source": [
    "We can use a shortcut to install some data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aba7543-fea8-4a41-a84e-ee436709181a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import bw2io as bi\n",
    "bi.install_project(\"USEEIO-1.1\")\n",
    "\n",
    "# If that doesn't work for whatever reason, we can import the original data with this:\n",
    "# bi.useeio11()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "611e82fd-2d4a-425c-912d-b973fd8b2e13",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"USEEIO-1.1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d23260fc-6e05-430b-aae6-b4390390372b",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.databases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdd92c2f-17b3-4d01-86ae-89dcb6d89830",
   "metadata": {},
   "outputs": [],
   "source": [
    "db = bd.Database(\"USEEIO-1.1\")\n",
    "db.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cbd2787-1293-43c6-85c1-93a09406b93e",
   "metadata": {},
   "source": [
    "This database has processes **and** products. What would this mean for drawing a graph?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "631dfa06-3322-4911-a4d7-2866a858e509",
   "metadata": {},
   "outputs": [],
   "source": [
    "{node['type'] for node in db}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f87311b8-28fd-4259-8e83-6b6a0112938f",
   "metadata": {},
   "source": [
    "We can search with the 'search' function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c66aa64d-138f-468f-b8ea-c8bafffbbbfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "fun = db.search(\"amusement\")[0]\n",
    "fun['name'] = 'fun'\n",
    "fun.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83fd3221-872e-4a29-97ea-9e9381a0d49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "db.search('amusement')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ac1549b-0780-4a97-84ea-3a719c23d14e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "{node['name'] for node in db if node['type'] == 'product'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a520b6b7-3633-4d4d-9ed7-e4407bb9ee15",
   "metadata": {},
   "source": [
    "## Interacting with the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fe2144f-665b-4442-9bcb-c9a46acd4a8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo = bd.get_node(name='Cattle ranches and feedlots', type='product')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2d44d33-a05d-4521-b703-d346e38818f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(moo) == bd.Node"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c922998-1b86-4d39-82a9-d886c6930a0a",
   "metadata": {},
   "source": [
    "We can assign any attributes to nodes (and to edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "981e7dd5-bef6-45ec-bf33-321abe9bc2e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo['moo'] = 'loud'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70d88e12-5191-44a9-917a-5cb2ad13f422",
   "metadata": {},
   "source": [
    "Note that this attributes are not saved to the database by default - we have to tell Brightway to save changed data!\n",
    "\n",
    "We have some attributes which are common to all inventory databases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1b0bea6-ff38-4a4e-9adb-0bd0e39930ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo['categories'], moo['location'], moo['unit']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "540ee517-75ef-4550-90c5-abd89a6468b7",
   "metadata": {},
   "source": [
    "The node classes act like dictionaries, and raise error for missing keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ced6e0e-140d-4cf0-9bd1-7d1b11a9af9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "moo['missing']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4c2b8b4-dd26-49eb-9558-228005f90a1d",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Iterate through all `product` nodes in the US EEIO and tag every node whose combined name and unit is more than 40 characters long with `\"long\" = True`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "566c30d9-4d10-4fc6-be5d-0898302df65a",
   "metadata": {},
   "source": [
    "## Exchange iterators\n",
    "\n",
    "We have shortcuts to traverse the supply chain graph. For inputs, we have `.technosphere()` and `.biospere()`; for producing edges, we have `.producers()`, and for edges to other nodes which consume the outputs of our node there is `.consumers()`. You can also get all edges with `.edges()`.\n",
    "\n",
    "These are all [iterators](https://jakevdp.github.io/WhirlwindTourOfPython/10-iterators.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de2ad280-6e61-490f-9751-e4b869289ec1",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"supply chain graph\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64e79602-2e52-49c0-80fb-61efa5509282",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.technosphere())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c810b72d-155a-4e97-9117-993b7bf9b434",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.biosphere())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78df6237-2f21-4e33-87ff-5ca321c0e697",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.consumers())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0041396-cce0-4d9c-b244-a6f2ec5ef885",
   "metadata": {},
   "source": [
    "If no edge with the type `production` is given, Brightway will assume that an activity produces one unit of its reference product, so sometimes the production edges are not given explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ebd16d3-b62d-410f-b6b3-ae06d6d5fdf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(cf.producers())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cceb5ee8-c5e2-47a5-8062-4718f5c0270e",
   "metadata": {},
   "source": [
    "The US EEIO is the same, it is normalized to the production of one USD. It can be interesting to sum the costs of the inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9336bf62-7c8d-4a0a-b16b-ac1270805445",
   "metadata": {},
   "outputs": [],
   "source": [
    "bd.projects.set_current(\"USEEIO-1.1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df9e68e2-3387-4a95-b24b-430035f1d166",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([o['amount'] for o in bd.get_node(name='Cattle ranches and feedlots', type='process').technosphere()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e02c3dc-7599-4329-89d2-874dcbc4fe39",
   "metadata": {},
   "source": [
    "# Contribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f3d70db-1daa-405f-8534-ebec445414b6",
   "metadata": {},
   "source": [
    "Let's show a little bit of what Brightway can do. We can compare the correlation of LCA scores across a variety of categories.\n",
    "\n",
    "There is an atuomatic way to do this in Brightway, but we can also program it manually to see how it works.\n",
    "\n",
    "Stop for a bit and think about what one would need to calculate LCA scores for 380 products and ~10 impact categories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dc4f1a5-96ba-4f59-9957-f2b9a2b05227",
   "metadata": {},
   "outputs": [],
   "source": [
    "products_in_order = [obj for obj in db if obj['type'] == 'product']\n",
    "categories_in_order = [method for method in bd.methods if method[0] == 'Impact Potential']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0a39ef0-36f5-440e-866c-ca23819335a2",
   "metadata": {},
   "source": [
    "In general, in Brightway there is *one secret* to getting good performance: Don't rebuild matrices unless you really need to. Rebuilding a matrix is not slow, but the time adds up if you do it a lot. But most importantly, if you are using `pypardiso` (normally everything except for ARM machines), and you keep the technosphere matrix the same, it will secretly remember all the preparation work it did to solve the linear system and you will get a factor of 100 speed increase on subsequent calculations.\n",
    "\n",
    "So, in this case we will use one `LCA` object, and use the `lci` method repeatedly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f83d15e4-798f-4e6e-8c38-6735c2bbe404",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "results = np.zeros((len(products_in_order), len(categories_in_order)))\n",
    "\n",
    "def get_lcia_scores(products, categories, results):\n",
    "    lca = bc.LCA({products[0]: 1}, categories[0])\n",
    "    lca.lci()\n",
    "    lca.lcia()\n",
    "    \n",
    "    method_matrices = [lca.characterization_matrix.copy()]\n",
    "    \n",
    "    for other_method in categories[1:]:\n",
    "        # Only build each characterization matrix once instead of once per product\n",
    "        lca.switch_method(other_method)\n",
    "        method_matrices.append(lca.characterization_matrix.copy())\n",
    "    \n",
    "    for i, product in enumerate(products):\n",
    "        lca.lci({product.id: 1})\n",
    "        for j, characterization_matrix in enumerate(method_matrices):\n",
    "            results[i, j] = (characterization_matrix * lca.inventory).sum()\n",
    "    \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df88c7ef-9954-45d8-8989-6811266fef3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "\n",
    "start = time()\n",
    "results = get_lcia_scores(products_in_order, categories_in_order, results)\n",
    "print(time() - start)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c4c7746-fb11-4f18-bc0d-88dfc9f18548",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Compare how long it would take to calculate LCA results for 3 products and 3 impact categories if you had to create a new LCA object each time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8206e376-94b6-4049-bc80-449664e41ef4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "\n",
    "def create_correlation_matrix(scores_array):\n",
    "    num_methods = scores_array.shape[1]\n",
    "    correlations = np.zeros((num_methods, num_methods))\n",
    "\n",
    "    for row in range(num_methods):\n",
    "        for col in range(num_methods):\n",
    "            if col <= row:\n",
    "                continue                               # Only need to compute correlation once\n",
    "            dataset_1 = scores_array[:, row]\n",
    "            dataset_2 = scores_array[:, col]\n",
    "            mask = (dataset_1 != 0) * (dataset_2 != 0) # Ignore activities that have zero score\n",
    "            corr = stats.kendalltau( # Get tau value, drop p-statistic\n",
    "                dataset_1[mask], \n",
    "                dataset_2[mask]\n",
    "            )[0]\n",
    "            if np.isnan(corr):\n",
    "                correlations[row, col] = 0\n",
    "            else:\n",
    "                correlations[row, col] = corr\n",
    "\n",
    "    correlations = correlations + correlations.T       # Make sorting easier by adding filling in lower left triangle\n",
    "    return correlations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "153a4d9c-ed3f-4cff-a1bd-c47ac9c2427e",
   "metadata": {},
   "outputs": [],
   "source": [
    "correlation_matrix = create_correlation_matrix(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "372ccc48-c5c9-41ca-aa88-414ceebc28a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78035852-533d-4e5e-8bf2-da0429f4e097",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(12, 12)\n",
    "\n",
    "masked_correlation = np.ma.array(correlation_matrix, mask=correlation_matrix == 0).T\n",
    "plt.pcolor(masked_correlation, cmap=plt.cm.cubehelix_r)\n",
    "plt.colorbar()\n",
    "plt.ylim(None, correlation_matrix.shape[1])\n",
    "plt.xlim(None, correlation_matrix.shape[0])\n",
    "plt.xticks(np.arange(0.5, 10), [obj[1] for obj in categories_in_order])\n",
    "plt.yticks(np.arange(0.5, 10), [obj[1] for obj in categories_in_order])\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed5c1470-8e9b-4194-b321-d6f235c6661a",
   "metadata": {},
   "outputs": [],
   "source": [
    "for category in categories_in_order:\n",
    "    print(category[1], bd.methods[category]['description'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6b1798b-f8cf-410f-9756-884febef5e55",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:bw25]",
   "language": "python",
   "name": "conda-env-bw25-py"
  },
  "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}