Example #1
0
def trafo3w_net():
    net = pp.create_empty_network()
    b1 = pp.create_bus(net, 220)
    b2 = pp.create_bus(net, 30)
    b3 = pp.create_bus(net, 10)
    pp.create_ext_grid(net,
                       b1,
                       s_sc_max_mva=100.,
                       s_sc_min_mva=40.,
                       rx_min=0.1,
                       rx_max=0.1)
    pp.create_load(net, b2, 10000, 2000)
    pp.create_load(net, b3, 10000, 4000)
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=b3,
                                            vn_hv_kv=222,
                                            vn_mv_kv=33,
                                            vn_lv_kv=11.,
                                            sn_hv_kva=50000,
                                            sn_mv_kva=30000,
                                            sn_lv_kva=20000,
                                            vsc_hv_percent=11,
                                            vscr_hv_percent=1.,
                                            vsc_mv_percent=11,
                                            vscr_mv_percent=1.,
                                            vsc_lv_percent=11.,
                                            vscr_lv_percent=1.,
                                            pfe_kw=10,
                                            i0_percent=0.2)
    return net
def add_test_trafo3w(net):
    b1, b2, ln = add_grid_connection(net, zone="test_trafo3w")
    b3 = pp.create_bus(net, vn_kv=0.6, zone="test_trafo3w")
    pp.create_load(net, b3, p_kw=200, q_kvar=0)
    b4 = pp.create_bus(net, vn_kv=0.4, zone="test_trafo3w")
    pp.create_load(net, b4, p_kw=100, q_kvar=0)

    pp.create_transformer3w_from_parameters(net, hv_bus=b2, mv_bus=b3, lv_bus=b4, vn_hv_kv=22,
                                            vn_mv_kv=.64, vn_lv_kv=.42, sn_hv_kva=1000,
                                            sn_mv_kva=700, sn_lv_kva=300, vsc_hv_percent=1.,
                                            vscr_hv_percent=.03, vsc_mv_percent=.5,
                                            vscr_mv_percent=.02, vsc_lv_percent=.25,
                                            vscr_lv_percent=.01, pfe_kw=.5, i0_percent=0.1,
                                            name="test", index=pp.get_free_id(net.trafo3w) + 1,
                                            tp_side="hv", tp_pos=2, tp_st_percent=1.25,
                                            tp_min=-5, tp_mid=0, tp_max=5)
    # adding out of service 3w trafo should not change results
    pp.create_transformer3w_from_parameters(net, hv_bus=b2, mv_bus=b3, lv_bus=b4, vn_hv_kv=20,
                                            vn_mv_kv=.6, vn_lv_kv=.4, sn_hv_kva=1000, sn_mv_kva=700,
                                            sn_lv_kva=300, vsc_hv_percent=2., vscr_hv_percent=.3,
                                            vsc_mv_percent=1., vscr_mv_percent=.2,
                                            vsc_lv_percent=.5, vscr_lv_percent=.1, pfe_kw=50.,
                                            i0_percent=1., name="test", in_service=False,
                                            index=pp.get_free_id(net.trafo3w) + 1)
    net.last_added_case = "test_trafo3w"
    return net
Example #3
0
def test_drop_inactive_elements():
    for service in (False, True):
        net = pp.create_empty_network()
        bus_sl = pp.create_bus(net, vn_kv=.4, in_service=service)
        pp.create_ext_grid(net, bus_sl, in_service=service)
        bus0 = pp.create_bus(net, vn_kv=.4, in_service=service)
        pp.create_switch(net, bus_sl, bus0, 'b', not service)
        bus1 = pp.create_bus(net, vn_kv=.4, in_service=service)
        pp.create_transformer(net, bus0, bus1, in_service=service,
                              std_type='63 MVA 110/20 kV')
        bus2 = pp.create_bus(net, vn_kv=.4, in_service=service)
        pp.create_line(net, bus1, bus2, length_km=1, in_service=service,
                       std_type='149-AL1/24-ST1A 10.0')
        pp.create_load(net, bus2, p_mw=0., in_service=service)
        pp.create_sgen(net, bus2, p_mw=0., in_service=service)
        bus3 = pp.create_bus(net, vn_kv=.4, in_service=service)
        bus4 = pp.create_bus(net, vn_kv=.4, in_service=service)
        pp.create_transformer3w_from_parameters(net, bus2, bus3, bus4, 0.4, 0.4, 0.4, 100, 50, 50,
                                                3, 3, 3, 1, 1, 1, 5, 1)
        # drop them
        tb.drop_inactive_elements(net)

        sum_of_elements = 0
        for element, table in net.items():
            # skip this one since we expect items here
            if element.startswith("_") or not isinstance(table, pd.DataFrame):
                continue
            try:
                if service and (element == 'ext_grid' or (element == 'bus' and len(net.bus) == 1)):
                    # if service==True, the 1 ext_grid and its bus are not dropped
                    continue
                if len(table) > 0:
                    sum_of_elements += len(table)
                    print(element)
            except TypeError:
                # _ppc is initialized with None and clashes when checking
                continue

        assert sum_of_elements == 0
        if service:
            assert len(net.ext_grid) == 1
            assert len(net.bus) == 1
            assert bus_sl in net.bus.index.values

    net = pp.create_empty_network()

    bus0 = pp.create_bus(net, vn_kv=.4, in_service=True)
    pp.create_ext_grid(net, bus0, in_service=True)
    bus1 = pp.create_bus(net, vn_kv=.4, in_service=False)
    pp.create_line(net, bus0, bus1, length_km=1, in_service=False,
                   std_type='149-AL1/24-ST1A 10.0')
    gen0 = pp.create_gen(net, bus=bus1, p_mw=0.001)

    tb.drop_inactive_elements(net)

    assert gen0 not in net.gen.index
