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)
def test_power_flow(): fname = Path(__file__).parent.parent.parent / \ 'Grids_and_profiles' / 'grids' / 'IEEE 5 Bus.xlsx' print('Reading...') main_circuit = FileOpen(fname).open() options = PowerFlowOptions(SolverType.NR, verbose=False, initialize_with_existing_solution=False, multi_core=False, dispatch_storage=True, control_q=ReactivePowerControlMode.Direct, control_p=True) # grid.export_profiles('ppppppprrrrroooofiles.xlsx') # exit() #################################################################################################################### # PowerFlowDriver #################################################################################################################### print('\n\n') power_flow = PowerFlowDriver(main_circuit, options) power_flow.run() main_circuit.build_graph() 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()) vc_options = VoltageCollapseOptions() 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() mdl = vc.results.mdl() mdl.plot() plt.show()
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()
error_tol=1e-3, tol=1e-6, max_it=20, verbose=False) numeric_circuit = grid.compile() numeric_inputs = numeric_circuit.compute() Sbase = np.zeros(len(grid.buses), dtype=complex) Vbase = np.zeros(len(grid.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(grid.buses)) print(unitary_vector) vc_inputs = VoltageCollapseInput(Sbase=Sbase, Vbase=Vbase, Starget=Sbase * (10 + unitary_vector)) vc = VoltageCollapse(circuit=grid, options=vc_options, inputs=vc_inputs) vc.run() smoothness_r = [] smoothness_i = [] data = vc.results.voltages print(data) # extracting the graph signals in cartesian coordinates for a in range(data.shape[0]): vv = data[a, :] vv_r = vv.real vv_i = vv.imag smoothness_r.append(vv_r.T.dot(R).dot(vv_r)) smoothness_i.append(vv_i.T.dot(-I).dot(vv_i))