VeraGridEngine 5.5.15__tar.gz → 5.5.16__tar.gz

{veragridengine-5.5.15 → veragridengine-5.5.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.5.15
+Version: 5.5.16
 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.5.15 → veragridengine-5.5.16}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -587,7 +587,7 @@ def add_investments(circuit: MultiCircuit,
     d = dict()
 
     for i, elm in enumerate(circuit.investments):
-        investment = convert_investment(elm, groups_dict=groups_dict[elm.group])
+        investment = convert_investment(elm, groups_dict=groups_dict)
         gslv_grid.add_investment(investment)
         d[elm] = investment
 

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Devices/Parents/editable_device.py

@@ -8,7 +8,7 @@ import numpy as np
 
 from VeraGridEngine.Devices.profile import Profile
 from typing import List, Dict, AnyStr, Any, Union, Type, Tuple
-from VeraGridEngine.basic_structures import Logger
+from VeraGridEngine.basic_structures import Logger, IntVec
 from VeraGridEngine.enumerations import (DeviceType, TimeFrame, BuildStatus, WindingsConnection,
                                          TapModuleControl, TapPhaseControl, SubObjectType, ConverterControlType,
                                          HvdcControlType, ActionType, AvailableTransferMode, ContingencyMethod,
@@ -844,6 +844,14 @@ class EditableDevice:
         for magnitude in self.properties_with_profile.keys():
             self.get_profile(magnitude=magnitude).clear()
 
+    def resample_profiles(self, indices: IntVec):
+        """
+        re-sample the object profiles (set all to None)
+        """
+        for magnitude in self.properties_with_profile.keys():
+            prof = self.get_profile(magnitude=magnitude)
+            prof.resample(indices=indices)
+
     def set_profile_values(self, t):
         """
         Set the profile values at t

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Devices/assets.py

@@ -614,6 +614,25 @@ class Assets:
             elm.delete_profiles()
         self.time_profile = None
 
+    def resample_profiles(self, indices: IntVec):
+        """
+        resample the given profiles to the indices
+        :param indices: array of indices to keep
+        """
+        self.time_profile = pd.DatetimeIndex([self.time_profile[i] for i in indices])
+
+        for elm in self.items():
+            elm.resample_profiles(indices=indices)
+
+    def resample_profiles2(self, t0: int, t1: int):
+        """
+        Resample profiles
+        :param t0: first time index
+        :param t1: second time index
+        """
+        indices = np.arange(t0, t1)
+        self.resample_profiles(indices=indices)
+
     # ------------------------------------------------------------------------------------------------------------------
     # Snapshot time
     # ------------------------------------------------------------------------------------------------------------------
@@ -1411,18 +1430,18 @@ class Assets:
         except ValueError:
             print(f"Could not delete {obj.name}")
 
-    def delete_buses(self, lst: Sequence[dev.Bus], delete_associated=False):
+    def delete_branches_with_sets(self, buses_to_remove: Set[dev.Bus], delete_associated: bool = False):
         """
-        Delete a :ref:`Bus<bus>` object from the grid.
-        :param lst: Array of objects to remove
-        :param delete_associated: Delete the associated branches and injections
+        Delete branch objects that may contain contingencies, remedial actions, or investments
+        Used when you delete buses connected to branches
+        :param buses_to_remove: Set of buses to remove
+        :param delete_associated: Delete the associated branches
+        :return: None
         """
-        buses_to_remove = set(lst)
 
         branches_to_delete = list()
-        injections_to_delete = list()
 
-        # delete associated Branches in reverse order
+        # First find branches to delete from the passed buses
         for branch_list in self.get_branch_lists(add_vsc=True, add_hvdc=True, add_switch=True):
             for i in range(len(branch_list) - 1, -1, -1):
                 if branch_list[i].bus_from in buses_to_remove:
@@ -1436,8 +1455,52 @@ class Assets:
                     else:
                         branch_list[i].bus_to = None
 
-        for elm in branches_to_delete:
-            self.delete_branch(obj=elm)
+        # Optimized branch removal by creating a set for faster lookups
+        branches_to_delete_set = set(branches_to_delete)
+        
+        # Remove branches directly from lists in one pass
+        # This is more efficient than calling delete_branch for each
+        for branch_list in self.get_branch_lists(add_vsc=True, add_hvdc=True, add_switch=True):
+            # Use list comprehension to not consider branches to delete 
+            # This is faster than the multiple remove() calls we had before
+            branch_list[:] = [b for b in branch_list if b not in branches_to_delete_set]
+        
+        # Batch process groupings, faster than calling delete_groupings_with_object for each branch
+        if branches_to_delete:
+            branch_idtags = {b.idtag for b in branches_to_delete}  # all idtags to consider
+            
+            # Process contingencies in batch
+            contingencies_to_delete = [elm for elm in self.contingencies if elm.device_idtag in branch_idtags]
+            for elm in contingencies_to_delete:
+                self.delete_contingency(elm, del_group=True)
+            
+            # Process remedial actions in batch
+            remedial_actions_to_delete = [elm for elm in self.remedial_actions if elm.device_idtag in branch_idtags]
+            for elm in remedial_actions_to_delete:
+                self.delete_remedial_action(elm, del_group=True)
+            
+            # Process investments in batch
+            investments_to_delete = [elm for elm in self.investments if elm.device_idtag in branch_idtags]
+            for elm in investments_to_delete:
+                self.delete_investment(elm, del_group=True)
+
+        else:
+            # No branches to delete, so nothing to be done
+            pass
+
+        return None
+
+    def delete_buses(self, lst: Sequence[dev.Bus], delete_associated=False):
+        """
+        Delete a :ref:`Bus<bus>` object from the grid.
+        :param lst: Array of objects to remove
+        :param delete_associated: Delete the associated branches and injections
+        """
+        buses_to_remove = set(lst)
+        injections_to_delete = list()
+
+        # We delete the associated branches by knowing the buses to remove
+        self.delete_branches_with_sets(buses_to_remove, delete_associated)
 
         # delete the associated injection devices
         for inj_list in self.get_injection_devices_lists():
@@ -1448,11 +1511,19 @@ class Assets:
                     else:
                         inj_list[i].bus = None
 
-        for elm in injections_to_delete:
-            self.delete_injection_device(obj=elm)
+        # Optimized batch deletion of injection devices
+        if injections_to_delete:
+            injections_to_delete_set = set(injections_to_delete)
+            for inj_list in self.get_injection_devices_lists():
+                # Use list comprehension to filter out injections we have to delete
+                inj_list[:] = [inj for inj in inj_list if inj not in injections_to_delete_set]
+        else:
+            # No injections to delete, so nothing to be done
+            pass
 
-        # delete the bus itself
-        for elm in buses_to_remove:
+        # delete the bus itself - use set difference for faster removal
+        buses_to_remove_list = list(buses_to_remove)
+        for elm in buses_to_remove_list:
             try:
                 self._buses.remove(elm)
             except ValueError:

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/IO/cim/cgmes/base.py

@@ -168,7 +168,12 @@ class Base:
             hex_string_without_X = hex_string[:-1]  # Remove the last character
         else:
             hex_string_without_X = hex_string  # No 'X', keep the original string
-        return int(hex_string_without_X, 16)  # hex string to int
+
+        try:
+            return int(hex_string_without_X, 16)  # hex string to int
+        except ValueError:
+            # an illegal value like 3c3b5330e94e444e965b688e0d1a88ebLASLACLG makes the previous crash
+            return hash(repr(self))
 
     def __lt__(self, other):
         return self.__hash__() < other.__hash__()

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/Clustering/clustering.py

@@ -27,7 +27,7 @@ def kmeans_sampling(x_input: Mat, n_points: int = 10) -> Tuple[IntVec, Vec, IntV
     model = KMeans(n_clusters=n_points, random_state=0, n_init=10)
 
     # model fitting
-    original_points_cluster_indices = model.fit_predict(x_input)
+    original_points_cluster_indices = model.fit_predict(np.nan_to_num(x_input))
 
     # compute probabilities
     centroids, counts = np.unique(model.labels_, return_counts=True)

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/Clustering/clustering_results.py

@@ -36,9 +36,9 @@ class ClusteringResults(ResultsTemplate):
             study_results_type=StudyResultsType.Clustering
         )
 
-        self.time_indices = time_indices
-        self.sampled_probabilities = sampled_probabilities
-        self.original_sample_idx = original_sample_idx
+        self.time_indices: IntVec = time_indices
+        self.sampled_probabilities: Vec = sampled_probabilities
+        self.original_sample_idx: IntVec = original_sample_idx
 
         self.register(name='time_indices', tpe=IntVec)
         self.register(name='sampled_probabilities', tpe=Vec)

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/helm_contingencies.py

@@ -5,7 +5,7 @@
 import numpy as np
 import scipy as sp
 
-from typing import List
+from typing import List, Tuple
 from VeraGridEngine.basic_structures import IntVec, CxVec
 from VeraGridEngine.DataStructures.numerical_circuit import NumericalCircuit
 from VeraGridEngine.Topology.admittance_matrices import compute_admittances
@@ -17,6 +17,7 @@ from VeraGridEngine.Simulations.PowerFlow.NumericalMethods.helm_power_flow impor
 def calc_V_outage(nc: NumericalCircuit,
                   If: CxVec,
                   Ybus: sp.sparse.csc_matrix,
+                  Yf: sp.sparse.csc_matrix,
                   sys_mat_factorization,
                   V0: CxVec,
                   S0: CxVec,
@@ -40,6 +41,7 @@ def calc_V_outage(nc: NumericalCircuit,
     :param nc: NumericalCircuit instance
     :param If: from currents of the initial power flow
     :param Ybus: original admittance matrix
+
     :param sys_mat_factorization:
     :param V0: initial voltage array
     :param S0: vector of powers
@@ -64,24 +66,26 @@ def calc_V_outage(nc: NumericalCircuit,
     #     npqpv, n = helm_preparation_dY(Yseries=Yseries, V0=V0, S0=S0,
     #                                    Ysh0=Ysh0, pq=pq, pv=pv, sl=vd, pqpv=pqpv)
 
+    conn = nc.get_connectivity_matrices()
+
     # compute the admittance of the contingency branches
-    adm = compute_admittances(R=nc.passive_branch_data.R[contingency_br_indices],
-                              X=nc.passive_branch_data.X[contingency_br_indices],
-                              G=nc.passive_branch_data.G[contingency_br_indices],
-                              B=nc.passive_branch_data.B[contingency_br_indices],
-                              tap_module=nc.active_branch_data.tap_module[contingency_br_indices],
-                              vtap_f=nc.passive_branch_data.virtual_tap_f[contingency_br_indices],
-                              vtap_t=nc.passive_branch_data.virtual_tap_t[contingency_br_indices],
-                              tap_angle=nc.active_branch_data.tap_angle[contingency_br_indices],
-                              Cf=nc.passive_branch_data.Cf[contingency_br_indices, :],
-                              Ct=nc.passive_branch_data.Ct[contingency_br_indices, :],
-                              Yshunt_bus=np.zeros(nc.nbus, dtype=complex),
-                              conn=nc.passive_branch_data.conn[contingency_br_indices],
-                              seq=1,
-                              add_windings_phase=False)
+    con_adm = compute_admittances(R=nc.passive_branch_data.R[contingency_br_indices],
+                                  X=nc.passive_branch_data.X[contingency_br_indices],
+                                  G=nc.passive_branch_data.G[contingency_br_indices],
+                                  B=nc.passive_branch_data.B[contingency_br_indices],
+                                  tap_module=nc.active_branch_data.tap_module[contingency_br_indices],
+                                  vtap_f=nc.passive_branch_data.virtual_tap_f[contingency_br_indices],
+                                  vtap_t=nc.passive_branch_data.virtual_tap_t[contingency_br_indices],
+                                  tap_angle=nc.active_branch_data.tap_angle[contingency_br_indices],
+                                  Cf=conn.Cf[contingency_br_indices, :],
+                                  Ct=conn.Ct[contingency_br_indices, :],
+                                  Yshunt_bus=np.zeros(nc.nbus, dtype=complex),
+                                  conn=nc.passive_branch_data.conn[contingency_br_indices],
+                                  seq=1,
+                                  add_windings_phase=False)
 
     # solve the modified HELM
-    _, V, _, norm_f = helm_coefficients_dY(dY=adm.Ybus,
+    _, V, _, norm_f = helm_coefficients_dY(dY=con_adm.Ybus,
                                            sys_mat_factorization=sys_mat_factorization,
                                            Uini=Uini,
                                            Xini=Xini,
@@ -104,7 +108,7 @@ def calc_V_outage(nc: NumericalCircuit,
                                            max_coeff=10)
 
     # compute flows
-    Sf = (nc.passive_branch_data.Cf * V) * np.conj(adm.Yf * V) * nc.Sbase
+    Sf = V[nc.passive_branch_data.F] * np.conj(Yf @ V) * nc.Sbase
 
     # compute contingency loading
     loading = Sf / (nc.passive_branch_data.rates + 1e-9)
@@ -168,11 +172,11 @@ class HelmVariations:
 
                     self.preparations.append(helm_prep)
 
-    def compute_variations(self, contingency_br_indices):
+    def compute_variations(self, contingency_br_indices: IntVec) -> Tuple[CxVec, CxVec, CxVec]:
         """
-
-        :param contingency_br_indices:
-        :return:
+        Compute a branch contingency
+        :param contingency_br_indices: array of branch indices to fail
+        :return: V, Sf, loading
         """
         n_br = self.numerical_circuit.nbr
         n_bus = self.numerical_circuit.nbus
@@ -191,32 +195,36 @@ class HelmVariations:
                     contingency_br_indices_is = list()
                     for c in contingency_br_indices:
                         ci = branch_index_mapping.get(c, None)
-                        if ci:
+                        if ci is not None:
                             contingency_br_indices_is.append(ci)
+                    contingency_br_indices_is = np.array(contingency_br_indices_is, dtype=int)
 
                     pre = self.preparations[n_island]
                     adm = island.get_admittance_matrices()
                     Sbus = island.get_power_injections_pu()
 
-                    V_isl, Sf_isl, loading_isl, err = calc_V_outage(nc=island,
-                                                                    If=np.zeros(island.nbr, dtype=complex),
-                                                                    Ybus=adm.Ybus,
-                                                                    sys_mat_factorization=pre.sys_mat_factorization,
-                                                                    V0=island.bus_data.Vbus,
-                                                                    S0=Sbus,
-                                                                    Uini=pre.Uini,
-                                                                    Xini=pre.Xini,
-                                                                    Yslack=pre.Yslack,
-                                                                    Vslack=pre.Vslack,
-                                                                    vec_P=pre.vec_P,
-                                                                    vec_Q=pre.vec_Q,
-                                                                    Ysh=pre.Ysh,
-                                                                    vec_W=pre.vec_W,
-                                                                    pq=pre.pq,
-                                                                    pv=pre.pv,
-                                                                    vd=pre.sl,
-                                                                    pqpv=pre.pqpv,
-                                                                    contingency_br_indices=contingency_br_indices_is)
+                    V_isl, Sf_isl, loading_isl, err = calc_V_outage(
+                        nc=island,
+                        If=np.zeros(island.nbr, dtype=complex),
+                        Ybus=adm.Ybus,
+                        Yf=adm.Yf,
+                        sys_mat_factorization=pre.sys_mat_factorization,
+                        V0=island.bus_data.Vbus,
+                        S0=Sbus,
+                        Uini=pre.Uini,
+                        Xini=pre.Xini,
+                        Yslack=pre.Yslack,
+                        Vslack=pre.Vslack,
+                        vec_P=pre.vec_P,
+                        vec_Q=pre.vec_Q,
+                        Ysh=pre.Ysh,
+                        vec_W=pre.vec_W,
+                        pq=pre.pq,
+                        pv=pre.pv,
+                        vd=pre.sl,
+                        pqpv=pre.pqpv,
+                        contingency_br_indices=contingency_br_indices_is
+                    )
 
                     # assign objects to the full matrix
                     V[island.bus_data.original_idx] = V_isl

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/helm_contingency_analysis.py

@@ -12,6 +12,7 @@ from VeraGridEngine.Simulations.ContingencyAnalysis.Methods.helm_contingencies i
 from VeraGridEngine.Simulations.PowerFlow.power_flow_worker import multi_island_pf_nc
 from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions, SolverType
 from VeraGridEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
+from VeraGridEngine.enumerations import ContingencyOperationTypes
 
 
 def helm_contingency_analysis(grid: MultiCircuit,
@@ -30,7 +31,7 @@ def helm_contingency_analysis(grid: MultiCircuit,
     """
 
     # set the numerical circuit
-    numerical_circuit = compile_numerical_circuit_at(grid, t_idx=t)
+    nc = compile_numerical_circuit_at(grid, t_idx=t)
 
     if options.pf_options is None:
         pf_opts = PowerFlowOptions(solver_type=SolverType.Linear,
@@ -41,30 +42,32 @@ def helm_contingency_analysis(grid: MultiCircuit,
 
     # declare the results
     results = ContingencyAnalysisResults(ncon=len(grid.contingency_groups),
-                                         nbr=numerical_circuit.nbr,
-                                         nbus=numerical_circuit.nbus,
-                                         branch_names=numerical_circuit.branch_names,
-                                         bus_names=numerical_circuit.bus_names,
-                                         bus_types=numerical_circuit.bus_types,
+                                         nbr=nc.nbr,
+                                         nbus=nc.nbus,
+                                         branch_names=nc.passive_branch_data.names,
+                                         bus_names=nc.bus_data.names,
+                                         bus_types=nc.bus_data.bus_types,
                                          con_names=grid.get_contingency_group_names())
 
     # get contingency groups dictionary
     cg_dict = grid.get_contingency_group_dict()
 
     branches_dict = grid.get_branches_dict(add_vsc=False, add_hvdc=False, add_switch=True)
-    calc_branches = grid.get_branches(add_hvdc=False, add_vsc=False, add_switch=True)
-    mon_idx = numerical_circuit.passive_branch_data.get_monitor_enabled_indices()
+    # calc_branches = grid.get_branches(add_hvdc=False, add_vsc=False, add_switch=True)
+    mon_idx = nc.passive_branch_data.get_monitor_enabled_indices()
 
     # keep the original states
-    original_br_active = numerical_circuit.passive_branch_data.active.copy()
-    original_gen_active = numerical_circuit.generator_data.active.copy()
-    original_gen_p = numerical_circuit.generator_data.p.copy()
+    original_br_active = nc.passive_branch_data.active.copy()
+    original_gen_active = nc.generator_data.active.copy()
+    original_gen_p = nc.generator_data.p.copy()
 
     # run 0
-    pf_res_0 = multi_island_pf_nc(nc=numerical_circuit,
+    pf_res_0 = multi_island_pf_nc(nc=nc,
                                   options=pf_opts)
 
-    helm_variations = HelmVariations(numerical_circuit=numerical_circuit)
+    helm_variations = HelmVariations(numerical_circuit=nc)
+
+    Sbus = nc.get_power_injections_pu()
 
     # for each contingency group
     for ic, contingency_group in enumerate(grid.contingency_groups):
@@ -77,15 +80,14 @@ def helm_contingency_analysis(grid: MultiCircuit,
         for cnt in contingencies:
 
             # search for the contingency in the Branches
-            if cnt.device_idtag in branches_dict:
-                br_idx = branches_dict[cnt.device_idtag]
-
-                if cnt.prop == 'active':
+            br_idx = branches_dict.get(cnt.device_idtag, None)
+            if br_idx is not None:
+                if cnt.prop == ContingencyOperationTypes.Active:
                     contingency_br_indices.append(br_idx)
                 else:
                     print(f'Unknown contingency property {cnt.prop} at {cnt.name} {cnt.idtag}')
             else:
-                pass
+                print(f"Contingency device not found in branches: {cnt.device_idtag}")
 
         # report progress
         if t is None:
@@ -94,29 +96,32 @@ def helm_contingency_analysis(grid: MultiCircuit,
                 calling_class.report_progress2(ic, len(grid.contingency_groups) * 100)
 
         # run
-        V, Sf, loading = helm_variations.compute_variations(contingency_br_indices=contingency_br_indices)
+        V, Sf, loading = helm_variations.compute_variations(
+            contingency_br_indices=np.array(contingency_br_indices)
+        )
 
         results.Sf[ic, :] = Sf
-        results.Sbus[ic, :] = numerical_circuit.Sbus
+        results.Sbus[ic, :] = Sbus
         results.loading[ic, :] = loading
         results.report.analyze(t=t,
                                t_prob=t_prob,
                                mon_idx=mon_idx,
-                               nc=numerical_circuit,
+                               nc=nc,
                                base_flow=np.abs(pf_res_0.Sf),
                                base_loading=np.abs(pf_res_0.loading),
                                contingency_flows=np.abs(Sf),
                                contingency_loadings=np.abs(loading),
                                contingency_idx=ic,
-                               contingency_group=contingency_group)
+                               contingency_group=contingency_group,
+                               srap_ratings=nc.passive_branch_data.protection_rates,)
 
         # revert the states for the next run
-        numerical_circuit.passive_branch_data.active = original_br_active.copy()
-        numerical_circuit.generator_data.active = original_gen_active.copy()
-        numerical_circuit.generator_data.p = original_gen_p.copy()
+        nc.passive_branch_data.active = original_br_active.copy()
+        nc.generator_data.active = original_gen_active.copy()
+        nc.generator_data.p = original_gen_p.copy()
 
         if calling_class is not None:
-            if calling_class.is_cancelled():
+            if calling_class.is_cancel():
                 return results
 
     return results

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/linear_contingency_analysis.py

@@ -48,13 +48,15 @@ def linear_contingency_analysis(nc: NumericalCircuit,
         report_text('Analyzing outage distribution factors in a non-linear fashion...')
 
     # declare the results
-    results = ContingencyAnalysisResults(ncon=len(linear_multiple_contingencies.contingency_groups_used),
-                                         nbr=nc.nbr,
-                                         nbus=nc.nbus,
-                                         branch_names=nc.passive_branch_data.names,
-                                         bus_names=nc.bus_data.names,
-                                         bus_types=nc.bus_data.bus_types,
-                                         con_names=linear_multiple_contingencies.get_contingency_group_names())
+    results = ContingencyAnalysisResults(
+        ncon=len(linear_multiple_contingencies.contingency_groups_used),
+        nbr=nc.nbr,
+        nbus=nc.nbus,
+        branch_names=nc.passive_branch_data.names,
+        bus_names=nc.bus_data.names,
+        bus_types=nc.bus_data.bus_types,
+        con_names=np.array(linear_multiple_contingencies.get_contingency_group_names())
+    )
 
     linear_analysis = LinearAnalysis(nc=nc,
                                      distributed_slack=options.lin_options.distribute_slack,
@@ -93,6 +95,7 @@ def linear_contingency_analysis(nc: NumericalCircuit,
             if multi_contingency.has_injection_contingencies():
                 contingency_group = linear_multiple_contingencies.contingency_groups_used[ic]
                 contingencies = linear_multiple_contingencies.contingency_group_dict[contingency_group.idtag]
+                linear_multiple_contingencies.get_single_con_branch_idx()
                 # injections = nc.set_linear_con_or_ra_status(event_list=contingencies)
                 injections = nc.set_con_or_ra_status(event_list=contingencies)
             else:
@@ -201,4 +204,3 @@ def linear_contingency_scan_numba(nbr: int, n_con_groups: int,
             problems.append((m, -1))
 
     return SbrCon, LoadingCon, problems
-

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/ContingencyAnalysis/contingencies_report.py

@@ -548,12 +548,17 @@ class ContingencyResultsReport:
         if contingency_idx == 0:  # only doing it once per hour
 
             for m in mon_idx:
-                if len(area_names):
-                    area_from = area_names[bus_area_indices[F[m]]]
-                    area_to = area_names[bus_area_indices[T[m]]]
-                else:
+
+                if area_names is None:
                     area_from = ""
                     area_to = ""
+                else:
+                    if len(area_names):
+                        area_from = area_names[bus_area_indices[F[m]]]
+                        area_to = area_names[bus_area_indices[T[m]]]
+                    else:
+                        area_from = ""
+                        area_to = ""
 
                 if abs(base_flow[m]) > nc.passive_branch_data.rates[m]:  # only add if overloaded
 
@@ -577,15 +582,19 @@ class ContingencyResultsReport:
                              srap_power=0.0,
                              solved_by_srap=False)
 
-        # Now evalueting the effect of contingencies
+        # Now evaluating the effect of contingencies
         for m in mon_idx:  # for each monitored branch ...
 
-            if len(area_names):
-                area_from = area_names[bus_area_indices[F[m]]]
-                area_to = area_names[bus_area_indices[T[m]]]
-            else:
+            if area_names is None:
                 area_from = ""
                 area_to = ""
+            else:
+                if len(area_names):
+                    area_from = area_names[bus_area_indices[F[m]]]
+                    area_to = area_names[bus_area_indices[T[m]]]
+                else:
+                    area_from = ""
+                    area_to = ""
 
             c_flow = abs(contingency_flows[m])
             b_flow = abs(base_flow[m])

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/ContingencyAnalysis/contingency_analysis_driver.py

@@ -122,7 +122,7 @@ class ContingencyAnalysisDriver(DriverTemplate):
                     options=self.options,
                     linear_multiple_contingencies=self.linear_multiple_contingencies,
                     area_names=area_names,
-                    bus_area_indices=bus_area_indices,
+                    bus_area_indices=np.array(bus_area_indices, dtype=int),
                     F=F,
                     T=T,
                     report_text=self.report_text,
@@ -145,7 +145,7 @@ class ContingencyAnalysisDriver(DriverTemplate):
                     options=self.options,
                     linear_multiple_contingencies=self.linear_multiple_contingencies,
                     area_names=area_names,
-                    bus_area_indices=bus_area_indices,
+                    bus_area_indices=np.array(bus_area_indices, dtype=int),
                     F=F,
                     T=T,
                     report_text=self.report_text,
@@ -164,6 +164,7 @@ class ContingencyAnalysisDriver(DriverTemplate):
                     t=t_idx,
                     t_prob=t_prob
                 )
+
             elif self.options.contingency_method == ContingencyMethod.OptimalPowerFlow:
                 self.results = optimal_linear_contingency_analysis(
                     grid=self.grid,

{veragridengine-5.5.15 → veragridengine-5.5.16}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -14,7 +14,7 @@ from scipy.sparse import lil_matrix
 from scipy.sparse.linalg import spsolve as scipy_spsolve
 
 from VeraGridEngine.enumerations import DeviceType
-from VeraGridEngine.basic_structures import Logger, Vec, IntVec, CxVec, Mat, ObjVec, CxMat, BoolVec, IntMat
+from VeraGridEngine.basic_structures import Logger, Vec, IntVec, CxVec, Mat, ObjVec, CxMat, BoolVec, IntMat, Vector
 from VeraGridEngine.DataStructures.numerical_circuit import NumericalCircuit
 from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_at
 from VeraGridEngine.Devices.Aggregation.contingency_group import ContingencyGroup
@@ -740,6 +740,8 @@ class ContingencyIndices:
         :param contingency_group: ContingencyGroup
         :param contingency_group_dict: dictionary to get the list of contingencies matching a contingency group
         :param branches_dict: dictionary to get the branch index by the branch idtag
+        :param hvdc_dict: dictionary to get the HvdcLine index by the branch idtag
+        :param vsc_dict: dictionary to get the Vsc index by the branch idtag
         :param injections_bus_index_dict: dictionary to get the injection device bus index by the generator idtag
         """
 
@@ -829,19 +831,17 @@ class LinearMultiContingencies:
         self.__vsc_dict = grid.get_vsc_index_dict()
         self.__injections_bus_index_dict = grid.get_injections_bus_index_dict(bus_index_dict=bus_index_dict)
 
-        self.contingency_indices_list = list()
+        self.contingency_indices_list = Vector(len(self.contingency_groups_used))
 
         # for each contingency group
         for ic, contingency_group in enumerate(self.contingency_groups_used):
-            self.contingency_indices_list.append(
-                ContingencyIndices(
-                    contingency_group=contingency_group,
-                    contingency_group_dict=self.__contingency_group_dict,
-                    branches_dict=self.__branches_dict,
-                    hvdc_dict=self.__hvdc_dict,
-                    vsc_dict=self.__vsc_dict,
-                    injections_bus_index_dict=self.__injections_bus_index_dict
-                )
+            self.contingency_indices_list[ic] = ContingencyIndices(
+                contingency_group=contingency_group,
+                contingency_group_dict=self.__contingency_group_dict,
+                branches_dict=self.__branches_dict,
+                hvdc_dict=self.__hvdc_dict,
+                vsc_dict=self.__vsc_dict,
+                injections_bus_index_dict=self.__injections_bus_index_dict
             )
 
         # list of LinearMultiContingency objects that are used later to compute the contingency flows
@@ -992,7 +992,7 @@ class LinearMultiContingencies:
 
     def get_single_con_branch_idx(self) -> Tuple[IntVec, IntVec]:
         """
-        Get the branch index array and the contringency group it belongs array
+        Get the branch index array and the contingency group it belongs array
         :return: array of single contingency branch indices,
                  array of the matching contingency groups
         """