Example #4
0
def test_transformer3w_phase_shift():
    test_ref = ((0.9995, -31.003), (0.9996, -60.764))
    test_tap_pos = {
        'hv': ((0.9615, -31.466), (0.9617, -61.209)),
        'mv': ((1.0389, -30.620), (0.9996, -60.764)),
        'lv': ((0.9995, -31.003), (1.039, -60.381))
    }
    test_tap_neg = {
        'hv': ((1.0405, -30.511), (1.0406, -60.291)),
        'mv': ((0.9602, -31.417), (0.9996, -60.764)),
        'lv': ((0.9995, -31.003), (0.9603, -61.178))
    }
    for side in ["hv", "mv", "lv"]:
        net = pp.create_empty_network()
        b1 = pp.create_bus(net, vn_kv=110.)
        pp.create_ext_grid(net, b1)
        b2 = pp.create_bus(net, vn_kv=20.)
        pp.create_load(net, b2, p_mw=10)
        b3 = pp.create_bus(net, vn_kv=0.4)
        pp.create_load(net, b3, p_mw=1)
        pp.create_transformer3w_from_parameters(net, hv_bus=b1, mv_bus=b2, lv_bus=b3, vn_hv_kv=110,
                                                vn_mv_kv=20, vn_lv_kv=0.4, sn_hv_mva=40,
                                                sn_mv_mva=30, sn_lv_mva=10,
                                                vk_hv_percent=5, vk_mv_percent=5,
                                                vk_lv_percent=5, vkr_hv_percent=0.1,
                                                vkr_mv_percent=0.1, vkr_lv_percent=0.1, pfe_kw=0,
                                                i0_percent=0.1, shift_mv_degree=30,
                                                shift_lv_degree=60, tap_side=side,
                                                tap_step_percent=2, tap_step_degree=10, tap_pos=0,
                                                tap_neutral=0, tap_min=-2,
                                                tap_max=2)
        pp.runpp(net, init="dc", calculate_voltage_angles=True)
        assert np.isclose(net.res_bus.vm_pu.at[b2], test_ref[0][0], rtol=1e-4)
        assert np.isclose(net.res_bus.va_degree.at[b2], test_ref[0][1], rtol=1e-4)
        assert np.isclose(net.res_bus.vm_pu.at[b3], test_ref[1][0], rtol=1e-4)
        assert np.isclose(net.res_bus.va_degree.at[b3], test_ref[1][1], rtol=1e-4)

        net.trafo3w.tap_pos.at[0] = 2
        pp.runpp(net, init="dc", calculate_voltage_angles=True)
        assert np.isclose(net.res_bus.vm_pu.at[b2], test_tap_pos[side][0][0], rtol=1e-4)
        assert np.isclose(net.res_bus.va_degree.at[b2], test_tap_pos[side][0][1], rtol=1e-4)
        assert np.isclose(net.res_bus.vm_pu.at[b3], test_tap_pos[side][1][0], rtol=1e-4)
        assert np.isclose(net.res_bus.va_degree.at[b3], test_tap_pos[side][1][1], rtol=1e-4)

        net.trafo3w.tap_pos.at[0] = -2
        pp.runpp(net, init="dc", calculate_voltage_angles=True)
        assert np.isclose(net.res_bus.vm_pu.at[b2], test_tap_neg[side][0][0], rtol=1e-4)
        assert np.isclose(net.res_bus.va_degree.at[b2], test_tap_neg[side][0][1], rtol=1e-4)
        assert np.isclose(net.res_bus.vm_pu.at[b3], test_tap_neg[side][1][0], rtol=1e-4)
        assert np.isclose(net.res_bus.va_degree.at[b3], test_tap_neg[side][1][1], rtol=1e-4)
Example #5
0
def simple_test_net():
    net = pp.create_empty_network()
    pp.set_user_pf_options(net, init='dc', calculate_voltage_angles=True)
    b0 = pp.create_bus(net, 110)
    b1 = pp.create_bus(net, 110)
    b2 = pp.create_bus(net, 20)
    b3 = pp.create_bus(net, 20)
    b4 = pp.create_bus(net, 6)

    pp.create_ext_grid(net, b0)
    pp.create_line(net, b0, b1, 10, "149-AL1/24-ST1A 110.0")

    pp.create_transformer(net, b1, b2, "25 MVA 110/20 kV", name='tr1')

    pp.create_transformer3w_from_parameters(net,
                                            b1,
                                            b3,
                                            b4,
                                            110,
                                            20,
                                            6,
                                            1e2,
                                            1e2,
                                            1e1,
                                            3,
                                            2,
                                            2,
                                            1,
                                            1,
                                            1,
                                            100,
                                            1,
                                            60,
                                            30,
                                            'hv',
                                            tap_step_percent=1.5,
                                            tap_step_degree=0,
                                            tap_pos=0,
                                            tap_neutral=0,
                                            tap_max=10,
                                            tap_min=-10,
                                            name='tr2')

    pp.create_load(net, b2, 1.5e1, 1, name='trafo1')
    pp.create_load(net, b3, 3e1, 1.5, name='trafo2_mv')
    pp.create_load(net, b4, 2, -0.15, name='trafo2_lv')

    return net
def add_test_trafo3w_tap(net):
    b1, b2, ln = add_grid_connection(net, zone="test_trafo3w_tap")
    b3 = pp.create_bus(net, vn_kv=0.6, zone="test_trafo3w_tap")
    pp.create_load(net, b3, p_kw=300, q_kvar=100)
    b4 = pp.create_bus(net, vn_kv=0.4, zone="test_trafo3w_tap")
    pp.create_load(net, b4, p_kw=200, q_kvar=50)
    t4 = pp.create_transformer3w_from_parameters(net,
                                                 hv_bus=b2,
                                                 mv_bus=b3,
                                                 lv_bus=b4,
                                                 vn_hv_kv=20,
                                                 vn_mv_kv=.6,
                                                 vn_lv_kv=.4,
                                                 sn_hv_kva=1000,
                                                 sn_mv_kva=700,
                                                 sn_lv_kva=300,
                                                 vsc_hv_percent=2.,
                                                 vscr_hv_percent=.3,
                                                 vsc_mv_percent=1.,
                                                 vscr_mv_percent=.2,
                                                 vsc_lv_percent=.5,
                                                 vscr_lv_percent=.1,
                                                 pfe_kw=50.,
                                                 i0_percent=1.,
                                                 name="test",
                                                 tp_side="hv",
                                                 tp_pos=-1,
                                                 tp_mid=0,
                                                 tp_min=-2,
                                                 tp_max=2,
                                                 tp_st_percent=1.25)
    net.last_added_case = "test_trafo3w_tap"
    return net
Example #7
0
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
Example #8
0
def network_with_trafo3ws():
    net = pp.create_empty_network()
    add_test_trafo(net)
    slack, hv, ln = add_grid_connection(net, zone="test_trafo3w")
    for _ in range(2):
        mv = pp.create_bus(net, vn_kv=0.6, zone="test_trafo3w")
        pp.create_load(net, mv, p_mw=0.8, q_mvar=0)
        lv = pp.create_bus(net, vn_kv=0.4, zone="test_trafo3w")
        pp.create_load(net, lv, p_mw=0.5, q_mvar=0)
        t3 = pp.create_transformer3w_from_parameters(net, hv_bus=hv, mv_bus=mv, lv_bus=lv, vn_hv_kv=22,
                                                vn_mv_kv=.64, vn_lv_kv=.42, sn_hv_mva=1,
                                                sn_mv_mva=0.7, sn_lv_mva=0.3, vk_hv_percent=1.,
                                                vkr_hv_percent=.03, vk_mv_percent=.5,
                                                vkr_mv_percent=.02, vk_lv_percent=.25,
                                                vkr_lv_percent=.01, pfe_kw=.5, i0_percent=0.1,
                                                name="test", index=pp.get_free_id(net.trafo3w) + 1,
                                                tap_side="hv", tap_pos=2, tap_step_percent=1.25,
                                                tap_min=-5, tap_neutral=0, tap_max=5)
    return (net, t3, hv, mv, lv)
