VeraGridEngine 5.6.2__tar.gz → 5.6.4__tar.gz

{veragridengine-5.6.2 → veragridengine-5.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.2
+Version: 5.6.4
 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.6.2 → veragridengine-5.6.4}/VeraGridEngine/Devices/assets.py

@@ -1577,17 +1577,33 @@ class Assets:
         buses_to_remove_set = buses_to_remove
         self._buses = ListSet([b for b in self._buses if b not in buses_to_remove_set])
 
-    def get_buses_by(self, filter_elements: List[Union[dev.Area, dev.Country, dev.Zone]]) -> List[dev.Bus]:
+    def get_buses_by(self, filter_elements: List[Union[dev.Area, dev.Zone,
+    dev.Country, dev.Community,
+    dev.Region, dev.Municipality]]) -> List[dev.Bus]:
         """
         Get a list of buses that can be found in the list of Areas | Zones | Countries
         :param filter_elements: list of Areas | Zones | Countries
         :return: list of buses
         """
         data: List[dev.Bus] = list()
+        filter_elements_set = set(filter_elements)
 
         for bus in self._buses:
 
-            if bus.area in filter_elements or bus.zone in filter_elements or bus.country in filter_elements:
+            ok = bus.area in filter_elements_set
+            ok = ok or bus.zone in filter_elements_set
+            ok = ok or bus.country in filter_elements_set
+
+            if bus.substation is not None:
+                ok = ok or bus.substation.municipality in filter_elements_set
+
+                if bus.substation.municipality is not None:
+                    ok = ok or bus.substation.municipality.region in filter_elements_set
+
+                    if bus.substation.municipality.region is not None:
+                        ok = ok or bus.substation.municipality.region.community in filter_elements_set
+
+            if ok:
                 data.append(bus)
 
         return data
@@ -4136,7 +4152,8 @@ class Assets:
         return logger
 
     def get_contingency_groups_in(self,
-                                  grouping_elements: List[Union[dev.Area, dev.Country, dev.Zone]]
+                                  grouping_elements: List[Union[dev.Area, dev.Zone,
+                                  dev.Country, dev.Community, dev.Region, dev.Municipality]]
                                   ) -> List[dev.ContingencyGroup]:
         """
         Get a filtered set of ContingencyGroups

{veragridengine-5.6.2 → veragridengine-5.6.4}/VeraGridEngine/Devices/multi_circuit.py

@@ -1617,6 +1617,42 @@ class MultiCircuit(Assets):
 
         return lst
 
+    def get_substations_set_from_grouping(self, selected_objects: List[ALL_DEV_TYPES]) -> Set[dev.Substation]:
+        """
+        Get substation from place
+        :param selected_objects: Regions, Areas, country, etc...
+        :return: Set of substations
+        """
+        elm2se: Dict[ALL_DEV_TYPES, List[dev.Substation]] = dict()
+
+        # Associate country, community, region and municipality to substation
+        for se in self.substations:
+            for elm in [se.country, se.community, se.region, se.municipality]:
+                if elm is not None:
+                    if elm in elm2se:
+                        elm2se[elm].append(se)
+                    else:
+                        elm2se[elm] = [se]
+
+        # associate voltage levels to substations
+        for vl in self.voltage_levels:
+            if vl.substation is not None:
+                elm2se[vl] = [vl.substation]
+
+        # associate buses to substations
+        for bus in self.buses:
+            if bus.substation is not None:
+                elm2se[bus] = [bus.substation]
+
+        substations = set()
+        for sel_obj in selected_objects:
+            se_list = elm2se.get(sel_obj, None)
+            if se_list is not None:
+                for se in se_list:
+                    substations.add(se)
+
+        return substations
+
     def fuse_devices(self) -> List[INJECTION_DEVICE_TYPES]:
         """
         Fuse all the different devices in a node to a single device per node
@@ -2922,73 +2958,77 @@ class MultiCircuit(Assets):
 
         return external, boundary, internal, boundary_branches, internal_branches
 
-    def get_buses_from_objects(self, elements: List[ALL_DEV_TYPES]) -> Set[dev.Bus]:
+    def get_buses_from_objects(self, elements: List[ALL_DEV_TYPES], dtype: DeviceType) -> Set[dev.Bus]:
         """
         Returns set of buses belonging to the list elements
 
         :param elements: list of objects
+        :param dtype: DeviceType of all the elements
         :return: set of buses
         """
 
