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