VeraGridEngine 5.4.8__tar.gz → 5.4.9__tar.gz

{veragridengine-5.4.8 → veragridengine-5.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.8
+Version: 5.4.9
 Summary: VeraGrid is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/VeraGrid
 Author: Santiago Peñate Vera et. Al.

{veragridengine-5.4.8 → veragridengine-5.4.9}/VeraGridEngine/Simulations/ATC/available_transfer_capacity_ts_driver.py

@@ -13,14 +13,16 @@ from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_a
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis_options import LinearAnalysisOptions
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis_ts_driver import LinearAnalysisTimeSeriesDriver
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis
-from VeraGridEngine.Simulations.ATC.available_transfer_capacity_driver import compute_atc_list, compute_alpha, compute_dP
+from VeraGridEngine.Simulations.ATC.available_transfer_capacity_driver import compute_atc_list, compute_alpha, \
+    compute_dP
 from VeraGridEngine.Simulations.ATC.available_transfer_capacity_options import AvailableTransferCapacityOptions
 from VeraGridEngine.Simulations.results_table import ResultsTable
 from VeraGridEngine.Simulations.results_template import ResultsTemplate
 from VeraGridEngine.Simulations.driver_template import TimeSeriesDriverTemplate
 from VeraGridEngine.Simulations.Clustering.clustering_results import ClusteringResults
 from VeraGridEngine.basic_structures import Vec, Mat, IntVec, StrVec, DateVec
-from VeraGridEngine.enumerations import StudyResultsType, AvailableTransferMode, ResultTypes, DeviceType, SimulationTypes
+from VeraGridEngine.enumerations import StudyResultsType, AvailableTransferMode, ResultTypes, DeviceType, \
+    SimulationTypes
 
 
 class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
@@ -29,7 +31,7 @@ class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
     """
 
     def __init__(self, br_names: StrVec, bus_names: StrVec, rates: Mat, contingency_rates: Mat, time_array: DateVec,
-                 clustering_results):
+                 clustering_results: Union[ClusteringResults, None] = None):
         """
 
         :param br_names:
@@ -104,8 +106,12 @@ class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
             m = rep[:, 1].astype(int)
             c = rep[:, 2].astype(int)
 
-            # time
-            self.report[:, 0] = self.time_array[t].strftime('%d/%m/%Y %H:%M').values
+            time_dict = {ti: t for ti, t in zip(self.time_indices, self.time_array)}
+
+            for i in range(self.report.shape[0]):
+                self.report[i, 0] = time_dict[t[i]].strftime('%d/%m/%Y %H:%M')
+                self.report[i, 3] = self.rates[t[i], m[i]]  # 'Rate', (time, branch)
+                self.report[i, 8] = self.contingency_rates[t[i], m[i]]
 
             # Branch name
             self.report[:, 1] = self.branch_names[m]
@@ -113,9 +119,6 @@ class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
             # Base flow'
             self.report[:, 2] = rep[:, 10]
 
-            # rate
-            self.report[:, 3] = self.rates[t, m]  # 'Rate', (time, branch)
-
             # alpha
             self.report[:, 4] = rep[:, 3]
 
@@ -130,9 +133,6 @@ class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
             # 'Limiting contingency flow'
             self.report[:, 7] = rep[:, 11]
 
-            # 'Contingency rate' (time, branch)
-            self.report[:, 8] = self.contingency_rates[t, m]
-
             # 'Beta'
             self.report[:, 9] = rep[:, 4]
 
@@ -149,8 +149,13 @@ class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
             self.report[:, 13] = rep[:, 9]
 
             # trim by abs alpha > threshold and loading <= 1
-            loading = np.abs(self.report[:, 2] / (self.report[:, 3] + 1e-20))
-            idx = np.where((np.abs(self.report[:, 4]) > threshold) & (loading <= 1.0))[0]
+            # loading = np.abs(self.report[:, 2] / (self.report[:, 3] + 1e-20))
+            idx = list()
+            for i in range(self.report.shape[0]):
+                if (abs(self.report[i, 4]) > threshold
+                        and abs(self.report[i, 2] / (self.report[i, 3] + 1e-20)) <= 1.0):
+                    idx.append(i)
+            idx = np.array(idx, dtype=int)
 
             self.report = self.report[idx, :]
 
@@ -164,7 +169,7 @@ class AvailableTransferCapacityTimeSeriesResults(ResultsTemplate):
         :return: dictionary of 2D numpy arrays (probably of complex numbers)
         """
         data = super().get_dict()
-        data['report'] =  self.report.tolist()
+        data['report'] = self.report.tolist()
         return data
 
     def mdl(self, result_type: ResultTypes) -> ResultsTable:
@@ -230,7 +235,7 @@ class AvailableTransferCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
         """
         Get time steps list of strings
         """
-
+        # No time steps because so far the only output is a report
         return []
 
     def run(self) -> None:
@@ -259,6 +264,8 @@ class AvailableTransferCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
             time_indices=self.time_indices
         )
 
+        la_driver.copy_signals(other=self)
+
         la_driver.run()
 
         # get the branch indices to analyze
@@ -318,8 +325,8 @@ class AvailableTransferCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
             # consider the HVDC transfer
             if self.options.Pf_hvdc is not None:
                 if len(self.options.idx_hvdc_br):
-                    base_exchange += (self.options.inter_area_hvdc_branch_sense * self.options.Pf_hvdc[
-                        t, self.options.idx_hvdc_br]).sum()
+                    base_exchange += (self.options.inter_area_hvdc_branch_sense
+                                      * self.options.Pf_hvdc[t, self.options.idx_hvdc_br]).sum()
 
             # compute ATC
             report = compute_atc_list(br_idx=br_idx,
@@ -348,7 +355,7 @@ class AvailableTransferCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
             else:
                 self.results.raw_report = np.r_[self.results.raw_report, report]
 
-            self.report_progress2(t, len(self.time_indices))
+            self.report_progress2(it, len(self.time_indices))
 
             if self.__cancel__:
                 break

{veragridengine-5.4.8 → veragridengine-5.4.9}/VeraGridEngine/Simulations/StateEstimation/state_estimation.py

@@ -144,7 +144,7 @@ def Jacobian_SE(Ybus: csc_matrix, Yf: csc_matrix, Yt: csc_matrix, V: CxVec,
 
 
 def get_measurements_and_deviations(se_input: StateEstimationInput, Sbase: float,
-                                    use_current_squared_meas:bool = True)-> Tuple[Vec, Vec, ObjVec]:
+                                    use_current_squared_meas: bool = True) -> Tuple[Vec, Vec, ObjVec]:
     """
     get_measurements_and_deviations the measurements into "measurements" and "sigma"
     ordering: Pinj, Pflow, Qinj, Qflow, Iflow, Vm
@@ -173,6 +173,7 @@ def get_measurements_and_deviations(se_input: StateEstimationInput, Sbase: float
             sigma[k] = m.get_standard_deviation_pu(Sbase)
             measurements[k] = m
             k += 1
+
     if not use_current_squared_meas:
         for lst in [se_input.if_value, se_input.it_value]:
             for m in lst:
@@ -672,7 +673,7 @@ def solve_se_nr(nc: NumericalCircuit,
         gx = HtW @ dz
 
         # Solve the increment
-        dx = spsolve(Gx, gx) # (HtW @ dz) * (new_state) = HtW @ H
+        dx = spsolve(Gx, gx)  # (HtW @ dz) * (new_state) = HtW @ H
 
         # modify the solution
         if fixed_slack:
@@ -817,6 +818,7 @@ def solve_se_nr(nc: NumericalCircuit,
                                          is_observable=bool(converged),
                                          bad_data_detected=bad_data_detected)
 
+
 def solve_se_gauss_newton(nc: NumericalCircuit,
                           Ybus: CscMat,
                           Yf: CscMat,
@@ -857,7 +859,8 @@ def solve_se_gauss_newton(nc: NumericalCircuit,
     load_per_bus = nc.load_data.get_injections_per_bus() / nc.Sbase
 
     # Get measurements
-    z, sigma, measurements = get_measurements_and_deviations(se_input=se_input, Sbase=nc.Sbase, use_current_squared_meas=True)
+    z, sigma, measurements = get_measurements_and_deviations(se_input=se_input, Sbase=nc.Sbase,
+                                                             use_current_squared_meas=True)
     # Weight matrix with regularization to avoid numerical issues
     sigma2 = np.power(sigma, 2.0)
     W_vec = 1.0 / np.maximum(sigma2, 1e-10)  # Avoid division by zero
@@ -871,7 +874,7 @@ def solve_se_gauss_newton(nc: NumericalCircuit,
     # Step control parameters
     max_step_va = 0.3  # radians
     max_step_vm = 0.2  # per unit
-    relaxation = 1.1   # initial step relaxation
+    relaxation = 1.1  # initial step relaxation
     obj_val_prev = 1e30
 
     while not converged and iter_ < max_iter:
@@ -897,7 +900,7 @@ def solve_se_gauss_newton(nc: NumericalCircuit,
         except:
             # If matrix is singular, use pseudo-inverse
             dx = spilu(G).solve(g)
-        #Update state
+        # Update state
         if fixed_slack:
             dVa = dx[:n_no_slack]
             dVm = dx[n_no_slack:]
@@ -1005,25 +1008,25 @@ def solve_se_gauss_newton(nc: NumericalCircuit,
 
 
 def decoupled_state_estimation(nc: NumericalCircuit,
-                          Ybus: CscMat,
-                          Yf: CscMat,
-                          Yt: CscMat,
-                          Yshunt_bus: CxVec,
-                          F: IntVec,
-                          T: IntVec,
-                          Cf: csc_matrix,
-                          Ct: csc_matrix,
-                          se_input: StateEstimationInput,
-                          vd: IntVec,
-                          pv: IntVec,
-                          no_slack: IntVec,
-                          tol=1e-9,
-                          max_iter=100,
-                          verbose: int = 0,
-                          c_threshold: float = 4.0,
-                          prefer_correct: bool = False,
-                          fixed_slack: bool = False,
-                          logger: Logger | None = None) -> NumericStateEstimationResults:
+                               Ybus: CscMat,
+                               Yf: CscMat,
+                               Yt: CscMat,
+                               Yshunt_bus: CxVec,
+                               F: IntVec,
+                               T: IntVec,
+                               Cf: csc_matrix,
+                               Ct: csc_matrix,
+                               se_input: StateEstimationInput,
+                               vd: IntVec,
+                               pv: IntVec,
+                               no_slack: IntVec,
+                               tol=1e-9,
+                               max_iter=100,
+                               verbose: int = 0,
+                               c_threshold: float = 4.0,
+                               prefer_correct: bool = False,
+                               fixed_slack: bool = False,
+                               logger: Logger | None = None) -> NumericStateEstimationResults:
     """
     Fast decoupled WLS state estimator using LU decomposition.
     Active power -> angles
@@ -1047,7 +1050,6 @@ def decoupled_state_estimation(nc: NumericalCircuit,
                                                              use_current_squared_meas=False)
     W = diags(1.0 / sigma ** 2, 0, format="csc")
 
-
     # --- Create measurement type mapping based on processing order ---
     # The measurements are processed in this fixed order:
     # 1. p_inj, 2. q_inj, 3. pg_inj, 4. qg_inj,
@@ -1110,11 +1112,11 @@ def decoupled_state_estimation(nc: NumericalCircuit,
         Wa = W[a_idx, :][:, a_idx].tocsc()
         Ga = Ha.T @ Wa @ Ha
         if Ga.shape[0] > 0:
-            #Ga_reg = Ga + eps_base * np.diag(np.max(np.abs(Ga), axis=0))
+            # Ga_reg = Ga + eps_base * np.diag(np.max(np.abs(Ga), axis=0))
             Ga = Ga + reg_eps * diags(np.ones(Ga.shape[0]), 0, format='csc')
 
         # --- 3) Compute Ta
-        Ta = Ha.T @ Wa @ dz[a_idx]/1
+        Ta = Ha.T @ Wa @ dz[a_idx] / 1
         # --- 4) Solve Ga * dtheta = Ta
         try:
             lu_ga = splu(Ga)
@@ -1138,7 +1140,7 @@ def decoupled_state_estimation(nc: NumericalCircuit,
         Wr = W[r_idx, :][:, r_idx].tocsc()
         Gr = Hr.T @ Wr @ Hr
         if Gr.shape[0] > 0:
-            #Gr_reg = Gr + eps_base * np.diag(np.max(np.abs(Gr), axis=0))
+            # Gr_reg = Gr + eps_base * np.diag(np.max(np.abs(Gr), axis=0))
             Gr = Gr + reg_eps_v * diags(np.ones(Gr.shape[0]), 0, format='csc')
 
         # --- 7) Compute Tr and solve Gr * dV = Tr
@@ -1173,7 +1175,7 @@ def decoupled_state_estimation(nc: NumericalCircuit,
 
         previous_max_update = norm_f
 
-        if norm_f < tol*100: # decoupled solution checks for both active & reactive parts against tolerance,
+        if norm_f < tol * 100:  # decoupled solution checks for both active & reactive parts against tolerance,
             # so its a bit lower, but it also provides same(very) result for all tests with more stricter tol
             converged = True
             if verbose > 0:
@@ -1209,5 +1211,5 @@ def decoupled_state_estimation(nc: NumericalCircuit,
                                          converged=bool(converged),
                                          iterations=iter_count,
                                          elapsed=time.time() - start_time,
-                                         is_observable=bool(converged), # by default it is observable if it converges
-                                         bad_data_detected=False)
+                                         is_observable=bool(converged),  # by default it is observable if it converges
+                                         bad_data_detected=False)

{veragridengine-5.4.8 → veragridengine-5.4.9}/VeraGridEngine/Simulations/driver_template.py

@@ -106,6 +106,16 @@ class DriverTemplate:
         """
         pass
 
+    def copy_signals(self, other: "TimeSeriesDriverTemplate"):
+        """
+        Copy the signals from another driver
+        :param other:
+        :return:
+        """
+        self.progress_signal = other.progress_signal
+        self.progress_text = other.progress_text
+        self.done_signal = other.done_signal
+
     def report_progress(self, val: float):
         """
         Report progress

{veragridengine-5.4.8 → veragridengine-5.4.9}/VeraGridEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # remember to keep a three-number version!!!
-__VeraGridEngine_VERSION__ = "5.4.8"
+__VeraGridEngine_VERSION__ = "5.4.9"
 
 url = 'https://github.com/SanPen/VeraGrid'