def perform_step_run(self):
"""
Perform only one step cascading
Returns:
Nothing
"""
# recompile the grid
self.grid.compile()
# initialize the simulator
if self.cascade_type is CascadeType.PowerFlow:
model_simulator = PowerFlow(self.grid, self.options)
elif self.cascade_type is CascadeType.LatinHypercube:
model_simulator = LatinHypercubeSampling(
self.grid, self.options, sampling_points=self.n_lhs_samples)
else:
model_simulator = PowerFlow(self.grid, self.options)
# For every circuit, run a power flow
# for c in self.grid.circuits:
model_simulator.run()
if self.current_step == 0:
# the first iteration try to trigger the selected indices, if any
idx, criteria = self.remove_elements(
self.grid,
idx=self.triggering_idx,
loading_vector=model_simulator.results.loading)
else:
# cascade normally
idx, criteria = self.remove_elements(
self.grid, loading_vector=model_simulator.results.loading)
# store the removed indices and the results
entry = CascadingReportElement(idx, model_simulator.results, criteria)
self.results.events.append(entry)
# increase the step number
self.current_step += 1
# print(model_simulator.results.get_convergence_report())
# send the finnish signal
self.progress_signal.emit(0.0)
self.progress_text.emit('Done!')
self.done_signal.emit()
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()
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()
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()
# vc.results.plot()
####################################################################################################################
# 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()
def run(self):
"""
Run the monte carlo simulation
@return:
"""
self.__cancel__ = False
# compile
# print('Compiling...', end='')
numerical_circuit = compile_time_circuit(self.grid)
calculation_inputs = split_time_circuit_into_islands(
numerical_circuit,
ignore_single_node_islands=self.options.ignore_single_node_islands)
self.results = CascadingResults(self.cascade_type)
# initialize the simulator
if self.cascade_type is CascadeType.PowerFlow:
model_simulator = PowerFlowDriver(self.grid, self.options)
elif self.cascade_type is CascadeType.LatinHypercube:
model_simulator = LatinHypercubeSampling(
self.grid, self.options, sampling_points=self.n_lhs_samples)
else:
model_simulator = PowerFlowDriver(self.grid, self.options)
self.progress_signal.emit(0.0)
self.progress_text.emit('Running cascading failure...')
n_grids = len(calculation_inputs) + self.max_additional_islands
if n_grids > len(self.grid.buses): # safety check
n_grids = len(self.grid.buses) - 1
# print('n grids: ', n_grids)
it = 0
while len(calculation_inputs) <= n_grids and it <= n_grids:
# For every circuit, run the model (time series, lhs, or whatever)
model_simulator.run()
# remove grid elements (branches)
idx, criteria = self.remove_probability_based(
numerical_circuit,
model_simulator.results,
max_val=1.0,
min_prob=0.1)
# store the removed indices and the results
entry = CascadingReportElement(idx, model_simulator.results,
criteria)
self.results.events.append(entry)
# recompile grid
calculation_inputs = split_time_circuit_into_islands(
numerical_circuit,
ignore_single_node_islands=self.options.
ignore_single_node_islands)
it += 1
prog = max(
len(calculation_inputs) / (n_grids + 1), it / (n_grids + 1))
self.progress_signal.emit(prog * 100.0)
if self.__cancel__:
break
print('Grid split into ', len(calculation_inputs), ' islands after',
it, ' steps')
# send the finnish signal
self.progress_signal.emit(0.0)
self.progress_text.emit('Done!')
self.done_signal.emit()