def _test_api_dcopf():
# TODO Make this work and parameterize this test using pytest
# fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_300BUS.xls'
# fname = 'Pegasus 89 Bus.xlsx'
# fname = 'Illinois200Bus.xlsx'
# fname = 'IEEE_30_new.xlsx'
# fname = 'lynn5buspq.xlsx'
# fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE_30_new.xlsx'
# fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE39.xlsx'
# fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_14.xls'
# fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_39Bus(Islands).xls'
# fname = 'D:\\GitHub\\GridCal\\Grids_and_profiles\\grids\\3 node battery opf.xlsx'
# fname = 'D:\\GitHub\\GridCal\\Grids_and_profiles\\grids\\IEEE_30_new.xlsx'
fname = 'C:\\Users\\spenate\\Documents\\PROYECTOS\\Monash\\phase0\\Grid\\Monash University Campus with profiles.xlsx'
print('loading...')
grid = FileOpen(fname).open()
grid.compile_snapshot()
opf_options = OptimalPowerFlowOptions()
# opf = OptimalPowerFlow(grid, opf_options)
# opf.run()
print('Running ts...')
opf_ts = OptimalPowerFlowTimeSeries(grid, opf_options)
opf_ts.run()
def test_api_helm():
np.set_printoptions(precision=4)
fname = os.path.join('..', '..', 'Grids_and_profiles', 'grids',
'IEEE 30 Bus with storage.xlsx')
grid = FileOpen(fname).open()
grid.compile_snapshot()
print('\n\n', grid.name)
# print('Ybus:\n', grid.circuits[0].power_flow_input.Ybus.todense())
options = PowerFlowOptions(SolverType.HELM, verbose=False, tolerance=1e-9)
power_flow = PowerFlowDriver(grid, options)
power_flow.run()
print_power_flow_results(power_flow)
def test_voltage_collapse(root_path=ROOT_PATH):
"""
:param root_path:
:return:
"""
fname = os.path.join('..', '..', 'Grids_and_profiles', 'grids', 'grid_2_islands.xlsx')
print('Reading...')
main_circuit = FileOpen(fname).open()
####################################################################################################################
# PowerFlowDriver
####################################################################################################################
print('\n\n')
vc_options = VoltageCollapseOptions()
# just for this test
numeric_circuit = main_circuit.compile_snapshot()
numeric_inputs = numeric_circuit.compute()
Sbase = np.zeros(len(main_circuit.buses), dtype=complex)
Vbase = np.zeros(len(main_circuit.buses), dtype=complex)
for c in numeric_inputs:
Sbase[c.original_bus_idx] = c.Sbus
Vbase[c.original_bus_idx] = c.Vbus
unitary_vector = -1 + 2 * np.random.random(len(main_circuit.buses))
# unitary_vector = random.random(len(grid.buses))
vc_inputs = VoltageCollapseInput(Sbase=Sbase,
Vbase=Vbase,
Starget=Sbase * (1 + unitary_vector))
vc = VoltageCollapse(circuit=main_circuit, options=vc_options,
inputs=vc_inputs)
vc.run()
# vc.results.plot()
fname = root_path / 'data' / 'output' / 'test_demo_5_node.png'
print(fname)
if __name__ == '__main__':
from GridCal.Engine.IO.file_handler import FileOpen
# fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/Lynn 5 Bus pv.gridcal'
# fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE39_1W.gridcal'
fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/grid_2_islands.xlsx'
# fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/Lynn 5 Bus pv (2 islands).gridcal'
main_circuit = FileOpen(fname).open()
main_circuit.buses[3].controlled_generators[0].enabled_dispatch = False
numerical_circuit_ = main_circuit.compile_snapshot()
problem = OpfSimple(numerical_circuit=numerical_circuit_)
print('Solving...')
status = problem.solve()
# print("Status:", status)
v = problem.get_voltage()
print('Angles\n', np.angle(v))
l = problem.get_loading()
print('Branch loading\n', l)
g = problem.get_generator_power()
print('Gen power\n', g)
def _test_api():
fname = os.path.join('..', '..', 'Grids_and_profiles', 'grids',
'IEEE 30 Bus with storage.xlsx')
print('Reading...')
main_circuit = FileOpen(fname).open()
pf_options = PowerFlowOptions(SolverType.NR,
verbose=False,
initialize_with_existing_solution=False,
multi_core=False,
dispatch_storage=True,
control_q=ReactivePowerControlMode.NoControl,
control_p=True)
####################################################################################################################
# PowerFlowDriver
####################################################################################################################
print('\n\n')
power_flow = PowerFlowDriver(main_circuit, pf_options)
power_flow.run()
print('\n\n', main_circuit.name)
print('\t|V|:', abs(power_flow.results.voltage))
print('\t|Sbranch|:', abs(power_flow.results.Sbranch))
print('\t|loading|:', abs(power_flow.results.loading) * 100)
print('\tReport')
print(power_flow.results.get_report_dataframe())
####################################################################################################################
# Short circuit
####################################################################################################################
print('\n\n')
print('Short Circuit')
sc_options = ShortCircuitOptions(bus_index=[16])
# grid, options, pf_options:, pf_results:
sc = ShortCircuit(grid=main_circuit,
options=sc_options,
pf_options=pf_options,
pf_results=power_flow.results)
sc.run()
print('\n\n', main_circuit.name)
print('\t|V|:', abs(main_circuit.short_circuit_results.voltage))
print('\t|Sbranch|:', abs(main_circuit.short_circuit_results.Sbranch))
print('\t|loading|:',
abs(main_circuit.short_circuit_results.loading) * 100)
####################################################################################################################
# Time Series
####################################################################################################################
print('Running TS...', '')
ts = TimeSeries(grid=main_circuit, options=pf_options, start_=0, end_=96)
ts.run()
numeric_circuit = main_circuit.compile_snapshot()
ts_analysis = TimeSeriesResultsAnalysis(numeric_circuit, ts.results)
####################################################################################################################
# OPF
####################################################################################################################
print('Running OPF...', '')
# opf_options = OptimalPowerFlowOptions(verbose=False,
# solver=SolverType.DC_OPF,
# mip_solver=False)
# opf = OptimalPowerFlow(grid=main_circuit, options=opf_options)
# opf.run()
####################################################################################################################
# OPF Time Series
####################################################################################################################
print('Running OPF-TS...', '')
# opf_options = OptimalPowerFlowOptions(verbose=False,
# solver=SolverType.NELDER_MEAD_OPF,
# mip_solver=False)
# opf_ts = OptimalPowerFlowTimeSeries(grid=main_circuit, options=opf_options,
# start_=0, end_=96)
# opf_ts.run()
####################################################################################################################
# Voltage collapse
####################################################################################################################
vc_options = VoltageCollapseOptions()
# just for this test
numeric_circuit = main_circuit.compile_snapshot()
numeric_inputs = numeric_circuit.compute()
Sbase = np.zeros(len(main_circuit.buses), dtype=complex)
Vbase = np.zeros(len(main_circuit.buses), dtype=complex)
for c in numeric_inputs:
Sbase[c.original_bus_idx] = c.Sbus
Vbase[c.original_bus_idx] = c.Vbus
unitary_vector = -1 + 2 * np.random.random(len(main_circuit.buses))
vc_inputs = VoltageCollapseInput(Sbase=Sbase,
Vbase=Vbase,
Starget=Sbase * (1 + unitary_vector))
vc = VoltageCollapse(circuit=main_circuit,
options=vc_options,
inputs=vc_inputs)
vc.run()
mdl = vc.results.mdl()
mdl.plot()
from matplotlib import pyplot as plt
plt.show()
####################################################################################################################
# Monte Carlo
####################################################################################################################
print('Running MC...')
mc_sim = MonteCarlo(main_circuit,
pf_options,
mc_tol=1e-5,
max_mc_iter=1000000)
mc_sim.run()
lst = np.array(list(range(mc_sim.results.n)), dtype=int)
# mc_sim.results.plot(ResultTypes.BusVoltageAverage, indices=lst, names=lst)
####################################################################################################################
# Latin Hypercube
####################################################################################################################
print('Running LHC...')
lhs_sim = LatinHypercubeSampling(main_circuit,
pf_options,
sampling_points=100)
lhs_sim.run()
####################################################################################################################
# Cascading
####################################################################################################################
print('Running Cascading...')
cascade = Cascading(main_circuit.copy(),
pf_options,
max_additional_islands=5,
cascade_type_=CascadeType.LatinHypercube,
n_lhs_samples_=10)
cascade.run()
cascade.perform_step_run()
cascade.perform_step_run()
cascade.perform_step_run()
cascade.perform_step_run()
