VeraGridEngine 5.5.9__tar.gz → 5.5.11__tar.gz

{veragridengine-5.5.9 → veragridengine-5.5.11}/PKG-INFO

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

{veragridengine-5.5.9 → veragridengine-5.5.11}/VeraGridEngine/Devices/assets.py

@@ -5,7 +5,7 @@
 import warnings
 import numpy as np
 import pandas as pd
-from typing import List, Dict, Tuple, Union, Any, Set, Generator
+from typing import List, Dict, Tuple, Union, Any, Set, Generator, Sequence
 import datetime as dateslib
 
 from VeraGridEngine.Devices.Dynamic.events import RmsEvent
@@ -1411,6 +1411,53 @@ class Assets:
         except ValueError:
             print(f"Could not delete {obj.name}")
 
+    def delete_buses(self, lst: Sequence[dev.Bus], delete_associated=False):
+        """
+        Delete a :ref:`Bus<bus>` object from the grid.
+        :param lst: Array of objects to remove
+        :param delete_associated: Delete the associated branches and injections
+        """
+        buses_to_remove = set(lst)
+
+        branches_to_delete = list()
+        injections_to_delete = list()
+
+        # delete associated Branches in reverse order
+        for branch_list in self.get_branch_lists(add_vsc=True, add_hvdc=True, add_switch=True):
+            for i in range(len(branch_list) - 1, -1, -1):
+                if branch_list[i].bus_from in buses_to_remove:
+                    if delete_associated:
+                        branches_to_delete.append(branch_list[i])
+                    else:
+                        branch_list[i].bus_from = None
+                elif branch_list[i].bus_to in buses_to_remove:
+                    if delete_associated:
+                        branches_to_delete.append(branch_list[i])
+                    else:
+                        branch_list[i].bus_to = None
+
+        for elm in branches_to_delete:
+            self.delete_branch(obj=elm)
+
+        # delete the associated injection devices
+        for inj_list in self.get_injection_devices_lists():
+            for i in range(len(inj_list) - 1, -1, -1):
+                if inj_list[i].bus in buses_to_remove:
+                    if delete_associated:
+                        injections_to_delete.append(inj_list[i])
+                    else:
+                        inj_list[i].bus = None
+
+        for elm in injections_to_delete:
+            self.delete_injection_device(obj=elm)
+
+        # delete the bus itself
+        for elm in buses_to_remove:
+            try:
+                self._buses.remove(elm)
+            except ValueError:
+                print(f"Could not delete {elm.name}")
+
     def get_buses_by(self, filter_elements: List[Union[dev.Area, dev.Country, dev.Zone]]) -> List[dev.Bus]:
         """
         Get a list of buses that can be found in the list of Areas | Zones | Countries

{veragridengine-5.5.9 → veragridengine-5.5.11}/VeraGridEngine/Devices/multi_circuit.py

@@ -1697,9 +1697,10 @@ class MultiCircuit(Assets):
 
         return v
 
-    def get_Sbus(self) -> CxVec:
+    def get_Sbus(self, apply_active: bool = False) -> CxVec:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (nbus) [MW + j MVAr]
         """
         val = np.zeros(self.get_bus_number(), dtype=complex)
@@ -1708,13 +1709,14 @@ class MultiCircuit(Assets):
         for elm in self.get_injection_devices_iter():
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.get_S_with_sign()
+                val[k] += elm.get_S_with_sign() * elm.active if apply_active else elm.get_S_with_sign()
 
         return val
 
