GridCalEngine 5.0.0a33__tar.gz → 5.0.2__tar.gz

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Core/DataStructures/numerical_circuit.py

@@ -1135,7 +1135,8 @@ class NumericalCircuit:
                 c=self.branch_data.c,
                 Yshunt_bus=self.Yshunt_from_devices,
                 conn=self.branch_data.conn,
-                seq=1
+                seq=1,
+                add_windings_phase=False
             )
         return self.admittances_.Ybus
 

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Core/admittance_matrices.py

@@ -142,7 +142,8 @@ def compute_admittances(R: Vec,
                         c: Vec,
                         Yshunt_bus: CxVec,
                         conn: Union[List[WindingsConnection], ObjVec],
-                        seq: int) -> Admittance:
+                        seq: int,
+                        add_windings_phase: bool = False) -> Admittance:
     """
     Compute the complete admittance matrices for the general power flow methods (Newton-Raphson based)
 
@@ -166,6 +167,7 @@ def compute_admittances(R: Vec,
     :param Yshunt_bus: array of shunts equivalent power per bus, from the shunt devices (p.u.)
     :param seq: Sequence [0, 1, 2]
     :param conn: array of windings connections (numpy array of WindingsConnection)
+    :param add_windings_phase: Add the phases of the transformer windings (for short circuits mainly)
     :return: Admittance instance
     """
     r30_deg = np.exp(1.0j * np.pi / 6.0)
