def test_demo_5_node(root_path=ROOT_PATH):
np.core.arrayprint.set_printoptions(precision=4)
grid = MultiCircuit()
# Add buses
bus1 = Bus('Bus 1', vnom=20)
grid.add_bus(bus1)
gen1 = Generator('Slack Generator', voltage_module=1.0)
grid.add_generator(bus1, gen1)
bus2 = Bus('Bus 2', vnom=20)
grid.add_bus(bus2)
grid.add_load(bus2, Load('load 2', P=40, Q=20))
bus3 = Bus('Bus 3', vnom=20)
grid.add_bus(bus3)
grid.add_load(bus3, Load('load 3', P=25, Q=15))
bus4 = Bus('Bus 4', vnom=20)
grid.add_bus(bus4)
grid.add_load(bus4, Load('load 4', P=40, Q=20))
bus5 = Bus('Bus 5', vnom=20)
grid.add_bus(bus5)
grid.add_load(bus5, Load('load 5', P=50, Q=20))
# add branches (Lines in this case)
grid.add_line(Line(bus1, bus2, 'line 1-2', r=0.05, x=0.11, b=0.02))
grid.add_line(Line(bus1, bus3, 'line 1-3', r=0.05, x=0.11, b=0.02))
grid.add_line(Line(bus1, bus5, 'line 1-5', r=0.03, x=0.08, b=0.02))
grid.add_line(Line(bus2, bus3, 'line 2-3', r=0.04, x=0.09, b=0.02))
grid.add_line(Line(bus2, bus5, 'line 2-5', r=0.04, x=0.09, b=0.02))
grid.add_line(Line(bus3, bus4, 'line 3-4', r=0.06, x=0.13, b=0.03))
grid.add_line(Line(bus4, bus5, 'line 4-5', r=0.04, x=0.09, b=0.02))
# grid.plot_graph()
print('\n\n', grid.name)
FileSave(grid, 'demo_5_node.json').save()
options = PowerFlowOptions(SolverType.NR, verbose=False)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print_power_flow_results(power_flow=power_flow)
v = np.array([1., 0.9553, 0.9548, 0.9334, 0.9534])
all_ok = np.isclose(np.abs(power_flow.results.voltage), v, atol=1e-3)
return all_ok
def test_demo_5_node(root_path):
np.core.arrayprint.set_printoptions(precision=4)
grid = MultiCircuit()
# Add buses
bus1 = Bus('Bus 1', vnom=20)
# bus1.is_slack = True
grid.add_bus(bus1)
gen1 = Generator('Slack Generator', voltage_module=1.0)
grid.add_generator(bus1, gen1)
bus2 = Bus('Bus 2', vnom=20)
grid.add_bus(bus2)
grid.add_load(bus2, Load('load 2', P=40, Q=20))
bus3 = Bus('Bus 3', vnom=20)
grid.add_bus(bus3)
grid.add_load(bus3, Load('load 3', P=25, Q=15))
bus4 = Bus('Bus 4', vnom=20)
grid.add_bus(bus4)
grid.add_load(bus4, Load('load 4', P=40, Q=20))
bus5 = Bus('Bus 5', vnom=20)
grid.add_bus(bus5)
grid.add_load(bus5, Load('load 5', P=50, Q=20))
# add branches (Lines in this case)
grid.add_branch(Branch(bus1, bus2, 'line 1-2', r=0.05, x=0.11, b=0.02))
grid.add_branch(Branch(bus1, bus3, 'line 1-3', r=0.05, x=0.11, b=0.02))
grid.add_branch(Branch(bus1, bus5, 'line 1-5', r=0.03, x=0.08, b=0.02))
grid.add_branch(Branch(bus2, bus3, 'line 2-3', r=0.04, x=0.09, b=0.02))
grid.add_branch(Branch(bus2, bus5, 'line 2-5', r=0.04, x=0.09, b=0.02))
grid.add_branch(Branch(bus3, bus4, 'line 3-4', r=0.06, x=0.13, b=0.03))
grid.add_branch(Branch(bus4, bus5, 'line 4-5', r=0.04, x=0.09, b=0.02))
# grid.plot_graph()
print('\n\n', grid.name)
options = PowerFlowOptions(SolverType.NR, verbose=False)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print_power_flow_results(power_flow=power_flow)
def 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_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 main():
####################################################################################################################
# Define the circuit
#
# A circuit contains all the grid information regardless of the islands formed or the amount of devices
####################################################################################################################
# create a circuit
grid = MultiCircuit(name='lynn 5 bus')
# let's create a master profile
st = datetime.datetime(2020, 1, 1)
dates = [st + datetime.timedelta(hours=i) for i in range(24)]
time_array = pd.to_datetime(dates)
x = np.linspace(-np.pi, np.pi, len(time_array))
y = np.abs(np.sin(x))
df_0 = pd.DataFrame(data=y, index=time_array) # complex values
# set the grid master time profile
grid.time_profile = df_0.index
####################################################################################################################
# Define the buses
####################################################################################################################
# I will define this bus with all the properties so you see
bus1 = Bus(name='Bus1',
vnom=10, # Nominal voltage in kV
vmin=0.9, # Bus minimum voltage in per unit
vmax=1.1, # Bus maximum voltage in per unit
xpos=0, # Bus x position in pixels
ypos=0, # Bus y position in pixels
height=0, # Bus height in pixels
width=0, # Bus width in pixels
active=True, # Is the bus active?
is_slack=False, # Is this bus a slack bus?
area='Defualt', # Area (for grouping purposes only)
zone='Default', # Zone (for grouping purposes only)
substation='Default' # Substation (for grouping purposes only)
)
# the rest of the buses are defined with the default parameters
bus2 = Bus(name='Bus2')
bus3 = Bus(name='Bus3')
bus4 = Bus(name='Bus4')
bus5 = Bus(name='Bus5')
# add the bus objects to the circuit
grid.add_bus(bus1)
grid.add_bus(bus2)
grid.add_bus(bus3)
grid.add_bus(bus4)
grid.add_bus(bus5)
####################################################################################################################
# Add the loads
####################################################################################################################
# In GridCal, the loads, generators ect are stored within each bus object:
# we'll define the first load completely
l2 = Load(name='Load',
G=0, B=0, # admittance of the ZIP model in MVA at the nominal voltage
Ir=0, Ii=0, # Current of the ZIP model in MVA at the nominal voltage
P=40, Q=20, # Power of the ZIP model in MVA
active=True, # Is active?
mttf=0.0, # Mean time to failure
mttr=0.0 # Mean time to recovery
)
grid.add_load(bus2, l2)
# Define the others with the default parameters
grid.add_load(bus3, Load(P=25, Q=15))
grid.add_load(bus4, Load(P=40, Q=20))
grid.add_load(bus5, Load(P=50, Q=20))
####################################################################################################################
# Add the generators
####################################################################################################################
g1 = Generator(name='gen',
active_power=0.0, # Active power in MW, since this generator is used to set the slack , is 0
voltage_module=1.0, # Voltage set point to control
Qmin=-9999, # minimum reactive power in MVAr
Qmax=9999, # Maximum reactive power in MVAr
Snom=9999, # Nominal power in MVA
power_prof=None, # power profile
vset_prof=None, # voltage set point profile
active=True # Is active?
)
grid.add_generator(bus1, g1)
####################################################################################################################
# Add the lines
####################################################################################################################
br1 = Branch(bus_from=bus1,
bus_to=bus2,
name='Line 1-2',
r=0.05, # resistance of the pi model in per unit
x=0.11, # reactance of the pi model in per unit
g=1e-20, # conductance of the pi model in per unit
b=0.02, # susceptance of the pi model in per unit
rate=50, # Rate in MVA
tap=1.0, # Tap value (value close to 1)
shift_angle=0, # Tap angle in radians
active=True, # is the branch active?
mttf=0, # Mean time to failure
mttr=0, # Mean time to recovery
branch_type=BranchType.Line, # Branch type tag
length=1, # Length in km (to be used with templates)
template=BranchTemplate() # Branch template (The default one is void)
)
grid.add_branch(br1)
grid.add_branch(Branch(bus1, bus3, name='Line 1-3', r=0.05, x=0.11, b=0.02, rate=50))
grid.add_branch(Branch(bus1, bus5, name='Line 1-5', r=0.03, x=0.08, b=0.02, rate=80))
grid.add_branch(Branch(bus2, bus3, name='Line 2-3', r=0.04, x=0.09, b=0.02, rate=3))
grid.add_branch(Branch(bus2, bus5, name='Line 2-5', r=0.04, x=0.09, b=0.02, rate=10))
grid.add_branch(Branch(bus3, bus4, name='Line 3-4', r=0.06, x=0.13, b=0.03, rate=30))
grid.add_branch(Branch(bus4, bus5, name='Line 4-5', r=0.04, x=0.09, b=0.02, rate=30))
FileSave(grid, 'lynn5node.gridcal').save()
####################################################################################################################
# Overwrite the default profiles with the custom ones
####################################################################################################################
for load in grid.get_loads():
load.P_prof = load.P * df_0.values[:, 0]
load.Q_prof = load.Q * df_0.values[:, 0]
for gen in grid.get_static_generators():
gen.P_prof = gen.Q * df_0.values[:, 0]
gen.Q_prof = gen.Q * df_0.values[:, 0]
for gen in grid.get_generators():
gen.P_prof = gen.P * df_0.values[:, 0]
####################################################################################################################
# Run a power flow simulation
####################################################################################################################
# We need to specify power flow options
pf_options = PowerFlowOptions(solver_type=SolverType.NR, # Base method to use
verbose=False, # Verbose option where available
tolerance=1e-6, # power error in p.u.
max_iter=25, # maximum iteration number
control_q=True # if to control the reactive power
)
# Declare and execute the power flow simulation
pf = PowerFlowDriver(grid, pf_options)
pf.run()
writer = pd.ExcelWriter('Results.xlsx')
# now, let's compose a nice DataFrame with the voltage results
headers = ['Vm (p.u.)', 'Va (Deg)', 'Vre', 'Vim']
Vm = np.abs(pf.results.voltage)
Va = np.angle(pf.results.voltage, deg=True)
Vre = pf.results.voltage.real
Vim = pf.results.voltage.imag
data = np.c_[Vm, Va, Vre, Vim]
v_df = pd.DataFrame(data=data, columns=headers, index=grid.bus_names)
# print('\n', v_df)
v_df.to_excel(writer, sheet_name='V')
# Let's do the same for the branch results
headers = ['Loading (%)', 'Current(p.u.)', 'Power (MVA)']
loading = np.abs(pf.results.loading) * 100
current = np.abs(pf.results.If)
power = np.abs(pf.results.Sf)
data = np.c_[loading, current, power]
br_df = pd.DataFrame(data=data, columns=headers, index=grid.branch_names)
br_df.to_excel(writer, sheet_name='Br')
# Finally the execution metrics
print('\nError:', pf.results.error)
print('Elapsed time (s):', pf.results.elapsed, '\n')
# print(tabulate(v_df, tablefmt="pipe", headers=v_df.columns.values))
# print()
# print(tabulate(br_df, tablefmt="pipe", headers=br_df.columns.values))
####################################################################################################################
# Run a time series power flow simulation
####################################################################################################################
ts = TimeSeries(grid=grid,
options=pf_options,
opf_time_series_results=None,
start_=0,
end_=None)
ts.run()
print()
print('-' * 200)
print('Time series')
print('-' * 200)
print('Voltage time series')
df_voltage = pd.DataFrame(data=np.abs(ts.results.voltage), columns=grid.bus_names, index=grid.time_profile)
df_voltage.to_excel(writer, sheet_name='Vts')
writer.close()
def 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_xfo_static_tap_3():
"""
Basic test with the main transformer's HV tap (X_C3) set at -2.5%
(0.975 pu), which raises the LV by the same amount (+2.5%).
"""
test_name = "test_xfo_static_tap_3"
grid = MultiCircuit(name=test_name)
grid.Sbase = Sbase
grid.time_profile = None
grid.logger = Logger()
# Create buses
POI = Bus(
name="POI",
vnom=100, # kV
is_slack=True)
grid.add_bus(POI)
B_C3 = Bus(name="B_C3", vnom=10) # kV
grid.add_bus(B_C3)
B_MV_M32 = Bus(name="B_MV_M32", vnom=10) # kV
grid.add_bus(B_MV_M32)
B_LV_M32 = Bus(name="B_LV_M32", vnom=0.6) # kV
grid.add_bus(B_LV_M32)
# Create voltage controlled generators (or slack, a.k.a. swing)
UT = Generator(name="Utility")
UT.bus = POI
grid.add_generator(POI, UT)
# Create static generators (with fixed power factor)
M32 = StaticGenerator(name="M32", P=4.2, Q=0.0) # MVA (complex)
M32.bus = B_LV_M32
grid.add_static_generator(B_LV_M32, M32)
# Create transformer types
s = 5 # MVA
z = 8 # %
xr = 40
SS = TransformerType(
name="SS",
hv_nominal_voltage=100, # kV
lv_nominal_voltage=10, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(SS)
s = 5 # MVA
z = 6 # %
xr = 20
PM = TransformerType(
name="PM",
hv_nominal_voltage=10, # kV
lv_nominal_voltage=0.6, # kV
nominal_power=s,
copper_losses=complex_impedance(z, xr).real * s * 1000 / Sbase,
iron_losses=6.25, # kW
no_load_current=0.5, # %
short_circuit_voltage=z)
grid.add_transformer_type(PM)
# Create branches
X_C3 = Branch(bus_from=POI,
bus_to=B_C3,
name="X_C3",
branch_type=BranchType.Transformer,
template=SS,
tap=0.975)
# update to a more precise tap changer
X_C3.apply_tap_changer(
TapChanger(taps_up=20, taps_down=20, max_reg=1.1, min_reg=0.9))
grid.add_branch(X_C3)
C_M32 = Branch(bus_from=B_C3,
bus_to=B_MV_M32,
name="C_M32",
r=0.784,
x=0.174)
grid.add_branch(C_M32)
X_M32 = Branch(bus_from=B_MV_M32,
bus_to=B_LV_M32,
name="X_M32",
branch_type=BranchType.Transformer,
template=PM)
grid.add_branch(X_M32)
# Apply templates (device types)
grid.apply_all_branch_types()
print("Buses:")
for i, b in enumerate(grid.buses):
print(f" - bus[{i}]: {b}")
print()
options = PowerFlowOptions(SolverType.NR,
verbose=True,
initialize_with_existing_solution=True,
multi_core=True,
control_q=ReactivePowerControlMode.Direct,
tolerance=1e-6,
max_iter=15)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print()
print(f"Test: {test_name}")
print()
print("Generators:")
for g in grid.get_generators():
print(f" - Generator {g}: q_min={g.Qmin} MVAR, q_max={g.Qmax} MVAR")
print()
print("Branches:")
for b in grid.branches:
print(f" - {b}:")
print(f" R = {round(b.R, 4)} pu")
print(f" X = {round(b.X, 4)} pu")
print(f" X/R = {round(b.X/b.R, 1)}")
print(f" G = {round(b.G, 4)} pu")
print(f" B = {round(b.B, 4)} pu")
print()
print("Transformer types:")
for t in grid.transformer_types:
print(f" - {t}: Copper losses={int(t.Pcu)}kW, "
f"Iron losses={int(t.Pfe)}kW, SC voltage={t.Vsc}%")
print()
print("Losses:")
for i in range(len(grid.branches)):
print(
f" - {grid.branches[i]}: losses={1000*round(power_flow.results.losses[i], 3)} kVA"
)
print()
equal = False
for i, branch in enumerate(grid.branches):
if branch.name == "X_C3":
equal = power_flow.results.tap_module[i] == branch.tap_module
if not equal:
grid.export_pf(f"{test_name}_results.xlsx", power_flow.results)
grid.save_excel(f"{test_name}_grid.xlsx")
assert equal
def 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 main():
####################################################################################################################
# Define the circuit
#
# A circuit contains all the grid information regardless of the islands formed or the amount of devices
####################################################################################################################
grid = MultiCircuit(name='lynn 5 bus')
####################################################################################################################
# Define the buses
####################################################################################################################
# I will define this bus with all the properties so you see
bus1 = Bus(name='Bus1',
vnom=10, # Nominal voltage in kV
vmin=0.9, # Bus minimum voltage in per unit
vmax=1.1, # Bus maximum voltage in per unit
xpos=0, # Bus x position in pixels
ypos=0, # Bus y position in pixels
height=0, # Bus height in pixels
width=0, # Bus width in pixels
active=True, # Is the bus active?
is_slack=False, # Is this bus a slack bus?
area='Defualt', # Area (for grouping purposes only)
zone='Default', # Zone (for grouping purposes only)
substation='Default' # Substation (for grouping purposes only)
)
# the rest of the buses are defined with the default parameters
bus2 = Bus(name='Bus2')
bus3 = Bus(name='Bus3')
bus4 = Bus(name='Bus4')
bus5 = Bus(name='Bus5')
# add the bus objects to the circuit
grid.add_bus(bus1)
grid.add_bus(bus2)
grid.add_bus(bus3)
grid.add_bus(bus4)
grid.add_bus(bus5)
####################################################################################################################
# Add the loads
####################################################################################################################
# In GridCal, the loads, generators ect are stored within each bus object:
# we'll define the first load completely
l2 = Load(name='Load',
G=0, # Impedance of the ZIP model in MVA at the nominal voltage
B=0,
Ir=0,
Ii=0, # Current of the ZIP model in MVA at the nominal voltage
P=40,
Q=20, # Power of the ZIP model in MVA
P_prof=None, # Impedance profile
Q_prof=None, # Current profile
Ir_prof=None, # Power profile
Ii_prof=None,
G_prof=None,
B_prof=None,
active=True, # Is active?
mttf=0.0, # Mean time to failure
mttr=0.0 # Mean time to recovery
)
grid.add_load(bus2, l2)
# Define the others with the default parameters
grid.add_load(bus3, Load(P=25, Q=15))
grid.add_load(bus4, Load(P=40, Q=20))
grid.add_load(bus5, Load(P=50, Q=20))
####################################################################################################################
# Add the generators
####################################################################################################################
g1 = Generator(name='gen',
active_power=0.0, # Active power in MW, since this generator is used to set the slack , is 0
voltage_module=1.0, # Voltage set point to control
Qmin=-9999, # minimum reactive power in MVAr
Qmax=9999, # Maximum reactive power in MVAr
Snom=9999, # Nominal power in MVA
power_prof=None, # power profile
vset_prof=None, # voltage set point profile
active=True # Is active?
)
grid.add_generator(bus1, g1)
####################################################################################################################
# Add the lines
####################################################################################################################
br1 = Branch(bus_from=bus1,
bus_to=bus2,
name='Line 1-2',
r=0.05, # resistance of the pi model in per unit
x=0.11, # reactance of the pi model in per unit
g=1e-20, # conductance of the pi model in per unit
b=0.02, # susceptance of the pi model in per unit
rate=50, # Rate in MVA
tap=1.0, # Tap value (value close to 1)
shift_angle=0, # Tap angle in radians
active=True, # is the branch active?
mttf=0, # Mean time to failure
mttr=0, # Mean time to recovery
branch_type=BranchType.Line, # Branch type tag
length=1, # Length in km (to be used with templates)
template=BranchTemplate() # Branch template (The default one is void)
)
grid.add_branch(br1)
grid.add_branch(Branch(bus1, bus3, name='Line 1-3', r=0.05, x=0.11, b=0.02, rate=50))
grid.add_branch(Branch(bus1, bus5, name='Line 1-5', r=0.03, x=0.08, b=0.02, rate=80))
grid.add_branch(Branch(bus2, bus3, name='Line 2-3', r=0.04, x=0.09, b=0.02, rate=3))
grid.add_branch(Branch(bus2, bus5, name='Line 2-5', r=0.04, x=0.09, b=0.02, rate=10))
grid.add_branch(Branch(bus3, bus4, name='Line 3-4', r=0.06, x=0.13, b=0.03, rate=30))
grid.add_branch(Branch(bus4, bus5, name='Line 4-5', r=0.04, x=0.09, b=0.02, rate=30))
####################################################################################################################
# Run a power flow simulation
####################################################################################################################
# We need to specify power flow options
pf_options = PowerFlowOptions(solver_type=SolverType.NR, # Base method to use
verbose=False, # Verbose option where available
tolerance=1e-6, # power error in p.u.
max_iter=25, # maximum iteration number
control_q=True # if to control the reactive power
)
# Declare and execute the power flow simulation
pf = PowerFlowDriver(grid, pf_options)
pf.run()
# now, let's compose a nice DataFrame with the voltage results
headers = ['Vm (p.u.)', 'Va (Deg)', 'Vre', 'Vim']
Vm = np.abs(pf.results.voltage)
Va = np.angle(pf.results.voltage, deg=True)
Vre = pf.results.voltage.real
Vim = pf.results.voltage.imag
data = np.c_[Vm, Va, Vre, Vim]
v_df = pd.DataFrame(data=data, columns=headers, index=grid.bus_names)
print('\n', v_df)
# Let's do the same for the branch results
headers = ['Loading (%)', 'Current(p.u.)', 'Power (MVA)']
loading = np.abs(pf.results.loading) * 100
current = np.abs(pf.results.Ibranch)
power = np.abs(pf.results.Sbranch)
data = np.c_[loading, current, power]
br_df = pd.DataFrame(data=data, columns=headers, index=grid.branch_names)
print('\n', br_df)
# Finally the execution metrics
print('\nError:', pf.results.error)
print('Elapsed time (s):', pf.results.elapsed, '\n')
print(v_df)
print()
print(br_df)
def __init__(self,
name='batt',
idtag=None,
active_power=0.0,
power_factor=0.8,
voltage_module=1.0,
is_controlled=True,
Qmin=-9999,
Qmax=9999,
Snom=9999,
Enom=9999,
p_min=-9999,
p_max=9999,
op_cost=1.0,
power_prof=None,
power_factor_prof=None,
vset_prof=None,
active=True,
Sbase=100,
enabled_dispatch=True,
mttf=0.0,
mttr=0.0,
charge_efficiency=0.9,
discharge_efficiency=0.9,
max_soc=0.99,
min_soc=0.3,
soc=0.8,
charge_per_cycle=0.1,
discharge_per_cycle=0.1):
Generator.__init__(self,
name=name,
idtag=idtag,
active_power=active_power,
power_factor=power_factor,
voltage_module=voltage_module,
is_controlled=is_controlled,
Qmin=Qmin,
Qmax=Qmax,
Snom=Snom,
power_prof=power_prof,
power_factor_prof=power_factor_prof,
vset_prof=vset_prof,
active=active,
p_min=p_min,
p_max=p_max,
op_cost=op_cost,
Sbase=Sbase,
enabled_dispatch=enabled_dispatch,
mttf=mttf,
mttr=mttr)
# type of this device
self.device_type = DeviceType.BatteryDevice
# manually modify the editable headers
self.editable_headers = {
'name':
GCProp('', str, 'Name of the battery'),
'idtag':
GCProp('', str, 'Unique ID'),
'bus':
GCProp('', DeviceType.BusDevice, 'Connection bus name'),
'active':
GCProp('', bool, 'Is the battery active?'),
'is_controlled':
GCProp('', bool, 'Is this battery voltage-controlled?'),
'P':
GCProp('MW', float, 'Active power'),
'Pf':
GCProp(
'', float,
'Power factor (cos(fi)). This is used for non-controlled batteries.'
),
'Vset':
GCProp('p.u.', float,
'Set voltage. This is used for controlled batteries.'),
'Snom':
GCProp('MVA', float, 'Nomnial power.'),
'Enom':
GCProp('MWh', float, 'Nominal energy capacity.'),
'max_soc':
GCProp('p.u.', float, 'Minimum state of charge.'),
'min_soc':
GCProp('p.u.', float, 'Maximum state of charge.'),
'soc_0':
GCProp('p.u.', float, 'Initial state of charge.'),
'charge_efficiency':
GCProp('p.u.', float, 'Charging efficiency.'),
'discharge_efficiency':
GCProp('p.u.', float, 'Discharge efficiency.'),
'discharge_per_cycle':
GCProp('p.u.', float, ''),
'Qmin':
GCProp('MVAr', float, 'Minimum reactive power.'),
'Qmax':
GCProp('MVAr', float, 'Maximum reactive power.'),
'Pmin':
GCProp('MW', float, 'Minimum active power. Used in OPF.'),
'Pmax':
GCProp('MW', float, 'Maximum active power. Used in OPF.'),
'Cost':
GCProp('e/MWh', float, 'Generation unitary cost. Used in OPF.'),
'enabled_dispatch':
GCProp('', bool, 'Enabled for dispatch? Used in OPF.'),
'mttf':
GCProp('h', float, 'Mean time to failure'),
'mttr':
GCProp('h', float, 'Mean time to recovery')
}
self.charge_efficiency = charge_efficiency
self.discharge_efficiency = discharge_efficiency
self.max_soc = max_soc
self.min_soc = min_soc
self.min_soc_charge = (self.max_soc + self.min_soc
) / 2 # SoC state to force the battery charge
self.charge_per_cycle = charge_per_cycle # charge 10% per cycle
self.discharge_per_cycle = discharge_per_cycle
self.min_energy = Enom * self.min_soc
self.Enom = Enom
self.soc_0 = soc
self.soc = soc
self.energy = self.Enom * self.soc
self.energy_array = None
self.power_array = None
def get_grid_lynn_5_bus_wiki():
grid = MultiCircuit(name='lynn 5 bus')
bus_1 = Bus(
name='bus_1',
vnom=10, # Nominal voltage in kV
vmin=0.9, # Bus minimum voltage in per unit
vmax=1.1, # Bus maximum voltage in per unit
xpos=0, # Bus x position in pixels
ypos=0, # Bus y position in pixels
height=0, # Bus height in pixels
width=0, # Bus width in pixels
active=True, # Is the bus active?
is_slack=False, # Is this bus a slack bus?
area='Default', # Area (for grouping purposes only)
zone='Default', # Zone (for grouping purposes only)
substation='Default' # Substation (for grouping purposes only)
)
bus_2 = Bus(name='bus_2')
bus_3 = Bus(name='bus_3')
bus_4 = Bus(name='bus_4')
bus_5 = Bus(name='bus_5')
grid.add_bus(bus_1)
grid.add_bus(bus_2)
grid.add_bus(bus_3)
grid.add_bus(bus_4)
grid.add_bus(bus_5)
load_2 = Load(
name='Load',
# impedance=complex(0, 0),
# Impedance of the ZIP model in MVA at the nominal voltage
# current=complex(0, 0),
# Current of the ZIP model in MVA at the nominal voltage
# power=complex(40, 20), # Power of the ZIP model in MVA
# impedance_prof=None, # Impedance profile
# current_prof=None, # Current profile
# power_prof=None, # Power profile
active=True, # Is active?
mttf=0.0, # Mean time to failure
mttr=0.0 # Mean time to recovery
)
grid.add_load(bus_2, load_2)
grid.add_load(
bus_3,
Load(
# power=complex(25, 15)
))
grid.add_load(
bus_4,
Load(
# power=complex(40, 20)
))
grid.add_load(
bus_5,
Load(
# power=complex(50, 20)
))
generator_1 = Generator(
name='gen',
active_power=0.0,
# Active power in MW, since this generator is used to set the slack , is 0
voltage_module=1.0, # Voltage set point to control
Qmin=-9999, # minimum reactive power in MVAr
Qmax=9999, # Maximum reactive power in MVAr
Snom=9999, # Nominal power in MVA
power_prof=None, # power profile
vset_prof=None, # voltage set point profile
active=True # Is active?
)
grid.add_generator(bus_1, generator_1)
branch_1 = Branch(
bus_from=bus_1,
bus_to=bus_2,
name='Line 1-2',
r=0.05, # resistance of the pi model in per unit
x=0.11, # reactance of the pi model in per unit
g=1e-20, # conductance of the pi model in per unit
b=0.02, # susceptance of the pi model in per unit
rate=50, # Rate in MVA
tap=1.0, # Tap value (value close to 1)
shift_angle=0, # Tap angle in radians
active=True, # is the branch active?
mttf=0, # Mean time to failure
mttr=0, # Mean time to recovery
branch_type=BranchType.Line, # Branch type tag
length=1, # Length in km (to be used with templates)
# type_obj=BranchTemplate()
# Branch template (The default one is void)
)
grid.add_branch(branch_1)
grid.add_branch(
Branch(bus_1, bus_3, name='Line 1-3', r=0.05, x=0.11, b=0.02, rate=50))
grid.add_branch(
Branch(bus_1, bus_5, name='Line 1-5', r=0.03, x=0.08, b=0.02, rate=80))
grid.add_branch(
Branch(bus_2, bus_3, name='Line 2-3', r=0.04, x=0.09, b=0.02, rate=3))
grid.add_branch(
Branch(bus_2, bus_5, name='Line 2-5', r=0.04, x=0.09, b=0.02, rate=10))
grid.add_branch(
Branch(bus_3, bus_4, name='Line 3-4', r=0.06, x=0.13, b=0.03, rate=30))
grid.add_branch(
Branch(bus_4, bus_5, name='Line 4-5', r=0.04, x=0.09, b=0.02, rate=30))
grid.compile()
return grid
def 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