def test_create_switches_raise_except():
    net = pp.create_empty_network()
    # standard
    b1 = pp.create_bus(net, 110)
    b2 = pp.create_bus(net, 110)
    b3 = pp.create_bus(net, 15)
    b4 = pp.create_bus(net, 15)
    b5 = pp.create_bus(net, 0.9)
    b6 = pp.create_bus(net, 0.4)
    l1 = pp.create_line(net, b1, b2, length_km=1, std_type="48-AL1/8-ST1A 10.0")
    t1 = pp.create_transformer(net, b2, b3, std_type='160 MVA 380/110 kV')
    t3w1 = pp.create_transformer3w_from_parameters(
        net,
        hv_bus=b4, mv_bus=b5, lv_bus=b6,
        vn_hv_kv=15., vn_mv_kv=0.9, vn_lv_kv=0.45, sn_hv_mva=0.6, sn_mv_mva=0.5,
        sn_lv_mva=0.4, vk_hv_percent=1., vk_mv_percent=1., vk_lv_percent=1.,
        vkr_hv_percent=0.3, vkr_mv_percent=0.3, vkr_lv_percent=0.3,
        pfe_kw=0.2, i0_percent=0.3, tap_neutral=0.
    )
    sw = pp.create_switch(net, bus=b1, element=l1, et="l", z_ohm=0.)
    with pytest.raises(UserWarning, match=r"Switches with indexes \[0\] already exist."):
        pp.create_switches(net, buses=[b1, b2, b3], elements=[l1, t1, b4], et=["l", "t", "b"], z_ohm=0.,
                           index=[sw, 1, 2])

    with pytest.raises(UserWarning, match=r"Cannot attach to buses \{6\}, they do not exist"):
        pp.create_switches(net, buses=[6, b2, b3], elements=[l1, t1, b4], et=["l", "t", "b"], z_ohm=0.)

    with pytest.raises(UserWarning, match="Line 1 does not exist"):
        pp.create_switches(net, buses=[b1, b2, b3], elements=[1, t1, b4], et=["l", "t", "b"], z_ohm=0.)
    with pytest.raises(UserWarning, match="Line %s not connected to bus %s" % (l1, b3)):
        pp.create_switches(net, buses=[b3, b2, b3], elements=[l1, t1, b4], et=["l", "t", "b"], z_ohm=0.)
    with pytest.raises(UserWarning, match="Trafo 1 does not exist"):
        pp.create_switches(net, buses=[b1, b2, b3], elements=[l1, 1, b4], et=["l", "t", "b"], z_ohm=0.)
    with pytest.raises(UserWarning, match="Trafo %s not connected to bus %s" % (t1, b1)):
        pp.create_switches(net, buses=[b1, b1, b3], elements=[l1, t1, b4], et=["l", "t", "b"], z_ohm=0.)
    with pytest.raises(UserWarning, match=r"Cannot attach to bus 6, bus does not exist"):
        pp.create_switches(net, buses=[b1, b2, b3], elements=[l1, t1, 6], et=["l", "t", "b"], z_ohm=0.)
    with pytest.raises(UserWarning, match="Trafo3w 1 does not exist"):
        pp.create_switches(net, buses=[b1, b2, b3], elements=[l1, t1, 1], et=["l", "t", "t3"], z_ohm=0.)
    with pytest.raises(UserWarning, match="Trafo3w %s not connected to bus %s" % (t3w1, b3)):
        pp.create_switches(net, buses=[b1, b2, b3], elements=[l1, t1, t3w1], et=["l", "t", "t3"], z_ohm=0.)
