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"] '''