VeraGridEngine 5.5.9__tar.gz → 5.5.12__tar.gz

{veragridengine-5.5.9 → veragridengine-5.5.12}/PKG-INFO

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

@@ -5,7 +5,7 @@
 import warnings
 import numpy as np
 import pandas as pd
-from typing import List, Dict, Tuple, Union, Any, Set, Generator
+from typing import List, Dict, Tuple, Union, Any, Set, Generator, Sequence
 import datetime as dateslib
 
 from VeraGridEngine.Devices.Dynamic.events import RmsEvent
@@ -1411,6 +1411,53 @@ class Assets:
         except ValueError:
             print(f"Could not delete {obj.name}")
 
+    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)
+
+        branches_to_delete = list()
+        injections_to_delete = list()
+
+        # delete associated Branches in reverse order
+        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:
+                    if delete_associated:
+                        branches_to_delete.append(branch_list[i])
+                    else:
+                        branch_list[i].bus_from = None
+                elif branch_list[i].bus_to in buses_to_remove:
+                    if delete_associated:
+                        branches_to_delete.append(branch_list[i])
+                    else:
+                        branch_list[i].bus_to = None
+
+        for elm in branches_to_delete:
+            self.delete_branch(obj=elm)
+
+        # delete the associated injection devices
+        for inj_list in self.get_injection_devices_lists():
+            for i in range(len(inj_list) - 1, -1, -1):
+                if inj_list[i].bus in buses_to_remove:
+                    if delete_associated:
+                        injections_to_delete.append(inj_list[i])
+                    else:
+                        inj_list[i].bus = None
+
+        for elm in injections_to_delete:
+            self.delete_injection_device(obj=elm)
+
+        # delete the bus itself
+        for elm in buses_to_remove:
+            try:
+                self._buses.remove(elm)
+            except ValueError:
+                print(f"Could not delete {elm.name}")
+
     def get_buses_by(self, filter_elements: List[Union[dev.Area, dev.Country, dev.Zone]]) -> List[dev.Bus]:
         """
         Get a list of buses that can be found in the list of Areas | Zones | Countries

{veragridengine-5.5.9 → veragridengine-5.5.12}/VeraGridEngine/Devices/multi_circuit.py

@@ -1697,9 +1697,10 @@ class MultiCircuit(Assets):
 
         return v
 
-    def get_Sbus(self) -> CxVec:
+    def get_Sbus(self, apply_active: bool = False) -> CxVec:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (nbus) [MW + j MVAr]
         """
         val = np.zeros(self.get_bus_number(), dtype=complex)
@@ -1708,13 +1709,14 @@ class MultiCircuit(Assets):
         for elm in self.get_injection_devices_iter():
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.get_S_with_sign()
+                val[k] += elm.get_S_with_sign() * elm.active if apply_active else elm.get_S_with_sign()
 
         return val
 
-    def get_Sbus_prof(self) -> CxMat:
+    def get_Sbus_prof(self, apply_active: bool = False) -> CxMat:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (ntime, nbus) [MW + j MVAr]
         """
         val = np.zeros((self.get_time_number(), self.get_bus_number()), dtype=complex)
@@ -1724,13 +1726,16 @@ class MultiCircuit(Assets):
         for elm in self.get_injection_devices_iter():
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[:, k] += elm.get_Sprof_with_sign()
-
+                if apply_active:
+                    val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                else:
+                    val[:, k] += elm.get_Sprof_with_sign()
         return val
 
-    def get_Pgen(self) -> Vec:
+    def get_Pgen(self, apply_active: bool = False) -> Vec:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (nbus) [MW + j MVAr]
         """
         val = np.zeros(self.get_bus_number(), dtype=float)
@@ -1739,29 +1744,30 @@ class MultiCircuit(Assets):
         for elm in self.generators:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         for elm in self.batteries:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         for elm in self.static_generators:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         for elm in self.external_grids:
             if elm.mode != ExternalGridMode.VD:
                 if elm.bus is not None:
                     k = bus_dict[elm.bus]
