def eval(self, x): """ Evaluate the Ackley function at x :param x: Data point :type x: numpy.array :return: Value at x :rtype: float """ # For every circuit, run the time series for numerical_island in self.numerical_input_islands: # sample from the CDF give the vector x of values in [0, 1] # c.sample_at(x) monte_carlo_input = make_monte_carlo_input(numerical_island) mc_time_series = monte_carlo_input.get_at(x) Y, I, S = mc_time_series.get_at(t=0) # run the sampled values # res = self.power_flow.run_at(0, mc=True) res = single_island_pf(circuit, Vbus, Sbus, Ibus, options=self.options, logger=self.logger) self.results.S_points[self.it, numerical_island.original_bus_idx] = S self.results.V_points[ self.it, numerical_island.original_bus_idx] = res.voltage[ numerical_island.original_bus_idx] self.results.Sbr_points[ self.it, numerical_island.original_branch_idx] = res.If[ numerical_island.original_branch_idx] self.results.loading_points[ self.it, numerical_island.original_branch_idx] = res.loading[ numerical_island.original_branch_idx] self.it += 1 if self.callback is not None: prog = self.it / self.max_eval * 100 self.callback(prog) f = abs(self.results.V_points[self.it - 1, :].sum()) / self.dim # print(prog, ' % \t', f) return f
def run_multi_thread(self): """ Run the monte carlo simulation @return: """ # print('LHS run') self.__cancel__ = False # initialize vars batch_size = self.sampling_points n = len(self.circuit.buses) m = len(self.circuit.branches) n_cores = multiprocessing.cpu_count() self.progress_signal.emit(0.0) self.progress_text.emit( 'Running Latin Hypercube Sampling in parallel using ' + str(n_cores) + ' cores ...') lhs_results = MonteCarloResults(n, m, batch_size) avg_res = PowerFlowResults() avg_res.initialize(n, m) # compile # print('Compiling...', end='') numerical_circuit = self.circuit.compile() numerical_islands = numerical_circuit.compute( branch_tolerance_mode=self.options.branch_impedance_tolerance_mode) lhs_results.bus_types = numerical_circuit.bus_types max_iter = batch_size * len(numerical_islands) Sbase = self.circuit.Sbase it = 0 # For every circuit, run the time series for numerical_island in numerical_islands: # try: # set the time series as sampled in the circuit monte_carlo_input = make_monte_carlo_input(numerical_island) mc_time_series = monte_carlo_input(batch_size, use_latin_hypercube=True) Vbus = numerical_island.Vbus # short cut the indices b_idx = numerical_island.original_bus_idx br_idx = numerical_island.original_branch_idx manager = multiprocessing.Manager() return_dict = manager.dict() t = 0 while t < batch_size and not self.__cancel__: k = 0 jobs = list() # launch only n_cores jobs at the time while k < n_cores + 2 and (t + k) < batch_size: # set the power values Y, I, S = mc_time_series.get_at(t) # run power flow at the circuit p = multiprocessing.Process( target=power_flow_worker, args=(t, self.options, numerical_island, Vbus, S / Sbase, I / Sbase, return_dict)) jobs.append(p) p.start() k += 1 t += 1 # wait for all jobs to complete for proc in jobs: proc.join() progress = ((t + 1) / batch_size) * 100 self.progress_signal.emit(progress) # collect results self.progress_text.emit('Collecting results...') for t in return_dict.keys(): # store circuit results at the time index 't' res = return_dict[t] lhs_results.S_points[ t, numerical_island.original_bus_idx] = res.Sbus lhs_results.V_points[ t, numerical_island.original_bus_idx] = res.voltage lhs_results.I_points[ t, numerical_island.original_branch_idx] = res.Ibranch lhs_results.loading_points[ t, numerical_island.original_branch_idx] = res.loading lhs_results.losses_points[ t, numerical_island.original_branch_idx] = res.losses # except Exception as ex: # print(c.name, ex) if self.__cancel__: break # compile MC results self.progress_text.emit('Compiling results...') lhs_results.compile() # compute the island branch results island_avg_res = numerical_island.compute_branch_results( lhs_results.voltage[b_idx]) # apply the island averaged results avg_res.apply_from_island(island_avg_res, b_idx=b_idx, br_idx=br_idx) # lhs_results the averaged branch magnitudes lhs_results.sbranch = avg_res.Sbranch lhs_results.losses = avg_res.losses self.results = lhs_results # send the finnish signal self.progress_signal.emit(0.0) self.progress_text.emit('Done!') self.done_signal.emit() return lhs_results
def run_single_thread(self): """ Run the monte carlo simulation @return: """ # print('LHS run') self.__cancel__ = False # initialize the power flow power_flow = PowerFlowMP(self.circuit, self.options) # initialize the grid time series results # we will append the island results with another function self.circuit.time_series_results = TimeSeriesResults(0, 0, 0, 0, 0) batch_size = self.sampling_points n = len(self.circuit.buses) m = len(self.circuit.branches) self.progress_signal.emit(0.0) self.progress_text.emit('Running Latin Hypercube Sampling...') lhs_results = MonteCarloResults(n, m, batch_size) avg_res = PowerFlowResults() avg_res.initialize(n, m) # compile the numerical circuit numerical_circuit = self.circuit.compile() numerical_input_islands = numerical_circuit.compute( branch_tolerance_mode=self.options.branch_impedance_tolerance_mode) max_iter = batch_size * len(numerical_input_islands) Sbase = numerical_circuit.Sbase it = 0 # For every circuit, run the time series for numerical_island in numerical_input_islands: # try: # set the time series as sampled in the circuit # build the inputs monte_carlo_input = make_monte_carlo_input(numerical_island) mc_time_series = monte_carlo_input(batch_size, use_latin_hypercube=True) Vbus = numerical_island.Vbus # short cut the indices b_idx = numerical_island.original_bus_idx br_idx = numerical_island.original_branch_idx # run the time series for t in range(batch_size): # set the power values from a Monte carlo point at 't' Y, I, S = mc_time_series.get_at(t) # Run the set monte carlo point at 't' res = power_flow.run_pf(circuit=numerical_island, Vbus=Vbus, Sbus=S / Sbase, Ibus=I / Sbase) # Gather the results lhs_results.S_points[ t, numerical_island.original_bus_idx] = res.Sbus lhs_results.V_points[ t, numerical_island.original_bus_idx] = res.voltage lhs_results.I_points[ t, numerical_island.original_branch_idx] = res.Ibranch lhs_results.loading_points[ t, numerical_island.original_branch_idx] = res.loading lhs_results.losses_points[ t, numerical_island.original_branch_idx] = res.losses it += 1 self.progress_signal.emit(it / max_iter * 100) if self.__cancel__: break if self.__cancel__: break # compile MC results self.progress_text.emit('Compiling results...') lhs_results.compile() # compute the island branch results island_avg_res = numerical_island.compute_branch_results( lhs_results.voltage[b_idx]) # apply the island averaged results avg_res.apply_from_island(island_avg_res, b_idx=b_idx, br_idx=br_idx) # lhs_results the averaged branch magnitudes lhs_results.sbranch = avg_res.Sbranch lhs_results.bus_types = numerical_circuit.bus_types # Ibranch = avg_res.Ibranch # loading = avg_res.loading # lhs_results.losses = avg_res.losses # flow_direction = avg_res.flow_direction # Sbus = avg_res.Sbus self.results = lhs_results # send the finnish signal self.progress_signal.emit(0.0) self.progress_text.emit('Done!') self.done_signal.emit() return lhs_results
def run_multi_thread(self): """ Run the monte carlo simulation @return: """ # print('LHS run') self.__cancel__ = False # initialize vars batch_size = self.sampling_points n = len(self.circuit.buses) m = self.circuit.get_branch_number() n_cores = multiprocessing.cpu_count() self.pool = multiprocessing.Pool() self.progress_signal.emit(0.0) self.progress_text.emit( 'Running Latin Hypercube Sampling in parallel using ' + str(n_cores) + ' cores ...') lhs_results = MonteCarloResults(n, m, batch_size, name='Latin Hypercube') avg_res = PowerFlowResults() avg_res.initialize(n, m) # compile the multi-circuit numerical_circuit = self.circuit.compile_time_series() # perform the topological computation calc_inputs_dict = numerical_circuit.compute( branch_tolerance_mode=self.options.branch_impedance_tolerance_mode, ignore_single_node_islands=self.options.ignore_single_node_islands) # for each partition of the profiles... for t_key, calc_inputs in calc_inputs_dict.items(): # For every island, run the time series for island_index, numerical_island in enumerate(calc_inputs): lhs_results.bus_types = numerical_circuit.bus_types monte_carlo_input = make_monte_carlo_input(numerical_island) mc_time_series = monte_carlo_input(batch_size, use_latin_hypercube=True) Vbus = numerical_island.Vbus branch_rates = numerical_island.branch_rates # short cut the indices b_idx = numerical_island.original_bus_idx br_idx = numerical_island.original_branch_idx # Start jobs self.returned_results = list() t = 0 while t < batch_size and not self.__cancel__: Ysh, Ibus, Sbus = mc_time_series.get_at(t) args = (t, self.options, numerical_island, Vbus, Sbus, Ibus, branch_rates) self.pool.apply_async(power_flow_worker_args, (args, ), callback=self.update_progress_mt) # wait for all jobs to complete self.pool.close() self.pool.join() # collect results self.progress_text.emit('Collecting results...') for t, res in self.returned_results: # store circuit results at the time index 't' lhs_results.S_points[ t, numerical_island.original_bus_idx] = res.Sbus lhs_results.V_points[ t, numerical_island.original_bus_idx] = res.voltage lhs_results.Sbr_points[ t, numerical_island.original_branch_idx] = res.Sf lhs_results.loading_points[ t, numerical_island.original_branch_idx] = res.loading lhs_results.losses_points[ t, numerical_island.original_branch_idx] = res.losses # compile MC results self.progress_text.emit('Compiling results...') lhs_results.compile() # compute the island branch results island_avg_res = numerical_island.compute_branch_results( lhs_results.voltage[b_idx]) # apply the island averaged results avg_res.apply_from_island(island_avg_res, b_idx=b_idx, br_idx=br_idx) # lhs_results the averaged branch magnitudes lhs_results.sbranch = avg_res.Sf lhs_results.losses = avg_res.losses self.results = lhs_results # send the finnish signal self.progress_signal.emit(0.0) self.progress_text.emit('Done!') self.done_signal.emit() return lhs_results
def run_single_thread(self): """ Run the monte carlo simulation @return: """ # print('LHS run') self.__cancel__ = False # initialize the grid time series results # we will append the island results with another function # batch_size = self.sampling_points self.progress_signal.emit(0.0) self.progress_text.emit('Running Latin Hypercube Sampling...') # compile the multi-circuit numerical_circuit = compile_time_circuit( circuit=self.circuit, apply_temperature=False, branch_tolerance_mode=BranchImpedanceMode.Specified, opf_results=self.opf_time_series_results) # do the topological computation calculation_inputs = numerical_circuit.split_into_islands( ignore_single_node_islands=self.options.ignore_single_node_islands) lhs_results = MonteCarloResults( n=numerical_circuit.nbus, m=numerical_circuit.nbr, p=self.sampling_points, bus_names=numerical_circuit.bus_names, branch_names=numerical_circuit.branch_names, bus_types=numerical_circuit.bus_types, name='Latin Hypercube') avg_res = PowerFlowResults( n=numerical_circuit.nbus, m=numerical_circuit.nbr, n_tr=numerical_circuit.ntr, n_hvdc=numerical_circuit.nhvdc, bus_names=numerical_circuit.bus_names, branch_names=numerical_circuit.branch_names, transformer_names=numerical_circuit.tr_names, hvdc_names=numerical_circuit.hvdc_names, bus_types=numerical_circuit.bus_types) it = 0 # For every island, run the time series for island_index, numerical_island in enumerate(calculation_inputs): # try: # set the time series as sampled in the circuit # build the inputs monte_carlo_input = make_monte_carlo_input(numerical_island) mc_time_series = monte_carlo_input(self.sampling_points, use_latin_hypercube=True) Vbus = numerical_island.Vbus[:, 0] # short cut the indices bus_idx = numerical_island.original_bus_idx br_idx = numerical_island.original_branch_idx # run the time series for t in range(self.sampling_points): # set the power values from a Monte carlo point at 't' Y, I, S = mc_time_series.get_at(t) # Run the set monte carlo point at 't' res = single_island_pf( circuit=numerical_island, Vbus=Vbus, Sbus=S, Ibus=I, branch_rates=numerical_island.branch_rates, options=self.options, logger=self.logger) # Gather the results lhs_results.S_points[t, bus_idx] = S lhs_results.V_points[t, bus_idx] = res.voltage lhs_results.Sbr_points[t, br_idx] = res.Sf lhs_results.loading_points[t, br_idx] = res.loading lhs_results.losses_points[t, br_idx] = res.losses it += 1 self.progress_signal.emit(it / self.sampling_points * 100) if self.__cancel__: break if self.__cancel__: break # compile MC results self.progress_text.emit('Compiling results...') lhs_results.compile() # compute the island branch results Sfb, Stb, If, It, Vbranch, loading, \ losses, flow_direction, Sbus = power_flow_post_process(numerical_island, Sbus=lhs_results.S_points.mean(axis=0)[bus_idx], V=lhs_results.V_points.mean(axis=0)[bus_idx], branch_rates=numerical_island.branch_rates) # apply the island averaged results avg_res.Sbus[bus_idx] = Sbus avg_res.voltage[bus_idx] = lhs_results.voltage[bus_idx] avg_res.Sf[br_idx] = Sfb avg_res.St[br_idx] = Stb avg_res.If[br_idx] = If avg_res.It[br_idx] = It avg_res.Vbranch[br_idx] = Vbranch avg_res.loading[br_idx] = loading avg_res.losses[br_idx] = losses avg_res.flow_direction[br_idx] = flow_direction self.results = lhs_results # send the finnish signal self.progress_signal.emit(0.0) self.progress_text.emit('Done!') self.done_signal.emit() return lhs_results
def run_single_thread(self): """ Run the monte carlo simulation @return: """ # print('LHS run') self.__cancel__ = False # initialize the grid time series results # we will append the island results with another function batch_size = self.sampling_points n = len(self.circuit.buses) m = len(self.circuit.branches) self.progress_signal.emit(0.0) self.progress_text.emit('Running Latin Hypercube Sampling...') lhs_results = MonteCarloResults(n, m, batch_size, name='Latin Hypercube') avg_res = PowerFlowResults() avg_res.initialize(n, m) # compile the multi-circuit numerical_circuit = self.circuit.compile() # perform the topological computation calc_inputs_dict = numerical_circuit.compute_ts( branch_tolerance_mode=self.options.branch_impedance_tolerance_mode, ignore_single_node_islands=self.options.ignore_single_node_islands) it = 0 # for each partition of the profiles... for t_key, calc_inputs in calc_inputs_dict.items(): # For every island, run the time series for island_index, numerical_island in enumerate(calc_inputs): # try: # set the time series as sampled in the circuit # build the inputs monte_carlo_input = make_monte_carlo_input(numerical_island) mc_time_series = monte_carlo_input(batch_size, use_latin_hypercube=True) Vbus = numerical_island.Vbus # short cut the indices b_idx = numerical_island.original_bus_idx br_idx = numerical_island.original_branch_idx # run the time series for t in range(batch_size): # set the power values from a Monte carlo point at 't' Y, I, S = mc_time_series.get_at(t) # Run the set monte carlo point at 't' res = single_island_pf( circuit=numerical_island, Vbus=Vbus, Sbus=S, Ibus=I, branch_rates=numerical_island.branch_rates, options=self.options, logger=self.logger) # Gather the results lhs_results.S_points[ t, numerical_island.original_bus_idx] = res.Sbus lhs_results.V_points[ t, numerical_island.original_bus_idx] = res.voltage lhs_results.I_points[ t, numerical_island.original_branch_idx] = res.Ibranch lhs_results.loading_points[ t, numerical_island.original_branch_idx] = res.loading lhs_results.losses_points[ t, numerical_island.original_branch_idx] = res.losses it += 1 self.progress_signal.emit(it / batch_size * 100) if self.__cancel__: break if self.__cancel__: break # compile MC results self.progress_text.emit('Compiling results...') lhs_results.compile() # compute the island branch results island_avg_res = numerical_island.compute_branch_results( lhs_results.voltage[b_idx]) # apply the island averaged results avg_res.apply_from_island(island_avg_res, b_idx=b_idx, br_idx=br_idx) # lhs_results the averaged branch magnitudes lhs_results.sbranch = avg_res.Sbranch lhs_results.bus_types = numerical_circuit.bus_types self.results = lhs_results # send the finnish signal self.progress_signal.emit(0.0) self.progress_text.emit('Done!') self.done_signal.emit() return lhs_results