@@ -212,14 +214,20 @@ def compute_admittances(R: Vec,
 
     elif seq == 1:  # positive sequence
 
-        # only need to include the phase shift of +-30 degrees
-        factor_psh = np.array([r30_deg if con == WindingsConnection.GD or con == WindingsConnection.SD else 1.0
-                               for con in conn])
+        if add_windings_phase:
+            # only need to include the phase shift of +-30 degrees
+            factor_psh = np.array([r30_deg if con == WindingsConnection.GD or con == WindingsConnection.SD else 1.0
+                                   for con in conn])
 
-        Yff = Gsw + (ys + bc2 + 1.0j * Beq) / (mp * mp * vtap_f * vtap_f)
-        Yft = -ys / (mp * np.exp(-1.0j * tap_angle) * vtap_f * vtap_t) * factor_psh
-        Ytf = -ys / (mp * np.exp(1.0j * tap_angle) * vtap_t * vtap_f) * np.conj(factor_psh)
-        Ytt = (ys + bc2) / (vtap_t * vtap_t)
+            Yff = Gsw + (ys + bc2 + 1.0j * Beq) / (mp * mp * vtap_f * vtap_f)
+            Yft = -ys / (mp * np.exp(-1.0j * tap_angle) * vtap_f * vtap_t) * factor_psh
+            Ytf = -ys / (mp * np.exp(1.0j * tap_angle) * vtap_t * vtap_f) * np.conj(factor_psh)
+            Ytt = (ys + bc2) / (vtap_t * vtap_t)
+        else:
+            Yff = Gsw + (ys + bc2 + 1.0j * Beq) / (mp * mp * vtap_f * vtap_f)
+            Yft = -ys / (mp * np.exp(-1.0j * tap_angle) * vtap_f * vtap_t)
+            Ytf = -ys / (mp * np.exp(1.0j * tap_angle) * vtap_t * vtap_f)
+            Ytt = (ys + bc2) / (vtap_t * vtap_t)
 
     else:  # original
         # Yff = Gsw + (ys + bc2 + 1.0j * Beq) / (mp * mp * vtap_f * vtap_f)

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Simulations/ContingencyAnalysis/helm_contingencies.py

@@ -95,7 +95,8 @@ def calc_V_outage(nc: NumericalCircuit,
                               c=nc.branch_data.c[contingency_br_indices],
                               Yshunt_bus=np.zeros(nc.nbus),
                               conn=nc.branch_data.conn[contingency_br_indices],
-                              seq=1)
+                              seq=1,
+                              add_windings_phase=False)
 
     # solve the modified HELM
     _, V, _, norm_f = helm_coefficients_dY(dY=adm.Ybus,

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Simulations/NTC/ntc_opf.py

@@ -33,9 +33,8 @@ from GridCalEngine.Core.DataStructures.load_data import LoadData
 from GridCalEngine.Core.DataStructures.branch_data import BranchData
 from GridCalEngine.Core.DataStructures.hvdc_data import HvdcData
 from GridCalEngine.Core.DataStructures.bus_data import BusData
-from GridCalEngine.basic_structures import Logger, Mat, Vec, IntVec, BoolVec, StrVec, DateVec, CxMat
-from GridCalEngine.Utils.MIP.selected_interface import (LpExp, LpVar, LpModel, get_lp_var_value, lpDot,
-                                                        set_var_bounds, join)
+from GridCalEngine.basic_structures import Logger, Vec, IntVec, BoolVec, StrVec, CxMat
+from GridCalEngine.Utils.MIP.selected_interface import LpExp, LpVar, LpModel, lpDot, set_var_bounds, join
 from GridCalEngine.enumerations import TransformerControlType, HvdcControlType, AvailableTransferMode
 from GridCalEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis, LinearMultiContingencies
 from GridCalEngine.Simulations.ATC.available_transfer_capacity_driver import compute_alpha
@@ -315,7 +314,7 @@ class BusNtcVars:
         self.Pcalc = np.zeros((nt, n_elm), dtype=object)
         self.inj_delta = np.zeros((nt, n_elm), dtype=object)
 
-    def get_values(self, Sbase: float) -> "BusNtcVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "BusNtcVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: BusVars
@@ -329,13 +328,11 @@ class BusNtcVars:
         for t in range(nt):
 
             for i in range(n_elm):
-                data.theta[t, i] = get_lp_var_value(self.theta[t, i])
-                data.shadow_prices[t, i] = get_lp_var_value(self.kirchhoff[t, i])
-
-                data.load_shedding[t, i] = get_lp_var_value(self.load_shedding[t, i]) * Sbase
-
-                data.Pcalc[t, i] = get_lp_var_value(self.Pcalc[t, i]) * Sbase
-                data.inj_delta[t, i] = get_lp_var_value(self.inj_delta[t, i])
+                data.theta[t, i] = model.get_value(self.theta[t, i])
+                data.shadow_prices[t, i] = model.get_dual_value(self.kirchhoff[t, i])
+                data.load_shedding[t, i] = model.get_value(self.load_shedding[t, i]) * Sbase
+                data.Pcalc[t, i] = model.get_value(self.Pcalc[t, i]) * Sbase
+                data.inj_delta[t, i] = model.get_value(self.inj_delta[t, i])
 
         # format the arrays appropriately
         data.theta = data.theta.astype(float, copy=False)
@@ -375,7 +372,7 @@ class BranchNtcVars:
         # t, m, c, contingency, negative_slack, positive_slack
         self.contingency_flow_data: List[Tuple[int, int, int, Union[float, LpVar, LpExp], LpVar, LpVar]] = list()
 
-    def get_values(self, Sbase: float) -> "BranchNtcVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "BranchNtcVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: BranchVars
@@ -387,19 +384,19 @@ class BranchNtcVars:
 
         for t in range(nt):
             for i in range(n_elm):
-                data.flows[t, i] = get_lp_var_value(self.flows[t, i]) * Sbase
-                data.flow_slacks_pos[t, i] = get_lp_var_value(self.flow_slacks_pos[t, i]) * Sbase
-                data.flow_slacks_neg[t, i] = get_lp_var_value(self.flow_slacks_neg[t, i]) * Sbase
-                data.tap_angles[t, i] = get_lp_var_value(self.tap_angles[t, i])
-                data.flow_constraints_ub[t, i] = get_lp_var_value(self.flow_constraints_ub[t, i])
-                data.flow_constraints_lb[t, i] = get_lp_var_value(self.flow_constraints_lb[t, i])
+                data.flows[t, i] = model.get_value(self.flows[t, i]) * Sbase
+                data.flow_slacks_pos[t, i] = model.get_value(self.flow_slacks_pos[t, i]) * Sbase
+                data.flow_slacks_neg[t, i] = model.get_value(self.flow_slacks_neg[t, i]) * Sbase
+                data.tap_angles[t, i] = model.get_value(self.tap_angles[t, i])
+                data.flow_constraints_ub[t, i] = model.get_value(self.flow_constraints_ub[t, i])
+                data.flow_constraints_lb[t, i] = model.get_value(self.flow_constraints_lb[t, i])
 
         for i in range(len(self.contingency_flow_data)):
             t, m, c, var, neg_slack, pos_slack = self.contingency_flow_data[i]
             self.contingency_flow_data[i] = (t, m, c,
-                                             get_lp_var_value(var),
-                                             get_lp_var_value(neg_slack),
-                                             get_lp_var_value(pos_slack))
+                                             model.get_value(var),
+                                             model.get_value(neg_slack),
+                                             model.get_value(pos_slack))
 
         # format the arrays appropriately
         data.flows = data.flows.astype(float, copy=False)
@@ -444,7 +441,7 @@ class HvdcNtcVars:
         self.rates = np.zeros((nt, n_elm), dtype=float)
         self.loading = np.zeros((nt, n_elm), dtype=float)
 
-    def get_values(self, Sbase: float) -> "HvdcNtcVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "HvdcNtcVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: HvdcVars
@@ -455,7 +452,7 @@ class HvdcNtcVars:
 
         for t in range(nt):
             for i in range(n_elm):
-                data.flows[t, i] = get_lp_var_value(self.flows[t, i]) * Sbase
+                data.flows[t, i] = model.get_value(self.flows[t, i]) * Sbase
 
         # format the arrays appropriately
         data.flows = data.flows.astype(float, copy=False)
@@ -500,7 +497,7 @@ class NtcVars:
         # power shift
         self.power_shift = np.zeros(nt, dtype=object)
 
-    def get_values(self, Sbase: float) -> "NtcVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "NtcVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: OpfVars instance
@@ -517,15 +514,15 @@ class NtcVars:
                        n_hvdc=self.n_hvdc,
                        model=self.model)
 
-        data.bus_vars = self.bus_vars.get_values(Sbase)
-        data.branch_vars = self.branch_vars.get_values(Sbase)
-        data.hvdc_vars = self.hvdc_vars.get_values(Sbase)
+        data.bus_vars = self.bus_vars.get_values(Sbase, model)
+        data.branch_vars = self.branch_vars.get_values(Sbase, model)
+        data.hvdc_vars = self.hvdc_vars.get_values(Sbase, model)
 
         # todo: check if acceptable_solution must to be an array, one solution per hour
         data.acceptable_solution = self.acceptable_solution
 
         for t in range(nt):
-            data.power_shift[t] = get_lp_var_value(self.power_shift[t])
+            data.power_shift[t] = model.get_value(self.power_shift[t])
 
         # format the arrays appropriately
         data.power_shift = data.power_shift.astype(float, copy=False)

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Simulations/OPF/linear_opf_ts.py

@@ -34,8 +34,7 @@ from GridCalEngine.Core.DataStructures.branch_data import BranchData
 from GridCalEngine.Core.DataStructures.hvdc_data import HvdcData
 from GridCalEngine.Core.DataStructures.bus_data import BusData
 from GridCalEngine.basic_structures import Logger, Vec, IntVec, DateVec
-from GridCalEngine.Utils.MIP.selected_interface import (LpExp, LpVar, LpModel, get_lp_var_value, lpDot,
-                                                        set_var_bounds, join)
+from GridCalEngine.Utils.MIP.selected_interface import LpExp, LpVar, LpModel, lpDot, set_var_bounds, join
 from GridCalEngine.enumerations import TransformerControlType, HvdcControlType
 from GridCalEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis, LinearMultiContingency, \
     LinearMultiContingencies
