def test_dcline_dispatch2(dcline_net):
net = dcline_net
pp.create_polynomial_cost(net, 0, "ext_grid", array([.08, 0]))
pp.create_polynomial_cost(net, 1, "ext_grid", array([.1, 0]))
net.bus["max_vm_pu"] = 2
net.bus["min_vm_pu"] = 0 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net)
consistency_checks(net, rtol=1e-3)
consistency_checks(net, rtol=1e-3)
rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \
(net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100
assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values)
p_eg_expect = array([-8.21525358e+05, -5.43498903e-02])
q_eg_expect = array([7787.55852923, 21048.59213887])
assert allclose(net.res_ext_grid.p_kw.values, p_eg_expect)
assert allclose(net.res_ext_grid.q_kvar.values, q_eg_expect)
p_from_expect = array([813573.88366999])
q_from_expect = array([-26446.0473644])
assert allclose(net.res_dcline.p_from_kw.values, p_from_expect)
assert allclose(net.res_dcline.q_from_kvar.values, q_from_expect)
p_to_expect = array([-805023.64719801])
q_to_expect = array([-21736.31196315])
assert allclose(net.res_dcline.p_to_kw.values, p_to_expect)
assert allclose(net.res_dcline.q_to_kvar.values, q_to_expect)
def test_trafo3w_loading():
net = pp.create_empty_network()
b1, b2, l1 = add_grid_connection(net, vn_kv=110.)
b3 = pp.create_bus(net, vn_kv=20.)
b4 = pp.create_bus(net, vn_kv=10.)
tidx = pp.create_transformer3w(net,
b2,
b3,
b4,
std_type='63/25/38 MVA 110/20/10 kV',
max_loading_percent=120)
pp.create_load(net, b3, 5e3, controllable=False)
id = pp.create_load(net,
b4,
5e3,
controllable=True,
max_p_kw=5e4,
min_p_kw=0,
min_q_kvar=-1e9,
max_q_kvar=1e9)
pp.create_polynomial_cost(net, id, "load", np.array([-1, 0]))
#pp.create_xward(net, b4, 1000, 1000, 1000, 1000, 0.1, 0.1, 1.0)
net.trafo3w.shift_lv_degree.at[tidx] = 120
net.trafo3w.shift_mv_degree.at[tidx] = 80
# pp.runopp(net, calculate_voltage_angles = True) >> Doesn't converge
for init in ["pf", "flat"]:
pp.runopp(net,
calculate_voltage_angles=False,
verbose=False,
init=init)
assert net["OPF_converged"]
assert abs(net.res_trafo3w.loading_percent.values - 120) < 1e-3
def test_cost_pol_q():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_sgen(net, 1, p_kw=-100, controllable=True, max_p_kw=-5, min_p_kw=-150, max_q_kvar=50,
min_q_kvar=-50)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_kw=20, controllable=False)
pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876,
c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
pp.create_polynomial_cost(net, 0, "sgen", np.array([0, -1, 0]), type="q")
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert abs(net.res_cost + (net.res_sgen.q_kvar.values)) < 1e-2
net.polynomial_cost.c.at[0] = np.array([[1, 0, 0]])
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert abs(net.res_cost - net.res_sgen.q_kvar.values**2) < 1e-5
def create_nodes(net, remote, mode='udp'):
# Create remote agents of type NetworkLoad
for i in range(len(net.load.index)):
node = sim.create_node(ntype='load',
addr='{}:{}'.format(address, next(port)),
mode=mode)
node.update_measure_period = 1
node.report_measure_period = 1
measure_queues[node.local] = Queue(maxsize=1)
node.update_measure_cb = allocation_updated
node.joined_callback = joined_network
addr_to_name[node.local] = net.load['name'][i]
if 'PV' in net.load['name'][i]:
net.load['controllable'][i] = True
net.load['min_p_kw'][i] = -30 # 30kW max production for each PV
net.load['max_p_kw'][i] = 0
net.load['min_q_kvar'][i] = 0
net.load['max_q_kvar'][i] = 0
pp.create_polynomial_cost(net, i, 'load', np.array([1, 0]))
net.load['name'][i] = "{}".format(node.local)
nodes.append(node)
for node in nodes:
node.run()
packet = Packet('join_ack', src=allocator.local, dst=node.local)
node.handle_receive(packet)
return nodes
def test_contingency_sgen(base_net):
net = base_net
pp.create_sgen(net,
1,
p_kw=-100,
q_kvar=0,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=50,
min_q_kvar=-50)
# pwl costs
# maximize the sgen feed in by using a positive cost slope
# using a slope of 1
# | /
# | /
# | /
# |/
#-------------------------------------------
# p_min_kw /|
# / |
# / |
pp.create_piecewise_linear_cost(
net, 0, "sgen",
array([[net.sgen.min_p_kw.at[0], net.sgen.min_p_kw.at[0]], [0, 0]]))
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0]) < 1e-5
# minimize the sgen feed in by using a positive cost slope
# using a slope of 1
# \ |
# \ |
# \ |
# \|
#-------------------------------------------
# p_min_kw |\
# | \
# | \
net.piecewise_linear_cost.f.at[0] *= -1
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0] * -1) < 1e-5
try:
net.piecewise_linear_cost = net.piecewise_linear_cost.drop(index=0)
except:
net.piecewise_linear_cost = net.piecewise_linear_cost.drop(0)
# first using a positive slope as in the case above
pp.create_polynomial_cost(net, 0, "sgen", array([1, 0]))
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0]) < 1e-5
# negative slope as in the case above
net.polynomial_cost.c.at[0] *= -1
pp.runopp(net)
assert abs(net.res_cost - net.res_sgen.p_kw.at[0] * -1) < 1e-5
def test_simplest_voltage():
""" Testing a very simple network without transformer for voltage
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_gen(net,
1,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=50,
min_q_kvar=-50)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_kw=20, controllable=False)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100)
pp.create_polynomial_cost(net, 0, "gen", np.array([100, 0]))
# run OPF
for init in ["pf", "flat"]:
pp.runopp(net, verbose=False, init=init)
assert net["OPF_converged"]
# check and assert result
logger.debug("test_simplest_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_ext_grid:\n%s" % net.res_ext_grid)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
pp.runopp(net, verbose=False, check_connectivity=True)
assert net["OPF_converged"]
# check and assert result
logger.debug("test_simplest_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_ext_grid:\n%s" % net.res_ext_grid)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
def test_dcopf_poly(simple_opf_test_net):
net = simple_opf_test_net
pp.create_polynomial_cost(net, 0, "gen", np.array([100, 0]))
# run OPF
pp.rundcopp(net, verbose=False)
# check and assert result
logger.debug("test_simplest_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_ext_grid:\n%s" % net.res_ext_grid)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert abs(100 * net.res_gen.p_kw.values - net.res_cost) < 1e-3
def test_opf_poly(simple_opf_test_net):
net = simple_opf_test_net
pp.create_polynomial_cost(net, 0, "gen", np.array([100, 0]))
# run OPF
for init in ["pf", "flat"]:
pp.runopp(net, verbose=False, init=init)
assert net["OPF_converged"]
# check and assert result
logger.debug("test_simplest_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_ext_grid:\n%s" % net.res_ext_grid)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert abs(100 * net.res_gen.p_kw.values - net.res_cost) < 1e-3
def test_dcline_dispatch3(dcline_net):
net = dcline_net
pp.create_polynomial_cost(net, 0, "dcline", array([1, 0]))
net.bus["max_vm_pu"] = 2 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net)
consistency_checks(net, rtol=1e-3)
consistency_checks(net, rtol=1e-3)
rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \
(net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100
assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values)
assert abs(net.res_dcline.p_from_kw.values - net.res_cost) < 1e-3
def test_some_sgens_not_controllable():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# create net
net = nw.create_cigre_network_mv(with_der="pv_wind")
net.bus["max_vm_pu"] = 1.1
net.bus["min_vm_pu"] = 0.9
net.line["max_loading_percent"] = 200
net.trafo["max_loading_percent"] = 100
net.sgen["min_p_kw"] = -net.sgen.sn_kva
net.sgen["max_p_kw"] = 0
net.sgen["max_q_kvar"] = 10
net.sgen["min_q_kvar"] = -10
net.sgen["controllable"] = 1
net.load["controllable"] = 0
net.sgen.controllable[net.sgen.bus == 4] = False
net.sgen.controllable[net.sgen.bus == 6] = False
net.sgen.controllable[net.sgen.bus == 8] = False
net.sgen.controllable[net.sgen.bus == 9] = False
for sgen_idx, row in net["sgen"].iterrows():
cost_sgen = pp.create_polynomial_cost(net, sgen_idx, 'sgen',
np.array([1, 0]))
net.polynomial_cost.c.at[cost_sgen] = np.array([[0.1, 0]])
# run OPF
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
# check if p_kw of non conrollable sgens are unchanged
assert np.allclose(net.res_sgen.p_kw[net.sgen.controllable == False],
net.sgen.p_kw[net.sgen.controllable == False])
assert not np.allclose(net.res_sgen.p_kw[net.sgen.controllable == True],
net.sgen.p_kw[net.sgen.controllable == True])
def test_no_controllables(simple_opf_test_net):
# was ist das problwem an diesem fall und wie fange ich es ab?
net = simple_opf_test_net
net.gen.controllable = False
# pp.runopp(net)
# net.gen = net.gen.drop(index=0)
pp.create_polynomial_cost(net, 0, "gen", np.array([0, -2, 0]))
pp.create_polynomial_cost(net, 0, "load", np.array([0, 1, 0]))
pp.runopp(net)
# def test_controllables_default():
# """ Testing sgens/gens/loads with no defined controllable parameter """
# # boundaries
# vm_max = 1.1
# #todo
# vm_min = 0.9
# max_line_loading_percent = 100
#9
# # create network
# net = pp.create_empty_network()
# b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
# b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
#
# pp.create_line(net, b1, b2, length_km=5, std_type="NAYY 4x50 SE",
# max_loading_percent=max_line_loading_percent)
#
# # test elements static
# pp.create_ext_grid(net, b2)
# pp.create_load(net, b1, p_kw=7.5, max_p_kw=10, min_p_kw=0,
# max_q_kvar=2.5, min_q_kvar=-2.5)
# net.load["controllable"] = False
# # load should default to controllable =False
# # pp.create_sgen(net, b1, p_kw=-25, max_p_kw=-10, min_p_kw=-25,
# # max_q_kvar=25, min_q_kvar=-25)
# # # sgen should default to controllable =True
# # pp.create_gen(net, b1, p_kw=-25, max_p_kw=-10, min_p_kw=-25,
# # max_q_kvar=25, min_q_kvar=-25)
# # # gen should default to controllable =True
#
# # costs
# pp.create_polynomial_cost(net, 0, "ext_grid", np.array([0,-3, 0]))
# pp.create_polynomial_cost(net, 0, "load", np.array([0, 1, 0]))
# pp.create_polynomial_cost(net, 0, "sgen", np.array([0, 2, 0]))
# pp.create_polynomial_cost(net, 0, "gen", np.array([0, 2, 0]))
pp.runopp(net, verbose=True)
assert net["OPF_converged"]
def test_cost_mixed():
""" Testing a very simple network for the resulting cost value
constraints with OPF """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_gen(net, 1, p_kw=-100, controllable=True, max_p_kw=-5, min_p_kw=-150, max_q_kvar=50,
min_q_kvar=-50)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_kw=20, controllable=False, max_q_kvar=50, max_p_kw=100, min_p_kw=50,
min_q_kvar=-50)
pp.create_line_from_parameters(net, 0, 1, 50, name="line2", r_ohm_per_km=0.876,
c_nf_per_km=260.0, max_i_ka=0.123, x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
# testing some combinations
pp.create_polynomial_cost(net, 0, "gen", np.array([0, 1, 0]))
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost == - net.res_gen.p_kw.values
net.polynomial_cost.c.at[0] = np.array([[1, 0, 0]])
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - net.res_gen.p_kw.values**2 < 1e-5
net.polynomial_cost.c.at[0] = np.array([[1, 0, 1]])
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost - net.res_gen.p_kw.values**2 - 1 < 1e-5
net.load.controllable.at[0] = True
pp.runopp(net, verbose=False)
assert net.res_cost - net.res_gen.p_kw.values ** 2 - 1 < 1e-5
pp.create_piecewise_linear_cost(net, 0, "load", np.array([[0, 0], [100, 100]]), type="p")
pp.runopp(net, verbose=False)
assert net.res_cost - net.res_gen.p_kw.values ** 2 - 1 - net.res_load.p_kw.values < 1e-5
def _create_costs(net, ppc, gen_lookup, type, idx):
if ppc['gencost'][idx, 0] == 1:
if not len(ppc['gencost'][idx, 4:]) == 2*ppc['gencost'][idx, 3]:
logger.error("In gencost line %s, the number n does not fit to the number of values" %
idx)
pp.create_piecewise_linear_cost(net, gen_lookup.element.at[idx],
gen_lookup.element_type.at[idx],
ppc['gencost'][idx, 4:], type)
elif ppc['gencost'][idx, 0] == 2:
if len(ppc['gencost'][idx, 4:]) == ppc['gencost'][idx, 3]:
n = len(ppc['gencost'][idx, 4:])
values = ppc['gencost'][idx, 4:] / power(1e3, array(range(n))[::-1])
else:
logger.error("In gencost line %s, the number n does not fit to the number of values" %
idx)
pp.create_polynomial_cost(net, gen_lookup.element.at[idx], gen_lookup.element_type.at[idx],
values, type)
else:
logger.info("Cost mode of gencost line %s is unknown." % idx)
def test_mixed_p_q_pol():
vm_max = 1.05
vm_min = 0.95
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_gen(net,
1,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=50,
min_q_kvar=-50)
pp.create_ext_grid(net, 0)
pp.create_load(net,
1,
p_kw=20,
controllable=False,
max_q_kvar=50,
max_p_kw=100,
min_p_kw=50,
min_q_kvar=-50)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100 * 690)
# testing some combinations
pp.create_polynomial_cost(net, 0, "gen", np.array([0, -1, 0]))
pp.create_polynomial_cost(net, 0, "gen", np.array([0, -1, 0]), type="q")
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
assert net.res_cost == -net.res_gen.p_kw.values + net.res_gen.q_kvar.values
def test_dcopf():
# create net
net = pp.create_empty_network()
pp.create_bus(net, vn_kv=10.)
pp.create_bus(net, vn_kv=.4)
pp.create_gen(net,
1,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=50,
min_q_kvar=-50)
pp.create_ext_grid(net, 0)
pp.create_load(net, 1, p_kw=20, controllable=False)
pp.create_line_from_parameters(net,
0,
1,
50,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100)
pp.create_polynomial_cost(net, 0, "gen", array([-100, 0]))
# run OPF
pp.rundcopp(net, verbose=False)
assert net["OPF_converged"]
# check and assert result
logger.debug("test_simplest_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_ext_grid:\n%s" % net.res_ext_grid)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert abs(100 * net.res_gen.p_kw.values - net.res_cost) < 1e-3
def test_opf_no_controllables_vs_pf():
""" Comparing the calculation results of PF and OPF in a simple network with non-controllable
elements """
# boundaries
vm_max = 1.3
vm_min = 0.9
max_line_loading_percent = 100
# create network
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
pp.create_line(net,
b1,
b2,
length_km=5,
std_type="NAYY 4x50 SE",
max_loading_percent=max_line_loading_percent)
# test elements static
pp.create_ext_grid(net, b2)
pp.create_load(net, b1, p_kw=7.5, controllable=False)
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=False,
max_p_kw=-10,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
# testing cost assignment (for non-controllable elements - see Gitlab Issue #27)
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([0, 3, 0]))
pp.create_polynomial_cost(net, 0, "load", np.array([0, -3, 0]))
pp.create_polynomial_cost(net, 0, "sgen", np.array([0, 2, 0]))
# do calculations
pp.runopp(net, verbose=True)
assert net["OPF_converged"]
res_opf_line_loading = net.res_line.loading_percent
res_opf_bus_voltages = net.res_bus.vm_pu
pp.runpp(net, verbose=True)
assert net["converged"]
res_pf_line_loading = net.res_line.loading_percent
res_pf_bus_voltages = net.res_bus.vm_pu
# assert calculation behaviour
assert np.isclose(res_opf_line_loading, res_pf_line_loading).all()
assert np.isclose(res_opf_bus_voltages, res_pf_bus_voltages).all()
min_p_kw=-200000,
max_p_kw=0,
min_q_kvar=-200000,
max_q_kvar=200000,
controllable=True)
pp.create_gen(net,
name='Brighton',
bus=4,
vm_pu=1,
p_kw=-600000,
min_p_kw=-600000,
max_p_kw=0,
min_q_kvar=-450000,
max_q_kvar=450000,
controllable=True)
pp.create_polynomial_cost(net, 0, 'ext_gen', np.array([0, 10 / 1000,
0])) #Brighton
pp.create_polynomial_cost(net, 0, 'gen', np.array([0, 14 / 1000, 0])) #Alta
pp.create_polynomial_cost(net, 1, 'gen', np.array([0, 15 / 1000,
0])) #Park City
pp.create_polynomial_cost(net, 2, 'gen', np.array([0, 30 / 1000,
0])) #Solitude
pp.create_polynomial_cost(net, 3, 'gen', np.array([0, 35 / 1000,
0])) #Sundancde
pp.create_polynomial_cost(net, 4, 'gen', np.array([0, 10 / 1000,
0])) #Sundancde
pp.create_line_from_parameters(net,
name='line1',
from_bus=0,
to_bus=1,
geodata=([0, 0], [25, 0]),
length_km=1,
def test_in_service_controllables():
""" Testing controllable but out of service elements behaviour """
# boundaries
vm_max = 1.1
vm_min = 0.9
max_line_loading_percent = 100
# create network
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
pp.create_line(net,
b1,
b2,
length_km=5,
std_type="NAYY 4x50 SE",
max_loading_percent=max_line_loading_percent)
# test elements static
pp.create_ext_grid(net, b2)
pp.create_load(net,
b1,
p_kw=7.5,
controllable=True,
max_p_kw=10,
min_p_kw=0,
max_q_kvar=2.5,
min_q_kvar=-2.5)
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=True,
max_p_kw=-10,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
# test elements
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_load(net,
b1,
p_kw=2.5,
controllable=True,
max_p_kw=2.5,
min_p_kw=0,
max_q_kvar=2.5,
min_q_kvar=-2.5)
# costs
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([0, 3, 0]))
pp.create_polynomial_cost(net, 0, "load", np.array([0, -1, 0]))
pp.create_polynomial_cost(net, 0, "sgen", np.array([0, 2, 0]))
pp.create_polynomial_cost(net, 1, "sgen", np.array([0, 1, 0]))
pp.create_polynomial_cost(net, 1, "load", np.array([0, -1, 0]))
net["sgen"].in_service.iloc[1] = False
net["load"].in_service.iloc[1] = False
pp.runopp(net, verbose=True)
assert net["OPF_converged"]
pp.create_line(net, bus3, bus4, length_km=50., std_type='149-AL1/24-ST1A 110.0', max_loading_percent=50) pp.create_line(net, bus4, bus2, length_km=40., std_type='149-AL1/24-ST1A 110.0', max_loading_percent=50) line = net.line #create loads pp.create_load(net, bus2, p_kw=60e3, controllable = False) pp.create_load(net, bus3, p_kw=70e3, controllable = False) pp.create_load(net, bus4, p_kw=10e3, controllable = False) load = net.load #create generators eg = pp.create_ext_grid(net, bus1) g0 = pp.create_gen(net, bus3, p_kw=-80e3, min_p_kw=-80e3, max_p_kw=0., vm_pu=1.01, controllable=True) g1 = pp.create_gen(net, bus4, p_kw=-100e3, min_p_kw=-100e3, max_p_kw=0., vm_pu=1.01, controllable=True) ext_grid = net.ext_grid gen = net.gen pp.create_polynomial_cost(net, 0, 'gen', array([-1e5, 0])) pp.create_polynomial_cost(net, 1, 'gen', array([-1e5, 0])) pp.runopp(net, verbose=True) res_gen = net.res_gen res_cost = net.res_cost res_ext_grid = net.res_ext_grid res_bus = net.res_bus res_trafo = net.res_trafo res_line = net.res_line
def test_storage_opf():
""" Testing a simple network with storage to ensure the correct behaviour
of the storage OPF-Functions """
# boundaries
vm_max = 1.1
vm_min = 0.9
max_line_loading_percent = 100
# create network
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
pp.create_line(net,
b1,
b2,
length_km=5,
std_type="NAYY 4x50 SE",
max_loading_percent=max_line_loading_percent)
# test elements static
pp.create_ext_grid(net, b2)
pp.create_load(net, b1, p_kw=7.5, controllable=False)
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=True,
max_p_kw=-10,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
# test elements
pp.create_storage(net,
b1,
p_kw=-25,
max_e_kwh=50,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_load(net,
b1,
p_kw=25,
controllable=True,
max_p_kw=25,
min_p_kw=0,
max_q_kvar=25,
min_q_kvar=-25)
# costs
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([0, -3, 0]))
pp.create_polynomial_cost(net, 0, "sgen", np.array([0, -2, 0]))
pp.create_polynomial_cost(net, 0, "storage", np.array([0, -1, 0]))
pp.create_polynomial_cost(net, 1, "sgen", np.array([0, -1, 0]))
pp.create_polynomial_cost(net, 1, "load", np.array([0, -3, 0]))
# test storage generator behaviour
net["storage"].in_service.iloc[0] = True
net["storage"].p_kw.iloc[0] = -25
net["sgen"].in_service.iloc[1] = False
net["load"].in_service.iloc[1] = False
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
res_stor_p_kw = net["res_storage"].p_kw.iloc[0]
res_stor_q_kvar = net["res_storage"].q_kvar.iloc[0]
res_cost_stor = net["res_cost"]
net["storage"].in_service.iloc[0] = False
net["storage"].p_kw.iloc[0] = -25
net["sgen"].in_service.iloc[1] = True
net["load"].in_service.iloc[1] = False
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
res_sgen_p_kw = net["res_sgen"].p_kw.iloc[1]
res_sgen_q_kvar = net["res_sgen"].q_kvar.iloc[1]
res_cost_sgen = net["res_cost"]
# assert storage generator behaviour
assert np.isclose(res_stor_p_kw, res_sgen_p_kw)
assert np.isclose(res_stor_q_kvar, res_sgen_q_kvar)
assert np.isclose(res_cost_stor, res_cost_sgen)
# test storage load behaviour
net["storage"].in_service.iloc[0] = True
net["storage"].p_kw.iloc[0] = 25
net["storage"].max_p_kw.iloc[0] = 25
net["storage"].min_p_kw.iloc[0] = 0
net["storage"].max_q_kvar.iloc[0] = 25
net["storage"].min_q_kvar.iloc[0] = -25
# gencost for storages: positive costs in pandapower per definition
# --> storage gencosts are similar to sgen gencosts (make_objective.py, l.128ff. and l.185ff.)
net["polynomial_cost"].c.iloc[2] = net["polynomial_cost"].c.iloc[4]
net["sgen"].in_service.iloc[1] = False
net["load"].in_service.iloc[1] = False
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
res_stor_p_kw = net["res_storage"].p_kw.iloc[0]
res_stor_q_kvar = net["res_storage"].q_kvar.iloc[0]
res_cost_stor = net["res_cost"]
net["storage"].in_service.iloc[0] = False
net["storage"].p_kw.iloc[0] = 25
net["sgen"].in_service.iloc[1] = False
net["load"].in_service.iloc[1] = True
pp.runopp(net, verbose=False)
assert net["OPF_converged"]
res_load_p_kw = net["res_load"].p_kw.iloc[1]
res_load_q_kvar = net["res_load"].q_kvar.iloc[1]
res_cost_load = net["res_cost"]
# assert storage load behaviour
assert np.isclose(res_stor_p_kw, res_load_p_kw)
assert np.isclose(res_stor_q_kvar, res_load_q_kvar)
assert np.isclose(res_cost_stor, res_cost_load)
def test_opf_varying_max_line_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# boundaries
vm_max = 1.5
vm_min = 0.5
max_trafo_loading = 800
max_line_loading = 13
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(
net,
0,
1,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
pfe_kw=0.11,
name=None,
in_service=True,
index=None,
max_loading_percent=max_trafo_loading)
pp.create_sgen(net,
3,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_sgen(net,
2,
p_kw=-100,
controllable=True,
max_p_kw=-5,
min_p_kw=-150,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_polynomial_cost(net, 0, "sgen", np.array([10, 0]))
pp.create_polynomial_cost(net, 1, "sgen", np.array([10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([-.1, 0]))
pp.create_line_from_parameters(net,
1,
2,
1,
name="line1",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.200,
x_ohm_per_km=0.1159876,
max_loading_percent=20)
pp.create_line_from_parameters(net,
1,
3,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.100,
x_ohm_per_km=0.1159876,
max_loading_percent=10)
# run OPF
pp.runopp(net, verbose=False, init="flat")
assert net["OPF_converged"]
assert sum(net["_ppc"]["branch"][:, 5] -
np.array([0.02771281 + 0.j, 0.00692820 + 0.j, 0.12800000 +
0.j])) < 1e-8
# assert and check result
logger.debug("test_opf_sgen_loading")
logger.debug("res_sgen:\n%s" % net.res_sgen)
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert net.res_line.loading_percent.at[0] - 20 < 1e-2
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert net.res_line.loading_percent.at[1] - 10 < 1e-2
def test_minimize_active_power_curtailment():
net = pp.create_empty_network()
# create buses
bus1 = pp.create_bus(net, vn_kv=220.)
bus2 = pp.create_bus(net, vn_kv=110.)
bus3 = pp.create_bus(net, vn_kv=110.)
bus4 = pp.create_bus(net, vn_kv=110.)
# create 220/110 kV transformer
pp.create_transformer(net, bus1, bus2, std_type="100 MVA 220/110 kV")
# create 110 kV lines
pp.create_line(net,
bus2,
bus3,
length_km=70.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus3,
bus4,
length_km=50.,
std_type='149-AL1/24-ST1A 110.0')
pp.create_line(net,
bus4,
bus2,
length_km=40.,
std_type='149-AL1/24-ST1A 110.0')
# create loads
pp.create_load(net, bus2, p_kw=60e3, controllable=False)
pp.create_load(net, bus3, p_kw=70e3, controllable=False)
pp.create_load(net, bus4, p_kw=10e3, controllable=False)
# create generators
pp.create_ext_grid(net, bus1)
pp.create_gen(net,
bus3,
p_kw=-80 * 1e3,
min_p_kw=-80e3,
max_p_kw=0,
vm_pu=1.01,
controllable=True)
pp.create_gen(net,
bus4,
p_kw=-100 * 1e3,
min_p_kw=-100e3,
max_p_kw=0,
vm_pu=1.01,
controllable=True)
net.trafo["max_loading_percent"] = 50
net.line["max_loading_percent"] = 50
net.bus["min_vm_pu"] = 1.0
net.bus["max_vm_pu"] = 1.02
pp.create_polynomial_cost(net, 0, "gen", array([-1e-5, 0]))
pp.create_polynomial_cost(net, 1, "gen", array([-1e-5, 0]))
pp.create_polynomial_cost(net, 0, "ext_grid", array([0, 0]))
pp.runopp(net, calculate_voltage_angles=True)
assert net["OPF_converged"]
assert allclose(net.res_bus.vm_pu.values,
array([1., 1.00000149, 1.01998544, 1.01999628]),
atol=1e-5)
assert allclose(net.res_bus.va_degree.values,
array([0., -0.7055226, 0.85974768, 2.24584537]),
atol=1e-5)
def test_opf_sgen_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# boundaries
vm_max = 1.5
vm_min = 0.5
max_trafo_loading = 800
max_line_loading = 13
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(
net,
0,
1,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
pfe_kw=0.11,
name=None,
in_service=True,
index=None,
max_loading_percent=max_trafo_loading)
pp.create_sgen(net,
3,
p_kw=-10,
controllable=True,
max_p_kw=-5,
min_p_kw=-15,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_polynomial_cost(net, 0, "sgen", np.array([-10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([.1, 0]))
pp.create_line_from_parameters(net,
1,
2,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=max_line_loading)
pp.create_line_from_parameters(net,
2,
3,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=max_line_loading)
# run OPF
for init in ["pf", "flat"]:
pp.runopp(net, verbose=False, init=init)
assert net["OPF_converged"]
# assert and check result
logger.debug("test_opf_sgen_loading")
logger.debug("res_sgen:\n%s" % net.res_sgen)
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert max(net.res_line.loading_percent) - max_line_loading < 1e-2
logger.debug("res_trafo.loading_percent:\n%s" %
net.res_trafo.loading_percent)
assert max(net.res_trafo.loading_percent) < max_trafo_loading
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
# check connectivity check
pp.runopp(net, verbose=False, check_connectivity=True)
def test_opf_gen_loading():
""" Testing a simple network with transformer for loading
constraints with OPF using a generator """
# wide open voltage boundaries to make sure they don't interfere with loading constraints
vm_max = 1.5
vm_min = 0.5
max_line_loading = 11
# create net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(net,
0,
1,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
pfe_kw=0.11,
name=None,
in_service=True,
index=None,
max_loading_percent=145)
pp.create_gen(net,
3,
p_kw=-10,
controllable=True,
max_p_kw=-5,
min_p_kw=-15,
max_q_kvar=50,
min_q_kvar=-50)
pp.create_polynomial_cost(net, 0, "gen", np.array([-10, 0]))
pp.create_ext_grid(net, 0)
pp.create_polynomial_cost(net, 0, "ext_grid", np.array([.1, 0]))
pp.create_line_from_parameters(net,
1,
2,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=max_line_loading)
pp.create_line_from_parameters(net,
2,
3,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=max_line_loading)
# run OPF
pp.runopp(net,
verbose=False,
OPF_VIOLATION=1e-1,
OUT_LIM_LINE=2,
PDIPM_GRADTOL=1e-10,
PDIPM_COMPTOL=1e-10,
PDIPM_COSTTOL=1e-10)
assert net["OPF_converged"]
# assert and check result
logger.debug("test_opf_gen_loading")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_line.loading_percent:\n%s" %
net.res_line.loading_percent)
assert max(net.res_line.loading_percent) < max_line_loading
logger.debug("res_trafo.loading_percent:\n%s" %
net.res_trafo.loading_percent)
assert max(net.res_trafo.loading_percent) < 145
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
def test_opf_gen_voltage():
""" Testing a simple network with transformer for voltage
constraints with OPF using a generator """
# boundaries:
vm_max = 1.05
vm_min = 0.95
# ceate net
net = pp.create_empty_network()
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=10.)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_bus(net, max_vm_pu=vm_max, min_vm_pu=vm_min, vn_kv=.4)
pp.create_transformer_from_parameters(net,
0,
1,
vsc_percent=3.75,
tp_max=2,
vn_lv_kv=0.4,
shift_degree=150,
tp_mid=0,
vn_hv_kv=10.0,
vscr_percent=2.8125,
tp_pos=0,
tp_side="hv",
tp_min=-2,
tp_st_percent=2.5,
i0_percent=0.68751,
sn_kva=16.0,
pfe_kw=0.11,
name=None,
in_service=True,
index=None,
max_loading_percent=200)
pp.create_gen(net,
3,
p_kw=-10,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=500,
min_q_kvar=-500)
pp.create_polynomial_cost(net, 0, "gen", np.array([10, 0]))
pp.create_ext_grid(net, 0)
pp.create_line_from_parameters(net,
1,
2,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100000)
pp.create_line_from_parameters(net,
2,
3,
1,
name="line2",
r_ohm_per_km=0.876,
c_nf_per_km=260.0,
max_i_ka=0.123,
x_ohm_per_km=0.1159876,
max_loading_percent=100000)
# run OPF
for init in ["pf", "flat"]:
pp.runopp(net, verbose=False, init=init)
assert net["OPF_converged"]
# check and assert result
logger.debug("test_opf_gen_voltage")
logger.debug("res_gen:\n%s" % net.res_gen)
logger.debug("res_bus.vm_pu: \n%s" % net.res_bus.vm_pu)
assert max(net.res_bus.vm_pu) < vm_max
assert min(net.res_bus.vm_pu) > vm_min
b5 = pp.create_bus(net, 380)
l1 = pp.create_line(net, b1, b2, 30, "490-AL1/64-ST1A 380.0")
l2 = pp.create_line(net, b3, b4, 20, "490-AL1/64-ST1A 380.0")
l3 = pp.create_line(net, b4, b5, 20, "490-AL1/64-ST1A 380.0")
dcl1 = pp.create_dcline(net, name="dc line", from_bus=b2, to_bus=b3, p_kw=0.2e6, loss_percent=1.0,
loss_kw=500, vm_from_pu=1.01, vm_to_pu=1.012, max_p_kw=1e6,
in_service=True)
eg1 = pp.create_ext_grid(net, b1, 1.02, max_p_kw=0.)
eg2 = pp.create_ext_grid(net, b5, 1.02, max_p_kw=0.)
l1 = pp.create_load(net, bus=b4, p_kw=800e3, controllable = False)
pp.runpp(net)
costeg0 = pp.create_polynomial_cost(net, 0, 'ext_grid', array([.1, 0]))
costeg1 = pp.create_polynomial_cost(net, 1, 'ext_grid', array([.08, 0]))
net.bus['max_vm_pu'] = 1.5
net.line['max_loading_percent'] = 1000
net.polynomial_cost.c.at[costeg0]= array([[0.08, 0]])
net.polynomial_cost.c.at[costeg1]= array([[0.1, 0]])
pp.runopp(net)
def test_contingency_load(base_net):
net = base_net
pp.create_load(net,
1,
p_kw=-100,
q_kvar=0,
controllable=True,
max_p_kw=150,
min_p_kw=5,
max_q_kvar=50,
min_q_kvar=-50)
# pwl costs
# minimze the load by using a positive cost slope
# using a slope of 1
# | /
# | /
# | /
# |/
# -------------------------------------------
# p_min_kw /|
# / |
# / |
pp.create_piecewise_linear_cost(
net, 1, "load",
array([[0, 0], [net.load.max_p_kw.at[1], net.load.max_p_kw.at[1]]]))
pp.runopp(net)
assert abs(net.res_cost - net.res_load.p_kw.at[1]) < 1e-5
# maximize the load in by using a negative cost slope
# using a slope of 1
# \ |
# \ |
# \ |
# \|
# -------------------------------------------
# p_min_kw |\
# | \
# | \
net.piecewise_linear_cost.f.at[0] *= -1
pp.runopp(net)
assert abs(net.res_cost - net.res_load.p_kw.at[1] * -1) < 1e-5
# poly costs
try:
net.piecewise_linear_cost = net.piecewise_linear_cost.drop(index=0)
except:
# legacy fix
net.piecewise_linear_cost = net.piecewise_linear_cost.drop(0)
# first using a positive slope as in the case above
pp.create_polynomial_cost(net, 1, "load", array([1, 0]))
pp.runopp(net)
assert abs(net.res_cost - net.res_load.p_kw.at[1]) < 1e-5
# negative slope as in the case above
net.polynomial_cost.c.at[0] *= -1
pp.runopp(net)
assert abs(net.res_cost - net.res_load.p_kw.at[1] * -1) < 1e-5
#create loads
pp.create_load(net, bus2, p_kw=60e3, controllable=False)
pp.create_load(net, bus3, p_kw=70e3, controllable=False)
pp.create_load(net, bus4, p_kw=10e3, controllable=False)
#create generators
eg = pp.create_ext_grid(net, bus1, min_p_kw=-1e9, max_p_kw=1e9)
g0 = pp.create_gen(net,
bus3,
p_kw=-80 * 1e3,
min_p_kw=-80e3,
max_p_kw=0,
vm_pu=1.01,
controllable=True)
g1 = pp.create_gen(net,
bus4,
p_kw=-100 * 1e3,
min_p_kw=-100e3,
max_p_kw=0,
vm_pu=1.01,
controllable=True)
costeg = pp.create_polynomial_cost(net, 0, 'ext_grid', np.array([-1, 0]))
costgen1 = pp.create_polynomial_cost(net, 0, 'gen', np.array([-1, 0]))
costgen2 = pp.create_polynomial_cost(net, 1, 'gen', np.array([-1, 0]))
runpm(net)
if net.OPF_converged:
from pandapower.test.consistency_checks import consistency_checks
consistency_checks(net)
def test_storage_opf():
""" Testing a simple network with storage to ensure the correct behaviour
of the storage OPF-Functions """
# boundaries
vm_max = 1.1
vm_min = 0.9
max_line_loading_percent = 100
# create network
net = pp.create_empty_network()
b1 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
b2 = pp.create_bus(net, vn_kv=0.4, max_vm_pu=vm_max, min_vm_pu=vm_min)
pp.create_line(net,
b1,
b2,
length_km=5,
std_type="NAYY 4x50 SE",
max_loading_percent=max_line_loading_percent)
# test elements static
pp.create_ext_grid(net, b2)
pp.create_load(net, b1, p_kw=7.5, controllable=False)
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=True,
max_p_kw=-10,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
# test elements
pp.create_storage(net,
b1,
p_kw=-25,
max_e_kwh=50,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_sgen(net,
b1,
p_kw=-25,
controllable=True,
max_p_kw=0,
min_p_kw=-25,
max_q_kvar=25,
min_q_kvar=-25)
pp.create_load(net,
b1,
p_kw=2.5,
controllable=True,
max_p_kw=2.5,
min_p_kw=0,
max_q_kvar=2.5,
min_q_kvar=-2.5)
# costs
pp.create_polynomial_cost(net, 0, "ext_grid", array([0, 3, 0]))
pp.create_polynomial_cost(net, 0, "load", array([0, -1, 0]))
pp.create_polynomial_cost(net, 0, "sgen", array([0, 2, 0]))
pp.create_polynomial_cost(net, 0, "storage", array([0, 1, 0]))
pp.create_polynomial_cost(net, 1, "sgen", array([0, 1, 0]))
pp.create_polynomial_cost(net, 1, "load", array([0, -1, 0]))
# test storage generator behaviour
net["storage"].in_service.iloc[0] = True
net["storage"].p_kw.iloc[0] = -25
net["sgen"].in_service.iloc[1] = False
net["load"].in_service.iloc[1] = False
pp.runopp(net, verbose=True)
#consistency_checks(net)
assert net["OPF_converged"]
'''
