diff --git a/bw_timex/timex_lca.py b/bw_timex/timex_lca.py
index 86067a3..bd464e2 100644
--- a/bw_timex/timex_lca.py
+++ b/bw_timex/timex_lca.py
@@ -1154,6 +1154,39 @@ def create_labelled_dynamic_biosphere_dataframe(self) -> pd.DataFrame:
return df
+ def create_labelled_dynamic_inventory_dataframe(self) -> pd.DataFrame:
+ """
+ Returns the dynamic_inventory_df with comprehensible labels for flows and activities instead of ids.
+
+ Parameters
+ ----------
+ None
+
+ Returns
+ -------
+ pd.DataFrame, dynamic inventory matrix as a pandas.DataFrame with comprehensible labels instead of ids.
+ """
+
+ if not hasattr(self, "dynamic_inventory_df"):
+ warnings.warn(
+ "Dynamic inventory not yet calculated. Call TimexLCA.lci(build_dynamic_biosphere=True) first."
+ )
+
+ df = self.dynamic_inventory_df.copy()
+ df["flow"] = df["flow"].apply(lambda x: bd.get_node(id=x)["name"])
+
+ activity_name_cache = {}
+
+ for activity in df["activity"].unique():
+ if activity not in activity_name_cache:
+ activity_name_cache[activity] = resolve_temporalized_node_name(
+ self.activity_time_mapping_dict_reversed[activity][0][1]
+ )
+
+ df["activity"] = df["activity"].map(activity_name_cache)
+
+ return df
+
def plot_dynamic_inventory(self, bio_flows, cumulative=False) -> None:
"""
Simple plot of dynamic inventory of a biosphere flow over time, with optional cumulative plotting.
diff --git a/bw_timex/utils.py b/bw_timex/utils.py
index bf9fb83..7e5556c 100644
--- a/bw_timex/utils.py
+++ b/bw_timex/utils.py
@@ -306,3 +306,34 @@ def plot_characterized_inventory_as_waterfall(
ax.set_axisbelow(True)
plt.grid(True)
plt.show()
+
+def get_exchange(**kwargs) -> Exchange:
+ """
+ Get an exchange from the database.
+ """
+ mapping = {
+ "input_code": ExchangeDataset.input_code,
+ "input_database": ExchangeDataset.input_database,
+ "output_code": ExchangeDataset.output_code,
+ "output_database": ExchangeDataset.output_database,
+ }
+ qs = ExchangeDataset.select()
+ for key, value in kwargs.items():
+ try:
+ qs = qs.where(mapping[key] == value)
+ except KeyError:
+ continue
+
+ candidates = [Exchange(obj) for obj in qs]
+ if len(candidates) > 1:
+ raise MultipleResults(
+ "Found {} results for the given search. Please be more specific or double-check your system model for duplicates.".format(len(candidates))
+ )
+ elif not candidates:
+ raise UnknownObject
+ return candidates[0]
+
+def add_temporal_distribution_to_exchange(temporal_distribution: TemporalDistribution, **kwargs):
+ exchange = get_exchange(**kwargs)
+ exchange["temporal_distribution"] = temporal_distribution
+ exchange.save()
\ No newline at end of file
diff --git a/dev/your_own_timex_lca.ipynb b/dev/your_own_timex_lca.ipynb
new file mode 100644
index 0000000..d50617b
--- /dev/null
+++ b/dev/your_own_timex_lca.ipynb
@@ -0,0 +1,582 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Your own time-explicit LCA\n",
+ "This notebooks is your playground! Create your own foreground system, link it to ecoinvent, add temporal information and use `bw_timex` to re-link your processes throughout time to prospective `premise`-databases."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import bw2data as bd\n",
+ "bd.projects.set_current(\"bw25_ei310_premise\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create a new foreground process:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if \"foreground\" in bd.databases:\n",
+ " del bd.databases[\"foreground\"]\n",
+ "foreground = bd.Database(\"foreground\")\n",
+ "foreground.register()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "some_stuff_i_do = foreground.new_node(\n",
+ " code=\"some stuff i do\",\n",
+ " name=\"some stuff i do\",\n",
+ ")\n",
+ "some_stuff_i_do.save()\n",
+ "some_stuff_i_do.new_edge(input=some_stuff_i_do, amount=1, type=\"production\").save()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Select some activities from ecoinvent to link to:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "house = bd.get_node(database=\"ecoinvent-3.10-cutoff\", name=\"building construction, multi-storey\", location=\"RER\")\n",
+ "work = bd.get_node(database=\"ecoinvent-3.10-cutoff\", name=\"operation, computer, laptop, active mode\", location=\"CH\")\n",
+ "co2 = bd.get_node(database=\"ecoinvent-3.10-biosphere\", name=\"Carbon dioxide, fossil\", categories=(\"air\",))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create edges and add temporal information:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# A process took place a while ago:\n",
+ "\n",
+ "import numpy as np\n",
+ "from bw_temporalis import TemporalDistribution\n",
+ "\n",
+ "edge_house_building = some_stuff_i_do.new_edge(\n",
+ " input=house,\n",
+ " amount=3, # m3, more like a dog house\n",
+ " type=\"technosphere\",\n",
+ ")\n",
+ "\n",
+ "td_house_building = TemporalDistribution(\n",
+ " date=np.array([-40], dtype=\"timedelta64[Y]\"),\n",
+ " amount=np.array([1]),\n",
+ ")\n",
+ "\n",
+ "edge_house_building[\"temporal_distribution\"] = td_house_building\n",
+ "edge_house_building.save()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Something that happens regularly:\n",
+ "\n",
+ "from bw_temporalis import easy_timedelta_distribution\n",
+ "\n",
+ "WORKYEARS = 30\n",
+ "edge_working = some_stuff_i_do.new_edge(\n",
+ " input=work,\n",
+ " amount=2080*WORKYEARS, # h, \n",
+ " type=\"technosphere\",\n",
+ ")\n",
+ "\n",
+ "td_working = easy_timedelta_distribution(\n",
+ " start=0, # (inclusive)\n",
+ " end=WORKYEARS, # (inclusive)\n",
+ " resolution=\"Y\",\n",
+ " steps=6, # Includes both start and end\n",
+ " kind=\"uniform\", \n",
+ ")\n",
+ "\n",
+ "edge_working[\"temporal_distribution\"] = td_working\n",
+ "edge_working.save()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# A specific emission profile\n",
+ "\n",
+ "planting_a_tree = foreground.new_node( \n",
+ " code=\"planting a tree\",\n",
+ " name=\"planting a tree\",\n",
+ " unit=\"unit\",\n",
+ ")\n",
+ "planting_a_tree.save()\n",
+ "planting_a_tree.new_edge(input=planting_a_tree, amount=1, type=\"production\").save()\n",
+ "planting_a_tree.new_edge(input=co2, amount=-1000, type=\"biosphere\").save()\n",
+ "\n",
+ "some_stuff_i_do.new_edge(\n",
+ " input=planting_a_tree,\n",
+ " amount=1,\n",
+ " type=\"technosphere\",\n",
+ ").save()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# oops, forgot to save the edge object or working with existing models? \n",
+ "# there's a utility function to help you out ;)\n",
+ "from bw_timex.utils import add_temporal_distribution_to_exchange\n",
+ "\n",
+ "td_co2_uptake_tree = easy_timedelta_distribution(\n",
+ " start=0, # (inclusive)\n",
+ " end=100, # (inclusive)\n",
+ " resolution=\"Y\",\n",
+ " steps=11, # Includes both start and end\n",
+ " kind=\"triangular\", \n",
+ " param=60,\n",
+ ")\n",
+ "\n",
+ "# only works if this is the only edge between these two nodes - otherwise, you need to specify the edge object directly\n",
+ "add_temporal_distribution_to_exchange(\n",
+ " temporal_distribution=td_co2_uptake_tree,\n",
+ " input_code=co2[\"code\"],\n",
+ " input_database=co2[\"database\"],\n",
+ " output_code=planting_a_tree[\"code\"],\n",
+ " output_database=planting_a_tree[\"database\"],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Provide some info on the prospective `premise`-databases:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from datetime import datetime\n",
+ "\n",
+ "database_date_dict = {\n",
+ " \"ecoinvent-3.10-cutoff\": datetime.strptime(\"2020\", \"%Y\"),\n",
+ " \"ei310-SSP2-RCP19-2030\": datetime.strptime(\"2030\", \"%Y\"),\n",
+ " \"ei310-SSP2-RCP19-2040\": datetime.strptime(\"2040\", \"%Y\"),\n",
+ " \"ei310-SSP2-RCP19-2050\": datetime.strptime(\"2050\", \"%Y\"),\n",
+ " \"foreground\": \"dynamic\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And create your TimexLCA, just as you've seen before:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/scikits/umfpack/umfpack.py:736: UmfpackWarning: (almost) singular matrix! (estimated cond. number: 1.40e+13)\n",
+ " warnings.warn(msg, UmfpackWarning)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from bw_timex import TimexLCA\n",
+ "\n",
+ "tlca = TimexLCA(\n",
+ " demand={some_stuff_i_do: 1},\n",
+ " method=(\"EF v3.1\", \"climate change\", \"global warming potential (GWP100)\"),\n",
+ " database_date_dict=database_date_dict,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timex_lca.py:195: UserWarning: No edge filter function provided. Skipping all edges within background databases.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Starting graph traversal\n",
+ "Calculation count: 3\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timeline_builder.py:475: Warning: Reference date 1984-01-01 00:00:00 is lower than all provided dates. Data will be taken from the closest higher year.\n",
+ " warnings.warn(\n",
+ "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timeline_builder.py:482: Warning: Reference date 2054-01-01 00:00:00 is higher than all provided dates. Data will be taken from the closest lower year.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
date_producer
\n",
+ "
producer_name
\n",
+ "
date_consumer
\n",
+ "
consumer_name
\n",
+ "
amount
\n",
+ "
interpolation_weights
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0
\n",
+ "
1984-01-01
\n",
+ "
building construction, multi-storey
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
3.0
\n",
+ "
{'ecoinvent-3.10-cutoff': 1}
\n",
+ "
\n",
+ "
\n",
+ "
1
\n",
+ "
2024-01-01
\n",
+ "
operation, computer, laptop, active mode
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
10400.0
\n",
+ "
{'ecoinvent-3.10-cutoff': 0.6000547495209416, ...
\n",
+ "
\n",
+ "
\n",
+ "
2
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
2024-01-01
\n",
+ "
-1
\n",
+ "
1.0
\n",
+ "
None
\n",
+ "
\n",
+ "
\n",
+ "
3
\n",
+ "
2024-01-01
\n",
+ "
planting a tree
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
1.0
\n",
+ "
None
\n",
+ "
\n",
+ "
\n",
+ "
4
\n",
+ "
2030-01-01
\n",
+ "
operation, computer, laptop, active mode
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
10400.0
\n",
+ "
{'ei310-SSP2-RCP19-2030': 1}
\n",
+ "
\n",
+ "
\n",
+ "
5
\n",
+ "
2036-01-01
\n",
+ "
operation, computer, laptop, active mode
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
10400.0
\n",
+ "
{'ei310-SSP2-RCP19-2030': 0.4000547645125958, ...
\n",
+ "
\n",
+ "
\n",
+ "
6
\n",
+ "
2042-01-01
\n",
+ "
operation, computer, laptop, active mode
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
10400.0
\n",
+ "
{'ei310-SSP2-RCP19-2040': 0.7998905009581166, ...
\n",
+ "
\n",
+ "
\n",
+ "
7
\n",
+ "
2048-01-01
\n",
+ "
operation, computer, laptop, active mode
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
10400.0
\n",
+ "
{'ei310-SSP2-RCP19-2040': 0.20010949904188335,...
\n",
+ "
\n",
+ "
\n",
+ "
8
\n",
+ "
2054-01-01
\n",
+ "
operation, computer, laptop, active mode
\n",
+ "
2024-01-01
\n",
+ "
some stuff i do
\n",
+ "
10400.0
\n",
+ "
{'ei310-SSP2-RCP19-2050': 1}
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " date_producer producer_name date_consumer \\\n",
+ "0 1984-01-01 building construction, multi-storey 2024-01-01 \n",
+ "1 2024-01-01 operation, computer, laptop, active mode 2024-01-01 \n",
+ "2 2024-01-01 some stuff i do 2024-01-01 \n",
+ "3 2024-01-01 planting a tree 2024-01-01 \n",
+ "4 2030-01-01 operation, computer, laptop, active mode 2024-01-01 \n",
+ "5 2036-01-01 operation, computer, laptop, active mode 2024-01-01 \n",
+ "6 2042-01-01 operation, computer, laptop, active mode 2024-01-01 \n",
+ "7 2048-01-01 operation, computer, laptop, active mode 2024-01-01 \n",
+ "8 2054-01-01 operation, computer, laptop, active mode 2024-01-01 \n",
+ "\n",
+ " consumer_name amount interpolation_weights \n",
+ "0 some stuff i do 3.0 {'ecoinvent-3.10-cutoff': 1} \n",
+ "1 some stuff i do 10400.0 {'ecoinvent-3.10-cutoff': 0.6000547495209416, ... \n",
+ "2 -1 1.0 None \n",
+ "3 some stuff i do 1.0 None \n",
+ "4 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2030': 1} \n",
+ "5 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2030': 0.4000547645125958, ... \n",
+ "6 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2040': 0.7998905009581166, ... \n",
+ "7 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2040': 0.20010949904188335,... \n",
+ "8 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2050': 1} "
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tlca.build_timeline()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/bw2calc/lca_base.py:127: SparseEfficiencyWarning: splu converted its input to CSC format\n",
+ " self.solver = factorized(self.technosphere_matrix)\n",
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/scikits/umfpack/umfpack.py:736: UmfpackWarning: (almost) singular matrix! (estimated cond. number: 7.43e+12)\n",
+ " warnings.warn(msg, UmfpackWarning)\n"
+ ]
+ }
+ ],
+ "source": [
+ "tlca.lci()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Characterize the inventory, looking at radiative forcing:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:80: UserWarning: No custom dynamic characterization functions provided. Using default dynamic characterization functions from `dynamic_characterization` meant to work with biosphere3 flows. The flows that are characterized are based on the selection of the initially chosen impact category. You can look up the mapping in the bw_timex.dynamic_characterizer.characterization_function_dict.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# notice how we don't specify a characterization_function_dict here?\n",
+ "# this triggers the use of some default ones that work with biosphere3! \n",
+ "# Check the docstrings for more info :) \n",
+ "\n",
+ "tlca.dynamic_lcia(\n",
+ " metric=\"radiative_forcing\",\n",
+ " time_horizon=100,\n",
+ ")\n",
+ "tlca.plot_dynamic_characterized_inventory(sum_emissions_within_activity=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "GWP:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:80: UserWarning: No custom dynamic characterization functions provided. Using default dynamic characterization functions from `dynamic_characterization` meant to work with biosphere3 flows. The flows that are characterized are based on the selection of the initially chosen impact category. You can look up the mapping in the bw_timex.dynamic_characterizer.characterization_function_dict.\n",
+ " warnings.warn(\n",
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:262: UserWarning: Using bw_timex's default CO2 characterization function for GWP reference.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from bw_timex.utils import plot_characterized_inventory_as_waterfall\n",
+ "plot_characterized_inventory_as_waterfall(tlca)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "timex",
+ "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.10.14"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/_static/custom.css b/docs/_static/custom.css
index 17c3ce3..29a67cb 100644
--- a/docs/_static/custom.css
+++ b/docs/_static/custom.css
@@ -47,3 +47,29 @@ body {
margin-left: 1rem;
}
}
+
+div.admonition.admonition-launch > .admonition-title {
+ background-color: var(--pst-color-secondary-bg);
+}
+
+div.admonition.admonition-launch {
+ border-color: var(--pst-color-secondary-highlight);
+}
+
+div.admonition.admonition-launch > .admonition-title::after {
+ content: "\f135";
+ color: var(--pst-color-text-base);
+}
+
+div.admonition.admonition-example > .admonition-title {
+ background-color: var(--pst-color-secondary-bg);
+}
+
+div.admonition.admonition-example {
+ border-color: var(--pst-color-secondary-highlight);
+}
+
+div.admonition.admonition-example > .admonition-title::after {
+ content: "\f518";
+ color: var(--pst-color-text-base);
+}
\ No newline at end of file
diff --git a/docs/conf.py b/docs/conf.py
index 1ea8394..ab8226f 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -81,6 +81,55 @@
graphviz_output_format = 'svg' # https://pydata-sphinx-theme.readthedocs.io/en/stable/examples/graphviz.html#inheritance-diagram
+# Inject custom JavaScript to handle theme switching
+mermaid_init_js = """
+ function initializeMermaidBasedOnTheme() {
+ const theme = document.documentElement.dataset.theme;
+
+ if (theme === 'dark') {
+ mermaid.initialize({
+ startOnLoad: true,
+ theme: 'base',
+ themeVariables: {
+ edgeLabelBackground: 'transparent',
+ defaultLinkColor: '#ced6dd',
+ titleColor: '#ced6dd',
+ nodeTextColor: '#ced6dd',
+ lineColor: '#ced6dd',
+ }
+ });
+ } else {
+ mermaid.initialize({
+ startOnLoad: true,
+ theme: 'base',
+ themeVariables: {
+ edgeLabelBackground: 'transparent',
+ defaultLinkColor: '#222832',
+ titleColor: '#222832',
+ nodeTextColor: '#222832',
+ lineColor: '#222832',
+ }
+ });
+ }
+
+ // Re-render all Mermaid diagrams
+ mermaid.contentLoaded();
+ }
+
+ // Observer to detect changes to the data-theme attribute
+ const themeObserver = new MutationObserver((mutations) => {
+ mutations.forEach((mutation) => {
+ if (mutation.type === 'attributes' && mutation.attributeName === 'data-theme') {
+ initializeMermaidBasedOnTheme();
+ }
+ });
+ });
+
+ themeObserver.observe(document.documentElement, { attributes: true });
+
+ initializeMermaidBasedOnTheme();
+"""
+
master_doc = "index"
root_doc = 'index'
@@ -116,7 +165,7 @@
"content/contributing": [],
"content/codeofconduct": [],
"content/license": [],
- "content/chagnelog": [],
+ "content/changelog": [],
}
html_theme_options = {
@@ -124,7 +173,7 @@
"announcement": "⚠️ This package is under active development and some functionalities may change in the future.",
"navbar_start": ["navbar-logo"],
"navbar_end": ["theme-switcher", "navbar-icon-links.html"],
- "navbar_align": "left",
+ "navbar_align": "content",
# "navbar_persistent": ["theme-switcher"], # this is where the search button is usually placed
"footer_start": ["copyright"],
"footer_end": ["footer"],
@@ -134,7 +183,7 @@
"icon_links": [
{
"name": "Launch interactive Demo on Binder",
- "url": "https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fexample_electric_vehicle_standalone.ipynb",
+ "url": "https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fgetting_started.ipynb",
"icon": "fa-solid fa-rocket",
},
{
diff --git a/docs/content/data/dynamic_characterized_inventory_gwp.svg b/docs/content/data/dynamic_characterized_inventory_gwp.svg
new file mode 100644
index 0000000..65f517c
--- /dev/null
+++ b/docs/content/data/dynamic_characterized_inventory_gwp.svg
@@ -0,0 +1,960 @@
+
+
+
diff --git a/docs/content/data/dynamic_characterized_inventory_radiative_forcing.svg b/docs/content/data/dynamic_characterized_inventory_radiative_forcing.svg
new file mode 100644
index 0000000..2be7b9b
--- /dev/null
+++ b/docs/content/data/dynamic_characterized_inventory_radiative_forcing.svg
@@ -0,0 +1,2344 @@
+
+
+
diff --git a/docs/content/data/dynamic_prospective_timeexplicit_dark.svg b/docs/content/data/dynamic_prospective_timeexplicit_dark.svg
new file mode 100644
index 0000000..d85cc8e
--- /dev/null
+++ b/docs/content/data/dynamic_prospective_timeexplicit_dark.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/docs/content/data/dynamic_prospective_timeexplicit_light.svg b/docs/content/data/dynamic_prospective_timeexplicit_light.svg
new file mode 100644
index 0000000..e45a20b
--- /dev/null
+++ b/docs/content/data/dynamic_prospective_timeexplicit_light.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/docs/content/data/matrix_stuff_dark.svg b/docs/content/data/matrix_stuff_dark.svg
new file mode 100644
index 0000000..dcf75cb
--- /dev/null
+++ b/docs/content/data/matrix_stuff_dark.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/docs/content/data/matrix_stuff_light.svg b/docs/content/data/matrix_stuff_light.svg
new file mode 100644
index 0000000..9f3e1c3
--- /dev/null
+++ b/docs/content/data/matrix_stuff_light.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/docs/content/data/method_small_steps_dark.svg b/docs/content/data/method_small_steps_dark.svg
new file mode 100644
index 0000000..726f06b
--- /dev/null
+++ b/docs/content/data/method_small_steps_dark.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/docs/content/data/method_small_steps_light.svg b/docs/content/data/method_small_steps_light.svg
new file mode 100644
index 0000000..cf507f4
--- /dev/null
+++ b/docs/content/data/method_small_steps_light.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/docs/content/data/td_convoluted.svg b/docs/content/data/td_convoluted.svg
new file mode 100644
index 0000000..a849cc0
--- /dev/null
+++ b/docs/content/data/td_convoluted.svg
@@ -0,0 +1,736 @@
+
+
+
diff --git a/docs/content/data/td_spread_over_four_months.svg b/docs/content/data/td_spread_over_four_months.svg
new file mode 100644
index 0000000..31faece
--- /dev/null
+++ b/docs/content/data/td_spread_over_four_months.svg
@@ -0,0 +1,786 @@
+
+
+
diff --git a/docs/content/data/td_two_and_four_years_ahead.svg b/docs/content/data/td_two_and_four_years_ahead.svg
new file mode 100644
index 0000000..8d0ad22
--- /dev/null
+++ b/docs/content/data/td_two_and_four_years_ahead.svg
@@ -0,0 +1,836 @@
+
+
+
diff --git a/docs/content/examples/example_electric_vehicle_premise.ipynb b/docs/content/examples/example_electric_vehicle_premise.ipynb
index d3b9931..58703e6 100644
--- a/docs/content/examples/example_electric_vehicle_premise.ipynb
+++ b/docs/content/examples/example_electric_vehicle_premise.ipynb
@@ -11,9 +11,12 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "This notebook shows how to use `bw_timex` with a cradle-to-grave case study of an electric vehicle (ev). The case study is simplified, not meant to reflect the complexity of electric mobility but to demonstrate how to use `bw_timex`. \n",
+ "This notebook shows how to use `bw_timex` with a cradle-to-grave case study of an electric vehicle. The case study is simplified, not meant to reflect the complexity of electric mobility but to demonstrate hot to use `bw_timex`. \n",
"\n",
- "> **Note:** This is the \"premise\" version of this notebook that works with ecoinvent and premise data. If you don't have access to that, please check out the [\"standalone\" version](https://github.com/brightway-lca/bw_timex/blob/main/notebooks/example_electric_vehicle_standalone.ipynb) of this notebook.\n"
+ "More information on the inner workings of `bw_timex` can be found [here](https://timex.readthedocs.io/en/latest/content/theory.html).\n",
+ "\n",
+ "\n",
+ "> **Note:** This is the \"premise\" version of this notebook that works with ecoinvent and premise data. If you don't have access to that, please check out the [\"standalone\" version](https://github.com/brightway-lca/bw_timex/blob/main/notebooks/example_electric_vehicle_standalone.ipynb) of this notebook."
]
},
{
diff --git a/docs/content/examples/index.md b/docs/content/examples/index.md
index c6cbe88..60c9b31 100644
--- a/docs/content/examples/index.md
+++ b/docs/content/examples/index.md
@@ -1,4 +1,4 @@
-# TimexLCA Examples
+# TimexLCA Examples
Here are some examples on how you can use `bw_timex`.
@@ -64,6 +64,6 @@ hidden:
maxdepth: 1
---
self
-example_ev
+example_electric_vehicle_premise
example_simple_dynamic_characterization
```
diff --git a/docs/content/getting_started/adding_temporal_information.md b/docs/content/getting_started/adding_temporal_information.md
new file mode 100644
index 0000000..1fdd79d
--- /dev/null
+++ b/docs/content/getting_started/adding_temporal_information.md
@@ -0,0 +1,257 @@
+# Step 1 - Adding temporal information
+
+To get you started with time-explicit LCA, we'll investigate this very simple production system with two "technosphere" nodes A and B and a "biosphere" node representing some CO2 emissions. For the sake of this example, we'll assume that we demand Process A to run exactly once.
+```{mermaid}
+:caption: Example production system
+flowchart LR
+subgraph background[background]
+ B(Process B):::bg
+end
+
+subgraph foreground[foreground]
+ A(Process A):::fg
+end
+
+subgraph biosphere[biosphere]
+ CO2(CO2):::bio
+end
+
+B-->|"3 kg \n "|A
+A-.->|"5 kg \n "|CO2
+B-.->|"11 kg \n "|CO2
+
+classDef fg color:#222832, fill:#3fb1c5, stroke:none;
+classDef bg color:#222832, fill:#3fb1c5, stroke:none;
+classDef bio color:#222832, fill:#9c5ffd, stroke:none;
+style background fill:none, stroke:none;
+style foreground fill:none, stroke:none;
+style biosphere fill:none, stroke:none;
+```
+
+:::{dropdown} Here's the code to set this up with brightway - but this is not essential here
+:icon: codescan
+
+```python
+import bw2data as bd
+
+bd.projects.set_current("getting_started_with_timex")
+
+bd.Database("biosphere").write(
+ {
+ ("biosphere", "CO2"): {
+ "type": "emission",
+ "name": "CO2",
+ },
+ }
+)
+
+bd.Database("background").write(
+ {
+ ("background", "B"): {
+ "name": "B",
+ "location": "somewhere",
+ "reference product": "B",
+ "exchanges": [
+ {
+ "amount": 1,
+ "type": "production",
+ "input": ("background", "B"),
+ },
+ {
+ "amount": 11,
+ "type": "biosphere",
+ "input": ("biosphere", "CO2"),
+ },
+ ],
+ },
+ }
+)
+
+bd.Database("foreground").write(
+ {
+ ("foreground", "A"): {
+ "name": "A",
+ "location": "somewhere",
+ "reference product": "A",
+ "exchanges": [
+ {
+ "amount": 1,
+ "type": "production",
+ "input": ("foreground", "A"),
+ },
+ {
+ "amount": 3,
+ "type": "technosphere",
+ "input": ("background", "B"),
+ },
+ {
+ "amount": 5,
+ "type": "biosphere",
+ "input": ("biosphere", "CO2"),
+ }
+ ],
+ },
+ }
+)
+
+bd.Method(("our", "method")).write(
+ [
+ (("biosphere", "CO2"), 1),
+ ]
+)
+```
+:::
+
+Now, if you want to consider time in your LCA, you need to somehow add temporal information. For time-explicit LCA, we consider two kinds of temporal information, that will be discussed in the following.
+
+## Temporal distributions
+To determine the timing of the exchanges within the production system, we add the `temporal_distribution` attribute to the respective exchanges. To carry the temporal information, we use the [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) class from [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). This class is a *container for a series of amount spread over time*, so it tells you what share of an exchange happens at what point in time. So, let's include this information in out production system - visually at first:
+```{mermaid}
+:caption: Temporalized example production system
+flowchart LR
+subgraph background[" "]
+ B_2020(Process B):::bg
+end
+
+subgraph foreground[" "]
+ A(Process A):::fg
+end
+
+subgraph biosphere[" "]
+ CO2:::b
+end
+
+ B_2020-->|"amounts: [30%,50%,20%] * 3 kg\n dates:[-2,0,+4]" years|A
+ A-.->|"amounts: [60%, 40%] * 5 kg\n dates: [0,+1]" years|CO2
+ B_2020-.->|"amounts: [100%] * 11 kg\n dates:[0]" years|CO2
+
+ classDef bg color:#222832, fill:#3fb1c5, stroke:none;
+ classDef fg color:#222832, fill:#3fb1c5, stroke:none;
+ classDef b color:#222832, fill:#9c5ffd, stroke:none;
+ style foreground fill:none, stroke:none;
+ style background fill:none, stroke:none;
+ style biosphere fill:none, stroke:none;
+
+```
+
+Now it's time to add this information to our modeled production system in brightway:
+```python
+import numpy as np
+from bw_temporalis import TemporalDistribution
+from bw_timex.utils import add_temporal_distribution_to_exchange
+
+# Starting with the exchange between A and B
+# First, create a TemporalDistribution with the time information from above
+td_b_to_a = TemporalDistribution(
+ date=np.array([-2, 0, 4], dtype="timedelta64[Y]"),
+ amount=np.array([0.3, 0.5, 0.2]),
+)
+
+# Now add the temporal distribution to the corresponding exchange. In
+# principle, you just have to do the following:
+# exchange_object["temporal_distribution"] = TemporalDistribution
+# We currently don't have the exchange-object at hand here, but we can
+# use the utility function add_temporal_distribution_to_exchange to help.
+add_temporal_distribution_to_exchange(
+ temporal_distribution=td_b_to_a,
+ input_code="B",
+ input_database="background",
+ output_code="A",
+ output_database="foreground"
+)
+
+# Now we do the same for our other temporalized exchange between A and CO2
+td_a_to_co2 = TemporalDistribution(
+ date=np.array([0, 1], dtype="timedelta64[Y]"),
+ amount=np.array([0.6, 0.4]),
+)
+
+# We actually only have to define enough fields to uniquely identify the
+# exchange here
+add_temporal_distribution_to_exchange(
+ temporal_distribution=td_a_to_co2,
+ input_code="CO2",
+ output_code="A"
+)
+```
+
+## Prospective data
+
+The other kind of temporal data we can add is some prospective information on how our processes change over time. So, for our simple example, let's say our background process B somehow evolves, so that it emitts less CO2 in the future. To make it precise, we assume that the original process we modeled above represents the process state in the year 2020, emitting 11 kg CO2, which reduces to 7 kg CO2 by 2030:
+
+
+```{mermaid}
+:caption: Temporalized example production system
+flowchart LR
+subgraph background[" "]
+ B_2020(Process B \n 2020):::bg
+ B_2030(Process B \n 2030):::bg
+end
+
+subgraph foreground[" "]
+ A(Process A):::fg
+end
+
+subgraph biosphere[" "]
+ CO2:::b
+end
+ B_2020-->|"amounts: [30%,50%,20%] * 3 kg\n dates:[-2,0,+4]" years|A
+ A-.->|"amounts: [60%, 40%] * 5 kg\n dates: [0,+1]" years|CO2
+ B_2020-.->|"amounts: [100%] * 11 kg\n dates:[0]" years|CO2
+ B_2030-.->|"amounts: [100%] * 7 kg\n dates:[0]" years|CO2
+
+ classDef bg color:#222832, fill:#3fb1c5, stroke:none;
+ classDef fg color:#222832, fill:#3fb1c5, stroke:none;
+ classDef b color:#222832, fill:#9c5ffd, stroke:none;
+ style foreground fill:none, stroke:none;
+ style background fill:none, stroke:none;
+ style biosphere fill:none, stroke:none;
+
+```
+
+:::{dropdown} Again, here's the code in case you're interested
+:icon: codescan
+
+```python
+bd.Database("background_2030").write(
+ {
+ ("background_2030", "B"): {
+ "name": "B",
+ "location": "somewhere",
+ "reference product": "B",
+ "exchanges": [
+ {
+ "amount": 1,
+ "type": "production",
+ "input": ("background_2030", "B"),
+ },
+ {
+ "amount": 7,
+ "type": "biosphere",
+ "input": ("biosphere", "CO2"),
+ },
+ ],
+ },
+ }
+)
+```
+:::
+
+So, as you can see, the prospective processes can reside within your normal brightway databases. To hand them to `bw_timex`, we just need to define a dictionary that maps the prospective database names to the point in time that they represent:
+
+```python
+from datetime import datetime
+
+# Note: The foreground does not represent a specific point in time, but should
+# later be dynamically distributed over time
+database_date_dict = {
+ "background": datetime.strptime("2020", "%Y"),
+ "background_2030": datetime.strptime("2030", "%Y"),
+ "foreground": "dynamic",
+}
+```
+
+:::{note}
+You can use whatever data source you want for this prospective data. A nice package from the Brightway cosmos that can help you is [premise](https://premise.readthedocs.io/en/latest/introduction.html).
+:::
+
diff --git a/docs/content/getting_started/build_process_timeline.md b/docs/content/getting_started/build_process_timeline.md
new file mode 100644
index 0000000..650c5e0
--- /dev/null
+++ b/docs/content/getting_started/build_process_timeline.md
@@ -0,0 +1,29 @@
+# Step 2 - Building the process timeline
+
+With all the temporal information prepared, we can now instantiate our TimexLCA object. This is very similar to a normal Brightway LCA object, but with the additional argument of our `database_date_dict`:
+
+```python
+from bw_timex import TimexLCA
+
+tlca = TimexLCA(
+ demand={("foreground", "A"): 1},
+ method=("our", "method"),
+ database_date_dict=database_date_dict,
+)
+```
+
+Using our new `tlca` object, we can now build the timeline of processes that leads to our functional unit, "A". If not specified otherwise, it's assumed that the demand occurs in the current year, which is 2024 at the time of writing this. Actually building the timeline is now very simple on the user-side:
+```python
+tlca.build_timeline()
+```
+
+The timeline that is returned looks like this:
+
+| date_producer | producer_name | date_consumer | consumer_name | amount | interpolation_weights |
+|---------------|---------------|---------------|---------------|--------|------------------------------------------------|
+| 2022-01-01 | B | 2024-01-01 | A | 0.9 | {'background': 0.8, 'background_2030': 0.2} |
+| 2024-01-01 | B | 2024-01-01 | A | 1.5 | {'background': 0.6, 'background_2030': 0.4} |
+| 2024-01-01 | A | 2024-01-01 | -1 | 1.0 | None |
+| 2028-01-01 | B | 2024-01-01 | A | 0.6 | {'background': 0.2, 'background_2030': 0.8} |
+
+Here we can see which share of which exchange happens at what point in time. Additionally, the "interpolation_weights" already tell us what share of an exchange should come from which database. With this info, we can calculate our time-explicit LCI in the next step.
\ No newline at end of file
diff --git a/docs/content/getting_started/index.md b/docs/content/getting_started/index.md
new file mode 100644
index 0000000..d45437c
--- /dev/null
+++ b/docs/content/getting_started/index.md
@@ -0,0 +1,35 @@
+# Getting Started
+
+This section will help you quickly getting started with your time-explicit LCA project. We're keeping it simple here - no deep dives into how things work in the background, no exploring of all the features and options `bw_timex` has. Just a quick walkthrough of the different steps of a `TimexLCA`. Here's a rundown:
+
+```{image} ../data/method_small_steps_light.svg
+:class: only-light
+:height: 450px
+:align: center
+```
+
+```{image} ../data/method_small_steps_dark.svg
+:class: only-dark
+:height: 450px
+:align: center
+```
+
+
+In the following sections, we'll walk through the steps 1-4, considering a very simple dummy system. If you directly want to look at a more complex example, take a look at our [example collection](../examples/index.md). If you're interested in the full details on how `bw_timex` works, you can also skip to our [Theory Section](../theory.md).
+
+```{admonition} You want more interaction?
+:class: admonition-launch
+
+[Launch this tutorial on Binder!](https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fgetting_started.ipynb) In this interactive environment, you can directly run the bw_timex code yourself whilst following along.
+```
+
+```{toctree}
+---
+hidden:
+maxdepth: 1
+---
+Step 1 - Adding temporal information
+Step 2 - Building the process timeline
+Step 3 - Calculating the time-explicit LCI
+Step 4 - Impact assessment
+```
\ No newline at end of file
diff --git a/docs/content/getting_started/lcia.md b/docs/content/getting_started/lcia.md
new file mode 100644
index 0000000..1066f3b
--- /dev/null
+++ b/docs/content/getting_started/lcia.md
@@ -0,0 +1,99 @@
+# Step 4 - Impact assessment
+To characterize the calculated inventory, we have two options: Static and dynamic life cycle impact assessment (LCIA).
+
+## Static LCIA
+If we don't care about the timing of the emissions, we can do static LCIA using the standard characterization factors. To characterize the inventory with the impact assessment method that we initially chose when creating our `TimexLCA` object, we can simply call:
+
+```python
+tlca.static_lcia()
+```
+
+and investigate the resulting score like this:
+
+```python
+print(tlca.static_score)
+```
+
+## Dynamic LCIA
+The inventory calculated by a `TimexLCA` retains temporal information. That means that in addition to knowing which process emitts what substance, we also know the timing of each emission. This allows for more advanced, dynamic characterization using characterization functions instead of just factors. In `bw_timex`, users can either use their own curstom functions or use some existing ones, e.g., from the package [`dynamic_characterization`](https://dynamic-characterization.readthedocs.io/en/latest/). We'll do the latter here.
+
+First, we need to define which characterization function we want to apply to which biosphere flow:
+
+```python
+from dynamic_characterization.timex import characterize_co2
+emission_id = bd.get_activity(("biosphere", "CO2")).id
+
+characterization_function_dict = {
+ emission_id: characterize_co2,
+}
+```
+
+So, let's characterize our inventory. As a metric we choose radiative forcing, and a time horizon of 100 years:
+
+```python
+tlca.dynamic_lcia(
+ metric="radiative_forcing",
+ time_horizon=100,
+ characterization_function_dict=characterization_function_dict,
+)
+```
+
+This returns the (dynamic) characterized inventory:
+
+| date | amount | flow | activity |
+|------------|----------------|------|----------|
+| 2023-01-01 | 1.512067e-14 | 1 | 5 |
+| 2024-01-01 | 1.419411e-14 | 1 | 5 |
+| 2024-12-31 | 2.322610e-14 | 1 | 6 |
+| 2024-12-31 | 4.941608e-15 | 1 | 7 |
+| 2024-12-31 | 1.343660e-14 | 1 | 5 |
+| ... | ... | ... | ... |
+| 2124-01-01 | 1.400972e-15 | 1 | 7 |
+| 2124-01-01 | 3.302104e-15 | 1 | 8 |
+| 2124-12-31 | 3.294094e-15 | 1 | 8 |
+| 2125-12-31 | 3.286213e-15 | 1 | 8 |
+| 2127-01-01 | 3.278458e-15 | 1 | 8 |
+
+To visualize what's going on, we can conveniently plot it with:
+```python
+tlca.plot_dynamic_characterized_inventory()
+```
+```{image} ../data/dynamic_characterized_inventory_radiative_forcing.svg
+:align: center
+:alt: Plot showing the radiative forcing over time
+```
+
+
+Of course we can also assess the "standard" climate change metric Global Warming Potential (GWP):
+```python
+tlca.dynamic_lcia(
+ metric="GWP",
+ time_horizon=100,
+ characterization_function_dict=characterization_function_dict,
+)
+```
+
+| date | amount | flow | activity |
+|------------|-----------|------|----------|
+| 2022-01-01 | 9.179606 | 1 | 5 |
+| 2024-01-01 | 14.100328 | 1 | 6 |
+| 2024-01-01 | 3.000000 | 1 | 7 |
+| 2025-01-01 | 2.000000 | 1 | 7 |
+| 2028-01-01 | 4.680263 | 1 | 8 |
+
+... and plot it:
+```python
+tlca.plot_dynamic_characterized_inventory()
+```
+```{image} ../data/dynamic_characterized_inventory_gwp.svg
+:align: center
+:alt: Plot showing the radiative forcing over time
+```
+
+
+For most of the functions we used here, there are numerous optional arguments and settings you can tweak. We explore some of them in our other [Examples](../examples/index.md), but when in doubt: Our code is pretty well documented and there are [docstrings](../api/index) everywhere - so please use them ☀️
+
+
+
+
+
diff --git a/docs/content/getting_started/time_explicit_lci.md b/docs/content/getting_started/time_explicit_lci.md
new file mode 100644
index 0000000..b992813
--- /dev/null
+++ b/docs/content/getting_started/time_explicit_lci.md
@@ -0,0 +1,11 @@
+# Step 3 - Calculating the time-explicit LCI
+
+Calculating the time-explicit LCI from the timeline is very simple, at least from the user perspective:
+
+```python
+tlca.lci()
+```
+
+Under the hood, we re-build the technosphere and biosphere matrices, adding new rows and columns to carry the extra temporal information. More on that in the [Theory Section](../theory.md#time-mapping).
+
+Now that the inventory is calculated, we can characterize it in the next step.
\ No newline at end of file
diff --git a/docs/content/installation.md b/docs/content/installation.md
index 46b0597..8346245 100644
--- a/docs/content/installation.md
+++ b/docs/content/installation.md
@@ -3,8 +3,8 @@
`bw_timex` is a Python software package. It's available via [`pip`](https://pypi.org/project/pip/) or [`conda`](https://docs.conda.io/en/latest/) / [`mamba`](https://mamba.readthedocs.io/en/latest/).
```{note}
-1) We currently recommend the installation via `conda` or `mamba`. That's what we're providing detailed instructions for below.
-2) bw_timex depends on Brightway25, and will install bw25-compatible versions of the bw packages. This means that it cannot be added to existing virtual environments that are based on Brightway2, e.g. virtual environments containing activity browser. Please install bw_timex in a separate virtual environment following the instructions below.
+1) We recommend installation via `conda` or `mamba`.
+2) bw_timex depends on Brightway25, and will install bw25-compatible versions of the bw packages. This means that it cannot be added to existing virtual environments that are based on Brightway2, e.g., environments containing [Activity Browser](https://github.com/LCA-ActivityBrowser/activity-browser). Please install bw_timex in a separate environment following the instructions below.
```
## Installing `bw_timex` using `conda` or `mamba`
diff --git a/docs/content/theory.md b/docs/content/theory.md
index a9db6f9..fcee16b 100644
--- a/docs/content/theory.md
+++ b/docs/content/theory.md
@@ -1,33 +1,28 @@
# Theory
-This section explains some of the theory behind `bw_timex`. Check out
-the flow chart below for a quick overview of how it all comes together,
-and you\'ll find more detailed explanations of each step in the
-following subsections.
+This section explains some of the theory behind time-explicit LCAs with `bw_timex`. In contrast to the [Getting Started section](getting_started/index.md), we explain a bit more of what`s going on in the background here. If this is still to vague for you, you can always check out our [API reference](api/index).
-```{image} data/method_light.svg
-:class: only-light
-:height: 450px
-:align: center
-```
+## Terminology
+LCA terminology can be confusing sometimes. Here's an attempt of visualizing what we mean with "time-explicit LCA". Essentially, it combines dynamic LCA, where processes are spread out over time, with prospective LCA, where processes change over time:
-```{image} data/method_dark.svg
+```{image} data/dynamic_prospective_timeexplicit_dark.svg
:class: only-dark
-:height: 450px
-:align: center
+```
+```{image} data/dynamic_prospective_timeexplicit_light.svg
+:class: only-light
```
-## User input
+## Data requirements
-`bw_timex` requires 3 inputs:
+For a time-explicit LCA, 3 inputs are required:
1. a static foreground system model with
2. temporal information using the attribute `temporal_distribution` on
- technosphere or biosphere exchanges in the foreground system modeel,
+ technosphere or biosphere exchanges in the foreground system model,
and
3. a set of background databases, which must have a reference in time.
-```{dropdown} ℹ️ More info on inputs
+```{note}
- The foreground system must have exchanges linked to one of the
background databases. These exchanges at the intersection between
foreground and background databases will be relinked by `bw_timex`.
@@ -42,15 +37,69 @@ following subsections.
the consuming process is adopted also for the producing process.
```
-## Graph traversal
+## Temporal distributions and graph traversal
+To determine the timing of the exchanges within the production system, we add the `temporal_distribution` attribute to the respective exchanges. To carry the temporal information, we use the [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) class from [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). This class is a *container for a series of amount spread over time*, so it tells you what share of an exchange happens at what point in time. If two consecutive edges in the supply chain graph carry a `TemporalDistribution`, they are [convoluted](https://en.wikipedia.org/wiki/Convolution).
+
+````{admonition} Example: Convolution
+:class: admonition-example
+
+Let's say we have two temporal distributions. The first dates 30% of some amount two years into the future, and 70% of that amount four years into the future:
+
+```python
+import numpy as np
+from bw_temporalis import TemporalDistribution
+
+two_and_four_years_ahead = TemporalDistribution(
+ date=np.array([2, 4], dtype="timedelta64[Y]"),
+ amount=np.array([0.3, 0.7])
+)
+
+two_and_four_years_ahead.graph(resolution="Y")
+```
+~~~{image} data/td_two_and_four_years_ahead.svg
+:align: center
+~~~
+
+
+
+The other distribution spreads an amount over the following 4 months, with decreasing shares:
+```python
+spread_over_four_months = TemporalDistribution(
+ date=np.array([0, 1, 2, 3], dtype="timedelta64[M]"),
+ amount=np.array([0.4, 0.3, 0.2, 0.1])
+)
+
+spread_over_four_months.graph(resolution="M")
+```
+~~~{image} data/td_spread_over_four_months.svg
+:align: center
+~~~
+
+
+
+Now let's see what happens when we convolute these temporal distributions:
+```python
+convoluted_distribution = two_and_four_years_ahead * spread_over_four_months
-`bw_timex` uses the graph traversal from
-[bw_temporalis](https://github.com/brightway-lca/bw_temporalis/tree/main)
-to propagate the temporal information along the supply chain. The graph
-traversal is priority-first, following the most impactful node in the
-graph based on the static pre-calculated LCIA score for a chosen impact
-category. All input arguments for the graph traversal, such as maximum
-calculation count or cut-off, can be passed to the `TimexLCA` instance.
+convoluted_distribution.graph(resolution="M")
+```
+~~~{image} data/td_convoluted.svg
+:align: center
+~~~
+
+
+
+Note how both the dates and the amounts get scaled.
+````
+
+To convolute all the temporal information from the supply chain graph, `bw_timex` uses the graph traversal from
+[bw_temporalis](https://github.com/brightway-lca/bw_temporalis/tree/main). An in-depth
+description of how this works is available in the [brightway-docs](https://docs.brightway.dev/en/latest/content/theory/graph_traversal.html). In short,
+it is a priority-first supply chain graph traversal, following the most
+impactful node in the graph based on the static pre-calculated LCIA score
+for a chosen impact category. Several input arguments for the graph traversal,
+such as maximum calculation count or cut-off, can be passed to the `TimexLCA`
+instance.
By default, only the foreground system is traversed, but nodes to be
skipped during traversal can be specified by a `edge_filter_function`.
@@ -59,7 +108,7 @@ temporal distributions of the process and the exchange it consumes into
the resoluting combined temporal distribution of the upstream producer
of the exchange.
-## Process timeline
+## Building the process timeline
The graph traversal returns a timeline that lists the time of each
technosphere exchange in the temporalized foreground system. Exchanges
@@ -71,31 +120,49 @@ resolutions down to seconds while one may not have a similar temporal
resolution for the databases. We recommend aligning `temporal_grouping`
to the temporal resolution of the available databases.
-> Let\'s consider the following system: a process A that consumes an
-> exchange b from a process B, which emits an emission X and both the
-> exchange b and the emission X occur at a certain point in time.
->
-> ```{image} data/example_ab_light.svg
-> :class: only-light
-> :height: 300px
-> :align: center
-> ```
->
-> ```{image} data/example_ab_dark.svg
-> :class: only-dark
-> :height: 300px
-> :align: center
-> ```
-> |
->
-> The resulting timeline looks like this:
->
-> | time | producer | consumer | amount |
-> |------|----------|----------|-----------------|
-> | 0 | A | n/a | 1 |
-> | 0 | B | A | 2 \* 0.2 = 0.4 |
-> | 1 | B | A | 2 \* 0.8 = 1.6 |
+````{admonition} Example: Timeline
+:class: admonition-example
+
+Let's consider the following system: a process A that consumes an
+exchange b from a process B, which emits an emission X and both the
+exchange b and the emission X occur at a certain point in time.
+```{mermaid}
+flowchart LR
+subgraph background[" "]
+ B_2020(Process B \n 2020):::bg
+ B_2030(Process B \n 2030):::bg
+end
+
+subgraph foreground[" "]
+ A(Process A):::fg
+end
+
+subgraph biosphere[" "]
+ CO2:::b
+end
+
+B_2020-->|"amounts: [30%,50%,20%] * 3 kg\n dates:[-2,0,+4]" years|A
+A-.->|"amounts: [60%, 40%] * 5 kg\n dates: [0,+1]" years|CO2
+B_2020-.->|"amounts: [100%] * 11 kg\n dates:[0]" years|CO2
+B_2030-.->|"amounts: [100%] * 7 kg\n dates:[0]" years|CO2
+
+classDef bg color:#222832, fill:#3fb1c5, stroke:none;
+classDef fg color:#222832, fill:#3fb1c5, stroke:none;
+classDef b color:#222832, fill:#9c5ffd, stroke:none;
+style foreground fill:none, stroke:none;
+style background fill:none, stroke:none;
+style biosphere fill:none, stroke:none;
+
+```
+The resulting timeline looks like this:
+| date_producer | producer_name | date_consumer | consumer_name | amount | interpolation_weights |
+|---------------|---------------|---------------|---------------|--------|------------------------------------------------|
+| 2022-01-01 | B | 2024-01-01 | A | 0.9 | {'background': 0.8, 'background_2030': 0.2} |
+| 2024-01-01 | B | 2024-01-01 | A | 1.5 | {'background': 0.6, 'background_2030': 0.4} |
+| 2024-01-01 | A | 2024-01-01 | -1 | 1.0 | None |
+| 2028-01-01 | B | 2024-01-01 | A | 0.6 | {'background': 0.2, 'background_2030': 0.8} |
+````
## Time mapping
@@ -107,13 +174,13 @@ databases based on temporal proximity. The new best-fitting background
producer(s) are mapped on the same name, reference product and location
as the old background producer.
-## Modified matrices
+## Modifying the matrices
`bw_timex` now modifies the technopshere and biosphere matrices using
`datapackages` from
[bw_processing](https://github.com/brightway-lca/bw_processing?tab=readme-ov-file).
-### Technosphere matrix modifications:
+### Technosphere matrix modifications
1. For each temporalized process in the timeline, a new process copy is
created, which links to its new temporalized producers and
@@ -124,7 +191,7 @@ as the old background producer.
relinks the exchanges to the new producing processes from the
best-fitting background database(s).
-### Biosphere matrix modifications:
+### Biosphere matrix modifications
Depending on the user\'s choice, two different biosphere matrices are
created:
@@ -143,20 +210,19 @@ created:
`TimexLCA.dynamic_inventory_df` contain the emissions of the system
per biosphere flow including its timestamp and its emitting process.
-> For the simple system above, a schematic representation of the matrix
-> modifications looks like this:
->
-> ```{image} data/matrix_light.svg
-> :class: only-light
-> :height: 300px
-> :align: center
-> ```
->
-> ```{image} data/matrix_dark.svg
-> :class: only-dark
-> :height: 300px
-> :align: center
-> ```
+```{admonition} Example: Matrix modifications
+:class: admonition-example
+For the simple system above, a schematic representation of the matrix
+modifications looks like this:
+~~~{image} data/matrix_stuff_light.svg
+:class: only-light
+:align: center
+~~~
+~~~{image} data/matrix_stuff_dark.svg
+:class: only-dark
+:align: center
+~~~
+```
## Static or dynamic impact assessment
@@ -181,9 +247,3 @@ horizon means that each emission is evaluated starting from its own
timing until the end of the time horizon. The former is the approach of
[Levasseur et al. 2010](https://pubs.acs.org/doi/10.1021/es9030003).
This behaviour is set with the boolean `fixed_time_horizon`.
-
-```{note}
-*Work in progress*. `bw_timex` *is under active development and the
-theory section might not reflect the latest code development. When in
-doubt, the source code is the most reliable source of information.*
-```
diff --git a/docs/index.md b/docs/index.md
index c1df594..dbd1320 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,6 +1,6 @@
# Time-explicit LCA with `bw_timex`
-[bw_timex](https://github.com/brightway-lca/bw_timex) is a python package for time-explicit Life Cycle Assessment that helps you assess the environmental impacts of products and processes over time. `bw_timex` builds on top of the [Brightway LCA framework](https://docs.brightway.dev/en/latest).
+`bw_timex` is a python package for [time-explicit Life Cycle Assessment](content/theory.md#terminology) that helps you assess the environmental impacts of products and processes over time. `bw_timex` builds on top of the [Brightway LCA framework](https://docs.brightway.dev/en/latest).
## Features
This package enables you to account for:
@@ -16,15 +16,6 @@ You can define temporal distributions for process and emission exchanges, which
- **Long-lived** products
- **Biogenic** carbon
-Here's a visualization of what `bw_timex` can do for you:
-
-```{image} content/data/timex_dark.svg
-:class: only-dark
-```
-```{image} content/data/timex_light.svg
-:class: only-light
-```
-
## Support
If you have any questions or need help, do not hesitate to contact us:
- Timo Diepers ([timo.diepers@ltt.rwth-aachen.de](mailto:timo.diepers@ltt.rwth-aachen.de))
@@ -37,8 +28,9 @@ hidden:
maxdepth: 1
---
Installation
-Examples
+Getting Started
Theory
+Examples
API
Contributing
Code of Conduct
diff --git a/notebooks/data/method.svg b/notebooks/data/method.svg
new file mode 100644
index 0000000..cf507f4
--- /dev/null
+++ b/notebooks/data/method.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/notebooks/getting_started.ipynb b/notebooks/getting_started.ipynb
new file mode 100644
index 0000000..52cd41f
--- /dev/null
+++ b/notebooks/getting_started.ipynb
@@ -0,0 +1,1072 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Getting Started with `bw_timex`\n",
+ "\n",
+ "This notebook will help you quickly getting started with your time-explicit LCA project. We're keeping it simple here - no deep dives into how things work in the background, no exploring of all the features and options `bw_timex` has. Just a quick walkthrough of the different steps of a `TimexLCA`. Here's a rundown:\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "\n",
+ "In the following sections, we'll walk through the steps 1-4, considering a very simple dummy system.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 1 - Adding temporal information\n",
+ "\n",
+ "To get you started with time-explicit LCA, we'll investigate this very simple production system with two \"technosphere\" nodes A and B and a \"biosphere\" node representing some CO2 emissions. For the sake of this example, we'll assume that we demand Process A to run exactly once.\n",
+ "\n",
+ "```mermaid\n",
+ "flowchart LR\n",
+ "subgraph background[background]\n",
+ " B(Process B):::bg\n",
+ "end\n",
+ "\n",
+ "subgraph foreground[foreground]\n",
+ " A(Process A):::fg\n",
+ "end\n",
+ "\n",
+ "subgraph biosphere[biosphere]\n",
+ " CO2(CO2):::bio\n",
+ "end\n",
+ "\n",
+ "B-->|\"3 kg \\n \"|A\n",
+ "A-.->|\"5 kg \\n \"|CO2\n",
+ "B-.->|\"11 kg \\n \"|CO2\n",
+ "\n",
+ "classDef fg color:#222832, fill:#3fb1c5, stroke:none;\n",
+ "classDef bg color:#222832, fill:#3fb1c5, stroke:none;\n",
+ "classDef bio color:#222832, fill:#9c5ffd, stroke:none;\n",
+ "style background fill:none, stroke:none;\n",
+ "style foreground fill:none, stroke:none;\n",
+ "style biosphere fill:none, stroke:none;\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "vscode": {
+ "languageId": "plaintext"
+ }
+ },
+ "source": [
+ "First, we need to model this production system - so far only \"normal\" brightway stuff:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 1/1 [00:00<00:00, 5652.70it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Vacuuming database \n",
+ "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 1/1 [00:00<00:00, 22795.13it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Vacuuming database \n",
+ "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 1/1 [00:00<00:00, 20460.02it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Vacuuming database \n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "import bw2data as bd\n",
+ "\n",
+ "bd.projects.set_current(\"getting_started_with_timex\")\n",
+ "\n",
+ "bd.Database(\"biosphere\").write(\n",
+ " {\n",
+ " (\"biosphere\", \"CO2\"): {\n",
+ " \"type\": \"emission\",\n",
+ " \"name\": \"CO2\",\n",
+ " },\n",
+ " }\n",
+ ")\n",
+ "\n",
+ "bd.Database(\"background\").write(\n",
+ " {\n",
+ " (\"background\", \"B\"): {\n",
+ " \"name\": \"B\",\n",
+ " \"location\": \"somewhere\",\n",
+ " \"reference product\": \"B\",\n",
+ " \"exchanges\": [\n",
+ " {\n",
+ " \"amount\": 1,\n",
+ " \"type\": \"production\",\n",
+ " \"input\": (\"background\", \"B\"),\n",
+ " },\n",
+ " {\n",
+ " \"amount\": 11,\n",
+ " \"type\": \"biosphere\",\n",
+ " \"input\": (\"biosphere\", \"CO2\"),\n",
+ " },\n",
+ " ],\n",
+ " },\n",
+ " }\n",
+ ")\n",
+ "\n",
+ "bd.Database(\"foreground\").write(\n",
+ " {\n",
+ " (\"foreground\", \"A\"): {\n",
+ " \"name\": \"A\",\n",
+ " \"location\": \"somewhere\",\n",
+ " \"reference product\": \"A\",\n",
+ " \"exchanges\": [\n",
+ " {\n",
+ " \"amount\": 1,\n",
+ " \"type\": \"production\",\n",
+ " \"input\": (\"foreground\", \"A\"),\n",
+ " },\n",
+ " {\n",
+ " \"amount\": 3,\n",
+ " \"type\": \"technosphere\",\n",
+ " \"input\": (\"background\", \"B\"),\n",
+ " },\n",
+ " {\n",
+ " \"amount\": 5,\n",
+ " \"type\": \"biosphere\",\n",
+ " \"input\": (\"biosphere\", \"CO2\"),\n",
+ " }\n",
+ " ],\n",
+ " },\n",
+ " }\n",
+ ")\n",
+ "\n",
+ "bd.Method((\"our\", \"method\")).write(\n",
+ " [\n",
+ " ((\"biosphere\", \"CO2\"), 1),\n",
+ " ]\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, if you want to consider time in your LCA, you need to somehow add temporal information. For time-explicit LCA, we consider two kinds of temporal information, that will be discussed in the following."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Temporal distributions\n",
+ "\n",
+ "To determine the timing of the exchanges within the production system, we add the `temporal_distribution` attribute to the respective exchanges. To carry the temporal information, we use the [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) class from [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). This class is a *container for a series of amount spread over time*, so it tells you what share of an exchange happens at what point in time. So, let's include this information in out production system - visually at first:\n",
+ "\n",
+ "```mermaid\n",
+ "flowchart LR\n",
+ "subgraph background[\" \"]\n",
+ " B_2020(Process B):::bg\n",
+ "end\n",
+ "\n",
+ "subgraph foreground[\" \"]\n",
+ " A(Process A):::fg\n",
+ "end\n",
+ "\n",
+ "subgraph biosphere[\" \"]\n",
+ " CO2:::b\n",
+ "end\n",
+ "\n",
+ "B_2020-->|\"amounts: [30%,50%,20%] * 3 kg\\n dates:[-2,0,+4]\" years|A\n",
+ "A-.->|\"amounts: [60%, 40%] * 5 kg\\n dates: [0,+1]\" years|CO2\n",
+ "B_2020-.->|\"amounts: [100%] * 11 kg\\n dates:[0]\" years|CO2\n",
+ "\n",
+ "classDef bg color:#222832, fill:#3fb1c5, stroke:none;\n",
+ "classDef fg color:#222832, fill:#3fb1c5, stroke:none;\n",
+ "classDef b color:#222832, fill:#9c5ffd, stroke:none;\n",
+ "style foreground fill:none, stroke:none;\n",
+ "style background fill:none, stroke:none;\n",
+ "style biosphere fill:none, stroke:none;\n",
+ "\n",
+ "```\n",
+ "\n",
+ "Now it's time to add this information to our modeled production system in brightway:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from bw_temporalis import TemporalDistribution\n",
+ "from bw_timex.utils import add_temporal_distribution_to_exchange\n",
+ "\n",
+ "# Starting with the exchange between A and B\n",
+ "# First, create a TemporalDistribution with the time information from above\n",
+ "td_b_to_a = TemporalDistribution(\n",
+ " date=np.array([-2, 0, 4], dtype=\"timedelta64[Y]\"),\n",
+ " amount=np.array([0.3, 0.5, 0.2]),\n",
+ ")\n",
+ "\n",
+ "# Now add the temporal distribution to the corresponding exchange. In \n",
+ "# principle, you just have to do the following:\n",
+ "# exchange_object[\"temporal_distribution\"] = TemporalDistribution \n",
+ "# We currently don't have the exchange-object at hand here, but we can \n",
+ "# use the utility function add_temporal_distribution_to_exchange to help.\n",
+ "add_temporal_distribution_to_exchange(\n",
+ " temporal_distribution=td_b_to_a, \n",
+ " input_code=\"B\", \n",
+ " input_database=\"background\",\n",
+ " output_code=\"A\",\n",
+ " output_database=\"foreground\"\n",
+ ")\n",
+ "\n",
+ "# Now we do the same for our other temporalized exchange between A and CO2\n",
+ "td_a_to_co2 = TemporalDistribution(\n",
+ " date=np.array([0, 1], dtype=\"timedelta64[Y]\"),\n",
+ " amount=np.array([0.6, 0.4]),\n",
+ ")\n",
+ "\n",
+ "# We actually only have to define enough fields to uniquely identify the \n",
+ "# exchange here\n",
+ "add_temporal_distribution_to_exchange(\n",
+ " temporal_distribution=td_a_to_co2, \n",
+ " input_code=\"CO2\", \n",
+ " output_code=\"A\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Prospective data\n",
+ "\n",
+ "The other kind of temporal data we can add is some prospective information on how our processes change over time. So, for our simple example, let's say our background process B somehow evolves, so that it emitts less CO2 in the future. To make it precise, we assume that the original process we modeled above represents the process state in the year 2020, emitting 11 kg CO2, which reduces to 7 kg CO2 by 2030:\n",
+ "\n",
+ "```mermaid\n",
+ "flowchart LR\n",
+ "subgraph background[\" \"]\n",
+ " B_2020(Process B \\n 2020):::bg\n",
+ " B_2030(Process B \\n 2030):::bg\n",
+ "end\n",
+ "\n",
+ "subgraph foreground[\" \"]\n",
+ " A(Process A):::fg\n",
+ "end\n",
+ "\n",
+ "subgraph biosphere[\" \"]\n",
+ " CO2:::b\n",
+ "end\n",
+ "\n",
+ "B_2020-->|\"amounts: [30%,50%,20%] * 3 kg\\n dates:[-2,0,+4]\" years|A\n",
+ "A-.->|\"amounts: [60%, 40%] * 5 kg\\n dates: [0,+1]\" years|CO2\n",
+ "B_2020-.->|\"amounts: [100%] * 11 kg\\n dates:[0]\" years|CO2\n",
+ "B_2030-.->|\"amounts: [100%] * 7 kg\\n dates:[0]\" years|CO2\n",
+ "\n",
+ "classDef bg color:#222832, fill:#3fb1c5, stroke:none;\n",
+ "classDef fg color:#222832, fill:#3fb1c5, stroke:none;\n",
+ "classDef b color:#222832, fill:#9c5ffd, stroke:none;\n",
+ "style foreground fill:none, stroke:none;\n",
+ "style background fill:none, stroke:none;\n",
+ "style biosphere fill:none, stroke:none;\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 1/1 [00:00<00:00, 14513.16it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Vacuuming database \n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "bd.Database(\"background_2030\").write(\n",
+ " {\n",
+ " (\"background_2030\", \"B\"): {\n",
+ " \"name\": \"B\",\n",
+ " \"location\": \"somewhere\",\n",
+ " \"reference product\": \"B\",\n",
+ " \"exchanges\": [\n",
+ " {\n",
+ " \"amount\": 1,\n",
+ " \"type\": \"production\",\n",
+ " \"input\": (\"background_2030\", \"B\"),\n",
+ " },\n",
+ " {\n",
+ " \"amount\": 7,\n",
+ " \"type\": \"biosphere\",\n",
+ " \"input\": (\"biosphere\", \"CO2\"),\n",
+ " },\n",
+ " ],\n",
+ " },\n",
+ " }\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 1/1 [00:00<00:00, 17476.27it/s]"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Vacuuming database \n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "bd.Database(\"background_2030\").write(\n",
+ " {\n",
+ " (\"background_2030\", \"B\"): {\n",
+ " \"name\": \"B\",\n",
+ " \"location\": \"somewhere\",\n",
+ " \"reference product\": \"B\",\n",
+ " \"exchanges\": [\n",
+ " {\n",
+ " \"amount\": 1,\n",
+ " \"type\": \"production\",\n",
+ " \"input\": (\"background_2030\", \"B\"),\n",
+ " },\n",
+ " {\n",
+ " \"amount\": 7,\n",
+ " \"type\": \"biosphere\",\n",
+ " \"input\": (\"biosphere\", \"CO2\"),\n",
+ " },\n",
+ " ],\n",
+ " },\n",
+ " }\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So, as you can see, the prospective processes can reside within your normal brightway databases. To hand them to `bw_timex`, we just need to define a dictionary that maps the prospective database names to the point in time that they represent:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from datetime import datetime\n",
+ "\n",
+ "# Note: The foreground does not represent a specific point in time, but should \n",
+ "# later be dynamically distributed over time\n",
+ "database_date_dict = {\n",
+ " \"background\": datetime.strptime(\"2020\", \"%Y\"),\n",
+ " \"background_2030\": datetime.strptime(\"2030\", \"%Y\"),\n",
+ " \"foreground\": \"dynamic\",\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> **Note:** You can use whatever data source you want for this prospective data. A nice package from the Brightway cosmos that can help you is [premise](https://premise.readthedocs.io/en/latest/introduction.html)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 2 - Building the process timeline \n",
+ "\n",
+ "With all the temporal information prepared, we can now instantiate our TimexLCA object. This is very similar to a normal Brightway LCA object, but with the additional argument of our `database_date_dict`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from bw_timex import TimexLCA\n",
+ "\n",
+ "tlca = TimexLCA(\n",
+ " demand={(\"foreground\", \"A\"): 1},\n",
+ " method=(\"our\", \"method\"),\n",
+ " database_date_dict=database_date_dict,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Using our new `tlca` object, we can now build the timeline of processes that leads to our functional unit, \"A\". If not specified otherwise, it's assumed that the demand occurs in the current year, which is 2024 at the time of writing this. Actually building the timeline is now very simple on the user-side:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Starting graph traversal\n",
+ "Calculation count: 1\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timex_lca.py:195: UserWarning: No edge filter function provided. Skipping all edges within background databases.\n",
+ " warnings.warn(\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
date_producer
\n",
+ "
producer_name
\n",
+ "
date_consumer
\n",
+ "
consumer_name
\n",
+ "
amount
\n",
+ "
interpolation_weights
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0
\n",
+ "
2022-01-01
\n",
+ "
B
\n",
+ "
2024-01-01
\n",
+ "
A
\n",
+ "
0.9
\n",
+ "
{'background': 0.7998905009581166, 'background...
\n",
+ "
\n",
+ "
\n",
+ "
1
\n",
+ "
2024-01-01
\n",
+ "
B
\n",
+ "
2024-01-01
\n",
+ "
A
\n",
+ "
1.5
\n",
+ "
{'background': 0.6000547495209416, 'background...
\n",
+ "
\n",
+ "
\n",
+ "
2
\n",
+ "
2024-01-01
\n",
+ "
A
\n",
+ "
2024-01-01
\n",
+ "
-1
\n",
+ "
1.0
\n",
+ "
None
\n",
+ "
\n",
+ "
\n",
+ "
3
\n",
+ "
2028-01-01
\n",
+ "
B
\n",
+ "
2024-01-01
\n",
+ "
A
\n",
+ "
0.6
\n",
+ "
{'background': 0.20010949904188335, 'backgroun...
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " date_producer producer_name date_consumer consumer_name amount \\\n",
+ "0 2022-01-01 B 2024-01-01 A 0.9 \n",
+ "1 2024-01-01 B 2024-01-01 A 1.5 \n",
+ "2 2024-01-01 A 2024-01-01 -1 1.0 \n",
+ "3 2028-01-01 B 2024-01-01 A 0.6 \n",
+ "\n",
+ " interpolation_weights \n",
+ "0 {'background': 0.7998905009581166, 'background... \n",
+ "1 {'background': 0.6000547495209416, 'background... \n",
+ "2 None \n",
+ "3 {'background': 0.20010949904188335, 'backgroun... "
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tlca.build_timeline()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Calling this directly returned the `tlca.timeline` dataframe. Here we can see which share of which exchange happens at what point in time. Additionally, the \"interpolation_weights\" already tell us what share of an exchange should come from which database. With this info, we can calculate our time-explicit LCI in the next step."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 3 - Calculating the time-explicit LCI\n",
+ "\n",
+ "Calculating the time-explicit LCI from the timeline is very simple, at least from the user perspective:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/bw2calc/lca_base.py:127: SparseEfficiencyWarning: splu converted its input to CSC format\n",
+ " self.solver = factorized(self.technosphere_matrix)\n"
+ ]
+ }
+ ],
+ "source": [
+ "tlca.lci()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Under the hood, we re-build the technosphere and biosphere matrices, adding new rows and columns to carry the extra temporal information. More on that in the [Theory Section](https://docs.brightway.dev/projects/bw-timex/en/latest/content/theory.html#Modifying-the-matrices) of our docs.\n",
+ "\n",
+ "Now that the inventory is calculated, we can characterize it in the next step."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 4 - Impact assessment\n",
+ "\n",
+ "To characterize the calculated inventory, we have two options: Static and dynamic life cycle impact assessment (LCIA).\n",
+ "\n",
+ "### Static LCIA\n",
+ "If we don't care about the timing of the emissions, we can do static LCIA using the standard characterization factors. To characterize the inventory with the impact assessment method that we initially chose when creating our `TimexLCA` object, we can simply call:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "tlca.static_lcia()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "and investigate the resulting score like this:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "32.96019709827539"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tlca.static_score"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Dynamic LCIA\n",
+ "\n",
+ "The inventory calculated by a `TimexLCA` retains temporal information. That means that in addition to knowing which process emitts what substance, we also know the timing of each emission. This allows for more advanced, dynamic characterization using characterization functions instead of just factors. In `bw_timex`, users can either use their own curstom functions or use some existing ones, e.g., from the package [`dynamic_characterization`](https://dynamic-characterization.readthedocs.io/en/latest/). We'll do the latter here. \n",
+ "\n",
+ "First, we need to define which characterization function we want to apply to which biosphere flow:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from dynamic_characterization.timex import characterize_co2\n",
+ "emission_id = bd.get_activity((\"biosphere\", \"CO2\")).id\n",
+ "\n",
+ "characterization_function_dict = {\n",
+ " co2: characterize_co2,\n",
+ " ch4: characterize_ch4,\n",
+ "}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So, let's characterize our inventory. As a metric we choose radiative forcing, and a time horizon of 100 years:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "