def run(self): """ run the voltage collapse simulation @return: """ print('Running voltage collapse...') nc = compile_snapshot_circuit( circuit=self.grid, apply_temperature=self.pf_options.apply_temperature_correction, branch_tolerance_mode=self.pf_options. branch_impedance_tolerance_mode, opf_results=self.opf_results) islands = nc.split_into_islands(ignore_single_node_islands=self. pf_options.ignore_single_node_islands) result_series = list() for island in islands: self.progress_text.emit('Running voltage collapse at circuit ' + str(nc) + '...') if len(island.vd) > 0 and len(island.pqpv) > 0: results = continuation_nr( Ybus=island.Ybus, Cf=island.Cf, Ct=island.Ct, Yf=island.Yf, Yt=island.Yt, branch_rates=island.branch_rates, Sbase=island.Sbase, Ibus_base=island.Ibus, Ibus_target=island.Ibus, Sbus_base=self.inputs.Sbase[island.original_bus_idx], Sbus_target=self.inputs.Starget[island.original_bus_idx], V=self.inputs.Vbase[island.original_bus_idx], distributed_slack=self.pf_options.distributed_slack, bus_installed_power=island.bus_installed_power, vd=island.vd, pv=island.pv, pq=island.pq, step=self.options.step, approximation_order=self.options.approximation_order, adapt_step=self.options.adapt_step, step_min=self.options.step_min, step_max=self.options.step_max, error_tol=self.options.error_tol, tol=self.options.tol, max_it=self.options.max_it, stop_at=self.options.stop_at, control_q=self.pf_options.control_Q, qmax_bus=island.Qmax_bus, qmin_bus=island.Qmin_bus, original_bus_types=island.bus_types, base_overload_number=self.inputs.base_overload_number, verbose=False, call_back_fx=self.progress_callback) # store the result series result_series.append(results) # analyze the result series to compact all the results into one object if len(result_series) > 0: max_len = max([len(r) for r in result_series]) else: max_len = 0 # declare results self.results = ContinuationPowerFlowResults( nval=max_len, nbus=nc.nbus, nbr=nc.nbr, bus_names=nc.bus_names, branch_names=nc.branch_names, bus_types=nc.bus_types) for i in range(len(result_series)): if len(result_series[i]) > 0: self.results.apply_from_island(result_series[i], islands[i].original_bus_idx, islands[i].original_branch_idx) print('done!') self.progress_text.emit('Done!') self.done_signal.emit()
def run(self): """ run the voltage collapse simulation @return: """ print('Running voltage collapse...') nbus = self.circuit.get_bus_number() numerical_circuit = compile_snapshot_circuit( circuit=self.circuit, apply_temperature=self.pf_options.apply_temperature_correction, branch_tolerance_mode=self.pf_options. branch_impedance_tolerance_mode, opf_results=self.opf_results) numerical_input_islands = split_into_islands( numeric_circuit=numerical_circuit, ignore_single_node_islands=self.pf_options. ignore_single_node_islands) self.results = VoltageCollapseResults( nbus=numerical_circuit.nbus, nbr=numerical_circuit.nbr, bus_names=numerical_circuit.bus_names) self.results.bus_types = numerical_circuit.bus_types for nc, numerical_island in enumerate(numerical_input_islands): self.progress_text.emit('Running voltage collapse at circuit ' + str(nc) + '...') if len(numerical_island.vd) > 0: Voltage_series, Lambda_series, \ normF, success = continuation_nr(Ybus=numerical_island.Ybus, Ibus_base=numerical_island.Ibus, Ibus_target=numerical_island.Ibus, Sbus_base=self.inputs.Sbase[numerical_island.original_bus_idx], Sbus_target=self.inputs.Starget[numerical_island.original_bus_idx], V=self.inputs.Vbase[numerical_island.original_bus_idx], pv=numerical_island.pv, pq=numerical_island.pq, step=self.options.step, approximation_order=self.options.approximation_order, adapt_step=self.options.adapt_step, step_min=self.options.step_min, step_max=self.options.step_max, error_tol=self.options.error_tol, tol=self.options.tol, max_it=self.options.max_it, stop_at=self.options.stop_at, verbose=False, call_back_fx=self.progress_callback) # nbus can be zero, because all the arrays are going to be overwritten res = VoltageCollapseResults( nbus=numerical_island.nbus, nbr=numerical_island.nbr, bus_names=numerical_island.bus_names) res.voltages = np.array(Voltage_series) res.lambdas = np.array(Lambda_series) res.error = normF res.converged = bool(success) else: res = VoltageCollapseResults( nbus=numerical_island.nbus, nbr=numerical_island.nbr, bus_names=numerical_island.bus_names) res.voltages = np.array([[0] * numerical_island.nbus]) res.lambdas = np.array([[0] * numerical_island.nbus]) res.error = [0] res.converged = True if len(res.voltages) > 0: # compute the island branch results Sbranch, Ibranch, Vbranch, \ loading, losses, flow_direction, \ Sbus = power_flow_post_process(calculation_inputs=numerical_island, Sbus=self.inputs.Starget[numerical_island.original_bus_idx], V=res.voltages[-1], branch_rates=numerical_island.branch_rates) # update results self.results.apply_from_island( voltage_collapse_res=res, Sbranch=Sbranch, Ibranch=Ibranch, loading=loading, losses=losses, Sbus=Sbus, bus_original_idx=numerical_island.original_bus_idx, branch_original_idx=numerical_island.original_branch_idx, nbus_full=nbus) else: print('No voltage values!') print('done!') self.progress_text.emit('Done!') self.done_signal.emit()
def run(self): """ run the voltage collapse simulation @return: """ print('Running voltage collapse...') nbus = len(self.circuit.buses) nbr = len(self.circuit.branches) self.results = VoltageCollapseResults(nbus=nbus, nbr=nbr) # compile the numerical circuit numerical_circuit = self.circuit.compile_snapshot() numerical_input_islands = numerical_circuit.compute() self.results.bus_types = numerical_circuit.bus_types for nc, numerical_island in enumerate(numerical_input_islands): self.progress_text.emit('Running voltage collapse at circuit ' + str(nc) + '...') if len(numerical_island.ref) > 0: Voltage_series, Lambda_series, \ normF, success = continuation_nr(Ybus=numerical_island.Ybus, Ibus_base=numerical_island.Ibus, Ibus_target=numerical_island.Ibus, Sbus_base=self.inputs.Sbase[numerical_island.original_bus_idx], Sbus_target=self.inputs.Starget[numerical_island.original_bus_idx], V=self.inputs.Vbase[numerical_island.original_bus_idx], pv=numerical_island.pv, pq=numerical_island.pq, step=self.options.step, approximation_order=self.options.approximation_order, adapt_step=self.options.adapt_step, step_min=self.options.step_min, step_max=self.options.step_max, error_tol=self.options.error_tol, tol=self.options.tol, max_it=self.options.max_it, stop_at=self.options.stop_at, verbose=False, call_back_fx=self.progress_callback) # nbus can be zero, because all the arrays are going to be overwritten res = VoltageCollapseResults(nbus=numerical_island.nbus, nbr=numerical_island.nbr) res.voltages = np.array(Voltage_series) res.lambdas = np.array(Lambda_series) res.error = normF res.converged = bool(success) else: res = VoltageCollapseResults(nbus=numerical_island.nbus, nbr=numerical_island.nbr) res.voltages = np.array([[0] * numerical_island.nbus]) res.lambdas = np.array([[0] * numerical_island.nbus]) res.error = [0] res.converged = True if len(res.voltages) > 0: # compute the island branch results branch_res = numerical_island.compute_branch_results( res.voltages[-1]) self.results.apply_from_island( res, branch_res, numerical_island.original_bus_idx, numerical_island.original_branch_idx, nbus) else: print('No voltage values!') print('done!') self.progress_text.emit('Done!') self.done_signal.emit()