@@ -88,7 +87,7 @@ class BusVars:
         self.kirchhoff = np.zeros((nt, n_elm), dtype=object)
         self.shadow_prices = np.zeros((nt, n_elm), dtype=float)
 
-    def get_values(self, Sbase: float) -> "BusVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "BusVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: BusVars
@@ -100,10 +99,10 @@ class BusVars:
 
         for t in range(nt):
             for i in range(n_elm):
-                data.theta[t, i] = get_lp_var_value(self.theta[t, i])
-                data.Pcalc[t, i] = get_lp_var_value(self.Pcalc[t, i])
-                data.branch_injections[t, i] = get_lp_var_value(self.branch_injections[t, i]) * Sbase
-                data.shadow_prices[t, i] = get_lp_var_value(self.kirchhoff[t, i])
+                data.theta[t, i] = model.get_value(self.theta[t, i])
+                data.Pcalc[t, i] = model.get_value(self.Pcalc[t, i])
+                data.branch_injections[t, i] = model.get_value(self.branch_injections[t, i]) * Sbase
+                data.shadow_prices[t, i] = model.get_dual_value(self.kirchhoff[t, i])
 
         # format the arrays aproprietly
         data.theta = data.theta.astype(float, copy=False)
@@ -128,7 +127,7 @@ class LoadVars:
 
         self.p = np.zeros((nt, n_elm), dtype=float)  # to be filled (no vars)
 
-    def get_values(self, Sbase: float) -> "LoadVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "LoadVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: LoadVars
@@ -140,7 +139,7 @@ class LoadVars:
 
         for t in range(nt):
             for i in range(n_elm):
-                data.shedding[t, i] = get_lp_var_value(self.shedding[t, i]) * Sbase
+                data.shedding[t, i] = model.get_value(self.shedding[t, i]) * Sbase
 
         # format the arrays aproprietly
         data.shedding = data.shedding.astype(float, copy=False)
@@ -165,7 +164,7 @@ class GenerationVars:
         self.starting_up = np.zeros((nt, n_elm), dtype=object)
         self.shutting_down = np.zeros((nt, n_elm), dtype=object)
 
-    def get_values(self, Sbase: float) -> "GenerationVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "GenerationVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: GenerationVars
@@ -175,11 +174,11 @@ class GenerationVars:
 
         for t in range(nt):
             for i in range(n_elm):
-                data.p[t, i] = get_lp_var_value(self.p[t, i]) * Sbase
-                data.shedding[t, i] = get_lp_var_value(self.shedding[t, i]) * Sbase
-                data.producing[t, i] = get_lp_var_value(self.producing[t, i])
-                data.starting_up[t, i] = get_lp_var_value(self.starting_up[t, i])
-                data.shutting_down[t, i] = get_lp_var_value(self.shutting_down[t, i])
+                data.p[t, i] = model.get_value(self.p[t, i]) * Sbase
+                data.shedding[t, i] = model.get_value(self.shedding[t, i]) * Sbase
+                data.producing[t, i] = model.get_value(self.producing[t, i])
+                data.starting_up[t, i] = model.get_value(self.starting_up[t, i])
+                data.shutting_down[t, i] = model.get_value(self.shutting_down[t, i])
 
         # format the arrays aproprietly
         data.p = data.p.astype(float, copy=False)
@@ -205,7 +204,7 @@ class BatteryVars(GenerationVars):
         GenerationVars.__init__(self, nt=nt, n_elm=n_elm)
         self.e = np.zeros((nt, n_elm), dtype=object)
 
-    def get_values(self, Sbase: float) -> "BatteryVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "BatteryVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: GenerationVars
@@ -215,12 +214,12 @@ class BatteryVars(GenerationVars):
 
         for t in range(nt):
             for i in range(n_elm):
