GridCalEngine 5.1.39__tar.gz → 5.1.41__tar.gz

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Compilers/circuit_to_bentayga.py

@@ -693,12 +693,24 @@ def bentayga_linear_matrices(circuit: MultiCircuit, distributed_slack=False):
 
 
 def translate_bentayga_pf_results(grid: MultiCircuit, res) -> PowerFlowResults:
+    """
+
+    :param grid:
+    :param res:
+    :return:
+    """
     results = PowerFlowResults(n=grid.get_bus_number(),
                                m=grid.get_branch_number_wo_hvdc(),
                                n_hvdc=grid.get_hvdc_number(),
+                               n_gen=grid.get_generators_number(),
+                               n_batt=grid.get_batteries_number(),
+                               n_sh=grid.get_shunt_like_device_number(),
                                bus_names=res.names,
                                branch_names=res.names,
                                hvdc_names=res.hvdc_names,
+                               gen_names=grid.get_generator_names(),
+                               batt_names=grid.get_battery_names(),
+                               sh_names=grid.get_shunt_like_devices_names(),
                                bus_types=res.bus_types)
 
     results.voltage = res.V[0, :]

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

@@ -1518,9 +1518,15 @@ def translate_newton_pa_pf_results(grid: MultiCircuit, res: "npa.PowerFlowResult
     results = PowerFlowResults(n=grid.get_bus_number(),
                                m=grid.get_branch_number_wo_hvdc(),
                                n_hvdc=grid.get_hvdc_number(),
+                               n_gen=grid.get_generators_number(),
+                               n_batt=grid.get_batteries_number(),
+                               n_sh=grid.get_shunt_like_device_number(),
                                bus_names=res.bus_names,
                                branch_names=res.branch_names,
                                hvdc_names=res.hvdc_names,
+                               gen_names=grid.get_generator_names(),
+                               batt_names=grid.get_battery_names(),
+                               sh_names=grid.get_shunt_like_devices_names(),
                                bus_types=res.bus_types)
 
     results.voltage = res.voltage[0, :]

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Compilers/circuit_to_pgm.py

@@ -669,9 +669,15 @@ def translate_pgm_results(grid: MultiCircuit, pf_res) -> PowerFlowResults:
     results = PowerFlowResults(n=nc.nbus,
                                m=nc.nbr,
                                n_hvdc=nc.nhvdc,
+                               n_gen=nc.ngen,
+                               n_batt=nc.nbatt,
+                               n_sh=nc.nshunt,
                                bus_names=nc.bus_names,
                                branch_names=nc.branch_names,
                                hvdc_names=nc.hvdc_names,
+                               gen_names=nc.generator_names,
+                               batt_names=nc.battery_names,
+                               sh_names=nc.shunt_names,
                                bus_types=nc.bus_types)
 
     if pf_res is None:

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -765,6 +765,14 @@ class NumericalCircuit:
         """
         return self.battery_data.names
 
+    @property
+    def shunt_names(self):
+        """
+
+        :return:
+        """
+        return self.shunt_data.names
+
     @property
     def hvdc_names(self):
         """

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

@@ -4370,6 +4370,17 @@ class Assets:
             elms += lst
         return elms
 
+    def get_shunt_like_devices_names(self) -> StrVec:
+        """
+        Get a list of all devices names that can inject or subtract power from a node
+        :return: Array of Shunt devices' names
+        """
+        elms = list()
+        for lst in self.get_shunt_like_devices_lists():
+            for elm in lst:
+                elms.append(elm.name)
+        return np.array(elms)
+
     def get_shunt_like_device_number(self) -> int:
         """
         Get a list of all devices that can inject or subtract power from a node
@@ -4674,6 +4685,9 @@ class Assets:
         elif device_type == DeviceType.BranchDevice:
             return self.get_branches_wo_hvdc()
 
+        elif device_type == DeviceType.ShuntLikeDevice:
+            return self.get_shunt_like_devices()
+
         elif device_type == DeviceType.NoDevice:
             return list()
 

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Devices/multi_circuit.py

@@ -333,11 +333,11 @@ class MultiCircuit(Assets):
 
         return cpy
 
-    def build_graph(self):
+    def build_graph(self) -> nx.MultiDiGraph:
         """
         Returns a networkx DiGraph object of the grid.
         """
-        graph = nx.DiGraph()
+        graph = nx.MultiDiGraph()
 
         bus_dictionary = dict()
 

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Devices/profile.py

@@ -255,7 +255,7 @@ class Profile:
         else:
             return 0.0
 
-    def set(self, arr: NumericVec):
+    def set(self, arr: NumericVec) -> bool:
         """
         Set array value
         :param arr:
@@ -278,31 +278,38 @@ class Profile:
                 if isinstance(base, np.bool_):
                     base = bool(base)
 
-                self._is_sparse = True
-                self._sparse_array = SparseArray(data_type=self.dtype)
+                if check_type(dtype=self.dtype, value=base):
+                    self._is_sparse = True
+                    self._sparse_array = SparseArray(data_type=self.dtype)
 
-                if most_common_count > 1:
-                    if isinstance(arr, np.ndarray):
-                        data, indptr = compress_array_numba(arr, base)
-                        data_map = {i: x for i, x in zip(indptr, data)}  # this is to use a native python dict
+                    if most_common_count > 1:
+                        if isinstance(arr, np.ndarray):
+                            data, indptr = compress_array_numba(arr, base)
+                            data_map = {i: x for i, x in zip(indptr, data)}  # this is to use a native python dict
+                        else:
+                            raise Exception('Unknown profile type' + str(type(arr)))
                     else:
-                        raise Exception('Unknown profile type' + str(type(arr)))
-                else:
-                    data_map = dict()
+                        data_map = dict()
 
-                self._sparse_array.create(size=len(arr),
-                                          default_value=base,
-                                          data=data_map)
-                check_type(dtype=self.dtype, value=base)
+                    self._sparse_array.create(size=len(arr),
+                                              default_value=base,
+                                              data=data_map)
+                else:
+                    print("Cannot set sparse array because the type check failed")
+                    return False
             else:
-                check_type(dtype=self.dtype, value=arr[0])
-                self._is_sparse = False
-                self._dense_array = arr
+                if check_type(dtype=self.dtype, value=arr[0]):
+                    self._is_sparse = False
+                    self._dense_array = arr
+                else:
+                    print("Cannot set dense array because the type check failed")
+                    return False
         else:
             self._is_sparse = False
             self._dense_array = arr
 
         self._initialized = True
+        return True
 
     def __eq__(self, other: "Profile") -> bool:
         """

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/IO/__init__.py

@@ -16,3 +16,6 @@ from GridCalEngine.IO.matpower.matpower_parser import parse_matpower_file, get_m
 from GridCalEngine.IO.raw.raw_parser_legacy import PSSeParser
 
 from GridCalEngine.IO.file_handler import FileOpen, FileSave, FileSavingOptions
+
+from GridCalEngine.IO.gridcal.remote import (gather_model_as_jsons_for_communication, RemoteInstruction,
+                                             SimulationTypes, send_json_data, get_certificate_path, get_certificate)

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

@@ -15,12 +15,15 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 import os
+import requests
+import asyncio
 from typing import Dict, Union, Any
 from uuid import uuid4, getnode
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.enumerations import (SimulationTypes, JobStatus)
+from GridCalEngine.basic_structures import Logger
 from GridCalEngine.IO.gridcal.pack_unpack import gather_model_as_jsons
-from GridCalEngine.IO.gridcal.zip_interface import save_results_in_zip
+from GridCalEngine.IO.file_system import get_create_gridcal_folder
 
 
 class RemoteInstruction:
@@ -137,6 +140,49 @@ class RemoteJob:
         self.instruction = RemoteInstruction(data=data['instruction'])
 
 
+def get_certificate_path() -> str:
+    """
+    Get a path to the certificates
+    :return:
+    """
+    return os.path.join(get_create_gridcal_folder(), "server_cert.pem")
+
+
+def get_certificate(base_url: str, certificate_path: str, pwd: str, logger: Logger = Logger()) -> bool:
+    """
+    Try connecting to the server
+    :return: ok?
+    """
+    # Make a GET request to the root endpoint
+    try:
+        response = requests.get(f"{base_url}/get_cert",
+                                headers={"API-Key": pwd},
+                                verify=False,
+                                timeout=2)
+
+        # Save the certificate to a file
+
+        with open(certificate_path, "wb") as cert_file:
+            cert_file.write(response.content)
+
+        # Check if the request was successful
+        if response.status_code == 200:
+            # Print the response body
+            # print("Response Body:", response.json())
+            # self.data_model.parse_data(data=response.json())
+            return True
+        else:
+            # Print error message
+            logger.add_error(msg=f"Response error", value=response.text)
+            return False
+    except ConnectionError as e:
+        logger.add_error(msg=f"Connection error", value=str(e))
+        return False
+    except Exception as e:
+        logger.add_error(msg=f"General exception error", value=str(e))
+        return False
+
+
 def gather_model_as_jsons_for_communication(circuit: MultiCircuit,
                                             instruction: RemoteInstruction) -> Dict[str, Dict[str, Dict[str, str]]]:
     """
@@ -160,3 +206,25 @@ 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]]]],
+                   endpoint_url: str,
+                   certificate: str) -> Any:
+    """
+    Send a file along with instructions about the file
+    :param json_data: Json with te model
+    :param endpoint_url: Web socket URL to connect to
+    :param certificate: SSL certificate path
+    :return service response
+    """
+
+    response = asyncio.get_event_loop().run_until_complete(
+        requests.post(
+            url=endpoint_url,
+            json=json_data,
+            stream=True,
+            verify=certificate
+        )
+    )
+
+    # return server response
+    return response.json()

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Simulations/PowerFlow/power_flow_driver.py

