def replace_components(n, c, df, pnl):
n.mremove(c, n.df(c).index)
import_components_from_dataframe(n, df, c)
for attr, df in pnl.items():
if not df.empty:
import_series_from_dataframe(n, df, c, attr)
def cluster_on_extra_high_voltage(network, busmap, with_time=True):
network_c = Network()
buses = aggregatebuses(network, busmap, {
'x': _leading(busmap, network.buses),
'y': _leading(busmap, network.buses)
})
# keep attached lines
lines = network.lines.copy()
mask = lines.bus0.isin(buses.index)
lines = lines.loc[mask, :]
# keep attached transformer
transformers = network.transformers.copy()
mask = transformers.bus0.isin(buses.index)
transformers = transformers.loc[mask, :]
io.import_components_from_dataframe(network_c, buses, "Bus")
io.import_components_from_dataframe(network_c, lines, "Line")
io.import_components_from_dataframe(network_c, transformers, "Transformer")
if with_time:
network_c.now = network.now
network_c.set_snapshots(network.snapshots)
# dealing with generators
network.generators['weight'] = 1
new_df, new_pnl = aggregategenerators(network, busmap, with_time)
io.import_components_from_dataframe(network_c, new_df, 'Generator')
for attr, df in iteritems(new_pnl):
io.import_series_from_dataframe(network_c, df, 'Generator', attr)
# dealing with all other components
aggregate_one_ports = components.one_port_components.copy()
aggregate_one_ports.discard('Generator')
for one_port in aggregate_one_ports:
new_df, new_pnl = aggregateoneport(network,
busmap,
component=one_port,
with_time=with_time)
io.import_components_from_dataframe(network_c, new_df, one_port)
for attr, df in iteritems(new_pnl):
io.import_series_from_dataframe(network_c, df, one_port, attr)
network_c.determine_network_topology()
return network_c
def concat_network(list_networks, ignore_standard_types=False):
'''
Function that merges technically identical, but temporally decoupled networks by concatenating
their time-dependent components (input & output)
-----
Param:
l_networks: list of daily solved networks (can be either l_networks_dispatch or l_networks_redispatch)
scenario: Determines whether input networks will have stores or not
'''
from pypsa.io import (import_components_from_dataframe,
import_series_from_dataframe)
from six import iterkeys
# create new network out of first network of the list of identical networks
n_input = list_networks[0].copy()
# Copy time indipendent components
# -------------------
override_components, override_component_attrs = n_input._retrieve_overridden_components(
)
nw = n_input.__class__(ignore_standard_types=ignore_standard_types,
override_components=override_components,
override_component_attrs=override_component_attrs)
for component in n_input.iterate_components(["Bus", "Carrier"] +
sorted(n_input.all_components -
{"Bus", "Carrier"})):
df = component.df
# drop the standard types to avoid them being read in twice
if not ignore_standard_types and component.name in n_input.standard_type_components:
df = component.df.drop(
nw.components[component.name]["standard_types"].index)
import_components_from_dataframe(nw, df, component.name)
# Time dependent components
# --------------------
# set snapshots
snapshots = n_input.snapshots
for network in list_networks[1:]:
snapshots = snapshots.union(network.snapshots)
nw.set_snapshots(snapshots)
# concat time dependent components from all networks in input list
for component in nw.iterate_components(["Bus", "Carrier"] +
sorted(n_input.all_components -
{"Bus", "Carrier"})):
component_t = component.list_name + "_t"
for attr, timeseries in component.pnl.items():
l_component = []
for network in list_networks:
# each time dependent dataframe
l_component.append(getattr(getattr(network, component_t),
attr))
# concat the components list to dataframe
df_component = pd.concat(l_component, axis=0)
# import time series from dataframe for output network
import_series_from_dataframe(nw, df_component, component.name,
attr)
# catch all remaining attributes of network
for attr in ["name", "srid"]:
setattr(nw, attr, getattr(n_input, attr))
# Concat objective value for partially solved networks
obj = 0
for network in list_networks:
if hasattr(network, 'objective'):
obj = obj + network.objective
nw.objective = obj
return nw
def cluster_on_extra_high_voltage(network, busmap, with_time=True):
""" Create a new clustered pypsa.Network given a busmap mapping all busids
to other busids of the same set.
Parameters
----------
network : pypsa.Network
Container for all network components.
busmap : dict
Maps old bus_ids to new bus_ids.
with_time : bool
If true time-varying data will also be aggregated.
Returns
-------
network : pypsa.Network
Container for all network components.
"""
network_c = Network()
buses = aggregatebuses(network, busmap, {
'x': _leading(busmap, network.buses),
'y': _leading(busmap, network.buses)
})
# keep attached lines
lines = network.lines.copy()
mask = lines.bus0.isin(buses.index)
lines = lines.loc[mask, :]
# keep attached transformer
transformers = network.transformers.copy()
mask = transformers.bus0.isin(buses.index)
transformers = transformers.loc[mask, :]
io.import_components_from_dataframe(network_c, buses, "Bus")
io.import_components_from_dataframe(network_c, lines, "Line")
io.import_components_from_dataframe(network_c, transformers, "Transformer")
if with_time:
network_c.snapshots = network.snapshots
network_c.set_snapshots(network.snapshots)
# dealing with generators
network.generators.control = "PV"
network.generators['weight'] = 1
new_df, new_pnl = aggregategenerators(network, busmap, with_time)
io.import_components_from_dataframe(network_c, new_df, 'Generator')
for attr, df in iteritems(new_pnl):
io.import_series_from_dataframe(network_c, df, 'Generator', attr)
# dealing with all other components
aggregate_one_ports = components.one_port_components.copy()
aggregate_one_ports.discard('Generator')
for one_port in aggregate_one_ports:
new_df, new_pnl = aggregateoneport(network,
busmap,
component=one_port,
with_time=with_time)
io.import_components_from_dataframe(network_c, new_df, one_port)
for attr, df in iteritems(new_pnl):
io.import_series_from_dataframe(network_c, df, one_port, attr)
network_c.determine_network_topology()
return network_c