-                    val[k] += elm.P
+                    val[k] += elm.P * elm.active if apply_active else elm.P
 
         return val
 
-    def get_Pload(self) -> Vec:
+    def get_Pload(self, apply_active: bool = False) -> Vec:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (nbus) [MW + j MVAr]
         """
         val = np.zeros(self.get_bus_number(), dtype=float)
@@ -1770,14 +1776,15 @@ class MultiCircuit(Assets):
         for elm in self.loads:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         return val
 
-    def get_Sbus_prof_fixed(self) -> CxMat:
+    def get_Sbus_prof_fixed(self, apply_active: bool = False) -> CxMat:
         """
         Get the complex bus power Injections considering those devices that cannot be dispatched
         This is, all devices except generators and batteries with enabled_dispatch=True
+        :param apply_active: Apply the active state?
         :return: (ntime, nbus) [MW + j MVAr]
         """
         val = np.zeros((self.get_time_number(), self.get_bus_number()), dtype=complex)
@@ -1786,20 +1793,27 @@ class MultiCircuit(Assets):
         for elm in self.get_load_like_devices():
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[:, k] += elm.get_Sprof_with_sign()
+                if apply_active:
+                    val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                else:
+                    val[:, k] += elm.get_Sprof_with_sign()
 
         for elm in self.get_generation_like_devices():
             if elm.bus is not None:
                 if not elm.enabled_dispatch:
                     k = bus_dict[elm.bus]
-                    val[:, k] += elm.get_Sprof_with_sign()
+                    if apply_active:
+                        val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                    else:
+                        val[:, k] += elm.get_Sprof_with_sign()
 
         return val
 
-    def get_Sbus_prof_dispatchable(self) -> CxMat:
+    def get_Sbus_prof_dispatchable(self, apply_active: bool = False) -> CxMat:
         """
         Get the complex bus power Injections only considering those devices that can be dispatched
         This is, generators and batteries with enabled_dispatch=True
+        :param apply_active: Apply the active state?
         :return: (ntime, nbus) [MW + j MVAr]
         """
         val = np.zeros((self.get_time_number(), self.get_bus_number()), dtype=complex)
@@ -1809,30 +1823,33 @@ class MultiCircuit(Assets):
             if elm.bus is not None:
                 if elm.enabled_dispatch:
                     k = bus_dict[elm.bus]
-                    val[:, k] += elm.get_Sprof_with_sign()
+                    if apply_active:
+                        val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                    else:
+                        val[:, k] += elm.get_Sprof_with_sign()
 
         return val
 
-    def get_Pbus(self) -> Vec:
+    def get_Pbus(self, apply_active: bool = False) -> Vec:
         """
         Get snapshot active power array per bus
         :return: Vec
         """
-        return self.get_Sbus().real
+        return self.get_Sbus(apply_active=apply_active).real
 
-    def get_Pbus_prof(self) -> Mat:
+    def get_Pbus_prof(self, apply_active: bool = False) -> Mat:
         """
         Get profiles active power per bus
         :return: Mat
         """
-        return self.get_Sbus_prof().real
+        return self.get_Sbus_prof(apply_active=apply_active).real
 
-    def get_imbalance(self) -> float:
+    def get_imbalance(self, apply_active: bool = False) -> float:
         """
         Get the system imbalance in per unit
         :return:
         """
-        P = self.get_Pbus()
+        P = self.get_Pbus(apply_active=apply_active)
         Pg = P[P > 0].sum()
         Pl = -P[P < 0].sum()
         if Pl > 0:

{veragridengine-5.5.9 → veragridengine-5.5.12}/VeraGridEngine/IO/file_handler.py

@@ -523,7 +523,9 @@ class FileSave:
         if self.file_name.endswith('.xlsx'):
             logger = self.save_excel()
 
-        elif self.file_name.endswith('.veragrid') or self.file_name.endswith('.dveragrid'):
+        elif (self.file_name.endswith('.veragrid')
+              or self.file_name.endswith('.dveragrid')
+              or self.file_name.endswith('.gridcal')):
             logger = self.save_zip()
 
         elif self.file_name.endswith('.sqlite'):

{veragridengine-5.5.9 → veragridengine-5.5.12}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -493,7 +493,7 @@ class LinearAnalysis:
             rates=rates
         )
 
-    def get_flows(self, Sbus: CxVec, P_hvdc: Vec | None = None, P_vsc: Vec | None = None) -> CxVec:
+    def get_flows(self, Sbus: CxVec | Vec, P_hvdc: Vec | None = None, P_vsc: Vec | None = None) -> CxVec | Vec:
         """
         Compute the time series branch Sf using the PTDF
         :param Sbus: Power Injections time series array (nbus)
