Bouw LHM netwerk¶
Met deze Notebook leiden we het netwerk van het Landelijk Hydrologisch Model (LHM) af op basis van het Distributie Model (DM), de routing van Local Surface Water (LSW) en een routing tussen DM en LSWs, waarbij we gebruik makn van het Landelijk Sobek Model (LSM) en het Landelijke KRW verkenner model (LKM).
Werkwijze in hoofdstukken:
- Afleiden LSW-netwerk: local service waters (lsws) waarvan een routing naar een andere lsw bekend is, routen we naar deze lsw. Dit levert tevens een lijst met
lsw-end-nodes
op, die in stap 2 aan het DM worden gekoppeld - AFleiden LSW-DM-links:
lsw-end-nodes
worden gekoppeld aan het DM via een gecombineerd netwerk van het Landelijk KRW verkenner model (LKM
) en het landelijk Sobek Model (LSM
). Voor hetLSM
is een lijst bekend van lateralen die afwateren naar of aanvoeren vanuit districten en DM-knopen. - Opbouw LHM-netwerk: het DM-netwerk nemen we over, het LSW-netwerk (
1
) en de LSW-DM-links (2
) worden daarmee geintegreerd.
1. LSW-netwerk¶
We lezen lswrouting.dik
(beschrijft lsw-naar-lsw-routing) en lsws.shp
. Met de functie lsw_network
kunnen we hier een lsw-netwerk van bouwen met lsw_links_gdf
en lsw_nodes_gdf
. De functie lsw_end_nodes
levert ons lsw eindknopen op die we moeten koppelen aan het DM.
In [1]:
Copied!
import geopandas as gpd
import pandas as pd
from config import load_src, DATA_DIR, MOZART_DIR, LSW_DIR, LHM_DIR
import networkx as nx
from networkx import NetworkXNoPath
from networkx.classes.function import path_weight
load_src()
from lhm.read import (
read_lsw_routing,
read_dw_keys,
read_dm_mz_to_obese,
read_sobek_network_shps,
read_dm_network_shps,
read_lkm_network_links
)
from lhm.lsw import lsw_end_nodes, lsw_network
from lhm.network import merge_lsm_lkm, create_graph, Network
from lhm.utils import report_progress
from shapely.geometry import LineString
import geopandas as gpd
import pandas as pd
from config import load_src, DATA_DIR, MOZART_DIR, LSW_DIR, LHM_DIR
import networkx as nx
from networkx import NetworkXNoPath
from networkx.classes.function import path_weight
load_src()
from lhm.read import (
read_lsw_routing,
read_dw_keys,
read_dm_mz_to_obese,
read_sobek_network_shps,
read_dm_network_shps,
read_lkm_network_links
)
from lhm.lsw import lsw_end_nodes, lsw_network
from lhm.network import merge_lsm_lkm, create_graph, Network
from lhm.utils import report_progress
from shapely.geometry import LineString
1.1. Bouwen lsw-netwerk¶
In [2]:
Copied!
# Inlezen lsw-routing
lsw_routing_dik = MOZART_DIR / r"mozartin/lswrouting.dik"
lsw_routing_df = read_lsw_routing(lsw_routing_dik)
# Inlezen en dissolven lsws
lsw_gdf = gpd.read_file(LSW_DIR / "lsws.shp").dissolve(by="LSWFINAL").reset_index()
# bouwen lsw-netwerk
lsw_links_gdf, lsw_nodes_gdf = lsw_network(lsw_gdf, lsw_routing_df, dissolve_lsws=False)
# Inlezen lsw-routing
lsw_routing_dik = MOZART_DIR / r"mozartin/lswrouting.dik"
lsw_routing_df = read_lsw_routing(lsw_routing_dik)
# Inlezen en dissolven lsws
lsw_gdf = gpd.read_file(LSW_DIR / "lsws.shp").dissolve(by="LSWFINAL").reset_index()
# bouwen lsw-netwerk
lsw_links_gdf, lsw_nodes_gdf = lsw_network(lsw_gdf, lsw_routing_df, dissolve_lsws=False)
1.2. Afleiden LSW-eindknopen¶
In [3]:
Copied!
# afleiden lsw-end-nodes
lsw_end_nodes_gdf = lsw_end_nodes(lsw_links_gdf, lsw_nodes_gdf).reset_index()
lsw_end_nodes_gdf["lsw_lkm"] = lsw_end_nodes_gdf["LSWFINAL"].apply(lambda x:f"LKM_{x}")
lsw_end_nodes_gdf = lsw_end_nodes_gdf[["LSWFINAL", "lsw_lkm", "DWRN", "geometry"]]
lsw_nodes_gdf.reset_index(inplace=True)
lsw_nodes_gdf["lsw_lkm"] = lsw_nodes_gdf["LSWFINAL"].apply(lambda x:f"LKM_{x}")
lsw_nodes_gdf.set_index("LSWFINAL", inplace=True)
print(f"aantal lsw-eindknopen: {len(lsw_end_nodes_gdf)}")
lsw_end_nodes_gdf.explore()
# afleiden lsw-end-nodes
lsw_end_nodes_gdf = lsw_end_nodes(lsw_links_gdf, lsw_nodes_gdf).reset_index()
lsw_end_nodes_gdf["lsw_lkm"] = lsw_end_nodes_gdf["LSWFINAL"].apply(lambda x:f"LKM_{x}")
lsw_end_nodes_gdf = lsw_end_nodes_gdf[["LSWFINAL", "lsw_lkm", "DWRN", "geometry"]]
lsw_nodes_gdf.reset_index(inplace=True)
lsw_nodes_gdf["lsw_lkm"] = lsw_nodes_gdf["LSWFINAL"].apply(lambda x:f"LKM_{x}")
lsw_nodes_gdf.set_index("LSWFINAL", inplace=True)
print(f"aantal lsw-eindknopen: {len(lsw_end_nodes_gdf)}")
lsw_end_nodes_gdf.explore()
aantal lsw-eindknopen: 2309
Out[3]:
Make this Notebook Trusted to load map: File -> Trust Notebook
2. LSW-DM-links¶
We doorlopen de volgende stappen:
- Inlezen:
- LSM-netwerk:
network_l.shp
ennetwork_n.shp
met de functieread_sobek_network_shps
DMMZTOSOBEKID_obese.txt
met functieread_dm_mz_to_obese
LKM25_links.shp
met functieread_lkm_network_links
dwkeys.txt
met functieread_dw_keys
- DM-netwerk met
read_dm_network_shps
- LSM-netwerk:
- Bouwen van lkm-lsm netwerk bestanden met functie
merge_lsm_lkm
en omzetten naar een netwerk-graaf - Afleiden afvoerlinks uit de graaf
- Afleiden van aanvoerlinks uit de graaf
2.1. Inlezen¶
In [4]:
Copied!
# Inlezen LSM-netwerk
network_l_gdf, network_n_gdf = read_sobek_network_shps(
DATA_DIR.joinpath("LSM_obsese", "LSMKRW")
)
# Inlezen DMMZTOSOBEKID_obese.txt
dm_mz_to_obese_txt = DATA_DIR.joinpath("LSM_obsese", "DMMZTOSOBEKID_obese.txt")
dm_mz_to_obese_df = read_dm_mz_to_obese(dm_mz_to_obese_txt)
dm_mz_to_obese_df = dm_mz_to_obese_df[
dm_mz_to_obese_df["LSM_id"].isin(network_n_gdf.index)
]
lat_discharge_mask = dm_mz_to_obese_df["flow_type"] == "D"
lat_extraction_mask = dm_mz_to_obese_df["flow_type"] == "E"
# Inlezen LKM25_links.shp
lkm25_links_shp = DATA_DIR.joinpath("lkm25","Schematisatie","KRWVerkenner","shapes","LKM25_Links.shp")
lkm25_links_gdf = read_lkm_network_links(lkm25_links_shp)
# Inlezen dwkeys.txt
dw_keys_df = read_dw_keys(DATA_DIR / r"lhm4.3\\dm\\txtfiles_git\\dwkeys.txt")
dw_discharge_mask = dw_keys_df["kty"] == "d"
dw_extractions_mask = dw_keys_df["kty"] == "e"
# Inlezen DM-netwerk
dm_links_gdf, dm_nodes_gdf = read_dm_network_shps(LHM_DIR / r"dm/data_dvc")
# Inlezen LSM-netwerk
network_l_gdf, network_n_gdf = read_sobek_network_shps(
DATA_DIR.joinpath("LSM_obsese", "LSMKRW")
)
# Inlezen DMMZTOSOBEKID_obese.txt
dm_mz_to_obese_txt = DATA_DIR.joinpath("LSM_obsese", "DMMZTOSOBEKID_obese.txt")
dm_mz_to_obese_df = read_dm_mz_to_obese(dm_mz_to_obese_txt)
dm_mz_to_obese_df = dm_mz_to_obese_df[
dm_mz_to_obese_df["LSM_id"].isin(network_n_gdf.index)
]
lat_discharge_mask = dm_mz_to_obese_df["flow_type"] == "D"
lat_extraction_mask = dm_mz_to_obese_df["flow_type"] == "E"
# Inlezen LKM25_links.shp
lkm25_links_shp = DATA_DIR.joinpath("lkm25","Schematisatie","KRWVerkenner","shapes","LKM25_Links.shp")
lkm25_links_gdf = read_lkm_network_links(lkm25_links_shp)
# Inlezen dwkeys.txt
dw_keys_df = read_dw_keys(DATA_DIR / r"lhm4.3\\dm\\txtfiles_git\\dwkeys.txt")
dw_discharge_mask = dw_keys_df["kty"] == "d"
dw_extractions_mask = dw_keys_df["kty"] == "e"
# Inlezen DM-netwerk
dm_links_gdf, dm_nodes_gdf = read_dm_network_shps(LHM_DIR / r"dm/data_dvc")
2.2. Bouwen LSM-LKM netwerk + graaf¶
In [5]:
Copied!
import warnings
warnings.filterwarnings("ignore")
# combineren lsm-lkm netwerk
network_links_gdf, network_nodes_gdf = merge_lsm_lkm(lkm25_links_gdf, network_l_gdf, network_n_gdf)
network_nodes_gdf.to_file(DATA_DIR / "lkm-lsm-network.gpkg", layer = "nodes")
network_links_gdf.to_file(DATA_DIR / "lkm-lsm-network.gpkg", layer = "links")
# afleiden netwerk-graaf
network_graph = create_graph(network_links_gdf, network_nodes_gdf)
import warnings
warnings.filterwarnings("ignore")
# combineren lsm-lkm netwerk
network_links_gdf, network_nodes_gdf = merge_lsm_lkm(lkm25_links_gdf, network_l_gdf, network_n_gdf)
network_nodes_gdf.to_file(DATA_DIR / "lkm-lsm-network.gpkg", layer = "nodes")
network_links_gdf.to_file(DATA_DIR / "lkm-lsm-network.gpkg", layer = "links")
# afleiden netwerk-graaf
network_graph = create_graph(network_links_gdf, network_nodes_gdf)
2.3 Afleiden afvoerlinks¶
In [6]:
Copied!
lsw_end_nodes_in_network_gdf = lsw_end_nodes_gdf[
lsw_end_nodes_gdf["lsw_lkm"].isin(network_nodes_gdf.index)
]
links = []
nbr_groups = len(lsw_end_nodes_in_network_gdf["DWRN"].unique())
for idx, (district, _lsw_end_nodes_df) in enumerate(lsw_end_nodes_in_network_gdf.groupby("DWRN")):
report_progress(idx+1, nbr_groups, interval=5)
# find dm_nodes to couple with
dm_nodes = dw_keys_df[
(dw_keys_df["oid"] == district) & dw_discharge_mask
]["nid"].to_list()
if not dm_nodes:
dm_nodes = dm_mz_to_obese_df[
(dm_mz_to_obese_df["DWRN"] == district) & lat_discharge_mask
]["DM"].to_list()
# find possible LSM laterals discharging to DM nodes
dm_mz_to_obese_select_df = dm_mz_to_obese_df[
dm_mz_to_obese_df["DM"].isin(dm_nodes) & lat_discharge_mask
]
missing_dm_links = dm_nodes
missing_lsw_links = []
# couple all lsw-end-nodes to DM-node(s)
for row in _lsw_end_nodes_df.itertuples():
lsw_from = row.LSWFINAL
lsw_node = lsw_nodes_gdf.at[lsw_from, "geometry"]
# find the shortest path between LSW-node and DM-node
for dm_to, _dm_mz_lat_df in dm_mz_to_obese_select_df.groupby("DM"):
path_found = False
dm_node = dm_nodes_gdf.at[dm_to, "geometry"]
paths = []
path_lengths = []
valid_laterals = _dm_mz_lat_df["LSM_id"]
for lateral in valid_laterals:
try:
path = nx.shortest_path(network_graph, source=row.lsw_lkm, target=lateral, weight="length", method='dijkstra')
# Exclude paths that pass through other lateral nodes
if all(node not in valid_laterals for node in path[1:-1]):
path = [i for i in path if not i.startswith("LKM_")]
length = path_weight(network_graph, path, weight="length")
paths.append(path)
path_lengths.append(length)
except NetworkXNoPath:
continue
if paths:
path_found = True
path = paths[path_lengths.index(min(path_lengths))]
lsm_to = path[0]
# define geometry
lsm_nodes = [network_nodes_gdf.at[i, "geometry"] for i in path]
# find idx of closest lsm-node to dm-node
distances = [i.distance(dm_node) for i in lsm_nodes]
idx = distances.index(min(distances))
geometry = LineString(([lsw_node] + lsm_nodes[:idx+1] + [dm_node]))
links += [(row.LSWFINAL, lsm_to, dm_to, district, "discharge", geometry)]
missing_dm_links = [i for i in missing_dm_links if i != dm_to]
if not path_found:
missing_lsw_links += [lsw_from]
# make sure every lsw has a link to# a DM node
for lsw_from in missing_lsw_links:
lsw_node = lsw_nodes_gdf.at[lsw_from, "geometry"]
dm_to = dm_nodes_gdf.loc[dm_nodes, "geometry"].distance(lsw_node).idxmin()
dm_node = dm_nodes_gdf.at[dm_to, "geometry"]
geometry = LineString([lsw_node, dm_node])
links += [(lsw_from, None, dm_to, district, "discharge", geometry)]
missing_dm_links = [i for i in missing_dm_links if i != dm_to]
# make sure every DM #is discharged from a LSW
for dm_to in missing_dm_links:
dm_node = dm_nodes_gdf.at[dm_to, "geometry"]
lsw_from = _lsw_end_nodes_df.set_index("LSWFINAL").distance(dm_node).idxmin()
lsw_node = lsw_nodes_gdf.at[lsw_from, "geometry"]
geometry = LineString([lsw_node, dm_node])
links += [(lsw_from, None, dm_to, district, "discharge", geometry)]
afvoer_links_gdf = gpd.GeoDataFrame(
data=links,
columns=["lsw","lsm", "dm", "dictrict", "flow_type", "geometry"],
crs=28992)
afvoer_links_gdf["node_from"] = afvoer_links_gdf["lsw"].apply(lambda x: f"MZlsw_{x}")
afvoer_links_gdf["node_to"] = afvoer_links_gdf["dm"].apply(lambda x: f"DMnd_{x}")
afvoer_links_gdf["link_type"] = "LSW-DM"
afvoer_links_gdf["index"] = afvoer_links_gdf.apply(
(lambda x: f"{x.node_from}-{x.node_to}"),
axis=1
)
lsw_end_nodes_in_network_gdf = lsw_end_nodes_gdf[
lsw_end_nodes_gdf["lsw_lkm"].isin(network_nodes_gdf.index)
]
links = []
nbr_groups = len(lsw_end_nodes_in_network_gdf["DWRN"].unique())
for idx, (district, _lsw_end_nodes_df) in enumerate(lsw_end_nodes_in_network_gdf.groupby("DWRN")):
report_progress(idx+1, nbr_groups, interval=5)
# find dm_nodes to couple with
dm_nodes = dw_keys_df[
(dw_keys_df["oid"] == district) & dw_discharge_mask
]["nid"].to_list()
if not dm_nodes:
dm_nodes = dm_mz_to_obese_df[
(dm_mz_to_obese_df["DWRN"] == district) & lat_discharge_mask
]["DM"].to_list()
# find possible LSM laterals discharging to DM nodes
dm_mz_to_obese_select_df = dm_mz_to_obese_df[
dm_mz_to_obese_df["DM"].isin(dm_nodes) & lat_discharge_mask
]
missing_dm_links = dm_nodes
missing_lsw_links = []
# couple all lsw-end-nodes to DM-node(s)
for row in _lsw_end_nodes_df.itertuples():
lsw_from = row.LSWFINAL
lsw_node = lsw_nodes_gdf.at[lsw_from, "geometry"]
# find the shortest path between LSW-node and DM-node
for dm_to, _dm_mz_lat_df in dm_mz_to_obese_select_df.groupby("DM"):
path_found = False
dm_node = dm_nodes_gdf.at[dm_to, "geometry"]
paths = []
path_lengths = []
valid_laterals = _dm_mz_lat_df["LSM_id"]
for lateral in valid_laterals:
try:
path = nx.shortest_path(network_graph, source=row.lsw_lkm, target=lateral, weight="length", method='dijkstra')
# Exclude paths that pass through other lateral nodes
if all(node not in valid_laterals for node in path[1:-1]):
path = [i for i in path if not i.startswith("LKM_")]
length = path_weight(network_graph, path, weight="length")
paths.append(path)
path_lengths.append(length)
except NetworkXNoPath:
continue
if paths:
path_found = True
path = paths[path_lengths.index(min(path_lengths))]
lsm_to = path[0]
# define geometry
lsm_nodes = [network_nodes_gdf.at[i, "geometry"] for i in path]
# find idx of closest lsm-node to dm-node
distances = [i.distance(dm_node) for i in lsm_nodes]
idx = distances.index(min(distances))
geometry = LineString(([lsw_node] + lsm_nodes[:idx+1] + [dm_node]))
links += [(row.LSWFINAL, lsm_to, dm_to, district, "discharge", geometry)]
missing_dm_links = [i for i in missing_dm_links if i != dm_to]
if not path_found:
missing_lsw_links += [lsw_from]
# make sure every lsw has a link to# a DM node
for lsw_from in missing_lsw_links:
lsw_node = lsw_nodes_gdf.at[lsw_from, "geometry"]
dm_to = dm_nodes_gdf.loc[dm_nodes, "geometry"].distance(lsw_node).idxmin()
dm_node = dm_nodes_gdf.at[dm_to, "geometry"]
geometry = LineString([lsw_node, dm_node])
links += [(lsw_from, None, dm_to, district, "discharge", geometry)]
missing_dm_links = [i for i in missing_dm_links if i != dm_to]
# make sure every DM #is discharged from a LSW
for dm_to in missing_dm_links:
dm_node = dm_nodes_gdf.at[dm_to, "geometry"]
lsw_from = _lsw_end_nodes_df.set_index("LSWFINAL").distance(dm_node).idxmin()
lsw_node = lsw_nodes_gdf.at[lsw_from, "geometry"]
geometry = LineString([lsw_node, dm_node])
links += [(lsw_from, None, dm_to, district, "discharge", geometry)]
afvoer_links_gdf = gpd.GeoDataFrame(
data=links,
columns=["lsw","lsm", "dm", "dictrict", "flow_type", "geometry"],
crs=28992)
afvoer_links_gdf["node_from"] = afvoer_links_gdf["lsw"].apply(lambda x: f"MZlsw_{x}")
afvoer_links_gdf["node_to"] = afvoer_links_gdf["dm"].apply(lambda x: f"DMnd_{x}")
afvoer_links_gdf["link_type"] = "LSW-DM"
afvoer_links_gdf["index"] = afvoer_links_gdf.apply(
(lambda x: f"{x.node_from}-{x.node_to}"),
axis=1
)
[####################] 100.0% completed
2.4 Afleiden aanvoerlinks¶
In [7]:
Copied!
# Graaf omzetten naar undirected
if network_graph.is_directed():
network_graph = network_graph.to_undirected()
lsw_nodes_in_network_gdf = lsw_nodes_gdf[
lsw_nodes_gdf["lsw_lkm"].isin(network_nodes_gdf.index)
]
# Zoeken naar links
links = []
nbr_groups = len(dw_keys_df[dw_extractions_mask]["oid"].unique())
for idx, (district, _extract_df) in enumerate(dw_keys_df[dw_extractions_mask].groupby("oid")):
report_progress(idx+1, nbr_groups, interval=5)
#print(f"district: {district}")
dm_nodes = _extract_df["nid"]
for dm_from in dm_nodes.values:
#print(f" dm-node: {dm_from}")
dm_node = dm_nodes_gdf.at[dm_from, "geometry"]
paths = []
path_lengths = []
lsws = []
dm_mz_to_obese_select_df = dm_mz_to_obese_df[
(dm_mz_to_obese_df["DM"] == dm_from) & lat_extraction_mask & (dm_mz_to_obese_df["DWRN"] == district)
]
lsw_district_nodes_df = lsw_end_nodes_in_network_gdf[lsw_end_nodes_in_network_gdf["DWRN"] == district]
if lsw_district_nodes_df.empty:
lsw_district_nodes_df = lsw_nodes_in_network_gdf[lsw_nodes_in_network_gdf["DWRN"] == district]
lsw_district_nodes_df.reset_index(inplace=True)
if not dm_mz_to_obese_select_df.empty:
lsm_from = dm_mz_to_obese_select_df["LSM_id"].values[0]
lkm_lsw_nodes = lsw_district_nodes_df["lsw_lkm"]
for row in lsw_district_nodes_df.itertuples():
lsw_lkm_to = row.lsw_lkm
try:
path = nx.shortest_path(network_graph, source=lsm_from, target=lsw_lkm_to, weight="length", method='dijkstra')
# Exclude paths that pass through other lateral nodes
if all(node not in lkm_lsw_nodes for node in path[1:-1]):
#path = [i for i in path if not i.startswith("LKM_")]
length = path_weight(network_graph, path, weight="length")
paths.append(path)
path_lengths.append(length)
except NetworkXNoPath:
continue
if paths:
idx = path_lengths.index(min(path_lengths))
path = paths[idx]
lsw_to = int(path[-1][4:])
path = [i for i in path if not i.startswith("LKM_")]
lsw_node = lsw_nodes_gdf.at[lsw_to, "geometry"]
# define geometry
lsm_nodes = [network_nodes_gdf.at[i, "geometry"] for i in path]
geometry = LineString(([dm_node] + lsm_nodes + [lsw_node]))
links += [(lsw_to, lsm_from, dm_from, district, "extraction", geometry)]
else:
lsw = lsw_district_nodes_df.loc[lsw_district_nodes_df.distance(dm_node).idxmin()]
lsw_to = lsw.LSWFINAL
lsw_node = lsw_nodes_gdf.at[lsw_to, "geometry"]
geometry = LineString([dm_node, lsw_node])
links += [(lsw_to, None, dm_from, district, "extraction", geometry)]
aanvoer_links_gdf = gpd.GeoDataFrame(
data=links,
columns=["lsw","lsm", "dm", "dictrict", "flow_type", "geometry"],
crs=28992)
aanvoer_links_gdf["node_from"] = aanvoer_links_gdf["dm"].apply(lambda x: f"DMnd_{x}")
aanvoer_links_gdf["node_to"] = aanvoer_links_gdf["lsw"].apply(lambda x: f"MZlsw_{x}")
aanvoer_links_gdf["link_type"] = "DM-LSW"
aanvoer_links_gdf["index"] = aanvoer_links_gdf.apply(
(lambda x: f"{x.node_from}-{x.node_to}"),
axis=1
)
# Graaf omzetten naar undirected
if network_graph.is_directed():
network_graph = network_graph.to_undirected()
lsw_nodes_in_network_gdf = lsw_nodes_gdf[
lsw_nodes_gdf["lsw_lkm"].isin(network_nodes_gdf.index)
]
# Zoeken naar links
links = []
nbr_groups = len(dw_keys_df[dw_extractions_mask]["oid"].unique())
for idx, (district, _extract_df) in enumerate(dw_keys_df[dw_extractions_mask].groupby("oid")):
report_progress(idx+1, nbr_groups, interval=5)
#print(f"district: {district}")
dm_nodes = _extract_df["nid"]
for dm_from in dm_nodes.values:
#print(f" dm-node: {dm_from}")
dm_node = dm_nodes_gdf.at[dm_from, "geometry"]
paths = []
path_lengths = []
lsws = []
dm_mz_to_obese_select_df = dm_mz_to_obese_df[
(dm_mz_to_obese_df["DM"] == dm_from) & lat_extraction_mask & (dm_mz_to_obese_df["DWRN"] == district)
]
lsw_district_nodes_df = lsw_end_nodes_in_network_gdf[lsw_end_nodes_in_network_gdf["DWRN"] == district]
if lsw_district_nodes_df.empty:
lsw_district_nodes_df = lsw_nodes_in_network_gdf[lsw_nodes_in_network_gdf["DWRN"] == district]
lsw_district_nodes_df.reset_index(inplace=True)
if not dm_mz_to_obese_select_df.empty:
lsm_from = dm_mz_to_obese_select_df["LSM_id"].values[0]
lkm_lsw_nodes = lsw_district_nodes_df["lsw_lkm"]
for row in lsw_district_nodes_df.itertuples():
lsw_lkm_to = row.lsw_lkm
try:
path = nx.shortest_path(network_graph, source=lsm_from, target=lsw_lkm_to, weight="length", method='dijkstra')
# Exclude paths that pass through other lateral nodes
if all(node not in lkm_lsw_nodes for node in path[1:-1]):
#path = [i for i in path if not i.startswith("LKM_")]
length = path_weight(network_graph, path, weight="length")
paths.append(path)
path_lengths.append(length)
except NetworkXNoPath:
continue
if paths:
idx = path_lengths.index(min(path_lengths))
path = paths[idx]
lsw_to = int(path[-1][4:])
path = [i for i in path if not i.startswith("LKM_")]
lsw_node = lsw_nodes_gdf.at[lsw_to, "geometry"]
# define geometry
lsm_nodes = [network_nodes_gdf.at[i, "geometry"] for i in path]
geometry = LineString(([dm_node] + lsm_nodes + [lsw_node]))
links += [(lsw_to, lsm_from, dm_from, district, "extraction", geometry)]
else:
lsw = lsw_district_nodes_df.loc[lsw_district_nodes_df.distance(dm_node).idxmin()]
lsw_to = lsw.LSWFINAL
lsw_node = lsw_nodes_gdf.at[lsw_to, "geometry"]
geometry = LineString([dm_node, lsw_node])
links += [(lsw_to, None, dm_from, district, "extraction", geometry)]
aanvoer_links_gdf = gpd.GeoDataFrame(
data=links,
columns=["lsw","lsm", "dm", "dictrict", "flow_type", "geometry"],
crs=28992)
aanvoer_links_gdf["node_from"] = aanvoer_links_gdf["dm"].apply(lambda x: f"DMnd_{x}")
aanvoer_links_gdf["node_to"] = aanvoer_links_gdf["lsw"].apply(lambda x: f"MZlsw_{x}")
aanvoer_links_gdf["link_type"] = "DM-LSW"
aanvoer_links_gdf["index"] = aanvoer_links_gdf.apply(
(lambda x: f"{x.node_from}-{x.node_to}"),
axis=1
)
[####################] 100.0% completed
3. Opbouw LHM-netwerk¶
In [8]:
Copied!
# DM-netwerk voorbereiden
dm_links_gdf["node_from"] = dm_links_gdf["node_from"].apply(lambda x: f"DMnd_{x}")
dm_links_gdf["node_to"] = dm_links_gdf["node_to"].apply(lambda x: f"DMnd_{x}")
dm_links_gdf["index"] = dm_links_gdf["index"].apply(lambda x: f"DMlk_{x}")
dm_links_gdf["link_type"] = "DM-DM"
dm_nodes_gdf["index"] = dm_nodes_gdf["index"].apply(lambda x: f"DMnd_{x}")
# LSW-netwerk voorbreiden
lsw_links_gdf["node_from"] = lsw_links_gdf["node_from"].apply(lambda x: f"MZlsw_{x}")
lsw_links_gdf["node_to"] = lsw_links_gdf["node_to"].apply(lambda x: f"MZlsw_{x}")
lsw_links_gdf["index"] = lsw_links_gdf.apply((lambda x: f"{x.node_from}-{x.node_to}"), axis=1)
lsw_links_gdf["link_type"] = "LSW-LSW"
lsw_nodes_gdf.reset_index(inplace=True)
lsw_nodes_gdf["index"] = lsw_nodes_gdf["LSWFINAL"].apply(lambda x: f"MZlsw_{x}")
# Samenstellen netwerk-links
links_gdf = pd.concat(
[lsw_links_gdf,
afvoer_links_gdf,
aanvoer_links_gdf,
dm_links_gdf]
)
# Samenstellen netwerk-nodes
nodes_gdf = pd.concat([lsw_nodes_gdf, dm_nodes_gdf])
# aanmaken lhm-netwerk en wegschrijven
lhm_netwerk = Network(nodes=nodes_gdf, links=links_gdf)
lhm_netwerk.to_gpkg(DATA_DIR / "lhm-netwerk.gpkg")
lhm_netwerk.explore()
# DM-netwerk voorbereiden
dm_links_gdf["node_from"] = dm_links_gdf["node_from"].apply(lambda x: f"DMnd_{x}")
dm_links_gdf["node_to"] = dm_links_gdf["node_to"].apply(lambda x: f"DMnd_{x}")
dm_links_gdf["index"] = dm_links_gdf["index"].apply(lambda x: f"DMlk_{x}")
dm_links_gdf["link_type"] = "DM-DM"
dm_nodes_gdf["index"] = dm_nodes_gdf["index"].apply(lambda x: f"DMnd_{x}")
# LSW-netwerk voorbreiden
lsw_links_gdf["node_from"] = lsw_links_gdf["node_from"].apply(lambda x: f"MZlsw_{x}")
lsw_links_gdf["node_to"] = lsw_links_gdf["node_to"].apply(lambda x: f"MZlsw_{x}")
lsw_links_gdf["index"] = lsw_links_gdf.apply((lambda x: f"{x.node_from}-{x.node_to}"), axis=1)
lsw_links_gdf["link_type"] = "LSW-LSW"
lsw_nodes_gdf.reset_index(inplace=True)
lsw_nodes_gdf["index"] = lsw_nodes_gdf["LSWFINAL"].apply(lambda x: f"MZlsw_{x}")
# Samenstellen netwerk-links
links_gdf = pd.concat(
[lsw_links_gdf,
afvoer_links_gdf,
aanvoer_links_gdf,
dm_links_gdf]
)
# Samenstellen netwerk-nodes
nodes_gdf = pd.concat([lsw_nodes_gdf, dm_nodes_gdf])
# aanmaken lhm-netwerk en wegschrijven
lhm_netwerk = Network(nodes=nodes_gdf, links=links_gdf)
lhm_netwerk.to_gpkg(DATA_DIR / "lhm-netwerk.gpkg")
lhm_netwerk.explore()
Out[8]:
Make this Notebook Trusted to load map: File -> Trust Notebook