-        buses = set()
-
-        for sel_obj in elements:
-
-            if isinstance(sel_obj, dev.Bus):
-                root_bus = sel_obj
-
-            elif isinstance(sel_obj, dev.Generator):
-                root_bus = sel_obj.bus
-
-            elif isinstance(sel_obj, dev.Battery):
-                root_bus = sel_obj.bus
+        if dtype == DeviceType.BusDevice:
 
-            elif isinstance(sel_obj, dev.Load):
-                root_bus = sel_obj.bus
+            return set(elements)
 
-            elif isinstance(sel_obj, dev.Shunt):
-                root_bus = sel_obj.bus
+        elif dtype == DeviceType.SubstationDevice:
 
-            elif isinstance(sel_obj, dev.Line):
-                root_bus = sel_obj.bus_from
-
-            elif isinstance(sel_obj, dev.Transformer2W):
-                root_bus = sel_obj.bus_from
-
-            elif isinstance(sel_obj, dev.DcLine):
-                root_bus = sel_obj.bus_from
-
-            elif isinstance(sel_obj, dev.HvdcLine):
-                root_bus = sel_obj.bus_from
-
-            elif isinstance(sel_obj, dev.VSC):
-                root_bus = sel_obj.bus_from
-
-            elif isinstance(sel_obj, dev.UPFC):
-                root_bus = sel_obj.bus_from
+            buses = set()
+            for sel_obj in elements:
+                sel = self.get_substation_buses(substation=sel_obj)
+                for bus in sel:
+                    buses.add(bus)
+            return buses
 
-            elif isinstance(sel_obj, dev.Switch):
-                root_bus = sel_obj.bus_from
+        elif dtype == DeviceType.VoltageLevelDevice:
 
-            elif isinstance(sel_obj, dev.VoltageLevel):
-                root_bus = None
+            buses = set()
+            for sel_obj in elements:
                 sel = self.get_voltage_level_buses(vl=sel_obj)
                 for bus in sel:
                     buses.add(bus)
+            return buses
 
-            elif isinstance(sel_obj, dev.Substation):
-                root_bus = None
-                sel = self.get_substation_buses(substation=sel_obj)
+        elif dtype in [DeviceType.CountryDevice,
+                       DeviceType.CommunityDevice,
+                       DeviceType.RegionDevice,
+                       DeviceType.MunicipalityDevice]:
+
+            se_set = self.get_substations_set_from_grouping(elements)
+            buses = set()
+            for se in se_set:
+                sel = self.get_substation_buses(substation=se)
                 for bus in sel:
                     buses.add(bus)
+            return buses
+
+        elif dtype in [DeviceType.GeneratorDevice,
+                       DeviceType.BatteryDevice,
+                       DeviceType.LoadDevice,
+                       DeviceType.ShuntDevice,
+                       DeviceType.CurrentInjectionDevice,
+                       DeviceType.ControllableShuntDevice,
+                       DeviceType.ExternalGridDevice,
+                       DeviceType.StaticGeneratorDevice]:
+
+            return {sel_obj.bus for sel_obj in elements}
+
+        elif dtype in [DeviceType.LineDevice,
+                       DeviceType.DCLineDevice,
+                       DeviceType.Transformer2WDevice,
+                       DeviceType.HVDCLineDevice,
+                       DeviceType.VscDevice,
+                       DeviceType.SeriesReactanceDevice,
+                       DeviceType.UpfcDevice,
+                       DeviceType.SwitchDevice]:
+
+            buses = set()
+            for sel_obj in elements:
+                buses.add(sel_obj.bus_from)
+            return buses
 
-            else:
-                root_bus = None
-
-            if root_bus is not None:
-                buses.add(root_bus)
-
-        return buses
+        else:
+            return set()
 
     def get_topology_data(self, t_idx: int | None = None):
         """

{veragridengine-5.6.2 → veragridengine-5.6.4}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -1024,19 +1024,23 @@ class LinearAnalysisTs:
 
     def __init__(self, grid: MultiCircuit,
                  distributed_slack: bool = True,
-                 correct_values: bool = False):
+                 correct_values: bool = False,
+                 time_indices: IntVec | None = None):
         """
         Constructor
         :param grid: MultiCircuit instance
         :param distributed_slack: boolean to distribute slack
         :param correct_values: boolean to fix out layer values