Example #10
0
    bus4 = pp.create_bus(net, vn_kv=110.)
    bus5 = pp.create_bus(net, vn_kv=110.)

    bus6 = 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,
                                            vsc_hv_percent=10.,
                                            vsc_mv_percent=10.,
                                            vsc_lv_percent=10.,
                                            vscr_hv_percent=0.5,
                                            vscr_mv_percent=0.5,
                                            vscr_lv_percent=0.5,
                                            pfe_kw=100.,
                                            i0_percent=0.1,
                                            shift_mv_degree=0,
                                            shift_lv_degree=0,
                                            sn_hv_kva=100e3,
                                            sn_mv_kva=50e3,
                                            sn_lv_kva=50e3)
    net.trafo3w["max_loading_percent"] = 50

    #create 110 kV lines
    pp.create_line(net,
                   bus2,
                   bus3,
def iec_60909_4():
    net = pp.create_empty_network()

    b1 = pp.create_bus(net, vn_kv=380.)
    b2 = pp.create_bus(net, vn_kv=110.)
    b3 = pp.create_bus(net, vn_kv=110.)
    b4 = pp.create_bus(net, vn_kv=110.)
    b5 = pp.create_bus(net, vn_kv=110.)
    b6 = pp.create_bus(net, vn_kv=10.)
    b7 = pp.create_bus(net, vn_kv=10.)
    b8 = pp.create_bus(net, vn_kv=30.)
    H = pp.create_bus(net, vn_kv=30.)
    HG1 = pp.create_bus(net, vn_kv=21.)
    HG2 = pp.create_bus(net, vn_kv=10.5)  # 10.5kV?
    T_T5 = pp.create_bus(net, vn_kv=10.5)
    T_T6 = pp.create_bus(net, vn_kv=10.5)

    pp.create_ext_grid(net, b1, s_sc_max_mva=38 * 380 * np.sqrt(3), rx_max=0.1)
    pp.create_ext_grid(net, b5, s_sc_max_mva=16 * 110 * np.sqrt(3), rx_max=0.1)

    pp.create_gen(net,
                  HG2,
                  p_mw=0.9 * 100,
                  vn_kv=10.5,
                  xdss_pu=0.16,
                  rdss_pu=0.005,
                  cos_phi=0.9,
                  sn_mva=100)
    pp.create_gen(net,
                  HG1,
                  p_mw=0.85 * 150,
                  vn_kv=21,
                  xdss_pu=0.14,
                  rdss_pu=0.002,
                  cos_phi=0.85,
                  sn_mva=150)
    pp.create_gen(net,
                  b6,
                  p_mw=0.8 * 10,
                  vn_kv=10.5,
                  xdss_pu=0.1,
                  rdss_pu=0.018,
                  cos_phi=0.8,
                  sn_mva=10)

    pp.create_transformer_from_parameters(
        net,
        b4,
        HG1,
        sn_mva=150,
        pfe_kw=0,
        i0_percent=0,  # FIXME: Optional for SC
        vn_hv_kv=115.,
        vn_lv_kv=21,
        vk_percent=16,
        vkr_percent=0.5)
    pp.create_transformer_from_parameters(net,
                                          b3,
                                          HG2,
                                          sn_mva=100,
                                          pfe_kw=0,
                                          i0_percent=0,
                                          vn_hv_kv=120.,
                                          vn_lv_kv=10.5,
                                          vk_percent=12,
                                          vkr_percent=0.5)

    pp.create_transformer3w_from_parameters(
        net,
        hv_bus=b1,
        mv_bus=b2,
        lv_bus=H,
        vn_hv_kv=400,
        vn_mv_kv=120,
        vn_lv_kv=30,
        sn_hv_mva=350,
        sn_mv_mva=350,
        sn_lv_mva=50,
        pfe_kw=0,
        i0_percent=0,  # FIXME: Optional for SC
        vk_hv_percent=21,
        vkr_hv_percent=.26,
        vk_mv_percent=10,
        vkr_mv_percent=.16,
        vk_lv_percent=7.,
        vkr_lv_percent=.16)
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=b8,
                                            vn_hv_kv=400,
                                            vn_mv_kv=120,
                                            vn_lv_kv=30,
                                            sn_hv_mva=350,
                                            sn_mv_mva=350,
                                            sn_lv_mva=50,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=21,
                                            vkr_hv_percent=.26,
                                            vk_mv_percent=10,
                                            vkr_mv_percent=.16,
                                            vk_lv_percent=7.,
                                            vkr_lv_percent=.16)

    pp.create_transformer3w_from_parameters(
        net,
        hv_bus=b5,
        mv_bus=b6,
        lv_bus=T_T5,
        vn_hv_kv=115.,
        vn_mv_kv=10.5,
        vn_lv_kv=10.5,
        sn_hv_mva=31.5,
        sn_mv_mva=31.5,
        sn_lv_mva=31.5,
        pfe_kw=0,
        i0_percent=0,  # FIXME: Optional for SC
        vk_hv_percent=12,
        vkr_hv_percent=.5,
        vk_mv_percent=12,
        vkr_mv_percent=.5,
        vk_lv_percent=12,
        vkr_lv_percent=.5)
    pp.create_transformer3w_from_parameters(
        net,
        hv_bus=b5,
        mv_bus=b6,
        lv_bus=T_T6,
        vn_hv_kv=115.,
        vn_mv_kv=10.5,
        vn_lv_kv=10.5,
        sn_hv_mva=31.5,
        sn_mv_mva=31.5,
        sn_lv_mva=31.5,
        pfe_kw=0,
        i0_percent=0,  # FIXME: Optional for SC
        vk_hv_percent=12,
        vkr_hv_percent=.5,
        vk_mv_percent=12,
        vkr_mv_percent=.5,
        vk_lv_percent=12,
        vkr_lv_percent=.5)

    # pp.create_transformer_from_parameters(net, b5, b6, sn_mva=31.5,
    #     pfe_kw=0, i0_percent=0,  # FIXME: Optional for SC
    #     vn_hv_kv=115., vn_lv_kv=10.5, vk_percent=12, vkr_percent=0.5)
    # pp.create_transformer_from_parameters(net, b5, b6, sn_mva=31.5,
    #     pfe_kw=0, i0_percent=0,  # FIXME: Optional for SC
    #     vn_hv_kv=115., vn_lv_kv=10.5, vk_percent=12, vkr_percent=0.5)

    # First try without motor in powerfactory
    # pp.create_motor(net, b7, p_mw=5.0, sn_mva=5.0 / 0.88,  k=5, rx=0.1)  # FIXME: R/X
    # pp.create_motor(net, b7, p_mw=2.0, sn_mva=2.0 / 0.89, k=5.2, rx=0.1)
    # pp.create_motor(net, b7, p_mw=2.0, sn_mva=2.0 / 0.89, k=5.2, rx=0.1)

    pp.create_line_from_parameters(
        net,
        b2,
        b3,
        name="L1",
        c_nf_per_km=0,
        max_i_ka=0,  # FIXME: Optional for SC
        length_km=20,
        r_ohm_per_km=0.12,
        x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b3,
                                   b4,
                                   name="L2",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3a",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3b",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b3,
                                   name="L4",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.096,
                                   x_ohm_per_km=0.388)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b4,
                                   name="L5",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=15,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b6,
                                   b7,
                                   name="L6",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=1,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)

    return net
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)
Example #13
0
def test_trafo3w_switches():
    net = pp.create_empty_network()
    add_test_trafo(net)
    slack, hv, ln = add_grid_connection(net, zone="test_trafo3w")
    for _ in range(2):
        mv = pp.create_bus(net, vn_kv=0.6, zone="test_trafo3w")
        pp.create_load(net, mv, p_kw=800, q_kvar=0)
        lv = pp.create_bus(net, vn_kv=0.4, zone="test_trafo3w")
        pp.create_load(net, lv, p_kw=500, q_kvar=0)
        t3 = pp.create_transformer3w_from_parameters(
            net,
            hv_bus=hv,
            mv_bus=mv,
            lv_bus=lv,
            vn_hv_kv=22,
            vn_mv_kv=.64,
            vn_lv_kv=.42,
            sn_hv_kva=1000,
            sn_mv_kva=700,
            sn_lv_kva=300,
            vsc_hv_percent=1.,
            vscr_hv_percent=.03,
            vsc_mv_percent=.5,
            vscr_mv_percent=.02,
            vsc_lv_percent=.25,
            vscr_lv_percent=.01,
            pfe_kw=.5,
            i0_percent=0.1,
            name="test",
            index=pp.get_free_id(net.trafo3w) + 1,
            tp_side="hv",
            tp_pos=2,
            tp_st_percent=1.25,
            tp_min=-5,
            tp_mid=0,
            tp_max=5)
    # open switch at hv side - t3 is disconnected
    s1 = pp.create_switch(net, bus=hv, element=t3, et="t3", closed=False)
    runpp_with_consistency_checks(net)
    assert np.isnan(net.res_bus.vm_pu.at[mv])
    assert np.isnan(net.res_bus.vm_pu.at[lv])
    assert np.isnan(net.res_trafo3w.p_hv_kw.at[t3]) == 0

    # open switch at mv side - mv is disconnected, lv is connected
    net.switch.bus.at[s1] = mv
    runpp_with_consistency_checks(net)

    assert np.isnan(net.res_bus.vm_pu.at[mv])
    assert not np.isnan(net.res_bus.vm_pu.at[lv])
    assert net.res_trafo3w.i_lv_ka.at[t3] > 1e-5
    assert net.res_trafo3w.i_mv_ka.at[t3] < 1e-5
    assert 490 < net.res_trafo3w.p_hv_kw.at[t3] < 510

    # open switch at lv side - lv is disconnected, mv is connected
    net.switch.bus.at[s1] = lv
    runpp_with_consistency_checks(net)

    assert np.isnan(net.res_bus.vm_pu.at[lv])
    assert not np.isnan(net.res_bus.vm_pu.at[mv])
    assert net.res_trafo3w.i_lv_ka.at[t3] < 1e-5
    assert net.res_trafo3w.i_mv_ka.at[t3] > 1e-5
    assert 790 < net.res_trafo3w.p_hv_kw.at[t3] < 810

    # open switch at lv and mv side - lv and mv is disconnected, t3 in open loop
    pp.create_switch(net, bus=mv, element=t3, et="t3", closed=False)
    runpp_with_consistency_checks(net)

    assert np.isnan(net.res_bus.vm_pu.at[lv])
    assert np.isnan(net.res_bus.vm_pu.at[mv])
    assert net.res_trafo3w.i_lv_ka.at[t3] < 1e-5
    assert net.res_trafo3w.i_mv_ka.at[t3] < 1e-5
    assert 0 < net.res_trafo3w.p_hv_kw.at[t3] < 1
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_kva=40000,
                                        sn_mv_kva=15000,
                                        sn_lv_kva=25000,
                                        vsc_hv_percent=10.1,
                                        vsc_mv_percent=10.1,
                                        vsc_lv_percent=10.1,
                                        vscr_hv_percent=0.266667,
                                        vscr_mv_percent=0.033333,
                                        vscr_lv_percent=0.04,
                                        pfe_kw=0,
                                        i0_percent=0,
                                        shift_mv_degree=30,
                                        shift_lv_degree=30,
                                        tp_side="hv",
                                        tp_mid=0,
                                        tp_min=-8,
                                        tp_max=8,
                                        tp_st_percent=1.25,
                                        tp_pos=0,
                                        name='HV-MV-MV-Trafo')

