def test_demo_5_node(root_path=ROOT_PATH):
np.core.arrayprint.set_printoptions(precision=4)
grid = MultiCircuit()
# Add buses
bus1 = Bus('Bus 1', vnom=20)
grid.add_bus(bus1)
gen1 = Generator('Slack Generator', voltage_module=1.0)
grid.add_generator(bus1, gen1)
bus2 = Bus('Bus 2', vnom=20)
grid.add_bus(bus2)
grid.add_load(bus2, Load('load 2', P=40, Q=20))
bus3 = Bus('Bus 3', vnom=20)
grid.add_bus(bus3)
grid.add_load(bus3, Load('load 3', P=25, Q=15))
bus4 = Bus('Bus 4', vnom=20)
grid.add_bus(bus4)
grid.add_load(bus4, Load('load 4', P=40, Q=20))
bus5 = Bus('Bus 5', vnom=20)
grid.add_bus(bus5)
grid.add_load(bus5, Load('load 5', P=50, Q=20))
# add branches (Lines in this case)
grid.add_line(Line(bus1, bus2, 'line 1-2', r=0.05, x=0.11, b=0.02))
grid.add_line(Line(bus1, bus3, 'line 1-3', r=0.05, x=0.11, b=0.02))
grid.add_line(Line(bus1, bus5, 'line 1-5', r=0.03, x=0.08, b=0.02))
grid.add_line(Line(bus2, bus3, 'line 2-3', r=0.04, x=0.09, b=0.02))
grid.add_line(Line(bus2, bus5, 'line 2-5', r=0.04, x=0.09, b=0.02))
grid.add_line(Line(bus3, bus4, 'line 3-4', r=0.06, x=0.13, b=0.03))
grid.add_line(Line(bus4, bus5, 'line 4-5', r=0.04, x=0.09, b=0.02))
# grid.plot_graph()
print('\n\n', grid.name)
FileSave(grid, 'demo_5_node.json').save()
options = PowerFlowOptions(SolverType.NR, verbose=False)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print_power_flow_results(power_flow=power_flow)
v = np.array([1., 0.9553, 0.9548, 0.9334, 0.9534])
all_ok = np.isclose(np.abs(power_flow.results.voltage), v, atol=1e-3)
return all_ok
def test_demo_5_node(root_path):
np.core.arrayprint.set_printoptions(precision=4)
grid = MultiCircuit()
# Add buses
bus1 = Bus('Bus 1', vnom=20)
# bus1.is_slack = True
grid.add_bus(bus1)
gen1 = Generator('Slack Generator', voltage_module=1.0)
grid.add_generator(bus1, gen1)
bus2 = Bus('Bus 2', vnom=20)
grid.add_bus(bus2)
grid.add_load(bus2, Load('load 2', P=40, Q=20))
bus3 = Bus('Bus 3', vnom=20)
grid.add_bus(bus3)
grid.add_load(bus3, Load('load 3', P=25, Q=15))
bus4 = Bus('Bus 4', vnom=20)
grid.add_bus(bus4)
grid.add_load(bus4, Load('load 4', P=40, Q=20))
bus5 = Bus('Bus 5', vnom=20)
grid.add_bus(bus5)
grid.add_load(bus5, Load('load 5', P=50, Q=20))
# add branches (Lines in this case)
grid.add_branch(Branch(bus1, bus2, 'line 1-2', r=0.05, x=0.11, b=0.02))
grid.add_branch(Branch(bus1, bus3, 'line 1-3', r=0.05, x=0.11, b=0.02))
grid.add_branch(Branch(bus1, bus5, 'line 1-5', r=0.03, x=0.08, b=0.02))
grid.add_branch(Branch(bus2, bus3, 'line 2-3', r=0.04, x=0.09, b=0.02))
grid.add_branch(Branch(bus2, bus5, 'line 2-5', r=0.04, x=0.09, b=0.02))
grid.add_branch(Branch(bus3, bus4, 'line 3-4', r=0.06, x=0.13, b=0.03))
grid.add_branch(Branch(bus4, bus5, 'line 4-5', r=0.04, x=0.09, b=0.02))
# grid.plot_graph()
print('\n\n', grid.name)
options = PowerFlowOptions(SolverType.NR, verbose=False)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print_power_flow_results(power_flow=power_flow)
def parse_bus_bars(self, cim: CIMCircuit, circuit: MultiCircuit):
"""
:param cim:
:param circuit:
:return:
"""
busbar_dict = dict()
if 'BusbarSection' in cim.elements_by_type.keys():
for elm in cim.elements_by_type['BusbarSection']:
obj = gcdev.Bus(name=str(elm.name), idtag=elm.uuid)
circuit.add_bus(obj)
busbar_dict[elm] = obj
else:
self.logger.add_error(
"No BusbarSections: There is no chance to reduce the grid")
return busbar_dict
def test_xfo_static_tap_3():
"""
Basic test with the main transformer's HV tap (X_C3) set at -2.5%
(0.975 pu), which raises the LV by the same amount (+2.5%).
"""
test_name = "test_xfo_static_tap_3"
grid = MultiCircuit(name=test_name)
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = Logger()
# Create buses
POI = Bus(
name="POI",
vnom=100, # kV
is_slack=True)
grid.add_bus(POI)
B_C3 = Bus(name="B_C3", vnom=10) # kV
grid.add_bus(B_C3)
B_MV_M32 = Bus(name="B_MV_M32", vnom=10) # kV
grid.add_bus(B_MV_M32)
B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) # kV
grid.add_bus(B_LV_M32)
# Create voltage controlled generators (or slack, a.k.a. swing)
UT = Generator(name="Utility")
UT.bus = POI
grid.add_generator(POI, UT)
# Create static generators (with fixed power factor)
M32 = StaticGenerator(name="M32", P=4.2, Q=0.0) # MVA (complex)
M32.bus = B_LV_M32
grid.add_static_generator(B_LV_M32, M32)
# Create transformer types
s = 5 # MVA
z = 8 # %
xr = 40
SS = TransformerType(
name="SS",
hv_nominal_voltage=100, # kV
lv_nominal_voltage=10, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(SS)
s = 5 # MVA
z = 6 # %
xr = 20
PM = TransformerType(
name="PM",
hv_nominal_voltage=10, # kV
lv_nominal_voltage=0.6, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(PM)
# Create branches
X_C3 = Branch(bus_from=POI,
bus_to=B_C3,
name="X_C3",
branch_type=BranchType.Transformer,
template=SS,
tap=0.975)
# update to a more precise tap changer
X_C3.apply_tap_changer(
TapChanger(taps_up=20, taps_down=20, max_reg=1.1, min_reg=0.9))
grid.add_branch(X_C3)
C_M32 = Branch(bus_from=B_C3,
bus_to=B_MV_M32,
name="C_M32",
r=0.784,
x=0.174)
grid.add_branch(C_M32)
X_M32 = Branch(bus_from=B_MV_M32,
bus_to=B_LV_M32,
name="X_M32",
branch_type=BranchType.Transformer,
template=PM)
grid.add_branch(X_M32)
# Apply templates (device types)
grid.apply_all_branch_types()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
options = PowerFlowOptions(SolverType.NR,
verbose=True,
initialize_with_existing_solution=True,
multi_core=True,
control_q=ReactivePowerControlMode.Direct,
tolerance=1e-6,
max_iter=15)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print()
print(f"Test: {test_name}")
print()
print("Generators:")
for g in grid.get_generators():
print(f" - Generator {g}: q_min={g.Qmin} MVAR, q_max={g.Qmax} MVAR")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 1)}")
print(f" G = {round(b.G, 4)} pu")
print(f" B = {round(b.B, 4)} pu")
print()
print("Transformer types:")
for t in grid.transformer_types:
print(f" - {t}: Copper losses={int(t.Pcu)}kW, "
f"Iron losses={int(t.Pfe)}kW, SC voltage={t.Vsc}%")
print()
print("Losses:")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA"
)
print()
equal = False
for i, branch in enumerate(grid.branches):
if branch.name == "X_C3":
equal = power_flow.results.tap_module[i] == branch.tap_module
if not equal:
grid.export_pf(f"{test_name}_results.xlsx", power_flow.results)
grid.save_excel(f"{test_name}_grid.xlsx")
assert equal
def parse_json_data(data) -> MultiCircuit:
"""
Parse JSON structure into GridCal MultiCircuit
:param data: JSON structure (list of dictionaries)
:return: GridCal MultiCircuit
"""
circuit = MultiCircuit()
bus_id = dict()
for element in data:
if element["phases"] == 'ps':
if element["type"] == "circuit":
circuit = MultiCircuit()
circuit.name = element["name"]
circuit.Sbase = element["Sbase"]
circuit.comments = element['comments']
elif element["type"] == "bus":
# create the bus and add some properties
elm = Bus(name=element["name"],
vnom=element["Vnom"],
vmin=0.9,
vmax=1.1,
xpos=element['x'],
ypos=element['y'],
height=element['h'],
width=element['w'],
active=True)
if element["is_slack"]:
elm.type = BusMode.Slack
if element["vmax"] > 0:
elm.Vmax = element["vmax"]
if element["vmin"] > 0:
elm.Vmin = element["vmin"]
elm.Zf = complex(element['rf'], element['xf'])
circuit.add_bus(elm)
# add the bus to the dictionary
bus_id[element["id"]] = elm
elif element["type"] == "load":
# get the matching bus object pointer
bus = bus_id[element["bus"]]
# create a load in the bus
elm = Load(name=element['name'],
G=element["G"],
B=element["B"],
Ir=element["Ir"],
Ii=element["Ii"],
P=element["P"],
Q=element["Q"],
active=element['active'])
bus.loads.append(elm)
elif element["type"] == "controlled_gen":
# get the matching bus object pointer
bus = bus_id[element["bus"]]
# create a load in the bus
elm = Generator(name=element['name'],
active_power=element["P"],
voltage_module=element["vset"],
Qmin=element['qmin'],
Qmax=element['qmax'],
Snom=element['Snom'],
power_prof=None,
vset_prof=None,
active=element['active'],
p_min=0.0,
p_max=element['Snom'],
op_cost=1.0)
bus.controlled_generators.append(elm)
elif element["type"] == "static_gen":
# get the matching bus object pointer
bus = bus_id[element["bus"]]
# create a load in the bus
elm = StaticGenerator(name=element['name'],
P=element['P'], Q=element['Q'],
active=element['active'])
bus.static_generators.append(elm)
elif element["type"] == "battery":
# get the matching bus object pointer
bus = bus_id[element["bus"]]
# create a load in the bus
elm = Battery(name=element['name'],
active_power=element["P"],
voltage_module=element["vset"],
Qmin=element['qmin'],
Qmax=element['qmax'],
Snom=element['Snom'],
Enom=element['Enom'],
power_prof=None,
vset_prof=None,
active=element['active'])
bus.batteries.append(elm)
elif element["type"] == "shunt":
# get the matching bus object pointer
bus = bus_id[element["bus"]]
# create a load in the bus
elm = Shunt(name=element['name'],
G=element["g"], B=element["b"],
active=element['active'])
bus.shunts.append(elm)
elif element["type"] == "branch":
# get the matching bus object pointer
bus1 = bus_id[element["from"]]
bus2 = bus_id[element["to"]]
# create a load in the bus
elm = Branch(bus_from=bus1,
bus_to=bus2,
name=element["name"],
r=element["r"],
x=element["x"],
g=element["g"],
b=element["b"],
rate=element["rate"],
tap=element["tap_module"],
shift_angle=element["tap_angle"],
active=element["active"],
mttf=0,
mttr=0,
branch_type=element["branch_type"])
circuit.add_branch(elm)
else:
warn('ID: ' + element["id"] + ' error: GridCal only takes positive sequence elements.')
return circuit
def parse_json_data_v2(data: dict, logger: Logger):
"""
New Json parser
:param data:
:param logger:
:return:
"""
devices = data['devices']
profiles = data['profiles']
if DeviceType.CircuitDevice.value in devices.keys():
dta = devices[DeviceType.CircuitDevice.value]
circuit = MultiCircuit(name=str(dta['name']),
Sbase=float(dta['sbase']),
fbase=float(dta['fbase']),
idtag=str(dta['id']))
jcircuit = devices["Circuit"]
circuit.Sbase = jcircuit["sbase"]
# Countries
country_dict = dict()
if 'Country' in devices.keys():
elms = devices["Country"]
for jentry in elms:
elm = Country(idtag=str(jentry['id']),
code=str(jentry['code']),
name=str(jentry['name']))
circuit.countries.append(elm)
country_dict[elm.idtag] = elm
else:
elm = Country(idtag=None, code='Default', name='Default')
circuit.countries.append(elm)
# Areas
areas_dict = dict()
if 'Area' in devices.keys():
elms = devices["Area"]
for jentry in elms:
elm = Area(idtag=str(jentry['id']),
code=str(jentry['code']),
name=str(jentry['name']))
circuit.areas.append(elm)
areas_dict[elm.idtag] = elm
else:
elm = Area(idtag=None, code='Default', name='Default')
circuit.areas.append(elm)
# Zones
zones_dict = dict()
if 'Zone' in devices.keys():
elms = devices["Zone"]
for jentry in elms:
elm = Zone(idtag=str(jentry['id']),
code=str(jentry['code']),
name=str(jentry['name']))
circuit.zones.append(elm)
zones_dict[elm.idtag] = elm
else:
elm = Zone(idtag=None, code='Default', name='Default')
circuit.zones.append(elm)
# Substations
substations_dict = dict()
if 'Substation' in devices.keys():
elms = devices["Substation"]
for jentry in elms:
elm = Substation(idtag=str(jentry['id']),
code=str(jentry['code']),
name=str(jentry['name']))
circuit.substations.append(elm)
substations_dict[elm.idtag] = elm
else:
elm = Substation(idtag=None, code='Default', name='Default')
circuit.substations.append(elm)
# buses
bus_dict = dict()
if 'Bus' in devices.keys():
buses = devices["Bus"]
for jentry in buses:
area_id = str(jentry['area']) if 'area' in jentry.keys() else ''
zone_id = str(jentry['zone']) if 'zone' in jentry.keys() else ''
substation_id = str(jentry['substation']) if 'substation' in jentry.keys() else ''
country_id = str(jentry['country']) if 'country' in jentry.keys() else ''
if area_id in areas_dict.keys():
area = areas_dict[area_id]
else:
area = circuit.areas[0]
if zone_id in zones_dict.keys():
zone = zones_dict[zone_id]
else:
zone = circuit.zones[0]
if substation_id in substations_dict.keys():
substation = substations_dict[substation_id]
else:
substation = circuit.substations[0]
if country_id in country_dict.keys():
country = country_dict[country_id]
else:
country = circuit.countries[0]
bus = Bus(name=str(jentry['name']),
idtag=str(jentry['id']),
vnom=float(jentry['vnom']),
vmin=float(jentry['vmin']),
vmax=float(jentry['vmax']),
r_fault=float(jentry['rf']),
x_fault=float(jentry['xf']),
xpos=float(jentry['x']),
ypos=float(jentry['y']),
height=float(jentry['h']),
width=float(jentry['w']),
active=bool(jentry['active']),
is_slack=bool(jentry['is_slack']),
area=area,
zone=zone,
substation=substation,
country=country,
longitude=float(jentry['lon']),
latitude=float(jentry['lat']))
bus_dict[jentry['id']] = bus
circuit.add_bus(bus)
if 'Generator' in devices.keys():
generators = devices["Generator"]
for jentry in generators:
gen = Generator(name=str(jentry['name']),
idtag=str(jentry['id']),
active_power=float(jentry['p']),
power_factor=float(jentry['pf']),
voltage_module=float(jentry['vset']),
is_controlled=bool(jentry['is_controlled']),
Qmin=float(jentry['qmin']),
Qmax=float(jentry['qmax']),
Snom=float(jentry['snom']),
active=bool(jentry['active']),
p_min=float(jentry['pmin']),
p_max=float(jentry['pmax']),
op_cost=float(jentry['cost']),
)
gen.bus = bus_dict[jentry['bus']]
circuit.add_generator(gen.bus, gen)
if 'Battery' in devices.keys():
batteries = devices["Battery"]
for jentry in batteries:
gen = Battery(name=str(jentry['name']),
idtag=str(jentry['id']),
active_power=float(jentry['p']),
power_factor=float(jentry['pf']),
voltage_module=float(jentry['vset']),
is_controlled=bool(jentry['is_controlled']),
Qmin=float(jentry['qmin']),
Qmax=float(jentry['qmax']),
Snom=float(jentry['snom']),
active=bool(jentry['active']),
p_min=float(jentry['pmin']),
p_max=float(jentry['pmax']),
op_cost=float(jentry['cost']),
)
gen.bus = bus_dict[jentry['bus']]
circuit.add_battery(gen.bus, gen)
if 'Load' in devices.keys():
loads = devices["Load"]
for jentry in loads:
elm = Load(name=str(jentry['name']),
idtag=str(jentry['id']),
P=float(jentry['p']),
Q=float(jentry['q']),
active=bool(jentry['active']))
elm.bus = bus_dict[jentry['bus']]
circuit.add_load(elm.bus, elm)
if "Shunt" in devices.keys():
shunts = devices["Shunt"]
for jentry in shunts:
elm = Shunt(name=str(jentry['name']),
idtag=str(jentry['id']),
G=float(jentry['g']),
B=float(jentry['b']),
active=bool(jentry['active']))
elm.bus = bus_dict[jentry['bus']]
circuit.add_shunt(elm.bus, elm)
if "Line" in devices.keys():
lines = devices["Line"]
for entry in lines:
elm = Line(bus_from=bus_dict[entry['bus_from']],
bus_to=bus_dict[entry['bus_to']],
name=str(entry['name']),
idtag=str(entry['id']),
r=float(entry['r']),
x=float(entry['x']),
b=float(entry['b']),
rate=float(entry['rate']),
active=entry['active'],
length=float(entry['length']),
)
circuit.add_line(elm)
if "Transformer" in devices.keys() or "Transformer2w" in devices.keys():
if "Transformer" in devices.keys():
transformers = devices["Transformer"]
elif "Transformer2w" in devices.keys():
transformers = devices["Transformer2w"]
else:
raise Exception('Transformer key not found')
for entry in transformers:
elm = Transformer2W(bus_from=bus_dict[entry['bus_from']],
bus_to=bus_dict[entry['bus_to']],
name=str(entry['name']),
idtag=str(entry['id']),
r=float(entry['r']),
x=float(entry['x']),
g=float(entry['g']),
b=float(entry['b']),
rate=float(entry['rate']),
active=bool(entry['active']),
tap=float(entry['tap_module']),
shift_angle=float(entry['tap_angle']),
)
circuit.add_transformer2w(elm)
if "VSC" in devices.keys():
vsc = devices["VSC"]
# TODO: call correct_buses_connection()
if "HVDC Line" in devices.keys():
hvdc = devices["HVDC Line"]
return circuit
else:
logger.add('The Json structure does not have a Circuit inside the devices!')
return MultiCircuit()
def test_tolerance_lf_higher():
test_name = "test_tolerance_lf_higher"
grid = MultiCircuit(name=test_name)
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = list()
# Create buses
Bus0 = Bus(name="Bus0", vnom=25, is_slack=True)
bus_1 = Bus(name="bus_1", vnom=25)
grid.add_bus(Bus0)
grid.add_bus(bus_1)
# Create load
grid.add_load(bus_1, Load(name="Load0", P=1.0, Q=0.4))
# Create slack bus
grid.add_generator(Bus0, Generator(name="Utility"))
# Create cable (r and x should be in pu)
grid.add_branch(
Branch(bus_from=Bus0,
bus_to=bus_1,
name="Cable1",
r=0.01,
x=0.05,
tolerance=10))
# Run non-linear power flow
options = PowerFlowOptions(
verbose=True,
branch_impedance_tolerance_mode=BranchImpedanceMode.Upper)
power_flow = PowerFlow(grid, options)
power_flow.run()
# Check solution
approx_losses = round(1000 * power_flow.results.losses[0], 3)
solution = complex(0.128, 0.58) # Expected solution from GridCal
# Tested on ETAP 16.1.0 and pandapower
print(
"\n=================================================================")
print(f"Test: {test_name}")
print(
"=================================================================\n")
print(f"Results: {approx_losses}")
print(f"Solution: {solution}")
print()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 2)}")
print()
print("Voltages:")
for i in range(len(grid.buses)):
print(
f" - {grid.buses[i]}: voltage={round(power_flow.results.voltage[i], 3)} pu"
)
print()
print("Losses:")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: losses={round(power_flow.results.losses[i], 3)} MVA"
)
print()
print("Loadings (power):")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: loading={round(power_flow.results.Sbranch[i], 3)} MVA"
)
print()
print("Loadings (current):")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: loading={round(power_flow.results.Ibranch[i], 3)} pu"
)
print()
assert approx_losses == solution
def test_basic():
"""
Basic GridCal test, also useful for a basic tutorial. In this case the
magnetizing branch of the transformers is neglected by inputting 1e-20
excitation current and iron core losses.
The results are identical to ETAP's, which always uses this assumption in
balanced load flow calculations.
"""
test_name = "test_basic"
grid = MultiCircuit(name=test_name)
S_base = 100 # MVA
grid.Sbase = S_base
grid.time_profile = None
grid.logger = list()
# Create buses
POI = Bus(
name="POI",
vnom=100, #kV
is_slack=True)
grid.add_bus(POI)
B_C3 = Bus(name="B_C3", vnom=10) #kV
grid.add_bus(B_C3)
B_MV_M32 = Bus(name="B_MV_M32", vnom=10) #kV
grid.add_bus(B_MV_M32)
B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) #kV
grid.add_bus(B_LV_M32)
# Create voltage controlled generators (or slack, a.k.a. swing)
UT = Generator(name="Utility")
UT.bus = POI
grid.add_generator(POI, UT)
# Create static generators (with fixed power factor)
M32 = StaticGenerator(
name="M32",
P=4.2, # MW
Q=0.0j) # MVAR
M32.bus = B_LV_M32
grid.add_static_generator(B_LV_M32, M32)
# Create transformer types
s = 5 # MVA
z = 8 # %
xr = 40
SS = TransformerType(
name="SS",
hv_nominal_voltage=100, # kV
lv_nominal_voltage=10, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / S_base,
iron_losses=1e-20,
no_load_current=1e-20,
short_circuit_voltage=z)
grid.add_transformer_type(SS)
s = 5 # MVA
z = 6 # %
xr = 20
PM = TransformerType(
name="PM",
hv_nominal_voltage=10, # kV
lv_nominal_voltage=0.6, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / S_base,
iron_losses=1e-20,
no_load_current=1e-20,
short_circuit_voltage=z)
grid.add_transformer_type(PM)
# Create branches
X_C3 = Branch(bus_from=POI,
bus_to=B_C3,
name="X_C3",
branch_type=BranchType.Transformer,
template=SS)
grid.add_branch(X_C3)
C_M32 = Branch(bus_from=B_C3,
bus_to=B_MV_M32,
name="C_M32",
r=0.784,
x=0.174)
grid.add_branch(C_M32)
X_M32 = Branch(bus_from=B_MV_M32,
bus_to=B_LV_M32,
name="X_M32",
branch_type=BranchType.Transformer,
template=PM)
grid.add_branch(X_M32)
# Apply templates (device types)
grid.apply_all_branch_types()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
options = PowerFlowOptions(SolverType.LM,
verbose=True,
initialize_with_existing_solution=True,
multi_core=True,
control_q=ReactivePowerControlMode.Direct,
tolerance=1e-6,
max_iter=99)
power_flow = PowerFlow(grid, options)
power_flow.run()
approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage]
solution = [
100.0, 99.6, 102.7, 102.9
] # Expected solution from GridCal and ETAP 16.1.0, for reference
print()
print(f"Test: {test_name}")
print(f"Results: {approx_volt}")
print(f"Solution: {solution}")
print()
print("Generators:")
for g in grid.get_generators():
print(f" - Generator {g}: q_min={g.Qmin}pu, q_max={g.Qmax}pu")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 1)}")
print(f" G = {round(b.G, 4)} pu")
print(f" B = {round(b.B, 4)} pu")
print()
print("Transformer types:")
for t in grid.transformer_types:
print(
f" - {t}: Copper losses={int(t.Pcu)}kW, Iron losses={int(t.Pfe)}kW, SC voltage={t.Vsc}%"
)
print()
print("Losses:")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA"
)
print()
equal = True
for i in range(len(approx_volt)):
if approx_volt[i] != solution[i]:
equal = False
assert equal
def parse_buses_data(circuit: MultiCircuit, data, area_idx_dict,
logger: Logger):
"""
Parse Matpower / FUBM Matpower bus data into GridCal
:param circuit: MultiCircuit instance
:param data: data dictionary
:param area_idx_dict: area index -> object dictionary
:return: bus index -> object dictionary
"""
# Buses
table = data['bus']
n = table.shape[0]
# load profiles
if 'Lprof' in data.keys():
Pprof = data['Lprof']
Qprof = data['LprofQ']
are_load_prfiles = True
print('There are load profiles')
else:
are_load_prfiles = False
if 'bus_names' in data.keys():
names = data['bus_names']
else:
names = [
'bus ' + str(int(table[i, matpower_buses.BUS_I])) for i in range(n)
]
# Buses
bus_idx_dict = dict()
for i in range(n):
# Create bus
area_idx = int(table[i, matpower_buses.BUS_AREA])
bus_idx = int(table[i, matpower_buses.BUS_I])
is_slack = False
if area_idx in area_idx_dict.keys():
area, ref_idx = area_idx_dict[area_idx]
if ref_idx == bus_idx:
is_slack = True
else:
area = circuit.default_area
code = str(bus_idx)
bus = Bus(name=names[i],
code=code,
vnom=table[i, matpower_buses.BASE_KV],
vmax=table[i, matpower_buses.VMAX],
vmin=table[i, matpower_buses.VMIN],
area=area,
is_slack=is_slack)
# store the given bus index in relation to its real index in the table for later
bus_idx_dict[table[i, matpower_buses.BUS_I]] = i
# determine if the bus is set as slack manually
tpe = table[i, matpower_buses.BUS_TYPE]
if tpe == matpower_buses.REF:
bus.is_slack = True
else:
bus.is_slack = False
# Add the load
if table[i, matpower_buses.PD] != 0 or table[i,
matpower_buses.QD] != 0:
load = Load(P=table[i, matpower_buses.PD],
Q=table[i, matpower_buses.QD])
load.bus = bus
bus.loads.append(load)
# Add the shunt
if table[i, matpower_buses.GS] != 0 or table[i,
matpower_buses.BS] != 0:
shunt = Shunt(G=table[i, matpower_buses.GS],
B=table[i, matpower_buses.BS])
shunt.bus = bus
bus.shunts.append(shunt)
# Add the bus to the circuit buses
circuit.add_bus(bus)
return bus_idx_dict
def main():
####################################################################################################################
# Define the circuit
#
# A circuit contains all the grid information regardless of the islands formed or the amount of devices
####################################################################################################################
# create a circuit
grid = MultiCircuit(name='lynn 5 bus')
# let's create a master profile
st = datetime.datetime(2020, 1, 1)
dates = [st + datetime.timedelta(hours=i) for i in range(24)]
time_array = pd.to_datetime(dates)
x = np.linspace(-np.pi, np.pi, len(time_array))
y = np.abs(np.sin(x))
df_0 = pd.DataFrame(data=y, index=time_array) # complex values
# set the grid master time profile
grid.time_profile = df_0.index
####################################################################################################################
# Define the buses
####################################################################################################################
# I will define this bus with all the properties so you see
bus1 = Bus(name='Bus1',
vnom=10, # Nominal voltage in kV
vmin=0.9, # Bus minimum voltage in per unit
vmax=1.1, # Bus maximum voltage in per unit
xpos=0, # Bus x position in pixels
ypos=0, # Bus y position in pixels
height=0, # Bus height in pixels
width=0, # Bus width in pixels
active=True, # Is the bus active?
is_slack=False, # Is this bus a slack bus?
area='Defualt', # Area (for grouping purposes only)
zone='Default', # Zone (for grouping purposes only)
substation='Default' # Substation (for grouping purposes only)
)
# the rest of the buses are defined with the default parameters
bus2 = Bus(name='Bus2')
bus3 = Bus(name='Bus3')
bus4 = Bus(name='Bus4')
bus5 = Bus(name='Bus5')
# add the bus objects to the circuit
grid.add_bus(bus1)
grid.add_bus(bus2)
grid.add_bus(bus3)
grid.add_bus(bus4)
grid.add_bus(bus5)
####################################################################################################################
# Add the loads
####################################################################################################################
# In GridCal, the loads, generators ect are stored within each bus object:
# we'll define the first load completely
l2 = Load(name='Load',
G=0, B=0, # admittance of the ZIP model in MVA at the nominal voltage
Ir=0, Ii=0, # Current of the ZIP model in MVA at the nominal voltage
P=40, Q=20, # Power of the ZIP model in MVA
active=True, # Is active?
mttf=0.0, # Mean time to failure
mttr=0.0 # Mean time to recovery
)
grid.add_load(bus2, l2)
# Define the others with the default parameters
grid.add_load(bus3, Load(P=25, Q=15))
grid.add_load(bus4, Load(P=40, Q=20))
grid.add_load(bus5, Load(P=50, Q=20))
####################################################################################################################
# Add the generators
####################################################################################################################
g1 = Generator(name='gen',
active_power=0.0, # Active power in MW, since this generator is used to set the slack , is 0
voltage_module=1.0, # Voltage set point to control
Qmin=-9999, # minimum reactive power in MVAr
Qmax=9999, # Maximum reactive power in MVAr
Snom=9999, # Nominal power in MVA
power_prof=None, # power profile
vset_prof=None, # voltage set point profile
active=True # Is active?
)
grid.add_generator(bus1, g1)
####################################################################################################################
# Add the lines
####################################################################################################################
br1 = Branch(bus_from=bus1,
bus_to=bus2,
name='Line 1-2',
r=0.05, # resistance of the pi model in per unit
x=0.11, # reactance of the pi model in per unit
g=1e-20, # conductance of the pi model in per unit
b=0.02, # susceptance of the pi model in per unit
rate=50, # Rate in MVA
tap=1.0, # Tap value (value close to 1)
shift_angle=0, # Tap angle in radians
active=True, # is the branch active?
mttf=0, # Mean time to failure
mttr=0, # Mean time to recovery
branch_type=BranchType.Line, # Branch type tag
length=1, # Length in km (to be used with templates)
template=BranchTemplate() # Branch template (The default one is void)
)
grid.add_branch(br1)
grid.add_branch(Branch(bus1, bus3, name='Line 1-3', r=0.05, x=0.11, b=0.02, rate=50))
grid.add_branch(Branch(bus1, bus5, name='Line 1-5', r=0.03, x=0.08, b=0.02, rate=80))
grid.add_branch(Branch(bus2, bus3, name='Line 2-3', r=0.04, x=0.09, b=0.02, rate=3))
grid.add_branch(Branch(bus2, bus5, name='Line 2-5', r=0.04, x=0.09, b=0.02, rate=10))
grid.add_branch(Branch(bus3, bus4, name='Line 3-4', r=0.06, x=0.13, b=0.03, rate=30))
grid.add_branch(Branch(bus4, bus5, name='Line 4-5', r=0.04, x=0.09, b=0.02, rate=30))
FileSave(grid, 'lynn5node.gridcal').save()
####################################################################################################################
# Overwrite the default profiles with the custom ones
####################################################################################################################
for load in grid.get_loads():
load.P_prof = load.P * df_0.values[:, 0]
load.Q_prof = load.Q * df_0.values[:, 0]
for gen in grid.get_static_generators():
gen.P_prof = gen.Q * df_0.values[:, 0]
gen.Q_prof = gen.Q * df_0.values[:, 0]
for gen in grid.get_generators():
gen.P_prof = gen.P * df_0.values[:, 0]
####################################################################################################################
# Run a power flow simulation
####################################################################################################################
# We need to specify power flow options
pf_options = PowerFlowOptions(solver_type=SolverType.NR, # Base method to use
verbose=False, # Verbose option where available
tolerance=1e-6, # power error in p.u.
max_iter=25, # maximum iteration number
control_q=True # if to control the reactive power
)
# Declare and execute the power flow simulation
pf = PowerFlowDriver(grid, pf_options)
pf.run()
writer = pd.ExcelWriter('Results.xlsx')
# now, let's compose a nice DataFrame with the voltage results
headers = ['Vm (p.u.)', 'Va (Deg)', 'Vre', 'Vim']
Vm = np.abs(pf.results.voltage)
Va = np.angle(pf.results.voltage, deg=True)
Vre = pf.results.voltage.real
Vim = pf.results.voltage.imag
data = np.c_[Vm, Va, Vre, Vim]
v_df = pd.DataFrame(data=data, columns=headers, index=grid.bus_names)
# print('\n', v_df)
v_df.to_excel(writer, sheet_name='V')
# Let's do the same for the branch results
headers = ['Loading (%)', 'Current(p.u.)', 'Power (MVA)']
loading = np.abs(pf.results.loading) * 100
current = np.abs(pf.results.If)
power = np.abs(pf.results.Sf)
data = np.c_[loading, current, power]
br_df = pd.DataFrame(data=data, columns=headers, index=grid.branch_names)
br_df.to_excel(writer, sheet_name='Br')
# Finally the execution metrics
print('\nError:', pf.results.error)
print('Elapsed time (s):', pf.results.elapsed, '\n')
# print(tabulate(v_df, tablefmt="pipe", headers=v_df.columns.values))
# print()
# print(tabulate(br_df, tablefmt="pipe", headers=br_df.columns.values))
####################################################################################################################
# Run a time series power flow simulation
####################################################################################################################
ts = TimeSeries(grid=grid,
options=pf_options,
opf_time_series_results=None,
start_=0,
end_=None)
ts.run()
print()
print('-' * 200)
print('Time series')
print('-' * 200)
print('Voltage time series')
df_voltage = pd.DataFrame(data=np.abs(ts.results.voltage), columns=grid.bus_names, index=grid.time_profile)
df_voltage.to_excel(writer, sheet_name='Vts')
writer.close()
def interpret_excel_v3(circuit: MultiCircuit, data):
"""
Interpret the file version 3
In this file version there are no complex numbers saved
:param circuit:
:param data: Dictionary with the excel file sheet labels and the corresponding DataFrame
:return: Nothing, just applies the loaded data to this MultiCircuit instance
"""
# print('Interpreting V2 data...')
# clear all the data
circuit.clear()
circuit.name = data['name']
# set the base magnitudes
circuit.Sbase = data['baseMVA']
# dictionary of branch types [name] -> type object
branch_types = dict()
# Set comments
circuit.comments = data['Comments'] if 'Comments' in data.keys() else ''
circuit.logger = Logger()
# common function
def set_object_attributes(obj_, attr_list, values):
for a, attr in enumerate(attr_list):
# Hack to change the enabled by active...
if attr == 'is_enabled':
attr = 'active'
if attr == 'type_obj':
attr = 'template'
if attr == 'wire_name':
attr = 'name'
if hasattr(obj_, attr):
conv = obj_.editable_headers[
attr].tpe # get the type converter
if conv is None:
setattr(obj_, attr, values[a])
elif conv is BranchType:
cbr = BranchTypeConverter(None)
setattr(obj_, attr, cbr(values[a]))
else:
setattr(obj_, attr, conv(values[a]))
else:
warn(str(obj_) + ' has no ' + attr + ' property.')
# time profile #################################################################################################
if 'time' in data.keys():
time_df = data['time']
circuit.time_profile = pd.to_datetime(time_df.values[:, 0])
else:
circuit.time_profile = None
# Add the buses ################################################################################################
bus_dict = dict()
if 'bus' in data.keys():
df = data['bus']
hdr = df.columns.values
vals = df.values
for i in range(len(df)):
obj = Bus()
set_object_attributes(obj, hdr, vals[i, :])
bus_dict[obj.name] = obj
circuit.add_bus(obj)
else:
circuit.logger.append('No buses in the file!')
# add the loads ################################################################################################
if 'load' in data.keys():
df = data['load']
bus_from = df['bus'].values
hdr = df.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = df[hdr].values
profles_attr = {
'load_P_prof': 'P_prof',
'load_Q_prof': 'Q_prof',
'load_Ir_prof': 'Ir_prof',
'load_Ii_prof': 'Ii_prof',
'load_G_prof': 'G_prof',
'load_B_prof': 'B_prof',
'load_active_prof': 'active_prof',
'load_Cost_prof': 'Cost_prof'
}
for i in range(df.shape[0]):
obj = Load()
set_object_attributes(obj, hdr, vals[i, :])
# parse profiles:
for sheet_name, load_attr in profles_attr.items():
if sheet_name in data.keys():
val = data[sheet_name].values[:, i]
idx = data[sheet_name].index
# setattr(obj, load_attr, pd.DataFrame(data=val, index=idx))
setattr(obj, load_attr, val)
if circuit.time_profile is None or len(
circuit.time_profile) < len(idx):
circuit.time_profile = idx
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) + ': Load bus is not in the buses list.\n' +
str(ex))
if obj.name == 'Load':
obj.name += str(len(bus.loads) + 1) + '@' + bus.name
obj.bus = bus
bus.loads.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No loads in the file!')
# add the controlled generators ################################################################################
if 'generator' in data.keys():
df = data['generator']
bus_from = df['bus'].values
hdr = df.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = df[hdr].values
for i in range(df.shape[0]):
obj = Generator()
set_object_attributes(obj, hdr, vals[i, :])
if 'generator_P_prof' in data.keys():
val = data['generator_P_prof'].values[:, i]
idx = data['generator_P_prof'].index
obj.create_profile(magnitude='P', index=idx, arr=val)
# also create the Pf array because there might not be values in the file
obj.create_profile(magnitude='Pf', index=idx, arr=None)
if circuit.time_profile is None or len(
circuit.time_profile) < len(idx):
circuit.time_profile = idx
if 'generator_Pf_prof' in data.keys():
val = data['generator_Pf_prof'].values[:, i]
idx = data['generator_Pf_prof'].index
obj.create_profile(magnitude='Pf', index=idx, arr=val)
if 'generator_Vset_prof' in data.keys():
val = data['generator_Vset_prof'].values[:, i]
idx = data['generator_Vset_prof'].index
obj.create_profile(magnitude='Vset', index=idx, arr=val)
if 'generator_active_prof' in data.keys():
val = data['generator_active_prof'].values[:, i]
idx = data['generator_active_prof'].index
obj.create_profile(magnitude='active', index=idx, arr=val)
if 'generator_Cost_prof' in data.keys():
val = data['generator_Cost_prof'].values[:, i]
idx = data['generator_Cost_prof'].index
obj.create_profile(magnitude='Cost', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) +
': Controlled generator bus is not in the buses list.\n' +
str(ex))
if obj.name == 'gen':
obj.name += str(len(bus.controlled_generators) +
1) + '@' + bus.name
obj.bus = bus
bus.controlled_generators.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No controlled generator in the file!')
# add the batteries ############################################################################################
if 'battery' in data.keys():
df = data['battery']
bus_from = df['bus'].values
hdr = df.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = df[hdr].values
for i in range(df.shape[0]):
obj = Battery()
set_object_attributes(obj, hdr, vals[i, :])
if 'battery_P_prof' in data.keys():
val = data['battery_P_prof'].values[:, i]
idx = data['battery_P_prof'].index
obj.create_profile(magnitude='P', index=idx, arr=val)
# also create the Pf array because there might not be values in the file
obj.create_profile(magnitude='Pf', index=idx, arr=None)
if 'battery_Vset_prof' in data.keys():
val = data['battery_Vset_prof'].values[:, i]
idx = data['battery_Vset_prof'].index
obj.create_profile(magnitude='Vset', index=idx, arr=val)
if 'battery_active_prof' in data.keys():
val = data['battery_active_prof'].values[:, i]
idx = data['battery_active_prof'].index
obj.create_profile(magnitude='active', index=idx, arr=val)
if 'battery_Cost_prof' in data.keys():
val = data['battery_Cost_prof'].values[:, i]
idx = data['battery_Cost_prof'].index
obj.create_profile(magnitude='Cost', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) + ': Battery bus is not in the buses list.\n' +
str(ex))
if obj.name == 'batt':
obj.name += str(len(bus.batteries) + 1) + '@' + bus.name
obj.bus = bus
bus.batteries.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No battery in the file!')
# add the static generators ####################################################################################
if 'static_generator' in data.keys():
df = data['static_generator']
bus_from = df['bus'].values
hdr = df.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = df[hdr].values
for i in range(df.shape[0]):
obj = StaticGenerator()
set_object_attributes(obj, hdr, vals[i, :])
if 'static_generator_Sprof' in data.keys():
val = data['static_generator_Sprof'].values[:, i]
idx = data['static_generator_Sprof'].index
obj.create_profile(magnitude='P', index=idx, arr=val.real)
obj.create_profile(magnitude='Q', index=idx, arr=val.imag)
if 'static_generator_P_prof' in data.keys():
val = data['static_generator_P_prof'].values[:, i]
idx = data['static_generator_P_prof'].index
obj.create_profile(magnitude='P', index=idx, arr=val)
if 'static_generator_Q_prof' in data.keys():
val = data['static_generator_Q_prof'].values[:, i]
idx = data['static_generator_Q_prof'].index
obj.create_profile(magnitude='Q', index=idx, arr=val)
if 'static_generator_active_prof' in data.keys():
val = data['static_generator_active_prof'].values[:, i]
idx = data['static_generator_active_prof'].index
obj.create_profile(magnitude='active', index=idx, arr=val)
if 'static_generator_Cost_prof' in data.keys():
val = data['static_generator_Cost_prof'].values[:, i]
idx = data['static_generator_Cost_prof'].index
obj.create_profile(magnitude='Cost', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) +
': Static generator bus is not in the buses list.\n' +
str(ex))
if obj.name == 'StaticGen':
obj.name += str(len(bus.static_generators) +
1) + '@' + bus.name
obj.bus = bus
bus.static_generators.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No static generator in the file!')
# add the shunts ###############################################################################################
if 'shunt' in data.keys():
df = data['shunt']
bus_from = df['bus'].values
hdr = df.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = df[hdr].values
for i in range(df.shape[0]):
obj = Shunt()
set_object_attributes(obj, hdr, vals[i, :])
if 'shunt_Y_profiles' in data.keys():
val = data['shunt_Y_profiles'].values[:, i]
idx = data['shunt_Y_profiles'].index
obj.create_profile(magnitude='G', index=idx, arr=val.real)
obj.create_profile(magnitude='B', index=idx, arr=val.imag)
if 'shunt_G_prof' in data.keys():
val = data['shunt_G_prof'].values[:, i]
idx = data['shunt_G_prof'].index
obj.create_profile(magnitude='G', index=idx, arr=val)
if 'shunt_B_prof' in data.keys():
val = data['shunt_B_prof'].values[:, i]
idx = data['shunt_B_prof'].index
obj.create_profile(magnitude='B', index=idx, arr=val)
if 'shunt_active_prof' in data.keys():
val = data['shunt_active_prof'].values[:, i]
idx = data['shunt_active_prof'].index
obj.create_profile(magnitude='active', index=idx, arr=val)
if 'shunt_Cost_prof' in data.keys():
val = data['shunt_Cost_prof'].values[:, i]
idx = data['shunt_Cost_prof'].index
obj.create_profile(magnitude='Cost', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) + ': Shunt bus is not in the buses list.\n' +
str(ex))
if obj.name == 'shunt':
obj.name += str(len(bus.shunts) + 1) + '@' + bus.name
obj.bus = bus
bus.shunts.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No shunt in the file!')
# Add the wires ################################################################################################
if 'wires' in data.keys():
df = data['wires']
hdr = df.columns.values
vals = df.values
for i in range(len(df)):
obj = Wire()
set_object_attributes(obj, hdr, vals[i, :])
circuit.add_wire(obj)
else:
circuit.logger.append('No wires in the file!')
# Add the overhead_line_types ##################################################################################
if 'overhead_line_types' in data.keys():
df = data['overhead_line_types']
if data['overhead_line_types'].values.shape[0] > 0:
for tower_name in df['tower_name'].unique():
obj = Tower()
dft = df[df['tower_name'] == tower_name]
vals = dft.values
wire_prop = df.columns.values[len(obj.editable_headers):]
# set the tower values
set_object_attributes(obj, obj.editable_headers.keys(),
vals[0, :])
# add the wires
if len(wire_prop) == 7:
for i in range(vals.shape[0]):
# ['wire_name' 'xpos' 'ypos' 'phase' 'r' 'x' 'gmr']
name = dft['wire_name'].values[i]
gmr = dft['gmr'].values[i]
r = dft['r'].values[i]
x = dft['x'].values[i]
xpos = dft['xpos'].values[i]
ypos = dft['ypos'].values[i]
phase = dft['phase'].values[i]
wire = Wire(name=name, gmr=gmr, r=r, x=x)
w = WireInTower(wire=wire,
xpos=xpos,
ypos=ypos,
phase=phase)
obj.wires_in_tower.append(w)
circuit.add_overhead_line(obj)
branch_types[str(obj)] = obj
else:
pass
else:
circuit.logger.append('No overhead_line_types in the file!')
# Add the wires ################################################################################################
if 'underground_cable_types' in data.keys():
df = data['underground_cable_types']
hdr = df.columns.values
vals = df.values
# for i in range(len(lst)):
# obj = UndergroundLineType()
# set_object_attributes(obj, hdr, vals[i, :])
# circuit.underground_cable_types.append(obj)
# branch_types[str(obj)] = obj
else:
circuit.logger.append('No underground_cable_types in the file!')
# Add the sequence line types ##################################################################################
if 'sequence_line_types' in data.keys():
df = data['sequence_line_types']
hdr = df.columns.values
vals = df.values
for i in range(len(df)):
obj = SequenceLineType()
set_object_attributes(obj, hdr, vals[i, :])
circuit.add_sequence_line(obj)
branch_types[str(obj)] = obj
else:
circuit.logger.append('No sequence_line_types in the file!')
# Add the transformer types ####################################################################################
if 'transformer_types' in data.keys():
df = data['transformer_types']
hdr = df.columns.values
vals = df.values
for i in range(len(df)):
obj = TransformerType()
set_object_attributes(obj, hdr, vals[i, :])
circuit.add_transformer_type(obj)
branch_types[str(obj)] = obj
else:
circuit.logger.append('No transformer_types in the file!')
# Add the branches #############################################################################################
if 'branch' in data.keys():
df = data['branch']
# fix the old 'is_transformer' property
if 'is_transformer' in df.columns.values:
df['is_transformer'] = df['is_transformer'].map({
True: 'transformer',
False: 'line'
})
df.rename(columns={'is_transformer': 'branch_type'}, inplace=True)
bus_from = df['bus_from'].values
bus_to = df['bus_to'].values
hdr = df.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus_from'))
hdr = np.delete(hdr, np.argwhere(hdr == 'bus_to'))
vals = df[hdr].values
for i in range(df.shape[0]):
try:
obj = Branch(bus_from=bus_dict[str(bus_from[i])],
bus_to=bus_dict[str(bus_to[i])])
except KeyError as ex:
raise Exception(
str(i) + ': Branch bus is not in the buses list.\n' +
str(ex))
set_object_attributes(obj, hdr, vals[i, :])
# set the branch
circuit.add_branch(obj)
obj.ensure_profiles_exist(circuit.time_profile)
if 'branch_active_prof' in data.keys():
val = data['branch_active_prof'].values[:, i]
idx = data['branch_active_prof'].index
obj.create_profile(magnitude='active', index=idx, arr=val)
if 'branch_Cost_prof' in data.keys():
val = data['branch_Cost_prof'].values[:, i]
idx = data['branch_Cost_prof'].index
obj.create_profile(magnitude='Cost', index=idx, arr=val)
if 'branch_temp_oper_prof' in data.keys():
val = data['branch_temp_oper_prof'].values[:, i]
idx = data['branch_temp_oper_prof'].index
obj.create_profile(magnitude='temp_oper', index=idx, arr=val)
# correct the branch template object
template_name = str(obj.template)
if template_name in branch_types.keys():
obj.template = branch_types[template_name]
print(template_name, 'updtaed!')
else:
circuit.logger.append('No branches in the file!')
# Other actions ################################################################################################
circuit.logger += circuit.apply_all_branch_types()
def test_xfo_static_tap_1():
"""
Basic test with the main transformer's HV tap (X_C3) set at +5% (1.05 pu),
which lowers the LV by the same amount (-5%).
"""
test_name = "test_xfo_static_tap_1"
grid = MultiCircuit(name=test_name)
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = Logger()
# Create buses
POI = Bus(
name="POI",
vnom=100, #kV
is_slack=True)
grid.add_bus(POI)
B_C3 = Bus(name="B_C3", vnom=10) #kV
grid.add_bus(B_C3)
B_MV_M32 = Bus(name="B_MV_M32", vnom=10) #kV
grid.add_bus(B_MV_M32)
B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) #kV
grid.add_bus(B_LV_M32)
# Create voltage controlled generators (or slack, a.k.a. swing)
UT = Generator(name="Utility")
UT.bus = POI
grid.add_generator(POI, UT)
# Create static generators (with fixed power factor)
M32 = StaticGenerator(name="M32", P=4.2, Q=0.0) # MVA (complex)
M32.bus = B_LV_M32
grid.add_static_generator(B_LV_M32, M32)
# Create transformer types
s = 5 # MVA
z = 8 # %
xr = 40
SS = TransformerType(
name="SS",
hv_nominal_voltage=100, # kV
lv_nominal_voltage=10, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(SS)
s = 5 # MVA
z = 6 # %
xr = 20
PM = TransformerType(
name="PM",
hv_nominal_voltage=10, # kV
lv_nominal_voltage=0.6, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(PM)
# Create branches
X_C3 = Branch(bus_from=POI,
bus_to=B_C3,
name="X_C3",
branch_type=BranchType.Transformer,
template=SS,
tap=1.05)
grid.add_branch(X_C3)
C_M32 = Branch(bus_from=B_C3,
bus_to=B_MV_M32,
name="C_M32",
r=0.784,
x=0.174)
grid.add_branch(C_M32)
X_M32 = Branch(bus_from=B_MV_M32,
bus_to=B_LV_M32,
name="X_M32",
branch_type=BranchType.Transformer,
template=PM)
grid.add_branch(X_M32)
# Apply templates (device types)
grid.apply_all_branch_types()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
options = PowerFlowOptions(SolverType.NR,
verbose=True,
initialize_with_existing_solution=True,
multi_core=True,
control_q=ReactivePowerControlMode.Direct,
tolerance=1e-6,
max_iter=99)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage]
solution = [100.0, 94.7, 98.0, 98.1] # Expected solution from GridCal
print()
print(f"Test: {test_name}")
print(f"Results: {approx_volt}")
print(f"Solution: {solution}")
print()
print("Generators:")
for g in grid.get_generators():
print(f" - Generator {g}: q_min={g.Qmin} MVAR, q_max={g.Qmax} MVAR")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 1)}")
print(f" G = {round(b.G, 4)} pu")
print(f" B = {round(b.B, 4)} pu")
print()
print("Transformer types:")
for t in grid.transformer_types:
print(
f" - {t}: Copper losses={int(t.Pcu)}kW, Iron losses={int(t.Pfe)}kW, SC voltage={t.Vsc}%"
)
print()
print("Losses:")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA"
)
print()
equal = True
for i in range(len(approx_volt)):
if approx_volt[i] != solution[i]:
equal = False
assert equal
def test_pv_3():
"""
Voltage controlled generator test, also useful for a basic tutorial. In this
case the generator M32 regulates the voltage at a setpoint of 1.025 pu, and
the slack bus (POI) regulates it at 1.0 pu.
The transformers' magnetizing branch losses are considered, as well as the
main power transformer's voltage regulator (X_C3) which regulates bus
B_MV_M32 at 1.005 pu.
In addition, the iterative PV control method is used instead of the usual
(faster) method.
"""
test_name = "test_pv_3"
grid = MultiCircuit(name=test_name)
Sbase = 100 # MVA
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = Logger()
# Create buses
POI = Bus(
name="POI",
vnom=100, # kV
is_slack=True)
grid.add_bus(POI)
B_MV_M32 = Bus(name="B_MV_M32", vnom=10) # kV
grid.add_bus(B_MV_M32)
B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) # kV
grid.add_bus(B_LV_M32)
# Create voltage controlled generators (or slack, a.k.a. swing)
UT = Generator(name="Utility")
UT.bus = POI
grid.add_generator(POI, UT)
M32 = Generator(name="M32",
active_power=4.2,
voltage_module=1.025,
Qmin=-2.5,
Qmax=2.5)
M32.bus = B_LV_M32
grid.add_generator(B_LV_M32, M32)
# Create transformer types
s = 100 # MVA
z = 8 # %
xr = 40
SS = TransformerType(
name="SS",
hv_nominal_voltage=100, # kV
lv_nominal_voltage=10, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=125, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(SS)
s = 5 # MVA
z = 6 # %
xr = 20
PM = TransformerType(
name="PM",
hv_nominal_voltage=10, # kV
lv_nominal_voltage=0.6, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(PM)
# Create branches
X_C3 = Branch(bus_from=POI,
bus_to=B_MV_M32,
name="X_C3",
branch_type=BranchType.Transformer,
template=SS,
bus_to_regulated=True,
vset=1.005)
X_C3.tap_changer = TapChanger(taps_up=16,
taps_down=16,
max_reg=1.1,
min_reg=0.9)
X_C3.tap_changer.set_tap(X_C3.tap_module)
grid.add_branch(X_C3)
X_M32 = Branch(bus_from=B_MV_M32,
bus_to=B_LV_M32,
name="X_M32",
branch_type=BranchType.Transformer,
template=PM)
grid.add_branch(X_M32)
# Apply templates (device types)
grid.apply_all_branch_types()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
options = PowerFlowOptions(SolverType.LM,
verbose=True,
initialize_with_existing_solution=True,
multi_core=True,
control_q=ReactivePowerControlMode.Iterative,
control_taps=TapsControlMode.Direct,
tolerance=1e-6,
max_iter=99)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage]
solution = [100.0, 100.7, 102.5] # Expected solution from GridCal
print()
print(f"Test: {test_name}")
print(f"Results: {approx_volt}")
print(f"Solution: {solution}")
print()
print("Generators:")
for g in grid.get_generators():
print(f" - Generator {g}: q_min={g.Qmin} MVAR, q_max={g.Qmax} MVAR")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X / b.R, 1)}")
print(f" G = {round(b.G, 4)} pu")
print(f" B = {round(b.B, 4)} pu")
print()
print("Transformer types:")
for t in grid.transformer_types:
print(
f" - {t}: Copper losses={int(t.Pcu)}kW, Iron losses={int(t.Pfe)}kW, SC voltage={t.Vsc}%"
)
print()
print("Losses:")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: losses={1000 * round(power_flow.results.losses[i], 3)} kVA"
)
print()
equal = True
for i in range(len(approx_volt)):
if approx_volt[i] != solution[i]:
equal = False
assert equal
def main():
####################################################################################################################
# Define the circuit
#
# A circuit contains all the grid information regardless of the islands formed or the amount of devices
####################################################################################################################
grid = MultiCircuit(name='lynn 5 bus')
####################################################################################################################
# Define the buses
####################################################################################################################
# I will define this bus with all the properties so you see
bus1 = Bus(name='Bus1',
vnom=10, # Nominal voltage in kV
vmin=0.9, # Bus minimum voltage in per unit
vmax=1.1, # Bus maximum voltage in per unit
xpos=0, # Bus x position in pixels
ypos=0, # Bus y position in pixels
height=0, # Bus height in pixels
width=0, # Bus width in pixels
active=True, # Is the bus active?
is_slack=False, # Is this bus a slack bus?
area='Defualt', # Area (for grouping purposes only)
zone='Default', # Zone (for grouping purposes only)
substation='Default' # Substation (for grouping purposes only)
)
# the rest of the buses are defined with the default parameters
bus2 = Bus(name='Bus2')
bus3 = Bus(name='Bus3')
bus4 = Bus(name='Bus4')
bus5 = Bus(name='Bus5')
# add the bus objects to the circuit
grid.add_bus(bus1)
grid.add_bus(bus2)
grid.add_bus(bus3)
grid.add_bus(bus4)
grid.add_bus(bus5)
####################################################################################################################
# Add the loads
####################################################################################################################
# In GridCal, the loads, generators ect are stored within each bus object:
# we'll define the first load completely
l2 = Load(name='Load',
G=0, # Impedance of the ZIP model in MVA at the nominal voltage
B=0,
Ir=0,
Ii=0, # Current of the ZIP model in MVA at the nominal voltage
P=40,
Q=20, # Power of the ZIP model in MVA
P_prof=None, # Impedance profile
Q_prof=None, # Current profile
Ir_prof=None, # Power profile
Ii_prof=None,
G_prof=None,
B_prof=None,
active=True, # Is active?
mttf=0.0, # Mean time to failure
mttr=0.0 # Mean time to recovery
)
grid.add_load(bus2, l2)
# Define the others with the default parameters
grid.add_load(bus3, Load(P=25, Q=15))
grid.add_load(bus4, Load(P=40, Q=20))
grid.add_load(bus5, Load(P=50, Q=20))
####################################################################################################################
# Add the generators
####################################################################################################################
g1 = Generator(name='gen',
active_power=0.0, # Active power in MW, since this generator is used to set the slack , is 0
voltage_module=1.0, # Voltage set point to control
Qmin=-9999, # minimum reactive power in MVAr
Qmax=9999, # Maximum reactive power in MVAr
Snom=9999, # Nominal power in MVA
power_prof=None, # power profile
vset_prof=None, # voltage set point profile
active=True # Is active?
)
grid.add_generator(bus1, g1)
####################################################################################################################
# Add the lines
####################################################################################################################
br1 = Branch(bus_from=bus1,
bus_to=bus2,
name='Line 1-2',
r=0.05, # resistance of the pi model in per unit
x=0.11, # reactance of the pi model in per unit
g=1e-20, # conductance of the pi model in per unit
b=0.02, # susceptance of the pi model in per unit
rate=50, # Rate in MVA
tap=1.0, # Tap value (value close to 1)
shift_angle=0, # Tap angle in radians
active=True, # is the branch active?
mttf=0, # Mean time to failure
mttr=0, # Mean time to recovery
branch_type=BranchType.Line, # Branch type tag
length=1, # Length in km (to be used with templates)
template=BranchTemplate() # Branch template (The default one is void)
)
grid.add_branch(br1)
grid.add_branch(Branch(bus1, bus3, name='Line 1-3', r=0.05, x=0.11, b=0.02, rate=50))
grid.add_branch(Branch(bus1, bus5, name='Line 1-5', r=0.03, x=0.08, b=0.02, rate=80))
grid.add_branch(Branch(bus2, bus3, name='Line 2-3', r=0.04, x=0.09, b=0.02, rate=3))
grid.add_branch(Branch(bus2, bus5, name='Line 2-5', r=0.04, x=0.09, b=0.02, rate=10))
grid.add_branch(Branch(bus3, bus4, name='Line 3-4', r=0.06, x=0.13, b=0.03, rate=30))
grid.add_branch(Branch(bus4, bus5, name='Line 4-5', r=0.04, x=0.09, b=0.02, rate=30))
####################################################################################################################
# Run a power flow simulation
####################################################################################################################
# We need to specify power flow options
pf_options = PowerFlowOptions(solver_type=SolverType.NR, # Base method to use
verbose=False, # Verbose option where available
tolerance=1e-6, # power error in p.u.
max_iter=25, # maximum iteration number
control_q=True # if to control the reactive power
)
# Declare and execute the power flow simulation
pf = PowerFlowDriver(grid, pf_options)
pf.run()
# now, let's compose a nice DataFrame with the voltage results
headers = ['Vm (p.u.)', 'Va (Deg)', 'Vre', 'Vim']
Vm = np.abs(pf.results.voltage)
Va = np.angle(pf.results.voltage, deg=True)
Vre = pf.results.voltage.real
Vim = pf.results.voltage.imag
data = np.c_[Vm, Va, Vre, Vim]
v_df = pd.DataFrame(data=data, columns=headers, index=grid.bus_names)
print('\n', v_df)
# Let's do the same for the branch results
headers = ['Loading (%)', 'Current(p.u.)', 'Power (MVA)']
loading = np.abs(pf.results.loading) * 100
current = np.abs(pf.results.Ibranch)
power = np.abs(pf.results.Sbranch)
data = np.c_[loading, current, power]
br_df = pd.DataFrame(data=data, columns=headers, index=grid.branch_names)
print('\n', br_df)
# Finally the execution metrics
print('\nError:', pf.results.error)
print('Elapsed time (s):', pf.results.elapsed, '\n')
print(v_df)
print()
print(br_df)
class GridGeneratorGUI(QDialog):
def __init__(
self,
parent=None,
):
"""
:param parent:
"""
QDialog.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle('Grid Generator')
self.g = RpgAlgorithm()
self.circuit = MultiCircuit()
self.applied = False
self.ui.applyButton.clicked.connect(self.apply)
self.ui.previewButton.clicked.connect(self.preview)
def msg(self, text, title="Warning"):
"""
Message box
:param text: Text to display
:param title: Name of the window
"""
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText(text)
# msg.setInformativeText("This is additional information")
msg.setWindowTitle(title)
# msg.setDetailedText("The details are as follows:")
msg.setStandardButtons(QMessageBox.Ok)
retval = msg.exec_()
def fill_graph(self):
"""
# set desired parameters and perform algorithm
:return:
"""
self.g = RpgAlgorithm()
n = self.ui.nodes_spinBox.value()
n0 = 10
r = self.ui.ratio_SpinBox.value()
if n0 >= n:
n0 = n - 1
self.g.set_params(n=n, n0=n0, r=r)
self.g.initialise()
self.g.grow()
def preview(self):
"""
:return:
"""
self.fill_graph()
G = nx.Graph(self.g.edges)
pos = {
i: (self.g.lat[i], self.g.lon[i])
for i in range(self.g.added_nodes)
}
self.ui.plotwidget.clear()
nx.draw(G,
ax=self.ui.plotwidget.get_axis(),
pos=pos,
with_labels=True,
node_color='lightblue')
self.ui.plotwidget.redraw()
def apply(self):
"""
Create graph, then the circuit and close
:return: Nothing
"""
self.fill_graph()
self.circuit = MultiCircuit()
explosion_factor = 10000.0
# number of nodes
n = self.g.added_nodes
# assign the load and generation buses
genbus = self.ui.generation_nodes_SpinBox.value()
loadbus = self.ui.load_nodes_SpinBox.value()
if (genbus + loadbus) > 100:
s = genbus + loadbus
genbus /= s
loadbus /= s
gen_buses_num = int(np.floor(n * genbus / 100))
load_buses_num = int(np.floor(n * loadbus / 100))
rng = default_rng()
numbers = rng.choice(n,
size=gen_buses_num + load_buses_num,
replace=False)
gen_buses = numbers[:gen_buses_num]
load_buses = numbers[gen_buses_num:]
pmax = self.ui.power_SpinBox.value()
# generate buses
bus_dict = dict()
for i in range(n):
bus = Bus(name='Bus ' + str(i + 1),
xpos=self.g.lat[i] * explosion_factor,
ypos=-self.g.lon[i] * explosion_factor)
bus_dict[i] = bus
self.circuit.add_bus(bus)
# generate loads
factor = np.random.random(load_buses_num)
factor /= factor.sum()
pf = self.ui.power_factor_SpinBox.value()
for k, i in enumerate(load_buses):
bus = bus_dict[i]
p = pmax * factor[k]
q = p * pf
load = Load(name='Load@bus' + str(i + 1), P=p, Q=q)
self.circuit.add_load(bus, load)
# generate generators
factor = np.random.random(gen_buses_num)
factor /= factor.sum()
for k, i in enumerate(gen_buses):
bus = bus_dict[i]
gen = Generator(name='Generator@bus' + str(i + 1),
active_power=pmax * factor[k])
self.circuit.add_generator(bus, gen)
# generate lines
r = self.ui.r_SpinBox.value()
x = self.ui.x_SpinBox.value()
b = self.ui.b_SpinBox.value()
for f, t in self.g.edges:
dx = (self.g.lat[f] - self.g.lat[t]) * explosion_factor
dy = (self.g.lon[f] - self.g.lon[t]) * explosion_factor
m = np.sqrt(
dx * dx +
dy * dy) / 10.0 # divided by 10 to have more meaningful values
b1 = bus_dict[f]
b2 = bus_dict[t]
lne = Line(bus_from=b1,
bus_to=b2,
name='Line ' + str(f) + '-' + str(t),
r=r * m,
x=x * m,
b=b * m,
length=m)
self.circuit.add_line(lne)
# quit
self.applied = True
self.close()
def parse_json_data_v2(data: dict, logger: Logger):
"""
New Json parser
:param data:
:param logger:
:return:
"""
devices = data['devices']
profiles = data['profiles']
if DeviceType.CircuitDevice.value in devices.keys():
dta = devices[DeviceType.CircuitDevice.value]
circuit = MultiCircuit(name=str(dta['name']),
Sbase=float(dta['sbase']),
fbase=float(dta['fbase']),
idtag=str(dta['id']))
jcircuit = devices["Circuit"]
circuit.Sbase = jcircuit["sbase"]
bus_dict = dict()
if 'Bus' in devices.keys():
buses = devices["Bus"]
for jentry in buses:
bus = Bus(name=str(jentry['name']),
idtag=str(jentry['id']),
vnom=float(jentry['vnom']),
vmin=float(jentry['vmin']),
vmax=float(jentry['vmax']),
r_fault=float(jentry['rf']),
x_fault=float(jentry['xf']),
xpos=float(jentry['x']),
ypos=float(jentry['y']),
height=float(jentry['h']),
width=float(jentry['w']),
active=bool(jentry['active']),
is_slack=bool(jentry['is_slack']),
# is_dc=jbus['id'],
area=jentry['area'],
zone=jentry['zone'],
substation=jentry['substation'],
# country=jbus['id'],
longitude=float(jentry['lon']),
latitude=float(jentry['lat']) )
bus_dict[jentry['id']] = bus
circuit.add_bus(bus)
if 'Generator' in devices.keys():
generators = devices["Generator"]
for jentry in generators:
gen = Generator(name=str(jentry['name']),
idtag=str(jentry['id']),
active_power=float(jentry['p']),
power_factor=float(jentry['pf']),
voltage_module=float(jentry['vset']),
is_controlled=bool(jentry['is_controlled']),
Qmin=float(jentry['qmin']),
Qmax=float(jentry['qmax']),
Snom=float(jentry['snom']),
# power_prof=jgen['name'],
# power_factor_prof=jgen['name'],
# vset_prof=jgen['name'],
# Cost_prof=jgen['name'],
active=bool(jentry['active']),
p_min=float(jentry['pmin']),
p_max=float(jentry['pmax']),
op_cost=float(jentry['cost']),
# Sbase=jgen['name'],
# enabled_dispatch=jgen['name'],
# mttf=jgen['name'],
# mttr=jgen['name']
)
gen.bus = bus_dict[jentry['bus']]
circuit.add_generator(gen.bus, gen)
if 'Battery' in devices.keys():
batteries = devices["Battery"]
for jentry in batteries:
gen = Battery(name=str(jentry['name']),
idtag=str(jentry['id']),
active_power=float(jentry['p']),
power_factor=float(jentry['pf']),
voltage_module=float(jentry['vset']),
is_controlled=bool(jentry['is_controlled']),
Qmin=float(jentry['qmin']),
Qmax=float(jentry['qmax']),
Snom=float(jentry['snom']),
# power_prof=jgen['name'],
# power_factor_prof=jgen['name'],
# vset_prof=jgen['name'],
# Cost_prof=jgen['name'],
active=bool(jentry['active']),
p_min=float(jentry['pmin']),
p_max=float(jentry['pmax']),
op_cost=float(jentry['cost']),
# Sbase=jgen['name'],
# enabled_dispatch=jgen['name'],
# mttf=jgen['name'],
# mttr=jgen['name']
)
gen.bus = bus_dict[jentry['bus']]
circuit.add_battery(gen.bus, gen)
if 'Load' in devices.keys():
loads = devices["Load"]
for jentry in loads:
elm = Load(name=str(jentry['name']),
idtag=str(jentry['id']),
# G: float = 0.0,
# B: float = 0.0,
# Ir: float = 0.0,
# Ii: float = 0.0,
P=float(jentry['p']),
Q=float(jentry['q']),
# cost=jentry['cost'],
# G_prof: Any = None,
# B_prof: Any = None,
# Ir_prof: Any = None,
# Ii_prof: Any = None,
# P_prof: Any = None,
# Q_prof: Any = None,
active=bool(jentry['active']))
elm.bus = bus_dict[jentry['bus']]
circuit.add_load(elm.bus, elm)
if "Shunt" in devices.keys():
shunts = devices["Shunt"]
for jentry in shunts:
elm = Shunt(name=str(jentry['name']),
idtag=str(jentry['id']),
G=float(jentry['g']),
B=float(jentry['b']),
# G_prof: Any = None,
# B_prof: Any = None,
active=bool(jentry['active']))
elm.bus = bus_dict[jentry['bus']]
circuit.add_shunt(elm.bus, elm)
if "Line" in devices.keys():
lines = devices["Line"]
for entry in lines:
elm = Line(bus_from=bus_dict[entry['bus_from']],
bus_to=bus_dict[entry['bus_to']],
name=str(entry['name']),
idtag=str(entry['id']),
r=float(entry['r']),
x=float(entry['x']),
b=float(entry['b']),
rate=float(entry['rate']),
active=entry['active'],
# tolerance: int = 0,
# cost: float = 0.0,
# mttf: int = 0,
# mttr: int = 0,
# r_fault: float = 0.0,
# x_fault: float = 0.0,
# fault_pos: float = 0.5,
length=float(entry['length']),
# temp_base: int = 20,
# temp_oper: int = 20,
# alpha: float = 0.00330,
# template: LineTemplate = LineTemplate(),
# rate_prof: Any = None,
# Cost_prof: Any = None,
# active_prof: Any = None,
# temp_oper_prof: Any = None
)
circuit.add_line(elm)
if "Transformer" in devices.keys():
transformers = devices["Transformer"]
for entry in transformers:
elm = Transformer2W(bus_from=bus_dict[entry['bus_from']],
bus_to=bus_dict[entry['bus_to']],
name=str(entry['name']),
idtag=str(entry['id']),
r=float(entry['r']),
x=float(entry['x']),
g=float(entry['g']),
b=float(entry['b']),
rate=float(entry['rate']),
active=bool(entry['active']),
tap=float(entry['tap_module']),
shift_angle=float(entry['tap_angle']),
# tolerance: int = 0,
# cost: float = 0.0,
# mttf: int = 0,
# mttr: int = 0,
# r_fault: float = 0.0,
# x_fault: float = 0.0,
# fault_pos: float = 0.5,
# temp_base: int = 20,
# temp_oper: int = 20,
# alpha: float = 0.00330,
# template: LineTemplate = LineTemplate(),
# rate_prof: Any = None,
# Cost_prof: Any = None,
# active_prof: Any = None,
# temp_oper_prof: Any = None
)
circuit.add_transformer2w(elm)
if "VSC" in devices.keys():
vsc = devices["VSC"]
if "HVDC Line" in devices.keys():
hvdc = devices["HVDC Line"]
return circuit
else:
logger.add('The Json structure does not have a Circuit inside the devices!')
return MultiCircuit()
def get_grid_lynn_5_bus_wiki():
grid = MultiCircuit(name='lynn 5 bus')
bus_1 = Bus(
name='bus_1',
vnom=10, # Nominal voltage in kV
vmin=0.9, # Bus minimum voltage in per unit
vmax=1.1, # Bus maximum voltage in per unit
xpos=0, # Bus x position in pixels
ypos=0, # Bus y position in pixels
height=0, # Bus height in pixels
width=0, # Bus width in pixels
active=True, # Is the bus active?
is_slack=False, # Is this bus a slack bus?
area='Default', # Area (for grouping purposes only)
zone='Default', # Zone (for grouping purposes only)
substation='Default' # Substation (for grouping purposes only)
)
bus_2 = Bus(name='bus_2')
bus_3 = Bus(name='bus_3')
bus_4 = Bus(name='bus_4')
bus_5 = Bus(name='bus_5')
grid.add_bus(bus_1)
grid.add_bus(bus_2)
grid.add_bus(bus_3)
grid.add_bus(bus_4)
grid.add_bus(bus_5)
load_2 = Load(
name='Load',
# impedance=complex(0, 0),
# Impedance of the ZIP model in MVA at the nominal voltage
# current=complex(0, 0),
# Current of the ZIP model in MVA at the nominal voltage
# power=complex(40, 20), # Power of the ZIP model in MVA
# impedance_prof=None, # Impedance profile
# current_prof=None, # Current profile
# power_prof=None, # Power profile
active=True, # Is active?
mttf=0.0, # Mean time to failure
mttr=0.0 # Mean time to recovery
)
grid.add_load(bus_2, load_2)
grid.add_load(
bus_3,
Load(
# power=complex(25, 15)
))
grid.add_load(
bus_4,
Load(
# power=complex(40, 20)
))
grid.add_load(
bus_5,
Load(
# power=complex(50, 20)
))
generator_1 = Generator(
name='gen',
active_power=0.0,
# Active power in MW, since this generator is used to set the slack , is 0
voltage_module=1.0, # Voltage set point to control
Qmin=-9999, # minimum reactive power in MVAr
Qmax=9999, # Maximum reactive power in MVAr
Snom=9999, # Nominal power in MVA
power_prof=None, # power profile
vset_prof=None, # voltage set point profile
active=True # Is active?
)
grid.add_generator(bus_1, generator_1)
branch_1 = Branch(
bus_from=bus_1,
bus_to=bus_2,
name='Line 1-2',
r=0.05, # resistance of the pi model in per unit
x=0.11, # reactance of the pi model in per unit
g=1e-20, # conductance of the pi model in per unit
b=0.02, # susceptance of the pi model in per unit
rate=50, # Rate in MVA
tap=1.0, # Tap value (value close to 1)
shift_angle=0, # Tap angle in radians
active=True, # is the branch active?
mttf=0, # Mean time to failure
mttr=0, # Mean time to recovery
branch_type=BranchType.Line, # Branch type tag
length=1, # Length in km (to be used with templates)
# type_obj=BranchTemplate()
# Branch template (The default one is void)
)
grid.add_branch(branch_1)
grid.add_branch(
Branch(bus_1, bus_3, name='Line 1-3', r=0.05, x=0.11, b=0.02, rate=50))
grid.add_branch(
Branch(bus_1, bus_5, name='Line 1-5', r=0.03, x=0.08, b=0.02, rate=80))
grid.add_branch(
Branch(bus_2, bus_3, name='Line 2-3', r=0.04, x=0.09, b=0.02, rate=3))
grid.add_branch(
Branch(bus_2, bus_5, name='Line 2-5', r=0.04, x=0.09, b=0.02, rate=10))
grid.add_branch(
Branch(bus_3, bus_4, name='Line 3-4', r=0.06, x=0.13, b=0.03, rate=30))
grid.add_branch(
Branch(bus_4, bus_5, name='Line 4-5', r=0.04, x=0.09, b=0.02, rate=30))
grid.compile()
return grid
def interprete_excel_v2(circuit: MultiCircuit, data):
"""
Interpret the file version 2
:param circuit:
:param data: Dictionary with the excel file sheet labels and the corresponding DataFrame
:return: Nothing, just applies the loaded data to this MultiCircuit instance
"""
# print('Interpreting V2 data...')
# clear all the data
circuit.clear()
circuit.name = data['name']
# set the base magnitudes
circuit.Sbase = data['baseMVA']
# dictionary of branch types [name] -> type object
branch_types = dict()
# Set comments
circuit.comments = data['Comments'] if 'Comments' in data.keys() else ''
circuit.time_profile = None
circuit.logger = Logger()
# common function
def set_object_attributes(obj_, attr_list, values):
for a, attr in enumerate(attr_list):
# Hack to change the enabled by active...
if attr == 'is_enabled':
attr = 'active'
if attr == 'type_obj':
attr = 'template'
if hasattr(obj_, attr):
conv = obj_.editable_headers[
attr].tpe # get the type converter
if conv is None:
setattr(obj_, attr, values[a])
elif conv is BranchType:
cbr = BranchTypeConverter(None)
setattr(obj_, attr, cbr(values[a]))
else:
setattr(obj_, attr, conv(values[a]))
else:
if attr in [
'Y', 'Z', 'I', 'S', 'seq_resistance', 'seq_admittance',
'Zf'
]:
if attr == 'Z':
val = complex(values[a])
re = 1 / val.real if val.real != 0.0 else 0
im = 1 / val.imag if val.imag != 0.0 else 0
setattr(obj_, 'G', re)
setattr(obj_, 'B', im)
if attr == 'Zf':
val = complex(values[a])
re = 1 / val.real if val.real != 0.0 else 0
im = 1 / val.imag if val.imag != 0.0 else 0
setattr(obj_, 'r_fault', re)
setattr(obj_, 'x_fault', im)
if attr == 'Y':
val = complex(values[a])
re = val.real
im = val.imag
setattr(obj_, 'G', re)
setattr(obj_, 'B', im)
elif attr == 'I':
val = complex(values[a])
setattr(obj_, 'Ir', val.real)
setattr(obj_, 'Ii', val.imag)
elif attr == 'S':
val = complex(values[a])
setattr(obj_, 'P', val.real)
setattr(obj_, 'Q', val.imag)
elif attr == 'seq_resistance':
val = complex(values[a])
setattr(obj_, 'R1', val.real)
setattr(obj_, 'X1', val.imag)
elif attr == 'seq_admittance':
val = complex(values[a])
setattr(obj_, 'Gsh1', val.real)
setattr(obj_, 'Bsh1', val.imag)
else:
warn(str(obj_) + ' has no ' + attr + ' property.')
# Add the buses ################################################################################################
bus_dict = dict()
if 'bus' in data.keys():
lst = data['bus']
hdr = lst.columns.values
vals = lst.values
for i in range(len(lst)):
obj = Bus()
set_object_attributes(obj, hdr, vals[i, :])
bus_dict[obj.name] = obj
circuit.add_bus(obj)
else:
circuit.logger.append('No buses in the file!')
# add the loads ################################################################################################
if 'load' in data.keys():
lst = data['load']
bus_from = lst['bus'].values
hdr = lst.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = lst[hdr].values
for i in range(len(lst)):
obj = Load()
set_object_attributes(obj, hdr, vals[i, :])
if 'load_Sprof' in data.keys():
idx = data['load_Sprof'].index
# create all the profiles
obj.create_profiles(index=idx)
# create the power profiles
val = np.array(
[complex(v) for v in data['load_Sprof'].values[:, i]])
obj.create_profile(magnitude='P', index=idx, arr=val.real)
obj.create_profile(magnitude='Q', index=idx, arr=val.imag)
if circuit.time_profile is None or len(
circuit.time_profile) < len(idx):
circuit.time_profile = idx
if 'load_Iprof' in data.keys():
val = np.array(
[complex(v) for v in data['load_Iprof'].values[:, i]])
idx = data['load_Iprof'].index
obj.create_profile(magnitude='Ir', index=idx, arr=val.real)
obj.create_profile(magnitude='Ii', index=idx, arr=val.imag)
if circuit.time_profile is None or len(
circuit.time_profile) < len(idx):
circuit.time_profile = idx
if 'load_Zprof' in data.keys():
val = np.array(
[complex(v) for v in data['load_Zprof'].values[:, i]])
idx = data['load_Zprof'].index
obj.create_profile(magnitude='G', index=idx, arr=val.real)
obj.create_profile(magnitude='B', index=idx, arr=val.imag)
if circuit.time_profile is None or len(
circuit.time_profile) < len(idx):
circuit.time_profile = idx
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) + ': Load bus is not in the buses list.\n' +
str(ex))
if obj.name == 'Load':
obj.name += str(len(bus.loads) + 1) + '@' + bus.name
obj.bus = bus
bus.loads.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No loads in the file!')
# add the controlled generators ################################################################################
if 'controlled_generator' in data.keys():
lst = data['controlled_generator']
bus_from = lst['bus'].values
hdr = lst.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = lst[hdr].values
for i in range(len(lst)):
obj = Generator()
set_object_attributes(obj, hdr, vals[i, :])
if 'CtrlGen_P_profiles' in data.keys():
val = data['CtrlGen_P_profiles'].values[:, i]
idx = data['CtrlGen_P_profiles'].index
obj.create_profile(magnitude='P', index=idx, arr=val)
# also create the Pf array because there might not be values in the file
obj.create_profile(magnitude='Pf', index=idx)
if 'CtrlGen_Pf_profiles' in data.keys():
val = data['CtrlGen_Pf_profiles'].values[:, i]
idx = data['CtrlGen_Pf_profiles'].index
obj.create_profile(magnitude='Pf', index=idx, arr=val)
if 'CtrlGen_Vset_profiles' in data.keys():
val = data['CtrlGen_Vset_profiles'].values[:, i]
idx = data['CtrlGen_Vset_profiles'].index
obj.create_profile(magnitude='Vset', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) +
': Controlled generator bus is not in the buses list.\n' +
str(ex))
if obj.name == 'gen':
obj.name += str(len(bus.controlled_generators) +
1) + '@' + bus.name
obj.bus = bus
bus.controlled_generators.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No controlled generator in the file!')
# add the batteries ############################################################################################
if 'battery' in data.keys():
lst = data['battery']
bus_from = lst['bus'].values
hdr = lst.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = lst[hdr].values
for i in range(len(lst)):
obj = Battery()
set_object_attributes(obj, hdr, vals[i, :])
if 'battery_P_profiles' in data.keys():
val = data['battery_P_profiles'].values[:, i]
idx = data['battery_P_profiles'].index
obj.create_profile(magnitude='P', index=idx, arr=val)
obj.create_profile(magnitude='Pf', index=idx)
if 'battery_Pf_profiles' in data.keys():
val = data['battery_Pf_profiles'].values[:, i]
idx = data['battery_Pf_profiles'].index
obj.create_profile(magnitude='Pf', index=idx, arr=val)
if 'battery_Vset_profiles' in data.keys():
val = data['battery_Vset_profiles'].values[:, i]
idx = data['battery_Vset_profiles'].index
obj.create_profile(magnitude='Vset', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) + ': Battery bus is not in the buses list.\n' +
str(ex))
if obj.name == 'batt':
obj.name += str(len(bus.batteries) + 1) + '@' + bus.name
obj.bus = bus
bus.batteries.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No battery in the file!')
# add the static generators ####################################################################################
if 'static_generator' in data.keys():
lst = data['static_generator']
bus_from = lst['bus'].values
hdr = lst.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = lst[hdr].values
for i in range(len(lst)):
obj = StaticGenerator()
set_object_attributes(obj, hdr, vals[i, :])
if 'static_generator_Sprof' in data.keys():
val = data['static_generator_Sprof'].values[:, i]
idx = data['static_generator_Sprof'].index
obj.create_profile(magnitude='P', index=idx, arr=val.real)
obj.create_profile(magnitude='Q', index=idx, arr=val.imag)
if 'static_generator_P_prof' in data.keys():
val = data['static_generator_P_prof'].values[:, i]
idx = data['static_generator_P_prof'].index
obj.create_profile(magnitude='P', index=idx, arr=val)
if 'static_generator_Q_prof' in data.keys():
val = data['static_generator_Q_prof'].values[:, i]
idx = data['static_generator_Q_prof'].index
obj.create_profile(magnitude='Q', index=idx, arr=val)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) +
': Static generator bus is not in the buses list.\n' +
str(ex))
if obj.name == 'StaticGen':
obj.name += str(len(bus.static_generators) +
1) + '@' + bus.name
obj.bus = bus
bus.static_generators.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No static generator in the file!')
# add the shunts ###############################################################################################
if 'shunt' in data.keys():
lst = data['shunt']
bus_from = lst['bus'].values
hdr = lst.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus'))
vals = lst[hdr].values
for i in range(len(lst)):
obj = Shunt()
set_object_attributes(obj, hdr, vals[i, :])
if 'shunt_Y_profiles' in data.keys():
val = data['shunt_Y_profiles'].values[:, i]
idx = data['shunt_Y_profiles'].index
obj.create_profile(magnitude='G', index=idx, arr=val.real)
obj.create_profile(magnitude='B', index=idx, arr=val.imag)
try:
bus = bus_dict[str(bus_from[i])]
except KeyError as ex:
raise Exception(
str(i) + ': Shunt bus is not in the buses list.\n' +
str(ex))
if obj.name == 'shunt':
obj.name += str(len(bus.shunts) + 1) + '@' + bus.name
obj.bus = bus
bus.shunts.append(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No shunt in the file!')
# Add the wires ################################################################################################
if 'wires' in data.keys():
lst = data['wires']
hdr = lst.columns.values
vals = lst.values
for i in range(len(lst)):
obj = Wire()
set_object_attributes(obj, hdr, vals[i, :])
circuit.add_wire(obj)
else:
circuit.logger.append('No wires in the file!')
# Add the overhead_line_types ##################################################################################
if 'overhead_line_types' in data.keys():
lst = data['overhead_line_types']
if data['overhead_line_types'].values.shape[0] > 0:
for tower_name in lst['tower_name'].unique():
obj = Tower()
vals = lst[lst['tower_name'] == tower_name].values
# set the tower values
set_object_attributes(obj, obj.editable_headers.keys(),
vals[0, :])
# add the wires
for i in range(vals.shape[0]):
wire = Wire()
set_object_attributes(wire, obj.get_wire_properties(),
vals[i,
len(obj.editable_headers):])
obj.wires_in_tower.append(wire)
circuit.add_overhead_line(obj)
branch_types[str(obj)] = obj
else:
pass
else:
circuit.logger.append('No overhead_line_types in the file!')
# Add the wires ################################################################################################
if 'underground_cable_types' in data.keys():
lst = data['underground_cable_types']
hdr = lst.columns.values
vals = lst.values
# for i in range(len(lst)):
# obj = UndergroundLineType()
# set_object_attributes(obj, hdr, vals[i, :])
# circuit.underground_cable_types.append(obj)
# branch_types[str(obj)] = obj
else:
circuit.logger.append('No underground_cable_types in the file!')
# Add the sequence line types ##################################################################################
if 'sequence_line_types' in data.keys():
lst = data['sequence_line_types']
hdr = lst.columns.values
vals = lst.values
for i in range(len(lst)):
obj = SequenceLineType()
set_object_attributes(obj, hdr, vals[i, :])
circuit.add_sequence_line(obj)
branch_types[str(obj)] = obj
else:
circuit.logger.append('No sequence_line_types in the file!')
# Add the transformer types ####################################################################################
if 'transformer_types' in data.keys():
lst = data['transformer_types']
hdr = lst.columns.values
vals = lst.values
for i in range(len(lst)):
obj = TransformerType()
set_object_attributes(obj, hdr, vals[i, :])
circuit.add_transformer_type(obj)
branch_types[str(obj)] = obj
else:
circuit.logger.append('No transformer_types in the file!')
# Add the branches #############################################################################################
if 'branch' in data.keys():
lst = data['branch']
# fix the old 'is_transformer' property
if 'is_transformer' in lst.columns.values:
lst['is_transformer'] = lst['is_transformer'].map({
True: 'transformer',
False: 'line'
})
lst.rename(columns={'is_transformer': 'branch_type'}, inplace=True)
bus_from = lst['bus_from'].values
bus_to = lst['bus_to'].values
hdr = lst.columns.values
hdr = np.delete(hdr, np.argwhere(hdr == 'bus_from'))
hdr = np.delete(hdr, np.argwhere(hdr == 'bus_to'))
vals = lst[hdr].values
for i in range(len(lst)):
try:
obj = Branch(bus_from=bus_dict[str(bus_from[i])],
bus_to=bus_dict[str(bus_to[i])])
except KeyError as ex:
raise Exception(
str(i) + ': Branch bus is not in the buses list.\n' +
str(ex))
set_object_attributes(obj, hdr, vals[i, :])
# correct the branch template object
template_name = str(obj.template)
if template_name in branch_types.keys():
obj.template = branch_types[template_name]
print(template_name, 'updated!')
# set the branch
circuit.add_branch(obj)
obj.ensure_profiles_exist(circuit.time_profile)
else:
circuit.logger.append('No branches in the file!')
# Other actions ################################################################################################
circuit.logger += circuit.apply_all_branch_types()
def interpret_data_v1(circuit: MultiCircuit, data) -> MultiCircuit:
"""
Pass the loaded table-like data to the structures
:param circuit:
:param data: Data dictionary
:return:
"""
circuit.clear()
# time profile
if 'master_time' in data.keys():
master_time_array = data['master_time']
else:
master_time_array = None
import GridCal.Engine.IO.matpower_bus_definitions as e
# Buses
table = data['bus']
n = table.shape[0]
# load profiles
if 'Lprof' in data.keys():
Pprof = data['Lprof']
Qprof = data['LprofQ']
are_load_prfiles = True
print('There are load profiles')
else:
are_load_prfiles = False
if 'bus_names' in data.keys():
names = data['bus_names']
else:
names = ['bus ' + str(i+1) for i in range(n)]
# Buses
bus_idx_dict = dict()
for i in range(n):
# Create bus
bus = Bus(name=names[i],
vnom=table[i, e.BASE_KV],
vmax=table[i, e.VMAX],
vmin=table[i, e.VMIN])
# store the given bus index in relation to its real index in the table for later
bus_idx_dict[table[i, e.BUS_I]] = i
# determine if the bus is set as slack manually
tpe = table[i, e.BUS_TYPE]
if tpe == e.REF:
bus.is_slack = True
else:
bus.is_slack = False
# Add the load
if table[i, e.PD] != 0 or table[i, e.QD] != 0:
load = Load(P=table[i, e.PD], Q=table[i, e.QD])
load.bus = bus
bus.loads.append(load)
# Add the shunt
if table[i, e.GS] != 0 or table[i, e.BS] != 0:
shunt = Shunt(G=table[i, e.GS], B=table[i, e.BS])
shunt.bus = bus
bus.shunts.append(shunt)
# Add the bus to the circuit buses
circuit.add_bus(bus)
import GridCal.Engine.IO.matpower_gen_definitions as e
# Generators
table = data['gen']
n = len(table)
# load profiles
if 'Gprof' in data.keys():
Gprof = data['Gprof']
are_gen_prfiles = True
print('There are gen profiles')
else:
are_gen_prfiles = False
if 'gen_names' in data.keys():
names = data['gen_names']
else:
names = ['gen ' + str(i) for i in range(n)]
for i in range(len(table)):
bus_idx = bus_idx_dict[int(table[i, e.GEN_BUS])]
gen = Generator(name=names[i],
active_power=table[i, e.PG],
voltage_module=table[i, e.VG],
Qmax=table[i, e.QMAX],
Qmin=table[i, e.QMIN])
# Add the generator to the bus
gen.bus = circuit.buses[bus_idx]
circuit.buses[bus_idx].controlled_generators.append(gen)
import GridCal.Engine.IO.matpower_branch_definitions as e
# Branches
table = data['branch']
n = len(table)
if 'branch_names' in data.keys():
names = data['branch_names']
else:
names = ['branch ' + str(i) for i in range(n)]
for i in range(len(table)):
f = circuit.buses[bus_idx_dict[int(table[i, e.F_BUS])]]
t = circuit.buses[bus_idx_dict[int(table[i, e.T_BUS])]]
if table.shape[1] == 37: # FUBM model
matpower_mode = table[i, e.CONV_A]
if matpower_mode > 0: # it is a converter
# this is by design of the matpower FUBM model, if it is a converter,
# the DC bus is always the from bus
f.is_dc = True
# determine the converter control mode
Pset = table[i, e.PF]
Vac_set = table[i, e.VT_SET]
Vdc_set = table[i, e.VF_SET]
Qset = table[i, e.QF]
m = table[i, e.TAP] if table[i, e.TAP] > 0 else 1.0
if matpower_mode == 1:
if Pset != 0.0:
control_mode = ConverterControlType.type_1_pf
elif Qset != 0.0:
control_mode = ConverterControlType.type_1_qf
elif Vac_set != 0.0:
control_mode = ConverterControlType.type_1_vac
else:
control_mode = ConverterControlType.type_1_free
elif matpower_mode == 2:
if Pset == 0.0:
control_mode = ConverterControlType.type_2_vdc
else:
control_mode = ConverterControlType.type_2_vdc_pf
elif matpower_mode == 3:
control_mode = ConverterControlType.type_3
elif matpower_mode == 4:
control_mode = ConverterControlType.type_4
else:
control_mode = ConverterControlType.type_1_free
branch = VSC(bus_from=f,
bus_to=t,
name='VSC' + str(len(circuit.vsc_converters) + 1),
active=bool(table[i, e.BR_STATUS]),
r1=table[i, e.BR_R],
x1=table[i, e.BR_X],
m=m,
m_max=table[i, e.MA_MAX],
m_min=table[i, e.MA_MIN],
theta=table[i, e.SHIFT],
theta_max=np.deg2rad(table[i, e.ANGMAX]),
theta_min=np.deg2rad(table[i, e.ANGMIN]),
G0=table[i, e.GSW],
Beq=table[i, e.BEQ],
Beq_max=table[i, e.BEQ_MAX],
Beq_min=table[i, e.BEQ_MIN],
rate=table[i, e.RATE_A],
kdp=table[i, e.KDP],
control_mode=control_mode,
Pset=Pset,
Qset=Qset,
Vac_set=Vac_set,
Vdc_set=Vdc_set,
alpha1=table[i, e.ALPHA1],
alpha2=table[i, e.ALPHA2],
alpha3=table[i, e.ALPHA3])
circuit.add_vsc(branch)
else:
if f.Vnom != t.Vnom or (table[i, e.TAP] != 1.0 and table[i, e.TAP] != 0) or table[i, e.SHIFT] != 0.0:
branch = Transformer2W(bus_from=f,
bus_to=t,
name=names[i],
r=table[i, e.BR_R],
x=table[i, e.BR_X],
g=0,
b=table[i, e.BR_B],
rate=table[i, e.RATE_A],
tap=table[i, e.TAP],
shift_angle=table[i, e.SHIFT],
active=bool(table[i, e.BR_STATUS]))
circuit.add_transformer2w(branch)
else:
branch = Line(bus_from=f,
bus_to=t,
name=names[i],
r=table[i, e.BR_R],
x=table[i, e.BR_X],
b=table[i, e.BR_B],
rate=table[i, e.RATE_A],
active=bool(table[i, e.BR_STATUS]))
circuit.add_line(branch)
else:
if f.Vnom != t.Vnom or (table[i, e.TAP] != 1.0 and table[i, e.TAP] != 0) or table[i, e.SHIFT] != 0.0:
branch = Transformer2W(bus_from=f,
bus_to=t,
name=names[i],
r=table[i, e.BR_R],
x=table[i, e.BR_X],
g=0,
b=table[i, e.BR_B],
rate=table[i, e.RATE_A],
tap=table[i, e.TAP],
shift_angle=table[i, e.SHIFT],
active=bool(table[i, e.BR_STATUS]))
circuit.add_transformer2w(branch)
else:
branch = Line(bus_from=f,
bus_to=t,
name=names[i],
r=table[i, e.BR_R],
x=table[i, e.BR_X],
b=table[i, e.BR_B],
rate=table[i, e.RATE_A],
active=bool(table[i, e.BR_STATUS]))
circuit.add_line(branch)
# convert normal lines into DC-lines if needed
for line in circuit.lines:
if line.bus_to.is_dc and line.bus_from.is_dc:
dc_line = DcLine(bus_from=line.bus_from,
bus_to=line.bus_to,
name=line.name,
active=line.active,
rate=line.rate,
r=line.R,
active_prof=line.active_prof,
rate_prof=line.rate_prof)
# add device to the circuit
circuit.add_dc_line(dc_line)
# delete the line from the circuit
circuit.delete_line(line)
# add the profiles
if master_time_array is not None:
circuit.format_profiles(master_time_array)
return circuit
def data_to_grid_object(data, pos_dict, codification="utf-8") -> MultiCircuit:
"""
Turns the read data dictionary into a GridCal MultiCircuit object
Args:
data: Dictionary of data read from a DGS file
pos_dict: Dictionary of objects and their positions read from a DGS file
Returns: GridCal MultiCircuit object
"""
###############################################################################
# Refactor data into classes
###############################################################################
# store tables for easy reference
'''
###############################################################################
* Line
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypLne,TypTow,TypGeo,TypCabsys
* chr_name: Characteristic Name
* dline: Parameters: Length of Line in km
* fline: Parameters: Derating Factor
* outserv: Out of Service
* pStoch: Failures: Element model in StoTyplne
'''
if "ElmLne" in data.keys():
lines = data["ElmLne"]
else:
lines = np.zeros((0, 20))
'''
###############################################################################
* Line Type
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* Ithr: Rated Short-Time (1s) Current (Conductor) in kA
* aohl_: Cable / OHL
* cline: Parameters per Length 1,2-Sequence: Capacitance C' in uF/km
* cline0: Parameters per Length Zero Sequence: Capacitance C0' in uF/km
* nlnph: Phases:1:2:3
* nneutral: Number of Neutrals:0:1
* rline: Parameters per Length 1,2-Sequence: AC-Resistance R'(20°C) in Ohm/km
* rline0: Parameters per Length Zero Sequence: AC-Resistance R0' in Ohm/km
* rtemp: Max. End Temperature in degC
* sline: Rated Current in kA
* uline: Rated Voltage in kV
* xline: Parameters per Length 1,2-Sequence: Reactance X' in Ohm/km
* xline0: Parameters per Length Zero Sequence: Reactance X0' in Ohm/km
'''
if "TypLne" in data.keys():
lines_types = data["TypLne"]
else:
lines_types = np.zeros((0, 20))
'''
###############################################################################
* 2-Winding Transformer
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypTr2
* chr_name: Characteristic Name
* sernum: Serial Number
* constr: Year of Construction
* cgnd_h: Internal Grounding Impedance, HV Side: Star Point:Connected:Not connected
* cgnd_l: Internal Grounding Impedance, LV Side: Star Point:Connected:Not connected
* i_auto: Auto Transformer
* nntap: Tap Changer 1: Tap Position
* ntrcn: Controller, Tap Changer 1: Automatic Tap Changing
* outserv: Out of Service
* ratfac: Rating Factor
'''
if "ElmTr2" in data.keys():
transformers = data["ElmTr2"]
else:
transformers = np.zeros((0, 20))
'''
###############################################################################
* 2-Winding Transformer Type
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* curmg: Magnetising Impedance: No Load Current in %
* dutap: Tap Changer 1: Additional Voltage per Tap in %
* frnom: Nominal Frequency in Hz
* manuf: Manufacturer
* nntap0: Tap Changer 1: Neutral Position
* nt2ag: Vector Group: Phase Shift in *30deg
* ntpmn: Tap Changer 1: Minimum Position
* ntpmx: Tap Changer 1: Maximum Position
* pcutr: Positive Sequence Impedance: Copper Losses in kW
* pfe: Magnetising Impedance: No Load Losses in kW
* phitr: Tap Changer 1: Phase of du in deg
* strn: Rated Power in MVA
* tap_side: Tap Changer 1: at Side:HV:LV
* tr2cn_h: Vector Group: HV-Side:Y :YN:Z :ZN:D
* tr2cn_l: Vector Group: LV-Side:Y :YN:Z :ZN:D
* uk0tr: Zero Sequence Impedance: Short-Circuit Voltage uk0 in %
* uktr: Positive Sequence Impedance: Short-Circuit Voltage uk in %
* ur0tr: Zero Sequence Impedance: SHC-Voltage (Re(uk0)) uk0r in %
* utrn_h: Rated Voltage: HV-Side in kV
* utrn_l: Rated Voltage: LV-Side in kV
* zx0hl_n: Zero Sequence Magnetising Impedance: Mag. Impedance/uk0
'''
if "TypTr2" in data.keys():
transformers_types = data["TypTr2"]
else:
transformers_types = np.zeros((0, 20))
'''
###############################################################################
* Terminal
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypBar
* chr_name: Characteristic Name
* iUsage: Usage:Busbar:Junction Node:Internal Node
* outserv: Out of Service
* phtech: Phase Technology:ABC:ABC-N:BI:BI-N:2PH:2PH-N:1PH:1PH-N:N
* uknom: Nominal Voltage: Line-Line in kV
'''
if "ElmTerm" in data.keys():
buses = data["ElmTerm"]
else:
buses = np.zeros((0, 20))
'''
###############################################################################
* Cubicle
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* obj_bus: Bus Index
* obj_id: Connected with in Elm*
'''
if "StaCubic" in data.keys():
cubicles = data["StaCubic"]
else:
cubicles = np.zeros((0, 20))
'''
###############################################################################
* General Load
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypLod,TypLodind
* chr_name: Characteristic Name
* outserv: Out of Service
* plini: Operating Point: Active Power in MW
* qlini: Operating Point: Reactive Power in Mvar
* scale0: Operating Point: Scaling Factor
'''
if "ElmLod" in data.keys():
loads = data["ElmLod"]
else:
loads = np.zeros((0, 20))
'''
###############################################################################
* External Grid
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* bustp: Bus Type:PQ:PV:SL
* cgnd: Internal Grounding Impedance: Star Point:Connected:Not connected
* iintgnd: Neutral Conductor: N-Connection:None:At terminal (ABC-N):Separate terminal
* ikssmin: Min. Values: Short-Circuit Current Ik''min in kA
* r0tx0: Max. Values Impedance Ratio: R0/X0 max.
* r0tx0min: Min. Values Impedance Ratio: R0/X0 min.
* rntxn: Max. Values: R/X Ratio (max.)
* rntxnmin: Min. Values: R/X Ratio (min.)
* snss: Max. Values: Short-Circuit Power Sk''max in MVA
* snssmin: Min. Values: Short-Circuit Power Sk''min in MVA
'''
if "ElmXnet" in data.keys():
external = data["ElmXnet"]
else:
external = np.zeros((0, 20))
'''
###############################################################################
* Grid
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* frnom: Nominal Frequency in Hz
'''
if "ElmNet" in data.keys():
grid = data["ElmNet"]
else:
grid = np.zeros((0, 20))
'''
###############################################################################
'''
if "ElmGenstat" in data.keys():
static_generators = data["ElmGenstat"]
else:
static_generators = np.zeros((0, 20))
'''
###############################################################################
* Synchronous Machine
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypSym
* chr_name: Characteristic Name
* i_mot: Generator/Motor
* iv_mode: Local Controller
* ngnum: Number of: parallel Machines
* outserv: Out of Service
* pgini: Dispatch: Active Power in MW
* q_max: Reactive Power Operational Limits: Max. in p.u.
* q_min: Reactive Power Operational Limits: Min. in p.u.
* qgini: Dispatch: Reactive Power in Mvar
* usetp: Dispatch: Voltage in p.u.
'''
if "ElmSym" in data.keys():
synchronous_machine = data["ElmSym"]
else:
synchronous_machine = np.zeros((0, 20))
'''
###############################################################################
* Synchronous Machine Type
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* cosn: Power Factor
* rstr: Stator Resistance: rstr in p.u.
* satur: For single fed short-circuit: Machine Type IEC909/IEC60909
* sgn: Nominal Apparent Power in MVA
* ugn: Nominal Voltage in kV
* xd: Synchronous Reactances: xd in p.u.
* xdsat: For single fed short-circuit: Reciprocal of short-circuit ratio (xdsat) in p.u.
* xdsss: Subtransient Reactance: saturated value xd''sat in p.u.
* xq: Synchronous Reactances: xq in p.u.
'''
if "TypSym" in data.keys():
synchronous_machine_type = data["TypSym"]
else:
synchronous_machine_type = np.zeros((0, 20))
'''
###############################################################################
* Asynchronous Machine
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypAsm*,TypAsmo*,TypAsm1*
* chr_name: Characteristic Name
* i_mot: Generator/Motor
* ngnum: Number of: parallel Machines
* outserv: Out of Service
* pgini: Dispatch: Active Power in MW
'''
if "ElmAsm" in data.keys():
asynchronous_machine = data["ElmAsm"]
else:
asynchronous_machine = np.zeros((0, 20))
'''
###############################################################################
* Synchronous Machine Type
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* i_mode: Input Mode
* aiazn: Consider Transient Parameter: Locked Rotor Current (Ilr/In) in p.u.
* amazn: Locked Rotor Torque in p.u.
* amkzn: Torque at Stalling Point in p.u.
* anend: Nominal Speed in rpm
* cosn: Rated Power Factor
* effic: Efficiency at nominal Operation in %
* frequ: Nominal Frequency in Hz
* i_cage: Rotor
* nppol: No of Pole Pairs
* pgn: Power Rating: Rated Mechanical Power in kW
* ugn: Rated Voltage in kV
* xmrtr: Rotor Leakage Reac. Xrm in p.u.
* xstr: Stator Reactance Xs in p.u.
'''
if "TypAsmo" in data.keys():
asynchronous_machine_type = data["TypAsmo"]
else:
asynchronous_machine_type = np.zeros((0, 20))
'''
###############################################################################
* Shunt/Filter
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* ctech: Technology
* fres: Design Parameter (per Step): Resonance Frequency in Hz
* greaf0: Design Parameter (per Step): Quality Factor (at fr)
* iswitch: Controller: Switchable
* ncapa: Controller: Act.No. of Step
* ncapx: Controller: Max. No. of Steps
* outserv: Out of Service
* qtotn: Design Parameter (per Step): Rated Reactive Power, L-C in Mvar
* shtype: Shunt Type
* ushnm: Nominal Voltage in kV
'''
if "ElmShnt" in data.keys():
shunts = data["ElmShnt"]
else:
shunts = np.zeros((0, 20))
'''
###############################################################################
* Breaker/Switch
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypSwitch
* chr_name: Characteristic Name
* aUsage: Switch Type
* nneutral: No. of Neutrals:0:1
* nphase: No. of Phases:1:2:3
* on_off: Closed
'''
if "ElmCoup" in data.keys():
switches = data["ElmCoup"]
else:
switches = np.zeros((0, 20))
###############################################################################
# Post process the data
###############################################################################
# put the tables that connect to a terminal in a list
classes = [lines, transformers, loads, external, static_generators, shunts,
synchronous_machine, asynchronous_machine]
# construct the terminals dictionary
'''
$$StaCubic;ID(a:40);loc_name(a:40);fold_id(p);chr_name(a:20);obj_bus(i);obj_id(p)
********************************************************************************
* Cubicle
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* obj_bus: Bus Index
* obj_id: Connected with in Elm*
********************************************************************************
'''
terminals_dict = dict() # dictionary to store the terminals ID associated with an object ID
cub_obj_idx = cubicles['obj_id'].values
cub_term_idx = cubicles['fold_id'].values
# for i, elm_id in enumerate(cub_obj_idx):
# bus_idx = cub_term_idx[i]
# terminals_dict[elm_id] = bus_idx
ID_idx = 0
for cla in classes:
if cla.__len__() > 0:
for ID in cla['ID'].values:
idx = np.where(cubicles == ID)[0]
terminals_dict[ID] = cub_term_idx[idx]
###############################################################################
# Generate GridCal data
###############################################################################
# general values
baseMVA = 100
frequency = grid['frnom'][0]
w = 2.0 * math.pi * frequency
circuit = MultiCircuit()
####################################################################################################################
# Terminals (nodes)
####################################################################################################################
'''
********************************************************************************
* Terminal
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypBar
* iUsage: Usage:Busbar:Junction Node:Internal Node
* uknom: Nominal Voltage: Line-Line in kV
* chr_name: Characteristic Name
* outserv: Out of Service
********************************************************************************
'''
# print('Parsing terminals')
buses_dict = dict()
for i in range(len(buses)):
ID = buses['ID'][i]
x, y = pos_dict[ID]
buses_dict[ID] = i
bus_name = buses['loc_name'][i].decode(codification) # BUS_Name
vnom = buses['uknom'][i]
bus = Bus(name=bus_name, vnom=vnom, vmin=0.9, vmax=1.1, xpos=x, ypos=-y, active=True)
circuit.add_bus(bus)
####################################################################################################################
# External grids (slacks)
####################################################################################################################
'''
###############################################################################
********************************************************************************
* External Grid
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* outserv: Out of Service
* snss: Max. Values: Short-Circuit Power Sk''max in MVA
* rntxn: Max. Values: R/X Ratio (max.)
* z2tz1: Max. Values Impedance Ratio: Z2/Z1 max.
* snssmin: Min. Values: Short-Circuit Power Sk''min in MVA
* rntxnmin: Min. Values: R/X Ratio (min.)
* z2tz1min: Min. Values Impedance Ratio: Z2/Z1 min.
* chr_name: Characteristic Name
* bustp: Bus Type:PQ:PV:SL
* pgini: Operation Point: Active Power in MW
* qgini: Operation Point: Reactive Power in Mvar
* phiini: Operation Point: Angle in deg
* usetp: Operation Point: Voltage Setpoint in p.u.
********************************************************************************
'''
for i in range(len(external)):
ID = external['ID'][i]
if 'phiini' in external.columns.values:
va = external['phiini'][i]
vm = external['usetp'][i]
else:
va = 0
vm = 1
buses = terminals_dict[ID] # array with the ID of the connection Buses
bus1 = buses_dict[buses[0]] # index of the bus
bus_obj = circuit.buses[bus1]
# apply the slack values to the buses structure if the element is marked as slack
if external['bustp'].values[i] == b'SL':
# create the slack entry on buses
bus_obj.is_slack = True
# BUSES[bus1, bd.BUS_TYPE] = 3
# BUSES[bus1, bd.VA] = va
# BUSES[bus1, bd.VM] = vm
#
# # create the slack entry on generators (add the slack generator)
# gen_ = gen_line.copy()
# gen_[gd.GEN_BUS] = bus1
# gen_[gd.MBASE] = baseMVA
# gen_[gd.VG] = vm
# gen_[gd.GEN_STATUS] = 1
# gen_[gd.PG] += external['pgini'].values[i]
#
# GEN.append(gen_)
# GEN_NAMES.append(external['loc_name'][i])
elif external['bustp'].values[i] == b'PV':
if 'pgini' in external.columns.values:
p = external['pgini'].values[i]
else:
p = 0
# add a generator to the bus
gen = Generator(name=external['loc_name'][i].decode(codification),
active_power=p,
voltage_module=vm, Qmin=-9999, Qmax=9999, Snom=9999,
power_prof=None, vset_prof=None)
circuit.add_generator(bus_obj, gen)
# # mark the bus as pv
# BUSES[bus1, bd.BUS_TYPE] = 2
# BUSES[bus1, bd.VA] = 0.0
# BUSES[bus1, bd.VM] = vm
# # add the PV entry on generators
# gen_ = gen_line.copy()
# gen_[gd.GEN_BUS] = bus1
# gen_[gd.MBASE] = baseMVA
# gen_[gd.VG] = vm
# gen_[gd.GEN_STATUS] = 1
# gen_[gd.PG] += external['pgini'].values[i]
#
# GEN.append(gen_)
# GEN_NAMES.append(external['loc_name'][i])
elif external['bustp'].values[i] == b'PQ':
# Add a load to the bus
load = Load(name=external['loc_name'][i].decode(codification),
P=external['pgini'].values[i],
Q=external['qgini'].values[i])
circuit.add_load(bus_obj, load)
# BUSES[bus1, bd.BUS_TYPE] = 1
# BUSES[bus1, bd.VA] = va
# BUSES[bus1, bd.VM] = vm
# BUSES[bus1, bd.PD] += external['pgini'].values[i]
# BUSES[bus1, bd.QD] += external['qgini'].values[i]
####################################################################################################################
# Lines (branches)
####################################################################################################################
# print('Parsing lines')
if lines_types.__len__() > 0:
lines_ID = lines['ID'].values
lines_type_id = lines['typ_id'].values
line_types_ID = lines_types['ID'].values
lines_lenght = lines['dline'].values
if 'outserv' in lines.keys():
lines_enables = lines['outserv']
else:
lines_enables = np.ones(len(lines_ID))
lines_R = lines_types['rline'].values
lines_L = lines_types['xline'].values
lines_C = lines_types['cline'].values
lines_rate = lines_types['sline'].values
lines_voltage = lines_types['uline'].values
for i in range(len(lines)):
# line_ = branch_line.copy()
ID = lines_ID[i]
ID_Type = lines_type_id[i]
type_idx = np.where(line_types_ID == ID_Type)[0][0]
buses = terminals_dict[ID] # array with the ID of the connection Buses
bus1 = buses_dict[buses[0]]
bus2 = buses_dict[buses[1]]
bus_from = circuit.buses[bus1]
bus_to = circuit.buses[bus2]
status = lines_enables[i]
# impedances
lenght = np.double(lines_lenght[i])
R = np.double(lines_R[type_idx]) * lenght # Ohm
L = np.double(lines_L[type_idx]) * lenght # Ohm
C = np.double(lines_C[type_idx]) * lenght * w * 1e-6 # S (siemens)
# pass impedance to per unit
vbase = np.double(lines_voltage[type_idx]) # kV
zbase = vbase**2 / baseMVA # Ohm
ybase = 1.0 / zbase # S
r = R / zbase # pu
l = L / zbase # pu
b = C / ybase # pu
# rated power
Irated = np.double(lines_rate[type_idx]) # kA
Smax = Irated * vbase # MVA
line = Branch(bus_from=bus_from, bus_to=bus_to,
name=lines['loc_name'][i].decode(codification),
r=r,
x=l,
g=1e-20,
b=b,
rate=Smax,
tap=1,
shift_angle=0,
active=status, mttf=0, mttr=0)
circuit.add_branch(line)
# # put all in the correct column
# line_[brd.F_BUS] = bus1
# line_[brd.T_BUS] = bus2
# line_[brd.BR_R] = r
# line_[brd.BR_X] = l
# line_[brd.BR_B] = c
# line_[brd.RATE_A] = Smax
# line_[brd.BR_STATUS] = status
# BRANCHES.append(line_)
#
# name_ = lines['loc_name'][i] # line_Name
# BRANCH_NAMES.append(name_)
#
# # add edge to graph
# g.add_edge(bus1, bus2)
else:
warn('Line types are empty')
####################################################################################################################
# Transformers (Branches)
####################################################################################################################
# print('Parsing transformers')
'''
********************************************************************************
* 2-Winding Transformer
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypTr2
* outserv: Out of Service
* nntap: Tap Changer 1: Tap Position
* sernum: Serial Number
* constr: Year of Construction
* chr_name: Characteristic Name
********************************************************************************
'''
if len(transformers_types) > 0:
'''
********************************************************************************
* 2-Winding Transformer Type
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* strn: Rated Power in MVA
* frnom: Nominal Frequency in Hz
* utrn_h: Rated Voltage: HV-Side in kV
* utrn_l: Rated Voltage: LV-Side in kV
* uktr: Positive Sequence Impedance: Short-Circuit Voltage uk in %
* pcutr: Positive Sequence Impedance: Copper Losses in kW
* uk0tr: Zero Sequence Impedance: Short-Circuit Voltage uk0 in %
* ur0tr: Zero Sequence Impedance: SHC-Voltage (Re(uk0)) uk0r in %
* tr2cn_h: Vector Group: HV-Side:Y :YN:Z :ZN:D
* tr2cn_l: Vector Group: LV-Side:Y :YN:Z :ZN:D
* nt2ag: Vector Group: Phase Shift in *30deg
* curmg: Magnetizing Impedance: No Load Current in %
* pfe: Magnetizing Impedance: No Load Losses in kW
* zx0hl_n: Zero Sequence Magnetizing Impedance: Mag. Impedance/uk0
* tap_side: Tap Changer 1: at Side:HV:LV
* dutap: Tap Changer 1: Additional Voltage per Tap in %
* phitr: Tap Changer 1: Phase of du in deg
* nntap0: Tap Changer 1: Neutral Position
* ntpmn: Tap Changer 1: Minimum Position
* ntpmx: Tap Changer 1: Maximum Position
* manuf: Manufacturer
* chr_name: Characteristic Name
********************************************************************************
'''
type_ID = transformers_types['ID'].values
HV_nominal_voltage = transformers_types['utrn_h'].values
LV_nominal_voltage = transformers_types['utrn_l'].values
Nominal_power = transformers_types['strn'].values
Copper_losses = transformers_types['pcutr'].values
Iron_losses = transformers_types['pfe'].values
No_load_current = transformers_types['curmg'].values
Short_circuit_voltage = transformers_types['uktr'].values
# GR_hv1 = transformers_types['ID']
# GX_hv1 = transformers_types['ID']
for i in range(len(transformers)):
# line_ = branch_line.copy()
ID = transformers['ID'][i]
ID_Type = transformers['typ_id'][i]
if ID_Type in type_ID:
type_idx = np.where(type_ID == ID_Type)[0][0]
buses = terminals_dict[ID] # array with the ID of the connection Buses
bus1 = buses_dict[buses[0]]
bus2 = buses_dict[buses[1]]
bus_from = circuit.buses[bus1]
bus_to = circuit.buses[bus2]
Smax = Nominal_power[type_idx]
# Uhv, Ulv, Sn, Pcu, Pfe, I0, Usc
tpe = TransformerType(hv_nominal_voltage=HV_nominal_voltage[type_idx],
lv_nominal_voltage=LV_nominal_voltage[type_idx],
nominal_power=Smax,
copper_losses=Copper_losses[type_idx],
iron_losses=Iron_losses[type_idx],
no_load_current=No_load_current[type_idx],
short_circuit_voltage=Short_circuit_voltage[type_idx],
gr_hv1=0.5,
gx_hv1=0.5)
Zs, Zsh = tpe.get_impedances()
if Zsh != 0:
Ysh = 1.0 / Zsh
else:
Ysh = 0j
status = 1 - transformers['outserv'][i]
trafo = Branch(bus_from=bus_from,
bus_to=bus_to,
name=transformers['loc_name'][i].decode(codification),
r=Zs.real,
x=Zs.imag,
g=Ysh.real,
b=Ysh.imag,
rate=Smax,
tap=1.0,
shift_angle=0.0,
active=status,
mttf=0,
mttr=0,
branch_type=BranchType.Transformer)
circuit.add_branch(trafo)
else:
warn('Transformer type not found!')
else:
warn('Transformer types are empty')
####################################################################################################################
# Loads (nodes)
####################################################################################################################
'''
********************************************************************************
* General Load
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypLod,TypLodind
* chr_name: Characteristic Name
* plini: Operating Point: Active Power in MW
* qlini: Operating Point: Reactive Power in Mvar
* scale0: Operating Point: Scaling Factor
********************************************************************************
'''
# print('Parsing Loads')
if len(loads) > 0:
loads_ID = loads['ID']
loads_P = loads['plini']
loads_Q = loads['qlini']
scale = loads['scale0']
for i in range(len(loads)):
ID = loads_ID[i]
bus_idx = buses_dict[(terminals_dict[ID][0])]
bus_obj = circuit.buses[bus_idx]
p = loads_P[i] * scale[i] # in MW
q = loads_Q[i] * scale[i] # in MVA
load = Load(name=loads['loc_name'][i].decode(codification),
P=p,
Q=q)
circuit.add_load(bus_obj, load)
# BUSES[bus_idx, 2] += p
# BUSES[bus_idx, 3] += q
else:
warn('There are no loads')
####################################################################################################################
# Shunts
####################################################################################################################
'''
********************************************************************************
* Shunt/Filter
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* chr_name: Characteristic Name
* shtype: Shunt Type
* ushnm: Nominal Voltage in kV
* qcapn: Design Parameter (per Step): Rated Reactive Power, C in Mvar
* ncapx: Controller: Max. No. of Steps
* ncapa: Controller: Act.No. of Step
* outserv: Out of Service
********************************************************************************
'''
for i in range(len(shunts)):
ID = shunts['ID'][i]
buses = terminals_dict[ID] # array with the ID of the connection Buses
bus1 = buses_dict[buses[0]]
bus_obj = circuit.buses[bus1]
name = shunts['loc_name'][i].decode(codification)
if 'qcapn' in shunts.columns.values:
b = shunts['ushnm'][i] / shunts['qcapn'][i]
elif 'qtotn' in shunts.columns.values:
b = shunts['ushnm'][i] / shunts['qtotn'][i]
else:
b = 1e-20
shunt = Shunt(name=name, B=b)
circuit.add_shunt(bus_obj, shunt)
####################################################################################################################
# Static generators (Gen)
####################################################################################################################
'''
********************************************************************************
* Static Generator
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* bus1: Terminal in StaCubic
* outserv: Out of Service
* sgn: Ratings: Nominal Apparent Power in MVA
* cosn: Ratings: Power Factor
* ngnum: Number of: parallel Machines
* pgini: Dispatch: Active Power in MW
* qgini: Dispatch: Reactive Power in Mvar
* av_mode: Local Controller
* ip_ctrl: Reference Machine
********************************************************************************
'''
for i in range(len(static_generators)):
ID = static_generators['ID'][i]
buses = terminals_dict[ID] # array with the ID of the connection Buses
bus1 = buses_dict[buses[0]]
bus_obj = circuit.buses[bus1]
mode = static_generators['av_mode'][i]
num_machines = static_generators['ngnum'][i]
gen = StaticGenerator(name=static_generators['loc_name'][i].decode(codification),
P=static_generators['pgini'][i] * num_machines,
Q=static_generators['qgini'][i] * num_machines)
circuit.add_static_generator(bus_obj, gen)
####################################################################################################################
# Synchronous Machine (Gen)
####################################################################################################################
'''
********************************************************************************
* Synchronous Machine
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* typ_id: Type in TypSym
* ngnum: Number of: parallel Machines
* i_mot: Generator/Motor
* chr_name: Characteristic Name
* outserv: Out of Service
* pgini: Dispatch: Active Power in MW
* qgini: Dispatch: Reactive Power in Mvar
* usetp: Dispatch: Voltage in p.u.
* iv_mode: Mode of Local Voltage Controller
* q_min: Reactive Power Operational Limits: Min. in p.u.
* q_max: Reactive Power Operational Limits: Max. in p.u.
********************************************************************************
'''
for i in range(len(synchronous_machine)):
ID = synchronous_machine['ID'][i]
buses = terminals_dict[ID] # array with the ID of the connection Buses
bus1 = buses_dict[buses[0]]
bus_obj = circuit.buses[bus1]
num_machines = synchronous_machine['ngnum'][i]
# Get the type element
'''
********************************************************************************
* Synchronous Machine Type
*
* ID: Unique identifier for DGS file
* loc_name: Name
* fold_id: In Folder
* sgn: Nominal Apparent Power in MVA
* ugn: Nominal Voltage in kV
* cosn: Power Factor
* xd: Synchronous Reactances: xd in p.u.
* xq: Synchronous Reactances: xq in p.u.
* xdsss: Subtransient Reactance: saturated value xd''sat in p.u.
* rstr: Stator Resistance: rstr in p.u.
* xdsat: For single fed short-circuit: Reciprocal of short-circuit ratio (xdsat) in p.u.
* satur: For single fed short-circuit: Machine Type IEC909/IEC60909
********************************************************************************
'''
typ = synchronous_machine_type[synchronous_machine_type.ID == synchronous_machine['typ_id'][i]]
snom = typ['sgn'].values[0]
vnom = synchronous_machine['usetp'][i]
name = synchronous_machine['loc_name'][i].decode(codification)
gen = Generator(name=name,
active_power=synchronous_machine['pgini'][i] * num_machines,
voltage_module=vnom,
Qmin=synchronous_machine['q_min'][i] * num_machines * snom,
Qmax=synchronous_machine['q_max'][i] * num_machines * snom,
Snom=snom,
power_prof=None,
vset_prof=None)
circuit.add_generator(bus_obj, gen)
# if synchronous_machine['pgini'][i] != 0:
# # gen = StaticGenerator(name=name, power=complex(0, synchronous_machine['pgini'][i]))
# gen = Generator(name=name, active_power=synchronous_machine['pgini'][i])
# circuit.add_static_generator(bus_obj, gen)
return circuit
def test_gridcal_regulator():
"""
GridCal test for the new implementation of transformer voltage regulators.
"""
test_name = "test_gridcal_regulator"
grid = MultiCircuit(name=test_name)
grid.Sbase = 100.0 # MVA
grid.time_profile = None
grid.logger = Logger()
# Create buses
POI = Bus(
name="POI",
vnom=100, # kV
is_slack=True)
grid.add_bus(POI)
B_C3 = Bus(name="B_C3", vnom=10) # kV
grid.add_bus(B_C3)
B_MV_M32 = Bus(name="B_MV_M32", vnom=10) # kV
grid.add_bus(B_MV_M32)
B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) # kV
grid.add_bus(B_LV_M32)
# Create voltage controlled generators (or slack, a.k.a. swing)
UT = Generator(name="Utility")
UT.bus = POI
grid.add_generator(POI, UT)
# Create static generators (with fixed power factor)
M32 = StaticGenerator(name="M32", P=4.2, Q=0.0) # MVA (complex)
M32.bus = B_LV_M32
grid.add_static_generator(B_LV_M32, M32)
# Create transformer types
s = 100 # MVA
z = 8 # %
xr = 40
SS = TransformerType(
name="SS",
hv_nominal_voltage=100, # kV
lv_nominal_voltage=10, # kV
nominal_power=s, # MVA
copper_losses=complex_impedance(z, xr).real * s * 1000.0 /
grid.Sbase, # kW
iron_losses=125, # kW
no_load_current=0.5, # %
short_circuit_voltage=z) # %
grid.add_transformer_type(SS)
s = 5 # MVA
z = 6 # %
xr = 20
PM = TransformerType(
name="PM",
hv_nominal_voltage=10, # kV
lv_nominal_voltage=0.6, # kV
nominal_power=s, # MVA
copper_losses=complex_impedance(z, xr).real * s * 1000.0 /
grid.Sbase, # kW
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z) # %
grid.add_transformer_type(PM)
# Create branches
X_C3 = Branch(bus_from=POI,
bus_to=B_C3,
name="X_C3",
branch_type=BranchType.Transformer,
template=SS,
bus_to_regulated=True,
vset=1.05)
X_C3.tap_changer = TapChanger(taps_up=16,
taps_down=16,
max_reg=1.1,
min_reg=0.9)
X_C3.tap_changer.set_tap(X_C3.tap_module)
grid.add_branch(X_C3)
C_M32 = Branch(bus_from=B_C3,
bus_to=B_MV_M32,
name="C_M32",
r=7.84,
x=1.74)
grid.add_branch(C_M32)
X_M32 = Branch(bus_from=B_MV_M32,
bus_to=B_LV_M32,
name="X_M32",
branch_type=BranchType.Transformer,
template=PM)
grid.add_branch(X_M32)
# Apply templates (device types)
grid.apply_all_branch_types()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
options = PowerFlowOptions(SolverType.NR,
verbose=True,
initialize_with_existing_solution=True,
multi_core=True,
control_q=ReactivePowerControlMode.Direct,
control_taps=TapsControlMode.Direct,
tolerance=1e-6,
max_iter=99)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
approx_volt = [round(100 * abs(v), 1) for v in power_flow.results.voltage]
solution = [100.0, 105.2, 130.0, 130.1] # Expected solution from GridCal
print()
print(f"Test: {test_name}")
print(f"Results: {approx_volt}")
print(f"Solution: {solution}")
print()
print("Generators:")
for g in grid.get_generators():
print(f" - Generator {g}: q_min={g.Qmin}pu, q_max={g.Qmax}pu")
print()
print("Branches:")
branches = grid.get_branches()
for b in grid.transformers2w:
print(
f" - {b}: R={round(b.R, 4)}pu, X={round(b.X, 4)}pu, X/R={round(b.X/b.R, 1)}, vset={b.vset}"
)
print()
print("Transformer types:")
for t in grid.transformer_types:
print(
f" - {t}: Copper losses={int(t.Pcu)}kW, Iron losses={int(t.Pfe)}kW, SC voltage={t.Vsc}%"
)
print()
print("Losses:")
for i in range(len(branches)):
print(
f" - {branches[i]}: losses={round(power_flow.results.losses[i], 3)} MVA"
)
print()
tr_vset = [tr.vset for tr in grid.transformers2w]
print(f"Voltage settings: {tr_vset}")
equal = np.isclose(approx_volt, solution, atol=1e-3).all()
assert equal
def load_iPA(file_name):
circuit = MultiCircuit()
with open(file_name) as json_file:
data = json.load(json_file)
# elements dictionaries
xfrm_dict = {entry['IdEnRed']: entry for entry in data['Transformadores']}
# nodes_dict = {entry['id']: entry for entry in data['Nudos']}
nodes_dict = dict()
buses_dict = dict()
for entry in data['Nudos']:
nodes_dict[entry['id']] = entry
bus = Bus(name=str(entry['id']))
buses_dict[entry['id']] = bus
if entry['id'] > 0: # omit the node 0 because it is the "earth node"...
circuit.add_bus(bus)
gen_dict = {entry['IdEnRed']: entry for entry in data['Generadores']}
load_dict = {entry['IdEnRed']: entry for entry in data['Consumos']}
sw_dict = {entry['IdEnRed']: entry for entry in data['Interruptores']}
# main grid
vector_red = data['Red']
'''
{'id': 0,
'Tipo': 1,
'E': 0,
'EFase': 0,
'Tomas': 0,
'R1': 1e-05,
'X1': 1e-05,
'R0': 1e-05,
'X0': 1e-05,
'RN': 1e-05,
'XN': 1e-05,
'P': 0,
'Q': 0,
'Nudo1': 2410,
'Nudo2': 2403,
'Carga_Max': -1,
'ClassID': 1090,
'ClassMEMBER': 98076366,
'Conf': 'abc',
'LineaMT': '2030:98075347',
'Unom': 15.0}
'''
for entry in vector_red:
# pick the general attributes
identifier = entry['id']
tpe = entry['Tipo']
n1_id = entry['Nudo1']
n2_id = entry['Nudo2']
# get the Bus objects associated to the bus indices
if n1_id in buses_dict.keys():
bus1 = buses_dict[n1_id]
if n2_id in buses_dict.keys():
bus2 = buses_dict[n2_id]
if tpe == 0: # Fuente de Tensión(elemento Ptheta)
# pick the bus that is not the earth bus...
if n1_id == 0:
bus = bus2
else:
bus = bus1
bus.is_slack = True
elm = Generator(name='Slack')
circuit.add_generator(bus, elm)
elif tpe == 1: # Elemento impedancia(lineas)
V = entry['Unom']
Zbase = V * V / circuit.Sbase
if identifier in load_dict.keys():
# load!!!
print('Load found in lines: WTF?')
else:
# line!!!
r = entry['R1'] / Zbase
x = entry['X1'] / Zbase
if r > 1e-5:
branch_type = BranchType.Line
else:
# mark as "generic branch" the branches with very low resistance
branch_type = BranchType.Branch
elm = Branch(bus_from=bus1,
bus_to=bus2,
name=str(identifier),
r=r,
x=x,
branch_type=branch_type)
circuit.add_branch(elm)
elif tpe == 2: # Elemento PQ
# pick the bus that is not the earth bus...
if n1_id == 0:
bus = bus2
else:
bus = bus1
p = entry['P'] # power in MW
q = entry['Q']
elm = Load(name=str(identifier), P=p * 1e-3, Q=q * 1e-3)
circuit.add_load(bus, elm)
elif tpe == 3: # Elemento PV
pass
elif tpe == 4: # Reg de tensión
V = entry['Unom']
Zbase = V * V / circuit.Sbase
r = entry['R1'] / Zbase
x = entry['X1'] / Zbase
elm = Branch(bus_from=bus1,
bus_to=bus2,
name=str(identifier),
r=r,
x=x,
branch_type=BranchType.Transformer)
circuit.add_branch(elm)
elif tpe == 5: # Transformador
V = entry['Unom']
Zbase = V * V / circuit.Sbase
r = entry['R1'] / Zbase
x = entry['X1'] / Zbase
elm = Branch(bus_from=bus1,
bus_to=bus2,
name=str(identifier),
r=r,
x=x,
branch_type=BranchType.Transformer)
circuit.add_branch(elm)
# return the circuit
return circuit
def test_corr_line_losses():
test_name = "test_corr_line_losses"
grid = MultiCircuit(name=test_name)
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = list()
# Create buses
Bus0 = Bus(name="Bus0", vnom=10, is_slack=True)
bus_1 = Bus(name="bus_1", vnom=10)
grid.add_bus(Bus0)
grid.add_bus(bus_1)
# Create load
grid.add_load(bus_1, Load(name="Load0", P=1.0, Q=0.4))
# Create slack bus
grid.add_generator(Bus0, Generator(name="Utility"))
# Create cable
cable = Branch(bus_from=Bus0,
bus_to=bus_1,
name="Cable0",
r=0.784,
x=0.174,
temp_base=20, # °C
temp_oper=90, # °C
alpha=0.00323) # Copper
grid.add_branch(cable)
options = PowerFlowOptions(verbose=True,
apply_temperature_correction=True)
power_flow = PowerFlow(grid, options)
power_flow.run()
# Check solution
approx_losses = round(power_flow.results.losses[0], 3)
solution = complex(0.011, 0.002) # Expected solution from GridCal
# Tested on ETAP 16.1.0
print("\n=================================================================")
print(f"Test: {test_name}")
print("=================================================================\n")
print(f"Results: {approx_losses}")
print(f"Solution: {solution}")
print()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 2)}")
print()
print("Voltages:")
for i in range(len(grid.buses)):
print(f" - {grid.buses[i]}: voltage={round(power_flow.results.voltage[i], 3)} pu")
print()
print("Losses:")
for i in range(len(grid.branches)):
print(f" - {grid.branches[i]}: losses={round(power_flow.results.losses[i], 3)} MVA")
print()
print("Loadings (power):")
for i in range(len(grid.branches)):
print(f" - {grid.branches[i]}: loading={round(power_flow.results.Sbranch[i], 3)} MVA")
print()
print("Loadings (current):")
for i in range(len(grid.branches)):
print(f" - {grid.branches[i]}: loading={round(power_flow.results.Ibranch[i], 3)} pu")
print()
assert approx_losses == solution
def load_dpx(file_name, contraction_factor=1000) -> MultiCircuit:
"""
Read DPX file
:param file_name: file name
:param contraction_factor: contraction factor
:return: MultiCircuit
"""
circuit = MultiCircuit()
Sbase = 100
circuit.Sbase = Sbase
SQRT3 = np.sqrt(3)
# read the raw data into a structured dictionary
print('Reading file...')
structures_dict, logger = read_dpx_data(file_name=file_name)
# format the read data
print('Packing data...')
data_structures, logger = repack(data_structures=structures_dict,
logger=logger)
buses_id_dict = dict()
# create nodes
for tpe in data_structures['Nodes']:
# Airline support post
# __headers__['Nodes']['APOIO'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST']
# __headers__['Nodes']['ARM'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'YEAR']
# __headers__['Nodes']['CX'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST']
# __headers__['Nodes']['CXN'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST']
# __headers__['Nodes']['LOAD'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'VMIN', 'VMAX', 'NCMPLAN'] # fill to fit...
if tpe in ['APOIO', 'ARM', 'CX', 'CXN', 'LOAD']:
df = data_structures['Nodes'][tpe]
for i in range(df.shape[0]):
name = 'B' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
Vnom = float(df['VBASE'].values[i])
x = float(df['GX'].values[i]) / contraction_factor
y = float(df['GY'].values[i]) / contraction_factor
id_ = df['ID'].values[i]
bus = Bus(name=name,
vnom=Vnom,
xpos=x,
ypos=y,
height=40,
width=60)
circuit.add_bus(bus)
buses_id_dict[id_] = bus
# Network Equivalent
# __headers__['Nodes']['EQUIV'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'VMIN', 'VMAX', 'ZONE',
# 'SEPNET', 'AUTOUP', 'P', 'Q', 'ELAST', 'SIMUL', 'HTYP', 'HARM5', 'HARM7',
# 'HARM11',
# 'HARM13', 'NOGRW', 'RS', 'XS', 'R1', 'X1', 'R2', 'X2', 'RH', 'XH', 'COM']
elif tpe == 'EQUIV':
df = data_structures['Nodes'][tpe]
for i in range(df.shape[0]):
name = 'B' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
Vnom = float(df['VBASE'].values[i])
x = float(df['GX'].values[i]) / contraction_factor
y = float(df['GY'].values[i]) / contraction_factor
id_ = df['ID'].values[i]
bus = Bus(name=name,
vnom=Vnom,
xpos=x,
ypos=y,
height=40,
width=60,
is_slack=True)
circuit.add_bus(bus)
buses_id_dict[id_] = bus
name = 'LD' + str(len(circuit.buses)) + '_' + str(
df['NAME'].values[i])
p = float(df['P'].values[i]) * Sbase
q = float(df['Q'].values[i]) * Sbase
load = Load(name=name, P=p, Q=q)
circuit.add_load(bus, load)
# Generator
# __headers__['Nodes']['GEN'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'MODEL', 'VMIN',
# 'VMAX',
# 'V', 'ENAB', 'P', 'Q', 'QMIN', 'QMAX', 'ELAST', 'HTYP', 'HARM5', 'HARM7',
# 'HARM11',
# 'HARM13', 'VNOM', 'RAT', 'TGEN', 'COST', 'YEAR']
elif tpe == 'GEN':
df = data_structures['Nodes'][tpe]
for i in range(df.shape[0]):
name = 'B' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
Vnom = float(df['VBASE'].values[i])
x = float(df['GX'].values[i]) / contraction_factor
y = float(df['GY'].values[i]) / contraction_factor
id_ = df['ID'].values[i]
bus = Bus(name=name,
vnom=Vnom,
xpos=x,
ypos=y,
height=40,
width=60)
circuit.add_bus(bus)
buses_id_dict[id_] = bus
mode = int(df['MODEL'].values[i])
if mode == 1:
name = 'GEN' + str(len(circuit.buses)) + '_' + str(
df['NAME'].values[i])
p = float(df['P'].values[i]) * Sbase
q = float(df['Q'].values[i]) * Sbase
v = float(df['V'].values[i]) # p.u.
gen = Generator(name=name,
active_power=p,
voltage_module=v)
circuit.add_generator(bus, gen)
else:
name = 'GENSTAT' + str(len(circuit.buses)) + '_' + str(
df['NAME'].values[i])
p = float(df['P'].values[i]) * Sbase
q = float(df['Q'].values[i]) * Sbase
gen = StaticGenerator(name=name, P=p, Q=q)
circuit.add_static_generator(bus, gen)
# Transformation station
# __headers__['Nodes']['PT'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'VMIN', 'VMAX',
# 'ZONE',
# 'ENAB', 'P', 'Q', 'ELAST', 'SIMUL', 'HTYP', 'HARM5', 'HARM7', 'HARM11', 'HARM13',
# 'NOGRW',
# 'EQEXIST', 'EQPOSS1', 'MCOST1', 'ICOST1', 'EQPOSS2', 'MCOST2', 'ICOST2',
# 'EQPOSS3', 'MCOST3',
# 'ICOST3', 'NCLI', 'EQTYPE', 'YEAR', 'COM', 'INFOCOM', 'ID_AUX']
elif tpe in ['PT', 'PTC']:
df = data_structures['Nodes'][tpe]
for i in range(df.shape[0]):
name = 'B' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
Vnom = float(df['VBASE'].values[i])
x = float(df['GX'].values[i]) / contraction_factor
y = float(df['GY'].values[i]) / contraction_factor
id_ = df['ID'].values[i]
bus = Bus(name=name,
vnom=Vnom,
xpos=x,
ypos=y,
height=40,
width=60)
name = 'LD' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
p = float(df['P'].values[i]) * Sbase
q = float(df['Q'].values[i]) * Sbase
load = Load(name=name, P=p, Q=q)
circuit.add_bus(bus)
circuit.add_load(bus, load)
buses_id_dict[id_] = bus
# Reference node
# __headers__['Nodes']['REF'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'VREF', 'RAT',
# 'COST', 'TGEN', 'YEAR']
elif tpe == 'REF':
df = data_structures['Nodes'][tpe]
for i in range(df.shape[0]):
name = 'B' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
Vnom = float(df['VBASE'].values[i])
x = float(df['GX'].values[i]) / contraction_factor
y = float(df['GY'].values[i]) / contraction_factor
id_ = df['ID'].values[i]
bus = Bus(name=name,
vnom=Vnom,
xpos=x,
ypos=y,
height=40,
width=60,
is_slack=True)
circuit.add_bus(bus)
buses_id_dict[id_] = bus
# Voltage Transformer
# __headers__['Nodes']['TT'] = ['CLASS', 'ID', 'NAME', 'VBASE', 'GX', 'GY', 'SX', 'SY', 'EXIST', 'VMIN', 'VMAX',
# 'DISABLE', 'HARM5', 'HARM7', 'HARM11', 'HARM13', 'EQEXIST', 'TAP', 'YEAR',
# 'ID_AUX']
elif tpe == 'TT':
df = data_structures['Nodes'][tpe]
for i in range(df.shape[0]):
name = 'B' + str(len(circuit.buses) + 1) + '_' + str(
df['NAME'].values[i])
Vnom = float(df['VBASE'].values[i])
x = float(df['GX'].values[i]) / contraction_factor
y = float(df['GY'].values[i]) / contraction_factor
id_ = df['ID'].values[i]
bus = Bus(name=name,
vnom=Vnom,
xpos=x,
ypos=y,
height=40,
width=60)
circuit.add_bus(bus)
buses_id_dict[id_] = bus
else:
logger.add_error('Not recognised under Nodes', tpe)
# create branches
for tpe in data_structures['Branches']:
# Condenser series or shunt
# __headers__['Branches']['CAP'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'EQ', 'YEAR']
if tpe in ['CAP', 'IND']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
# get equipment reference in the catalogue
eq_id = df['EQ'].values[i]
df_cat = data_structures['CatalogBranch'][tpe]
cat_elm = df_cat[df_cat['EQ'] == eq_id]
try:
x = float(cat_elm['REAC'].values[0]) * Sbase
except:
x = 1e-20
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
x=x,
branch_type=BranchType.Branch)
circuit.add_branch(br)
# Estimator
# __headers__['Branches']['ESTIM'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'INDEP', 'I', 'SIMULT']
if tpe in ['ESTIM']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
branch_type=BranchType.Branch)
circuit.add_branch(br)
# Breaker
# __headers__['Branches']['DISJ'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT',
# 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'YEAR', 'CONTROL']
# Fuse
# __headers__['Branches']['FUS'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT',
# 'TISOL','TRECONF', 'TREPAIR', 'EQ', 'YEAR']
# Switch
# __headers__['Branches']['INTR'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT',
# 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'YEAR', 'DRIVE', 'CONTROL']
# Disconnector
# __headers__['Branches']['SECC'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT',
# 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'YEAR', 'DRIVE', 'CONTROL']
if tpe in ['DISJ', 'FUS', 'INTR', 'SECC']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
state = bool(int(df['STAT'].values[i]))
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
active=state,
branch_type=BranchType.Switch)
circuit.add_branch(br)
# Lines, cables and bars
# fill until it fits or truncate the data
# __headers__['Branches']['LINE'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'COLOR', 'GEOLEN', 'LEN',
# 'STAT',
# 'PERM', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'RERAT', 'EQEXIST', 'NPOSS',
# 'CHOOSEQ', 'INSRTCOST', 'EQPOSS1', 'MATCOST1', 'EQPOSS2', 'MATCOST2',
# 'EQPOSS3',
# 'MATCOST3', 'NCOOG', 'GX1', 'GY1', 'GX2', 'GY2']
if tpe in ['LINE']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
length = float(df['LEN'].values[i])
# get equipment reference in the catalogue
eq_id = df['EQEXIST'].values[i]
df_cat = data_structures['CatalogBranch'][tpe]
cat_elm = df_cat[df_cat['EQ'] == eq_id]
try:
r = float(cat_elm['R'].values[0]) * length / 1000
except:
r = 1e-20
try:
x = float(cat_elm['X'].values[0]) * length / 1000
except:
x = 1e-20
try:
b = float(cat_elm['B'].values[0]) * length / 1000
except:
b = 1e-20
Imax = float(
cat_elm['RATTYP'].values[0]) / 1000.0 # pass from A to kA
Vnom = float(cat_elm['VNOM'].values[0]) # kV
Smax = Imax * Vnom * SQRT3 # MVA
# correct for zero values which are problematic
r = r if r > 0.0 else 1e-20
x = x if x > 0.0 else 1e-20
b = b if b > 0.0 else 1e-20
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
r=r,
x=x,
b=b,
rate=Smax,
length=length,
branch_type=BranchType.Line)
circuit.add_branch(br)
# Intensity Transformer
# __headers__['Branches']['TI'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'INDEP', 'I', 'SIMULT', 'EXIST', 'STAT',
# 'PERM', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'EQ', 'TAP1', 'TAP2', 'YEAR']
if tpe in ['TI']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
# get equipment reference in the catalogue
eq_id = df['EQ'].values[i]
df_cat = data_structures['CatalogBranch'][tpe]
cat_elm = df_cat[df_cat['EQ'] == eq_id]
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
branch_type=BranchType.Transformer)
circuit.add_branch(br)
# Self-transformer
# __headers__['Branches']['XFORM1'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'ID3', 'ID1N', 'ID2N', 'ID3N',
# 'EXIST',
# 'STAT', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'RERAT', 'CON1', 'RE1',
# 'XE1',
# 'CON2', 'RE2', 'XE2', 'CON3', 'RE3', 'XE3', 'LOSS', 'TPERM', 'SETVSEL',
# 'SETV',
# 'EQ', 'TAP1', 'TAP2', 'TAP3', 'YEAR', 'NUM']
if tpe in ['XFORM1', 'XFORM2']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
# get equipment reference in the catalogue
# eq_id = df['EQ'].values[i]
eq_id = df['XE3'].values[
i] # to correct the bad data formatting these file has...
df_cat = data_structures['CatalogBranch'][tpe]
cat_elm = df_cat[df_cat['EQ'] == eq_id]
if cat_elm.shape[0] > 0:
r1 = float(cat_elm['RD1'].values[0])
r2 = float(cat_elm['RD2'].values[0])
x1 = float(cat_elm['XD1'].values[0])
x2 = float(cat_elm['XD2'].values[0])
s1 = float(cat_elm['SNOMTYP1'].values[0]
) / 1000.0 # from kVA to MVA
s2 = float(cat_elm['SNOMTYP2'].values[0]
) / 1000.0 # from kVA to MVA
r = r1 + r2
x = x1 + x2
s = s1 + s2
r = r if r > 0.0 else 1e-20
x = x if x > 0.0 else 1e-20
s = s if s > 0.0 else 1e-20
else:
r = 1e-20
x = 1e-20
s = 1e-20
logger.add_error('Not found.', tpe + ':' + eq_id)
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
r=r,
x=x,
rate=s,
branch_type=BranchType.Transformer)
circuit.add_branch(br)
# 3-winding transformer
# __headers__['Branches']['XFORM3'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'ID3', 'ID1N', 'ID2N', 'ID3N',
# 'EXIST',
# 'STAT', 'FAILRT', 'TISOL', 'TRECONF', 'TREPAIR', 'RERAT', 'CON1', 'RE1',
# 'XE1',
# 'CON2', 'RE2', 'XE2', 'CON3', 'RE3', 'XE3', 'LOSS', 'TPERM', 'SETVSEL',
# 'SETV',
# 'EQ', 'TAP1', 'TAP2', 'TAP3', 'YEAR', 'NUM']
if tpe in ['XFORM3']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
id3 = df['ID3'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
b3 = buses_id_dict[id3]
# get equipment reference in the catalogue
eq_id = df['EQ'].values[i]
df_cat = data_structures['CatalogBranch'][tpe]
cat_elm = df_cat[df_cat['EQ'] == eq_id]
r1 = float(cat_elm['RD1'].values[0])
r2 = float(cat_elm['RD2'].values[0])
r3 = float(cat_elm['RD3'].values[0])
x1 = float(cat_elm['XD1'].values[0])
x2 = float(cat_elm['XD2'].values[0])
x3 = float(cat_elm['XD3'].values[0])
s1 = float(
cat_elm['SNOMTYP1'].values[0]) / 1000.0 # from kVA to MVA
s2 = float(
cat_elm['SNOMTYP2'].values[0]) / 1000.0 # from kVA to MVA
s3 = float(
cat_elm['SNOMTYP3'].values[0]) / 1000.0 # from kVA to MVA
r12 = r1 + r2
x12 = x1 + x2
s12 = s1 + s2
r13 = r1 + r3
x13 = x1 + x3
s13 = s1 + s3
r23 = r2 + r3
x23 = x2 + x3
s23 = s2 + s3
r12 = r12 if r12 > 0.0 else 1e-20
x12 = x12 if x12 > 0.0 else 1e-20
s12 = s12 if s12 > 0.0 else 1e-20
r13 = r13 if r13 > 0.0 else 1e-20
x13 = x13 if x13 > 0.0 else 1e-20
s13 = s13 if s13 > 0.0 else 1e-20
r23 = r23 if r23 > 0.0 else 1e-20
x23 = x23 if x23 > 0.0 else 1e-20
s23 = s23 if s23 > 0.0 else 1e-20
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
r=r12,
x=x12,
rate=s12,
branch_type=BranchType.Transformer)
circuit.add_branch(br)
br = Branch(bus_from=b1,
bus_to=b3,
name=name,
r=r13,
x=x13,
rate=s13,
branch_type=BranchType.Transformer)
circuit.add_branch(br)
br = Branch(bus_from=b2,
bus_to=b3,
name=name,
r=r23,
x=x23,
rate=s23,
branch_type=BranchType.Transformer)
circuit.add_branch(br)
# Neutral impedance
# __headers__['Branches']['ZN'] = ['CLASS', 'ID', 'NAME', 'ID1', 'ID2', 'EXIST', 'STAT', 'PERM', 'FAILRT',
# 'TISOL','TRECONF', 'TREPAIR', 'EQ', 'YEAR']
if tpe in ['ZN']:
df = data_structures['Branches'][tpe]
for i in range(df.shape[0]):
name = df['NAME'].values[i]
id1 = df['ID1'].values[i]
id2 = df['ID2'].values[i]
b1 = buses_id_dict[id1]
b2 = buses_id_dict[id2]
br = Branch(bus_from=b1,
bus_to=b2,
name=name,
branch_type=BranchType.Branch)
circuit.add_branch(br)
# return the circuit and the logs
return circuit, logger
obj2
) # call this again, but this time it is not a Branch object
else:
raise Exception('Unrecognized branch type ' +
obj.device_type.value)
# Draw schematic subset
self.grid_editor.add_elements_to_schematic(
buses=list(buses),
lines=lines,
dc_lines=dc_lines,
transformers2w=transformers2w,
hvdc_lines=hvdc_lines,
vsc_devices=vsc_converters,
upfc_devices=upfc_devices,
explode_factor=1.0,
prog_func=None,
text_func=print)
self.grid_editor.center_nodes()
if __name__ == "__main__":
app = QApplication(sys.argv)
circuit_ = MultiCircuit()
circuit_.add_bus(Bus('bus1'))
window = BusViewerGUI(circuit=circuit_, root_bus=circuit_.buses[0])
window.resize(1.61 * 700.0, 600.0) # golden ratio
window.show()
sys.exit(app.exec_())
def test_line_losses_1():
"""
Basic line losses test.
"""
test_name = "test_line_losses_1"
grid = MultiCircuit(name=test_name)
Sbase = 100 # MVA
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = Logger()
# Create buses
Bus0 = Bus(name="Bus0", vnom=25, is_slack=True)
Bus1 = Bus(name="Bus1", vnom=25)
grid.add_bus(Bus0)
grid.add_bus(Bus1)
# Create load
grid.add_load(Bus1, Load(name="Load0", P=1.0, Q=0.4))
# Create slack bus
grid.add_generator(Bus0, Generator(name="Utility"))
# Create cable (r and x should be in pu)
grid.add_branch(
Line(bus_from=Bus0, bus_to=Bus1, name="Cable1", r=0.01, x=0.05))
# Run non-linear load flow
options = PowerFlowOptions(verbose=True)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
# Check solution
approx_losses = round(1000 * power_flow.results.losses[0], 3)
solution = complex(0.116, 0.58) # Expected solution from GridCal
# Tested on ETAP 16.1.0 and pandapower
print(
"\n=================================================================")
print(f"Test: {test_name}")
print(
"=================================================================\n")
print(f"Results: {approx_losses}")
print(f"Solution: {solution}")
print()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
print("Branches:")
branches = grid.get_branches()
for b in branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 2)}")
print()
print("Voltages:")
for i in range(len(grid.buses)):
print(
f" - {grid.buses[i]}: voltage={round(power_flow.results.voltage[i], 3)} pu"
)
print()
print("Losses:")
for i in range(len(branches)):
print(
f" - {branches[i]}: losses={round(power_flow.results.losses[i], 3)} MVA"
)
print()
print("Loadings (power):")
for i in range(len(branches)):
print(
f" - {branches[i]}: loading={round(power_flow.results.Sf[i], 3)} MVA"
)
print()
print("Loadings (current):")
for i in range(len(branches)):
print(
f" - {branches[i]}: loading={round(power_flow.results.If[i], 3)} pu"
)
print()
assert approx_losses == solution
def interpret_data_v1(circuit: MultiCircuit, data) -> MultiCircuit:
"""
Pass the loaded table-like data to the structures
:param circuit:
:param data: Data dictionary
:return:
"""
circuit.clear()
# time profile
if 'master_time' in data.keys():
master_time_array = data['master_time']
else:
master_time_array = None
import GridCal.Engine.IO.matpower_bus_definitions as e
# Buses
table = data['bus']
buses_dict = dict()
n = len(table)
# load profiles
if 'Lprof' in data.keys():
Pprof = data['Lprof']
Qprof = data['LprofQ']
are_load_prfiles = True
print('There are load profiles')
else:
are_load_prfiles = False
if 'bus_names' in data.keys():
names = data['bus_names']
else:
names = ['bus ' + str(i) for i in range(n)]
# Buses
bus_idx_dict = dict()
for i in range(n):
# Create bus
bus = Bus(name=names[i],
vnom=table[i, e.BASE_KV],
vmax=table[i, e.VMAX],
vmin=table[i, e.VMIN])
# store the given bus index in relation to its real index in the table for later
bus_idx_dict[table[i, e.BUS_I]] = i
# determine if the bus is set as slack manually
tpe = table[i, e.BUS_TYPE]
if tpe == e.REF:
bus.is_slack = True
else:
bus.is_slack = False
# Add the load
if table[i, e.PD] != 0 or table[i, e.QD] != 0:
load = Load(P=table[i, e.PD], Q=table[i, e.QD])
load.bus = bus
bus.loads.append(load)
# Add the shunt
if table[i, e.GS] != 0 or table[i, e.BS] != 0:
shunt = Shunt(G=table[i, e.GS], B=table[i, e.BS])
shunt.bus = bus
bus.shunts.append(shunt)
# Add the bus to the circuit buses
circuit.add_bus(bus)
import GridCal.Engine.IO.matpower_gen_definitions as e
# Generators
table = data['gen']
n = len(table)
# load profiles
if 'Gprof' in data.keys():
Gprof = data['Gprof']
are_gen_prfiles = True
print('There are gen profiles')
else:
are_gen_prfiles = False
if 'gen_names' in data.keys():
names = data['gen_names']
else:
names = ['gen ' + str(i) for i in range(n)]
for i in range(len(table)):
bus_idx = bus_idx_dict[int(table[i, e.GEN_BUS])]
gen = Generator(name=names[i],
active_power=table[i, e.PG],
voltage_module=table[i, e.VG],
Qmax=table[i, e.QMAX],
Qmin=table[i, e.QMIN])
# Add the generator to the bus
gen.bus = circuit.buses[bus_idx]
circuit.buses[bus_idx].controlled_generators.append(gen)
import GridCal.Engine.IO.matpower_branch_definitions as e
# Branches
table = data['branch']
n = len(table)
if 'branch_names' in data.keys():
names = data['branch_names']
else:
names = ['branch ' + str(i) for i in range(n)]
for i in range(len(table)):
f = circuit.buses[bus_idx_dict[int(table[i, e.F_BUS])]]
t = circuit.buses[bus_idx_dict[int(table[i, e.T_BUS])]]
if f.Vnom != t.Vnom or table[i, e.TAP] != 1.0 or table[i, e.SHIFT] != 0.0:
branch = Transformer2W(bus_from=f,
bus_to=t,
name=names[i],
r=table[i, e.BR_R],
x=table[i, e.BR_X],
g=0,
b=table[i, e.BR_B],
rate=table[i, e.RATE_A],
tap=table[i, e.TAP],
shift_angle=table[i, e.SHIFT],
active=bool(table[i, e.BR_STATUS]))
circuit.add_transformer2w(branch)
else:
branch = Line(bus_from=f,
bus_to=t,
name=names[i],
r=table[i, e.BR_R],
x=table[i, e.BR_X],
b=table[i, e.BR_B],
rate=table[i, e.RATE_A],
active=bool(table[i, e.BR_STATUS]))
circuit.add_line(branch)
# add the profiles
if master_time_array is not None:
circuit.format_profiles(master_time_array)
print('Interpreted.')
return circuit