+        :param time_indices: Array of time indices
         """
 
         if not grid.has_time_series:
             raise Exception("The grid does not have any time series :(")
 
+        self.time_indices = grid.get_all_time_indices() if time_indices is None else time_indices
+
         # get the states matrix
-        mat: IntMat = grid.get_branch_active_time_array()
+        mat: IntMat = grid.get_branch_active_time_array()[self.time_indices, None]
 
         # analyze how many PTDF's we need to get
         self.groups, self.mapping = find_different_states(mat)
@@ -1052,7 +1056,7 @@ class LinearAnalysisTs:
 
         self.nbr = grid.get_branch_number()
         self.nbus = grid.get_bus_number()
-        self.nt = grid.get_time_number()
+        self.nt = len(self.time_indices)
 
     def get_linear_analysis_at(self, t_idx: int) -> LinearAnalysis:
         """

{veragridengine-5.6.2 → veragridengine-5.6.4}/VeraGridEngine/Simulations/LinearFactors/linear_analysis_ts_driver.py

@@ -73,13 +73,13 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
         self.tic()
         self.__cancel__ = False
         self.report_text('Computing TS linear analysis...')
-        lin_ts = LinearAnalysisTs(self.grid)
+        lin_ts = LinearAnalysisTs(grid=self.grid, time_indices=self.time_indices)
 
         self.report_text('Computing flows...')
 
         if self.simplified_compilation:
             # Theoretically equivallent but cannot be ensured 100%
-            self.results.S = self.grid.get_Pbus_prof(apply_active=True)
+            self.results.S = self.grid.get_Pbus_prof(apply_active=True)[self.time_indices]
             self.results.Sf = lin_ts.get_flows_ts(P=self.results.S,
                                                   progress_func=self.report_progress,
                                                   progress_text=self.report_text)

{veragridengine-5.6.2 → veragridengine-5.6.4}/VeraGridEngine/Simulations/results_template.py

@@ -101,6 +101,10 @@ class ResultsTemplate:
 
     @property
     def data_variables(self):
+        """
+
+        :return:
+        """
         return self._data_variables
 
     @property

{veragridengine-5.6.2 → veragridengine-5.6.4}/VeraGridEngine/Utils/NumericalMethods/numerical_stability.py

@@ -16,7 +16,7 @@ def sparse_instability_svd_test(A: csc_matrix, condition_number_thrshold: float
     :return: condition_number (float): The condition number of the matrix
              unstable (bool): 'stable' or 'unstable' based on the condition number
     """
-    if A.shape[0] != 0:
+    if A.shape[0] > 2:  # 0 < k < A.shape[0]
         # Compute the singular values using the svds function (k=2 to get largest and smallest)
         u, s, vt = svds(A, k=2)  # Gets the smallest and largest singular values
 

{veragridengine-5.6.2 → veragridengine-5.6.4}/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.6.2"
+__VeraGridEngine_VERSION__ = "5.6.4"
 
 url = 'https://github.com/SanPen/VeraGrid'
 

{veragridengine-5.6.2 → veragridengine-5.6.4}/VeraGridEngine/enumerations.py

@@ -2118,6 +2118,9 @@ class ContingencyFilteringMethods(Enum):
     """
     AllActive = "All active contingencies"
     Country = "Country"
+    Community = "Community"
+    Region = "Region"
+    Municipality = "Municipality"
     Zone = "Zone"
     Area = "Area"
     SensitiveToMonitored = "Sensitive to monitored"
@@ -2379,6 +2382,32 @@ class GridReductionMethod(Enum):
             return s
 
 
+class BusReductionMethod(Enum):
+    """
+    GridReductionMethod
+    """
+    Reduce = "Reduce"
+    Keep = "Keep"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return str(self)
+
+    @staticmethod
+    def argparse(s):
+        """
+
+        :param s:
+        :return:
+        """
+        try:
+            return BusReductionMethod[s]
+        except KeyError:
+            return s
+
+
 class VarPowerFlowRefferenceType(Enum):
     """
     GridReductionMethod