def get_island(self, bus_idx):
"""
get the array of branch indices that belong to the islands given by the bus indices
:param bus_idx: array of bus indices
:return: array of island branch indices
"""
return tp.get_elements_of_the_island(self.C_branch_bus_f + self.C_branch_bus_t, bus_idx)
def get_island(self, bus_idx):
"""
Get the elements of the island given the bus indices
:param bus_idx: list of bus indices
:return: list of line indices of the island
"""
return tp.get_elements_of_the_island(self.C_vsc_bus, bus_idx)
def get_island(self, bus_idx):
"""
Get HVDC indices of the island given by the bus indices
:param bus_idx: list of bus indices
:return: list of HVDC lines indices
"""
return tp.get_elements_of_the_island(
self.C_hvdc_bus_f + self.C_hvdc_bus_t, bus_idx)
def get_acdc_pf_island(circuit: AcDcSnapshotCircuit,
bus_idx) -> "AcDcSnapshotCircuit":
"""
Get the island corresponding to the given buses
:param bus_idx: array of bus indices
:return: SnapshotCircuit
"""
# find the indices of the devices of the island
br_idx = tp.get_elements_of_the_island(
circuit.C_branch_bus_f + circuit.C_branch_bus_t, bus_idx)
line_idx = tp.get_elements_of_the_island(circuit.C_line_bus, bus_idx)
dc_line_idx = tp.get_elements_of_the_island(circuit.C_dc_line_bus, bus_idx)
tr_idx = tp.get_elements_of_the_island(circuit.C_tr_bus, bus_idx)
vsc_idx = tp.get_elements_of_the_island(circuit.C_vsc_bus, bus_idx)
load_idx = tp.get_elements_of_the_island(circuit.C_bus_load.T, bus_idx)
stagen_idx = tp.get_elements_of_the_island(
circuit.C_bus_static_generator.T, bus_idx)
gen_idx = tp.get_elements_of_the_island(circuit.C_bus_gen.T, bus_idx)
batt_idx = tp.get_elements_of_the_island(circuit.C_bus_batt.T, bus_idx)
shunt_idx = tp.get_elements_of_the_island(circuit.C_bus_shunt.T, bus_idx)
nc = AcDcSnapshotCircuit(
nbus=len(bus_idx),
nline=len(line_idx),
ndcline=len(dc_line_idx),
ntr=len(tr_idx),
nvsc=len(vsc_idx),
nload=len(load_idx),
ngen=len(gen_idx),
nbatt=len(batt_idx),
nshunt=len(shunt_idx),
nstagen=len(stagen_idx),
sbase=circuit.Sbase,
apply_temperature=circuit.apply_temperature,
branch_tolerance_mode=circuit.branch_tolerance_mode)
nc.original_bus_idx = bus_idx
nc.original_branch_idx = br_idx
nc.original_line_idx = line_idx
nc.original_tr_idx = tr_idx
nc.original_gen_idx = gen_idx
nc.original_bat_idx = batt_idx
# bus ----------------------------------------------------------------------------------------------------------
nc.bus_names = circuit.bus_names[bus_idx]
nc.bus_active = circuit.bus_active[bus_idx]
nc.Vbus = circuit.Vbus[bus_idx]
nc.bus_types = circuit.bus_types[bus_idx]
# branch common ------------------------------------------------------------------------------------------------
nc.branch_names = circuit.branch_names[br_idx]
nc.branch_active = circuit.branch_active[br_idx]
nc.F = circuit.F[br_idx]
nc.T = circuit.T[br_idx]
nc.branch_rates = circuit.branch_rates[br_idx]
nc.C_branch_bus_f = circuit.C_branch_bus_f[np.ix_(br_idx, bus_idx)]
nc.C_branch_bus_t = circuit.C_branch_bus_t[np.ix_(br_idx, bus_idx)]
nc.R = circuit.R[br_idx]
nc.X = circuit.X[br_idx]
nc.G = circuit.G[br_idx]
nc.B = circuit.B[br_idx]
nc.m = circuit.m[br_idx]
nc.theta = circuit.theta[br_idx]
nc.Beq = circuit.Beq[br_idx]
nc.G0 = circuit.G0[br_idx]
nc.tap_f = circuit.tap_f[br_idx]
nc.tap_t = circuit.tap_t[br_idx]
nc.Inom = circuit.Inom[br_idx]
nc.Pset = circuit.Pset[br_idx]
nc.Qset = circuit.Qset[br_idx]
nc.vf_set = circuit.vt_set[br_idx]
nc.vt_set = circuit.vf_set[br_idx]
nc.control_mode = circuit.control_mode[br_idx]
# load ---------------------------------------------------------------------------------------------------------
nc.load_names = circuit.load_names[load_idx]
nc.load_active = circuit.load_active[load_idx]
nc.load_s = circuit.load_s[load_idx]
nc.C_bus_load = circuit.C_bus_load[np.ix_(bus_idx, load_idx)]
# static generators --------------------------------------------------------------------------------------------
nc.static_generator_names = circuit.static_generator_names[stagen_idx]
nc.static_generator_active = circuit.static_generator_active[stagen_idx]
nc.static_generator_s = circuit.static_generator_s[stagen_idx]
nc.C_bus_static_generator = circuit.C_bus_static_generator[np.ix_(
bus_idx, stagen_idx)]
# battery ------------------------------------------------------------------------------------------------------
nc.battery_names = circuit.battery_names[batt_idx]
nc.battery_active = circuit.battery_active[batt_idx]
nc.battery_controllable = circuit.battery_controllable[batt_idx]
nc.battery_p = circuit.battery_p[batt_idx]
nc.battery_pf = circuit.battery_pf[batt_idx]
nc.battery_v = circuit.battery_v[batt_idx]
nc.battery_qmin = circuit.battery_qmin[batt_idx]
nc.battery_qmax = circuit.battery_qmax[batt_idx]
nc.C_bus_batt = circuit.C_bus_batt[np.ix_(bus_idx, batt_idx)]
# generator ----------------------------------------------------------------------------------------------------
nc.generator_names = circuit.generator_names[gen_idx]
nc.generator_active = circuit.generator_active[gen_idx]
nc.generator_controllable = circuit.generator_controllable[gen_idx]
nc.generator_p = circuit.generator_p[gen_idx]
nc.generator_pf = circuit.generator_pf[gen_idx]
nc.generator_v = circuit.generator_v[gen_idx]
nc.generator_qmin = circuit.generator_qmin[gen_idx]
nc.generator_qmax = circuit.generator_qmax[gen_idx]
nc.C_bus_gen = circuit.C_bus_gen[np.ix_(bus_idx, gen_idx)]
# shunt --------------------------------------------------------------------------------------------------------
nc.shunt_names = circuit.shunt_names[shunt_idx]
nc.shunt_active = circuit.shunt_active[shunt_idx]
nc.shunt_admittance = circuit.shunt_admittance[shunt_idx]
nc.C_bus_shunt = circuit.C_bus_shunt[np.ix_(bus_idx, shunt_idx)]
return nc
def get_opf_time_island(self, bus_idx, time_idx) -> "OpfTimeCircuit":
"""
Get the island corresponding to the given buses
:param bus_idx: array of bus indices
:param time_idx: array of time indices
:return: TiTimeCircuitmeIsland
"""
# find the indices of the devices of the island
line_idx = tp.get_elements_of_the_island(self.C_line_bus, bus_idx)
tr_idx = tp.get_elements_of_the_island(self.C_tr_bus, bus_idx)
vsc_idx = tp.get_elements_of_the_island(self.C_vsc_bus, bus_idx)
hvdc_idx = tp.get_elements_of_the_island(
self.C_hvdc_bus_f + self.C_hvdc_bus_t, bus_idx)
br_idx = tp.get_elements_of_the_island(
self.C_branch_bus_f + self.C_branch_bus_t, bus_idx)
load_idx = tp.get_elements_of_the_island(self.C_bus_load.T, bus_idx)
stagen_idx = tp.get_elements_of_the_island(self.C_bus_static_generator.T,
bus_idx)
gen_idx = tp.get_elements_of_the_island(self.C_bus_gen.T, bus_idx)
batt_idx = tp.get_elements_of_the_island(self.C_bus_batt.T, bus_idx)
shunt_idx = tp.get_elements_of_the_island(self.C_bus_shunt.T, bus_idx)
nc = OpfTimeCircuit(nbus=len(bus_idx),
nline=len(line_idx),
ntr=len(tr_idx),
nvsc=len(vsc_idx),
nhvdc=len(hvdc_idx),
nload=len(load_idx),
ngen=len(gen_idx),
nbatt=len(batt_idx),
nshunt=len(shunt_idx),
nstagen=len(stagen_idx),
ntime=len(time_idx),
sbase=self.Sbase,
time_array=self.time_array[time_idx],
apply_temperature=self.apply_temperature,
branch_tolerance_mode=self.branch_tolerance_mode)
nc.original_time_idx = time_idx
nc.original_bus_idx = bus_idx
nc.original_branch_idx = br_idx
nc.original_tr_idx = tr_idx
nc.original_gen_idx = gen_idx
nc.original_bat_idx = batt_idx
# bus ----------------------------------------------------------------------------------------------------------
nc.bus_names = self.bus_names[bus_idx]
nc.bus_types = self.bus_types[bus_idx]
nc.bus_installed_power = self.bus_installed_power[bus_idx]
nc.bus_active = self.bus_active[np.ix_(time_idx, bus_idx)]
nc.Vbus = self.Vbus[np.ix_(time_idx, bus_idx)]
# branch common ------------------------------------------------------------------------------------------------
nc.branch_names = self.branch_names[br_idx]
nc.branch_active = self.branch_active[np.ix_(time_idx, br_idx)]
nc.branch_rates = self.branch_rates[np.ix_(time_idx, br_idx)]
nc.branch_cost = self.branch_cost[np.ix_(time_idx, br_idx)]
nc.branch_R = self.branch_R[br_idx]
nc.branch_X = self.branch_X[br_idx]
nc.F = self.F[br_idx]
nc.T = self.T[br_idx]
nc.C_branch_bus_f = self.C_branch_bus_f[np.ix_(br_idx, bus_idx)]
nc.C_branch_bus_t = self.C_branch_bus_t[np.ix_(br_idx, bus_idx)]
# lines --------------------------------------------------------------------------------------------------------
nc.line_names = self.line_names[line_idx]
nc.line_R = self.line_R[line_idx]
nc.line_X = self.line_X[line_idx]
nc.line_B = self.line_B[line_idx]
nc.line_temp_base = self.line_temp_base[line_idx]
nc.line_temp_oper = self.line_temp_oper[line_idx]
nc.line_alpha = self.line_alpha[line_idx]
nc.line_impedance_tolerance = self.line_impedance_tolerance[line_idx]
nc.C_line_bus = self.C_line_bus[np.ix_(line_idx, bus_idx)]
# transformer 2W + 3W ------------------------------------------------------------------------------------------
nc.tr_names = self.tr_names[tr_idx]
nc.tr_R = self.tr_R[tr_idx]
nc.tr_X = self.tr_X[tr_idx]
nc.tr_G = self.tr_G[tr_idx]
nc.tr_B = self.tr_B[tr_idx]
nc.tr_tap_f = self.tr_tap_f[tr_idx]
nc.tr_tap_t = self.tr_tap_t[tr_idx]
nc.tr_tap_mod = self.tr_tap_mod[tr_idx]
nc.tr_tap_ang = self.tr_tap_ang[tr_idx]
nc.C_tr_bus = self.C_tr_bus[np.ix_(tr_idx, bus_idx)]
# hvdc line ----------------------------------------------------------------------------------------------------
nc.hvdc_names = self.hvdc_names[hvdc_idx]
nc.hvdc_active = self.hvdc_active[np.ix_(time_idx, hvdc_idx)]
nc.hvdc_rate = self.hvdc_rate[np.ix_(time_idx, hvdc_idx)]
nc.hvdc_Pf = self.hvdc_Pf[np.ix_(time_idx, hvdc_idx)]
nc.hvdc_Pt = self.hvdc_Pt[np.ix_(time_idx, hvdc_idx)]
nc.C_hvdc_bus_f = self.C_hvdc_bus_f[np.ix_(hvdc_idx, bus_idx)]
nc.C_hvdc_bus_t = self.C_hvdc_bus_t[np.ix_(hvdc_idx, bus_idx)]
# vsc converter ------------------------------------------------------------------------------------------------
nc.vsc_names = self.vsc_names[vsc_idx]
nc.vsc_R1 = self.vsc_R1[vsc_idx]
nc.vsc_X1 = self.vsc_X1[vsc_idx]
nc.vsc_Gsw = self.vsc_Gsw[vsc_idx]
nc.vsc_Beq = self.vsc_Beq[vsc_idx]
nc.vsc_m = self.vsc_m[vsc_idx]
nc.vsc_theta = self.vsc_theta[vsc_idx]
nc.C_vsc_bus = self.C_vsc_bus[np.ix_(vsc_idx, bus_idx)]
# load ---------------------------------------------------------------------------------------------------------
nc.load_names = self.load_names[load_idx]
nc.load_active = self.load_active[np.ix_(time_idx, load_idx)]
nc.load_s = self.load_s[np.ix_(time_idx, load_idx)]
nc.load_cost = self.load_cost[np.ix_(time_idx, load_idx)]
nc.C_bus_load = self.C_bus_load[np.ix_(bus_idx, load_idx)]
# static generators --------------------------------------------------------------------------------------------
nc.static_generator_names = self.static_generator_names[stagen_idx]
nc.static_generator_active = self.static_generator_active[np.ix_(
time_idx, stagen_idx)]
nc.static_generator_s = self.static_generator_s[np.ix_(
time_idx, stagen_idx)]
nc.C_bus_static_generator = self.C_bus_static_generator[np.ix_(
bus_idx, stagen_idx)]
# battery ------------------------------------------------------------------------------------------------------
nc.battery_names = self.battery_names[batt_idx]
nc.battery_controllable = self.battery_controllable[batt_idx]
nc.battery_dispatchable = self.battery_dispatchable[batt_idx]
nc.battery_installed_p = self.battery_installed_p[batt_idx]
nc.battery_enom = self.battery_enom[batt_idx]
nc.battery_min_soc = self.battery_min_soc[batt_idx]
nc.battery_max_soc = self.battery_max_soc[batt_idx]
nc.battery_soc_0 = self.battery_soc_0[batt_idx]
nc.battery_charge_efficiency = self.battery_charge_efficiency[batt_idx]
nc.battery_discharge_efficiency = self.battery_discharge_efficiency[
batt_idx]
nc.battery_active = self.battery_active[np.ix_(time_idx, batt_idx)]
nc.battery_p = self.battery_p[np.ix_(time_idx, batt_idx)]
nc.battery_pf = self.battery_pf[np.ix_(time_idx, batt_idx)]
nc.battery_v = self.battery_v[np.ix_(time_idx, batt_idx)]
nc.battery_cost = self.battery_cost[np.ix_(time_idx, batt_idx)]
nc.battery_pmin = self.battery_pmin[batt_idx]
nc.battery_pmax = self.battery_pmax[batt_idx]
nc.C_bus_batt = self.C_bus_batt[np.ix_(bus_idx, batt_idx)]
# generator ----------------------------------------------------------------------------------------------------
nc.generator_names = self.generator_names[gen_idx]
nc.generator_controllable = self.generator_controllable[gen_idx]
nc.generator_dispatchable = self.generator_dispatchable[gen_idx]
nc.battery_installed_p = self.battery_installed_p[gen_idx]
nc.generator_active = self.generator_active[np.ix_(time_idx, gen_idx)]
nc.generator_p = self.generator_p[np.ix_(time_idx, gen_idx)]
nc.generator_pf = self.generator_pf[np.ix_(time_idx, gen_idx)]
nc.generator_v = self.generator_v[np.ix_(time_idx, gen_idx)]
nc.generator_cost = self.generator_cost[np.ix_(time_idx, gen_idx)]
nc.generator_pmin = self.generator_pmin[gen_idx]
nc.generator_pmax = self.generator_pmax[gen_idx]
nc.C_bus_gen = self.C_bus_gen[np.ix_(bus_idx, gen_idx)]
# shunt --------------------------------------------------------------------------------------------------------
nc.shunt_names = self.shunt_names[shunt_idx]
nc.shunt_active = self.shunt_active[np.ix_(time_idx, shunt_idx)]
nc.shunt_admittance = self.shunt_admittance[np.ix_(time_idx, shunt_idx)]
nc.C_bus_shunt = self.C_bus_shunt[np.ix_(bus_idx, shunt_idx)]
return nc
def get_island(self, bus_idx):
return tp.get_elements_of_the_island(self.C_bus_shunt.T, bus_idx)
def get_island(self, bus_idx):
return tp.get_elements_of_the_island(self.C_bus_static_generator.T,
bus_idx)