-                data.p[t, i] = get_lp_var_value(self.p[t, i]) * Sbase
-                data.e[t, i] = get_lp_var_value(self.e[t, i]) * Sbase
-                data.shedding[t, i] = get_lp_var_value(self.shedding[t, i]) * Sbase
-                data.producing[t, i] = get_lp_var_value(self.producing[t, i])
-                data.starting_up[t, i] = get_lp_var_value(self.starting_up[t, i])
-                data.shutting_down[t, i] = get_lp_var_value(self.shutting_down[t, i])
+                data.p[t, i] = model.get_value(self.p[t, i]) * Sbase
+                data.e[t, i] = model.get_value(self.e[t, i]) * Sbase
+                data.shedding[t, i] = model.get_value(self.shedding[t, i]) * Sbase
+                data.producing[t, i] = model.get_value(self.producing[t, i])
+                data.starting_up[t, i] = model.get_value(self.starting_up[t, i])
+                data.shutting_down[t, i] = model.get_value(self.shutting_down[t, i])
 
             # format the arrays aproprietly
             data.p = data.p.astype(float, copy=False)
@@ -257,31 +256,30 @@ class BranchVars:
         # t, m, c, contingency, negative_slack, positive_slack
         self.contingency_flow_data: List[Tuple[int, int, int, Union[float, LpVar, LpExp], LpVar, LpVar]] = list()
 
-    def get_values(self, Sbase: float) -> "BranchVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "BranchVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: BranchVars
         """
         nt, n_elm = self.flows.shape
         data = BranchVars(nt=nt, n_elm=n_elm)
-
         data.rates = self.rates
 
         for t in range(nt):
             for i in range(n_elm):
-                data.flows[t, i] = get_lp_var_value(self.flows[t, i]) * Sbase
-                data.flow_slacks_pos[t, i] = get_lp_var_value(self.flow_slacks_pos[t, i]) * Sbase
-                data.flow_slacks_neg[t, i] = get_lp_var_value(self.flow_slacks_neg[t, i]) * Sbase
-                data.tap_angles[t, i] = get_lp_var_value(self.tap_angles[t, i])
-                data.flow_constraints_ub[t, i] = get_lp_var_value(self.flow_constraints_ub[t, i])
-                data.flow_constraints_lb[t, i] = get_lp_var_value(self.flow_constraints_lb[t, i])
+                data.flows[t, i] = model.get_value(self.flows[t, i]) * Sbase
+                data.flow_slacks_pos[t, i] = model.get_value(self.flow_slacks_pos[t, i]) * Sbase
+                data.flow_slacks_neg[t, i] = model.get_value(self.flow_slacks_neg[t, i]) * Sbase
+                data.tap_angles[t, i] = model.get_value(self.tap_angles[t, i])
+                data.flow_constraints_ub[t, i] = model.get_value(self.flow_constraints_ub[t, i])
+                data.flow_constraints_lb[t, i] = model.get_value(self.flow_constraints_lb[t, i])
 
         for i in range(len(self.contingency_flow_data)):
             t, m, c, var, neg_slack, pos_slack = self.contingency_flow_data[i]
             self.contingency_flow_data[i] = (t, m, c,
-                                             get_lp_var_value(var),
-                                             get_lp_var_value(neg_slack),
-                                             get_lp_var_value(pos_slack))
+                                             model.get_value(var),
+                                             model.get_value(neg_slack),
+                                             model.get_value(pos_slack))
 
         # format the arrays aproprietly
         data.flows = data.flows.astype(float, copy=False)
@@ -326,7 +324,7 @@ class HvdcVars:
         self.rates = np.zeros((nt, n_elm), dtype=float)
         self.loading = np.zeros((nt, n_elm), dtype=float)
 
-    def get_values(self, Sbase: float) -> "HvdcVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "HvdcVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: HvdcVars
@@ -337,7 +335,7 @@ class HvdcVars:
 
         for t in range(nt):
             for i in range(n_elm):
-                data.flows[t, i] = get_lp_var_value(self.flows[t, i]) * Sbase
+                data.flows[t, i] = model.get_value(self.flows[t, i]) * Sbase
 
         # format the arrays aproprietly
         data.flows = data.flows.astype(float, copy=False)
@@ -380,7 +378,7 @@ class OpfVars:
         self.branch_vars = BranchVars(nt=nt, n_elm=nbr)
         self.hvdc_vars = HvdcVars(nt=nt, n_elm=n_hvdc)
 
-    def get_values(self, Sbase: float) -> "OpfVars":
+    def get_values(self, Sbase: float, model: LpModel) -> "OpfVars":
         """
         Return an instance of this class where the arrays content are not LP vars but their value
         :return: OpfVars instance