-    def get_Sbus_prof(self) -> CxMat:
+    def get_Sbus_prof(self, apply_active: bool = False) -> CxMat:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (ntime, nbus) [MW + j MVAr]
         """
         val = np.zeros((self.get_time_number(), self.get_bus_number()), dtype=complex)
@@ -1724,13 +1726,16 @@ class MultiCircuit(Assets):
         for elm in self.get_injection_devices_iter():
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[:, k] += elm.get_Sprof_with_sign()
-
+                if apply_active:
+                    val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                else:
+                    val[:, k] += elm.get_Sprof_with_sign()
         return val
 
-    def get_Pgen(self) -> Vec:
+    def get_Pgen(self, apply_active: bool = False) -> Vec:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (nbus) [MW + j MVAr]
         """
         val = np.zeros(self.get_bus_number(), dtype=float)
@@ -1739,29 +1744,30 @@ class MultiCircuit(Assets):
         for elm in self.generators:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         for elm in self.batteries:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         for elm in self.static_generators:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         for elm in self.external_grids:
             if elm.mode != ExternalGridMode.VD:
                 if elm.bus is not None:
                     k = bus_dict[elm.bus]
-                    val[k] += elm.P
+                    val[k] += elm.P * elm.active if apply_active else elm.P
 
         return val
 
-    def get_Pload(self) -> Vec:
+    def get_Pload(self, apply_active: bool = False) -> Vec:
         """
         Get the complex bus power Injections
+        :param apply_active: Apply the active state?
         :return: (nbus) [MW + j MVAr]
         """
         val = np.zeros(self.get_bus_number(), dtype=float)
@@ -1770,14 +1776,15 @@ class MultiCircuit(Assets):
         for elm in self.loads:
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[k] += elm.P
+                val[k] += elm.P * elm.active if apply_active else elm.P
 
         return val
 
-    def get_Sbus_prof_fixed(self) -> CxMat:
+    def get_Sbus_prof_fixed(self, apply_active: bool = False) -> CxMat:
         """
         Get the complex bus power Injections considering those devices that cannot be dispatched
         This is, all devices except generators and batteries with enabled_dispatch=True
+        :param apply_active: Apply the active state?
         :return: (ntime, nbus) [MW + j MVAr]
         """
         val = np.zeros((self.get_time_number(), self.get_bus_number()), dtype=complex)
@@ -1786,20 +1793,27 @@ class MultiCircuit(Assets):
         for elm in self.get_load_like_devices():
             if elm.bus is not None:
                 k = bus_dict[elm.bus]
-                val[:, k] += elm.get_Sprof_with_sign()
+                if apply_active:
+                    val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                else:
+                    val[:, k] += elm.get_Sprof_with_sign()
 
         for elm in self.get_generation_like_devices():
             if elm.bus is not None:
                 if not elm.enabled_dispatch:
                     k = bus_dict[elm.bus]
-                    val[:, k] += elm.get_Sprof_with_sign()
+                    if apply_active:
+                        val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                    else:
+                        val[:, k] += elm.get_Sprof_with_sign()
 
         return val
 
-    def get_Sbus_prof_dispatchable(self) -> CxMat:
+    def get_Sbus_prof_dispatchable(self, apply_active: bool = False) -> CxMat:
         """
         Get the complex bus power Injections only considering those devices that can be dispatched
         This is, generators and batteries with enabled_dispatch=True
+        :param apply_active: Apply the active state?
         :return: (ntime, nbus) [MW + j MVAr]
         """
         val = np.zeros((self.get_time_number(), self.get_bus_number()), dtype=complex)
@@ -1809,30 +1823,33 @@ class MultiCircuit(Assets):
             if elm.bus is not None:
                 if elm.enabled_dispatch:
                     k = bus_dict[elm.bus]
-                    val[:, k] += elm.get_Sprof_with_sign()
+                    if apply_active:
+                        val[:, k] += elm.get_Sprof_with_sign() * elm.active_prof.toarray()
+                    else:
+                        val[:, k] += elm.get_Sprof_with_sign()
 
         return val
 
-    def get_Pbus(self) -> Vec:
+    def get_Pbus(self, apply_active: bool = False) -> Vec:
         """
         Get snapshot active power array per bus
         :return: Vec
         """