@@ -514,7 +514,7 @@ class LinearAnalysis:
         else:
             raise Exception(f'Sbus has unsupported dimensions: {Sbus.shape}')
 
-    def get_flows2d(self, Sbus: CxMat, P_hvdc: Mat | None = None, P_vsc: Mat | None = None) -> CxMat:
+    def get_flows2d(self, Sbus: CxMat | Mat, P_hvdc: Mat | None = None, P_vsc: Mat | None = None) -> CxMat | Mat:
         """
         Compute the time series branch Sf using the PTDF
         :param Sbus: Power Injections time series array (time, nbus) for 2D
@@ -557,9 +557,9 @@ class LinearAnalysis:
         """
         if flows.ndim == 2:
 
-            Pbus, _, _, _ = np.linalg.lstsq(self.PTDF, flows)
+            Pbus_t, _, _, _ = np.linalg.lstsq(self.PTDF, flows.T)
 
-            return Pbus
+            return Pbus_t.T
         else:
             raise Exception(f'flows has unsupported dimensions: {flows.shape}')
 
@@ -1090,10 +1090,12 @@ class LinearAnalysisTs:
 
         return flow_ts
 
-    def get_flows_ts(self, P: CxMat | Mat) -> CxMat | Mat:
+    def get_flows_ts(self, P: CxMat | Mat, progress_func=None, progress_text=None) -> CxMat | Mat:
         """
         Get the flow time series of all branches given the injection time series all buses
         :param P: Bus injection time series
+        :param progress_func: Progres function
+        :param progress_text: Progress text function
         :return: Branches flow time series
         """
         # must have the same size
@@ -1101,13 +1103,22 @@ class LinearAnalysisTs:
         assert P.shape[1] == self.nbus
 
         flow_ts = np.zeros((self.nt, self.nbr))
-
+        ii = 0
+        nn = len(self.groups)
         for t_idx, list_of_represented_time_steps in self.groups.items():
+
+            if progress_text is not None:
+                progress_text(f"Computing flows for time group {t_idx}")
+
             # get the linear analysis
             lin: LinearAnalysis = self._linear_analysis[t_idx]
 
             flow_ts[list_of_represented_time_steps, :] = lin.get_flows2d(Sbus=P[list_of_represented_time_steps, :])
 
+            if progress_func is not None:
+                ii += 1
+                progress_func(ii / nn * 100.0)
+
         return flow_ts
 
     def get_injections_ts(self, flows_ts: CxMat | Mat) -> CxMat | Mat:

{veragridengine-5.5.9 → veragridengine-5.5.12}/VeraGridEngine/Simulations/LinearFactors/linear_analysis_ts_driver.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import Dict, Union, TYPE_CHECKING
 from VeraGridEngine.basic_structures import IntVec
-from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis
+from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis, LinearAnalysisTs
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis_options import LinearAnalysisOptions
 from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_at
 from VeraGridEngine.enumerations import SimulationTypes
@@ -28,13 +28,16 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
                  options: Union[LinearAnalysisOptions, None] = None,
                  time_indices: Union[IntVec, None] = None,
                  clustering_results: Union[ClusteringResults, None] = None,
-                 opf_time_series_results=None):
+                 opf_time_series_results=None,
+                 simplified_compilation: bool = True):
         """
         TimeSeries Analysis constructor
         :param grid: MultiCircuit instance
         :param options: LinearAnalysisOptions instance (optional)
         :param time_indices: array of time indices to simulate (optional)
         :param clustering_results: ClusteringResults instance (optional)
+        :param simplified_compilation: If true, the detailed compilation is replaced with a very fast
+                                       status analysis from LinearAnalysisTs
         """
         TimeSeriesDriverTemplate.__init__(
             self,
@@ -47,6 +50,8 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
 
         self.opf_time_series_results = opf_time_series_results
 
+        self.simplified_compilation = simplified_compilation
+
         self.drivers: Dict[int, LinearAnalysis] = dict()
 
         self.results = LinearAnalysisTimeSeriesResults(
@@ -66,37 +71,38 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
         """
 
         self.tic()
-
-        self.report_text('Computing TS linear analysis...')
-
         self.__cancel__ = False
-
-        # Compute bus Injections
-        # Pbus = self.grid.get_Pbus_prof()
-
-        # Compute different topologies to consider
-        # tpg = self.get_topologic_groups()
-
-        for it, t in enumerate(self.time_indices):
-            self.report_text('Linear analysis at ' + str(self.grid.time_profile[t]))
-            self.report_progress2(it, len(self.time_indices))
-
-            nc: NumericalCircuit = compile_numerical_circuit_at(circuit=self.grid,
-                                                                t_idx=t,
-                                                                opf_results=self.opf_time_series_results,
-                                                                logger=self.logger)
-
-            driver_ = LinearAnalysis(
-                nc=nc,
-                distributed_slack=self.options.distribute_slack,
-                correct_values=self.options.correct_values,
-                # distributed_slack=True,
-                # correct_values=False,
-            )
-
-            Sbus = nc.get_power_injections_pu()
-            self.results.S[it, :] = Sbus * nc.Sbase
-            self.results.Sf[it, :] = driver_.get_flows(Sbus=Sbus) * nc.Sbase
+        self.report_text('Computing TS linear analysis...')
+        lin_ts = LinearAnalysisTs(self.grid)
+
+        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.Sf = lin_ts.get_flows_ts(P=self.results.S,
+                                                  progress_func=self.report_progress,
+                                                  progress_text=self.report_text)
+
+        else:
+            for it, t in enumerate(self.time_indices):
+                self.report_text('Linear analysis at ' + str(self.grid.time_profile[t]))
+                self.report_progress2(it, len(self.time_indices))
+
+                nc: NumericalCircuit = compile_numerical_circuit_at(circuit=self.grid,
+                                                                    t_idx=t,
+                                                                    opf_results=self.opf_time_series_results,
+                                                                    logger=self.logger)
+
+                driver_ = LinearAnalysis(
+                    nc=nc,
+                    distributed_slack=self.options.distribute_slack,
+                    correct_values=self.options.correct_values,
+                )
+
+                Sbus = nc.get_power_injections_pu()
+                self.results.S[it, :] = Sbus * nc.Sbase
+                self.results.Sf[it, :] = driver_.get_flows(Sbus=Sbus) * nc.Sbase
 
         rates = self.grid.get_branch_rates()
         self.results.loading = self.results.Sf.real / (rates + 1e-9)

{veragridengine-5.5.9 → veragridengine-5.5.12}/VeraGridEngine/Simulations/NTC/ntc_driver.py

@@ -97,7 +97,8 @@ class OptimalNetTransferCapacityDriver(DriverTemplate):
                 progress_func=self.report_progress,
                 export_model_fname=self.options.opf_options.export_model_fname,
                 verbose=self.options.opf_options.verbose,
-                robust=self.options.opf_options.robust
+                robust=self.options.opf_options.robust,
+                mip_framework=self.options.opf_options.mip_framework
             )
 
         # pack the results