# show transformer3w table
Example #15
0
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_kva=300000,
                                          vn_hv_kv=380,
                                          vn_lv_kv=110,
                                          vscr_percent=0.06,
                                          vsc_percent=8,
                                          pfe_kw=0,
                                          i0_percent=0,
                                          tp_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_kva=400,
                                          vn_hv_kv=10,
                                          vn_lv_kv=0.4,
                                          vscr_percent=1.325,
                                          vsc_percent=4,
                                          pfe_kw=0.95,
                                          i0_percent=0.2375,
                                          tp_side="hv",
                                          tp_mid=0,
                                          tp_min=-2,
                                          tp_max=2,
                                          tp_st_percent=2.5,
                                          tp_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_kva=40000,
                                            sn_mv_kva=15000,
                                            sn_lv_kva=25000,
                                            vsc_hv_percent=10.1,
                                            vsc_mv_percent=10.1,
                                            vsc_lv_percent=10.1,
                                            vscr_hv_percent=0.266667,
                                            vscr_mv_percent=0.033333,
                                            vscr_lv_percent=0.04,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            shift_mv_degree=30,
                                            shift_lv_degree=30,
                                            tp_side="hv",
                                            tp_mid=0,
                                            tp_min=-8,
                                            tp_max=8,
                                            tp_st_percent=1.25,
                                            tp_pos=0,
                                            name='HV-MV-MV-Trafo')

    # --- Static generators

    # HV
    pp.create_sgen(net,
                   pp.get_element_index(net, "bus", 'Bus SB 5'),
                   p_kw=-20000,
                   q_kvar=-4000,
                   sn_kva=45000,
                   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'] = [-500, -500, -15000, -2000]
    mv_sgens['q'] = [0, -50, -3000, -100]
    mv_sgens['sn'] = [750, 1000, 20000, 5000]
    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_kw=sgen.p,
                       q_kvar=sgen.q,
                       sn_kva=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'] = [-6, -5, -5, -5, -5, -5]
    lv_sgens['q'] = 0
    lv_sgens['sn'] = [12, 10, 10, 10, 10, 10]
    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_kw=sgen.p,
                       q_kvar=sgen.q,
                       sn_kva=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'] = 38000
    hv_loads['q'] = 6000

    for _, load in hv_loads.iterrows():
        bus_idx = pp.get_element_index(net, "bus", load.bus)
        pp.create_load(net,
                       bus_idx,
                       p_kw=load.p,
                       q_kvar=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'] = [6000, 18000, 400, 400, 400, 400, 400, 400]
    mv_loads['q'] = [2000, 4000, 100, 60, 60, 60, 60, 60]

    for _, load in mv_loads.iterrows():
        bus_idx = pp.get_element_index(net, "bus", load.bus)
        pp.create_load(net,
                       bus_idx,
                       p_kw=load.p,
                       q_kvar=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'] = [100] + [10] * 11
    lv_loads['q'] = [10] + [3] * 11

    for _, load in lv_loads.iterrows():
        bus_idx = pp.get_element_index(net, "bus", load.bus)
        pp.create_load(net,
                       bus_idx,
                       p_kw=load.p,
                       q_kvar=load.q,
                       name=load.load_name)

    # --- Other

    # Shunt
    pp.create_shunt(net,
                    pp.get_element_index(net, "bus", 'Bus HV1'),
                    p_kw=0,
                    q_kvar=-960,
                    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_kw=-1e5,
                  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_kva=100000,
                        name='Impedance')

    # xwards
    pp.create_xward(net,
                    pp.get_element_index(net, "bus", 'Bus HV3'),
                    ps_kw=23942,
                    qs_kvar=-12241.87,
                    pz_kw=2814.571,
                    qz_kvar=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_kw=3776,
                    qs_kvar=-7769.979,
                    pz_kw=9174.917,
                    qz_kvar=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
Example #16
0
def iec_60909_4_small(with_xward=False):
    net = pp.create_empty_network()
    net.sn_mva = 23

    b1 = pp.create_bus(net, vn_kv=380.)
    b2 = pp.create_bus(net, vn_kv=110.)
    b3 = pp.create_bus(net, vn_kv=110.)
    b5 = pp.create_bus(net, vn_kv=110.)
    b8 = pp.create_bus(net, vn_kv=30.)
    H = pp.create_bus(net, vn_kv=30.)
    HG2 = pp.create_bus(net, vn_kv=10)

    pp.create_ext_grid(net,
                       b1,
                       s_sc_max_mva=38 * 380 * np.sqrt(3),
                       rx_max=0.1,
                       x0x_max=3,
                       r0x0_max=0.15)
    pp.create_ext_grid(net,
                       b5,
                       s_sc_max_mva=16 * 110 * np.sqrt(3),
                       rx_max=0.1,
                       x0x_max=3.3,
                       r0x0_max=0.2)

    t1 = pp.create_transformer_from_parameters(net,
                                               b3,
                                               HG2,
                                               sn_mva=100,
                                               pfe_kw=0,
                                               i0_percent=0,
                                               vn_hv_kv=120.,
                                               vn_lv_kv=10.5,
                                               vk_percent=12,
                                               vkr_percent=0.5,
                                               vk0_percent=12,
                                               vkr0_percent=0.5,
                                               mag0_percent=100,
                                               mag0_rx=0,
                                               si0_hv_partial=0.5,
                                               shift_degree=5,
                                               vector_group="YNd")
    pp.create_gen(net,
                  HG2,
                  p_mw=0.9 * 100,
                  vn_kv=10.5,
                  xdss_pu=0.16,
                  rdss_ohm=0.005,
                  cos_phi=0.9,
                  sn_mva=100,
                  pg_percent=7.5,
                  slack=True,
                  power_station_trafo=t1)

    pp.create_transformer3w_from_parameters(
        net,
        hv_bus=b1,
        mv_bus=b2,
        lv_bus=H,
        vn_hv_kv=400,
        vn_mv_kv=120,
        vn_lv_kv=30,
        sn_hv_mva=350,
        sn_mv_mva=350,
        sn_lv_mva=50,
        pfe_kw=0,
        i0_percent=0,  # FIXME: Optional for SC
        vk_hv_percent=21,
        vkr_hv_percent=.26,
        vk_mv_percent=7,
        vkr_mv_percent=.16,
        vk_lv_percent=10.,
        vkr_lv_percent=.16)
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=b8,
                                            vn_hv_kv=400,
                                            vn_mv_kv=120,
                                            vn_lv_kv=30,
                                            sn_hv_mva=350,
                                            sn_mv_mva=350,
                                            sn_lv_mva=50,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=21,
                                            vkr_hv_percent=.26,
                                            vk_mv_percent=7,
                                            vkr_mv_percent=.16,
                                            vk_lv_percent=10.,
                                            vkr_lv_percent=.16)

    pp.create_line_from_parameters(
        net,
        b2,
        b3,
        name="L1",
        c_nf_per_km=0,
        max_i_ka=0,  # FIXME: Optional for SC
        length_km=20,
        r_ohm_per_km=0.12,
        x_ohm_per_km=0.39,
        r0_ohm_per_km=0.32,
        x0_ohm_per_km=1.26,
        c0_nf_per_km=0,
        g0_us_per_km=0)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3a",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39,
                                   r0_ohm_per_km=0.52,
                                   x0_ohm_per_km=1.86,
                                   c0_nf_per_km=0,
                                   g0_us_per_km=0)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3b",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39,
                                   r0_ohm_per_km=0.52,
                                   x0_ohm_per_km=1.86,
                                   c0_nf_per_km=0,
                                   g0_us_per_km=0)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b3,
                                   name="L4",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.096,
                                   x_ohm_per_km=0.388,
                                   r0_ohm_per_km=0.22,
                                   x0_ohm_per_km=1.1,
                                   c0_nf_per_km=0,
                                   g0_us_per_km=0)

    if with_xward:
        pp.create_xward(net, b5, 1, 0, 0, 0, 10, 20, 1)

    return net
