def test_equal_eval_name_warning_and_costs():
net = nw.case5()
pp.create_pwl_cost(net, 0, "sgen", [[0, 20, 1], [20, 30, 2]])
pp.create_pwl_cost(net, 0, "gen", [[0, 20, 1], [20, 30, 2]])
pp.create_pwl_cost(net, 1, "gen", [[0, 20, 1], [20, 30, 2]])
pp.create_pwl_cost(net, 2, "gen", [[0, 20, 1], [20, 30, 2]])
df = pd.DataFrame({
0: [200, 300, 400, 500],
1: [400, 300, 100, 50],
2: [100, 300, 200, 100]
})
ds = ts.DFData(df.astype(np.float64))
_ = ct.ConstControl(net,
"load",
"p_mw",
net.load.index,
profile_name=net.load.index,
data_source=ds)
ow = ts.OutputWriter(net, output_path=None)
ow.log_variable("res_sgen", "p_mw", None, np.max, 'warnme')
ow.log_variable("res_load", "p_mw", None, np.max, 'warnme')
ow.log_variable("pwl_cost", "points", eval_function=cost_logging)
ow.remove_log_variable("res_bus", "vm_pu")
ow.remove_log_variable("res_line", "loading_percent")
ts.run_timeseries(net, verbose=False)
p_sgen = ow.output["res_sgen.p_mw"]
p_load = ow.output["res_load.p_mw"]
cost = ow.output["pwl_cost.points"]
assert not np.all(p_sgen.values == p_load.values)
assert cost.shape == (4, 4)
assert len(ow.np_results) == 3
def test_storage_opt():
net = nw.case5()
pp.create_storage(net,
2,
p_mw=1.,
max_e_mwh=.2,
soc_percent=100.,
q_mvar=1.)
pp.create_storage(net,
3,
p_mw=1.,
max_e_mwh=.3,
soc_percent=100.,
q_mvar=1.)
# optimize for 24 time steps. At the end the SOC is 0%
storage_results = pp.runpm_storage_opf(net, n_timesteps=24)
assert np.allclose(storage_results[0].loc[22, "soc_mwh"],
0.004960,
rtol=1e-4,
atol=1e-4)
assert np.allclose(storage_results[0].loc[23, "soc_mwh"], 0.)
assert np.allclose(storage_results[1].loc[22, "soc_percent"],
29.998074,
rtol=1e-4,
atol=1e-4)
assert np.allclose(storage_results[1].loc[23, "soc_mwh"], 0.)
def test_ots_opt():
net = nw.case5()
branch_status = net["line"].loc[:, "in_service"].values
assert np.array_equal(np.array([1, 1, 1, 1, 1, 1]).astype(bool), branch_status.astype(bool))
pp.runpm_ots(net)
branch_status = net["res_line"].loc[:, "in_service"].values
pp.runpp(net)
net.line.loc[:, "in_service"] = branch_status.astype(bool)
pp.runpp(net)
try:
assert np.array_equal(np.array([1, 1, 1, 0, 1, 0]).astype(bool), branch_status.astype(bool))
except AssertionError:
assert np.array_equal(np.array([0, 1, 1, 1, 1, 0]).astype(bool), branch_status.astype(bool))
def test_case5():
net = pn.case5()
assert net.converged
_ppc_element_test(net, 5, 6, 5, False)
dev_path = pathlib.PurePath(jul_path, "dev", "PandaModels")
if os.path.exists(dev_path):
Warning("PandaModels is in development mode.")
json_path = pathlib.PurePath(dev_path, "test", "data")
else:
json_path = tempfile.gettempdir()
types = ["pm", "powerflow", "opf", "custom"]
net = {type: pp.create_empty_network()
for type in types}
net["tnep"] = pn.create_cigre_network_mv()
net["ots"] = pn.case5()
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.,
value_optimizer.step()
for target_param, param in zip(target_value_net.parameters(), value_net.parameters()):
target_param.data.copy_(
target_param.data * (1.0 - soft_tau) + param.data * soft_tau
)
for target_param, param in zip(target_policy_net.parameters(), policy_net.parameters()):
target_param.data.copy_(
target_param.data * (1.0 - soft_tau) + param.data * soft_tau
)
return value_net,policy_net,target_value_net,target_policy_net,policy_optimizer,value_optimizer,value_loss,policy_loss
env = Grid(pn.case5())
Ns=env.StateFeatures()[0]*env.StateFeatures()[1]
state_dim = Ns
action_dim = env.ActionFeature()
ou_noise = OUNoise(action_dim)
hidden_dim = 256
value_net = ValueNetwork(state_dim, action_dim, hidden_dim).to(device)
policy_net = PolicyNetwork(state_dim, action_dim, hidden_dim).to(device)
best_value_net = ValueNetwork(state_dim, action_dim, hidden_dim).to(device)
best_policy_net = PolicyNetwork(state_dim, action_dim, hidden_dim).to(device)
path = '/model'
import pandapower as pp
import pandapower.networks as pn
from numba import jit
import pandas as pd
import numpy as np
import copy
import random as rnd
#action = [rnd.uniform(-1,1) for i in range(9)]
net = pn.case5()
class Grid(object):
def __init__(self,
net,
max_loading=1,
Vbusmax=1.03,
Vbusmin=0.98,
max_shedding=0.2,
T_max=21):
"""
Initialize the environment
:param net: Power grid (for example IEEE 24-bus)
:param max_loading: maximum line thermal limit
:param Vbusmax: Maximum upper bound for Bus magnitude voltage
:param Vbusmin : Minimum lower bound for Bus magnitude voltage
"""
self.net_origin = net
self.net = copy.deepcopy(net)
self.max_loading = max_loading
grid1 = pn.case118() grid2 = pn.case118() # grid1 = pn.case39() # grid2 = pn.case39() # grid1 = pn.case6515rte() # grid2 = pn.case6515rte() # grid1 = pn.case9241pegase() # grid2 = pn.case9241pegase() # grid1 = pn.case1888rte() # grid2 = pn.case1888rte() # without trafo, ordering issue nor shunt, no parrallel line grid1 = pn.case5() grid2 = pn.case5() # without trafo, ordering issue, nor shunt, no parrallel line grid1 = pn.case6ww() grid2 = pn.case6ww() # # without trafo, but ordering issue and shunt, no parrallel line grid1 = pn.case30() grid2 = pn.case30() # # with trafo, ordering issue, and shunt, no parrallel line grid1 = pn.case14() grid2 = pn.case14() # # with trafo, ordering issue, and shunt, with parrallel line