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() 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() 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_api_helm(): np.set_printoptions(precision=4) # fname = 'Muthu4Bus.xls' # fname = 'IEEE_30BUS.xls' fname = 'IEEE_39Bus.xls' # fname = 'case9target.xls' grid = FileOpen(fname).open() grid.compile() print('\n\n', grid.name) # print('Ybus:\n', grid.circuits[0].power_flow_input.Ybus.todense()) options = PowerFlowOptions(SolverType.HELM_STABLE, verbose=False, tolerance=1e-9) power_flow = PowerFlow(grid, options) power_flow.run() print_power_flow_results(power_flow)
def test_api_multi_core(): batch_size = 10000 # fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_300BUS.xls' # fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_118.xls' # fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_57BUS.xls' fname = '/home/santi/Documentos/GitHub/GridCal/Grids_and_profiles/grids/IEEE_30_new.xlsx' # fname = 'D:\GitHub\GridCal\Grids_and_profiles\grids\IEEE_30_new.xlsx' # fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_14.xls' # fname = '/Data/Doctorado/spv_phd/GridCal_project/GridCal/IEEE_39Bus(Islands).xls' grid = FileOpen(fname).open() grid.compile() print('\n\n', grid.name) options = PowerFlowOptions(SolverType.NR, verbose=False) power_flow = PowerFlow(grid, options) power_flow.run() # create instances of the of the power flow simulation given the grid print('cloning...') pool = Pool() instances = pool.map(simulation_constructor, [[grid, options]] * batch_size) # run asynchronous power flows on the created instances print('running...') instances = pool.map_async(instance_executor, instances) # monitor progress while True: if instances.ready(): break remaining = instances._number_left progress = ((batch_size - remaining + 1) / batch_size) * 100 print("Waiting for", remaining, "tasks to complete...", progress, '%') time.sleep(0.5) # display the collected results for instance in instances.get(): print('\n\n' + instance.name)
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_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() 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() 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() 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()