Example #17
0
def iec_60909_4():
    net = pp.create_empty_network()
    net.sn_mva = 23

    b1 = pp.create_bus(net, vn_kv=380.)
    b2 = pp.create_bus(net, vn_kv=110.)
    b3 = pp.create_bus(net, vn_kv=110.)
    b4 = pp.create_bus(net, vn_kv=110.)
    b5 = pp.create_bus(net, vn_kv=110.)
    b6 = pp.create_bus(net, vn_kv=10.)
    b7 = pp.create_bus(net, vn_kv=10.)
    b8 = pp.create_bus(net, vn_kv=30.)

    HG1 = pp.create_bus(net, vn_kv=20)
    HG2 = pp.create_bus(net, vn_kv=10)  # 10.5kV?
    T_T5 = pp.create_bus(net, vn_kv=10)
    T_T6 = pp.create_bus(net, vn_kv=10)
    H = pp.create_bus(net, vn_kv=30.)

    pp.create_ext_grid(net, b1, s_sc_max_mva=38 * 380 * np.sqrt(3), rx_max=0.1)
    pp.create_ext_grid(net, b5, s_sc_max_mva=16 * 110 * np.sqrt(3), rx_max=0.1)

    # t1 = pp.create_transformer_from_parameters(net, b4, HG1, sn_mva=150,
    #     pfe_kw=0, i0_percent=0,
    #     vn_hv_kv=115., vn_lv_kv=21, vk_percent=16, vkr_percent=0.5,
    #     pt_percent=12, oltc=True)
    t1 = pp.create_transformers_from_parameters(net, [b4], [HG1],
                                                sn_mva=[150],
                                                pfe_kw=[0],
                                                i0_percent=[0],
                                                vn_hv_kv=[115.],
                                                vn_lv_kv=[21],
                                                vk_percent=[16],
                                                vkr_percent=[0.5],
                                                pt_percent=[12],
                                                oltc=[True])
    pp.create_gen(net,
                  HG1,
                  p_mw=0.85 * 150,
                  vn_kv=21,
                  xdss_pu=0.14,
                  rdss_ohm=0.002,
                  cos_phi=0.85,
                  sn_mva=150,
                  pg_percent=0,
                  power_station_trafo=t1[0])

    t2 = pp.create_transformer_from_parameters(net,
                                               b3,
                                               HG2,
                                               sn_mva=100,
                                               pfe_kw=0,
                                               i0_percent=0,
                                               vn_hv_kv=120.,
                                               vn_lv_kv=10.5,
                                               vk_percent=12,
                                               vkr_percent=0.5,
                                               oltc=False)
    pp.create_gen(net,
                  HG2,
                  p_mw=0.9 * 100,
                  vn_kv=10.5,
                  xdss_pu=0.16,
                  rdss_ohm=0.005,
                  cos_phi=0.9,
                  sn_mva=100,
                  pg_percent=7.5,
                  slack=True,
                  power_station_trafo=t2)

    # # Add gen 3
    # pp.create_gen(net, b6, p_mw=0.9 * 100, vn_kv=10.5,
    #               xdss_pu=0.1, rdss_ohm=0.018, cos_phi=0.8, sn_mva=10, pg_percent=5)
    # Add gen 3
    pp.create_gen(net,
                  b6,
                  p_mw=0.9 * 100,
                  vn_kv=10.5,
                  xdss_pu=0.1,
                  rdss_ohm=0.018,
                  cos_phi=0.8,
                  sn_mva=10,
                  pg_percent=0)

    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=H,
                                            vn_hv_kv=400,
                                            vn_mv_kv=120,
                                            vn_lv_kv=30,
                                            sn_hv_mva=350,
                                            sn_mv_mva=350,
                                            sn_lv_mva=50,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=21,
                                            vkr_hv_percent=.26,
                                            vk_mv_percent=7,
                                            vkr_mv_percent=.16,
                                            vk_lv_percent=10.,
                                            vkr_lv_percent=.16)
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=b8,
                                            vn_hv_kv=400,
                                            vn_mv_kv=120,
                                            vn_lv_kv=30,
                                            sn_hv_mva=350,
                                            sn_mv_mva=350,
                                            sn_lv_mva=50,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=21,
                                            vkr_hv_percent=.26,
                                            vk_mv_percent=7,
                                            vkr_mv_percent=.16,
                                            vk_lv_percent=10.,
                                            vkr_lv_percent=.16)

    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b5,
                                            mv_bus=b6,
                                            lv_bus=T_T5,
                                            vn_hv_kv=115.,
                                            vn_mv_kv=10.5,
                                            vn_lv_kv=10.5,
                                            sn_hv_mva=31.5,
                                            sn_mv_mva=31.5,
                                            sn_lv_mva=31.5,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=12,
                                            vkr_hv_percent=.5,
                                            vk_mv_percent=12,
                                            vkr_mv_percent=.5,
                                            vk_lv_percent=12,
                                            vkr_lv_percent=.5)
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b5,
                                            mv_bus=b6,
                                            lv_bus=T_T6,
                                            vn_hv_kv=115.,
                                            vn_mv_kv=10.5,
                                            vn_lv_kv=10.5,
                                            sn_hv_mva=31.5,
                                            sn_mv_mva=31.5,
                                            sn_lv_mva=31.5,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=12,
                                            vkr_hv_percent=.5,
                                            vk_mv_percent=12,
                                            vkr_mv_percent=.5,
                                            vk_lv_percent=12,
                                            vkr_lv_percent=.5)

    pp.create_motor(net,
                    b7,
                    pn_mech_mw=5.0,
                    cos_phi=0.88,
                    cos_phi_n=0.88,
                    efficiency_n_percent=97.5,
                    vn_kv=10,
                    rx=0.1,
                    lrc_pu=5)
    for _ in range(2):
        pp.create_motor(net,
                        b7,
                        pn_mech_mw=2.0,
                        cos_phi=0.89,
                        cos_phi_n=0.89,
                        efficiency_n_percent=96.8,
                        vn_kv=10,
                        rx=0.1,
                        lrc_pu=5.2)

    pp.create_line_from_parameters(
        net,
        b2,
        b3,
        name="L1",
        c_nf_per_km=0,
        max_i_ka=0,  # FIXME: Optional for SC
        length_km=20,
        r_ohm_per_km=0.12,
        x_ohm_per_km=0.39,
    )
    pp.create_line_from_parameters(net,
                                   b3,
                                   b4,
                                   name="L2",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3a",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3b",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b3,
                                   name="L4",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.096,
                                   x_ohm_per_km=0.388)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b4,
                                   name="L5",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=15,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.386)
    pp.create_line_from_parameters(net,
                                   b6,
                                   b7,
                                   name="L6",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=1,
                                   r_ohm_per_km=0.082,
                                   x_ohm_per_km=0.086)

    return net
