コード例 #1
0
    def n_minus_k(self):
        """
        Run N-1 simulation in series
        :return: returns the results
        """

        self.progress_text.emit("Filtering elements by voltage")

        self.numerical_circuit = compile_snapshot_circuit(self.grid)

        results = NMinusKResults(
            m=self.numerical_circuit.nbr,
            n=self.numerical_circuit.nbus,
            branch_names=self.numerical_circuit.branch_names,
            bus_names=self.numerical_circuit.bus_names,
            bus_types=self.numerical_circuit.bus_types)

        self.progress_text.emit('Analyzing outage distribution factors...')
        linear_analysis = LinearAnalysis(
            grid=self.grid,
            distributed_slack=self.options.distributed_slack,
            correct_values=self.options.correct_values)
        linear_analysis.run()

        Pbus = self.numerical_circuit.get_injections(False).real[:, 0]
        PTDF = linear_analysis.results.PTDF
        LODF = linear_analysis.results.LODF

        # compute the branch flows in "n"
        flows_n = np.dot(PTDF, Pbus)

        self.progress_text.emit('Computing flows...')
        nl = self.numerical_circuit.nbr
        for c in range(nl):  # branch that fails (contingency)

            # for m in range(nl):  # branch to monitor
            #     results.Sf[m, c] = flows_n[m] + LODF[m, c] * flows_n[c]
            #     results.loading[m, c] = results.Sf[m, c] / (self.numerical_circuit.branch_rates[m] + 1e-9)

            results.Sbranch[:, c] = flows_n[:] + LODF[:, c] * flows_n[c]
            results.loading[:, c] = results.Sbranch[:, c] / (
                self.numerical_circuit.branch_rates + 1e-9)

            results.S[c, :] = Pbus

            self.progress_signal.emit((c + 1) / nl * 100)

        results.otdf = LODF

        return results
コード例 #2
0
    def run(self):
        """
        Run the time series simulation
        @return:
        """
        self.__cancel__ = False
        a = time.time()

        if self.end_ is None:
            self.end_ = len(self.grid.time_profile) + 1
        time_indices = np.arange(self.start_, self.end_)

        ts_numeric_circuit = compile_time_circuit(self.grid)
        self.results = PtdfTimeSeriesResults(
            n=ts_numeric_circuit.nbus,
            m=ts_numeric_circuit.nbr,
            time_array=ts_numeric_circuit.time_array[time_indices],
            bus_names=ts_numeric_circuit.bus_names,
            bus_types=ts_numeric_circuit.bus_types,
            branch_names=ts_numeric_circuit.branch_names)

        self.indices = pd.to_datetime(
            ts_numeric_circuit.time_array[time_indices])

        self.progress_text.emit('Computing PTDF...')
        ptdf_analysis = LinearAnalysis(
            grid=self.grid, distributed_slack=self.options.distribute_slack)
        ptdf_analysis.run()

        self.progress_text.emit('Computing branch flows...')

        Pbus_0 = ts_numeric_circuit.get_power_injections().real[:,
                                                                time_indices]
        self.results.Sbranch = ptdf_analysis.get_branch_time_series(Pbus_0)

        # compute post process
        self.results.loading = self.results.Sbranch / (
            ptdf_analysis.numerical_circuit.branch_rates + 1e-9)
        self.results.S = Pbus_0.T

        self.elapsed = time.time() - a

        # send the finnish signal
        self.progress_signal.emit(0.0)
        self.progress_text.emit('Done!')
        self.done_signal.emit()