From 3407131f60e3799a1f27442930d06fb73797e60a Mon Sep 17 00:00:00 2001 From: mabudz Date: Sun, 7 Jan 2024 21:25:39 +0100 Subject: [PATCH 01/29] init sankey --- message_ix/report/__init__.py | 1 + message_ix/util/__init__.py | 25 ++++ tutorial/westeros/westeros_sankey.ipynb | 162 ++++++++++++++++++++++++ 3 files changed, 188 insertions(+) create mode 100644 tutorial/westeros/westeros_sankey.ipynb diff --git a/message_ix/report/__init__.py b/message_ix/report/__init__.py index 5e17d7744..e3d686b8c 100644 --- a/message_ix/report/__init__.py +++ b/message_ix/report/__init__.py @@ -145,6 +145,7 @@ "message::costs", "message::emissions", ), + ("message::sankey", "concat", "out::pyam", "in::pyam"), ) diff --git a/message_ix/util/__init__.py b/message_ix/util/__init__.py index 5700c7a38..2ca8e27e0 100644 --- a/message_ix/util/__init__.py +++ b/message_ix/util/__init__.py @@ -9,6 +9,7 @@ import pandas as pd from ixmp.backend import ItemType from pandas.api.types import is_scalar +from pyam.utils import get_variable_components as gvc from message_ix.core import Scenario from message_ix.models import MACRO, MESSAGE @@ -315,3 +316,27 @@ def expand_dims(scenario: Scenario, name, **data): # Add the expanded data scenario.add_par(name, new_data) + +def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed = []): + + df_filtered = df.filter( + region=region+'*', + year=year) + + mapping = {} + for var in df_filtered['variable']: + if gvc(var, 0) == 'in': + mapping[var] = (gvc(var, [1,2], join=True), gvc(var, [3,4], join=True)) + if gvc(var, 0) == 'out': + mapping[var] = (gvc(var, [3,4], join=True), gvc(var, [1,2], join=True)) + + + + for k in mapping.keys(): + for flow in flows_not_needed: + if flow in k: + variables_not_needed.append(k) + for var in variables_not_needed: + del mapping[var] + + return mapping \ No newline at end of file diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb new file mode 100644 index 000000000..8acc18ddc --- /dev/null +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -0,0 +1,162 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Westeros Tutorial - Introducing Sankey diagrams\n", + "\n", + "Sankey diagrams are a useful technique to visualize energy flow accounts.\n", + "\n", + "This tutorial introduces the sankey feature provided by the ``pyam`` packages.\n", + "\n", + "\n", + "**Pre-requisites**\n", + "- You have the *MESSAGEix* framework installed and working\n", + " In particular, you should have installed ``message_ix``, ``pyam``, and ``plotly``\n", + "- Complete tutorial Part 1 (``westeros_baseline.ipynb``) and Introducing Reporting (``westeros_report.ipynb``)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from message_ix.report import Reporter\n", + "import ixmp\n", + "import message_ix\n", + "\n", + "mp = ixmp.Platform()\n", + "scenario = message_ix.Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Remove any existing solution\n", + "try:\n", + " scenario.remove_solution()\n", + "except ValueError:\n", + " pass\n", + "\n", + "scenario.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create the reporter object. (Since \"-\" is not a unit, we replace it by \"\".)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rep = Reporter.from_scenario(scenario)\n", + "\n", + "rep.configure(units={\"replace\": {\"-\": \"\"}})\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use the `message::sankey` reporter option to generate a pyam.dataframe including the reqiured input (`in::pyam`) and output flows (`out::pyam`) in iamc format.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df=rep.get(\"message::sankey\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The utility function `sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed=[])` can be used to create the required mapping for the `plot.sankey()` function of the `pyam` package.\n", + "\n", + "In some models it might be necessary to exclude variables and flow to get meaningful sankey diagrams. But let´s try with all!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mapping=message_ix.util.sankey_mapper(df,year=700,region=\"Westeros\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The pyam function `plot.sankey(mapping)`returns a plotly sankey figure object that can be further modified.\n", + "\n", + "To plot it as an interactive diagram in your web browser, you can do the following." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import plotly.offline as pof\n", + "fig = df.filter(year=700).plot.sankey(mapping=mapping)\n", + "pof.plot(fig) # opens a new window in your browser" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do not forget to close the database ;-) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mp.close_db()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "messageix", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.18" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7ee572e0640b214d6b3e8dde382e0f614b23c893 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Wed, 10 Jan 2024 13:11:07 +0100 Subject: [PATCH 02/29] Apply formatting and fix import from pyam * In recent pyam versions, get_variable_components moved to pyam.str --- message_ix/util/__init__.py | 24 ++++++++++-------------- tutorial/westeros/westeros_sankey.ipynb | 16 ++++++++-------- 2 files changed, 18 insertions(+), 22 deletions(-) diff --git a/message_ix/util/__init__.py b/message_ix/util/__init__.py index 2ca8e27e0..075a08425 100644 --- a/message_ix/util/__init__.py +++ b/message_ix/util/__init__.py @@ -9,7 +9,7 @@ import pandas as pd from ixmp.backend import ItemType from pandas.api.types import is_scalar -from pyam.utils import get_variable_components as gvc +from pyam.str import get_variable_components as gvc from message_ix.core import Scenario from message_ix.models import MACRO, MESSAGE @@ -317,21 +317,17 @@ def expand_dims(scenario: Scenario, name, **data): # Add the expanded data scenario.add_par(name, new_data) -def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed = []): - df_filtered = df.filter( - region=region+'*', - year=year) +def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed=[]): + df_filtered = df.filter(region=region + "*", year=year) mapping = {} - for var in df_filtered['variable']: - if gvc(var, 0) == 'in': - mapping[var] = (gvc(var, [1,2], join=True), gvc(var, [3,4], join=True)) - if gvc(var, 0) == 'out': - mapping[var] = (gvc(var, [3,4], join=True), gvc(var, [1,2], join=True)) - - - + for var in df_filtered["variable"]: + if gvc(var, 0) == "in": + mapping[var] = (gvc(var, [1, 2], join=True), gvc(var, [3, 4], join=True)) + if gvc(var, 0) == "out": + mapping[var] = (gvc(var, [3, 4], join=True), gvc(var, [1, 2], join=True)) + for k in mapping.keys(): for flow in flows_not_needed: if flow in k: @@ -339,4 +335,4 @@ def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed = for var in variables_not_needed: del mapping[var] - return mapping \ No newline at end of file + return mapping diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb index 8acc18ddc..cda97290d 100644 --- a/tutorial/westeros/westeros_sankey.ipynb +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -23,12 +23,13 @@ "metadata": {}, "outputs": [], "source": [ - "from message_ix.report import Reporter\n", "import ixmp\n", + "\n", "import message_ix\n", + "from message_ix.report import Reporter\n", "\n", "mp = ixmp.Platform()\n", - "scenario = message_ix.Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")\n" + "scenario = message_ix.Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")" ] }, { @@ -61,9 +62,7 @@ "source": [ "rep = Reporter.from_scenario(scenario)\n", "\n", - "rep.configure(units={\"replace\": {\"-\": \"\"}})\n", - "\n", - "\n" + "rep.configure(units={\"replace\": {\"-\": \"\"}})" ] }, { @@ -79,7 +78,7 @@ "metadata": {}, "outputs": [], "source": [ - "df=rep.get(\"message::sankey\")" + "df = rep.get(\"message::sankey\")" ] }, { @@ -97,7 +96,7 @@ "metadata": {}, "outputs": [], "source": [ - "mapping=message_ix.util.sankey_mapper(df,year=700,region=\"Westeros\")" + "mapping = message_ix.util.sankey_mapper(df, year=700, region=\"Westeros\")" ] }, { @@ -116,8 +115,9 @@ "outputs": [], "source": [ "import plotly.offline as pof\n", + "\n", "fig = df.filter(year=700).plot.sankey(mapping=mapping)\n", - "pof.plot(fig) # opens a new window in your browser" + "pof.plot(fig) # opens a new window in your browser" ] }, { From 1d193b56518caaa1a1d37756c9306d69579e666b Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Thu, 14 Mar 2024 14:34:04 +0100 Subject: [PATCH 03/29] Move sankey_mapper to own file --- message_ix/util/__init__.py | 21 --------------------- message_ix/util/sankey.py | 28 ++++++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 21 deletions(-) create mode 100644 message_ix/util/sankey.py diff --git a/message_ix/util/__init__.py b/message_ix/util/__init__.py index 075a08425..5700c7a38 100644 --- a/message_ix/util/__init__.py +++ b/message_ix/util/__init__.py @@ -9,7 +9,6 @@ import pandas as pd from ixmp.backend import ItemType from pandas.api.types import is_scalar -from pyam.str import get_variable_components as gvc from message_ix.core import Scenario from message_ix.models import MACRO, MESSAGE @@ -316,23 +315,3 @@ def expand_dims(scenario: Scenario, name, **data): # Add the expanded data scenario.add_par(name, new_data) - - -def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed=[]): - df_filtered = df.filter(region=region + "*", year=year) - - mapping = {} - for var in df_filtered["variable"]: - if gvc(var, 0) == "in": - mapping[var] = (gvc(var, [1, 2], join=True), gvc(var, [3, 4], join=True)) - if gvc(var, 0) == "out": - mapping[var] = (gvc(var, [3, 4], join=True), gvc(var, [1, 2], join=True)) - - for k in mapping.keys(): - for flow in flows_not_needed: - if flow in k: - variables_not_needed.append(k) - for var in variables_not_needed: - del mapping[var] - - return mapping diff --git a/message_ix/util/sankey.py b/message_ix/util/sankey.py new file mode 100644 index 000000000..c41c8e4df --- /dev/null +++ b/message_ix/util/sankey.py @@ -0,0 +1,28 @@ +from typing import Any, Optional + +import pandas as pd + +try: + from pyam.str import get_variable_components as gvc +except ImportError: # Python < 3.10, pandas < 2.0 + from pyam.utils import get_variable_components as gvc + + +def sankey_mapper( + df: pd.DataFrame, + year: int, + region: str, + exclude: list[Optional[str]] = [], +) -> dict[str, Any]: + mapping = {} + + for var in df.filter(region=region + "*", year=year).variable: + is_input = gvc(var, 0) == "in" + (start_idx, end_idx) = ([1, 2], [3, 4]) if is_input else ([3, 4], [1, 2]) + source = gvc(var, start_idx, join=True) + target = gvc(var, end_idx, join=True) + if source in exclude or target in exclude: + continue + mapping[var] = (source, target) + + return mapping From 295fda5281fb6fcf73c0b2058f3f0c7b42474e7c Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Thu, 14 Mar 2024 14:34:24 +0100 Subject: [PATCH 04/29] Add plotly as optional dependency --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 7f47e878e..17182d5de 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,7 +55,7 @@ docs = [ "sphinx_rtd_theme", "sphinxcontrib-bibtex", ] -tutorial = ["jupyter", "matplotlib", "message_ix[report]"] +tutorial = ["jupyter", "matplotlib", "message_ix[report]", "plotly"] report = ["ixmp[report]"] tests = [ "asyncssh", From fb3ea1993aa3c5053f93ef802e1878773d8eac1b Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Thu, 14 Mar 2024 14:35:11 +0100 Subject: [PATCH 05/29] Update tutorial --- tutorial/westeros/westeros_sankey.ipynb | 58 ++++++++++++++++++++----- 1 file changed, 48 insertions(+), 10 deletions(-) diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb index cda97290d..a172a9d7e 100644 --- a/tutorial/westeros/westeros_sankey.ipynb +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -25,11 +25,10 @@ "source": [ "import ixmp\n", "\n", - "import message_ix\n", - "from message_ix.report import Reporter\n", + "from message_ix import Scenario\n", "\n", "mp = ixmp.Platform()\n", - "scenario = message_ix.Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")" + "scenario = Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")" ] }, { @@ -51,7 +50,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Create the reporter object. (Since \"-\" is not a unit, we replace it by \"\".)" + "Create the reporter object. (Since ``\"-\"`` is not a unit, we replace it by ``\"\"``.)" ] }, { @@ -60,6 +59,8 @@ "metadata": {}, "outputs": [], "source": [ + "from message_ix.report import Reporter\n", + "\n", "rep = Reporter.from_scenario(scenario)\n", "\n", "rep.configure(units={\"replace\": {\"-\": \"\"}})" @@ -85,7 +86,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The utility function `sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed=[])` can be used to create the required mapping for the `plot.sankey()` function of the `pyam` package.\n", + "The utility function `sankey_mapper(df, year, region, exclude=[])` can be used to create the required mapping for the `figures.sankey()` function of the `pyam` package.\n", "\n", "In some models it might be necessary to exclude variables and flow to get meaningful sankey diagrams. But let´s try with all!" ] @@ -96,7 +97,9 @@ "metadata": {}, "outputs": [], "source": [ - "mapping = message_ix.util.sankey_mapper(df, year=700, region=\"Westeros\")" + "from message_ix.util.sankey import sankey_mapper\n", + "\n", + "mapping = sankey_mapper(df, year=700, region=\"Westeros\")" ] }, { @@ -114,10 +117,45 @@ "metadata": {}, "outputs": [], "source": [ - "import plotly.offline as pof\n", + "from pyam.figures import sankey\n", "\n", - "fig = df.filter(year=700).plot.sankey(mapping=mapping)\n", - "pof.plot(fig) # opens a new window in your browser" + "fig = sankey(df=df.filter(year=700), mapping=mapping)\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mapping_without_final_electricity = sankey_mapper(\n", + " df, year=700, region=\"Westeros\", exclude=[\"final|electricity\"]\n", + ")\n", + "mapping_without_final_electricity" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = sankey(df=df.filter(year=700), mapping=mapping_without_final_electricity)\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mapping_without_wind_ppl_standard = sankey_mapper(\n", + " df, year=700, region=\"Westeros\", exclude=[\"wind_ppl|standard\"]\n", + ")\n", + "fig = sankey(df=df.filter(year=700), mapping=mapping_without_wind_ppl_standard)\n", + "fig.show()" ] }, { @@ -153,7 +191,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.18" + "version": "3.10.12" }, "orig_nbformat": 4 }, From 6d89e5aadbcc7fbb955f9f60e75c8e89b0a0a9fd Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Thu, 14 Mar 2024 14:44:39 +0100 Subject: [PATCH 06/29] Remove forgotten temp output --- tutorial/westeros/westeros_sankey.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb index a172a9d7e..957058142 100644 --- a/tutorial/westeros/westeros_sankey.ipynb +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -131,8 +131,7 @@ "source": [ "mapping_without_final_electricity = sankey_mapper(\n", " df, year=700, region=\"Westeros\", exclude=[\"final|electricity\"]\n", - ")\n", - "mapping_without_final_electricity" + ")" ] }, { From cd7433153ca5ca8a8cae24cf026ac2c1c5e85853 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Thu, 14 Mar 2024 14:44:54 +0100 Subject: [PATCH 07/29] Add test for sankey_mapper --- message_ix/tests/test_util.py | 54 +++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/message_ix/tests/test_util.py b/message_ix/tests/test_util.py index bb29e6dc5..f579aef76 100644 --- a/message_ix/tests/test_util.py +++ b/message_ix/tests/test_util.py @@ -4,7 +4,9 @@ import pytest from message_ix import Scenario, make_df +from message_ix.report import Reporter from message_ix.testing import make_dantzig, make_westeros +from message_ix.util.sankey import sankey_mapper def test_make_df(): @@ -59,3 +61,55 @@ def test_testing_make_scenario(test_mp, request): # Westeros model can be created scen = make_westeros(test_mp, solve=True, request=request) assert isinstance(scen, Scenario) + + +def test_sankey_mapper(test_mp): + # NB: we actually only need a pd.DataFrame that has the same form as the result of + # these setup steps, so maybe this can be simplified + scen = make_westeros(test_mp, solve=True) + rep = Reporter.from_scenario(scen) + rep.configure(units={"replace": {"-": ""}}) + df = rep.get("message::sankey") + + # Set expectations + expected_all = { + "in|final|electricity|bulb|standard": ("final|electricity", "bulb|standard"), + "in|secondary|electricity|grid|standard": ( + "secondary|electricity", + "grid|standard", + ), + "out|final|electricity|grid|standard": ("grid|standard", "final|electricity"), + "out|secondary|electricity|coal_ppl|standard": ( + "coal_ppl|standard", + "secondary|electricity", + ), + "out|secondary|electricity|wind_ppl|standard": ( + "wind_ppl|standard", + "secondary|electricity", + ), + "out|useful|light|bulb|standard": ("bulb|standard", "useful|light"), + } + expected_without_final_electricity = { + "in|secondary|electricity|grid|standard": ( + "secondary|electricity", + "grid|standard", + ), + "out|secondary|electricity|coal_ppl|standard": ( + "coal_ppl|standard", + "secondary|electricity", + ), + "out|secondary|electricity|wind_ppl|standard": ( + "wind_ppl|standard", + "secondary|electricity", + ), + "out|useful|light|bulb|standard": ("bulb|standard", "useful|light"), + } + + # Load all variables + mapping_all = sankey_mapper(df, year=700, region="Westeros") + assert mapping_all == expected_all + + mapping_without_final_electricity = sankey_mapper( + df, year=700, region="Westeros", exclude=["final|electricity"] + ) + assert mapping_without_final_electricity == expected_without_final_electricity From 29f8137dc20c2cfc2517d49ec669202aa05178e1 Mon Sep 17 00:00:00 2001 From: mabudz Date: Sun, 7 Jan 2024 21:25:39 +0100 Subject: [PATCH 08/29] init sankey --- message_ix/util/__init__.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/message_ix/util/__init__.py b/message_ix/util/__init__.py index 5700c7a38..2ca8e27e0 100644 --- a/message_ix/util/__init__.py +++ b/message_ix/util/__init__.py @@ -9,6 +9,7 @@ import pandas as pd from ixmp.backend import ItemType from pandas.api.types import is_scalar +from pyam.utils import get_variable_components as gvc from message_ix.core import Scenario from message_ix.models import MACRO, MESSAGE @@ -315,3 +316,27 @@ def expand_dims(scenario: Scenario, name, **data): # Add the expanded data scenario.add_par(name, new_data) + +def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed = []): + + df_filtered = df.filter( + region=region+'*', + year=year) + + mapping = {} + for var in df_filtered['variable']: + if gvc(var, 0) == 'in': + mapping[var] = (gvc(var, [1,2], join=True), gvc(var, [3,4], join=True)) + if gvc(var, 0) == 'out': + mapping[var] = (gvc(var, [3,4], join=True), gvc(var, [1,2], join=True)) + + + + for k in mapping.keys(): + for flow in flows_not_needed: + if flow in k: + variables_not_needed.append(k) + for var in variables_not_needed: + del mapping[var] + + return mapping \ No newline at end of file From 372adff27ef46ee3802ca7d6e69713e10340b47b Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Wed, 10 Jan 2024 13:11:07 +0100 Subject: [PATCH 09/29] Apply formatting and fix import from pyam * In recent pyam versions, get_variable_components moved to pyam.str --- message_ix/util/__init__.py | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/message_ix/util/__init__.py b/message_ix/util/__init__.py index 2ca8e27e0..075a08425 100644 --- a/message_ix/util/__init__.py +++ b/message_ix/util/__init__.py @@ -9,7 +9,7 @@ import pandas as pd from ixmp.backend import ItemType from pandas.api.types import is_scalar -from pyam.utils import get_variable_components as gvc +from pyam.str import get_variable_components as gvc from message_ix.core import Scenario from message_ix.models import MACRO, MESSAGE @@ -317,21 +317,17 @@ def expand_dims(scenario: Scenario, name, **data): # Add the expanded data scenario.add_par(name, new_data) -def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed = []): - df_filtered = df.filter( - region=region+'*', - year=year) +def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed=[]): + df_filtered = df.filter(region=region + "*", year=year) mapping = {} - for var in df_filtered['variable']: - if gvc(var, 0) == 'in': - mapping[var] = (gvc(var, [1,2], join=True), gvc(var, [3,4], join=True)) - if gvc(var, 0) == 'out': - mapping[var] = (gvc(var, [3,4], join=True), gvc(var, [1,2], join=True)) - - - + for var in df_filtered["variable"]: + if gvc(var, 0) == "in": + mapping[var] = (gvc(var, [1, 2], join=True), gvc(var, [3, 4], join=True)) + if gvc(var, 0) == "out": + mapping[var] = (gvc(var, [3, 4], join=True), gvc(var, [1, 2], join=True)) + for k in mapping.keys(): for flow in flows_not_needed: if flow in k: @@ -339,4 +335,4 @@ def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed = for var in variables_not_needed: del mapping[var] - return mapping \ No newline at end of file + return mapping From a733d19f1c13b76b1550bec70c6fa82ff120fa1d Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Thu, 14 Mar 2024 14:34:04 +0100 Subject: [PATCH 10/29] Move sankey_mapper to own file --- message_ix/util/__init__.py | 21 --------------------- 1 file changed, 21 deletions(-) diff --git a/message_ix/util/__init__.py b/message_ix/util/__init__.py index 075a08425..5700c7a38 100644 --- a/message_ix/util/__init__.py +++ b/message_ix/util/__init__.py @@ -9,7 +9,6 @@ import pandas as pd from ixmp.backend import ItemType from pandas.api.types import is_scalar -from pyam.str import get_variable_components as gvc from message_ix.core import Scenario from message_ix.models import MACRO, MESSAGE @@ -316,23 +315,3 @@ def expand_dims(scenario: Scenario, name, **data): # Add the expanded data scenario.add_par(name, new_data) - - -def sankey_mapper(df, year, region, flows_not_needed=[], variables_not_needed=[]): - df_filtered = df.filter(region=region + "*", year=year) - - mapping = {} - for var in df_filtered["variable"]: - if gvc(var, 0) == "in": - mapping[var] = (gvc(var, [1, 2], join=True), gvc(var, [3, 4], join=True)) - if gvc(var, 0) == "out": - mapping[var] = (gvc(var, [3, 4], join=True), gvc(var, [1, 2], join=True)) - - for k in mapping.keys(): - for flow in flows_not_needed: - if flow in k: - variables_not_needed.append(k) - for var in variables_not_needed: - del mapping[var] - - return mapping From 03f371df8892947f541b1c7ce27ecba4e4108039 Mon Sep 17 00:00:00 2001 From: daymontas1 Date: Wed, 5 Jun 2024 13:58:53 +0200 Subject: [PATCH 11/29] Extract sankey functionality from init and update the westeros_sankey tutorial --- tutorial/westeros/westeros_sankey.ipynb | 2867 ++++++++++++++++++++++- 1 file changed, 2847 insertions(+), 20 deletions(-) diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb index 957058142..186c810ce 100644 --- a/tutorial/westeros/westeros_sankey.ipynb +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -19,13 +19,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 1, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ "import ixmp\n", "\n", "from message_ix import Scenario\n", + "# Import Sankey functionality\n", + "from message_ix.report.sankey import SankeyReporter\n", "\n", "mp = ixmp.Platform()\n", "scenario = Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")" @@ -33,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -55,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -75,9 +79,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], + "source": [ + "SankeyReporter.add_tasks(rep)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "output: mixed units ['-', 'GWa'] discarded\n" + ] + } + ], "source": [ "df = rep.get(\"message::sankey\")" ] @@ -93,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -113,9 +134,963 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\koutsandreas\\AppData\\Local\\miniconda3\\envs\\message_new\\Lib\\site-packages\\pyam\\figures.py:58: FutureWarning: Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n", + " _df.replace(label_mapping, inplace=True)\n" + ] + }, + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "link": { + "hovertemplate": "\"%{source.label}\" to \"%{target.label}\": %{value}", + "source": [ + 1, + 3, + 0, + 6, + 4, + 5 + ], + "target": [ + 5, + 0, + 1, + 3, + 3, + 2 + ], + "value": [ + 55, + 61.111111111111114, + 55.00000000000001, + 47.37429150867584, + 13.736819602435279, + 55 + ] + }, + "node": { + "color": "blue", + "hovertemplate": "%{label}: %{value}", + "label": [ + "grid|standard", + "final|electricity", + "useful|light", + "secondary|electricity", + "wind_ppl|standard", + "bulb|standard", + "coal_ppl|standard" + ], + "line": { + "color": "black", + "width": 0.5 + }, + "pad": 15, + "thickness": 10 + }, + "type": "sankey", + "valuesuffix": "" + } + ], + "layout": { + "autosize": true, + "font": { + "size": 10 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "region: Westeros|Westeros, year: 700" + } + } + }, + "image/png": "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", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from pyam.figures import sankey\n", "\n", @@ -125,7 +1100,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -136,9 +1111,929 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\koutsandreas\\AppData\\Local\\miniconda3\\envs\\message_new\\Lib\\site-packages\\pyam\\figures.py:58: FutureWarning:\n", + "\n", + "Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n", + "\n" + ] + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "link": { + "hovertemplate": "\"%{source.label}\" to \"%{target.label}\": %{value}", + "source": [ + 2, + 5, + 3, + 4 + ], + "target": [ + 0, + 2, + 2, + 1 + ], + "value": [ + 61.111111111111114, + 47.37429150867584, + 13.736819602435279, + 55 + ] + }, + "node": { + "color": "blue", + "hovertemplate": "%{label}: %{value}", + "label": [ + "grid|standard", + "useful|light", + "secondary|electricity", + "wind_ppl|standard", + "bulb|standard", + "coal_ppl|standard" + ], + "line": { + "color": "black", + "width": 0.5 + }, + "pad": 15, + "thickness": 10 + }, + "type": "sankey", + "valuesuffix": "" + } + ], + "layout": { + "autosize": true, + "font": { + "size": 10 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "region: Westeros|Westeros, year: 700" + } + } + }, + "image/png": "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", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = sankey(df=df.filter(year=700), mapping=mapping_without_final_electricity)\n", "fig.show()" @@ -146,12 +2041,938 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\koutsandreas\\AppData\\Local\\miniconda3\\envs\\message_new\\Lib\\site-packages\\pyam\\figures.py:58: FutureWarning:\n", + "\n", + "Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n", + "\n" + ] + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "link": { + "hovertemplate": "\"%{source.label}\" to \"%{target.label}\": %{value}", + "source": [ + 1, + 3, + 0, + 5, + 4 + ], + "target": [ + 4, + 0, + 1, + 3, + 2 + ], + "value": [ + 55, + 61.111111111111114, + 55.00000000000001, + 47.37429150867584, + 55 + ] + }, + "node": { + "color": "blue", + "hovertemplate": "%{label}: %{value}", + "label": [ + "grid|standard", + "final|electricity", + "useful|light", + "secondary|electricity", + "bulb|standard", + "coal_ppl|standard" + ], + "line": { + "color": "black", + "width": 0.5 + }, + "pad": 15, + "thickness": 10 + }, + "type": "sankey", + "valuesuffix": "" + } + ], + "layout": { + "autosize": true, + "font": { + "size": 10 + }, + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "region: Westeros|Westeros, year: 700" + } + } + }, + "image/png": "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", + "text/html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "mapping_without_wind_ppl_standard = sankey_mapper(\n", - " df, year=700, region=\"Westeros\", exclude=[\"wind_ppl|standard\"]\n", + " df,\n", + " year=700,\n", + " region=\"Westeros\",\n", + " exclude=[\"wind_ppl|standard\"],\n", ")\n", "fig = sankey(df=df.filter(year=700), mapping=mapping_without_wind_ppl_standard)\n", "fig.show()" @@ -166,17 +2987,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "mp.close_db()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "messageix", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -190,10 +3018,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 + "version": "3.12.3" + } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From aff53b80d2d270eafd18503d31a24bd878d003c0 Mon Sep 17 00:00:00 2001 From: daymontas1 Date: Wed, 5 Jun 2024 14:14:20 +0200 Subject: [PATCH 12/29] Extract sankey functionality from init and update the westeros_sankey tutorial --- message_ix/report/sankey.py | 69 +++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 message_ix/report/sankey.py diff --git a/message_ix/report/sankey.py b/message_ix/report/sankey.py new file mode 100644 index 000000000..bcb84fd89 --- /dev/null +++ b/message_ix/report/sankey.py @@ -0,0 +1,69 @@ +<<<<<<< HEAD +import logging +from functools import partial +from typing import Tuple, Mapping, List + +from genno.operator import broadcast_map +from ixmp.report import Key +from .pyam import collapse_message_cols + +# Assuming TASKS1 was where Sankey tasks were defined: +TASKS1 = ( + ("message::sankey", "concat", "out::pyam", "in::pyam"), +) + +def get_sankey_tasks() -> List[Tuple[Tuple, Mapping]]: + """Return a list of tasks for Sankey diagram reporting.""" + to_add: List[Tuple[Tuple, Mapping]] = [] + strict = dict(strict=True) + + # This might include specific Sankey diagram configuration or additional tasks. + for t in TASKS1: + to_add.append((t, strict)) + + return to_add + +class SankeyReporter: + """A specialized reporter for generating Sankey diagrams.""" + + @staticmethod + def add_tasks(reporter, fail_action: str = "raise") -> None: + """Add Sankey-related tasks to a given reporter.""" + reporter.add_queue(get_sankey_tasks(), fail=fail_action) + +# This class can then be imported and used in your main reporting script to add Sankey tasks. +======= +import logging +from functools import partial +from typing import Tuple, Mapping, List + +from genno.operator import broadcast_map +from ixmp.report import Key +from .pyam import collapse_message_cols + +# Assuming TASKS1 was where Sankey tasks were defined: +TASKS1 = ( + ("message::sankey", "concat", "out::pyam", "in::pyam"), +) + +def get_sankey_tasks() -> List[Tuple[Tuple, Mapping]]: + """Return a list of tasks for Sankey diagram reporting.""" + to_add: List[Tuple[Tuple, Mapping]] = [] + strict = dict(strict=True) + + # This might include specific Sankey diagram configuration or additional tasks. + for t in TASKS1: + to_add.append((t, strict)) + + return to_add + +class SankeyReporter: + """A specialized reporter for generating Sankey diagrams.""" + + @staticmethod + def add_tasks(reporter, fail_action: str = "raise") -> None: + """Add Sankey-related tasks to a given reporter.""" + reporter.add_queue(get_sankey_tasks(), fail=fail_action) + +# This class can then be imported and used in your main reporting script to add Sankey tasks. +>>>>>>> 72ca946039b356740f500ef0fd141d03bea6ed50 From 244e583b510f21682c52e97ad6ce2a59b8e1884c Mon Sep 17 00:00:00 2001 From: daymontas1 Date: Wed, 5 Jun 2024 14:17:13 +0200 Subject: [PATCH 13/29] Extract sankey functionality from init and update the westeros_sankey tutorial --- message_ix/report/__init__.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/message_ix/report/__init__.py b/message_ix/report/__init__.py index e3d686b8c..40e35762c 100644 --- a/message_ix/report/__init__.py +++ b/message_ix/report/__init__.py @@ -125,7 +125,6 @@ ("emi:nl-t-ya-m-e", dict(kind="emi", var="emis")), ] -#: Automatic reports that :func:`~genno.operator.concat` quantities converted to IAMC #: format. TASKS1 = ( ( @@ -145,7 +144,6 @@ "message::costs", "message::emissions", ), - ("message::sankey", "concat", "out::pyam", "in::pyam"), ) From dba4d29b2231cc110f6bad7c9e4c49c9bdf8f353 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Mon, 23 Sep 2024 15:44:51 +0200 Subject: [PATCH 14/29] Clean up report/sankey after rebase --- message_ix/report/sankey.py | 50 +++---------------------------------- 1 file changed, 3 insertions(+), 47 deletions(-) diff --git a/message_ix/report/sankey.py b/message_ix/report/sankey.py index bcb84fd89..e0503d161 100644 --- a/message_ix/report/sankey.py +++ b/message_ix/report/sankey.py @@ -1,50 +1,8 @@ -<<<<<<< HEAD -import logging -from functools import partial -from typing import Tuple, Mapping, List - -from genno.operator import broadcast_map -from ixmp.report import Key -from .pyam import collapse_message_cols +from typing import List, Mapping, Tuple # Assuming TASKS1 was where Sankey tasks were defined: -TASKS1 = ( - ("message::sankey", "concat", "out::pyam", "in::pyam"), -) +TASKS1 = (("message::sankey", "concat", "out::pyam", "in::pyam"),) -def get_sankey_tasks() -> List[Tuple[Tuple, Mapping]]: - """Return a list of tasks for Sankey diagram reporting.""" - to_add: List[Tuple[Tuple, Mapping]] = [] - strict = dict(strict=True) - - # This might include specific Sankey diagram configuration or additional tasks. - for t in TASKS1: - to_add.append((t, strict)) - - return to_add - -class SankeyReporter: - """A specialized reporter for generating Sankey diagrams.""" - - @staticmethod - def add_tasks(reporter, fail_action: str = "raise") -> None: - """Add Sankey-related tasks to a given reporter.""" - reporter.add_queue(get_sankey_tasks(), fail=fail_action) - -# This class can then be imported and used in your main reporting script to add Sankey tasks. -======= -import logging -from functools import partial -from typing import Tuple, Mapping, List - -from genno.operator import broadcast_map -from ixmp.report import Key -from .pyam import collapse_message_cols - -# Assuming TASKS1 was where Sankey tasks were defined: -TASKS1 = ( - ("message::sankey", "concat", "out::pyam", "in::pyam"), -) def get_sankey_tasks() -> List[Tuple[Tuple, Mapping]]: """Return a list of tasks for Sankey diagram reporting.""" @@ -57,6 +15,7 @@ def get_sankey_tasks() -> List[Tuple[Tuple, Mapping]]: return to_add + class SankeyReporter: """A specialized reporter for generating Sankey diagrams.""" @@ -64,6 +23,3 @@ class SankeyReporter: def add_tasks(reporter, fail_action: str = "raise") -> None: """Add Sankey-related tasks to a given reporter.""" reporter.add_queue(get_sankey_tasks(), fail=fail_action) - -# This class can then be imported and used in your main reporting script to add Sankey tasks. ->>>>>>> 72ca946039b356740f500ef0fd141d03bea6ed50 From a3743e1e5bc89a8bb0e96dfd93dc182289f54251 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Mon, 23 Sep 2024 15:45:10 +0200 Subject: [PATCH 15/29] Clean up westeros_sankey after rebase --- tutorial/westeros/westeros_sankey.ipynb | 2847 +---------------------- 1 file changed, 18 insertions(+), 2829 deletions(-) diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb index 186c810ce..e5d8b811d 100644 --- a/tutorial/westeros/westeros_sankey.ipynb +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "scrolled": true }, @@ -28,8 +28,6 @@ "import ixmp\n", "\n", "from message_ix import Scenario\n", - "# Import Sankey functionality\n", - "from message_ix.report.sankey import SankeyReporter\n", "\n", "mp = ixmp.Platform()\n", "scenario = Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")" @@ -37,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -59,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -79,26 +77,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "# Import Sankey functionality\n", + "from message_ix.report.sankey import SankeyReporter\n", + "\n", "SankeyReporter.add_tasks(rep)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "output: mixed units ['-', 'GWa'] discarded\n" - ] - } - ], + "outputs": [], "source": [ "df = rep.get(\"message::sankey\")" ] @@ -114,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -134,963 +127,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\koutsandreas\\AppData\\Local\\miniconda3\\envs\\message_new\\Lib\\site-packages\\pyam\\figures.py:58: FutureWarning: Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n", - " _df.replace(label_mapping, inplace=True)\n" - ] - }, - { - "data": { - "text/html": [ - " \n", - " " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "link": { - "hovertemplate": "\"%{source.label}\" to \"%{target.label}\": %{value}", - "source": [ - 1, - 3, - 0, - 6, - 4, - 5 - ], - "target": [ - 5, - 0, - 1, - 3, - 3, - 2 - ], - "value": [ - 55, - 61.111111111111114, - 55.00000000000001, - 47.37429150867584, - 13.736819602435279, - 55 - ] - }, - "node": { - "color": "blue", - "hovertemplate": "%{label}: %{value}", - "label": [ - "grid|standard", - "final|electricity", - "useful|light", - "secondary|electricity", - "wind_ppl|standard", - "bulb|standard", - "coal_ppl|standard" - ], - "line": { - "color": "black", - "width": 0.5 - }, - "pad": 15, - "thickness": 10 - }, - "type": "sankey", - "valuesuffix": "" - } - ], - "layout": { - "autosize": true, - "font": { - "size": 10 - }, - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "fillpattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "region: Westeros|Westeros, year: 700" - } - } - }, - "image/png": "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", - "text/html": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from pyam.figures import sankey\n", "\n", @@ -1100,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1111,929 +150,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\koutsandreas\\AppData\\Local\\miniconda3\\envs\\message_new\\Lib\\site-packages\\pyam\\figures.py:58: FutureWarning:\n", - "\n", - "Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n", - "\n" - ] - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "link": { - "hovertemplate": "\"%{source.label}\" to \"%{target.label}\": %{value}", - "source": [ - 2, - 5, - 3, - 4 - ], - "target": [ - 0, - 2, - 2, - 1 - ], - "value": [ - 61.111111111111114, - 47.37429150867584, - 13.736819602435279, - 55 - ] - }, - "node": { - "color": "blue", - "hovertemplate": "%{label}: %{value}", - "label": [ - "grid|standard", - "useful|light", - "secondary|electricity", - "wind_ppl|standard", - "bulb|standard", - "coal_ppl|standard" - ], - "line": { - "color": "black", - "width": 0.5 - }, - "pad": 15, - "thickness": 10 - }, - "type": "sankey", - "valuesuffix": "" - } - ], - "layout": { - "autosize": true, - "font": { - "size": 10 - }, - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "fillpattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "region: Westeros|Westeros, year: 700" - } - } - }, - "image/png": "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", - "text/html": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = sankey(df=df.filter(year=700), mapping=mapping_without_final_electricity)\n", "fig.show()" @@ -2041,932 +160,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\koutsandreas\\AppData\\Local\\miniconda3\\envs\\message_new\\Lib\\site-packages\\pyam\\figures.py:58: FutureWarning:\n", - "\n", - "Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`\n", - "\n" - ] - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "link": { - "hovertemplate": "\"%{source.label}\" to \"%{target.label}\": %{value}", - "source": [ - 1, - 3, - 0, - 5, - 4 - ], - "target": [ - 4, - 0, - 1, - 3, - 2 - ], - "value": [ - 55, - 61.111111111111114, - 55.00000000000001, - 47.37429150867584, - 55 - ] - }, - "node": { - "color": "blue", - "hovertemplate": "%{label}: %{value}", - "label": [ - "grid|standard", - "final|electricity", - "useful|light", - "secondary|electricity", - "bulb|standard", - "coal_ppl|standard" - ], - "line": { - "color": "black", - "width": 0.5 - }, - "pad": 15, - "thickness": 10 - }, - "type": "sankey", - "valuesuffix": "" - } - ], - "layout": { - "autosize": true, - "font": { - "size": 10 - }, - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "fillpattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "region: Westeros|Westeros, year: 700" - } - } - }, - "image/png": "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", - "text/html": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "mapping_without_wind_ppl_standard = sankey_mapper(\n", " df,\n", @@ -2987,19 +183,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mp.close_db()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From df93425e0a4ebfe1a6879b5424445a568f654a7d Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 09:05:37 +0200 Subject: [PATCH 16/29] Restore mysteriously deleted line --- message_ix/report/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/message_ix/report/__init__.py b/message_ix/report/__init__.py index 40e35762c..5e17d7744 100644 --- a/message_ix/report/__init__.py +++ b/message_ix/report/__init__.py @@ -125,6 +125,7 @@ ("emi:nl-t-ya-m-e", dict(kind="emi", var="emis")), ] +#: Automatic reports that :func:`~genno.operator.concat` quantities converted to IAMC #: format. TASKS1 = ( ( From 9c3d4f68ab0de36c9bca38c46f8d398063ac22f3 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:05:10 +0200 Subject: [PATCH 17/29] Allow adding sankey-computations as Reporter. function --- message_ix/report/__init__.py | 21 +++++++++++++++++++++ message_ix/report/sankey.py | 25 ------------------------- 2 files changed, 21 insertions(+), 25 deletions(-) delete mode 100644 message_ix/report/sankey.py diff --git a/message_ix/report/__init__.py b/message_ix/report/__init__.py index 5e17d7744..b453728e8 100644 --- a/message_ix/report/__init__.py +++ b/message_ix/report/__init__.py @@ -243,3 +243,24 @@ def add_tasks(self, fail_action: Union[int, str] = "raise") -> None: # Use a queue pattern via Reporter.add_queue() self.add_queue(get_tasks(), fail=fail_action) + + def add_sankey(self, fail_action: Union[int, str] = "raise") -> None: + """Add the calculations required to produce Sankey plots. + + Parameters + ---------- + fail_action : "raise" or int + :mod:`logging` level or level name, passed to the `fail` argument of + :meth:`.Reporter.add_queue`. + """ + # NOTE This includes just one task for the base version, but could later be + # expanded. + self.add_queue( + [ + ( + ("message::sankey", "concat", "out::pyam", "in::pyam"), + dict(strict=True), + ) + ], + fail=fail_action, + ) diff --git a/message_ix/report/sankey.py b/message_ix/report/sankey.py deleted file mode 100644 index e0503d161..000000000 --- a/message_ix/report/sankey.py +++ /dev/null @@ -1,25 +0,0 @@ -from typing import List, Mapping, Tuple - -# Assuming TASKS1 was where Sankey tasks were defined: -TASKS1 = (("message::sankey", "concat", "out::pyam", "in::pyam"),) - - -def get_sankey_tasks() -> List[Tuple[Tuple, Mapping]]: - """Return a list of tasks for Sankey diagram reporting.""" - to_add: List[Tuple[Tuple, Mapping]] = [] - strict = dict(strict=True) - - # This might include specific Sankey diagram configuration or additional tasks. - for t in TASKS1: - to_add.append((t, strict)) - - return to_add - - -class SankeyReporter: - """A specialized reporter for generating Sankey diagrams.""" - - @staticmethod - def add_tasks(reporter, fail_action: str = "raise") -> None: - """Add Sankey-related tasks to a given reporter.""" - reporter.add_queue(get_sankey_tasks(), fail=fail_action) From 155f530787008447167b3ab983d4dd758cbbdc06 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:06:26 +0200 Subject: [PATCH 18/29] Test reporter.add_sankey --- message_ix/tests/test_report.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/message_ix/tests/test_report.py b/message_ix/tests/test_report.py index 9523a23fe..ca00d36a5 100644 --- a/message_ix/tests/test_report.py +++ b/message_ix/tests/test_report.py @@ -272,3 +272,20 @@ def add_tm(df, name="Activity"): # Results have the expected units assert all(df5["unit"] == "centiUSD / case") assert_series_equal(df4["value"], df5["value"] / 100.0) + + +def test_reporter_add_sankey(test_mp, request): + scen = make_westeros( + test_mp, emissions=True, solve=True, quiet=True, request=request + ) + + # Reporter.from_scenario can handle Westeros example model + rep = Reporter.from_scenario(scen) + + # Westeros-specific configuration: '-' is a reserved character in pint + configure(units={"replace": {"-": ""}}) + + # Add Sankey calculation(s) + rep.add_sankey() + + assert rep.check_keys("message::sankey") From 153fbe1b23e5ea2d8b4f0bee0c3561d8c85a1504 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:13:26 +0200 Subject: [PATCH 19/29] Refactor map_for_sankey and corresponding test --- message_ix/tests/test_util.py | 31 +++++--------- message_ix/util/sankey.py | 80 ++++++++++++++++++++++++++--------- 2 files changed, 72 insertions(+), 39 deletions(-) diff --git a/message_ix/tests/test_util.py b/message_ix/tests/test_util.py index f579aef76..61d0238af 100644 --- a/message_ix/tests/test_util.py +++ b/message_ix/tests/test_util.py @@ -6,7 +6,7 @@ from message_ix import Scenario, make_df from message_ix.report import Reporter from message_ix.testing import make_dantzig, make_westeros -from message_ix.util.sankey import sankey_mapper +from message_ix.util.sankey import map_for_sankey def test_make_df(): @@ -63,12 +63,13 @@ def test_testing_make_scenario(test_mp, request): assert isinstance(scen, Scenario) -def test_sankey_mapper(test_mp): - # NB: we actually only need a pd.DataFrame that has the same form as the result of - # these setup steps, so maybe this can be simplified - scen = make_westeros(test_mp, solve=True) +def test_map_for_sankey(test_mp, request): + # NB: we actually only need a pyam.IamDataFrame that has the same form as the result + # of these setup steps, so maybe this can be simplified + scen = make_westeros(test_mp, solve=True, request=request) rep = Reporter.from_scenario(scen) rep.configure(units={"replace": {"-": ""}}) + rep.add_sankey() df = rep.get("message::sankey") # Set expectations @@ -90,26 +91,16 @@ def test_sankey_mapper(test_mp): "out|useful|light|bulb|standard": ("bulb|standard", "useful|light"), } expected_without_final_electricity = { - "in|secondary|electricity|grid|standard": ( - "secondary|electricity", - "grid|standard", - ), - "out|secondary|electricity|coal_ppl|standard": ( - "coal_ppl|standard", - "secondary|electricity", - ), - "out|secondary|electricity|wind_ppl|standard": ( - "wind_ppl|standard", - "secondary|electricity", - ), - "out|useful|light|bulb|standard": ("bulb|standard", "useful|light"), + key: value + for (key, value) in expected_all.items() + if "final|electricity" not in value } # Load all variables - mapping_all = sankey_mapper(df, year=700, region="Westeros") + mapping_all = map_for_sankey(df, year=700, region="Westeros") assert mapping_all == expected_all - mapping_without_final_electricity = sankey_mapper( + mapping_without_final_electricity = map_for_sankey( df, year=700, region="Westeros", exclude=["final|electricity"] ) assert mapping_without_final_electricity == expected_without_final_electricity diff --git a/message_ix/util/sankey.py b/message_ix/util/sankey.py index c41c8e4df..e22f11fe3 100644 --- a/message_ix/util/sankey.py +++ b/message_ix/util/sankey.py @@ -1,28 +1,70 @@ -from typing import Any, Optional +from typing import Any, List, LiteralString, Optional, Tuple, Union -import pandas as pd +from pyam import IamDataFrame try: - from pyam.str import get_variable_components as gvc + from pyam.str import get_variable_components except ImportError: # Python < 3.10, pandas < 2.0 - from pyam.utils import get_variable_components as gvc + from pyam.utils import get_variable_components -def sankey_mapper( - df: pd.DataFrame, +def map_for_sankey( + iam_df: IamDataFrame, year: int, region: str, exclude: list[Optional[str]] = [], -) -> dict[str, Any]: - mapping = {} - - for var in df.filter(region=region + "*", year=year).variable: - is_input = gvc(var, 0) == "in" - (start_idx, end_idx) = ([1, 2], [3, 4]) if is_input else ([3, 4], [1, 2]) - source = gvc(var, start_idx, join=True) - target = gvc(var, end_idx, join=True) - if source in exclude or target in exclude: - continue - mapping[var] = (source, target) - - return mapping +) -> dict[str, Tuple[Union[List, Any, LiteralString], Union[List, Any, LiteralString]]]: + """Maps input to output flows to enable Sankey plots. + + Parameters + ---------- + iam_df: :class:`pyam.IamDataframe` + The IAMC-format DataFrame holding the data to plot as Sankey diagrams. + year: int + The year to display in the Sankey diagram. + region: str + The region to display in the Sankey diagram. + exclude: list[str], optional + If provided, exclude these keys from the Sankey diagram. Defaults to an empty + list, i.e. showing all flows. + + Returns + ------- + mapping: dict + A mapping from variable names to their inputs and outputs. + """ + return { + var: get_source_and_target(var) + for var in iam_df.filter(region=region + "*", year=year).variable + if not exclude_flow(get_source_and_target(var), exclude) + } + + +def get_source_and_target( + variable: str, +) -> Tuple[Union[List, Any, LiteralString], Union[List, Any, LiteralString]]: + """Get source and target for the `variable` flow.""" + start_idx, end_idx = set_start_and_end_index(variable) + return ( + get_variable_components(variable, start_idx, join=True), + get_variable_components(variable, end_idx, join=True), + ) + + +def set_start_and_end_index(variable: str) -> Tuple[List[int], List[int]]: + """Get indices of source and target in variable name.""" + return ( + ([1, 2], [3, 4]) + if get_variable_components(variable, 0) == "in" + else ([3, 4], [1, 2]) + ) + + +def exclude_flow( + flow: Tuple[Union[List, Any, LiteralString], Union[List, Any, LiteralString]], + exclude: List[Optional[str]], +) -> bool: + """Exclude sources or targets of variable flow if requested.""" + if flow[0] in exclude or flow[1] in exclude: + return True + return False From 0c869c5fba559404f709d6b9ca02bb5446a65009 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:13:57 +0200 Subject: [PATCH 20/29] Clean up tutorial --- tutorial/westeros/westeros_sankey.ipynb | 127 ++++++++++++++++-------- 1 file changed, 85 insertions(+), 42 deletions(-) diff --git a/tutorial/westeros/westeros_sankey.ipynb b/tutorial/westeros/westeros_sankey.ipynb index e5d8b811d..329fa813f 100644 --- a/tutorial/westeros/westeros_sankey.ipynb +++ b/tutorial/westeros/westeros_sankey.ipynb @@ -13,13 +13,20 @@ "\n", "**Pre-requisites**\n", "- You have the *MESSAGEix* framework installed and working\n", - " In particular, you should have installed ``message_ix``, ``pyam``, and ``plotly``\n", - "- Complete tutorial Part 1 (``westeros_baseline.ipynb``) and Introducing Reporting (``westeros_report.ipynb``)" + " In particular, you should have installed ``message_ix``, ``pyam``, and ``plotly``.\n", + "- Complete tutorial Part 1 (``westeros_baseline.ipynb``) and Introducing Reporting (``westeros_report.ipynb``)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start as usual by connecting to a database and loading a scenario. Note that we do not `clone()` the scenario here because we do not intend to make any changes to it. " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "scrolled": true }, @@ -30,29 +37,38 @@ "from message_ix import Scenario\n", "\n", "mp = ixmp.Platform()\n", - "scenario = Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")" + "scenario = Scenario(mp, model=\"Westeros Electrified\", scenario=\"baseline\")\n", + "\n", + "# Ensure the scenario has a solution\n", + "if not scenario.has_solution():\n", + " scenario.solve(quiet=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we create the `Reporter` object. Since ``\"-\"`` is a reserved character in the unit-handling [pint](https://github.com/hgrecco/pint), we need to replace it by ``\"\"``." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ - "# Remove any existing solution\n", - "try:\n", - " scenario.remove_solution()\n", - "except ValueError:\n", - " pass\n", + "from message_ix.report import Reporter\n", "\n", - "scenario.solve()" + "rep = Reporter.from_scenario(scenario)\n", + "\n", + "rep.configure(units={\"replace\": {\"-\": \"\"}})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Create the reporter object. (Since ``\"-\"`` is not a unit, we replace it by ``\"\"``.)" + "This `Reporter` already includes everything we need to construct the `pyam.IamDataFrame` required for plotting Sankey diagrams! In other words, it includes the input and output flows in the IAMC format (`in::pyam` and `out::pyam`, respectively). We can start the calculation manually:" ] }, { @@ -61,35 +77,43 @@ "metadata": {}, "outputs": [], "source": [ - "from message_ix.report import Reporter\n", + "from genno.operator import concat\n", "\n", - "rep = Reporter.from_scenario(scenario)\n", + "pyam_out = rep.get(\"out::pyam\")\n", + "pyam_in = rep.get(\"in::pyam\")\n", "\n", - "rep.configure(units={\"replace\": {\"-\": \"\"}})" + "concat(pyam_out, pyam_in)\n", + "\n", + "# Please note: if you don't use the convenience function below, you need to store the\n", + "# result of concat(pyam_out, pyam_in) as df here!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Use the `message::sankey` reporter option to generate a pyam.dataframe including the reqiured input (`in::pyam`) and output flows (`out::pyam`) in iamc format.\n" + "Or we can use a built-in convenience function. This will also add the calculation to the `Reporter`, so the same calculation would not need to be repeated if it's used anywhere else, saving us time and memory." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "# Import Sankey functionality\n", - "from message_ix.report.sankey import SankeyReporter\n", - "\n", - "SankeyReporter.add_tasks(rep)" + "rep.add_sankey()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `pyam.IamDataFrame` is accessible through the key `message::sankey`:\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -100,29 +124,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The utility function `sankey_mapper(df, year, region, exclude=[])` can be used to create the required mapping for the `figures.sankey()` function of the `pyam` package.\n", - "\n", - "In some models it might be necessary to exclude variables and flow to get meaningful sankey diagrams. But let´s try with all!" + "Now, we can use the utility function `map_for_sankey(iam_df, year, region, exclude=[])` to create the mapping required for the `figures.sankey()` function of the `pyam` package. Each Sankey diagram will depict one year and region, which we have to provide to the function. In some models it might be necessary to exclude variables and flows to get meaningful Sankey diagrams; for this, you can use `exclude` as detailed below. But let´s try with all!" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "from message_ix.util.sankey import sankey_mapper\n", + "from message_ix.util.sankey import map_for_sankey\n", "\n", - "mapping = sankey_mapper(df, year=700, region=\"Westeros\")" + "mapping = map_for_sankey(df, year=700, region=\"Westeros\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The pyam function `plot.sankey(mapping)`returns a plotly sankey figure object that can be further modified.\n", + "The pyam function `pyam.figures.sankey()`returns a `plotly` figure object of our desired Sankey diagram that can be further modified. However, it can currently only handle data for single years, so we need to ensure that the input data we provide is filtered for the same year we filtered for above. \n", "\n", - "To plot it as an interactive diagram in your web browser, you can do the following." + "Finally, we can plot it as an interactive diagram!" ] }, { @@ -137,40 +159,61 @@ "fig.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With hundreds of variables, you can imagine this diagram getting crowded! We can use the `exclude` parameter of `map_for_sankey()` to exclude variables we are not interested in:" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "mapping_without_final_electricity = sankey_mapper(\n", - " df, year=700, region=\"Westeros\", exclude=[\"final|electricity\"]\n", + "mapping_without_wind_ppl_standard = map_for_sankey(\n", + " df,\n", + " year=700,\n", + " region=\"Westeros\",\n", + " exclude=[\"wind_ppl|standard\"],\n", ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we can display the figure as before:" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "fig = sankey(df=df.filter(year=700), mapping=mapping_without_final_electricity)\n", + "fig = sankey(df=df.filter(year=700), mapping=mapping_without_wind_ppl_standard)\n", "fig.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can pick any variable for this, even if it's in the middle of another flow! And for this scenario, you can pick other years, too:" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "mapping_without_wind_ppl_standard = sankey_mapper(\n", - " df,\n", - " year=700,\n", - " region=\"Westeros\",\n", - " exclude=[\"wind_ppl|standard\"],\n", + "mapping_without_final_electricity = map_for_sankey(\n", + " df, year=720, region=\"Westeros\", exclude=[\"final|electricity\"]\n", ")\n", - "fig = sankey(df=df.filter(year=700), mapping=mapping_without_wind_ppl_standard)\n", + "fig = sankey(df=df.filter(year=720), mapping=mapping_without_final_electricity)\n", "fig.show()" ] }, @@ -178,12 +221,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Do not forget to close the database ;-) " + "And lastly, as always, please do not forget to close the database ;-) " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ From 604ed30bcc0fe8f39466974a10736b16e7d98ae2 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:14:16 +0200 Subject: [PATCH 21/29] Add new tutorial to test suite --- message_ix/tests/test_tutorials.py | 1 + 1 file changed, 1 insertion(+) diff --git a/message_ix/tests/test_tutorials.py b/message_ix/tests/test_tutorials.py index 3e92de825..ffb02cb1b 100644 --- a/message_ix/tests/test_tutorials.py +++ b/message_ix/tests/test_tutorials.py @@ -86,6 +86,7 @@ def _t(group: Union[str, None], basename: str, *, check=None, marks=None): _t("w0", f"{W}_addon_technologies"), _t("w0", f"{W}_historical_new_capacity"), _t("w0", f"{W}_multinode_energy_trade"), + _t("w0", f"{W}_sankey"), # NB this is the same value as in test_reporter() _t(None, f"{W}_report", check=[("len-rep-graph", 13724)]), _t("at0", "austria", check=[("solve-objective-value", 206321.90625)]), From 53fa17e65d9829e45aead9456f3bc8cdb2cd1122 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:19:15 +0200 Subject: [PATCH 22/29] Exclude submodules of pyam from mypy, too --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 17182d5de..08e2c928e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -96,7 +96,7 @@ local_partial_types = true [[tool.mypy.overrides]] # Packages/modules for which no type hints are available. module = [ - "pyam", + "pyam.*", "scipy.*", # Indirectly via ixmp; this should be a subset of the list in ixmp's pyproject.toml "jpype", From 6bf6eba6fc1b1cc7e6de5c229e649ad34c55272a Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:35:49 +0200 Subject: [PATCH 23/29] Fix LiteralString import for old Python versions --- message_ix/util/sankey.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/message_ix/util/sankey.py b/message_ix/util/sankey.py index e22f11fe3..10f209cb8 100644 --- a/message_ix/util/sankey.py +++ b/message_ix/util/sankey.py @@ -1,4 +1,4 @@ -from typing import Any, List, LiteralString, Optional, Tuple, Union +from typing import Any, List, Optional, Tuple, Union from pyam import IamDataFrame @@ -7,6 +7,11 @@ except ImportError: # Python < 3.10, pandas < 2.0 from pyam.utils import get_variable_components +try: + from typing import LiteralString +except ImportError: # Python < 3.11 + from typing_extensions import LiteralString + def map_for_sankey( iam_df: IamDataFrame, From d32fe75639d5ec048212cfc83a5f8d6a8a5db0d5 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:42:16 +0200 Subject: [PATCH 24/29] Fix List type hint for Python 3.8 --- message_ix/util/sankey.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/message_ix/util/sankey.py b/message_ix/util/sankey.py index 10f209cb8..12db24605 100644 --- a/message_ix/util/sankey.py +++ b/message_ix/util/sankey.py @@ -17,7 +17,7 @@ def map_for_sankey( iam_df: IamDataFrame, year: int, region: str, - exclude: list[Optional[str]] = [], + exclude: List[Optional[str]] = [], ) -> dict[str, Tuple[Union[List, Any, LiteralString], Union[List, Any, LiteralString]]]: """Maps input to output flows to enable Sankey plots. From c595c93ee473a3dc651a6fe86ef939066460970f Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 13:49:10 +0200 Subject: [PATCH 25/29] Fix Dict type hint for Python 3.8 --- message_ix/util/sankey.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/message_ix/util/sankey.py b/message_ix/util/sankey.py index 12db24605..77730dc41 100644 --- a/message_ix/util/sankey.py +++ b/message_ix/util/sankey.py @@ -1,4 +1,4 @@ -from typing import Any, List, Optional, Tuple, Union +from typing import Any, Dict, List, Optional, Tuple, Union from pyam import IamDataFrame @@ -18,7 +18,7 @@ def map_for_sankey( year: int, region: str, exclude: List[Optional[str]] = [], -) -> dict[str, Tuple[Union[List, Any, LiteralString], Union[List, Any, LiteralString]]]: +) -> Dict[str, Tuple[Union[List, Any, LiteralString], Union[List, Any, LiteralString]]]: """Maps input to output flows to enable Sankey plots. Parameters From 2dd4a832c5308564069cb6ab3258a6e82b48b095 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 14:51:29 +0200 Subject: [PATCH 26/29] Add PR to release notes --- RELEASE_NOTES.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/RELEASE_NOTES.rst b/RELEASE_NOTES.rst index 24a7501c9..17a0f11a0 100644 --- a/RELEASE_NOTES.rst +++ b/RELEASE_NOTES.rst @@ -12,6 +12,7 @@ All changes - :mod:`message_ix` is tested and compatible with `Python 3.13 `__ (:pull:`881`). - Support for Python 3.8 is dropped (:pull:`881`), as it has reached end-of-life. +- Add functionality to create Sankey diagrams from :class:`.Reporter` together with a new tutorial showcase (:pull:`770`). - Add option to :func:`.util.copy_model` from a non-default location of model files (:pull:`877`). .. _v3.9.0: From 6e086bdf6acc896df83e87b23e9dbd803d0e0e65 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 15:01:49 +0200 Subject: [PATCH 27/29] Mention new tutorial in docs --- tutorial/README.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tutorial/README.rst b/tutorial/README.rst index 5ea76bdf0..cb73d8615 100644 --- a/tutorial/README.rst +++ b/tutorial/README.rst @@ -164,6 +164,10 @@ framework, such as used in global research applications of |MESSAGEix|. module to ‘report’ results, e.g. do post-processing, plotting, and other calculations (:tut:`westeros/westeros_report.ipynb`). + #. After familiarizing yourself with ‘reporting’, learn how to quickly assess + variable flows by plotting Sankey diagrams + (:tut:`westeros/westeros_sankey.ipynb`). + #. Build the baseline scenario using data stored in Excel files to populate sets and parameters: From c1da0669131ac1333a873e8b54f7fb405b0f1403 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 15:07:24 +0200 Subject: [PATCH 28/29] Add new functionality to docs --- doc/api.rst | 2 ++ doc/reporting.rst | 1 + 2 files changed, 3 insertions(+) diff --git a/doc/api.rst b/doc/api.rst index dfe05ade0..331d08868 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -300,6 +300,8 @@ Utility methods .. automodule:: message_ix.util :members: expand_dims, copy_model, make_df +.. automodule:: message_ix.util.Sankey + :members: map_for_sankey Testing utilities ----------------- diff --git a/doc/reporting.rst b/doc/reporting.rst index b6ea7516f..540f20952 100644 --- a/doc/reporting.rst +++ b/doc/reporting.rst @@ -215,6 +215,7 @@ These automatic contents are prepared using: .. autosummary:: add add_queue + add_sankey add_single apply check_keys From f48ca8389f833072df536f42b4184fae1519a907 Mon Sep 17 00:00:00 2001 From: Fridolin Glatter Date: Tue, 24 Sep 2024 15:13:24 +0200 Subject: [PATCH 29/29] Fix typo in docs --- doc/api.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/api.rst b/doc/api.rst index 331d08868..e17e468a6 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -300,7 +300,7 @@ Utility methods .. automodule:: message_ix.util :members: expand_dims, copy_model, make_df -.. automodule:: message_ix.util.Sankey +.. automodule:: message_ix.util.sankey :members: map_for_sankey Testing utilities