Example #18
0
def iec_60909_4_small(n_t3=1, num_earth=1, with_gen=False):
    net = pp.create_empty_network()

    b1 = pp.create_bus(net, vn_kv=380.)
    b2 = pp.create_bus(net, vn_kv=110.)
    b3 = pp.create_bus(net, vn_kv=110.)
    b5 = pp.create_bus(net, vn_kv=110.)
    b8 = pp.create_bus(net, vn_kv=30.)
    HG2 = pp.create_bus(net, vn_kv=10)

    pp.create_ext_grid(
        net,
        b1,
        s_sc_max_mva=38 * 380 * np.sqrt(3),
        rx_max=0.1,
        x0x_max=3,
        r0x0_max=0.15,
        s_sc_min_mva=38 * 380 * np.sqrt(3) / 10,
        rx_min=0.1,
        x0x_min=3,
        r0x0_min=0.15,
    )
    pp.create_ext_grid(net,
                       b5,
                       s_sc_max_mva=16 * 110 * np.sqrt(3),
                       rx_max=0.1,
                       x0x_max=3.3,
                       r0x0_max=0.2,
                       s_sc_min_mva=16 * 110 * np.sqrt(3) / 10,
                       rx_min=0.1,
                       x0x_min=3.3,
                       r0x0_min=0.2)

    if num_earth == 1:
        vector_group = ("YYNd", "YNYd")
    else:
        vector_group = ("YNYNd", "YNYNd")

    if n_t3 == 2:
        pp.create_transformer3w_from_parameters(net,
                                                hv_bus=b1,
                                                mv_bus=b2,
                                                lv_bus=b8,
                                                vn_hv_kv=400,
                                                vn_mv_kv=120,
                                                vn_lv_kv=30,
                                                sn_hv_mva=350,
                                                sn_mv_mva=350,
                                                sn_lv_mva=50,
                                                pfe_kw=0,
                                                i0_percent=0,
                                                vk_hv_percent=21,
                                                vkr_hv_percent=.26,
                                                vk_mv_percent=7,
                                                vkr_mv_percent=.16,
                                                vk_lv_percent=10.,
                                                vkr_lv_percent=.16,
                                                vk0_hv_percent=44.1,
                                                vkr0_hv_percent=0.26,
                                                vk0_mv_percent=6.2996,
                                                vkr0_mv_percent=0.03714,
                                                vk0_lv_percent=6.2996,
                                                vkr0_lv_percent=0.03714,
                                                vector_group=vector_group[0])
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=b8,
                                            vn_hv_kv=400,
                                            vn_mv_kv=120,
                                            vn_lv_kv=30,
                                            sn_hv_mva=350,
                                            sn_mv_mva=350,
                                            sn_lv_mva=50,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=21,
                                            vkr_hv_percent=.26,
                                            vk_mv_percent=7,
                                            vkr_mv_percent=.16,
                                            vk_lv_percent=10.,
                                            vkr_lv_percent=.16,
                                            vk0_hv_percent=44.1,
                                            vkr0_hv_percent=0.26,
                                            vk0_mv_percent=6.2996,
                                            vkr0_mv_percent=0.03714,
                                            vk0_lv_percent=6.2996,
                                            vkr0_lv_percent=0.03714,
                                            vector_group=vector_group[1])

    pp.create_line_from_parameters(
        net,
        b2,
        b3,
        name="L1",
        c_nf_per_km=0,
        max_i_ka=0,  # FIXME: Optional for SC
        length_km=20,
        r_ohm_per_km=0.12,
        x_ohm_per_km=0.39,
        r0_ohm_per_km=0.32,
        x0_ohm_per_km=1.26,
        c0_nf_per_km=0,
        g0_us_per_km=0,
        endtemp_degree=80)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3a",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39,
                                   r0_ohm_per_km=0.52,
                                   x0_ohm_per_km=1.86,
                                   c0_nf_per_km=0,
                                   g0_us_per_km=0,
                                   endtemp_degree=80)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3b",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39,
                                   r0_ohm_per_km=0.52,
                                   x0_ohm_per_km=1.86,
                                   c0_nf_per_km=0,
                                   g0_us_per_km=0,
                                   endtemp_degree=80)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b3,
                                   name="L4",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.096,
                                   x_ohm_per_km=0.388,
                                   r0_ohm_per_km=0.22,
                                   x0_ohm_per_km=1.1,
                                   c0_nf_per_km=0,
                                   g0_us_per_km=0,
                                   endtemp_degree=80)

    if with_gen:
        t1 = pp.create_transformer_from_parameters(net,
                                                   b3,
                                                   HG2,
                                                   sn_mva=100,
                                                   pfe_kw=0,
                                                   i0_percent=0,
                                                   vn_hv_kv=120.,
                                                   vn_lv_kv=10.5,
                                                   vk_percent=12,
                                                   vkr_percent=0.5,
                                                   vk0_percent=12,
                                                   vkr0_percent=0.5,
                                                   mag0_percent=100,
                                                   mag0_rx=0,
                                                   si0_hv_partial=0.5,
                                                   shift_degree=5,
                                                   vector_group="YNd")
        pp.create_gen(net,
                      HG2,
                      p_mw=0.9 * 100,
                      vn_kv=10.5,
                      xdss_pu=0.16,
                      rdss_ohm=0.005,
                      cos_phi=0.9,
                      sn_mva=100,
                      pg_percent=7.5,
                      slack=True,
                      power_station_trafo=t1)

    return net