@@ -63,9 +63,15 @@ class PowerFlowDriver(DriverTemplate):
         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.convergence_reports = list()
@@ -79,7 +85,7 @@ class PowerFlowDriver(DriverTemplate):
         """
         return list()
 
-    def add_report(self):
+    def add_report(self) -> None:
         """
         Add a report of the results (in-place)
         """
@@ -137,9 +143,15 @@ class PowerFlowDriver(DriverTemplate):
             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_generators_number(),
+                                            n_batt=self.grid.get_batteries_number(),
+                                            n_sh=self.grid.get_shunt_like_device_number(),
                                             bus_names=res.bus_names,
                                             branch_names=res.branch_names,
                                             hvdc_names=res.hvdc_names,
+                                            gen_names=self.grid.get_generator_names(),
+                                            batt_names=self.grid.get_battery_names(),
+                                            sh_names=self.grid.get_shunt_like_devices_names(),
                                             bus_types=res.bus_types)
 
             self.results = translate_newton_pa_pf_results(self.grid, res)
@@ -153,9 +165,15 @@ class PowerFlowDriver(DriverTemplate):
             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_generators_number(),
+                                            n_batt=self.grid.get_batteries_number(),
+                                            n_sh=self.grid.get_shunt_like_device_number(),
                                             bus_names=res.names,
                                             branch_names=res.names,
                                             hvdc_names=res.hvdc_names,
+                                            gen_names=self.grid.get_generator_names(),
+                                            batt_names=self.grid.get_battery_names(),
+                                            sh_names=self.grid.get_shunt_like_devices_names(),
                                             bus_types=res.bus_types)
 
             self.results = translate_bentayga_pf_results(self.grid, res)

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Simulations/PowerFlow/power_flow_results.py

@@ -82,9 +82,15 @@ class PowerFlowResults(ResultsTemplate):
             n: int,
             m: int,
             n_hvdc: int,
+            n_gen: int,
+            n_batt: int,
+            n_sh: int,
             bus_names: np.ndarray,
             branch_names: np.ndarray,
             hvdc_names: np.ndarray,
+            gen_names: np.ndarray,
+            batt_names: np.ndarray,
+            sh_names: np.ndarray,
             bus_types: np.ndarray,
             clustering_results=None):
         """
