df= pd.read_csv(r"C:\Users\Asus\Documents\GitHub\Gisele_MILP\cluster3_PS.csv") grid= pd.read_csv(r"C:\Users\Asus\Documents\GitHub\Gisele_MILP\connections_output.csv") SS=pd.DataFrame(df) for i in SS.index: if (df.loc[i]['Population'] == 0) | (df.loc[i]['PS'] == 1): SS.drop(i,inplace=True) ############################################## #creating Primary Substations pp.create_bus(net, name = "110 kV bar", vn_kv =110, type='b', index=0, geodata=(840689.518725477973931,8509568.724492659792304)) pp.create_bus(net, name = "20 kV bar", vn_kv =20, type='b',index=grid.at[0,"id1"], geodata=(840689.518725477973931,8509568.724492659792304)) ############################################## #creating Secondary Substations for i in SS.index: pp.create_bus(net, vn_kv=20, type='b',index= SS.at[i,"id"], geodata=(SS.at[i,"X"], SS.at[i,"Y"])) ############################################## #creating External Grid (Slack Bus) pp.create_ext_grid(net, 0, vm_pu = 1) ##############################################
def test_opf_sgen_voltage(): """ Testing a simple network with transformer for voltage constraints with OPF using a static generator """ # boundaries vm_max = 1.04 vm_min = 0.96 # 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=1000000) 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", array([-100, 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=1000000) 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=1000000) # run OPF pp.runopp(net, verbose=False) assert net["OPF_converged"] # assert and check result logger.debug("test_opf_sgen_voltage") logger.debug("res_sgen:\n%s" % net.res_sgen) 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
import pandapower as pp import pandapower.networks net = pp.create_empty_network() #Network Buses (Note: A substation can have multiple buses) bus1 = pp.create_bus(net, name="HV Busbar", vn_kv=110, type="b") bus2 = pp.create_bus(net, name="HV Busbar 2", vn_kv=110, type="b") bus3 = pp.create_bus(net, name="HV Transformer Bus", vn_kv=110, type="n") bus4 = pp.create_bus(net, name="MV Transformer Bus", vn_kv=20, type="n") bus5 = pp.create_bus(net, name="MV Main Bus", vn_kv=20, type="b") bus6 = pp.create_bus(net, name="MV Bus 1", vn_kv=20, type="b") bus7 = pp.create_bus(net, name="MV Bus 2", vn_kv=20, type="b") #Adding Transformers to the Network trafo1 = pp.create_transformer(net, bus3, bus4, name="110kV/20kV transformer", std_type="25 MVA 110/20 kV") #Lines line1 = pp.create_line(net, bus1, bus2, length_km=10.0, std_type="N2XS(FL)2Y 1x300 RM/35 64/110 kV") line2 = pp.create_line(net, bus5,
def example_simple(): """ Returns the simple example network from the pandapower tutorials. OUTPUT: net - simple example network EXAMPLE: >>> import pandapower.networks >>> net = pandapower.networks.example_simple() """ net = pp.create_empty_network() # create buses bus1 = pp.create_bus(net, name="HV Busbar", vn_kv=110., type="b") bus2 = pp.create_bus(net, name="HV Busbar 2", vn_kv=110., type="b") bus3 = pp.create_bus(net, name="HV Transformer Bus", vn_kv=110., type="n") bus4 = pp.create_bus(net, name="MV Transformer Bus", vn_kv=20., type="n") bus5 = pp.create_bus(net, name="MV Main Bus", vn_kv=20., type="b") bus6 = pp.create_bus(net, name="MV Bus 1", vn_kv=20., type="b") bus7 = pp.create_bus(net, name="MV Bus 2", vn_kv=20., type="b") # create external grid pp.create_ext_grid(net, bus1, vm_pu=1.02, va_degree=50) # create transformer pp.create_transformer(net, bus3, bus4, name="110kV/20kV transformer", std_type="25 MVA 110/20 kV") # create lines pp.create_line(net, bus1, bus2, length_km=10, std_type="N2XS(FL)2Y 1x300 RM/35 64/110 kV", name="Line 1") line2 = pp.create_line(net, bus5, bus6, length_km=2.0, std_type="NA2XS2Y 1x240 RM/25 12/20 kV", name="Line 2") line3 = pp.create_line(net, bus6, bus7, length_km=3.5, std_type="48-AL1/8-ST1A 20.0", name="Line 3") line4 = pp.create_line(net, bus7, bus5, length_km=2.5, std_type="NA2XS2Y 1x240 RM/25 12/20 kV", name="Line 4") # create bus-bus switches pp.create_switch(net, bus2, bus3, et="b", type="CB") pp.create_switch(net, bus4, bus5, et="b", type="CB") # create bus-line switches pp.create_switch(net, bus5, line2, et="l", type="LBS", closed=True) pp.create_switch(net, bus6, line2, et="l", type="LBS", closed=True) pp.create_switch(net, bus6, line3, et="l", type="LBS", closed=True) pp.create_switch(net, bus7, line3, et="l", type="LBS", closed=False) pp.create_switch(net, bus7, line4, et="l", type="LBS", closed=True) pp.create_switch(net, bus5, line4, et="l", type="LBS", closed=True) # create load pp.create_load(net, bus7, p_mw=2, q_mvar=4, scaling=0.6, name="load") # create generator pp.create_gen(net, bus6, p_mw=6, max_q_mvar=3, min_q_mvar=-3, vm_pu=1.03, name="generator") # create static generator pp.create_sgen(net, bus7, p_mw=2, q_mvar=-0.5, name="static generator") # create shunt pp.create_shunt(net, bus3, q_mvar=-0.96, p_mw=0, name='Shunt') return net
def test_pandapower_case(): # more complicated examples like # net = pandapower.networks.example_simple() # can be used once the import of e.g. switches is perfected # create empty net net = pp.create_empty_network() # create buses b1 = pp.create_bus(net, vn_kv=20.0, name="Bus 1") b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") # create bus elements pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=b3, p_mw=0.1, q_mvar=0.05, name="Load") # create branch elements pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE") # because of phase angles, need to init with DC pp.runpp(net, calculate_voltage_angles=True, init="dc") n = pypsa.Network() n.import_from_pandapower_net(net) # seed PF with LPF solution because of phase angle jumps n.lpf() n.pf(use_seed=True) # use same index for everything net.res_bus.index = net.bus.name.values net.res_line.index = net.line.name.values # compare bus angles equal(n.buses_t.v_ang.loc["now"] * 180 / np.pi, net.res_bus.va_degree) # compare bus voltage magnitudes equal(n.buses_t.v_mag_pu.loc["now"], net.res_bus.vm_pu) # compare bus active power (NB: pandapower uses load signs) equal(n.buses_t.p.loc["now"], -net.res_bus.p_mw) # compare bus active power (NB: pandapower uses load signs) equal(n.buses_t.q.loc["now"], -net.res_bus.q_mvar) # compare branch flows equal(n.lines_t.p0.loc["now"], net.res_line.p_from_mw) equal(n.lines_t.p1.loc["now"], net.res_line.p_to_mw) equal(n.lines_t.q0.loc["now"], net.res_line.q_from_mvar) equal(n.lines_t.q1.loc["now"], net.res_line.q_to_mvar) equal(n.transformers_t.p0.loc["now"], net.res_trafo.p_hv_mw) equal(n.transformers_t.p1.loc["now"], net.res_trafo.p_lv_mw) equal(n.transformers_t.q0.loc["now"], net.res_trafo.q_hv_mvar) equal(n.transformers_t.q1.loc["now"], net.res_trafo.q_lv_mvar)
def test_without_ext_grid(): net = pp.create_empty_network() min_vm_pu = 0.95 max_vm_pu = 1.05 # create buses bus1 = pp.create_bus(net, vn_kv=220., geodata=(5, 9)) bus2 = pp.create_bus(net, vn_kv=110., geodata=(6, 10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus3 = pp.create_bus(net, vn_kv=110., geodata=(10, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus4 = pp.create_bus(net, vn_kv=110., geodata=(8, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus5 = pp.create_bus(net, vn_kv=110., geodata=(6, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) # create 220/110/110 kV 3W-transformer pp.create_transformer3w_from_parameters(net, bus1, bus2, bus5, vn_hv_kv=220, vn_mv_kv=110, vn_lv_kv=110, vk_hv_percent=10., vk_mv_percent=10., vk_lv_percent=10., vkr_hv_percent=0.5, vkr_mv_percent=0.5, vkr_lv_percent=0.5, pfe_kw=100, i0_percent=0.1, shift_mv_degree=0, shift_lv_degree=0, sn_hv_mva=100, sn_mv_mva=50, sn_lv_mva=50) # 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') pp.create_line(net, bus4, bus5, length_km=30., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=60, controllable=False) pp.create_load(net, bus3, p_mw=70, controllable=False) pp.create_load(net, bus4, p_mw=10, controllable=False) # create generators g1 = pp.create_gen(net, bus1, p_mw=40, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, slack=True, min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1000) g2 = pp.create_gen(net, bus3, p_mw=40, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, vm_pu=1.01, min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu, max_p_mw=40.) pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=2000) g3 = pp.create_gen(net, bus4, p_mw=0.050, min_p_mw=0, min_q_mvar=-20, max_q_mvar=20, vm_pu=1.01, min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu, max_p_mw=0.05) pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3000) pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g2], 0, atol=1e-5, rtol=1e-5) assert np.isclose(net.res_gen.p_mw.at[g3], 0, atol=1e-5, rtol=1e-5) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3) net.trafo3w["max_loading_percent"] = 150. pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert 149. < net.res_trafo3w.loading_percent.values[0] < 150.01 assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3 + net.res_gen.p_mw.at[g2] * 2e3) pp.runpm_dc_opf(net) consistency_checks(net, rtol=1e-3, test_q=False) assert 149. < net.res_trafo3w.loading_percent.values[0] < 150.01 assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] * 1e3 + net.res_gen.p_mw.at[g2] * 2e3)
def test_3ph_isolated_nodes(): v_base = 110 # 110kV Base Voltage mva_base = 100 # 100 MVA net = pp.create_empty_network(sn_mva=mva_base) busn = pp.create_bus(net, vn_kv=v_base, name="busn", index=1) pp.create_bus(net, vn_kv=20., in_service=True, index=2, name="busx") busk = pp.create_bus(net, vn_kv=v_base, name="busk", index=5) busl = pp.create_bus(net, vn_kv=v_base, name="busl", index=6) pp.create_bus(net, vn_kv=20., in_service=False, index=3) busy = pp.create_bus(net, vn_kv=20., in_service=True, index=0, name="busy") pp.create_ext_grid(net, bus=busn, vm_pu=1.0, name="Grid Connection", s_sc_max_mva=5000, rx_max=0.1) net.ext_grid["r0x0_max"] = 0.1 net.ext_grid["x0x_max"] = 1.0 pp.create_std_type( net, { "r0_ohm_per_km": 0.0848, "x0_ohm_per_km": 0.4649556, "c0_nf_per_km": 230.6, "max_i_ka": 0.963, "r_ohm_per_km": 0.0212, "x_ohm_per_km": 0.1162389, "c_nf_per_km": 230 }, "example_type") # Loads on supplied buses pp.create_asymmetric_load(net, busk, p_a_mw=50, q_a_mvar=50, p_b_mw=10, q_b_mvar=15, p_c_mw=10, q_c_mvar=5) pp.create_load(net, bus=busl, p_mw=7, q_mvar=0.070, name="Load 1") # Loads on unsupplied buses pp.create_load(net, bus=busy, p_mw=70, q_mvar=70, name="Load Y") pp.create_line(net, from_bus=busn, to_bus=busk, length_km=50.0, std_type="example_type") pp.create_line(net, from_bus=busl, to_bus=busk, length_km=50.0, std_type="example_type") pp.add_zero_impedance_parameters(net) runpp_3ph_with_consistency_checks(net) assert net['converged'] assert np.allclose(net.res_bus_3ph.T[[0, 2, 3]].T[[ "vm_a_pu", "va_a_degree", "vm_b_pu", "va_b_degree", "vm_c_pu", "va_c_degree" ]], np.nan, equal_nan=True) assert np.allclose( net.res_bus_3ph.T[[0, 2, 3]].T[[ "p_a_mw", "q_a_mvar", "p_b_mw", "q_b_mvar", "p_c_mw", "q_c_mvar" ]], 0.0)
def _create_empty_network_with_transformer(trafotype, V_OS=10., V_US=0.4): """ Creates a Network with transformer and infeeder. The reference bus on the \ high-voltage side is called "Trafostation_OS". The bus on the low-voltage \ side is called "main_busbar". The voltage levels can be set manually and the transformer parameter can \ be set with "ti" """ pd_net = pp.create_empty_network() NFA2X4x70 = { "c_nf_per_km": 0, "r_ohm_per_km": 0.443, "x_ohm_per_km": 0.069, "max_i_ka": 0.270, "type": "ol", "q_mm2": 70 } NAYY4x50 = { "c_nf_per_km": 670, "r_ohm_per_km": 0.6417, "x_ohm_per_km": 0.084823, "max_i_ka": 0.141, "type": "cs", "q_mm2": 50 } NAYY4x150 = { "c_nf_per_km": 830, "r_ohm_per_km": 0.2067, "x_ohm_per_km": 0.08042478, "max_i_ka": 0.275, "type": "cs", "q_mm2": 150 } NAYY4x185 = { "c_nf_per_km": 830, "r_ohm_per_km": 0.165, "x_ohm_per_km": 0.08042478, "max_i_ka": 0.313, "type": "cs", "q_mm2": 185 } NYY4x35 = { "c_nf_per_km": 0, "r_ohm_per_km": 0.5240284, "x_ohm_per_km": 0.08513716, "max_i_ka": 0.156, "type": "cs", "q_mm2": 35 } pp.create_std_type(net=pd_net, data=NFA2X4x70, name="NFA2X 4x70", element="line") pp.create_std_type(net=pd_net, data=NAYY4x50, name="NAYY 4x50", element="line") pp.create_std_type(net=pd_net, data=NAYY4x150, name="NAYY 4x150", element="line") pp.create_std_type(net=pd_net, data=NAYY4x185, name="NAYY 4x185", element="line") pp.create_std_type(net=pd_net, data=NYY4x35, name="NYY 4x35", element="line") T100kVA = { "sn_kva": 100, "vn_hv_kv": 10, "vn_lv_kv": 0.4, "vsc_percent": 4, "vscr_percent": 1.2, "pfe_kw": 0.45, "i0_percent": 0.25, "shift_degree": 150, "vector_group": "Dyn5" } T160kVA = { "sn_kva": 160, "vn_hv_kv": 10, "vn_lv_kv": 0.4, "vsc_percent": 4, "vscr_percent": 1.2, "pfe_kw": 0.38, "i0_percent": 0.26, "shift_degree": 150, "vector_group": "Dyn5" } pp.create_std_type(net=pd_net, data=T100kVA, name="0.1 MVA 10/0.4 kV", element="trafo") pp.create_std_type(net=pd_net, data=T160kVA, name="0.16 MVA 10/0.4 kV", element="trafo") busnr1 = pp.create_bus(pd_net, name="Trafostation_OS", vn_kv=V_OS) pp.create_ext_grid(pd_net, bus=busnr1) main_busbar_nr = pp.create_bus(pd_net, name="main_busbar", vn_kv=V_US, type="b") pp.create_transformer(pd_net, hv_bus=busnr1, lv_bus=main_busbar_nr, std_type=trafotype, name="trafo 1") return pd_net, main_busbar_nr
def test_4bus_network(init, recycle): v_base = 110 # 110kV Base Voltage mva_base = 100 # 100 MVA net = pp.create_empty_network(sn_mva=mva_base) # ============================================================================= # Main Program # ============================================================================= busn = pp.create_bus(net, vn_kv=v_base, name="busn") busk = pp.create_bus(net, vn_kv=v_base, name="busk") busm = pp.create_bus(net, vn_kv=v_base, name="busm") busp = pp.create_bus(net, vn_kv=v_base, name="busp") pp.create_ext_grid(net, bus=busn, vm_pu=1.0, name="Grid Connection", s_sc_max_mva=5000, rx_max=0.1, r0x0_max=0.1, x0x_max=1.0) pp.create_std_type( net, { "r0_ohm_per_km": .154, "x0_ohm_per_km": 0.5277876, "c0_nf_per_km": 170.4, "max_i_ka": 0.741, "r_ohm_per_km": .0385, "x_ohm_per_km": 0.1319469, "c_nf_per_km": 170 }, "example_type3") pp.create_line(net, from_bus=busn, to_bus=busm, length_km=1.0, std_type="example_type3") pp.create_line(net, from_bus=busn, to_bus=busp, length_km=1.0, std_type="example_type3") pp.create_line_from_parameters(net, from_bus=busn, to_bus=busk, length_km=1.0, r0_ohm_per_km=.1005, x0_ohm_per_km=0.4900884, c0_nf_per_km=200.5, max_i_ka=0.89, r_ohm_per_km=.0251, x_ohm_per_km=0.1225221, c_nf_per_km=210) pp.create_line_from_parameters(net, from_bus=busk, to_bus=busm, length_km=1.0, r0_ohm_per_km=0.0848, x0_ohm_per_km=0.4649556, c0_nf_per_km=230.6, max_i_ka=0.963, r_ohm_per_km=0.0212, x_ohm_per_km=0.1162389, c_nf_per_km=230) pp.create_line_from_parameters(net, from_bus=busk, to_bus=busp, length_km=1.0, r0_ohm_per_km=.3048, x0_ohm_per_km=0.6031856, c0_nf_per_km=140.3, max_i_ka=0.531, r_ohm_per_km=.0762, x_ohm_per_km=0.1507964, c_nf_per_km=140) pp.add_zero_impedance_parameters(net) pp.create_asymmetric_load(net, busk, p_a_mw=50, q_a_mvar=20, p_b_mw=80, q_b_mvar=60, p_c_mw=20, q_c_mvar=5) pp.create_asymmetric_load(net, busm, p_a_mw=50, q_a_mvar=50, p_b_mw=10, q_b_mvar=15, p_c_mw=10, q_c_mvar=5) pp.create_asymmetric_load(net, busp, p_a_mw=50, q_a_mvar=20, p_b_mw=60, q_b_mvar=20, p_c_mw=10, q_c_mvar=5) runpp_3ph_with_consistency_checks(net, init=init, recycle=recycle) runpp_3ph_with_consistency_checks(net, init=init, recycle=recycle) assert net['converged'] bus_pp = np.abs(net.res_bus_3ph[[ 'vm_a_pu', 'vm_b_pu', 'vm_c_pu' ]][~np.isnan(net.res_bus_3ph.vm_a_pu)].values) bus_pf = np.abs( np.array([[0.98085729, 0.97711997, 1.04353786], [0.97828577, 0.97534651, 1.04470864], [0.97774307, 0.97648197, 1.04421233], [0.9780892, 0.97586805, 1.04471106]])) assert np.max(np.abs(bus_pp - bus_pf)) < 1e-8 line_pp = np.abs(net.res_line_3ph[[ 'i_a_from_ka', 'i_b_from_ka', 'i_c_from_ka', 'i_a_to_ka', 'i_b_to_ka', 'i_c_to_ka', 'p_a_from_mw', 'p_b_from_mw', 'p_c_from_mw', 'q_a_from_mvar', 'q_b_from_mvar', 'q_c_from_mvar', 'p_a_to_mw', 'p_b_to_mw', 'p_c_to_mw', 'q_a_to_mvar', 'q_b_to_mvar', 'q_c_to_mvar', 'loading_a_percent', 'loading_b_percent', 'loading_c_percent', 'loading_percent' ]].values) line_pf = np.abs( np.array([[ 0.98898804851, 0.68943734, 0.19848961, 0.99093993, 0.69146384, 0.19966503, 49.87434308, 33.86579548, 12.44659879, 36.16562613, 26.14426519, 4.25746428, -49.75842138, -33.90236497, -12.45155362, -36.19862688, -26.25675246, -4.50384238, 133.730100000000, 93.314960000000, 26.945350000000, 133.730100000000 ], [ 0.87075816277, 1.03463205, 0.19072622, 0.87210779, 1.03599167, 0.19188991, 49.59359423, 58.53676842, 11.97553941, 21.96967200, 26.37559958, 4.04458873, -49.47110289, -58.55284705, -11.98669516, -22.07474008, -26.34476811, -4.29078447, 117.693400000000, 139.809900000000, 25.896070000000, 139.809900000000 ], [ 0.95760407055, 1.14786582, 0.24829126, 0.95975383, 1.15028040, 0.24975553, 50.87938854, 57.53628873, 15.54470531, 31.13888557, 41.99378843, 5.39758513, -50.76249094, -57.56374777, -15.56099267, -31.28560646, -41.99056453, -5.69609575, 107.837500000000, 129.245000000000, 28.062420000000, 129.245000000000 ], [ 0.21780921494, 0.42795803, 0.03706412, 0.22229619, 0.42603286, 0.03771703, 0.23292404, -23.88471674, -2.45255095, 13.53037092, -11.49972060, 0.17971665, -0.24157862, 23.90236497, 2.45155361, -13.80137312, 11.25675247, -0.49615762, 23.083720000000, 44.440090000000, 3.916618000000, 44.440090000000 ], [ 0.03712221482, 0.10766244, 0.03093505, 0.03446871, 0.10500386, 0.03179428, 0.52956690, 1.44846452, -1.98645639, -2.24476446, -6.50971485, 0.51637910, -0.52889712, -1.44715295, 1.98669515, 2.07474008, 6.34476812, -0.70921554, 6.991001000000, 20.275410000000, 5.987624000000, 20.275410000000 ]])) assert np.max(np.abs(line_pp - line_pf)) < 1e-4
def test_3ph_two_bus_line_powerfactory(): net = pp.create_empty_network() b1 = pp.create_bus(net, vn_kv=0.4) b2 = pp.create_bus(net, vn_kv=0.4) pp.create_ext_grid(net, b1, vm_pu=1.0, s_sc_max_mva=10, rx_max=0.1) net.ext_grid["x0x_max"] = 1. net.ext_grid["r0x0_max"] = 0.1 pp.create_std_type( net, { "r_ohm_per_km": 0.1013, "x_ohm_per_km": 0.06911504, "c_nf_per_km": 690, "g_us_per_km": 0, "max_i_ka": 0.44, "c0_nf_per_km": 312.4, "r0_ohm_per_km": 0.4053, "x0_ohm_per_km": 0.2764602 }, "N2XRY 3x185sm 0.6/1kV") pp.create_line(net, b1, b2, 0.4, std_type="N2XRY 3x185sm 0.6/1kV") pp.add_zero_impedance_parameters(net) pp.create_load(net, b2, p_mw=0.010, q_mvar=0.010) pp.create_asymmetric_load(net, b2, p_a_mw=0.020, q_a_mvar=0.010, p_b_mw=0.015, q_b_mvar=0.005, p_c_mw=0.025, q_c_mvar=0.010) runpp_3ph_with_consistency_checks(net) assert net['converged'] bus_pp = np.abs(net.res_bus_3ph[['vm_a_pu', 'vm_b_pu', 'vm_c_pu']].values) bus_pf = np.abs( np.array([[0.99939853552, 1.0013885141, 0.99921580141], [0.97401782343, 0.98945593737, 0.96329605983]])) assert np.max(np.abs(bus_pp - bus_pf)) < 4e-6 line_pp = np.abs(net.res_line_3ph[[ 'i_a_from_ka', 'i_b_from_ka', 'i_c_from_ka', 'i_a_to_ka', 'i_b_to_ka', 'i_c_to_ka', 'p_a_from_mw', 'p_b_from_mw', 'p_c_from_mw', 'q_a_from_mvar', 'q_b_from_mvar', 'q_c_from_mvar', 'p_a_to_mw', 'p_b_to_mw', 'p_c_to_mw', 'q_a_to_mvar', 'q_b_to_mvar', 'q_c_to_mvar' ]].values) line_pf = np.abs( np.array([[ 0.11946088987, 0.08812337783, 0.14074226065, 0.1194708224, 0.088131567331, 0.14075063601, 0.023810539354, 0.01855791658, 0.029375192747, 0.013901720672, 0.008421814704, 0.013852398586, -0.023333142958, -0.018333405987, -0.028331643666, -0.013332756527, -0.008333413919, -0.013332422725 ]])) assert np.max(np.abs(line_pp - line_pf)) < 1e-5 line_load_pp = np.abs(net.res_line_3ph[[ 'loading_a_percent', 'loading_b_percent', 'loading_c_percent', 'loading_percent' ]].values) line_load_pf = np.abs(np.array([[27.1525, 20.0299, 31.98878, 31.98878]])) assert np.max(np.abs(line_load_pp - line_load_pf)) < 1e-2
if not np.allclose( result, res_trafo_i_ka, atol=tolerances[trafo_vector_group]): raise ValueError( "Incorrect results for vector group %s" % trafo_vector_group, res_trafo_i_ka, result) def check_results(net, trafo_vector_group, results): check_bus_voltages(net, results[0], trafo_vector_group) check_line_currents(net, results[1], trafo_vector_group) check_trafo_currents(net, results[2], trafo_vector_group) def make_nw(net, bushv, tap_ps, case, vector_group): b1 = pp.create_bus(net, bushv, zone=vector_group, index=pp.get_free_id(net.bus)) b2 = pp.create_bus(net, 0.4, zone=vector_group) b3 = pp.create_bus(net, 0.4, zone=vector_group) pp.create_ext_grid(net, b1, s_sc_max_mva=10000, rx_max=0.1, r0x0_max=0.1, x0x_max=1.0) pp.create_transformer_from_parameters(net, hv_bus=b1, lv_bus=b2, sn_mva=1.6, vn_hv_kv=10, vn_lv_kv=0.4,
def test_init_slack_with_multiple_transformers(): np.random.seed(123) net = pp.create_empty_network() pp.create_bus(net, 220, index=0) pp.create_bus(net, 110, index=1) pp.create_bus(net, 110, index=2) pp.create_bus(net, 110, index=3) pp.create_bus(net, 10, index=4) pp.create_bus(net, 10, index=5) pp.create_bus(net, 10, index=6) pp.create_bus(net, 10, index=7, in_service=False) pp.create_transformer(net, 3, 7, std_type="63 MVA 110/10 kV", in_service=False) pp.create_transformer(net, 3, 4, std_type="63 MVA 110/10 kV") pp.create_transformer(net, 0, 1, std_type="100 MVA 220/110 kV") pp.create_line(net, 1, 2, 2.0, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV") pp.create_line(net, 1, 3, 2.0, std_type="N2XS(FL)2Y 1x120 RM/35 64/110 kV") pp.create_line(net, 4, 5, 2.0, std_type="NA2XS2Y 1x95 RM/25 12/20 kV") pp.create_line(net, 5, 6, 2.0, std_type="NA2XS2Y 1x95 RM/25 12/20 kV") pp.create_load(net, 2, 5000, 3300) pp.create_load(net, 5, 900, 500) pp.create_load(net, 6, 700, 300) pp.create_ext_grid(net, bus=0, vm_pu=1.04, va_degree=10., name="Slack 220 kV") pp.runpp(net) for bus, row in net.res_bus[net.bus.in_service == True].iterrows(): pp.create_measurement(net, "v", "bus", row.vm_pu * r(0.01), 0.01, bus) if row.p_kw != 0.: continue pp.create_measurement(net, "p", "bus", -row.p_kw * r(), max(1.0, abs(0.03 * row.p_kw)), bus) pp.create_measurement(net, "q", "bus", -row.q_kvar * r(), max(1.0, abs(0.03 * row.q_kvar)), bus) pp.create_measurement(net, "p", "line", net.res_line.p_from_kw[0], 10., bus=1, element=0) pp.create_measurement(net, "q", "line", net.res_line.q_from_kvar[0], 10., bus=1, element=0) pp.create_measurement(net, "p", "line", net.res_line.p_from_kw[2], 10., bus=4, element=2) pp.create_measurement(net, "q", "line", net.res_line.q_from_kvar[2], 10., bus=4, element=2) pp.create_measurement(net, "p", "line", net.res_line.p_from_kw[3], 10., bus=5, element=3) pp.create_measurement(net, "q", "line", net.res_line.q_from_kvar[3], 10., bus=5, element=3) success = estimate(net, init='slack') diff_v = net.res_bus_est.vm_pu.values - np.asarray([ 1.044860374, 1.0425606695, 1.0423765983, 1.0425110929, 1.0412160717, 1.0294819221, 1.0244679562, np.nan ]) diff_delta = net.res_bus_est.va_degree.values - np.asarray([ 10., 9.5804972667, 9.5764432027, 9.5785762652, -140.5572134472, -140.5248734844, -140.5280590882, np.nan ]) assert success assert (np.nanmax(abs(diff_v)) < 1e-8) assert (np.nanmax(abs(diff_delta)) < 1e-8)
def test_3bus(): # 1. Create network net = pp.create_empty_network() pp.create_ext_grid(net, 0) pp.create_bus(net, name="bus1", vn_kv=1.) pp.create_bus(net, name="bus2", vn_kv=1.) pp.create_bus(net, name="bus3", vn_kv=1.) pp.create_line_from_parameters(net, 0, 1, 1, r_ohm_per_km=0.7, x_ohm_per_km=0.2, c_nf_per_km=0, max_i_ka=1) pp.create_line_from_parameters(net, 0, 2, 1, r_ohm_per_km=0.8, x_ohm_per_km=0.8, c_nf_per_km=0, max_i_ka=1) pp.create_line_from_parameters(net, 1, 2, 1, r_ohm_per_km=1, x_ohm_per_km=0.6, c_nf_per_km=0, max_i_ka=1) pp.create_measurement(net, "p", "line", -0.0011e3, 0.01e3, bus=0, element=0) # p12 pp.create_measurement(net, "q", "line", 0.024e3, 0.01e3, bus=0, element=0) # q12 pp.create_measurement(net, "p", "bus", 0.018e3, 0.01e3, bus=2) # p3 pp.create_measurement(net, "q", "bus", -0.1e3, 0.01e3, bus=2) # q3 pp.create_measurement(net, "v", "bus", 1.08, 0.05, 0) # u1 pp.create_measurement(net, "v", "bus", 1.015, 0.05, 2) # u3 # 2. Do state estimation success = estimate(net, init='flat') v_result = net.res_bus_est.vm_pu.values delta_result = net.res_bus_est.va_degree.values target_v = np.array([1.0627, 1.0589, 1.0317]) diff_v = target_v - v_result target_delta = np.array([0., 0.8677, 3.1381]) diff_delta = target_delta - delta_result assert success assert (np.nanmax(abs(diff_v)) < 1e-4) assert (np.nanmax(abs(diff_delta)) < 1e-4)
def test_3bus_with_2_slacks(): # load the net which already contains 3 buses net = load_3bus_network() # add the same net with different slack (no galvanic connection) # skip bus index 4 as further stability test pp.create_ext_grid(net, 5) pp.create_bus(net, name="bus5", vn_kv=1., index=5) pp.create_bus(net, name="bus6", vn_kv=1., index=6) pp.create_bus(net, name="bus7", vn_kv=1., index=7) pp.create_line_from_parameters(net, 5, 6, 1, r_ohm_per_km=.01, x_ohm_per_km=.03, c_nf_per_km=0., max_i_ka=1) pp.create_line_from_parameters(net, 5, 7, 1, r_ohm_per_km=.02, x_ohm_per_km=.05, c_nf_per_km=0., max_i_ka=1) pp.create_line_from_parameters(net, 6, 7, 1, r_ohm_per_km=.03, x_ohm_per_km=.08, c_nf_per_km=0., max_i_ka=1) pp.create_measurement(net, "v", "bus", 1.006, .004, bus=5) # V at bus 5 pp.create_measurement(net, "v", "bus", .968, .004, bus=6) # V at bus 6 pp.create_measurement(net, "p", "bus", -501, 10, 6) # P at bus 6 pp.create_measurement(net, "q", "bus", -286, 10, 6) # Q at bus 6 pp.create_measurement(net, "p", "line", 888, 8, 5, 3) # Pline (bus 1 -> bus 2) at bus 5 pp.create_measurement(net, "p", "line", 1173, 8, 5, 4) # Pline (bus 1 -> bus 3) at bus 5 pp.create_measurement(net, "q", "line", 568, 8, 5, 3) # Qline (bus 1 -> bus 2) at bus 5 pp.create_measurement(net, "q", "line", 663, 8, 5, 4) # Qline (bus 1 -> bus 3) at bus 5 # 2. Do state estimation success = estimate(net, init='flat', maximum_iterations=10) v_result = net.res_bus_est.vm_pu.values delta_result = net.res_bus_est.va_degree.values target_v = np.array( [0.9996, 0.9741, 0.9438, np.nan, 0.9996, 0.9741, 0.9438]) diff_v = target_v - v_result target_delta = np.array([ 0.0, -1.2475469989322963, -2.7457167371166862, np.nan, 0.0, -1.2475469989322963, -2.7457167371166862 ]) diff_delta = target_delta - delta_result assert success assert (np.nanmax(abs(diff_v)) < 1e-4) assert (np.nanmax(abs(diff_delta)) < 1e-4)
def test_pwl(): net = pp.create_empty_network() # create buses bus1 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1) bus2 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1) bus3 = pp.create_bus(net, vn_kv=110., min_vm_pu=0.9, max_vm_pu=1.1) # create 110 kV lines pp.create_line(net, bus1, bus2, length_km=50., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus2, bus3, length_km=50., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=80, controllable=False) # create generators g1 = pp.create_gen(net, bus1, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01, slack=True) g2 = pp.create_gen(net, bus3, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01) # net.gen["controllable"] = False pp.create_pwl_cost(net, g1, 'gen', [[0, 2, 2], [2, 80, 5]]) pp.create_pwl_cost(net, g2, 'gen', [[0, 2, 2], [2, 80, 5]]) pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.iloc[0], net.res_gen.p_mw.iloc[1]) assert np.isclose(net.res_gen.q_mvar.iloc[0], net.res_gen.q_mvar.iloc[1]) net.pwl_cost.drop(net.pwl_cost.index, inplace=True) g3 = pp.create_gen(net, bus1, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01) pp.create_pwl_cost(net, g1, 'gen', [[0, 2, 1.], [2, 80, 8.]]) pp.create_pwl_cost(net, g2, 'gen', [[0, 3, 2.], [3, 80, 14]]) pp.create_pwl_cost(net, g3, 'gen', [[0, 1, 3.], [1, 80, 10.]]) net.load.p_mw = 1 pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g2], 0) assert np.isclose(net.res_gen.p_mw.at[g3], 0) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1]) net.load.p_mw = 3 pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g3], 0) assert np.isclose(net.res_gen.p_mw.at[g1], 2) assert np.isclose(net.res_cost, net.res_gen.p_mw.at[g1] + net.res_gen.p_mw.at[g2] * 2) net.load.p_mw = 5 pp.runpm_ac_opf(net) consistency_checks(net, rtol=1e-3) assert np.isclose(net.res_gen.p_mw.at[g1], 2) assert np.isclose(net.res_gen.p_mw.at[g2], 3) assert np.isclose( net.res_cost, net.res_gen.p_mw.at[g1] + net.res_gen.p_mw.at[g2] * 2 + net.res_gen.p_mw.at[g3] * 3)
# -*- coding: utf-8 -*- """ Created on Wed May 30 13:37:56 2018 @author: uoa-student2 """ import pandapower as pp from numpy import array net = pp.create_empty_network() #create buses bus1 = pp.create_bus(net, vn_kv=220., min_vm_pu=1.0, max_vm_pu=1.02) bus2 = pp.create_bus(net, vn_kv=110., min_vm_pu=1.0, max_vm_pu=1.02) bus3 = pp.create_bus(net, vn_kv=110., min_vm_pu=1.0, max_vm_pu=1.02) bus4 = pp.create_bus(net, vn_kv=110., min_vm_pu=1.0, max_vm_pu=1.02) bus = net.bus #create 220/110 kV transformer pp.create_transformer(net, bus1, bus2, std_type="100 MVA 220/110 kV", max_loading_percent=50) trafo = net.trafo #create 110 kV lines pp.create_line(net, bus2, bus3, length_km=70., std_type='149-AL1/24-ST1A 110.0', max_loading_percent=50) 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)
def net_3w_trafo_opf(): 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.) bus5 = pp.create_bus(net, vn_kv=110.) pp.create_bus(net, vn_kv=110., in_service=False) # create 220/110 kV transformer pp.create_transformer3w_from_parameters(net, bus1, bus2, bus5, vn_hv_kv=220, vn_mv_kv=110, vn_lv_kv=110, vk_hv_percent=10., vk_mv_percent=10., vk_lv_percent=10., vkr_hv_percent=0.5, vkr_mv_percent=0.5, vkr_lv_percent=0.5, pfe_kw=100, i0_percent=0.1, shift_mv_degree=0, shift_lv_degree=0, sn_hv_mva=100, sn_mv_mva=50, sn_lv_mva=50) # 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') pp.create_line(net, bus4, bus5, length_km=30., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=60, controllable=False) pp.create_load(net, bus3, p_mw=70, controllable=False) pp.create_sgen(net, bus3, p_mw=10, controllable=False) # create generators pp.create_ext_grid(net, bus1, min_p_mw=0, max_p_mw=1000, max_q_mvar=0.01, min_q_mvar=0) pp.create_gen(net, bus3, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01) pp.create_gen(net, bus4, p_mw=80, min_p_mw=0, max_p_mw=80, vm_pu=1.01) net.gen["controllable"] = False return net
def _add_lines_with_branched_loads(net, n_lines, startbus, length_per_line, std_type="NAYY 4x150 SE", p_per_load_in_kw=0, q_per_load_in_kvar=0, length_branchout_line_1=0.022, length_branchout_line_2=0, std_type_branchout_line_1="NAYY 4x50 SE", std_type_branchout_line_2="NAYY 4x50 SE", prob_branchout_line_1=0.5, branchnr=1): """ Creates a single unsplitted branch on the startbus. each bus on the main \ line is connected to a branch out line which connects \ the loadbus (households). If there are two std_types given for the branch_out_lin. The cable_types \ interchange with the given probability If there are two lengths of branchoutlines are given, the \ lengths interchange. It begins with length 1 and switches to length 2. The cable with length 1 \ is named as "MUF_" and length 2 becomes "KV_". Loads will only be added if p_per_load_in_kw or q_per_load_in_kvar \ is assigned The branch number could be assigned with branchnr. It will be added to the\ name ti keep track on the node position """ # support function startpoint_bus = 1 startpoint_line = 1 bus_before = startbus length_branchout_line = length_branchout_line_1 # destinct between Muffe und Kabelverteiler if length_branchout_line_2: bustype = "MUF" else: bustype = "bus" std_type_branchout_line = std_type_branchout_line_1 for i in range(n_lines): buscounter = startpoint_bus + i linecounter = startpoint_line + i created_bus_nr = pp.create_bus(net, name="%s_%d_%d" % (bustype, branchnr, buscounter), type="b" if bustype == "KV" else "n", vn_kv=.4) pp.create_line(net, bus_before, created_bus_nr, length_km=length_per_line, name="line_%d_%d" % (branchnr, linecounter), std_type=std_type) loadbusnr = pp.create_bus(net, name="loadbus_%d_%d" % (branchnr, buscounter), vn_kv=.4) pp.create_line(net, created_bus_nr, loadbusnr, length_km=length_branchout_line, name="branchout_line_%d_%d" % (branchnr, linecounter), std_type=std_type_branchout_line) if p_per_load_in_kw or q_per_load_in_kvar: pp.create_load(net, loadbusnr, p_kw=p_per_load_in_kw, q_kvar=q_per_load_in_kvar) bus_before = created_bus_nr # rueckgefuehrter Wert in der Schleife # alternates the lenght of the branch out lines if needed if length_branchout_line_2: if length_branchout_line == length_branchout_line_1: length_branchout_line = length_branchout_line_2 bustype = "KV" else: length_branchout_line = length_branchout_line_1 bustype = "MUF" # changes branch out lines according to the probabillity if needed if std_type_branchout_line_2: if rd.random() > prob_branchout_line_1: std_type_branchout_line = std_type_branchout_line_2 else: std_type_branchout_line = std_type_branchout_line_1 return net
def test_voltage_angles(): 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.) b5 = pp.create_bus(net, vn_kv=10., in_service=False) 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, p_mw=5, controllable=False) load_id = pp.create_load(net, b4, p_mw=5, controllable=True, max_p_mw=25, min_p_mw=0, min_q_mvar=-1e-6, max_q_mvar=1e-6) pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=1) pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=1000) net.trafo3w.shift_lv_degree.at[tidx] = 10 net.trafo3w.shift_mv_degree.at[tidx] = 30 net.bus.loc[:, "max_vm_pu"] = 1.1 net.bus.loc[:, "min_vm_pu"] = .9 custom_file = os.path.join( os.path.abspath(os.path.dirname(pp.test.__file__)), "test_files", "run_powermodels_custom.jl") # load is zero since costs are high. PF results should be the same as OPF net.load.loc[1, "p_mw"] = 0. pp.runpp(net, calculate_voltage_angles=True) va_degree = net.res_bus.loc[:, "va_degree"].values vm_pu = net.res_bus.loc[:, "vm_pu"].values loading3w = net.res_trafo3w.loc[:, "loading_percent"].values for run in [pp.runpm_ac_opf, partial(pp.runpm, julia_file=custom_file)]: run(net, calculate_voltage_angles=True) consistency_checks(net) assert 30. < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3]) % 360 < 32. assert 10. < (net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b4]) % 360 < 11. assert np.isnan(net.res_bus.va_degree.at[b5]) assert np.allclose(net.res_bus.va_degree.values, va_degree, atol=1e-6, rtol=1e-6, equal_nan=True) assert np.allclose(net.res_bus.vm_pu.values, vm_pu, atol=1e-6, rtol=1e-6, equal_nan=True) assert np.allclose(net.res_trafo3w.loading_percent, loading3w, atol=1e-2, rtol=1e-2, equal_nan=True)
def test_cost_piecewise_linear_gen_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_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 * 690) with pytest.raises(ValueError): pp.create_piecewise_linear_cost(net, 0, "gen", np.array([[0, 0], [1, 50], [2, 100]]), type="q") with pytest.raises(ValueError): pp.create_piecewise_linear_cost(net, 0, "gen", np.array([[0, 0], [-1, 50], [-2, 100]]), type="q") with pytest.raises(ValueError): pp.create_piecewise_linear_cost(net, 0, "gen", np.array([[-10, 0], [-200, 50], [-50, 100]]), type="q") pp.create_piecewise_linear_cost(net, 0, "gen", np.array([[-50, 50], [0, 0], [50, -50]]), type="q") # run OPF pp.runopp(net, verbose=False) assert net["OPF_converged"] assert net.res_cost - net.res_ext_grid.q_kvar.values < 1e-3
def tnep_grid(): net = pp.create_empty_network() min_vm_pu = 0.95 max_vm_pu = 1.05 # create buses bus1 = pp.create_bus(net, vn_kv=110., geodata=(5, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus2 = pp.create_bus(net, vn_kv=110., geodata=(6, 10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus3 = pp.create_bus(net, vn_kv=110., geodata=(10, 9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) bus4 = pp.create_bus(net, vn_kv=110., geodata=(8, 8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu) # create 110 kV lines pp.create_line(net, bus1, bus2, length_km=70., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus1, bus3, length_km=50., std_type='149-AL1/24-ST1A 110.0') pp.create_line(net, bus1, bus4, length_km=100., std_type='149-AL1/24-ST1A 110.0') # create loads pp.create_load(net, bus2, p_mw=60) pp.create_load(net, bus3, p_mw=70) pp.create_load(net, bus4, p_mw=50) # create generators g1 = pp.create_gen(net, bus1, p_mw=9.513270, min_p_mw=0, max_p_mw=200, vm_pu=1.01, slack=True) pp.create_poly_cost(net, g1, 'gen', cp1_eur_per_mw=1) g2 = pp.create_gen(net, bus2, p_mw=78.403291, min_p_mw=0, max_p_mw=200, vm_pu=1.01) pp.create_poly_cost(net, g2, 'gen', cp1_eur_per_mw=3) g3 = pp.create_gen(net, bus3, p_mw=92.375601, min_p_mw=0, max_p_mw=200, vm_pu=1.01) pp.create_poly_cost(net, g3, 'gen', cp1_eur_per_mw=3) net.line["max_loading_percent"] = 20 # possible new lines (set out of service in line DataFrame) l1 = pp.create_line(net, bus1, bus4, 10., std_type="305-AL1/39-ST1A 110.0", name="new_line1", max_loading_percent=20., in_service=False) l2 = pp.create_line(net, bus2, bus4, 20., std_type="149-AL1/24-ST1A 110.0", name="new_line2", max_loading_percent=20., in_service=False) l3 = pp.create_line(net, bus3, bus4, 30., std_type='149-AL1/24-ST1A 110.0', name="new_line3", max_loading_percent=20., in_service=False) l4 = pp.create_line(net, bus3, bus4, 40., std_type='149-AL1/24-ST1A 110.0', name="new_line4", max_loading_percent=20., in_service=False) new_line_index = [l1, l2, l3, l4] construction_costs = [10., 20., 30., 45.] # create new line dataframe init_ne_line(net, new_line_index, construction_costs) return net
def create_test_network(): """Creates a simple pandapower test network """ net = pp.create_empty_network() b1 = pp.create_bus(net, name="bus1", vn_kv=10.) pp.create_ext_grid(net, b1) b2 = pp.create_bus(net, name="bus2", geodata=(1, 2), vn_kv=.4) b3 = pp.create_bus(net, name="bus3", geodata=(1, 3), vn_kv=.4, index=7) b4 = pp.create_bus(net, name="bus4", vn_kv=10.) pp.create_transformer_from_parameters(net, b4, b2, 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) # 0.016 MVA 10/0.4 kV ET 16/23 SGB pp.create_line_from_parameters(net, b2, b3, 1, name="line1", r_ohm_per_km=0.2067, ices=0.389985, c_nf_per_km=720.0, max_i_ka=0.328, x_ohm_per_km=0.1897522, geodata=np.array([[1, 2], [3, 4]])) # NAYY 1x150RM 0.6/1kV ir pp.create_line_from_parameters(net, b1, b4, 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) # NAYSEY 3x35rm/16 6/10kV pp.create_load(net, b2, p_kw=10, q_kvar=0, name="load1") pp.create_load(net, b3, p_kw=40, q_kvar=2, name="load2") pp.create_gen(net, b4, p_kw=-200., vm_pu=1.0) pp.create_sgen(net, b3, p_kw=-50, sn_kva=100) return net
def create_cigre_network_mv(with_der=False): net_cigre_mv = pp.create_empty_network() # Linedata line_data = {'c_nf_per_km': 151.1749, 'r_ohm_per_km': 0.501, 'x_ohm_per_km': 0.716, 'imax_ka': 0.145, 'type': 'cs'} pp.create_std_type(net_cigre_mv, line_data, name='CABLE_CIGRE_MV', element='line') line_data = {'c_nf_per_km': 10.09679, 'r_ohm_per_km': 0.510, 'x_ohm_per_km': 0.366, 'imax_ka': 0.195, 'type': 'ol'} pp.create_std_type(net_cigre_mv, line_data, name='OHL_CIGRE_MV', element='line') # Busses bus0 = pp.create_bus(net_cigre_mv, name='Bus 0', vn_kv=110, type='b', zone='CIGRE_MV') bus1 = pp.create_bus(net_cigre_mv, name='Bus 1', vn_kv=20, type='b', zone='CIGRE_MV') bus2 = pp.create_bus(net_cigre_mv, name='Bus 2', vn_kv=20, type='b', zone='CIGRE_MV') bus3 = pp.create_bus(net_cigre_mv, name='Bus 3', vn_kv=20, type='b', zone='CIGRE_MV') bus4 = pp.create_bus(net_cigre_mv, name='Bus 4', vn_kv=20, type='b', zone='CIGRE_MV') bus5 = pp.create_bus(net_cigre_mv, name='Bus 5', vn_kv=20, type='b', zone='CIGRE_MV') bus6 = pp.create_bus(net_cigre_mv, name='Bus 6', vn_kv=20, type='b', zone='CIGRE_MV') bus7 = pp.create_bus(net_cigre_mv, name='Bus 7', vn_kv=20, type='b', zone='CIGRE_MV') bus8 = pp.create_bus(net_cigre_mv, name='Bus 8', vn_kv=20, type='b', zone='CIGRE_MV') bus9 = pp.create_bus(net_cigre_mv, name='Bus 9', vn_kv=20, type='b', zone='CIGRE_MV') bus10 = pp.create_bus(net_cigre_mv, name='Bus 10', vn_kv=20, type='b', zone='CIGRE_MV') bus11 = pp.create_bus(net_cigre_mv, name='Bus 11', vn_kv=20, type='b', zone='CIGRE_MV') bus12 = pp.create_bus(net_cigre_mv, name='Bus 12', vn_kv=20, type='b', zone='CIGRE_MV') bus13 = pp.create_bus(net_cigre_mv, name='Bus 13', vn_kv=20, type='b', zone='CIGRE_MV') bus14 = pp.create_bus(net_cigre_mv, name='Bus 14', vn_kv=20, type='b', zone='CIGRE_MV') # Lines pp.create_line(net_cigre_mv, bus1, bus2, length_km=2.82, std_type='CABLE_CIGRE_MV', name='Line 1-2') pp.create_line(net_cigre_mv, bus2, bus3, length_km=4.42, std_type='CABLE_CIGRE_MV', name='Line 2-3') pp.create_line(net_cigre_mv, bus3, bus4, length_km=0.61, std_type='CABLE_CIGRE_MV', name='Line 3-4') pp.create_line(net_cigre_mv, bus4, bus5, length_km=0.56, std_type='CABLE_CIGRE_MV', name='Line 4-5') pp.create_line(net_cigre_mv, bus5, bus6, length_km=1.54, std_type='CABLE_CIGRE_MV', name='Line 5-6') pp.create_line(net_cigre_mv, bus7, bus8, length_km=1.67, std_type='CABLE_CIGRE_MV', name='Line 7-8') pp.create_line(net_cigre_mv, bus8, bus9, length_km=0.32, std_type='CABLE_CIGRE_MV', name='Line 8-9') pp.create_line(net_cigre_mv, bus9, bus10, length_km=0.77, std_type='CABLE_CIGRE_MV', name='Line 9-10') pp.create_line(net_cigre_mv, bus10, bus11, length_km=0.33, std_type='CABLE_CIGRE_MV', name='Line 10-11') pp.create_line(net_cigre_mv, bus3, bus8, length_km=1.3, std_type='CABLE_CIGRE_MV', name='Line 3-8') pp.create_line(net_cigre_mv, bus12, bus13, length_km=4.89, std_type='OHL_CIGRE_MV', name='Line 12-13') pp.create_line(net_cigre_mv, bus13, bus14, length_km=2.99, std_type='OHL_CIGRE_MV', name='Line 13-14') line6_7 = pp.create_line(net_cigre_mv, bus6, bus7, length_km=0.24, std_type='CABLE_CIGRE_MV', name='Line 6-7') line4_11 = pp.create_line(net_cigre_mv, bus11, bus4, length_km=0.49, std_type='CABLE_CIGRE_MV', name='Line 11-4') line8_14 = pp.create_line(net_cigre_mv, bus14, bus8, length_km=2., std_type='OHL_CIGRE_MV', name='Line 14-8') # Ext-Grid pp.create_ext_grid(net_cigre_mv, bus0, vm_pu=1.03, va_degree=0., s_sc_max_mva=5000, s_sc_min_mva=5000, rx_max=0.1, rx_min=0.1) # Trafos trafo0 = pp.create_transformer_from_parameters(net_cigre_mv, bus0, bus1, sn_kva=25000, vn_hv_kv=110, vn_lv_kv=20, vscr_percent=0.16, vsc_percent=12.00107, pfe_kw=0, i0_percent=0, shift_degree=30.0, name='Trafo 0-1') trafo1 = pp.create_transformer_from_parameters(net_cigre_mv, bus0, bus12, sn_kva=25000, vn_hv_kv=110, vn_lv_kv=20, vscr_percent=0.16, vsc_percent=12.00107, pfe_kw=0, i0_percent=0, shift_degree=30.0, name='Trafo 0-12') # Switches # S2 pp.create_switch(net_cigre_mv, bus6, line6_7, et='l', closed=True, type='LBS') pp.create_switch(net_cigre_mv, bus7, line6_7, et='l', closed=False, type='LBS', name='S2') # S3 pp.create_switch(net_cigre_mv, bus4, line4_11, et='l', closed=False, type='LBS', name='S3') pp.create_switch(net_cigre_mv, bus11, line4_11, et='l', closed=True, type='LBS') # S1 pp.create_switch(net_cigre_mv, bus8, line8_14, et='l', closed=False, type='LBS', name='S1') pp.create_switch(net_cigre_mv, bus14, line8_14, et='l', closed=True, type='LBS') # trafos pp.create_switch(net_cigre_mv, bus0, trafo0, et='t', closed=True, type='CB') pp.create_switch(net_cigre_mv, bus0, trafo1, et='t', closed=True, type='CB') # Loads # Residential pp.create_load(net_cigre_mv, bus1, p_kw=14994.0, q_kvar=3044.66156, name='Load R1') pp.create_load(net_cigre_mv, bus3, p_kw=276.45, q_kvar=69.28490, name='Load R3') pp.create_load(net_cigre_mv, bus4, p_kw=431.65, q_kvar=108.18169, name='Load R4') pp.create_load(net_cigre_mv, bus5, p_kw=727.5, q_kvar=182.32869, name='Load R5') pp.create_load(net_cigre_mv, bus6, p_kw=548.05, q_kvar=137.35428, name='Load R6') pp.create_load(net_cigre_mv, bus8, p_kw=586.85, q_kvar=147.07847, name='Load R8') pp.create_load(net_cigre_mv, bus10, p_kw=475.3, q_kvar=119.12141, name='Load R10') pp.create_load(net_cigre_mv, bus11, p_kw=329.8, q_kvar=82.65567, name='Load R11') pp.create_load(net_cigre_mv, bus12, p_kw=14994.0, q_kvar=3044.66156, name='Load R12') pp.create_load(net_cigre_mv, bus14, p_kw=208.55, q_kvar=52.26756, name='Load R14') # Commercial / Industrial pp.create_load(net_cigre_mv, bus1, p_kw=4845.0, q_kvar=1592.47449, name='Load CI1') pp.create_load(net_cigre_mv, bus3, p_kw=225.25, q_kvar=139.59741, name='Load CI3') pp.create_load(net_cigre_mv, bus7, p_kw=76.5, q_kvar=47.41044, name='Load CI7') pp.create_load(net_cigre_mv, bus9, p_kw=573.75, q_kvar=355.57831, name='Load CI9') pp.create_load(net_cigre_mv, bus10, p_kw=68.0, q_kvar=42.14262, name='Load CI10') pp.create_load(net_cigre_mv, bus12, p_kw=5016.0, q_kvar=1648.67947, name='Load CI12') pp.create_load(net_cigre_mv, bus13, p_kw=34.0, q_kvar=21.07131, name='Load CI13') pp.create_load(net_cigre_mv, bus14, p_kw=331.5, q_kvar=205.44525, name='Load CI14') # Optional distributed energy recources if with_der: pp.create_sgen(net_cigre_mv, bus3, p_kw=-20, q_kvar=0, sn_kva=20, name='PV 3', type='PV') pp.create_sgen(net_cigre_mv, bus4, p_kw=-20, q_kvar=0, sn_kva=20, name='PV 4', type='PV') pp.create_sgen(net_cigre_mv, bus5, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 5', type='PV') pp.create_sgen(net_cigre_mv, bus6, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 6', type='PV') pp.create_sgen(net_cigre_mv, bus8, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 8', type='PV') pp.create_sgen(net_cigre_mv, bus9, p_kw=-30, q_kvar=0, sn_kva=30, name='PV 9', type='PV') pp.create_sgen(net_cigre_mv, bus10, p_kw=-40, q_kvar=0, sn_kva=40, name='PV 10', type='PV') pp.create_sgen(net_cigre_mv, bus11, p_kw=-10, q_kvar=0, sn_kva=10, name='PV 11', type='PV') pp.create_sgen(net_cigre_mv, bus7, p_kw=-1500, q_kvar=0, sn_kva=1500, name='WKA 7', type='WP') return net_cigre_mv
#Define Constants DBV = 350 #Demand Bus Voltage in kV, just for now can be changed later GBV = 350 #Generation Bus Voltage in kV, just for now can be changed later Power_factor = 0.8 Theta = np.arccos(Power_factor) P2Q = np.tan(Theta) R_230 = 0.0015 X_230 = 0.00023 C_230 = 100 Max_230 = 25.006 #Create Demand Buses Region1Bus = pp.create_bus(net, vn_kv=500, name="Region 1 Bus") Region2Bus = pp.create_bus(net, vn_kv=500, name="Region 2 Bus") Region3Bus = pp.create_bus(net, vn_kv=DBV, name="Region 3 Bus") NCRBus = pp.create_bus(net, vn_kv=500, name="NCR Bus") Region4ABus = pp.create_bus(net, vn_kv=500, name="Region 4A Bus") CARBus = pp.create_bus(net, vn_kv=DBV, name="CAR Bus") Region4B1Bus = pp.create_bus(net, vn_kv=500, name="Region 4B1 Bus") Region4B2Bus = pp.create_bus(net, vn_kv=230, name="Region 4B2 Bus") Region5Bus = pp.create_bus(net, vn_kv=DBV, name="Region 5 Bus") Region6Bus = pp.create_bus(net, vn_kv=500, name="Region 6 Bus") Region7Bus = pp.create_bus(net, vn_kv=500, name="Region 7 Bus") Region8Bus = pp.create_bus(net, vn_kv=DBV, name="Region 8 Bus") Mindanao1Bus = pp.create_bus(net, vn_kv=DBV, name="Mindanao 1 Bus") Mindanao2Bus = pp.create_bus(net, vn_kv=DBV, name="Mindanao 2 Bus") Mindanao3Bus = pp.create_bus(net, vn_kv=500, name="Mindanao 3 Bus")
def create_cigre_network_lv(): net_cigre_lv = pp.create_empty_network() # Linedata # UG1 line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.162, 'x_ohm_per_km': 0.0832, 'imax_ka': 1.0, 'type': 'cs'} pp.create_std_type(net_cigre_lv, line_data, name='UG1', element='line') # UG2 line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.2647, 'x_ohm_per_km': 0.0823, 'imax_ka': 1.0, 'type': 'cs'} pp.create_std_type(net_cigre_lv, line_data, name='UG2', element='line') # UG3 line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.822, 'x_ohm_per_km': 0.0847, 'imax_ka': 1.0, 'type': 'cs'} pp.create_std_type(net_cigre_lv, line_data, name='UG3', element='line') # OH1 line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 0.4917, 'x_ohm_per_km': 0.2847, 'imax_ka': 1.0, 'type': 'ol'} pp.create_std_type(net_cigre_lv, line_data, name='OH1', element='line') # OH2 line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 1.3207, 'x_ohm_per_km': 0.321, 'imax_ka': 1.0, 'type': 'ol'} pp.create_std_type(net_cigre_lv, line_data, name='OH2', element='line') # OH3 line_data = {'c_nf_per_km': 0.0, 'r_ohm_per_km': 2.0167, 'x_ohm_per_km': 0.3343, 'imax_ka': 1.0, 'type': 'ol'} pp.create_std_type(net_cigre_lv, line_data, name='OH3', element='line') # Busses bus0 = pp.create_bus(net_cigre_lv, name='Bus 0', vn_kv=20.0, type='b', zone='CIGRE_LV') busR0 = pp.create_bus(net_cigre_lv, name='Bus R0', vn_kv=20.0, type='b', zone='CIGRE_LV') busR1 = pp.create_bus(net_cigre_lv, name='Bus R1', vn_kv=0.4, type='b', zone='CIGRE_LV') busR2 = pp.create_bus(net_cigre_lv, name='Bus R2', vn_kv=0.4, type='m', zone='CIGRE_LV') busR3 = pp.create_bus(net_cigre_lv, name='Bus R3', vn_kv=0.4, type='m', zone='CIGRE_LV') busR4 = pp.create_bus(net_cigre_lv, name='Bus R4', vn_kv=0.4, type='m', zone='CIGRE_LV') busR5 = pp.create_bus(net_cigre_lv, name='Bus R5', vn_kv=0.4, type='m', zone='CIGRE_LV') busR6 = pp.create_bus(net_cigre_lv, name='Bus R6', vn_kv=0.4, type='m', zone='CIGRE_LV') busR7 = pp.create_bus(net_cigre_lv, name='Bus R7', vn_kv=0.4, type='m', zone='CIGRE_LV') busR8 = pp.create_bus(net_cigre_lv, name='Bus R8', vn_kv=0.4, type='m', zone='CIGRE_LV') busR9 = pp.create_bus(net_cigre_lv, name='Bus R9', vn_kv=0.4, type='m', zone='CIGRE_LV') busR10 = pp.create_bus(net_cigre_lv, name='Bus R10', vn_kv=0.4, type='m', zone='CIGRE_LV') busR11 = pp.create_bus(net_cigre_lv, name='Bus R11', vn_kv=0.4, type='m', zone='CIGRE_LV') busR12 = pp.create_bus(net_cigre_lv, name='Bus R12', vn_kv=0.4, type='m', zone='CIGRE_LV') busR13 = pp.create_bus(net_cigre_lv, name='Bus R13', vn_kv=0.4, type='m', zone='CIGRE_LV') busR14 = pp.create_bus(net_cigre_lv, name='Bus R14', vn_kv=0.4, type='m', zone='CIGRE_LV') busR15 = pp.create_bus(net_cigre_lv, name='Bus R15', vn_kv=0.4, type='m', zone='CIGRE_LV') busR16 = pp.create_bus(net_cigre_lv, name='Bus R16', vn_kv=0.4, type='m', zone='CIGRE_LV') busR17 = pp.create_bus(net_cigre_lv, name='Bus R17', vn_kv=0.4, type='m', zone='CIGRE_LV') busR18 = pp.create_bus(net_cigre_lv, name='Bus R18', vn_kv=0.4, type='m', zone='CIGRE_LV') busI0 = pp.create_bus(net_cigre_lv, name='Bus I0', vn_kv=20.0, type='b', zone='CIGRE_LV') busI1 = pp.create_bus(net_cigre_lv, name='Bus I1', vn_kv=0.4, type='b', zone='CIGRE_LV') busI2 = pp.create_bus(net_cigre_lv, name='Bus I2', vn_kv=0.4, type='m', zone='CIGRE_LV') busC0 = pp.create_bus(net_cigre_lv, name='Bus C0', vn_kv=20.0, type='b', zone='CIGRE_LV') busC1 = pp.create_bus(net_cigre_lv, name='Bus C1', vn_kv=0.4, type='b', zone='CIGRE_LV') busC2 = pp.create_bus(net_cigre_lv, name='Bus C2', vn_kv=0.4, type='m', zone='CIGRE_LV') busC3 = pp.create_bus(net_cigre_lv, name='Bus C3', vn_kv=0.4, type='m', zone='CIGRE_LV') busC4 = pp.create_bus(net_cigre_lv, name='Bus C4', vn_kv=0.4, type='m', zone='CIGRE_LV') busC5 = pp.create_bus(net_cigre_lv, name='Bus C5', vn_kv=0.4, type='m', zone='CIGRE_LV') busC6 = pp.create_bus(net_cigre_lv, name='Bus C6', vn_kv=0.4, type='m', zone='CIGRE_LV') busC7 = pp.create_bus(net_cigre_lv, name='Bus C7', vn_kv=0.4, type='m', zone='CIGRE_LV') busC8 = pp.create_bus(net_cigre_lv, name='Bus C8', vn_kv=0.4, type='m', zone='CIGRE_LV') busC9 = pp.create_bus(net_cigre_lv, name='Bus C9', vn_kv=0.4, type='m', zone='CIGRE_LV') busC10 = pp.create_bus(net_cigre_lv, name='Bus C10', vn_kv=0.4, type='m', zone='CIGRE_LV') busC11 = pp.create_bus(net_cigre_lv, name='Bus C11', vn_kv=0.4, type='m', zone='CIGRE_LV') busC12 = pp.create_bus(net_cigre_lv, name='Bus C12', vn_kv=0.4, type='m', zone='CIGRE_LV') busC13 = pp.create_bus(net_cigre_lv, name='Bus C13', vn_kv=0.4, type='m', zone='CIGRE_LV') busC14 = pp.create_bus(net_cigre_lv, name='Bus C14', vn_kv=0.4, type='m', zone='CIGRE_LV') busC15 = pp.create_bus(net_cigre_lv, name='Bus C15', vn_kv=0.4, type='m', zone='CIGRE_LV') busC16 = pp.create_bus(net_cigre_lv, name='Bus C16', vn_kv=0.4, type='m', zone='CIGRE_LV') busC17 = pp.create_bus(net_cigre_lv, name='Bus C17', vn_kv=0.4, type='m', zone='CIGRE_LV') busC18 = pp.create_bus(net_cigre_lv, name='Bus C18', vn_kv=0.4, type='m', zone='CIGRE_LV') busC19 = pp.create_bus(net_cigre_lv, name='Bus C19', vn_kv=0.4, type='m', zone='CIGRE_LV') busC20 = pp.create_bus(net_cigre_lv, name='Bus C20', vn_kv=0.4, type='m', zone='CIGRE_LV') # Lines pp.create_line(net_cigre_lv, busR1, busR2, length_km=0.035, std_type='UG1', name='Line R1-R2') pp.create_line(net_cigre_lv, busR2, busR3, length_km=0.035, std_type='UG1', name='Line R2-R3') pp.create_line(net_cigre_lv, busR3, busR4, length_km=0.035, std_type='UG1', name='Line R3-R4') pp.create_line(net_cigre_lv, busR4, busR5, length_km=0.035, std_type='UG1', name='Line R4-R5') pp.create_line(net_cigre_lv, busR5, busR6, length_km=0.035, std_type='UG1', name='Line R5-R6') pp.create_line(net_cigre_lv, busR6, busR7, length_km=0.035, std_type='UG1', name='Line R6-R7') pp.create_line(net_cigre_lv, busR7, busR8, length_km=0.035, std_type='UG1', name='Line R7-R8') pp.create_line(net_cigre_lv, busR8, busR9, length_km=0.035, std_type='UG1', name='Line R8-R9') pp.create_line(net_cigre_lv, busR9, busR10, length_km=0.035, std_type='UG1', name='Line R9-R10') pp.create_line(net_cigre_lv, busR3, busR11, length_km=0.030, std_type='UG3', name='Line R3-R11') pp.create_line(net_cigre_lv, busR4, busR12, length_km=0.035, std_type='UG3', name='Line R4-R12') pp.create_line(net_cigre_lv, busR12, busR13, length_km=0.035, std_type='UG3', name='Line R12-R13') pp.create_line(net_cigre_lv, busR13, busR14, length_km=0.035, std_type='UG3', name='Line R13-R14') pp.create_line(net_cigre_lv, busR14, busR15, length_km=0.030, std_type='UG3', name='Line R14-R15') pp.create_line(net_cigre_lv, busR6, busR16, length_km=0.030, std_type='UG3', name='Line R6-R16') pp.create_line(net_cigre_lv, busR9, busR17, length_km=0.030, std_type='UG3', name='Line R9-R17') pp.create_line(net_cigre_lv, busR10, busR18, length_km=0.030, std_type='UG3', name='Line R10-R18') pp.create_line(net_cigre_lv, busI1, busI2, length_km=0.2, std_type='UG2', name='Line I1-I2') pp.create_line(net_cigre_lv, busC1, busC2, length_km=0.030, std_type='OH1', name='Line C1-C2') pp.create_line(net_cigre_lv, busC2, busC3, length_km=0.030, std_type='OH1', name='Line C2-C3') pp.create_line(net_cigre_lv, busC3, busC4, length_km=0.030, std_type='OH1', name='Line C3-C4') pp.create_line(net_cigre_lv, busC4, busC5, length_km=0.030, std_type='OH1', name='Line C4-C5') pp.create_line(net_cigre_lv, busC5, busC6, length_km=0.030, std_type='OH1', name='Line C5-C6') pp.create_line(net_cigre_lv, busC6, busC7, length_km=0.030, std_type='OH1', name='Line C6-C7') pp.create_line(net_cigre_lv, busC7, busC8, length_km=0.030, std_type='OH1', name='Line C7-C8') pp.create_line(net_cigre_lv, busC8, busC9, length_km=0.030, std_type='OH1', name='Line C8-C9') pp.create_line(net_cigre_lv, busC3, busC10, length_km=0.030, std_type='OH2', name='Line C3-C10') pp.create_line(net_cigre_lv, busC10, busC11, length_km=0.030, std_type='OH2', name='Line C10-C11') pp.create_line(net_cigre_lv, busC11, busC12, length_km=0.030, std_type='OH3', name='Line C11-C12') pp.create_line(net_cigre_lv, busC11, busC13, length_km=0.030, std_type='OH3', name='Line C11-C13') pp.create_line(net_cigre_lv, busC10, busC14, length_km=0.030, std_type='OH3', name='Line C10-C14') pp.create_line(net_cigre_lv, busC5, busC15, length_km=0.030, std_type='OH2', name='Line C5-C15') pp.create_line(net_cigre_lv, busC15, busC16, length_km=0.030, std_type='OH2', name='Line C15-C16') pp.create_line(net_cigre_lv, busC15, busC17, length_km=0.030, std_type='OH3', name='Line C15-C17') pp.create_line(net_cigre_lv, busC16, busC18, length_km=0.030, std_type='OH3', name='Line C16-C18') pp.create_line(net_cigre_lv, busC8, busC19, length_km=0.030, std_type='OH3', name='Line C8-C19') pp.create_line(net_cigre_lv, busC9, busC20, length_km=0.030, std_type='OH3', name='Line C9-C20') # Trafos pp.create_transformer_from_parameters(net_cigre_lv, busR0, busR1, sn_kva=500, vn_hv_kv=20.0, vn_lv_kv=0.4, vscr_percent=1.0, vsc_percent=4.123106, pfe_kw=0.0, i0_percent=0.0, shift_degree=30.0, tp_pos=0.0, name='Trafo R0-R1') pp.create_transformer_from_parameters(net_cigre_lv, busI0, busI1, sn_kva=150, vn_hv_kv=20.0, vn_lv_kv=0.4, vscr_percent=1.003125, vsc_percent=4.126896, pfe_kw=0.0, i0_percent=0.0, shift_degree=30.0, tp_pos=0.0, name='Trafo I0-I1') pp.create_transformer_from_parameters(net_cigre_lv, busC0, busC1, sn_kva=300, vn_hv_kv=20.0, vn_lv_kv=0.4, vscr_percent=0.993750, vsc_percent=4.115529, pfe_kw=0.0, i0_percent=0.0, shift_degree=30.0, tp_pos=0.0, name='Trafo C0-C1') # External grid pp.create_ext_grid(net_cigre_lv, bus0, vm_pu=1.0, va_degree=0.0, s_sc_max_mva=100.0, s_sc_min_mva=100.0, rx_max=1.0, rx_min=1.0) # Loads pp.create_load(net_cigre_lv, busR1, p_kw=190.0, q_kvar=62.449980, name='Load R1') pp.create_load(net_cigre_lv, busR11, p_kw=14.25, q_kvar=4.683748, name='Load R11') pp.create_load(net_cigre_lv, busR15, p_kw=49.4, q_kvar=16.236995, name='Load R15') pp.create_load(net_cigre_lv, busR16, p_kw=52.25, q_kvar=17.173744, name='Load R16') pp.create_load(net_cigre_lv, busR17, p_kw=33.25, q_kvar=10.928746, name='Load R17') pp.create_load(net_cigre_lv, busR18, p_kw=44.65, q_kvar=14.675745, name='Load R18') pp.create_load(net_cigre_lv, busI2, p_kw=85.0, q_kvar=52.678269, name='Load I2') pp.create_load(net_cigre_lv, busC1, p_kw=108.0, q_kvar=52.306787, name='Load C1') pp.create_load(net_cigre_lv, busC12, p_kw=18.0, q_kvar=8.717798, name='Load C12') pp.create_load(net_cigre_lv, busC13, p_kw=18.0, q_kvar=8.717798, name='Load C13') pp.create_load(net_cigre_lv, busC14, p_kw=22.5, q_kvar=10.897247, name='Load C14') pp.create_load(net_cigre_lv, busC17, p_kw=22.5, q_kvar=10.897247, name='Load C17') pp.create_load(net_cigre_lv, busC18, p_kw=7.2, q_kvar=3.487119, name='Load C18') pp.create_load(net_cigre_lv, busC19, p_kw=14.4, q_kvar=6.974238, name='Load C19') pp.create_load(net_cigre_lv, busC20, p_kw=7.2, q_kvar=3.487119, name='Load C20') # Switches pp.create_switch(net_cigre_lv, bus0, busR0, et='b', closed=True, type='CB', name='S1') pp.create_switch(net_cigre_lv, bus0, busI0, et='b', closed=True, type='CB', name='S2') pp.create_switch(net_cigre_lv, bus0, busC0, et='b', closed=True, type='CB', name='S3') return net_cigre_lv
def example_multivoltage(): """ Returns the multivoltage example network from the pandapower tutorials. OUTPUT: net - multivoltage example network EXAMPLE: >>> import pandapower.networks >>> net = pandapower.networks.example_multivoltage() """ net = pp.create_empty_network() # --- Busses # HV # Double busbar pp.create_bus(net, name='Double Busbar 1', vn_kv=380, type='b') pp.create_bus(net, name='Double Busbar 2', vn_kv=380, type='b') for i in range(10): pp.create_bus(net, name='Bus DB T%s' % i, vn_kv=380, type='n') for i in range(1, 5): pp.create_bus(net, name='Bus DB %s' % i, vn_kv=380, type='n') # Single busbar pp.create_bus(net, name='Single Busbar', vn_kv=110, type='b') for i in range(1, 6): pp.create_bus(net, name='Bus SB %s' % i, vn_kv=110, type='n') for i in range(1, 6): for j in [1, 2]: pp.create_bus(net, name='Bus SB T%s.%s' % (i, j), vn_kv=110, type='n') # Remaining for i in range(1, 5): pp.create_bus(net, name='Bus HV%s' % i, vn_kv=110, type='n') # MV pp.create_bus(net, name='Bus MV0 20kV', vn_kv=20, type='n') for i in range(8): pp.create_bus(net, name='Bus MV%s' % i, vn_kv=10, type='n') # LV pp.create_bus(net, name='Bus LV0', vn_kv=0.4, type='n') for i in range(1, 6): pp.create_bus(net, name='Bus LV1.%s' % i, vn_kv=0.4, type='m') for i in range(1, 5): pp.create_bus(net, name='Bus LV2.%s' % i, vn_kv=0.4, type='m') pp.create_bus(net, name='Bus LV2.2.1', vn_kv=0.4, type='m') pp.create_bus(net, name='Bus LV2.2.2', vn_kv=0.4, type='m') # --- Lines # HV hv_lines = pd.DataFrame() hv_lines['line_name'] = ['HV Line%s' % i for i in range(1, 7)] hv_lines['from_bus'] = [ 'Bus SB 2', 'Bus HV1', 'Bus HV2', 'Bus HV1', 'Bus HV3', 'Bus SB 3' ] hv_lines['to_bus'] = [ 'Bus HV1', 'Bus HV2', 'Bus HV4', 'Bus HV4', 'Bus HV4', 'Bus HV3' ] hv_lines['std_type'] = '184-AL1/30-ST1A 110.0' hv_lines['length'] = [30, 20, 30, 15, 25, 30] hv_lines['parallel'] = [1, 1, 1, 1, 1, 2] for _, hv_line in hv_lines.iterrows(): from_bus = pp.get_element_index(net, "bus", hv_line.from_bus) to_bus = pp.get_element_index(net, "bus", hv_line.to_bus) pp.create_line(net, from_bus, to_bus, length_km=hv_line.length, std_type=hv_line.std_type, name=hv_line.line_name, parallel=hv_line.parallel) # MV mv_lines = pd.DataFrame() mv_lines['line_name'] = ['MV Line%s' % i for i in range(1, 9)] mv_lines['from_bus'] = ['Bus MV%s' % i for i in list(range(7)) + [0]] mv_lines['to_bus'] = ['Bus MV%s' % i for i in list(range(1, 8)) + [7]] mv_lines['length'] = 1.5 mv_lines['std_type'] = 'NA2XS2Y 1x185 RM/25 12/20 kV' for _, mv_line in mv_lines.iterrows(): from_bus = pp.get_element_index(net, "bus", mv_line.from_bus) to_bus = pp.get_element_index(net, "bus", mv_line.to_bus) pp.create_line(net, from_bus, to_bus, length_km=mv_line.length, std_type=mv_line.std_type, name=mv_line.line_name) # LV lv_lines = pd.DataFrame() lv_line_idx = [ '1.1', '1.2', '1.3', '1.4', '1.6', '2.1', '2.2', '2.3', '2.4', '2.2.1', '2.2.2' ] lv_lines['line_name'] = ['LV Line%s' % i for i in lv_line_idx] lv_line_idx = [ '0', '1.1', '1.2', '1.3', '1.4', '0', '2.1', '2.2', '2.3', '2.2', '2.2.1' ] lv_lines['from_bus'] = ['Bus LV%s' % i for i in lv_line_idx] lv_line_idx = [ '1.1', '1.2', '1.3', '1.4', '1.5', '2.1', '2.2', '2.3', '2.4', '2.2.1', '2.2.2' ] lv_lines['to_bus'] = ['Bus LV%s' % i for i in lv_line_idx] lv_lines['length'] = [0.08] * 5 + [0.12] * 6 lv_lines['std_type'] = ['NAYY 4x120 SE'] * 7 + ['15-AL1/3-ST1A 0.4'] * 4 for _, lv_line in lv_lines.iterrows(): from_bus = pp.get_element_index(net, "bus", lv_line.from_bus) to_bus = pp.get_element_index(net, "bus", lv_line.to_bus) pp.create_line(net, from_bus, to_bus, length_km=lv_line.length, std_type=lv_line.std_type, name=lv_line.line_name) # --- Transformer hv_bus = pp.get_element_index(net, "bus", "Bus DB 2") lv_bus = pp.get_element_index(net, "bus", "Bus SB 1") pp.create_transformer_from_parameters(net, hv_bus, lv_bus, sn_mva=300, vn_hv_kv=380, vn_lv_kv=110, vkr_percent=0.06, vk_percent=8, pfe_kw=0, i0_percent=0, tap_pos=0, shift_degree=0, name='EHV-HV-Trafo') hv_bus = pp.get_element_index(net, "bus", "Bus MV4") lv_bus = pp.get_element_index(net, "bus", "Bus LV0") pp.create_transformer_from_parameters(net, hv_bus, lv_bus, sn_mva=0.4, vn_hv_kv=10, vn_lv_kv=0.4, vkr_percent=1.325, vk_percent=4, pfe_kw=0.95, i0_percent=0.2375, tap_side="hv", tap_neutral=0, tap_min=-2, tap_max=2, tap_step_percent=2.5, tap_pos=0, shift_degree=150, name='MV-LV-Trafo') # Trafo3w hv_bus = pp.get_element_index(net, "bus", "Bus HV2") mv_bus = pp.get_element_index(net, "bus", "Bus MV0 20kV") lv_bus = pp.get_element_index(net, "bus", "Bus MV0") pp.create_transformer3w_from_parameters(net, hv_bus, mv_bus, lv_bus, vn_hv_kv=110, vn_mv_kv=20, vn_lv_kv=10, sn_hv_mva=40, sn_mv_mva=15, sn_lv_mva=25, vk_hv_percent=10.1, vk_mv_percent=10.1, vk_lv_percent=10.1, vkr_hv_percent=0.266667, vkr_mv_percent=0.033333, vkr_lv_percent=0.04, pfe_kw=0, i0_percent=0, shift_mv_degree=30, shift_lv_degree=30, tap_side="hv", tap_neutral=0, tap_min=-8, tap_max=8, tap_step_percent=1.25, tap_pos=0, name='HV-MV-MV-Trafo') # --- Static generators # HV pp.create_sgen(net, pp.get_element_index(net, "bus", 'Bus SB 5'), p_mw=20, q_mvar=4, sn_mva=45, type='WP', name='Wind Park') # MV mv_sgens = pd.DataFrame() mv_sgens['sgen_name'] = [ 'Biogas plant', 'Further MV Generator', 'Industry Generator', 'PV Park' ] mv_sgens['bus'] = ['Bus MV6', 'Bus MV0', 'Bus MV0 20kV', 'Bus MV5'] mv_sgens['p'] = [0.5, 0.5, 15, 2] mv_sgens['q'] = [0, 0.05, 3, 0.1] mv_sgens['sn'] = [0.75, 1, 20, 5] mv_sgens['type'] = ['SGEN', 'SGEN', 'SGEN', 'PV'] for _, sgen in mv_sgens.iterrows(): bus_idx = pp.get_element_index(net, "bus", sgen.bus) pp.create_sgen(net, bus_idx, p_mw=sgen.p, q_mvar=sgen.q, sn_mva=sgen.sn, type=sgen.type, name=sgen.sgen_name) # LV lv_sgens = pd.DataFrame() lv_sgens['sgen_name'] = ['PV'] + ['PV(%s)' % i for i in range(1, 6)] lv_sgens['bus'] = [ 'Bus LV%s' % i for i in ['1.1', '1.3', '2.3', '2.4', '2.2.1', '2.2.2'] ] lv_sgens['p'] = [0.006, 0.005, 0.005, 0.005, 0.005, 0.005] lv_sgens['q'] = 0 lv_sgens['sn'] = [0.012, 0.01, 0.01, 0.01, 0.01, 0.01] lv_sgens['type'] = 'PV' for _, sgen in lv_sgens.iterrows(): bus_idx = pp.get_element_index(net, "bus", sgen.bus) pp.create_sgen(net, bus_idx, p_mw=sgen.p, q_mvar=sgen.q, sn_mva=sgen.sn, type=sgen.type, name=sgen.sgen_name) # --- Loads # HV hv_loads = pd.DataFrame() hv_loads['load_name'] = ['MV Net %s' % i for i in range(5)] hv_loads['bus'] = ['Bus SB 4', 'Bus HV1', 'Bus HV2', 'Bus HV3', 'Bus HV4'] hv_loads['p'] = 38 hv_loads['q'] = 6 for _, load in hv_loads.iterrows(): bus_idx = pp.get_element_index(net, "bus", load.bus) pp.create_load(net, bus_idx, p_mw=load.p, q_mvar=load.q, name=load.load_name) # MV mv_loads = pd.DataFrame() mv_loads['load_name'] = ['Further MV-Rings', 'Industry Load' ] + ['LV Net %s' % i for i in [1, 2, 3, 5, 6, 7]] mv_loads['bus'] = ['Bus MV0', 'Bus MV0 20kV' ] + ['Bus MV%s' % i for i in [1, 2, 3, 5, 6, 7]] mv_loads['p'] = [6, 18, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4] mv_loads['q'] = [2, 4, 0.1, 0.06, 0.06, 0.06, 0.06, 0.06] for _, load in mv_loads.iterrows(): bus_idx = pp.get_element_index(net, "bus", load.bus) pp.create_load(net, bus_idx, p_mw=load.p, q_mvar=load.q, name=load.load_name) # LV lv_loads = pd.DataFrame() idx = ['', '(1)', '(2)', '(3)', '(4)', '(5)'] lv_loads['load_name'] = ['Further LV-Feeders Load'] + [ 'Residential Load%s' % i for i in idx[0:5] ] + ['Rural Load%s' % i for i in idx[0:6]] lv_loads['bus'] = [ 'Bus LV%s' % i for i in [ '0', '1.1', '1.2', '1.3', '1.4', '1.5', '2.1', '2.2', '2.3', '2.4', '2.2.1', '2.2.2' ] ] lv_loads['p'] = [0.1] + [0.01] * 11 lv_loads['q'] = [0.01] + [0.03] * 11 for _, load in lv_loads.iterrows(): bus_idx = pp.get_element_index(net, "bus", load.bus) pp.create_load(net, bus_idx, p_mw=load.p, q_mvar=load.q, name=load.load_name) # --- Other # Shunt pp.create_shunt(net, pp.get_element_index(net, "bus", 'Bus HV1'), p_mw=0, q_mvar=-0.96, name='Shunt') # ExtGrids pp.create_ext_grid(net, pp.get_element_index(net, "bus", 'Double Busbar 1'), vm_pu=1.03, va_degree=0, name='External grid', s_sc_max_mva=10000, rx_max=0.1, rx_min=0.1) # Gen pp.create_gen(net, pp.get_element_index(net, "bus", 'Bus HV4'), vm_pu=1.03, p_mw=100, name='Gas turbine') # Impedance pp.create_impedance(net, pp.get_element_index(net, "bus", 'Bus HV3'), pp.get_element_index(net, "bus", 'Bus HV1'), rft_pu=0.074873, xft_pu=0.198872, sn_mva=100, name='Impedance') # xwards pp.create_xward(net, pp.get_element_index(net, "bus", 'Bus HV3'), ps_mw=23.942, qs_mvar=-12.24187, pz_mw=2.814571, qz_mvar=0, r_ohm=0, x_ohm=12.18951, vm_pu=1.02616, name='XWard 1') pp.create_xward(net, pp.get_element_index(net, "bus", 'Bus HV1'), ps_mw=3.776, qs_mvar=-7.769979, pz_mw=9.174917, qz_mvar=0, r_ohm=0, x_ohm=50.56217, vm_pu=1.024001, name='XWard 2') # --- Switches # HV # Bus-bus switches hv_bus_sw = pd.DataFrame() hv_bus_sw['bus_name'] = ['DB DS%s' % i for i in range(14)] + \ ['DB CB%s' % i for i in range(5)] + \ ['SB DS%s.%s' % (i, j) for i in range(1, 6) for j in range(1, 3)] + \ ['SB CB%s' % i for i in range(1, 6)] hv_bus_sw['from_bus'] = ['Double Busbar %s' % i for i in [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]] + \ ['Bus DB T%s' % i for i in [2, 4, 6, 8, 0, 3, 5, 7, 9]] + \ ['Bus SB T1.1', 'Single Busbar', 'Bus SB T2.1', 'Single Busbar', 'Bus SB T3.1', 'Single Busbar', 'Bus SB T4.1', 'Single Busbar', 'Bus SB T5.1', 'Single Busbar'] + \ ['Bus SB T%s.2' % i for i in range(1, 6)] hv_bus_sw['to_bus'] = ['Bus DB %s' % i for i in ['T0', 'T1', 'T3', 'T3', 'T5', 'T5', 'T7', 'T7', 'T9', 'T9', '1', '2', '3', '4', 'T1', 'T2', 'T4', 'T6', 'T8']] + \ ['Bus SB %s' % i for i in ['1', 'T1.2', '2', 'T2.2', '3', 'T3.2', '4', 'T4.2', '5', 'T5.2']] + \ ['Bus SB T%s.1' % i for i in range(1, 6)] hv_bus_sw['type'] = ['DS'] * 14 + ['CB'] * 5 + ['DS'] * 10 + ['CB'] * 5 hv_bus_sw['et'] = 'b' hv_bus_sw['closed'] = [ bool(i) for i in [1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1] + [1] * 15 ] for _, switch in hv_bus_sw.iterrows(): from_bus = pp.get_element_index(net, "bus", switch.from_bus) to_bus = pp.get_element_index(net, "bus", switch.to_bus) pp.create_switch(net, from_bus, to_bus, et=switch.et, closed=switch.closed, type=switch.type, name=switch.bus_name) # Bus-Line switches hv_buses = net.bus[(net.bus.vn_kv == 380) | (net.bus.vn_kv == 110)].index hv_ls = net.line[(net.line.from_bus.isin(hv_buses)) & (net.line.to_bus.isin(hv_buses))] for _, line in hv_ls.iterrows(): for bus in [line.from_bus, line.to_bus]: pp.create_switch(net, bus, line.name, et='l', closed=True, type='LBS', name='Switch %s - %s' % (net.bus.name.at[bus], line['name'])) # MV # Bus-line switches mv_buses = net.bus[(net.bus.vn_kv == 10) | (net.bus.vn_kv == 20)].index mv_ls = net.line[(net.line.from_bus.isin(mv_buses)) & (net.line.to_bus.isin(mv_buses))] for _, line in mv_ls.iterrows(): for bus in [line.from_bus, line.to_bus]: pp.create_switch(net, bus, line.name, et='l', closed=True, type='LBS', name='Switch %s - %s' % (net.bus.name.at[bus], line['name'])) open_switch_id = net.switch[( net.switch.name == 'Switch Bus MV5 - MV Line5')].index net.switch.closed.loc[open_switch_id] = False # LV # Bus-line switches lv_buses = net.bus[net.bus.vn_kv == 0.4].index lv_ls = net.line[(net.line.from_bus.isin(lv_buses)) & (net.line.to_bus.isin(lv_buses))] for _, line in lv_ls.iterrows(): for bus in [line.from_bus, line.to_bus]: pp.create_switch(net, bus, line.name, et='l', closed=True, type='LBS', name='Switch %s - %s' % (net.bus.name.at[bus], line['name'])) # Trafoswitches # HV pp.create_switch(net, pp.get_element_index(net, "bus", 'Bus DB 2'), pp.get_element_index(net, "trafo", 'EHV-HV-Trafo'), et='t', closed=True, type='LBS', name='Switch DB2 - EHV-HV-Trafo') pp.create_switch(net, pp.get_element_index(net, "bus", 'Bus SB 1'), pp.get_element_index(net, "trafo", 'EHV-HV-Trafo'), et='t', closed=True, type='LBS', name='Switch SB1 - EHV-HV-Trafo') # LV pp.create_switch(net, pp.get_element_index(net, "bus", 'Bus MV4'), pp.get_element_index(net, "trafo", 'MV-LV-Trafo'), et='t', closed=True, type='LBS', name='Switch MV4 - MV-LV-Trafo') pp.create_switch(net, pp.get_element_index(net, "bus", 'Bus LV0'), pp.get_element_index(net, "trafo", 'MV-LV-Trafo'), et='t', closed=True, type='LBS', name='Switch LV0 - MV-LV-Trafo') # --- Powerflow # run power flow and generate result tables pp.runpp(net, init='dc', calculate_voltage_angles=True, Numba=False) return net
def create_cigre_network_hv(length_km_6a_6b=0.1): net_cigre_hv = pp.create_empty_network() # Linedata # Line220kV line_data = {'c_nf_per_km': 9.08, 'r_ohm_per_km': 0.0653, 'x_ohm_per_km': 0.398, 'imax_ka': 1.14, 'type': 'ol'} pp.create_std_type(net_cigre_hv, line_data, 'Line220kV', element='line') # Line380kV line_data = {'c_nf_per_km': 11.5, 'r_ohm_per_km': 0.0328, 'x_ohm_per_km': 0.312, 'imax_ka': 1.32, 'type': 'ol'} pp.create_std_type(net_cigre_hv, line_data, 'Line380kV', element='line') # Busses bus1 = pp.create_bus(net_cigre_hv, name='Bus 1', vn_kv=220, type='b', zone='CIGRE_HV') bus2 = pp.create_bus(net_cigre_hv, name='Bus 2', vn_kv=220, type='b', zone='CIGRE_HV') bus3 = pp.create_bus(net_cigre_hv, name='Bus 3', vn_kv=220, type='b', zone='CIGRE_HV') bus4 = pp.create_bus(net_cigre_hv, name='Bus 4', vn_kv=220, type='b', zone='CIGRE_HV') bus5 = pp.create_bus(net_cigre_hv, name='Bus 5', vn_kv=220, type='b', zone='CIGRE_HV') bus6a = pp.create_bus(net_cigre_hv, name='Bus 6a', vn_kv=220, type='b', zone='CIGRE_HV') bus6b = pp.create_bus(net_cigre_hv, name='Bus 6b', vn_kv=220, type='b', zone='CIGRE_HV') bus7 = pp.create_bus(net_cigre_hv, name='Bus 7', vn_kv=380, type='b', zone='CIGRE_HV') bus8 = pp.create_bus(net_cigre_hv, name='Bus 8', vn_kv=380, type='b', zone='CIGRE_HV') bus9 = pp.create_bus(net_cigre_hv, name='Bus 9', vn_kv=22, type='b', zone='CIGRE_HV') bus10 = pp.create_bus(net_cigre_hv, name='Bus 10', vn_kv=22, type='b', zone='CIGRE_HV') bus11 = pp.create_bus(net_cigre_hv, name='Bus 11', vn_kv=22, type='b', zone='CIGRE_HV') bus12 = pp.create_bus(net_cigre_hv, name='Bus 12', vn_kv=22, type='b', zone='CIGRE_HV') # Lines pp.create_line(net_cigre_hv, bus1, bus2, length_km=100, std_type='Line220kV', name='Line 1-2') pp.create_line(net_cigre_hv, bus1, bus6a, length_km=300, std_type='Line220kV', name='Line 1-6a') pp.create_line(net_cigre_hv, bus2, bus5, length_km=300, std_type='Line220kV', name='Line 2-5') pp.create_line(net_cigre_hv, bus3, bus4, length_km=100, std_type='Line220kV', name='Line 3-4') pp.create_line(net_cigre_hv, bus3, bus4, length_km=100, std_type='Line220kV', name='Line 3-4_2') pp.create_line(net_cigre_hv, bus4, bus5, length_km=300, std_type='Line220kV', name='Line 4-5') pp.create_line(net_cigre_hv, bus4, bus6a, length_km=300, std_type='Line220kV', name='Line 4-6a') pp.create_line(net_cigre_hv, bus7, bus8, length_km=600, std_type='Line380kV', name='Line 7-8') pp.create_line(net_cigre_hv, bus6a, bus6b, length_km=length_km_6a_6b, std_type='Line220kV', name='Line 6a-6b') # Trafos pp.create_transformer_from_parameters(net_cigre_hv, bus7, bus1, sn_kva=1000000, vn_hv_kv=380, vn_lv_kv=220, vscr_percent=0.0, vsc_percent=13.0, pfe_kw=0, i0_percent=0, shift_degree=0.0, name='Trafo 1-7') pp.create_transformer_from_parameters(net_cigre_hv, bus8, bus3, sn_kva=1000000, vn_hv_kv=380, vn_lv_kv=220, vscr_percent=0.0, vsc_percent=13.0, pfe_kw=0, i0_percent=0, shift_degree=0.0, name='Trafo 3-8') pp.create_transformer_from_parameters(net_cigre_hv, bus1, bus9, sn_kva=1000000, vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0, vsc_percent=13.0, pfe_kw=0, i0_percent=0, shift_degree=330.0, name='Trafo 9-1') pp.create_transformer_from_parameters(net_cigre_hv, bus2, bus10, sn_kva=1000000, vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0, vsc_percent=13.0, pfe_kw=0, i0_percent=0, shift_degree=330.0, name='Trafo 10-2') pp.create_transformer_from_parameters(net_cigre_hv, bus3, bus11, sn_kva=1000000, vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0, vsc_percent=13.0, pfe_kw=0, i0_percent=0, shift_degree=330.0, name='Trafo 11-3') pp.create_transformer_from_parameters(net_cigre_hv, bus6b, bus12, sn_kva=500000, vn_hv_kv=220, vn_lv_kv=22, vscr_percent=0.0, vsc_percent=13.0, pfe_kw=0, i0_percent=0, shift_degree=330.0, name='Trafo 12-6b') # Loads pp.create_load(net_cigre_hv, bus2, p_kw=285000, q_kvar=200000, name='Load 2') pp.create_load(net_cigre_hv, bus3, p_kw=325000, q_kvar=244000, name='Load 3') pp.create_load(net_cigre_hv, bus4, p_kw=326000, q_kvar=244000, name='Load 4') pp.create_load(net_cigre_hv, bus5, p_kw=103000, q_kvar=62000, name='Load 5') pp.create_load(net_cigre_hv, bus6a, p_kw=435000, q_kvar=296000, name='Load 6a') # External grid pp.create_ext_grid(net_cigre_hv, bus9, vm_pu=1.03, va_degree=0, name='Generator 9') # Generators pp.create_gen(net_cigre_hv, bus10, vm_pu=1.03, p_kw=-5e5, name='Generator 10') pp.create_gen(net_cigre_hv, bus11, vm_pu=1.03, p_kw=-2e5, name='Generator 11') pp.create_gen(net_cigre_hv, bus12, vm_pu=1.03, p_kw=-3e5, name='Generator 12') # Shunts pp.create_shunt(net_cigre_hv, bus4, p_kw=0.0, q_kvar=-160000, name='Shunt 4') pp.create_shunt(net_cigre_hv, bus5, p_kw=0.0, q_kvar=-80000, name='Shunt 5') pp.create_shunt(net_cigre_hv, bus6a, p_kw=0.0, q_kvar=-180000, name='Shunt 6a') return net_cigre_hv
import pandapower as pp #create empty net net = pp.create_empty_network() #create buses bus1 = pp.create_bus(net, vn_kv=20., name="Bus 1") bus2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") bus3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") #create bus elements pp.create_ext_grid(net, bus=bus1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=bus3, p_mw=0.100, q_mvar=0.05, name="Load") #create branch elements trafo = pp.create_transformer(net, hv_bus=bus1, lv_bus=bus2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") line = pp.create_line(net, from_bus=bus2, to_bus=bus3, length_km=0.1, std_type="NAYY 4x50 SE", name="Line") pp.runpp(net) #Power Flow print(net.res_bus) net.res_bus net.res_line net.res_trafo print(net.res_bus)
intrC.index = intrC['ID'] intrC_idx = intrC['ID'] intrC.index = intrC['i'] main_idx.drop_duplicates(inplace=True) coll_idx.drop_duplicates(inplace=True) intrC_idx.drop_duplicates(inplace=True) ##### CREATE MAIN BRANCH: BUSES & LINES ############### # creating Secondary Substations for i in main_idx.index: if (df.at[i, "Population"] == "0"): pp.create_bus(net, vn_kv=20, type='n', index=main_idx[i], geodata=(df.at[main_idx[i], "X"], df.at[main_idx[i], "Y"])) else: pp.create_bus(net, vn_kv=20, type='b', index=main_idx[i], geodata=(df.at[main_idx[i], "X"], df.at[main_idx[i], "Y"])) for i in main_intr.index: pp.create_line(net, from_bus=main_intr.at[i, 'ID1'], to_bus=main_intr.at[i, 'ID2'], length_km=1,
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", array([10, 0])) pp.create_ext_grid(net, 0) pp.create_polynomial_cost(net, 0, "ext_grid", 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_pandapower_case(): #more complicated examples like #net = pandapower.networks.example_simple() #can be used once the import of e.g. switches is perfected #create empty net net = pp.create_empty_network() #create buses b1 = pp.create_bus(net, vn_kv=20., name="Bus 1") b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") #create bus elements pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=b3, p_kw=100, q_kvar=50, name="Load") #create branch elements tid = pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE") #because of phase angles, need to init with DC pp.runpp(net,calculate_voltage_angles=True,init="dc") n = pypsa.Network() n.import_from_pandapower_net(net) #seed PF with LPF solution because of phase angle jumps n.lpf() n.pf(use_seed=True) #use same index for everything net.res_bus.index = net.bus.name.values net.res_line.index = net.line.name.values #compare bus angles np.testing.assert_array_almost_equal(n.buses_t.v_ang.loc["now"]*180/np.pi,net.res_bus.va_degree) #compare bus voltage magnitudes np.testing.assert_array_almost_equal(n.buses_t.v_mag_pu.loc["now"],net.res_bus.vm_pu) #compare bus active power (NB: pandapower uses load signs) np.testing.assert_array_almost_equal(n.buses_t.p.loc["now"],-net.res_bus.p_kw/1e3) #compare bus active power (NB: pandapower uses load signs) np.testing.assert_array_almost_equal(n.buses_t.q.loc["now"],-net.res_bus.q_kvar/1e3) #compare branch flows np.testing.assert_array_almost_equal(n.lines_t.p0.loc["now"],net.res_line.p_from_kw/1e3) np.testing.assert_array_almost_equal(n.lines_t.p1.loc["now"],net.res_line.p_to_kw/1e3) np.testing.assert_array_almost_equal(n.lines_t.q0.loc["now"],net.res_line.q_from_kvar/1e3) np.testing.assert_array_almost_equal(n.lines_t.q1.loc["now"],net.res_line.q_to_kvar/1e3) np.testing.assert_array_almost_equal(n.transformers_t.p0.loc["now"],net.res_trafo.p_hv_kw/1e3) np.testing.assert_array_almost_equal(n.transformers_t.p1.loc["now"],net.res_trafo.p_lv_kw/1e3) np.testing.assert_array_almost_equal(n.transformers_t.q0.loc["now"],net.res_trafo.q_hv_kvar/1e3) np.testing.assert_array_almost_equal(n.transformers_t.q1.loc["now"],net.res_trafo.q_lv_kvar/1e3)