def heat(buses, datapackage_dir): """ Parameters ---------- buses: dict Dictionary with two keys: decentral and central and their values beeing the names of the buses datapackage_dir: str Directory of datapackage where resources are stored """ bus_elements = {} # Add heat buses per sub_bus and region (r) for sub_bus, regions in buses.items(): for region in regions: bus_elements["-".join([region, "heat", sub_bus])] = { "type": "bus", "carrier": "heat", "geometry": None, "balanced": True, } building.write_elements( "bus.csv", pd.DataFrame.from_dict(bus_elements, orient="index"), os.path.join(datapackage_dir, "data", "elements"), )
def add(buses, sensitivities, datapackage_dir): """ """ commodities = {} bus_elements = {} bio_potential = (Package( "https://raw.githubusercontent.com/ZNES-datapackages/" "technology-potential/master/datapackage.json").get_resource( "carrier").read(keyed=True)) bio_potential = pd.DataFrame(bio_potential).set_index( ["country", "carrier"]) bio_potential.rename(index={"UK": "GB"}, inplace=True) bio_potential = bio_potential.loc[bio_potential["source"] == "hotmaps"].to_dict() if buses.get("biomass"): for b in buses["biomass"]: bus_name = "-".join([b, "biomass", "bus"]) commodity_name = "-".join([b, "biomass", "commodity"]) factor = 1 # scaling factor for biomass potential if sensitivities is not None: factor = sensitivities.get(commodity_name, 1) commodities[commodity_name] = { "type": "commodity", "tech": "commodity", "carrier": "biomass", "bus": bus_name, "amount": float(bio_potential["value"].get( (b, "biomass"), 0)) * 1e6 * factor, # TWh -> MWh } bus_elements[bus_name] = { "type": "bus", "carrier": "biomass", "geometry": None, "balanced": True, } if commodities: building.write_elements( "commodity.csv", pd.DataFrame.from_dict(commodities, orient="index"), os.path.join(datapackage_dir, "data/elements"), ) building.write_elements( "bus.csv", pd.DataFrame.from_dict(bus_elements, orient="index"), os.path.join(datapackage_dir, "data/elements"), )
def electricity(buses, datapackage_dir, raw_data_path): """ Parameters ---------- buses: dict Dictionary with two keys: decentral and central and their values beeing the names of the buses datapackage_dir: str Directory of datapackage where resources are stored raw_data_path: str Path to directory where raw data can be found """ filepath = building.download_data( "http://ec.europa.eu/eurostat/cache/GISCO/geodatafiles/" "NUTS_2013_10M_SH.zip", unzip_file="NUTS_2013_10M_SH/data/NUTS_RG_10M_2013.shp", directory=raw_data_path, ) building.download_data( "http://ec.europa.eu/eurostat/cache/GISCO/geodatafiles/" "NUTS_2013_10M_SH.zip", unzip_file="NUTS_2013_10M_SH/data/NUTS_RG_10M_2013.dbf", directory=raw_data_path, ) if not os.path.exists(filepath): print("Shapefile data not found. Did you download raw data?") # get nuts 1 regions for german neighbours nuts0 = pd.Series(geometry.nuts(filepath, nuts=0, tolerance=0.1)) nuts0.index = [i.replace("UK", "GB") for i in nuts0.index] el_buses = pd.Series(name="geometry") el_buses.index.name = "name" for r in buses: el_buses[r + "-electricity"] = nuts0[r] building.write_geometries( "buses.csv", el_buses, os.path.join(datapackage_dir, "data", "geometries"), ) # Add electricity buses bus_elements = {} for b in el_buses.index: bus_elements[b] = { "type": "bus", "carrier": "electricity", "geometry": b, "balanced": True, } building.write_elements( "bus.csv", pd.DataFrame.from_dict(bus_elements, orient="index"), os.path.join(datapackage_dir, "data", "elements"), )
def excess(datapackage_dir): """ """ path = os.path.join(datapackage_dir, "data", "elements") buses = building.read_elements("bus.csv", directory=path) buses.index.name = "bus" buses = buses.loc[buses["carrier"] == "electricity"] elements = pd.DataFrame(buses.index) elements["type"] = "excess" elements["carrier"] = "electricity" elements["tech"] = "excess" elements["name"] = elements["bus"] + "-excess" elements["marginal_cost"] = 0 elements.set_index("name", inplace=True) building.write_elements("excess.csv", elements, directory=path)
def tyndp(buses, scenario, datapackage_dir, raw_data_path, sensitivities): """ """ filepath = building.download_data( "https://www.entsoe.eu/Documents/TYNDP%20documents/TYNDP2018/" "Scenarios%20Data%20Sets/Input%20Data.xlsx", directory=raw_data_path, sensitivities=None, ) df = pd.read_excel(filepath, sheet_name="Demand") df["countries"] = [i[0:2] for i in df.index] # for aggregation by country elements = df.groupby("countries").sum()[scenario].to_frame() elements.index.name = "bus" elements = elements.loc[buses] elements.reset_index(inplace=True) elements["name"] = elements.apply( lambda row: row.bus + "-electricity-load", axis=1) elements["profile"] = elements.apply( lambda row: row.bus + "-electricity-load-profile", axis=1) elements["type"] = "load" elements["carrier"] = "electricity" elements.set_index("name", inplace=True) elements.bus = [b + "-electricity" for b in elements.bus] elements["amount"] = elements[scenario] * 1000 # MWh -> GWh if sensitivities is not None: for k in sensitivities: if "load" in k: elements.loc[k, "amount"] = sensitivities[k] * 1000 building.write_elements( "load.csv", elements, directory=os.path.join(datapackage_dir, "data", "elements"), )
""" """ import pandas as pd from oemof.tabular.datapackage import building config = building.read_build_config('config.toml') buses = building.read_elements('bus.csv') buses.index.name = 'bus' elements = pd.DataFrame(buses.index) elements['type'] = 'shortage' elements['name'] = elements['bus'].str[:2] + '-shortage' elements['capacity'] = 50000 elements['marginal_cost'] = 1000 elements.set_index('name', inplace=True) building.write_elements('shortage.csv', elements)
def german_heat_system( heat_buses, weather_year, scenario, scenario_year, wacc, decentral_heat_flex_share, sensitivities, datapackage_dir, raw_data_path, ): """ """ technologies = pd.DataFrame( # Package('/home/planet/data/datapackages/technology-cost/datapackage.json') Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/technology/datapackage.json" ).get_resource("heat").read(keyed=True)).set_index( ["year", "parameter", "carrier", "tech"]) data = (pd.DataFrame( Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/capacities/datapackage.json"). get_resource("german-heat-system").read(keyed=True)).set_index( ["scenario", "year", "carrier", "tech"]).loc[(scenario, scenario_year)]) filepath = building.download_data( "https://data.open-power-system-data.org/when2heat/" "opsd-when2heat-2019-08-06.zip", directory=raw_data_path, unzip_file="opsd-when2heat-2019-08-06/", ) df = pd.read_csv( os.path.join(filepath, "opsd-when2heat-2019-08-06", "when2heat.csv"), index_col=[0], parse_dates=True, sep=";", ) cop = pd.read_csv( os.path.join(filepath, "opsd-when2heat-2019-08-06", "when2heat.csv"), decimal=",", index_col=[0], parse_dates=True, sep=";", ) df = df[~((df.index.month == 2) & (df.index.day == 29))] cop = cop[~((cop.index.month == 2) & (cop.index.day == 29))] data["country"] = "DE" data.set_index("country", append=True, inplace=True) if sensitivities is not None: for k, v in sensitivities.items(): k = k.split("-") data.at[(k[1], k[2], k[0]), "value"] = v elements = [] sequences = {} weather_year = str(weather_year) gshp_cop = cop.loc[ weather_year, ["DE_COP_GSHP_floor", "DE_COP_GSHP_radiator", "DE_COP_GSHP_water"], ].mean(axis=1) ashp_cop = cop.loc[ weather_year, ["DE_COP_ASHP_floor", "DE_COP_ASHP_radiator", "DE_COP_ASHP_water"], ].mean(axis=1) el_buses = building.read_elements("bus.csv", directory=os.path.join( datapackage_dir, "data/elements")) heat_demand_total = (float(data.loc[("decentral_heat", "load"), "value"]) * 1000) # MWh for bustype, buses in heat_buses.items(): carrier = bustype + "_heat" for b in buses: heat_bus = "-".join([b, carrier, "bus"]) flex_peak_demand_heat = ( df.loc[weather_year][b + "_heat_demand_total"] / df.loc[weather_year][b + "_heat_demand_total"].sum() # MW * heat_demand_total).max() * decentral_heat_flex_share peak_demand_heat = ( df.loc[weather_year][b + "_heat_demand_total"] / df.loc[weather_year][b + "_heat_demand_total"].sum() # MW * heat_demand_total).max() * (1 - decentral_heat_flex_share) el_buses.loc[heat_bus] = [True, "heat", None, "bus"] profile_name = "-".join([b, carrier, "load", "profile"]) if "flex" in bustype: elements.append({ "name": "-".join([b, carrier, "load"]), "type": "load", "bus": heat_bus, "amount": heat_demand_total * decentral_heat_flex_share, "profile": profile_name, "carrier": carrier, }) elements.append({ "name": "-".join([b, carrier, "gshp"]), "type": "conversion", "to_bus": heat_bus, "capacity_cost": ( float(technologies.loc[(2050, "fom", "decentral_heat", "gshp"), "value", ]) + annuity( float(technologies.loc[( 2050, "capex", "decentral_heat", "gshp", ), "value", ]), float(technologies.loc[( 2050, "lifetime", "decentral_heat", "gshp", ), "value", ]), wacc, ) * 1000, # €/kW -> €/MW )[0], "from_bus": "DE-electricity", "expandable": True, "capacity": flex_peak_demand_heat, "efficiency": "DE-gshp-profile", "carrier": carrier, "tech": "gshp", }) name = "-".join([b, carrier, "tes"]) if sensitivities is not None: if name in sensitivities.keys(): capacity = sensitivities[name] else: capacity = flex_peak_demand_heat else: capacity = flex_peak_demand_heat carrier = carrier.replace("flex-", "") elements.append({ "name": name, "type": "storage", "bus": heat_bus, # "capacity": capacity, "capacity_cost": 0, "storage_capacity_cost": (float(technologies.loc[(2050, "fom", "decentral_heat", "tes"), "value", ]) * 1000) + ( annuity( float(technologies.loc[( 2050, "capex_energy", "decentral_heat", "tes", ), "value", ]), float(technologies.loc[( 2050, "lifetime", "decentral_heat", "tes", ), "value", ]), wacc, ) * 1000, # €/kWh -> €/MWh )[0], "expandable": True, # "storage_capacity": capacity * float(technologies.loc[ # (2050, "max_hours", carrier, "tes"), # "value" # ]), "efficiency": float( technologies.loc[(2050, "efficiency", carrier, "tes"), "value"])**0.5, # rountrip conversion "loss": technologies.loc[(2050, "loss", carrier, "tes"), "value"], "marginal_cost": 0.001, "carrier": carrier, "tech": "tes", }) else: elements.append({ "name": "-".join([b, carrier, "load"]), "type": "load", "bus": heat_bus, "amount": heat_demand_total * (1 - decentral_heat_flex_share), "profile": profile_name, "carrier": carrier, }) elements.append({ "name": "-".join([b, carrier, "gshp"]), "type": "conversion", "to_bus": heat_bus, "capacity_cost": 0, "expandable": False, "from_bus": "DE-electricity", "capacity": peak_demand_heat, "efficiency": "DE-gshp-profile", "carrier": carrier, "tech": "gshp", }) sequences[profile_name] = ( df.loc[weather_year][b + "_heat_demand_total"] / df.loc[weather_year][b + "_heat_demand_total"].sum()) sequences_df = pd.DataFrame(sequences) sequences_df.index.name = "timeindex" sequences_df.index = building.timeindex(year=str(scenario_year)) sequences_cop = pd.concat([gshp_cop, ashp_cop], axis=1) sequences_cop.columns = ["DE-gshp-profile", "DE-ashp-profile"] sequences_cop.index.name = "timeindex" sequences_cop.index = building.timeindex(year=str(scenario_year)) building.write_sequences( "efficiency_profile.csv", sequences_cop, directory=os.path.join(datapackage_dir, "data/sequences"), ) if "NEPC" in scenario: must_run_sequences = {} must_run_sequences["DE-must-run-profile"] = ( df.loc[weather_year][b + "_heat_demand_total"] / df.loc[weather_year][b + "_heat_demand_total"].max()) must_run_sequences_df = pd.DataFrame(must_run_sequences) must_run_sequences_df = (must_run_sequences_df * 3 * 8300).clip( upper=8300) / 8300 # calibrate for 2030NEPC must_run_sequences_df.index.name = "timeindex" must_run_sequences_df.index = building.timeindex( year=str(scenario_year)) building.write_sequences( "volatile_profile.csv", must_run_sequences_df, directory=os.path.join(datapackage_dir, "data/sequences"), ) building.write_elements( "heat_load.csv", pd.DataFrame([i for i in elements if i["type"] == "load"]).set_index("name"), directory=os.path.join(datapackage_dir, "data/elements"), ) building.write_elements( "heatpump.csv", pd.DataFrame([i for i in elements if i["type"] == "conversion"]).set_index("name"), directory=os.path.join(datapackage_dir, "data/elements"), ) building.write_elements( "heat_storage.csv", pd.DataFrame([i for i in elements if i["type"] == "storage"]).set_index("name"), directory=os.path.join(datapackage_dir, "data/elements"), ) building.write_elements( "bus.csv", el_buses, directory=os.path.join(datapackage_dir, "data/elements"), replace=True, ) building.write_sequences( "heat_load_profile.csv", sequences_df, directory=os.path.join(datapackage_dir, "data/sequences"), )
def ehighway(buses, year, scenario="100% RES", datapackage_dir=None, raw_data_path=None): """ Parameter --------- buses: array like List with buses represented by iso country code year: integer Scenario year to select. One of: 2040, 2050 datapackage_dir: string Directory for tabular resource scenario: Name of ehighway scenario to select. One of: ["Large Scale RES", "100% RES", "Big & Market", "Fossil & Nuclear", "Small & Local"], default: "100% RES" raw_data_path: string Path where raw data file `e-Highway_database_per_country-08022016.xlsx` is located """ filename = "e-Highway_database_per_country-08022016.xlsx" filepath = os.path.join(raw_data_path, filename) if year == 2050: sheet = "T40" elif year == 2040: sheet = "T39" else: raise ValueError( "Value of argument `year` must be integer 2040 or 2050!") if os.path.exists(filepath): df = pd.read_excel(filepath, sheet_name=sheet, index_col=[0], skiprows=[0, 1]) else: raise FileNotFoundError( "File for e-Highway loads does not exist. Did you download data?") df.set_index("Scenario", inplace=True) # Scenario in same colum as ctrcode df.drop(df.index[0:1], inplace=True) # remove row with units df.dropna(how="all", axis=1, inplace=True) elements = df.loc[buses, scenario].to_frame() elements = elements.rename(columns={scenario: "amount"}) elements.index.name = "bus" elements.reset_index(inplace=True) elements["name"] = elements.apply( lambda row: row.bus + "-electricity-load", axis=1) elements["profile"] = elements.apply( lambda row: row.bus + "-electricity-load-profile", axis=1) elements["type"] = "load" elements["carrier"] = "electricity" elements.set_index("name", inplace=True) elements.bus = [b + "-electricity" for b in elements.bus] elements["amount"] = elements["amount"] * 1000 # to MWh path = os.path.join(datapackage_dir, "data", "elements") building.write_elements("load.csv", elements, directory=path)
def german_energy_system( datapackage_dir, raw_data_path, scenario_name, cost_scenario, technologies, scenario_year, sensitivities, ): """Extracts german specific scenario data from input datapackage Parameters ----------- scenario_name: str Name of scenario scenario_year: int Year of scenario (one of 2030, 2040, 2050) cost_scenario: str Name of cost scenario technologies: DataFrame DataFrame with the technology data like efficiencies etc. datapackage_dir: string Directory for tabular resource raw_data_path: string Path where raw data file is located """ data = (pd.DataFrame( Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/capacities/datapackage.json"). get_resource("german-electricity-system").read(keyed=True)).set_index( ["scenario", "year", "carrier", "tech"]).loc[(scenario_name, scenario_year)]) carrier_package = Package( "https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/carrier/datapackage.json") carrier_cost = (pd.DataFrame( carrier_package.get_resource("carrier-cost").read( keyed=True)).set_index(["scenario", "carrier"]).sort_index()) emission_factors = (pd.DataFrame( carrier_package.get_resource("emission-factor").read( keyed=True)).set_index(["carrier"]).sort_index()) elements = {} # prepare data for usage in _elements() function countries = ["DE"] _data = data["value"].T _data.name = "DE" _data = _data.to_frame().T elements = _elements( countries, _data, technologies, carrier_cost, emission_factors, cost_scenario, scenario_year, sensitivities, ) load = _load(countries, _data, sensitivities) for k, v in elements.items(): v.update(load[k]) df = pd.DataFrame.from_dict(elements, orient="index") element_list = [ "dispatchable", "volatile", "conversion", "storage", "load", ] for element_type in element_list: building.write_elements( element_type + ".csv", df.loc[df["type"] == element_type].dropna(how="all", axis=1), directory=os.path.join(datapackage_dir, "data", "elements"), overwrite=True, )
loc[pd.IndexSlice[year, np.nan, np.nan, np.nan, 'eaf'], 'value'] for (country, carrier, tech), row in s.iterrows(): capacity, geom = row.values name = country + '-' + carrier + '-' + tech vom = technologies.at[(year, carrier, tech, 'vom'), 'value'] eta = technologies.at[(year, carrier, tech, 'efficiency'), 'value'] ef = carriers.at[(year, carrier, 'emission-factor', 't (CO2)/MWh'), 'value'] fuel = carriers.at[(year, carrier, 'cost', 'EUR/MWh'), 'value'] marginal_cost = (fuel + vom + co2 * ef) / eta geometry[name] = geom element = { 'bus': country + '-electricity', 'tech': tech, 'carrier': carrier, 'capacity': capacity, 'marginal_cost': float(marginal_cost), 'output_parameters': json.dumps( {'max': eaf, 'emission_factor': float(ef / eta)}), 'type': 'dispatchable'} elements[name] = element building.write_geometries('dispatchable.geojson', pd.Series( list(geometry.values()), index=geometry.keys())) building.write_elements('dispatchable.csv', pd.DataFrame.from_dict(elements, orient='index'))
def tyndp(buses, grid_loss, scenario, datapackage_dir, raw_data_path): """ Parameter --------- buses: array like List with buses represented by iso country code grid_loss: numeric Loss for transshipment model (oemof.tabular.facades.Link component attribute) scenario: str Scenario name (e.g. 2040GCA) datapackage_dir: string Directory for tabular resource raw_data_path: string Path where raw data file is located """ filepath = building.download_data( "https://www.entsoe.eu/Documents/TYNDP%20documents/TYNDP2018/" "Scenarios%20Data%20Sets/Input%20Data.xlsx", directory=raw_data_path, ) mapper = { "2030": ["CBA Capacities", "Unnamed: 3"], "2040GCA": ["Unnamed: 8", "Unnamed: 9"], "2040ST": ["Unnamed: 5", "Unnamed: 6"], "2040DG": ["Unnamed: 6", "Unnamed: 7"], } df = pd.read_excel( filepath, sheet_name="NTC", index_col=[0], skiprows=[1, 2] )[mapper[scenario]] df.columns = ["=>", "<="] df["links"] = df.index.astype(str) df["links"] = df["links"].apply( lambda row: (row.split("-")[0][0:2], row.split("-")[1][0:2]) ) df = df.groupby(df["links"]).sum() df.reset_index(inplace=True) df = pd.concat( [ pd.DataFrame( df["links"].apply(lambda row: [row[0], row[1]]).tolist(), columns=["from", "to"], ), df[["=>", "<="]], ], axis=1, ) elements = {} for idx, row in df.iterrows(): if (row["from"] in buses and row["to"] in buses) and row[ "from" ] != row["to"]: predecessor = row["from"] + "-electricity" successor = row["to"] + "-electricity" element_name = predecessor + "-" + successor element = { "type": "link", "loss": grid_loss, "from_bus": predecessor, "to_bus": successor, "tech": "transshipment", "from_to_capacity": row["=>"], # still need to think how to "to_from_capacity": row["<="], "marginal_cost": 0.0001, } elements[element_name] = element building.write_elements( "link.csv", pd.DataFrame.from_dict(elements, orient="index"), directory=os.path.join(datapackage_dir, "data", "elements"), )
config = building.read_build_config('config.toml') filepath = building.download_data( 'http://ec.europa.eu/eurostat/cache/GISCO/geodatafiles/' 'NUTS_2013_10M_SH.zip', unzip_file='NUTS_2013_10M_SH/data/NUTS_RG_10M_2013.shp') building.download_data( 'http://ec.europa.eu/eurostat/cache/GISCO/geodatafiles/' 'NUTS_2013_10M_SH.zip', unzip_file='NUTS_2013_10M_SH/data/NUTS_RG_10M_2013.dbf') # get nuts 1 regions for german neighbours nuts0 = pd.Series(geometry.nuts(filepath, nuts=0, tolerance=0.1)) hubs = pd.Series(name='geometry') hubs.index.name = 'name' # add hubs and their geometry for r in config['countries']: hubs[r + '-electricity'] = nuts0[r] hub_elements = pd.DataFrame(hubs).drop('geometry', axis=1) hub_elements.loc[:, 'type'] = 'bus' hub_elements.loc[:, 'balanced'] = True hub_elements.loc[:, 'geometry'] = hubs.index building.write_geometries('bus.geojson', hubs) building.write_elements('bus.csv', hub_elements)
def ehighway_generation( countries, cost_scenario, scenario="100% RES", datapackage_dir=None, raw_data_path=None, ccgt_share=0.66, scenario_year=2050, ): """ """ scenario_mapper = {"100% RES": "T54"} filename = "e-Highway_database_per_country-08022016.xlsx" data = pd.read_excel( building.download_data( "http://www.e-highway2050.eu/fileadmin/documents/Results/" + filename, directory=raw_data_path, ), sheet_name=scenario_mapper[scenario], index_col=[1], skiprows=3, encoding="utf-8", ) data = data.loc[countries] technologies = pd.DataFrame( # Package('/home/planet/data/datapackages/technology-cost/datapackage.json') Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/technology/datapackage.json" ).get_resource("technology").read(keyed=True)).set_index( ["year", "parameter", "carrier", "tech"]) storage_capacities = (pd.DataFrame( Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/capacities/datapackage.json"). get_resource("storage-capacities").read(keyed=True)).set_index( ["year", "country"]).loc[scenario_year]) storage_capacities.drop("phs", axis=1, inplace=True) storage_capacities.rename( columns={ "acaes": ("cavern", "acaes"), "redox": ("redox", "battery"), "lithium": ("lithium", "battery"), "hydrogen": ("hydrogen", "storage"), }, inplace=True, ) carrier_package = Package( "https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/carrier/datapackage.json") carrier_cost = (pd.DataFrame( carrier_package.get_resource("carrier-cost").read( keyed=True)).set_index(["scenario", "carrier"]).sort_index()) emission_factors = (pd.DataFrame( carrier_package.get_resource("emission-factor").read( keyed=True)).set_index(["carrier"]).sort_index()) data["CCGT"] = data["TOTAL GAS"] * ccgt_share data["OCGT"] = data["TOTAL GAS"] * (1 - ccgt_share) rename_cols = { "Wind": ("wind", "onshore"), "Wind North Sea": ("wind", "offshore"), "PV": ("solar", "pv"), "OCGT": ("gas", "ocgt"), "CCGT": ("gas", "ccgt"), "TOTAL Biomass": ("biomass", "st"), "RoR": ("hydro", "ror"), "PSP": ("hydro", "phs"), "Hydro with reservoir": ("hydro", "rsv"), } data.rename(columns=rename_cols, inplace=True) data = data[[i for i in rename_cols.values()]] data = pd.concat([data, storage_capacities], axis=1, sort=True) elements = _elements( countries, data, technologies, carrier_cost, emission_factors, cost_scenario, scenario_year, ) load = _load(countries, data) for k, v in elements.items(): v.update(load[k]) df = pd.DataFrame.from_dict(elements, orient="index") df = df[df.capacity != 0] for element_type in [ "dispatchable", "volatile", "conversion", "storage", "reservoir", "load", ]: building.write_elements( element_type + ".csv", df.loc[df["type"] == element_type].dropna(how="all", axis=1), directory=os.path.join(datapackage_dir, "data", "elements"), overwrite=True, )
def generation(config, scenario_year, datapackage_dir, raw_data_path): """ """ countries, scenario_year = ( config["buses"]["electricity"], config["scenario"]["year"], ) building.download_data( "https://zenodo.org/record/804244/files/Hydro_Inflow.zip?download=1", directory=raw_data_path, unzip_file="Hydro_Inflow/", ) technologies = pd.DataFrame( Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/technology/datapackage.json"). get_resource("technology").read(keyed=True)).set_index( ["year", "parameter", "carrier", "tech"]) hydro_data = pd.DataFrame( Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/hydro/datapackage.json").get_resource( "hydro").read(keyed=True)).set_index(["year", "country"]) hydro_data.rename(index={"UK": "GB"}, inplace=True) # for iso code inflows = _get_hydro_inflow( inflow_dir=os.path.join(raw_data_path, "Hydro_Inflow")) inflows = inflows.loc[inflows.index.year == config["scenario"]["weather_year"], :] inflows["DK"], inflows["LU"] = 0, inflows["BE"] for c in hydro_data.columns: if c != "source": hydro_data[c] = hydro_data[c].astype(float) capacities = hydro_data.loc[scenario_year].loc[countries][[ "ror", "rsv", "phs" ]] ror_shares = hydro_data.loc[scenario_year].loc[countries]["ror-share"] max_hours = hydro_data.loc[scenario_year].loc[countries][[ "rsv-max-hours", "phs-max-hours" ]] rsv_factor = hydro_data.loc[scenario_year].loc[countries]["rsv-factor"] # ror elements = {} for country in countries: name = country + "-hydro-ror" capacity = capacities.loc[country, "ror"] # eta = technologies.loc[ # (scenario_year, "efficiency", "hydro", "ror"), "value" # ] if capacity > 0: elements[name] = { "type": "volatile", "tech": "ror", "carrier": "hydro", "bus": country + "-electricity", "capacity": capacity, "profile": country + "-ror-profile", "efficiency": 1, # as already included in inflow profile } building.write_elements( "ror.csv", pd.DataFrame.from_dict(elements, orient="index"), directory=os.path.join(datapackage_dir, "data", "elements"), ) sequences = (inflows[countries] * ror_shares * 1000) / capacities["ror"] col = list(set(countries) - set(["NO", "SE"])) sequences[col] = sequences[col] * 1.5 # correction factor sequences = sequences[countries].copy() sequences.dropna(axis=1, inplace=True) sequences.clip(upper=1, inplace=True) sequences.columns = sequences.columns.astype(str) + "-ror-profile" building.write_sequences( "ror_profile.csv", sequences.set_index(building.timeindex(str(scenario_year))), directory=os.path.join(datapackage_dir, "data", "sequences"), ) # reservoir elements = {} for country in countries: name = country + "-hydro-reservoir" capacity = capacities.loc[country, "rsv"] rsv_max_hours = max_hours.loc[country, "rsv-max-hours"] # eta = technologies.loc[ # (scenario_year, "efficiency", "hydro", "rsv"), "value" # ] if capacity > 0: elements[name] = { "type": "reservoir", "tech": "rsv", "carrier": "hydro", "bus": country + "-electricity", "capacity": capacity, "storage_capacity": capacity * rsv_max_hours, "profile": country + "-reservoir-profile", "efficiency": 1, # as already included in inflow profile "marginal_cost": 0.0000001, } building.write_elements( "reservoir.csv", pd.DataFrame.from_dict(elements, orient="index"), directory=os.path.join(datapackage_dir, "data", "elements"), ) sequences = inflows[countries] * (1 - ror_shares) * 1000 sequences[["NO", "SE"]] = (sequences[["NO", "SE"]] * 1.6) # correction factor sequences = sequences[countries].copy() sequences.dropna(axis=1, inplace=True) sequences.columns = sequences.columns.astype(str) + "-reservoir-profile" building.write_sequences( "reservoir_profile.csv", sequences.set_index(building.timeindex(str(scenario_year))), directory=os.path.join(datapackage_dir, "data", "sequences"), ) # phs elements = {} for country in countries: name = country + "-hydro-phs" capacity = capacities.loc[country, "phs"] phs_max_hours = max_hours.loc[country, "phs-max-hours"] eta = technologies.loc[(scenario_year, "efficiency", "hydro", "phs"), "value"] if capacity > 0: elements[name] = { "type": "storage", "tech": "phs", "carrier": "hydro", "bus": country + "-electricity", "capacity": capacity, "loss": 0, "marginal_cost": 1, "storage_capacity": capacity * phs_max_hours, "storage_capacity_initial": 0.5, "efficiency": float(eta)**(0.5), # rountrip to input/output eta } building.write_elements( "phs.csv", pd.DataFrame.from_dict(elements, orient="index"), directory=os.path.join(datapackage_dir, "data", "elements"), )
def ehighway( buses, year, grid_loss, scenario="100% RES", datapackage_dir=None, raw_data_path=None, ): """ Parameter --------- buses: array like List with buses represented by iso country code year: integer Scenario year to select. One of: 2030, 2050. If year is 2030, the starting grid will be used, meaning the scenario argument will have no impact datapackage_dir: string Directory for tabular resource scenario: Name of ehighway scenario to select. One of: ["Large Scale RES", "100% RES", "Big & Market", "Fossil & Nuclear", "Small & Local"], default: "100% RES" raw_data_path: string Path where raw data file `e-Highway_database_per_country-08022016.xlsx` is located """ filename = "e-Highway_database_per_country-08022016.xlsx" filepath = building.download_data(filename, directory=raw_data_path) if os.path.exists(filepath): df_2030 = pd.read_excel( filepath, sheet_name="T93", index_col=[1], skiprows=[0, 1, 3] ).fillna(0) df_2050 = pd.read_excel( filepath, sheet_name="T94", index_col=[1], skiprows=[0, 1, 3] ).fillna(0) else: raise FileNotFoundError( "File for e-Highway capacities does not exist. Did you download?" ) df_2050 = _prepare_frame(df_2050).set_index(["Links"]) df_2030 = _prepare_frame(df_2030).set_index(["Links"]) elements = {} for idx, row in df_2030.iterrows(): if row["from"] in buses and row["to"] in buses: predecessor = row["from"] + "-electricity" successor = row["to"] + "-electricity" element_name = predecessor + "-" + successor if year == 2030: capacity = row[scenario] elif year == 2050: capacity = row[scenario] + df_2050.to_dict()[scenario].get( idx, 0 ) element = { "type": "link", "loss": grid_loss, "from_bus": predecessor, "to_bus": successor, "tech": "transshipment", "from_to_capacity": capacity, "to_from_capacity": capacity, "marginal_cost": 0.0001, # "length": row["Length"], } elements[element_name] = element building.write_elements( "link.csv", pd.DataFrame.from_dict(elements, orient="index"), directory=os.path.join(datapackage_dir, "data/elements"), )
eta = technologies.loc[(year, 'hydro', 'ror', 'efficiency'), 'value'] if capacity > 0: elements[name] = { 'type': 'volatile', 'tech': 'ror', 'carrier': 'hydro', 'bus': country + '-electricity', 'capacity': capacity, 'profile': country + '-ror-profile', 'efficiency': eta } building.write_elements( 'ror.csv', pd.DataFrame.from_dict(elements, orient='index')) sequences = (inflows * ror_shares * 1000) / capacities['ror_power'] sequences = sequences[countries].copy() sequences.dropna(axis=1, inplace=True) sequences.columns = sequences.columns.astype(str) + '-ror-profile' building.write_sequences( 'ror_profile.csv', sequences.set_index(building.timeindex(str(year)))) # reservoir elements = {} for country in countries: name = country + '-reservoir'
""" """ import pandas as pd from oemof.tabular.datapackage import building buses = building.read_elements('bus.csv') buses.index.name = 'bus' elements = pd.DataFrame(buses.index) elements['type'] = 'excess' elements['name'] = elements['bus'].str[:2] + '-excess' elements['marginal_cost'] = 0 elements.set_index('name', inplace=True) building.write_elements('excess.csv', elements)
# wind-onshore element_name = country + '-wind-onshore' element = { 'bus': country + '-electricity', 'tech': 'wind-onshore', 'carrier': 'wind', 'capacity': wind_capacity, 'profile': country + '-wind-onshore-profile', 'marginal_cost': 0, 'type': 'volatile'} elements[element_name] = element # solar element_name = country + '-pv' element = { 'bus': country + '-electricity', 'tech': 'pv', 'carrier': 'solar', 'capacity': df.loc['Solar Total Installed Capacity - MW', int(year)], 'profile': country + '-pv-profile', 'marginal_cost': 0, 'type': 'volatile'} elements[element_name] = element building.write_elements('volatile.csv', pd.DataFrame.from_dict(elements, orient='index'))
def tyndp_generation_2018( countries, vision, scenario, scenario_year, datapackage_dir, raw_data_path, ccgt_share=0.66, sensitivities=None, ): """Extracts TYNDP2018 generation data and writes to datapackage for oemof tabular usage Parameters ----------- countries: list List with countries to extract (Names in country codes) vision: str TYNDP Vision (one of 2040 GCA, 2030 DG, etc.) scenario: str Name of scenario to be used for cost assumptions etc scenario_year: str Year of scenario datapackage_dir: string Directory for tabular resource raw_data_path: string Path where raw data file `ENTSO%20Scenario%202018%20Generation%20Capacities.xlsm` is located ccgt_share: Share of ccgt generation of total gas generation """ storage_capacities = (pd.DataFrame( Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/capacities/datapackage.json"). get_resource("storage-capacities").read(keyed=True)).set_index( ["year", "country"]).loc[scenario_year]) storage_capacities.drop("phs", axis=1, inplace=True) storage_capacities.rename( columns={ "acaes": ("cavern", "acaes"), "redox": ("redox", "battery"), "lithium": ("lithium", "battery"), "hydrogen": ("hydrogen", "storage"), }, inplace=True, ) filepath = building.download_data( "https://www.entsoe.eu/Documents/TYNDP%20documents/TYNDP2018/" "Scenarios%20Data%20Sets/ENTSO%20Scenario%202018%20Generation%20Capacities.xlsm", directory=raw_data_path, ) df = pd.read_excel(filepath, sheet_name=vision, index_col=0, skiprows=[0, 1]) colnames = [ "Biofuels", "Gas", "Hard coal", "Hydro-pump", "Hydro-run", "Hydro-turbine", "Lignite", "Nuclear", "Oil", "Othernon-RES", "Other RES", "Solar-thermal", "Solar-\nPV", "Wind-\non-shore", "Wind-\noff-shore", ] newnames = [ ("biomass", "st"), ("gas", "ocgt"), ("coal", "st"), ("hydro", "phs"), ("hydro", "ror"), ("hydro", "rsv"), ("lignite", "st"), ("uranium", "st"), ("oil", "ocgt"), ("mixed", "st"), ("other", "res"), ("solar", "thermal"), ("solar", "pv"), ("wind", "onshore"), ("wind", "offshore"), ] df = df.rename(columns=dict(zip(colnames, newnames))) df[("biomass", "st")] += df[("other", "res")] df.drop([("other", "res")], axis=1, inplace=True) df.index.name = "zones" df.reset_index(inplace=True) df = pd.concat( [ pd.DataFrame( df["zones"].apply(lambda row: [row[0:2], row[2::]]).tolist(), columns=["country", "zone"], ), df, ], axis=1, sort=True, ) df = df.groupby("country").sum() df[("gas", "ccgt")] = df[("gas", "ocgt")] * ccgt_share df[("gas", "ocgt")] = df[("gas", "ocgt")] * (1 - ccgt_share) # as raw data is divided in turbine and pump (where turbine is also from # pump storages as well as reservoirs) df[("hydro", "rsv")] = (df[("hydro", "rsv")] - df[("hydro", "phs")]).clip(0) technologies = pd.DataFrame( # Package('/home/planet/data/datapackages/technology-cost/datapackage.json') Package("https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/technology/datapackage.json" ).get_resource("technology").read(keyed=True)).set_index( ["year", "parameter", "carrier", "tech"]) carrier_package = Package( "https://raw.githubusercontent.com/ZNES-datapackages/" "angus-input-data/master/carrier/datapackage.json") carrier_cost = (pd.DataFrame( carrier_package.get_resource("carrier-cost").read( keyed=True)).set_index(["scenario", "carrier"]).sort_index()) emission_factors = (pd.DataFrame( carrier_package.get_resource("emission-factor").read( keyed=True)).set_index(["carrier"]).sort_index()) df = pd.concat([df, storage_capacities], axis=1, sort=True) elements = _elements( countries, df, technologies, carrier_cost, emission_factors, scenario, scenario_year, sensitivities, ) # load = _load(countries, df) # for k,v in load.items(): # v.update(load[k]) df = pd.DataFrame.from_dict(elements, orient="index") df = df[df.capacity != 0] # write elements to CSV-files for element_type in ["dispatchable", "volatile", "conversion", "storage"]: building.write_elements( element_type + ".csv", df.loc[df["type"] == element_type].dropna(how="all", axis=1), directory=os.path.join(datapackage_dir, "data", "elements"), )