@@ -137,6 +143,19 @@ class PowerFlowResults(ResultsTemplate):
                     ResultTypes.HvdcPowerFrom,
                     ResultTypes.HvdcPowerTo
                 ],
+
+                ResultTypes.GeneratorResults: [
+                    ResultTypes.GeneratorReactivePower,
+                ],
+
+                ResultTypes.BatteryResults: [
+                    ResultTypes.BatteryReactivePower,
+                ],
+
+                ResultTypes.ShuntResults: [
+                    ResultTypes.ShuntReactivePower,
+                ],
+
                 ResultTypes.AreaResults: [
                     ResultTypes.InterAreaExchange,
                     ResultTypes.ActivePowerFlowPerArea,
@@ -156,6 +175,9 @@ class PowerFlowResults(ResultsTemplate):
         self.bus_names: StrVec = bus_names
         self.branch_names: StrVec = branch_names
         self.hvdc_names: StrVec = hvdc_names
+        self.gen_names = gen_names
+        self.batt_names = batt_names
+        self.sh_names = sh_names
         self.bus_types: IntVec = bus_types
 
         # vars for the inter-area computation
@@ -187,6 +209,10 @@ class PowerFlowResults(ResultsTemplate):
         self.hvdc_Pt: Vec = np.zeros(n_hvdc)
         self.hvdc_loading: Vec = np.zeros(n_hvdc)
 
+        self.gen_q: Vec = np.zeros(n_gen)
+        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
@@ -755,6 +781,39 @@ class PowerFlowResults(ResultsTemplate):
                                 ylabel='(MW)',
                                 units='(MW)')
 
