def test_dcline_dispatch2(dcline_net):
net = dcline_net
pp.create_polynomial_cost(net, 0, "ext_grid", array([.08, 0]))
pp.create_polynomial_cost(net, 1, "ext_grid", array([.1, 0]))
net.bus["max_vm_pu"] = 2
net.bus["min_vm_pu"] = 0 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net)
consistency_checks(net, rtol=1e-3)
consistency_checks(net, rtol=1e-3)
rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \
(net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100
assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values)
p_eg_expect = array([-8.21525358e+05, -5.43498903e-02])
q_eg_expect = array([7787.55852923, 21048.59213887])
assert allclose(net.res_ext_grid.p_kw.values, p_eg_expect)
assert allclose(net.res_ext_grid.q_kvar.values, q_eg_expect)
p_from_expect = array([813573.88366999])
q_from_expect = array([-26446.0473644])
assert allclose(net.res_dcline.p_from_kw.values, p_from_expect)
assert allclose(net.res_dcline.q_from_kvar.values, q_from_expect)
p_to_expect = array([-805023.64719801])
q_to_expect = array([-21736.31196315])
assert allclose(net.res_dcline.p_to_kw.values, p_to_expect)
assert allclose(net.res_dcline.q_to_kvar.values, q_to_expect)
def test_dispatch1(dcline_net):
net = dcline_net
pp.create_pwl_cost(net, 0, "ext_grid", [[-1e12, 1e9, 100]])
pp.create_pwl_cost(net, 1, "ext_grid", [[-1e12, 1e9, 80]])
net.bus["max_vm_pu"] = 2
net.bus["min_vm_pu"] = 0 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net, delta=1e-8)
consistency_checks(net)
rel_loss_expect = (net.res_dcline.pl_mw - net.dcline.loss_mw) / \
(net.res_dcline.p_from_mw - net.res_dcline.pl_mw) * 100
assert allclose(rel_loss_expect.values,
net.dcline.loss_percent.values,
rtol=1e-2)
assert allclose(net.res_ext_grid.p_mw.values, [0.5, 805], atol=0.1)
assert allclose(net.res_ext_grid.q_mvar.values,
[-7.78755773243, 0.62830727889],
atol=1e-3)
assert allclose(net.res_dcline.p_from_mw.values, [0.500754071], atol=1e-3)
assert allclose(net.res_dcline.q_from_mvar.values, [7.78745600524])
assert allclose(net.res_dcline.p_to_mw.values, array([-5.48553789e-05]))
assert allclose(net.res_dcline.q_to_mvar.values, array([-.62712636707]))
def test_dispatch1(dcline_net):
net = dcline_net
pp.create_piecewise_linear_cost(
net, 0, "ext_grid", array([[-1e12, -0.1 * 1e12], [1e12, .1 * 1e12]]))
pp.create_piecewise_linear_cost(
net, 1, "ext_grid", array([[-1e12, -0.08 * 1e12], [1e12, .08 * 1e12]]))
net.bus["max_vm_pu"] = 2
net.bus["min_vm_pu"] = 0 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net)
consistency_checks(net, rtol=1e-3)
rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \
(net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100
assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values)
p_eg_expect = array([-5.00078353e+02, -8.05091476e+05])
q_eg_expect = array([7787.55773243, -628.30727889])
assert allclose(net.res_ext_grid.p_kw.values, p_eg_expect)
assert allclose(net.res_ext_grid.q_kvar.values, q_eg_expect)
p_from_expect = array([500.0754071])
q_from_expect = array([7787.45600524])
assert allclose(net.res_dcline.p_from_kw.values, p_from_expect)
assert allclose(net.res_dcline.q_from_kvar.values, q_from_expect)
p_to_expect = array([-0.0746605])
q_to_expect = array([-627.12636707])
assert allclose(net.res_dcline.p_to_kw.values, p_to_expect)
assert allclose(net.res_dcline.q_to_kvar.values, q_to_expect)
def test_dcline_dispatch2(dcline_net):
net = dcline_net
pp.create_poly_cost(net, 0, "ext_grid", cp1_eur_per_mw=80)
pp.create_poly_cost(net, 1, "ext_grid", cp1_eur_per_mw=100)
# pp.create_poly_cost(net, 0, "ext_grid", array([.08, 0]))
# pp.create_poly_cost(net, 1, "ext_grid", array([.1, 0]))
net.bus["max_vm_pu"] = 2
net.bus["min_vm_pu"] = 0 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
# pp.runopp(net, delta=get_delta_try_except(net))
pp.runopp(net)
consistency_checks(net, rtol=1e-3)
rel_loss_expect = (net.res_dcline.pl_mw - net.dcline.loss_mw) / \
(net.res_dcline.p_from_mw - net.res_dcline.pl_mw) * 100
assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values)
p_eg_expect = array([8.21525358e+02, 5.43498903e-05])
q_eg_expect = array([-7787.55852923e-3, -21048.59213887e-3])
assert allclose(net.res_ext_grid.p_mw.values, p_eg_expect)
assert allclose(net.res_ext_grid.q_mvar.values, q_eg_expect)
p_from_expect = array([813573.88366999e-3])
q_from_expect = array([-26446.0473644e-3])
assert allclose(net.res_dcline.p_from_mw.values, p_from_expect)
assert allclose(net.res_dcline.q_from_mvar.values, q_from_expect)
p_to_expect = array([-805023.64719801e-3])
q_to_expect = array([-21736.31196315e-3])
assert allclose(net.res_dcline.p_to_mw.values, p_to_expect)
assert allclose(net.res_dcline.q_to_mvar.values, q_to_expect)
def test_dcline_dispatch3(dcline_net):
net = dcline_net
pp.create_polynomial_cost(net, 0, "dcline", array([1, 0]))
net.bus["max_vm_pu"] = 2 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net)
consistency_checks(net, rtol=1e-3)
consistency_checks(net, rtol=1e-3)
rel_loss_expect = (net.res_dcline.pl_kw - net.dcline.loss_kw) / \
(net.res_dcline.p_from_kw - net.res_dcline.pl_kw) * 100
assert allclose(rel_loss_expect.values, net.dcline.loss_percent.values)
assert abs(net.res_dcline.p_from_kw.values - net.res_cost) < 1e-3
def test_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], atol=1e-4)
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, atol=1e-4)
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, atol=1e-4)
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=50,
min_p_mw=0,
min_q_mvar=-1e6,
max_q_mvar=1e6)
pp.create_poly_cost(net, load_id, "load", cp1_eur_per_mw=-1000)
net.trafo3w.shift_lv_degree.at[tidx] = 120
net.trafo3w.shift_mv_degree.at[tidx] = 80
custom_file = os.path.join(
os.path.abspath(os.path.dirname(pp.test.__file__)), "test_files",
"run_powermodels_custom.jl")
# TODO: pp.runpm_dc gives does not seem to consider the voltage angles. Is this intended behaviour?
for run in [pp.runpm_ac_opf, partial(pp.runpm, julia_file=custom_file)]:
run(net)
consistency_checks(net)
print(net.res_bus.va_degree.at[b1] - net.res_bus.va_degree.at[b3])
print(net.res_bus.va_degree.at[b1])
print(net.res_bus.va_degree.at[b3])
assert 119.9 < net.res_trafo3w.loading_percent.at[tidx] <= 120
assert 85 < (net.res_bus.va_degree.at[b1] -
net.res_bus.va_degree.at[b3]) % 360 < 86
assert 120 < (net.res_bus.va_degree.at[b1] -
net.res_bus.va_degree.at[b4]) % 360 < 130
assert np.isnan(net.res_bus.va_degree.at[b5])
def test_compare_pwl_and_poly(net_3w_trafo_opf):
net = net_3w_trafo_opf
pp.create_pwl_cost(net, 0, 'ext_grid', [[0, 1, 1]])
pp.create_pwl_cost(net, 0, 'gen', [[0, 30, 3], [30, 80, 3]])
pp.create_pwl_cost(net, 1, 'gen', [[0, 100, 2]])
pp.runpm_ac_opf(net)
consistency_checks(net)
p_gen = net.res_gen.p_mw.values
q_gen = net.res_gen.q_mvar.values
vm_bus = net.res_bus.vm_pu.values
va_bus = net.res_bus.va_degree.values
net.pwl_cost.drop(net.pwl_cost.index, inplace=True)
pp.create_poly_cost(net, 0, 'ext_grid', cp1_eur_per_mw=1)
pp.create_poly_cost(net, 0, 'gen', cp1_eur_per_mw=3)
pp.create_poly_cost(net, 1, 'gen', cp1_eur_per_mw=2)
pp.runpm_ac_opf(net)
consistency_checks(net)
np.allclose(p_gen, net.res_gen.p_mw.values)
np.allclose(q_gen, net.res_gen.q_mvar.values)
np.allclose(vm_bus, net.res_bus.vm_pu.values)
np.allclose(va_bus, net.res_bus.va_degree.values)
pp.runpm_dc_opf(net)
consistency_checks(net)
np.allclose(p_gen, net.res_gen.p_mw.values)
np.allclose(va_bus, net.res_bus.va_degree.values)
def test_dcline_dispatch3(dcline_net):
net = dcline_net
pp.create_poly_cost(net, 4, "dcline", cp1_eur_per_mw=1.5)
net.bus["max_vm_pu"] = 1.03 # needs to be constrained more than default
net.line[
"max_loading_percent"] = 1000 # does not converge if unconstrained
pp.runopp(net)
consistency_checks(net, rtol=1e-1)
# dc line is not dispatched because of the assigned costs
assert isclose(net.res_dcline.at[4, "p_to_mw"], 0, atol=1e-2)
assert all(net.res_ext_grid.p_mw.values > 0)
# costs for ext_grid at the end of the DC line get double the costs of DC line transfer
pp.create_poly_cost(net, 1, "ext_grid", cp1_eur_per_mw=2000)
pp.runopp(net)
#now the total power is supplied through the DC line
assert (net.res_dcline.at[4, "p_to_mw"]) < 1e3
assert net.res_ext_grid.p_mw.at[1] < 1
assert isclose(net.res_cost, net.res_dcline.at[4, "p_from_mw"] * 1.5)
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_compare_pwl_and_poly(net_3w_trafo_opf):
net = net_3w_trafo_opf
net.ext_grid.loc[:, "min_p_mw"] = -999.
net.ext_grid.loc[:, "max_p_mw"] = 999.
net.ext_grid.loc[:, "max_q_mvar"] = 999.
net.ext_grid.loc[:, "min_q_mvar"] = -999.
pp.create_pwl_cost(net, 0, 'ext_grid', [[0, 1, 1]])
pp.create_pwl_cost(net, 0, 'gen', [[0, 30, 3], [30, 80, 3]])
pp.create_pwl_cost(net, 1, 'gen', [[0, 80, 2]])
net.bus.loc[:, "max_vm_pu"] = 1.1
net.bus.loc[:, "min_vm_pu"] = .9
pp.runpm_ac_opf(net)
consistency_checks(net)
p_gen = net.res_gen.p_mw.values
q_gen = net.res_gen.q_mvar.values
vm_bus = net.res_bus.vm_pu.values
va_bus = net.res_bus.va_degree.values
net.pwl_cost.drop(net.pwl_cost.index, inplace=True)
pp.create_poly_cost(net, 0, 'ext_grid', cp1_eur_per_mw=1)
pp.create_poly_cost(net, 0, 'gen', cp1_eur_per_mw=3)
pp.create_poly_cost(net, 1, 'gen', cp1_eur_per_mw=2)
# pp.runopp(net)
pp.runpm_ac_opf(net, correct_pm_network_data=False)
consistency_checks(net)
np.allclose(p_gen, net.res_gen.p_mw.values)
np.allclose(q_gen, net.res_gen.q_mvar.values)
np.allclose(vm_bus, net.res_bus.vm_pu.values)
np.allclose(va_bus, net.res_bus.va_degree.values)
# pp.rundcopp(net)
pp.runpm_dc_opf(net, correct_pm_network_data=False)
consistency_checks(net, test_q=False)
np.allclose(p_gen, net.res_gen.p_mw.values)
np.allclose(va_bus, net.res_bus.va_degree.values)
#create loads
pp.create_load(net, bus2, p_kw=60e3, controllable=False)
pp.create_load(net, bus3, p_kw=70e3, controllable=False)
pp.create_load(net, bus4, p_kw=10e3, controllable=False)
#create generators
eg = pp.create_ext_grid(net, bus1, min_p_kw=-1e9, max_p_kw=1e9)
g0 = pp.create_gen(net,
bus3,
p_kw=-80 * 1e3,
min_p_kw=-80e3,
max_p_kw=0,
vm_pu=1.01,
controllable=True)
g1 = pp.create_gen(net,
bus4,
p_kw=-100 * 1e3,
min_p_kw=-100e3,
max_p_kw=0,
vm_pu=1.01,
controllable=True)
costeg = pp.create_polynomial_cost(net, 0, 'ext_grid', np.array([-1, 0]))
costgen1 = pp.create_polynomial_cost(net, 0, 'gen', np.array([-1, 0]))
costgen2 = pp.create_polynomial_cost(net, 1, 'gen', np.array([-1, 0]))
runpm(net)
if net.OPF_converged:
from pandapower.test.consistency_checks import consistency_checks
consistency_checks(net)
def test_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)
