GridCalEngine 5.1.40__tar.gz → 5.1.42__tar.gz

{GridCalEngine-5.1.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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
 
@@ -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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40 → GridCalEngine-5.1.42}/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.40"
+__GridCalEngine_VERSION__ = "5.1.42"
 
 url = 'https://github.com/SanPen/GridCal'
 

{GridCalEngine-5.1.40 → GridCalEngine-5.1.42}/GridCalEngine/enumerations.py

@@ -444,6 +444,7 @@ class MIPSolvers(Enum):
     CPLEX = 'CPLEX'
     GUROBI = 'GUROBI'
     XPRESS = 'XPRESS'
+    PDLP = 'PDLP'
 
     def __str__(self):
         return self.value
@@ -974,6 +975,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 +1485,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 +1670,7 @@ class ResultTypes(Enum):
     GeneratorResults = 'Generators'
     LoadResults = 'Loads'
     BatteryResults = 'Batteries'
+    ShuntResults = 'Shunt like devices'
     StatisticResults = 'Statistics'
 
     # fluid

{GridCalEngine-5.1.40 → GridCalEngine-5.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.1.40
+Version: 5.1.42
 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.