-        return self.get_Sbus().real
+        return self.get_Sbus(apply_active=apply_active).real
 
-    def get_Pbus_prof(self) -> Mat:
+    def get_Pbus_prof(self, apply_active: bool = False) -> Mat:
         """
         Get profiles active power per bus
         :return: Mat
         """
-        return self.get_Sbus_prof().real
+        return self.get_Sbus_prof(apply_active=apply_active).real
 
-    def get_imbalance(self) -> float:
+    def get_imbalance(self, apply_active: bool = False) -> float:
         """
         Get the system imbalance in per unit
         :return:
         """
-        P = self.get_Pbus()
+        P = self.get_Pbus(apply_active=apply_active)
         Pg = P[P > 0].sum()
         Pl = -P[P < 0].sum()
         if Pl > 0:

{veragridengine-5.5.9 → veragridengine-5.5.11}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -493,7 +493,7 @@ class LinearAnalysis:
             rates=rates
         )
 
-    def get_flows(self, Sbus: CxVec, P_hvdc: Vec | None = None, P_vsc: Vec | None = None) -> CxVec:
+    def get_flows(self, Sbus: CxVec | Vec, P_hvdc: Vec | None = None, P_vsc: Vec | None = None) -> CxVec | Vec:
         """
         Compute the time series branch Sf using the PTDF
         :param Sbus: Power Injections time series array (nbus)
@@ -514,7 +514,7 @@ class LinearAnalysis:
         else:
             raise Exception(f'Sbus has unsupported dimensions: {Sbus.shape}')
 
-    def get_flows2d(self, Sbus: CxMat, P_hvdc: Mat | None = None, P_vsc: Mat | None = None) -> CxMat:
+    def get_flows2d(self, Sbus: CxMat | Mat, P_hvdc: Mat | None = None, P_vsc: Mat | None = None) -> CxMat | Mat:
         """
         Compute the time series branch Sf using the PTDF
         :param Sbus: Power Injections time series array (time, nbus) for 2D
@@ -557,9 +557,9 @@ class LinearAnalysis:
         """
         if flows.ndim == 2:
 
-            Pbus, _, _, _ = np.linalg.lstsq(self.PTDF, flows)
+            Pbus_t, _, _, _ = np.linalg.lstsq(self.PTDF, flows.T)
 
-            return Pbus
+            return Pbus_t.T
         else:
             raise Exception(f'flows has unsupported dimensions: {flows.shape}')
 
@@ -1090,10 +1090,12 @@ class LinearAnalysisTs:
 
         return flow_ts
 
-    def get_flows_ts(self, P: CxMat | Mat) -> CxMat | Mat:
+    def get_flows_ts(self, P: CxMat | Mat, progress_func=None, progress_text=None) -> CxMat | Mat:
         """
         Get the flow time series of all branches given the injection time series all buses
         :param P: Bus injection time series
+        :param progress_func: Progres function
+        :param progress_text: Progress text function
         :return: Branches flow time series
         """
         # must have the same size
@@ -1101,13 +1103,22 @@ class LinearAnalysisTs:
         assert P.shape[1] == self.nbus
 
         flow_ts = np.zeros((self.nt, self.nbr))
-
+        ii = 0
+        nn = len(self.groups)
         for t_idx, list_of_represented_time_steps in self.groups.items():
+
+            if progress_text is not None:
+                progress_text(f"Computing flows for time group {t_idx}")
+
             # get the linear analysis
             lin: LinearAnalysis = self._linear_analysis[t_idx]
 
             flow_ts[list_of_represented_time_steps, :] = lin.get_flows2d(Sbus=P[list_of_represented_time_steps, :])
 
+            if progress_func is not None:
+                ii += 1
+                progress_func(ii / nn * 100.0)
+
         return flow_ts
 
     def get_injections_ts(self, flows_ts: CxMat | Mat) -> CxMat | Mat:

{veragridengine-5.5.9 → veragridengine-5.5.11}/VeraGridEngine/Simulations/LinearFactors/linear_analysis_ts_driver.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import Dict, Union, TYPE_CHECKING
 from VeraGridEngine.basic_structures import IntVec
-from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis
+from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis, LinearAnalysisTs
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis_options import LinearAnalysisOptions
 from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_at
 from VeraGridEngine.enumerations import SimulationTypes
@@ -28,13 +28,16 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
                  options: Union[LinearAnalysisOptions, None] = None,
                  time_indices: Union[IntVec, None] = None,
                  clustering_results: Union[ClusteringResults, None] = None,
-                 opf_time_series_results=None):
+                 opf_time_series_results=None,
+                 simplified_compilation: bool = True):
         """
         TimeSeries Analysis constructor
         :param grid: MultiCircuit instance
         :param options: LinearAnalysisOptions instance (optional)
         :param time_indices: array of time indices to simulate (optional)
         :param clustering_results: ClusteringResults instance (optional)
+        :param simplified_compilation: If true, the detailed compilation is replaced with a very fast
+                                       status analysis from LinearAnalysisTs
         """
         TimeSeriesDriverTemplate.__init__(
             self,
@@ -47,6 +50,8 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
 
         self.opf_time_series_results = opf_time_series_results
 
+        self.simplified_compilation = simplified_compilation
+
         self.drivers: Dict[int, LinearAnalysis] = dict()
 
         self.results = LinearAnalysisTimeSeriesResults(
@@ -66,37 +71,38 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
         """
 
         self.tic()
-
-        self.report_text('Computing TS linear analysis...')
-
         self.__cancel__ = False
-
-        # Compute bus Injections
-        # Pbus = self.grid.get_Pbus_prof()
-
-        # Compute different topologies to consider
-        # tpg = self.get_topologic_groups()
-
-        for it, t in enumerate(self.time_indices):
-            self.report_text('Linear analysis at ' + str(self.grid.time_profile[t]))
-            self.report_progress2(it, len(self.time_indices))
-
-            nc: NumericalCircuit = compile_numerical_circuit_at(circuit=self.grid,
-                                                                t_idx=t,
-                                                                opf_results=self.opf_time_series_results,
-                                                                logger=self.logger)
-
-            driver_ = LinearAnalysis(
-                nc=nc,
-                distributed_slack=self.options.distribute_slack,
-                correct_values=self.options.correct_values,
-                # distributed_slack=True,
-                # correct_values=False,
-            )
-
-            Sbus = nc.get_power_injections_pu()
-            self.results.S[it, :] = Sbus * nc.Sbase
-            self.results.Sf[it, :] = driver_.get_flows(Sbus=Sbus) * nc.Sbase
+        self.report_text('Computing TS linear analysis...')
+        lin_ts = LinearAnalysisTs(self.grid)
+
+        self.report_text('Computing flows...')
+
+        if self.simplified_compilation:
+            # Theoretically equivallent but cannot be ensured 100%
+            self.results.S = self.grid.get_Pbus_prof(apply_active=True)
+            self.results.Sf = lin_ts.get_flows_ts(P=self.results.S,
+                                                  progress_func=self.report_progress,
+                                                  progress_text=self.report_text)
+
+        else:
+            for it, t in enumerate(self.time_indices):
+                self.report_text('Linear analysis at ' + str(self.grid.time_profile[t]))
+                self.report_progress2(it, len(self.time_indices))
+
+                nc: NumericalCircuit = compile_numerical_circuit_at(circuit=self.grid,
+                                                                    t_idx=t,
+                                                                    opf_results=self.opf_time_series_results,
+                                                                    logger=self.logger)
+
+                driver_ = LinearAnalysis(
+                    nc=nc,
+                    distributed_slack=self.options.distribute_slack,
+                    correct_values=self.options.correct_values,
+                )
+
+                Sbus = nc.get_power_injections_pu()
+                self.results.S[it, :] = Sbus * nc.Sbase
+                self.results.Sf[it, :] = driver_.get_flows(Sbus=Sbus) * nc.Sbase
 
         rates = self.grid.get_branch_rates()
         self.results.loading = self.results.Sf.real / (rates + 1e-9)