def iec_60909_4_small():
    net = pp.create_empty_network()

    b1 = pp.create_bus(net, vn_kv=380.)
    b2 = pp.create_bus(net, vn_kv=110.)
    b3 = pp.create_bus(net, vn_kv=110.)
    b5 = pp.create_bus(net, vn_kv=110.)
    b8 = pp.create_bus(net, vn_kv=30.)
    H = pp.create_bus(net, vn_kv=30.)
    HG1 = pp.create_bus(net, vn_kv=21.)
    HG2 = pp.create_bus(net, vn_kv=10)  # 10.5kV?
    T_T5 = pp.create_bus(net, vn_kv=10.5)
    T_T6 = pp.create_bus(net, vn_kv=10.5)

    pp.create_ext_grid(net, b1, s_sc_max_mva=38 * 380 * np.sqrt(3), rx_max=0.1)
    pp.create_ext_grid(net, b5, s_sc_max_mva=16 * 110 * np.sqrt(3), rx_max=0.1)

    pp.create_gen(net,
                  HG2,
                  p_mw=0.9 * 100,
                  vn_kv=10.5,
                  xdss_pu=0.16,
                  rdss_pu=0.005,
                  cos_phi=0.9,
                  sn_mva=100)

    pp.create_transformer_from_parameters(net,
                                          b3,
                                          HG2,
                                          sn_mva=100,
                                          pfe_kw=0,
                                          i0_percent=0,
                                          vn_hv_kv=120.,
                                          vn_lv_kv=10.5,
                                          vk_percent=12,
                                          vkr_percent=0.5)

    pp.create_transformer3w_from_parameters(
        net,
        hv_bus=b1,
        mv_bus=b2,
        lv_bus=H,
        vn_hv_kv=400,
        vn_mv_kv=120,
        vn_lv_kv=30,
        sn_hv_mva=350,
        sn_mv_mva=350,
        sn_lv_mva=50,
        pfe_kw=0,
        i0_percent=0,  # FIXME: Optional for SC
        vk_hv_percent=21,
        vkr_hv_percent=.26,
        vk_mv_percent=7,
        vkr_mv_percent=.16,
        vk_lv_percent=10.,
        vkr_lv_percent=.16)
    pp.create_transformer3w_from_parameters(net,
                                            hv_bus=b1,
                                            mv_bus=b2,
                                            lv_bus=b8,
                                            vn_hv_kv=400,
                                            vn_mv_kv=120,
                                            vn_lv_kv=30,
                                            sn_hv_mva=350,
                                            sn_mv_mva=350,
                                            sn_lv_mva=50,
                                            pfe_kw=0,
                                            i0_percent=0,
                                            vk_hv_percent=21,
                                            vkr_hv_percent=.26,
                                            vk_mv_percent=7,
                                            vkr_mv_percent=.16,
                                            vk_lv_percent=10.,
                                            vkr_lv_percent=.16)

    pp.create_line_from_parameters(
        net,
        b2,
        b3,
        name="L1",
        c_nf_per_km=0,
        max_i_ka=0,  # FIXME: Optional for SC
        length_km=20,
        r_ohm_per_km=0.12,
        x_ohm_per_km=0.39,
    )
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3a",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b2,
                                   b5,
                                   name="L3b",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=5,
                                   r_ohm_per_km=0.12,
                                   x_ohm_per_km=0.39)
    pp.create_line_from_parameters(net,
                                   b5,
                                   b3,
                                   name="L4",
                                   c_nf_per_km=0,
                                   max_i_ka=0,
                                   length_km=10,
                                   r_ohm_per_km=0.096,
                                   x_ohm_per_km=0.388)

    return net
Example #20
0
min_vm_pu = 0.95
max_vm_pu = 1.05

for type in types:
    #create buses
    bus1 = pp.create_bus(net[type], vn_kv=220., geodata=(5,9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
    bus2 = pp.create_bus(net[type], vn_kv=110., geodata=(6,10), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
    bus3 = pp.create_bus(net[type], vn_kv=110., geodata=(10,9), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
    bus4 = pp.create_bus(net[type], vn_kv=110., geodata=(8,8), min_vm_pu=min_vm_pu, max_vm_pu=max_vm_pu)
    bus5 = pp.create_bus(net[type], 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[type], 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=10,
                                        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
    l1 = pp.create_line(net[type], bus2, bus3, length_km=70., std_type='149-AL1/24-ST1A 110.0')
    l2 = pp.create_line(net[type], bus3, bus4, length_km=50., std_type='149-AL1/24-ST1A 110.0')
    l3 = pp.create_line(net[type], bus4, bus2, length_km=40., std_type='149-AL1/24-ST1A 110.0')
    l4 = pp.create_line(net[type], bus4, bus5, length_km=30., std_type='149-AL1/24-ST1A 110.0')

    #create loads
    pp.create_load(net[type], bus2, p_mw=60)
    pp.create_load(net[type], bus3, p_mw=70)
    pp.create_load(net[type], bus4, p_mw=10)

    #create generators