262 lines
8.3 KiB
Python
Executable File
262 lines
8.3 KiB
Python
Executable File
"""
|
|
Builds clustered natural gas network based on data from:
|
|
|
|
[1] the SciGRID Gas project
|
|
(https://www.gas.scigrid.de/)
|
|
|
|
[2] ENTSOG capacity map
|
|
(https://www.entsog.eu/sites/default/files/2019-10/Capacities%20for%20Transmission%20Capacity%20Map%20RTS008_NS%20-%20DWH_final.xlsx)
|
|
"""
|
|
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
|
|
import re
|
|
import json
|
|
|
|
import pandas as pd
|
|
import geopandas as gpd
|
|
import numpy as np
|
|
|
|
from shapely.geometry import Point
|
|
|
|
|
|
def concat_gdf(gdf_list, crs='EPSG:4326'):
|
|
"""Convert to gepandas dataframe with given Coordinate Reference System (crs)."""
|
|
return gpd.GeoDataFrame(pd.concat(gdf_list),crs=crs)
|
|
|
|
|
|
def string2list(string, with_None=True):
|
|
"""Convert string format to a list."""
|
|
p = re.compile('(?<!\\\\)\'')
|
|
string = p.sub('\"', string)
|
|
|
|
if with_None:
|
|
p2 = re.compile('None')
|
|
string = p2.sub('\"None\"', string)
|
|
|
|
return json.loads(string)
|
|
|
|
|
|
def load_gas_network(df_path):
|
|
"""Load and format gas network data."""
|
|
|
|
df = pd.read_csv(df_path, sep=',')
|
|
|
|
df.long = df.long.apply(string2list)
|
|
df.lat = df.lat.apply(string2list)
|
|
df.node_id = df.node_id.apply(string2list)
|
|
|
|
# pipes which can be used in both directions
|
|
both_direct_df = df[df.is_bothDirection == 1].reset_index(drop=True)
|
|
both_direct_df.node_id = both_direct_df.node_id.apply(lambda x: [x[1], x[0]])
|
|
both_direct_df.long = both_direct_df.long.apply(lambda x: [x[1], x[0]])
|
|
both_direct_df.lat = both_direct_df.lat.apply(lambda x: [x[1], x[0]])
|
|
|
|
df_singledirect = pd.concat([df, both_direct_df]).reset_index(drop=True)
|
|
df_singledirect.drop('is_bothDirection', axis=1)
|
|
|
|
# create shapely geometry points
|
|
df['point1'] = df.apply(lambda x: Point((x['long'][0], x['lat'][0])), axis=1)
|
|
df['point2'] = df.apply(lambda x: Point((x['long'][1], x['lat'][1])), axis=1)
|
|
df['point1_name'] = df.node_id.str[0]
|
|
df['point2_name'] = df.node_id.str[1]
|
|
|
|
part1 = df[['point1', 'point1_name']]
|
|
part2 = df[['point2', 'point2_name']]
|
|
part1.columns = ['geometry', 'name']
|
|
part2.columns = ['geometry', 'name']
|
|
points = [part1, part2]
|
|
points = concat_gdf(points)
|
|
points = points.drop_duplicates()
|
|
points.reset_index(drop=True, inplace=True)
|
|
|
|
return df, points
|
|
|
|
|
|
def load_bus_regions(onshore_path, offshore_path):
|
|
"""Load pypsa-eur on- and offshore regions and concat."""
|
|
|
|
bus_regions_offshore = gpd.read_file(offshore_path)
|
|
bus_regions_onshore = gpd.read_file(onshore_path)
|
|
bus_regions = concat_gdf([bus_regions_offshore, bus_regions_onshore])
|
|
bus_regions = bus_regions.dissolve(by='name', aggfunc='sum')
|
|
bus_regions = bus_regions.reset_index()
|
|
|
|
return bus_regions
|
|
|
|
|
|
def points2buses(input_points, bus_regions):
|
|
"""Map gas network points to network buses depending on bus region."""
|
|
|
|
points = input_points.copy()
|
|
points['bus'] = None
|
|
buses_list = set(bus_regions.name)
|
|
for bus in buses_list:
|
|
mask = bus_regions[bus_regions.name == bus]
|
|
index = gpd.clip(points, mask).index
|
|
points.loc[index, 'bus'] = bus
|
|
|
|
return points
|
|
|
|
|
|
def build_gas_network_topology(df, points2buses):
|
|
"""Create gas network between pypsa buses.
|
|
|
|
Parameters
|
|
----------
|
|
df : pd.DataFrame
|
|
gas network data
|
|
points2buses_map : pd.DataFrame
|
|
mapping of gas network points to pypsa buses
|
|
|
|
Returns
|
|
-------
|
|
gas_connections : pd.DataFrame
|
|
gas network connecting pypsa buses
|
|
"""
|
|
|
|
tmp_df = points2buses[['bus', 'name']]
|
|
|
|
tmp_df.columns = ['buses_start', 'name']
|
|
gas_connections = df.merge(tmp_df, left_on='point1_name', right_on='name')
|
|
|
|
tmp_df.columns = ['buses_destination', 'name']
|
|
gas_connections = gas_connections.merge(tmp_df, left_on='point2_name', right_on='name')
|
|
|
|
# drop all pipes connecting the same bus
|
|
gas_connections = gas_connections[gas_connections.buses_start != gas_connections.buses_destination]
|
|
gas_connections.reset_index(drop=True, inplace=True)
|
|
gas_connections.drop(['point1', 'point2'], axis=1, inplace=True)
|
|
|
|
return gas_connections
|
|
|
|
|
|
def check_missing(nodes, gas_connections):
|
|
"""Check which nodes are not connected to the gas network."""
|
|
|
|
start_buses = gas_connections.buses_start.dropna().unique()
|
|
end_buses = gas_connections.buses_destination.dropna().unique()
|
|
|
|
missing_start = nodes[[bus not in start_buses for bus in nodes]]
|
|
missing_end = nodes[[bus not in end_buses for bus in nodes]]
|
|
|
|
logger.info(f"- The following buses are missing in gas network data as a start bus:"
|
|
f"\n {', '.join(map(str, missing_start))} \n"
|
|
f"- The following buses are missing in gas network data as an end bus:"
|
|
f"\n {', '.join(map(str, missing_end))} \n"
|
|
f"- The following buses are missing completely:"
|
|
f"\n {', '.join(map(str, missing_start.intersection(missing_end)))}")
|
|
|
|
|
|
def clean_dataset(nodes, gas_connections):
|
|
"""Convert units and save only necessary data."""
|
|
|
|
check_missing(nodes, gas_connections)
|
|
|
|
determine_pipe_capacity(gas_connections)
|
|
|
|
cols = [
|
|
'is_bothDirection',
|
|
'capacity_recalculated',
|
|
'buses_start',
|
|
'buses_destination',
|
|
'id',
|
|
'length_km'
|
|
]
|
|
clean_pipes = gas_connections[cols].dropna()
|
|
|
|
|
|
# convert GW -> MW
|
|
clean_pipes.loc[:, 'capacity_recalculated'] *= 1e3
|
|
|
|
# rename columns
|
|
to_rename = {
|
|
'capacity_recalculated': 'pipe_capacity_MW',
|
|
'buses_start': 'bus0',
|
|
'buses_destination': 'bus1'
|
|
}
|
|
clean_pipes.rename(columns=to_rename, inplace=True)
|
|
|
|
return clean_pipes
|
|
|
|
|
|
def diameter2capacity(pipe_diameter_mm):
|
|
"""Calculate pipe capacity based on diameter.
|
|
|
|
20 inch (500 mm) 50 bar -> 1.5 GW CH4 pipe capacity (LHV)
|
|
24 inch (600 mm) 50 bar -> 5 GW CH4 pipe capacity (LHV)
|
|
36 inch (900 mm) 50 bar -> 11.25 GW CH4 pipe capacity (LHV)
|
|
48 inch (1200 mm) 80 bar -> 21.7 GW CH4 pipe capacity (LHV)
|
|
|
|
Based on p.15 of https://gasforclimate2050.eu/wp-content/uploads/2020/07/2020_European-Hydrogen-Backbone_Report.pdf
|
|
"""
|
|
|
|
# slopes definitions
|
|
m0 = (5 - 1.5) / (600 - 500)
|
|
m1 = (11.25 - 5) / (900 - 600)
|
|
m2 = (21.7 - 11.25) / (1200 - 900)
|
|
|
|
# intercept
|
|
a0 = -16
|
|
a1 = -7.5
|
|
a2 = -20.1
|
|
|
|
if pipe_diameter_mm < 500:
|
|
return np.nan
|
|
elif pipe_diameter_mm < 600:
|
|
return a0 + m0 * pipe_diameter_mm
|
|
elif pipe_diameter_mm < 900:
|
|
return a1 + m1 * pipe_diameter_mm
|
|
else:
|
|
return a2 + m2 * pipe_diameter_mm
|
|
|
|
|
|
def determine_pipe_capacity(gas_network):
|
|
"""Check pipe capacity depending on diameter and pressure."""
|
|
|
|
gas_network["capacity_recalculated"] = gas_network.diameter_mm.apply(diameter2capacity)
|
|
|
|
# if pipe capacity smaller than 1.5 GW take original pipe capacity
|
|
low_cap = gas_network.Capacity_GWh_h < 1.5
|
|
gas_network.loc[low_cap, "capacity_recalculated"] = gas_network.loc[low_cap, "capacity_recalculated"].fillna(gas_network.loc[low_cap, "Capacity_GWh_h"])
|
|
|
|
# for pipes without diameter assume 500 mm diameter
|
|
gas_network["capacity_recalculated"].fillna(1.5, inplace=True)
|
|
|
|
# for nord stream take orginal data
|
|
nord_stream = gas_network[gas_network.max_pressure_bar==220].index
|
|
gas_network.loc[nord_stream, "capacity_recalculated"] = gas_network.loc[nord_stream, "Capacity_GWh_h"]
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
if 'snakemake' not in globals():
|
|
from helper import mock_snakemake
|
|
snakemake = mock_snakemake('build_gas_network',
|
|
network='elec', simpl='', clusters='37',
|
|
lv='1.0', opts='', planning_horizons='2020',
|
|
sector_opts='168H-T-H-B-I')
|
|
|
|
logging.basicConfig(level=snakemake.config['logging_level'])
|
|
|
|
# import gas network data
|
|
gas_network, points = load_gas_network(snakemake.input.gas_network)
|
|
|
|
# get clustered bus regions
|
|
bus_regions = load_bus_regions(
|
|
snakemake.input.regions_onshore,
|
|
snakemake.input.regions_offshore
|
|
)
|
|
nodes = pd.Index(bus_regions.name.unique())
|
|
|
|
# map gas network points to network buses
|
|
points2buses_map = points2buses(points, bus_regions)
|
|
|
|
# create gas network between pypsa nodes
|
|
gas_connections = build_gas_network_topology(gas_network, points2buses_map)
|
|
|
|
gas_connections = clean_dataset(nodes, gas_connections)
|
|
|
|
gas_connections.to_csv(snakemake.output.clustered_gas_network)
|