{veragridengine-5.5.9 → veragridengine-5.5.11}/VeraGridEngine/Simulations/NTC/ntc_driver.py

@@ -97,7 +97,8 @@ class OptimalNetTransferCapacityDriver(DriverTemplate):
                 progress_func=self.report_progress,
                 export_model_fname=self.options.opf_options.export_model_fname,
                 verbose=self.options.opf_options.verbose,
-                robust=self.options.opf_options.robust
+                robust=self.options.opf_options.robust,
+                mip_framework=self.options.opf_options.mip_framework
             )
 
         # pack the results

{veragridengine-5.5.9 → veragridengine-5.5.11}/VeraGridEngine/Simulations/NTC/ntc_opf.py

@@ -12,7 +12,7 @@ import os
 import numpy as np
 from typing import List, Union, Tuple, Callable
 
-from VeraGridEngine.enumerations import MIPSolvers, ZonalGrouping
+from VeraGridEngine.enumerations import MIPSolvers, MIPFramework, ZonalGrouping
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.Devices.Aggregation.contingency_group import ContingencyGroup
 from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_at
@@ -26,10 +26,11 @@ from VeraGridEngine.DataStructures.hvdc_data import HvdcData
 from VeraGridEngine.DataStructures.vsc_data import VscData
 from VeraGridEngine.DataStructures.bus_data import BusData
 from VeraGridEngine.basic_structures import Logger, Vec, IntVec, BoolVec, CxMat, Mat, ObjVec
-from VeraGridEngine.Utils.MIP.selected_interface import LpExp, LpVar, LpModel, join
+from VeraGridEngine.Utils.MIP.selected_interface import LpExp, LpVar, LpModel, join, get_model_instance
 from VeraGridEngine.enumerations import TapPhaseControl, HvdcControlType, AvailableTransferMode, ConverterControlType
 from VeraGridEngine.Simulations.LinearFactors.linear_analysis import LinearAnalysis, LinearMultiContingencies
-from VeraGridEngine.Simulations.ATC.available_transfer_capacity_driver import compute_alpha, compute_alpha_n1, compute_dP
+from VeraGridEngine.Simulations.ATC.available_transfer_capacity_driver import compute_alpha, compute_alpha_n1, \
+    compute_dP
 from VeraGridEngine.IO.file_system import opf_file_path
 
 
@@ -1082,6 +1083,10 @@ class NtcVars:
         return self.bus_vars.Vm * np.exp(1j * self.bus_vars.Va)
 
     def check_kirchhoff(self, tol: float = 1e-10):
+        """
+
+        :param tol:
+        """
         nodal_power = self.bus_vars.Pbalance
 
 
