GridCalEngine 5.1.41__tar.gz → 5.1.43__tar.gz

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/Compilers/circuit_to_newton_pa.py

@@ -1257,11 +1257,11 @@ def get_newton_pa_linear_opf_options(opf_opt: OptimalPowerFlowOptions,
     opt.use_ramp_constraints = False
     opt.lodf_threshold = opf_opt.lodf_tolerance
 
-    if opf_opt.aggregations_from is not None:
-        opt.areas_from = [area_dict[e] for e in opf_opt.aggregations_from]
-
-    if opf_opt.aggregations_to is not None:
-        opt.areas_to = [area_dict[e] for e in opf_opt.aggregations_to]
+    # if opf_opt.aggregations_from is not None:
+    #     opt.areas_from = [area_dict[e] for e in opf_opt.aggregations_from]
+    #
+    # if opf_opt.aggregations_to is not None:
+    #     opt.areas_to = [area_dict[e] for e in opf_opt.aggregations_to]
 
     return opt
 

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/Devices/assets.py

@@ -3115,6 +3115,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 +4141,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]:
         """

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/IO/gridcal/remote.py

@@ -206,7 +206,7 @@ def gather_model_as_jsons_for_communication(circuit: MultiCircuit,
     return data
 
 
-def send_json_data(json_data: Dict[str, Union[str, Dict[str, Dict[str, str]]]],
+async def send_json_data(json_data: Dict[str, Union[str, Dict[str, Dict[str, str]]]],
                    endpoint_url: str,
                    certificate: str) -> Any:
     """
@@ -217,13 +217,11 @@ def send_json_data(json_data: Dict[str, Union[str, Dict[str, Dict[str, str]]]],
     :return service response
     """
 
-    response = asyncio.get_event_loop().run_until_complete(
-        requests.post(
-            url=endpoint_url,
-            json=json_data,
-            stream=True,
-            verify=certificate
-        )
+    response = requests.post(
+        url=endpoint_url,
+        json=json_data,
+        stream=True,
+        verify=certificate
     )
 
     # return server response

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/GridCalEngine/Simulations/LinearFactors/linear_analysis_ts_driver.py

@@ -103,13 +103,10 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
 
             driver_.run()
 
-            # Sf = driver_.get_flows(Sbus=Pbus[time_indices_, :])
-
-            self.results.S[it, :] = nc.Sbus
-            self.results.Sf[it, :] = driver_.get_flows(Sbus=nc.Sbus)
+            self.results.S[it, :] = nc.Sbus * nc.Sbase
+            self.results.Sf[it, :] = driver_.get_flows(Sbus=nc.Sbus) * nc.Sbase
 
         rates = self.grid.get_branch_rates_wo_hvdc()
         self.results.loading = self.results.Sf / (rates + 1e-9)
-        # self.results.S = Pbus[self.time_indices, :]
 
         self.toc()

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/Simulations/LinearFactors/linear_analysis_ts_results.py

@@ -135,10 +135,17 @@ class LinearAnalysisTimeSeriesResults(ResultsTemplate):
             )
 
         elif result_type == ResultTypes.BranchActivePowerFrom:
-            labels = self.branch_names
-            data = self.Sf.real
-            y_label = '(MW)'
-            title = 'Branch power '
+
+            return ResultsTable(
+                data=self.Sf.real,
+                index=self.time_array,
+                idx_device_type=DeviceType.TimeDevice,
+                columns=self.branch_names,
+                cols_device_type=DeviceType.BranchDevice,
+                title=result_type.value,
+                ylabel='(MW)',
+                units='(MW)'
+            )
 
         elif result_type == ResultTypes.BranchLoading:
 

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/Simulations/OPF/opf_ts_results.py

@@ -106,7 +106,7 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
 
                                                     ResultTypes.LoadResults: [ResultTypes.LoadShedding],
 
-                                                    ResultTypes.BranchResults: [ResultTypes.BranchPower,
+                                                    ResultTypes.BranchResults: [ResultTypes.BranchActivePowerFrom,
                                                                                 ResultTypes.BranchLoading,
                                                                                 ResultTypes.BranchOverloads,
                                                                                 ResultTypes.BranchTapAngle],
@@ -363,7 +363,7 @@ class OptimalPowerFlowTimeSeriesResults(ResultsTemplate):
                                 xlabel='',
                                 units='(MW)')
 
-        elif result_type == ResultTypes.BranchPower:
+        elif result_type == ResultTypes.BranchActivePowerFrom:
 
             return ResultsTable(data=self.Sf.real,
                                 index=pd.to_datetime(self.time_array),

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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.41 → GridCalEngine-5.1.43}/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()
 

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/Simulations/results_template.py

@@ -372,11 +372,14 @@ class ResultsTemplate:
                         pass
                         # print(prop, value.ndim, value.dtype)
 
-    def parse_saved_data(self, grid: MultiCircuit, data_dict: Dict[str, pd.DataFrame]) -> None:
+    def parse_saved_data(self, grid: MultiCircuit,
+                         data_dict: Dict[str, pd.DataFrame],
+                         logger: Logger = Logger()) -> None:
         """
 
         :param grid: MultiCircuit
         :param data_dict: Dictionary with the info loaded from disk
+        :param logger: Logger
         :return:
         """
         self.time_array = grid.get_time_array()
@@ -410,7 +413,19 @@ class ResultsTemplate:
                     if array.size == 1:
                         array = array[0]
 
-                setattr(self, res_prop.name, array)
+                curr_value = getattr(self, res_prop.name)
+
+                if isinstance(curr_value, np.ndarray):
+                    if curr_value.shape == array.shape:
+                        setattr(self, res_prop.name, array)
+                    else:
+                        logger.add_error(msg="Wrong array shape",
+                                         device_class=self.name,
+                                         device_property=res_prop.name,
+                                         value=str(array.shape),
+                                         expected_value=str(curr_value.shape))
+                else:
+                    setattr(self, res_prop.name, array)
 
 
 class DriverToSave:

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/Utils/MIP/ortools_interface.py

@@ -42,7 +42,7 @@ def get_available_mip_solvers() -> List[str]:
     Get a list of candidate solvers
     :return:
     """
-    candidates = ['SCIP', 'CBC', 'CPLEX', 'GUROBI', 'XPRESS', 'HIGHS', 'GLOP']
+    candidates = ['SCIP', 'CBC', 'CPLEX', 'GUROBI', 'XPRESS', 'HIGHS', 'GLOP', 'PDLP']
     res = list()
     for c in candidates:
         solver = ort.Solver.CreateSolver(c)

GridCalEngine-5.1.43/GridCalEngine/Utils/progress_bar.py

@@ -0,0 +1,34 @@
+# GridCal
+# Copyright (C) 2015 - 2024 Santiago Peñate Vera
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# 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 sys
+
+
+def print_progress_bar(iteration: int, total: int, length=40):
+    """
+    Simple text progress bar
+    :param iteration: current iteration (1 based)
+    :param total: total progress
+    :param length: length of the bar in characters
+    """
+    if iteration > total:
+        iteration = total
+
+    percent = (iteration / total)
+    arrow = '=' * int(length * percent) + '>'
+    spaces = ' ' * (length - len(arrow))
+    sys.stdout.write(f'\r[{arrow}{spaces}] {percent:.1%}')
+    sys.stdout.flush()

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/__version__.py

@@ -16,7 +16,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # do not forget to keep a three-number version!!!
-__GridCalEngine_VERSION__ = "5.1.41"
+__GridCalEngine_VERSION__ = "5.1.43"
 
 url = 'https://github.com/SanPen/GridCal'
 

{GridCalEngine-5.1.41 → GridCalEngine-5.1.43}/GridCalEngine/enumerations.py

@@ -444,6 +444,7 @@ class MIPSolvers(Enum):
     CPLEX = 'CPLEX'
     GUROBI = 'GUROBI'
     XPRESS = 'XPRESS'
+    PDLP = 'PDLP'
 
     def __str__(self):
         return self.value