def test_ow_index():
net = simple_four_bus_system()
steps = [3, 5, 7]
p_data = pd.DataFrame(index=steps,
columns=["0", "1"],
data=[
[0.01, 0.02],
[0.03, 0.04],
[0.05, 0.06],
])
v_data = pd.DataFrame(index=steps, columns=["0"], data=[1.01, 1.03, 1.02])
ds_p = DFData(p_data)
ds_v = DFData(v_data)
ct.ConstControl(net,
element='load',
variable='p_mw',
element_index=net.load.index.tolist(),
data_source=ds_p,
profile_name=p_data.columns)
ct.ConstControl(net,
element='ext_grid',
variable='vm_pu',
element_index=0,
data_source=ds_v,
profile_name='0')
ow = OutputWriter(net)
ow.log_variable('res_bus', 'vm_pu')
ow.log_variable('res_line', 'loading_percent')
run_timeseries(net, time_steps=p_data.index, verbose=False)
assert np.all(ow.output["res_line.loading_percent"].index == p_data.index)
def _preparte_grid(net):
"""
:param net:
:type net:
:return:
:rtype:
"""
ds_sink, ds_source = _data_source()
const_sink = control.ConstControl(
net,
element='sink',
variable='mdot_kg_per_s',
element_index=net.sink.index.values,
data_source=ds_sink,
profile_name=net.sink.index.values.astype(str))
const_source = control.ConstControl(
net,
element='source',
variable='mdot_kg_per_s',
element_index=net.source.index.values,
data_source=ds_source,
profile_name=net.source.index.values.astype(str))
del const_sink.initial_powerflow
const_sink.initial_pipeflow = False
del const_source.initial_powerflow
const_source.initial_pipeflow = False
return net
def test_new_pp_object_io():
net = networks.mv_oberrhein()
ds = DFData(pd.DataFrame(data=np.array([[0, 1, 2], [7, 8, 9]])))
control.ConstControl(net,
'sgen',
'p_mw',
42,
profile_name=0,
data_source=ds)
control.ContinuousTapControl(net, 142, 1)
obj = net.controller.object.at[0]
obj.run = pp.runpp
s = json.dumps(net, cls=PPJSONEncoder)
net1 = json.loads(s, cls=PPJSONDecoder)
obj1 = net1.controller.object.at[0]
obj2 = net1.controller.object.at[1]
assert isinstance(obj1, control.ConstControl)
assert isinstance(obj2, control.ContinuousTapControl)
assert obj1.run is pp.runpp
assert isinstance(obj1.data_source, DFData)
assert isinstance(obj1.data_source.df, pd.DataFrame)
def test_equal_eval_name_warning_and_costs():
net = nw.case5()
pp.create_pwl_cost(net, 0, "sgen", [[0, 20, 1], [20, 30, 2]])
pp.create_pwl_cost(net, 0, "gen", [[0, 20, 1], [20, 30, 2]])
pp.create_pwl_cost(net, 1, "gen", [[0, 20, 1], [20, 30, 2]])
pp.create_pwl_cost(net, 2, "gen", [[0, 20, 1], [20, 30, 2]])
df = pd.DataFrame({
0: [200, 300, 400, 500],
1: [400, 300, 100, 50],
2: [100, 300, 200, 100]
})
ds = ts.DFData(df.astype(np.float64))
_ = ct.ConstControl(net,
"load",
"p_mw",
net.load.index,
profile_name=net.load.index,
data_source=ds)
ow = ts.OutputWriter(net, output_path=None)
ow.log_variable("res_sgen", "p_mw", None, np.max, 'warnme')
ow.log_variable("res_load", "p_mw", None, np.max, 'warnme')
ow.log_variable("pwl_cost", "points", eval_function=cost_logging)
ow.remove_log_variable("res_bus", "vm_pu")
ow.remove_log_variable("res_line", "loading_percent")
ts.run_timeseries(net, verbose=False)
p_sgen = ow.output["res_sgen.p_mw"]
p_load = ow.output["res_load.p_mw"]
cost = ow.output["pwl_cost.points"]
assert not np.all(p_sgen.values == p_load.values)
assert cost.shape == (4, 4)
assert len(ow.np_results) == 3
def test_json_io_same_net(net_in, tmp_path):
control.ConstControl(net_in, 'load', 'p_mw', 0)
s = pp.to_json(net_in)
net1 = pp.from_json_string(s)
assert isinstance(net1.controller.object.at[0], control.ConstControl)
filename = os.path.abspath(str(tmp_path)) + "testfile.json"
pp.to_json(net_in, filename)
net2 = pp.from_json(filename)
assert isinstance(net2.controller.object.at[0], control.ConstControl)
def _prepare_grid(net):
"""
Writing the DataSources of sinks and sources to the net with ConstControl.
:param net: Previously created or loaded pandapipes network
:type net: pandapipesNet
:return: Prepared network for time series simulation
:rtype: pandapipesNet
"""
ds_sink, ds_source = _data_source()
control.ConstControl(net,
element='sink',
variable='mdot_kg_per_s',
element_index=net.sink.index.values,
data_source=ds_sink,
profile_name=net.sink.index.values.astype(str))
control.ConstControl(net,
element='source',
variable='mdot_kg_per_s',
element_index=net.source.index.values,
data_source=ds_source,
profile_name=net.source.index.values.astype(str))
def test_output_writer_log(simple_test_net):
net = simple_test_net
# timeseries data
df = pd.DataFrame([[15, 30, 2], [12, 27, 1.5], [7, 29, 2.1]])
ds = DFData(df)
# Create gen controller with datasource
ct.ConstControl(net,
element="load",
variable="p_mw",
element_index=[0, 2],
data_source=ds,
profile_name=[0, 2])
# Create, add output and set outputwriter
ow = OutputWriter(net, output_path=tempfile.gettempdir())
ow.remove_log_variable("res_bus")
orig_index = [0, 1]
ow.log_variable("res_bus", "vm_pu", orig_index)
ow.log_variable("res_sgen", "p_mw")
ow.log_variable("res_sgen", "q_mvar")
# Run timeseries
run_timeseries(net, time_steps=range(2), verbose=False)
# --- double logged variables handling
ow2 = copy.deepcopy(ow)
new_idx = 2
ow2.log_variable("res_bus", "vm_pu", new_idx, eval_name="test")
run_timeseries(net, time_steps=range(2), output_writer=ow2, verbose=False)
assert all(ow2.output["res_bus.vm_pu"].columns == orig_index + [new_idx])
# Todo: This test makes no sense if res_bus is logged by default
# ow3 = copy.deepcopy(ow)
# new_idx = [2, 3]
# ow3.log_variable("res_bus", "vm_pu", new_idx)
# run_timeseries(net, time_steps=range(2), output_writer=ow3)
# assert all(ow3.output["res_bus.vm_pu"].columns == orig_index + new_idx)
ow4 = copy.deepcopy(ow)
new_idx = [2, 4]
ow4.log_variable("res_bus", "vm_pu", new_idx, eval_name=["test1", "test2"])
run_timeseries(net, time_steps=range(2), output_writer=ow4, verbose=False)
assert all(ow4.output["res_bus.vm_pu"].columns == orig_index + new_idx)
def release_control_test_network():
# empty net
net = pp.create_empty_network("net", add_stdtypes=False)
# fluid
pp.create_fluid_from_lib(net, "water", overwrite=True)
# junctions
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 0", index=None, in_service=True,
type="junction", geodata=None)
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 1")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 2")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 3")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 4")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 5")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 6")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 7")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 8")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 9")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 10")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 11")
pp.create_junction(net, pn_bar=3, tfluid_k=293, height_m=0, name="Junction 12")
# pipes
pp.create_pipe_from_parameters(net, from_junction=0, to_junction=8, length_km=3, diameter_m=0.01, k_mm=1,
loss_coefficient=0, sections=10, alpha_w_per_m2k=10, text_k=293,
qext_w=0., name="Pipe 0", index=None, geodata=None, in_service=True, type="pipe")
pp.create_pipe_from_parameters(net, 9, 2, length_km=6, diameter_m=0.075, k_mm=.1, sections=10,
alpha_w_per_m2k=3,
name="Pipe 1")
pp.create_pipe_from_parameters(net, 2, 12, length_km=5, diameter_m=0.06, k_mm=.1, sections=10,
alpha_w_per_m2k=20,
name="Pipe 2")
pp.create_pipe_from_parameters(net, 4, 12, length_km=0.1, diameter_m=0.07, k_mm=.1, sections=10,
alpha_w_per_m2k=2,
name="Pipe 3")
pp.create_pipe_from_parameters(net, 5, 3, length_km=1, diameter_m=0.09, k_mm=.1, sections=10, alpha_w_per_m2k=3,
name="Pipe 4")
pp.create_pipe_from_parameters(net, 4, 11, length_km=2.5, diameter_m=0.08, k_mm=.1, sections=10,
alpha_w_per_m2k=15,
name="Pipe 5")
pp.create_pipe_from_parameters(net, 7, 6, length_km=4.5, diameter_m=0.085, k_mm=.1, sections=10,
alpha_w_per_m2k=2.5, name="Pipe 6")
pp.create_pipe_from_parameters(net, 1, 7, length_km=4, diameter_m=0.03, k_mm=.1, sections=10, alpha_w_per_m2k=1,
name="Pipe 7")
# external grids
pp.create_ext_grid(net, junction=0, p_bar=3, t_k=300, name="External Grid 0", in_service=True, index=None,
type="pt")
pp.create_ext_grid(net, 1, p_bar=5, t_k=350, name="External Grid 1", type="pt")
# sinks
pp.create_sink(net, junction=2, mdot_kg_per_s=0.2, scaling=1., name="Sink 0", index=None, in_service=True,
type="sink")
pp.create_sink(net, 3, mdot_kg_per_s=0.1, name="Sink 1")
pp.create_sink(net, 4, mdot_kg_per_s=0.5, name="Sink 2")
pp.create_sink(net, 5, mdot_kg_per_s=0.07, name="Sink 3")
pp.create_sink(net, 6, mdot_kg_per_s=0.09, name="Sink 4")
pp.create_sink(net, 7, mdot_kg_per_s=0.1, name="Sink 5")
# sources
pp.create_source(net, junction=8, mdot_kg_per_s=0.1, scaling=1., name="Source 0", index=None, in_service=True,
type="source")
pp.create_source(net, junction=9, mdot_kg_per_s=0.03, name="Source 1")
pp.create_source(net, junction=10, mdot_kg_per_s=0.04, name="Source 2")
pp.create_source(net, junction=11, mdot_kg_per_s=0.09, name="Source 3")
# valves
pp.create_valve(net, from_junction=8, to_junction=9, diameter_m=0.1, opened=True, loss_coefficient=0,
name="Valve 0", index=None, type="valve")
pp.create_valve(net, 9, 4, diameter_m=0.05, opened=True, name="Valve 1")
# pump
pp.create_pump_from_parameters(net, from_junction=8, to_junction=3, new_std_type_name="Pump",
pressure_list=[6.1, 5.8, 4],
flowrate_list=[0, 19, 83], reg_polynomial_degree=2,
poly_coefficents=None, name=None, index=None, in_service=True,
type="pump")
# circulation pump mass
pp.create_circ_pump_const_mass_flow(net, from_junction=3, to_junction=4, p_bar=6, mdot_kg_per_s=1,
t_k=290, name="Circ. Pump Mass", index=None, in_service=True,
type="pt")
# circulation pump pressure
pp.create_circ_pump_const_pressure(net, from_junction=11, to_junction=5, p_bar=5, plift_bar=2,
t_k=290, name="Circ. Pump Pressure", index=None, in_service=True, type="pt")
# heat exchanger
pp.create_heat_exchanger(net, from_junction=10, to_junction=6, diameter_m=0.08, qext_w=50, loss_coefficient=0,
name="Heat Exchanger 0", index=None, in_service=True, type="heat_exchanger")
pp.create_heat_exchanger(net, from_junction=4, to_junction=10, diameter_m=0.08, qext_w=28000,
loss_coefficient=0,
name="Heat Exchanger 1", index=None, in_service=True, type="heat_exchanger")
# time series
profiles_sink = pd.read_csv(os.path.join(pp_dir, 'test', 'api', 'release_cycle',
'release_control_test_sink_profiles.csv'), index_col=0)
profiles_source = pd.read_csv(os.path.join(pp_dir, 'test', 'api', 'release_cycle',
'release_control_test_source_profiles.csv'), index_col=0)
ds_sink = DFData(profiles_sink)
ds_source = DFData(profiles_source)
const_sink = control.ConstControl(net, element='sink', variable='mdot_kg_per_s',
element_index=net.sink.index.values, data_source=ds_sink,
profile_name=net.sink.index.values.astype(str))
const_source = control.ConstControl(net, element='source', variable='mdot_kg_per_s',
element_index=net.source.index.values,
data_source=ds_source,
profile_name=net.source.index.values.astype(str))
const_sink.initial_run = False
const_source.initial_run = False
pp.pipeflow(net)
pp.to_json(net, os.path.join(path, 'example_%s.json' % pp.__version__))
return net
# load a pandapower network
net = nw.mv_oberrhein(scenario='generation')
# number of time steps
n_ts = 95
# load your timeseries from a file (here csv file)
# df = pd.read_csv("sgen_timeseries.csv")
# or create a DataFrame with some random time series as an example
df = pd.DataFrame(np.random.normal(1., 0.1, size=(n_ts, len(net.sgen.index))),
index=list(range(n_ts)), columns=net.sgen.index) * net.sgen.p_mw.values
# create the data source from it
ds = DFData(df)
# initialising ConstControl controller to update values of the regenerative generators ("sgen" elements)
# the element_index specifies which elements to update (here all sgens in the net since net.sgen.index is passed)
# the controlled variable is "p_mw"
# the profile_name are the columns in the csv file (here this is also equal to the sgen indices 0-N )
const_sgen = control.ConstControl(net, element='sgen', element_index=net.sgen.index,
variable='p_mw', data_source=ds, profile_name=net.sgen.index)
# do the same for loads
# df = pd.read_csv("load_timeseries.csv")
# create a DataFrame with some random time series as an example
df = pd.DataFrame(np.random.normal(1., 0.1, size=(n_ts, len(net.load.index))),
index=list(range(n_ts)), columns=net.load.index) * net.load.p_mw.values
ds = DFData(df)
const_load = control.ConstControl(net, element='load', element_index=net.load.index,
variable='p_mw', data_source=ds, profile_name=net.load.index)
# starting the timeseries simulation for one day -> 96 15 min values.
timeseries.run_timeseries(net,numba=False)
