diff --git a/message_ix/tests/data/add_tech/westeros_carbon_removal_data.yaml b/message_ix/tests/data/add_tech/westeros_carbon_removal_data.yaml new file mode 100644 index 000000000..c2640e30f --- /dev/null +++ b/message_ix/tests/data/add_tech/westeros_carbon_removal_data.yaml @@ -0,0 +1,98 @@ +daccs: + year_init: 700 + inv_cost_: + par_name: inv_cost + value: 100 + unit: USD/(tCO2/yr) + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + fix_cost_: + par_name: fix_cost + value: 5 + unit: USD/(tCO2/yr)/yr + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + year_act: + rate: 0 + var_cost_: + par_name: var_cost + value: 5 + unit: USD/tCO2 + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + year_act: + rate: 0 + input_: + par_name: input + value: 0.0028 + unit: '-' + node_loc: + Westeros: 1 + mode: + standard: 1 + commodity: + electricity: 1 + level: + final: 1 + output_: + par_name: output + value: 1 + unit: tCO2 + node_loc: + Westeros: 1 + mode: + standard: 1 + commodity: + CO2: 1 + level: + final: 1 + capacity_factor_: + par_name: capacity_factor + value: 0.913 + unit: '-' + node_loc: + Westeros: 1 + emission_factor_: + par_name: emission_factor + value: -1 + unit: tCO2/tCO2 + node_loc: + Westeros: 1 + mode: + standard: 1 + emission: + CO2: 1 + technical_lifetime_: + par_name: technical_lifetime + value: 25 + unit: y + node_loc: + Westeros: 1 + initial_new_capacity_up_: + par_name: initial_new_capacity_up + value: 0.5 + unit: Mt CO2/yr + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + time: + year: 1 + growth_new_capacity_up_: + par_name: growth_new_capacity_up + value: 0.05 + unit: '-' + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + time: + year: 1 + + \ No newline at end of file diff --git a/message_ix/tests/test_tutorials.py b/message_ix/tests/test_tutorials.py index edf6facc2..24721804b 100644 --- a/message_ix/tests/test_tutorials.py +++ b/message_ix/tests/test_tutorials.py @@ -86,6 +86,8 @@ 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}_carbon_removal"), + _t("w0", f"{W}_multinode_emissions_bounds_daccs"), # 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)]), diff --git a/message_ix/tests/tools/test_add_tech.py b/message_ix/tests/tools/test_add_tech.py new file mode 100644 index 000000000..136826cf6 --- /dev/null +++ b/message_ix/tests/tools/test_add_tech.py @@ -0,0 +1,28 @@ +from message_ix.testing import make_dantzig +from message_ix.tools.add_tech import print_df + + +def test_print_df(test_mp, request, test_data_path, tmp_path): + scen = make_dantzig(test_mp, quiet=True, request=request) + scen.check_out() + path = test_data_path.joinpath("add_tech") + output_dir = tmp_path.joinpath("add_tec") + output_dir.mkdir() + print_df( + scenario=scen, + input_path=str(path.joinpath("westeros_carbon_removal_data.yaml")), + output_dir=output_dir, + ) + + # TODO: adapt this to read parameter names from yaml file + parameter_list = scen.par_list() + for parameter in parameter_list: + assert (output_dir / f"{parameter}.xlsx").exists() + + +# def test_get_values(): +# get_values() + + +# def test_get_report(): +# get_report() diff --git a/message_ix/tools/add_tech/__init__.py b/message_ix/tools/add_tech/__init__.py new file mode 100644 index 000000000..79ec10e92 --- /dev/null +++ b/message_ix/tools/add_tech/__init__.py @@ -0,0 +1,553 @@ +import os +from pathlib import Path +from typing import Any, Union + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import yaml + +from message_ix import Scenario +from message_ix.models import MESSAGE_ITEMS +from message_ix.utils import make_df + + +def add_missing_commodities_to_scenario( + scenario: Scenario, tech_data: dict, par_idx: dict, tec: str, name: str +) -> None: + if tec not in scenario.set("technology"): + scenario.add_set("technology", tec) + + if "commodity" in par_idx[tec][name]: + commodity = list(tech_data[tec][name]["commodity"].keys())[0] + if commodity not in scenario.set("commodity"): + scenario.add_set("commodity", commodity) + + +def prepare_kwargs_for_make_df( + tech_data: dict, par_idx: dict, tec: str, name: str +) -> dict[str, Union[Any, list]]: + kwargs = {} + if all(idx in par_idx[tec][name] for idx in ["year_vtg", "year_act"]): + kwargs = { + "year_vtg": tech_data[tec]["year_vtg"], + "year_act": tech_data[tec]["year_act"], + } + elif "year_vtg" in par_idx[tec][name]: + kwargs = {"year_vtg": sorted(set(tech_data[tec]["year_vtg"]))} + else: + kwargs = {"year_act": sorted(set(tech_data[tec]["year_act"]))} + # if 'year_rel' is present, the values are assumed + # from 'year_act' values + if "year_rel" in par_idx[tec][name]: + kwargs.update({"year_rel": sorted(set(tech_data[tec]["year_act"]))}) + return kwargs + + +def generate_df( + scenario, + filepath="", +): + """ + This function generate parameter dataframe, matching the data input + in yaml file and parameter's dimension + + Parameters + ---------- + scenario : message_ix.Scenario() + MESSAGEix Scenario where the data will be included + filepath : string, path of the input file + the default is in the module's folder + """ + + if not filepath: + module_path = os.path.abspath(__file__) # get the module path + package_path = os.path.dirname( + os.path.dirname(module_path) + ) # get the package path + path = os.path.join( + package_path, "add_dac/tech_data.yaml" + ) # join the current working directory with a filename + + else: + path = filepath + + with open(path, "r") as stream: + tech_data = yaml.safe_load(stream) + + assert isinstance(tech_data, dict) + + # Set up dictionary of parameter indices list + par_idx = {} + data = {} + + # Create dicitonary of parameter indices and data + for tech in set(tech_data): + # add vintage and active years and update tech_data for each tech + years_vtg_act = scenario.vintage_and_active_years() + years_vtg_act = years_vtg_act[ + years_vtg_act["year_vtg"] >= tech_data[tech]["year_init"] + ] + tech_data[tech]["year_vtg"] = years_vtg_act["year_vtg"].to_list() + tech_data[tech]["year_act"] = years_vtg_act["year_act"].to_list() + + # collect parameter indices and update data + par_idx.update( + { + tech: { + name: { + idx: [] + for idx in list( + MESSAGE_ITEMS[tech_data[tech][name]["par_name"]].get( + "idx_names" + ) + ) + } + for name in set(tech_data[tech]) + - set(["year_init", "year_vtg", "year_act"]) + } + } + ) + + data.update({tech: {name: [] for name in list(par_idx[tech].keys())}}) + + # If those are not provided, then this block of code + # is needed to retrieve them from the data input + regions = [] + emissions = [] + times = [] + modes = [] + commodities = [] + levels = [] + relations = [] + + set_elements_dict = { + "node_loc": {"data": regions, "name": "node"}, + "emission": {"data": emissions, "name": "emission"}, + "mode": {"data": modes, "name": "mode"}, + "time": {"data": times, "name": "time"}, + "commodity": {"data": commodities, "name": "commodity"}, + "level": {"data": levels, "name": "level"}, + "time_origin": {"data": times, "name": "time"}, + "time_dest": {"data": times, "name": "time"}, + "relation": {"data": relations, "name": "relation"}, + "node_rel": {"data": regions, "name": "node"}, + } + + # Create DataFrame for all parameters + for tec, val in data.items(): + for name in val.keys(): + add_missing_commodities_to_scenario( + scenario=scenario, + tech_data=tech_data, + par_idx=par_idx, + tec=tec, + name=name, + ) + + kwargs = prepare_kwargs_for_make_df( + tech_data=tech_data, par_idx=par_idx, tec=tec, name=name + ) + + df = make_df( + tech_data[tec][name]["par_name"], + technology=tec, + value=tech_data[tec][name]["value"], + unit=tech_data[tec][name]["unit"], + **kwargs, + ) + + # create empty dataframe + idx_exp = [ + e + for e in par_idx[tec][name] + if e + not in [ + "technology", + "year_vtg", + "year_act", + "year_rel", + "node_origin", + "node_dest", + "node_rel", + "time_origin", + "time_dest", + ] + ] + + for idx in idx_exp: + default = ( + { + e: 1 + for e in list(scenario.set(set_elements_dict[idx]["name"]))[1:] + } + if idx in ["node_loc", "mode"] + else { + e: 1 for e in list(scenario.set(set_elements_dict[idx]["name"])) + } + ) + + listidx = list(tech_data[tec][name].get(idx, default)) + listdfidx = [] + for e in listidx: + df1 = df.copy() + df1[idx] = [e] * len(df) + listdfidx.append(df1) + df = pd.concat(listdfidx, ignore_index=True) + + # assigning values for node and time related indices + for idx in df.columns: + if idx in ["node_origin", "node_dest", "node_rel"]: + df[idx] = df["node_loc"] + elif idx in ["time_origin", "time_dest"]: + df[idx] = df["time"] + + # Calculate values of row-by-row multipliers + mult = [] + for i in range(len(df)): + # node_loc factor + _node_loc = ( + tech_data[tec] + .get(name, {}) + .get("node_loc", {}) + .get(df.get("node_loc", {}).get(i), 1) + ) + + # year_vtg factor + # _year_vtg = (1+rate)**delta_years + + if "year_vtg" in df.columns: + usf_year_vtg = ( + tech_data[tec] + .get(name, {}) + .get("year_vtg", {}) + .get(df["year_vtg"][i], 1) + ) + + exp_year_vtg = df["year_vtg"][i] - tech_data[tech]["year_init"] + + _year_vtg = ( + np.power( + ( + 1 + + tech_data[tec] + .get(name, {}) + .get("year_vtg", {}) + .get("rate", 0.0) + ), + exp_year_vtg, + ) + * usf_year_vtg + ) + else: + _year_vtg = 1 + + # year_act factor + # _year_act = ((1+rate)**(year_act-year_vtg))*usf_year_act + # if both years present + # _year_act = ((1+rate)**(year_act-first_active_year))*usf_year_act + # if no year_vtg + + if "year_act" in df.columns: + usf_year_act = ( + tech_data[tec] + .get(name, {}) + .get("year_act", {}) + .get(df["year_act"][i], 1) + ) + + exp_year_act = df["year_act"][i] - ( + df["year_vtg"][i] + if "year_vtg" in df.columns + else tech_data[tech]["year_init"] + ) + + _year_act = ( + np.power( + ( + 1 + + tech_data[tec] + .get(name, {}) + .get("year_act", {}) + .get("rate", 0) + ), + exp_year_act, + ) + * usf_year_act + ) + else: + _year_act = 1 + + # get mode multiplier from model_data + _mode = ( + tech_data[tec] + .get(name, {}) + .get("mode", {}) + .get(df.get("mode", {}).get(i), 1) + ) + + mult.append( + np.prod( + [ + _node_loc, + _year_vtg, + _year_act, + _mode, + ] + ) + ) + + # index adjusted df + value = df["value"] * mult + value = [e for e in value] + df["value"] = value + + data[tec][name] = df + + return data + + +def print_df(scenario: Scenario, input_path: str, output_dir: Path) -> None: + data = generate_df(scenario, input_path) + for tec, val in data.items(): + with pd.ExcelWriter( + str(output_dir / f"{tec}.xlsx"), engine="xlsxwriter", mode="w" + ) as writer: + for sheet_name, sheet_data in val.items(): + sheet_data.to_excel(writer, sheet_name=sheet_name, index=False) + + +def add_tech(scenario, filepath=""): + """ + Parameters + ---------- + scenario : message_ix.Scenario() + MESSAGEix Scenario where the data will be included + filepath : string, path of the input file + the default is in the module's folder + """ + + # check if all required sets already in scenario + # TODO: this must not be hardcoded here + # if "CO2_storage" not in scenario.set("emission"): + # scenario.add_set("emission", "CO2_storage") + # if "co2_storage_pot" not in scenario.set("type_emission"): + # scenario.add_set("type_emission", "co2_storage_pot") + # if "co2_potential" not in scenario.set("type_tec"): + # scenario.add_set("type_tec", "co2_potential") + # if "co2_stor" not in scenario.set("technology"): + # scenario.add_set("technology", "co2_stor") + + # scenario.add_set("cat_emission", ["co2_storage_pot", "CO2_storage"]) + # scenario.add_set("cat_tec", ["co2_potential", "co2_stor"]) + + # Reading new technology database + if not filepath: + module_path = os.path.abspath(__file__) # get the module path + package_path = os.path.dirname( + os.path.dirname(module_path) + ) # get the package path + path = os.path.join( + package_path, "add_dac/tech_data.yaml" + ) # join the current working directory with a filename + data = generate_df(scenario, path) + else: + data = generate_df(scenario, filepath) + + if not filepath: + module_path = os.path.abspath(__file__) # get the module path + package_path = os.path.dirname( + os.path.dirname(module_path) + ) # get the package path + path = os.path.join( + package_path, "add_dac/tech_data.yaml" + ) # join the current working directory with a filename + with open(path, "r") as stream: + tech_data = yaml.safe_load(stream) + else: + with open(filepath, "r") as stream: + tech_data = yaml.safe_load(stream) + + # TODO: @ywpratama, bring in the set information here from the YAML file + # Adding parameters by technology and name + for tec, val in data.items(): + if tec not in set(scenario.set("technology")): + scenario.add_set("technology", tec) + + for name in val.keys(): + if tech_data[tec][name]["par_name"] == "relation_activity": + for rel in tech_data[tec][name]["relation"]: + if rel not in set(scenario.set("relation")): + scenario.add_set("relation", rel) + # if tech_data[tec][name]["relation"][0] not in set( + # scenario.set("relation") + # ): + # scenario.add_set("relation", tech_data[tec][name]["relation"][0]) + scenario.add_par(tech_data[tec][name]["par_name"], data[tec][name]) + + # TODO: @ywpratama, add in the relation_actiavity for emissions in the yaml file + # Specific for daccs setup in the global model, + # "CO2_Emission_Global_Total" relation should be added via + # yaml file referencing this method below + + # n_nodes = np.int32(len(scenario.set("node")) - 2) + + # excluding 'World' and 'RXX_GLB' + # reg_exception = ["World", f"R{n_nodes}_GLB"] + # node_loc = [e for e in scenario.set("node") if e not in reg_exception] + # year_act = [e for e in scenario.set("year") if e >= 2025] + + # Creating dataframe for CO2_Emission_Global_Total relation + # CO2_global_par = [] + # for reg in node_loc: + # CO2_global_par.append( + # make_df( + # "relation_activity", + # relation="CO2_Emission_Global_Total", + # node_rel=f"R{n_nodes}_GLB", + # year_rel=year_act, + # node_loc=reg, + # technology="co2_stor", + # year_act=year_act, + # mode="M1", + # value=-1, + # unit="-", + # ) + # ) + # CO2_global_par = pd.concat(CO2_global_par) + # relation lower and upper bounds + # rel_lower_upper = [] + # for rel in ["co2_trans", "bco2_trans"]: + # for reg in node_loc: + # rel_lower_upper.append( + # make_df( + # "relation_lower", + # relation=rel, + # node_rel=reg, + # year_rel=year_act, + # value=0, + # unit="-", + # ) + # ) + # rel_lower_upper = pd.concat(rel_lower_upper) + # Adding the dataframe to the scenario + # scenario.add_par("relation_activity", CO2_global_par) + # scenario.add_par("relation_lower", rel_lower_upper) + # scenario.add_par("relation_upper", rel_lower_upper) + + +def get_values( + scenario, + variable="", + valuetype="lvl", + # filters = {} +): + # filters must use 'cat_tec' to aggregate technology + # don't forget to include check unit + """ + Parameters + ---------- + scenario : message_ix.Scenario() + MESSAGEix Scenario where the data will be included + variable : string + name of variable to report + valuetype : string, 'lvl' or 'mrg' + type of values reported to report, + either level or marginal. + default is 'lvl' + """ + + if isinstance(scenario.var(variable), pd.DataFrame): + df = scenario.var(variable) + dimensions = [col for col in df.columns if col not in ["lvl", "mrg"]] + return df.set_index(dimensions)[[valuetype]] + else: + return scenario.var(variable)[valuetype] + + +def get_report( + scenario, + technologies=[], +): + """ + Parameters + ---------- + scenario : message_ix.Scenario() + MESSAGEix Scenario where the data will be included + technologies : string or list + name of technology to be reported + variable : string or list + name of variable to report + """ + var_dict = {var: [] for var in ["CAP", "CAP_NEW", "INVESTMENT", "REMOVAL"]} + + # listing model years to be reported + years_rep = sorted( + scenario.set("cat_year") + .set_index("type_year") + .loc["cumulative", "year"] + .to_list() + ) + + # Create dataframe + for var in var_dict.keys(): + # primary variables + if var in ["CAP", "CAP_NEW"]: + df = ( + get_values(scenario, var)["lvl"] + .unstack() + .loc[:, technologies, :] + .groupby(["node_loc"]) + .sum() + )[years_rep] + + # investment + elif var == "INVESTMENT": + depl = ( + get_values(scenario, "CAP_NEW")["lvl"].unstack().loc[:, technologies, :] + )[years_rep] + + dfic = scenario.par("inv_cost") + + inv = ( + dfic.loc[dfic["technology"].isin(technologies)] + .set_index(["node_loc", "technology", "year_vtg"])["value"] + .unstack() + ) + + df = depl.mul(inv).groupby(["node_loc"]).sum() + + # removal + elif var == "REMOVAL": + acts = get_values(scenario, "ACT").droplevel(["mode", "time"]) + df = ( + acts.loc[:, technologies, :, :]["lvl"] + .unstack() + .groupby(["node_loc"]) + .sum() + ) + + df.loc["World"] = df.sum(axis=0) + + var_dict[var] = df + + # Create dictionary for variable dataframes and write variables to excel + with pd.ExcelWriter("get_report_output.xlsx", engine="openpyxl") as writer: + for var in var_dict.keys(): + var_dict[var].to_excel(writer, sheet_name=var) + + frame_count = 0 + fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(10, 6)) + for k, v in var_dict.items(): + r = np.int32(np.floor(frame_count / 2)) + c = frame_count - r * 2 + frame_count += 1 + for reg in range(len(v)): + kwargs = {"marker": "o"} if reg == 11 else {} + axs[r, c].plot(v.columns, v.iloc[reg], label=v.index[reg], **kwargs) + axs[r, c].set_title(k) + axs[0, 0].legend(ncols=2) + plt.tight_layout() + plt.show() + + return var_dict diff --git a/message_ix/util/tutorial.py b/message_ix/util/tutorial.py index c4285dcda..76b49d6eb 100644 --- a/message_ix/util/tutorial.py +++ b/message_ix/util/tutorial.py @@ -10,7 +10,9 @@ PLOTS = [ ("activity", operator.stacked_bar, "out:nl-t-ya", "GWa"), ("capacity", operator.stacked_bar, "CAP:nl-t-ya", "GW"), + ("cdr capacity", operator.stacked_bar, "CAP:nl-t-ya", "tCO2/yr"), ("demand", operator.stacked_bar, "demand:n-c-y", "GWa"), + ("emission", operator.stacked_bar, "emi:nl-t-ya", "tCO2"), ("extraction", operator.stacked_bar, "EXT:n-c-g-y", "GW"), ("new capacity", operator.stacked_bar, "CAP_NEW:nl-t-yv", "GWa"), ("prices", operator.stacked_bar, "PRICE_COMMODITY:n-c-y", "¢/kW·h"), @@ -27,6 +29,8 @@ def prepare_plots(rep: Reporter, input_costs="$/GWa") -> None: - ``plot extraction`` - ``plot fossil supply curve`` - ``plot capacity`` + - ``plot cdr capacity`` + - ``plot emission`` - ``plot new capacity`` - ``plot prices`` @@ -47,7 +51,7 @@ def prepare_plots(rep: Reporter, input_costs="$/GWa") -> None: # Add one node to the reporter for each plot for title, func, key_str, units in PLOTS: # Convert the string to a Key object so as to reference its .dims - key = Key(key_str) + key = Key.from_str_or_key(key_str) # Operation for the reporter comp = partial( diff --git a/tutorial/README.rst b/tutorial/README.rst index 5ea76bdf0..47ee9b6f7 100644 --- a/tutorial/README.rst +++ b/tutorial/README.rst @@ -158,6 +158,9 @@ framework, such as used in global research applications of |MESSAGEix|. #. Modeling of a multi-node energy system and representing trade between nodes (:tut:`westeros/westeros_multinode_energy_trade.ipynb`). + #. Including carbon removal technologies + (:tut:`westeros/westeros_carbon_removal.ipynb`). + #. Use other features of :mod:`message_ix` and :mod:`ixmp`: #. ⭐ After the MESSAGE model has solved, use the :mod:`.message_ix.report` diff --git a/tutorial/westeros/data/westeros_carbon_removal_data.yaml b/tutorial/westeros/data/westeros_carbon_removal_data.yaml new file mode 100644 index 000000000..c2640e30f --- /dev/null +++ b/tutorial/westeros/data/westeros_carbon_removal_data.yaml @@ -0,0 +1,98 @@ +daccs: + year_init: 700 + inv_cost_: + par_name: inv_cost + value: 100 + unit: USD/(tCO2/yr) + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + fix_cost_: + par_name: fix_cost + value: 5 + unit: USD/(tCO2/yr)/yr + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + year_act: + rate: 0 + var_cost_: + par_name: var_cost + value: 5 + unit: USD/tCO2 + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + year_act: + rate: 0 + input_: + par_name: input + value: 0.0028 + unit: '-' + node_loc: + Westeros: 1 + mode: + standard: 1 + commodity: + electricity: 1 + level: + final: 1 + output_: + par_name: output + value: 1 + unit: tCO2 + node_loc: + Westeros: 1 + mode: + standard: 1 + commodity: + CO2: 1 + level: + final: 1 + capacity_factor_: + par_name: capacity_factor + value: 0.913 + unit: '-' + node_loc: + Westeros: 1 + emission_factor_: + par_name: emission_factor + value: -1 + unit: tCO2/tCO2 + node_loc: + Westeros: 1 + mode: + standard: 1 + emission: + CO2: 1 + technical_lifetime_: + par_name: technical_lifetime + value: 25 + unit: y + node_loc: + Westeros: 1 + initial_new_capacity_up_: + par_name: initial_new_capacity_up + value: 0.5 + unit: Mt CO2/yr + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + time: + year: 1 + growth_new_capacity_up_: + par_name: growth_new_capacity_up + value: 0.05 + unit: '-' + node_loc: + Westeros: 1 + year_vtg: + rate: 0 + time: + year: 1 + + \ No newline at end of file diff --git a/tutorial/westeros/data/westeros_multinode_daccs_data.yaml b/tutorial/westeros/data/westeros_multinode_daccs_data.yaml new file mode 100644 index 000000000..7074c4569 --- /dev/null +++ b/tutorial/westeros/data/westeros_multinode_daccs_data.yaml @@ -0,0 +1,102 @@ +daccs: + year_init: 700 + inv_cost_: + par_name: inv_cost + value: 100 + unit: USD/(tCO2/yr) + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + year_vtg: + rate: 0 + fix_cost_: + par_name: fix_cost + value: 5 + unit: USD/(tCO2/yr)/yr + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + year_vtg: + rate: 0 + year_act: + rate: 0 + var_cost_: + par_name: var_cost + value: 5 + unit: USD/tCO2 + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + year_vtg: + rate: 0 + year_act: + rate: 0 + input_: + par_name: input + value: 0.0028 + unit: '-' + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + mode: + standard: 1 + commodity: + electricity: 1 + level: + final: 1 + capacity_factor_: + par_name: capacity_factor + value: 0.913 + unit: '-' + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + emission_factor_: + par_name: emission_factor + value: -1 + unit: tCO2/tCO2 + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + mode: + standard: 1 + emission: + CO2: 1 + technical_lifetime_: + par_name: technical_lifetime + value: 25 + unit: y + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + initial_new_capacity_up_: + par_name: initial_new_capacity_up + value: 0.5 + unit: Mt CO2/yr + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + year_vtg: + rate: 0 + time: + year: 1 + growth_new_capacity_up_: + par_name: growth_new_capacity_up + value: 0.05 + unit: '-' + node_loc: + Westeros: 1 + Essos: 1 + Stepstones: 1 + year_vtg: + rate: 0 + time: + year: 1 diff --git a/tutorial/westeros/westeros_carbon_removal.ipynb b/tutorial/westeros/westeros_carbon_removal.ipynb new file mode 100644 index 000000000..8f279922e --- /dev/null +++ b/tutorial/westeros/westeros_carbon_removal.ipynb @@ -0,0 +1,422 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ce427fd", + "metadata": {}, + "source": [ + "# Westeros tutorial - Adding DACCS in climate mitigation scenario\n", + "In the previous tutorials, we have learnt how to create a baseline scenario (`westeros_baseline.ipynb`) and add emissions bounds (`westeros_emissions_bounds.ipynb`) to the baseline scenario. Here, we will show how to include an additional/new technology to a MESSAGE model. While the combination of currently existing technologies might be able to deliver the Paris targets, the deployment of some new technologies might improve the probability of meeting the targets and/or reducing the costs. These technologies include CO2 removal (CDR) technologies. Hence, in this tutorial, we will use direct air carbon capture and storage (DACCS) as an example of new technologies to be considered in climate mitigation pathways. \n", + "\n", + "In order to smoothly follow this tutorial, you have to alrady have the MESSAGEix framework installed and working. Additionally, you should have run the Westeros baseline and emissions bounds scenarios successfully as this tutorial is built on top of those scenarios.\n", + "\n", + "If all set, we can start by importing all the packages we need and connect to a database that store the scenario input and results. We can also name the model as `Westeros Electrified` here.\n", + "\n", + "In this tutorial, we will use add_dac tool which requires user to specify the location of the data, in yaml format. As such, we use os package to help us specifying the yaml file.\n", + "\n", + "## Requirements\n", + "\n", + "This tutorial requires that you have run `westeros_emissions_bounds.ipynb` and have [`message-ix-models`](https://github.com/iiasa/message-ix-models) installed." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "239a17a2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "if (typeof IPython !== 'undefined') { IPython.OutputArea.prototype._should_scroll = function(lines){ return false; }}" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "\n", + "import pandas as pd\n", + "import ixmp\n", + "import message_ix\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from message_ix.utils import make_df\n", + "from message_ix.tools.add_tech import add_tech\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "57257989", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "mp = ixmp.Platform()\n", + "\n", + "model = \"Westeros Electrified\"" + ] + }, + { + "cell_type": "markdown", + "id": "c82f18ff", + "metadata": {}, + "source": [ + "After we are connected to the database, we can call the prevously run `\"emission_bound\"` scenario as our base model and clone the data before we start adding DACCS to the model. As prevoiusly mentioned, to run this tutorial, you have to have succesfully run the `\"emission_bound\"` scenario, which was built based on the `\"baseline\"` scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9a868ad2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This Scenario has a solution, use `Scenario.remove_solution()` or `Scenario.clone(..., keep_solution=False)`\n" + ] + } + ], + "source": [ + "base = message_ix.Scenario(mp, model=model, scenario=\"emission_bound\")\n", + "\n", + "scenario = base.clone(\n", + " model,\n", + " \"emission_bound_daccs\",\n", + " \"adding daccs using add_dac tool\",\n", + " keep_solution=False,)\n", + "scenario.check_out()\n", + "\n", + "year_df = scenario.vintage_and_active_years()\n", + "vintage_years, act_years = year_df[\"year_vtg\"], year_df[\"year_act\"]\n", + "model_horizon = scenario.set(\"year\")\n", + "country = \"Westeros\"" + ] + }, + { + "cell_type": "markdown", + "id": "b5db71ca", + "metadata": {}, + "source": [ + "# Adding DACCS description\n", + "First step of adding DACCS as a technology in the model is by including DACCS into the `\"technology\"` set." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3b203192", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "mp.add_unit(\"USD/(tCO2/yr)\")\n", + "mp.add_unit(\"USD/(tCO2/yr)/yr\")\n", + "mp.add_unit(\"USD/tCO2\")\n", + "mp.add_unit(\"tCO2/tCO2\")\n", + "mp.add_unit(\"tCO2\")\n", + "mp.add_unit(\"Mt CO2/yr\")\n", + "\n", + "\n", + "filepath = os.path.join(os.getcwd(), \"data/westeros_carbon_removal_data.yaml\")\n", + "add_tech(scenario, filepath=filepath)\n" + ] + }, + { + "cell_type": "markdown", + "id": "017c5ca3", + "metadata": {}, + "source": [ + "Similar to what we did when generating the `\"baseline\"` scenario, the first thing we need to do is defining the input and output comodities of each technology. " + ] + }, + { + "cell_type": "markdown", + "id": "54cc0111", + "metadata": {}, + "source": [ + "# Solve Statement\n", + "Finally, this is the solve statement" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3131e0dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Objective value: 196264.453125\n" + ] + } + ], + "source": [ + "scenario.commit(comment=\"Adding daccs using add_dac tool\")\n", + "scenario.set_as_default()\n", + "\n", + "scenario.solve()\n", + "scenario.var(\"OBJ\")[\"lvl\"]\n", + "\n", + "print('Objective value: ', scenario.var(\"OBJ\")[\"lvl\"])" + ] + }, + { + "cell_type": "markdown", + "id": "dad6cedb", + "metadata": {}, + "source": [ + "# Plotting Results and Compare\n", + "Finally, this is the plotting results command to compare emissions bound scenarios with and without DACCS" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "19e29174", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# Create a Reporter object to describe and carry out reporting\n", + "# calculations and operations (like plotting) based on `scenario`\n", + "# Add keys like \"plot activity\" to describe reporting operations.\n", + "# See tutorial/utils/plotting.py\n", + "from message_ix.report import Reporter\n", + "from message_ix.util.tutorial import prepare_plots\n", + "\n", + "rep_ori = Reporter.from_scenario(base)\n", + "rep_new = Reporter.from_scenario(scenario)" + ] + }, + { + "cell_type": "markdown", + "id": "eb382f4d", + "metadata": {}, + "source": [ + "## System acticity" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ea31acff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without DACCS\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With DACCS\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Without DACCS\")\n", + "prepare_plots(rep_ori)\n", + "rep_ori.set_filters(t=[\"coal_ppl\", \"wind_ppl\"])\n", + "rep_ori.get(\"plot activity\")\n", + "plt.show()\n", + "\n", + "print(\"With DACCS\")\n", + "prepare_plots(rep_new)\n", + "rep_new.set_filters(t=[\"coal_ppl\", \"wind_ppl\"])\n", + "rep_new.get(\"plot activity\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f28be730", + "metadata": {}, + "source": [ + "### DACCS Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "803233f0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prepare_plots(rep_new)\n", + "rep_new.set_filters(t=[\"daccs\"])\n", + "rep_new.get(\"plot removal capacity\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d03f4f74", + "metadata": {}, + "source": [ + "## Emissions" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "76423c69", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without DACCS\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq0AAAHTCAYAAAANnCGHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEW0lEQVR4nO3de3zP9f//8ft75wPbjB0sNtLEHCKKochpIb/USiSWRGkkyyGfcpZTSapRSviIDlJ9ouScwoycPkKS+Expm9M2Jpttr98fLnt9e7eNmW3vl9yul8v7Uu/n8/l+vx6v117m7vV+vp8vm2EYhgAAAAALc3J0AQAAAMCVEFoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAGXq6NGjstlsWrBgQam/t81m07hx40r9fQFYD6EV14VPPvlENptNn3/+eYG+2267TTabTRs2bCjQFxoaqhYtWpR6PZMnT9YXX3xR6u9bHsaNGyebzVbkIzk52dEllqkTJ05oyJAhqlOnjjw9PRUYGKg777xTI0eO1Llz50p9e+fPn9e4ceP07bfflvp7X6s2bdoUeR7UqVPH0eUBgB0XRxcAFEerVq0kSZs2bdIDDzxgtmdkZOjHH3+Ui4uLNm/erHvuucfsO3bsmI4dO6YePXqUej2TJ0/WQw89pG7dupX6e5eXOXPmqEKFCgXa/fz8yr+YcnL69Gk1bdpUGRkZeuKJJ1SnTh2dOnVK//3vfzVnzhwNHDiw0GNyLc6fP6/x48dLuhQSraZatWqaMmVKgXZfX99S20ZYWJj+/PNPubq6ltp75vvzzz/l4sJfZcCNgD/puC6EhISoZs2a2rRpk117QkKCDMPQww8/XKAv/3l+4LW6CxcuyM3NTU5O5fMByEMPPaQqVaqUy7YuJzMzU97e3uWyrXnz5ikpKUmbN28ucAU+IyNDbm5u5VKHlfj6+uqxxx4r023YbDZ5eHiUyXuX1fsCsB6mB+C60apVK+3atUt//vmn2bZ582bVq1dPnTp10tatW5WXl2fXZ7PZ1LJlS7Ptgw8+UJMmTeTp6Sl/f3/16NFDx44ds9vOoUOHFB0dreDgYHl4eKhatWrq0aOH0tPTJV36CzgzM1MLFy40P0p9/PHHzdf//vvveuKJJxQUFCR3d3fVq1dP77//vt02vv32W9lsNn300Ud66aWXdNNNN8nLy0sZGRmSpKVLl5p1VqlSRY899ph+//13u/dITk5W3759Va1aNbm7u6tq1aq6//77dfTo0Ws6zn+v8ZNPPtHLL7+satWqycPDQ+3atdMvv/xSYHxiYqLuvfde+fr6ysvLS61bt9bmzZvtxuRPTdi/f78effRRVapUyfxHRV5ensaNG6eQkBB5eXnpnnvu0f79+1WjRg3z+P7666+y2WyaOXNmge1v2bJFNptNH374YZH7dPjwYTk7O6t58+YF+nx8fMwANHbsWLm6uurEiRMFxg0YMEB+fn66cOGCJOmHH35QVFSUqlSpIk9PT9WsWVNPPPGEpEtzOQMCAiRJ48ePN8+Xv87B/Omnn/TQQw/J399fHh4eatq0qb788ku7bS5YsEA2m02bNm3Ss88+q4CAAPn5+empp55Sdna20tLS1KdPH1WqVEmVKlXSiBEjZBhGkcfhauX/3H7++Wc99thj8vX1VUBAgEaPHi3DMHTs2DHdf//98vHxUXBwsGbMmGH3+sLmtBbn/L3csc1X2JzWXbt2qVOnTvLx8VGFChXUrl07bd261W5M/jHdvHmz4uLiFBAQIG9vbz3wwAOF/twBOB5XWnHdaNWqlRYtWqTExETzY9b8K2YtWrRQenq6fvzxRzVs2NDsq1OnjipXrixJevnllzV69Gh1795dTz75pE6cOKE333xTd999t3bt2iU/Pz9lZ2crKipKWVlZGjx4sIKDg/X7779rxYoVSktLk6+vrxYtWqQnn3xSd955pwYMGCBJqlWrliQpJSVFzZs3l81m06BBgxQQEKCVK1eqX79+ysjI0HPPPWe3TxMnTpSbm5uGDRumrKwsubm5acGCBerbt6/uuOMOTZkyRSkpKZo1a5Y2b95s1ilJ0dHR2rdvnwYPHqwaNWooNTVVa9asUVJSkmrUqHHF43n69OkCbS4uLgWmB0ydOlVOTk4aNmyY0tPTNX36dPXq1UuJiYnmmPXr16tTp05q0qSJxo4dKycnJ82fP19t27bV999/rzvvvNPuPR9++GGFh4dr8uTJZrgaNWqUpk+frq5duyoqKkp79uxRVFSUGQ4l6eabb1bLli21ePFiDR061O49Fy9erIoVK+r+++8vcp/DwsKUm5urRYsWKSYmpshxvXv31oQJE/Txxx9r0KBBZnt2drY+/fRTRUdHy8PDQ6mpqerYsaMCAgL0wgsvyM/PT0ePHtVnn30mSQoICDCnHTzwwAN68MEHJck8R/ft26eWLVvqpptu0gsvvCBvb2998skn6tatm5YtW2Y3FUaSeU6OHz9eW7du1dy5c+Xn56ctW7YoNDRUkydP1tdff61XXnlF9evXV58+fYrcx3y5ubk6efJkgXZPT88CV8AfeeQR1a1bV1OnTtVXX32lSZMmyd/fX++8847atm2radOmafHixRo2bJjuuOMO3X333UVu90rn75WObVH27dunu+66Sz4+PhoxYoRcXV31zjvvqE2bNtq4caOaNWtW4JhWqlRJY8eO1dGjR/X6669r0KBB+vjjj6947ACUMwO4Tuzbt8+QZEycONEwDMO4ePGi4e3tbSxcuNAwDMMICgoy4uPjDcMwjIyMDMPZ2dno37+/YRiGcfToUcPZ2dl4+eWX7d5z7969houLi9m+a9cuQ5KxdOnSy9bi7e1txMTEFGjv16+fUbVqVePkyZN27T169DB8fX2N8+fPG4ZhGBs2bDAkGTfffLPZZhiGkZ2dbQQGBhr169c3/vzzT7N9xYoVhiRjzJgxhmEYxpkzZwxJxiuvvHL5g1aIsWPHGpIKfdx6663muPwa69ata2RlZZnts2bNMiQZe/fuNQzDMPLy8ozw8HAjKirKyMvLM8edP3/eqFmzptGhQ4cC2+7Zs6ddTcnJyYaLi4vRrVs3u/Zx48YZkuyO9TvvvGNIMg4cOGB33KpUqVLoz+Tv2wkICDAkGXXq1DGefvppY8mSJUZaWlqBsZGRkUazZs3s2j777DNDkrFhwwbDMAzj888/NyQZ27dvL3KbJ06cMCQZY8eOLdDXrl07o0GDBsaFCxfMtry8PKNFixZGeHi42TZ//nxDUoFjHBkZadhsNuPpp58223Jycoxq1aoZrVu3vuyxMAzDaN26dZHnwlNPPWWOy/+5DRgwoMB2bDabMXXqVLP9zJkzhqenp93P4siRI4YkY/78+eaYK52/xTm2hmEUOLbdunUz3NzcjMOHD5ttx48fNypWrGjcfffdZlv+MW3fvr3dMR06dKjh7Oxc6DkBwLGYHoDrRt26dVW5cmVzruqePXuUmZlpzk1s0aKF+XF0QkKCcnNzzY+eP/vsM+Xl5al79+46efKk+QgODlZ4eLi58kD+l09WrVql8+fPX1V9hmFo2bJl6tq1qwzDsNtOVFSU0tPTtXPnTrvXxMTEyNPT03z+ww8/KDU1Vc8884zdXL0uXbqoTp06+uqrryRdugrm5uamb7/9VmfOnLmqOvMtW7ZMa9assXvMnz+/wLi+ffvazfW86667JF36qF6Sdu/erUOHDunRRx/VqVOnzH3OzMxUu3bt9N1339lN25Ckp59+2u75unXrlJOTo2eeecauffDgwQXq6d69uzw8PLR48WKzbdWqVTp58uQV52YGBQVpz549evrpp3XmzBm9/fbbevTRRxUYGKiJEyfafaTep08fJSYm6vDhw2bb4sWLVb16dbVu3VrS/31pbcWKFbp48eJlt/13p0+f1vr169W9e3edPXvWPG6nTp1SVFSUDh06VGBKSL9+/WSz2cznzZo1k2EY6tevn9nm7Oyspk2bmj+fK6lRo0aB82DNmjUFPhWQpCeffLLAdv6+fT8/P916662X3X5xzt+SHNvc3FytXr1a3bp1080332y2V61aVY8++qg2bdpkTsHJN2DAALtjetdddyk3N1f/+9//irVNAOWH0Irrhs1mU4sWLcy5q5s3b1ZgYKBuueUWSfahNf+/+aH10KFDMgxD4eHhCggIsHscOHBAqampkqSaNWsqLi5O7733nqpUqaKoqCjFx8eb81kv58SJE0pLS9PcuXMLbKNv376SZG4nX82aNe2e5/9FeeuttxZ4/zp16pj97u7umjZtmlauXKmgoCDdfffdmj59+lUtV3X33Xerffv2do/IyMgC40JDQ+2eV6pUSZLMsHHo0CFJlwL43/f7vffeU1ZWVoHjV9R+5/8s8/n7+5vby+fn56euXbtqyZIlZtvixYt10003qW3btlfc76pVq2rOnDn6448/dPDgQb3xxhsKCAjQmDFjNG/ePHPcI488Ind3dzMcp6ena8WKFerVq5cZclq3bq3o6GiNHz9eVapU0f3336/58+crKyvrinX88ssvMgxDo0ePLnDcxo4dK6ng+fL3n0X+P7KqV69eoL24/5jx9vYucB60b9++0CWvCtu+h4dHgS/0XWn7xTl/S3JsT5w4ofPnzxf656du3brKy8srMIf9Suc3AOtgTiuuK61atdLy5cu1d+/eAt8Ab9GihYYPH67ff/9dmzZtUkhIiHm1JS8vTzabTStXrpSzs3OB9/3rMkczZszQ448/rv/85z9avXq1nn32WU2ZMkVbt25VtWrViqwt/2riY489VuR8yfy5jPn+epX1aj333HPq2rWrvvjiC61atUqjR4/WlClTtH79ejVu3LjE7/t3hR0vSeZVyfz9fuWVV9SoUaNCx/59Galr2W/p0lXQpUuXasuWLWrQoIG+/PJLPfPMM1e18oLNZlPt2rVVu3ZtdenSReHh4Vq8eLF5NbFSpUq67777tHjxYo0ZM0affvqpsrKy7K7m2mw2ffrpp9q6dauWL1+uVatW6YknntCMGTO0devWyy6flX/chg0bpqioqELH/D3EF/WzKKzdKMUvYl1uO1c6P4pypfP3Wo7tte5TceoHUP4Irbiu/HW91s2bN9t9hNmkSRO5u7vr22+/VWJiojp37mz21apVS4ZhqGbNmqpdu/YVt9OgQQM1aNBAL730krZs2aKWLVvq7bff1qRJkyTJ7uPEfAEBAapYsaJyc3PVvn37Eu1fWFiYJOngwYMFrhoePHjQ7P/rfj3//PN6/vnndejQITVq1EgzZszQBx98UKLtl0T+l9B8fHyueb9/+eUXu6uwp06dKvSK17333quAgAAtXrxYzZo10/nz59W7d+8SbVu69AWvSpUq6Y8//rBr79Onj+6//35t375dixcvVuPGjVWvXr0Cr2/evLmaN2+ul19+WUuWLFGvXr300Ucf6cknnyz0XMnfpiS5urqW+Lhd74pz/l7u2P5dQECAvLy8dPDgwQJ9P/30k5ycnApclQZw/WB6AK4rTZs2Necz/v7773ZXWt3d3XX77bcrPj5emZmZduuzPvjgg3J2dtb48eMLXEExDEOnTp2SdGmtzpycHLv+Bg0ayMnJye5jSW9vb6WlpdmNc3Z2VnR0tJYtW6Yff/yxQO3FWUanadOmCgwM1Ntvv223vZUrV+rAgQPq0qWLpEsL1v/1W/XSpQBQsWLFYn00XZqaNGmiWrVq6dVXXy30jlLF2e927drJxcVFc+bMsWt/6623Ch3v4uKinj176pNPPtGCBQvUoEGDAlexC5OYmKjMzMwC7du2bdOpU6cKfKzcqVMnValSRdOmTdPGjRsLzJk9c+ZMgfMp/2pz/s/By8tLkgqcL4GBgWrTpo3eeeedAmFZKt5xu14V5/wtzrH9O2dnZ3Xs2FH/+c9/7JbOSklJ0ZIlS9SqVSv5+PiU3o4AKFdcacV1xc3NTXfccYe+//57ubu7q0mTJnb9LVq0MNeI/GtorVWrliZNmqRRo0bp6NGj6tatmypWrKgjR47o888/14ABAzRs2DCtX79egwYN0sMPP6zatWsrJydHixYtMgNpviZNmmjt2rV67bXXzBsfNGvWTFOnTtWGDRvUrFkz9e/fXxERETp9+rR27typtWvXFrrM1F+5urpq2rRp6tu3r1q3bq2ePXuaS17VqFHDXObp559/Vrt27dS9e3dFRETIxcVFn3/+uVJSUop9B7BPP/200I9YO3TooKCgoGK9hyQ5OTnpvffeU6dOnVSvXj317dtXN910k37//Xdt2LBBPj4+Wr58+WXfIygoSEOGDNGMGTP0//7f/9O9996rPXv2aOXKlapSpUqhVyv79OmjN954Qxs2bNC0adOKVeuiRYu0ePFiPfDAA2rSpInc3Nx04MABvf/++/Lw8NC//vUvu/Gurq7q0aOH3nrrLTk7O6tnz552/QsXLtTs2bP1wAMPqFatWjp79qzeffdd+fj4mFf6PT09FRERoY8//li1a9eWv7+/6tevr/r16ys+Pl6tWrVSgwYN1L9/f918881KSUlRQkKCfvvtN+3Zs6dY+3Ut0tPTi7wyX1Y3HSjO+VucY1uYSZMmac2aNWrVqpWeeeYZubi46J133lFWVpamT59eJvsDoJyU/4IFwLUZNWqUIclo0aJFgb78JYkqVqxo5OTkFOhftmyZ0apVK8Pb29vw9vY26tSpY8TGxhoHDx40DMMwfv31V+OJJ54watWqZXh4eBj+/v7GPffcY6xdu9bufX766Sfj7rvvNjw9PQssyZSSkmLExsYa1atXN1xdXY3g4GCjXbt2xty5c80x+ctJFbW01scff2w0btzYcHd3N/z9/Y1evXoZv/32m9l/8uRJIzY21qhTp47h7e1t+Pr6Gs2aNTM++eSTKx6/yy15pb8s51RUjX9fvijfrl27jAcffNCoXLmy4e7uboSFhRndu3c31q1bV2DbJ06cKFBXTk6OMXr0aCM4ONjw9PQ02rZtaxw4cMCoXLmy3ZJOf1WvXj3DycnJ7thczn//+19j+PDhxu233274+/sbLi4uRtWqVY2HH37Y2LlzZ6Gv2bZtmyHJ6NixY4G+nTt3Gj179jRCQ0MNd3d3IzAw0LjvvvuMH374wW7cli1bjCZNmhhubm4Flmg6fPiw0adPHyM4ONhwdXU1brrpJuO+++4zPv30U3NM/vJMf1/+qajjGRMTY3h7e1/xeFxuyau//vVwtdtp3bq1Ua9ePfP538+Z4py/xT22fz+e+a+NiooyKlSoYHh5eRn33HOPsWXLFrsxRR3T/PM+/88BAOuwGQazzQFYU1pamipVqqRJkybpxRdfLNDfuHFj+fv7a926dWVWw549e9SoUSP9+9//vqZ5swCAa8OcVgCW8Nfb8+Z7/fXXJcm8A9pf/fDDD9q9e3ex7vp0Ld59911VqFDBvJsVAMAxmNMKwBI+/vhjLViwQJ07d1aFChW0adMmffjhh+rYsaNatmxpjvvxxx+1Y8cOzZgxQ1WrVtUjjzxSJvUsX75c+/fv19y5czVo0KACtzQFAJQvQisAS2jYsKFcXFw0ffp0ZWRkmF/Oyl9mLN+nn36qCRMm6NZbb9WHH35od+ew0jR48GClpKSoc+fOGj9+fJlsAwBQfMxpBQAAgOUxpxUAAACWR2gFAACA5TGnVZfuAX78+HFVrFixyFsuAgAAazEMQ2fPnlVISIicnLgO909HaJV0/Phx7kcNAMB16tixY6pWrZqjy0AZI7RKqlixoqRLJz33pQYA4PqQkZGh6tWrm3+P45/N4aH1999/18iRI7Vy5UqdP39et9xyi+bPn6+mTZtKunTpf+zYsXr33XeVlpamli1bas6cOQoPDzff4/Tp0xo8eLCWL18uJycnRUdHa9asWYXeV70w+VMCfHx8CK0AAFxnmNp3Y3DoBJAzZ86oZcuWcnV11cqVK7V//37NmDFDlSpVMsdMnz5db7zxht5++20lJibK29tbUVFRunDhgjmmV69e2rdvn9asWaMVK1bou+++04ABAxyxSwAAACgDDl2n9YUXXtDmzZv1/fffF9pvGIZCQkL0/PPPa9iwYZKk9PR0BQUFacGCBerRo4cOHDigiIgIbd++3bw6+80336hz58767bffFBIScsU6MjIy5Ovrq/T0dK60AgBwneDv7xuLQ6+0fvnll2ratKkefvhhBQYGqnHjxnr33XfN/iNHjig5OVnt27c323x9fdWsWTMlJCRIkhISEuTn52cGVklq3769nJyclJiYWOh2s7KylJGRYfcAAACAdTk0tP7666/m/NRVq1Zp4MCBevbZZ7Vw4UJJUnJysiQpKCjI7nVBQUFmX3JysgIDA+36XVxc5O/vb475uylTpsjX19d8sHIAAACAtTk0tObl5en222/X5MmT1bhxYw0YMED9+/fX22+/XabbHTVqlNLT083HsWPHynR7AAAAuDYODa1Vq1ZVRESEXVvdunWVlJQkSQoODpYkpaSk2I1JSUkx+4KDg5WammrXn5OTo9OnT5tj/s7d3d1cKYAVAwAAAKzPoaG1ZcuWOnjwoF3bzz//rLCwMElSzZo1FRwcrHXr1pn9GRkZSkxMVGRkpCQpMjJSaWlp2rFjhzlm/fr1ysvLU7NmzcphLwAAAFDWHLpO69ChQ9WiRQtNnjxZ3bt317Zt2zR37lzNnTtX0qV115577jlNmjRJ4eHhqlmzpkaPHq2QkBB169ZN0qUrs/fee685reDixYsaNGiQevToUayVAwAAAGB9Dl3ySpJWrFihUaNG6dChQ6pZs6bi4uLUv39/sz//5gJz585VWlqaWrVqpdmzZ6t27drmmNOnT2vQoEF2Nxd44403in1zAZbMAADg+sPf3zcWh4dWK+CkBwDg+sPf3zcWh85pBQAAAIqD0AoAAADLI7QCAADA8gitAAAAsDyHLnkFAEBpq/HCV44u4R/h6NQuji4BsMOVVgAAAFgeoRUAAACWR2gFAACA5RFaAQAAYHmEVgAAAFgeoRUAAACWR2gFAACA5bFOK4ASYz3M0sOamABweVxpBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlkdoBQAAgOURWgEAAGB5hFYAAABYHqEVAAAAlufQ0Dpu3DjZbDa7R506dcz+CxcuKDY2VpUrV1aFChUUHR2tlJQUu/dISkpSly5d5OXlpcDAQA0fPlw5OTnlvSsAAAAoQy6OLqBevXpau3at+dzF5f9KGjp0qL766istXbpUvr6+GjRokB588EFt3rxZkpSbm6suXbooODhYW7Zs0R9//KE+ffrI1dVVkydPLvd9AQAAQNlweGh1cXFRcHBwgfb09HTNmzdPS5YsUdu2bSVJ8+fPV926dbV161Y1b95cq1ev1v79+7V27VoFBQWpUaNGmjhxokaOHKlx48bJzc2tvHcHAAAAZcDhc1oPHTqkkJAQ3XzzzerVq5eSkpIkSTt27NDFixfVvn17c2ydOnUUGhqqhIQESVJCQoIaNGigoKAgc0xUVJQyMjK0b9++IreZlZWljIwMuwcAAACsy6GhtVmzZlqwYIG++eYbzZkzR0eOHNFdd92ls2fPKjk5WW5ubvLz87N7TVBQkJKTkyVJycnJdoE1vz+/ryhTpkyRr6+v+ahevXrp7hgAAABKlUOnB3Tq1Mn8/4YNG6pZs2YKCwvTJ598Ik9PzzLb7qhRoxQXF2c+z8jIILgCAABYmMOnB/yVn5+fateurV9++UXBwcHKzs5WWlqa3ZiUlBRzDmxwcHCB1QTynxc2Tzafu7u7fHx87B4AAACwLkuF1nPnzunw4cOqWrWqmjRpIldXV61bt87sP3jwoJKSkhQZGSlJioyM1N69e5WammqOWbNmjXx8fBQREVHu9QMAAKBsOHR6wLBhw9S1a1eFhYXp+PHjGjt2rJydndWzZ0/5+vqqX79+iouLk7+/v3x8fDR48GBFRkaqefPmkqSOHTsqIiJCvXv31vTp05WcnKyXXnpJsbGxcnd3d+SuAQAAoBQ5NLT+9ttv6tmzp06dOqWAgAC1atVKW7duVUBAgCRp5syZcnJyUnR0tLKyshQVFaXZs2ebr3d2dtaKFSs0cOBARUZGytvbWzExMZowYYKjdgkAAABlwKGh9aOPPrpsv4eHh+Lj4xUfH1/kmLCwMH399delXRoAAAAsxFJzWgEAAIDCEFoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeZYJrVOnTpXNZtNzzz1ntl24cEGxsbGqXLmyKlSooOjoaKWkpNi9LikpSV26dJGXl5cCAwM1fPhw5eTklHP1AAAAKEuWCK3bt2/XO++8o4YNG9q1Dx06VMuXL9fSpUu1ceNGHT9+XA8++KDZn5ubqy5duig7O1tbtmzRwoULtWDBAo0ZM6a8dwEAAABlyOGh9dy5c+rVq5feffddVapUyWxPT0/XvHnz9Nprr6lt27Zq0qSJ5s+fry1btmjr1q2SpNWrV2v//v364IMP1KhRI3Xq1EkTJ05UfHy8srOzHbVLAAAAKGUOD62xsbHq0qWL2rdvb9e+Y8cOXbx40a69Tp06Cg0NVUJCgiQpISFBDRo0UFBQkDkmKipKGRkZ2rdvX5HbzMrKUkZGht0DAAAA1uXiyI1/9NFH2rlzp7Zv316gLzk5WW5ubvLz87NrDwoKUnJysjnmr4E1vz+/ryhTpkzR+PHjr7F6AAAAlBeHXWk9duyYhgwZosWLF8vDw6Nctz1q1Cilp6ebj2PHjpXr9gEAAHB1HBZad+zYodTUVN1+++1ycXGRi4uLNm7cqDfeeEMuLi4KCgpSdna20tLS7F6XkpKi4OBgSVJwcHCB1QTyn+ePKYy7u7t8fHzsHgAAALAuh4XWdu3aae/evdq9e7f5aNq0qXr16mX+v6urq9atW2e+5uDBg0pKSlJkZKQkKTIyUnv37lVqaqo5Zs2aNfLx8VFERES57xMAAADKhsPmtFasWFH169e3a/P29lblypXN9n79+ikuLk7+/v7y8fHR4MGDFRkZqebNm0uSOnbsqIiICPXu3VvTp09XcnKyXnrpJcXGxsrd3b3c9wkAAABlw6FfxLqSmTNnysnJSdHR0crKylJUVJRmz55t9js7O2vFihUaOHCgIiMj5e3trZiYGE2YMMGBVQMAAKC0WSq0fvvtt3bPPTw8FB8fr/j4+CJfExYWpq+//rqMKwMAAIAjOXydVgAAAOBKCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALM/F0QWg+Gq88JWjS/jHODq1i6NLAAAAV4ErrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8l6sZ/Mcff2jdunXy9/dX+/bt5ebmZvZlZmZqxowZGjNmTKkXCQAAUBJ5eXnKzs52dBkogqurq5ydnYs1ttihdfv27erYsaPy8vJ08eJF3XTTTfriiy9Ur149SdK5c+c0fvx4QisAALCE7OxsHTlyRHl5eY4uBZfh5+en4OBg2Wy2y44rdmj917/+pQceeEDvvfeeMjMzNXLkSLVu3Vpr1qxR48aNr7lgAACA0mIYhv744w85OzurevXqcnJiRqTVGIah8+fPKzU1VZJUtWrVy44vdmjdsWOH4uPj5eTkpIoVK2r27NkKDQ1Vu3bttGrVKoWGhl5b5QAAAKUkJydH58+fV0hIiLy8vBxdDorg6ekpSUpNTVVgYOBlpwpc1ZzWCxcu2D1/4YUX5OLioo4dO+r9998vQakAAAClLzc3V5Lsvn8Da8r/R8XFixdLJ7TWr19fW7ZsUcOGDe3ahw0bpry8PPXs2bOEpQIAAJSNK82ThOMV92dU7Akeffr00ebNmwvtGzFihMaPH88UAQAAAJSJYofWJ598UosWLSqyf+TIkTpy5EipFAUAAICyYbPZ9MUXX5Tb9hYsWCA/P79rfp+rmtOa77///a9+/vlnSVLt2rULTBkAAACwohovfFWu2zs6tUu5bu+f7KpC67Zt29SvXz/t379fhmFIupTW69Wrp3nz5umOO+4okyIBAABwYyv29ID9+/erXbt28vT01AcffKCdO3dq586dWrRokdzd3dWuXTvt37+/LGsFAAD4x8vLy9P06dN1yy23yN3dXaGhoXr55ZclSXv37lXbtm3l6empypUra8CAATp37pz52u3bt6tDhw6qUqWKfH191bp1a+3cubNEdRw9elQ2m00fffSRWrRoIQ8PD9WvX18bN240x3z77bey2Wz66quv1LBhQ3l4eKh58+b68ccfr+0gFKLYoXXcuHHq0KGDEhMT1bNnTzVq1EiNGjXSo48+qm3btqldu3YaN25cqRcIAABwIxk1apSmTp2q0aNHa//+/VqyZImCgoKUmZmpqKgoVapUSdu3b9fSpUu1du1aDRo0yHzt2bNnFRMTo02bNmnr1q0KDw9X586ddfbs2RLXM3z4cD3//PPatWuXIiMj1bVrV506darAmBkzZmj79u0KCAhQ165ddfHixRJvszDFnh6wYcMGrVy5stBlCWw2m/71r3+pc+fOpVocAADAjeTs2bOaNWuW3nrrLcXExEiSatWqpVatWundd9/VhQsX9O9//1ve3t6SpLfeektdu3bVtGnTFBQUpLZt29q939y5c+Xn56eNGzfqvvvuK1FNgwYNUnR0tCRpzpw5+uabbzRv3jyNGDHCHDN27Fh16NBBkrRw4UJVq1ZNn3/+ubp3716ibRam2Fdaz549q6CgoCL7g4ODrzrFz5kzRw0bNpSPj498fHwUGRmplStXmv0XLlxQbGysKleurAoVKig6OlopKSl275GUlKQuXbrIy8tLgYGBGj58uHJycq6qDgAAACs4cOCAsrKy1K5du0L7brvtNjOwSlLLli2Vl5engwcPSpJSUlLUv39/hYeHy9fXVz4+Pjp37pySkpJKXFNkZKT5/y4uLmratKkOHDhQ5Bh/f3/deuutBcZcq2KH1rCwMG3btq3I/sTERIWFhV3VxqtVq6apU6dqx44d+uGHH9S2bVvdf//92rdvnyRp6NChWr58uZYuXaqNGzfq+PHjevDBB83X5+bmqkuXLsrOztaWLVu0cOFCLViwQGPGjLmqOgAAAKwg/7amJRUTE6Pdu3dr1qxZ2rJli3bv3q3KlSsrOzu7lCp0nGKH1h49eiguLq7QibV79+7VsGHD9Mgjj1zVxrt27arOnTsrPDxctWvX1ssvv6wKFSpo69atSk9P17x58/Taa6+pbdu2atKkiebPn68tW7Zo69atkqTVq1dr//79+uCDD9SoUSN16tRJEydOVHx8/D/ihwMAAG4s4eHh8vT01Lp16wr01a1bV3v27FFmZqbZtnnzZjk5OenWW281nz/77LPq3Lmz6tWrJ3d3d508efKaasrPXZKUk5OjHTt2qG7dukWOOXPmjH7++ecCY65Vsee0jho1SmvXrlWjRo3UoUMH1a1bV4Zh6MCBA1q7dq3uvPNO/etf/ypxIbm5uVq6dKkyMzMVGRmpHTt26OLFi2rfvr05pk6dOgoNDVVCQoKaN2+uhIQENWjQwG7aQlRUlAYOHKh9+/apcePGhW4rKytLWVlZ5vOMjIwS1w0AAFBaPDw8NHLkSI0YMUJubm5q2bKlTpw4oX379qlXr14aO3asYmJiNG7cOJ04cUKDBw9W7969zSwUHh6uRYsWqWnTpsrIyNDw4cOv+eptfHy8wsPDVbduXc2cOVNnzpzRE088YTdmwoQJqly5soKCgvTiiy+qSpUq6tat2zVt9++KHVo9PDy0YcMGzZw5Ux9++KG53EHt2rU1adIkDR06VO7u7lddwN69exUZGakLFy6oQoUK+vzzzxUREaHdu3fLzc2twB0UgoKClJycLElKTk4uMM82/3n+mMJMmTJF48ePv+paAQDA9e16WOx/9OjRcnFx0ZgxY3T8+HFVrVpVTz/9tLy8vLRq1SoNGTJEd9xxh7y8vBQdHa3XXnvNfO28efM0YMAA3X777apevbomT56sYcOGXVM9U6dO1dSpU7V7927dcsst+vLLL1WlSpUCY4YMGaJDhw6pUaNGWr58udzc3K5pu393VTcXcHNz08iRIzVy5MhSK+DWW2/V7t27lZ6erk8//VQxMTF263+VhVGjRikuLs58npGRoerVq5fpNgEAAIrDyclJL774ol588cUCfQ0aNND69euLfG3jxo21fft2u7aHHnrI7nn+DaKKq27dukpMTLzsmFatWhW5Nuvjjz+uxx9//Kq2WZhiz2k9c+aM3nzzzUI/Sk9PTy+y70rc3Nx0yy23qEmTJpoyZYpuu+02zZo1S8HBwcrOzlZaWprd+JSUFAUHB0u6tGLB31cTyH+eP6Yw7u7u5ooF+Q8AAABYV7FD61tvvaXvvvuu0IDn6+ur77//Xm+++eY1F5SXl6esrCw1adJErq6udhORDx48qKSkJHNZhcjISO3du1epqanmmDVr1sjHx0cRERHXXAsAAMA/1eTJk1WhQoVCH506dXJ0eQUUe3rAsmXLNGPGjCL7n3rqKQ0bNqzQS9lFGTVqlDp16qTQ0FCdPXtWS5Ys0bfffqtVq1bJ19dX/fr1U1xcnPz9/eXj46PBgwcrMjJSzZs3lyR17NhRERER6t27t6ZPn67k5GS99NJLio2NLdH8WgAAgBvF008/XeTi/56enrrpppuuOJWgTZs2Vz3doKSKHVoPHz6s8PDwIvvDw8N1+PDhq9p4amqq+vTpoz/++EO+vr5q2LChVq1aZd5RYebMmXJyclJ0dLSysrIUFRWl2bNnm693dnbWihUrNHDgQEVGRsrb21sxMTGaMGHCVdUBAABwo/H395e/v7+jyyi2YodWZ2dnHT9+XKGhoYX2Hz9+XE5OxZ5tIOnSN9wux8PDQ/Hx8YqPjy9yTFhYmL7++uur2i4AALgxlNdVQJRccX9GxU6ZjRs31hdffFFk/+eff17kuqgAAADlydnZWZK42dB14Pz585IkV1fXy44r9pXWQYMGqUePHqpWrZoGDhxongy5ubmaPXu2Zs6cqSVLllxDyQAAAKXDxcVFXl5eOnHihFxdXa/602CUPcMwdP78eaWmpsrPz8/MlkUpdmiNjo7WiBEj9Oyzz+rFF1/UzTffLEn69ddfde7cOQ0fPrzAOmAAAACOYLPZVLVqVR05ckT/+9//HF0OLsPPz++yS5Xmu6qbC7z88svq1q2bFi1apMOHD8swDLVu3VqPPvqo7rjjDiUlJRU55xUAAKA8ubm5KTw8nCkCFubq6nrFK6z5riq0SlLz5s31xx9/KDAw0K791KlTqlmzpnJzc6/2LQEAAMqEk5OTPDw8HF0GSsFVT/AwDEM2m61A+7lz5zgpAAAAUCaKfaU1Li5O0qU5IqNHj5aXl5fZl5ubq8TERDVq1KjUCwQAAACKHVp37dol6dKV1r1798rNzc3sc3Nz02233aZhw4aVfoUAAAC44RU7tG7YsEGS1LdvX82aNUs+Pj5lVhQAAADwV1f9Raz58+eXRR0AAABAkVhpFwAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeYRWAAAAWB6hFQAAAJZHaAUAAIDlEVoBAABgeQ4NrVOmTNEdd9yhihUrKjAwUN26ddPBgwftxly4cEGxsbGqXLmyKlSooOjoaKWkpNiNSUpKUpcuXeTl5aXAwEANHz5cOTk55bkrAAAAKEMODa0bN25UbGystm7dqjVr1ujixYvq2LGjMjMzzTFDhw7V8uXLtXTpUm3cuFHHjx/Xgw8+aPbn5uaqS5cuys7O1pYtW7Rw4UItWLBAY8aMccQuAQAAoAy4OHLj33zzjd3zBQsWKDAwUDt27NDdd9+t9PR0zZs3T0uWLFHbtm0lSfPnz1fdunW1detWNW/eXKtXr9b+/fu1du1aBQUFqVGjRpo4caJGjhypcePGyc3NzRG7BgAAgFJkqTmt6enpkiR/f39J0o4dO3Tx4kW1b9/eHFOnTh2FhoYqISFBkpSQkKAGDRooKCjIHBMVFaWMjAzt27ev0O1kZWUpIyPD7gEAAADrskxozcvL03PPPaeWLVuqfv36kqTk5GS5ubnJz8/PbmxQUJCSk5PNMX8NrPn9+X2FmTJlinx9fc1H9erVS3lvAAAAUJosE1pjY2P1448/6qOPPirzbY0aNUrp6enm49ixY2W+TQAAAJScQ+e05hs0aJBWrFih7777TtWqVTPbg4ODlZ2drbS0NLurrSkpKQoODjbHbNu2ze798lcXyB/zd+7u7nJ3dy/lvQAAAEBZceiVVsMwNGjQIH3++edav369atasadffpEkTubq6at26dWbbwYMHlZSUpMjISElSZGSk9u7dq9TUVHPMmjVr5OPjo4iIiPLZEQAAAJQph15pjY2N1ZIlS/Sf//xHFStWNOeg+vr6ytPTU76+vurXr5/i4uLk7+8vHx8fDR48WJGRkWrevLkkqWPHjoqIiFDv3r01ffp0JScn66WXXlJsbCxXUwEAAP4hHBpa58yZI0lq06aNXfv8+fP1+OOPS5JmzpwpJycnRUdHKysrS1FRUZo9e7Y51tnZWStWrNDAgQMVGRkpb29vxcTEaMKECeW1GwAAAChjDg2thmFccYyHh4fi4+MVHx9f5JiwsDB9/fXXpVkaAAAALMQyqwcAAAAARSG0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIcGlq/++47de3aVSEhIbLZbPriiy/s+g3D0JgxY1S1alV5enqqffv2OnTokN2Y06dPq1evXvLx8ZGfn5/69eunc+fOleNeAAAAoKw5NLRmZmbqtttuU3x8fKH906dP1xtvvKG3335biYmJ8vb2VlRUlC5cuGCO6dWrl/bt26c1a9ZoxYoV+u677zRgwIDy2gUAAACUAxdHbrxTp07q1KlToX2GYej111/XSy+9pPvvv1+S9O9//1tBQUH64osv1KNHDx04cEDffPONtm/frqZNm0qS3nzzTXXu3FmvvvqqQkJCym1fAAAAUHYsO6f1yJEjSk5OVvv27c02X19fNWvWTAkJCZKkhIQE+fn5mYFVktq3by8nJyclJiYW+d5ZWVnKyMiwewAAAMC6LBtak5OTJUlBQUF27UFBQWZfcnKyAgMD7fpdXFzk7+9vjinMlClT5Ovraz6qV69eytUDAACgNFk2tJalUaNGKT093XwcO3bM0SUBAADgMiwbWoODgyVJKSkpdu0pKSlmX3BwsFJTU+36c3JydPr0aXNMYdzd3eXj42P3AAAAgHVZNrTWrFlTwcHBWrdundmWkZGhxMRERUZGSpIiIyOVlpamHTt2mGPWr1+vvLw8NWvWrNxrBgAAQNlw6OoB586d0y+//GI+P3LkiHbv3i1/f3+Fhobqueee06RJkxQeHq6aNWtq9OjRCgkJUbdu3SRJdevW1b333qv+/fvr7bff1sWLFzVo0CD16NGDlQMAAAD+QRwaWn/44Qfdc8895vO4uDhJUkxMjBYsWKARI0YoMzNTAwYMUFpamlq1aqVvvvlGHh4e5msWL16sQYMGqV27dnJyclJ0dLTeeOONct8XAAAAlB2HhtY2bdrIMIwi+202myZMmKAJEyYUOcbf319Lliwpi/IAAABgEZad0woAAADkI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADLI7QCAADA8gitAAAAsDxCKwAAACyP0AoAAADL+8eE1vj4eNWoUUMeHh5q1qyZtm3b5uiSAAAAUEr+EaH1448/VlxcnMaOHaudO3fqtttuU1RUlFJTUx1dGgAAAErBPyK0vvbaa+rfv7/69u2riIgIvf322/Ly8tL777/v6NIAAABQClwcXcC1ys7O1o4dOzRq1CizzcnJSe3bt1dCQkKhr8nKylJWVpb5PD09XZKUkZFRtsVeo7ys844u4R/D6j/r6wXnZOnhnCw9nJel43o4J/NrNAzDwZWgPFz3ofXkyZPKzc1VUFCQXXtQUJB++umnQl8zZcoUjR8/vkB79erVy6RGWI/v646uALDHOQmruZ7OybNnz8rX19fRZaCMXfehtSRGjRqluLg483leXp5Onz6typUry2azObCy61tGRoaqV6+uY8eOycfHx9HlAJI4L2E9nJOlxzAMnT17ViEhIY4uBeXgug+tVapUkbOzs1JSUuzaU1JSFBwcXOhr3N3d5e7ubtfm5+dXViXecHx8fPhFDMvhvITVcE6WDq6w3jiu+y9iubm5qUmTJlq3bp3ZlpeXp3Xr1ikyMtKBlQEAAKC0XPdXWiUpLi5OMTExatq0qe688069/vrryszMVN++fR1dGgAAAErBPyK0PvLIIzpx4oTGjBmj5ORkNWrUSN98802BL2ehbLm7u2vs2LEFpl4AjsR5CavhnARKxmawTgQAAAAs7rqf0woAAIB/PkIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMv7R9xcAI6Tk5Ojffv2KTk5WZIUHBysiIgIubq6Orgy3MiSk5OVmJhod142a9ZMwcHBDq4MNyp+VwLXjtCKEsnLy9OYMWMUHx+v9PR0uz5fX18NGjRI48ePl5MTF/NRfjIzM/XUU0/po48+ks1mk7+/vyTp9OnTMgxDPXv21DvvvCMvLy8HV4obBb8rgdLDnxKUyAsvvKC5c+dq6tSp+vXXX5WZmanMzEz9+uuvmjZtmubOnatRo0Y5ukzcYIYMGaJt27bpq6++0oULF5SSkqKUlBRduHBBX3/9tbZt26YhQ4Y4ukzcQPhdCZQebuOKEgkODtbChQsVFRVVaP+qVavUp08fpaSklHNluJFVqlRJX331lVq0aFFo/+bNm3XffffpzJkz5VwZblT8rgRKD1daUSJnz55VSEhIkf1Vq1ZVZmZmOVYEXPoo1s3Nrch+Nzc35eXllWNFuNHxuxIoPYRWlEibNm00bNgwnTx5skDfyZMnNXLkSLVp06b8C8MN7b777tOAAQO0a9euAn27du3SwIED1bVrVwdUhhsVvyuB0sP0AJTIsWPH1LlzZ/30009q0KCBgoKCJEkpKSnau3evIiIitGLFClWvXt3BleJGcubMGT366KNatWqVKlWqpMDAQElSamqq0tLSFBUVpSVLlsjPz8+xheKGwe9KoPQQWlFieXl5WrVqlbZu3Wq3jEtkZKQ6duzIt2HhMD/99JMSEhIKnJd16tRxcGW4EfG7EigdhFYAAABYHuu04pps27atwBWtFi1a6I477nBwZUBBZ86c0fLly9WnTx9Hl4IbTF5eXqFXVPPy8vTbb78pNDTUAVUB1xeutKJEUlNTFR0drc2bNys0NNRunlZSUpJatmypZcuWmXMKASvYs2ePbr/9duXm5jq6FNwgMjIy9OSTT2r58uXy8fHRU089pbFjx8rZ2VnSpd+ZISEhnJNAMXClFSXyzDPPKDc3VwcOHNCtt95q13fw4EE98cQTio2N1dKlSx1UIW5EGRkZl+0/e/ZsOVUCXDJ69Gjt2bNHixYtUlpamiZNmqSdO3fqs88+M5dn49oRUDxcaUWJVKxYUd99950aN25caP+OHTvUpk0bQgLKlZOTk2w2W5H9hmHIZrNxVQvlJiwsTAsXLjSXtTp58qS6dOkiPz8/ffnll0pLS+NKK1BMXGlFibi7u1/2qtbZs2fl7u5ejhUBl/4x9eKLL6pZs2aF9h86dEhPPfVUOVeFG9mJEycUFhZmPq9SpYrWrl2rqKgode7cWe+9954DqwOuL4RWlMgjjzyimJgYzZw5U+3atZOPj4+kSx/Prlu3TnFxcerZs6eDq8SN5vbbb5cktW7dutB+Pz8/PopFuQoNDdWBAwdUs2ZNs61ixYpavXq1OnbsqAceeMCB1QHXF0IrSuS1115TXl6eevTooZycHHNuVnZ2tlxcXNSvXz+9+uqrDq4SN5pHH31U58+fL7I/ODhYY8eOLceKcKPr0KGD5s+fr86dO9u1V6hQQatWrVKHDh0cVBlw/WFOK65JRkaGfvjhB6WkpEi6FAqaNGliXnkFgBvZmTNndPz4cdWrV6/Q/rNnz2rnzp1FfjoA4P8QWlEigwcPVvfu3XXXXXc5uhTAxHkJq+GcBEoPoRUlkv8t7Vq1aqlfv36KiYlRcHCwo8vCDY7zElbDOQmUHm54jBJbvXq1OnfurFdffVWhoaG6//77tWLFCuXl5Tm6NNzAOC9hNZyTQOkgtKLEGjRooNdff13Hjx/XBx98oKysLHXr1k3Vq1fXiy++qF9++cXRJeIGxHkJq+GcBEoH0wNQIk5OTkpOTi5wm9akpCS9//77WrBggY4dO8aC2ShXnJewGs5JoPQQWlEiRf0izmcYhtauXctyLihXnJewGs5JoPQwPQAlEhYWJmdn5yL7bTYbv4RR7jgvYTWck0Dp4UorAAAALI8rrQAAALA8QisAAAAsj9AKAAAAyyO0AgAAwPIIrQAAALA8QiuA64JhGGrfvr2ioqIK9M2ePVt+fn767bffHFAZAKA8EFoBXBdsNpvmz5+vxMREvfPOO2b7kSNHNGLECL355puqVq1aqW7z4sWLpfp+AICSI7QCuG5Ur15ds2bN0rBhw3TkyBEZhqF+/fqpY8eOaty4sTp16qQKFSooKChIvXv31smTJ83XfvPNN2rVqpX8/PxUuXJl3XfffTp8+LDZf/ToUdlsNn388cdq3bq1PDw8tHjxYkfsJgCgENxcAMB1p1u3bkpPT9eDDz6oiRMnat++fapXr56efPJJ9enTR3/++adGjhypnJwcrV+/XpK0bNky2Ww2NWzYUOfOndOYMWN09OhR7d69W05OTjp69Khq1qypGjVqaMaMGWrcuLE8PDxUtWpVB+8tAEAitAK4DqWmpqpevXo6ffq0li1bph9//FHff/+9Vq1aZY757bffVL16dR08eFC1a9cu8B4nT55UQECA9u7dq/r165uh9fXXX9eQIUPKc3cAAMXA9AAA153AwEA99dRTqlu3rrp166Y9e/Zow4YNqlChgvmoU6eOJJlTAA4dOqSePXvq5ptvlo+Pj2rUqCFJSkpKsnvvpk2bluu+AACKx8XRBQBASbi4uMjF5dKvsHPnzqlr166aNm1agXH5H+937dpVYWFhevfddxUSEqK8vDzVr19f2dnZduO9vb3LvngAwFUjtAK47t1+++1atmyZatSoYQbZvzp16pQOHjyod999V3fddZckadOmTeVdJgDgGjA9AMB1LzY2VqdPn1bPnj21fft2HT58WKtWrVLfvn2Vm5urSpUqqXLlypo7d65++eUXrV+/XnFxcY4uGwBwFQitAK57ISEh2rx5s3Jzc9WxY0c1aNBAzz33nPz8/OTk5CQnJyd99NFH2rFjh+rXr6+hQ4fqlVdecXTZAICrwOoBAAAAsDyutAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALI/QCgAAAMsjtAIAAMDyCK0AAACwPEIrAAAALO//A9ZEVPK5DJH4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "emission_factor: mixed units ['tCO2/kWa', 'tCO2/tCO2'] discarded\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With DACCS\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Without DACCS\")\n", + "prepare_plots(rep_ori)\n", + "rep_ori.set_filters(t=[\"coal_ppl\", \"wind_ppl\"])\n", + "rep_ori.get(\"plot emission\")\n", + "plt.show()\n", + "\n", + "print(\"With DACCS\")\n", + "prepare_plots(rep_new)\n", + "rep_new.set_filters(t=[\"coal_ppl\", \"wind_ppl\",\"daccs\"])\n", + "rep_new.get(\"plot emission\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "436e75d0", + "metadata": {}, + "source": [ + "## Close the connection with the database" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ff03f487", + "metadata": {}, + "outputs": [], + "source": [ + "mp.close_db()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c907fa13", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/westeros/westeros_multinode_emissions_bounds_daccs.ipynb b/tutorial/westeros/westeros_multinode_emissions_bounds_daccs.ipynb new file mode 100644 index 000000000..dd98f3326 --- /dev/null +++ b/tutorial/westeros/westeros_multinode_emissions_bounds_daccs.ipynb @@ -0,0 +1,1387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ce427fd", + "metadata": {}, + "source": [ + "# Westeros multinode tutorial: Adding DACCS in climate mitigation scenario\n", + "In the previous tutorials, we have learnt how to create a baseline scenario (`westeros_baseline.ipynb`) and add emissions bounds (`westeros_emissions_bounds.ipynb`) to the baseline scenario. Here, we will show how to include an additional/new technology to a MESSAGE model. While the combination of currently existing technologies might be able to deliver the Paris targets, the deployment of some new technologies might improve the probability of meeting the targets and/or reducing the costs. These technologies include CO2 removal (CDR) technologies. Hence, in this tutorial, we will use direct air carbon capture and storage (DACCS) as an example of new technologies to be considered in climate mitigation pathways. \n", + "\n", + "In order to smoothly follow this tutorial, you have to alrady have the MESSAGEix framework installed and working. Additionally, you should have run the Westeros baseline and emissions bounds scenarios successfully as this tutorial is built on top of those scenarios.\n", + "\n", + "If all set, we can start by importing all the packages we need and connect to a database that store the scenario input and results. We can also name the model as `Westeros Electrified` here.\n", + "\n", + "In this tutorial, we will use add_dac tool which requires user to specify the location of the data, in yaml format. As such, we use os package to help us specifying the yaml file." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "239a17a2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "if (typeof IPython !== 'undefined') { IPython.OutputArea.prototype._should_scroll = function(lines){ return false; }}" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "\n", + "import pandas as pd\n", + "import ixmp\n", + "import message_ix\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from message_ix.utils import make_df\n", + "from message_ix.tools.add_tech import add_tech\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "\n", + "mp = ixmp.Platform()\n", + "\n", + "model = \"Westeros Electrified\"" + ] + }, + { + "cell_type": "markdown", + "id": "c82f18ff", + "metadata": {}, + "source": [ + "After we are connected to the database, we can call the prevously run `\"emission_bound\"` scenario as our base model and clone the data before we start adding DACCS to the model. As prevoiusly mentioned, to run this tutorial, you have to have succesfully run the `\"emission_bound\"` scenario, which was built based on the `\"baseline\"` scenario." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9a868ad2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This Scenario has a solution, use `Scenario.remove_solution()` or `Scenario.clone(..., keep_solution=False)`\n", + "Existing index sets of 'EMISSION_EQUIVALENCE' ['node', 'emission', 'type_tec', 'year'] do not match []\n" + ] + } + ], + "source": [ + "base = message_ix.Scenario(mp, model=model, scenario=\"multinode_hub\")\n", + "\n", + "scenario = base.clone(\n", + " model,\n", + " \"multinode_hub_emission_bound\",\n", + " \"multinode_hub with emission bound\",\n", + " keep_solution=False,)\n", + "scenario.check_out()\n", + "\n", + "year_df = scenario.vintage_and_active_years()\n", + "vintage_years, act_years = year_df[\"year_vtg\"], year_df[\"year_act\"]\n", + "model_horizon = scenario.set(\"year\")\n", + "regions = [reg for reg in scenario.set(\"node\") if reg not in [\"World\",\"hub\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "76550d22", + "metadata": {}, + "outputs": [], + "source": [ + "# add emission factor\n", + "# First we introduce the emission of CO2 and the emission category GHG\n", + "scenario.add_set(\"emission\", \"CO2\")\n", + "scenario.add_cat(\"emission\", \"GHG\", \"CO2\")\n", + "\n", + "# Then we add new units to the model library (needed only once)\n", + "mp.add_unit(\"tCO2/kWa\")\n", + "mp.add_unit(\"MtCO2\")\n", + "\n", + "model_years = sorted(list(set(act_years)))\n", + "\n", + "# Last we add CO2 emissions factor to the coal powerplant\n", + "for reg in regions:\n", + " emission_factor = make_df(\n", + " \"emission_factor\",\n", + " node_loc=reg,\n", + " year_vtg=vintage_years,\n", + " year_act=act_years,\n", + " mode=\"standard\",\n", + " unit=\"tCO2/kWa\",\n", + " technology=\"coal_ppl\",\n", + " emission=\"CO2\",\n", + " value=7.4,\n", + " )\n", + " scenario.add_par(\"emission_factor\", emission_factor)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "92db3cd7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
node_parentnode
0WorldWorld
1WorldWesteros
2WesterosWesteros
\n", + "
" + ], + "text/plain": [ + " node_parent node\n", + "0 World World\n", + "1 World Westeros\n", + "2 Westeros Westeros" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scenario.set(\"map_node\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "af163208", + "metadata": {}, + "outputs": [], + "source": [ + "# map regions to \"World\"\n", + "for reg in regions:\n", + " if reg not in set(scenario.set(\"map_node\")[\"node\"]):\n", + " scenario.add_set(\"map_node\", [\"World\",reg])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "08e01c46", + "metadata": {}, + "outputs": [], + "source": [ + "# add emission bound\n", + "scenario.add_par(\n", + " \"bound_emission\", [\"World\", \"GHG\", \"all\", \"cumulative\"], value=1500.0, unit=\"MtCO2\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "292a8a04", + "metadata": {}, + "source": [ + "**Solve scenario without DACCS**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c1ad537b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Objective value: 490718.46875\n" + ] + } + ], + "source": [ + "scenario.commit(comment=\"Multinode scenario emission bound without daccs\")\n", + "scenario.set_as_default()\n", + "\n", + "scenario.solve()\n", + "scenario.var(\"OBJ\")[\"lvl\"]\n", + "\n", + "print('Objective value: ', scenario.var(\"OBJ\")[\"lvl\"])" + ] + }, + { + "cell_type": "markdown", + "id": "e8ae8744", + "metadata": {}, + "source": [ + "**Comparing results**\n", + "\n", + "**--- Without emissions limit:**" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "055b7ed2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nodecommoditylevelyeartimelvlmrg
0Westeroslightuseful700year166.4453360.0
1Westeroslightuseful710year162.0395390.0
2Westeroslightuseful720year161.0026270.0
3Essoslightuseful700year166.4453360.0
4Essoslightuseful710year162.0395390.0
5Essoslightuseful720year161.0026270.0
6Stepstoneslightuseful700year161.4029650.0
7Stepstoneslightuseful710year162.0395390.0
8Stepstoneslightuseful720year161.0026270.0
\n", + "
" + ], + "text/plain": [ + " node commodity level year time lvl mrg\n", + "0 Westeros light useful 700 year 166.445336 0.0\n", + "1 Westeros light useful 710 year 162.039539 0.0\n", + "2 Westeros light useful 720 year 161.002627 0.0\n", + "3 Essos light useful 700 year 166.445336 0.0\n", + "4 Essos light useful 710 year 162.039539 0.0\n", + "5 Essos light useful 720 year 161.002627 0.0\n", + "6 Stepstones light useful 700 year 161.402965 0.0\n", + "7 Stepstones light useful 710 year 162.039539 0.0\n", + "8 Stepstones light useful 720 year 161.002627 0.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "base.var(\"PRICE_COMMODITY\", {\"commodity\": \"light\"})" + ] + }, + { + "cell_type": "markdown", + "id": "75dacb1a", + "metadata": {}, + "source": [ + "**--- With emissions limit:**" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2f45ad85", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nodecommoditylevelyeartimelvlmrg
0Westeroslightuseful700year266.3493900.0
1Westeroslightuseful710year317.0235180.0
2Westeroslightuseful720year413.4551980.0
3Essoslightuseful700year266.3493900.0
4Essoslightuseful710year317.0235180.0
5Essoslightuseful720year413.4551980.0
6Stepstoneslightuseful700year256.5496840.0
7Stepstoneslightuseful710year317.0235180.0
8Stepstoneslightuseful720year413.4551980.0
\n", + "
" + ], + "text/plain": [ + " node commodity level year time lvl mrg\n", + "0 Westeros light useful 700 year 266.349390 0.0\n", + "1 Westeros light useful 710 year 317.023518 0.0\n", + "2 Westeros light useful 720 year 413.455198 0.0\n", + "3 Essos light useful 700 year 266.349390 0.0\n", + "4 Essos light useful 710 year 317.023518 0.0\n", + "5 Essos light useful 720 year 413.455198 0.0\n", + "6 Stepstones light useful 700 year 256.549684 0.0\n", + "7 Stepstones light useful 710 year 317.023518 0.0\n", + "8 Stepstones light useful 720 year 413.455198 0.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scenario.var(\"PRICE_COMMODITY\", {\"commodity\": \"light\"})" + ] + }, + { + "cell_type": "markdown", + "id": "b5db71ca", + "metadata": {}, + "source": [ + "# Adding DACCS description\n", + "First step of adding DACCS as a technology in the model is by including DACCS into the `\"technology\"` set." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4ecb3adb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Existing index sets of 'EMISSION_EQUIVALENCE' ['node', 'emission', 'type_tec', 'year'] do not match []\n" + ] + } + ], + "source": [ + "dac_scenario = scenario.clone(\n", + " model,\n", + " \"multinode_hub_emission_bound_dac\",\n", + " \"multinode_hub with emission bound and dac\",\n", + " keep_solution=False,)\n", + "dac_scenario.check_out()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3b203192", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "mp.add_unit(\"USD/(tCO2/yr)\")\n", + "mp.add_unit(\"USD/(tCO2/yr)/yr\")\n", + "mp.add_unit(\"USD/tCO2\")\n", + "mp.add_unit(\"tCO2/tCO2\")\n", + "mp.add_unit(\"tCO2\")\n", + "mp.add_unit(\"Mt CO2/yr\")\n", + "\n", + "\n", + "filepath = os.path.join(os.getcwd(), \"data/westeros_multinode_daccs_data.yaml\")\n", + "add_tech(dac_scenario, filepath=filepath)" + ] + }, + { + "cell_type": "markdown", + "id": "017c5ca3", + "metadata": {}, + "source": [ + "Similar to what we did when generating the `\"baseline\"` scenario, the first thing we need to do is defining the input and output comodities of each technology. " + ] + }, + { + "cell_type": "markdown", + "id": "54cc0111", + "metadata": {}, + "source": [ + "# Solve Statement\n", + "Finally, this is the solve statement" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3131e0dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Objective Value\n", + "Without DACCS: 490718.46875\n", + "With DACCS : 474427.21875\n" + ] + } + ], + "source": [ + "dac_scenario.commit(comment=\"Multinode Emission Bound with DACCS\")\n", + "dac_scenario.set_as_default()\n", + "\n", + "dac_scenario.solve()\n", + "dac_scenario.var(\"OBJ\")[\"lvl\"]\n", + "\n", + "print('Objective Value')\n", + "print('Without DACCS: ', scenario.var(\"OBJ\")[\"lvl\"])\n", + "print('With DACCS : ', dac_scenario.var(\"OBJ\")[\"lvl\"])" + ] + }, + { + "cell_type": "markdown", + "id": "dad6cedb", + "metadata": {}, + "source": [ + "# Plotting Results and Compare\n", + "Finally, this is the plotting results command to compare emissions bound scenarios with and without DACCS" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "19e29174", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# Create a Reporter object to describe and carry out reporting\n", + "# calculations and operations (like plotting) based on `scenario`\n", + "# Add keys like \"plot activity\" to describe reporting operations.\n", + "# See tutorial/utils/plotting.py\n", + "from message_ix.report import Reporter\n", + "from message_ix.util.tutorial import prepare_plots\n", + "import matplotlib.pyplot as plt\n", + "\n", + "rep_ori = Reporter.from_scenario(scenario)\n", + "rep_new = Reporter.from_scenario(dac_scenario)\n", + "\n", + "prepare_plots(rep_ori)\n", + "prepare_plots(rep_new)" + ] + }, + { + "cell_type": "markdown", + "id": "eb382f4d", + "metadata": {}, + "source": [ + "## System acticity" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ea31acff", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Westeros\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAADVCAYAAABZh4SrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvpUlEQVR4nO3deVhWdf7/8efNjsoiKpuyuQUu5RoDUuIWX00my3IZSyOXZlJHc2mycpsWTXPLnMrJ0nHJcrQmbVxKxRKRNNGfNuYWpOaAmuwmCpzfH16c6Q5UUOBGeT2u676u7vP53Oe878MJXn7O55xjMQzDQERERKSGs7N1ASIiIiLVgUKRiIiICApFIiIiIoBCkYiIiAigUCQiIiICKBSJiIiIAApFIiIiIoBCkYiIiAigUCQiIiICKBSJ3JHi4+OxWCykpqZW6HotFgvTpk0rc99Ro0ZV6PZFRCqTQpFUax9//DEWi4VPPvmkRNs999yDxWJh+/btJdoCAwOJjIys8Hpee+01Pv300wpfb2U7e/YsFouFMWPGlGgbM2YMFouFqVOnlmgbPHgwjo6OXLx4sdT17tq1i2nTppGZmVmh9aampmKxWMyXo6Mj9evXJzIykhdeeIGTJ09e9/PPPfccFouF/v37X7ffiRMnePrpp2ncuDEuLi64u7vTqVMnFixYwC+//GLVt7CwkA8++IDo6Gi8vLxwdnYmODiYuLg49u7da9X34MGDPProowQFBeHi4kLDhg3p0aMHCxcuvLkdIiJVQqFIqrWoqCgAdu7cabU8OzubQ4cO4eDgQEJCglXbqVOnOHXqlPnZinS7hiJvb2+aNWtWYj8CJCQklLofi9vatm1LrVq1APjll1946aWXzPZdu3Yxffr0Cg9FxQYOHMjy5ctZsmQJkydPpnHjxsyfP5+wsDBWr15d6mcMw+DDDz8kODiY9evXk5OTU2q/zz//nNatW/Pxxx8TGxvLwoULmTFjBoGBgUycONEqQP7yyy/07t2bp556CsMweOGFF3j77bcZPHgwiYmJ3HvvvZw+fRq4uk86dOjAgQMHGD58OG+99RbDhg3Dzs6OBQsWVPxOEpEK42DrAkSux9/fn5CQkBJ/zBMTEzEMg8cee6xEW/H7yghFleHSpUs4OTlhZ1e5/0aJioriH//4B7m5udSpUweAvLw8Dhw4QL9+/fjss88oLCzE3t4egP/+97/88MMPPPTQQ+Y6XFxcKrXG32rXrh2PP/641bIff/yRBx54gCFDhhAWFsY999xj1R4fH8/p06fZtm0bMTExrFu3jiFDhlj1SUlJYcCAAQQFBbFt2zb8/PzMtpEjR3L8+HE+//xzc9nEiRPZtGkT8+bNY+zYsVbrmjp1KvPmzTPfv/rqq3h4eLBnzx48PT2t+p49e/ZmdoOIVBGNFEm1FxUVRXJystXpjISEBFq2bEnPnj3ZvXs3RUVFVm0Wi4VOnTqZy1asWEH79u1xdXXFy8uLAQMGcOrUKavtHDt2jL59++Lr64uLiwuNGjViwIABZGVlAVfnyOTl5bFs2TLztM6TTz5pfv6nn37iqaeewsfHB2dnZ1q2bMn7779vtY3iuT6rV6/mpZdeomHDhtSqVYvs7GwA1qxZY9ZZv359Hn/8cX766SerdaSlpREXF0ejRo1wdnbGz8+Phx566Ibzh6KioigsLGT37t3msqSkJAoKCpgwYQK5ubns37/faj8Wf67Yr+cUTZs2jYkTJwIQEhJi7pPf1vHpp5/SqlUrc59s2rTpunXeSFBQEEuXLuXy5cvMmjWrRPvKlStp0aIFXbp0oXv37qxcubJEn1mzZpGbm8uSJUusAlGxpk2bmiNFp0+f5t1336VHjx4lAhGAvb09EyZMoFGjRsDVU3ItW7YsEYjg6oidiFRfGimSai8qKorly5eTlJREdHQ0cPUPdmRkJJGRkWRlZXHo0CHuvvtusy00NJR69eoBV//lPnnyZPr168ewYcM4d+4cCxcu5P777yc5ORlPT08uX75MTEwM+fn5jB49Gl9fX3766Sc2bNhAZmYmHh4eLF++nGHDhnHvvfcyYsQIAJo0aQJAeno6v/vd78zJxQ0aNGDjxo0MHTqU7OzsEn9MX375ZZycnJgwYQL5+fk4OTmxdOlS4uLi6NixIzNmzCA9PZ0FCxaQkJBg1gnQt29fvvvuO0aPHk1wcDBnz57liy++4OTJkwQHB193P8LVkbTu3bub+6p58+a0bduWRo0akZCQQPv27c22X3/utx555BGOHj3Khx9+yLx586hfvz4ADRo0MPvs3LmTdevW8cwzz+Dm5sabb75J3759OXnypPnzuRkRERE0adKEL774wmp5fn4+a9euZfz48cDV029xcXGkpaXh6+tr9lu/fj2NGzcu07yzjRs3UlBQwBNPPFGm2oKCgkhMTOTQoUO0atWqHN9KRGzOEKnmvvvuOwMwXn75ZcMwDOPKlStG7dq1jWXLlhmGYRg+Pj7GokWLDMMwjOzsbMPe3t4YPny4YRiGkZqaatjb2xuvvvqq1ToPHjxoODg4mMuTk5MNwFizZs11a6ldu7YxZMiQEsuHDh1q+Pn5GefPn7daPmDAAMPDw8O4ePGiYRiGsX37dgMwGjdubC4zDMO4fPmy4e3tbbRq1cr45ZdfzOUbNmwwAGPKlCmGYRhGRkaGARizZ8++bp3F20lJSbFa7u3tbXTr1s18HxMTY8TFxRmGYRj9+vUzHnvsMbOtQ4cORrNmzaw+DxhTp04138+ePbvU7RT3dXJyMo4fP24uO3DggAEYCxcuvG79KSkpN/yeDz30kAEYWVlZ5rJ//vOfBmAcO3bMMIyrx4OLi4sxb948s09WVpYBGA899NB1ayj27LPPGoCRnJxcpv5btmwx7O3tDXt7eyMiIsJ47rnnjM2bNxuXL18u0+dFxHZ0+kyqvbCwMOrVq2fOFTpw4AB5eXnmv/IjIyPNUY3ExEQKCwvN0Y1169ZRVFREv379OH/+vPny9fWlWbNm5pVrHh4eAGzevPmaV1pdi2EYrF27ltjYWAzDsNpOTEwMWVlZ7Nu3z+ozQ4YMwdXV1Xy/d+9ezp49yzPPPGM1b+fBBx8kNDTUnN/i6uqKk5MT8fHxZGRklKtOgE6dOpGUlERhYSFFRUXs3r3b3I+dOnUy9+PFixfZv3//Lc/L6t69uzmaBnD33Xfj7u7ODz/8cEvrBcx5Ub+eSL1y5Uo6dOhA06ZNAXBzc+PBBx+0OoVWfKrSzc2tTNspb/8ePXqQmJjI73//ew4cOMCsWbOIiYmhYcOGfPbZZ2Vah4jYhkKRVHsWi4XIyEhz7lBCQgLe3t7mH75fh6LfnvI5duwYhmHQrFkzGjRoYPU6fPiwOfE1JCSEcePG8d5771G/fn1iYmJYtGiROZ/oes6dO0dmZiaLFy8usY24uDig5ATbkJAQq/c//vgjAHfddVeJ9YeGhprtzs7OvP7662zcuBEfHx/uv/9+Zs2aRVpaWpn2ZVRUlDl36NChQ2RlZZlzryIjIzlz5gypqanmXKNbDUWBgYElltWtW/emAt1v5ebmAv8LK5mZmfz73/+mc+fOHD9+3Hx16tSJvXv3cvToUQDc3d0BrnlV2m+Vtz9Ax44dWbduHRkZGXzzzTdMmjSJnJwcHn30Uf7zn/+UeT0iUrU0p0huC1FRUaxfv56DBw+a84mKRUZGMnHiRH766Sd27tyJv78/jRs3BqCoqAiLxcLGjRvNq6p+rXi0AWDOnDk8+eST/Otf/2LLli38+c9/ZsaMGezevducRFua4knejz/+eImrnIoVz3cq9utRovIaO3YssbGxfPrpp2zevJnJkyczY8YMtm3bRtu2ba/72V/PK3JycsLLy4vQ0FAA2rRpQ61atdi5cycpKSlW/W9Wafscro6u3apDhw7h7e1thpY1a9aQn5/PnDlzmDNnTon+K1euZPr06bi7u+Pv78+hQ4fKtJ3i/XPw4EHatGlTrhqdnJzo2LEjHTt2pHnz5sTFxbFmzZpS7wklIranUCS3hV//MU9ISLCauNy+fXucnZ2Jj48nKSmJXr16mW1NmjTBMAxCQkJo3rz5DbfTunVrWrduzUsvvcSuXbvo1KkT77zzDq+88gpwddTqtxo0aICbmxuFhYXmBObyCgoKAuDIkSN07drVqu3IkSNm+6+/1/jx4xk/fjzHjh2jTZs2zJkzhxUrVlx3O+3atTODj7OzMxEREeZ3cnBwoGPHjiQkJJCSkoK3t/cN91lp+6MqJCYmcuLECavL9VeuXEmrVq1KDRzvvvsuq1atYvr06QD07t2bxYsXk5iYSERExHW31bNnT+zt7VmxYkWZJ1uXpkOHDsDVWx2ISPWk02dyW+jQoQMuLi6sXLmSn376yWqkyNnZmXbt2rFo0SLy8vKsRjceeeQR7O3tmT59eonRCcMw+Pnnn4Gr80YKCgqs2lu3bo2dnR35+fnmstq1a5e4UaG9vT19+/Zl7dq1pY4+nDt3rkzfz9vbm3feecdqexs3buTw4cM8+OCDwNW5PpcuXbL6bJMmTXBzc7P63LU4ODgQHh5OQkJCiRE3uDrq9tVXX7F7926rWxpcS+3atQEq7eaNpfnxxx958skncXJyMm8JcOrUKb766iv69evHo48+WuIVFxfH8ePHSUpKAq7e8bp27doMGzaM9PT0Ets4ceKEeaPFgIAAhg8fzpYtW0q9I3VRURFz5swxb964ffv2UkfC/v3vfwOlnyIVkepBI0VyWyg+DfH111/j7OxsXjZeLDIy0jxl8utQ1KRJE1555RUmTZpEamoqffr0wc3NjZSUFD755BNGjBjBhAkT2LZtG6NGjeKxxx6jefPmFBQUsHz5cjPwFGvfvj1ffvklc+fONW8sGR4ezsyZM9m+fTvh4eEMHz6cFi1acOHCBfbt28eXX37JhQsXrvv9HB0def3114mLi6Nz584MHDjQvCQ/ODiYZ599FoCjR4/SrVs3+vXrR4sWLXBwcOCTTz4hPT2dAQMGlGlfRkVFmRPMfxt8IiMjmTFjRon9eC3FP4cXX3yRAQMG4OjoSGxsrBmWbtW+fftYsWIFRUVFZGZmsmfPHtauXYvFYmH58uXmaclVq1ZhGAa///3vS11Pr169cHBwYOXKlYSHh9OkSRNWrVpF//79CQsLY/DgwbRq1YrLly+za9cu1qxZY3UPqjlz5nDixAn+/Oc/s27dOnr37k3dunU5efIka9as4fvvvzf3/+jRo7l48SIPP/wwoaGh5jo/+ugj87EgIlJN2ey6N5FymjRpkgEYkZGRJdrWrVtnAIabm5tRUFBQon3t2rVGVFSUUbt2baN27dpGaGioMXLkSOPIkSOGYRjGDz/8YDz11FNGkyZNDBcXF8PLy8vo0qWL8eWXX1qt5/vvvzfuv/9+w9XV1QCsLs9PT083Ro4caQQEBBiOjo6Gr6+v0a1bN2Px4sVmn+JL5a916f9HH31ktG3b1nB2dja8vLyMQYMGGadPnzbbz58/b4wcOdIIDQ01ateubXh4eBjh4eHGxx9/bLWea12SbxiGsXnzZgMwHBwcjLy8PKu2n3/+2bBYLAZgJCUllfgsv7kk3zAM4+WXXzYaNmxo2NnZWW0TMEaOHFliHUFBQaXe1uDXii/JL345ODgYXl5eRnh4uDFp0iTjxx9/tOrfunVrIzAw8LrrjI6ONry9vY0rV66Yy44ePWoMHz7cCA4ONpycnAw3NzejU6dOxsKFC41Lly5Zfb6goMB47733jPvuu8/w8PAwHB0djaCgICMuLs7qcv2NGzcaTz31lBEaGmrUqVPHcHJyMpo2bWqMHj3aSE9Pv26NImJbFsOogBmPIlKtxMfH06VLF1JSUq57Q0cREfkfzSkSERERQaFIREREBFAoEhEREQFAc4pERERE0EiRiIiICKBQJCIiIgLo5o3A1TvSnjlzBjc3N5s9tkBERGzLMAxycnLw9/fHzk5jBjWRQhFw5swZAgICbF2GiIhUA6dOnbruQ6DlzqVQBLi5uQFX/0cofuK2iIjULNnZ2QQEBJh/E6TmUSjif0/6dnd3VygSEanhNI2i5tJJUxEREREUikREREQAnT4TEak2gp//3NYl2FzqzAdtXYLUYBopEhEREUGhSERERARQKBIREREBFIpEREREAIUiEREREUChSERERARQKBIREREBFIpEREREAIUiEREREUChSERERASwcSj66quviI2Nxd/fH4vFwqeffmrVbhgGU6ZMwc/PD1dXV7p3786xY8es+ly4cIFBgwbh7u6Op6cnQ4cOJTc3twq/hYiIiNwJbBqK8vLyuOeee1i0aFGp7bNmzeLNN9/knXfeISkpidq1axMTE8OlS5fMPoMGDeK7777jiy++YMOGDXz11VeMGDGiqr6CiIiI3CFs+kDYnj170rNnz1LbDMNg/vz5vPTSSzz00EMA/OMf/8DHx4dPP/2UAQMGcPjwYTZt2sSePXvo0KEDAAsXLqRXr1688cYb+Pv7V9l3ERERkdtbtZ1TlJKSQlpaGt27dzeXeXh4EB4eTmJiIgCJiYl4enqagQige/fu2NnZkZSUdM115+fnk52dbfUSERGRmq3ahqK0tDQAfHx8rJb7+PiYbWlpaXh7e1u1Ozg44OXlZfYpzYwZM/Dw8DBfAQEBFVy9iIiI3G6qbSiqTJMmTSIrK8t8nTp1ytYliYiIiI1V21Dk6+sLQHp6utXy9PR0s83X15ezZ89atRcUFHDhwgWzT2mcnZ1xd3e3eomIiEjNVm1DUUhICL6+vmzdutVclp2dTVJSEhEREQBERESQmZnJt99+a/bZtm0bRUVFhIeHV3nNIiIicvuy6dVnubm5HD9+3HyfkpLC/v378fLyIjAwkLFjx/LKK6/QrFkzQkJCmDx5Mv7+/vTp0weAsLAw/u///o/hw4fzzjvvcOXKFUaNGsWAAQN05ZmIiIiUi01D0d69e+nSpYv5fty4cQAMGTKEpUuX8txzz5GXl8eIESPIzMwkKiqKTZs24eLiYn5m5cqVjBo1im7dumFnZ0ffvn158803q/y7iIiIyO3NYhiGYesibC07OxsPDw+ysrI0v0hEbCb4+c9tXYLNpc580Gbb1t8CqbZzikRERESqkkKRiIiICDaeUyQi/6NTJ7Y9dSIiopEiERERERSKRERERACFIhERERFAc4pERETKpbCwkCtXrti6DCkjR0dH7O3ty9RXoUhERKQMDMMgLS2NzMxMW5ci5eTp6Ymvry8Wi+W6/RSKREREyqA4EHl7e1OrVq0b/oEV2zMMg4sXL5oPj/fz87tuf4UiERGRGygsLDQDUb169WxdjpSDq6srAGfPnsXb2/u6p9I00VpEROQGiucQ1apVy8aVyM0o/rndaC6YQpGIiEgZ6ZTZ7amsPzeFIhEREREUikREREQATbQWERG5JVX53MLq+HxAi8XCJ598Qp8+fapke0uXLmXs2LGVcmsEjRSJiIiIoFAkIiIiAigUiYiI3NGKioqYNWsWTZs2xdnZmcDAQF599VUADh48SNeuXXF1daVevXqMGDGC3Nxc87N79uyhR48e1K9fHw8PDzp37sy+fftuqo7U1FQsFgurV68mMjISFxcXWrVqxY4dO8w+8fHxWCwWPv/8c+6++25cXFz43e9+x6FDh25tJ5TRTYWiwsJC3njjDe699158fX3x8vKyeomIiEj1MGnSJGbOnMnkyZP5z3/+w6pVq/Dx8SEvL4+YmBjq1q3Lnj17WLNmDV9++SWjRo0yP5uTk8OQIUPYuXMnu3fvplmzZvTq1YucnJybrmfixImMHz+e5ORkIiIiiI2N5eeffy7RZ86cOezZs4cGDRoQGxtbJc+bu6lQNH36dObOnUv//v3Jyspi3LhxPPLII9jZ2TFt2rQKLlFERERuRk5ODgsWLGDWrFkMGTKEJk2aEBUVxbBhw1i1ahWXLl3iH//4B61ataJr16689dZbLF++nPT0dAC6du3K448/TmhoKGFhYSxevJiLFy9aje6U16hRo+jbty9hYWG8/fbbeHh4sGTJEqs+U6dOpUePHrRu3Zply5aRnp7OJ598ckv7oixuKhStXLmSv//974wfPx4HBwcGDhzIe++9x5QpU9i9e3dF1ygiIiI34fDhw+Tn59OtW7dS2+655x5q165tLuvUqRNFRUUcOXIEgPT0dIYPH06zZs3w8PDA3d2d3NxcTp48edM1RUREmP/t4OBAhw4dOHz48DX7eHl5cdddd5XoUxlu6pL8tLQ0WrduDUCdOnXIysoCoHfv3kyePLniqhMREZGbVvzcr5s1ZMgQfv75ZxYsWEBQUBDOzs5ERERw+fLlCqqwermpkaJGjRrx3//+F4AmTZqwZcsW4OqELGdn54qrTkRERG5as2bNcHV1ZevWrSXawsLCOHDgAHl5eeayhIQE7OzsuOuuu8z3f/7zn+nVqxctW7bE2dmZ8+fP31JNvz6jVFBQwLfffktYWNg1+2RkZHD06NESfSrDTY0UPfzww2zdupXw8HBGjx7N448/zpIlSzh58iTPPvtsRdcoIiIiN8HFxYW//OUvPPfcczg5OdGpUyfOnTvHd999x6BBg5g6dSpDhgxh2rRpnDt3jtGjR/PEE0/g4+MDXA1Vy5cvp0OHDmRnZzNx4sRbHn1atGgRzZo1IywsjHnz5pGRkcFTTz1l1eevf/0r9erVw8fHhxdffJH69etXyc0hbyoUzZw50/zv/v37ExgYSGJiIs2aNSM2NrbCihMREanuquNdpn9t8uTJODg4MGXKFM6cOYOfnx9//OMfqVWrFps3b2bMmDF07NiRWrVq0bdvX+bOnWt+dsmSJYwYMYJ27doREBDAa6+9xoQJE26pnpkzZzJz5kz2799P06ZN+eyzz6hfv36JPmPGjOHYsWO0adOG9evX4+TkdEvbLQuLYRhGWTsHBQXRtWtXunbtSnR0NAEBAZVZW5XJzs7Gw8ODrKws3N3dbV2O1FBV+aiA6qq6/3GpbDoGbHsMXO9vwaVLl0hJSSEkJAQXFxcbVXh7S01NJSQkhOTkZNq0aVNqn/j4eLp06UJGRgaenp4Vtu2y/vzKNacoLi6OlJQURowYQXBwME2bNmX48OGsXr2atLS0Wy5aRERExFbKFYqmTZtGfHw8mZmZfPHFFwwaNIijR4/y5JNP0rBhQ8LCwhg5cmRl1SoiIiLV1GuvvUadOnVKffXs2dPW5ZXJTc0pcnZ2Nk+jwdWZ4XPmzGHhwoW88847LFq0qEKLFBERkertj3/8I/369Su1zdXVlYYNG3KjGTvR0dE37FOZbioUXb58mcTEROLj44mPjycpKYmGDRvy6KOP0rlz54quUURERKq5O+FRX+UKRX/961/NEBQUFMT999/PiBEjWLlyJf7+/pVVo4iIiEilK1comjZtGoGBgcyZM4fHHnuMevXqVVZdIiIiIlWqXKFo48aNbN++naVLlzJmzBiaN29OdHQ0nTt3pnPnzjRo0KCy6rzzTfOwdQW2Ny3L1hWIiEgNVq6rz2JiYpg5cya7d+/m/PnzvP7669SqVYtZs2bRqFEjWrZsyahRoyqrVhEREZFKc1PPPgNwc3OjV69evPbaayxYsIBx48Zx+vRp3n777YqsT0RERKRKlPvqs6KiIvbu3cv27duJj48nISGBvLw8GjVqxMMPP0yXLl0qo04REZHqqSqnP1TiNIOlS5cyduxYMjMzb2k90dHRtGnThvnz51dIXTdSljtll1W5QlHPnj3ZtWsXOTk5+Pv706VLF+bNm0eXLl1o3LjxLRUiIiIittO/f3969epl6zJsqlynzzw9PZk9ezZHjhzh9OnTLF++nKFDh1ZaIJo2bRoWi8XqFRoaarZfunSJkSNHUq9ePerUqUPfvn1JT0+vlFpERETuZK6urnh7e9u6DJsqVyh6//338ff3p1mzZgBMmjSJcePGma+JEydy6dKlCi2wZcuW/Pe//zVfO3fuNNueffZZ1q9fz5o1a9ixYwdnzpzhkUceqdDti4iI3K42bNiAp6cnhYWFAOzfvx+LxcLzzz9v9hk2bBiPP/44S5cutXoI67Rp02jTpg3Lly8nODgYDw8PBgwYQE5OjtknLy+PwYMHU6dOHfz8/JgzZ0656gsODubll19m4MCB1K5dm4YNG5Z4KobFYuHtt9+mZ8+euLq60rhxY/75z3/exN64sXKFomXLlvHuu++a79966y127dpFcnIyycnJrFixosInWjs4OODr62u+6tevD0BWVhZLlixh7ty5dO3alfbt2/PBBx+wa9cudu/eXaE1iIiI3I7uu+8+cnJySE5OBmDHjh3Ur1+f+Ph4s8+OHTuIjo4u9fMnTpzg008/ZcOGDWzYsIEdO3Ywc+ZMs33ixIns2LGDf/3rX2zZsoX4+Hj27dtXrhpnz57NPffcQ3JyMs8//zxjxozhiy++sOozefJk+vbty4EDBxg0aBADBgzg8OHD5dpOWZQrFK1YsYIRI0ZYLVu1ahXbt29n+/btzJ49m48//rhCCzx27Bj+/v40btyYQYMGcfLkSQC+/fZbrly5Qvfu3c2+oaGhBAYGkpiYeN115ufnk52dbfUSERG503h4eNCmTRszBMXHx/Pss8+SnJxMbm4uP/30E8ePH7/mI7qKiopYunQprVq14r777uOJJ55g69atAOTm5rJkyRLeeOMNunXrRuvWrVm2bBkFBQXlqrFTp048//zzNG/enNGjR/Poo48yb948qz6PPfYYw4YNo3nz5rz88st06NCBhQsXln+H3EC5QtGJEydo3bq1+d7FxQU7u/+t4t577+U///lPhRUXHh7O0qVL2bRpE2+//TYpKSlm6k1LS8PJyclqqA/Ax8eHtLS06653xowZeHh4mK+AgIAKq1lERKQ66dy5M/Hx8RiGwddff80jjzxCWFgYO3fuZMeOHVbTYn4rODgYNzc3872fnx9nz54FrmaCy5cvEx4ebrZ7eXlx1113lau+iIiIEu9/OwpUlj4VoVxXn2VmZpKfn2++P3funFV7UVGRVfut6tmzp/nfd999N+Hh4QQFBfHxxx/j6up60+stngtVLDs7W8FIRETuSNHR0bz//vscOHAAR0dHQkNDiY6OJj4+noyMjOs+yN3R0dHqvcVioaioqLJLtplyhaJGjRpx6NCha6bA//f//h+NGjWqkMJK4+npSfPmzTl+/Dg9evTg8uXLZGZmWo0Wpaen4+vre931ODs74+zsXGl13ozgS6tsXYLNpdq6ABGRO1DxGZZ58+aZASg6OpqZM2eSkZHB+PHjb2q9TZo0wdHRkaSkJAIDAwHIyMjg6NGj1w1av/XbecC7d+8mLCysxLLBgwdbvW/btu1N1X095Tp91qtXL6ZMmVLqFWa//PIL06dP58EHH6yw4n4rNzeXEydO4OfnR/v27XF0dDTPbQIcOXKEkydPlhhmExERqanq1q3L3XffzcqVK80J1ffffz/79u0rd4D5tTp16jB06FAmTpzItm3bOHToEE8++aTVtJqySEhIYNasWRw9epRFixaxZs0axowZY9VnzZo1vP/++xw9epSpU6fyzTffVMpjxco1UvTCCy/w8ccfc9dddzFq1CiaN28OXA0jb731FgUFBbzwwgsVVtyECROIjY0lKCiIM2fOMHXqVOzt7Rk4cCAeHh4MHTqUcePG4eXlhbu7O6NHjyYiIoLf/e53FVaDiIjIdd0GD7Pu3Lkz+/fvN0ORl5cXLVq0ID09vdxzgH5t9uzZ5ObmEhsbi5ubG+PHjycrq3z7Y/z48ezdu5fp06fj7u7O3LlziYmJseozffp0Vq9ezTPPPIOfnx8ffvghLVq0uOm6r8ViGIZRng+kpKTwpz/9iS+++ILij1osFnr06MHf/va3Cr2R44ABA/jqq6/4+eefadCgAVFRUbz66qs0adIEuHrzxvHjx/Phhx+Sn59PTEwMf/vb3254+uy3srOz8fDwICsrC3d39wqrvzyCn//cJtutTlJnVt4o4+1Ax4COAR0Dtj0Grve34NKlS6SkpBASEoKLi4uNKrzzBAcHM3bsWMaOHXvNPhaLhU8++YQ+ffrc9HbK+vMr97PPQkJC2LRpExcuXOD48eMANG3aFC8vr5su9lpWr1593XYXFxcWLVpU4kZPIiIiIuVV7lBUzMvLi3vvvbciaxEREZE7xNdff211Fflv5ebmVmE1ZXPToUhERETkWjp06MD+/fuv2yc1NfWG6ynnLJ9bolAkIiIiFc7V1ZWmTZvauoxyKd91cyIiIjVYVY5aSMUp689NoUhEROQGiu/sfPHiRRtXIjej+Of22zt0/5ZOn4mIiNyAvb09np6e5nO/atWqhcVisXFVciOGYXDx4kXOnj2Lp6cn9vb21+2vUCQiIlIGxffAKw5Gcvvw9PQs0z0MFYpERETKwGKx4Ofnh7e3N1euXLF1OVJGjo6ONxwhKqZQJCIiUg729vZl/iMrtxdNtBYRERFBoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhERERFAoUhEREQEUCgSERERAe6gULRo0SKCg4NxcXEhPDycb775xtYliYiIyG3kjghFH330EePGjWPq1Kns27ePe+65h5iYGM6ePWvr0kREROQ2cUeEorlz5zJ8+HDi4uJo0aIF77zzDrVq1eL999+3dWkiIiJym3CwdQG36vLly3z77bdMmjTJXGZnZ0f37t1JTEws9TP5+fnk5+eb77OysgDIzs6u3GKvoyj/os22XV3Ycv9XBzoGdAzoGLDtMVC8bcMwbFaD2NZtH4rOnz9PYWEhPj4+Vst9fHz4/vvvS/3MjBkzmD59eonlAQEBlVKjlI3HfFtXILamY0CqwzGQk5ODh4eHrcsQG7jtQ9HNmDRpEuPGjTPfFxUVceHCBerVq4fFYrFhZbaRnZ1NQEAAp06dwt3d3dbliA3oGBDQcWAYBjk5Ofj7+9u6FLGR2z4U1a9fH3t7e9LT062Wp6en4+vrW+pnnJ2dcXZ2tlrm6elZWSXeNtzd3WvkL0L5Hx0DAjX7ONAIUc1220+0dnJyon379mzdutVcVlRUxNatW4mIiLBhZSIiInI7ue1HigDGjRvHkCFD6NChA/feey/z588nLy+PuLg4W5cmIiIit4k7IhT179+fc+fOMWXKFNLS0mjTpg2bNm0qMflaSufs7MzUqVNLnFKUmkPHgICOAxGLoWsPRURERG7/OUUiIiIiFUGhSERERASFIhERERFAoUhEREQEUCgSERERARSKRERERACFIhERERHgDrl5o5RfQUEB3333HWlpaQD4+vrSokULHB0dbVyZVKW0tDSSkpKsjoPw8PBrPjdQ7jz6XSDyPwpFNUxRURFTpkxh0aJFZGVlWbV5eHgwatQopk+fjp2dBhHvZHl5eTz99NOsXr0ai8WCl5cXABcuXMAwDAYOHMi7775LrVq1bFypVBb9LhApSUd7DfP888+zePFiZs6cyQ8//EBeXh55eXn88MMPvP766yxevJhJkybZukypZGPGjOGbb77h888/59KlS6Snp5Oens6lS5f497//zTfffMOYMWNsXaZUIv0uEClJj/moYXx9fVm2bBkxMTGltm/evJnBgweTnp5exZVJVapbty6ff/45kZGRpbYnJCTQu3dvMjIyqrgyqSr6XSBSkkaKapicnBz8/f2v2e7n50deXl4VViS2UFRUhJOT0zXbnZycKCoqqsKKpKrpd4FISQpFNUx0dDQTJkzg/PnzJdrOnz/PX/7yF6Kjo6u+MKlSvXv3ZsSIESQnJ5doS05O5k9/+hOxsbE2qEyqin4XiJSk02c1zKlTp+jVqxfff/89rVu3xsfHB4D09HQOHjxIixYt2LBhAwEBATauVCpTRkYGf/jDH9i8eTN169bF29sbgLNnz5KZmUlMTAyrVq3C09PTtoVKpdHvApGSFIpqoKKiIjZv3szu3butLsONiIjggQce0NUmNcj3339PYmJiieMgNDTUxpVJVdDvAhFrCkUiIiIi6D5FNdY333xTYoQgMjKSjh072rgyqQ4yMjJYv349gwcPtnUpUsmKiopKHREqKiri9OnTBAYG2qAqEdvQSFENc/bsWfr27UtCQgKBgYFW8whOnjxJp06dWLt2rTnHRGqmAwcO0K5dOwoLC21dilSS7Oxshg0bxvr163F3d+fpp59m6tSp2NvbA1d/J/j7++sYkBpFI0U1zDPPPENhYSGHDx/mrrvusmo7cuQITz31FCNHjmTNmjU2qlCqQnZ29nXbc3JyqqgSsZXJkydz4MABli9fTmZmJq+88gr79u1j3bp15u0a9G9mqWk0UlTDuLm58dVXX9G2bdtS27/99luio6P1R/EOZ2dnh8ViuWa7YRhYLBaNEtzBgoKCWLZsmXnZ/fnz53nwwQfx9PTks88+IzMzUyNFUuNopKiGcXZ2vu4oQU5ODs7OzlVYkdiCm5sbL774IuHh4aW2Hzt2jKeffrqKq5KqdO7cOYKCgsz39evX58svvyQmJoZevXrx3nvv2bA6EdtQKKph+vfvz5AhQ5g3bx7dunXD3d0duHo6ZevWrYwbN46BAwfauEqpbO3atQOgc+fOpbZ7enrq1MkdLjAwkMOHDxMSEmIuc3NzY8uWLTzwwAM8/PDDNqxOxDYUimqYuXPnUlRUxIABAygoKDDnDly+fBkHBweGDh3KG2+8YeMqpbL94Q9/4OLFi9ds9/X1ZerUqVVYkVS1Hj168MEHH9CrVy+r5XXq1GHz5s306NHDRpWJ2I7mFNVQ2dnZ7N2713zYo6+vL+3btzdHjkTkzpaRkcGZM2do2bJlqe05OTns27fvmqOJIncihaIaZvTo0fTr14/77rvP1qWIDek4EB0DIiUpFNUwxVcdNWnShKFDhzJkyBB8fX1tXZZUMR0HomNApCQ92KYG2rJlC7169eKNN94gMDCQhx56iA0bNlBUVGTr0qQK6TgQHQMi1hSKaqDWrVszf/58zpw5w4oVK8jPz6dPnz4EBATw4osvcvz4cVuXKFVAx4HoGBCxptNnNYydnR1paWklHuNx8uRJ3n//fZYuXcqpU6d0w7Y7nI4D0TEgUpJCUQ1zrV+ExQzD4Msvv9TluHc4HQeiY0CkJJ0+q2GCgoLMBz6WxmKx6JdgDaDjQHQMiJSkkSIRERERNFIkIiIiAigUiYiIiAAKRSIiIiKAQpGIiIgIoFAkcscxDIPu3bsTExNTou1vf/sbnp6enD592gaViYhUbwpFIncYi8XCBx98QFJSEu+++665PCUlheeee46FCxfSqFGjCt3mlStXKnR9IiK2oFAkcgcKCAhgwYIFTJgwgZSUFAzDYOjQoTzwwAO0bduWnj17UqdOHXx8fHjiiSc4f/68+dlNmzYRFRWFp6cn9erVo3fv3pw4ccJsT01NxWKx8NFHH9G5c2dcXFxYuXKlLb6miEiF0n2KRO5gffr0ISsri0ceeYSXX36Z7777jpYtWzJs2DAGDx7ML7/8wl/+8hcKCgrYtm0bAGvXrsVisXD33XeTm5vLlClTSE1NZf/+/djZ2ZGamkpISAjBwcHMmTOHtm3b4uLigp+fn42/rYjIrVEoErmDnT17lpYtW3LhwgXWrl3LoUOH+Prrr9m8ebPZ5/Tp0wQEBHDkyBGaN29eYh3nz5+nQYMGHDx4kFatWpmhaP78+YwZM6Yqv46ISKXS6TORO5i3tzdPP/00YWFh9OnThwMHDrB9+3bq1KljvkJDQwHMU2THjh1j4MCBNG7cGHd3d4KDg4GrDwr9tQ4dOlTpdxERqWwOti5ARCqXg4MDDg5X/1fPzc0lNjaW119/vUS/4tNfsbGxBAUF8fe//x1/f3+Kiopo1aoVly9ftupfu3btyi9eRKQKKRSJ1CDt2rVj7dq1BAcHm0Hp137++WeOHDnC3//+d+677z4Adu7cWdVliojYhE6fidQgI0eO5MKFCwwcOJA9e/Zw4sQJNm/eTFxcHIWFhdStW5d69eqxePFijh8/zrZt2xg3bpytyxYRqRIKRSI1iL+/PwkJCRQWFvLAAw/QunVrxo4di6enJ3Z2dtjZ2bF69Wq+/fZbWrVqxbPPPsvs2bNtXbaISJXQ1WciIiIiaKRIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERQKFIREREBFAoEhEREQEUikREREQAhSIRERERAP4/rXRwh6inCQAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Essos\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stepstones\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams[\"figure.figsize\"] = (5,1.5)\n", + "\n", + "for reg in regions:\n", + " print(reg)\n", + " \n", + " filter_params = {\"t\":[\"coal_ppl\", \"wind_ppl\"],\"nl\":reg}\n", + " \n", + " rep_ori.set_filters(**filter_params)\n", + " rep_ori.get(\"plot activity\")\n", + " plt.title(reg+'|Without DACCS')\n", + " \n", + " rep_new.set_filters(**filter_params)\n", + " rep_new.get(\"plot activity\")\n", + " plt.title(reg+'|With DACCS')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0a1c03d1", + "metadata": {}, + "source": [ + "## DACCS Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "59637e3d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams[\"figure.figsize\"] = (5,1.5)\n", + "\n", + "for reg in regions:\n", + " rep_new.set_filters(t=[\"daccs\"],nl=reg)\n", + " rep_new.get(\"plot cdr capacity\")\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15ddfc37", + "metadata": {}, + "source": [ + "## Emissions" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "01420a57", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "emission_factor: mixed units ['tCO2/kWa', 'tCO2/tCO2'] discarded\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Westeros\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "emission_factor: mixed units ['tCO2/kWa', 'tCO2/tCO2'] discarded\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Essos\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkoAAADVCAYAAACojN8mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsAklEQVR4nO3dd1gU594+8HsBaSKsoIBEmgmKooINBTU2lCNK1FgxrxKj0STWYIvyqmDiiSbHGGNLNLYQLK/HEjs2jIoIRAULahQh6pGi1AUbss/vD37McbOMogKLcH+ua67LnefZme/AXMvt88zOKIQQAkRERESkRU/XBRARERFVVQxKRERERDIYlIiIiIhkMCgRERERyWBQIiIiIpLBoEREREQkg0GJiIiISAaDEhEREZEMBiUiIiIiGQxKRFVASkoKFAoFjh8/Xq7bdXJywocffljmvn379i3X/RMRvekYlKja2LBhAxQKhexy5swZXZdYZkVFRTA3N0e/fv202pYsWQKFQoHAwECttrlz50KhUODPP/8sdbuJiYkICQlBSkpKeZf8WjZt2oTvv/++zP2dnJyk36uenh6USiVatGiBsWPHIiYm5rnv3b9/PxQKBezs7KBWq2X75eXlITQ0FO7u7jAzM4OJiQmaN2+OmTNn4u7du1r9jx8/jvfffx+2trYwNDSEtbU1/P39sWPHDo1+9+7dw+TJk+Hq6goTExNYW1vD09MTM2fORH5+fpl/BkRUOQx0XQBReZs/fz6cnZ211r/zzjs6qObV6Ovro0OHDjh9+rRWW1RUFAwMDBAVFVVqm7W1NRo3bgwAuHbtGvT0/vv/ocTERISGhqJr165wcnKqsPpf1qZNm3Dp0iVMmTKlzO/x8PDA1KlTAQAqlQpXrlzBtm3bsGbNGnz++ef47rvvSn1feHg4nJyckJKSgmPHjsHHx0erz82bN+Hj44Nbt25h8ODBGDt2LAwNDXHhwgWsXbsWO3fu1Aij8+bNw/z58+Hi4oJx48bB0dERmZmZ2L9/PwYOHIjw8HAMHz4cWVlZaNu2LfLy8vDRRx/B1dUVmZmZuHDhAlatWoVPP/0UZmZmL/fDI6KKJYiqifXr1wsAIi4uTtelvLTk5GQBQERGRkrrQkNDBQCRmJio0dfW1lYMHz5cABCpqanS+sLCQlG7dm0xYMAA2f1s27ZNaz8lHB0dRZ8+fV77WF5Fnz59hKOjY5n7y9X64MED0b9/fwFArFy5Uqs9Pz9f1K5dW/zwww+iVatW4sMPP9TqU1hYKNzd3YWpqak4efKkVntubq6YPXu29LrkZzpo0CDx5MkTrf4HDx4Ue/bsEUII8c033wgAIioqqtTtPnz48PkHTkSVjlNvVCNt2bIFbdq0QZ06dWBubo4WLVpg6dKlUnthYSFCQ0Ph4uICY2NjWFlZoVOnTjh8+LDGdo4dO4bOnTujdu3aUCqV6NevH65cuaLRR6VSYcqUKXBycoKRkRGsra3Rs2dPnDt37rk1durUCQA0Ro5u3ryJtLQ0TJgwAcbGxhpt8fHxKCgokN4HaF6jtGHDBgwePBgA0K1bN2nq6u/XRZ06dQqenp4wNjZGo0aN8Msvv2jVdvPmTQwePBiWlpYwNTVFhw4dsG/fPo0+JVOhf5/mO378uMZ+u3btin379uGvv/6SanrV0S4TExOEhYXB0tISCxYsgBBCo33nzp14+PAhBg8ejGHDhmHHjh149OiRRp/t27cjISEBwcHBGj/LEubm5liwYIH0es6cObC0tMS6detQq1Ytrf6+vr7StV9JSUnSaGFp2zU2Nn6l4yaiisOgRNVObm4u7t+/r7FkZmZK7YcPH0ZAQADq1q2LRYsWYeHChejatatG6AgJCUFoaCi6deuG5cuXIzg4GA4ODhrh5siRI/D19UVGRgZCQkIQFBSE06dPo2PHjhrh4JNPPsGqVaswcOBArFy5EtOmTYOJiYlWoPq7Dh06wMDAAKdOnZLWRUVFoXbt2mjXrh3atm2rUXPJv0v74w4A7777LiZNmgQAmD17NsLCwhAWFoamTZtKfW7cuIFBgwahZ8+eWLx4MerWrYsPP/wQly9flvqkp6fD29sbERER+Oyzz7BgwQI8evQI7733Hnbu3PncYypNcHAwPDw8UK9ePamml7le6e/MzMwwYMAA/Oc//0FiYqJGW3h4OLp16wZbW1sMGzYMKpUKe/bs0eize/duAMCIESNeuK/r16/j6tWr6N+/P+rUqfPC/o6OjigqKkJYWNhLHBER6ZSuh7SIykvJ1Ftpi5GRkdRv8uTJwtzcXDx9+lR2W+7u7i+chvLw8BDW1tYiMzNTWpeQkCD09PTEyJEjpXUWFhZi/Pjxz91WaVNvQgjRrl078fbbb0uvx40bJ7p16yaEEGLGjBmiXbt2UtugQYOEqampKCwslNY5OjqKwMBA6fWLpt4AiBMnTkjrMjIyhJGRkZg6daq0bsqUKQKAxrSUSqUSzs7OwsnJSRQVFQkh/vv7SE5O1thPZGSkVg3lNfVWYsmSJQKA+O2336R16enpwsDAQKxZs0Za5+3tLfr166fx3latWgkLC4sy1fHbb78JAGLJkiVl6p+Wlibq168vAAhXV1fxySefiE2bNomcnJwyvZ+IKh9HlKjaWbFiBQ4fPqyxHDhwQGpXKpUoKCjQmkZ7llKpxOXLl3H9+vVS21NTUxEfH48PP/wQlpaW0vqWLVuiZ8+e2L9/v8a2YmJiSv2m1It06tQJSUlJSEtLA1A8auTt7Q0A6NixI86fP48HDx5Ibe3bt4eBwat/R6NZs2bo3Lmz9Lp+/fpo0qQJbt68Ka3bv38/PD09NUauzMzMMHbsWKSkpGiN4uhCyQXRKpVKWrdlyxbo6elh4MCB0rqAgAAcOHAA2dnZ0rq8vLwyjQ6V9AVQ5v42NjZISEjAJ598guzsbPz4448YPnw4rK2t8eWXX2pNFRKR7jEoUbXj6ekJHx8fjaVbt25S+2effYbGjRujd+/eaNiwIT766CMcPHhQYxvz589HTk4OGjdujBYtWmD69Om4cOGC1P7XX38BAJo0aaK1/6ZNm+L+/fsoKCgAAHzzzTe4dOkS7O3t4enpiZCQEI3g8TzPXqeUk5ODy5cvo2PHjgAAb29vPH36FLGxsUhOTkZqaqrstFtZOTg4aK2rW7euRpD466+/ZI+7pF3XSr5m/2yA+fXXX+Hp6YnMzEzcuHEDN27cQKtWrfDkyRNs27ZN6mdubq4RsJ7H3NwcAMrcHwAaNGiAVatWITU1FdeuXcMPP/yA+vXrY+7cuVi7dm2Zt0NElYNBiWoca2trxMfHY/fu3XjvvfcQGRmJ3r17a9yX6N1330VSUhLWrVuH5s2b4+eff0br1q3x888/v/T+hgwZgps3b2LZsmWws7PDt99+Czc3N41RLjklwefUqVOIjo4GAHh5eQEA6tWrBxcXF5w6dUq6jul1g5K+vn6p619lpEOhUJS6vqio6KW39bIuXboE4L+3hLh+/Tri4uJw6tQpuLi4SEvJzys8PFx6r6urK3Jzc3H79u0X7sfV1RUAcPHixZeuUaFQoHHjxpg4cSJOnDgBPT09jTqIqGpgUKIaydDQEP7+/li5ciWSkpIwbtw4/PLLL7hx44bUx9LSEqNGjcLmzZtx+/ZttGzZEiEhIQCKL8oFiu9T9HdXr15FvXr1ULt2bWldgwYN8Nlnn2HXrl1ITk6GlZWVxjen5FhbW0thKCoqCs2aNYNSqZTavb29ERUVhaioKOjr60shSo5ceHkZjo6Ossdd0g4Uj0QBQE5Ojka/0kacyqOuEvn5+di5cyfs7e2lUa7w8HDUqlULW7ZswbZt2zSWyZMn4+TJk7h16xYAwN/fH0DxCNSLNG7cGE2aNMFvv/32WjeLbNSoEerWrYvU1NRX3gYRVQwGJapxnv0GHADo6emhZcuWAIDHjx+X2sfMzAzvvPOO1N6gQQN4eHhg48aNGkHg0qVLOHToEPz8/AAUj57k5uZqbMva2hp2dnbStl6kU6dOiI+Px6FDh6Trk0p4e3sjOjoaJ0+eRMuWLV94rUxJePt7eHkZfn5+iI2NlUa4AKCgoACrV6+Gk5MTmjVrBgB4++23AQAnTpyQ+hUVFWH16tWl1vX3n9OrePjwIUaMGIGsrCwEBwdLASw8PBydO3fG0KFDMWjQII1l+vTpAIDNmzcDAAYNGoQWLVpgwYIFGsdYQqVSITg4WHodGhqKzMxMjBkzBk+fPtXqf+jQIezduxcAEBMTI03JPis2NhaZmZmlTmkSkW7xztxU7Rw4cEAa3XiWt7c3GjVqhDFjxiArKwvdu3dHw4YN8ddff2HZsmXw8PCQRiCaNWuGrl27ok2bNrC0tMQff/yBf//735gwYYK0vW+//Ra9e/eGl5cXRo8ejYcPH2LZsmWwsLCQRp5UKhUaNmyIQYMGSY/COHLkCOLi4rB48eIyHU+nTp2wfv16xMXFYfz48VrHlJubi9zcXEycOPGF2/Lw8IC+vj4WLVqE3NxcGBkZoXv37rC2ti5TLQDwxRdfYPPmzejduzcmTZoES0tLbNy4EcnJydi+fbt0J3A3Nzd06NABs2bNQlZWFiwtLbFly5ZSw0SbNm2wdetWBAUFoV27djAzM5NGduT85z//kUZ98vPzkZiYiG3btiEtLQ1Tp07FuHHjABSHkxs3bmj87p711ltvoXXr1ggPD8fMmTNRq1Yt7NixAz4+Pnj33XcxZMgQdOzYEbVq1cLly5exadMm1K1bVxoRHDp0KC5evIgFCxbg/PnzCAgIkO7MffDgQRw9ehSbNm0CAISFhSE8PBwDBgxAmzZtYGhoiCtXrmDdunUwNjbG7Nmzy/x7IKJKouuv3RGVl+fdHgCAWL9+vRBCiH//+9+iV69ewtraWhgaGgoHBwcxbtw4jbtcf/XVV8LT01MolUphYmIiXF1dxYIFC7TuvHzkyBHRsWNHYWJiIszNzYW/v7/GnbQfP34spk+fLtzd3UWdOnVE7dq1hbu7u9Zdo+VuDyCEENeuXZOO4c8//9RoU6vVQqlUCgBi69atWu/9++0BhBBizZo1olGjRkJfX19jn3Jfue/SpYvo0qWLxrqkpCQxaNAgoVQqhbGxsfD09BR79+7Vem9SUpLw8fERRkZGwsbGRsyePVscPnxY61jz8/PF8OHDpWN50a0CSm5lAEAoFAphbm4u3NzcxMcffyxiYmI0+k6cOFEAEElJSbLbCwkJEQBEQkKCtC47O1vMnTtXtGjRQpiamgpjY2PRvHlzMWvWLI1zpcTRo0dFv379hLW1tTAwMBD169cX/v7+GrcouHDhgpg+fbpo3bq1sLS0FAYGBqJBgwZi8ODB4ty5c889ZiLSDYUQ/D4qka6lpKTA2dkZkZGR6Nq1q67LISKi/4/XKBERERHJYFAiIiIiksGgRERERCSD1ygRERERyeCIEhEREZEMBiUiIiIiGTq94eSJEyfw7bff4uzZs0hNTcXOnTvRv39/qV0IgXnz5mHNmjXIyclBx44dsWrVKri4uEh9srKyMHHiROzZs0d6MvjSpUulp4cDwIULFzB+/HjExcWhfv36mDhxImbMmFHmOtVqNe7evYs6deqU66MWiIjozSKEgEqlgp2dnXRzVarmdHkTp/3794vg4GCxY8cOAUDs3LlTo33hwoXCwsJC7Nq1SyQkJIj33ntPODs7i4cPH0p9/vGPfwh3d3dx5swZcfLkSfHOO++IgIAAqT03N1fY2NiIDz74QFy6dEls3rxZmJiYiJ9++qnMdd6+ffu5NzLkwoULFy41a7l9+/Zr/w2kN0OVuZhboVBojCgJIWBnZ4epU6di2rRpAIDc3FzY2Nhgw4YNGDZsGK5cuYJmzZohLi4Obdu2BQAcPHgQfn5+uHPnDuzs7LBq1SoEBwcjLS0NhoaGAIofwbBr165SH3NRmtzcXCiVSty+fRvm5ublf/BERPRGyMvLg729PXJycmBhYaHrcqgSVNlnvSUnJyMtLQ0+Pj7SOgsLC7Rv3x7R0dEYNmwYoqOjoVQqpZAEAD4+PtDT00NMTAwGDBiA6OhovPvuu1JIAgBfX18sWrQI2dnZ0hPOn/X48WONB5aqVCoAgLm5OYMSERHxMowapMpOsKalpQEAbGxsNNbb2NhIbWlpaVoP8zQwMIClpaVGn9K28ew+/u7rr7+GhYWFtNjb27/+AREREdEbp8oGJV2aNWuW9ET23Nxc3L59W9clERERkQ5U2ak3W1tbAEB6ejoaNGggrU9PT4eHh4fUJyMjQ+N9T58+RVZWlvR+W1tbpKena/QpeV3S5++MjIxgZGRULsdBRFSenL7Yp+sSdC5lYR9dl0A1SJUdUXJ2doatrS2OHj0qrcvLy0NMTAy8vLwAAF5eXsjJycHZs2elPseOHYNarUb79u2lPidOnEBhYaHU5/Dhw2jSpEmp1ycRERERldBpUMrPz0d8fDzi4+MBFF/AHR8fj1u3bkGhUGDKlCn46quvsHv3bly8eBEjR46EnZ2d9M24pk2b4h//+Ac+/vhjxMbGIioqChMmTMCwYcNgZ2cHABg+fDgMDQ0xevRoXL58GVu3bsXSpUsRFBSko6MmIiKiN4VOp97++OMPdOvWTXpdEl4CAwOxYcMGzJgxAwUFBRg7dixycnLQqVMnHDx4EMbGxtJ7wsPDMWHCBPTo0UO64eQPP/wgtVtYWODQoUMYP3482rRpg3r16mHu3LkYO3Zs5R0oERERvZGqzH2UqrK8vDxYWFggNzeXtwcgIp3iNUq6vUaJfw9qnip7jRIRERGRrjEoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSYaDrAoio7Jy+2KfrEnQqZWEfXZdARDUMR5SIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDIOX6ZyamoqjR4/C0tISPj4+MDQ0lNoKCgqwePFizJ07t9yLJCIiepMUFRWhsLBQ12VQKWrVqgV9ff0y9y9zUIqLi0OvXr2gVqtRWFiIt956C7t27YKbmxsAID8/H6GhoQxKRERUYwkhkJaWhpycHF2XQs+hVCpha2sLhULxwr5lDkqzZ8/GgAED8PPPP6OgoAAzZ85Ely5dcPjwYbRq1eq1CiYiIqoOSkKStbU1TE1Ny/SHmCqPEAIPHjxARkYGAKBBgwYvfE+Zg9LZs2exYsUK6OnpoU6dOli5ciUcHBzQo0cPREREwMHB4dUrJyIiesMVFRVJIcnKykrX5ZAMExMTAEBGRgasra1fOA33UtcoPXr0SOP1F198AQMDA/Tq1Qvr1q17yVKJiIiqj5JrkkxNTXVcCb1Iye+osLCw/IJS8+bNcfr0abRs2VJj/bRp06BWqxEQEPAKpRIREVUvnG6r+l7md1Tm2wOMHDkSUVFRpbbNmDEDoaGhnH4jIiKiaqXMQWnMmDEICwuTbZ85cyaSk5PLpSgiIiKqPhQKBXbt2lVp+9uwYQOUSmW5bOulrlEqceHCBfz5558AgMaNG2tNxxEREVExpy/2Ver+Uhb2qdT9VXcvFZRiY2MxevRoJCYmQggBoDglurm5Ye3atWjXrl2FFElERESkC2WeektMTESPHj1gYmKCX3/9FefOncO5c+cQFhYGIyMj9OjRA4mJiRVZKxEREVUAtVqNb775Bu+88w6MjIzg4OCABQsWAAAuXryI7t27w8TEBFZWVhg7dizy8/Ol98bFxaFnz56oV68eLCws0KVLF5w7d+6V6khJSYFCocCWLVvg7e0NY2NjNG/eHL///rvU5/jx41AoFNi3bx9atmwJY2NjdOjQAZcuXXq9H4KMMgelkJAQ9OzZEzExMQgICICHhwc8PDwwfPhwxMbGokePHggJCSnX4kJCQqBQKDQWV1dXqf3Ro0cYP348rKysYGZmhoEDByI9PV1jG7du3UKfPn1gamoKa2trTJ8+HU+fPi3XOomIiN5ks2bNwsKFCzFnzhwkJiZi06ZNsLGxQUFBAXx9fVG3bl3ExcVh27ZtOHLkCCZMmCC9V6VSITAwEKdOncKZM2fg4uICPz8/qFSqV65n+vTpmDp1Ks6fPw8vLy/4+/sjMzNTq8/ixYsRFxeH+vXrw9/fv0IeG1PmqbfIyEgcOHCg1K/UKRQKzJ49G35+fuVaHAC4ubnhyJEj0msDg/+W/Pnnn2Pfvn3Ytm0bLCwsMGHCBLz//vvSt/OKiorQp08f2Nra4vTp00hNTcXIkSNRq1Yt/POf/yz3WomIiN40KpUKS5cuxfLlyxEYGAgAePvtt9GpUyesWbMGjx49wi+//ILatWsDAJYvXw5/f38sWrQINjY26N69u8b2Vq9eDaVSid9//x19+/Z9pZomTJiAgQMHAgBWrVqFgwcPYu3atZgxY4bUZ968eejZsycAYOPGjWjYsCF27tyJIUOGvNI+5ZR5REmlUsHGxka23dbW9rXSoxwDAwPY2tpKS7169QAAubm5WLt2Lb777jt0794dbdq0wfr163H69GmcOXMGAHDo0CEkJibi119/hYeHB3r37o0vv/wSK1aswJMnT8q9ViIiojfNlStX8PjxY/To0aPUNnd3dykkAUDHjh2hVqtx7do1AEB6ejo+/vhjuLi4wMLCAubm5sjPz8etW7deuSYvLy/p3wYGBmjbti2uXLki28fS0hJNmjTR6lMeyhyUHB0dERsbK9seExMDR0fHcinqWdevX4ednR0aNWqEDz74QPrBnz17FoWFhfDx8ZH6urq6wsHBAdHR0QCA6OhotGjRQiPg+fr6Ii8vD5cvX5bd5+PHj5GXl6exEBERVUclj/R4VYGBgYiPj8fSpUtx+vRpxMfHw8rKqtoMSJQ5KA0bNgxBQUGlXix18eJFTJs2DUOHDi3X4tq3b48NGzbg4MGDWLVqFZKTk9G5c2eoVCqkpaXB0NBQ6z4JNjY2SEtLA1D8cMK/j4KVvC7pU5qvv/4aFhYW0mJvb1+ux0VERFRVuLi4wMTEBEePHtVqa9q0KRISElBQUCCti4qKgp6eHpo0aSK9njRpEvz8/ODm5gYjIyPcv3//tWoqmRkCgKdPn+Ls2bNo2rSpbJ/s7Gz8+eefWn3KQ5mvUZo1axaOHDkCDw8P9OzZE02bNoUQAleuXMGRI0fg6emJ2bNnl2txvXv3lv7dsmVLtG/fHo6Ojvi///u/107AzzNr1iwEBQVJr/Py8hiWiIioWjI2NsbMmTMxY8YMGBoaomPHjrh37x4uX76MDz74APPmzUNgYCBCQkJw7949TJw4ESNGjJAGHlxcXBAWFoa2bdsiLy8P06dPf+2/0StWrICLiwuaNm2KJUuWIDs7Gx999JFGn/nz58PKygo2NjYIDg5GvXr10L9//9fab2nKPKJkbGyMyMhILFiwAKmpqfjxxx/x008/IS0tDV999RUiIyNhbGxc7gU+S6lUonHjxrhx4wZsbW3x5MkT5OTkaPRJT0+Hra0tgOLrpv7+LbiS1yV9SmNkZARzc3ONhYiIqLqaM2cOpk6dirlz56Jp06YYOnQoMjIyYGpqioiICGRlZaFdu3YYNGgQevTogeXLl0vvXbt2LbKzs9G6dWuMGDECkyZNgrW19WvVs3DhQixcuBDu7u44deoUdu/eLV2j/GyfyZMno02bNkhLS8OePXtgaGj4WvstjUKU3DnyDZCfnw8HBweEhIQgMDAQ9evXx+bNm6Ur469duwZXV1dER0ejQ4cOOHDgAPr27YvU1FTpl7Z69WpMnz4dGRkZMDIyKtN+8/LyYGFhgdzcXIYm0qnKvsNvVcM7DvMcAHR7Hjzv78GjR4+QnJwMZ2fnCh84qK5SUlLg7OyM8+fPw8PDo9Q+x48fR7du3ZCdnf3Kjyl5md9VmUeUsrOzsWzZslIvbM7NzZVtex3Tpk3D77//jpSUFJw+fRoDBgyAvr4+AgICYGFhgdGjRyMoKAiRkZE4e/YsRo0aBS8vL3To0AEA0KtXLzRr1gwjRoxAQkICIiIi8L//+78YP358mUMSERER1VxlDkrLly/HiRMnSh1RsbCwwMmTJ7Fs2bJyLe7OnTsICAhAkyZNMGTIEFhZWeHMmTOoX78+AGDJkiXo27cvBg4ciHfffRe2trbYsWOH9H59fX3s3bsX+vr68PLywv/8z/9g5MiRmD9/frnWSURERC/2z3/+E2ZmZqUuz16XXJWUeerNw8MDixcvLvU+CwBw9OhRTJs2DefPny/XAqsCTr1RVVHTp1049cZzAODU25ssKysLWVlZpbaZmJjgrbfeqpQ6XuZ3VeZvvSUlJcHFxUW23cXFBUlJSWWvkoiIiGoUS0tLWFpa6rqMl1LmqTd9fX3cvXtXtv3u3bvQ0yvz5oiIiKqlN+g7UjXWy/yOypxsWrVqhV27dsm279y5E61atSrzjomIiKqTWrVqAQAePHig40roRUp+RyW/s+cp89TbhAkTMGzYMDRs2BCffvop9PX1ARQ/eHblypVYsmQJNm3a9IolExERvdn09fWhVCqRkZEBADA1NS31QfKkO0IIPHjwABkZGVAqlVKWeZ4yB6WBAwdixowZmDRpEoKDg9GoUSMAwM2bN5Gfn4/p06dj0KBBr149ERHRG67kZsYlYYmqJqVS+dwbTz+rzEEJABYsWID+/fsjLCwMSUlJEEKgS5cuGD58ONq1a4dbt27BwcHhlYomIiJ60ykUCjRo0ADW1tYoLCzUdTlUilq1apVpJKnESwUlAOjQoYPGna5LZGZmwtnZGUVFRS+7SSIiompFX1//pf4YU9X10l9TE0KUOuean5/P+0YQERFRtVLmEaWgoCAAxcOKc+bMgampqdRWVFSEmJgY2eeyEBEREb2JyhyUSu64LYTAxYsXNZ7Qa2hoCHd3d0ybNq38KyQiIiLSkTIHpcjISADAqFGjsHTpUj7KQwdq+qML+PgKIiKqbC99Mff69esrog4iIiKiKofPHCEiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSUaOC0ooVK+Dk5ARjY2O0b98esbGxui6JiIiIqrAaE5S2bt2KoKAgzJs3D+fOnYO7uzt8fX2RkZGh69KIiIioiqoxQem7777Dxx9/jFGjRqFZs2b48ccfYWpqinXr1um6NCIiIqqiDHRdQGV48uQJzp49i1mzZknr9PT04OPjg+joaK3+jx8/xuPHj6XXubm5AIC8vLyKL/Y51I8f6HT/uqbrn39VwHOA50BNPwcA3Z4HJfsWQuisBqpcNSIo3b9/H0VFRbCxsdFYb2Njg6tXr2r1//rrrxEaGqq13t7evsJqpBez+F7XFZCu8RwgoGqcByqVChYWFrougypBjQhKL2vWrFkICgqSXqvVamRlZcHKygoKhUKHlelOXl4e7O3tcfv2bZibm+u6HNIBngPEc6B4JEmlUsHOzk7XpVAlqRFBqV69etDX10d6errG+vT0dNja2mr1NzIygpGRkcY6pVJZkSW+MczNzWvsByQV4zlANf0c4EhSzVIjLuY2NDREmzZtcPToUWmdWq3G0aNH4eXlpcPKiIiIqCqrESNKABAUFITAwEC0bdsWnp6e+P7771FQUIBRo0bpujQiIiKqompMUBo6dCju3buHuXPnIi0tDR4eHjh48KDWBd5UOiMjI8ybN09rSpJqDp4DxHOAaiKF4HcciYiIiEpVI65RIiIiInoVDEpEREREMhiUiIiIiGQwKBERERHJYFAiIiIiksGgRERERCSDQYmIiIhIRo254SS9vKdPn+Ly5ctIS0sDANja2qJZs2aoVauWjiujypKWloaYmBiNc6B9+/alPiORqid+DlBNx6BEWtRqNebOnYsVK1YgNzdXo83CwgITJkxAaGgo9PQ4IFldFRQUYNy4cdiyZQsUCgUsLS0BAFlZWRBCICAgAD/99BNMTU11XClVFH4OEBXjGU5avvjiC6xevRoLFy7EzZs3UVBQgIKCAty8eROLFi3C6tWrMWvWLF2XSRVo8uTJiI2Nxb59+/Do0SOkp6cjPT0djx49wv79+xEbG4vJkyfrukyqQPwcICrGR5iQFltbW2zcuBG+vr6ltkdERGDkyJFIT0+v5MqostStWxf79u2Dt7d3qe1RUVHo27cvsrOzK7kyqiz8HCAqxhEl0qJSqWBnZyfb3qBBAxQUFFRiRVTZ1Go1DA0NZdsNDQ2hVqsrsSKqbPwcICrGoERaunbtimnTpuH+/ftabffv38fMmTPRtWvXyi+MKk3fvn0xduxYnD9/Xqvt/Pnz+PTTT+Hv76+Dyqiy8HOAqBin3kjL7du34efnh6tXr6JFixawsbEBAKSnp+PixYto1qwZ9u7dC3t7ex1XShUlOzsbw4cPR0REBOrWrQtra2sAQEZGBnJycuDr64tNmzZBqVTqtlCqMPwcICrGoESlUqvViIiIwJkzZzS+Fuzl5YVevXrxmy41xNWrVxEdHa11Dri6uuq4MqoM/BwgYlAiIiIiksX7KJGs2NhYrdEEb29vtGvXTseVka5lZ2djz549GDlypK5LoQqmVqtLHTlSq9W4c+cOHBwcdFAVUeXhiBJpycjIwMCBAxEVFQUHBweNaxNu3bqFjh07Yvv27dJ1K1TzJCQkoHXr1igqKtJ1KVRB8vLyMGbMGOzZswfm5uYYN24c5s2bB319fQDFnwd2dnY8B6ja44gSafnss89QVFSEK1euoEmTJhpt165dw0cffYTx48dj27ZtOqqQKlpeXt5z21UqVSVVQroyZ84cJCQkICwsDDk5Ofjqq69w7tw57NixQ7p1BP+fTTUBR5RIS506dXDixAm0atWq1PazZ8+ia9eu/GNZjenp6UGhUMi2CyGgUCg4mlCNOTo6YuPGjdItAO7fv48+ffpAqVRi9+7dyMnJ4YgS1QgcUSItRkZGzx1RUKlUMDIyqsSKqLLVqVMHwcHBaN++fant169fx7hx4yq5KqpM9+7dg6Ojo/S6Xr16OHLkCHx9feHn54eff/5Zh9URVR4GJdIydOhQBAYGYsmSJejRowfMzc0BFE/HHD16FEFBQQgICNBxlVSRWrduDQDo0qVLqe1KpZLTLtWcg4MDrly5AmdnZ2ldnTp1cOjQIfTq1QsDBgzQYXVElYdBibR89913UKvVGDZsGJ4+fSpdj/DkyRMYGBhg9OjR+Ne//qXjKqkiDR8+HA8ePJBtt7W1xbx58yqxIqpsPXv2xPr16+Hn56ex3szMDBEREejZs6eOKiOqXLxGiWTl5eXhjz/+kB56aWtrizZt2kgjTERUfWVnZ+Pu3btwc3MrtV2lUuHcuXOyo45E1QWDEmmZOHEihgwZgs6dO+u6FNIRngPEc4CoGIMSaSn5xtPbb7+N0aNHIzAwELa2trouiyoRzwHiOUBUjA/qoVIdOnQIfn5++Ne//gUHBwf069cPe/fuhVqt1nVpVEl4DhDPASIGJZLRokULfP/997h79y5+/fVXPH78GP3794e9vT2Cg4Nx48YNXZdIFYznAPEcIOLUG5VCT08PaWlpWo8ouXXrFtatW4cNGzbg9u3bvNFcNcZzgHgOEBVjUCItch+QJYQQOHLkCL8eXI3xHCCeA0TFOPVGWhwdHaUHX5ZGoVDww7Ga4zlAPAeIinFEiYiIiEgGR5SIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiaiGEULAx8cHvr6+Wm0rV66EUqnEnTt3dFAZEVHVw6BEVMMoFAqsX78eMTEx+Omnn6T1ycnJmDFjBpYtW4aGDRuW6z4LCwvLdXtERJWFQYmoBrK3t8fSpUsxbdo0JCcnQwiB0aNHo1evXmjVqhV69+4NMzMz2NjYYMSIEbh//7703oMHD6JTp05QKpWwsrJC3759kZSUJLWnpKRAoVBg69at6NKlC4yNjREeHq6LwyQiem28jxJRDda/f3/k5ubi/fffx5dffonLly/Dzc0NY8aMwciRI/Hw4UPMnDkTT58+xbFjxwAA27dvh0KhQMuWLZGfn4+5c+ciJSUF8fHx0NPTQ0pKCpydneHk5ITFixejVatWMDY2RoMGDXR8tEREL49BiagGy8jIgJubG7KysrB9+3ZcunQJJ0+eREREhNTnzp07sLe3x7Vr19C4cWOtbdy/fx/169fHxYsX0bx5cykoff/995g8eXJlHg4RUbnj1BtRDWZtbY1x48ahadOm6N+/PxISEhAZGQkzMzNpcXV1BQBpeu369esICAhAo0aNYG5uDicnJwDFD0t9Vtu2bSv1WIiIKoKBrgsgIt0yMDCAgUHxR0F+fj78/f2xaNEirX4lU2f+/v5wdHTEmjVrYGdnB7VajebNm+PJkyca/WvXrl3xxRMRVTAGJSKStG7dGtu3b4eTk5MUnp6VmZmJa9euYc2aNejcuTMA4NSpU5VdJhFRpeHUGxFJxo8fj6ysLAQEBCAuLg5JSUmIiIjAqFGjUFRUhLp168LKygqrV6/GjRs3cOzYMQQFBem6bCKiCsOgREQSOzs7REVFoaioCL169UKLFi0wZcoUKJVK6OnpQU9PD1u2bMHZs2fRvHlzfP755/j22291XTYRUYXht96IiIiIZHBEiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQyGJSIiIiIZDAoEREREclgUCIiIiKSwaBEREREJINBiYiIiEgGgxIRERGRDAYlIiIiIhkMSkREREQy/h8d7QUA/4zEzQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "emission_factor: mixed units ['tCO2/kWa', 'tCO2/tCO2'] discarded\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stepstones\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams[\"figure.figsize\"] = (5,1.5)\n", + " \n", + "for reg in regions:\n", + " print(reg)\n", + " filter_params = {\"t\":[\"coal_ppl\", \"wind_ppl\",\"daccs\"],\"nl\":reg}\n", + " rep_ori.set_filters(**filter_params)\n", + " rep_ori.get(\"plot emission\")\n", + " plt.title(reg+'|Without DACCS')\n", + "\n", + " rep_new.set_filters(**filter_params)\n", + " rep_new.get(\"plot emission\")\n", + " plt.title(reg+'|With DACCS')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3c83b884", + "metadata": {}, + "source": [ + "**Comparing prices**\n", + "\n", + "**--- Without DACCS:**" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "769b5684", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nodecommoditylevelyeartimelvlmrg
0Westeroslightuseful700year266.3493900.0
1Westeroslightuseful710year317.0235180.0
2Westeroslightuseful720year413.4551980.0
3Essoslightuseful700year266.3493900.0
4Essoslightuseful710year317.0235180.0
5Essoslightuseful720year413.4551980.0
6Stepstoneslightuseful700year256.5496840.0
7Stepstoneslightuseful710year317.0235180.0
8Stepstoneslightuseful720year413.4551980.0
\n", + "
" + ], + "text/plain": [ + " node commodity level year time lvl mrg\n", + "0 Westeros light useful 700 year 266.349390 0.0\n", + "1 Westeros light useful 710 year 317.023518 0.0\n", + "2 Westeros light useful 720 year 413.455198 0.0\n", + "3 Essos light useful 700 year 266.349390 0.0\n", + "4 Essos light useful 710 year 317.023518 0.0\n", + "5 Essos light useful 720 year 413.455198 0.0\n", + "6 Stepstones light useful 700 year 256.549684 0.0\n", + "7 Stepstones light useful 710 year 317.023518 0.0\n", + "8 Stepstones light useful 720 year 413.455198 0.0" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scenario.var(\"PRICE_COMMODITY\", {\"commodity\": \"light\"})" + ] + }, + { + "cell_type": "markdown", + "id": "c6908324", + "metadata": {}, + "source": [ + "**--- With DACCS:**" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3fa44357", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nodecommoditylevelyeartimelvlmrg
0Westeroslightuseful700year232.2626840.0
1Westeroslightuseful710year264.1438490.0
2Westeroslightuseful720year327.3197890.0
3Essoslightuseful700year232.2626840.0
4Essoslightuseful710year264.1438490.0
5Essoslightuseful720year327.3197890.0
6Stepstoneslightuseful700year224.0861550.0
7Stepstoneslightuseful710year264.1438490.0
8Stepstoneslightuseful720year327.3197890.0
\n", + "
" + ], + "text/plain": [ + " node commodity level year time lvl mrg\n", + "0 Westeros light useful 700 year 232.262684 0.0\n", + "1 Westeros light useful 710 year 264.143849 0.0\n", + "2 Westeros light useful 720 year 327.319789 0.0\n", + "3 Essos light useful 700 year 232.262684 0.0\n", + "4 Essos light useful 710 year 264.143849 0.0\n", + "5 Essos light useful 720 year 327.319789 0.0\n", + "6 Stepstones light useful 700 year 224.086155 0.0\n", + "7 Stepstones light useful 710 year 264.143849 0.0\n", + "8 Stepstones light useful 720 year 327.319789 0.0" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dac_scenario.var(\"PRICE_COMMODITY\", {\"commodity\": \"light\"})" + ] + }, + { + "cell_type": "markdown", + "id": "436e75d0", + "metadata": {}, + "source": [ + "## Close the connection with the database" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ff03f487", + "metadata": {}, + "outputs": [], + "source": [ + "mp.close_db()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c907fa13", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}