+        elif result_type == ResultTypes.GeneratorReactivePower:
+
+            return ResultsTable(data=self.gen_q,
+                                index=self.gen_names,
+                                idx_device_type=DeviceType.GeneratorDevice,
+                                columns=[result_type.value],
+                                cols_device_type=DeviceType.NoDevice,
+                                title=result_type.value,
+                                ylabel='(MVAr)',
+                                units='(MVAr)')
+
+        elif result_type == ResultTypes.BatteryReactivePower:
+
+            return ResultsTable(data=self.battery_q,
+                                index=self.batt_names,
+                                idx_device_type=DeviceType.BatteryDevice,
+                                columns=[result_type.value],
+                                cols_device_type=DeviceType.NoDevice,
+                                title=result_type.value,
+                                ylabel='(MVAr)',
+                                units='(MVAr)')
+
+        elif result_type == ResultTypes.ShuntReactivePower:
+
+            return ResultsTable(data=self.shunt_q,
+                                index=self.sh_names,
+                                idx_device_type=DeviceType.ShuntLikeDevice,
+                                columns=[result_type.value],
+                                cols_device_type=DeviceType.NoDevice,
+                                title=result_type.value,
+                                ylabel='(MVAr)',
+                                units='(MVAr)')
+
         else:
             raise Exception('Unsupported result type: ' + str(result_type))
 

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Simulations/PowerFlow/power_flow_worker.py

@@ -36,7 +36,7 @@ from GridCalEngine.DataStructures.numerical_circuit import compile_numerical_cir
 from GridCalEngine.Simulations.PowerFlow.NumericalMethods.discrete_controls import compute_slack_distribution
 from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.Devices.Aggregation.area import Area
-from GridCalEngine.basic_structures import CxVec, CscMat
+from GridCalEngine.basic_structures import CxVec, CscMat, Vec
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
@@ -489,9 +489,15 @@ def single_island_pf(nc: NumericalCircuit,
     results = PowerFlowResults(n=nc.nbus,
                                m=nc.nbr,
                                n_hvdc=nc.nhvdc,
+                               n_gen=nc.ngen,
+                               n_batt=nc.nbatt,
+                               n_sh=nc.nshunt,
                                bus_names=nc.bus_names,
                                branch_names=nc.branch_names,
                                hvdc_names=nc.hvdc_names,
+                               gen_names=nc.generator_names,
+                               batt_names=nc.battery_names,
+                               sh_names=nc.shunt_names,
                                bus_types=bus_types)
 
     results.Sbus = solution.Scalc * nc.Sbase  # MVA
@@ -551,9 +557,9 @@ def power_flow_post_process(
         Sbus[vd] = V[vd] * np.conj(Ybus[vd, :] @ V)
 
         # Reactive power at the pv nodes
-        P = Sbus[pv].real
-        Q = (V[pv] * np.conj(Ybus[pv, :] @ V)).imag
-        Sbus[pv] = P + 1j * Q  # keep the original P injection and set the calculated reactive power
+        P_pv = Sbus[pv].real
+        Q_pv = (V[pv] * np.conj(Ybus[pv, :] @ V)).imag
+        Sbus[pv] = P_pv + 1j * Q_pv  # keep the original P injection and set the calculated reactive power for PV nodes
 
         # Branches current, loading, etc
         Vf = V[calculation_inputs.branch_data.F]
@@ -601,6 +607,35 @@ def power_flow_post_process(
     return Sfb, Stb, If, It, Vbranch, loading, losses, Sbus
 
 
+def split_reactive_power_into_devices(nc: NumericalCircuit, Qbus: Vec) -> Tuple[Vec, Vec, Vec]:
+    """
+    This function splits the reactive power of the power flow solution (nbus) into reactive power per device that
+    is able to control reactive power as an injection (generators, batteries, shunts)
+    :param nc: NumericalCircuit
+    :param Qbus: Array of nodal reactive power (nbus)
+    :return: Qgen (ngen), Qbatt (nbatt), Qsh (nsh)
+    """
+    q_max_total = nc.generator_data.C_bus_elm @ (
+            nc.generator_data.qmax * nc.generator_data.active * nc.generator_data.controllable)
+
+    q_max_total += nc.battery_data.C_bus_elm @ (
+            nc.battery_data.qmax * nc.battery_data.active * nc.battery_data.controllable)
+
+    q_max_total += nc.shunt_data.C_bus_elm @ (
+            nc.shunt_data.qmax * nc.shunt_data.active * nc.shunt_data.controllable)
+
+    bus_idx = nc.generator_data.get_bus_indices()
+    Qgen = Qbus[bus_idx] * nc.generator_data.qmax / (q_max_total[bus_idx] + 1e-20)
+
+    bus_idx = nc.battery_data.get_bus_indices()
+    Qbatt = Qbus[bus_idx] * nc.battery_data.qmax / (q_max_total[bus_idx] + 1e-20)
+
+    bus_idx = nc.shunt_data.get_bus_indices()
+    Qsh = Qbus[bus_idx] * nc.shunt_data.qmax / (q_max_total[bus_idx] + 1e-20)
+
+    return Qgen, Qbatt, Qsh
+
+
 def multi_island_pf_nc(nc: NumericalCircuit,
                        options: PowerFlowOptions,
                        logger=Logger(),
@@ -621,9 +656,15 @@ def multi_island_pf_nc(nc: NumericalCircuit,
         n=nc.nbus,
         m=nc.nbr,
         n_hvdc=nc.nhvdc,
+        n_gen=nc.ngen,
+        n_batt=nc.nbatt,
+        n_sh=nc.nshunt,
         bus_names=nc.bus_data.names,
         branch_names=nc.branch_data.names,
         hvdc_names=nc.hvdc_data.names,
+        gen_names=nc.generator_names,
+        batt_names=nc.battery_names,
+        sh_names=nc.shunt_names,
         bus_types=nc.bus_data.bus_types,
     )
 
@@ -743,6 +784,9 @@ def multi_island_pf_nc(nc: NumericalCircuit,
     results.hvdc_loading = loading_hvdc
     results.hvdc_losses = Losses_hvdc * nc.Sbase
 
+    # do the reactive power partition and store the values
+    results.gen_q, results.battery_q, results.shunt_q = split_reactive_power_into_devices(nc=nc, Qbus=results.Sbus.imag)
+
     return results
 
 

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Simulations/StateEstimation/state_stimation_driver.py

@@ -114,9 +114,15 @@ class StateEstimationResults(PowerFlowResults):
                                   n=n,
                                   m=m,
                                   n_hvdc=0,
+                                  n_gen=0,
+                                  n_batt=0,
+                                  n_sh=0,
                                   bus_names=bus_names,
                                   branch_names=branch_names,
                                   hvdc_names=hvdc_names,
+                                  gen_names=np.empty(0, dtype=object),
+                                  batt_names=np.empty(0, dtype=object),
+                                  sh_names=np.empty(0, dtype=object),
                                   bus_types=bus_types)
 
 

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Simulations/Stochastic/stochastic_power_flow_driver.py

@@ -132,9 +132,15 @@ class StochasticPowerFlowDriver(DriverTemplate):
         avg_res = PowerFlowResults(n=numerical_circuit.nbus,
                                    m=numerical_circuit.nbr,
                                    n_hvdc=numerical_circuit.nhvdc,
+                                   n_gen=numerical_circuit.ngen,
+                                   n_batt=numerical_circuit.nbatt,
+                                   n_sh=numerical_circuit.nshunt,
                                    bus_names=numerical_circuit.bus_names,
                                    branch_names=numerical_circuit.branch_names,
                                    hvdc_names=numerical_circuit.hvdc_names,
+                                   gen_names=numerical_circuit.generator_names,
+                                   batt_names=numerical_circuit.battery_names,
+                                   sh_names=numerical_circuit.shunt_names,
                                    bus_types=numerical_circuit.bus_types)
 
         variance_sum = 0.0

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/GridCalEngine/Utils/Sparse/sparse_array.py

@@ -35,19 +35,19 @@ def check_type(dtype: PROFILE_TYPES, value: Any) -> bool:
     """
     tpe = type(value)
     if tpe in [bool, np.bool_]:
-        assert dtype == bool
+        return dtype == bool
     elif tpe in [int, np.int32, np.int64]:
-        assert dtype == int or dtype == float
+        return dtype == int or dtype == float
     elif tpe in [float, np.float32, np.float64]:
-        assert dtype == float
+        return dtype == float
     elif issubclass(tpe, Enum):
-        assert tpe == dtype  # check that the enum type is the same
+        return tpe == dtype  # check that the enum type is the same
 
     elif isinstance(dtype, DeviceType):
         return True
 
     elif dtype == Vec:
-        assert isinstance(value, np.ndarray) or value is None
+        return isinstance(value, np.ndarray) or value is None
 
     else:
         raise Exception("Sparse array type value Not recognized")

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/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.39"
+__GridCalEngine_VERSION__ = "5.1.41"
 
 url = 'https://github.com/SanPen/GridCal'
 

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

@@ -974,6 +974,7 @@ class DeviceType(Enum):
     GeneratorDevice = 'Generator'
     StaticGeneratorDevice = 'Static Generator'
     ShuntDevice = 'Shunt'
+    ShuntLikeDevice = 'Shunt like devices'
     UpfcDevice = 'UPFC'  # unified power flow controller
     ExternalGridDevice = 'External grid'
     LoadLikeDevice = 'Load like'
@@ -1483,12 +1484,17 @@ class ResultTypes(Enum):
     LoadShedding = 'Load shedding'
     GeneratorShedding = 'Generator shedding'
     GeneratorPower = 'Generator power'
+    GeneratorReactivePower = 'Generator reactive power'
     GeneratorCost = 'Generator cost'
     GeneratorFuels = 'Generator fuels'
     GeneratorEmissions = 'Generator emissions'
     GeneratorProducing = 'Generator producing'
     GeneratorStartingUp = 'Generator starting up'
     GeneratorShuttingDown = 'Generator shutting down'
+
+    BatteryReactivePower = 'Battery reactive power'
+    ShuntReactivePower = 'Shunt reactive power'
+
     BusVoltagePolarPlot = 'Voltage plot'
     BusNodalCapacity = "Nodal capacity"
 
@@ -1663,6 +1669,7 @@ class ResultTypes(Enum):
     GeneratorResults = 'Generators'
     LoadResults = 'Loads'
     BatteryResults = 'Batteries'
+    ShuntResults = 'Shunt like devices'
     StatisticResults = 'Statistics'
 
     # fluid

{GridCalEngine-5.1.39 → GridCalEngine-5.1.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.1.39
+Version: 5.1.41
 Summary: GridCal is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/GridCal
 Author: Santiago Peñate Vera et. Al.