def parse_matpower_file(filename, export=False) -> MultiCircuit:
"""
Args:
filename:
export:
Returns:
"""
# open the file as text
with open(filename, 'r') as myfile:
text = myfile.read().replace('\n', '')
# split the file into its case variables (the case variables always start with 'mpc.')
chunks = text.split('mpc.')
# declare circuit
circuit = MultiCircuit()
data = dict()
# further process the loaded text
for chunk in chunks:
vals = chunk.split('=')
key = vals[0].strip()
if key == "baseMVA":
v = find_between(chunk, '=', ';')
circuit.Sbase = float(v)
elif key == "bus":
if chunk.startswith("bus_name"):
v = txt2mat(find_between(chunk, '{', '}'),
line_splitter=';',
to_float=False)
v = np.ndarray.flatten(v)
data['bus_names'] = v
else:
data['bus'] = txt2mat(find_between(chunk, '[', ']'),
line_splitter=';')
elif key == "gencost":
data['gen_cost'] = txt2mat(find_between(chunk, '[', ']'),
line_splitter=';')
elif key == "gen":
data['gen'] = txt2mat(find_between(chunk, '[', ']'),
line_splitter=';')
elif key == "branch":
data['branch'] = txt2mat(find_between(chunk, '[', ']'),
line_splitter=';')
circuit = interpret_data_v1(circuit, data)
return circuit
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 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
def data_frames_to_circuit(data: Dict):
"""
Interpret data dictionary
:param data: dictionary of data frames
:return: MultiCircuit instance
"""
# create circuit
circuit = MultiCircuit()
if 'name' in data.keys():
circuit.name = data['name']
# set the base magnitudes
if 'baseMVA' in data.keys():
circuit.Sbase = data['baseMVA']
# Set comments
if 'Comments' in data.keys():
circuit.comments = data['Comments']
if 'ModelVersion' in data.keys():
circuit.model_version = int(data['ModelVersion'])
if 'UserName' in data.keys():
circuit.user_name = data['UserName']
# dictionary of objects to iterate
object_types = get_objects_dictionary()
circuit.logger = Logger()
# time profile -----------------------------------------------------------------------------------------------------
if 'time' in data.keys():
time_df = data['time']
circuit.time_profile = pd.to_datetime(time_df.values[:, 0], dayfirst=True)
else:
circuit.time_profile = None
# dictionary of dictionaries by element type
# elements_dict[DataType][element_name] = actual object
elements_dict = dict()
# ------------------------------------------------------------------------------------------------------------------
# for each element type...
for key, template_elm in object_types.items():
if key in data.keys():
# get the DataFrame
df = data[key]
# create the objects ...
devices = list()
devices_dict = dict()
if 'idtag' in df.columns.values:
for i in range(df.shape[0]):
elm = type(template_elm)()
idtag = df['idtag'].values[i]
# create the buses dictionary, this works because the bus is the first key in "object_types"
devices_dict[idtag] = elm
# add the device to the elements
devices.append(elm)
else:
for i in range(df.shape[0]):
elm = type(template_elm)()
idtag = df['name'].values[i]
# create the buses dictionary, this works because the bus is the first key in "object_types"
devices_dict[idtag] = elm
# add the device to the elements
devices.append(elm)
elements_dict[template_elm.device_type] = devices_dict
# fill in the objects
if df.shape[0] > 0:
# for each property ...
for prop, gc_prop in template_elm.editable_headers.items():
# if the object property exists in the data file, set all the object's property
if prop in df.columns.values:
# get the type converter
dtype = gc_prop.tpe
# for each object, set the property
for i in range(df.shape[0]):
# convert and assign the data
if dtype is None:
val = df[prop].values[i]
setattr(devices[i], prop, val)
elif dtype == DeviceType.BusDevice:
# check if the bus is in the dictionary...
if df[prop].values[i] in elements_dict[DeviceType.BusDevice].keys():
parent_bus = elements_dict[DeviceType.BusDevice][df[prop].values[i]]
setattr(devices[i], prop, parent_bus)
# add the device to the bus
if template_elm.device_type in [DeviceType.LoadDevice,
DeviceType.GeneratorDevice,
DeviceType.BatteryDevice,
DeviceType.StaticGeneratorDevice,
DeviceType.ShuntDevice,
DeviceType.ExternalGridDevice]:
parent_bus.add_device(devices[i])
else:
circuit.logger.append('Bus not found: ' + str(df[prop].values[i]))
elif dtype in [DeviceType.TransformerTypeDevice, # template types mostly
DeviceType.SequenceLineDevice,
DeviceType.TowerDevice]:
if df[prop].values[i] in elements_dict[dtype].keys():
# get the actual template and set it
val = elements_dict[dtype][df[prop].values[i]]
setattr(devices[i], prop, val)
else:
circuit.logger.append(dtype.value + ' type not found: ' + str(df[prop].values[i]))
else:
# regular types (int, str, float, etc...)
val = dtype(df[prop].values[i])
setattr(devices[i], prop, val)
# search the profiles in the data and assign them
if prop in template_elm.properties_with_profile.keys():
# get the profile property
prop_prof = template_elm.properties_with_profile[prop]
# build the profile property file-name to get it from the data
profile_name = key + '_' + prop_prof
if profile_name in data.keys():
# get the profile DataFrame
dfp = data[profile_name]
# for each object, set the profile
for i in range(dfp.shape[1]):
profile = dfp.values[:, i]
setattr(devices[i], prop_prof, profile.astype(dtype))
else:
circuit.logger.append(prop + ' profile was not found in the data')
else:
circuit.logger.append(prop + ' of object type ' + str(template_elm.device_type) +
' not found in the input data')
else:
# no objects of this type
pass
# ensure profiles existence
if circuit.time_profile is not None:
for i in range(df.shape[0]):
devices[i].ensure_profiles_exist(circuit.time_profile)
# add the objects to the circuit (buses, branches ot template types)
if template_elm.device_type == DeviceType.BusDevice:
circuit.buses = devices
elif template_elm.device_type == DeviceType.BranchDevice:
for d in devices:
circuit.add_branch(d) # each branch needs to be converted accordingly
elif template_elm.device_type == DeviceType.LineDevice:
circuit.lines = devices
elif template_elm.device_type == DeviceType.DCLineDevice:
circuit.dc_lines = devices
elif template_elm.device_type == DeviceType.Transformer2WDevice:
circuit.transformers2w = devices
elif template_elm.device_type == DeviceType.HVDCLineDevice:
circuit.hvdc_lines = devices
elif template_elm.device_type == DeviceType.VscDevice:
circuit.vsc_converters = devices
elif template_elm.device_type == DeviceType.TowerDevice:
circuit.overhead_line_types = devices
elif template_elm.device_type == DeviceType.TransformerTypeDevice:
circuit.transformer_types = devices
elif template_elm.device_type == DeviceType.UnderGroundLineDevice:
circuit.underground_cable_types = devices
elif template_elm.device_type == DeviceType.SequenceLineDevice:
circuit.sequence_line_types = devices
elif template_elm.device_type == DeviceType.WireDevice:
circuit.wire_types = devices
else:
circuit.logger.append('The data does not contain information about the objects of type ' + str(key))
# fill in wires into towers ----------------------------------------------------------------------------------------
if 'tower_wires' in data.keys():
df = data['tower_wires']
for i in range(df.shape[0]):
tower_name = df['tower_name'].values[i]
wire_name = df['wire_name'].values[i]
if (tower_name in elements_dict[DeviceType.TowerDevice].keys()) and \
(wire_name in elements_dict[DeviceType.WireDevice].keys()):
tower = elements_dict[DeviceType.TowerDevice][tower_name]
wire = elements_dict[DeviceType.WireDevice][wire_name]
xpos = df['xpos'].values[i]
ypos = df['ypos'].values[i]
phase = df['phase'].values[i]
w = WireInTower(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
tower.wires_in_tower.append(w)
# Other actions ----------------------------------------------------------------------------------------------------
circuit.logger += circuit.apply_all_branch_types()
return circuit
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 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 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_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 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_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 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 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 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 data_frames_to_circuit(data: Dict):
"""
Interpret data dictionary
:param data: dictionary of data frames
:return: MultiCircuit instance
"""
# create circuit
circuit = MultiCircuit()
if 'name' in data.keys():
circuit.name = str(data['name'])
if circuit.name == 'nan':
circuit.name = ''
# set the base magnitudes
if 'baseMVA' in data.keys():
circuit.Sbase = data['baseMVA']
# Set comments
if 'Comments' in data.keys():
circuit.comments = str(data['Comments'])
if circuit.comments == 'nan':
circuit.comments = ''
if 'ModelVersion' in data.keys():
circuit.model_version = int(data['ModelVersion'])
if 'UserName' in data.keys():
circuit.user_name = data['UserName']
# dictionary of objects to iterate
object_types = get_objects_dictionary()
circuit.logger = Logger()
# time profile -----------------------------------------------------------------------------------------------------
if 'time' in data.keys():
time_df = data['time']
circuit.time_profile = pd.to_datetime(time_df.values[:, 0], dayfirst=True)
else:
circuit.time_profile = None
# dictionary of dictionaries by element type
# elements_dict[DataType][element_name] = actual object
elements_dict = dict()
elements_dict_by_name = dict()
# ------------------------------------------------------------------------------------------------------------------
# for each element type...
for key, template_elm in object_types.items():
if key in data.keys():
# get the DataFrame
df = data[key]
# create the objects ...
devices = list()
devices_dict = dict()
if 'idtag' in df.columns.values:
for i in range(df.shape[0]):
elm = type(template_elm)()
idtag = df['idtag'].values[i]
# create the buses dictionary, this works because the bus is the first key in "object_types"
devices_dict[idtag] = elm
# add the device to the elements
devices.append(elm)
else:
for i in range(df.shape[0]):
elm = type(template_elm)()
idtag = df['name'].values[i]
# create the buses dictionary, this works because the bus is the first key in "object_types"
devices_dict[idtag] = elm
# add the device to the elements
devices.append(elm)
elements_dict[template_elm.device_type] = devices_dict
# fill in the objects
if df.shape[0] > 0:
# for each property ...
for object_property_name, gc_prop in template_elm.editable_headers.items():
# if the object property exists in the data file, set all the object's property
if object_property_name in df.columns.values:
# get the type converter
dtype = gc_prop.tpe
# for each object, set the property
for i in range(df.shape[0]):
# convert and assign the data
if dtype is None:
val = df[object_property_name].values[i]
setattr(devices[i], object_property_name, val)
elif dtype in [DeviceType.SubstationDevice,
DeviceType.AreaDevice,
DeviceType.ZoneDevice,
DeviceType.CountryDevice]:
"""
This piece is to assign the objects matching the Area, Substation, Zone and Country
The cases may be:
a) there is a matching id tag -> ok, assign it
b) the value is a string -> create the relevant object,
make sure it is not repeated by name
inset the object in its matching object dictionary
"""
# search for the Substation, Area, Zone or Country matching object and assign the object
# this is the stored string (either idtag or name...)
val = str(df[object_property_name].values[i])
if dtype not in elements_dict.keys():
elements_dict[dtype] = dict()
if dtype not in elements_dict_by_name.keys():
elements_dict_by_name[dtype] = dict()
if val in elements_dict[dtype].keys():
# the grouping exists as object, use it
grouping = elements_dict[dtype][val]
else:
# create the grouping
if val in elements_dict_by_name[dtype].keys():
grouping = elements_dict_by_name[dtype][val]
else:
grouping = type(object_types[dtype.value.lower()])(name=val)
elements_dict[dtype][grouping.idtag] = grouping
# store also by name
elements_dict_by_name[dtype][grouping.name] = grouping
# set the object
setattr(devices[i], object_property_name, grouping)
elif dtype == DeviceType.BusDevice:
# check if the bus is in the dictionary...
if df[object_property_name].values[i] in elements_dict[DeviceType.BusDevice].keys():
parent_bus: dev.Bus = elements_dict[DeviceType.BusDevice][df[object_property_name].values[i]]
setattr(devices[i], object_property_name, parent_bus)
# add the device to the bus
if template_elm.device_type in [DeviceType.LoadDevice,
DeviceType.GeneratorDevice,
DeviceType.BatteryDevice,
DeviceType.StaticGeneratorDevice,
DeviceType.ShuntDevice,
DeviceType.ExternalGridDevice]:
parent_bus.add_device(devices[i])
else:
circuit.logger.add_error('Bus not found', str(df[object_property_name].values[i]))
elif dtype in [DeviceType.TransformerTypeDevice, # template types mostly
DeviceType.SequenceLineDevice,
DeviceType.TowerDevice]:
if df[object_property_name].values[i] in elements_dict[dtype].keys():
# get the actual template and set it
val = elements_dict[dtype][df[object_property_name].values[i]]
setattr(devices[i], object_property_name, val)
else:
circuit.logger.add_error(dtype.value + ' type not found',
str(df[object_property_name].values[i]))
elif dtype == bool:
# regular types (int, str, float, etc...)
val = df[object_property_name].values[i]
if val == 'False':
setattr(devices[i], object_property_name, False)
elif val == 'True':
setattr(devices[i], object_property_name, True)
else:
setattr(devices[i], object_property_name, bool(val))
else:
# regular types (int, str, float, etc...)
val = dtype(df[object_property_name].values[i])
setattr(devices[i], object_property_name, val)
# search the profiles in the data and assign them
if object_property_name in template_elm.properties_with_profile.keys():
# get the profile property
prop_prof = template_elm.properties_with_profile[object_property_name]
# build the profile property file-name to get it from the data
profile_name = key + '_' + prop_prof
if profile_name in data.keys():
# get the profile DataFrame
dfp = data[profile_name]
# for each object, set the profile
for i in range(dfp.shape[1]):
profile = dfp.values[:, i]
setattr(devices[i], prop_prof, profile.astype(dtype))
else:
circuit.logger.add_error('Profile was not found in the data', object_property_name)
else:
circuit.logger.add_error(object_property_name + ' of object type ' + str(template_elm.device_type) +
' not found in the input data')
else:
# no objects of this type
pass
# ensure profiles existence
if circuit.time_profile is not None:
for i in range(df.shape[0]):
devices[i].ensure_profiles_exist(circuit.time_profile)
# add the objects to the circuit (buses, branches ot template types)
if template_elm.device_type == DeviceType.BusDevice:
circuit.buses = devices
# elif template_elm.device_type == DeviceType.SubstationDevice:
# circuit.substations = devices
#
# elif template_elm.device_type == DeviceType.AreaDevice:
# circuit.areas = devices
#
# elif template_elm.device_type == DeviceType.ZoneDevice:
# circuit.zones = devices
#
# elif template_elm.device_type == DeviceType.CountryDevice:
# circuit.countries = devices
elif template_elm.device_type == DeviceType.BranchDevice:
for d in devices:
circuit.add_branch(d) # each branch needs to be converted accordingly
elif template_elm.device_type == DeviceType.LineDevice:
circuit.lines = devices
elif template_elm.device_type == DeviceType.DCLineDevice:
circuit.dc_lines = devices
elif template_elm.device_type == DeviceType.Transformer2WDevice:
circuit.transformers2w = devices
elif template_elm.device_type == DeviceType.HVDCLineDevice:
circuit.hvdc_lines = devices
elif template_elm.device_type == DeviceType.UpfcDevice:
circuit.upfc_devices = devices
elif template_elm.device_type == DeviceType.VscDevice:
for dev in devices:
dev.correct_buses_connection()
circuit.vsc_devices = devices
elif template_elm.device_type == DeviceType.TowerDevice:
circuit.overhead_line_types = devices
elif template_elm.device_type == DeviceType.TransformerTypeDevice:
circuit.transformer_types = devices
elif template_elm.device_type == DeviceType.UnderGroundLineDevice:
circuit.underground_cable_types = devices
elif template_elm.device_type == DeviceType.SequenceLineDevice:
circuit.sequence_line_types = devices
elif template_elm.device_type == DeviceType.WireDevice:
circuit.wire_types = devices
else:
circuit.logger.add_error('The data does not contain information about the type', str(key))
# fill in wires into towers ----------------------------------------------------------------------------------------
if 'tower_wires' in data.keys():
df = data['tower_wires']
for i in range(df.shape[0]):
tower_name = df['tower_name'].values[i]
wire_name = df['wire_name'].values[i]
if (tower_name in elements_dict[DeviceType.TowerDevice].keys()) and \
(wire_name in elements_dict[DeviceType.WireDevice].keys()):
tower = elements_dict[DeviceType.TowerDevice][tower_name]
wire = elements_dict[DeviceType.WireDevice][wire_name]
xpos = df['xpos'].values[i]
ypos = df['ypos'].values[i]
phase = df['phase'].values[i]
w = dev.WireInTower(wire=wire, xpos=xpos, ypos=ypos, phase=phase)
tower.wires_in_tower.append(w)
# Other actions ----------------------------------------------------------------------------------------------------
circuit.logger += circuit.apply_all_branch_types()
# Add the groups ---------------------------------------------------------------------------------------------------
if DeviceType.SubstationDevice in elements_dict.keys():
circuit.substations = list(elements_dict[DeviceType.SubstationDevice].values())
if DeviceType.AreaDevice in elements_dict.keys():
circuit.areas = list(elements_dict[DeviceType.AreaDevice].values())
if DeviceType.ZoneDevice in elements_dict.keys():
circuit.zones = list(elements_dict[DeviceType.ZoneDevice].values())
if DeviceType.CountryDevice in elements_dict.keys():
circuit.countries = list(elements_dict[DeviceType.CountryDevice].values())
return circuit
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 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