@@ -1118,7 +1123,7 @@ def get_base_power(Sbase: float,
     #         ps = active_branch_data_t.tap_angle[k] / (branch_data_t.X[k] + 1e-20)
     #         f = branch_data_t.F[k]
     #         t = branch_data_t.T[k]
-    #         branch_bus_dp[f] -= ps
+    #         branch_bus_dp[f] += -ps
     #         branch_bus_dp[t] += ps
 
     base_power = gen_per_bus + batt_per_bus + load_per_bus  # + branch_bus_dp
@@ -1129,7 +1134,7 @@ def get_base_power(Sbase: float,
         gen_sum = gen_per_bus.sum()
         if gen_sum != 0:
             share = gen_per_bus / gen_sum
-            gen_per_bus -= share * diff  # we make the generators balance the system
+            gen_per_bus += - share * diff  # we make the generators balance the system
         else:
             raise ValueError("Cannot balance the circumstance")
 
@@ -1335,7 +1340,7 @@ def add_linear_injections_formulation_proper(t: Union[int, None],
             i = gen_data_t.bus_idx[k]
             ntc_vars.bus_vars.delta_p[t, i] += ntc_vars.gen_vars.p_inc[t, k]
 
-            f_obj -= ntc_vars.gen_vars.p_inc[t, k] * gen_data_t.shift_key[k]
+            f_obj += - ntc_vars.gen_vars.p_inc[t, k] * gen_data_t.shift_key[k]
         else:
             # the generator is maxed out
             pass
@@ -1354,7 +1359,7 @@ def add_linear_injections_formulation_proper(t: Union[int, None],
             i = batt_data_t.bus_idx[k]
             ntc_vars.bus_vars.delta_p[t, i] += ntc_vars.batt_vars.p_inc[t, k]
 
-            f_obj -= ntc_vars.batt_vars.p_inc[t, k] * batt_data_t.shift_key[k]
+            f_obj += - ntc_vars.batt_vars.p_inc[t, k] * batt_data_t.shift_key[k]
         else:
             # the battery is maxed out
             pass
@@ -1371,9 +1376,9 @@ def add_linear_injections_formulation_proper(t: Union[int, None],
             ntc_vars.delta_2[t] += ntc_vars.gen_vars.p_inc[t, k]
 
             i = gen_data_t.bus_idx[k]
-            ntc_vars.bus_vars.delta_p[t, i] -= ntc_vars.gen_vars.p_inc[t, k]
+            ntc_vars.bus_vars.delta_p[t, i] += - ntc_vars.gen_vars.p_inc[t, k]
 
-            f_obj -= ntc_vars.gen_vars.p_inc[t, k] * gen_data_t.shift_key[k]
+            f_obj += - ntc_vars.gen_vars.p_inc[t, k] * gen_data_t.shift_key[k]
         else:
             # the generator cannot go lower
             pass
@@ -1385,13 +1390,13 @@ def add_linear_injections_formulation_proper(t: Union[int, None],
             else:
                 margin_dwn = (batt_data_t.p[k] - batt_data_t.pmin[k]) / Sbase
             ntc_vars.batt_vars.p_inc[t, k] = prob.add_var(lb=0, ub=margin_dwn, name=join("batt_n_inc_", [t, k]))
-            ntc_vars.batt_vars.p[t, k] -= ntc_vars.batt_vars.p_inc[t, k]
+            ntc_vars.batt_vars.p[t, k] += - ntc_vars.batt_vars.p_inc[t, k]
             ntc_vars.delta_2[t] += ntc_vars.batt_vars.p_inc[t, k]
 
             i = batt_data_t.bus_idx[k]
-            ntc_vars.bus_vars.delta_p[t, i] -= ntc_vars.batt_vars.p_inc[t, k]
+            ntc_vars.bus_vars.delta_p[t, i] += - ntc_vars.batt_vars.p_inc[t, k]
 
-            f_obj -= ntc_vars.batt_vars.p_inc[t, k] * batt_data_t.shift_key[k]
+            f_obj += -ntc_vars.batt_vars.p_inc[t, k] * batt_data_t.shift_key[k]
         else:
             # the battery cannot go lower
             pass
@@ -1409,8 +1414,8 @@ def add_linear_injections_formulation_proper(t: Union[int, None],
 
     for k in range(load_data_t.nelm):
         i = load_data_t.bus_idx[k]
-        ntc_vars.bus_vars.Pinj[t, i] -= ntc_vars.load_vars.p[t, k]
-        ntc_vars.bus_vars.Pbalance[t, i] -= ntc_vars.load_vars.p[t, k]
+        ntc_vars.bus_vars.Pinj[t, i] += -ntc_vars.load_vars.p[t, k]
+        ntc_vars.bus_vars.Pbalance[t, i] += -ntc_vars.load_vars.p[t, k]
 
     # add the area equality constraint
     ntc_vars.delta_sl_1[t] = prob.add_var(lb=0, ub=prob.INFINITY, name=join("DeltaSL_up_", [t]))
@@ -1554,8 +1559,8 @@ def add_linear_branches_formulation(t_idx: int,
                         )
 
             # We save in Pcalc the balance of the branch flows
-            bus_vars.Pbalance[t_idx, fr] -= branch_vars.flows[t_idx, m]
-            bus_vars.Pbalance[t_idx, to] += branch_vars.flows[t_idx, m]
+            bus_vars.Pbalance[t_idx, fr] = bus_vars.Pbalance[t_idx, fr] - branch_vars.flows[t_idx, m]
+            bus_vars.Pbalance[t_idx, to] = bus_vars.Pbalance[t_idx, to] + branch_vars.flows[t_idx, m]
 
             # Monitoring logic: Avoid unrealistic ntc flows over CEP rule limit in N condition
             if monitor_only_ntc_load_rule_branches:
@@ -1596,15 +1601,15 @@ def add_linear_branches_formulation(t_idx: int,
 
                     # here flows is always a variable
                     prob.set_var_bounds(branch_vars.flows[t_idx, m],
-                                   lb=-rate_pu * (abs(loading[m]) + 0.1),
-                                   ub=rate_pu * (abs(loading[m]) + 0.1))
+                                        lb=-rate_pu * (abs(loading[m]) + 0.1),
+                                        ub=rate_pu * (abs(loading[m]) + 0.1))
                 else:
                     # here flows is always a variable
                     prob.set_var_bounds(branch_vars.flows[t_idx, m], lb=-rate_pu, ub=rate_pu)
 
     # add the inter-area flows to the objective function with the correct sign
     for k, sense in branch_vars.inter_space_branches:
-        f_obj -= branch_vars.flows[t_idx, k] * sense
+        f_obj += -branch_vars.flows[t_idx, k] * sense
 
     return f_obj
 
@@ -1827,7 +1832,7 @@ def add_linear_hvdc_formulation(t_idx: int,
                     )
 
                 # add the injections matching the flow
-                vars_bus.Pbalance[t_idx, fr] -= hvdc_vars.flows[t_idx, m]
+                vars_bus.Pbalance[t_idx, fr] += - hvdc_vars.flows[t_idx, m]
                 vars_bus.Pbalance[t_idx, to] += hvdc_vars.flows[t_idx, m]
 
             elif hvdc_data_t.control_mode[m] == HvdcControlType.type_1_Pset:
@@ -1842,7 +1847,7 @@ def add_linear_hvdc_formulation(t_idx: int,
                     )
 
                     # add the injections matching the flow
-                    vars_bus.Pbalance[t_idx, fr] -= hvdc_vars.flows[t_idx, m]
+                    vars_bus.Pbalance[t_idx, fr] += -hvdc_vars.flows[t_idx, m]
                     vars_bus.Pbalance[t_idx, to] += hvdc_vars.flows[t_idx, m]
 
                 else:
@@ -1860,7 +1865,7 @@ def add_linear_hvdc_formulation(t_idx: int,
                     hvdc_vars.flows[t_idx, m] = P0
 
                     # add the injections matching the flow
-                    vars_bus.Pbalance[t_idx, fr] -= hvdc_vars.flows[t_idx, m]
+                    vars_bus.Pbalance[t_idx, fr] += -hvdc_vars.flows[t_idx, m]
                     vars_bus.Pbalance[t_idx, to] += hvdc_vars.flows[t_idx, m]
             else:
                 raise Exception('OPF: Unknown HVDC control mode {}'.format(hvdc_data_t.control_mode[m]))
@@ -1870,7 +1875,7 @@ def add_linear_hvdc_formulation(t_idx: int,
 
     # add the flows to the objective function
     for k, sense in hvdc_vars.inter_space_hvdc:
-        f_obj -= hvdc_vars.flows[t_idx, k] * sense
+        f_obj += -hvdc_vars.flows[t_idx, k] * sense
 
     return f_obj
 
@@ -2066,7 +2071,7 @@ def add_linear_vsc_formulation(t_idx: int,
                                  value=f"{vsc_data_t.control1[m]}, {vsc_data_t.control2[m]}")
 
             # add the injections matching the flow
-            bus_vars.Pbalance[t_idx, fr] -= vsc_vars.flows[t_idx, m]
+            bus_vars.Pbalance[t_idx, fr] += -vsc_vars.flows[t_idx, m]
             bus_vars.Pbalance[t_idx, to] += vsc_vars.flows[t_idx, m]
 
         else:
@@ -2075,7 +2080,7 @@ def add_linear_vsc_formulation(t_idx: int,
 
     # add the flows to the objective function
     for k, sense in vsc_vars.inter_space_vsc:
-        f_obj -= vsc_vars.flows[t_idx, k] * sense
+        f_obj += -vsc_vars.flows[t_idx, k] * sense
 
     if not any_dc_slack and vsc_data_t.nelm > 0:
         logger.add_warning("No DC Slack! set Vm_dc in any of the converters")
@@ -2143,7 +2148,8 @@ def run_linear_ntc_opf(grid: MultiCircuit,
                        progress_func: Union[None, Callable[[float], None]] = None,
                        export_model_fname: Union[None, str] = None,
                        verbose: int = 0,
-                       robust: bool = False) -> NtcVars:
+                       robust: bool = False,
+                       mip_framework: MIPFramework = MIPFramework.PuLP) -> NtcVars:
     """
 
     :param grid: MultiCircuit instance
@@ -2167,6 +2173,7 @@ def run_linear_ntc_opf(grid: MultiCircuit,
     :param export_model_fname: Export the model into LP and MPS?
     :param verbose: Verbosity level
     :param robust: Robust optimization?
+    :param mip_framework: MIPFramework to use
     :return: NtcVars class with the results
     """
     mode_2_int = {
@@ -2188,7 +2195,10 @@ def run_linear_ntc_opf(grid: MultiCircuit,
     n_vsc = grid.get_vsc_number()
 
     # Declare the LP model
-    lp_model: LpModel = LpModel(solver_type)
+    lp_model: LpModel = get_model_instance(tpe=mip_framework, solver_type=solver_type)
+    print("Solving NTC with", lp_model.name)
+    logger.add_info(f"MIP Framework", value=lp_model.name)
+    logger.add_info(f"MIP Solver", value=solver_type.value)
 
     # declare structures of LP vars
     mip_vars = NtcVars(nt=1, nbus=n, ng=ng, nb=nb, nl=nl, nbr=nbr, n_hvdc=n_hvdc, n_vsc=n_vsc,
@@ -2381,7 +2391,8 @@ def run_linear_ntc_opf(grid: MultiCircuit,
                     dT=1.0
                 )
 
-                branch_loading_con = np.abs(branch_flows / (nc.passive_branch_data.contingency_rates / nc.Sbase + 1e-20))
+                branch_loading_con = np.abs(
+                    branch_flows / (nc.passive_branch_data.contingency_rates / nc.Sbase + 1e-20))
 
                 # formulate the contingencies
                 f_obj += add_linear_branches_contingencies_formulation(
@@ -2435,7 +2446,7 @@ def run_linear_ntc_opf(grid: MultiCircuit,
     # gather the results
     logger.add_info(msg="Status", value=lp_model.status2string(status))
 
-    if status == LpModel.OPTIMAL:
+    if status == lp_model.OPTIMAL:
         logger.add_info("Objective function", value=lp_model.fobj_value())
         mip_vars.acceptable_solution[t_idx] = True
     else: