GridCalEngine 5.1.42__tar.gz → 5.1.45__tar.gz

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Devices/assets.py

@@ -504,11 +504,6 @@ class Assets:
         if self.time_profile is None:
             raise Exception('Cannot ensure profiles existence without a time index. Try format_profiles instead')
 
-        # for key, tpe in self.device_type_name_dict.items():
-        #     elements = self.get_elements_by_type(device_type=tpe)
-        #     for elm in elements:
-        #         elm.ensure_profiles_exist(self.time_profile)
-
         for elm in self.items():
             elm.ensure_profiles_exist(self.time_profile)
 
@@ -3115,6 +3110,13 @@ class Assets:
         """
         return self._contingency_groups
 
+    def get_contingency_groups_number(self) -> int:
+        """
+
+        :return:
+        """
+        return len(self._contingency_groups)
+
     def add_contingency_group(self, obj: dev.ContingencyGroup):
         """
         Add contingency group
@@ -4134,12 +4136,12 @@ class Assets:
             lst += dev_list
         return lst
 
-    def get_branches_wo_hvdc_names(self) -> List[str]:
+    def get_branches_wo_hvdc_names(self) -> StrVec:
         """
         Get the non HVDC branches' names
         :return: list of names
         """
-        return [e.name for e in self.get_branches_wo_hvdc()]
+        return np.array([e.name for e in self.get_branches_wo_hvdc()])
 
     def get_branches(self) -> List[BRANCH_TYPES]:
         """
@@ -4314,7 +4316,6 @@ class Assets:
             for elm in lst:
                 yield elm
 
-
     # ------------------------------------------------------------------------------------------------------------------
     # Load-like devices
     # ------------------------------------------------------------------------------------------------------------------
@@ -4501,28 +4502,28 @@ class Assets:
         """
 
         if device_type == DeviceType.LoadDevice:
-            return self.get_loads()
+            return self._loads
 
         elif device_type == DeviceType.StaticGeneratorDevice:
-            return self.get_static_generators()
+            return self._static_generators
 
         elif device_type == DeviceType.GeneratorDevice:
-            return self.get_generators()
+            return self._generators
 
         elif device_type == DeviceType.BatteryDevice:
-            return self.get_batteries()
+            return self._batteries
 
         elif device_type == DeviceType.ShuntDevice:
-            return self.get_shunts()
+            return self._shunts
 
         elif device_type == DeviceType.ExternalGridDevice:
-            return self.get_external_grids()
+            return self._external_grids
 
         elif device_type == DeviceType.CurrentInjectionDevice:
-            return self.get_current_injections()
+            return self._current_injections
 
         elif device_type == DeviceType.ControllableShuntDevice:
-            return self.get_controllable_shunts()
+            return self._controllable_shunts
 
         elif device_type == DeviceType.LineDevice:
             return self._lines
@@ -4634,15 +4635,6 @@ class Assets:
         elif device_type == DeviceType.EmissionGasDevice:
             return self._emission_gases
 
-        # elif device_type == DeviceType.GeneratorTechnologyAssociation:
-        #     return self._generators_technologies
-        #
-        # elif device_type == DeviceType.GeneratorFuelAssociation:
-        #     return self._generators_fuels
-        #
-        # elif device_type == DeviceType.GeneratorEmissionAssociation:
-        #     return self._generators_emissions
-
         elif device_type == DeviceType.ConnectivityNodeDevice:
             return self._connectivity_nodes
 
@@ -5289,7 +5281,7 @@ class Assets:
 
         return found
 
-    def get_all_elements_dict(self, logger = Logger()) -> Tuple[Dict[str, ALL_DEV_TYPES], bool]:
+    def get_all_elements_dict(self, logger=Logger()) -> Tuple[Dict[str, ALL_DEV_TYPES], bool]:
         """
         Get a dictionary of all elements
         :param: logger: Logger

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Devices/multi_circuit.py

@@ -1309,6 +1309,32 @@ class MultiCircuit(Assets):
         # assign the new base
         self.Sbase = Sbase_new
 
+    def get_injection_devices_grouped_by_substation(self) -> Dict[dev.Substation, Dict[DeviceType, List[INJECTION_DEVICE_TYPES]]]:
+        """
+        Get the injection devices grouped by bus and by device type
+        :return: Dict[bus, Dict[DeviceType, List[Injection devs]]
+        """
+        groups: Dict[dev.Substation, Dict[DeviceType, List[INJECTION_DEVICE_TYPES]]] = dict()
+
+        for lst in self.get_injection_devices_lists():
+
+            for elm in lst:
+
+                if elm.bus.substation is not None:
+
+                    devices_by_type = groups.get(elm.bus.substation, None)
+
+                    if devices_by_type is None:
+                        groups[elm.bus.substation] = {elm.device_type: [elm]}
+                    else:
+                        lst = devices_by_type.get(elm.device_type, None)
+                        if lst is None:
+                            devices_by_type[elm.device_type] = [elm]
+                        else:
+                            devices_by_type[elm.device_type].append(elm)
+
+        return groups
+
     def get_injection_devices_grouped_by_bus(self) -> Dict[dev.Bus, Dict[DeviceType, List[INJECTION_DEVICE_TYPES]]]:
         """
         Get the injection devices grouped by bus and by device type

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Devices/profile.py

@@ -19,6 +19,8 @@ from typing import Union, Dict, Tuple, List, Any
 from collections import Counter
 import numpy as np
 import numba as nb
+from numpy import dtype
+
 from GridCalEngine.basic_structures import Numeric, NumericVec, IntVec
 from GridCalEngine.enumerations import DeviceType
 from GridCalEngine.Utils.Sparse.sparse_array import SparseArray, PROFILE_TYPES, check_type
@@ -336,7 +338,16 @@ class Profile:
         if self._is_sparse:
             return self._sparse_array[key]
         else:
-            return self._dense_array[key]
+
+            if self._dense_array is None:
+                # WTF, initialize sparse
+                self._is_sparse = True
+                self._sparse_array = SparseArray(data_type=self.dtype)
+                self._sparse_array.default_value = self.default_value
+                print("Initializing sparse when querying, this signals a mis initilaization")
+                return self.default_value
+            else:
+                return self._dense_array[key]
 
     def __setitem__(self, key: int, value):
         """
@@ -392,7 +403,12 @@ class Profile:
                 if self._is_sparse:
                     self._sparse_array.resize(n=n)
                 else:
-                    self._dense_array.resize(n)
+                    try:
+                        self._dense_array.resize(n)
+                    except ValueError:
+                        new_arr = np.zeros(n, dtype=self._dense_array.dtype)
+                        new_arr[:len(self._dense_array)] = self._dense_array
+                        self._dense_array = new_arr  # this is to avoid ValueError when resizing a numpy array of Objects
             else:
                 self._initialized = True
                 self.create_sparse(size=n, default_value=self.default_value)

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/IO/gridcal/pack_unpack.py

@@ -267,8 +267,7 @@ def profile_todict(profile: Profile) -> Dict[str, str]:
         return {
             'is_sparse': True,
             'size': s,
-            'default': profile.default_value
-            if profile.sparse_array is None else profile.sparse_array.default_value,
+            'default': profile.default_value if profile.sparse_array is None else profile.sparse_array.default_value,
             'sparse_data': {
                 'map': dict()
             }
@@ -288,8 +287,9 @@ def profile_todict_idtag(profile: Profile) -> Dict[str, str]:
             'size': profile.size(),
             'default': default,
             'sparse_data': {
-                'map': {key: val.idtag for key, val in profile.sparse_array.get_map().items()}
-                if profile.sparse_array else dict()
+                'map': {key: val.idtag if hasattr(val, 'idtag') else None
+                        for key, val in profile.sparse_array.get_map().items()}
+                if profile.sparse_array is not None else dict()
             }
         }
     else:
@@ -297,7 +297,8 @@ def profile_todict_idtag(profile: Profile) -> Dict[str, str]:
             'is_sparse': profile.is_sparse,
             'size': profile.size(),
             'default': default,
-            'dense_data': [e.idtag for e in profile.dense_array] if profile.dense_array else list(),
+            'dense_data': [e.idtag if hasattr(e, 'idtag') else None for e in profile.dense_array]
+            if profile.dense_array is not None else list(),
         }
 
 
@@ -434,6 +435,10 @@ def gather_model_as_jsons(circuit: MultiCircuit) -> Dict[str, Dict[str, str]]:
     :param circuit:
     :return:
     """
+
+    if circuit.has_time_series:
+        circuit.ensure_profiles_exist()
+
     data: Dict[str, Union[Dict[str, str], List[Dict[str, str]]]] = dict()
 
     # declare objects to iterate  name: [sample object, list of objects, headers]
@@ -1469,4 +1474,7 @@ def parse_gridcal_data(data: Dict[str, Union[str, float, pd.DataFrame, Dict[str,
     if text_func is not None:
         text_func("Done!")
 
+    if circuit.has_time_series:
+        circuit.ensure_profiles_exist()
+
     return circuit

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ATC/available_transfer_capacity_driver.py

@@ -403,7 +403,7 @@ class AvailableTransferCapacityDriver(DriverTemplate):
     tpe = SimulationTypes.NetTransferCapacity_run
     name = tpe.value
 
-    def __init__(self, grid: MultiCircuit, options: AvailableTransferCapacityOptions):
+    def __init__(self, grid: MultiCircuit, options: AvailableTransferCapacityOptions | None):
         """
         Power Transfer Distribution Factors class constructor
         @param grid: MultiCircuit Object
@@ -416,10 +416,11 @@ class AvailableTransferCapacityDriver(DriverTemplate):
         self.options = options
 
         # OPF results
-        self.results = AvailableTransferCapacityResults(br_names=[],
-                                                        bus_names=[],
-                                                        rates=[],
-                                                        contingency_rates=[],
+        rates = self.grid.get_branch_rates_wo_hvdc()
+        self.results = AvailableTransferCapacityResults(br_names=self.grid.get_branch_names_wo_hvdc(),
+                                                        bus_names=self.grid.get_bus_names(),
+                                                        rates=rates,
+                                                        contingency_rates=rates,
                                                         clustering_results=None)
 
     def run(self) -> None:

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ATC/available_transfer_capacity_ts_driver.py

@@ -14,6 +14,8 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
+
 import numpy as np
 from typing import Union, List
 
@@ -201,8 +203,8 @@ class AvailableTransferCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
 
     def __init__(self,
                  grid: MultiCircuit,
-                 options: AvailableTransferCapacityOptions,
-                 time_indices: np.ndarray,
+                 options: AvailableTransferCapacityOptions | None,
+                 time_indices: DateVec,
                  clustering_results: Union[ClusteringResults, None] = None):
 
         """

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/Clustering/clustering_driver.py

@@ -39,10 +39,10 @@ class ClusteringDriver(DriverTemplate):
 
         self.options: ClusteringAnalysisOptions = options
 
-        self.results: Union[ClusteringResults, None] = ClusteringResults(time_indices=np.empty(0, dtype=int),
-                                                                         sampled_probabilities=np.empty(0),
-                                                                         time_array=np.empty(0),
-                                                                         original_sample_idx=np.empty(0, dtype=int))
+        self.results: ClusteringResults = ClusteringResults(time_indices=np.empty(0, dtype=int),
+                                                            sampled_probabilities=np.empty(0),
+                                                            time_array=np.empty(0),
+                                                            original_sample_idx=np.empty(0, dtype=int))
 
     def run(self):
         """

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ContingencyAnalysis/contingency_analysis_driver.py

@@ -14,7 +14,9 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
 
+import numpy as np
 from typing import Union, List
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.enumerations import EngineType, ContingencyMethod, SimulationTypes
@@ -44,7 +46,7 @@ class ContingencyAnalysisDriver(DriverTemplate):
 
     def __init__(self,
                  grid: MultiCircuit,
-                 options: ContingencyAnalysisOptions,
+                 options: ContingencyAnalysisOptions | None,
                  linear_multiple_contingencies: Union[LinearMultiContingencies, None] = None,
                  engine: EngineType = EngineType.GridCal):
         """
@@ -78,13 +80,13 @@ class ContingencyAnalysisDriver(DriverTemplate):
 
         # N-K results
         self.results = ContingencyAnalysisResults(
-            ncon=0,
-            nbus=0,
-            nbr=0,
-            bus_names=(),
-            branch_names=(),
-            bus_types=(),
-            con_names=()
+            ncon=self.grid.get_contingency_groups_number(),
+            nbus=self.grid.get_bus_number(),
+            nbr=self.grid.get_branch_number_wo_hvdc(),
+            bus_names=self.grid.get_bus_names(),
+            branch_names=self.grid.get_branch_names_wo_hvdc(),
+            bus_types=np.ones(self.grid.get_bus_number()),
+            con_names=self.grid.get_contingency_group_names()
         )
 
     def get_steps(self) -> List[str]:

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ContingencyAnalysis/contingency_analysis_ts_driver.py

@@ -66,13 +66,13 @@ class ContingencyAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
 
         # N-K results
         self.results: ContingencyAnalysisTimeSeriesResults = ContingencyAnalysisTimeSeriesResults(
-            n=0,
-            nbr=0,
-            time_array=(),
-            bus_names=(),
-            branch_names=(),
-            bus_types=(),
-            con_names=(),
+            n=self.grid.get_bus_number(),
+            nbr=self.grid.get_branch_number_wo_hvdc(),
+            time_array=self.grid.time_profile[time_indices],
+            bus_names=self.grid.get_bus_names(),
+            branch_names=self.grid.get_branch_names_wo_hvdc(),
+            bus_types=np.ones(self.grid.get_bus_number()),
+            con_names=self.grid.get_contingency_group_names(),
             clustering_results=clustering_results
         )
 

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ContinuationPowerFlow/continuation_power_flow_driver.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+import numpy as np
 from typing import Union
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.DataStructures.numerical_circuit import compile_numerical_circuit_at
@@ -58,11 +59,11 @@ class ContinuationPowerFlowDriver(DriverTemplate):
         self.t = t
 
         self.results = ContinuationPowerFlowResults(nval=0,
-                                                    nbus=0,
-                                                    nbr=0,
-                                                    bus_names=[],
-                                                    branch_names=[],
-                                                    bus_types=[])
+                                                    nbus=self.grid.get_bus_number(),
+                                                    nbr=self.grid.get_branch_number_wo_hvdc(),
+                                                    bus_names=self.grid.get_bus_names(),
+                                                    branch_names=self.grid.get_branch_names_wo_hvdc(),
+                                                    bus_types=np.ones(self.grid.get_bus_number()))
 
     def get_steps(self):
         """

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ContinuationPowerFlow/continuation_power_flow_input.py

@@ -20,7 +20,9 @@ from GridCalEngine.basic_structures import CxVec
 
 
 class ContinuationPowerFlowInput:
+    """
 
+    """
     def __init__(self, Sbase: CxVec, Vbase: CxVec, Starget: CxVec, base_overload_number=0):
         """
         ContinuationPowerFlowInput constructor

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/LinearFactors/linear_analysis_driver.py

@@ -55,11 +55,11 @@ class LinearAnalysisDriver(DriverTemplate):
         self.opf_results = opf_results
 
         # Results
-        self.results: Union[LinearAnalysisResults, None] = LinearAnalysisResults(n_br=0,
-                                                                                 n_bus=0,
-                                                                                 br_names=(),
-                                                                                 bus_names=(),
-                                                                                 bus_types=())
+        self.results: LinearAnalysisResults = LinearAnalysisResults(n_br=self.grid.get_branch_number_wo_hvdc(),
+                                                                    n_bus=self.grid.get_bus_number(),
+                                                                    br_names=self.grid.get_branch_names_wo_hvdc(),
+                                                                    bus_names=self.grid.get_bus_names(),
+                                                                    bus_types=np.ones(self.grid.get_bus_number()))
 
         self.all_solved: bool = True
 

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/PowerFlow/power_flow_driver.py

@@ -60,19 +60,19 @@ class PowerFlowDriver(DriverTemplate):
 
         self.opf_results: Union[OptimalPowerFlowResults, None] = opf_results
 
-        self.results = PowerFlowResults(n=0,
-                                        m=0,
-                                        n_hvdc=0,
-                                        n_gen=0,
-                                        n_batt=0,
-                                        n_sh=0,
-                                        bus_names=np.empty(0, dtype=object),
-                                        branch_names=np.empty(0, dtype=object),
-                                        hvdc_names=np.empty(0, dtype=object),
-                                        gen_names=np.empty(0, dtype=object),
-                                        batt_names=np.empty(0, dtype=object),
-                                        sh_names=np.empty(0, dtype=object),
-                                        bus_types=np.empty(0))
+        self.results = PowerFlowResults(n=self.grid.get_bus_number(),
+                                        m=self.grid.get_branch_number_wo_hvdc(),
+                                        n_hvdc=self.grid.get_hvdc_number(),
+                                        n_gen=self.grid.get_generation_like_number(),
+                                        n_batt=self.grid.get_batteries_number(),
+                                        n_sh=self.grid.get_shunt_like_device_number(),
+                                        bus_names=self.grid.get_bus_names(),
+                                        branch_names=self.grid.get_branches_wo_hvdc_names(),
+                                        hvdc_names=self.grid.get_hvdc_names(),
+                                        gen_names=self.grid.get_generation_like_names(),
+                                        batt_names=self.grid.get_battery_names(),
+                                        sh_names=self.grid.get_shunt_like_devices_names(),
+                                        bus_types=np.ones(self.grid.get_bus_number()))
 
         self.convergence_reports = list()
 

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/PowerFlow/power_flow_results.py

@@ -213,14 +213,17 @@ class PowerFlowResults(ResultsTemplate):
         self.battery_q: Vec = np.zeros(n_batt)
         self.shunt_q: Vec = np.zeros(n_sh)
 
-        self.island_number = 0
-
         self.plot_bars_limit: int = 100
         self.convergence_reports = list()
 
         self.register(name='bus_names', tpe=StrVec)
         self.register(name='branch_names', tpe=StrVec)
         self.register(name='hvdc_names', tpe=StrVec)
+
+        self.register(name='gen_names', tpe=StrVec)
+        self.register(name='batt_names', tpe=StrVec)
+        self.register(name='sh_names', tpe=StrVec)
+
         self.register(name='bus_types', tpe=IntVec)
 
         self.register(name='F', tpe=IntVec)
@@ -249,7 +252,11 @@ class PowerFlowResults(ResultsTemplate):
         self.register(name='hvdc_Pt', tpe=Vec)
         self.register(name='hvdc_loading', tpe=Vec)
 
-        self.register(name='island_number', tpe=int)
+        self.register(name='gen_q', tpe=Vec)
+        self.register(name='battery_q', tpe=Vec)
+        self.register(name='shunt_q', tpe=Vec)
+
+        # self.register(name='island_number', tpe=int)
 
     def apply_new_rates(self, nc: NumericalCircuit):
         """

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/PowerFlow/power_flow_ts_driver.py

@@ -61,16 +61,16 @@ class PowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
         self.options = PowerFlowOptions() if options is None else options
 
         self.opf_time_series_results = opf_time_series_results
-
-        self.results = PowerFlowTimeSeriesResults(n=0,
-                                                  m=0,
-                                                  n_hvdc=0,
-                                                  bus_names=np.empty(0),
-                                                  branch_names=np.empty(0),
-                                                  hvdc_names=np.empty(0),
-                                                  time_array=np.empty(0),
-                                                  bus_types=np.empty(0),
-                                                  area_names=None,
+        n = grid.get_bus_number()
+        self.results = PowerFlowTimeSeriesResults(n=n,
+                                                  m=grid.get_branch_number_wo_hvdc(),
+                                                  n_hvdc=grid.get_hvdc_number(),
+                                                  bus_names=grid.get_bus_names(),
+                                                  branch_names=grid.get_branch_names_wo_hvdc(),
+                                                  hvdc_names=grid.get_hvdc_names(),
+                                                  time_array=self.grid.get_time_array()[self.time_indices],
+                                                  bus_types=np.ones(n),
+                                                  area_names=grid.get_area_names(),
                                                   clustering_results=None)
 
     def run_single_thread(self, time_indices) -> PowerFlowTimeSeriesResults:
@@ -142,7 +142,7 @@ class PowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
                                              branch_names=res.names,
                                              hvdc_names=res.hvdc_names,
                                              bus_types=res.bus_types,
-                                             time_array=self.grid.time_profile,
+                                             time_array=self.grid.get_time_array(),
                                              clustering_results=self.clustering_results)
 
         results.voltage = res.V

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/PowerFlow/power_flow_ts_results.py

@@ -39,7 +39,7 @@ class PowerFlowTimeSeriesResults(ResultsTemplate):
                  bus_names: np.ndarray,
                  branch_names: np.ndarray,
                  hvdc_names: np.ndarray,
-                 time_array: np.ndarray,
+                 time_array: DateVec,
                  bus_types: np.ndarray,
                  area_names: Union[np.ndarray, None] = None,
                  clustering_results: Union[ClusteringResults, None] = None):

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/PowerFlow/power_flow_worker.py

@@ -683,7 +683,6 @@ def multi_island_pf_nc(nc: NumericalCircuit,
 
     # compute islands
     islands = nc.split_into_islands(ignore_single_node_islands=options.ignore_single_node_islands)
-    results.island_number = len(islands)
 
     # initialize the all controls var
     all_controls_ok = False  # to run the first time

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/ShortCircuitStudies/short_circuit_driver.py

@@ -14,13 +14,16 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
 
 import numpy as np
-from typing import Union, List
+
+
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.basic_structures import CxVec
 from GridCalEngine.Simulations.PowerFlow.power_flow_driver import PowerFlowResults, PowerFlowOptions
+from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
 from GridCalEngine.Simulations.ShortCircuitStudies.short_circuit_worker import (short_circuit_ph3,
                                                                                 short_circuit_unbalanced)
 from GridCalEngine.Simulations.ShortCircuitStudies.short_circuit_results import ShortCircuitResults
@@ -38,10 +41,10 @@ class ShortCircuitDriver(DriverTemplate):
     tpe = SimulationTypes.ShortCircuit_run
 
     def __init__(self, grid: MultiCircuit,
-                 options: ShortCircuitOptions,
-                 pf_options: PowerFlowOptions,
-                 pf_results: PowerFlowResults,
-                 opf_results=None):
+                 options: ShortCircuitOptions | None,
+                 pf_options: PowerFlowOptions | None,
+                 pf_results: PowerFlowResults | None,
+                 opf_results: OptimalPowerFlowResults | None = None):
         """
         ShortCircuitDriver class constructor
         :param grid: MultiCircuit Object
@@ -52,25 +55,23 @@ class ShortCircuitDriver(DriverTemplate):
         """
         DriverTemplate.__init__(self, grid=grid)
 
-        # power flow results
-        self.pf_results = pf_results
-
-        self.pf_options = pf_options
-
-        self.opf_results = opf_results
+        self.pf_results: PowerFlowResults | None = pf_results
+        self.pf_options: PowerFlowOptions | None = pf_options
+        self.opf_results: OptimalPowerFlowResults | None = opf_results
 
         # Options to use
-        self.options = options
+        self.options: ShortCircuitOptions | None = options
 
         # declare an empty results object
-        self.results: ShortCircuitResults = ShortCircuitResults(n=0,
-                                                                m=0,
-                                                                n_hvdc=0,
-                                                                bus_names=np.empty(0),
-                                                                branch_names=np.empty(0),
-                                                                hvdc_names=np.empty(0),
-                                                                bus_types=np.empty(0),
-                                                                area_names=None)
+        n = grid.get_bus_number()
+        self.results: ShortCircuitResults = ShortCircuitResults(n=n,
+                                                                m=grid.get_branch_number_wo_hvdc(),
+                                                                n_hvdc=grid.get_hvdc_number(),
+                                                                bus_names=grid.get_bus_names(),
+                                                                branch_names=grid.get_branch_names_wo_hvdc(),
+                                                                hvdc_names=grid.get_hvdc_names(),
+                                                                bus_types=np.ones(n),
+                                                                area_names=grid.get_area_names())
 
         self.logger = Logger()
 

{GridCalEngine-5.1.42 → GridCalEngine-5.1.45}/GridCalEngine/Simulations/Stochastic/stochastic_power_flow_driver.py

@@ -69,12 +69,12 @@ class StochasticPowerFlowDriver(DriverTemplate):
 
         self.simulation_type = simulation_type
 
-        self.results = StochasticPowerFlowResults(n=0,
-                                                  m=0,
-                                                  p=0,
-                                                  bus_names=np.empty(0),
-                                                  branch_names=np.empty(0),
-                                                  bus_types=np.empty(0))
+        self.results = StochasticPowerFlowResults(n=self.grid.get_bus_number(),
+                                                  m=self.grid.get_branch_number_wo_hvdc(),
+                                                  p=self.max_sampling_points,
+                                                  bus_names=self.grid.get_bus_names(),
+                                                  branch_names=self.grid.get_branch_names_wo_hvdc(),
+                                                  bus_types=np.ones(self.grid.get_bus_number()))
 
         self.logger = Logger()