@@ -392,12 +390,12 @@ class OpfVars:
                        nl=self.nl,
                        nbr=self.nbr,
                        n_hvdc=self.n_hvdc)
-        data.bus_vars = self.bus_vars.get_values(Sbase)
-        data.load_vars = self.load_vars.get_values(Sbase)
-        data.gen_vars = self.gen_vars.get_values(Sbase)
-        data.batt_vars = self.batt_vars.get_values(Sbase)
-        data.branch_vars = self.branch_vars.get_values(Sbase)
-        data.hvdc_vars = self.hvdc_vars.get_values(Sbase)
+        data.bus_vars = self.bus_vars.get_values(Sbase, model)
+        data.load_vars = self.load_vars.get_values(Sbase, model)
+        data.gen_vars = self.gen_vars.get_values(Sbase, model)
+        data.batt_vars = self.batt_vars.get_values(Sbase, model)
+        data.branch_vars = self.branch_vars.get_values(Sbase, model)
+        data.hvdc_vars = self.hvdc_vars.get_values(Sbase, model)
 
         data.acceptable_solution = self.acceptable_solution
         return data
@@ -636,8 +634,9 @@ def add_linear_battery_formulation(t: Union[int, None],
 
                     # power boundaries of the generator
                     if not skip_generation_limits:
-                        batt_vars.p[t, k].SetLb(batt_data_t.availability[k] * batt_data_t.pmin[k] / Sbase)
-                        batt_vars.p[t, k].SetUb(batt_data_t.availability[k] * batt_data_t.pmax[k] / Sbase)
+                        set_var_bounds(var=batt_vars.p[t, k],
+                                       lb=batt_data_t.availability[k] * batt_data_t.pmin[k] / Sbase,
+                                       ub=batt_data_t.availability[k] * batt_data_t.pmax[k] / Sbase)
 
                 # compute the time increment in hours
                 dt = (time_array[t] - time_array[t - 1]).seconds / 3600.0
@@ -994,8 +993,7 @@ def add_linear_node_balance(t_idx: int,
                             gen_vars: GenerationVars,
                             batt_vars: BatteryVars,
                             load_vars: LoadVars,
-                            prob: LpModel,
-                            logger: Logger):
+                            prob: LpModel):
     """
     Add the kirchoff nodal equality
     :param t_idx: time step
@@ -1027,13 +1025,10 @@ def add_linear_node_balance(t_idx: int,
 
     # add the equality restrictions
     for k in range(bus_data.nbus):
-        name = join("kirchoff_", [t_idx, k], "_")
-        try:
-            bus_vars.kirchhoff[t_idx, k] = prob.add_cst(
-                cst=bus_vars.Pcalc[t_idx, k] == P_esp[k],
-                name=name)
-        except AttributeError:
-            logger.add_warning("Kirchoff 0=0", name, comment='Cannot enforce Pcalc zero=Pset zero')
+        bus_vars.kirchhoff[t_idx, k] = prob.add_cst(
+            cst=bus_vars.Pcalc[t_idx, k] == P_esp[k],
+            name=join("kirchoff_", [t_idx, k], "_")
+        )
 
     for i in vd:
         set_var_bounds(var=bus_vars.theta[t_idx, i], lb=0.0, ub=0.0)
@@ -1195,8 +1190,7 @@ def run_linear_opf_ts(grid: MultiCircuit,
                                     gen_vars=mip_vars.gen_vars,
                                     batt_vars=mip_vars.batt_vars,
                                     load_vars=mip_vars.load_vars,
-                                    prob=lp_model,
-                                    logger=logger)
+                                    prob=lp_model)
 
             # add branch contingencies ---------------------------------------------------------------------------------
             if consider_contingencies:
@@ -1259,16 +1253,18 @@ def run_linear_opf_ts(grid: MultiCircuit,
 
     # gather the results
     if status == LpModel.OPTIMAL:
-        print('Solution:')
-        print('Objective value =', lp_model.fobj_value())
+        logger.add_info("Objective function", value=lp_model.fobj_value())
         mip_vars.acceptable_solution = True
     else:
-        print('The problem does not have an optimal solution.')
+        logger.add_error("The problem does not have an optimal solution.")
         mip_vars.acceptable_solution = False
         lp_file_name = grid.name + "_debug.lp"
         lp_model.save_model(file_name=lp_file_name)
-        print("Debug LP model saved as:", lp_file_name)
+        logger.add_info("Debug LP model saved", value=lp_file_name)
+
+    vars_v = mip_vars.get_values(grid.Sbase, model=lp_model)
 
-    vars_v = mip_vars.get_values(grid.Sbase)
+    # add the model logger to the main logger
+    logger += lp_model.logger
 
     return vars_v

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Simulations/OPF/opf_results.py

@@ -382,7 +382,7 @@ class OptimalPowerFlowResults(ResultsTemplate):
 
         elif result_type == ResultTypes.HvdcLoading:
             labels = self.hvdc_names
-            y = self.hvdc_loading
+            y = self.hvdc_loading * 100.0
             y_label = '(%)'
             title = 'HVDC loading'
 

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Simulations/OPF/opf_ts_driver.py

@@ -18,7 +18,6 @@ import datetime
 
 import numpy as np
 import pandas as pd
-import time
 from typing import Union
 from GridCalEngine.basic_structures import TimeGrouping, get_time_groups
 from GridCalEngine.Core.Devices.multi_circuit import MultiCircuit
@@ -213,8 +212,7 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
             self.results.generator_power[time_indices, :] = opf_vars.gen_vars.p
             self.results.Sf[time_indices, :] = opf_vars.branch_vars.flows
             self.results.St[time_indices, :] = -opf_vars.branch_vars.flows
-            self.results.overloads[time_indices,
-            :] = opf_vars.branch_vars.flow_slacks_pos - opf_vars.branch_vars.flow_slacks_neg
+            self.results.overloads[time_indices, :] = opf_vars.branch_vars.flow_slacks_pos - opf_vars.branch_vars.flow_slacks_neg
             self.results.loading[time_indices, :] = opf_vars.branch_vars.loading
             self.results.phase_shift[time_indices, :] = opf_vars.branch_vars.tap_angles
             # self.results.Sbus[time_indices, :] = problem.get_power_injections()

{GridCalEngine-5.0.0a33 → GridCalEngine-5.0.2}/GridCalEngine/Simulations/PowerFlow/power_flow_driver.py

@@ -46,8 +46,9 @@ class PowerFlowDriver(DriverTemplate):
         """
         PowerFlowDriver class constructor
         :param grid: MultiCircuit instance
-        :param options: PowerFlowOptions instance
-        :param opf_results: OptimalPowerFlowResults instance
+        :param options: PowerFlowOptions instance (optional)
+        :param opf_results: OptimalPowerFlowResults instance (optional)
+        :param engine: EngineType (i.e. EngineType.GridCal) (optional)
         """
 
         DriverTemplate.__init__(self, grid=grid, engine=engine)